CVE-2021-41205: TensorFlow is an open source platform for machine learning. In affected versions the shape inference functions for the `

Summary: 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.

Solution: The fix will be included in TensorFlow 2.7.0. The patch will also be applied to TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these versions are affected and still supported.


CVE-2021-41204: TensorFlow is an open source platform for machine learning. In affected versions during TensorFlow's Grappler optimizer

Summary: TensorFlow, an open source machine learning platform, has a bug in its Grappler optimizer (the part that optimizes computational graphs) where constant folding (simplifying calculations before running them) incorrectly tries to copy resource tensors (special data structures that shouldn't be modified), causing the program to crash. The issue affects multiple versions of TensorFlow.

Solution: The fix will be included in TensorFlow 2.7.0. Updates will also be available in TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4.


CVE-2021-41203: TensorFlow is an open source platform for machine learning. In affected versions an attacker can trigger undefined behav

Summary: 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.

Solution: The fixes will be included in TensorFlow 2.7.0. Additionally, patches will be cherry-picked (applied) to TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, which are also affected and still in the supported range.


CVE-2021-41210: TensorFlow is an open source platform for machine learning. In affected versions the shape inference functions for `Spar

Summary: 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.

Solution: The fix is included in TensorFlow 2.7.0. The patch was also cherry-picked (applied to earlier versions) for TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, which were still in the supported range at the time.


CVE-2021-41201: TensorFlow is an open source platform for machine learning. In affeced versions during execution, `EinsumHelper::ParseEq

Summary: 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.

Solution: The fix will be included in TensorFlow 2.7.0. The fix will also be backported (cherry-picked) to TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4.


CVE-2021-41200: TensorFlow is an open source platform for machine learning. In affected versions if `tf.summary.create_file_writer` is c

Summary: 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.

Solution: The fix will be included in TensorFlow 2.7.0. The developers will also apply this fix to TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, which are still in the supported range. Users can reference the patch commit at https://github.com/tensorflow/tensorflow/commit/874bda09e6702cd50bac90b453b50bcc65b2769e.


CVE-2021-41199: TensorFlow is an open source platform for machine learning. In affected versions if `tf.image.resize` is called with a l

Summary: 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.

Solution: The fix will be included in TensorFlow 2.7.0. The fix will also be backported to TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4.


CVE-2021-41198: TensorFlow is an open source platform for machine learning. In affected versions if `tf.tile` is called with a large inp

Summary: 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.

Solution: The fix is included in TensorFlow 2.7.0. The patch will also be backported (applied to older versions) in TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4.


CVE-2021-41197: TensorFlow is an open source platform for machine learning. In affected versions TensorFlow allows tensor to have a larg

Summary: 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.

Solution: The fix will be included in TensorFlow 2.7.0. Users of affected versions should update to TensorFlow 2.7.0, or apply cherrypicked patches available for TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4.


CVE-2021-41196: TensorFlow is an open source platform for machine learning. In affected versions the Keras pooling layers can trigger a

Summary: 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.

Solution: Update to TensorFlow 2.7.0, or apply the fix via cherrypicked commits in TensorFlow 2.6.1, TensorFlow 2.5.2, or TensorFlow 2.4.4.


CVE-2021-41195: TensorFlow is an open source platform for machine learning. In affected versions the implementation of `tf.math.segment_

Summary: 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.

Solution: The fix will be included in TensorFlow 2.7.0. TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4 will also receive this patch as these versions are still supported.


CVE-2021-42694: An issue was discovered in the character definitions of the Unicode Specification through 14.0. The specification allows

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

Solution: The Unicode Consortium provides guidance on mitigations for this class of issues in Unicode Technical Standard #39, Unicode Security Mechanisms, and has documented this security vulnerability in Unicode Technical Report #36, Unicode Security Considerations.


CVE-2021-41127: Rasa is an open source machine learning framework to automate text-and voice-based conversations. In affected versions a

Summary: Rasa is a framework for building conversational AI systems, and versions before 2.8.10 have a vulnerability where a malicious model file (a compressed archive containing trained AI weights) can overwrite or replace important bot files. This happens because the software doesn't properly validate what's inside the model file before extracting it.

Solution: The vulnerability is fixed in Rasa 2.8.10. For users unable to update, ensure that users do not upload untrusted model files, and restrict CLI (command-line interface, a text-based way to control software) or API endpoint access (network connections that allow external programs to interact with Rasa) where a malicious actor could target a deployed Rasa instance.


Video: Understanding Image Scaling Attacks

Summary: Adversaries can hide a smaller image within a larger one so that it becomes visible when a computer resizes the image using insecure interpolation (a method of calculating pixel values between known points). The video demonstrates this attack technique and explains how to prevent it from happening.

Solution: The source mentions that mitigation is discussed in the video but does not explicitly state the mitigation steps in the text provided. N/A -- no specific mitigation described in source.


CVE-2021-39207: parlai is a framework for training and evaluating AI models on a variety of openly available dialogue datasets. In affec

Summary: ParlAI, a framework for training AI models on dialogue datasets, has a vulnerability where it unsafely loads YAML files (a data format), allowing attackers to execute arbitrary code on affected systems. The vulnerability occurs because the framework uses an unsafe YAML loader that can be tricked into running malicious code hidden in data files.

Solution: Update ParlAI to version v1.1.0 or above. If upgrading is not possible, change the Loader to SafeLoader as a workaround. See commit 507d066ef432ea27d3e201da08009872a2f37725 for details.


Using Microsoft Counterfit to create adversarial examples for Husky AI

Summary: This post describes Microsoft Counterfit, a tool for testing machine learning models against adversarial attacks (subtle modifications to input data designed to fool AI systems). The author demonstrates how to set up Counterfit, create a custom target for a husky image classifier, and use the tool's built-in attack modules to test the model's robustness.

Solution: N/A -- no mitigation discussed in source.

Microsoft Counterfit
HuggingFace
IBM Adversarial Robustness Toolbox
TextAttack
Keras
TensorFlow


CVE-2021-37690: TensorFlow is an end-to-end open source platform for machine learning. In affected versions when running shape functions

Summary: TensorFlow, an open-source machine learning platform, had a bug where certain shape functions created temporary data structures (ShapeAndType structs) that were deleted too quickly, causing crashes (segfaults, or sudden program failures) if other code tried to access them. The issue was that while normal output shapes were being protected by copying them to safer ownership, the code wasn't doing the same protection for shapes and types together.

Solution: The issue was patched in GitHub commit ee119d4a498979525046fba1c3dd3f13a039fbb1 and fixed by applying the same cloning logic to output shapes and types. The fix is included in TensorFlow 2.6.0, and was also backported (added to earlier versions) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37692: TensorFlow is an end-to-end open source platform for machine learning. In affected versions under certain conditions, Go

Summary: TensorFlow (an open source machine learning platform) had a bug where Go code could crash the program during memory cleanup of string tensors if encoding failed. The problem occurred because the cleanup process assumed encoding always succeeded, but didn't check whether it actually did.

Solution: The fix defers calling the finalizer function (the cleanup code) until after the tensor is fully created, and changes how memory is deallocated for string tensors to be based on bytes actually written rather than assuming encoding succeeded. This was patched in GitHub commit 8721ba96e5760c229217b594f6d2ba332beedf22 and will be included in TensorFlow 2.6.0 and will be backported to TensorFlow 2.5.1.


CVE-2021-37691: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can craft a TFLi

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where an attacker can create a specially crafted TFLite model (a lightweight version of TensorFlow for mobile and embedded devices) that causes a division by zero error (a crash that happens when code tries to divide a number by zero) in its LSH projection feature. This flaw affects multiple versions of TensorFlow.

Solution: The issue has been patched in GitHub commit 0575b640091680cfb70f4dd93e70658de43b94f9. The fix will be included in TensorFlow 2.6.0 and will also be backported (applied to older versions) to TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37687: TensorFlow is an end-to-end open source platform for machine learning. In affected versions TFLite's [`GatherNd` impleme

