Browse All

TensorFlow, an open source machine learning platform, has a vulnerability in the `SparseFillEmptyRows` function that can cause a heap OOB access (out-of-bounds read, where a program tries to read memory it shouldn't access) when the size of `indices` does not match the size of `values`. This is a memory safety bug that could potentially crash the program or expose sensitive data.

TensorFlow, an open source machine learning platform, has a vulnerability in its `FusedBatchNorm` kernels that allows heap OOB access (out-of-bounds memory reading, where a program tries to read data outside the memory space it's allowed to use). This bug affects multiple older versions of TensorFlow that are still supported.

TensorFlow, an open source platform for machine learning, has a vulnerability in its sparse matrix multiplication code where it can crash or behave unpredictably (undefined behavior) if matrix dimensions are 0 or less, because the code tries to write to an empty memory location (nullptr, a reference to nothing). When dimensions are invalid, the code should create an empty output but not write to it, otherwise it causes a heap OOB access (writing data outside the boundaries of allocated memory).

TensorFlow, an open source machine learning platform, has a bug in its shape inference code for the `tf.ragged.cross` function where it tries to use a null pointer (a reference to nothing), causing undefined behavior. The vulnerability is caused by accessing an uninitialized pointer (a memory location that hasn't been set up yet).

TensorFlow, an open source machine learning platform, has a vulnerability in its shape inference code for the `tf.ragged.cross` function that allows reading data outside the bounds of allocated memory (an out-of-bounds read, which can cause crashes or expose sensitive data). The vulnerability affects multiple versions of TensorFlow and has been patched in newer releases.

TensorFlow, an open-source machine learning platform, has a vulnerability in its shape inference code for the `QuantizeV2` function that allows reading memory outside of the intended boundaries (heap OOB read, or out-of-bounds read) when the `axis` parameter is given a negative value less than -1. This happens because the code doesn't properly validate that negative axis values stay within acceptable bounds before accessing memory.

TensorFlow, an open source platform for machine learning, has a vulnerability in its shape inference functions for `QuantizeAndDequantizeV*` operations that can cause the program to read data outside the bounds of allocated memory (an out-of-bounds read, which is a memory safety error). This affects multiple versions of TensorFlow.

TensorFlow, an open-source machine learning platform, has a vulnerability where attackers can cause crashes or undefined behavior (unpredictable program execution) by modifying saved checkpoints (saved states of a trained model) from outside the system, because the checkpoint loading code doesn't properly validate file formats. This affects multiple versions of TensorFlow that are still being supported.

TensorFlow, an open source machine learning platform, had a vulnerability in its shape inference functions for `SparseCountSparseOutput` that could cause an out-of-bounds read (accessing memory outside the intended area of a heap-allocated array, which can crash the program or leak data). This vulnerability affected multiple versions of TensorFlow.

TensorFlow, an open source machine learning platform, has a bug in the `EinsumHelper::ParseEquation()` function where it fails to properly initialize certain flags (variables that track whether ellipsis notation is used in inputs and outputs). The function only sets these flags to true but never to false, which can cause the program to read uninitialized memory (garbage values) if code calling this function assumes the flags are always set correctly.

CVE-2021-42694 is a vulnerability in the Unicode Specification (up to version 14.0) that allows attackers to create source code identifiers (like function names) using homoglyphs (characters that look identical but are technically different) to sneak malicious code into software. An attacker could use these visually identical but distinct characters in upstream dependencies (external code libraries), and developers reviewing the code might not catch the deception, allowing the malicious code to be used downstream (in other software that depends on it).