Products / tensorflow-cpu
tensorflow-cpu
423 records.
- Division by 0 in inplace operations An empty-input check uses OR instead of AND, so crafted arguments reach a division by zero in the inplace operation and crash it.
- Segfault on strings tensors with mistmatched dimensions, due to Go code A garbage-collection finaliser frees string tensor data whose encoding previously failed, so it dereferences invalid memory and crashes.
- Reference binding to nullptr in boosted trees Malformed empty or mismatched tensor inputs to boosted-trees ops are not validated, so a reference is bound to null, causing undefined behaviour.
- Segfault and heap buffer overflow in `{Experimental,}DatasetToTFRecord` Dataset-to-TFRecord ops assume every record is a string without checking, so numeric records cause a heap overflow and crash.
- Null pointer dereference in `MatrixDiagPartOp` A missing check on the padding_value tensor leads to reading the first element of an empty buffer, causing a null dereference.
- Incomplete validation in `QuantizeV2` Missing shape checks in the quantization op let mismatched range tensors cause out-of-bounds heap reads and null reference access.
- Heap OOB in nested `tf.map_fn` with `RaggedTensor`s Missing inner shape checks when converting variant tensors to ragged tensors leave output buffers filled with uninitialised heap data.
- Crash caused by integer conversion to unsigned A negative stream count passed to the quantile resource is converted to an unsigned value, causing an enormous reservation and a crash.
- Null pointer dereference and heap OOB read in operations restoring tensors Restore ops given an empty or short tensor name list index past the end of a heap buffer or dereference a null pointer, causing out-of-bounds reads.
- Bad alloc in `StringNGrams` caused by integer conversion Negative ngram widths passed to StringNGrams convert to huge unsigned sizes, causing an oversized memory allocation that fails.
- Floating point exception in `SparseDenseCwiseDiv` The sparse-dense division kernel does not handle a zero divisor, so a floating point exception crashes the process.
- Heap buffer overflow in `FractionalAvgPoolGrad` An empty input tensor is not validated in the fractional average pooling gradient, so the kernel reads and writes outside its allocated buffers.
- Null pointer dereference in `RaggedTensorToTensor` Passing an empty row partition types list to RaggedTensorToTensor makes the kernel dereference a null pointer, crashing the process.
- Heap OOB in TFLite's `Gather*` implementations Gather operations accept negative index values without checking, so a crafted model makes the interpreter read out-of-bounds heap memory.
- Use after free in boosted trees creation A resource freed after failed initialisation is freed again during cleanup because refcounting and smart-pointer handling disagree, causing a use after free.
- Infinite loop in TFLite A crafted model with ellipsis strided-slice parameters makes the loop counter fail to advance, so the TFLite kernel loops forever.
- Reference binding to nullptr and heap OOB in binary cwise ops Binary elementwise gradient ops skip a size check on mismatched inputs, so a reference binds to null and reads past the heap buffer.
- FPE in TFLite pooling operations TFLite pooling kernels divide by a dimension without a zero check, so crafted inputs trigger a floating point exception that crashes the process.
- Missing validation in shape inference for `Dequantize` Unvalidated axis values in Dequantize shape inference select an invalid rank, causing a segfault when arguments are malformed.
- Division by 0 in `ResourceGather` A zero batch size in ResourceGather causes a division by zero that crashes the process.
- Reference binding to nullptr in map operations An empty indices argument in map operations leaves a reference bound to null, causing undefined behaviour in the kernel.
- Heap OOB in boosted trees Out-of-range indices in the sparse best-split calculation cause heap out-of-bounds reads when the caller supplies crafted stats summary indices.
- Arbitrary code execution due to YAML deserialization Keras model_from_yaml calls an unsafe YAML loader, so a crafted model config can instantiate Python objects and run code when loaded.
- FPE in TFLite division operations TFLite division does not check for zero divisors, so a zero-valued divisor tensor crashes the process.
- Reference binding to nullptr in shape inference Shape inference for SparseFillEmptyRows does not reject empty inputs, so it binds a reference to a null pointer, causing undefined behaviour.
- Incomplete validation in MKL requantization Missing dimension validation in the MKL requantization kernels lets crafted inputs cause null reference binding and out-of-bounds heap access.
- Null pointer dereference in TFLite A crafted TFLite model drives a broadcast path that dereferences a null pointer, crashing the interpreter when it is invoked.
- Crash in NMS ops caused by integer conversion to unsigned A negative output size is implicitly converted to an unsigned value during vector resize, causing the NMS kernel to crash.
- Reference binding to nullptr in `RaggedTensorToVariant` Empty split arguments in a raw op call cause a null reference to be bound, producing undefined behaviour from crafted tensor inputs.
- Reference binding to nullptr in unicode encoding Calling the UnicodeEncode op with empty split tensors makes the kernel bind a reference to null before checking for emptiness, causing undefined behaviour.
- Null pointer dereference in TFLite MLIR optimizations A crafted TFLite model containing an L2NormalizeReduceAxis operator causes an unchecked iterator dereference in the MLIR optimizer, crashing the process.
- Incorrect validation of `SaveV2` inputs SaveV2 sets an error status on invalid inputs but keeps executing, so crafted inputs cause a null pointer dereference.
- Heap OOB read in TFLite's implementation of `Minimum` or `Maximum` TFLite Minimum and Maximum broadcasting indexes both inputs with the same index without bounds checks, so an empty input causes heap out-of-bounds reads.
- Division by zero in optimized pooling implementations in TFLite Optimized TFLite pooling kernels divide by stride values from the model without checking for zero, so a crafted model triggers a division-by-zero crash.
- CHECK-fail in AddManySparseToTensorsMap A crafted sparse shape passed to a TensorFlow op triggers a CHECK failure that aborts the process.
- Heap buffer overflow in `QuantizedReshape` QuantizedReshape reads the first element of its threshold tensors without checking they are non-empty, so empty inputs cause a heap overflow.
- Heap buffer overflow in `BandedTriangularSolve` Empty input tensors are not validated before a banded triangular solve op, so the computation writes past the end of a heap buffer.
- CHECK-fail in `tf.raw_ops.IRFFT` A crafted empty-length input to the inverse real FFT hits an assertion in the Eigen code, crashing the process.
- CHECK-fail in DrawBoundingBoxes An empty image passed to DrawBoundingBoxes hits a CHECK assertion that aborts the process instead of returning an error.
- Heap out of bounds read in `RequantizationRange` RequantizationRange reads the first element of input_min and input_max without checking they are non-empty, causing an out-of-bounds heap read.
- Division by zero in TFLite's convolution code Several TFLite convolution computations divide by a user-controlled dimension value that is never checked for zero, crashing the process.
- CHECK-fail in tf.raw_ops.EncodePng Passing an empty pixel tensor to the PNG encoder op passes a null buffer into a CHECK, aborting the process.
- Division by zero in TFLite's implementation of `GatherNd` A crafted TFLite model supplies an empty params tensor, so a zero dimension is used as a divisor in the GatherNd kernel.
- Heap buffer overflow in `RaggedBinCount` RaggedBincount reads past the end of the splits tensor when that input is not a valid sparse structure, causing a heap out-of-bounds read.
- Type confusion during tensor casts lead to dereferencing null pointers Passing non-numeric tensor dtypes to numeric TensorFlow operations leads to null pointer dereferences and process crashes.
- Heap out of bounds in `QuantizedBatchNormWithGlobalNormalization` Empty quantisation range tensors passed to a quantised batch normalisation op make it read past allocated memory, crashing the process.
- Heap buffer overflow in `StringNGrams` Crafted string and split inputs to StringNGrams produce padding-only tokens that trigger a heap buffer overflow during n-gram generation.
- Null dereference in Grappler's `TrySimplify` The arithmetic optimizer dereferences a null pointer when simplifying a graph node that has no inputs, crashing the process.
- Reference binding to null in `ParameterizedTruncatedNormal` An empty shape argument is read at index zero without validation, so the kernel binds a reference to a null pointer.
- Division by 0 in `Conv2D` A zero-sized Conv2D input makes the kernel divide by a caller-controlled filter dimension, crashing the operation with a division by zero.