Summary: TensorFlow Lite (TFLite, a lightweight version of TensorFlow for mobile and embedded devices) has a vulnerability in its `GatherNd` and `Gather` operations that fail to check for negative indices. An attacker can exploit this by creating a specially designed model with negative values to read sensitive data from the heap (temporary memory storage), potentially exposing private information.

Solution: The issue was patched in GitHub commits bb6a0383ed553c286f87ca88c207f6774d5c4a8f and eb921122119a6b6e470ee98b89e65d721663179d. The fix is included in TensorFlow 2.6.0 and will be backported to TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37685: TensorFlow is an end-to-end open source platform for machine learning. In affected versions TFLite's [`expand_dims.cc`](

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in TFLite (TensorFlow Lite, a lightweight version for mobile devices) where a negative `axis` parameter value can cause the software to read data outside the intended memory area. This could potentially expose sensitive information or crash the program.

Solution: The issue was patched in GitHub commit d94ffe08a65400f898241c0374e9edc6fa8ed257. The fix is included in TensorFlow 2.6.0 and was also applied to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37684: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementations of pooli

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability in its pooling operations where the code doesn't check if divisors are zero before dividing, which can cause crashes. The issue has been patched and will be included in upcoming versions of TensorFlow.

Solution: Update to TensorFlow 2.6.0, or apply the patch from GitHub commit dfa22b348b70bb89d6d6ec0ff53973bacb4f4695. If you cannot upgrade to 2.6.0, use patched versions 2.5.1, 2.4.3, or 2.3.4 (these versions will receive the fix via cherrypick).


CVE-2021-37683: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of divisi

Summary: TensorFlow, a popular machine learning platform, has a vulnerability in its division operation in TFLite (a lightweight version for mobile devices) where it doesn't check if the divisor (the number you're dividing by) is zero, which can cause crashes. The issue has been fixed and will be available in several updated versions of the software.

Solution: The fix is included in TensorFlow 2.6.0. It will also be backported (applied to older versions still receiving support) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4. Users should update to one of these patched versions.


CVE-2021-37682: TensorFlow is an end-to-end open source platform for machine learning. In affected versions all TFLite operations that u

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in TFLite (TensorFlow Lite, a lightweight version for mobile devices) where operations using quantization (a technique that reduces model size by using lower-precision numbers) can accidentally use uninitialized values because the code doesn't properly check whether quantization settings are valid before using them. This could cause unpredictable behavior in machine learning models running on mobile or embedded devices.

