Intel Optimization For Tensorflow vulnerabilities

CVE-2023-25664 [HIGH] CWE-120 TensorFlow has Heap-buffer-overflow in AvgPoolGrad TensorFlow has Heap-buffer-overflow in AvgPoolGrad ### Impact ```python import os os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0' import tensorflow as tf print(tf.__version__) with tf.device("CPU"): ksize = [1, 40, 128, 1] strides = [1, 128, 128, 30] padding = "SAME" data_format = "NHWC" orig_input_shape = [11, 9, 78, 9] grad = tf.saturate_cast(tf.random.uniform([16, 16, 16, 16], minval=-128, maxval=129, dtype=tf.int64),

CVE-2022-23587 [HIGH] CWE-190 Integer overflow in TensorFlow Integer overflow in TensorFlow ### Impact Under certain scenarios, Grappler component of TensorFlow is vulnerable to an integer overflow during [cost estimation for crop and resize](https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/grappler/costs/op_level_cost_estimator.cc#L2621-L2689). Since the cropping parameters are user controlled, a malicious person can trigger undefined behav

CVE-2022-21726 [HIGH] CWE-125 Out of bounds read in Tensorflow Out of bounds read in Tensorflow ### Impact The [implementation of `Dequantize`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/dequantize_op.cc#L92-L153) does not fully validate the value of `axis` and can result in heap OOB accesses: ```python import tensorflow as tf @tf.function def test(): y = tf.raw_ops.Dequantize( input=tf.constant([1,1],dtype=tf.qint32), min_ra

CVE-2022-21740 [HIGH] CWE-120 Heap overflow in Tensorflow Heap overflow in Tensorflow ### Impact The [implementation of `SparseCountSparseOutput`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/count_ops.cc#L168-L273) is vulnerable to a heap overflow: ```python import tensorflow as tf import numpy as np tf.raw_ops.SparseCountSparseOutput( indices=[[-1,-1]], values=[2], dense_shape=[1, 1], weights=[1], binary_output=True, minlengt

CVE-2022-23573 [HIGH] CWE-908 Uninitialized variable access in Tensorflow Uninitialized variable access in Tensorflow ### Impact The [implementation of `AssignOp`](https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/kernels/assign_op.h#L30-L143) can result in copying unitialized data to a new tensor. This later results in undefined behavior. The implementation has a check that the left hand side of the assignment is initialized (to minimize nu

CVE-2022-23562 [HIGH] CWE-190 Integer overflow in Tensorflow Integer overflow in Tensorflow ### Impact The implementation of `Range` suffers from integer overflows. These can trigger undefined behavior or, in some scenarios, extremely large allocations. ### Patches We have patched the issue in GitHub commit [f0147751fd5d2ff23251149ebad9af9f03010732](https://github.com/tensorflow/tensorflow/commit/f0147751fd5d2ff23251149ebad9af9f03010732) (merging [#51733](https://github.com/tensorflow/tensorfl

CVE-2021-41208 [CRITICAL] CWE-476 Incomplete validation in boosted trees code Incomplete validation in boosted trees code ### Impact The [code for boosted trees in TensorFlow](https://github.com/tensorflow/tensorflow/blob/e0b6e58c328059829c3eb968136f17aa72b6c876/tensorflow/core/kernels/boosted_trees/stats_ops.cc) is still missing validation. As a result, attackers can trigger denial of service (via dereferencing `nullptr`s or via `CHECK`-failures) as well as abuse undefined behavior (binding re

[HIGH] CWE-354 Improper Validation of Integrity Check Value in TensorFlow Improper Validation of Integrity Check Value in TensorFlow ### Impact The implementation of [`tf.sparse.split`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/sparse_split_op.cc#L26-L102) does not fully validate the input arguments. Hence, a malicious user can trigger a denial of service via a segfault or a heap OOB read: ```python import tensorflow as tf da

CVE-2022-21728 [HIGH] CWE-125 Out of bounds read in Tensorflow Out of bounds read in Tensorflow ### Impact The [implementation of shape inference for `ReverseSequence`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/ops/array_ops.cc#L1636-L1671) does not fully validate the value of `batch_dim` and can result in a heap OOB read: ```python import tensorflow as tf @tf.function def test(): y = tf.raw_ops.ReverseSequence( input = ['aaa','bbb'

CVE-2019-16778 [LOW] CWE-122 Heap buffer overflow in `UnsortedSegmentSum` in TensorFlow Heap buffer overflow in `UnsortedSegmentSum` in TensorFlow ### Impact A heap buffer overflow in `UnsortedSegmentSum` can be produced when the `Index` template argument is `int32`. In this case `data_size` and `num_segments` fields are truncated from `int64` to `int32` and can produce negative numbers, resulting in accessing out of bounds heap memory. This is unlikely to be exploitable and was detected and

