Intel Optimization For Tensorflow vulnerabilities

CVE-2023-25669 [HIGH] CWE-697 TensorFlow has Floating Point Exception in AvgPoolGrad with XLA TensorFlow has Floating Point Exception in AvgPoolGrad with XLA ### Impact If the stride and window size are not positive for `tf.raw_ops.AvgPoolGrad`, it can give an FPE. ```python import tensorflow as tf import numpy as np @tf.function(jit_compile=True) def test(): y = tf.raw_ops.AvgPoolGrad(orig_input_shape=[1,0,0,0], grad=[[[[0.39117979]]]], ksize=[1,0,0,0], strides=[1,0,0,0], padding="SAME", dat

CVE-2023-25666 [HIGH] CWE-697 TensorFlow has Floating Point Exception in AudioSpectrogram TensorFlow has Floating Point Exception in AudioSpectrogram ### Impact version:2.11.0 //core/ops/audio_ops.cc:70 Status SpectrogramShapeFn(InferenceContext* c) { ShapeHandle input; TF_RETURN_IF_ERROR(c->WithRank(c->input(0), 2, &input)); int32_t window_size; TF_RETURN_IF_ERROR(c->GetAttr("window_size", &window_size)); int32_t stride; TF_RETURN_IF_ERROR(c->GetAttr("stride", &stride)); .....[1] DimensionHa

CVE-2020-26267 [LOW] CWE-125 Lack of validation in data format attributes in TensorFlow Lack of validation in data format attributes in TensorFlow ### Impact The `tf.raw_ops.DataFormatVecPermute` API does not validate the `src_format` and `dst_format` attributes. [The code](https://github.com/tensorflow/tensorflow/blob/304b96815324e6a73d046df10df6626d63ac12ad/tensorflow/core/kernels/data_format_ops.cc) assumes that these two arguments define a permutation of `NHWC`. However, these assumptions

CVE-2021-29592 [MEDIUM] CWE-476 Null pointer dereference in TFLite's `Reshape` operator Null pointer dereference in TFLite's `Reshape` operator ### Impact The fix for [CVE-2020-15209](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-15209) missed the case when the target shape of `Reshape` operator is given by the elements of a 1-D tensor. As such, the [fix for the vulnerability](https://github.com/tensorflow/tensorflow/blob/9c1dc920d8ffb4893d6c9d27d1f039607b326743/tensorflow/lite/core/s

CVE-2022-35991 [HIGH] `CHECK` fail in `TensorListScatter` and `TensorListScatterV2` in eager mode `CHECK` fail in `TensorListScatter` and `TensorListScatterV2` in eager mode ### Impact Another instance of CVE-2022-35991, where `TensorListScatter` and `TensorListScatterV2` crash via non scalar inputs in`element_shape`, was found in eager mode and fixed. ```python import tensorflow as tf arg_0=tf.random.uniform(shape=(2, 2, 2), dtype=tf.float16, maxval=None) arg_1=tf.random.uniform(shape=(2, 2, 2

CVE-2022-35935 [MEDIUM] CWE-617 TensorFlow vulnerable to `CHECK` failure in `SobolSample` via missing validation TensorFlow vulnerable to `CHECK` failure in `SobolSample` via missing validation ### Impact The implementation of SobolSampleOp is vulnerable to a denial of service via CHECK-failure (assertion failure) caused by assuming `input(0)`, `input(1)`, and `input(2)` to be scalar. ```python import tensorflow as tf tf.raw_ops.SobolSample(dim=tf.constant([1,0]), num_results=tf.constant([1]),

CVE-2022-23592 [HIGH] CWE-125 Out of bounds read in Tensorflow Out of bounds read in Tensorflow ### Impact TensorFlow's [type inference](https://github.com/tensorflow/tensorflow/blob/274df9b02330b790aa8de1cee164b70f72b9b244/tensorflow/core/graph/graph.cc#L223-L229) can cause a heap OOB read as the bounds checking is done in a `DCHECK` (which is a no-op during production): ```cc if (node_t.type_id() != TFT_UNSET) { int ix = input_idx[i]; DCHECK(ix < node_t.args_size()) << "input " << i << " sho

CVE-2020-15214 [CRITICAL] CWE-787 Out of bounds write in tensorflow-lite Out of bounds write in tensorflow-lite ### Impact In TensorFlow Lite models using segment sum can trigger a write out bounds / segmentation fault if the segment ids are not sorted. Code assumes that the segment ids are in increasing order, using the last element of the tensor holding them to determine the dimensionality of output tensor: https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf

CVE-2023-25671 [HIGH] CWE-787 TensorFlow has segmentation fault in tfg-translate TensorFlow has segmentation fault in tfg-translate ### Impact Out-of-bounds access due to mismatched integer type sizes in ValueMap::Manager::GetValueOrCreatePlaceholder. Bug with tfg-translate call to InitMlir. The problem happens with generic functions, as it is already handled for non-generic functions. This is because they, unlike non-generic functions, are using the "old importer". A better long-term solution

CVE-2023-25675 [HIGH] CWE-697 TensorFlow has Segfault in Bincount with XLA TensorFlow has Segfault in Bincount with XLA ### Impact When running with XLA, `tf.raw_ops.Bincount` segfaults when given a parameter `weights` that is neither the same shape as parameter `arr` nor a length-0 tensor. ```python import tensorflow as tf func = tf.raw_ops.Bincount para={'arr': 6, 'size': 804, 'weights': [52, 351]} @tf.function(jit_compile=True) def fuzz_jit(): y = func(**para) return y print(fuzz_jit())

