Intel Optimization For Tensorflow vulnerabilities

CVE-2021-29563 [LOW] CWE-617 CHECK-fail in `tf.raw_ops.RFFT` CHECK-fail in `tf.raw_ops.RFFT` ### Impact An attacker can cause a denial of service by exploiting a `CHECK`-failure coming from the implementation of `tf.raw_ops.RFFT`: ```python import tensorflow as tf inputs = tf.constant([1], shape=[1], dtype=tf.float32) fft_length = tf.constant([0], shape=[1], dtype=tf.int32) tf.raw_ops.RFFT(input=inputs, fft_length=fft_length) ``` The above example causes Eigen code to operate on an empty ma

CVE-2021-29522 [LOW] CWE-369 Division by 0 in `Conv3DBackprop*` Division by 0 in `Conv3DBackprop*` ### Impact The `tf.raw_ops.Conv3DBackprop*` operations fail to validate that the input tensors are not empty. In turn, this would result in a division by 0: ```python import tensorflow as tf input_sizes = tf.constant([0, 0, 0, 0, 0], shape=[5], dtype=tf.int32) filter_tensor = tf.constant([], shape=[0, 0, 0, 1, 0], dtype=tf.float32) out_backprop = tf.constant([], shape=[0, 0, 0, 0, 0], dtype=tf.f

CVE-2021-29602 [LOW] CWE-369 Division by zero in TFLite's implementation of `DepthwiseConv` Division by zero in TFLite's implementation of `DepthwiseConv` ### Impact The implementation of the `DepthwiseConv` TFLite operator is [vulnerable to a division by zero error](https://github.com/tensorflow/tensorflow/blob/1a8e885b864c818198a5b2c0cbbeca5a1e833bc8/tensorflow/lite/kernels/depthwise_conv.cc#L287-L288): ```cc int num_input_channels = SizeOfDimension(input, 3); TF_LITE_ENSURE_EQ(context, num_

CVE-2021-41222 [MEDIUM] CWE-682 Segfault due to negative splits in `SplitV` Segfault due to negative splits in `SplitV` ### Impact The [implementation](https://github.com/tensorflow/tensorflow/blob/e71b86d47f8bc1816bf54d7bddc4170e47670b97/tensorflow/core/kernels/split_v_op.cc#L49-L205) of `SplitV` can trigger a segfault is an attacker supplies negative arguments: ```python import tensorflow as tf tf.raw_ops.SplitV( value=tf.constant([]), size_splits=[-1, -2] ,axis=0, num_split=2) ``` This oc

CVE-2021-37683 [MEDIUM] CWE-369 FPE in TFLite division operations FPE in TFLite division operations ### Impact The implementation of division in TFLite is [vulnerable to a division by 0 error](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/lite/kernels/div.cc) There is no check that the divisor tensor does not contain zero elements. ### Patches We have patched the issue in GitHub commit [1e206baedf8bef0334cca3eb92bab134ef525a28](https://githu

CVE-2021-37673 [MEDIUM] CWE-20 `CHECK`-fail in `MapStage` `CHECK`-fail in `MapStage` ### Impact An attacker can trigger a denial of service via a `CHECK`-fail in `tf.raw_ops.MapStage`: ```python import tensorflow as tf tf.raw_ops.MapStage( key=tf.constant([], shape=[0, 0, 0, 0], dtype=tf.int64), indices=tf.constant((0), dtype=tf.int32), values=[tf.constant((0), dtype=tf.int32)], dtypes=[tf.int32, tf.int64], capacity=0, memory_limit=0, container='', shared_name='') ``` The [implementation](ht

CVE-2021-37661 [MEDIUM] CWE-681 Crash caused by integer conversion to unsigned Crash caused by integer conversion to unsigned ### Impact An attacker can cause a denial of service in `boosted_trees_create_quantile_stream_resource` by using negative arguments: ```python import tensorflow as tf from tensorflow.python.ops import gen_boosted_trees_ops import numpy as np v= tf.Variable([0.0, 0.0, 0.0, 0.0, 0.0]) gen_boosted_trees_ops.boosted_trees_create_quantile_stream_resource( quantile_stream_re

CVE-2021-37668 [MEDIUM] CWE-369 FPE in `tf.raw_ops.UnravelIndex` FPE in `tf.raw_ops.UnravelIndex` ### Impact An attacker can cause denial of service in applications serving models using `tf.raw_ops.UnravelIndex` by triggering a division by 0: ```python import tensorflow as tf tf.raw_ops.UnravelIndex(indices=-1, dims=[1,0,2]) ``` The [implementation](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/core/kernels/unravel_index_op.cc#L36) does not

CVE-2021-37691 [MEDIUM] CWE-369 FPE in LSH in TFLite FPE in LSH in TFLite ### Impact An attacker can craft a TFLite model that would trigger a division by zero error in LSH [implementation](https://github.com/tensorflow/tensorflow/blob/149562d49faa709ea80df1d99fc41d005b81082a/tensorflow/lite/kernels/lsh_projection.cc#L118). ```cc int RunningSignBit(const TfLiteTensor* input, const TfLiteTensor* weight, float seed) { int input_item_bytes = input->bytes / SizeOfDimension(input, 0); // ... } ```