CVE-2018-7575 [CRITICAL] CWE-190 Integer Overflow or Wraparound in Google TensorFlow Integer Overflow or Wraparound in Google TensorFlow ### Issue Description Google TensorFlow 1.7.x and earlier is affected by a Buffer Overflow vulnerability. The type of exploitation is context-dependent. The block size in meta file might contain a large int64 value which causes an integer overflow upon addition. Subsequent code using n as index may cause an out-of-bounds read. ### Impact A maliciously crafted

CVE-2022-35937 [HIGH] CWE-125 TensorFlow vulnerable to OOB read in `Gather_nd` in TF Lite TensorFlow vulnerable to OOB read in `Gather_nd` in TF Lite ### Impact The [`GatherNd`](https://github.com/tensorflow/tensorflow/blob/f463040eb3997e42e60a2ffc6dc72de7ef11dbb4/tensorflow/lite/kernels/gather_nd.cc#L105-L111) function takes arguments that determine the sizes of inputs and outputs. If the inputs given are greater than or equal to the sizes of the outputs, an out-of-bounds memory read is trigge

CVE-2022-41902 [HIGH] CWE-125 Out of bounds write in grappler in Tensorflow Out of bounds write in grappler in Tensorflow ### Impact The function [MakeGrapplerFunctionItem](https://https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/grappler/utils/functions.cc#L221) takes arguments that determine the sizes of inputs and outputs. If the inputs given are greater than or equal to the sizes of the outputs, an out-of-bounds memory read or a crash is triggered. ### Patches We have p

CVE-2022-41910 [MEDIUM] CWE-125 Heap overflow in `QuantizeAndDequantizeV2` Heap overflow in `QuantizeAndDequantizeV2` ### Impact The function [MakeGrapplerFunctionItem](https://https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/grappler/utils/functions.cc#L221) takes arguments that determine the sizes of inputs and outputs. If the inputs given are greater than or equal to the sizes of the outputs, an out-of-bounds memory read or a crash is triggered. ```python import tensorflo

CVE-2022-41880 [MEDIUM] CWE-125 Tensorflow vulnerable to Out-of-Bounds Read Tensorflow vulnerable to Out-of-Bounds Read ### Impact When the [`BaseCandidateSamplerOp`](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/candidate_sampler_ops.cc) function receives a value in `true_classes` larger than `range_max`, a heap oob vuln occurs. ```python tf.raw_ops.ThreadUnsafeUnigramCandidateSampler( true_classes=[[0x100000,1]], num_true = 2, num_sampled = 2, unique = False, ra

CVE-2021-41228 [MEDIUM] CWE-78 Code injection in `saved_model_cli` Code injection in `saved_model_cli` ### Impact TensorFlow's `saved_model_cli` tool is vulnerable to a code injection as it [calls `eval` on user supplied strings](https://github.com/tensorflow/tensorflow/blob/87462bfac761435a46641ff2f10ad0b6e5414a4b/tensorflow/python/tools/saved_model_cli.py#L524-L550) ```python def preprocess_input_exprs_arg_string(input_exprs_str): ... for input_raw in filter(bool, input_exprs_str.split(';'))

CVE-2023-27506 [HIGH] CWE-92 CVE-2023-27506: Improper buffer restrictions in the Intel(R) Optimization for Tensorflow software before version 2.1 Improper buffer restrictions in the Intel(R) Optimization for Tensorflow software before version 2.12 may allow an authenticated user to potentially enable escalation of privilege via local access.

CVE-2022-21730 [HIGH] CWE-125 Out of bounds read in Tensorflow Out of bounds read in Tensorflow ### Impact The [implementation of `FractionalAvgPoolGrad`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/fractional_avg_pool_op.cc#L209-L360) does not consider cases where the input tensors are invalid allowing an attacker to read from outside of bounds of heap: ```python import tensorflow as tf @tf.function def test(): y = tf.raw_ops

CVE-2023-25673 [HIGH] CWE-697 TensorFlow has Floating Point Exception in TensorListSplit with XLA TensorFlow has Floating Point Exception in TensorListSplit with XLA ### Impact FPE in TensorListSplit with XLA ```python import tensorflow as tf func = tf.raw_ops.TensorListSplit para = {'tensor': [1], 'element_shape': -1, 'lengths': [0]} @tf.function(jit_compile=True) def fuzz_jit(): y = func(**para) return y print(fuzz_jit()) ``` ### Patches We have patched the issue in GitHub commit [728113a

CVE-2023-25659 [HIGH] CWE-125 TensorFlow vulnerable to Out-of-Bounds Read in DynamicStitch TensorFlow vulnerable to Out-of-Bounds Read in DynamicStitch ### Impact If the parameter `indices` for `DynamicStitch` does not match the shape of the parameter `data`, it can trigger an stack OOB read. ```python import tensorflow as tf func = tf.raw_ops.DynamicStitch para={'indices': [[0xdeadbeef], [405], [519], [758], [1015]], 'data': [[110.27793884277344], [120.29475402832031], [157.2418212890625], [1