AI Sec Watch

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.

TensorFlow (an open source platform for machine learning) has a bug where calling a specific function called `tf.summary.create_file_writer` with non-scalar arguments (values that aren't single numbers) causes the program to crash due to a failed assertion check. This vulnerability affects several versions of TensorFlow.

TensorFlow (an open source machine learning platform) has a bug in its `tf.image.resize` function where using very large input values causes the program to crash due to an integer overflow (when a number becomes too large for its storage type). The overflow is caught by a safety check that stops the entire process.

TensorFlow (an open source machine learning platform) crashes when the `tf.tile` function (which repeats tensor data) is called with very large inputs, because the number of output elements exceeds what an `int64_t` integer type can hold, causing an overflow that triggers a safety check and terminates the process.

TensorFlow (an open source machine learning platform) has a vulnerability where tensors (multi-dimensional arrays of numbers) with very large dimensions can cause an integer overflow (when a calculation produces a number too big to store), resulting in a crash or inconsistent behavior. The vulnerability occurs because the code checks for overflow incorrectly in some parts of the codebase.

TensorFlow (an open source machine learning platform) has a bug in its Keras pooling layers (functions that reduce data size by sampling from groups of values) that can cause a segfault (crash where the program tries to access invalid memory) if the pool size is 0 or if a dimension is negative, because the code doesn't check that these values are positive.

TensorFlow's `tf.math.segment_*` operations (functions that process data divided into segments) crash with a denial of service error when a segment ID is very large, because the code doesn't properly handle cases where the output size exceeds what an int64_t (a 64-bit integer type) can store. The crash happens in both CPU and GPU implementations when computing output shape.

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).