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
- Segfault in `simplifyBroadcast` in Tensorflow Calling simplifyBroadcast with all-scalar shapes builds an empty vector that is then indexed, causing a segmentation fault.
- NULL Pointer Dereference and Access of Uninitialized Pointer in TensorFlow Missing validation in boosted trees stats ops allows out-of-bounds heap reads and writes, null pointer dereferences and CHECK failures.
- Reachable Assertion in Tensorflow A tensor protobuf with an invalid dtype or shape and zero elements violates a CHECK assertion, crashing the TensorFlow process.
- Undefined behavior in `SparseTensorSliceDataset` Unvalidated sparse tensor inputs lead the dataset op to dereference a null pointer, crashing the process.
- Uninitialized variable access in Tensorflow AssignOp checks only that the destination tensor is initialised, so it copies uninitialised source data into a new tensor, causing undefined behaviour.
- `CHECK`-fails when building invalid tensor shapes in Tensorflow Several TensorFlow operations accept invalid tensor shapes that trip internal CHECK assertions and crash the process.
- Integer overflow in Tensorflow An integer overflow in the Range op's size computation causes undefined behaviour or oversized allocations when the caller controls the range arguments.
- Integer overflows in Tensorflow Missing shape validation and an unchecked TensorShape construction let crafted sparse tensor inputs overflow, causing huge allocations or assertion crashes.
- Crash when type cannot be specialized in Tensorflow A failed type specialisation during shape inference hits a debug-only check, so the runtime unwraps an error status and crashes.
- Out of bounds read in Tensorflow Invalid inputs to the fractional average pooling gradient op are not checked, causing reads past the end of a heap buffer.
- Out of bounds read in Tensorflow Graph type inference checks an input index only with a debug-mode assertion, so a crafted graph can index past a heap array in release builds.
- Insecure temporary file in Tensorflow TensorFlow uses tempfile.mktemp, so another process can create the predicted filename first in a race and redirect the subsequent file operation.
- Integer Overflow or Wraparound in TensorFlow A user-controlled tensor shape reaches a CHECK in the Grappler constant folding pass, triggering an assertion failure that crashes the process.
- Integer overflow leading to crash in Tensorflow Integer overflow in SparseCountSparseOutput produces a bad allocation size that crashes the TensorFlow process.
- Abort caused by allocating a vector that is too large in Tensorflow A user-supplied dimension count read from a tensor drives a very large up-front vector reservation during shape inference, which can abort the process.
- Arbitrary code execution in H2 Console A crafted H2 JDBC URL with an INIT=RUNSCRIPT setting makes the console run an attacker-supplied SQL script.
- Files on the host computer can be accessed from the Gradio interface Older Gradio versions served static files without path checks, so anyone with a public link could read host files by path.
- RCE in H2 Console The H2 Console accepts JNDI lookups that load remote classes, letting an exposed console instance run attacker-supplied code.
- Inefficient Regular Expression Complexity in nltk (word_tokenize, sent_tokenize) A long crafted input makes the Punkt-based tokenizers and word_tokenize run regex backtracking that takes super-linear time.
- NLTK Vulnerable to REDoS Regex taggers in NLTK can be driven into catastrophic backtracking by crafted input, stalling the process.
- Improper Restriction of XML External Entity Reference in com.h2database:h2. Retrieving SQLXML as a DOM source makes H2 parse XML with external entities enabled, so attacker-supplied entities can read or fetch resources.
- Overflow/crash in `tf.tile` when tiling tensor is large Oversized tile arguments overflow the output element count, triggering a CHECK failure that aborts the process.
- Heap OOB in `SparseBinCount` Sparse bin-count does not check that values fit the output shape, so an out-of-range bin index writes past a heap buffer.
- Heap buffer overflow in `Transpose` Shape inference for Transpose does not validate negative permutation indices, so an out-of-range index causes a heap buffer overflow.
- Code injection in `saved_model_cli` The saved_model_cli tool passes user-supplied input expressions to eval, so crafted arguments execute arbitrary Python code on the host.
- Heap OOB read in all `tf.raw_ops.QuantizeAndDequantizeV*` ops Shape inference for the QuantizeAndDequantizeV* ops reads heap memory beyond an array when given a negative axis value.
- Undefined behavior via `nullptr` reference binding in sparse matrix multiplication Zero-dimension inputs to SparseMatMul bind a reference to null, causing undefined behaviour and heap out-of-bounds writes.
- Incomplete validation in boosted trees code Missing input validation in boosted trees stats kernels lets crafted arguments cause null dereferences, assertion failures, and out-of-bounds heap reads and writes.
- Null pointer exception when `Exit` node is not preceded by `Enter` op A raw TensorFlow Exit op with no matching Enter causes graph construction to dereference a null parent pointer and crash the process.
- Overflow/crash in `tf.image.resize` when size is large An oversized resize argument overflows the computed output element count and trips a CHECK that aborts the process.
- FPE in convolutions with zero size filters Convolution kernels divide by zero when given empty filter tensors, crashing the process with a floating-point exception.
- Segfault while copying constant resource tensor Constant folding during graph optimisation attempts a deep copy of a resource tensor that should be immutable, and the copy crashes the process.
- A use of uninitialized value vulnerability in Tensorflow A saved model without a dequeue node makes TensorFlow's Grappler optimizer read a variable that was never initialised.
- FPE in `ParallelConcat` A ParallelConcat call with a zero shape is not validated, so the kernel divides by zero and the process crashes.
- Integer division by 0 in `tf.raw_ops.AllToAll` A zero split_count argument makes AllToAll shape inference divide by zero during tracing, crashing the process.
- Segfault due to negative splits in `SplitV` Negative values in the split size list are not validated, so crafted arguments make the split operation segfault.
- Crash in `tf.math.segment_*` operations Passing a very large segment id to tf.math.segment_* ops overflows a shape calculation, triggering a CHECK failure that aborts the process.
- Access to invalid memory during shape inference in `Cudnn*` ops Shape inference for Cudnn RNN ops reads dimensions from inputs of unchecked rank, causing out-of-bounds heap memory access.
- Heap OOB in shape inference for `QuantizeV2` Shape inference for QuantizeV2 uses a negative axis below -1 as an index into input dimensions without bounds checking, reading memory before a heap buffer.
- Heap OOB in `FusedBatchNorm` kernels Malformed tensor shapes passed to the FusedBatchNormGrad kernel cause a heap out-of-bounds access.
- Heap OOB read in `tf.ragged.cross` Shape inference for the ragged cross op reads past a heap buffer when given crafted sparse inputs.
- Incomplete validation in `tf.summary.create_file_writer` Passing non-scalar arguments to the summary file writer constructor trips an assertion and crashes the process.
- Use after free / memory leak in `CollectiveReduceV2` An async error path in CollectiveReduceV2 uses a callback after it was moved from, causing use-after-free and memory leaks.
- Deadlock in mutually recursive `tf.function` objects A non-reentrant lock causes mutually recursive tf.function objects to deadlock when called, hanging any process that loads such a model.
- Unitialized access in `EinsumHelper::ParseEquation` The einsum equation parser does not set ellipsis flags on every path, so callers read uninitialised variables.
- Arbitrary memory read in `ImmutableConst` A crafted ImmutableConst op maps an attacker-named file as string memory, letting the attacker read arbitrary file contents.
- Heap OOB read in `tf.raw_ops.SparseCountSparseOutput` Shape inference for a sparse count op never checks the rank of its indices input, so a malformed tensor triggers an out-of-bounds heap read.
- Crash in `max_pool3d` when size argument is 0 or negative Pooling layers do not check that window sizes are positive, so a zero or negative dimension crashes the process.
- Incomplete validation of shapes in multiple TF ops Several ops skip shape validation on tensor arguments, allowing crashes and out-of-bounds heap reads or writes.
- Crashes due to overflow and `CHECK`-fail in ops with large tensor shapes Tensor shape size computations can overflow int64 and hit CHECK failures, so a crafted shape crashes the process instead of returning an error.