Browse All

TensorFlow (an open source machine learning platform) has a vulnerability in the `ImmutableConst` operation that allows attackers to read arbitrary memory contents. The issue occurs because the operation doesn't properly handle a special type of string called `tstring` that can reference memory-mapped data.

TensorFlow's Grappler optimizer (the part of TensorFlow that improves how machine learning models run) has a bug where a variable called `dequeue_node` is never initialized if a saved model doesn't contain a specific type of operation called a `Dequeue` node. This uninitialized variable could cause the optimizer to behave unpredictably or crash.

TensorFlow, an open source platform for machine learning, has a vulnerability in the `SplitV` function where supplying negative arguments can cause a segfault (a crash from accessing invalid memory). The crash happens when the `size_splits` parameter contains multiple values with at least one being negative.

TensorFlow (an open source platform for machine learning) contains a vulnerability in its shape inference function for the `Transpose` operation where negative values in the `perm` parameter can cause a heap buffer overflow (writing data outside the intended memory boundaries). The issue stems from insufficient validation of the indices in `perm` before they are processed.

TensorFlow, an open source machine learning platform, has a vulnerability in its `tf.function` API (a feature that converts Python functions into optimized operations) where mutually recursive functions (functions that call each other back and forth) can cause a deadlock using a non-reentrant Lock (a mechanism that prevents simultaneous access but doesn't allow the same thread to re-enter it). An attacker could cause a denial of service by tricking users into loading vulnerable models, though this scenario is uncommon.

TensorFlow, an open source machine learning platform, has a bug in its shape inference code for the `AllToAll` function that causes a division by zero error (when a value is divided by 0, causing the program to crash) whenever the `split_count` argument is set to 0. This vulnerability could allow an attacker to crash or disrupt a TensorFlow application.

TensorFlow (an open source platform for machine learning) has a bug where its convolution operators (mathematical functions that process data in neural networks) crash with a division by zero error when given empty filter tensors (arrays of parameters). This vulnerability affects multiple versions of TensorFlow.

TensorFlow, an open source platform for machine learning, has a vulnerability in its `ParallelConcat` function that lacks proper input validation and can cause a division by zero error (a crash caused by dividing a number by zero). The affected versions have known fixes available through updates to TensorFlow 2.7.0 and earlier supported versions.

TensorFlow, an open source platform for machine learning, has a bug in its `tf.range` function where a conditional statement mixes two different number types (int64, a large integer type, and double, a decimal number type). Due to how C++ automatically converts between these types, the calculation overflows (produces incorrect results that are too large to store). This causes the output size calculation to fail.

TensorFlow, an open source machine learning platform, has a vulnerability where the code that builds a control flow graph (the structure representing how data moves through a model) crashes when it assumes paired nodes exist but they don't. When the first node in a pair is missing, the code tries to use a null pointer (a reference to nothing), causing the program to crash.

TensorFlow, an open source machine learning platform, has a vulnerability where the shape inference code for `DeserializeSparse` (a function that converts serialized data back into sparse tensors, which are data structures that efficiently store mostly-empty matrices) can crash due to a null pointer dereference (trying to access memory that hasn't been allocated). This happens because the code incorrectly assumes the input tensor has a specific structure.