Intel Optimization For Tensorflow vulnerabilities

CVE-2022-23565 [HIGH] CWE-617 `CHECK`-failures in Tensorflow `CHECK`-failures in Tensorflow ### Impact An attacker can trigger denial of service via assertion failure by altering a `SavedModel` on disk such that `AttrDef`s of some operation are duplicated. ### Patches We have patched the issue in GitHub commit [c2b31ff2d3151acb230edc3f5b1832d2c713a9e0](https://github.com/tensorflow/tensorflow/commit/c2b31ff2d3151acb230edc3f5b1832d2c713a9e0). The fix will be included in TensorFlow 2.8.0. We wi

CVE-2021-41211 [HIGH] CWE-125 Heap OOB in shape inference for `QuantizeV2` Heap OOB in shape inference for `QuantizeV2` ### Impact The [shape inference code for `QuantizeV2`](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/framework/common_shape_fns.cc#L2509-L2530) can trigger a read outside of bounds of heap allocated array: ```python import tensorflow as tf @tf.function def test(): data=tf.raw_ops.QuantizeV2( input=[1.0,1.0], min_range=

CVE-2021-41226 [MEDIUM] CWE-125 Heap OOB in `SparseBinCount` Heap OOB in `SparseBinCount` ### Impact The [implementation](https://github.com/tensorflow/tensorflow/blob/e71b86d47f8bc1816bf54d7bddc4170e47670b97/tensorflow/core/kernels/bincount_op.cc#L353-L417) of `SparseBinCount` is vulnerable to a heap OOB: ```python import tensorflow as tf tf.raw_ops.SparseBincount( indices=[[0],[1],[2]] values=[0,-10000000] dense_shape=[1,1] size=[1] weights=[3,2,1] binary_output=False) ``` This is because

CVE-2021-29560 [LOW] CWE-125 Heap buffer overflow in `RaggedTensorToTensor` Heap buffer overflow in `RaggedTensorToTensor` ### Impact An attacker can cause a heap buffer overflow in `tf.raw_ops.RaggedTensorToTensor`: ```python import tensorflow as tf shape = tf.constant([10, 10], shape=[2], dtype=tf.int64) values = tf.constant(0, shape=[1], dtype=tf.int64) default_value = tf.constant(0, dtype=tf.int64) l = [849, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

CVE-2022-21739 [HIGH] CWE-476 Null pointer dereference in TensorFlow Null pointer dereference in TensorFlow ### Impact The [implementation of `QuantizedMaxPool`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/quantized_pooling_ops.cc#L114-L130) has an undefined behavior where user controlled inputs can trigger a reference binding to null pointer. ```python import tensorflow as tf tf.raw_ops.QuantizedMaxPool( input = tf.constant([

CVE-2018-7577 [HIGH] CWE-20 Improper Input Validation in Google TensorFlow Improper Input Validation in Google TensorFlow Memcpy parameter overlap in Google Snappy library 1.1.4, as used in Google TensorFlow before 1.7.1, could result in a crash or read from other parts of process memory.

CVE-2022-29208 [HIGH] CWE-787 Segfault and OOB write due to incomplete validation in `EditDistance` in TensorFlow Segfault and OOB write due to incomplete validation in `EditDistance` in TensorFlow ### Impact The implementation of [`tf.raw_ops.EditDistance`]() has incomplete validation. Users can pass negative values to cause a segmentation fault based denial of service: ```python import tensorflow as tf hypothesis_indices = tf.constant(-1250999896764, shape=[3, 3], dtype=tf.int64) hypothesis

CVE-2021-41223 [MEDIUM] CWE-125 Heap OOB in `FusedBatchNorm` kernels Heap OOB in `FusedBatchNorm` kernels ### Impact The [implementation](https://github.com/tensorflow/tensorflow/blob/e71b86d47f8bc1816bf54d7bddc4170e47670b97/tensorflow/core/kernels/fused_batch_norm_op.cc#L1292) of `FusedBatchNorm` kernels is vulnerable to a heap OOB: ```python import tensorflow as tf tf.raw_ops.FusedBatchNormGrad( y_backprop=tf.constant([i for i in range(9)],shape=(1,1,3,3),dtype=tf.float32) x=tf.constant([i

CVE-2021-29590 [LOW] CWE-125 Heap OOB read in TFLite's implementation of `Minimum` or `Maximum` Heap OOB read in TFLite's implementation of `Minimum` or `Maximum` ### Impact The implementations of the `Minimum` and `Maximum` TFLite operators can be used to read data outside of bounds of heap allocated objects, if any of the two input tensor arguments are empty. This is because [the broadcasting implementation](https://github.com/tensorflow/tensorflow/blob/0d45ea1ca641b21b73bcf9c00e0179cda284e7

CVE-2021-29553 [LOW] CWE-125 Heap OOB in `QuantizeAndDequantizeV3` Heap OOB in `QuantizeAndDequantizeV3` ### Impact An attacker can read data outside of bounds of heap allocated buffer in `tf.raw_ops.QuantizeAndDequantizeV3`: ```python import tensorflow as tf tf.raw_ops.QuantizeAndDequantizeV3( input=[2.5,2.5], input_min=[0,0], input_max=[1,1], num_bits=[30], signed_input=False, range_given=False, narrow_range=False, axis=3) ``` This is because the [implementation](https://github.com/tensorf

