Browse / AI Framework and Platform Flaws / Memory corruption
Memory corruption
159 records in AI Framework and Platform Flaws.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Heap buffer overflow in Tensorflow A double-indexed reverse map in the sparse fill gradient can point past the end of the gradient values buffer, writing outside a heap allocation.
- Integer truncation in Shard API usage Shard callers pass lambdas taking 32-bit integers where 64-bit is expected, so large workloads truncate indices and write outside heap buffers.
- Out of bounds access in tensorflow-lite A crafted negative segment id in a TFLite segment sum kernel makes the write index fall outside a heap buffer.
- Heap buffer overflow in Tensorflow Sparse count inputs with mismatched indices and values shapes cause out-of-bounds heap reads and writes.
- Data corruption in tensorflow-lite A no-op debug check in the Lite interpreter lets a crafted model with mismatched tensor dimensions cause out-of-bounds reads and writes.
- Out of bounds write in tensorflow-lite A Lite model whose segment ids are unsorted causes the segment sum kernel to size the output too small, then write past its end.
- Heap buffer overflow in Tensorflow RaggedCountSparseOutput does not check that splits form a valid partition of values, so a crafted input drives a read past a heap buffer.