CVE-2023-25672: TensorFlow is an open source platform for machine learning. The function `tf.raw_ops.LookupTableImportV2` cannot handle

Summary: TensorFlow, an open source platform for machine learning, has a bug in the `tf.raw_ops.LookupTableImportV2` function where it cannot properly handle scalar values (single values, not arrays) in the `values` parameter, causing an NPE (null pointer exception, when the program tries to use a value that doesn't exist). This is a type of vulnerability called NULL Pointer Dereference (CWE-476).

Solution: A fix is included in TensorFlow version 2.12.0 and version 2.11.1. Users can also reference the patch at https://github.com/tensorflow/tensorflow/commit/980b22536abcbbe1b4a5642fc940af33d8c19b69.


CVE-2023-25671: TensorFlow is an open source platform for machine learning. There is out-of-bounds access due to mismatched integer type

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability called out-of-bounds access (a bug where code tries to read or write data outside the memory area it should access), caused by mismatched integer type sizes (using different number formats where the same one was expected). The issue can be fixed by updating to TensorFlow version 2.12.0 or 2.11.1.

Solution: A fix is included in TensorFlow version 2.12.0 and version 2.11.1.


CVE-2023-25670: TensorFlow is an open source platform for machine learning. Versions prior to 2.12.0 and 2.11.1 have a null point error

Summary: TensorFlow (an open source machine learning platform) versions before 2.12.0 and 2.11.1 have a null pointer dereference (a crash caused by trying to access memory that doesn't exist) in a specific feature called QuantizedMatMulWithBiasAndDequantize when MKL (a math optimization library) is enabled. This bug can cause the software to crash or behave unexpectedly.

Solution: Update to TensorFlow version 2.12.0 or version 2.11.1, which include fixes for this vulnerability.


CVE-2023-25669: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, if the stride and windo

Summary: TensorFlow (an open source platform for machine learning) has a bug in the `tf.raw_ops.AvgPoolGrad` function where invalid input values can cause a floating point exception (a crash due to an illegal math operation). This affects TensorFlow versions before 2.12.0 and 2.11.1.

Solution: Update to TensorFlow version 2.12.0 or version 2.11.1, which include a fix for this issue.


CVE-2023-25668: TensorFlow is an open source platform for machine learning. Attackers using Tensorflow prior to 2.12.0 or 2.11.1 can acc

Summary: TensorFlow (an open-source machine learning platform) versions before 2.12.0 and 2.11.1 have a vulnerability that allows attackers to access heap memory (the part of a computer's memory used for dynamic storage) that shouldn't be accessible, potentially causing the program to crash or allowing remote code execution (running commands on a system remotely without authorization). This is caused by heap-based buffer overflow and out-of-bounds read errors (reading data from memory locations outside the intended boundaries).

Solution: The fix will be included in TensorFlow version 2.12.0 and will also be cherry-picked (selectively applied) to TensorFlow version 2.11.1.


CVE-2023-25667: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, integer overflow occurs

Summary: TensorFlow, an open source machine learning platform, had an integer overflow vulnerability (a bug where calculations exceed the maximum number a computer can store) in versions before 2.12.0 and 2.11.1. The bug occurred when processing video frames with certain dimensions, potentially affecting full HD screencasts with at least 346 frames.

Solution: Update to TensorFlow version 2.12.0 or version 2.11.1, which include the fix for this vulnerability.


CVE-2023-25666: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, there is a floating poi

Summary: TensorFlow, an open source machine learning platform, had a floating point exception (a math error that crashes a program) in its AudioSpectrogram component before versions 2.12.0 and 2.11.1. This bug could cause the software to crash when processing certain audio data.

Solution: Update TensorFlow to version 2.12.0 or version 2.11.1, which include the fix for this vulnerability.


CVE-2023-25665: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, when `SparseSparseMaxim

Summary: TensorFlow (an open source platform for machine learning) versions before 2.12.0 and 2.11.1 have a bug where the SparseSparseMaximum function crashes with a null pointer error (when the program tries to access memory that doesn't exist) if given invalid sparse tensors (multi-dimensional arrays with mostly empty values) as inputs. This is a stability issue that can cause the program to fail.

Solution: Update to TensorFlow version 2.12.0 or version 2.11.1, which include a fix for this vulnerability.


CVE-2023-25664: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, there is a heap buffer

Summary: TensorFlow, an open source machine learning platform, had a heap buffer overflow vulnerability (a memory safety bug where data is written beyond allocated space) in a function called TAvgPoolGrad before versions 2.12.0 and 2.11.1. This vulnerability could potentially allow attackers to crash the software or execute code.

Solution: Update TensorFlow to version 2.12.0 or 2.11.1, which include the fix for this vulnerability.


CVE-2023-25663: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, when `ctx->step_contain

Summary: TensorFlow, an open source machine learning platform, had a vulnerability in versions before 2.12.0 and 2.11.1 where a null pointer dereference (a crash caused by trying to use a memory location that doesn't exist) could occur in the Lookup function when a certain pointer was null. This weakness is classified as CWE-476 (NULL Pointer Dereference).

Solution: Update to TensorFlow version 2.12.0 or 2.11.1, which include the fix for this vulnerability. The patch is available at https://github.com/tensorflow/tensorflow/commit/239139d2ae6a81ae9ba499ad78b56d9b2931538a.


CVE-2023-25662: TensorFlow is an open source platform for machine learning. Versions prior to 2.12.0 and 2.11.1 are vulnerable to intege

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in versions before 2.12.0 and 2.11.1 involving integer overflow (a math error where a number gets too large and wraps around) in the EditDistance function. This bug could potentially cause unexpected behavior or crashes in machine learning programs using affected versions.

Solution: Update TensorFlow to version 2.12.0 or version 2.11.1, both of which include a fix for this vulnerability.


CVE-2023-25660: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, when the parameter `sum

Summary: TensorFlow, an open source platform for machine learning, has a bug in its `tf.raw_ops.Print` function that causes a seg fault (a crash where the program tries to access memory it shouldn't) when the `summarize` parameter is set to zero. The bug happens because the code tries to use a nullptr (a reference to nothing instead of valid data).

Solution: A fix is included in TensorFlow version 2.12.0 and version 2.11.1. Users should update to one of these versions or later.


CVE-2023-25659: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, if the parameter `indic

Summary: TensorFlow, an open source machine learning platform, had a vulnerability where mismatched parameters in the `DynamicStitch` function could cause a stack OOB read (out-of-bounds read, where a program accesses memory it shouldn't). This flaw affected versions before 2.12.0 and 2.11.1.


CVE-2023-25658: TensorFlow is an open source platform for machine learning. Prior to versions 2.12.0 and 2.11.1, an out of bounds read i

Summary: TensorFlow, an open source platform for machine learning, had an out of bounds read vulnerability (a bug where code tries to access memory it shouldn't) in a component called GRUBlockCellGrad before versions 2.12.0 and 2.11.1. This vulnerability could potentially allow attackers to read sensitive data or crash the system.


CVE-2023-1177: Path Traversal: '\..\filename' in GitHub repository mlflow/mlflow prior to 2.2.1.

Summary: CVE-2023-1177 is a path traversal vulnerability (a flaw where an attacker can access files outside the intended directory by using special characters like '..') in MLflow versions before 2.2.1. This weakness allows attackers to potentially read or access files they shouldn't be able to reach on the system.

Solution: Update MLflow to version 2.2.1 or later. A patch is available at https://github.com/mlflow/mlflow/pull/7891/commits/7162a50c654792c21f3e4a160eb1a0e6a34f6e6e


CVE-2023-1176: Absolute Path Traversal in GitHub repository mlflow/mlflow prior to 2.2.2.

Summary: CVE-2023-1176 is an absolute path traversal vulnerability (a bug where an attacker can access files anywhere on a system by using file paths that start from the root directory) found in MLflow, an open-source platform for managing machine learning experiments, affecting versions before 2.2.2. The vulnerability was discovered and reported through the huntr.dev bug bounty program.

Solution: Fixed in version 2.2.2. A patch is available at https://github.com/mlflow/mlflow/commit/63ef72aa4334a6473ce7f889573c92fcae0b3c0d.


CVE-2023-27494: Streamlit, software for turning data scripts into web applications, had a cross-site scripting (XSS) vulnerability in ve

Summary: Streamlit, software that converts data scripts into web applications, had a cross-site scripting vulnerability (XSS, where an attacker injects malicious code that runs in a user's browser) in versions 0.63.0 through 0.80.0. An attacker could craft a malicious URL containing JavaScript code, trick a user into clicking it, and the Streamlit server would execute that code in the victim's browser.

Solution: Update to version 0.81.0, which contains a patch for this vulnerability.


Yolo: Natural Language to Shell Commands with ChatGPT API

Summary: Yolo is a tool that uses ChatGPT API (OpenAI's language model accessed through code) to translate natural language questions into shell commands (the text-based interface for controlling a computer) that can be executed automatically. The tool helps users who forget command syntax by converting plain English requests into proper bash, zsh, or PowerShell commands, with a safety feature that shows the command before running it unless the user enables automatic execution.

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


CVE-2022-23535: LiteDB is a small, fast and lightweight .NET NoSQL embedded database. Versions prior to 5.0.13 are subject to Deserializ

Summary: LiteDB, a lightweight database library for .NET, has a vulnerability in versions before 5.0.13 where it can deserialize (convert data from a format like JSON back into usable objects) untrusted data. If an attacker sends specially crafted JSON to an application using LiteDB, the library may load unsafe objects by using a special `_type` field that tells it what class to create, potentially allowing malicious code execution.

Solution: Update LiteDB to version 5.0.13 or later. The source notes this version includes basic fixes to prevent the issue, though it is not completely guaranteed when using `Object` type. A future major version will add an allow-list to control which assemblies (code libraries) can be loaded. For immediate protection, consult the vendor advisory for additional workarounds.


CVE-2023-25823: Gradio is an open-source Python library to build machine learning and data science demos and web applications. Versions

Summary: Gradio is a Python library for building AI demo applications, and versions before 3.13.1 accidentally exposed private SSH keys (security credentials that grant system access) when users enabled share links to let others access their apps. This meant anyone connecting to a shared Gradio app could steal the SSH key and access other users' Gradio demos or exploit them further depending on what data or capabilities the app had access to.

Solution: Update to version 3.13.1 or later. Gradio recommends updating to version 3.19.1 or later, where the FRP (Fast Reverse Proxy) solution has been properly tested.


CVE-2022-26076: Uncontrolled search path element in the Intel(R) oneAPI Deep Neural Network (oneDNN) before version 2022.1 may allow an

Summary: CVE-2022-26076 is a vulnerability in Intel's oneAPI Deep Neural Network library (oneDNN, a software framework for machine learning tasks) before version 2022.1 that involves an uncontrolled search path element (a weakness where a program looks for files in directories it shouldn't trust, potentially allowing attackers to substitute malicious files). An authenticated user (someone with login access) could exploit this through local access to gain higher system privileges.

Intel oneAPI Deep Neural Network (oneDNN)


CVE-2023-23382: Azure Machine Learning Compute Instance Information Disclosure Vulnerability

Summary: CVE-2023-23382 is a vulnerability in Azure Machine Learning Compute Instance that allows unauthorized access to sensitive information. The vulnerability is related to storing passwords in a recoverable format (CWE-257, meaning passwords are saved in a way that can be converted back to their original form), making it easier for attackers to steal credentials.


CVE-2023-0405: The GPT AI Power: Content Writer & ChatGPT & Image Generator & WooCommerce Product Writer & AI Training WordPress plugin

Summary: A WordPress plugin called 'GPT AI Power' before version 1.4.38 has a security flaw where logged-in users can modify any posts without proper authorization checks (nonce and privilege verification, which are security measures that confirm a user has permission to perform an action). This means someone with basic login access could change or delete content they shouldn't be able to touch.

Solution: Update the plugin to version 1.4.38 or later.


CVE-2022-25882: Versions of the package onnx before 1.13.0 are vulnerable to Directory Traversal as the external_data field of the tenso

Summary: ONNX (a machine learning model format library) versions before 1.13.0 contain a directory traversal vulnerability (a security flaw where an attacker can access files outside the intended folder by using paths like '../../../etc/passwd'). An attacker could exploit the external_data field in tensor proto (data structure in ONNX models) to read sensitive files from anywhere on a system.

Solution: Update to ONNX version 1.13.0 or later.


Standard Setting

Summary: The EU AI Act requires technical standards to be written by European standardization organizations (CEN and CENELEC) that explain how companies can safely build high-risk AI systems. These standards follow a six-step approval process and, once published and approved by the European Commission, become 'harmonized and cited standards' that legally presume compliance with safety regulations if companies follow them. The drafting process is currently ongoing but behind schedule, with different standards at different completion stages.


CVE-2022-41910: TensorFlow is an open source platform for machine learning. The function MakeGrapplerFunctionItem takes arguments that d

Summary: TensorFlow, an open source platform for machine learning, has a bug in the MakeGrapplerFunctionItem function where providing inputs larger than or equal to the output sizes causes an out-of-bounds memory read (reading data from memory locations the program shouldn't access) or a crash. The issue has been patched and will be included in TensorFlow 2.11.0 as well as backported to earlier versions.

Solution: The fix is available in GitHub commit a65411a1d69edfb16b25907ffb8f73556ce36bb7. Users should update to TensorFlow 2.11.0, or for earlier versions, update to 2.8.4, 2.9.3, or 2.10.1 where the patch has been backported.


CVE-2022-41902: TensorFlow is an open source platform for machine learning. The function MakeGrapplerFunctionItem takes arguments that d

Summary: TensorFlow, an open source machine learning platform, has a bug in its MakeGrapplerFunctionItem function where providing input sizes that are greater than or equal to output sizes causes an out-of-bounds memory read (accessing memory locations outside the intended range) or a crash. This vulnerability affects how TensorFlow processes data when sizes are mismatched.

Solution: The issue has been patched in GitHub commit a65411a1d69edfb16b25907ffb8f73556ce36bb7. The fix is included in TensorFlow 2.11.0, and will also be included in TensorFlow 2.8.4, 2.9.3, and 2.10.1.


ChatGPT: Imagine you are a database server

Summary: This post demonstrates that ChatGPT can be prompted to roleplay as a Microsoft SQL Server (a database management system) and respond with realistic database commands and results, including creating databases, tables, inserting data, and writing stored procedures (reusable blocks of SQL code). The author shows that ChatGPT can understand user intent well enough to execute complex database operations like UPSERTs (operations that update existing records or insert new ones if they don't exist), even when given incomplete information.


CVE-2022-45907: In PyTorch before trunk/89695, torch.jit.annotations.parse_type_line can cause arbitrary code execution because eval is

Summary: PyTorch versions before trunk/89695 have a vulnerability in the torch.jit.annotations.parse_type_line function that can allow arbitrary code execution (running attacker-controlled commands on a system) because it uses eval unsafely (eval is a function that executes code from text input without proper safety checks).


CVE-2022-41911: TensorFlow is an open source platform for machine learning. When printing a tensor, we get it's data as a `const char*`

Summary: TensorFlow, an open source platform for machine learning, has a bug where converting character data to boolean values can cause crashes because the conversion is undefined unless the character is exactly 0 or 1. This issue affects the process of printing tensors (multi-dimensional arrays of data used in machine learning).

Solution: The issue has been patched in GitHub commit `1be74370327`. The fix will be included in TensorFlow 2.11.0, and will also be applied to TensorFlow 2.10.1, TensorFlow 2.9.3, and TensorFlow 2.8.4.


CVE-2022-41909: TensorFlow is an open source platform for machine learning. An input `encoded` that is not a valid `CompositeTensorVaria

Summary: TensorFlow (an open source machine learning platform) has a vulnerability where invalid input to a specific function causes a segfault (a crash where the program tries to access memory it shouldn't). The bug occurs when `tf.raw_ops.CompositeTensorVariantToComponents` receives an `encoded` parameter that is not a valid `CompositeTensorVariant` tensor (a data structure for machine learning computations).

Solution: The issue has been patched in GitHub commits bf594d08d377dc6a3354d9fdb494b32d45f91971 and 660ce5a89eb6766834bdc303d2ab3902aef99d3d. The fix will be included in TensorFlow 2.11, and will also be backported to TensorFlow 2.10.1, 2.9.3, and TensorFlow 2.8.4.


CVE-2022-41908: TensorFlow is an open source platform for machine learning. An input `token` that is not a UTF-8 bytestring will trigger

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where passing a `token` input that is not UTF-8 encoded (a character encoding standard) causes the `tf.raw_ops.PyFunc` function to crash with a CHECK fail (a safety check that stops execution when something is wrong). This is a type of improper input validation weakness, meaning the function doesn't properly check whether its input is in the correct format before processing it.

Solution: The issue has been patched in GitHub commit 9f03a9d3bafe902c1e6beb105b2f24172f238645. The fix is included in TensorFlow 2.11, and will also be patched in TensorFlow 2.10.1, 2.9.3, and TensorFlow 2.8.4.


CVE-2022-41907: TensorFlow is an open source platform for machine learning. When `tf.raw_ops.ResizeNearestNeighborGrad` is given a large

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in the `tf.raw_ops.ResizeNearestNeighborGrad` function where a large `size` input causes an integer overflow (a calculation error where a number becomes too big for its storage space). This bug allows an attacker to potentially crash the system or execute malicious code.

Solution: The fix is included in TensorFlow 2.11 and has been backported to TensorFlow 2.10.1, 2.9.3, and 2.8.4. Users should update to one of these patched versions. The specific patch is available in GitHub commit 00c821af032ba9e5f5fa3fe14690c8d28a657624.


CVE-2022-41901: TensorFlow is an open source platform for machine learning. An input `sparse_matrix` that is not a matrix with a shape w

Summary: TensorFlow, an open source machine learning platform, has a bug where invalid input to the `SparseMatrixNNZ` function (a function that counts non-zero values in a sparse matrix, which is a matrix stored efficiently by only keeping non-zero elements) causes the program to crash with a CHECK fail (an assertion error, where the program stops because a required condition wasn't met). This vulnerability affects multiple versions of TensorFlow.

Solution: The issue has been patched in GitHub commit f856d02e5322821aad155dad9b3acab1e9f5d693. The fix is included in TensorFlow 2.11 and has been backported (adapted for older versions) to TensorFlow 2.10.1, 2.9.3, and 2.8.4.


CVE-2022-41900: TensorFlow is an open source platform for machine learning. The security vulnerability results in FractionalMax(AVG)Pool

Summary: TensorFlow (an open source machine learning platform) has a security vulnerability in its FractionalMaxPool and FractionalAvgPool functions when given invalid pooling_ratio values. Attackers can exploit this to access heap memory (the computer's temporary storage area outside normal program control), potentially causing the system to crash or allowing remote code execution (running harmful commands on someone else's computer).

Solution: The vulnerability was patched in GitHub commit 216525144ee7c910296f5b05d214ca1327c9ce48. The fix will be included in TensorFlow 2.11.0, and the patch will also be applied to TensorFlow 2.10.1.


CVE-2022-41899: TensorFlow is an open source platform for machine learning. Inputs `dense_features` or `example_state_data` not of rank

Summary: TensorFlow (an open source machine learning platform) has a bug where certain inputs with incorrect dimensions crash the SdcaOptimizer component due to a failed validation check. This happens when `dense_features` or `example_state_data` inputs don't have the expected 2D structure (rank 2, meaning a table with rows and columns).

Solution: The fix is included in TensorFlow 2.11. For users on earlier versions, the patch will also be available in TensorFlow 2.10.1, 2.9.3, and 2.8.4. The specific fix is referenced in GitHub commit 80ff197d03db2a70c6a111f97dcdacad1b0babfa.


CVE-2022-41898: TensorFlow is an open source platform for machine learning. If `SparseFillEmptyRowsGrad` is given empty inputs, TensorFl

Summary: TensorFlow, an open source machine learning platform, crashes when a function called `SparseFillEmptyRowsGrad` receives empty inputs instead of data. This happens because the code doesn't properly validate (check) what data it receives before trying to process it.

Solution: The fix is included in TensorFlow version 2.11. For users still on older supported versions, patches were also applied to TensorFlow 2.10.1, 2.9.3, and 2.8.4. Users should update to one of these patched versions. The specific patch commit is af4a6a3c8b95022c351edae94560acc61253a1b8 on GitHub.


CVE-2022-41897: TensorFlow is an open source platform for machine learning. If `FractionMaxPoolGrad` is given outsize inputs `row_poolin

Summary: TensorFlow (an open-source machine learning platform) crashes when a function called `FractionMaxPoolGrad` receives oversized inputs for `row_pooling_sequence` and `col_pooling_sequence` parameters. This is caused by an out-of-bounds read (accessing memory locations outside the intended range), which allows the program to fail unexpectedly.

Solution: The patch is available in GitHub commit d71090c3e5ca325bdf4b02eb236cfb3ee823e927. Users should upgrade to TensorFlow 2.11, or apply the patch to supported earlier versions: 2.10.1, 2.9.3, and 2.8.4.


CVE-2022-41896: TensorFlow is an open source platform for machine learning. If `ThreadUnsafeUnigramCandidateSampler` is given input `fil

Summary: TensorFlow (an open-source platform for machine learning) has a vulnerability where a function called `ThreadUnsafeUnigramCandidateSampler` crashes if it receives an input value for `filterbank_channel_count` that exceeds the maximum allowed size. This is caused by improper input validation (failure to check that user-provided values are within acceptable limits).

Solution: The fix is included in TensorFlow 2.11. The patch has also been backported to TensorFlow 2.10.1, 2.9.3, and 2.8.4. Users should update to one of these versions or later.


CVE-2022-41895: TensorFlow is an open source platform for machine learning. If `MirrorPadGrad` is given outsize input `paddings`, Tensor

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where the `MirrorPadGrad` function crashes with a heap OOB error (out-of-bounds memory access, where the software tries to read memory it shouldn't) when given incorrectly sized input padding values. This bug allows attackers to potentially crash TensorFlow applications.

Solution: The fix is included in TensorFlow 2.11 and has been backported (applied to older versions) in TensorFlow 2.10.1, 2.9.3, and 2.8.4. Users should update to one of these patched versions. The fix was committed in GitHub commit 717ca98d8c3bba348ff62281fdf38dcb5ea1ec92.


CVE-2022-41894: TensorFlow is an open source platform for machine learning. The reference kernel of the `CONV_3D_TRANSPOSE` TensorFlow L

Summary: TensorFlow Lite's `CONV_3D_TRANSPOSE` operator (a component that flips and reorganizes 3D data during machine learning processing) had a bug where it incorrectly calculated memory addresses when adding bias values, potentially allowing an attacker to write data outside the intended memory area (buffer overflow, where data gets written beyond allocated boundaries). The vulnerability only affects users who employ TensorFlow's default kernel resolver in their interpreter.

Solution: The issue was patched in GitHub commit 72c0bdcb25305b0b36842d746cc61d72658d2941. The fix will be included in TensorFlow 2.11, and will be backported to TensorFlow 2.10.1, 2.9.3, and TensorFlow 2.8.4.


CVE-2022-41893: TensorFlow is an open source platform for machine learning. If `tf.raw_ops.TensorListResize` is given a nonscalar value

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in the `tf.raw_ops.TensorListResize` function where providing a nonscalar value (a value that isn't a single number) for the `size` input causes a CHECK fail, which can be exploited to trigger a denial of service attack (making the system crash or become unavailable).

Solution: The issue has been patched in GitHub commit 888e34b49009a4e734c27ab0c43b0b5102682c56. The fix is included in TensorFlow 2.11 and will be backported to TensorFlow 2.10.1, 2.9.3, and 2.8.4.


CVE-2022-41891: TensorFlow is an open source platform for machine learning. If `tf.raw_ops.TensorListConcat` is given `element_shape=[]`

Summary: TensorFlow, an open source machine learning platform, has a vulnerability where a specific function called `tf.raw_ops.TensorListConcat` crashes with a segmentation fault (a memory error that causes a program to suddenly stop) when given certain invalid input. This crash can be exploited to cause a denial of service attack (making the service unavailable to users).

Solution: The fix is included in TensorFlow 2.11 and will be cherrypicked (backported) to TensorFlow 2.10.1, 2.9.3, and 2.8.4. Users can refer to GitHub commit fc33f3dc4c14051a83eec6535b608abe1d355fde for the patch details.


CVE-2022-41890: TensorFlow is an open source platform for machine learning. If `BCast::ToShape` is given input larger than an `int32`, i

Summary: TensorFlow is a machine learning platform that had a bug where a function called `BCast::ToShape` would crash when given very large numbers (larger than an `int32`, which is a 32-bit integer) even though it was designed to handle even larger numbers called `int64`. This bug could be triggered by using the `tf.experimental.numpy.outer` function with large inputs.

Solution: The issue was patched in GitHub commit 8310bf8dd188ff780e7fc53245058215a05bdbe5. The fix will be included in TensorFlow 2.11, and will also be backported (applied to earlier versions) in TensorFlow 2.10.1, 2.9.3, and TensorFlow 2.8.4.


CVE-2022-41889: TensorFlow is an open source platform for machine learning. If a list of quantized tensors is assigned to an attribute,

Summary: TensorFlow, an open source machine learning platform, had a bug where passing quantized tensors (specially compressed numeric data) to certain functions caused the parsing code to fail silently and return a null pointer (empty reference) instead of the expected data. This could cause crashes or unexpected behavior in machine learning programs using affected TensorFlow functions.

Solution: The issue was patched in GitHub commit e9e95553e5411834d215e6770c81a83a3d0866ce and will be included in TensorFlow 2.11. The fix will also be backported (applied to earlier versions) in TensorFlow 2.10.1, 2.9.3, and 2.8.4.


CVE-2022-41888: TensorFlow is an open source platform for machine learning. When running on GPU, `tf.image.generate_bounding_box_proposa

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `tf.image.generate_bounding_box_proposals` function when running on GPU. The function fails to validate that the `scores` input has the correct rank (dimension structure), which could cause problems. This is classified as improper input validation (CWE-20, where a program doesn't properly check if data meets required specifications).

Solution: The fix is included in TensorFlow 2.11 and has been backported to versions 2.10.1, 2.9.3, and 2.8.4. Users should update to one of these patched versions. The patch details are available in GitHub commit cf35502463a88ca7185a99daa7031df60b3c1c98.


CVE-2022-41887: TensorFlow is an open source platform for machine learning. `tf.keras.losses.poisson` receives a `y_pred` and `y_true` t

Summary: TensorFlow's poisson loss function (a tool for measuring prediction errors in machine learning) crashes when certain input dimensions multiply together and exceed the limit of a 32-bit integer, causing a size mismatch during broadcast assignment (aligning data for computation). The vulnerability affects multiple versions of TensorFlow.

Solution: The issue has been patched in GitHub commit c5b30379ba87cbe774b08ac50c1f6d36df4ebb7c. The fix will be included in TensorFlow 2.11, and will also be patched in TensorFlow 2.10.1 and 2.9.3. TensorFlow 2.8.x will not receive this patch due to dependency changes in the underlying Eigen library between versions.


CVE-2022-41886: TensorFlow is an open source platform for machine learning. When `tf.raw_ops.ImageProjectiveTransformV2` is given a larg

Summary: TensorFlow (an open source platform for machine learning) has a bug in the `tf.raw_ops.ImageProjectiveTransformV2` function where it overflows (uses more memory than available) when given a large output shape. This vulnerability was caused by an incorrect calculation of buffer size (the amount of memory needed to store data).

Solution: The fix is available in TensorFlow 2.11. For users on earlier versions still receiving support, the patch will be included in TensorFlow 2.10.1, 2.9.3, and TensorFlow 2.8.4. Users can also apply the fix directly via GitHub commit 8faa6ea692985dbe6ce10e1a3168e0bd60a723ba.


CVE-2022-41885: TensorFlow is an open source platform for machine learning. When `tf.raw_ops.FusedResizeAndPadConv2D` is given a large t

Summary: TensorFlow (an open source machine learning platform) has a vulnerability in the `tf.raw_ops.FusedResizeAndPadConv2D` function where a buffer overflow (a memory error where data exceeds available space) occurs when given very large tensor shapes. The bug stems from an incorrect buffer size calculation.

Solution: The fix is available in TensorFlow 2.11. For users on earlier versions, the patch has been applied to TensorFlow 2.10.1, 2.9.3, and 2.8.4. Users should update to one of these versions.


CVE-2022-41884: TensorFlow is an open source platform for machine learning. If a numpy array is created with a shape such that one eleme

Summary: TensorFlow, an open source machine learning platform, has a bug where creating a numpy array (a data structure for storing numbers) with a specific shape (one dimension with zero elements and others summing to a large number) causes an error. The developers have created a fix and will release it in upcoming versions of TensorFlow.

Solution: The fix is included in TensorFlow 2.11. For users on earlier versions still receiving support, the patch will also be available in TensorFlow 2.10.1, 2.9.3, and TensorFlow 2.8.4. The fix is available in GitHub commit 2b56169c16e375c521a3bc8ea658811cc0793784.


CVE-2022-41880: TensorFlow is an open source platform for machine learning. When the `BaseCandidateSamplerOp` function receives a value

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in the `BaseCandidateSamplerOp` function that causes a heap OOB read (out-of-bounds read, where a program accesses memory it shouldn't) when it receives certain invalid input values. This is a memory safety bug that could allow attackers to read sensitive data from the program's memory.

Solution: The issue has been patched in GitHub commit b389f5c944cadfdfe599b3f1e4026e036f30d2d4. Users should update to TensorFlow 2.11, or if using earlier versions, update to TensorFlow 2.10.1, 2.9.3, or 2.8.4, which will also receive the fix through a cherry-pick (backporting the patch to older supported versions).


CVE-2022-41883: TensorFlow is an open source platform for machine learning. When ops that have specified input sizes receive a differing

Summary: TensorFlow (an open source platform for machine learning) has a bug where certain operations crash when they receive a different number of inputs than expected, which could cause the program to stop working. This vulnerability is classified as an out-of-bounds read (accessing memory outside the intended range).

Solution: The fix is included in TensorFlow 2.11. Users on earlier versions should update to TensorFlow 2.10.1, 2.9.3, or 2.8.4, which have the patch applied through GitHub commit f5381e0e10b5a61344109c1b7c174c68110f7629.


CVE-2022-36022: Deeplearning4J is a suite of tools for deploying and training deep learning models using the JVM. Packages org.deeplearn

Summary: Deeplearning4J (a tool for building machine learning models on Java systems) versions up to 1.0.0-M2.1 have a vulnerability where some test code references unclaimed S3 buckets (cloud storage spaces that no longer belong to the original owner), which could potentially be exploited by attackers who claim those buckets. This mainly affects older natural language processing examples in the software.

Solution: Users should upgrade to snapshots (development versions) of Deeplearning4J. A full release with the fix is planned for a later date. As a workaround, download a word2vec Google News vector (a pre-trained language model) from a new source using git lfs (a system for managing large files in code repositories).


CVE-2022-36027: TensorFlow is an open source platform for machine learning. When converting transposed convolutions using per-channel we

Summary: TensorFlow (an open source platform for machine learning) crashes when converting transposed convolutions (a type of neural network layer operation) with per-channel weight quantization (a compression technique that reduces precision individually for different channels). The crash causes a segfault (a memory access error that terminates the program), crashing the Python process.

Solution: The issue has been patched in GitHub commit aa0b852a4588cea4d36b74feb05d93055540b450. The fix will be included in TensorFlow 2.10.0, and will also be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-36017: TensorFlow is an open source platform for machine learning. If `Requantize` is given `input_min`, `input_max`, `requeste

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability where a function called `Requantize` crashes when given certain types of input data (tensors of nonzero rank), allowing attackers to trigger a denial of service attack (making the system unavailable). The issue has been fixed and will be released in updated versions of the software.

Solution: The fix is included in TensorFlow 2.10.0. The patch will also be applied to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Users should upgrade to one of these patched versions. There are no known workarounds for this issue.


CVE-2022-36016: TensorFlow is an open source platform for machine learning. When `tensorflow::full_type::SubstituteFromAttrs` receives a

Summary: TensorFlow, an open source platform for machine learning, has a bug where a specific function (`tensorflow::full_type::SubstituteFromAttrs`) crashes the program instead of properly reporting an error when it receives incorrect input (a `FullTypeDef` that doesn't have exactly three arguments). This crash could potentially be exploited to make TensorFlow applications stop working.

Solution: The issue is patched in GitHub commit 6104f0d4091c260ce9352f9155f7e9b725eab012. The fix will be included in TensorFlow 2.10.0 and will also be applied to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-36015: TensorFlow is an open source platform for machine learning. When `RangeSize` receives values that do not fit into an `in

Summary: TensorFlow (an open source platform for machine learning) has a bug where the `RangeSize` function crashes when it receives numbers too large to fit into an `int64_t` (a 64-bit integer data type). This is caused by an integer overflow (when a number becomes too large for its data type to handle).

Solution: Update to TensorFlow 2.10.0, or apply the patch from GitHub commit 37e64539cd29fcfb814c4451152a60f5d107b0f0. Users of TensorFlow 2.9.1, 2.8.1, or 2.7.2 should also update to patched versions of those releases. The source states: 'There are no known workarounds for this issue.'


CVE-2022-36014: TensorFlow is an open source platform for machine learning. When `mlir::tfg::TFOp::nameAttr` receives null type list att

Summary: TensorFlow (an open source machine learning platform) crashes when a specific internal function receives null type list attributes (empty or missing type information). The developers have fixed the bug and will release the patch in upcoming versions of the software.

Solution: The fix will be included in TensorFlow 2.10.0. Patches will also be applied to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Users should update to one of these patched versions when available.


CVE-2022-36013: TensorFlow is an open source platform for machine learning. When `mlir::tfg::GraphDefImporter::ConvertNodeDef` tries to

Summary: TensorFlow (an open source platform for machine learning) crashes when a component called mlir::tfg::GraphDefImporter::ConvertNodeDef tries to convert NodeDefs (data structures that define operations) without an operation name. This is a crash vulnerability that could cause the software to stop working unexpectedly.

Solution: The fix is included in TensorFlow 2.10.0 and will be cherrypicked (a process of applying specific fixes to older versions) into TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Users should update to one of these patched versions. The source notes there are no known workarounds for this issue.


CVE-2022-36012: TensorFlow is an open source platform for machine learning. When `mlir::tfg::ConvertGenericFunctionToFunctionDef` is giv

Summary: TensorFlow (an open source platform for machine learning) crashes when a specific internal function called `mlir::tfg::ConvertGenericFunctionToFunctionDef` receives empty function attributes (data describing how a function should behave). This is a reachable assertion vulnerability, meaning the program encounters an unexpected condition it cannot handle.

Solution: Update to TensorFlow 2.10.0, or apply the patch from GitHub commit ad069af92392efee1418c48ff561fd3070a03d7b. Users of earlier versions should also update to TensorFlow 2.9.1, 2.8.1, or 2.7.2, which will also include this fix.


CVE-2022-36011: TensorFlow is an open source platform for machine learning. When `mlir::tfg::ConvertGenericFunctionToFunctionDef` is giv

Summary: TensorFlow, an open source machine learning platform, has a bug where a specific function crashes with a null dereference (trying to use a memory address that doesn't exist) when given empty function attributes. The issue affects multiple versions of TensorFlow and has no known workarounds.

Solution: The issue was patched in GitHub commit 1cf45b831eeb0cab8655c9c7c5d06ec6f45fc41b. The fix will be included in TensorFlow 2.10.0 and will be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-36005: TensorFlow is an open source platform for machine learning. When `tf.quantization.fake_quant_with_min_max_vars_gradient`

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability in its `tf.quantization.fake_quant_with_min_max_vars_gradient` function where nonscalar (multi-dimensional) input values for `min` or `max` parameters cause a CHECK fail, which is a crash that could enable a denial of service attack (disrupting service availability). The vulnerability affects multiple supported versions of TensorFlow.

Solution: The issue has been patched in GitHub commit f3cf67ac5705f4f04721d15e485e192bb319feed. The fix will be included in TensorFlow 2.10.0, and will also be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. There are no known workarounds.


CVE-2022-36004: TensorFlow is an open source platform for machine learning. When `tf.random.gamma` receives large input shape and rates,

Summary: TensorFlow (an open source machine learning platform) has a bug in its `tf.random.gamma` function where large input values can cause a denial of service attack (making the system crash or stop responding). The developers have fixed the issue and will release it in TensorFlow 2.10.0, along with updates to older supported versions.

Solution: Update to TensorFlow 2.10.0, or if you need an earlier version, update to TensorFlow 2.9.1, TensorFlow 2.8.1, or TensorFlow 2.7.2, as these versions include the patch from GitHub commit 552bfced6ce4809db5f3ca305f60ff80dd40c5a3. The source notes there are no known workarounds for this issue.


CVE-2022-36003: TensorFlow is an open source platform for machine learning. When `RandomPoissonV2` receives large input shape and rates,

Summary: TensorFlow (an open source machine learning platform) has a vulnerability in its `RandomPoissonV2` function where large input values can cause a CHECK fail (a safety check that stops execution), allowing attackers to trigger a denial of service attack (making the system unavailable). The vulnerability affects multiple versions of TensorFlow.

Solution: The issue has been patched in GitHub commit 552bfced6ce4809db5f3ca305f60ff80dd40c5a3. The fix is included in TensorFlow 2.10.0 and will be backported (applied to older versions) in TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. There are no known workarounds for this issue.


CVE-2022-36002: TensorFlow is an open source platform for machine learning. When `Unbatch` receives a nonscalar input `id`, it gives a `

Summary: TensorFlow (an open source machine learning platform) has a vulnerability where the `Unbatch` operation crashes when it receives a nonscalar input `id` (a variable with multiple dimensions rather than a single value), which can be exploited to cause a denial of service attack (making a system unavailable by overwhelming it).

Solution: The issue has been patched in GitHub commit 4419d10d576adefa36b0e0a9425d2569f7c0189f. Users should upgrade to TensorFlow 2.10.0 or apply the patch to supported versions 2.9.1, 2.8.1, and 2.7.2. No workarounds are available.


CVE-2022-36001: TensorFlow is an open source platform for machine learning. When `DrawBoundingBoxes` receives an input `boxes` that is n

Summary: TensorFlow (an open-source machine learning platform) has a vulnerability in its `DrawBoundingBoxes` function where receiving input boxes that aren't float data types causes a CHECK fail, which can be exploited to disable the system through a denial of service attack (overwhelming it with requests). The vulnerability affects multiple versions of TensorFlow.

Solution: The issue has been patched in GitHub commit da0d65cdc1270038e72157ba35bf74b85d9bda11. Users should update to TensorFlow 2.10.0, or for earlier versions, update to TensorFlow 2.9.1, 2.8.1, or 2.7.2, as these patched versions are available for affected and still-supported releases. No workarounds exist.


CVE-2022-36000: TensorFlow is an open source platform for machine learning. When `mlir::tfg::ConvertGenericFunctionToFunctionDef` is giv

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where a specific internal function crashes when it receives empty function attributes, causing a null dereference (an error where the software tries to use a memory location that doesn't exist). This bug affects multiple versions of TensorFlow and has no known workarounds.

Solution: The issue is patched in GitHub commit aed36912609fc07229b4d0a7b44f3f48efc00fd0. The fix will be included in TensorFlow 2.10.0, and has been backported (adapted for older versions) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35999: TensorFlow is an open source platform for machine learning. When `Conv2DBackpropInput` receives empty `out_backprop` inp

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability where a function called `Conv2DBackpropInput` crashes when it receives empty input arrays, allowing attackers to cause a denial of service attack (making the system unavailable). The issue affects both CPU and GPU processing and has been patched in the codebase.

Solution: The fix is included in TensorFlow 2.10.0 and will be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Users should update to one of these patched versions. There are no known workarounds for this issue.


CVE-2022-35998: TensorFlow is an open source platform for machine learning. If `EmptyTensorList` receives an input `element_shape` with

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability in its `EmptyTensorList` function that crashes when given certain inputs, allowing attackers to trigger a denial of service attack (making a service unavailable by overwhelming it). The bug occurs when the function receives an `element_shape` input with more than one dimension.

Solution: The issue is patched in GitHub commit c8ba76d48567aed347508e0552a257641931024d. Users should update to TensorFlow 2.10.0, or for those on earlier versions, update to TensorFlow 2.9.1, 2.8.1, or 2.7.2 (which will include a cherrypicked fix). No workarounds exist for this vulnerability.


CVE-2022-35997: TensorFlow is an open source platform for machine learning. If `tf.sparse.cross` receives an input `separator` that is n

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `tf.sparse.cross` function where passing a non-scalar `separator` input (a parameter that isn't a single value) causes a CHECK fail, which can crash the program in a denial of service attack (making a system unavailable by overwhelming it). The flaw affects multiple versions of TensorFlow.

Solution: The issue has been patched in GitHub commit 83dcb4dbfa094e33db084e97c4d0531a559e0ebf. The fix will be included in TensorFlow 2.10.0 and will be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35996: TensorFlow is an open source platform for machine learning. If `Conv2D` is given empty `input` and the `filter` and `pad

Summary: TensorFlow, an open source machine learning platform, has a bug in its `Conv2D` function (a tool for processing image data) where empty input combined with certain filter and padding settings causes division-by-zero errors. This vulnerability allows attackers to crash the system in a denial of service attack (temporarily making a service unavailable by overwhelming or breaking it).

Solution: The issue has been patched in GitHub commit 611d80db29dd7b0cfb755772c69d60ae5bca05f9. The fix will be included in TensorFlow 2.10.0, and will also be backported (added to older versions still being supported) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. No workarounds are available.


CVE-2022-35995: TensorFlow is an open source platform for machine learning. When `AudioSummaryV2` receives an input `sample_rate` with m

Summary: TensorFlow (an open source machine learning platform) has a vulnerability in its `AudioSummaryV2` function where passing a `sample_rate` input with multiple elements causes a CHECK failure, which can be exploited to trigger a denial of service attack (making the system unavailable by overloading it).

Solution: Update to TensorFlow 2.10.0 or the patched versions 2.9.1, 2.8.1, or 2.7.2. The fix is included in GitHub commit bf6b45244992e2ee543c258e519489659c99fb7f. No workarounds are available, so updating is required.


CVE-2022-35994: TensorFlow is an open source platform for machine learning. When `CollectiveGather` receives an scalar input `input`, it

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability where a function called `CollectiveGather` crashes when it receives a scalar input (a single number rather than a list of numbers), allowing attackers to cause a denial of service attack (making the system unavailable). The issue has been fixed and will be released in upcoming versions of TensorFlow.

Solution: The fix is included in TensorFlow 2.10.0. It will also be backported (added to older versions still being supported) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Users should update to one of these patched versions. There are no known workarounds for this issue.


CVE-2022-35993: TensorFlow is an open source platform for machine learning. When `SetSize` receives an input `set_shape` that is not a 1

Summary: TensorFlow has a vulnerability where the `SetSize` function crashes when it receives an input called `set_shape` that is not a 1D tensor (a one-dimensional array of data). An attacker can exploit this crash to launch a denial of service attack (making the system unavailable to legitimate users).

Solution: Update TensorFlow to version 2.10.0 or apply patches to supported versions 2.9.1, 2.8.1, and 2.7.2. The fix is available in GitHub commit cf70b79d2662c0d3c6af74583641e345fc939467.


CVE-2022-35992: TensorFlow is an open source platform for machine learning. When `TensorListFromTensor` receives an `element_shape` of a

Summary: TensorFlow (an open source machine learning platform) has a bug in the `TensorListFromTensor` function where certain inputs cause a CHECK failure that can be exploited to crash the system. This vulnerability affects multiple versions of TensorFlow and has no known workarounds.

Solution: Update to TensorFlow 2.10.0, or apply the patch from GitHub commit 3db59a042a38f4338aa207922fa2f476e000a6ee. For users on older supported versions, updates are also available for TensorFlow 2.9.1, 2.8.1, and 2.7.2.


CVE-2022-35991: TensorFlow is an open source platform for machine learning. When `TensorListScatter` and `TensorListScatterV2` receive a

Summary: TensorFlow, an open-source machine learning platform, has a vulnerability where two functions (`TensorListScatter` and `TensorListScatterV2`) crash when given certain types of input, allowing attackers to cause a denial of service attack (making the system unavailable). The issue has been fixed and will be released in upcoming versions.

Solution: The issue has been patched in GitHub commit bb03fdf4aae944ab2e4b35c7daa051068a8b7f61. The fix will be included in TensorFlow 2.10.0, and will also be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-36026: TensorFlow is an open source platform for machine learning. If `QuantizeAndDequantizeV3` is given a nonscalar `num_bits`

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability in its `QuantizeAndDequantizeV3` function where passing a nonscalar `num_bits` input tensor (a multi-dimensional array instead of a single value) causes the program to crash, which can be exploited for a denial of service attack (making a service unavailable by overwhelming or crashing it). The issue affects multiple TensorFlow versions.

Solution: The issue has been patched in GitHub commit f3f9cb38ecfe5a8a703f2c4a8fead434ef291713. The fix will be included in TensorFlow 2.10.0 and will be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. No workarounds are available; users should update to these patched versions.


CVE-2022-36019: TensorFlow is an open source platform for machine learning. If `FakeQuantWithMinMaxVarsPerChannel` is given `min` or `ma

Summary: TensorFlow (an open source machine learning platform) has a vulnerability where a specific function called `FakeQuantWithMinMaxVarsPerChannel` crashes when given certain types of input data, allowing attackers to cause a denial of service attack (making the system stop working). The developers have fixed the bug in their code.

Solution: The fix is included in TensorFlow 2.10.0, and will also be patched in earlier versions 2.9.1, 2.8.1, and 2.7.2. Users should update to one of these versions or later.


CVE-2022-36018: TensorFlow is an open source platform for machine learning. If `RaggedTensorToVariant` is given a `rt_nested_splits` lis

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability where a function called `RaggedTensorToVariant` can crash if it receives incorrectly formatted input (tensors with ranks other than one). An attacker could use this crash to launch a denial of service attack (making the system unavailable).

Solution: The issue has been patched in GitHub commit 88f93dfe691563baa4ae1e80ccde2d5c7a143821. The fix is included in TensorFlow 2.10.0 and will also be backported to (applied to earlier versions of) TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35990: TensorFlow is an open source platform for machine learning. When `tf.quantization.fake_quant_with_min_max_vars_per_chann

Summary: A vulnerability in TensorFlow (an open source platform for machine learning) allows attackers to crash the system by sending specially formatted inputs to a specific function called `tf.quantization.fake_quant_with_min_max_vars_per_channel_gradient`, causing a denial of service attack (where a system becomes unavailable). The issue occurs when the function receives input parameters with the wrong structure (rank other than 1).

Solution: The vulnerability was patched in GitHub commit f3cf67ac5705f4f04721d15e485e192bb319feed. The fix is included in TensorFlow 2.10.0 and will also be backported (applied to older versions still receiving updates) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. There are no known workarounds for this issue.


CVE-2022-35989: TensorFlow is an open source platform for machine learning. When `MaxPool` receives a window size input array `ksize` wi

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability in its MaxPool function, which crashes when given a window size array with dimensions larger than the input data, allowing attackers to cause a denial of service attack (making the system unavailable). The issue has been patched and will be fixed in upcoming versions.

Solution: The fix is included in TensorFlow 2.10.0 and will be cherrypicked into TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Users should update to one of these patched versions. No workarounds are available.


CVE-2022-35988: TensorFlow is an open source platform for machine learning. When `tf.linalg.matrix_rank` receives an empty input `a`, th

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability in its `tf.linalg.matrix_rank` function, which crashes when given an empty input. An attacker could exploit this crash to cause a denial of service attack (making the system unavailable by overwhelming it with requests or triggering failures).

Solution: The issue has been patched in GitHub commit c55b476aa0e0bd4ee99d0f3ad18d9d706cd1260a. The fix will be included in TensorFlow 2.10.0 and will be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35987: TensorFlow is an open source platform for machine learning. `DenseBincount` assumes its input tensor `weights` to either

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability in its `DenseBincount` function where it doesn't properly check if the `weights` input tensor (a data structure holding numbers) has the correct shape, allowing attackers to crash the program through a denial of service attack (making a system unavailable by overwhelming it).

Solution: The issue has been patched in GitHub commit bf4c14353c2328636a18bfad1e151052c81d5f43 and will be included in TensorFlow 2.10.0. The fix will also be included in earlier versions: TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35986: TensorFlow is an open source platform for machine learning. If `RaggedBincount` is given an empty input tensor `splits`,

Summary: TensorFlow (an open source machine learning platform) has a bug where the `RaggedBincount` function crashes when given an empty input tensor called `splits`, which can be exploited to launch a denial of service attack (making a service unavailable by overwhelming it). The vulnerability affects multiple versions of the software.

Solution: Update to TensorFlow 2.10.0, or apply the patch from GitHub commit 7a4591fd4f065f4fa903593bc39b2f79530a74b8. If you cannot update to 2.10.0 yet, cherrypicked fixes are also available in TensorFlow 2.9.1, 2.8.1, and 2.7.2. There are no known workarounds for this issue.


CVE-2022-35985: TensorFlow is an open source platform for machine learning. If `LRNGrad` is given an `output_image` input tensor that is

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability in its `LRNGrad` function where passing an incorrectly formatted input tensor (one that is not 4-dimensional) causes the program to crash, allowing attackers to trigger a denial of service attack (making the system unavailable).

Solution: The issue was patched in GitHub commit bd90b3efab4ec958b228cd7cfe9125be1c0cf255. The fix is included in TensorFlow 2.10.0 and will be backported (applied to older supported versions) in TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35984: TensorFlow is an open source platform for machine learning. `ParameterizedTruncatedNormal` assumes `shape` is of type `i

Summary: TensorFlow (an open source machine learning platform) has a bug in the `ParameterizedTruncatedNormal` function where it only accepts one data type (`int32`) for the `shape` parameter, but crashes when given the correct type (`int64`), which could allow an attacker to cause a denial of service (making the software unavailable).

Solution: The issue was patched in GitHub commit 72180be03447a10810edca700cbc9af690dfeb51. The fix will be included in TensorFlow 2.10.0 and will also be backported (added to older versions still receiving updates) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. There are no known workarounds for this issue.


CVE-2022-35983: TensorFlow is an open source platform for machine learning. If `Save` or `SaveSlices` is run over tensors of an unsuppor

Summary: TensorFlow (an open source machine learning platform) has a vulnerability where running certain save operations on data types (formats for storing numbers) that aren't supported causes the program to crash, which could be used for a denial of service attack (making a service unavailable by overwhelming it). The vulnerability affects multiple versions of TensorFlow.

Solution: The fix is included in TensorFlow 2.10.0 and will be backported (added to older versions) in TensorFlow 2.9.1, 2.8.1, and 2.7.2. Users should update to one of these patched versions.


CVE-2022-35982: TensorFlow is an open source platform for machine learning. If `SparseBincount` is given inputs for `indices`, `values`,

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in the `SparseBincount` function where invalid sparse tensor (a compressed way of storing data with mostly empty values) inputs can crash the program, potentially allowing attackers to cause a denial of service attack (making the system unavailable). The issue has been patched and will be fixed in upcoming versions of TensorFlow.

Solution: The fix is included in TensorFlow 2.10.0 and has been cherrypicked (backported) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Users should update to one of these patched versions.


CVE-2022-35981: TensorFlow is an open source platform for machine learning. `FractionalMaxPoolGrad` validates its inputs with `CHECK` fa

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `FractionalMaxPoolGrad` function (a component that processes pooling operations) where it uses CHECK failures instead of returning errors to validate inputs. If someone sends incorrectly sized inputs to this function, they can trigger a denial of service attack (making the system crash or become unresponsive).

Solution: Update TensorFlow to version 2.10.0 or apply the patch from GitHub commit 8741e57d163a079db05a7107a7609af70931def4. The fix is also being included in TensorFlow 2.9.1, 2.8.1, and 2.7.2.


CVE-2022-35979: TensorFlow is an open source platform for machine learning. If `QuantizedRelu` or `QuantizedRelu6` are given nonscalar i

Summary: TensorFlow (an open-source machine learning platform) has a vulnerability where two functions called `QuantizedRelu` and `QuantizedRelu6` crash when given certain types of incorrect inputs for their `min_features` or `max_features` parameters, which attackers could exploit to cause a denial of service attack (making the system unavailable).

Solution: The issue has been patched in GitHub commit 49b3824d83af706df0ad07e4e677d88659756d89. The fix is included in TensorFlow 2.10.0 and will be backported (applied to older versions still being supported) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. No workarounds are available, so users must update to a patched version.


CVE-2022-35974: TensorFlow is an open source platform for machine learning. If `QuantizeDownAndShrinkRange` is given nonscalar inputs fo

Summary: TensorFlow (an open source machine learning platform) has a bug where a function called `QuantizeDownAndShrinkRange` crashes if it receives nonscalar inputs (arrays or objects with multiple values instead of single values) for certain parameters, allowing attackers to cause a denial of service attack (making the system unavailable).

Solution: The issue has been patched in GitHub commit 73ad1815ebcfeb7c051f9c2f7ab5024380ca8613. The fix will be included in TensorFlow 2.10.0, and will also be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35973: TensorFlow is an open source platform for machine learning. If `QuantizedMatMul` is given nonscalar input for: `min_a`,

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `QuantizedMatMul` function that crashes when given certain types of improper input (nonscalar values for min/max parameters), allowing attackers to trigger a denial of service attack (making the system unavailable). The issue has been fixed and will be released in updated versions of TensorFlow.

Solution: The fix is available in GitHub commit aca766ac7693bf29ed0df55ad6bfcc78f35e7f48 and will be included in TensorFlow 2.10.0. Users of TensorFlow 2.9.1, 2.8.1, and 2.7.2 should update to the patched versions of those releases (2.9.1, 2.8.1, and 2.7.2 respectively), as the fix will be cherry-picked into these supported versions.


CVE-2022-35972: TensorFlow is an open source platform for machine learning. If `QuantizedBiasAdd` is given `min_input`, `max_input`, `mi

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `QuantizedBiasAdd` function that crashes when given certain tensor inputs of nonzero rank (multi-dimensional arrays), allowing attackers to launch a denial of service attack (making the system unavailable). The developers have identified and patched the issue.

Solution: The fix is included in TensorFlow 2.10.0 and will also be backported to TensorFlow 2.9.1, 2.8.1, and 2.7.2. Users should update to one of these patched versions.


CVE-2022-35971: TensorFlow is an open source platform for machine learning. If `FakeQuantWithMinMaxVars` is given `min` or `max` tensors

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in the `FakeQuantWithMinMaxVars` function where providing certain types of input tensors (multidimensional arrays of numbers) causes the program to crash, enabling a denial of service attack (making a system unavailable to users). The vulnerability has been identified and fixed in the codebase.

Solution: The fix is included in TensorFlow 2.10.0. Users of earlier versions should update to TensorFlow 2.9.1, TensorFlow 2.8.1, or TensorFlow 2.7.2, which will receive the patch through a cherry-pick (backporting the fix to older versions). No workarounds are available.


CVE-2022-35970: TensorFlow is an open source platform for machine learning. If `QuantizedInstanceNorm` is given `x_min` or `x_max` tenso

Summary: TensorFlow (an open source platform for machine learning) has a bug in the `QuantizedInstanceNorm` function where passing certain tensor inputs (`x_min` or `x_max` with nonzero rank, which are multi-dimensional arrays of numerical data) causes a segfault (a crash from accessing invalid memory), allowing attackers to trigger a denial of service attack (making the system unavailable). The vulnerability was fixed and will be released in TensorFlow 2.10.0, with backported patches for earlier versions.

Solution: Update to TensorFlow 2.10.0 or apply the cherrypick commits to TensorFlow 2.9.1, 2.8.1, or 2.7.2. The fix is available in GitHub commit 785d67a78a1d533759fcd2f5e8d6ef778de849e0. No workarounds exist for this issue.


CVE-2022-35969: TensorFlow is an open source platform for machine learning. The implementation of `Conv2DBackpropInput` requires `input_

Summary: TensorFlow (an open-source machine learning platform) has a bug in the `Conv2DBackpropInput` function where it crashes if the `input_sizes` parameter is not 4-dimensional, allowing attackers to cause a denial of service (making the system unavailable). The issue has been fixed and will be released in upcoming versions.

Solution: The fix is included in TensorFlow 2.10.0. For users on older versions, the patch will be available in TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Update to one of these versions or later.


CVE-2022-35968: TensorFlow is an open source platform for machine learning. The implementation of `AvgPoolGrad` does not fully validate

Summary: TensorFlow, an open source machine learning platform, has a bug in the `AvgPoolGrad` function where it doesn't properly check the input parameter `orig_input_shape`. This incomplete validation causes a CHECK failure (a crash that stops the program), which attackers can exploit to perform a denial of service attack (making the system unavailable to legitimate users).

Solution: The issue has been patched in GitHub commit 3a6ac52664c6c095aa2b114e742b0aa17fdce78f. The fix will be included in TensorFlow 2.10.0, and will be backported (added to older versions still being supported) in TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35967: TensorFlow is an open source platform for machine learning. If `QuantizedAdd` is given `min_input` or `max_input` tensor

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `QuantizedAdd` function (a tool for adding quantized numbers, which are rounded values used to save memory). If this function receives certain tensor inputs of nonzero rank (multi-dimensional arrays), it crashes the program, which can be exploited to cause a denial of service attack (making the system unavailable to legitimate users).

Solution: The issue is patched in GitHub commit 49b3824d83af706df0ad07e4e677d88659756d89. The fix will be included in TensorFlow 2.10.0 and will be backported (applied to older supported versions) as TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35966: TensorFlow is an open source platform for machine learning. If `QuantizedAvgPool` is given `min_input` or `max_input` te

Summary: A bug in TensorFlow (an open source platform for machine learning) called `QuantizedAvgPool` can crash when given certain types of inputs, allowing attackers to launch a denial of service attack (making a system unavailable). The issue has been fixed and will be released in upcoming versions of the software.

Solution: The fix is available in GitHub commit 7cdf9d4d2083b739ec81cfdace546b0c99f50622. The patch will be included in TensorFlow 2.10.0 and will also be applied to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35965: TensorFlow is an open source platform for machine learning. If `LowerBound` or `UpperBound` is given an empty`sorted_inp

Summary: TensorFlow (an open source platform for machine learning) has a bug where the `LowerBound` or `UpperBound` functions crash if given an empty input list, causing a nullptr dereference (trying to access memory that doesn't exist). This crash can be exploited to launch a denial of service attack (making the system unavailable to legitimate users).

Solution: The issue was patched in GitHub commit bce3717eaef4f769019fd18e990464ca4a2efeea. The fix will be included in TensorFlow 2.10.0 and will also be back-ported (applied retroactively) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35964: TensorFlow is an open source platform for machine learning. The implementation of `BlockLSTMGradV2` does not fully valid

Summary: TensorFlow (an open source platform for machine learning) has a bug in the `BlockLSTMGradV2` function that doesn't properly check its inputs, allowing attackers to crash the system with a denial of service attack (causing the program to stop working). The vulnerability affects multiple versions of TensorFlow.

Solution: The issue has been patched in GitHub commit 2a458fc4866505be27c62f81474ecb2b870498fa. The fix will be included in TensorFlow 2.10.0 and will be back-ported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. There are no known workarounds.


CVE-2022-35963: TensorFlow is an open source platform for machine learning. The implementation of `FractionalAvgPoolGrad` does not fully

Summary: A bug in TensorFlow (an open source machine learning platform) within a function called `FractionalAvgPoolGrad` doesn't properly check its input data, causing an overflow (when a number becomes too large for the program to handle) that crashes the program and can be exploited to launch a denial of service attack (making a service unavailable to users).

Solution: The issue has been patched in GitHub commit 03a659d7be9a1154fdf5eeac221e5950fec07dad. The fix will be included in TensorFlow 2.10.0 and will also be applied to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35960: TensorFlow is an open source platform for machine learning. In `core/kernels/list_kernels.cc's TensorListReserve`, `num_

Summary: TensorFlow (an open source machine learning platform) has a bug in its TensorListReserve function where it assumes `num_elements` is a tensor with only one value, but crashes if given multiple values. This causes the function to fail when users try to use `tf.raw_ops.TensorListReserve` with improperly sized input.

Solution: The issue has been patched in GitHub commit b5f6fbfba76576202b72119897561e3bd4f179c7. The fix is included in TensorFlow 2.10.0, and will also be released in TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35959: TensorFlow is an open source platform for machine learning. The implementation of `AvgPool3DGradOp` does not fully valid

Summary: TensorFlow (an open source machine learning platform) has a bug in `AvgPool3DGradOp` (a function that calculates gradients for 3D average pooling operations) where it doesn't properly check the `orig_input_shape` input value. This causes an overflow (when a number gets too large for its container) that crashes the system with a CHECK failure, allowing attackers to perform a denial of service attack (making the system unavailable).

Solution: The issue was patched in GitHub commit 9178ac9d6389bdc54638ab913ea0e419234d14eb. The fix is included in TensorFlow 2.10.0 and will be backported (adapted for older versions) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35952: TensorFlow is an open source platform for machine learning. The `UnbatchGradOp` function takes an argument `id` that is

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

Solution: The issue was patched in GitHub commit 5f945fc6409a3c1e90d6970c9292f805f6e6ddf2. The fix will be included in TensorFlow 2.10.0 and will also be backported to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35941: TensorFlow is an open source platform for machine learning. The `AvgPoolOp` function takes an argument `ksize` that must

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

Solution: Update to TensorFlow 2.10.0 or apply the patch from GitHub commit 3a6ac52664c6c095aa2b114e742b0aa17fdce78f. If you are using TensorFlow 2.9.1, 2.8.1, or 2.7.2, updates including the fix will be released for these versions as well.


CVE-2022-35940: TensorFlow is an open source platform for machine learning. The `RaggedRangOp` function takes an argument `limits` that

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

Solution: The issue has been patched in GitHub commit 37cefa91bee4eace55715eeef43720b958a01192. The fix will be included in TensorFlow 2.10.0, and will also be applied to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2.


CVE-2022-35939: TensorFlow is an open source platform for machine learning. The `ScatterNd` function takes an input argument that determ

Summary: TensorFlow's `ScatterNd` function (a tool that places values into specific positions of an output array) has a bug where invalid input indices can write data to the wrong location or crash the program. The vulnerability affects multiple versions of TensorFlow.

Solution: The issue is patched in GitHub commit b4d4b4cb019bd7240a52daa4ba61e3cc814f0384. The fix will be included in TensorFlow 2.10.0 and will be backported (applied to older versions still being supported) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. The source notes there are no known workarounds.


CVE-2022-35938: TensorFlow is an open source platform for machine learning. The `GatherNd` function takes arguments that determine the s

Summary: A bug in TensorFlow (an open source platform for machine learning) exists in the `GatherNd` function, which retrieves values from arrays using index arrays. When input sizes are greater than or equal to output sizes, the function tries to read memory outside its allowed bounds (out-of-bounds memory read), causing errors or system crashes. The vulnerability affects multiple recent versions of TensorFlow.

Solution: The fix has been patched in GitHub commit 4142e47e9e31db481781b955ed3ff807a781b494 and will be included in TensorFlow 2.10.0. The fix will also be backported (applied to older versions still being supported) to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. Users should update to these patched versions.


CVE-2022-35937: TensorFlow is an open source platform for machine learning. The `GatherNd` function takes arguments that determine the s

Summary: TensorFlow's `GatherNd` function (a tool that retrieves values from arrays based on index locations) has a vulnerability where it can read memory it shouldn't access if certain input sizes are too large. This happens because the function doesn't properly check if inputs exceed the expected output sizes, potentially exposing sensitive data or crashing the system.

Solution: The fix will be included in TensorFlow 2.10.0. Patched versions will also be available in TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2. The source notes there are no known workarounds for this issue.


CVE-2022-35935: TensorFlow is an open source platform for machine learning. The implementation of SobolSampleOp is vulnerable to a denia

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

Solution: The fix is included in TensorFlow 2.10.0. The patch will also be applied to TensorFlow 2.9.1, TensorFlow 2.8.1, and TensorFlow 2.7.2, which are still supported. Users should update to one of these patched versions. No workarounds are available until an update is applied.


CVE-2022-35934: TensorFlow is an open source platform for machine learning. The implementation of tf.reshape op in TensorFlow is vulnera

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

Solution: Update to TensorFlow 2.10.0, or apply the cherrypick to versions 2.9.1, 2.8.1, or 2.7.2 (the patched versions for users on older supported releases). The fix is included in GitHub commit 61f0f9b94df8c0411f0ad0ecc2fec2d3f3c33555. There are no known workarounds for this issue.


Malicious Python Packages and Code Execution via pip download

Summary: Running pip download (a Python command that downloads packages without installing them) can execute malicious code on your computer due to a design flaw, even though many people assume only pip install poses a security risk. This vulnerability allows attackers to run arbitrary code (commands of their choice) simply by downloading a compromised package.

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


Machine Learning Attack Series: Backdooring Pickle Files

Summary: Pickle files (Python's serialization format for saving objects) can be backdoored because they execute code through opcodes (instructions that control a virtual machine). Attackers can inject malicious commands into pickle files using tools like fickling, and when someone loads the file, the hidden code runs without interrupting the program's normal function. This is especially dangerous in shared environments like Google Colab, where an infected pickle file could give attackers access to a user's connected Google Drive.

Solution: The source mentions fickling, a tool by Trail of Bits that can both inject code into pickle files and check them for backdoors using two built-in safety features: '--check-safety' (which checks for malicious opcodes) and '--trace' (which shows the various opcodes). The source also recommends: "only ever open pickle files that you created or trust."

Trail of Bits
StyleGAN2-ADA
Google Colab
Husky AI


CVE-2022-35918: Streamlit is a data oriented application development framework for python. Users hosting Streamlit app(s) that use custo

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

Solution: Upgrade to Streamlit version 1.11.1 or later. The source explicitly states, 'This issue has been resolved in version 1.11.1. Users are advised to upgrade.' No workarounds are available.


CVE-2020-25459: An issue was discovered in function sync_tree in hetero_decision_tree_guest.py in WeBank FATE (Federated AI Technology E

Summary: CVE-2020-25459 is a vulnerability in WeBank FATE (Federated AI Technology Enabler, a system for training machine learning models across multiple parties) versions 0.1 through 1.4.2 that allows attackers to read sensitive information during the training process. The issue exists in a function called sync_tree in the hetero_decision_tree_guest.py file, which means attackers could access private data while the model is being trained.


CVE-2022-29216: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, TensorFlow

Summary: TensorFlow's `saved_model_cli` tool (a utility for working with saved machine learning models) had a code injection vulnerability in versions before 2.9.0, 2.8.1, 2.7.2, and 2.6.4, which could allow an attacker to open a reverse shell (a backdoor connection giving remote control of a system). The vulnerability existed because the tool used `eval` (a function that executes text as code) on user input for compatibility with older test cases, but since the tool requires manual operation, the practical risk was limited.

Solution: Update TensorFlow to version 2.9.0, 2.8.1, 2.7.2, or 2.6.4 or later. The maintainers removed the `safe=False` argument, so all parsing is now done without calling `eval`.


CVE-2022-29213: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the `tf.co

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

Solution: Update TensorFlow to one of the patched versions: 2.9.0, 2.8.1, 2.7.2, or 2.6.4.


CVE-2022-29212: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, certain TF

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

Solution: Update to TensorFlow versions 2.9.0, 2.8.1, 2.7.2, or 2.6.4, which contain a patch for this issue.


CVE-2022-29211: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

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


CVE-2022-29210: TensorFlow is an open source platform for machine learning. In version 2.8.0, the `TensorKey` hash function used total e

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

Solution: This issue is patched in TensorFlow versions 2.9.0 and 2.8.1.


CVE-2022-29209: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the macros

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

Solution: Update TensorFlow to version 2.9.0, 2.8.1, 2.7.2, or 2.6.4 or later, as these versions contain a patch for this issue.


CVE-2022-29208: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow, an open source platform for machine learning, has a vulnerability in the `tf.raw_ops.EditDistance` function where incomplete validation allows users to pass negative values that cause a segmentation fault (a program crash from accessing invalid memory). An attacker could exploit this by crafting input that produces negative array indices, allowing writes before the intended array location and potentially crashing the system.


CVE-2022-29206: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

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

Solution: Update TensorFlow to versions 2.9.0, 2.8.1, 2.7.2, or 2.6.4 or later, which contain a patch for this issue.


CVE-2022-29205: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, there is a

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

Solution: Update to TensorFlow version 2.9.0, 2.8.1, 2.7.2, or 2.6.4 or later, which contain a patch for this issue.


CVE-2022-29204: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

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


CVE-2022-29203: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: CVE-2022-29203 is a vulnerability in TensorFlow (an open source platform for machine learning) where a function called `tf.raw_ops.SpaceToBatchND` has an integer overflow bug (a situation where a calculation produces a number too large for the system to handle). This overflow causes a denial of service (making the system crash or become unavailable) when the buggy code tries to allocate memory for output data.

Solution: Update TensorFlow to version 2.9.0, 2.8.1, 2.7.2, or 2.6.4, which contain patches for this issue.


CVE-2022-29202: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: A vulnerability in TensorFlow (an open source platform for machine learning) versions prior to 2.9.0, 2.8.1, 2.7.2, and 2.6.4 allows attackers to cause a denial of service (making a system unavailable by consuming all available memory) by exploiting the `tf.ragged.constant` function, which does not properly check its input arguments. The vulnerability exists because of improper input validation (checking that data meets expected requirements before using it).

Solution: Update TensorFlow to version 2.9.0, 2.8.1, 2.7.2, or 2.6.4 or later. The source states: 'Versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4 contain a patch for this issue.'


CVE-2022-29201: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow, an open source machine learning platform, had a vulnerability in its `tf.raw_ops.QuantizedConv2D` function (a tool for processing images with reduced precision) before versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4 where it did not properly check input arguments, causing references to point to nullptr (an invalid memory location). This flaw was fixed in the mentioned versions.


CVE-2022-29207: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, multiple T

Summary: TensorFlow (an open source platform for machine learning) has a vulnerability in versions before 2.9.0, 2.8.1, 2.7.2, and 2.6.4 where certain operations fail when given an invalid resource handle (a reference to data or tools the program needs). In eager mode (where TensorFlow executes code immediately rather than preparing a plan first), this can cause a reference to point to a null pointer (a memory location that doesn't exist), leading to undefined behavior and potential crashes or errors. Graph mode had safeguards that prevented this issue.


CVE-2022-29200: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow (an open-source machine learning platform) has a bug in the `tf.raw_ops.LSTMBlockCell` function where it doesn't properly check that input arguments have the correct structure. An attacker can exploit this to cause a denial of service attack (crashing the program), because the code fails when trying to access elements inside incorrectly-shaped inputs.

Solution: Update TensorFlow to version 2.9.0, 2.8.1, 2.7.2, or 2.6.4 or later, which contain a patch for this issue.


CVE-2022-29199: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow (an open source machine learning platform) had a bug in the `tf.raw_ops.LoadAndRemapMatrix` function that didn't properly check its input arguments, specifically whether the `initializing_values` parameter was valid. This missing validation could cause the program to crash (denial of service, a type of attack that makes a service unavailable), even though the attacker doesn't gain control of the system.

Solution: Update TensorFlow to version 2.9.0, 2.8.1, 2.7.2, or 2.6.4 or later, which contain patches for this issue.


CVE-2022-29198: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in a function called `tf.raw_ops.SparseTensorToCSRSparseMatrix` that doesn't properly check its inputs before processing them. This missing validation allows attackers to cause a denial of service attack (making the system crash or become unavailable) by sending specially crafted data that violates the expected format for sparse tensors (data structures that store mostly empty values efficiently).


CVE-2022-29197: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: A bug in TensorFlow (an open source machine learning platform) versions before 2.9.0, 2.8.1, 2.7.2, and 2.6.4 fails to validate input arguments to the `tf.raw_ops.UnsortedSegmentJoin` function, allowing attackers to trigger a denial of service attack (making the system crash or become unavailable). The vulnerability stems from the code assuming `num_segments` is a scalar (a single value) without checking this assumption first.


CVE-2022-29196: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow, an open source machine learning platform, has a vulnerability in its `tf.raw_ops.Conv3DBackpropFilterV2` function (a tool for training neural networks) that fails to properly check its input arguments before processing them. This missing validation allows attackers to crash the program with a denial of service attack (making it unavailable to legitimate users).

Solution: Update to TensorFlow versions 2.9.0, 2.8.1, 2.7.2, or 2.6.4, which contain patches that fix this input validation issue.


CVE-2022-29195: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow (an open source platform for machine learning) versions before 2.9.0, 2.8.1, 2.7.2, and 2.6.4 have a bug in the `tf.raw_ops.StagePeek` function that fails to check whether the `index` input is a scalar (a single number), allowing attackers to crash the system. This is a denial of service attack (making a service unavailable by overwhelming or breaking it).


CVE-2022-29193: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow, an open source platform for machine learning, had a vulnerability in the `tf.raw_ops.TensorSummaryV2` function that failed to properly validate (check the correctness of) input arguments before using them. This flaw could be exploited to cause a denial of service attack (making the system crash or become unavailable) by triggering a CHECK-failure (a forced program halt when an expected condition is not met).


CVE-2022-29194: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow, an open source machine learning platform, had a vulnerability in its `tf.raw_ops.DeleteSessionTensor` function (a specific operation within TensorFlow) that failed to properly check its input arguments before using them. This flaw could be exploited to cause a denial of service attack (making a system crash or become unavailable by sending specially crafted requests).


CVE-2022-29192: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow, an open source machine learning platform, had a vulnerability in the `tf.raw_ops.QuantizeAndDequantizeV4Grad` function where it did not fully validate input arguments before processing them. This bug could crash the system (a denial of service attack, where an attacker makes a service unavailable) in versions before 2.9.0, 2.8.1, 2.7.2, and 2.6.4.

Solution: Update TensorFlow to one of the patched versions: 2.9.0, 2.8.1, 2.7.2, or 2.6.4. A patch is available at https://github.com/tensorflow/tensorflow/commit/098e7762d909bac47ce1dbabe6dfd06294cb9d58.


CVE-2022-29191: TensorFlow is an open source platform for machine learning. Prior to versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4, the implem

Summary: TensorFlow, an open source machine learning platform, had a vulnerability in its `tf.raw_ops.GetSessionTensor` function (a command for retrieving tensor data from a session) where it did not properly validate input arguments, allowing attackers to crash the system through a denial of service attack (making software unavailable by overwhelming or breaking it). The vulnerability was fixed in TensorFlow versions 2.9.0, 2.8.1, 2.7.2, and 2.6.4.


CVE-2022-21426: Vulnerability in the Oracle Java SE, Oracle GraalVM Enterprise Edition product of Oracle Java SE (component: JAXP). Supp

Summary: A vulnerability in Oracle Java SE and Oracle GraalVM Enterprise Edition (a high-performance Java runtime) in the JAXP component (Java API for XML Processing, which handles XML data) allows an unauthenticated attacker to partially disable these systems over a network. The vulnerability affects specific versions of Java and can be exploited through untrusted code in web applications or through web services that supply data to the vulnerable APIs, with a severity rating of 5.3 out of 10.

Oracle Java SE
Oracle GraalVM Enterprise Edition