AI & LLM Vulnerabilities

TensorFlow, a machine learning platform, has a vulnerability in the `UnbatchGradOp` function (a component that processes gradient calculations) where it doesn't properly validate its inputs. If given a non-scalar `id` (a single value instead of what's expected) or an incorrectly sized `batch_index` (a list of indices), the function crashes the program. There are no known workarounds for this issue.

TensorFlow's `AvgPoolOp` function has a bug where it doesn't check if the `ksize` argument (a parameter that controls pooling window size) is positive, allowing negative values to crash the program. The issue has been patched and will be included in upcoming TensorFlow releases.

TensorFlow's `RaggedRangOp` function has a bug where passing a very large float value to the `limits` argument causes it to overflow when converted to an `int64` (a 64-bit integer type), crashing the entire program with an abort signal. This vulnerability affects multiple versions of TensorFlow and has no known workaround.

TensorFlow (an open source platform for machine learning) has a bug in SobolSampleOp that crashes the program when it receives unexpected input types, because the code assumes certain inputs will be scalars (single values rather than arrays). This denial of service vulnerability has been fixed and will be released in upcoming versions.

TensorFlow's tf.reshape operation (a function that changes a tensor's shape without altering its data) has a vulnerability that allows attackers to crash the program by causing an integer overflow (when a number exceeds the maximum value a system can store), triggering a denial of service attack (making the service unavailable). The issue affects multiple versions of TensorFlow and has been patched.

Streamlit, a Python framework for building data applications, has a directory traversal vulnerability (a type of attack where an attacker uses specially crafted file paths to access files they shouldn't be able to reach) in versions before 1.11.1. An attacker could trick the Streamlit server into reading and returning sensitive files from the server's file system, such as logs or other confidential information.

TensorFlow, an open source platform for machine learning, had a bug in two signal processing functions (`tf.compat.v1.signal.rfft2d` and `tf.compat.v1.signal.rfft3d`) where missing input validation (checking that data meets expected requirements before processing) could cause the software to crash under certain conditions. The bug was fixed in versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4.

TensorFlow, an open source machine learning platform, had a bug in versions before 2.9.0, 2.8.1, 2.7.2, and 2.6.4 where certain converted models would crash when loaded. The problem occurred because the code assumed that quantization (a technique to compress model size by reducing numerical precision) would always use scaling factors smaller than 1, but sometimes the scale was larger, causing the program to stop unexpectedly.

TensorFlow, an open source platform for machine learning, has a vulnerability in the `tf.histogram_fixed_width` function where it crashes if the input data contains NaN (Not a Number, a special floating point value representing undefined results). The crash happens because the code tries to convert NaN to an integer without checking for it first, and this bug only affects the CPU version of TensorFlow.

TensorFlow version 2.8.0 had a bug in the `TensorKey` hash function (a function that converts data into a fixed-size code for quick lookups), where it incorrectly used `AllocatedBytes()` (an estimate of memory used by a tensor, including referenced data like strings) to access the actual tensor data bytes. This caused crashes because `AllocatedBytes()` doesn't represent the real contiguous memory buffer, and certain data types like `tstring` contain pointers rather than actual values.

TensorFlow, an open source machine learning platform, had a bug in versions before 2.9.0, 2.8.1, 2.7.2, and 2.6.4 where assertion macros (special code blocks that check if conditions are true) incorrectly compared different data types, specifically `size_t` and `int` values (two different ways to store whole numbers). This type confusion could cause assertions to trigger incorrectly due to how the computer converts between these different number types.

CVE-2022-29206 is a bug in TensorFlow (an open source machine learning platform) where a specific function called `tf.raw_ops.SparseTensorDenseAdd` doesn't properly check its input arguments, causing a nullptr (a reference pointing to nothing) to be accessed during execution, which leads to undefined behavior. This vulnerability affects TensorFlow versions before 2.9.0, 2.8.1, 2.7.2, and 2.6.4.

TensorFlow (an open-source machine learning platform) has a bug in older versions where calling certain compatibility functions with unsupported data types causes the program to crash. When the code tries to process a missing function, it attempts to use a null pointer (a reference to nothing in memory), which causes a segmentation fault (a type of crash where the program accesses memory it shouldn't).

TensorFlow, an open source platform for machine learning, has a vulnerability in one of its operations called `tf.raw_ops.UnsortedSegmentJoin` where it doesn't properly check its inputs before using them. If someone provides a negative number where a positive one is expected, it causes the program to crash with an assertion failure, which is a type of denial of service attack (making software unavailable by crashing it).