Solution: The issue has been patched in GitHub commits 537bc7c723439b9194a358f64d871dd326c18887, 4a91f2069f7145aab6ba2d8cfe41be8a110c18a5, and 8933b8a21280696ab119b63263babdb54c298538. The fix is included in TensorFlow 2.6.0 and has been backported to TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37679: TensorFlow is an end-to-end open source platform for machine learning. In affected versions it is possible to nest a `tf

Summary: TensorFlow has a vulnerability where nesting `tf.map_fn` (a function that applies operations to tensor elements) calls with RaggedTensor inputs (tensors with variable row lengths) and no function signature can leak uninitialized memory from the heap and potentially cause data loss. The bug occurs because the code doesn't verify that inner tensor shapes match when converting from a Variant tensor to a RaggedTensor.

Solution: The issue was patched in GitHub commit 4e2565483d0ffcadc719bd44893fb7f609bb5f12. The fix is included in TensorFlow 2.6.0 and was also backported (applied to earlier versions) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37678: TensorFlow is an end-to-end open source platform for machine learning. In affected versions TensorFlow and Keras can be

Summary: TensorFlow and Keras had a security flaw where loading machine learning models from YAML files (a text format for storing data) could let attackers run arbitrary code (any commands they want) on a system. The problem was caused by using an unsafe YAML parser that doesn't validate what code it runs.

Solution: The TensorFlow team removed YAML format support entirely and patched the issue in GitHub commit 23d6383eb6c14084a8fc3bdf164043b974818012. The fix is included in TensorFlow 2.6.0, and will also be backported (applied to older versions) in TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37677: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the shape inference code for

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in its shape inference code for the `tf.raw_ops.Dequantize` function that could crash a system (denial of service via segfault, which is when a program crashes due to accessing invalid memory) if an attacker provides invalid arguments. The bug exists because the code doesn't properly validate the `axis` parameter before using it to access tensor dimensions (the size measurements of data structures in machine learning).

Solution: The issue has been patched in GitHub commit da857cfa0fde8f79ad0afdbc94e88b5d4bbec764. The fix is included in TensorFlow 2.6.0 and will be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37674: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can trigger a de

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where attackers can cause a denial of service (making a system unavailable by crashing it) through a segmentation fault (a memory error that crashes a program) in the MaxPoolGrad operation due to missing input validation on certain data structures called tensors. The vulnerability exists because an earlier fix for a related issue was incomplete.

Solution: The issue has been patched in GitHub commit 136b51f10903e044308cf77117c0ed9871350475. The fix will be included in TensorFlow 2.6.0 and will be backported to TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37673: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can trigger a de

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where attackers can crash the system (denial of service, a type of attack that makes a service unavailable) through a function called `tf.raw_ops.MapStage` because it doesn't validate that the `key` input is a proper non-empty tensor (a multi-dimensional array of numbers). This bug affects multiple versions of TensorFlow.

Solution: The issue has been patched in GitHub commit d7de67733925de196ec8863a33445b73f9562d1d. The fix will be included in TensorFlow 2.6.0, and will also be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37672: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can read from ou

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where an attacker can read data outside the intended memory bounds (a heap overflow, which is when a program accesses memory it shouldn't) by sending specially crafted invalid arguments to a function called tf.raw_ops.SdcaOptimizerV2. The vulnerability exists because the code doesn't verify that the length of input labels matches the number of examples being processed.

Solution: The issue has been patched in GitHub commit a4e138660270e7599793fa438cd7b2fc2ce215a6. The fix will be included in TensorFlow 2.6.0, and will also be backported (applied to older supported versions) to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37670: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can read from ou

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where attackers can read data outside the intended memory bounds by sending specially crafted arguments to certain functions like `tf.raw_ops.UpperBound` and `tf.raw_ops.LowerBound`. The vulnerability exists because the code doesn't properly validate the rank (the number of dimensions) of the input data it receives. This could allow attackers to access sensitive information stored in memory.

Solution: The issue was patched in GitHub commit 42459e4273c2e47a3232cc16c4f4fff3b3a35c38. The fix will be included in TensorFlow 2.6.0 and will also be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37669: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause denial

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in its `tf.raw_ops.NonMaxSuppressionV5` function that allows attackers to crash applications by supplying a negative number, which causes a division by zero error due to improper type conversion (converting a signed integer to an unsigned integer).

Solution: Update to TensorFlow 2.6.0 or apply the patches in GitHub commits 3a7362750d5c372420aa8f0caf7bf5b5c3d0f52d and b5cdbf12ffcaaffecf98f22a6be5a64bb96e4f58. Patches are also being cherry-picked (backported) into TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37668: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause denial

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability (CVE-2021-37668) where attackers can crash applications by exploiting the `tf.raw_ops.UnravelIndex` function through division by zero (a math error where a program tries to divide by 0). The bug occurs because the code doesn't check if the `dims` tensor (a multi-dimensional array) is empty before performing calculations.

Solution: The issue was patched in GitHub commit a776040a5e7ebf76eeb7eb923bf1ae417dd4d233. The fix is included in TensorFlow 2.6.0 and will be backported (adapted for earlier versions) to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37665: TensorFlow is an end-to-end open source platform for machine learning. In affected versions due to incomplete validation

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its MKL implementation where incomplete validation of input tensor dimensions allows attackers to trigger undefined behavior (accessing invalid memory locations or reading data outside allocated memory bounds). Two operations, requantization and MklRequantizePerChannelOp, are affected by this flaw.

Solution: The issue was patched in GitHub commits 9e62869465573cb2d9b5053f1fa02a81fce21d69 and 203214568f5bc237603dbab6e1fd389f1572f5c9. The fix is included in TensorFlow 2.6.0 and was backported to versions 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37663: TensorFlow is an end-to-end open source platform for machine learning. In affected versions due to incomplete validation

Summary: TensorFlow, a machine learning platform, has a vulnerability in its `tf.raw_ops.QuantizeV2` function where incomplete validation (checking that inputs meet requirements) allows attackers to cause crashes or read data from invalid memory locations. The vulnerability occurs because the code doesn't properly verify that input parameters have matching sizes and are within valid ranges.

Solution: The issue has been patched in GitHub commit 6da6620efad397c85493b8f8667b821403516708. The fix will be included in TensorFlow 2.6.0 and has also been backported (adapted for older versions) to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37689: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can craft a TFLi

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where an attacker can create a malicious model file that crashes the system by triggering a null pointer dereference (accessing memory at an invalid location without checking if it's safe). The problem occurs in the MLIR optimization (a compiler technique that improves code performance) of the L2NormalizeReduceAxis operator, which tries to access data in a vector without first verifying the vector contains any elements.

Solution: The issue has been patched in GitHub commit d6b57f461b39fd1aa8c1b870f1b974aac3554955. The fix is included in TensorFlow 2.6.0 and has been backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37688: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can craft a TFLi

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where an attacker can create a specially crafted TFLite model (a lightweight version of TensorFlow for mobile devices) that causes a null pointer dereference (attempting to access memory that doesn't exist), crashing the system and preventing it from working. The flaw occurs because the code tries to access a pointer without checking if it's valid first.

Solution: The issue was patched in GitHub commit 15691e456c7dc9bd6be203b09765b063bf4a380c. The fix will be included in TensorFlow 2.6.0 and will also be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37686: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the strided slice implementa

Summary: TensorFlow 2.6.0 has a bug in its strided slice implementation (a feature that extracts portions of arrays), which attackers can exploit to create models that cause infinite loops (the program gets stuck repeating the same instructions endlessly). The bug appears in TFLite (TensorFlow Lite, a lightweight version for mobile devices) when handling ellipsis (a shorthand notation using '...' in array indexing).

Solution: The issue has been patched in GitHub commit dfa22b348b70bb89d6d6ec0ff53973bacb4f4695. Update TensorFlow to a version after 2.6.0.


CVE-2021-37681: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of SVDF i

Summary: TensorFlow (an open source machine learning platform) has a vulnerability in its SVDF implementation (a neural network component) in TFLite (a lightweight version for mobile devices) where a null pointer error (attempting to use data that doesn't exist in memory) can occur. The bug happens because the `GetVariableInput` function can return a null pointer, but the code doesn't check for this before trying to use it as valid data.

Solution: The issue has been patched in GitHub commit 5b048e87e4e55990dae6b547add4dae59f4e1c76. The fix will be included in TensorFlow 2.6.0, and will also be backported (adapted for older versions) to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37680: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of fully

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its fully connected layers (neural network components that connect all inputs to all outputs) in TFLite (a lightweight version for mobile devices) that causes a division by zero error (attempting to divide by zero, which crashes the program). The issue has been patched and will be included in upcoming updates.

Solution: The fix will be included in TensorFlow 2.6.0. It will also be backported (applied to older versions still being supported) to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37676: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefi

Summary: TensorFlow (an open-source platform for machine learning) has a vulnerability where an attacker can trigger undefined behavior (unpredictable program crashes or malfunctions) by exploiting the `tf.raw_ops.SparseFillEmptyRows` function, which fails to check whether input arguments are empty tensors (multi-dimensional arrays). This flaw exists in the shape inference code, which is responsible for determining the size and structure of data.

Solution: The issue has been patched in GitHub commit 578e634b4f1c1c684d4b4294f9e5281b2133b3ed. The fix will be included in TensorFlow 2.6.0 and will also be back-ported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37675: TensorFlow is an end-to-end open source platform for machine learning. In affected versions most implementations of conv

Summary: TensorFlow, a machine learning platform, has a vulnerability where attackers can crash the software by exploiting division by zero errors in convolution operators (mathematical operations that process data in machine learning models). This happens because the code that checks input shapes is missing validation steps before performing divisions, allowing someone to trigger a denial of service (making the system unavailable).

Solution: The issue has been patched in GitHub commit 8a793b5d7f59e37ac7f3cd0954a750a2fe76bad4. The fix will be included in TensorFlow 2.6.0 and will be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37671: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefi

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its Map and OrderedMap operations where an attacker can cause undefined behavior (unpredictable or dangerous program actions) by exploiting a missing check for empty data indices. The code checks if indices are in order but doesn't verify they exist, leaving a gap that can lead to null pointer reference binding (attempting to use memory that hasn't been allocated).

Solution: The fix is included in TensorFlow 2.6.0 and was cherrypicked into TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4. Users of affected versions should update to one of these patched releases.


CVE-2021-37667: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefi

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where an attacker can cause undefined behavior (unpredictable program crashes or malfunctions) by exploiting a flaw in the `tf.raw_ops.UnicodeEncode` function. The problem occurs because the code reads data from a tensor without first checking if that tensor is empty, which can lead to a null pointer dereference (trying to access memory that doesn't exist).

Solution: The issue is patched in GitHub commit 2e0ee46f1a47675152d3d865797a18358881d7a6. The fix will be included in TensorFlow 2.6.0 and will also be backported (applied to earlier versions still receiving updates) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37666: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefi

Summary: TensorFlow, an open source machine learning platform, has a vulnerability (CVE-2021-37666) where attackers can cause undefined behavior (unpredictable program crashes or errors) by exploiting incomplete validation in the RaggedTensorToVariant function. The flaw occurs when the function receives empty input values that it doesn't properly check for.

Solution: The issue has been patched in GitHub commit be7a4de6adfbd303ce08be4332554dff70362612. The fix will be included in TensorFlow 2.6.0, and will also be back-ported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37652: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation for `tf.r

Summary: TensorFlow, a machine learning platform, has a use-after-free vulnerability (a bug where freed memory is accessed again) in the `tf.raw_ops.BoostedTreesCreateEnsemble` function that attackers can trigger with specially crafted input. The issue stems from refactoring that changed a resource from a naked pointer (basic memory reference) to a smart pointer (automatic memory management), causing the resource to be freed twice and its members to be accessed during cleanup after it's already been deallocated.