CVE-2021-29532 [LOW] CWE-125 Heap out of bounds read in `RaggedCross` Heap out of bounds read in `RaggedCross` ### Impact An attacker can force accesses outside the bounds of heap allocated arrays by passing in invalid tensor values to `tf.raw_ops.RaggedCross`: ```python import tensorflow as tf ragged_values = [] ragged_row_splits = [] sparse_indices = [] sparse_values = [] sparse_shape = [] dense_inputs_elem = tf.constant([], shape=[92, 0], dtype=tf.int64) dense_inputs = [dense_inputs_elem]

CVE-2021-37664 [HIGH] CWE-125 Heap OOB in boosted trees Heap OOB in boosted trees ### Impact An attacker can read from outside of bounds of heap allocated data by sending specially crafted illegal arguments to `BoostedTreesSparseCalculateBestFeatureSplit`: ```python import tensorflow as tf tf.raw_ops.BoostedTreesSparseCalculateBestFeatureSplit( node_id_range=[0,10], stats_summary_indices=[[1, 2, 3, 0x1000000]], stats_summary_values=[1.0], stats_summary_shape=[1,1,1,1], l1=l2=[1.0], tree_compl

CVE-2021-37654 [HIGH] CWE-125 Heap OOB and CHECK fail in `ResourceGather` Heap OOB and CHECK fail in `ResourceGather` ### Impact An attacker can trigger a crash via a `CHECK`-fail in debug builds of TensorFlow using `tf.raw_ops.ResourceGather` or a read from outside the bounds of heap allocated data in the same API in a release build: ```python import tensorflow as tf tensor = tf.constant(value=[[1,2],[3,4],[5,6]],shape=(3,2),dtype=tf.uint32) v = tf.Variable(tensor) tf.raw_ops.ResourceGather(

CVE-2021-37635 [HIGH] CWE-125 Heap out of bounds access in sparse reduction operations Heap out of bounds access in sparse reduction operations ### Impact The implementation of sparse reduction operations in TensorFlow can trigger accesses outside of bounds of heap allocated data: ```python import tensorflow as tf x = tf.SparseTensor( indices=[[773, 773, 773], [773, 773, 773]], values=[1, 1], dense_shape=[337, 337, 337]) tf.sparse.reduce_sum(x, 1) ``` The [implementation](https://github.com/

CVE-2021-29570 [LOW] CWE-125 Heap out of bounds read in `MaxPoolGradWithArgmax` Heap out of bounds read in `MaxPoolGradWithArgmax` ### Impact The implementation of `tf.raw_ops.MaxPoolGradWithArgmax` can cause reads outside of bounds of heap allocated data if attacker supplies specially crafted inputs: ```python import tensorflow as tf input = tf.constant([10.0, 10.0, 10.0], shape=[1, 1, 3, 1], dtype=tf.float32) grad = tf.constant([10.0, 10.0, 10.0, 10.0], shape=[1, 1, 1, 4], dtype=tf.float32)

CVE-2022-23563 [HIGH] CWE-367 Insecure temporary file in Tensorflow Insecure temporary file in Tensorflow ### Impact In multiple places, TensorFlow uses `tempfile.mktemp` to create temporary files. While this is acceptable in testing, in utilities and libraries it is dangerous as a different process can create the file between the check for the filename in `mktemp` and the actual creation of the file by a subsequent operation (a TOC/TOU type of weakness). In several instances, TensorFlow was s

CVE-2020-15200 [HIGH] CWE-122 Segfault in Tensorflow Segfault in Tensorflow ### Impact The `RaggedCountSparseOutput` implementation does not validate that the input arguments form a valid ragged tensor. In particular, there is no validation that the values in the `splits` tensor generate a valid partitioning of the `values` tensor. Thus, the [following code](https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/core/kernels/count_ops.cc#L248-L265 ) se

CVE-2018-21233 [HIGH] CWE-125 Out-of-bounds read in TensorFlow possibly causing disclosure of the contents of process memory. Out-of-bounds read in TensorFlow possibly causing disclosure of the contents of process memory. TensorFlow before 1.7.0 has an integer overflow that causes an out-of-bounds read, possibly causing disclosure of the contents of process memory. This occurs in the DecodeBmp feature of the BMP decoder in `core/kernels/decode_bmp_op.cc`.

CVE-2021-29613 [MEDIUM] CWE-125 Incomplete validation in `tf.raw_ops.CTCLoss` Incomplete validation in `tf.raw_ops.CTCLoss` ### Impact Incomplete validation in `tf.raw_ops.CTCLoss` allows an attacker to trigger an OOB read from heap: ```python import tensorflow as tf inputs = tf.constant([], shape=[10, 16, 0], dtype=tf.float32) labels_indices = tf.constant([], shape=[8, 0], dtype=tf.int64) labels_values = tf.constant([-100] * 8, shape=[8], dtype=tf.int32) sequence_length = tf.constant([-100]

CVE-2021-41212 [HIGH] CWE-125 Heap OOB read in `tf.ragged.cross` Heap OOB read in `tf.ragged.cross` ### Impact The [shape inference code for `tf.ragged.cross`](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/ops/ragged_array_ops.cc#L64) can trigger a read outside of bounds of heap allocated array: ```python import tensorflow as tf @tf.function def test(): y = tf.raw_ops.RaggedCross(ragged_values=[], ragged_row_splits=[], sparse_indices=[[