All tracked items across vulnerabilities, news, research, incidents, and regulatory updates.
TensorFlow Lite (a lightweight version of TensorFlow used on mobile and embedded devices) versions before 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 had a bug where a specially crafted model file could trick the software into trying to read from an empty memory location (null pointer dereference, where the program attempts to access data that doesn't exist). An attacker could modify the model file to convert a read-only tensor (a data structure the AI uses) into a read-write one, causing the runtime to crash or behave unpredictably when it tries to use that tensor.
Fix: Update to TensorFlow Lite versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later. The issue is patched in commit 0b5662bc.
NVD/CVE DatabaseTensorFlow Lite (a lightweight version of TensorFlow for mobile and embedded devices) before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 has a bug where it doesn't properly check if two tensors (multi-dimensional arrays of data) have compatible sizes. An attacker can exploit this to cause the interpreter to read or write data outside of the allocated memory region, potentially crashing the program or enabling other attacks.
TensorFlow Lite (a machine learning framework for mobile and embedded devices) had a bug in versions before 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 where it failed to properly validate array indices (positions) after converting negative numbers to positive ones. This allowed the program to access memory outside its intended bounds, causing crashes or data corruption. The vulnerability only appeared in non-debug builds because the validation check was disabled in those versions.
A vulnerability in TensorFlow (a machine learning framework) before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 allows attackers to crash systems or corrupt data by modifying a SavedModel (TensorFlow's format for storing trained models). This can disable services that use TensorFlow to run AI models for predictions.
TensorFlow versions before 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 have a vulnerability in the `StringNGrams` function where the `data_splits` argument (a parameter controlling how input data is divided) is not properly checked. This lack of validation allows attackers to trigger a heap overflow (a memory error where data overwrites adjacent memory), potentially exposing sensitive data like return addresses that could help bypass ASLR (address space layout randomization, a security technique that randomizes where programs load in memory).
In eager mode (a way TensorFlow runs code immediately instead of building a computation graph first), versions before 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 fail to set up session state properly. This causes a null pointer dereference (trying to use a pointer that points to nothing), which crashes the program with a segmentation fault (a memory access error).
TensorFlow versions before 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 contain a format string vulnerability (a bug where attackers can manipulate how data is printed to cause crashes) in the tf.strings.as_string function. By controlling the `fill` argument, an attacker can trigger a segmentation fault (a crash caused by accessing invalid memory).
TensorFlow versions before 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 have a bug in the Shard API (a feature that divides work across multiple processors) where functions with smaller integer types are used instead of the required 64-bit integers. When processing large amounts of data, this causes integer truncation (cutting off the extra digits), which can lead to memory crashes, data corruption, or unauthorized memory access.
TensorFlow versions before 2.3.1 have a bug in the `RaggedCountSparseOutput` function where it doesn't properly check that input arguments are valid ragged tensors (a special data structure for storing data with varying lengths). This missing validation can cause a heap buffer overflow (reading memory outside the allowed bounds), which could crash the program or potentially allow attackers to execute code.
TensorFlow versions before 2.3.1 have a bug in the `RaggedCountSparseOutput` function where it doesn't properly check that input data is valid, which can cause a heap buffer overflow (unsafe memory access that corrupts data). If the first value in the `splits` tensor (a structure that partitions data) isn't 0, the program crashes with a segmentation fault (an error when accessing memory illegally).
TensorFlow before version 2.3.1 has a bug in the `RaggedCountSparseOutput` function where it doesn't check that the `splits` tensor (a data structure that describes how elements are grouped in a ragged tensor, which is an array with uneven row lengths) has enough elements. If a user provides an empty or single-element `splits` tensor, the program crashes with a SIGABRT signal (an abort signal sent by the operating system).
TensorFlow (an open-source machine learning framework) versions before 2.3.1 have a bug in the `SparseCountSparseOutput` function where it doesn't check that two input arrays called `indices` and `values` have matching sizes. When the code tries to read from both arrays at the same time without this check, it can accidentally access memory outside the bounds of allocated space, which is a serious security risk.
TensorFlow before version 2.3.1 has a bug in the `SparseCountSparseOutput` function where it doesn't check that input data is in the correct format, specifically that the `indices` tensor (a data structure holding array positions) has the right shape. Attackers can exploit this by sending incorrectly shaped data, which causes the program to crash and creates a denial of service (a type of attack that makes a service unavailable). This vulnerability affects TensorFlow systems where users can control input data.
TensorFlow version 2.3.0 has a vulnerability in two functions, `SparseCountSparseOutput` and `RaggedCountSparseOutput`, that don't check whether the weights tensor (a data structure with values and their positions) matches the shape of the main data being processed. This missing validation allows an attacker to read data outside the intended memory area by providing fewer weights than data values, potentially exposing sensitive information from the computer's memory.
TensorFlow versions before 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 contain a heap buffer overflow (a type of memory error where a program writes data outside its allocated memory space) in the `SparseFillEmptyRowsGrad` function. The bug occurs because of incorrect array indexing that allows `reverse_index_map(i)` to access memory beyond the bounds of `grad_values`, potentially causing the program to crash or behave unexpectedly.
TensorFlow (an open-source machine learning library) before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 has a bug in the `SparseFillEmptyRowsGrad` function where it doesn't properly check the shape (dimensions) of one of its inputs called `grad_values_t`. An attacker could exploit this by sending invalid data to cause the program to crash, disrupting AI systems that use TensorFlow to serve predictions.
TensorFlow versions before 2.2.1 and 2.3.1 have a vulnerability in the `dlpack.to_dlpack` function where it can be tricked into using uninitialized memory (memory that hasn't been set to a known value), leading to further memory corruption. The problem occurs because the code assumes the input is a TensorFlow tensor, but an attacker can pass in a regular Python object instead, causing a faulty type conversion that accesses memory incorrectly.
TensorFlow versions before 2.2.1 and 2.3.1 have a memory leak (wasted computer memory that isn't freed) when users pass a list of strings to a function called `dlpack.to_dlpack`. The bug happens because the code doesn't properly check for error conditions during validation, so it continues running even when it should stop and clean up.
TensorFlow versions before 2.2.1 and 2.3.1 have a bug where invalid arguments to `dlpack.to_dlpack` (a function that converts data between formats) cause the code to create null pointers (memory references that point to nothing) without properly checking for errors. This can lead to the program crashing or behaving unpredictably when it tries to use these invalid pointers.
TensorFlow versions before 1.15.4, 2.0.3, 2.1.2, 2.2.1, and 2.3.1 have a bug in the `tf.raw_ops.Switch` operation where it tries to access a null pointer (a reference to nothing), causing the program to crash. The problem occurs because the operation outputs two tensors (data structures in machine learning frameworks) but only one is actually created, leaving the other as an undefined reference that shouldn't be accessed.
Fix: Update TensorFlow Lite to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later. The issue was patched in commit 8ee24e7949a203d234489f9da2c5bf45a7d5157d.
NVD/CVE DatabaseFix: Update TensorFlow Lite to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later. The issue is patched in commit 2d88f470dea2671b430884260f3626b1fe99830a.
NVD/CVE DatabaseFix: Update TensorFlow to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later, which include the patch from commit adf095206f25471e864a8e63a0f1caef53a0e3a6.
NVD/CVE DatabaseFix: Update TensorFlow to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later, where the issue is patched in commit 0462de5b544ed4731aa2fb23946ac22c01856b80.
NVD/CVE DatabaseFix: Update TensorFlow to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later. The issue is patched in commit 9a133d73ae4b4664d22bd1aa6d654fec13c52ee1.
NVD/CVE DatabaseFix: Update TensorFlow to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later. The issue is patched in commit 33be22c65d86256e6826666662e40dbdfe70ee83.
NVD/CVE DatabaseFix: Update TensorFlow to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later. The issue is patched in commits 27b417360cbd671ef55915e4bb6bb06af8b8a832 and ca8c013b5e97b1373b3bb1c97ea655e69f31a575.
NVD/CVE DatabaseFix: Update TensorFlow to version 2.3.1 or later. The issue is patched in commit 3cbb917b4714766030b28eba9fb41bb97ce9ee02.
NVD/CVE DatabaseFix: Update TensorFlow to version 2.3.1 or later, which includes the patch released in commit 3cbb917b4714766030b28eba9fb41bb97ce9ee02.
NVD/CVE DatabaseFix: Update TensorFlow to version 2.3.1 or later. The issue is patched in commit 3cbb917b4714766030b28eba9fb41bb97ce9ee02.
NVD/CVE DatabaseFix: Update TensorFlow to version 2.3.1 or later. The issue is patched in commit 3cbb917b4714766030b28eba9fb41bb97ce9ee02.
NVD/CVE DatabaseFix: Update TensorFlow to version 2.3.1 or later. The issue is patched in commit 3cbb917b4714766030b28eba9fb41bb97ce9ee02.
NVD/CVE DatabaseFix: The issue is patched in commit 3cbb917b4714766030b28eba9fb41bb97ce9ee02 and is released in TensorFlow version 2.3.1. Users should upgrade to version 2.3.1 or later.
NVD/CVE DatabaseFix: Update TensorFlow to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later. The issue is patched in commit 390611e0d45c5793c7066110af37c8514e6a6c54.
NVD/CVE DatabaseFix: Update TensorFlow to version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later, which contain the patch released in commit 390611e0d45c5793c7066110af37c8514e6a6c54.
NVD/CVE DatabaseFix: Upgrade to TensorFlow version 2.2.1 or 2.3.1, where the issue is patched in commit 22e07fb204386768e5bcbea563641ea11f96ceb8.
NVD/CVE DatabaseFix: Update TensorFlow to version 2.2.1 or 2.3.1, which include the fix released in commit 22e07fb204386768e5bcbea563641ea11f96ceb8.
NVD/CVE DatabaseFix: Update TensorFlow to version 2.2.1 or 2.3.1, which contain the patch for this issue.
NVD/CVE DatabaseFix: Update to TensorFlow version 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1 or later. The issue is patched in commit da8558533d925694483d2c136a9220d6d49d843c.
NVD/CVE Database