Solution: The issue was patched in GitHub commit 5ecec9c6fbdbc6be03295685190a45e7eee726ab. The fix is included in TensorFlow 2.6.0 and was also backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37648: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the code for `tf.raw_ops.Sav

Summary: TensorFlow, a machine learning platform, has a vulnerability in its `SaveV2` function where input validation fails to properly stop execution, allowing an attacker to trigger a null pointer dereference (a crash caused by accessing invalid memory). The validation check uses a method that only sets an error status but doesn't actually stop the function, so harmful operations continue anyway.

Solution: The issue was patched in GitHub commit 9728c60e136912a12d99ca56e106b7cce7af5986. The fix is included in TensorFlow 2.6.0 and will also be backported (applied to older versions) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37664: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can read from ou

Summary: TensorFlow (an open-source platform for machine learning) has a vulnerability where an attacker can read data from outside the intended memory area by sending specially crafted invalid arguments to a specific function called `BoostedTreesSparseCalculateBestFeatureSplit`. The problem occurs because the code doesn't properly check that input values are within valid ranges.

Solution: The issue was patched in GitHub commit e84c975313e8e8e38bb2ea118196369c45c51378. The fix is included in TensorFlow 2.6.0 and will be backported (applied retroactively) to TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37662: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can generate und

Summary: TensorFlow, an open-source platform for machine learning, has a vulnerability in two functions (BoostedTreesCalculateBestGainsPerFeature and BoostedTreesCalculateBestFeatureSplitV2) where attackers can cause undefined behavior (unpredictable program crashes or errors) by exploiting missing input validation that fails to check for null references (empty pointers). The issue allows attackers to trigger these crashes through specially crafted inputs.

Solution: The fix is included in TensorFlow 2.6.0 and will be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4. Users should update to one of these patched versions.


CVE-2021-37661: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause a deni

Summary: TensorFlow, a machine learning platform, has a vulnerability where attackers can crash the system by passing negative numbers to the `boosted_trees_create_quantile_stream_resource` function. The bug happens because the code doesn't check if the input is negative before using it to allocate memory (reserve, which expects an unsigned integer, or a whole number with no sign). When a negative number gets converted to an unsigned integer, it becomes a huge positive number that causes the program to crash.

Solution: The issue has been patched in GitHub commit 8a84f7a2b5a2b27ecf88d25bad9ac777cd2f7992. The fix will be included in TensorFlow 2.6.0 and will also be backported (added to older versions still being supported) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37659: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefi

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where an attacker can cause undefined behavior (unpredictable or unsafe program execution) by exploiting binary cwise operations (element-wise math operations between two arrays) that don't check if their inputs have the same size. This missing check allows the program to read from invalid memory locations and crash or behave unexpectedly.

Solution: The issue was patched in GitHub commit 93f428fd1768df147171ed674fee1fc5ab8309ec. The fix will be included in TensorFlow 2.6.0, and will also be backported (applied to earlier versions still receiving support) to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37658: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefi

Summary: TensorFlow, a machine learning platform, has a vulnerability in its MatrixSetDiagV operations where an attacker can cause undefined behavior (unpredictable program crashes or errors) by passing an empty tensor (a data structure with no elements) as input, since the code doesn't properly validate that the input tensor has at least one element before trying to access it.

Solution: The issue was patched in GitHub commit ff8894044dfae5568ecbf2ed514c1a37dc394f1b. The fix is included in TensorFlow 2.6.0 and will be backported (applied to older versions still receiving support) to TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37657: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefi

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability (CVE-2021-37657) where attackers can cause undefined behavior (unpredictable crashes or errors) by exploiting incomplete validation in matrix diagonal operations. The vulnerability occurs because the code doesn't check if the input tensor (a multi-dimensional array of data) is empty before trying to access its first element.

Solution: The issue was patched in GitHub commit f2a673bd34f0d64b8e40a551ac78989d16daad09. The fix is included in TensorFlow 2.6.0, and will also be available in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37656: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefi

Summary: TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause undefined behavior (unpredictable program crashes or errors) by exploiting incomplete validation in the `tf.raw_ops.RaggedTensorToSparse` function. The function fails to check that split values are in increasing order, allowing an attacker to bind a reference to a null pointer (a reference to an empty memory location).

Solution: The issue has been patched in GitHub commit 1071f554dbd09f7e101324d366eec5f4fe5a3ece. The fix will be included in TensorFlow 2.6.0, and will also be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37655: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can trigger a re

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability where an attacker can read data outside the bounds of allocated memory (a heap buffer overflow) by sending invalid arguments to a specific function called `tf.raw_ops.ResourceScatterUpdate`. The bug exists because the code doesn't properly validate the relationship between the shapes of two inputs called `indices` and `updates`, checking only that their element counts are divisible rather than verifying the correct dimensional relationship needed for broadcasting (automatically expanding smaller arrays to match larger ones).

Solution: The issue was patched in GitHub commit 01cff3f986259d661103412a20745928c727326f. The fix is included in TensorFlow 2.6.0 and will be cherrypicked to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37654: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can trigger a cr

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability in the `tf.raw_ops.ResourceGather` function that allows attackers to crash the software or read data from memory they shouldn't access by supplying an invalid `batch_dims` parameter (a dimension value that exceeds the tensor's rank, which is the number of dimensions in a data structure). The bug occurs because the code doesn't validate that the user's input is within acceptable bounds before using it.

Solution: The issue was patched in GitHub commit bc9c546ce7015c57c2f15c168b3d9201de679a1d. The fix is included in TensorFlow 2.6.0 and was also applied to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37651: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation for `tf.r

