Products / tensorflow-cpu
tensorflow-cpu
423 records.
- Division by zero in TFLite's implementation of `EmbeddingLookup` A crafted model whose embedding tensor has a zero-sized first dimension causes a division by zero during lookup, crashing the interpreter.
- Heap out of bounds read in `MaxPoolGradWithArgmax` Mismatched tensor sizes cause the kernel to use one index into two arrays of different lengths, reading past the end of a heap buffer.
- Heap OOB access in unicode ops UnicodeEncode assumes its values and splits tensors form a valid sparse tensor, so malformed inputs cause reads past the end of a heap buffer.
- Reference binding to nullptr in `SdcaOptimizer` Calling the raw SdcaOptimizer op with malformed sparse inputs binds a reference to null, causing undefined behaviour and a crash.
- Session operations in eager mode lead to null pointer dereferences Calling session-related raw ops in eager mode, where no session state exists, makes the kernel dereference a null pointer.
- Division by 0 in `QuantizedMul` An empty tensor passed to a quantised multiply causes a modulo by zero, because the divisor comes from the caller's input.
- Heap buffer overflow in `FractionalAvgPoolGrad` Pooling sequence arguments are not checked against the gradient shape, so the op reads or writes past a heap buffer.
- CHECK-fail in `QuantizeAndDequantizeV4Grad` A gradient op does not validate input tensor ranks, so a crafted call hits a CHECK failure that crashes the process.
- CHECK-fail in SparseConcat A crafted shape tensor makes the output shape constructor fail a CHECK assertion in SparseConcat, aborting the process.
- Overflow/denial of service in `tf.raw_ops.ReverseSequence` Invalid sequence and batch dimension arguments are not validated, causing a stack overflow or assertion failure in ReverseSequence.
- Null pointer dereference in `EditDistance` A crafted empty sparse input makes EditDistance allocate an empty output and then write to its buffer, dereferencing a null pointer and crashing the process.
- CHECK-fail in SparseCross due to type confusion Mismatched sparse index, value and shape combinations trip an internal consistency check that aborts the process, crashing the TensorFlow runtime.
- Division by zero in `Conv3D` A zero-sized filter dimension makes a modulo operation divide by zero, and mismatched tensor shapes trigger an Eigen assertion, both crashing the process.
- Heap buffer overflow in `MaxPoolGrad` An unchecked index into the gradient-related output tensor writes past the end of an input buffer, corrupting heap memory.
- Heap buffer overflow in `MaxPool3DGradGrad` Missing validation of pooling parameters lets a crafted MaxPool3DGradGrad call write past the end of a heap buffer.
- Undefined behavior in `MaxPool3DGradGrad` Empty tensors passed to MaxPool3DGradGrad are not validated, so the kernel dereferences null pointers and crashes.
- Null pointer dereference via invalid Ragged Tensors An invalid ragged tensor argument causes a null pointer dereference because the code reads splits without checking the tensor is non-empty.
- Heap buffer overflow in `QuantizedResizeBilinear` Empty tensors passed as quantization range inputs are read at index zero without a size check, causing a heap buffer overflow.
- Heap buffer overflow in `RaggedTensorToTensor` Crafted ragged tensor row partitions make the conversion kernel use one index for two arrays, writing past a heap buffer.
- Heap out of bounds write in `RaggedBinCount` A splits argument that is not a valid sparse layout makes the bincount kernel write before the start of the output buffer.
- Interpreter crash from `tf.io.decode_raw` A width calculation in the padded decode_raw kernel mixes element size and byte length, causing out-of-bounds writes that crash the interpreter.
- Division by zero in TFLite's implementation of hashtable lookup A crafted TFLite model with a zero first dimension in the values tensor causes a division by zero in hashtable lookup, crashing the interpreter.
- Division by zero in TFLite's implementation of Split A crafted TFLite model sets a split count of zero, so the Split operator divides by zero and crashes.
- Integer overflow in TFLite concatentation A model with oversized concatenation dimensions overflows a 32-bit int during shape computation, leading to out-of-bounds memory handling in TFLite.
- Incomplete validation in `SparseReshape` Missing validation of sparse tensor inputs lets a crafted tensor trigger a CHECK failure that crashes the process.
- Division by 0 in `MaxPoolGradWithArgmax` An empty batch dimension in MaxPoolGradWithArgmax is used as a divisor without a check, causing a division by zero crash.
- Heap buffer overflow and undefined behavior in `FusedBatchNorm` Empty or undersized tensors passed to FusedBatchNorm cause a heap buffer overflow and a null pointer dereference.
- Heap OOB read in `tf.raw_ops.Dequantize` Passing min and max range tensors with mismatched shapes makes the dequantize kernel read beyond the end of a heap buffer.
- Division by 0 in `Conv3DBackprop*` Empty input tensors reach a shard-size calculation that divides by zero, crashing the 3D convolution backprop kernels.
- Division by zero in TFLite's implementation of `BatchToSpaceNd` A crafted model with a zero block shape value causes a divide by zero in the TFLite BatchToSpaceNd kernel, crashing the process.
- Incomplete validation in `SparseAdd` Missing validation of sparse tensor shapes and empty inputs lets crafted tensor triples cause null dereferences and out-of-bounds heap writes.
- Heap OOB write in TFLite A crafted TFLite model with an invalid axis value makes the ArgMin/ArgMax kernel write past the end of a heap array.
- Stack overflow due to looping TFLite subgraph A crafted TFLite model with a cyclic subgraph, such as a While op whose body and condition share a subgraph, causes unbounded recursion or looping during inference.
- Division by 0 in `FractionalAvgPool` Crafted input shape and pooling ratio make a computed output size zero, causing a division by zero that crashes the process at runtime.
- CHECK-fail in `CTCGreedyDecoder` Crafted inputs with invalid sequence lengths trigger a CHECK assertion in the decoder, aborting the process instead of returning an error.
- Division by 0 in `Reverse` Reverse computes a cost by dividing by the first dimension size, so a zero-sized first dimension causes a division-by-zero crash.
- Segfault in tf.raw_ops.ImmutableConst Passing resource or variant dtypes to the immutable constant op makes it treat tensor contents as scalars, causing a segfault.
- CHECK-fail in `LoadAndRemapMatrix` A tensor of the wrong rank passed as the checkpoint path triggers a CHECK failure in LoadAndRemapMatrix that aborts the process.
- Heap OOB read in TFLite A crafted TFLite model with an out-of-range split axis makes the Split_V kernel read heap memory beyond the tensor dimension array.
- Heap OOB in `QuantizeAndDequantizeV3` The axis argument is not range-checked before indexing the input tensor, so a crafted value reads past a heap buffer.
- Reference binding to null pointer in `MatrixDiag*` ops Matrix diagonal ops dereference empty tensor inputs without checking them, causing a null pointer crash.
- Heap buffer overflow in `SparseTensorToCSRSparseMatrix` A crafted sparse tensor makes the CSR conversion index outside a heap array, corrupting memory and crashing the process.
- Segfault in SparseCountSparseOutput A negative dense shape passed to a sparse count op sizes a vector from an invalid value, breaking its invariants and crashing the process.
- Heap out of bounds read in `RaggedCross` Invalid tensor shapes passed to RaggedCross skip argument validation, causing heap reads outside allocated buffers.
- Division by zero in TFLite's implementation of `SpaceToDepth` A crafted TFLite model sets the SpaceToDepth block size to zero, so the Prepare step divides by zero when the model is loaded.
- Division by zero in `Conv2DBackpropFilter` Crafted empty tensor shapes make the Conv2DBackpropFilter work-unit size zero, triggering a division by zero exception.
- Division by zero in TFLite's implementation of `OneHot` A crafted TFLite model with a zero-sized indices dimension makes OneHot compute a zero prefix size and then divide by it.
- Integer overflow in TFLite memory allocation A crafted TFLite model makes an integer size calculation overflow, so malloc receives a negative size and later memory access goes out of bounds.
- Heap buffer overflow caused by rounding Rounding in the quantized bilinear resize can make the computed upper index smaller than the lower one, so a crafted input tensor reads or writes outside a heap buffer.
- CHECK-failure in `UnsortedSegmentJoin` UnsortedSegmentJoin assumes num_segments is a single-element scalar, so an empty tensor triggers a CHECK failure that terminates the process.