Browse / AI Framework and Platform Flaws
AI Framework and Platform Flaws
Classic software bugs in the libraries and platforms that run AI: memory corruption, traversal, SSRF, auth. 1,542 records. Reference: CWE.
- Denial of service 377
- Authentication and access control 256
- Path traversal and file access 192
- Memory corruption 159
- Code and command execution 133
- Server-side request forgery 103
- Information exposure 78
- Sandbox escape 76
- Cross-site scripting 68
- Other weaknesses 46
- SQL and query injection 22
- Real-world incidents 10
- Cross-site request forgery 8
- Unsafe deserialisation 8
- Data exfiltration 6
- 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.
- 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 `Conv2DBackpropFilter` Crafted empty tensor shapes make the Conv2DBackpropFilter work-unit size zero, triggering a division by zero exception.
- 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 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.
- 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.
- 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.