ecosystem
stringclasses 11
values | vuln_id
stringlengths 10
19
| summary
stringlengths 4
220
⌀ | details
stringlengths 34
13.5k
| aliases
stringlengths 17
87
⌀ | modified_date
stringdate 2019-03-26 14:13:00
2022-05-10 08:46:52
| published_date
stringdate 2012-06-17 03:41:00
2022-05-10 08:46:50
| severity
stringclasses 5
values | score
float64 0
10
⌀ | cwe_id
stringclasses 581
values | refs
stringlengths 82
11.6k
| introduced
stringclasses 843
values | code_refs
stringlengths 46
940
| commits
stringlengths 46
940
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
PyPI | PYSEC-2021-396 | null | TensorFlow is an open source platform for machine learning. In affected versions an attacker can trigger undefined behavior, integer overflows, segfaults and `CHECK`-fail crashes if they can change saved checkpoints from outside of TensorFlow. This is because the checkpoints loading infrastructure is missing validation for invalid file formats. The fixes will be included in TensorFlow 2.7.0. We will also cherrypick these commits on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range. | {'CVE-2021-41203', 'GHSA-7pxj-m4jf-r6h2'} | 2021-11-13T06:52:42.793363Z | 2021-11-05T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/e8dc63704c88007ee4713076605c90188d66f3d2', 'https://github.com/tensorflow/tensorflow/commit/b619c6f865715ca3b15ef1842b5b95edbaa710ad', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-7pxj-m4jf-r6h2', 'https://github.com/tensorflow/tensorflow/commit/368af875869a204b4ac552b9ddda59f6a46a56ec', 'https://github.com/tensorflow/tensorflow/commit/abcced051cb1bd8fb05046ac3b6023a7ebcc4578'} | null | {'https://github.com/tensorflow/tensorflow/commit/e8dc63704c88007ee4713076605c90188d66f3d2', 'https://github.com/tensorflow/tensorflow/commit/abcced051cb1bd8fb05046ac3b6023a7ebcc4578', 'https://github.com/tensorflow/tensorflow/commit/b619c6f865715ca3b15ef1842b5b95edbaa710ad', 'https://github.com/tensorflow/tensorflow/commit/368af875869a204b4ac552b9ddda59f6a46a56ec'} | {'https://github.com/tensorflow/tensorflow/commit/e8dc63704c88007ee4713076605c90188d66f3d2', 'https://github.com/tensorflow/tensorflow/commit/abcced051cb1bd8fb05046ac3b6023a7ebcc4578', 'https://github.com/tensorflow/tensorflow/commit/b619c6f865715ca3b15ef1842b5b95edbaa710ad', 'https://github.com/tensorflow/tensorflow/commit/368af875869a204b4ac552b9ddda59f6a46a56ec'} |
PyPI | GHSA-m539-j985-hcr8 | Crash in `max_pool3d` when size argument is 0 or negative | ### Impact
The Keras pooling layers can trigger a segfault if the size of the pool is 0 or if a dimension is negative:
```python
import tensorflow as tf
pool_size = [2, 2, 0]
layer = tf.keras.layers.MaxPooling3D(strides=1, pool_size=pool_size)
input_tensor = tf.random.uniform([3, 4, 10, 11, 12], dtype=tf.float32)
res = layer(input_tensor)
```
This is due to the TensorFlow's implementation of pooling operations where the values in the sliding window are not checked to be strictly positive.
### Patches
We have patched the issue in GitHub commit [12b1ff82b3f26ff8de17e58703231d5a02ef1b8b](https://github.com/tensorflow/tensorflow/commit/12b1ff82b3f26ff8de17e58703231d5a02ef1b8b) (merging [#51975](https://github.com/tensorflow/tensorflow/pull/51975)).
The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported externally via a [GitHub issue](https://github.com/tensorflow/tensorflow/issues/51936).
| {'CVE-2021-41196'} | 2022-03-03T05:13:52.073527Z | 2021-11-10T19:36:21Z | MODERATE | null | {'CWE-191'} | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-m539-j985-hcr8', 'https://github.com/tensorflow/tensorflow/commit/12b1ff82b3f26ff8de17e58703231d5a02ef1b8b', 'https://github.com/tensorflow/tensorflow/issues/51936', 'https://github.com/tensorflow/tensorflow', 'https://nvd.nist.gov/vuln/detail/CVE-2021-41196'} | null | {'https://github.com/tensorflow/tensorflow/commit/12b1ff82b3f26ff8de17e58703231d5a02ef1b8b'} | {'https://github.com/tensorflow/tensorflow/commit/12b1ff82b3f26ff8de17e58703231d5a02ef1b8b'} |
PyPI | PYSEC-2020-115 | null | In Tensorflow before versions 2.2.1 and 2.3.1, if a user passes a list of strings to `dlpack.to_dlpack` there is a memory leak following an expected validation failure. The issue occurs because the `status` argument during validation failures is not properly checked. Since each of the above methods can return an error status, the `status` value must be checked before continuing. The issue is patched in commit 22e07fb204386768e5bcbea563641ea11f96ceb8 and is released in TensorFlow versions 2.2.1, or 2.3.1. | {'CVE-2020-15192', 'GHSA-8fxw-76px-3rxv'} | 2021-09-01T08:19:32.462320Z | 2020-09-25T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-8fxw-76px-3rxv', 'http://lists.opensuse.org/opensuse-security-announce/2020-10/msg00065.html', 'https://github.com/tensorflow/tensorflow/commit/22e07fb204386768e5bcbea563641ea11f96ceb8', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.3.1'} | null | {'https://github.com/tensorflow/tensorflow/commit/22e07fb204386768e5bcbea563641ea11f96ceb8'} | {'https://github.com/tensorflow/tensorflow/commit/22e07fb204386768e5bcbea563641ea11f96ceb8'} |
PyPI | GHSA-rqjh-jp2r-59cj | nltk is vulnerable to Inefficient Regular Expression Complexity | nltk is vulnerable to Inefficient Regular Expression Complexity | {'CVE-2021-3842'} | 2022-03-03T05:13:29.207812Z | 2022-01-06T22:24:14Z | HIGH | null | {'CWE-1333'} | {'https://github.com/nltk/nltk', 'https://github.com/nltk/nltk/commit/2a50a3edc9d35f57ae42a921c621edc160877f4d', 'https://nvd.nist.gov/vuln/detail/CVE-2021-3842', 'https://huntr.dev/bounties/761a761e-2be2-430a-8d92-6f74ffe9866a'} | null | {'https://github.com/nltk/nltk/commit/2a50a3edc9d35f57ae42a921c621edc160877f4d'} | {'https://github.com/nltk/nltk/commit/2a50a3edc9d35f57ae42a921c621edc160877f4d'} |
PyPI | PYSEC-2021-816 | null | TensorFlow is an open source platform for machine learning. In affected versions the implementations for convolution operators trigger a division by 0 if passed empty filter tensor arguments. The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range. | {'GHSA-6hpv-v2rx-c5g6', 'CVE-2021-41209'} | 2021-12-09T06:35:42.527822Z | 2021-11-05T22:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/f2c3931113eaafe9ef558faaddd48e00a6606235', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-6hpv-v2rx-c5g6'} | null | {'https://github.com/tensorflow/tensorflow/commit/f2c3931113eaafe9ef558faaddd48e00a6606235'} | {'https://github.com/tensorflow/tensorflow/commit/f2c3931113eaafe9ef558faaddd48e00a6606235'} |
PyPI | PYSEC-2021-115 | null | The package glances before 3.2.1 are vulnerable to XML External Entity (XXE) Injection via the use of Fault to parse untrusted XML data, which is known to be vulnerable to XML attacks.
| {'CVE-2021-23418', 'SNYK-PYTHON-GLANCES-1311807', 'GHSA-r2mj-8wgq-73m6'} | 2021-07-29T20:29:05.800424Z | 2021-07-29T18:15:00Z | null | null | null | {'https://github.com/nicolargo/glances/commit/85d5a6b4af31fcf785d5a61086cbbd166b40b07a', 'https://github.com/nicolargo/glances/issues/1025', 'https://snyk.io/vuln/SNYK-PYTHON-GLANCES-1311807', 'https://github.com/advisories/GHSA-r2mj-8wgq-73m6', 'https://github.com/nicolargo/glances/commit/4b87e979afdc06d98ed1b48da31e69eaa3a9fb94', 'https://github.com/nicolargo/glances/commit/9d6051be4a42f692392049fdbfc85d5dfa458b32'} | null | {'https://github.com/nicolargo/glances/commit/9d6051be4a42f692392049fdbfc85d5dfa458b32', 'https://github.com/nicolargo/glances/commit/4b87e979afdc06d98ed1b48da31e69eaa3a9fb94', 'https://github.com/nicolargo/glances/commit/85d5a6b4af31fcf785d5a61086cbbd166b40b07a'} | {'https://github.com/nicolargo/glances/commit/4b87e979afdc06d98ed1b48da31e69eaa3a9fb94', 'https://github.com/nicolargo/glances/commit/85d5a6b4af31fcf785d5a61086cbbd166b40b07a', 'https://github.com/nicolargo/glances/commit/9d6051be4a42f692392049fdbfc85d5dfa458b32'} |
PyPI | PYSEC-2021-545 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a denial of service via `CHECK`-fail in `tf.strings.substr` with invalid arguments. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'CVE-2021-29617', 'GHSA-mmq6-q8r3-48fm'} | 2021-12-09T06:35:01.587221Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/issues/46900', 'https://github.com/tensorflow/issues/46974', 'https://github.com/tensorflow/tensorflow/commit/890f7164b70354c57d40eda52dcdd7658677c09f', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-mmq6-q8r3-48fm'} | null | {'https://github.com/tensorflow/tensorflow/commit/890f7164b70354c57d40eda52dcdd7658677c09f'} | {'https://github.com/tensorflow/tensorflow/commit/890f7164b70354c57d40eda52dcdd7658677c09f'} |
PyPI | PYSEC-2021-400 | null | TensorFlow is an open source platform for machine learning. In affected versions the code for boosted trees in TensorFlow is still missing validation. As a result, attackers can trigger denial of service (via dereferencing `nullptr`s or via `CHECK`-failures) as well as abuse undefined behavior (binding references to `nullptr`s). An attacker can also read and write from heap buffers, depending on the API that gets used and the arguments that are passed to the call. Given that the boosted trees implementation in TensorFlow is unmaintained, it is recommend to no longer use these APIs. We will deprecate TensorFlow's boosted trees APIs in subsequent releases. The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range. | {'GHSA-57wx-m983-2f88', 'CVE-2021-41208'} | 2021-11-13T06:52:43.429056Z | 2021-11-05T22:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-57wx-m983-2f88', 'https://github.com/tensorflow/tensorflow/commit/5c8c9a8bfe750f9743d0c859bae112060b216f5c'} | null | {'https://github.com/tensorflow/tensorflow/commit/5c8c9a8bfe750f9743d0c859bae112060b216f5c'} | {'https://github.com/tensorflow/tensorflow/commit/5c8c9a8bfe750f9743d0c859bae112060b216f5c'} |
PyPI | GHSA-j8qc-5fqr-52fp | Division by zero in `Conv2DBackpropFilter` | ### Impact
An attacker can cause a division by zero to occur in `Conv2DBackpropFilter`:
```python
import tensorflow as tf
input_tensor = tf.constant([], shape=[0, 0, 0, 0], dtype=tf.float32)
filter_sizes = tf.constant([0, 0, 0, 0], shape=[4], dtype=tf.int32)
out_backprop = tf.constant([], shape=[0, 0, 0, 0], dtype=tf.float32)
tf.raw_ops.Conv2DBackpropFilter(
input=input_tensor,
filter_sizes=filter_sizes,
out_backprop=out_backprop,
strides=[1, 1, 1, 1],
use_cudnn_on_gpu=False,
padding='SAME',
explicit_paddings=[],
data_format='NHWC',
dilations=[1, 1, 1, 1]
)
```
This is because the [implementation](https://github.com/tensorflow/tensorflow/blob/1b0296c3b8dd9bd948f924aa8cd62f87dbb7c3da/tensorflow/core/kernels/conv_grad_filter_ops.cc#L513-L522) computes a divisor based on user provided data (i.e., the shape of the tensors given as arguments):
```cc
const size_t size_A = output_image_size * filter_total_size;
const size_t size_B = output_image_size * dims.out_depth;
const size_t size_C = filter_total_size * dims.out_depth;
const size_t work_unit_size = size_A + size_B + size_C;
const size_t shard_size = (target_working_set_size + work_unit_size - 1) / work_unit_size;
```
If all shapes are empty then `work_unit_size` is 0. Since there is no check for this case before division, this results in a runtime exception, with potential to be abused for a denial of service.
### Patches
We have patched the issue in GitHub commit [c570e2ecfc822941335ad48f6e10df4e21f11c96](https://github.com/tensorflow/tensorflow/commit/c570e2ecfc822941335ad48f6e10df4e21f11c96).
The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by Yakun Zhang and Ying Wang of Baidu X-Team. | {'CVE-2021-29538'} | 2022-03-03T05:13:10.370231Z | 2021-05-21T14:22:38Z | LOW | null | {'CWE-369'} | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-j8qc-5fqr-52fp', 'https://github.com/tensorflow/tensorflow/commit/c570e2ecfc822941335ad48f6e10df4e21f11c96', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29538'} | null | {'https://github.com/tensorflow/tensorflow/commit/c570e2ecfc822941335ad48f6e10df4e21f11c96'} | {'https://github.com/tensorflow/tensorflow/commit/c570e2ecfc822941335ad48f6e10df4e21f11c96'} |
PyPI | PYSEC-2022-33 | null | b2-sdk-python is a python library to access cloud storage provided by backblaze. Linux and Mac releases of the SDK version 1.14.0 and below contain a key disclosure vulnerability that, in certain conditions, can be exploited by local attackers through a time-of-check-time-of-use (TOCTOU) race condition. SDK users of the SqliteAccountInfo format are vulnerable while users of the InMemoryAccountInfo format are safe. The SqliteAccountInfo saves API keys (and bucket name-to-id mapping) in a local database file ($XDG_CONFIG_HOME/b2/account_info, ~/.b2_account_info or a user-defined path). When first created, the file is world readable and is (typically a few milliseconds) later altered to be private to the user. If the directory containing the file is readable by a local attacker then during the brief period between file creation and permission modification, a local attacker can race to open the file and maintain a handle to it. This allows the local attacker to read the contents after the file after the sensitive information has been saved to it. Consumers of this SDK who rely on it to save data using SqliteAccountInfo class should upgrade to the latest version of the SDK. Those who believe a local user might have opened a handle using this race condition, should remove the affected database files and regenerate all application keys. Users should upgrade to b2-sdk-python 1.14.1 or later. | {'CVE-2022-23651', 'GHSA-p867-fxfr-ph2w'} | 2022-03-07T17:33:46.032301Z | 2022-02-23T23:15:00Z | null | null | null | {'https://github.com/Backblaze/b2-sdk-python/commit/62476638986e5b6d7459aca5ef8ce220760226e0', 'https://github.com/Backblaze/b2-sdk-python/security/advisories/GHSA-p867-fxfr-ph2w', 'https://pypi.org/project/b2sdk/'} | null | {'https://github.com/Backblaze/b2-sdk-python/commit/62476638986e5b6d7459aca5ef8ce220760226e0'} | {'https://github.com/Backblaze/b2-sdk-python/commit/62476638986e5b6d7459aca5ef8ce220760226e0'} |
PyPI | PYSEC-2020-284 | null | In eager mode, TensorFlow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1 does not set the session state. Hence, calling `tf.raw_ops.GetSessionHandle` or `tf.raw_ops.GetSessionHandleV2` results in a null pointer dereference In linked snippet, in eager mode, `ctx->session_state()` returns `nullptr`. Since code immediately dereferences this, we get a segmentation fault. The issue is patched in commit 9a133d73ae4b4664d22bd1aa6d654fec13c52ee1, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1. | {'GHSA-q8gv-q7wr-9jf8', 'CVE-2020-15204'} | 2021-12-09T06:34:42.248668Z | 2020-09-25T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-q8gv-q7wr-9jf8', 'http://lists.opensuse.org/opensuse-security-announce/2020-10/msg00065.html', 'https://github.com/tensorflow/tensorflow/commit/9a133d73ae4b4664d22bd1aa6d654fec13c52ee1', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.3.1'} | null | {'https://github.com/tensorflow/tensorflow/commit/9a133d73ae4b4664d22bd1aa6d654fec13c52ee1'} | {'https://github.com/tensorflow/tensorflow/commit/9a133d73ae4b4664d22bd1aa6d654fec13c52ee1'} |
PyPI | PYSEC-2021-284 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can generate undefined behavior via a reference binding to nullptr in `BoostedTreesCalculateBestGainsPerFeature` and similar attack can occur in `BoostedTreesCalculateBestFeatureSplitV2`. The [implementation](https://github.com/tensorflow/tensorflow/blob/84d053187cb80d975ef2b9684d4b61981bca0c41/tensorflow/core/kernels/boosted_trees/stats_ops.cc) does not validate the input values. We have patched the issue in GitHub commit 9c87c32c710d0b5b53dc6fd3bfde4046e1f7a5ad and in commit 429f009d2b2c09028647dd4bb7b3f6f414bbaad7. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'CVE-2021-37662', 'GHSA-f5cx-5wr3-5qrc'} | 2021-08-27T03:22:45.118929Z | 2021-08-12T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/9c87c32c710d0b5b53dc6fd3bfde4046e1f7a5ad', 'https://github.com/tensorflow/tensorflow/commit/429f009d2b2c09028647dd4bb7b3f6f414bbaad7', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-f5cx-5wr3-5qrc'} | null | {'https://github.com/tensorflow/tensorflow/commit/429f009d2b2c09028647dd4bb7b3f6f414bbaad7', 'https://github.com/tensorflow/tensorflow/commit/9c87c32c710d0b5b53dc6fd3bfde4046e1f7a5ad'} | {'https://github.com/tensorflow/tensorflow/commit/429f009d2b2c09028647dd4bb7b3f6f414bbaad7', 'https://github.com/tensorflow/tensorflow/commit/9c87c32c710d0b5b53dc6fd3bfde4046e1f7a5ad'} |
PyPI | PYSEC-2021-791 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions 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). We have patched the issue in GitHub commit 718721986aa137691ee23f03638867151f74935f. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'CVE-2021-37680', 'GHSA-cfpj-3q4c-jhvr'} | 2021-12-09T06:35:39.345760Z | 2021-08-12T22:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-cfpj-3q4c-jhvr', 'https://github.com/tensorflow/tensorflow/commit/718721986aa137691ee23f03638867151f74935f'} | null | {'https://github.com/tensorflow/tensorflow/commit/718721986aa137691ee23f03638867151f74935f'} | {'https://github.com/tensorflow/tensorflow/commit/718721986aa137691ee23f03638867151f74935f'} |
PyPI | GHSA-6j9c-grc6-5m6g | CHECK-fail in SparseConcat | ### Impact
An attacker can trigger a denial of service via a `CHECK`-fail in `tf.raw_ops.SparseConcat`:
```python
import tensorflow as tf
import numpy as np
indices_1 = tf.constant([[514, 514], [514, 514]], dtype=tf.int64)
indices_2 = tf.constant([[514, 530], [599, 877]], dtype=tf.int64)
indices = [indices_1, indices_2]
values_1 = tf.zeros([0], dtype=tf.int64)
values_2 = tf.zeros([0], dtype=tf.int64)
values = [values_1, values_2]
shape_1 = tf.constant([442, 514, 514, 515, 606, 347, 943, 61, 2], dtype=tf.int64)
shape_2 = tf.zeros([9], dtype=tf.int64)
shapes = [shape_1, shape_2]
tf.raw_ops.SparseConcat(indices=indices, values=values, shapes=shapes, concat_dim=2)
```
This is because the [implementation](https://github.com/tensorflow/tensorflow/blob/b432a38fe0e1b4b904a6c222cbce794c39703e87/tensorflow/core/kernels/sparse_concat_op.cc#L76) takes the values specified in `shapes[0]` as dimensions for the output shape:
```cc
TensorShape input_shape(shapes[0].vec<int64>());
```
The [`TensorShape` constructor](https://github.com/tensorflow/tensorflow/blob/6f9896890c4c703ae0a0845394086e2e1e523299/tensorflow/core/framework/tensor_shape.cc#L183-L188) uses a `CHECK` operation which triggers when [`InitDims`](https://github.com/tensorflow/tensorflow/blob/6f9896890c4c703ae0a0845394086e2e1e523299/tensorflow/core/framework/tensor_shape.cc#L212-L296) returns a non-OK status.
```cc
template <class Shape>
TensorShapeBase<Shape>::TensorShapeBase(gtl::ArraySlice<int64> dim_sizes) {
set_tag(REP16);
set_data_type(DT_INVALID);
TF_CHECK_OK(InitDims(dim_sizes));
}
```
In our scenario, this occurs when adding a dimension from the argument results in overflow:
```cc
template <class Shape>
Status TensorShapeBase<Shape>::InitDims(gtl::ArraySlice<int64> dim_sizes) {
...
Status status = Status::OK();
for (int64 s : dim_sizes) {
status.Update(AddDimWithStatus(internal::SubtleMustCopy(s)));
if (!status.ok()) {
return status;
}
}
}
template <class Shape>
Status TensorShapeBase<Shape>::AddDimWithStatus(int64 size) {
...
int64 new_num_elements;
if (kIsPartial && (num_elements() < 0 || size < 0)) {
new_num_elements = -1;
} else {
new_num_elements = MultiplyWithoutOverflow(num_elements(), size);
if (TF_PREDICT_FALSE(new_num_elements < 0)) {
return errors::Internal("Encountered overflow when multiplying ",
num_elements(), " with ", size,
", result: ", new_num_elements);
}
}
...
}
```
This is a legacy implementation of the constructor and operations should use `BuildTensorShapeBase` or `AddDimWithStatus` to prevent `CHECK`-failures in the presence of overflows.
### Patches
We have patched the issue in GitHub commit [69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c](https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c).
The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by Yakun Zhang and Ying Wang of Baidu X-Team. | {'CVE-2021-29534'} | 2022-03-03T05:13:13.591077Z | 2021-05-21T14:22:24Z | LOW | null | {'CWE-754'} | {'https://nvd.nist.gov/vuln/detail/CVE-2021-29534', 'https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-6j9c-grc6-5m6g'} | null | {'https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c'} | {'https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c'} |
PyPI | GHSA-92x2-jw7w-xvvx | Cookie and header exposure in twisted | ### Impact
Cookie and Authorization headers are leaked when following cross-origin redirects in `twited.web.client.RedirectAgent` and `twisted.web.client.BrowserLikeRedirectAgent`. | {'CVE-2022-21712'} | 2022-03-07T20:47:56.478654Z | 2022-02-07T22:36:00Z | HIGH | null | {'CWE-346', 'CWE-200'} | {'https://github.com/twisted/twisted/releases/tag/twisted-22.1.0', 'https://lists.debian.org/debian-lts-announce/2022/02/msg00021.html', 'https://github.com/twisted/twisted/security/advisories/GHSA-92x2-jw7w-xvvx', 'https://github.com/twisted/twisted', 'https://github.com/twisted/twisted/commit/af8fe78542a6f2bf2235ccee8158d9c88d31e8e2', 'https://nvd.nist.gov/vuln/detail/CVE-2022-21712'} | null | {'https://github.com/twisted/twisted/commit/af8fe78542a6f2bf2235ccee8158d9c88d31e8e2'} | {'https://github.com/twisted/twisted/commit/af8fe78542a6f2bf2235ccee8158d9c88d31e8e2'} |
PyPI | PYSEC-2021-512 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a denial of service via a `CHECK`-fail in caused by an integer overflow in constructing a new tensor shape. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/0908c2f2397c099338b901b067f6495a5b96760b/tensorflow/core/kernels/sparse_split_op.cc#L66-L70) builds a dense shape without checking that the dimensions would not result in overflow. The `TensorShape` constructor(https://github.com/tensorflow/tensorflow/blob/6f9896890c4c703ae0a0845394086e2e1e523299/tensorflow/core/framework/tensor_shape.cc#L183-L188) uses a `CHECK` operation which triggers when `InitDims`(https://github.com/tensorflow/tensorflow/blob/6f9896890c4c703ae0a0845394086e2e1e523299/tensorflow/core/framework/tensor_shape.cc#L212-L296) returns a non-OK status. This is a legacy implementation of the constructor and operations should use `BuildTensorShapeBase` or `AddDimWithStatus` to prevent `CHECK`-failures in the presence of overflows. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'GHSA-xvjm-fvxx-q3hv', 'CVE-2021-29584'} | 2021-12-09T06:34:56.381620Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/4c0ee937c0f61c4fc5f5d32d9bb4c67428012a60', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-xvjm-fvxx-q3hv'} | null | {'https://github.com/tensorflow/tensorflow/commit/4c0ee937c0f61c4fc5f5d32d9bb4c67428012a60'} | {'https://github.com/tensorflow/tensorflow/commit/4c0ee937c0f61c4fc5f5d32d9bb4c67428012a60'} |
PyPI | GHSA-c582-c96p-r5cq | Memory exhaustion in Tensorflow | ### Impact
The [implementation of `ThreadPoolHandle`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/data/experimental/threadpool_dataset_op.cc#L79-L135) can be used to trigger a denial of service attack by allocating too much memory:
```python
import tensorflow as tf
y = tf.raw_ops.ThreadPoolHandle(num_threads=0x60000000,display_name='tf')
```
This is because the `num_threads` argument is only checked to not be negative, but there is no upper bound on its value.
### Patches
We have patched the issue in GitHub commit [e3749a6d5d1e8d11806d4a2e9cc3123d1a90b75e](https://github.com/tensorflow/tensorflow/commit/e3749a6d5d1e8d11806d4a2e9cc3123d1a90b75e).
The fix will be included in TensorFlow 2.8.0. We will also cherrypick this commit on TensorFlow 2.7.1, TensorFlow 2.6.3, and TensorFlow 2.5.3, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by Yu Tian of Qihoo 360 AIVul Team. | {'CVE-2022-21732'} | 2022-03-03T05:13:08.731915Z | 2022-02-10T00:20:29Z | MODERATE | null | {'CWE-770', 'CWE-400'} | {'https://github.com/tensorflow/tensorflow/commit/e3749a6d5d1e8d11806d4a2e9cc3123d1a90b75e', 'https://github.com/tensorflow/tensorflow/', 'https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/data/experimental/threadpool_dataset_op.cc#L79-L135', 'https://nvd.nist.gov/vuln/detail/CVE-2022-21732', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-c582-c96p-r5cq'} | null | {'https://github.com/tensorflow/tensorflow/commit/e3749a6d5d1e8d11806d4a2e9cc3123d1a90b75e'} | {'https://github.com/tensorflow/tensorflow/commit/e3749a6d5d1e8d11806d4a2e9cc3123d1a90b75e'} |
PyPI | GHSA-9p77-mmrw-69c7 | Null-dereference in Tensorflow | ### Impact
When decoding a tensor from protobuf, TensorFlow might do a null-dereference if attributes of some mutable arguments to some operations are missing from the proto. This is [guarded by a `DCHECK`](https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/full_type_util.cc#L104-L106):
```cc
const auto* attr = attrs.Find(arg->s());
DCHECK(attr != nullptr);
if (attr->value_case() == AttrValue::kList) {
// ...
}
```
However, `DCHECK` is a no-op in production builds and an assertion failure in debug builds. In the first case execution proceeds to the dereferencing of the null pointer, whereas in the second case it results in a crash due to the assertion failure.
### Patches
We have patched the issue in GitHub commit [8a513cec4bec15961fbfdedcaa5376522980455c](https://github.com/tensorflow/tensorflow/commit/8a513cec4bec15961fbfdedcaa5376522980455c).
The fix will be included in TensorFlow 2.8.0. We will also cherrypick this commit on TensorFlow 2.7.1, and TensorFlow 2.6.3, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions. | {'CVE-2022-23570'} | 2022-03-03T05:13:46.493647Z | 2022-02-09T23:33:35Z | MODERATE | null | {'CWE-476'} | {'https://github.com/tensorflow/tensorflow/commit/8a513cec4bec15961fbfdedcaa5376522980455c', 'https://github.com/tensorflow/tensorflow/', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/full_type_util.cc#L104-L106', 'https://nvd.nist.gov/vuln/detail/CVE-2022-23570', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-9p77-mmrw-69c7'} | null | {'https://github.com/tensorflow/tensorflow/commit/8a513cec4bec15961fbfdedcaa5376522980455c'} | {'https://github.com/tensorflow/tensorflow/commit/8a513cec4bec15961fbfdedcaa5376522980455c'} |
PyPI | PYSEC-2020-142 | null | A mis-handling of invalid unicode characters in the Java implementation of Tink versions prior to 1.5 allows an attacker to change the ID part of a ciphertext, which result in the creation of a second ciphertext that can decrypt to the same plaintext. This can be a problem with encrypting deterministic AEAD with a single key, and rely on a unique ciphertext-per-plaintext. | {'CVE-2020-8929', 'GHSA-g5vf-v6wf-7w2r'} | 2020-10-29T22:16:00Z | 2020-10-19T13:15:00Z | null | null | null | {'https://github.com/google/tink/security/advisories/GHSA-g5vf-v6wf-7w2r', 'https://github.com/google/tink/commit/93d839a5865b9d950dffdc9d0bc99b71280a8899'} | null | {'https://github.com/google/tink/commit/93d839a5865b9d950dffdc9d0bc99b71280a8899'} | {'https://github.com/google/tink/commit/93d839a5865b9d950dffdc9d0bc99b71280a8899'} |
PyPI | PYSEC-2022-64 | null | Tensorflow is an Open Source Machine Learning Framework. The implementation of `SparseCountSparseOutput` is vulnerable to a heap overflow. The fix will be included in TensorFlow 2.8.0. We will also cherrypick this commit on TensorFlow 2.7.1, TensorFlow 2.6.3, and TensorFlow 2.5.3, as these are also affected and still in supported range. | {'CVE-2022-21740', 'GHSA-44qp-9wwf-734r'} | 2022-03-09T00:17:31.800762Z | 2022-02-03T15:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/adbbabdb0d3abb3cdeac69e38a96de1d678b24b3', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-44qp-9wwf-734r', 'https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/count_ops.cc#L168-L273', 'https://github.com/tensorflow/tensorflow/commit/2b7100d6cdff36aa21010a82269bc05a6d1cc74a'} | null | {'https://github.com/tensorflow/tensorflow/commit/adbbabdb0d3abb3cdeac69e38a96de1d678b24b3', 'https://github.com/tensorflow/tensorflow/commit/2b7100d6cdff36aa21010a82269bc05a6d1cc74a'} | {'https://github.com/tensorflow/tensorflow/commit/adbbabdb0d3abb3cdeac69e38a96de1d678b24b3', 'https://github.com/tensorflow/tensorflow/commit/2b7100d6cdff36aa21010a82269bc05a6d1cc74a'} |
PyPI | PYSEC-2019-104 | null | ** DISPUTED ** core.py in Mitogen before 0.2.8 has a typo that drops the unidirectional-routing protection mechanism in the case of a child that is initiated by another child. The Ansible extension is unaffected. NOTE: the vendor disputes this issue because it is exploitable only in conjunction with hypothetical other factors, i.e., an affected use case within a library caller, and a bug in the message receiver policy code that led to reliance on this extra protection mechanism. | {'CVE-2019-15149', 'GHSA-8rf6-w2mx-4xjh'} | 2019-08-30T11:38:00Z | 2019-08-18T20:15:00Z | null | null | null | {'https://mitogen.networkgenomics.com/changelog.html#v0-2-8-2019-08-18', 'https://github.com/advisories/GHSA-8rf6-w2mx-4xjh', 'https://github.com/dw/mitogen/commit/5924af1566763e48c42028399ea0cd95c457b3dc'} | null | {'https://github.com/dw/mitogen/commit/5924af1566763e48c42028399ea0cd95c457b3dc'} | {'https://github.com/dw/mitogen/commit/5924af1566763e48c42028399ea0cd95c457b3dc'} |
PyPI | GHSA-22wc-c9wj-6q2v | VVE-2021-0001: Memory corruption using function calls within arrays | ### Impact
When performing a function call inside an array, there is a memory corruption issue that occurs because of an incorrect pointer to the the tip of the stack.
### Patches
This issue was partially fixed in [VVE-2020-0004](https://github.com/vyperlang/vyper/security/advisories/GHSA-2r3x-4mrv-mcxf), however the fix did not update similar code for arrays, which had a similar issue. The issue is fully fixed in https://github.com/vyperlang/vyper/pull/2345 | null | 2022-03-03T05:13:32.598774Z | 2021-04-19T15:12:05Z | MODERATE | null | {'CWE-129'} | {'https://github.com/vyperlang/vyper/security/advisories/GHSA-22wc-c9wj-6q2v', 'https://github.com/vyperlang/vyper/commit/11b7b5b7e59bc9dc859d51cd41a924b59fe47c9e', 'https://github.com/vyperlang/vyper/pull/2345', 'https://pypi.org/project/vyper'} | null | {'https://github.com/vyperlang/vyper/commit/11b7b5b7e59bc9dc859d51cd41a924b59fe47c9e'} | {'https://github.com/vyperlang/vyper/commit/11b7b5b7e59bc9dc859d51cd41a924b59fe47c9e'} |
PyPI | PYSEC-2021-457 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a heap buffer overflow in `tf.raw_ops.QuantizedResizeBilinear` by manipulating input values so that float rounding results in off-by-one error in accessing image elements. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/44b7f486c0143f68b56c34e2d01e146ee445134a/tensorflow/core/kernels/quantized_resize_bilinear_op.cc#L62-L66) computes two integers (representing the upper and lower bounds for interpolation) by ceiling and flooring a floating point value. For some values of `in`, `interpolation->upper[i]` might be smaller than `interpolation->lower[i]`. This is an issue if `interpolation->upper[i]` is capped at `in_size-1` as it means that `interpolation->lower[i]` points outside of the image. Then, in the interpolation code(https://github.com/tensorflow/tensorflow/blob/44b7f486c0143f68b56c34e2d01e146ee445134a/tensorflow/core/kernels/quantized_resize_bilinear_op.cc#L245-L264), this would result in heap buffer overflow. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'GHSA-jfp7-4j67-8r3q', 'CVE-2021-29529'} | 2021-12-09T06:34:47.879310Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/f851613f8f0fb0c838d160ced13c134f778e3ce7', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-jfp7-4j67-8r3q'} | null | {'https://github.com/tensorflow/tensorflow/commit/f851613f8f0fb0c838d160ced13c134f778e3ce7'} | {'https://github.com/tensorflow/tensorflow/commit/f851613f8f0fb0c838d160ced13c134f778e3ce7'} |
PyPI | PYSEC-2021-768 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefined behavior via binding a reference to null pointer in all operations of type `tf.raw_ops.MatrixDiagV*`. The [implementation](https://github.com/tensorflow/tensorflow/blob/84d053187cb80d975ef2b9684d4b61981bca0c41/tensorflow/core/kernels/linalg/matrix_diag_op.cc) has incomplete validation that the value of `k` is a valid tensor. We have check that this value is either a scalar or a vector, but there is no check for the number of elements. If this is an empty tensor, then code that accesses the first element of the tensor is wrong. We have patched the issue in GitHub commit f2a673bd34f0d64b8e40a551ac78989d16daad09. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'CVE-2021-37657', 'GHSA-5xwc-mrhx-5g3m'} | 2021-12-09T06:35:37.257593Z | 2021-08-12T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/f2a673bd34f0d64b8e40a551ac78989d16daad09', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-5xwc-mrhx-5g3m'} | null | {'https://github.com/tensorflow/tensorflow/commit/f2a673bd34f0d64b8e40a551ac78989d16daad09'} | {'https://github.com/tensorflow/tensorflow/commit/f2a673bd34f0d64b8e40a551ac78989d16daad09'} |
PyPI | PYSEC-2021-292 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can read from outside of bounds of heap allocated data by sending specially crafted illegal arguments to `tf.raw_ops.UpperBound`. The [implementation](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/core/kernels/searchsorted_op.cc#L85-L104) does not validate the rank of `sorted_input` argument. A similar issue occurs in `tf.raw_ops.LowerBound`. We have patched the issue in GitHub commit 42459e4273c2e47a3232cc16c4f4fff3b3a35c38. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'GHSA-9697-98pf-4rw7', 'CVE-2021-37670'} | 2021-08-27T03:22:45.845259Z | 2021-08-12T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-9697-98pf-4rw7', 'https://github.com/tensorflow/tensorflow/commit/42459e4273c2e47a3232cc16c4f4fff3b3a35c38'} | null | {'https://github.com/tensorflow/tensorflow/commit/42459e4273c2e47a3232cc16c4f4fff3b3a35c38'} | {'https://github.com/tensorflow/tensorflow/commit/42459e4273c2e47a3232cc16c4f4fff3b3a35c38'} |
PyPI | PYSEC-2020-292 | null | In TensorFlow Lite before versions 2.2.1 and 2.3.1, models using segment sum can trigger writes outside of bounds of heap allocated buffers by inserting negative elements in the segment ids tensor. Users having access to `segment_ids_data` can alter `output_index` and then write to outside of `output_data` buffer. This might result in a segmentation fault but it can also be used to further corrupt the memory and can be chained with other vulnerabilities to create more advanced exploits. The issue is patched in commit 204945b19e44b57906c9344c0d00120eeeae178a and is released in TensorFlow versions 2.2.1, or 2.3.1. A potential workaround would be to add a custom `Verifier` to the model loading code to ensure that the segment ids are all positive, although this only handles the case when the segment ids are stored statically in the model. A similar validation could be done if the segment ids are generated at runtime between inference steps. If the segment ids are generated as outputs of a tensor during inference steps, then there are no possible workaround and users are advised to upgrade to patched code. | {'GHSA-hx2x-85gr-wrpq', 'CVE-2020-15212'} | 2021-12-09T06:34:43.741009Z | 2020-09-25T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-hx2x-85gr-wrpq', 'https://github.com/tensorflow/tensorflow/commit/204945b19e44b57906c9344c0d00120eeeae178a', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.3.1'} | null | {'https://github.com/tensorflow/tensorflow/commit/204945b19e44b57906c9344c0d00120eeeae178a'} | {'https://github.com/tensorflow/tensorflow/commit/204945b19e44b57906c9344c0d00120eeeae178a'} |
PyPI | GHSA-627q-g293-49q7 | Abort caused by allocating a vector that is too large in Tensorflow | ### Impact
During shape inference, TensorFlow can [allocate a large vector](https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/shape_inference.cc#L788-L790) based on a value from a tensor controlled by the user:
```cc
const auto num_dims = Value(shape_dim);
std::vector<DimensionHandle> dims;
dims.reserve(num_dims);
```
### Patches
We have patched the issue in GitHub commit [1361fb7e29449629e1df94d44e0427ebec8c83c7](https://github.com/tensorflow/tensorflow/commit/1361fb7e29449629e1df94d44e0427ebec8c83c7).
The fix will be included in TensorFlow 2.8.0. We will also cherrypick this commit on TensorFlow 2.7.1, TensorFlow 2.6.3, and TensorFlow 2.5.3, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions. | {'CVE-2022-23580'} | 2022-03-03T05:12:37.453930Z | 2022-02-07T22:01:24Z | MODERATE | null | {'CWE-400'} | {'https://nvd.nist.gov/vuln/detail/CVE-2022-23580', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/shape_inference.cc#L788-L790', 'https://github.com/tensorflow/tensorflow/', 'https://github.com/tensorflow/tensorflow/commit/1361fb7e29449629e1df94d44e0427ebec8c83c7', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-627q-g293-49q7'} | null | {'https://github.com/tensorflow/tensorflow/commit/1361fb7e29449629e1df94d44e0427ebec8c83c7'} | {'https://github.com/tensorflow/tensorflow/commit/1361fb7e29449629e1df94d44e0427ebec8c83c7'} |
PyPI | GHSA-jfp7-4j67-8r3q | Heap buffer overflow caused by rounding | ### Impact
An attacker can trigger a heap buffer overflow in `tf.raw_ops.QuantizedResizeBilinear` by manipulating input values so that float rounding results in off-by-one error in accessing image elements:
```python
import tensorflow as tf
l = [256, 328, 361, 17, 361, 361, 361, 361, 361, 361, 361, 361, 361, 361, 384]
images = tf.constant(l, shape=[1, 1, 15, 1], dtype=tf.qint32)
size = tf.constant([12, 6], shape=[2], dtype=tf.int32)
min = tf.constant(80.22522735595703)
max = tf.constant(80.39215850830078)
tf.raw_ops.QuantizedResizeBilinear(images=images, size=size, min=min, max=max,
align_corners=True, half_pixel_centers=True)
```
This is because the [implementation](https://github.com/tensorflow/tensorflow/blob/44b7f486c0143f68b56c34e2d01e146ee445134a/tensorflow/core/kernels/quantized_resize_bilinear_op.cc#L62-L66) computes two integers (representing the upper and lower bounds for interpolation) by ceiling and flooring a floating point value:
```cc
const float in_f = std::floor(in);
interpolation->lower[i] = std::max(static_cast<int64>(in_f), static_cast<int64>(0));
interpolation->upper[i] = std::min(static_cast<int64>(std::ceil(in)), in_size - 1);
```
For some values of `in`, `interpolation->upper[i]` might be smaller than `interpolation->lower[i]`. This is an issue if `interpolation->upper[i]` is capped at `in_size-1` as it means that `interpolation->lower[i]` points outside of the image. Then, [in the interpolation code](https://github.com/tensorflow/tensorflow/blob/44b7f486c0143f68b56c34e2d01e146ee445134a/tensorflow/core/kernels/quantized_resize_bilinear_op.cc#L245-L264), this would result in heap buffer overflow:
```cc
template <int RESOLUTION, typename T, typename T_SCALE, typename T_CALC>
inline void OutputLerpForChannels(const InterpolationCache<T_SCALE>& xs,
const int64 x, const T_SCALE ys_ilerp,
const int channels, const float min,
const float max, const T* ys_input_lower_ptr,
const T* ys_input_upper_ptr,
T* output_y_ptr) {
const int64 xs_lower = xs.lower[x];
...
for (int c = 0; c < channels; ++c) {
const T top_left = ys_input_lower_ptr[xs_lower + c];
...
}
}
```
For the other cases where `interpolation->upper[i]` is smaller than `interpolation->lower[i]`, we can set them to be equal without affecting the output.
### Patches
We have patched the issue in GitHub commit [f851613f8f0fb0c838d160ced13c134f778e3ce7](https://github.com/tensorflow/tensorflow/commit/f851613f8f0fb0c838d160ced13c134f778e3ce7).
The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by Ying Wang and Yakun Zhang of Baidu X-Team. | {'CVE-2021-29529'} | 2022-03-03T05:13:48.265071Z | 2021-05-21T14:22:05Z | LOW | null | {'CWE-131', 'CWE-193'} | {'https://github.com/tensorflow/tensorflow/commit/f851613f8f0fb0c838d160ced13c134f778e3ce7', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-jfp7-4j67-8r3q', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29529'} | null | {'https://github.com/tensorflow/tensorflow/commit/f851613f8f0fb0c838d160ced13c134f778e3ce7'} | {'https://github.com/tensorflow/tensorflow/commit/f851613f8f0fb0c838d160ced13c134f778e3ce7'} |
PyPI | GHSA-cqhg-xjhh-p8hf | Out-of-bounds reads in Pillow | Pillow before 6.2.3 and 7.x before 7.0.1 has multiple out-of-bounds reads in libImaging/FliDecode.c. | {'CVE-2020-10177'} | 2022-03-03T05:13:58.743050Z | 2020-07-27T21:52:43Z | MODERATE | null | {'CWE-125'} | {'https://github.com/python-pillow/Pillow/commits/master/src/libImaging', 'https://lists.debian.org/debian-lts-announce/2020/08/msg00012.html', 'https://pillow.readthedocs.io/en/stable/releasenotes/6.2.3.html', 'https://github.com/python-pillow/Pillow/pull/4503', 'https://nvd.nist.gov/vuln/detail/CVE-2020-10177', 'https://snyk.io/vuln/SNYK-PYTHON-PILLOW-574573', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/HOKHNWV2VS5GESY7IBD237E7C6T3I427/', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/BEBCPE4F2VHTIT6EZA2YZQZLPVDEBJGD/', 'https://usn.ubuntu.com/4430-2/', 'https://pillow.readthedocs.io/en/stable/releasenotes/7.1.0.html', 'https://usn.ubuntu.com/4430-1/', 'https://github.com/python-pillow/Pillow/pull/4538', 'https://github.com/python-pillow/Pillow'} | null | {'https://github.com/python-pillow/Pillow/commits/master/src/libImaging'} | {'https://github.com/python-pillow/Pillow/commits/master/src/libImaging'} |
PyPI | PYSEC-2020-338 | null | In TensorFlow before 1.15.2 and 2.0.1, converting a string (from Python) to a tf.float16 value results in a segmentation fault in eager mode as the format checks for this use case are only in the graph mode. This issue can lead to denial of service in inference/training where a malicious attacker can send a data point which contains a string instead of a tf.float16 value. Similar effects can be obtained by manipulating saved models and checkpoints whereby replacing a scalar tf.float16 value with a scalar string will trigger this issue due to automatic conversions. This can be easily reproduced by tf.constant("hello", tf.float16), if eager execution is enabled. This issue is patched in TensorFlow 1.15.1 and 2.0.1 with this vulnerability patched. TensorFlow 2.1.0 was released after we fixed the issue, thus it is not affected. Users are encouraged to switch to TensorFlow 1.15.1, 2.0.1 or 2.1.0. | {'GHSA-977j-xj7q-2jr9', 'CVE-2020-5215'} | 2021-12-09T06:35:16.944663Z | 2020-01-28T22:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-977j-xj7q-2jr9', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.0.1', 'https://github.com/tensorflow/tensorflow/commit/5ac1b9e24ff6afc465756edf845d2e9660bd34bf', 'https://github.com/tensorflow/tensorflow/releases/tag/v1.15.2'} | null | {'https://github.com/tensorflow/tensorflow/commit/5ac1b9e24ff6afc465756edf845d2e9660bd34bf'} | {'https://github.com/tensorflow/tensorflow/commit/5ac1b9e24ff6afc465756edf845d2e9660bd34bf'} |
PyPI | PYSEC-2017-15 | null | The serializer in html5lib before 0.99999999 might allow remote attackers to conduct cross-site scripting (XSS) attacks by leveraging mishandling of special characters in attribute values, a different vulnerability than CVE-2016-9909. | {'CVE-2016-9910'} | 2021-07-05T00:01:21.869008Z | 2017-02-22T16:59:00Z | null | null | null | {'http://www.securityfocus.com/bid/95132', 'https://github.com/html5lib/html5lib-python/commit/9b8d8eb5afbc066b7fac9390f5ec75e5e8a7cab7', 'http://www.openwall.com/lists/oss-security/2016/12/08/8', 'https://github.com/html5lib/html5lib-python/issues/11', 'https://html5lib.readthedocs.io/en/latest/changes.html#b9', 'https://github.com/html5lib/html5lib-python/issues/12', 'http://www.openwall.com/lists/oss-security/2016/12/06/5'} | null | {'https://github.com/html5lib/html5lib-python/commit/9b8d8eb5afbc066b7fac9390f5ec75e5e8a7cab7'} | {'https://github.com/html5lib/html5lib-python/commit/9b8d8eb5afbc066b7fac9390f5ec75e5e8a7cab7'} |
PyPI | GHSA-79fv-9865-4qcv | Heap buffer overflow in `MaxPoolGrad` | ### Impact
The implementation of `tf.raw_ops.MaxPoolGrad` is vulnerable to a heap buffer overflow:
```python
import tensorflow as tf
orig_input = tf.constant([0.0], shape=[1, 1, 1, 1], dtype=tf.float32)
orig_output = tf.constant([0.0], shape=[1, 1, 1, 1], dtype=tf.float32)
grad = tf.constant([], shape=[0, 0, 0, 0], dtype=tf.float32)
ksize = [1, 1, 1, 1]
strides = [1, 1, 1, 1]
padding = "SAME"
tf.raw_ops.MaxPoolGrad(
orig_input=orig_input, orig_output=orig_output, grad=grad, ksize=ksize,
strides=strides, padding=padding, explicit_paddings=[])
```
The [implementation](https://github.com/tensorflow/tensorflow/blob/ab1e644b48c82cb71493f4362b4dd38f4577a1cf/tensorflow/core/kernels/maxpooling_op.cc#L194-L203) fails to validate that indices used to access elements of input/output arrays are valid:
```cc
for (int index = out_start; index < out_end; ++index) {
int input_backprop_index = out_arg_max_flat(index);
FastBoundsCheck(input_backprop_index - in_start, in_end - in_start);
input_backprop_flat(input_backprop_index) += out_backprop_flat(index);
}
```
Whereas accesses to `input_backprop_flat` are guarded by `FastBoundsCheck`, the indexing in `out_backprop_flat` can result in OOB access.
### Patches
We have patched the issue in GitHub commit [a74768f8e4efbda4def9f16ee7e13cf3922ac5f7](https://github.com/tensorflow/tensorflow/commit/a74768f8e4efbda4def9f16ee7e13cf3922ac5f7).
The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by Ying Wang and Yakun Zhang of Baidu X-Team. | {'CVE-2021-29579'} | 2022-03-03T05:13:47.961411Z | 2021-05-21T14:26:23Z | LOW | null | {'CWE-787', 'CWE-119'} | {'https://nvd.nist.gov/vuln/detail/CVE-2021-29579', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-79fv-9865-4qcv', 'https://github.com/tensorflow/tensorflow/commit/a74768f8e4efbda4def9f16ee7e13cf3922ac5f7'} | null | {'https://github.com/tensorflow/tensorflow/commit/a74768f8e4efbda4def9f16ee7e13cf3922ac5f7'} | {'https://github.com/tensorflow/tensorflow/commit/a74768f8e4efbda4def9f16ee7e13cf3922ac5f7'} |
PyPI | PYSEC-2021-62 | null | python-cryptography 3.2 is vulnerable to Bleichenbacher timing attacks in the RSA decryption API, via timed processing of valid PKCS#1 v1.5 ciphertext. | {'CVE-2020-25659', 'GHSA-hggm-jpg3-v476'} | 2021-01-19T21:48:00Z | 2021-01-11T16:15:00Z | null | null | null | {'https://github.com/advisories/GHSA-hggm-jpg3-v476', 'https://github.com/pyca/cryptography/pull/5507/commits/ce1bef6f1ee06ac497ca0c837fbd1c7ef6c2472b'} | null | {'https://github.com/pyca/cryptography/pull/5507/commits/ce1bef6f1ee06ac497ca0c837fbd1c7ef6c2472b'} | {'https://github.com/pyca/cryptography/pull/5507/commits/ce1bef6f1ee06ac497ca0c837fbd1c7ef6c2472b'} |
PyPI | PYSEC-2021-787 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can cause undefined behavior via binding a reference to null pointer in `tf.raw_ops.SparseFillEmptyRows`. The shape inference [implementation](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/core/ops/sparse_ops.cc#L608-L634) does not validate that the input arguments are not empty tensors. We have patched the issue in GitHub commit 578e634b4f1c1c684d4b4294f9e5281b2133b3ed. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'CVE-2021-37676', 'GHSA-v768-w7m9-2vmm'} | 2021-12-09T06:35:38.998901Z | 2021-08-12T22:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-v768-w7m9-2vmm', 'https://github.com/tensorflow/tensorflow/commit/578e634b4f1c1c684d4b4294f9e5281b2133b3ed'} | null | {'https://github.com/tensorflow/tensorflow/commit/578e634b4f1c1c684d4b4294f9e5281b2133b3ed'} | {'https://github.com/tensorflow/tensorflow/commit/578e634b4f1c1c684d4b4294f9e5281b2133b3ed'} |
PyPI | GHSA-2vj5-px25-gjrp | pytorch-lightning is vulnerable to Deserialization of Untrusted Data | pytorch-lightning is vulnerable to Deserialization of Untrusted Data. | {'CVE-2021-4118'} | 2022-03-30T18:33:00.647017Z | 2022-01-06T23:58:59Z | HIGH | null | {'CWE-502'} | {'https://github.com/pytorchlightning/pytorch-lightning/commit/62f1e82e032eb16565e676d39e0db0cac7e34ace', 'https://github.com/PyTorchLightning/pytorch-lightning/releases/tag/1.6.0', 'https://nvd.nist.gov/vuln/detail/CVE-2021-4118', 'https://huntr.dev/bounties/31832f0c-e5bb-4552-a12c-542f81f111e6', 'https://github.com/PyTorchLightning/pytorch-lightning/pull/11099', 'https://github.com/PyTorchLightning/pytorch-lightning/issues/11045', 'https://github.com/pytorchlightning/pytorch-lightning'} | null | {'https://github.com/pytorchlightning/pytorch-lightning/commit/62f1e82e032eb16565e676d39e0db0cac7e34ace'} | {'https://github.com/pytorchlightning/pytorch-lightning/commit/62f1e82e032eb16565e676d39e0db0cac7e34ace'} |
PyPI | PYSEC-2020-154 | null | In Wagtail before versions 2.7.4 and 2.9.3, when a form page type is made available to Wagtail editors through the `wagtail.contrib.forms` app, and the page template is built using Django's standard form rendering helpers such as form.as_p, any HTML tags used within a form field's help text will be rendered unescaped in the page. Allowing HTML within help text is an intentional design decision by Django; however, as a matter of policy Wagtail does not allow editors to insert arbitrary HTML by default, as this could potentially be used to carry out cross-site scripting attacks, including privilege escalation. This functionality should therefore not have been made available to editor-level users. The vulnerability is not exploitable by an ordinary site visitor without access to the Wagtail admin. Patched versions have been released as Wagtail 2.7.4 (for the LTS 2.7 branch) and Wagtail 2.9.3 (for the current 2.9 branch). In these versions, help text will be escaped to prevent the inclusion of HTML tags. Site owners who wish to re-enable the use of HTML within help text (and are willing to accept the risk of this being exploited by editors) may set WAGTAILFORMS_HELP_TEXT_ALLOW_HTML = True in their configuration settings. Site owners who are unable to upgrade to the new versions can secure their form page templates by rendering forms field-by-field as per Django's documentation, but omitting the |safe filter when outputting the help text. | {'GHSA-2473-9hgq-j7xw', 'CVE-2020-15118'} | 2020-07-28T12:29:00Z | 2020-07-20T18:15:00Z | null | null | null | {'https://github.com/wagtail/wagtail/commit/d9a41e7f24d08c024acc9a3094940199df94db34', 'https://docs.djangoproject.com/en/3.0/ref/models/fields/#django.db.models.Field.help_text', 'https://github.com/wagtail/wagtail/security/advisories/GHSA-2473-9hgq-j7xw', 'https://docs.wagtail.io/en/stable/reference/contrib/forms/index.html#usage', 'https://github.com/wagtail/wagtail/blob/master/docs/releases/2.9.3.rst'} | null | {'https://github.com/wagtail/wagtail/commit/d9a41e7f24d08c024acc9a3094940199df94db34'} | {'https://github.com/wagtail/wagtail/commit/d9a41e7f24d08c024acc9a3094940199df94db34'} |
PyPI | GHSA-hq37-853p-g5cf | Regular Expression Denial of Service in CairoSVG | # Doyensec Vulnerability Advisory
* Regular Expression Denial of Service (REDoS) in cairosvg
* Affected Product: CairoSVG v2.0.0+
* Vendor: https://github.com/Kozea
* Severity: Medium
* Vulnerability Class: Denial of Service
* Author(s): Ben Caller ([Doyensec](https://doyensec.com))
## Summary
When processing SVG files, the python package CairoSVG uses two regular expressions which are vulnerable to Regular Expression Denial of Service (REDoS).
If an attacker provides a malicious SVG, it can make cairosvg get stuck processing the file for a very long time.
## Technical description
The vulnerable regular expressions are
https://github.com/Kozea/CairoSVG/blob/9c4a982b9a021280ad90e89707eacc1d114e4ac4/cairosvg/colors.py#L190-L191
The section between 'rgb(' and the final ')' contains multiple overlapping groups.
Since all three infinitely repeating groups accept spaces, a long string of spaces causes catastrophic backtracking when it is not followed by a closing parenthesis.
The complexity is cubic, so doubling the length of the malicious string of spaces makes processing take 8 times as long.
## Reproduction steps
Create a malicious SVG of the form:
<svg width="1" height="1"><rect fill="rgb( ;"/></svg>
with the following code:
'<svg width="1" height="1"><rect fill="rgb(' + (' ' * 3456) + ';"/></svg>'
Note that there is no closing parenthesis before the semi-colon.
Run cairosvg e.g.:
cairosvg cairo-redos.svg -o x.png
and notice that it hangs at 100% CPU. Increasing the number of spaces increases the processing time with cubic complexity.
## Remediation
Fix the regexes to avoid overlapping parts. Perhaps remove the [ \n\r\t]* groups from the regex, and use .strip() on the returned capture group.
## Disclosure timeline
- 2020-12-30: Vulnerability disclosed via email to CourtBouillon | {'CVE-2021-21236'} | 2022-03-03T05:13:35.572602Z | 2021-01-06T16:57:50Z | MODERATE | null | {'CWE-400'} | {'https://github.com/Kozea/CairoSVG/commit/cfc9175e590531d90384aa88845052de53d94bf3', 'https://pypi.org/project/CairoSVG/', 'https://nvd.nist.gov/vuln/detail/CVE-2021-21236', 'https://github.com/Kozea/CairoSVG/releases/tag/2.5.1', 'https://github.com/Kozea/CairoSVG/security/advisories/GHSA-hq37-853p-g5cf'} | null | {'https://github.com/Kozea/CairoSVG/commit/cfc9175e590531d90384aa88845052de53d94bf3'} | {'https://github.com/Kozea/CairoSVG/commit/cfc9175e590531d90384aa88845052de53d94bf3'} |
PyPI | GHSA-3ff2-r28g-w7h9 | Heap buffer overflow in `Transpose` | ### Impact
The [shape inference function for `Transpose`](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/ops/array_ops.cc#L121-L185) is vulnerable to a heap buffer overflow:
```python
import tensorflow as tf
@tf.function
def test():
y = tf.raw_ops.Transpose(x=[1,2,3,4],perm=[-10])
return y
test()
```
This occurs whenever `perm` contains negative elements. The shape inference function does not validate that the indices in `perm` are all valid:
```cc
for (int32_t i = 0; i < rank; ++i) {
int64_t in_idx = data[i];
if (in_idx >= rank) {
return errors::InvalidArgument("perm dim ", in_idx,
" is out of range of input rank ", rank);
}
dims[i] = c->Dim(input, in_idx);
}
```
where `Dim(tensor, index)` accepts either a positive index less than the rank of the tensor or the special value `-1` for unknown dimensions.
### Patches
We have patched the issue in GitHub commit [c79ba87153ee343401dbe9d1954d7f79e521eb14](https://github.com/tensorflow/tensorflow/commit/c79ba87153ee343401dbe9d1954d7f79e521eb14).
The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by members of the Aivul Team from Qihoo 360. | {'CVE-2021-41216'} | 2022-03-03T05:12:02.115739Z | 2021-11-10T18:57:19Z | MODERATE | null | {'CWE-120', 'CWE-787'} | {'https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/ops/array_ops.cc#L121-L185', 'https://nvd.nist.gov/vuln/detail/CVE-2021-41216', 'https://github.com/tensorflow/tensorflow/commit/c79ba87153ee343401dbe9d1954d7f79e521eb14', 'https://github.com/tensorflow/tensorflow', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-3ff2-r28g-w7h9'} | null | {'https://github.com/tensorflow/tensorflow/commit/c79ba87153ee343401dbe9d1954d7f79e521eb14'} | {'https://github.com/tensorflow/tensorflow/commit/c79ba87153ee343401dbe9d1954d7f79e521eb14'} |
PyPI | PYSEC-2018-26 | null | qutebrowser version introduced in v0.11.0 (1179ee7a937fb31414d77d9970bac21095358449) contains a Cross Site Scripting (XSS) vulnerability in history command, qute://history page that can result in Via injected JavaScript code, a website can steal the user's browsing history. This attack appear to be exploitable via the victim must open a page with a specially crafted <title> attribute, and then open the qute://history site via the :history command. This vulnerability appears to have been fixed in fixed in v1.3.3 (4c9360237f186681b1e3f2a0f30c45161cf405c7, to be released today) and v1.4.0 (5a7869f2feaa346853d2a85413d6527c87ef0d9f, released later this week). | {'CVE-2018-1000559', 'GHSA-m4fw-77v7-924m'} | 2021-06-10T06:51:59.879286Z | 2018-06-26T16:29:00Z | null | null | null | {'https://github.com/advisories/GHSA-m4fw-77v7-924m', 'https://github.com/qutebrowser/qutebrowser/commit/4c9360237f186681b1e3f2a0f30c45161cf405c7', 'https://github.com/qutebrowser/qutebrowser/commit/5a7869f2feaa346853d2a85413d6527c87ef0d9f', 'https://github.com/qutebrowser/qutebrowser/issues/4011'} | null | {'https://github.com/qutebrowser/qutebrowser/commit/4c9360237f186681b1e3f2a0f30c45161cf405c7', 'https://github.com/qutebrowser/qutebrowser/commit/5a7869f2feaa346853d2a85413d6527c87ef0d9f'} | {'https://github.com/qutebrowser/qutebrowser/commit/5a7869f2feaa346853d2a85413d6527c87ef0d9f', 'https://github.com/qutebrowser/qutebrowser/commit/4c9360237f186681b1e3f2a0f30c45161cf405c7'} |
PyPI | PYSEC-2021-154 | null | TensorFlow is an end-to-end open source platform for machine learning. A malicious user could trigger a division by 0 in `Conv3D` implementation. The implementation(https://github.com/tensorflow/tensorflow/blob/42033603003965bffac51ae171b51801565e002d/tensorflow/core/kernels/conv_ops_3d.cc#L143-L145) does a modulo operation based on user controlled input. Thus, when `filter` has a 0 as the fifth element, this results in a division by 0. Additionally, if the shape of the two tensors is not valid, an Eigen assertion can be triggered, resulting in a program crash. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'GHSA-772p-x54p-hjrv', 'CVE-2021-29517'} | 2021-08-27T03:22:24.411852Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-772p-x54p-hjrv', 'https://github.com/tensorflow/tensorflow/commit/799f835a3dfa00a4d852defa29b15841eea9d64f'} | null | {'https://github.com/tensorflow/tensorflow/commit/799f835a3dfa00a4d852defa29b15841eea9d64f'} | {'https://github.com/tensorflow/tensorflow/commit/799f835a3dfa00a4d852defa29b15841eea9d64f'} |
PyPI | PYSEC-2021-504 | null | TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPool3DGradGrad` is vulnerable to a heap buffer overflow. The implementation(https://github.com/tensorflow/tensorflow/blob/596c05a159b6fbb9e39ca10b3f7753b7244fa1e9/tensorflow/core/kernels/pooling_ops_3d.cc#L694-L696) does not check that the initialization of `Pool3dParameters` completes successfully. Since the constructor(https://github.com/tensorflow/tensorflow/blob/596c05a159b6fbb9e39ca10b3f7753b7244fa1e9/tensorflow/core/kernels/pooling_ops_3d.cc#L48-L88) uses `OP_REQUIRES` to validate conditions, the first assertion that fails interrupts the initialization of `params`, making it contain invalid data. In turn, this might cause a heap buffer overflow, depending on default initialized values. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'GHSA-7cqx-92hp-x6wh', 'CVE-2021-29576'} | 2021-12-09T06:34:55.161027Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/63c6a29d0f2d692b247f7bf81f8732d6442fad09', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-7cqx-92hp-x6wh'} | null | {'https://github.com/tensorflow/tensorflow/commit/63c6a29d0f2d692b247f7bf81f8732d6442fad09'} | {'https://github.com/tensorflow/tensorflow/commit/63c6a29d0f2d692b247f7bf81f8732d6442fad09'} |
PyPI | PYSEC-2021-441 | null | TensorFlow is an end-to-end open source platform for machine learning. Calling TF operations with tensors of non-numeric types when the operations expect numeric tensors result in null pointer dereferences. The conversion from Python array to C++ array(https://github.com/tensorflow/tensorflow/blob/ff70c47a396ef1e3cb73c90513da4f5cb71bebba/tensorflow/python/lib/core/ndarray_tensor.cc#L113-L169) is vulnerable to a type confusion. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'GHSA-452g-f7fp-9jf7', 'CVE-2021-29513'} | 2021-12-09T06:34:45.368024Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/030af767d357d1b4088c4a25c72cb3906abac489', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-452g-f7fp-9jf7'} | null | {'https://github.com/tensorflow/tensorflow/commit/030af767d357d1b4088c4a25c72cb3906abac489'} | {'https://github.com/tensorflow/tensorflow/commit/030af767d357d1b4088c4a25c72cb3906abac489'} |
PyPI | PYSEC-2012-7 | null | The django.http.HttpRequest.get_host function in Django 1.3.x before 1.3.4 and 1.4.x before 1.4.2 allows remote attackers to generate and display arbitrary URLs via crafted username and password Host header values. | {'CVE-2012-4520'} | 2021-07-15T02:22:08.562601Z | 2012-11-18T23:55:00Z | null | null | null | {'http://www.osvdb.org/86493', 'http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=691145', 'http://securitytracker.com/id?1027708', 'http://lists.fedoraproject.org/pipermail/package-announce/2012-October/090904.html', 'http://ubuntu.com/usn/usn-1757-1', 'http://www.openwall.com/lists/oss-security/2012/10/30/4', 'http://lists.fedoraproject.org/pipermail/package-announce/2012-October/090666.html', 'https://bugzilla.redhat.com/show_bug.cgi?id=865164', 'http://secunia.com/advisories/51314', 'https://github.com/django/django/commit/b45c377f8f488955e0c7069cad3f3dd21910b071', 'http://lists.fedoraproject.org/pipermail/package-announce/2012-October/090970.html', 'http://ubuntu.com/usn/usn-1632-1', 'https://github.com/django/django/commit/9305c0e12d43c4df999c3301a1f0c742264a657e', 'https://github.com/django/django/commit/92d3430f12171f16f566c9050c40feefb830a4a3', 'http://www.debian.org/security/2013/dsa-2634', 'http://secunia.com/advisories/51033', 'https://www.djangoproject.com/weblog/2012/oct/17/security/'} | null | {'https://github.com/django/django/commit/9305c0e12d43c4df999c3301a1f0c742264a657e', 'https://github.com/django/django/commit/b45c377f8f488955e0c7069cad3f3dd21910b071', 'https://github.com/django/django/commit/92d3430f12171f16f566c9050c40feefb830a4a3'} | {'https://github.com/django/django/commit/b45c377f8f488955e0c7069cad3f3dd21910b071', 'https://github.com/django/django/commit/92d3430f12171f16f566c9050c40feefb830a4a3', 'https://github.com/django/django/commit/9305c0e12d43c4df999c3301a1f0c742264a657e'} |
PyPI | PYSEC-2017-42 | null | The password reset form in Weblate before 2.10.1 provides different error messages depending on whether the email address is associated with an account, which allows remote attackers to enumerate user accounts via a series of requests. | {'CVE-2017-5537'} | 2021-07-05T00:01:28.288013Z | 2017-03-15T15:59:00Z | null | null | null | {'https://github.com/WeblateOrg/weblate/blob/weblate-2.10.1/docs/changes.rst', 'http://www.openwall.com/lists/oss-security/2017/01/18/11', 'http://www.securityfocus.com/bid/95676', 'https://github.com/WeblateOrg/weblate/commit/abe0d2a29a1d8e896bfe829c8461bf8b391f1079', 'https://github.com/WeblateOrg/weblate/issues/1317', 'http://www.openwall.com/lists/oss-security/2017/01/20/1'} | null | {'https://github.com/WeblateOrg/weblate/commit/abe0d2a29a1d8e896bfe829c8461bf8b391f1079'} | {'https://github.com/WeblateOrg/weblate/commit/abe0d2a29a1d8e896bfe829c8461bf8b391f1079'} |
PyPI | GHSA-7xxv-wpxj-mx5v | Out-of-bounds read in typed-ast and cpython may allow an attacker to crash the interpreter process (ast_for_arguments case). | typed_ast 1.3.0 and 1.3.1 has an ast_for_arguments out-of-bounds read. An attacker with the ability to cause a Python interpreter to parse Python source (but not necessarily execute it) may be able to crash the interpreter process. This could be a concern, for example, in a web-based service that parses (but does not execute) Python code. (This issue also affected certain Python 3.8.0-alpha prereleases.) | {'CVE-2019-19275'} | 2022-03-03T05:12:41.201920Z | 2019-12-02T18:03:09Z | HIGH | null | {'CWE-125'} | {'https://github.com/python/cpython/commit/a4d78362397fc3bced6ea80fbc7b5f4827aec55e', 'https://bugs.python.org/issue36495', 'https://github.com/python/cpython/commit/dcfcd146f8e6fc5c2fc16a4c192a0c5f5ca8c53c', 'https://nvd.nist.gov/vuln/detail/CVE-2019-19275', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/LG5H4Q6LFVRX7SFXLBEJMNQFI4T5SCEA/', 'https://github.com/python/typed_ast/commit/156afcb26c198e162504a57caddfe0acd9ed7dce', 'https://github.com/python/typed_ast/commit/dc317ac9cff859aa84eeabe03fb5004982545b3b'} | null | {'https://github.com/python/cpython/commit/dcfcd146f8e6fc5c2fc16a4c192a0c5f5ca8c53c', 'https://github.com/python/cpython/commit/a4d78362397fc3bced6ea80fbc7b5f4827aec55e', 'https://github.com/python/typed_ast/commit/dc317ac9cff859aa84eeabe03fb5004982545b3b', 'https://github.com/python/typed_ast/commit/156afcb26c198e162504a57caddfe0acd9ed7dce'} | {'https://github.com/python/cpython/commit/a4d78362397fc3bced6ea80fbc7b5f4827aec55e', 'https://github.com/python/typed_ast/commit/dc317ac9cff859aa84eeabe03fb5004982545b3b', 'https://github.com/python/cpython/commit/dcfcd146f8e6fc5c2fc16a4c192a0c5f5ca8c53c', 'https://github.com/python/typed_ast/commit/156afcb26c198e162504a57caddfe0acd9ed7dce'} |
PyPI | PYSEC-2021-695 | null | TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPoolGradWithArgmax` can cause reads outside of bounds of heap allocated data if attacker supplies specially crafted inputs. The implementation(https://github.com/tensorflow/tensorflow/blob/ac328eaa3870491ababc147822cd04e91a790643/tensorflow/core/kernels/requantization_range_op.cc#L49-L50) assumes that the `input_min` and `input_max` tensors have at least one element, as it accesses the first element in two arrays. If the tensors are empty, `.flat<T>()` is an empty object, backed by an empty array. Hence, accesing even the 0th element is a read outside the bounds. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'CVE-2021-29569', 'GHSA-3h8m-483j-7xxm'} | 2021-12-09T06:35:26.658454Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-3h8m-483j-7xxm', 'https://github.com/tensorflow/tensorflow/commit/ef0c008ee84bad91ec6725ddc42091e19a30cf0e'} | null | {'https://github.com/tensorflow/tensorflow/commit/ef0c008ee84bad91ec6725ddc42091e19a30cf0e'} | {'https://github.com/tensorflow/tensorflow/commit/ef0c008ee84bad91ec6725ddc42091e19a30cf0e'} |
PyPI | GHSA-9w7f-m4j4-j3xw | Gerapy < 0.9.8 may cause remote code execution | ### Impact
project_configure function exist remote code execute in Gerapy < 0.9.8
### Patches
Patched in version 0.9.8, please install with:
```
pip3 install -U gerapy
``` | {'CVE-2021-43857'} | 2022-03-03T05:13:29.100217Z | 2022-01-06T17:36:38Z | HIGH | null | {'CWE-78'} | {'http://packetstormsecurity.com/files/165459/Gerapy-0.9.7-Remote-Code-Execution.html', 'https://github.com/Gerapy/Gerapy/issues/219', 'https://github.com/Gerapy/Gerapy/commit/49bcb19be5e0320e7e1535f34fe00f16a3cf3b28', 'https://github.com/Gerapy/Gerapy', 'https://nvd.nist.gov/vuln/detail/CVE-2021-43857', 'https://github.com/Gerapy/Gerapy/security/advisories/GHSA-9w7f-m4j4-j3xw'} | null | {'https://github.com/Gerapy/Gerapy/commit/49bcb19be5e0320e7e1535f34fe00f16a3cf3b28'} | {'https://github.com/Gerapy/Gerapy/commit/49bcb19be5e0320e7e1535f34fe00f16a3cf3b28'} |
PyPI | PYSEC-2021-553 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of `tf.raw_ops.SparseReshape` can be made to trigger an integral division by 0 exception. The [implementation](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/reshape_util.cc#L176-L181) calls the reshaping functor whenever there is at least an index in the input but does not check that shape of the input or the target shape have both a non-zero number of elements. The [reshape functor](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/reshape_util.cc#L40-L78) blindly divides by the dimensions of the target shape. Hence, if this is not checked, code will result in a division by 0. We have patched the issue in GitHub commit 4923de56ec94fff7770df259ab7f2288a74feb41. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1 as this is the other affected version. | {'GHSA-95xm-g58g-3p88', 'CVE-2021-37640'} | 2021-12-09T06:35:02.412159Z | 2021-08-12T18:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-95xm-g58g-3p88', 'https://github.com/tensorflow/tensorflow/commit/4923de56ec94fff7770df259ab7f2288a74feb41'} | null | {'https://github.com/tensorflow/tensorflow/commit/4923de56ec94fff7770df259ab7f2288a74feb41'} | {'https://github.com/tensorflow/tensorflow/commit/4923de56ec94fff7770df259ab7f2288a74feb41'} |
PyPI | GHSA-3w67-q784-6w7c | Division by zero in TFLite's implementation of `GatherNd` | ### Impact
The reference implementation of the `GatherNd` TFLite operator is [vulnerable to a division by zero error](https://github.com/tensorflow/tensorflow/blob/0d45ea1ca641b21b73bcf9c00e0179cda284e7e7/tensorflow/lite/kernels/internal/reference/reference_ops.h#L966):
```cc
ret.dims_to_count[i] = remain_flat_size / params_shape.Dims(i);
```
An attacker can craft a model such that `params` input would be an empty tensor. In turn, `params_shape.Dims(.)` would be zero, in at least one dimension.
### Patches
We have patched the issue in GitHub commit [8e45822aa0b9f5df4b4c64f221e64dc930a70a9d](https://github.com/tensorflow/tensorflow/commit/8e45822aa0b9f5df4b4c64f221e64dc930a70a9d).
The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by members of the Aivul Team from Qihoo 360. | {'CVE-2021-29589'} | 2022-03-03T05:12:11.969027Z | 2021-05-21T14:26:51Z | LOW | null | {'CWE-369'} | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-3w67-q784-6w7c', 'https://github.com/tensorflow/tensorflow/commit/8e45822aa0b9f5df4b4c64f221e64dc930a70a9d', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29589'} | null | {'https://github.com/tensorflow/tensorflow/commit/8e45822aa0b9f5df4b4c64f221e64dc930a70a9d'} | {'https://github.com/tensorflow/tensorflow/commit/8e45822aa0b9f5df4b4c64f221e64dc930a70a9d'} |
PyPI | PYSEC-2021-800 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can craft a TFLite model that would trigger a null pointer dereference, which would result in a crash and denial of service. This is caused by the MLIR optimization of `L2NormalizeReduceAxis` operator. The [implementation](https://github.com/tensorflow/tensorflow/blob/149562d49faa709ea80df1d99fc41d005b81082a/tensorflow/compiler/mlir/lite/transforms/optimize.cc#L67-L70) unconditionally dereferences a pointer to an iterator to a vector without checking that the vector has elements. We have patched the issue in GitHub commit d6b57f461b39fd1aa8c1b870f1b974aac3554955. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'GHSA-wf5p-c75w-w3wh', 'CVE-2021-37689'} | 2021-12-09T06:35:40.116575Z | 2021-08-12T22:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-wf5p-c75w-w3wh', 'https://github.com/tensorflow/tensorflow/commit/d6b57f461b39fd1aa8c1b870f1b974aac3554955'} | null | {'https://github.com/tensorflow/tensorflow/commit/d6b57f461b39fd1aa8c1b870f1b974aac3554955'} | {'https://github.com/tensorflow/tensorflow/commit/d6b57f461b39fd1aa8c1b870f1b974aac3554955'} |
PyPI | GHSA-j3f7-7rmc-6wqj | Improper certificate management in AWS IoT Device SDK v2 | The AWS IoT Device SDK v2 for Java, Python, C++ and Node.js appends a user supplied Certificate Authority (CA) to the root CAs instead of overriding it on macOS systems. Additionally, SNI validation is also not enabled when the CA has been “overridden”. TLS handshakes will thus succeed if the peer can be verified either from the user-supplied CA or the system’s default trust-store. Attackers with access to a host’s trust stores or are able to compromise a certificate authority already in the host's trust store (note: the attacker must also be able to spoof DNS in this case) may be able to use this issue to bypass CA pinning. An attacker could then spoof the MQTT broker, and either drop traffic and/or respond with the attacker's data, but they would not be able to forward this data on to the MQTT broker because the attacker would still need the user's private keys to authenticate against the MQTT broker. The 'aws_tls_ctx_options_override_default_trust_store_*' function within the aws-c-io submodule has been updated to address this behavior. This issue affects: Amazon Web Services AWS IoT Device SDK v2 for Java versions prior to 1.5.0 on macOS. Amazon Web Services AWS IoT Device SDK v2 for Python versions prior to 1.7.0 on macOS. Amazon Web Services AWS IoT Device SDK v2 for C++ versions prior to 1.14.0 on macOS. Amazon Web Services AWS IoT Device SDK v2 for Node.js versions prior to 1.6.0 on macOS. Amazon Web Services AWS-C-IO 0.10.7 on macOS. | {'CVE-2021-40831'} | 2022-03-03T05:14:12.538986Z | 2021-11-24T20:35:03Z | MODERATE | null | {'CWE-295'} | {'https://github.com/aws/aws-iot-device-sdk-python-v2/commit/5aef82573202309063eb540b72cee0e565f85a2d', 'https://github.com/aws/aws-iot-device-sdk-python-v2', 'https://github.com/awslabs/aws-c-io/', 'https://github.com/aws/aws-iot-device-sdk-cpp-v2', 'https://github.com/aws/aws-iot-device-sdk-js-v2', 'https://github.com/aws/aws-iot-device-sdk-js-v2/commit/22f1989f5bdb0bdd9c912a5a2d255ee6c0854f68', 'https://github.com/aws/aws-iot-device-sdk-java-v2', 'https://nvd.nist.gov/vuln/detail/CVE-2021-40831', 'https://github.com/aws/aws-iot-device-sdk-java-v2/commit/46375e9b1bfb34109b9ff3b1eff9c770f9daa186'} | null | {'https://github.com/aws/aws-iot-device-sdk-js-v2/commit/22f1989f5bdb0bdd9c912a5a2d255ee6c0854f68', 'https://github.com/aws/aws-iot-device-sdk-java-v2/commit/46375e9b1bfb34109b9ff3b1eff9c770f9daa186', 'https://github.com/aws/aws-iot-device-sdk-python-v2/commit/5aef82573202309063eb540b72cee0e565f85a2d'} | {'https://github.com/aws/aws-iot-device-sdk-js-v2/commit/22f1989f5bdb0bdd9c912a5a2d255ee6c0854f68', 'https://github.com/aws/aws-iot-device-sdk-python-v2/commit/5aef82573202309063eb540b72cee0e565f85a2d', 'https://github.com/aws/aws-iot-device-sdk-java-v2/commit/46375e9b1bfb34109b9ff3b1eff9c770f9daa186'} |
PyPI | PYSEC-2021-416 | null | TensorFlow is an open source platform for machine learning. In affected versions the implementation of `SparseFillEmptyRows` can be made to trigger a heap OOB access. This occurs whenever the size of `indices` does not match the size of `values`. The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range. | {'GHSA-rg3m-hqc5-344v', 'CVE-2021-41224'} | 2021-11-13T06:52:45.767410Z | 2021-11-05T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-rg3m-hqc5-344v', 'https://github.com/tensorflow/tensorflow/commit/67bfd9feeecfb3c61d80f0e46d89c170fbee682b'} | null | {'https://github.com/tensorflow/tensorflow/commit/67bfd9feeecfb3c61d80f0e46d89c170fbee682b'} | {'https://github.com/tensorflow/tensorflow/commit/67bfd9feeecfb3c61d80f0e46d89c170fbee682b'} |
PyPI | GHSA-x345-32rc-8h85 | Denial of service attack via push rule patterns in matrix-synapse | ### Impact
"Push rules" can specify [conditions](https://matrix.org/docs/spec/client_server/r0.6.1#conditions) under which they will match, including `event_match`, which matches event content against a pattern including wildcards.
Certain patterns can cause very poor performance in the matching engine, leading to a denial-of-service when processing moderate length events.
### Patches
The issue is patched by https://github.com/matrix-org/synapse/commit/03318a766cac9f8b053db2214d9c332a977d226c.
### Workarounds
A potential workaround might be to prevent users from making custom push rules, by blocking such requests at a reverse-proxy.
### For more information
If you have any questions or comments about this advisory, email us at security@matrix.org. | {'CVE-2021-29471'} | 2022-04-07T15:17:03.062048Z | 2021-05-13T20:22:51Z | LOW | null | {'CWE-400', 'CWE-331'} | {'https://github.com/matrix-org/synapse', 'https://github.com/matrix-org/synapse/releases/tag/v1.33.2', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29471', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/TNNAJOZNMVMXM6AS7RFFKB4QLUJ4IFEY/', 'https://github.com/matrix-org/synapse/security/advisories/GHSA-x345-32rc-8h85', 'https://github.com/matrix-org/synapse/commit/03318a766cac9f8b053db2214d9c332a977d226c'} | null | {'https://github.com/matrix-org/synapse/commit/03318a766cac9f8b053db2214d9c332a977d226c'} | {'https://github.com/matrix-org/synapse/commit/03318a766cac9f8b053db2214d9c332a977d226c'} |
PyPI | GHSA-g8wg-cjwc-xhhp | Heap OOB in nested `tf.map_fn` with `RaggedTensor`s | ### Impact
It is possible to nest a `tf.map_fn` within another `tf.map_fn` call. However, if the input tensor is a `RaggedTensor` and there is no function signature provided, code assumes the output is a fully specified tensor and fills output buffer with uninitialized contents from the heap:
```python
import tensorflow as tf
x = tf.ragged.constant([[1,2,3], [4,5], [6]])
t = tf.map_fn(lambda r: tf.map_fn(lambda y: r, r), x)
z = tf.ragged.constant([[[1,2,3],[1,2,3],[1,2,3]],[[4,5],[4,5]],[[6]]])
```
The `t` and `z` outputs should be identical, however this is not the case. The last row of `t` contains data from the heap which can be used to leak other memory information.
The bug lies in the conversion from a `Variant` tensor to a `RaggedTensor`. The [implementation](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/core/kernels/ragged_tensor_from_variant_op.cc#L177-L190) does not check that all inner shapes match and this results in the additional dimensions in the above example.
The same implementation can result in data loss, if input tensor is tweaked:
```python
import tensorflow as tf
x = tf.ragged.constant([[1,2], [3,4,5], [6]])
t = tf.map_fn(lambda r: tf.map_fn(lambda y: r, r), x)
```
Here, the output tensor will only have 2 elements for each inner dimension.
### Patches
We have patched the issue in GitHub commit [4e2565483d0ffcadc719bd44893fb7f609bb5f12](https://github.com/tensorflow/tensorflow/commit/4e2565483d0ffcadc719bd44893fb7f609bb5f12).
The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by Haris Sahovic. | {'CVE-2021-37679'} | 2022-03-03T05:13:19.482245Z | 2021-08-25T14:41:00Z | HIGH | null | {'CWE-125', 'CWE-681'} | {'https://github.com/tensorflow/tensorflow', 'https://github.com/tensorflow/tensorflow/commit/4e2565483d0ffcadc719bd44893fb7f609bb5f12', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-g8wg-cjwc-xhhp', 'https://nvd.nist.gov/vuln/detail/CVE-2021-37679'} | null | {'https://github.com/tensorflow/tensorflow/commit/4e2565483d0ffcadc719bd44893fb7f609bb5f12'} | {'https://github.com/tensorflow/tensorflow/commit/4e2565483d0ffcadc719bd44893fb7f609bb5f12'} |
PyPI | PYSEC-2021-734 | null | TensorFlow is an end-to-end open source platform for machine learning. Due to lack of validation in `tf.raw_ops.RaggedTensorToTensor`, an attacker can exploit an undefined behavior if input arguments are empty. The implementation(https://github.com/tensorflow/tensorflow/blob/656e7673b14acd7835dc778867f84916c6d1cac2/tensorflow/core/kernels/ragged_tensor_to_tensor_op.cc#L356-L360) only checks that one of the tensors is not empty, but does not check for the other ones. There are multiple `DCHECK` validations to prevent heap OOB, but these are no-op in release builds, hence they don't prevent anything. The fix will be included in TensorFlow 2.5.0. We will also cherrypick these commits on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'GHSA-rgvq-pcvf-hx75', 'CVE-2021-29608'} | 2021-12-09T06:35:33.390905Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/b761c9b652af2107cfbc33efd19be0ce41daa33e', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-rgvq-pcvf-hx75', 'https://github.com/tensorflow/tensorflow/commit/c4d7afb6a5986b04505aca4466ae1951686c80f6', 'https://github.com/tensorflow/tensorflow/commit/f94ef358bb3e91d517446454edff6535bcfe8e4a'} | null | {'https://github.com/tensorflow/tensorflow/commit/b761c9b652af2107cfbc33efd19be0ce41daa33e', 'https://github.com/tensorflow/tensorflow/commit/c4d7afb6a5986b04505aca4466ae1951686c80f6', 'https://github.com/tensorflow/tensorflow/commit/f94ef358bb3e91d517446454edff6535bcfe8e4a'} | {'https://github.com/tensorflow/tensorflow/commit/c4d7afb6a5986b04505aca4466ae1951686c80f6', 'https://github.com/tensorflow/tensorflow/commit/b761c9b652af2107cfbc33efd19be0ce41daa33e', 'https://github.com/tensorflow/tensorflow/commit/f94ef358bb3e91d517446454edff6535bcfe8e4a'} |
PyPI | PYSEC-2021-364 | null | Scrapy-splash is a library which provides Scrapy and JavaScript integration. In affected versions users who use [`HttpAuthMiddleware`](http://doc.scrapy.org/en/latest/topics/downloader-middleware.html#module-scrapy.downloadermiddlewares.httpauth) (i.e. the `http_user` and `http_pass` spider attributes) for Splash authentication will have any non-Splash request expose your credentials to the request target. This includes `robots.txt` requests sent by Scrapy when the `ROBOTSTXT_OBEY` setting is set to `True`. Upgrade to scrapy-splash 0.8.0 and use the new `SPLASH_USER` and `SPLASH_PASS` settings instead to set your Splash authentication credentials safely. If you cannot upgrade, set your Splash request credentials on a per-request basis, [using the `splash_headers` request parameter](https://github.com/scrapy-plugins/scrapy-splash/tree/0.8.x#http-basic-auth), instead of defining them globally using the [`HttpAuthMiddleware`](http://doc.scrapy.org/en/latest/topics/downloader-middleware.html#module-scrapy.downloadermiddlewares.httpauth). Alternatively, make sure all your requests go through Splash. That includes disabling the [robots.txt middleware](https://docs.scrapy.org/en/latest/topics/downloader-middleware.html#topics-dlmw-robots). | {'CVE-2021-41124', 'GHSA-823f-cwm9-4g74'} | 2021-10-11T01:16:42.816754Z | 2021-10-05T21:15:00Z | null | null | null | {'https://github.com/scrapy-plugins/scrapy-splash/security/advisories/GHSA-823f-cwm9-4g74', 'https://github.com/scrapy-plugins/scrapy-splash/commit/2b253e57fe64ec575079c8cdc99fe2013502ea31'} | null | {'https://github.com/scrapy-plugins/scrapy-splash/commit/2b253e57fe64ec575079c8cdc99fe2013502ea31'} | {'https://github.com/scrapy-plugins/scrapy-splash/commit/2b253e57fe64ec575079c8cdc99fe2013502ea31'} |
PyPI | PYSEC-2021-671 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a denial of service via a `CHECK`-fail in converting sparse tensors to CSR Sparse matrices. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/800346f2c03a27e182dd4fba48295f65e7790739/tensorflow/core/kernels/sparse/kernels.cc#L66) does a double redirection to access an element of an array allocated on the heap. If the value at `indices(i, 0)` is such that `indices(i, 0) + 1` is outside the bounds of `csr_row_ptr`, this results in writing outside of bounds of heap allocated data. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'CVE-2021-29545', 'GHSA-hmg3-c7xj-6qwm'} | 2021-12-09T06:35:22.627279Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-hmg3-c7xj-6qwm', 'https://github.com/tensorflow/tensorflow/commit/1e922ccdf6bf46a3a52641f99fd47d54c1decd13'} | null | {'https://github.com/tensorflow/tensorflow/commit/1e922ccdf6bf46a3a52641f99fd47d54c1decd13'} | {'https://github.com/tensorflow/tensorflow/commit/1e922ccdf6bf46a3a52641f99fd47d54c1decd13'} |
PyPI | GHSA-c9qf-r67m-p7cg | Null pointer dereference in `CompressElement` | ### Impact
It is possible to trigger a null pointer dereference in TensorFlow by passing an invalid input to `tf.raw_ops.CompressElement`:
```python
import tensorflow as tf
tf.raw_ops.CompressElement(components=[[]])
```
The [implementation](https://github.com/tensorflow/tensorflow/blob/47a06f40411a69c99f381495f490536972152ac0/tensorflow/core/data/compression_utils.cc#L34) was accessing the size of a buffer obtained from the return of a separate function call before validating that said buffer is valid.
### Patches
We have patched the issue in GitHub commit [5dc7f6981fdaf74c8c5be41f393df705841fb7c5](https://github.com/tensorflow/tensorflow/commit/5dc7f6981fdaf74c8c5be41f393df705841fb7c5).
The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by members of the Aivul Team from Qihoo 360. Concurrently, it was resolved in `master` branch as it was also discovered internally and fixed before the report was handled. | {'CVE-2021-37637'} | 2022-03-03T05:12:29.841961Z | 2021-08-25T14:44:12Z | HIGH | null | {'CWE-476'} | {'https://github.com/tensorflow/tensorflow/commit/5dc7f6981fdaf74c8c5be41f393df705841fb7c5', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-c9qf-r67m-p7cg', 'https://nvd.nist.gov/vuln/detail/CVE-2021-37637'} | null | {'https://github.com/tensorflow/tensorflow/commit/5dc7f6981fdaf74c8c5be41f393df705841fb7c5'} | {'https://github.com/tensorflow/tensorflow/commit/5dc7f6981fdaf74c8c5be41f393df705841fb7c5'} |
PyPI | PYSEC-2021-221 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a denial of service via a `CHECK`-fail in caused by an integer overflow in constructing a new tensor shape. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/0908c2f2397c099338b901b067f6495a5b96760b/tensorflow/core/kernels/sparse_split_op.cc#L66-L70) builds a dense shape without checking that the dimensions would not result in overflow. The `TensorShape` constructor(https://github.com/tensorflow/tensorflow/blob/6f9896890c4c703ae0a0845394086e2e1e523299/tensorflow/core/framework/tensor_shape.cc#L183-L188) uses a `CHECK` operation which triggers when `InitDims`(https://github.com/tensorflow/tensorflow/blob/6f9896890c4c703ae0a0845394086e2e1e523299/tensorflow/core/framework/tensor_shape.cc#L212-L296) returns a non-OK status. This is a legacy implementation of the constructor and operations should use `BuildTensorShapeBase` or `AddDimWithStatus` to prevent `CHECK`-failures in the presence of overflows. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. | {'GHSA-xvjm-fvxx-q3hv', 'CVE-2021-29584'} | 2021-08-27T03:22:36.340283Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/4c0ee937c0f61c4fc5f5d32d9bb4c67428012a60', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-xvjm-fvxx-q3hv'} | null | {'https://github.com/tensorflow/tensorflow/commit/4c0ee937c0f61c4fc5f5d32d9bb4c67428012a60'} | {'https://github.com/tensorflow/tensorflow/commit/4c0ee937c0f61c4fc5f5d32d9bb4c67428012a60'} |
PyPI | PYSEC-2021-108 | null | An issue was discovered in urllib3 before 1.26.5. When provided with a URL containing many @ characters in the authority component, the authority regular expression exhibits catastrophic backtracking, causing a denial of service if a URL were passed as a parameter or redirected to via an HTTP redirect. | {'GHSA-q2q7-5pp4-w6pg', 'CVE-2021-33503'} | 2021-07-02T18:56:20.858344Z | 2021-06-29T11:15:00Z | null | null | null | {'https://github.com/advisories/GHSA-q2q7-5pp4-w6pg', 'https://github.com/urllib3/urllib3/commit/2d4a3fee6de2fa45eb82169361918f759269b4ec'} | null | {'https://github.com/urllib3/urllib3/commit/2d4a3fee6de2fa45eb82169361918f759269b4ec'} | {'https://github.com/urllib3/urllib3/commit/2d4a3fee6de2fa45eb82169361918f759269b4ec'} |
PyPI | PYSEC-2021-558 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation of `tf.raw_ops.QuantizeAndDequantizeV4Grad` is vulnerable to an integer overflow issue caused by converting a signed integer value to an unsigned one and then allocating memory based on this value. The [implementation](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/quantize_and_dequantize_op.cc#L126) uses the `axis` value as the size argument to `absl::InlinedVector` constructor. But, the constructor uses an unsigned type for the argument, so the implicit conversion transforms the negative value to a large integer. We have patched the issue in GitHub commit 96f364a1ca3009f98980021c4b32be5fdcca33a1. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, and TensorFlow 2.4.3, as these are also affected and still in supported range. | {'CVE-2021-37645', 'GHSA-9w2p-5mgw-p94c'} | 2021-12-09T06:35:02.832886Z | 2021-08-12T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/96f364a1ca3009f98980021c4b32be5fdcca33a1', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-9w2p-5mgw-p94c'} | null | {'https://github.com/tensorflow/tensorflow/commit/96f364a1ca3009f98980021c4b32be5fdcca33a1'} | {'https://github.com/tensorflow/tensorflow/commit/96f364a1ca3009f98980021c4b32be5fdcca33a1'} |
PyPI | GHSA-pgcq-h79j-2f69 | Incomplete validation of shapes in multiple TF ops | ### Impact
Several TensorFlow operations are missing validation for the shapes of the tensor arguments involved in the call. Depending on the API, this can result in undefined behavior and segfault or `CHECK`-fail related crashes but in some scenarios writes and reads from heap populated arrays are also possible.
We have discovered these issues internally via tooling while working on improving/testing GPU op determinism. As such, we don't have reproducers and there will be multiple fixes for these issues.
### Patches
We have patched the issue in GitHub commits [68422b215e618df5ad375bcdc6d2052e9fd3080a](https://github.com/tensorflow/tensorflow/commit/68422b215e618df5ad375bcdc6d2052e9fd3080a), [4d74d8a00b07441cba090a02e0dd9ed385145bf4](https://github.com/tensorflow/tensorflow/commit/4d74d8a00b07441cba090a02e0dd9ed385145bf4), [579261dcd446385831fe4f7457d802a59685121d](https://github.com/tensorflow/tensorflow/commit/579261dcd446385831fe4f7457d802a59685121d), [da4aad5946be30e5f049920fa076e1f7ef021261](https://github.com/tensorflow/tensorflow/commit/da4aad5946be30e5f049920fa076e1f7ef021261), [4dddb2fd0b01cdd196101afbba6518658a2c9e07](https://github.com/tensorflow/tensorflow/commit/4dddb2fd0b01cdd196101afbba6518658a2c9e07), and [e7f497570abb6b4ae5af4970620cd880e4c0c904](https://github.com/tensorflow/tensorflow/commit/e7f497570abb6b4ae5af4970620cd880e4c0c904).
These fixes will be included in TensorFlow 2.7.0. We will also cherrypick these commits on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions. | {'CVE-2021-41206'} | 2022-03-03T05:13:43.298539Z | 2021-11-10T19:03:38Z | HIGH | null | {'CWE-354'} | {'https://nvd.nist.gov/vuln/detail/CVE-2021-41206', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-pgcq-h79j-2f69', 'https://github.com/tensorflow/tensorflow/commit/da4aad5946be30e5f049920fa076e1f7ef021261', 'https://github.com/tensorflow/tensorflow/commit/4dddb2fd0b01cdd196101afbba6518658a2c9e07', 'https://github.com/tensorflow/tensorflow/commit/e7f497570abb6b4ae5af4970620cd880e4c0c904', 'https://github.com/tensorflow/tensorflow/commit/68422b215e618df5ad375bcdc6d2052e9fd3080a', 'https://github.com/tensorflow/tensorflow/commit/4d74d8a00b07441cba090a02e0dd9ed385145bf4', 'https://github.com/tensorflow/tensorflow/commit/579261dcd446385831fe4f7457d802a59685121d', 'https://github.com/tensorflow/tensorflow'} | null | {'https://github.com/tensorflow/tensorflow/commit/68422b215e618df5ad375bcdc6d2052e9fd3080a', 'https://github.com/tensorflow/tensorflow/commit/e7f497570abb6b4ae5af4970620cd880e4c0c904', 'https://github.com/tensorflow/tensorflow/commit/4dddb2fd0b01cdd196101afbba6518658a2c9e07', 'https://github.com/tensorflow/tensorflow/commit/da4aad5946be30e5f049920fa076e1f7ef021261', 'https://github.com/tensorflow/tensorflow/commit/4d74d8a00b07441cba090a02e0dd9ed385145bf4', 'https://github.com/tensorflow/tensorflow/commit/579261dcd446385831fe4f7457d802a59685121d'} | {'https://github.com/tensorflow/tensorflow/commit/4d74d8a00b07441cba090a02e0dd9ed385145bf4', 'https://github.com/tensorflow/tensorflow/commit/4dddb2fd0b01cdd196101afbba6518658a2c9e07', 'https://github.com/tensorflow/tensorflow/commit/68422b215e618df5ad375bcdc6d2052e9fd3080a', 'https://github.com/tensorflow/tensorflow/commit/579261dcd446385831fe4f7457d802a59685121d', 'https://github.com/tensorflow/tensorflow/commit/e7f497570abb6b4ae5af4970620cd880e4c0c904', 'https://github.com/tensorflow/tensorflow/commit/da4aad5946be30e5f049920fa076e1f7ef021261'} |
PyPI | GHSA-3m3h-v9hv-9j4h | Cross-site Scripting in django-wiki | In Django-wiki, versions 0.0.20 to 0.7.8 are vulnerable to Stored Cross-Site Scripting (XSS) in Notifications Section. An attacker who has access to edit pages can inject JavaScript payload in the title field. When a victim gets a notification regarding the changes made in the application, the payload in the notification panel renders and loads external JavaScript. | {'CVE-2021-25986'} | 2022-03-03T05:11:38.545951Z | 2021-12-02T17:49:40Z | MODERATE | null | {'CWE-79'} | {'https://github.com/django-wiki/django-wiki', 'https://www.whitesourcesoftware.com/vulnerability-database/CVE-2021-25986', 'https://github.com/django-wiki/django-wiki/pull/1148', 'https://github.com/django-wiki/django-wiki/commit/9eaccc7519e4206a4d2f22640882f0737b2da9c5', 'https://nvd.nist.gov/vuln/detail/CVE-2021-25986'} | null | {'https://github.com/django-wiki/django-wiki/commit/9eaccc7519e4206a4d2f22640882f0737b2da9c5'} | {'https://github.com/django-wiki/django-wiki/commit/9eaccc7519e4206a4d2f22640882f0737b2da9c5'} |
PyPI | GHSA-57wx-m983-2f88 | Incomplete validation in boosted trees code | ### Impact
The [code for boosted trees in TensorFlow](https://github.com/tensorflow/tensorflow/blob/e0b6e58c328059829c3eb968136f17aa72b6c876/tensorflow/core/kernels/boosted_trees/stats_ops.cc) is still missing validation. As a result, attackers can trigger denial of service (via dereferencing `nullptr`s or via `CHECK`-failures) as well as abuse undefined behavior (binding references to `nullptr`s). An attacker can also read and write from heap buffers, depending on the API that gets used and the arguments that are passed to the call.
**Note**: Given that the boosted trees implementation in TensorFlow is unmaintained, it is recommend to no longer use these APIs. Instead, please use the downstream [TensorFlow Decision Forests](https://github.com/tensorflow/decision-forests) project which is newer and supports more features. We will deprecate TensorFlow's boosted trees APIs in subsequent releases.
### Patches
We have patched the issue in GitHub commit [5c8c9a8bfe750f9743d0c859bae112060b216f5c](https://github.com/tensorflow/tensorflow/commit/5c8c9a8bfe750f9743d0c859bae112060b216f5c).
The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by members of the Aivul Team from Qihoo 360. | {'CVE-2021-41208'} | 2022-03-03T05:12:33.756260Z | 2021-11-10T19:37:56Z | CRITICAL | null | {'CWE-476', 'CWE-824'} | {'https://github.com/tensorflow/tensorflow', 'https://github.com/tensorflow/tensorflow/commit/5c8c9a8bfe750f9743d0c859bae112060b216f5c', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-57wx-m983-2f88', 'https://nvd.nist.gov/vuln/detail/CVE-2021-41208'} | null | {'https://github.com/tensorflow/tensorflow/commit/5c8c9a8bfe750f9743d0c859bae112060b216f5c'} | {'https://github.com/tensorflow/tensorflow/commit/5c8c9a8bfe750f9743d0c859bae112060b216f5c'} |
PyPI | GHSA-q34h-97wf-8r8j | vault-cli contains possible RCE when reading user-defined data | ### Impact
_What kind of vulnerability is it? Who is impacted?_
vault-cli features the ability for rendering templated values (as explained in the [documentation](https://github.com/peopledoc/vault-cli/blob/2.2.1/docs/howto/templated_secrets.rst)). When a secret starts with the prefix `!template!`, vault-cli interprets the rest of the contents of the secret as a Jinja2 template.
Jinja2 is a powerful templating engine and it's not designed to safely render arbitrary templates. An attacker controlling a jinja2 template rendered on a machine can trigger arbitrary code, making this a Remote Code Execution (RCE) risk.
If the content of the vault can be completely trusted, then this is not a problem. Otherwise, if your threat model includes cases where an attacker can manipulate a secret value read from the vault using vault-cli, then this vulnerability may impact you.
This does not impact `vault` itself, except for the fact that the attacker, having an RCE on the machine that executes `vault-cli`, may abuse the token that `vault-cli` uses, to read, write or delete other data from the vault.
### Patches
_Has the problem been patched? What versions should users upgrade to?_
In 3.0.0, the code related to interpreting vault templated secrets has been removed entirely.
### Workarounds
_Is there a way for users to fix or remediate the vulnerability without upgrading?_
Using the environment variable `VAULT_CLI_RENDER=false` or the flag `--no-render` (placed between `vault-cli` and the subcommand, e.g. `vault-cli --no-render get-all`) or adding `render: false` to the vault-cli configuration yaml file disables rendering and removes the vulnerability.
Using the python library, you can use: `vault_cli.get_client(render=False)` when creating your client to get a client that will not render templated secrets and thus operates securely.
### References
_Are there any links users can visit to find out more?_
Here's an article explaining how jinja2 templates might be exploited to have side effects: https://podalirius.net/en/publications/grehack-2021-optimizing-ssti-payloads-for-jinja2/
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [the vault-cli repo](https://github.com/peopledoc/vault-cli/issues/new)
| {'CVE-2021-43837'} | 2022-03-03T05:13:34.513125Z | 2021-12-16T21:02:12Z | HIGH | null | {'CWE-74'} | {'https://github.com/peopledoc/vault-cli', 'https://github.com/peopledoc/vault-cli/releases/tag/3.0.0', 'https://github.com/peopledoc/vault-cli/commit/3ba3955887fd6b7d4d646c8b260f21cebf5db852', 'https://github.com/peopledoc/vault-cli/security/advisories/GHSA-q34h-97wf-8r8j', 'https://nvd.nist.gov/vuln/detail/CVE-2021-43837', 'https://github.com/peopledoc/vault-cli/pull/198', 'https://podalirius.net/en/publications/grehack-2021-optimizing-ssti-payloads-for-jinja2/'} | null | {'https://github.com/peopledoc/vault-cli/commit/3ba3955887fd6b7d4d646c8b260f21cebf5db852'} | {'https://github.com/peopledoc/vault-cli/commit/3ba3955887fd6b7d4d646c8b260f21cebf5db852'} |
PyPI | PYSEC-2022-101 | null | Tensorflow is an Open Source Machine Learning Framework. TensorFlow's type inference can cause a heap out of bounds read as the bounds checking is done in a `DCHECK` (which is a no-op during production). An attacker can control the `input_idx` variable such that `ix` would be larger than the number of values in `node_t.args`. The fix will be included in TensorFlow 2.8.0. This is the only affected version. | {'CVE-2022-23592', 'GHSA-vq36-27g6-p492'} | 2022-03-09T00:17:36.334274Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/blob/274df9b02330b790aa8de1cee164b70f72b9b244/tensorflow/core/graph/graph.cc#L223-L229', 'https://github.com/tensorflow/tensorflow/commit/c99d98cd189839dcf51aee94e7437b54b31f8abd', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-vq36-27g6-p492'} | null | {'https://github.com/tensorflow/tensorflow/commit/c99d98cd189839dcf51aee94e7437b54b31f8abd'} | {'https://github.com/tensorflow/tensorflow/commit/c99d98cd189839dcf51aee94e7437b54b31f8abd'} |
PyPI | PYSEC-2021-333 | null | sqlparse is a non-validating SQL parser module for Python. In sqlparse versions 0.4.0 and 0.4.1 there is a regular Expression Denial of Service in sqlparse vulnerability. The regular expression may cause exponential backtracking on strings containing many repetitions of '\r\n' in SQL comments. Only the formatting feature that removes comments from SQL statements is affected by this regular expression. As a workaround don't use the sqlformat.format function with keyword strip_comments=True or the --strip-comments command line flag when using the sqlformat command line tool. The issues has been fixed in sqlparse 0.4.2. | {'CVE-2021-32839', 'GHSA-p5w8-wqhj-9hhf'} | 2021-09-23T00:11:34.256842Z | 2021-09-20T17:15:00Z | null | null | null | {'https://github.com/andialbrecht/sqlparse/commit/8238a9e450ed1524e40cb3a8b0b3c00606903aeb', 'https://github.com/andialbrecht/sqlparse/security/advisories/GHSA-p5w8-wqhj-9hhf'} | null | {'https://github.com/andialbrecht/sqlparse/commit/8238a9e450ed1524e40cb3a8b0b3c00606903aeb'} | {'https://github.com/andialbrecht/sqlparse/commit/8238a9e450ed1524e40cb3a8b0b3c00606903aeb'} |
PyPI | PYSEC-2021-763 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions the implementation for `tf.raw_ops.BoostedTreesCreateEnsemble` can result in a use after free error if an attacker supplies specially crafted arguments. The [implementation](https://github.com/tensorflow/tensorflow/blob/f24faa153ad31a4b51578f8181d3aaab77a1ddeb/tensorflow/core/kernels/boosted_trees/resource_ops.cc#L55) uses a reference counted resource and decrements the refcount if the initialization fails, as it should. However, when the code was written, the resource was represented as a naked pointer but later refactoring has changed it to be a smart pointer. Thus, when the pointer leaves the scope, a subsequent `free`-ing of the resource occurs, but this fails to take into account that the refcount has already reached 0, thus the resource has been already freed. During this double-free process, members of the resource object are accessed for cleanup but they are invalid as the entire resource has been freed. We have patched the issue in GitHub commit 5ecec9c6fbdbc6be03295685190a45e7eee726ab. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'CVE-2021-37652', 'GHSA-m7fm-4jfh-jrg6'} | 2021-12-09T06:35:36.820839Z | 2021-08-12T22:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/5ecec9c6fbdbc6be03295685190a45e7eee726ab', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-m7fm-4jfh-jrg6'} | null | {'https://github.com/tensorflow/tensorflow/commit/5ecec9c6fbdbc6be03295685190a45e7eee726ab'} | {'https://github.com/tensorflow/tensorflow/commit/5ecec9c6fbdbc6be03295685190a45e7eee726ab'} |
PyPI | PYSEC-2021-299 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions 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. The shape inference [implementation](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/core/ops/array_ops.cc#L2999-L3014) uses `axis` to select between two different values for `minmax_rank` which is then used to retrieve tensor dimensions. However, code assumes that `axis` can be either `-1` or a value greater than `-1`, with no validation for the other values. We have patched the issue in GitHub commit da857cfa0fde8f79ad0afdbc94e88b5d4bbec764. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'CVE-2021-37677', 'GHSA-qfpc-5pjr-mh26'} | 2021-08-27T03:22:46.477427Z | 2021-08-12T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-qfpc-5pjr-mh26', 'https://github.com/tensorflow/tensorflow/commit/da857cfa0fde8f79ad0afdbc94e88b5d4bbec764'} | null | {'https://github.com/tensorflow/tensorflow/commit/da857cfa0fde8f79ad0afdbc94e88b5d4bbec764'} | {'https://github.com/tensorflow/tensorflow/commit/da857cfa0fde8f79ad0afdbc94e88b5d4bbec764'} |
PyPI | PYSEC-2020-333 | null | In affected versions of TensorFlow the tf.raw_ops.DataFormatVecPermute API does not validate the src_format and dst_format attributes. The code assumes that these two arguments define a permutation of NHWC. This can result in uninitialized memory accesses, read outside of bounds and even crashes. This is fixed in versions 1.15.5, 2.0.4, 2.1.3, 2.2.2, 2.3.2, and 2.4.0. | {'CVE-2020-26267', 'GHSA-c9f3-9wfr-wgh7'} | 2021-12-09T06:35:16.197426Z | 2020-12-10T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-c9f3-9wfr-wgh7', 'https://github.com/tensorflow/tensorflow/commit/ebc70b7a592420d3d2f359e4b1694c236b82c7ae'} | null | {'https://github.com/tensorflow/tensorflow/commit/ebc70b7a592420d3d2f359e4b1694c236b82c7ae'} | {'https://github.com/tensorflow/tensorflow/commit/ebc70b7a592420d3d2f359e4b1694c236b82c7ae'} |
PyPI | PYSEC-2020-299 | null | In affected versions of TensorFlow the tf.raw_ops.ImmutableConst operation returns a constant tensor created from a memory mapped file which is assumed immutable. However, if the type of the tensor is not an integral type, the operation crashes the Python interpreter as it tries to write to the memory area. If the file is too small, TensorFlow properly returns an error as the memory area has fewer bytes than what is needed for the tensor it creates. However, as soon as there are enough bytes, the above snippet causes a segmentation fault. This is because the allocator used to return the buffer data is not marked as returning an opaque handle since the needed virtual method is not overridden. This is fixed in versions 1.15.5, 2.0.4, 2.1.3, 2.2.2, 2.3.2, and 2.4.0. | {'CVE-2020-26268', 'GHSA-hhvc-g5hv-48c6'} | 2021-12-09T06:34:44.590878Z | 2020-12-10T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-hhvc-g5hv-48c6', 'https://github.com/tensorflow/tensorflow/commit/c1e1fc899ad5f8c725dcbb6470069890b5060bc7'} | null | {'https://github.com/tensorflow/tensorflow/commit/c1e1fc899ad5f8c725dcbb6470069890b5060bc7'} | {'https://github.com/tensorflow/tensorflow/commit/c1e1fc899ad5f8c725dcbb6470069890b5060bc7'} |
PyPI | PYSEC-2020-276 | null | In Tensorflow version 2.3.0, the `SparseCountSparseOutput` and `RaggedCountSparseOutput` implementations don't validate that the `weights` tensor has the same shape as the data. The check exists for `DenseCountSparseOutput`, where both tensors are fully specified. In the sparse and ragged count weights are still accessed in parallel with the data. But, since there is no validation, a user passing fewer weights than the values for the tensors can generate a read from outside the bounds of the heap buffer allocated for the weights. The issue is patched in commit 3cbb917b4714766030b28eba9fb41bb97ce9ee02 and is released in TensorFlow version 2.3.1. | {'GHSA-pg59-2f92-5cph', 'CVE-2020-15196'} | 2021-12-09T06:34:41.429939Z | 2020-09-25T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/3cbb917b4714766030b28eba9fb41bb97ce9ee02', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-pg59-2f92-5cph', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.3.1'} | null | {'https://github.com/tensorflow/tensorflow/commit/3cbb917b4714766030b28eba9fb41bb97ce9ee02'} | {'https://github.com/tensorflow/tensorflow/commit/3cbb917b4714766030b28eba9fb41bb97ce9ee02'} |
PyPI | PYSEC-2021-276 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions 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. The [implementation](https://github.com/tensorflow/tensorflow/blob/f24faa153ad31a4b51578f8181d3aaab77a1ddeb/tensorflow/core/kernels/resource_variable_ops.cc#L660-L668) does not check that the `batch_dims` value that the user supplies is less than the rank of the input tensor. Since the implementation uses several for loops over the dimensions of `tensor`, this results in reading data from outside the bounds of heap allocated buffer backing the tensor. We have patched the issue in GitHub commit bc9c546ce7015c57c2f15c168b3d9201de679a1d. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'CVE-2021-37654', 'GHSA-2r8p-fg3c-wcj4'} | 2021-08-27T03:22:44.348474Z | 2021-08-12T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-2r8p-fg3c-wcj4', 'https://github.com/tensorflow/tensorflow/commit/bc9c546ce7015c57c2f15c168b3d9201de679a1d'} | null | {'https://github.com/tensorflow/tensorflow/commit/bc9c546ce7015c57c2f15c168b3d9201de679a1d'} | {'https://github.com/tensorflow/tensorflow/commit/bc9c546ce7015c57c2f15c168b3d9201de679a1d'} |
PyPI | GHSA-rv62-4pmj-xw6h | Moderate severity vulnerability that affects jupyterhub and notebook | An Open Redirect vulnerability for all browsers in Jupyter Notebook before 5.7.8 and some browsers (Chrome, Firefox) in JupyterHub before 0.9.6 allows crafted links to the login page, which will redirect to a malicious site after successful login. Servers running on a base_url prefix are not affected. | {'CVE-2019-10255'} | 2022-03-03T05:13:29.561514Z | 2019-04-02T15:46:54Z | MODERATE | null | {'CWE-601'} | {'https://github.com/jupyter/notebook', 'https://github.com/jupyter/notebook/commit/70fe9f0ddb3023162ece21fbb77d5564306b913b', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/UP5RLEES2JBBNSNLBR65XM6PCD4EMF7D/', 'https://github.com/jupyter/notebook/commit/08c4c898182edbe97aadef1815cce50448f975cb', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/VMDPJBVXOVO6LYGAT46VZNHH6JKSCURO/', 'https://nvd.nist.gov/vuln/detail/CVE-2019-10255', 'https://github.com/jupyter/notebook/compare/05aa4b2...16cf97c', 'https://blog.jupyter.org/open-redirect-vulnerability-in-jupyter-jupyterhub-adf43583f1e4', 'https://github.com/jupyter/notebook/commit/d65328d4841892b412aef9015165db1eb029a8ed', 'https://github.com/advisories/GHSA-rv62-4pmj-xw6h'} | null | {'https://github.com/jupyter/notebook/commit/d65328d4841892b412aef9015165db1eb029a8ed', 'https://github.com/jupyter/notebook/commit/70fe9f0ddb3023162ece21fbb77d5564306b913b', 'https://github.com/jupyter/notebook/commit/08c4c898182edbe97aadef1815cce50448f975cb'} | {'https://github.com/jupyter/notebook/commit/70fe9f0ddb3023162ece21fbb77d5564306b913b', 'https://github.com/jupyter/notebook/commit/08c4c898182edbe97aadef1815cce50448f975cb', 'https://github.com/jupyter/notebook/commit/d65328d4841892b412aef9015165db1eb029a8ed'} |
PyPI | PYSEC-2021-626 | null | TensorFlow is an open source platform for machine learning. In affected versions the process of building the control flow graph for a TensorFlow model is vulnerable to a null pointer exception when nodes that should be paired are not. This occurs because the code assumes that the first node in the pairing (e.g., an `Enter` node) always exists when encountering the second node (e.g., an `Exit` node). When this is not the case, `parent` is `nullptr` so dereferencing it causes a crash. The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range. | {'CVE-2021-41217', 'GHSA-5crj-c72x-m7gq'} | 2021-12-09T06:35:09.978431Z | 2021-11-05T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/05cbebd3c6bb8f517a158b0155debb8df79017ff', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-5crj-c72x-m7gq'} | null | {'https://github.com/tensorflow/tensorflow/commit/05cbebd3c6bb8f517a158b0155debb8df79017ff'} | {'https://github.com/tensorflow/tensorflow/commit/05cbebd3c6bb8f517a158b0155debb8df79017ff'} |
PyPI | PYSEC-2022-96 | null | Tensorflow is an Open Source Machine Learning Framework. Under certain scenarios, Grappler component of TensorFlow is vulnerable to an integer overflow during cost estimation for crop and resize. Since the cropping parameters are user controlled, a malicious person can trigger undefined behavior. The fix will be included in TensorFlow 2.8.0. We will also cherrypick this commit on TensorFlow 2.7.1, TensorFlow 2.6.3, and TensorFlow 2.5.3, as these are also affected and still in supported range. | {'CVE-2022-23587', 'GHSA-8jj7-5vxc-pg2q'} | 2022-03-09T00:17:35.797116Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-8jj7-5vxc-pg2q', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/grappler/costs/op_level_cost_estimator.cc#L2621-L2689', 'https://github.com/tensorflow/tensorflow/commit/0aaaae6eca5a7175a193696383f582f53adab23f'} | null | {'https://github.com/tensorflow/tensorflow/commit/0aaaae6eca5a7175a193696383f582f53adab23f'} | {'https://github.com/tensorflow/tensorflow/commit/0aaaae6eca5a7175a193696383f582f53adab23f'} |
PyPI | GHSA-jj53-8fmw-f2w2 | Adding a private/unlisted room to a community exposes room metadata in an unauthorised manner. | ### Impact
Unauthorised users can access the name, avatar, topic and number of members of a room if they know the ID of the room. This vulnerability is limited to homeservers where:
- the vulnerable homeserver is in the room; and
- untrusted users are permitted to create groups (communities).
By default, only homeserver administrators can create groups. However, homeserver administrators can already access this information in the database or using the admin API. As a result, only homeservers where the configuration setting `enable_group_creation` has been set to `true` are impacted.
### Patches
Server administrators should upgrade to 1.41.1 or higher.
### Workarounds
Server administrators can set `enable_group_creation` to `false` in their homeserver configuration (this is the default value) to prevent creation of groups by non-administrators.
Administrators that are using a reverse proxy could, with partial loss of group functionality, block the following endpoints:
* `/_matrix/client/r0/groups/{group_id}/rooms`
* `/_matrix/client/unstable/groups/{group_id}/rooms`
### References
n/a
### For more information
If you have any questions or comments about this advisory, e-mail us at security@matrix.org.
| {'CVE-2021-39163'} | 2022-03-03T05:13:57.111332Z | 2021-09-01T18:25:44Z | LOW | null | {'CWE-200'} | {'https://github.com/matrix-org/synapse/commit/cb35df940a', 'https://github.com/matrix-org/synapse', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/PXT7ID7DNBRN2TVTETU3SYQHJKEG6PXN/', 'https://github.com/matrix-org/synapse/releases/tag/v1.41.1', 'https://nvd.nist.gov/vuln/detail/CVE-2021-39163', 'https://github.com/matrix-org/synapse/security/advisories/GHSA-jj53-8fmw-f2w2', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/2VHDEPCZ22GJFMZCWA2XZAGPOEV72POF/'} | null | {'https://github.com/matrix-org/synapse/commit/cb35df940a'} | {'https://github.com/matrix-org/synapse/commit/cb35df940a'} |
PyPI | GHSA-95xm-g58g-3p88 | Integer division by 0 in sparse reshaping | ### Impact
The implementation of `tf.raw_ops.SparseReshape` can be made to trigger an integral division by 0 exception:
```python
import tensorflow as tf
tf.raw_ops.SparseReshape(
input_indices = np.ones((1,3)),
input_shape = np.array([1,1,0]),
new_shape = np.array([1,0]))
```
The [implementation](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/reshape_util.cc#L176-L181) calls the reshaping functor whenever there is at least an index in the input but does not check that shape of the input or the target shape have both a non-zero number of elements.
The [reshape functor](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/reshape_util.cc#L40-L78) blindly divides by the dimensions of the target shape. Hence, if this is not checked, code will result in a division by 0.
### Patches
We have patched the issue in GitHub commit [4923de56ec94fff7770df259ab7f2288a74feb41](https://github.com/tensorflow/tensorflow/commit/4923de56ec94fff7770df259ab7f2288a74feb41).
The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1 as this is the other affected version.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by members of the Aivul Team from Qihoo 360. | {'CVE-2021-37640'} | 2022-03-03T05:13:02.147643Z | 2021-08-25T14:44:02Z | MODERATE | null | {'CWE-369'} | {'https://nvd.nist.gov/vuln/detail/CVE-2021-37640', 'https://github.com/tensorflow/tensorflow/commit/4923de56ec94fff7770df259ab7f2288a74feb41', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-95xm-g58g-3p88'} | null | {'https://github.com/tensorflow/tensorflow/commit/4923de56ec94fff7770df259ab7f2288a74feb41'} | {'https://github.com/tensorflow/tensorflow/commit/4923de56ec94fff7770df259ab7f2288a74feb41'} |
PyPI | GHSA-977j-xj7q-2jr9 | Segmentation faultin TensorFlow when converting a Python string to `tf.float16` | ### Impact
Converting a string (from Python) to a `tf.float16` value results in a segmentation fault in eager mode as the format checks for this use case are only in the graph mode.
This issue can lead to denial of service in inference/training where a malicious attacker can send a data point which contains a string instead of a `tf.float16` value.
Similar effects can be obtained by manipulating saved models and checkpoints whereby replacing a scalar `tf.float16` value with a scalar string will trigger this issue due to automatic conversions.
This can be easily reproduced by `tf.constant("hello", tf.float16)`, if eager execution is enabled.
### Patches
We have patched the vulnerability in GitHub commit [5ac1b9](https://github.com/tensorflow/tensorflow/commit/5ac1b9e24ff6afc465756edf845d2e9660bd34bf).
We are additionally releasing TensorFlow 1.15.1 and 2.0.1 with this vulnerability patched.
TensorFlow 2.1.0 was released after we fixed the issue, thus it is not affected.
We encourage users to switch to TensorFlow 1.15.1, 2.0.1 or 2.1.0.
### For more information
Please consult [`SECURITY.md`](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions. | {'CVE-2020-5215'} | 2022-03-03T05:13:26.765830Z | 2020-01-28T21:32:29Z | HIGH | null | {'CWE-754'} | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-977j-xj7q-2jr9', 'https://nvd.nist.gov/vuln/detail/CVE-2020-5215', 'https://github.com/tensorflow/tensorflow/commit/5ac1b9e24ff6afc465756edf845d2e9660bd34bf', 'https://github.com/tensorflow/tensorflow/releases/tag/v1.15.2', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.0.1'} | null | {'https://github.com/tensorflow/tensorflow/commit/5ac1b9e24ff6afc465756edf845d2e9660bd34bf'} | {'https://github.com/tensorflow/tensorflow/commit/5ac1b9e24ff6afc465756edf845d2e9660bd34bf'} |
PyPI | PYSEC-2022-156 | null | Tensorflow is an Open Source Machine Learning Framework. TensorFlow's type inference can cause a heap out of bounds read as the bounds checking is done in a `DCHECK` (which is a no-op during production). An attacker can control the `input_idx` variable such that `ix` would be larger than the number of values in `node_t.args`. The fix will be included in TensorFlow 2.8.0. This is the only affected version. | {'CVE-2022-23592', 'GHSA-vq36-27g6-p492'} | 2022-03-09T00:18:30.013116Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/blob/274df9b02330b790aa8de1cee164b70f72b9b244/tensorflow/core/graph/graph.cc#L223-L229', 'https://github.com/tensorflow/tensorflow/commit/c99d98cd189839dcf51aee94e7437b54b31f8abd', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-vq36-27g6-p492'} | null | {'https://github.com/tensorflow/tensorflow/commit/c99d98cd189839dcf51aee94e7437b54b31f8abd'} | {'https://github.com/tensorflow/tensorflow/commit/c99d98cd189839dcf51aee94e7437b54b31f8abd'} |
PyPI | GHSA-r478-c2pc-m7gx | DNS reply verification issue in dnslinb | The dnslib package through 0.9.16 for Python does not verify that the ID value in a DNS reply matches an ID value in a query. | {'CVE-2022-22846'} | 2022-03-03T05:13:18.614948Z | 2022-01-12T20:07:10Z | HIGH | null | null | {'https://github.com/paulc/dnslib/', 'https://github.com/paulc/dnslib/issues/30', 'https://github.com/paulc/dnslib/commit/76e8677699ed098387d502c57980f58da642aeba', 'https://nvd.nist.gov/vuln/detail/CVE-2022-22846'} | null | {'https://github.com/paulc/dnslib/commit/76e8677699ed098387d502c57980f58da642aeba'} | {'https://github.com/paulc/dnslib/commit/76e8677699ed098387d502c57980f58da642aeba'} |
PyPI | PYSEC-2019-119 | null | SaltStack Salt 2018.3, 2019.2 is affected by: SQL Injection. The impact is: An attacker could escalate privileges on MySQL server deployed by cloud provider. It leads to RCE. The component is: The mysql.user_chpass function from the MySQL module for Salt. The attack vector is: specially crafted password string. The fixed version is: 2018.3.4. | {'CVE-2019-1010259'} | 2019-08-13T18:15:00Z | 2019-07-18T17:15:00Z | null | null | null | {'https://github.com/saltstack/salt/pull/51462', 'https://github.com/saltstack/salt/blob/f22de0887cd7167887f113bf394244b74fb36b6b/salt/modules/mysql.py#L1534', 'https://github.com/ShantonRU/salt/commit/a46c86a987c78e74e87969d8d3b27094e6544b7a'} | null | {'https://github.com/ShantonRU/salt/commit/a46c86a987c78e74e87969d8d3b27094e6544b7a'} | {'https://github.com/ShantonRU/salt/commit/a46c86a987c78e74e87969d8d3b27094e6544b7a'} |
PyPI | PYSEC-2022-79 | null | Tensorflow is an Open Source Machine Learning Framework. When decoding a tensor from protobuf, TensorFlow might do a null-dereference if attributes of some mutable arguments to some operations are missing from the proto. This is guarded by a `DCHECK`. However, `DCHECK` is a no-op in production builds and an assertion failure in debug builds. In the first case execution proceeds to the dereferencing of the null pointer, whereas in the second case it results in a crash due to the assertion failure. The fix will be included in TensorFlow 2.8.0. We will also cherrypick this commit on TensorFlow 2.7.1, and TensorFlow 2.6.3, as these are also affected and still in supported range. | {'CVE-2022-23570', 'GHSA-9p77-mmrw-69c7'} | 2022-03-09T00:17:33.672987Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/8a513cec4bec15961fbfdedcaa5376522980455c', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-9p77-mmrw-69c7', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/full_type_util.cc#L104-L106'} | null | {'https://github.com/tensorflow/tensorflow/commit/8a513cec4bec15961fbfdedcaa5376522980455c'} | {'https://github.com/tensorflow/tensorflow/commit/8a513cec4bec15961fbfdedcaa5376522980455c'} |
PyPI | PYSEC-2020-44 | null | This affects the package Gerapy from 0 and before 0.9.3. The input being passed to Popen, via the project_configure endpoint, isn’t being sanitized. | {'GHSA-g57j-q48p-9vm2', 'CVE-2020-7698', 'SNYK-PYTHON-GERAPY-572470'} | 2020-07-31T14:59:00Z | 2020-07-29T13:15:00Z | null | null | null | {'https://github.com/Gerapy/Gerapy/commit/e8446605eb2424717418eae199ec7aad573da2d2', 'https://snyk.io/vuln/SNYK-PYTHON-GERAPY-572470', 'https://github.com/advisories/GHSA-g57j-q48p-9vm2'} | null | {'https://github.com/Gerapy/Gerapy/commit/e8446605eb2424717418eae199ec7aad573da2d2'} | {'https://github.com/Gerapy/Gerapy/commit/e8446605eb2424717418eae199ec7aad573da2d2'} |
PyPI | PYSEC-2020-325 | null | In tensorflow-lite before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, if a TFLite saved model uses the same tensor as both input and output of an operator, then, depending on the operator, we can observe a segmentation fault or just memory corruption. We have patched the issue in d58c96946b and will release patch releases for all versions between 1.15 and 2.3. We recommend users to upgrade to TensorFlow 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1. | {'CVE-2020-15210', 'GHSA-x9j7-x98r-r4w2'} | 2021-12-09T06:35:15.211180Z | 2020-09-25T19:15:00Z | null | null | null | {'http://lists.opensuse.org/opensuse-security-announce/2020-10/msg00065.html', 'https://github.com/tensorflow/tensorflow/commit/d58c96946b2880991d63d1dacacb32f0a4dfa453', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-x9j7-x98r-r4w2', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.3.1'} | null | {'https://github.com/tensorflow/tensorflow/commit/d58c96946b2880991d63d1dacacb32f0a4dfa453'} | {'https://github.com/tensorflow/tensorflow/commit/d58c96946b2880991d63d1dacacb32f0a4dfa453'} |
PyPI | PYSEC-2021-775 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can read from outside of bounds of heap allocated data by sending specially crafted illegal arguments to `BoostedTreesSparseCalculateBestFeatureSplit`. The [implementation](https://github.com/tensorflow/tensorflow/blob/84d053187cb80d975ef2b9684d4b61981bca0c41/tensorflow/core/kernels/boosted_trees/stats_ops.cc) needs to validate that each value in `stats_summary_indices` is in range. We have patched the issue in GitHub commit e84c975313e8e8e38bb2ea118196369c45c51378. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'CVE-2021-37664', 'GHSA-r4c4-5fpq-56wg'} | 2021-12-09T06:35:37.904410Z | 2021-08-12T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-r4c4-5fpq-56wg', 'https://github.com/tensorflow/tensorflow/commit/e84c975313e8e8e38bb2ea118196369c45c51378'} | null | {'https://github.com/tensorflow/tensorflow/commit/e84c975313e8e8e38bb2ea118196369c45c51378'} | {'https://github.com/tensorflow/tensorflow/commit/e84c975313e8e8e38bb2ea118196369c45c51378'} |
PyPI | PYSEC-2021-325 | null | Flask-RESTX (pypi package flask-restx) is a community driven fork of Flask-RESTPlus. Flask-RESTX before version 0.5.1 is vulnerable to ReDoS (Regular Expression Denial of Service) in email_regex. This is fixed in version 0.5.1. | {'CVE-2021-32838', 'GHSA-3q6g-vf58-7m4g'} | 2021-09-20T20:31:06.092661Z | 2021-09-20T18:15:00Z | null | null | null | {'https://github.com/advisories/GHSA-3q6g-vf58-7m4g', 'https://github.com/python-restx/flask-restx/commit/bab31e085f355dd73858fd3715f7ed71849656da', 'https://github.com/python-restx/flask-restx/issues/372', 'https://github.com/python-restx/flask-restx/blob/fd99fe11a88531f5f3441a278f7020589f9d2cc0/flask_restx/inputs.py#L51', 'https://pypi.org/project/flask-restx/'} | null | {'https://github.com/python-restx/flask-restx/commit/bab31e085f355dd73858fd3715f7ed71849656da'} | {'https://github.com/python-restx/flask-restx/commit/bab31e085f355dd73858fd3715f7ed71849656da'} |
PyPI | PYSEC-2021-90 | null | Flask-AppBuilder is a development framework, built on top of Flask. User enumeration in database authentication in Flask-AppBuilder <= 3.2.3. Allows for a non authenticated user to enumerate existing accounts by timing the response time from the server when you are logging in. Upgrade to version 3.3.0 or higher to resolve. | {'GHSA-434h-p4gx-jm89', 'CVE-2021-29621'} | 2021-06-09T05:01:12.347920Z | 2021-06-07T19:15:00Z | null | null | null | {'https://github.com/dpgaspar/Flask-AppBuilder/security/advisories/GHSA-434h-p4gx-jm89', 'https://github.com/dpgaspar/Flask-AppBuilder/commit/780bd0e8fbf2d36ada52edb769477e0a4edae580', 'https://pypi.org/project/Flask-AppBuilder/'} | null | {'https://github.com/dpgaspar/Flask-AppBuilder/commit/780bd0e8fbf2d36ada52edb769477e0a4edae580'} | {'https://github.com/dpgaspar/Flask-AppBuilder/commit/780bd0e8fbf2d36ada52edb769477e0a4edae580'} |
PyPI | PYSEC-2021-630 | null | TensorFlow is an open source platform for machine learning. In affected versions the shape inference code for the `Cudnn*` operations in TensorFlow can be tricked into accessing invalid memory, via a heap buffer overflow. This occurs because the ranks of the `input`, `input_h` and `input_c` parameters are not validated, but code assumes they have certain values. The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range. | {'CVE-2021-41221', 'GHSA-cqv6-3phm-hcwx'} | 2021-12-09T06:35:10.512289Z | 2021-11-05T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-cqv6-3phm-hcwx', 'https://github.com/tensorflow/tensorflow/commit/af5fcebb37c8b5d71c237f4e59c6477015c78ce6'} | null | {'https://github.com/tensorflow/tensorflow/commit/af5fcebb37c8b5d71c237f4e59c6477015c78ce6'} | {'https://github.com/tensorflow/tensorflow/commit/af5fcebb37c8b5d71c237f4e59c6477015c78ce6'} |
PyPI | GHSA-hgc3-hp6x-wpgx | Antilles Dependency Confusion Vulnerability | ### Potential Impact:
Remote code execution.
### Scope of Impact:
Open-source project specific.
### Summary Description:
A dependency confusion vulnerability was reported in the Antilles open-source software prior to version 1.0.1 that could allow for remote code execution during installation due to a package listed in requirements.txt not existing in the public package index (PyPi).
MITRE classifies this weakness as an Uncontrolled Search Path Element (CWE-427) in which a private package dependency may be replaced by an unauthorized package of the same name published to a well-known public repository such as PyPi.
The configuration has been updated to only install components built by Antilles, removing all other public package indexes. Additionally, the antilles-tools dependency has been published to PyPi.
### Mitigation Strategy for Customers (what you should do to protect yourself):
Remove previous versions of Antilles as a precautionary measure and Update to version 1.0.1 or later.
### Acknowledgement:
The Antilles team thanks Kotko Vladyslav for reporting this issue.
### References:
https://github.com/lenovo/Antilles/commit/c7b9c5740908b343aceefe69733d9972e64df0b9
| {'CVE-2021-3840'} | 2022-03-03T05:12:31.166669Z | 2021-11-03T17:36:22Z | HIGH | null | {'CWE-427'} | {'https://github.com/lenovo/Antilles', 'https://nvd.nist.gov/vuln/detail/CVE-2021-3840', 'https://github.com/lenovo/Antilles/security/advisories/GHSA-hgc3-hp6x-wpgx', 'https://github.com/lenovo/Antilles/commit/c7b9c5740908b343aceefe69733d9972e64df0b9'} | null | {'https://github.com/lenovo/Antilles/commit/c7b9c5740908b343aceefe69733d9972e64df0b9'} | {'https://github.com/lenovo/Antilles/commit/c7b9c5740908b343aceefe69733d9972e64df0b9'} |
PyPI | GHSA-976r-qfjj-c24w | Command injection via Celery broker in Apache Airflow | An issue was found in Apache Airflow versions 1.10.10 and below. When using CeleryExecutor, if an attacker can connect to the broker (Redis, RabbitMQ) directly, it is possible to inject commands, resulting in the celery worker running arbitrary commands. | {'CVE-2020-11981'} | 2022-03-21T23:01:56.303254Z | 2020-07-27T16:57:33Z | CRITICAL | null | {'CWE-78'} | {'https://github.com/apache/airflow/commit/afa4b11fddfdbadb048f742cf66d5c21c675a5c8', 'https://lists.apache.org/thread.html/r7255cf0be3566f23a768e2a04b40fb09e52fcd1872695428ba9afe91%40%3Cusers.airflow.apache.org%3E', 'https://nvd.nist.gov/vuln/detail/CVE-2020-11981', 'https://issues.apache.org/jira/browse/AIRFLOW-6351'} | null | {'https://github.com/apache/airflow/commit/afa4b11fddfdbadb048f742cf66d5c21c675a5c8'} | {'https://github.com/apache/airflow/commit/afa4b11fddfdbadb048f742cf66d5c21c675a5c8'} |
PyPI | PYSEC-2021-260 | null | TensorFlow is an end-to-end open source platform for machine learning. Sending invalid argument for `row_partition_types` of `tf.raw_ops.RaggedTensorToTensor` API results in a null pointer dereference and undefined behavior. The [implementation](https://github.com/tensorflow/tensorflow/blob/47a06f40411a69c99f381495f490536972152ac0/tensorflow/core/kernels/ragged_tensor_to_tensor_op.cc#L328) accesses the first element of a user supplied list of values without validating that the provided list is not empty. We have patched the issue in GitHub commit 301ae88b331d37a2a16159b65b255f4f9eb39314. The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range. | {'GHSA-hwr7-8gxx-fj5p', 'CVE-2021-37638'} | 2021-08-27T03:22:42.935785Z | 2021-08-12T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/301ae88b331d37a2a16159b65b255f4f9eb39314', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-hwr7-8gxx-fj5p'} | null | {'https://github.com/tensorflow/tensorflow/commit/301ae88b331d37a2a16159b65b255f4f9eb39314'} | {'https://github.com/tensorflow/tensorflow/commit/301ae88b331d37a2a16159b65b255f4f9eb39314'} |
PyPI | GHSA-r6jx-9g48-2r5r | Arbitrary code execution due to YAML deserialization | ### Impact
TensorFlow and Keras can be tricked to perform arbitrary code execution when deserializing a Keras model from YAML format.
```python
from tensorflow.keras import models
payload = '''
!!python/object/new:type
args: ['z', !!python/tuple [], {'extend': !!python/name:exec }]
listitems: "__import__('os').system('cat /etc/passwd')"
'''
models.model_from_yaml(payload)
```
The [implementation](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/python/keras/saving/model_config.py#L66-L104) uses `yaml.unsafe_load` which can perform arbitrary code execution on the input.
### Patches
Given that YAML format support requires a significant amount of work, we have removed it for now.
We have patched the issue in GitHub commit [23d6383eb6c14084a8fc3bdf164043b974818012](https://github.com/tensorflow/tensorflow/commit/23d6383eb6c14084a8fc3bdf164043b974818012).
The fix will be included in TensorFlow 2.6.0. We will also cherrypick this commit on TensorFlow 2.5.1, TensorFlow 2.4.3, and TensorFlow 2.3.4, as these are also affected and still in supported range.
### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
### Attribution
This vulnerability has been reported by Arjun Shibu. | {'CVE-2021-37678'} | 2022-03-23T23:00:12.045441Z | 2021-08-25T14:41:12Z | CRITICAL | null | {'CWE-502'} | {'https://nvd.nist.gov/vuln/detail/CVE-2021-37678', 'https://github.com/tensorflow/tensorflow', 'https://github.com/tensorflow/tensorflow/commit/23d6383eb6c14084a8fc3bdf164043b974818012', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-r6jx-9g48-2r5r'} | null | {'https://github.com/tensorflow/tensorflow/commit/23d6383eb6c14084a8fc3bdf164043b974818012'} | {'https://github.com/tensorflow/tensorflow/commit/23d6383eb6c14084a8fc3bdf164043b974818012'} |
PyPI | PYSEC-2021-149 | null | TensorFlow is an end-to-end open source platform for machine learning. 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. This will cause a read from outside the bounds of the `splits` tensor buffer in the implementation of the `RaggedBincount` op(https://github.com/tensorflow/tensorflow/blob/8b677d79167799f71c42fd3fa074476e0295413a/tensorflow/core/kernels/bincount_op.cc#L430-L433). Before the `for` loop, `batch_idx` is set to 0. The user controls the `splits` array, making it contain only one element, 0. Thus, the code in the `while` loop would increment `batch_idx` and then try to read `splits(1)`, which is outside of bounds. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2 and TensorFlow 2.3.3, as these are also affected. | {'GHSA-4278-2v5v-65r4', 'CVE-2021-29512'} | 2021-08-27T03:22:23.518786Z | 2021-05-14T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/eebb96c2830d48597d055d247c0e9aebaea94cd5', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-4278-2v5v-65r4'} | null | {'https://github.com/tensorflow/tensorflow/commit/eebb96c2830d48597d055d247c0e9aebaea94cd5'} | {'https://github.com/tensorflow/tensorflow/commit/eebb96c2830d48597d055d247c0e9aebaea94cd5'} |
PyPI | PYSEC-2021-519 | null | TensorFlow is an end-to-end open source platform for machine learning. TFlite graphs must not have loops between nodes. However, this condition was not checked and an attacker could craft models that would result in infinite loop during evaluation. In certain cases, the infinite loop would be replaced by stack overflow due to too many recursive calls. For example, the `While` implementation(https://github.com/tensorflow/tensorflow/blob/106d8f4fb89335a2c52d7c895b7a7485465ca8d9/tensorflow/lite/kernels/while.cc) could be tricked into a scneario where both the body and the loop subgraphs are the same. Evaluating one of the subgraphs means calling the `Eval` function for the other and this quickly exhaust all stack space. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range. Please consult our security guide(https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions. | {'CVE-2021-29591', 'GHSA-cwv3-863g-39vx'} | 2021-12-09T06:34:57.477070Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-cwv3-863g-39vx', 'https://github.com/tensorflow/tensorflow/commit/c6173f5fe66cdbab74f4f869311fe6aae2ba35f4', 'https://github.com/tensorflow/tensorflow/commit/9c1dc920d8ffb4893d6c9d27d1f039607b326743'} | null | {'https://github.com/tensorflow/tensorflow/commit/c6173f5fe66cdbab74f4f869311fe6aae2ba35f4', 'https://github.com/tensorflow/tensorflow/commit/9c1dc920d8ffb4893d6c9d27d1f039607b326743'} | {'https://github.com/tensorflow/tensorflow/commit/c6173f5fe66cdbab74f4f869311fe6aae2ba35f4', 'https://github.com/tensorflow/tensorflow/commit/9c1dc920d8ffb4893d6c9d27d1f039607b326743'} |
PyPI | PYSEC-2020-149 | null | The _encode_invalid_chars function in util/url.py in the urllib3 library 1.25.2 through 1.25.7 for Python allows a denial of service (CPU consumption) because of an inefficient algorithm. The percent_encodings array contains all matches of percent encodings. It is not deduplicated. For a URL of length N, the size of percent_encodings may be up to O(N). The next step (normalize existing percent-encoded bytes) also takes up to O(N) for each step, so the total time is O(N^2). If percent_encodings were deduplicated, the time to compute _encode_invalid_chars would be O(kN), where k is at most 484 ((10+6*2)^2). | {'GHSA-hmv2-79q8-fv6g', 'CVE-2020-7212'} | 2020-03-09T16:55:00Z | 2020-03-06T20:15:00Z | null | null | null | {'https://github.com/urllib3/urllib3/commit/a74c9cfbaed9f811e7563cfc3dce894928e0221a', 'https://pypi.org/project/urllib3/1.25.8/', 'https://github.com/urllib3/urllib3/blob/master/CHANGES.rst', 'https://github.com/advisories/GHSA-hmv2-79q8-fv6g'} | null | {'https://github.com/urllib3/urllib3/commit/a74c9cfbaed9f811e7563cfc3dce894928e0221a'} | {'https://github.com/urllib3/urllib3/commit/a74c9cfbaed9f811e7563cfc3dce894928e0221a'} |
PyPI | GHSA-73m2-3pwg-5fgc | Catastrophic backtracking in regex allows Denial of Service in Waitress | ### Impact
When waitress receives a header that contains invalid characters it will cause the regular expression engine to catastrophically backtrack causing the process to use 100% CPU time and blocking any other interactions.
This would allow an attacker to send a single request with an invalid header and take the service offline.
Invalid header example:
```
Bad-header: xxxxxxxxxxxxxxx\x10
```
Increasing the number of `x`'s in the header will increase the amount of time Waitress spends in the regular expression engine.
This issue was introduced in version 1.4.2 when the regular expression was updated to attempt to match the behaviour required by errata associated with RFC7230.
### Patches
The regular expression that is used to validate incoming headers has been updated in version 1.4.3, it is recommended that people upgrade to the new version of Waitress as soon as possible.
### Workarounds
If you have deployed a reverse proxy in front of Waitress it may already be rejecting requests that include invalid headers.
### Thanks
The Pylons Project would like to thank [Fil Zembowicz](https://github.com/fzembow) for reaching out and disclosing this vulnerability!
### References
Catastrophic backtracking explained: https://www.regular-expressions.info/catastrophic.html
### For more information
If you have any questions or comments about this advisory:
- open an issue at https://github.com/Pylons/waitress/issues (if not sensitive or security related)
- email the Pylons Security mailing list: pylons-project-security@googlegroups.com (if security related) | {'CVE-2020-5236'} | 2022-03-24T19:27:20Z | 2020-02-04T03:07:31Z | CRITICAL | null | {'CWE-400'} | {'https://github.com/Pylons/waitress/commit/6e46f9e3f014d64dd7d1e258eaf626e39870ee1f', 'https://github.com/Pylons/waitress', 'https://github.com/Pylons/waitress/security/advisories/GHSA-73m2-3pwg-5fgc', 'https://nvd.nist.gov/vuln/detail/CVE-2020-5236'} | null | {'https://github.com/Pylons/waitress/commit/6e46f9e3f014d64dd7d1e258eaf626e39870ee1f'} | {'https://github.com/Pylons/waitress/commit/6e46f9e3f014d64dd7d1e258eaf626e39870ee1f'} |
PyPI | PYSEC-2022-80 | null | Tensorflow is an Open Source Machine Learning Framework. When decoding a tensor from protobuf, a TensorFlow process can encounter cases where a `CHECK` assertion is invalidated based on user controlled arguments, if the tensors have an invalid `dtype` and 0 elements or an invalid shape. This allows attackers to cause denial of services in TensorFlow processes. The fix will be included in TensorFlow 2.8.0. We will also cherrypick this commit on TensorFlow 2.7.1, TensorFlow 2.6.3, and TensorFlow 2.5.3, as these are also affected and still in supported range. | {'GHSA-j3mj-fhpq-qqjj', 'CVE-2022-23571'} | 2022-03-09T00:17:33.801262Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/5b491cd5e41ad63735161cec9c2a568172c8b6a3', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-j3mj-fhpq-qqjj'} | null | {'https://github.com/tensorflow/tensorflow/commit/5b491cd5e41ad63735161cec9c2a568172c8b6a3'} | {'https://github.com/tensorflow/tensorflow/commit/5b491cd5e41ad63735161cec9c2a568172c8b6a3'} |
PyPI | PYSEC-2020-52 | null | jupyterhub-systemdspawner enables JupyterHub to spawn single-user notebook servers using systemd. In jupyterhub-systemdspawner before version 0.15 user API tokens issued to single-user servers are specified in the environment of systemd units. These tokens are incorrectly accessible to all users. In particular, the-littlest-jupyterhub is affected, which uses systemdspawner by default. This is patched in jupyterhub-systemdspawner v0.15 | {'GHSA-cg54-gpgr-4rm6', 'CVE-2020-26261'} | 2020-12-10T21:46:00Z | 2020-12-09T17:15:00Z | null | null | null | {'https://github.com/jupyterhub/systemdspawner/security/advisories/GHSA-cg54-gpgr-4rm6', 'https://pypi.org/project/jupyterhub-systemdspawner/', 'https://github.com/jupyterhub/systemdspawner/blob/master/CHANGELOG.md#v015', 'https://github.com/jupyterhub/systemdspawner/commit/a4d08fd2ade1cfd0ef2c29dc221e649345f23580'} | null | {'https://github.com/jupyterhub/systemdspawner/commit/a4d08fd2ade1cfd0ef2c29dc221e649345f23580'} | {'https://github.com/jupyterhub/systemdspawner/commit/a4d08fd2ade1cfd0ef2c29dc221e649345f23580'} |
PyPI | PYSEC-2022-140 | null | Tensorflow is an Open Source Machine Learning Framework. The implementation of `OpLevelCostEstimator::CalculateOutputSize` is vulnerable to an integer overflow if an attacker can create an operation which would involve tensors with large enough number of elements. We can have a large enough number of dimensions in `output_shape.dim()` or just a small number of dimensions being large enough to cause an overflow in the multiplication. The fix will be included in TensorFlow 2.8.0. We will also cherrypick this commit on TensorFlow 2.7.1, TensorFlow 2.6.3, and TensorFlow 2.5.3, as these are also affected and still in supported range. | {'GHSA-wm93-f238-7v37', 'CVE-2022-23576'} | 2022-03-09T00:18:27.816300Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/grappler/costs/op_level_cost_estimator.cc#L1598-L1617', 'https://github.com/tensorflow/tensorflow/commit/b9bd6cfd1c50e6807846af9a86f9b83cafc9c8ae', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-wm93-f238-7v37'} | null | {'https://github.com/tensorflow/tensorflow/commit/b9bd6cfd1c50e6807846af9a86f9b83cafc9c8ae'} | {'https://github.com/tensorflow/tensorflow/commit/b9bd6cfd1c50e6807846af9a86f9b83cafc9c8ae'} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.