Intel Optimization For Tensorflow vulnerabilities

CVE-2022-23584 [HIGH] CWE-416 Use after free in `DecodePng` kernel Use after free in `DecodePng` kernel ### Impact A malicious user can cause a use after free behavior when [decoding PNG images](https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/kernels/image/decode_image_op.cc#L339-L346): ```cc if (/* ... error conditions ... */) { png::CommonFreeDecode(&decode); OP_REQUIRES(context, false, errors::InvalidArgument("PNG size too large for int:

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-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-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-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-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-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-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-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-2023-30767 [MEDIUM] CWE-92 CVE-2023-30767: Improper buffer restrictions in Intel(R) Optimization for TensorFlow before version 2.13.0 may allow Improper buffer restrictions in Intel(R) Optimization for TensorFlow before version 2.13.0 may allow an authenticated user to potentially enable escalation of privilege via local access.

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]