CVE-2023-25670 [HIGH] CWE-476 TensorFlow has Null Pointer Error in QuantizedMatMulWithBiasAndDequantize TensorFlow has Null Pointer Error in QuantizedMatMulWithBiasAndDequantize ### Impact NPE in QuantizedMatMulWithBiasAndDequantize with MKL enable ```python import tensorflow as tf func = tf.raw_ops.QuantizedMatMulWithBiasAndDequantize para={'a': tf.constant(138, dtype=tf.quint8), 'b': tf.constant(4, dtype=tf.qint8), 'bias': [[31.81644630432129, 47.21876525878906], [109.95201110839844, 152.079

CVE-2023-25660 [HIGH] CWE-476 TensorFlow vulnerable to seg fault in `tf.raw_ops.Print` TensorFlow vulnerable to seg fault in `tf.raw_ops.Print` ### Impact When the parameter `summarize` of `tf.raw_ops.Print` is zero, the new method `SummarizeArray` will reference to a nullptr, leading to a seg fault. ```python import tensorflow as tf tf.raw_ops.Print(input = tf.constant([1, 1, 1, 1],dtype=tf.int32), data = [[False, False, False, False], [False], [False, False, False]], message = 'tmp/I', firs

CVE-2021-41201 [HIGH] CWE-824 Unitialized access in `EinsumHelper::ParseEquation` Unitialized access in `EinsumHelper::ParseEquation` ### Impact During execution, [`EinsumHelper::ParseEquation()`](https://github.com/tensorflow/tensorflow/blob/e0b6e58c328059829c3eb968136f17aa72b6c876/tensorflow/core/kernels/linalg/einsum_op_impl.h#L126-L181) is supposed to set the flags in `input_has_ellipsis` vector and `*output_has_ellipsis` boolean to indicate whether there is ellipsis in the corresponding in

CVE-2021-29571 [LOW] CWE-787 Memory corruption in `DrawBoundingBoxesV2` Memory corruption in `DrawBoundingBoxesV2` ### 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 images = tf.fill([10, 96, 0, 1], 0.) boxes = tf.fill([10, 53, 0], 0.) colors = tf.fill([0, 1], 0.) tf.raw_ops.DrawBoundingBoxesV2(images=images, boxes=boxes, colors=colors) ``

CVE-2021-41221 [HIGH] CWE-120 Access to invalid memory during shape inference in `Cudnn*` ops Access to invalid memory during shape inference in `Cudnn*` ops ### Impact The [shape inference code](https://github.com/tensorflow/tensorflow/blob/9ff27787893f76d6971dcd1552eb5270d254f31b/tensorflow/core/ops/cudnn_rnn_ops.cc) for the `Cudnn*` operations in TensorFlow can be tricked into accessing invalid memory, via a heap buffer overflow: ```python import tensorflow as tf @tf.function def func(): r

CVE-2021-29514 [LOW] CWE-787 Heap out of bounds write in `RaggedBinCount` Heap out of bounds write in `RaggedBinCount` ### Impact If the `splits` argument of `RaggedBincount` does not specify a valid [`SparseTensor`](https://www.tensorflow.org/api_docs/python/tf/sparse/SparseTensor), then an attacker can trigger a heap buffer overflow: ```python import tensorflow as tf tf.raw_ops.RaggedBincount(splits=[7,8], values= [5, 16, 51, 76, 29, 27, 54, 95],\ size= 59, weights= [0, 0, 0, 0, 0, 0, 0, 0],

CVE-2021-41219 [HIGH] CWE-125 Undefined behavior via `nullptr` reference binding in sparse matrix multiplication Undefined behavior via `nullptr` reference binding in sparse matrix multiplication ### Impact The [code for sparse matrix multiplication](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/sparse_matmul_op.cc#L954-L1086) is vulnerable to undefined behavior via binding a reference to `nullptr`: ```python import tensorflow as

CVE-2023-25801 [HIGH] CWE-415 TensorFlow has double free in Fractional(Max/Avg)Pool TensorFlow has double free in Fractional(Max/Avg)Pool ### Impact `nn_ops.fractional_avg_pool_v2` and `nn_ops.fractional_max_pool_v2` require the first and fourth elements of their parameter `pooling_ratio` to be equal to 1.0, as pooling on batch and channel dimensions is not supported. ```python import tensorflow as tf import os import numpy as np from tensorflow.python.ops import nn_ops try: arg_0_tensor = tf.

CVE-2020-15203 [HIGH] CWE-134 Denial of Service in Tensorflow Denial of Service in Tensorflow ### Impact By controlling the `fill` argument of [`tf.strings.as_string`](https://www.tensorflow.org/api_docs/python/tf/strings/as_string), a malicious attacker is able to trigger a format string vulnerability due to the way the internal format use in a `printf` call is constructed: https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/core/kernels/as_string_

CVE-2020-15206 [HIGH] CWE-20 Denial of Service in Tensorflow Denial of Service in Tensorflow ### Impact Changing the TensorFlow's `SavedModel` protocol buffer and altering the name of required keys results in segfaults and data corruption while loading the model. This can cause a denial of service in products using `tensorflow-serving` or other inference-as-a-service installments. We have added fixes to this in f760f88b4267d981e13f4b302c437ae800445968 and fcfef195637c6e365577829c4d67681695956e