CVE-2021-37644 [MEDIUM] CWE-617 `std::abort` raised from `TensorListReserve` `std::abort` raised from `TensorListReserve` ### Impact Providing a negative element to `num_elements` list argument of `tf.raw_ops.TensorListReserve` causes the runtime to abort the process due to reallocating a `std::vector` to have a negative number of elements: ```python import tensorflow as tf tf.raw_ops.TensorListReserve( element_shape = tf.constant([1]), num_elements=tf.constant([-1]), element_dtype = tf.int32

CVE-2021-37680 [MEDIUM] CWE-369 Division by zero in TFLite Division by zero in TFLite ### Impact The implementation of fully connected layers in TFLite is [vulnerable to a division by zero error](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/lite/kernels/fully_connected.cc#L226): ```cc const int batch_size = input_size / filter->dims->data[1]; ``` An attacker can craft a model such that `filter->dims->data[1]` is 0. ### Patches We have patc

CVE-2021-37677 [MEDIUM] CWE-1284 Missing validation in shape inference for `Dequantize` Missing validation in shape inference for `Dequantize` ### Impact The shape inference code for `tf.raw_ops.Dequantize` has a vulnerability that could trigger a denial of service via a segfault if an attacker provides invalid arguments: ```python import tensorflow as tf tf.compat.v1.disable_v2_behavior() tf.raw_ops.Dequantize( input_tensor = tf.constant(-10.0, dtype=tf.float32), input_tensor = tf.cast(input

CVE-2022-23594 [HIGH] CWE-125 Out of bounds read in Tensorflow Out of bounds read in Tensorflow ### Impact The [TFG dialect of TensorFlow (MLIR)](https://github.com/tensorflow/tensorflow/tree/274df9b02330b790aa8de1cee164b70f72b9b244/tensorflow/core/ir/importexport) makes several assumptions about the incoming `GraphDef` before converting it to the MLIR-based dialect. If an attacker changes the `SavedModel` format on disk to invalidate these assumptions and the `GraphDef` is then converted to M

CVE-2021-37684 [MEDIUM] CWE-369 FPE in TFLite pooling operations FPE in TFLite pooling operations ### Impact The implementations of pooling in TFLite are vulnerable to division by 0 errors as there are no checks for divisors not being 0. ### Patches We have patched the issue in GitHub commit [dfa22b348b70bb89d6d6ec0ff53973bacb4f4695](https://github.com/tensorflow/tensorflow/commit/dfa22b348b70bb89d6d6ec0ff53973bacb4f4695). The fix will be included in TensorFlow 2.6.0. We will also cherrypick

CVE-2021-41204 [MEDIUM] CWE-824 Segfault while copying constant resource tensor Segfault while copying constant resource tensor ### Impact During TensorFlow's Grappler optimizer phase, constant folding might attempt to deep copy a resource tensor. This results in a segfault, as these tensors are supposed to not change. ### Patches We have patched the issue in GitHub commit [7731e8dfbe4a56773be5dc94d631611211156659](https://github.com/tensorflow/tensorflow/commit/7731e8dfbe4a56773be5dc94d631611

CVE-2021-41209 [MEDIUM] CWE-369 FPE in convolutions with zero size filters FPE in convolutions with zero size filters ### Impact The [implementations for convolution operators](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/conv_ops.cc) trigger a division by 0 if passed empty filter tensor arguments. ### Patches We have patched the issue in GitHub commit [f2c3931113eaafe9ef558faaddd48e00a6606235](https://github.com/tensorflow/tens

CVE-2021-41207 [MEDIUM] CWE-369 FPE in `ParallelConcat` FPE in `ParallelConcat` ### Impact The [implementation of `ParallelConcat`](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/inplace_ops.cc#L72-L97) misses some input validation and can produce a division by 0: ```python import tensorflow as tf @tf.function def test(): y = tf.raw_ops.ParallelConcat(values=[['tf']],shape=0) return y test() ``` ### Patches We have patched the

CVE-2020-15192 [MEDIUM] CWE-20 Memory leak in Tensorflow Memory leak in Tensorflow ### Impact If a user passes a list of strings to `dlpack.to_dlpack` there is a memory leak following an expected validation failure: https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/c/eager/dlpack.cc#L100-L104 The allocated memory is from https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/c/eager/dlpack.cc#L256 The i

CVE-2021-29617 [LOW] CWE-755 Crash in `tf.strings.substr` due to `CHECK`-fail Crash in `tf.strings.substr` due to `CHECK`-fail ### Impact An attacker can cause a denial of service via `CHECK`-fail in `tf.strings.substr` with invalid arguments: ```python import tensorflow as tf tf.strings.substr(input='abc', len=1, pos=[1,-1]) ``` ```python import tensorflow as tf tf.strings.substr(input='abc', len=1, pos=[1,2]) ``` ### Patches We have received a patch for the issue in GitHub commit [890f7164

CVE-2021-29526 [LOW] CWE-369 Division by 0 in `Conv2D` Division by 0 in `Conv2D` ### Impact An attacker can trigger a division by 0 in `tf.raw_ops.Conv2D`: ```python import tensorflow as tf input = tf.constant([], shape=[0, 0, 0, 0], dtype=tf.float32) filter = tf.constant([], shape=[0, 0, 0, 0], dtype=tf.float32) strides = [1, 1, 1, 1] padding = "SAME" tf.raw_ops.Conv2D(input=input, filter=filter, strides=strides, padding=padding) ``` This is because the [implementation](https://github.com