AI Sec Watch

TensorFlow, an open-source machine learning framework, has a bug in the `SparseTensorSliceDataset` component where it can crash by dereferencing a null pointer (accessing memory that doesn't exist) when given certain inputs. The code doesn't properly check that its three input arguments meet required conditions before using them.

A bug in TensorFlow's `StringNGrams` function (a tool that breaks text into small overlapping pieces) allows attackers to crash the system by causing it to run out of memory through an integer overflow (when a number gets too large and wraps around to an incorrect value). The problem stems from missing validation on the `pad_width` parameter, which can result in a negative `ngram_width` value that causes excessive memory allocation.

TensorFlow (an open source machine learning framework) has a vulnerability in its `ThreadPoolHandle` component that allows attackers to cause a denial of service attack (making a service unavailable by overwhelming it) by allocating excessive memory. The problem exists because the code only checks that the `num_threads` argument is not negative, but does not limit how large the value can be.

TensorFlow, an open-source machine learning framework, has a bug in its shape inference (the process of figuring out data dimensions) for the `ConcatV2` operation that can be exploited to crash a program through a segfault (a memory access error). The vulnerability occurs because a type confusion (mixing up different data types) allows a negative value to bypass a safety check, potentially letting attackers cause a denial of service attack (making the system unavailable).

TensorFlow, an open-source machine learning framework, has a vulnerability in its `FractionalAvgPoolGrad` function that fails to validate input data properly, allowing an attacker to read memory from outside the intended bounds of the heap (out-of-bounds read, where a program accesses data it shouldn't). This is a memory safety issue that could let attackers access sensitive information.

TensorFlow, an open source machine learning framework, has a bug in its shape inference for the `ReverseSequence` operation where it doesn't properly check if the `batch_dim` parameter is a negative number, allowing it to read memory outside the intended array bounds (a heap OOB read, or out-of-bounds read that accesses invalid memory). While the code checks that `batch_dim` isn't larger than the input rank, it fails to reject negative values that are too extreme, which can cause the program to access memory before the start of the array.

TensorFlow, an open source machine learning framework, has a vulnerability in its shape inference for the `Dequantize` operation where the `axis` argument is not properly validated. An attacker can provide an unexpectedly large `axis` value that causes an integer overflow (when a number becomes too large and wraps around to a negative or incorrect value) when the code adds 1 to it.

TensorFlow, an open-source machine learning framework, has a bug in its `Dequantize` function where the `axis` parameter (which specifies which dimension to operate on) isn't properly validated. This allows attackers to read past the end of an array in memory, potentially causing crashes or exposing sensitive data through a heap OOB (out-of-bounds) access, which means reading memory locations outside the intended storage area.

A vulnerability in Oracle Java SE and Oracle GraalVM Enterprise Edition's JAXP component (a Java library for processing XML data) allows an attacker on the network to read some data they shouldn't have access to without needing to log in. The vulnerability affects several older versions of Java and can be exploited through web services or untrusted code running in a Java sandbox (a restricted environment meant to safely run untrusted programs).