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 `ResourceGather` A zero batch size in ResourceGather causes a division by zero that crashes the process.
- Reference binding to nullptr in map operations An empty indices argument in map operations leaves a reference bound to null, causing undefined behaviour in the kernel.
- Heap OOB in boosted trees Out-of-range indices in the sparse best-split calculation cause heap out-of-bounds reads when the caller supplies crafted stats summary indices.
- FPE in TFLite division operations TFLite division does not check for zero divisors, so a zero-valued divisor tensor crashes the process.
- Reference binding to nullptr in shape inference Shape inference for SparseFillEmptyRows does not reject empty inputs, so it binds a reference to a null pointer, causing undefined behaviour.
- Incomplete validation in MKL requantization Missing dimension validation in the MKL requantization kernels lets crafted inputs cause null reference binding and out-of-bounds heap access.
- Crash in NMS ops caused by integer conversion to unsigned A negative output size is implicitly converted to an unsigned value during vector resize, causing the NMS kernel to crash.
- Reference binding to nullptr in `RaggedTensorToVariant` Empty split arguments in a raw op call cause a null reference to be bound, producing undefined behaviour from crafted tensor inputs.
- Reference binding to nullptr in unicode encoding Calling the UnicodeEncode op with empty split tensors makes the kernel bind a reference to null before checking for emptiness, causing undefined behaviour.
- Incorrect validation of `SaveV2` inputs SaveV2 sets an error status on invalid inputs but keeps executing, so crafted inputs cause a null pointer dereference.
- Heap OOB read in TFLite's implementation of `Minimum` or `Maximum` TFLite Minimum and Maximum broadcasting indexes both inputs with the same index without bounds checks, so an empty input causes heap out-of-bounds reads.
- Division by zero in optimized pooling implementations in TFLite Optimized TFLite pooling kernels divide by stride values from the model without checking for zero, so a crafted model triggers a division-by-zero crash.
- CHECK-fail in AddManySparseToTensorsMap A crafted sparse shape passed to a TensorFlow op triggers a CHECK failure that aborts the process.
- Heap buffer overflow in `QuantizedReshape` QuantizedReshape reads the first element of its threshold tensors without checking they are non-empty, so empty inputs cause a heap overflow.
- 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.
- CHECK-fail in `tf.raw_ops.IRFFT` A crafted empty-length input to the inverse real FFT hits an assertion in the Eigen code, crashing the process.
- CHECK-fail in DrawBoundingBoxes An empty image passed to DrawBoundingBoxes hits a CHECK assertion that aborts the process instead of returning an error.
- 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.
- Division by zero in TFLite's convolution code Several TFLite convolution computations divide by a user-controlled dimension value that is never checked for zero, crashing the process.
- CHECK-fail in tf.raw_ops.EncodePng Passing an empty pixel tensor to the PNG encoder op passes a null buffer into a CHECK, aborting the process.
- Division by zero in TFLite's implementation of `GatherNd` A crafted TFLite model supplies an empty params tensor, so a zero dimension is used as a divisor in the GatherNd kernel.
- 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.
- Type confusion during tensor casts lead to dereferencing null pointers Passing non-numeric tensor dtypes to numeric TensorFlow operations leads to null pointer dereferences and process crashes.
- 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.
- Null dereference in Grappler's `TrySimplify` The arithmetic optimizer dereferences a null pointer when simplifying a graph node that has no inputs, crashing the process.
- 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.
- Division by 0 in `Conv2D` A zero-sized Conv2D input makes the kernel divide by a caller-controlled filter dimension, crashing the operation with a division by zero.
- 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.
- 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.