Browse / AI Framework and Platform Flaws / Memory corruption
Memory corruption
159 records in AI Framework and Platform Flaws.
- ONNX: Out-of-Bounds Read in RNN/GRU/LSTM Shape Inference (Old Opsets, Missing Rank Check) A malformed old-opset RNN node with a short input shape makes shape inference read past array bounds, crashing any process that loads the model.
- vLLM: Incomplete CVE-2025-62164 remediation can be bypassed by concurrent prompt parts Two concurrent prompt-embedding parts race on a process-wide sparse-check flag, letting a malformed sparse tensor reach dense conversion unchecked.
- ONNX: Heap-Buffer-Overflow READ in Gemm Version Converter Adapter via Undersized Input Shape The Gemm 7-to-6 version adapter reads shape entries without checking tensor rank, so a model with a one-dimensional input reads past its heap allocation.
- vLLM makes Use of Uninitialized Resource A helper in vLLM's KV cache interface reads an uninitialised resource, reachable remotely though hard to exploit.
- MLX has heap-buffer-overflow in load() A crafted NumPy .npy header makes the loader read past a heap buffer because it truncates the header at a null byte and skips a length check.
- PyTorch is Vulnerable to Memory Consumption through pad_packed_sequence Function A crafted input to the PyTorch packed sequence padding function causes memory corruption, but only with local access.
- PyTorch is vulnerable to memory corruption through its torch.lstm_cell function Crafted inputs to torch.lstm_cell cause memory corruption when the function is invoked locally.
- PyTorch is vulnerable to memory corruption through its torch.jit.script function A crafted input to torch.jit.script causes memory corruption in PyTorch, which can be triggered locally.
- PyTorch is vulnerable to memory corruption through its unpack_sequence function A crafted input to torch's unpack_sequence corrupts memory in native code, and the flaw can be triggered locally.
- PyTorch Tuple Handler is Vulnerable to Memory Corruption through Manipulation of None Argument Passing a None argument to a profiler callback helper causes out-of-bounds memory writes in the tuple handling code.
- TensorFlow has segfault in array_ops.upper_bound Passing a tensor that is not rank 2 to upper_bound makes the op read invalid memory and crash with a segmentation fault.
- Pytorch use-after-free vulnerability A use-after-free in the mobile interpreter's runtime code lets memory be accessed after it has been released.
- Onnx Out-of-bounds Read vulnerability An off-by-one in the assertion macros' string copy causes an out-of-bounds read.
- PaddlePaddle stack overflow in paddle.searchsorted Crafted input to the searchsorted tensor operation overflows the stack, causing a crash or corrupting memory.
- PaddlePaddle heap buffer overflow in paddle.repeat_interleave A heap buffer overflow in the repeat_interleave tensor operation lets crafted arguments write past allocated memory.
- PaddlePaddle stack overflow in paddle.linalg.lu_unpack Crafted input to the linear algebra unpacking function overflows the stack in the PaddlePaddle framework.
- Use after free in PaddlePaddle A buffer is used after being freed in the paddle.diagonal tensor operation, a use-after-free in native code.
- Heap buffer overflow in PaddlePaddle A heap buffer overflow in the paddle.trace tensor operation lets crafted input corrupt memory, causing crashes or possibly further compromise.
- TensorFlow vulnerable to Out-of-Bounds Read in GRUBlockCellGrad Crafted tensor inputs to the GRU block cell gradient op make it read beyond the bounds of its buffer.
- TensorFlow has Heap-buffer-overflow in AvgPoolGrad AvgPoolGrad does not validate its size and stride arguments against the input shape, causing a heap buffer overflow.
- TensorFlow vulnerable to Out-of-Bounds Read in DynamicStitch Mismatched indices and data shapes passed to DynamicStitch make the kernel read past the end of a stack buffer.
- TensorFlow has double free in Fractional(Max/Avg)Pool Pooling ratios with non-unit batch or channel values passed to the fractional pooling ops trigger a double free.
- TensorFlow vulnerable to segfault when opening multiframe gif A crafted multi-frame GIF overflows an integer size calculation during decoding, leading to a segmentation fault.
- TensorFlow has a heap out-of-buffer read vulnerability in the QuantizeAndDequantize operation An oversized axis argument to QuantizeAndDequantize ops causes an out-of-bounds heap read, which can crash the process or lead to code execution.
- TensorFlow has segmentation fault in tfg-translate Mismatched integer sizes in generic function handling cause out-of-bounds memory access when tfg-translate processes crafted input.
- PaddlePaddle Out-of-bounds Read vulnerability gather_tree reads past the end of its input buffer, which is an out-of-bounds read in the PaddlePaddle kernel.
- Tensorflow vulnerable to Out-of-Bounds Read A true_classes entry larger than range_max makes the candidate sampler read past the end of a heap buffer.
- Overflow in `ResizeNearestNeighborGrad` A large size input makes the nearest-neighbour gradient kernel overflow its size calculation, corrupting memory.
- Overflow in `ImageProjectiveTransformV2` An oversized output shape causes an integer overflow in the image transform's size calculation, leading to invalid memory handling.
- Overflow in `FusedResizeAndPadConv2D` A very large size argument makes FusedResizeAndPadConv2D's shape arithmetic overflow, leading to out-of-bounds memory handling.
- Out of bounds write in grappler in Tensorflow Input and output size arguments to the Grappler function builder can be mismatched, causing an out-of-bounds memory read or a crash.
- `FractionalMaxPoolGrad` Heap out of bounds read Out-of-range pooling sequence values passed to a TensorFlow fractional max pool gradient op cause a heap out-of-bounds read that crashes the process.
- Heap overflow in `QuantizeAndDequantizeV2` Quantisation arguments with mismatched sizes and an oversized axis cause an out-of-bounds memory read in TensorFlow's Grappler function construction.
- `MirrorPadGrad` heap out of bounds read Out-of-range paddings values passed to the MirrorPadGrad op make it read outside a heap buffer during gradient computation.
- Out of bounds segmentation fault due to unequal op inputs in Tensorflow Calling the op with mismatched counts of indices and data tensors triggers an out-of-bounds access and a segmentation fault.
- FractionalMaxPool and FractionalAVGPool heap out-of-bounds acess A pooling_ratio below 1 causes out-of-bounds heap access in the fractional max and average pooling kernels.
- Buffer overflow in `CONV_3D_TRANSPOSE` on TFLite A crafted model with mismatched channel counts makes the reference Conv3DTranspose kernel advance its pointer incorrectly, writing bias values past the buffer.
- TensorFlow vulnerable to heap out of bounds read in filesystem glob matching The filesystem glob matcher indexes the directory array past its end, so a glob over a specific directory layout reads out of bounds and crashes.
- TensorFlow vulnerable to OOB write in `scatter_nd` in TF Lite Out-of-range index values in ScatterNd cause writes outside the output tensor buffer.
- TensorFlow vulnerable to OOB read in `Gather_nd` in TF Lite Certain GatherNd input sizes are not checked against output sizes, causing reads past the end of the buffer in TF Lite.
- Segfault and OOB write due to incomplete validation in `EditDistance` in TensorFlow Crafted negative indices make EditDistance read or write outside its buffers, causing a crash or memory corruption.
- Heap buffer overflow due to incorrect hash function in TensorFlow The tensor key hash reads raw bytes using a size estimate that does not match the contiguous buffer, causing heap overflows.
- Missing validation results in undefined behavior in `QuantizedConv2D` Passing empty minimum and maximum tensors to the quantized convolution op leaves internal references null, so the kernel reads through invalid pointers.
- Missing validation results in undefined behavior in `SparseTensorDenseAdd Mismatched sparse indices and empty values reach a kernel that binds a reference to null, causing undefined behaviour.
- Incomplete validation in `SparseSparseMinimum` SparseSparseMinimum accepts invalid sparse tensor triples that are not checked for empty inputs or index-shape consistency, causing out-of-bounds heap writes.
- Integer overflow in Tensorflow Multiplying tensor dimension sizes in the cost estimator can overflow for very large operations, producing a wrong output size.
- Out of bounds read in Tensorflow The Dequantize op does not check the upper bound of the axis argument, so out-of-range values cause heap reads past the end of the dimension array.
- Use after free in `DecodePng` kernel After freeing PNG decode state on an error path, the decoder reads width and height values that are no longer defined, causing a use-after-free.
- Improper Validation of Integrity Check Value in TensorFlow Sparse split does not check that the axis argument is scalar, so crafted arguments cause out-of-bounds reads and segfaults.
- Heap overflow in Tensorflow Negative minlength and maxlength values passed to a sparse count op with crafted indices cause writes past the end of a heap buffer.