Products / tensorflow
tensorflow
433 records.
- 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.
- Null pointer dereference in TFLite's `Reshape` operator A reshape input with no data buffer, supplied as a 1-D shape tensor, slips past an earlier null check and is dereferenced.
- Division by 0 in `QuantizedBiasAdd` Empty quantized inputs make an Eigen kernel divide by a zero element count, causing undefined behaviour and a crash.
- Heap buffer overflow in `QuantizedMul` Passing empty tensors where scalar quantization ranges are expected makes the kernel read element zero from an empty buffer, overflowing the heap.
- Crash in `tf.strings.substr` due to `CHECK`-fail Invalid position arguments to tf.strings.substr trigger a CHECK failure that crashes the TensorFlow process.
- Invalid validation in `QuantizeAndDequantizeV2` A validation condition mixing || accepts axis values below -1 in QuantizeAndDequantizeV2, causing a heap underflow during the operation.
- Heap buffer overflow in `SparseSplit` A user-controlled split dimension index is used to access an array without bounds checks, letting SparseSplit write past a heap buffer.
- Division by zero in padding computation in TFLite A crafted TFLite model with stride zero causes a division by zero during output size calculation, crashing the interpreter.
- Division by 0 in `QuantizedBatchNormWithGlobalNormalization` Zero-sized quantized inputs make the batch normalization op divide by zero at runtime, crashing the process.
- CHECK-fail in `tf.raw_ops.RFFT` A zero FFT length makes the RFFT kernel operate on an empty matrix, triggering an assertion that terminates the process.
- Division by zero in TFLite's implementation of `SVDF` A crafted model file sets the SVDF rank parameter to zero, and the kernel divides by it, crashing the interpreter.
- Heap OOB access in `Dilation2DBackpropInput` Dilation2DBackpropInput writes to computed indices without checking them against the input tensor size when given invalid filter arguments, producing out-of-bounds heap writes.
- Division by 0 in `DenseCountSparseOutput` Empty batch dimensions in the values tensor cause a division by zero in the count kernel, crashing the process.
- Stack overflow in `ParseAttrValue` with nested tensors Deeply nested tensor attribute input recurses without limit in the parser, overflowing the stack and crashing the process.
- Division by 0 in `FusedBatchNorm` A zero last dimension in FusedBatchNorm inputs causes a division by zero that crashes the process.
- Division by 0 in `Conv2DBackpropFilter` A zero-sized input to a convolution gradient op makes the kernel take a modulus by a caller-controlled zero, crashing the process.
- Null pointer dereference in `SparseFillEmptyRows` A sparse tensor with an empty dense shape reaches an unchecked dereference because validation was left as a TODO, crashing the process.
- Division by zero in TFLite's implementation of `DepthwiseConv` A crafted TFLite model with a zero-sized input channel dimension causes a division by zero in the DepthwiseConv kernel when loaded.
- Heap OOB and null pointer dereference in `RaggedTensorToTensor` Empty input tensors to RaggedTensorToTensor skip required checks in release builds, allowing out-of-bounds heap access.
- Division by zero in TFLite's implementation of `SpaceToBatchNd` A crafted TFLite model sets a zero block dimension in SpaceToBatchNd, triggering a division by zero when the model is run.
- Heap buffer overflow in `AvgPool3DGrad` Mismatched dimensions between the original input shape and the gradient tensor are not validated, so the kernel writes past a heap buffer.
- Division by zero in TFLite's implementation of `DepthToSpace` A model with a zero block_size reaches a division in DepthToSpace, causing a crash when the interpreter runs it.
- Division by zero in TFLite's implementation of `TransposeConv` A TransposeConv model with zero stride values triggers a division by zero in the optimized kernel during inference.
- Segfault in `CTCBeamSearchDecoder` The CTC beam search decoder does not detect empty input tensors, so it reads from a null buffer and crashes.
- OOB read in `MatrixTriangularSolve` A failed shape check in MatrixTriangularSolve sets an error status but does not return, so the kernel continues with empty tensors and reads out of bounds.
- Incomplete validation in `tf.raw_ops.CTCLoss` Missing shape validation in CTCLoss lets crafted empty or negative tensors trigger heap out-of-bounds reads, heap overflow and null pointer dereference.
- Heap buffer overflow in `Conv3DBackprop*` Unvalidated argument shapes passed to Conv3DBackprop raw ops let attacker-chosen sizes cause writes past the end of a heap buffer.
- Memory corruption in `DrawBoundingBoxesV2` DrawBoundingBoxesV2 does not check that the boxes tensor's last dimension is 4, so attacker-supplied inputs cause out-of-bounds heap reads and writes.
- Lack of validation in `SparseDenseCwiseMul` Missing dimension checks in SparseDenseCwiseMul let crafted inputs trigger assertion failures or writes outside heap-allocated buffers.
- Segfault in `tf.raw_ops.SparseCountSparseOutput` Invalid arguments to SparseCountSparseOutput cause a segmentation fault in TensorFlow.
- Division by 0 in `QuantizedConv2D` A zero-sized filter in QuantizedConv2D causes a division by zero that crashes TensorFlow.
- Division by 0 in `QuantizedAdd` A zero-sized input shape makes a modulo operation divide by zero, crashing the quantized add op.
- Undefined behavior and `CHECK`-fail in `FractionalMaxPoolGrad` Empty or mismatched input tensors passed to the raw gradient op trigger undefined behaviour and a CHECK failure that aborts the whole process.
- Invalid validation in `SparseMatrixSparseCholesky` An empty permutation argument passes validation that checks only the dtype, leading to a null pointer dereference and process crash.
- Heap buffer overflow in `Conv2DBackpropFilter` Crafted tensor shapes and strides make the filter gradient kernel size its buffer incorrectly, causing a heap overflow when the op runs.
- Division by 0 in `Conv2DBackpropInput` Empty filter and gradient tensors make the op divide by a caller-controlled zero quantity, crashing the process.
- Null pointer dereference in `StringNGrams` Missing validation of data_splits lets crafted input yield a null output buffer that is later written, crashing the process.
- Crash in `tf.transpose` with complex inputs Passing a complex value together with conjugate=True to the transpose operation triggers a crash.
- CHECK-fail due to integer overflow Integer overflow when building a dense shape in the sparse split op triggers a CHECK failure that crashes the process.
- Division by 0 in `SparseMatMul` An empty input matrix causes a division by zero inside the sparse matrix multiplication kernel, raising a runtime error.
- Lack of validation in data format attributes in TensorFlow Format attributes are not validated in the data-format permutation op, so crafted strings cause out-of-bounds and uninitialised memory reads.
- Write to immutable memory region in TensorFlow ImmutableConst maps a file as read-only but allocates non-integral tensors from it, so writes to the mapped region crash the process.
- CHECK-fail in LSTM with zero-length input in TensorFlow An LSTM or GRU layer receiving zero-length input triggers a CHECK failure that crashes the process on the CUDA backend.
- Heap out of bounds access in MakeEdge in TensorFlow A crafted saved model can cause edge creation to use out-of-range indices, reading heap memory outside the arrays during graph construction.
- Uninitialized memory access in TensorFlow Quantized tensor types are not default-initialised, so a saved model can make the runtime read uninitialised memory.
- Segfault in `tf.quantization.quantize_and_dequantize` An out-of-range axis argument to quantize_and_dequantize reads past the end of a shape array because the bounds check is only a debug assertion.
- Float cast overflow undefined behavior Very large boxes in crop and resize become NaN after casting, causing undefined behaviour that later segfaults.
- Segfault in Tensorflow The eager runtime iterates over a null output tensor for one branch of the Switch op, crashing the process when that branch is taken.