Summary: TensorFlow, a machine learning platform, has a vulnerability in the `tf.raw_ops.FractionalAvgPoolGrad` function where it can access memory outside the bounds of allocated buffers (a buffer overflow, where a program reads from memory it shouldn't access) when given an empty input. The function fails to check whether the input is empty before trying to read from it.

Solution: The issue was patched in GitHub commit 0f931751fb20f565c4e94aa6df58d54a003cdb30. The fix will be included in TensorFlow 2.6.0, and will also be applied to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37650: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation for `tf.r

Summary: TensorFlow, a machine learning platform, has a vulnerability in two functions that can cause a heap buffer overflow (writing data past the end of allocated memory) and crash the program when processing dataset records. The code incorrectly assumes all records are strings without checking, but users might pass numeric types instead, triggering the error.

Solution: The issue was patched in GitHub commit e0b6e58c328059829c3eb968136f17aa72b6c876. The fix is included in TensorFlow 2.6.0 and was also applied to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37646: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of `tf.ra

Summary: TensorFlow (an open-source machine learning platform) has a vulnerability in the `tf.raw_ops.StringNGrams` function where negative input values cause an integer overflow (a bug where a number wraps around to an unexpectedly large value). When a negative value is converted to an unsigned integer (a number that can only be positive) for memory allocation, it becomes a very large number, potentially causing the program to crash or behave unexpectedly.

Solution: The issue is patched in GitHub commit c283e542a3f422420cfdb332414543b62fc4e4a5. The fix will be included in TensorFlow 2.6.0 and will also be cherry-picked (applied to older supported versions) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37645: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of `tf.ra

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.QuantizeAndDequantizeV4Grad` function where a negative integer is incorrectly converted to an unsigned integer, causing an integer overflow (when a number becomes too large for its data type) and potentially allocating excessive memory. This bug could allow attackers to crash the system or cause other harmful effects.

Solution: The issue was patched in GitHub commit 96f364a1ca3009f98980021c4b32be5fdcca33a1. Users should update to TensorFlow 2.6.0, or apply the cherrypicked fix available in TensorFlow 2.5.1 and TensorFlow 2.4.3.


CVE-2021-37644: TensorFlow is an end-to-end open source platform for machine learning. In affected versions providing a negative element

Summary: TensorFlow (an open source machine learning platform) has a vulnerability where passing a negative number to the `num_elements` argument of `tf.raw_ops.TensorListReserve` causes the program to crash. The problem occurs because the code uses `std::vector.resize()` (a function that changes the size of a data container) with user input without checking if that input is valid first.

Solution: The issue was patched in GitHub commit 8a6e874437670045e6c7dc6154c7412b4a2135e2. The fix will be included in TensorFlow 2.6.0 and will be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37641: TensorFlow is an end-to-end open source platform for machine learning. In affected versions if the arguments to `tf.raw_

Summary: TensorFlow, a machine learning platform, has a vulnerability in the `tf.raw_ops.RaggedGather` function where invalid input arguments can cause the program to read memory outside the bounds of allocated buffers (a heap buffer overflow). The bug occurs because the code reads tensor dimensions without first checking that the tensor has at least one dimension, and doesn't verify that required tensor lists aren't empty.

Solution: The issue was patched in GitHub commit a2b743f6017d7b97af1fe49087ae15f0ac634373. The fix is included in TensorFlow 2.6.0 and was also backported (applied to older versions) to TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37635: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of sparse

Summary: TensorFlow, a popular machine learning platform, has a bug in its sparse reduction operations (functions that combine data in a specific way) that can cause the software to access memory outside its allocated boundaries. The problem occurs because the code doesn't properly check that reduction groups stay within valid limits or that index values point to valid parts of the input data.

Solution: The issue was patched in GitHub commit 87158f43f05f2720a374f3e6d22a7aaa3a33f750. The fix is included in TensorFlow 2.6.0 and will be cherry-picked (backported to older versions) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37649: TensorFlow is an end-to-end open source platform for machine learning. The code for `tf.raw_ops.UncompressElement` can b

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `tf.raw_ops.UncompressElement` function where it tries to use a pointer (a reference to a location in memory) without checking if that pointer is valid, causing a null pointer dereference (crash when accessing an empty memory location). An attacker could exploit this by providing specially crafted data to crash the program.

Solution: The issue has been patched in GitHub commit 7bdf50bb4f5c54a4997c379092888546c97c3ebd. The fix is included in TensorFlow 2.6.0 and has been backported (applied to earlier versions) to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37647: TensorFlow is an end-to-end open source platform for machine learning. When a user does not supply arguments that determ

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability where the `tf.raw_ops.SparseTensorSliceDataset` function can crash by trying to access memory that doesn't exist (null pointer dereference) when a user provides incomplete arguments for a sparse tensor (a data structure optimized for data with many zero values). The bug occurs because the code doesn't properly validate the case when one part of the sparse tensor is empty but the other part is provided.

Solution: The issue has been patched in GitHub commit 02cc160e29d20631de3859c6653184e3f876b9d7. The fix will be included in TensorFlow 2.6.0, and will also be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37643: TensorFlow is an end-to-end open source platform for machine learning. If a user does not provide a valid padding value

Summary: TensorFlow has a vulnerability where the MatrixDiagPartOp function doesn't check if input data exists before reading from it, causing either a null pointer dereference (a crash from accessing memory that doesn't exist) or incorrect behavior that ignores most of the data. This happens when users don't provide valid padding values to this operation.

Solution: The issue was patched in GitHub commit 482da92095c4d48f8784b1f00dda4f81c28d2988. The fix is included in TensorFlow 2.6.0 and was also backported to TensorFlow 2.5.1, 2.4.3, and 2.3.4.


CVE-2021-37639: TensorFlow is an end-to-end open source platform for machine learning. When restoring tensors via raw APIs, if the tenso

Summary: TensorFlow, a machine learning platform, has a vulnerability where attackers can crash the program or read memory they shouldn't access by providing incomplete or missing tensor names when restoring data. The bug happens because the code doesn't check if there are enough items in a list before trying to access them, leading to either a null pointer dereference (a crash from accessing invalid memory) or an out-of-bounds read (accessing memory outside the intended storage area).

Solution: The issue was patched in GitHub commit 9e82dce6e6bd1f36a57e08fa85af213e2b2f2622. The fix is included in TensorFlow 2.6.0 and was also backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37638: TensorFlow is an end-to-end open source platform for machine learning. Sending invalid argument for `row_partition_types

Summary: A vulnerability in TensorFlow (a machine learning platform) allows attackers to crash the program by sending an invalid empty list to the `tf.raw_ops.RaggedTensorToTensor` function, which tries to access the first element without checking if the list is empty first, causing undefined behavior (unpredictable program actions). This is a null pointer dereference (attempting to use a memory location that contains no valid data).

Solution: The fix was patched in GitHub commit 301ae88b331d37a2a16159b65b255f4f9eb39314 and will be included in TensorFlow 2.6.0. The patch was also applied to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37637: TensorFlow is an end-to-end open source platform for machine learning. It is possible to trigger a null pointer derefere

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability where passing invalid input to a specific function (tf.raw_ops.CompressElement) can cause a null pointer dereference (an error that occurs when code tries to access memory that hasn't been properly initialized). The bug happened because the code checked the size of a data buffer without first verifying that the buffer itself was valid.

Solution: The issue was patched in GitHub commit 5dc7f6981fdaf74c8c5be41f393df705841fb7c5. The fix will be included in TensorFlow 2.6.0, and will also be backported (applied to older versions) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37660: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause a floa

Summary: TensorFlow (an open source machine learning platform) has a vulnerability where an attacker can crash the system by causing a floating point exception (a math error that stops the program) through specially crafted inputs to inplace operations (functions that modify data in place). The bug exists because the code uses the wrong logical operator, checking if either condition is true instead of checking if both are true.

Solution: The issue has been patched in GitHub commit e86605c0a336c088b638da02135ea6f9f6753618. The fix will be included in TensorFlow 2.6.0 and will also be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37653: TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can trigger a cr

Summary: TensorFlow, a machine learning platform, has a vulnerability where an attacker can crash the system through a floating point exception (a math error that occurs when dividing by zero) in the `tf.raw_ops.ResourceGather` function. The problem happens because the code divides by a value without first checking if that value is zero.

Solution: The issue was patched in GitHub commit ac117ee8a8ea57b73d34665cdf00ef3303bc0b11. The fix will be included in TensorFlow 2.6.0, and will also be backported to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37642: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of `tf.ra

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in the `tf.raw_ops.ResourceScatterDiv` function that causes a division by 0 error (attempting to divide by zero, which crashes programs). The problem exists because the code treats all division operations the same way without special handling for the case when the divisor is zero.

Solution: The issue was patched in GitHub commit 4aacb30888638da75023e6601149415b39763d76. The fix will be included in TensorFlow 2.6.0, and will also be backported (applied to older versions) in TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-37640: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of `tf.ra

Summary: TensorFlow, an open-source machine learning platform, has a bug in the `tf.raw_ops.SparseReshape` function where it can crash with a division by zero error (dividing a number by zero). This happens because the code doesn't check if the target shape has any elements before dividing by it, allowing attackers to trigger this crash by providing specially crafted input.

Solution: The issue was patched in GitHub commit 4923de56ec94fff7770df259ab7f2288a74feb41. The fix is included in TensorFlow 2.6.0 and will also be applied to TensorFlow 2.5.1.


CVE-2021-37636: TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of `tf.ra

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability in its `tf.raw_ops.SparseDenseCwiseDiv` function where division by zero is not properly handled, causing the program to crash or behave unexpectedly. The vulnerability affects multiple older versions of TensorFlow that are still being supported.

Solution: The issue has been patched in GitHub commit d9204be9f49520cdaaeb2541d1dc5187b23f31d9. The fix is included in TensorFlow 2.6.0, and the patch was also applied to TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4.


CVE-2021-35958: TensorFlow through 2.5.0 allows attackers to overwrite arbitrary files via a crafted archive when tf.keras.utils.get_fil

Summary: TensorFlow versions up to 2.5.0 have a vulnerability where attackers can overwrite arbitrary files by providing a specially crafted archive when the tf.keras.utils.get_file function is used with the extract=True setting. This happens because the function doesn't properly validate file paths during extraction (a weakness called path traversal, where attackers manipulate file paths to access files outside intended directories). The vendor notes that this function was not designed to handle untrusted archives.

Solution: N/A -- no mitigation discussed in source.


CVE-2021-29619: TensorFlow is an end-to-end open source platform for machine learning. Passing invalid arguments (e.g., discovered via f

Summary: TensorFlow (an open-source platform for machine learning) has a bug where passing invalid arguments to a specific function called `tf.raw_ops.SparseCountSparseOutput` causes a segfault (a crash where the program tries to access memory it shouldn't). This happens because the function doesn't properly handle exceptional conditions (unexpected or invalid inputs).

Solution: The fix will be included in TensorFlow 2.5.0. Patches will also be applied to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, as these versions are also affected and still supported.


CVE-2021-29618: TensorFlow is an end-to-end open source platform for machine learning. Passing a complex argument to `tf.transpose` at t

Summary: TensorFlow (an open source machine learning platform) crashes when you pass a complex argument to the `tf.transpose` function while also using the `conjugate=True` argument. This happens because the software doesn't properly handle this unusual combination of inputs.

Solution: Update to TensorFlow 2.5.0 or later. If you're using an older supported version, updates are also available for TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4.


CVE-2021-29617: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a denial of service via `CH

Summary: TensorFlow is a machine learning platform that had a vulnerability where an attacker could crash the system by sending invalid arguments to the `tf.strings.substr` function, which performs string operations. This vulnerability was caused by improper error handling (not properly catching and managing exceptional conditions that shouldn't happen).

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in earlier versions: TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29616: TensorFlow is an end-to-end open source platform for machine learning. The implementation of TrySimplify(https://github.

Summary: TensorFlow, a machine learning platform, has a vulnerability where TrySimplify (a code optimization component) can crash by dereferencing a null pointer (trying to access memory that doesn't exist) when optimizing nodes with no inputs. This undefined behavior can cause the program to fail unexpectedly.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (applied to older versions) to TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4, which are still supported.


CVE-2021-29615: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `ParseAttrValue`(https://gi

Summary: A vulnerability in TensorFlow (an open source machine learning platform) allows attackers to cause a stack overflow (a crash caused by a program using too much memory on the call stack) by sending specially crafted input to the `ParseAttrValue` function through recursion (when a function calls itself repeatedly).

Solution: The fix will be included in TensorFlow 2.5.0. It will also be applied to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29614: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.io.decode_raw` produces

Summary: A bug in TensorFlow's `tf.io.decode_raw` function causes incorrect results and crashes when using certain combinations of parameters. The problem stems from incorrect pointer arithmetic (moving through memory incorrectly), which causes the function to skip parts of input data and write outside the allocated memory bounds (OOB write, where data is written to memory locations it shouldn't access), potentially leading to crashes or more serious attacks.

Solution: The fix will be included in TensorFlow 2.5.0 and will be backported (adapted for older versions) to TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4.


CVE-2021-29613: TensorFlow is an end-to-end open source platform for machine learning. Incomplete validation in `tf.raw_ops.CTCLoss` all

Summary: TensorFlow (an open-source machine learning platform) has a vulnerability in its `tf.raw_ops.CTCLoss` function where incomplete validation (insufficient checking of input data) allows an attacker to trigger an OOB read from heap (accessing memory outside the intended boundaries). This is a memory safety issue that could crash the program or expose sensitive data.

Solution: The fix is included in TensorFlow 2.5.0. Users of earlier versions should update to: TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, or TensorFlow 2.1.4, as these versions contain cherrypicked patches (code changes applied to older versions) that address the vulnerability.


CVE-2021-29612: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a heap buffer overflow in

Summary: TensorFlow has a vulnerability (CVE-2021-29612) where a specific operation called `tf.raw_ops.BandedTriangularSolve` can be tricked into accessing memory it shouldn't (a heap buffer overflow, where an attacker reads or writes beyond the intended memory boundaries). The bug happens because the code doesn't properly check if input data is empty, and it doesn't verify that earlier validation checks actually succeeded before continuing to process the data.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (applied to earlier versions) in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29611: TensorFlow is an end-to-end open source platform for machine learning. Incomplete validation in `SparseReshape` results

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `SparseReshape` function where it doesn't properly check that input arguments are valid before using them. This incomplete validation allows an attacker to cause a denial of service (a crash that makes the system unavailable) by triggering a CHECK-failure, which is a built-in safety check that stops execution when something goes wrong.

Solution: The fix will be included in TensorFlow 2.5.0. The developers will also backport (apply the fix to older versions) this commit to TensorFlow 2.4.2 and TensorFlow 2.3.3, which are the only affected versions.


CVE-2021-29610: TensorFlow is an end-to-end open source platform for machine learning. The validation in `tf.raw_ops.QuantizeAndDequanti

Summary: TensorFlow has a vulnerability in the `QuantizeAndDequantizeV2` function where incorrect validation of the `axis` parameter allows invalid values to pass through, potentially causing heap underflow (a memory safety error where data is accessed below allocated memory boundaries). This flaw could let attackers read or write to other data stored in the heap (the area of memory used for dynamic storage).

Solution: The fix will be included in TensorFlow 2.5.0 and will be backported (cherry-picked) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29609: TensorFlow is an end-to-end open source platform for machine learning. Incomplete validation in `SparseAdd` results in a

Summary: TensorFlow's `SparseAdd` function (a tool for adding sparse tensors, which are data structures with mostly empty values) has incomplete validation that allows attackers to cause undefined behavior like accessing null memory or writing data outside allocated memory bounds. The vulnerability exists because the code doesn't properly check if tensors are empty or if their dimensions match, letting attackers send invalid sparse tensors that exploit unprotected assumptions.

Solution: The fix will be included in TensorFlow 2.5.0 and will be cherry-picked (backported) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29608: TensorFlow is an end-to-end open source platform for machine learning. Due to lack of validation in `tf.raw_ops.RaggedTe

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in a function called `tf.raw_ops.RaggedTensorToTensor` that fails to properly validate (check) all input arguments. An attacker can cause undefined behavior (unpredictable crashes or memory access errors) by providing empty inputs, because the code only checks that one input isn't empty while skipping checks on the others.

Solution: The fix will be included in TensorFlow 2.5.0. TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4 will also receive the fix through cherrypicked commits, as these versions are affected and still supported.


CVE-2021-29607: TensorFlow is an end-to-end open source platform for machine learning. Incomplete validation in `SparseAdd` results in a

Summary: TensorFlow, an open-source machine learning platform, has a bug in its `SparseAdd` function where it doesn't fully check the validity of sparse tensors (data structures that efficiently store mostly empty matrices). This allows attackers to send malformed tensors that can cause the program to crash or write data to unintended memory locations.

Solution: The fix will be included in TensorFlow 2.5.0. Patches will also be available in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29606: TensorFlow is an end-to-end open source platform for machine learning. A specially crafted TFLite model could trigger an

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in TFLite (TensorFlow Lite, a lightweight version for mobile devices) where a maliciously designed model can trigger an OOB read (out-of-bounds read, accessing memory outside the intended data area) on the heap when the `Split_V` operation receives an invalid axis value that falls outside the expected range.

Solution: The fix will be included in TensorFlow 2.5.0. Additionally, the fix will be backported (applied to earlier versions still receiving support) to TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4.


CVE-2021-29605: TensorFlow is an end-to-end open source platform for machine learning. The TFLite code for allocating `TFLiteIntArray`s

Summary: TensorFlow, a machine learning platform, has a vulnerability in its TFLite component (a lightweight version for mobile devices) where an attacker can create a malicious model that causes an integer overflow (when a calculation produces a number too large to fit in its storage type, wrapping around to become negative). This overflow leads to invalid memory allocation, potentially causing the program to crash or behave unpredictably.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (adapted for older versions) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29604: TensorFlow is an end-to-end open source platform for machine learning. The TFLite implementation of hashtable lookup is

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its TFLite (TensorFlow Lite, a lightweight version for mobile devices) hashtable lookup implementation that can cause a division by zero error (a crash caused by dividing by zero). An attacker could create a malicious model that triggers this crash by setting a dimension to 0.

Solution: The fix will be included in TensorFlow 2.5.0. The fix will also be backported to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29603: TensorFlow is an end-to-end open source platform for machine learning. A specially crafted TFLite model could trigger an

Summary: TensorFlow, a machine learning platform, has a vulnerability where a specially crafted TFLite model (a lightweight version of TensorFlow for mobile devices) can cause an OOB write on heap (writing data beyond allocated memory boundaries) in the ArgMin/ArgMax operations. The bug occurs when the axis_value parameter falls outside valid bounds, causing the code to write past the end of the output array.

Solution: The fix will be included in TensorFlow 2.5.0. The developers will also apply this fix as a cherry-pick (a targeted patch) to TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4, which are still in the supported version range.


CVE-2021-29602: TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `DepthwiseConv` TFLite

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in its `DepthwiseConv` operator (a component that performs a specific type of mathematical operation on data) where an attacker could craft a malicious model that causes a division by zero error (trying to divide a number by zero, which crashes the program). This allows an attacker to potentially crash or disrupt systems using this component.


CVE-2021-29601: TensorFlow is an end-to-end open source platform for machine learning. The TFLite implementation of concatenation is vul

Summary: TensorFlow's TFLite (a lightweight version for mobile and embedded devices) has a bug where it can experience an integer overflow (when a number gets too large to fit in its assigned storage space) in the concatenation operation (combining multiple data arrays into one). An attacker could create a malicious machine learning model that exploits this by making dimension values too large, and this problem can occur when converting regular TensorFlow models to the TFLite format.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (applied to older versions still being supported) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29600: TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `OneHot` TFLite operato

Summary: TensorFlow's `OneHot` operator (a component that converts index values into one-hot encoded vectors) in TFLite, the lightweight version for mobile devices, has a division by zero vulnerability. An attacker could create a malicious model that causes the operator to divide by zero, potentially crashing the system or causing unexpected behavior.

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, which are still in the supported range.


CVE-2021-29599: TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `Split` TFLite operator

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability in its `Split` operator for TFLite (TensorFlow Lite, a lightweight version for mobile devices) that causes a division by zero error (a crash that happens when code tries to divide a number by zero). An attacker can create a malicious model that sets `num_splits` to 0, triggering this crash.

Solution: The fix will be included in TensorFlow 2.5.0. The patch will also be applied to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29598: TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `SVDF` TFLite operator

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in its SVDF TFLite operator (a component that performs specific neural network calculations on mobile devices) where an attacker can craft a malicious model that causes a division by zero error (attempting to divide a number by zero, which crashes the program). This happens when a parameter called `params->rank` is set to 0.

Solution: The fix will be included in TensorFlow 2.5.0. The fix will also be backported (applied to earlier versions) in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29597: TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `SpaceToBatchNd` TFLite

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in its `SpaceToBatchNd` operator (a function that rearranges data in neural network models) that can be triggered by a division by zero error (when code tries to divide a number by zero, crashing the system). An attacker can create a malicious model that causes this crash by setting one dimension of the block input to 0.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (applied to earlier versions) to TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4.


CVE-2021-29596: TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `EmbeddingLookup` TFLit

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `EmbeddingLookup` operator that can cause a division by zero error (a crash caused by trying to divide by zero). An attacker could craft a malicious model with a specific input dimension set to 0 to trigger this crash.

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29595: TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `DepthToSpace` TFLite o

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `DepthToSpace` TFLite operator (a component that processes neural network data in a specific format called TensorFlow Lite). An attacker can create a malicious model that causes a division by zero error (when code tries to divide a number by zero, crashing the system), potentially allowing them to disrupt or crash applications using this operator.


CVE-2021-29594: TensorFlow is an end-to-end open source platform for machine learning. TFLite's convolution code(https://github.com/tens

Summary: TensorFlow's TFLite (a lightweight version of the machine learning platform) has a bug in its convolution code (math operations that process image data) where user-controlled values can be used as divisors without checking if they're zero, which could cause crashes or unexpected behavior. This happens because division by zero is not prevented in the code.

Solution: The fix will be included in TensorFlow 2.5.0. The fix will also be backported (applied to older versions still being supported) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29593: TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `BatchToSpaceNd` TFLite

Summary: TensorFlow, a platform for building machine learning models, has a vulnerability in its `BatchToSpaceNd` operator (a function that reshapes data), which can crash when an attacker provides specially crafted input that causes a division by zero error (attempting to divide by zero, which is mathematically impossible). An attacker could exploit this to cause the software to malfunction.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (applied to earlier versions still being supported) in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29592: TensorFlow is an end-to-end open source platform for machine learning. The fix for CVE-2020-15209(https://cve.mitre.org/

Summary: A previous security fix for TensorFlow (a machine learning platform) didn't work properly when the Reshape operator (which changes a tensor's shape, or dimensions) received its target shape from a 1-D tensor (a single row of data). This incomplete fix accidentally allowed a problematic null-buffer-backed tensor (a data structure with no actual memory backing) to be used, creating a security weakness.

Solution: The fix will be included in TensorFlow 2.5.0 and will be backported (adapted for earlier versions) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29591: TensorFlow is an end-to-end open source platform for machine learning. TFlite graphs must not have loops between nodes.

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where TFlite graphs (computational structures that define ML models) were not properly checked to prevent loops between nodes. An attacker could create malicious models that cause infinite loops or stack overflow (running out of memory from too many nested function calls) during model evaluation, potentially crashing the system.

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, as these versions are also affected and still supported.


CVE-2021-29590: TensorFlow is an end-to-end open source platform for machine learning. The implementations of the `Minimum` and `Maximum

Summary: TensorFlow (an open source machine learning platform) has a vulnerability in its `Minimum` and `Maximum` operators that can allow reading data outside the bounds of allocated memory if one of the input tensors is empty, because the broadcasting implementation (the process of making tensors compatible for operations) doesn't check whether array indexes are valid. This is a memory access bug that could expose sensitive data.

Solution: The fix will be included in TensorFlow 2.5.0 and will be backported to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29589: TensorFlow is an end-to-end open source platform for machine learning. The reference implementation of the `GatherNd` TF

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its GatherNd operator (a function that gathers data from a tensor, or multi-dimensional array) where an attacker can cause a division by zero error (a crash caused by dividing by zero) by crafting a malicious model with an empty input. This could allow an attacker to crash or disrupt applications using this operator.

Solution: The fix will be included in TensorFlow 2.5.0. TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4 will also receive this fix through a cherrypick (applying the same fix to older supported versions).


CVE-2021-29588: TensorFlow is an end-to-end open source platform for machine learning. The optimized implementation of the `TransposeCon

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `TransposeConv` operator (a neural network layer that reshapes data) where a division by zero error can occur if an attacker creates a malicious model with stride values set to 0. This bug could cause the software to crash or behave unexpectedly when processing such a model.

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in earlier supported versions: TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4 through a cherrypick commit (applying the fix to multiple versions).


CVE-2021-29587: TensorFlow is an end-to-end open source platform for machine learning. The `Prepare` step of the `SpaceToDepth` TFLite o

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in its `SpaceToDepth` operator (a tool that rearranges data in neural networks) where the code doesn't check if a value called `block_size` is zero before dividing by it, which could cause a crash. An attacker could create a malicious model that sets `block_size` to zero to trigger this division-by-zero error.

Solution: The fix will be included in TensorFlow 2.5.0. TensorFlow will also backport (apply the same fix to older supported versions) this commit to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29586: TensorFlow is an end-to-end open source platform for machine learning. Optimized pooling implementations in TFLite fail

Summary: TensorFlow's pooling code (the part that downsamples data in neural networks) has a bug where it doesn't check if stride values, which control how much data to skip, are zero before doing math with them. An attacker can create a special machine learning model that forces stride to be zero, causing a division by zero error (dividing by zero, which crashes programs) that could crash or be exploited.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be added to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, as these versions are affected and still supported.


CVE-2021-29585: TensorFlow is an end-to-end open source platform for machine learning. The TFLite computation for size of output after p

Summary: TensorFlow, a popular machine learning platform, has a bug in TFLite (TensorFlow Lite, a lightweight version for mobile and embedded devices) where a function called `ComputeOutSize` divides by a `stride` parameter without checking if it's zero first. An attacker could create a specially crafted model that triggers this division-by-zero error, potentially crashing the application.

Solution: The fix will be included in TensorFlow 2.5.0. The fix will also be cherry-picked (applied to older versions) into TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4.


CVE-2021-29584: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a denial of service via a

Summary: TensorFlow (a machine learning platform) has a vulnerability where an attacker can crash the system by triggering an integer overflow (when a number becomes too large for the system to handle) in the code that creates tensor shapes (multi-dimensional arrays). The problem occurs because the code doesn't check if dimension calculations will overflow before creating a new tensor shape.

Solution: The fix will be included in TensorFlow 2.5.0. Additionally, the fix will be backported (applied to older versions) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, as these versions are also affected and still supported.


CVE-2021-29583: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.FusedBatchNorm`

Summary: TensorFlow's `tf.raw_ops.FusedBatchNorm` function has a vulnerability where it doesn't properly check that certain input values (scale, offset, mean, and variance) match the size of the data being processed, which can cause a heap buffer overflow (reading data beyond allocated memory boundaries) or crash the program by accessing null pointers if empty tensors are provided.

Solution: The fix will be included in TensorFlow 2.5.0 and will also be backported to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29582: TensorFlow is an end-to-end open source platform for machine learning. Due to lack of validation in `tf.raw_ops.Dequanti

Summary: TensorFlow, a popular machine learning platform, has a vulnerability in its `Dequantize` operation where the code doesn't check that two input values (called `min_range` and `max_range` tensors, which are multi-dimensional arrays of data) have matching dimensions before using them together, allowing an attacker to read memory from outside the intended area. This is a type of memory safety bug that could let attackers access sensitive data or crash the system.

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in earlier versions: TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29581: TensorFlow is an end-to-end open source platform for machine learning. Due to lack of validation in `tf.raw_ops.CTCBeamS

Summary: TensorFlow, a machine learning platform, has a vulnerability in one of its functions (`tf.raw_ops.CTCBeamSearchDecoder`) that fails to check if input data is empty before processing it. When an attacker provides empty input, the software crashes (segmentation fault, which is when a program tries to read from memory it shouldn't access), causing a denial of service (making the system unavailable).

Solution: The fix will be included in TensorFlow 2.5.0. The developers will also apply this fix to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, which are still supported versions.


CVE-2021-29580: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.FractionalMaxPo

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in the `tf.raw_ops.FractionalMaxPoolGrad` function that can crash the program when given empty input tensors (arrays of data with no elements). The bug occurs because the code doesn't properly check that input and output tensors are valid before processing them, which can be exploited to cause a denial of service attack (making the system unavailable).

Solution: The fix will be included in TensorFlow 2.5.0. The patch will also be applied to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, as these versions are still supported.


CVE-2021-29579: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPoolGrad` is

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `tf.raw_ops.MaxPoolGrad` function called a heap buffer overflow (a bug where a program writes data beyond the memory it's allowed to use). The vulnerability occurs because the code doesn't properly check that array indices are valid before accessing data, which could allow attackers to read or corrupt memory.

Solution: The fix will be included in TensorFlow 2.5.0. Additionally, the fix will be backported to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29578: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.FractionalAvgPo

Summary: TensorFlow (an open-source machine learning platform) has a vulnerability in a function called `tf.raw_ops.FractionalAvgPoolGrad` that can cause a heap buffer overflow (a memory error where a program writes data beyond allocated space). The bug happens because the code doesn't properly check that input arguments have the correct size before processing them.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (adapted and applied to older versions still receiving support) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29577: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.AvgPool3DGrad`

Summary: A vulnerability called CVE-2021-29577 exists in TensorFlow (an open source platform for machine learning) in a function called `tf.raw_ops.AvgPool3DGrad`. The function has a heap buffer overflow (a memory safety bug where code writes data beyond the limits of allocated memory), which happens because the code assumes two data structures called `orig_input_shape` and `grad` tensors (multi-dimensional arrays of data) have matching dimensions but doesn't actually verify this before proceeding.

Solution: The fix will be included in TensorFlow 2.5.0. TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4 will also receive this fix through a cherrypick commit, as these versions are still supported.


CVE-2021-29576: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPool3DGradGr

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability in a specific function called `tf.raw_ops.MaxPool3DGradGrad` that can cause a heap buffer overflow (a type of memory corruption where data overflows into adjacent memory). The problem occurs because the code doesn't properly check whether initialization completes successfully, leaving data in an invalid state.

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability is also being patched in earlier versions: TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29575: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.ReverseSequence

Summary: A bug in TensorFlow (an open-source machine learning platform) in the `tf.raw_ops.ReverseSequence` function fails to check if input arguments are valid, allowing attackers to cause a denial of service (making the system crash or stop responding) through stack overflow (when a program uses too much memory on the call stack) or CHECK-failure (when an internal safety check fails). The vulnerability affects multiple recent versions of TensorFlow.

Solution: The fix will be included in TensorFlow 2.5.0. Additionally, the fix will be backported (applied to older versions) in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29574: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPool3DGradGr

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.MaxPool3DGradGrad` function where it doesn't check if input tensors (data structures that hold multi-dimensional arrays) are empty before accessing their contents. An attacker can provide empty tensors to cause a null pointer dereference (trying to access memory that doesn't exist), crashing the program or potentially executing malicious code.


CVE-2021-29573: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPoolGradWith

Summary: TensorFlow, an open-source platform for machine learning, has a vulnerability in the `tf.raw_ops.MaxPoolGradWithArgmax` function where it divides by a batch dimension (a count of data samples) without first checking that the number is not zero. This can cause a division by zero error, which crashes the program or causes unexpected behavior.


CVE-2021-29572: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.SdcaOptimizer`

Summary: TensorFlow, a machine learning platform, has a bug in the `tf.raw_ops.SdcaOptimizer` function where it crashes when given invalid input because it tries to access memory that doesn't exist (null pointer dereference, which is undefined behavior in programming). The code doesn't check that user inputs meet the function's requirements before processing them.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (applied retroactively) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, which are still in the supported range.


CVE-2021-29571: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPoolGradWith

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.MaxPoolGradWithArgmax` function where attackers can provide specially crafted input data to read and write outside the bounds of heap-allocated memory (memory areas assigned during program execution), potentially causing memory corruption. The issue occurs because the code assumes the last element of the `boxes` input is 4 without checking it first, so attackers can pass smaller values to access memory they shouldn't.

Solution: The fix will be included in TensorFlow 2.5.0 and will also be backported (copied to earlier versions still being supported) in TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4.


CVE-2021-29570: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPoolGradWith

Summary: A vulnerability in TensorFlow (an open source machine learning platform) called CVE-2021-29570 affects the `tf.raw_ops.MaxPoolGradWithArgmax` function, which can read outside the bounds of allocated memory (a heap overflow) if an attacker provides specially designed inputs. The bug occurs because the code uses the same value to look up data in two different arrays without checking that both arrays are the same size.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be applied to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4, which are still in the supported range.


CVE-2021-29569: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPoolGradWith

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.MaxPoolGradWithArgmax` function where specially crafted inputs can cause the program to read memory outside the bounds of allocated heap memory (a memory safety violation). The bug occurs because the code assumes input tensors contain at least one element, but if they're empty, accessing even the first element reads invalid memory.

Solution: The fix will be included in TensorFlow 2.5.0. The fix will also be backported (applied to older versions) in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29568: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger undefined behavior by bin

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `ParameterizedTruncatedNormal` function where attackers can cause undefined behavior (unpredictable program crashes or corruption) by passing an empty array as input, because the code doesn't check if the input is valid before trying to access its first element. This flaw affects multiple versions of the software.

Solution: Update to TensorFlow 2.5.0 or later. If you use an earlier version, update to one of these patched releases: TensorFlow 2.4.2, 2.3.3, 2.2.3, or 2.1.4.


CVE-2021-29567: TensorFlow is an end-to-end open source platform for machine learning. Due to lack of validation in `tf.raw_ops.SparseDe

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.SparseDenseCwiseMul` function that lacks proper validation of input dimensions. An attacker can exploit this to cause denial of service (program crashes through failed checks) or write to memory locations outside the bounds of allocated buffers (heap overflow, unintended memory access).

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29566: TensorFlow is an end-to-end open source platform for machine learning. An attacker can write outside the bounds of heap

Summary: TensorFlow, a machine learning platform, has a vulnerability where attackers can write data outside the allocated memory bounds (a heap buffer overflow) by sending invalid arguments to a specific function called `tf.raw_ops.Dilation2DBackpropInput`. The bug exists because the code doesn't properly check input values before writing to memory arrays.

Solution: The fix will be included in TensorFlow 2.5.0. The fix will also be applied to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29565: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a null pointer dereferenc

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability (CVE-2021-29565) where a null pointer dereference (a crash caused by the program trying to use memory it shouldn't access) can occur in the `tf.raw_ops.SparseFillEmptyRows` function if an attacker provides an empty `dense_shape` tensor due to missing validation checks. This flaw affects multiple versions of TensorFlow and could allow an attacker to crash the program.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (ported to earlier versions) to TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29564: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a null pointer dereferenc

Summary: TensorFlow, a machine learning platform, has a vulnerability in its EditDistance function where attackers can cause a null pointer dereference (a crash caused by accessing memory that doesn't exist) by sending specially crafted input parameters that don't get validated properly. The vulnerability allows attackers to potentially crash or disrupt TensorFlow applications.

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in earlier supported versions: TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.


CVE-2021-29563: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a denial of service by expl

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability where an attacker can crash the program by sending empty data to the RFFT function (a mathematical operation for transforming signals). The crash happens because the underlying code (Eigen, a math library) fails an assertion (a safety check) when it tries to process an empty matrix (a grid of numbers with no values).

Solution: The fix will be included in TensorFlow 2.5.0. The vulnerability will also be patched in earlier versions: TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4.