Intel Optimization For Tensorflow vulnerabilities

CVE-2020-15211 [MEDIUM] CWE-125 Out of bounds access in tensorflow-lite Out of bounds access in tensorflow-lite ### Impact In TensorFlow Lite, saved models in the flatbuffer format use a double indexing scheme: a model has a set of subgraphs, each subgraph has a set of operators and each operator has a set of input/output tensors. The flatbuffer format uses indices for the tensors, indexing into an array of tensors that is owned by the subgraph. This results in a pattern of double array indexin

CVE-2020-15191 [MEDIUM] CWE-20 Undefined behavior in Tensorflow Undefined behavior in Tensorflow ### Impact If a user passes an invalid argument to `dlpack.to_dlpack` the expected validations will cause variables to bind to `nullptr` while setting a `status` variable to the error condition. However, this `status` argument is not properly checked: https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/c/eager/dlpack.cc#L265-L267 Hence, code following

CVE-2018-7576 [HIGH] CWE-476 Null pointer dereference in TensorFlow leads to exploitation Null pointer dereference in TensorFlow leads to exploitation Google TensorFlow 1.0.0 through 1.5.1 is affected by: Null Pointer Dereference. The type of exploitation is: context-dependent.

CVE-2020-26266 [MEDIUM] CWE-908 Uninitialized memory access in TensorFlow Uninitialized memory access in TensorFlow ### Impact Under certain cases, a saved model can trigger use of uninitialized values during code execution. This is caused by having tensor buffers be filled with the default value of the type but forgetting to [default initialize the quantized floating point types in Eigen](https://github.com/tensorflow/tensorflow/blob/f70160322a579144950dff1537dcbe3c7c09d6f5/third_party/eigen3/

CVE-2021-37685 [MEDIUM] CWE-125 Heap OOB in TFLite Heap OOB in TFLite ### Impact TFLite's [`expand_dims.cc`](https://github.com/tensorflow/tensorflow/blob/149562d49faa709ea80df1d99fc41d005b81082a/tensorflow/lite/kernels/expand_dims.cc#L36-L50) contains a vulnerability which allows reading one element outside of bounds of heap allocated data: ```cc if (axis size; ++i) { if (i data[i] = input_dims.data[i]; } else if (i == axis) { output_dims->data[i] = 1; } else { output_dims->data[i] = input_di

CVE-2021-37670 [MEDIUM] CWE-125 Heap OOB in `UpperBound` and `LowerBound` Heap OOB in `UpperBound` and `LowerBound` ### Impact An attacker can read from outside of bounds of heap allocated data by sending specially crafted illegal arguments to `tf.raw_ops.UpperBound`: ```python import tensorflow as tf tf.raw_ops.UpperBound( sorted_input=[1,2,3], values=tf.constant(value=[[0,0,0],[1,1,1],[2,2,2]],dtype=tf.int64), out_type=tf.int64) ``` The [implementation](https://github.com/tensorflow/tensor

CVE-2021-37674 [HIGH] CWE-1284 Incomplete validation in `MaxPoolGrad` Incomplete validation in `MaxPoolGrad` ### Impact An attacker can trigger a denial of service via a segmentation fault in `tf.raw_ops.MaxPoolGrad` caused by missing validation: ```python import tensorflow as tf tf.raw_ops.MaxPoolGrad( orig_input = tf.constant([], shape=[3, 0, 0, 2], dtype=tf.float32), orig_output = tf.constant([], shape=[3, 0, 0, 2], dtype=tf.float32), grad = tf.constant([], shape=[3, 0, 0, 2], dtype=tf.flo

CVE-2020-15201 [MEDIUM] CWE-122 Heap buffer overflow in Tensorflow Heap buffer overflow 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. Hence, this code is prone to heap buffer overflow: https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/t

CVE-2019-9635 [HIGH] CWE-476 NULL Pointer Dereference in Google TensorFlow NULL Pointer Dereference in Google TensorFlow NULL pointer dereference in Google TensorFlow before 1.12.1 could cause a denial of service via an invalid GIF file.

CVE-2022-29212 [MEDIUM] CWE-20 Core dump when loading TFLite models with quantization in TensorFlow Core dump when loading TFLite models with quantization in TensorFlow ### Impact Certain TFLite models that were created using TFLite model converter would crash when loaded in the TFLite interpreter. The culprit is that during quantization the scale of values could be greater than 1 but code was always assuming sub-unit scaling. Thus, since code was calling [`QuantizeMultiplierSmallerThanOneExp`

CVE-2021-37672 [MEDIUM] CWE-125 Heap OOB in `SdcaOptimizerV2` Heap OOB in `SdcaOptimizerV2` ### Impact An attacker can read from outside of bounds of heap allocated data by sending specially crafted illegal arguments to `tf.raw_ops.SdcaOptimizerV2`: ```python import tensorflow as tf tf.raw_ops.SdcaOptimizerV2( sparse_example_indices=[[1]], sparse_feature_indices=[[1]], sparse_feature_values=[[1.0,2.0]], dense_features=[[1.0]], example_weights=[1.0], example_labels=[], sparse_indices=[1], spar

