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.


CVE-2021-29562: 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 machine learning platform) has a vulnerability where an attacker can cause a denial of service (making a service unavailable) by triggering a CHECK-failure in the `tf.raw_ops.IRFFT` function, which is part of TensorFlow's low-level operations. This happens because of a reachable assertion (a check in the code that can be deliberately violated).

Solution: Update TensorFlow to version 2.5.0 or later. If you are using an older supported version, apply the patch available in TensorFlow 2.4.2, 2.3.3, 2.2.3, or 2.1.4, as these versions also received the fix through a cherrypick commit (the specific fix is available at https://github.com/tensorflow/tensorflow/commit/1c56f53be0b722ca657cbc7df461ed676c8642a2).


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

Summary: CVE-2021-29561 is a vulnerability in TensorFlow (an open source machine learning platform) where an attacker can crash a program by sending an invalid tensor (a multi-dimensional array of numbers) to the `LoadAndRemapMatrix` function instead of the expected scalar value (a single number). This causes a validation check to fail and terminates the process, creating a denial of service attack (making the system unavailable).

Solution: The fix is included in TensorFlow 2.5.0. The vulnerability is also patched in TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3, and TensorFlow 2.1.4 through cherry-picked commits (applying specific fixes to older supported versions).


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

Summary: TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a heap buffer overflow (memory corruption from writing past allocated memory limits) in the RaggedTensorToTensor function by providing specially crafted input shapes. The bug occurs because the code uses the same index to access two different arrays, and if one array is shorter than the other, it reads or writes to invalid memory locations.

Solution: The fix will be included in TensorFlow 2.5.0. Additionally, the commit fixing this issue will be cherry-picked (applied as a backport) to TensorFlow 2.4.2, 2.3.3, 2.2.3, and 2.1.4, which are all affected and still in the supported range.


CVE-2021-29559: TensorFlow is an end-to-end open source platform for machine learning. An attacker can access data outside of bounds of

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.UnicodeEncode` function that allows attackers to read data outside the bounds of a heap allocated array (memory that a program has requested to store data). The problem occurs because the code assumes the input data describes a valid sparse tensor (a matrix with mostly empty values) without properly validating it first.

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-29558: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a heap buffer overflow in `

Summary: TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a heap buffer overflow (a memory safety error where data is written outside its allocated space) in the `tf.raw_ops.SparseSplit` function by controlling an offset value that accesses an array.


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

Summary: TensorFlow (an open-source machine learning platform) has a vulnerability where an attacker can crash a system by triggering a divide-by-zero error (FPE, or floating-point exception) in a specific operation called `tf.raw_ops.SparseMatMul` when given an empty tensor (a multidimensional array with no data). This causes a denial of service attack (making the system unavailable to legitimate users).

Solution: Update to TensorFlow 2.5.0 or later. If you cannot upgrade to 2.5.0, the fix will also be available in TensorFlow 2.4.2, 2.3.3, 2.2.3, or 2.1.4, depending on which version you currently use.


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

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where an attacker can cause a denial of service (making a service unavailable) by triggering a FPE (floating-point exception, a math error that crashes a program) runtime error in a specific function called `tf.raw_ops.Reverse`. The bug happens because the code divides by the first dimension of a tensor (a multi-dimensional array of numbers) without properly checking if that dimension is zero.

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-29555: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a denial of service via a F

Summary: TensorFlow is a machine learning platform that has a vulnerability in its `tf.raw_ops.FusedBatchNorm` operation, which can be exploited by an attacker to cause a denial of service (making the system unavailable) through a FPE runtime error (a math operation that crashes when dividing by zero). The problem occurs because the code performs division based on a dimension value that users can control.

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


CVE-2021-29553: TensorFlow is an end-to-end open source platform for machine learning. An attacker can read data outside of bounds of he

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.QuantizeAndDequantizeV3` function where an attacker can read data outside the bounds of a heap allocated buffer (memory region used for dynamic storage) by exploiting an unvalidated `axis` attribute. The code fails to check the user-supplied `axis` value before using it to access array elements, potentially allowing unauthorized data access.


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

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where an attacker can crash the program by passing an empty tensor (a multi-dimensional array of numbers) as the `num_segments` argument to the `UnsortedSegmentJoin` operation. The code assumes this input will always be a valid scalar (a single number), so when it's empty, a safety check fails and terminates the process, causing a denial of service (making the system unavailable).

Solution: The fix will be included in TensorFlow 2.5.0. Additionally, the fix will 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-29551: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `MatrixTriangularSolve`(htt

Summary: TensorFlow, a platform for building machine learning models, has a bug in its `MatrixTriangularSolve` function (a tool for solving certain types of math problems) where the program fails to stop running if a validation check (a safety test) fails. This could cause the system to hang or consume resources indefinitely.

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.


CVE-2021-29550: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a runtime division by zero

Summary: TensorFlow has a vulnerability in the `FractionalAvgPool` operation where an attacker can provide specially crafted input values to cause a division by zero error (a crash caused by dividing by zero), leading to denial of service (making the system unavailable). The bug happens because user-controlled values aren't properly validated before being used in mathematical operations, allowing the computed output size to become zero.

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


CVE-2021-29549: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a runtime division by zero

Summary: TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a division by zero error (attempting to divide by zero, which crashes a program) in a specific operation called `tf.raw_ops.QuantizedBatchNormWithGlobalNormalization`. The bug happens because the code performs a modulo operation (finding the remainder after division) without checking if the divisor is zero first, and an attacker can craft input shapes to make this divisor equal zero.

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-29548: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a runtime division by zero

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where attackers can trigger a division by zero error (attempting to divide a number by zero, which crashes a program) in a specific operation, causing the service to become unavailable. The bug exists because the code doesn't properly check all the requirements that should be enforced before running the operation.


CVE-2021-29547: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a segfault and denial of se

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in a specific operation called `tf.raw_ops.QuantizedBatchNormWithGlobalNormalization` that allows attackers to crash the system by accessing memory outside intended bounds. The bug occurs when the operation receives empty inputs, causing it to try to read from an invalid memory location.

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-29546: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger an integer division by ze

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability where an attacker can cause an integer division by zero (a crash caused by dividing by zero) in the `tf.raw_ops.QuantizedBiasAdd` function. The bug occurs because the code divides by the number of elements in an input without first checking that this number is not zero.

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


CVE-2021-29545: 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 cause a denial of service (making the system crash or stop responding) by triggering a failed safety check when converting sparse tensors (data structures with mostly empty values) to CSR sparse matrices. The bug happens because the code tries to access memory locations that are outside the bounds of allocated space, which can corrupt data.

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-29544: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a denial of service via a

Summary: TensorFlow has a vulnerability where an attacker can crash the system (a denial of service, or DoS attack) by sending specially crafted data to a specific function called `tf.raw_ops.QuantizeAndDequantizeV4Grad`. The bug happens because the function doesn't check that its input data (called tensors, which are multi-dimensional arrays) has the correct structure, causing the program to fail when it tries to process them.

Solution: The fix will be included in TensorFlow 2.5.0. The fix will also be applied to TensorFlow 2.4.2, which is the only other affected version.


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

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in its CTCGreedyDecoder function that allows attackers to crash the program through a denial of service attack (an attack that makes a service unavailable). The problem occurs because the code uses a CHECK statement that aborts the program instead of handling invalid input properly.


CVE-2021-29542: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a heap buffer overflow by p

Summary: TensorFlow, a machine learning platform, has a vulnerability where attackers can cause a heap buffer overflow (a memory safety error where data is written beyond allocated memory) by sending specially crafted inputs to the `tf.raw_ops.StringNGrams` function. The problem occurs because the code doesn't properly handle edge cases where input splitting results in only padding elements, potentially causing the program to read from invalid memory locations.

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-29541: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a dereference of a null p

Summary: A vulnerability in TensorFlow (a platform for building machine learning models) allows an attacker to cause a null pointer dereference (a crash caused by trying to access memory that doesn't exist) in the `tf.raw_ops.StringNGrams` function by providing invalid input that isn't properly checked. This happens because the code doesn't fully validate the `data_splits` argument before using it, potentially causing the program to crash when trying to write data.

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


CVE-2021-29540: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a heap buffer overflow to o

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability where an attacker can cause a heap buffer overflow (a memory corruption bug where data is written beyond the intended memory region) in the Conv2DBackpropFilter function. This happens because the code calculates the filter tensor size but doesn't check that it matches the actual number of elements, leading to memory safety issues when the code later reads or writes to this buffer.

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


CVE-2021-29539: TensorFlow is an end-to-end open source platform for machine learning. Calling `tf.raw_ops.ImmutableConst`(https://www.t

Summary: TensorFlow (an open source machine learning platform) has a bug where calling a specific function with certain data types causes a segfault (crash where the program tries to access invalid memory). The function assumes the data will be simple scalars (single values), but fails when given more complex data types like `tf.resource` or `tf.variant`.

Solution: The issue is patched in commit 4f663d4b8f0bec1b48da6fa091a7d29609980fa4 and will be released in TensorFlow 2.5.0. TensorFlow nightly packages after this commit will also have the fix. As a workaround, users can prevent the segfault by inserting a filter for the `dtype` argument when using `tf.raw_ops.ImmutableConst`.


CVE-2021-29538: TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a division by zero to occur

Summary: TensorFlow, a machine learning platform, has a vulnerability (CVE-2021-29538) where an attacker can cause a division by zero error in the Conv2DBackpropFilter function (a tool for training neural networks) by providing empty tensor shapes, which could crash the system. The bug occurs because the code calculates a divisor from user input without checking if it equals zero before dividing by it.


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

Summary: TensorFlow, a machine learning platform, has a vulnerability where attackers can cause a heap buffer overflow (a memory safety error where data is written past the intended memory boundaries) in the `QuantizedResizeBilinear` function by providing invalid threshold values for quantization (the process of reducing data precision). The bug occurs because the code assumes these inputs are always valid numbers and doesn't properly check them before using them.

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


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

Summary: TensorFlow, a machine learning platform, has a heap buffer overflow vulnerability (a memory safety bug where code writes beyond allocated memory) in the `QuantizedReshape` function. The vulnerability occurs when an attacker passes empty tensors (multi-dimensional arrays) as threshold inputs, causing the code to incorrectly access memory at position 0 of an empty buffer.


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

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability (CVE-2021-29535) where attackers can cause a heap buffer overflow (a memory safety error where code writes beyond allocated memory) in the `QuantizedMul` function by providing invalid threshold values for quantization. The bug occurs because the code assumes input values are always valid and tries to access data that doesn't exist when empty tensors (multi-dimensional arrays) are passed in.

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


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

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where an attacker can crash the program through a denial of service attack by sending specially crafted input to the `SparseConcat` function. The problem occurs because the code uses a `CHECK` operation (a safety check that crashes the program if something goes wrong) instead of safer error-handling methods like `BuildTensorShapeBase` or `AddDimWithStatus`.

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-29533: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a denial of service via a

Summary: TensorFlow has a vulnerability (CVE-2021-29533) where an attacker can crash the application by sending an empty image to the `tf.raw_ops.DrawBoundingBoxes` function. The bug exists because the code uses `CHECK` assertions (which crash the program on failure) instead of `OP_REQUIRES` (which returns an error message to the user) to validate user input, causing the program to abort when it receives invalid data.

Solution: The fix will be included in TensorFlow 2.5.0. The commit will also be backported 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-29532: TensorFlow is an end-to-end open source platform for machine learning. An attacker can force accesses outside the bounds

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability in the `tf.raw_ops.RaggedCross` function that allows attackers to access memory outside the intended boundaries of arrays (heap OOB reads, meaning out-of-bounds reads in heap memory) by sending specially crafted invalid tensor values. The problem occurs because the code doesn't validate user-supplied arguments before using them to access array elements.


CVE-2021-29531: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a `CHECK` fail in PNG enc

Summary: TensorFlow has a vulnerability where an attacker can crash the system by sending an empty image tensor to the PNG encoding function. The code only checks if the total pixels overflow, but doesn't validate that the image actually contains data, so passing an empty matrix causes a null pointer (a reference to nothing in memory) that crashes the program in a denial of service attack (making the service unavailable).

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, which are still in the supported range.


CVE-2021-29530: 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 where an attacker can cause a null pointer dereference (accessing memory that doesn't exist, crashing the program) by providing invalid input to a specific function called `tf.raw_ops.SparseMatrixSparseCholesky`. The problem occurs because the code fails to properly validate inputs due to a macro that returns early from a validation function without stopping the main code from continuing.

Solution: The fix is to either explicitly check `context->status()` or convert `ValidateInputs` to return a `Status`. The fix is 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-29529: 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 heap buffer overflow vulnerability (a memory access bug where data is written beyond allocated space) in its image resizing function that can be triggered by specially crafted input values causing incorrect array index calculations. An attacker can exploit this by manipulating floating-point numbers so that rounding errors cause the function to access memory outside the intended image data.

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, which are still in the supported range.


CVE-2021-29528: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a division by 0 in `tf.ra

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability where an attacker can cause a division by zero error in the `tf.raw_ops.QuantizedMul` function by controlling a value used in a division operation. This crash could disrupt systems using the affected code.

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-29527: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a division by 0 in `tf.ra

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where an attacker can cause a division by zero error (crashing the program by dividing by zero) in the `tf.raw_ops.QuantizedConv2D` function by controlling a value that the code divides by. This happens because the code doesn't check if that value is zero before using it in math.

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-29526: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a division by 0 in `tf.ra

Summary: TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a division by zero error in the Conv2D function (a tool that processes image data) by controlling certain input values. This crash occurs because the code divides by a number that comes directly from the attacker's input without checking if it's zero first.

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


CVE-2021-29525: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a division by 0 in `tf.ra

Summary: TensorFlow, a machine learning platform, has a vulnerability where an attacker can cause a division by zero error in a specific function called `tf.raw_ops.Conv2DBackpropInput` by controlling certain input values. This happens because the code divides by a number that comes from the attacker's input without checking if it's zero first.


CVE-2021-29524: TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a division by 0 in `tf.ra

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where an attacker can cause a division by zero error (a crash caused by attempting math with zero as a divisor) in a specific function called `tf.raw_ops.Conv2DBackpropFilter` by controlling a value used in a modulus operation (a calculation that finds remainders). This bug affects multiple older versions of the software.


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

Summary: TensorFlow (an open source machine learning platform) has a vulnerability where an attacker can crash the program through a denial of service attack by sending malicious input to the `AddManySparseToTensorsMap` function. The problem occurs because the code uses an outdated constructor method that fails abruptly when it encounters numeric overflow (when a number gets too large for the system to handle), rather than handling the error gracefully.

Solution: The fix will be included in TensorFlow 2.5.0. Additionally, the fix will 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-29522: TensorFlow is an end-to-end open source platform for machine learning. The `tf.raw_ops.Conv3DBackprop*` operations fail

Summary: A bug in TensorFlow (an open source machine learning platform) allows attackers to cause a denial of service (making a system unavailable) by triggering a division by zero error in the `tf.raw_ops.Conv3DBackprop*` operations. The operations don't check if input tensors are empty before using them in calculations, which crashes the system if an attacker controls the input sizes.

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-29521: TensorFlow is an end-to-end open source platform for machine learning. Specifying a negative dense shape in `tf.raw_ops.

Summary: TensorFlow (an open source platform for machine learning) has a bug where passing a negative number in the dense shape parameter to `tf.raw_ops.SparseCountSparseOutput` causes a crash. This happens because the code assumes the shape values are always positive and doesn't validate them before using them to create a data structure, which violates the safety rules of the underlying `std::vector` (a list-like data structure in C++).

Solution: The fix will be included in TensorFlow 2.5.0. This commit will also be applied to TensorFlow 2.4.2 and TensorFlow 2.3.3. The solution ensures that the `dense_shape` argument is validated to be a valid tensor shape, meaning all elements must be non-negative.


CVE-2021-29520: TensorFlow is an end-to-end open source platform for machine learning. Missing validation between arguments to `tf.raw_o

Summary: TensorFlow, a machine learning platform, has a vulnerability in its `tf.raw_ops.Conv3DBackprop*` operations where missing validation of input arguments can cause a heap buffer overflow (a crash or security issue where a program writes data beyond its allocated memory). The problem occurs because the code assumes three data structures (called tensors) have matching shapes, but doesn't check this before accessing them simultaneously.

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-29519: TensorFlow is an end-to-end open source platform for machine learning. The API of `tf.raw_ops.SparseCross` allows combin

Summary: TensorFlow, a machine learning platform, has a vulnerability in its `tf.raw_ops.SparseCross` function that can crash a program (denial of service) by tricking the code into mixing incompatible data types (string type with integer type). The vulnerability occurs because the implementation incorrectly processes a tensor, thinking it contains one type of data when it actually contains another.

Solution: The fix prevents mixing `DT_STRING` and `DT_INT64` types and 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-29518: TensorFlow is an end-to-end open source platform for machine learning. In eager mode (default in TF 2.0 and later), sess

Summary: TensorFlow has a vulnerability where eager mode (the default execution style in TensorFlow 2.0+) allows users to call raw operations that shouldn't work, causing a null pointer dereference (an error where the program tries to use an empty memory reference). The problem occurs because the code doesn't check whether the session state pointer is valid before using it, leading to undefined behavior (unpredictable outcomes).

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


CVE-2021-29517: TensorFlow is an end-to-end open source platform for machine learning. A malicious user could trigger a division by 0 in

Summary: A vulnerability in TensorFlow (an open source platform for machine learning) allows a malicious user to crash the program by providing specially crafted input to the Conv3D function (a tool for processing 3D image data). The vulnerability occurs because the code performs a division or modulo operation (mathematical operations that can fail) based on user-provided data, and if certain values are zero, the program crashes.

Solution: The fix will be included in TensorFlow 2.5.0. Additionally, the fix will 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-29516: TensorFlow is an end-to-end open source platform for machine learning. Calling `tf.raw_ops.RaggedTensorToVariant` with a

Summary: TensorFlow, a machine learning platform, has a vulnerability in the `RaggedTensorToVariant` function where passing invalid ragged tensors (data structures for irregular-shaped arrays) causes a null pointer dereference (accessing memory that hasn't been set, crashing the program). The function doesn't check whether the ragged tensor is empty before trying to use it.

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


CVE-2021-29515: TensorFlow is an end-to-end open source platform for machine learning. The implementation of `MatrixDiag*` operations(ht

Summary: TensorFlow (an open-source machine learning platform) has a vulnerability in its `MatrixDiag*` operations (functions that create diagonal matrices from tensor data) because the code doesn't check whether the input tensors are empty, which could cause the program to crash or behave unexpectedly. This bug affects multiple versions of TensorFlow.

Solution: The fix will be included in TensorFlow 2.5.0. It will also be backported (added 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-29514: TensorFlow is an end-to-end open source platform for machine learning. If the `splits` argument of `RaggedBincount` does

Summary: TensorFlow has a vulnerability in its RaggedBincount operation where invalid input arguments can cause a heap buffer overflow (a crash or memory corruption from accessing memory outside allocated bounds). An attacker can craft malicious input to make the code read or write to memory it shouldn't access, potentially compromising the system running the code.

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


CVE-2021-29513: TensorFlow is an end-to-end open source platform for machine learning. Calling TF operations with tensors of non-numeric

Summary: TensorFlow, a machine learning platform, has a vulnerability where operations that expect numeric tensors (data types representing numbers) crash when given non-numeric tensors instead, due to a type confusion bug (mixing up data types) in the conversion from Python code to C++ code. The developers have fixed this issue and will release it in multiple versions.

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.