CVE-2021-41197 [MEDIUM] CWE-190 Crashes due to overflow and `CHECK`-fail in ops with large tensor shapes Crashes due to overflow and `CHECK`-fail in ops with large tensor shapes ### Impact TensorFlow allows tensor to have a large number of dimensions and each dimension can be as large as desired. However, the total number of elements in a tensor must fit within an `int64_t`. If an overflow occurs, `MultiplyWithoutOverflow` would return a negative result. In the majority of TensorFlow codebase t

CVE-2021-41195 [MEDIUM] CWE-190 Crash in `tf.math.segment_*` operations Crash in `tf.math.segment_*` operations ### Impact The implementation of `tf.math.segment_*` operations results in a `CHECK`-fail related abort (and denial of service) if a segment id in `segment_ids` is large. ```python import tensorflow as tf tf.math.segment_max(data=np.ones((1,10,1)), segment_ids=[1676240524292489355]) tf.math.segment_min(data=np.ones((1,10,1)), segment_ids=[1676240524292489355]) tf.math.segment_mean(d

CVE-2022-29209 [MEDIUM] CWE-843 Type confusion leading to `CHECK`-failure based denial of service in TensorFlow Type confusion leading to `CHECK`-failure based denial of service in TensorFlow ### Impact The [macros that TensorFlow uses for writing assertions (e.g., `CHECK_LT`, `CHECK_GT`, etc.)](https://github.com/tensorflow/tensorflow/blob/f3b9bf4c3c0597563b289c0512e98d4ce81f886e/tensorflow/core/platform/default/logging.h) have an incorrect logic when comparing `size_t` and `int` values. Due t

CVE-2022-29204 [MEDIUM] CWE-191 Missing validation causes denial of service via `Conv3DBackpropFilterV2` Missing validation causes denial of service via `Conv3DBackpropFilterV2` ### Impact The implementation of [`tf.raw_ops.UnsortedSegmentJoin`](https://github.com/tensorflow/tensorflow/blob/f3b9bf4c3c0597563b289c0512e98d4ce81f886e/tensorflow/core/kernels/unsorted_segment_join_op.cc#L83-L148) does not fully validate the input arguments. This results in a `CHECK`-failure which can be used to trig

CVE-2022-29199 [MEDIUM] CWE-20 Missing validation causes denial of service via `LoadAndRemapMatrix` Missing validation causes denial of service via `LoadAndRemapMatrix` ### Impact The implementation of [`tf.raw_ops.LoadAndRemapMatrix`](https://github.com/tensorflow/tensorflow/blob/f3b9bf4c3c0597563b289c0512e98d4ce81f886e/tensorflow/core/kernels/load_and_remap_matrix_op.cc#L70-L98) does not fully validate the input arguments. This results in a `CHECK`-failure which can be used to trigger a denia

CVE-2022-29211 [MEDIUM] CWE-20 Segfault if `tf.histogram_fixed_width` is called with NaN values in TensorFlow Segfault if `tf.histogram_fixed_width` is called with NaN values in TensorFlow ### Impact The implementation of [`tf.histogram_fixed_width`](https://github.com/tensorflow/tensorflow/blob/f3b9bf4c3c0597563b289c0512e98d4ce81f886e/tensorflow/core/kernels/histogram_op.cc) is vulnerable to a crash when the values array contain `NaN` elements: ```python import tensorflow as tf import numpy a

CVE-2021-37686 [MEDIUM] CWE-835 Infinite loop in TFLite Infinite loop in TFLite ### Impact The strided slice implementation in TFLite has a logic bug which can allow an attacker to trigger an infinite loop. This arises from newly introduced support for [ellipsis in axis definition](https://github.com/tensorflow/tensorflow/blob/149562d49faa709ea80df1d99fc41d005b81082a/tensorflow/lite/kernels/strided_slice.cc#L103-L122): ```cc for (int i = 0; i params->ellipsis_mask) { // ... int ellipsis_end_id

CVE-2022-29206 [MEDIUM] CWE-20 Missing validation results in undefined behavior in `SparseTensorDenseAdd Missing validation results in undefined behavior in `SparseTensorDenseAdd ### Impact The implementation of [`tf.raw_ops.SparseTensorDenseAdd`](https://github.com/tensorflow/tensorflow/blob/f3b9bf4c3c0597563b289c0512e98d4ce81f886e/tensorflow/core/kernels/sparse_tensor_dense_add_op.cc) does not fully validate the input arguments: ```python import tensorflow as tf a_indices = tf.constant(0, s

CVE-2022-29203 [MEDIUM] CWE-190 Integer overflow in `SpaceToBatchND` Integer overflow in `SpaceToBatchND` ### Impact The implementation of `tf.raw_ops.SpaceToBatchND` (in all backends such as XLA and handwritten kernels) is vulnerable to an integer overflow: ```python import tensorflow as tf input = tf.constant(-3.5e+35, shape=[10,19,22], dtype=tf.float32) block_shape = tf.constant(-1879048192, shape=[2], dtype=tf.int64) paddings = tf.constant(0, shape=[2,2], dtype=tf.int32) tf.raw_ops.SpaceT