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-789 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions TensorFlow and Keras can be tricked to perform arbitrary code execution when deserializing a Keras model from YAML format. 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. 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. 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-37678', 'GHSA-r6jx-9g48-2r5r'} | 2021-12-09T06:35:39.175638Z | 2021-08-12T23:15:00Z | null | null | null | {'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-623 | null | TensorFlow is an open source platform for machine learning. In affected versions the shape inference code for `tf.ragged.cross` has an undefined behavior due to binding a reference to `nullptr`. 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-vwhq-49r4-gj9v', 'CVE-2021-41214'} | 2021-12-09T06:35:09.506027Z | 2021-11-05T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/fa6b7782fbb14aa08d767bc799c531f5e1fb3bb8', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-vwhq-49r4-gj9v'} | null | {'https://github.com/tensorflow/tensorflow/commit/fa6b7782fbb14aa08d767bc799c531f5e1fb3bb8'} | {'https://github.com/tensorflow/tensorflow/commit/fa6b7782fbb14aa08d767bc799c531f5e1fb3bb8'} |
PyPI | PYSEC-2021-766 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions an attacker can trigger a read from outside of bounds of heap allocated data by sending invalid arguments to `tf.raw_ops.ResourceScatterUpdate`. The [implementation](https://github.com/tensorflow/tensorflow/blob/f24faa153ad31a4b51578f8181d3aaab77a1ddeb/tensorflow/core/kernels/resource_variable_ops.cc#L919-L923) has an incomplete validation of the relationship between the shapes of `indices` and `updates`: instead of checking that the shape of `indices` is a prefix of the shape of `updates` (so that broadcasting can happen), code only checks that the number of elements in these two tensors are in a divisibility relationship. We have patched the issue in GitHub commit 01cff3f986259d661103412a20745928c727326f. 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-7fvx-3jfc-2cpc', 'CVE-2021-37655'} | 2021-12-09T06:35:37.088195Z | 2021-08-12T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/01cff3f986259d661103412a20745928c727326f', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-7fvx-3jfc-2cpc'} | null | {'https://github.com/tensorflow/tensorflow/commit/01cff3f986259d661103412a20745928c727326f'} | {'https://github.com/tensorflow/tensorflow/commit/01cff3f986259d661103412a20745928c727326f'} |
PyPI | PYSEC-2015-26 | null | Cross-site scripting (XSS) vulnerability in the file browser in notebook/notebookapp.py in IPython Notebook before 3.2.2 and Jupyter Notebook 4.0.x before 4.0.5 allows remote attackers to inject arbitrary web script or HTML via a folder name. NOTE: this was originally reported as a cross-site request forgery (CSRF) vulnerability, but this may be inaccurate. | {'CVE-2015-6938'} | 2021-07-15T02:22:16.172109Z | 2015-09-21T19:59:00Z | null | null | null | {'http://lists.fedoraproject.org/pipermail/package-announce/2015-September/166460.html', 'http://lists.fedoraproject.org/pipermail/package-announce/2015-September/166471.html', 'https://github.com/jupyter/notebook/commit/dd9876381f0ef09873d8c5f6f2063269172331e3', 'http://lists.opensuse.org/opensuse-updates/2015-10/msg00016.html', 'http://seclists.org/oss-sec/2015/q3/474', 'http://lists.fedoraproject.org/pipermail/package-announce/2015-September/167670.html', 'https://github.com/jupyter/notebook/commit/35f32dd2da804d108a3a3585b69ec3295b2677ed', 'https://bugzilla.redhat.com/show_bug.cgi?id=1259405', 'https://github.com/ipython/ipython/commit/3ab41641cf6fce3860c73d5cf4645aa12e1e5892', 'http://seclists.org/oss-sec/2015/q3/544'} | null | {'https://github.com/ipython/ipython/commit/3ab41641cf6fce3860c73d5cf4645aa12e1e5892', 'https://github.com/jupyter/notebook/commit/35f32dd2da804d108a3a3585b69ec3295b2677ed', 'https://github.com/jupyter/notebook/commit/dd9876381f0ef09873d8c5f6f2063269172331e3'} | {'https://github.com/ipython/ipython/commit/3ab41641cf6fce3860c73d5cf4645aa12e1e5892', 'https://github.com/jupyter/notebook/commit/dd9876381f0ef09873d8c5f6f2063269172331e3', 'https://github.com/jupyter/notebook/commit/35f32dd2da804d108a3a3585b69ec3295b2677ed'} |
PyPI | PYSEC-2020-336 | null | In affected versions of TensorFlow running an LSTM/GRU model where the LSTM/GRU layer receives an input with zero-length results in a CHECK failure when using the CUDA backend. This can result in a query-of-death vulnerability, via denial of service, if users can control the input to the layer. 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-26270', 'GHSA-m648-33qf-v3gp'} | 2021-12-09T06:35:16.648712Z | 2020-12-10T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-m648-33qf-v3gp', 'https://github.com/tensorflow/tensorflow/commit/14755416e364f17fb1870882fa778c7fec7f16e3'} | null | {'https://github.com/tensorflow/tensorflow/commit/14755416e364f17fb1870882fa778c7fec7f16e3'} | {'https://github.com/tensorflow/tensorflow/commit/14755416e364f17fb1870882fa778c7fec7f16e3'} |
PyPI | GHSA-c5x2-p679-95wc | Null pointer dereference in `SparseTensorSliceDataset` | ### Impact
When a user does not supply arguments that determine a valid sparse tensor, `tf.raw_ops.SparseTensorSliceDataset` implementation can be made to dereference a null pointer:
```python
import tensorflow as tf
tf.raw_ops.SparseTensorSliceDataset(
indices=[[],[],[]],
values=[1,2,3],
dense_shape=[3,3])
```
The [implementation](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/data/sparse_tensor_slice_dataset_op.cc#L240-L251) has some argument validation but fails to consider the case when either `indices` or `values` are provided for an empty sparse tensor when the other is not.
If `indices` is empty (as in the example above), then [code that performs validation](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/data/sparse_tensor_slice_dataset_op.cc#L260-L261) (i.e., checking that the indices are monotonically increasing) results in a null pointer dereference:
```cc
for (int64_t i = 0; i < indices->dim_size(0); ++i) {
int64_t next_batch_index = indices->matrix<int64>()(i, 0);
...
}
```
If `indices` as provided by the user is empty, then `indices` in the C++ code above is backed by an empty `std::vector`, hence calling `indices->dim_size(0)` results in null pointer dereferencing (same as calling `std::vector::at()` on an empty vector).
### Patches
We have patched the issue in GitHub commit [02cc160e29d20631de3859c6653184e3f876b9d7](https://github.com/tensorflow/tensorflow/commit/02cc160e29d20631de3859c6653184e3f876b9d7).
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. | {'CVE-2021-37647'} | 2022-03-03T05:13:33.785331Z | 2021-08-25T14:43:32Z | HIGH | null | {'CWE-476'} | {'https://nvd.nist.gov/vuln/detail/CVE-2021-37647', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-c5x2-p679-95wc', 'https://github.com/tensorflow/tensorflow/commit/02cc160e29d20631de3859c6653184e3f876b9d7'} | null | {'https://github.com/tensorflow/tensorflow/commit/02cc160e29d20631de3859c6653184e3f876b9d7'} | {'https://github.com/tensorflow/tensorflow/commit/02cc160e29d20631de3859c6653184e3f876b9d7'} |
PyPI | PYSEC-2022-153 | null | Tensorflow is an Open Source Machine Learning Framework. Under certain scenarios, Grappler component of TensorFlow can trigger a null pointer dereference. There are 2 places where this can occur, for the same malicious alteration of a `SavedModel` file (fixing the first one would trigger the same dereference in the second place). First, during constant folding, the `GraphDef` might not have the required nodes for the binary operation. If a node is missing, the correposning `mul_*child` would be null, and the dereference in the subsequent line would be incorrect. We have a similar issue during `IsIdentityConsumingSwitch`. 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-23589', 'GHSA-9px9-73fg-3fqp'} | 2022-03-09T00:18:29.733275Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/grappler/mutable_graph_view.cc#L59-L74', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/grappler/optimizers/constant_folding.cc#L3466-L3497', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-9px9-73fg-3fqp', 'https://github.com/tensorflow/tensorflow/commit/045deec1cbdebb27d817008ad5df94d96a08b1bf', 'https://github.com/tensorflow/tensorflow/commit/0a365c029e437be0349c31f8d4c9926b69fa3fa1'} | null | {'https://github.com/tensorflow/tensorflow/commit/045deec1cbdebb27d817008ad5df94d96a08b1bf', 'https://github.com/tensorflow/tensorflow/commit/0a365c029e437be0349c31f8d4c9926b69fa3fa1'} | {'https://github.com/tensorflow/tensorflow/commit/045deec1cbdebb27d817008ad5df94d96a08b1bf', 'https://github.com/tensorflow/tensorflow/commit/0a365c029e437be0349c31f8d4c9926b69fa3fa1'} |
PyPI | PYSEC-2018-28 | null | The Requests package before 2.20.0 for Python sends an HTTP Authorization header to an http URI upon receiving a same-hostname https-to-http redirect, which makes it easier for remote attackers to discover credentials by sniffing the network. | {'GHSA-x84v-xcm2-53pg', 'CVE-2018-18074'} | 2021-06-16T00:03:24.800813Z | 2018-10-09T17:29:00Z | null | null | null | {'http://lists.opensuse.org/opensuse-security-announce/2019-07/msg00024.html', 'https://github.com/requests/requests/pull/4718', 'https://usn.ubuntu.com/3790-2/', 'https://github.com/requests/requests/issues/4716', 'https://github.com/requests/requests/commit/c45d7c49ea75133e52ab22a8e9e13173938e36ff', 'https://usn.ubuntu.com/3790-1/', 'https://bugs.debian.org/910766', 'http://docs.python-requests.org/en/master/community/updates/#release-and-version-history', 'https://github.com/advisories/GHSA-x84v-xcm2-53pg', 'https://access.redhat.com/errata/RHSA-2019:2035'} | null | {'https://github.com/requests/requests/commit/c45d7c49ea75133e52ab22a8e9e13173938e36ff'} | {'https://github.com/requests/requests/commit/c45d7c49ea75133e52ab22a8e9e13173938e36ff'} |
PyPI | GHSA-p867-fxfr-ph2w | b2-sdk-python TOCTOU application key disclosure | ### Impact
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.
### Patches
Users should upgrade to b2-sdk-python 1.14.1 or later.
### For more information
See the related advisory in the [B2 Command Line Tool](https://github.com/Backblaze/B2_Command_Line_Tool), a consumer of this SDK.
If you have any questions or comments about this advisory:
* Open an issue in [b2-sdk-python](https://github.com/Backblaze/b2-sdk-python)
* Email us at [security@backblaze.com](mailto:security@backblaze.com)
| {'CVE-2022-23651'} | 2022-03-08T18:31:44.904661Z | 2022-02-24T12:08:24Z | MODERATE | null | {'CWE-367'} | {'https://github.com/Backblaze/b2-sdk-python', 'https://pypi.org/project/b2sdk/', 'https://nvd.nist.gov/vuln/detail/CVE-2022-23651', 'https://github.com/Backblaze/b2-sdk-python/commit/62476638986e5b6d7459aca5ef8ce220760226e0', 'https://github.com/Backblaze/b2-sdk-python/security/advisories/GHSA-p867-fxfr-ph2w'} | null | {'https://github.com/Backblaze/b2-sdk-python/commit/62476638986e5b6d7459aca5ef8ce220760226e0'} | {'https://github.com/Backblaze/b2-sdk-python/commit/62476638986e5b6d7459aca5ef8ce220760226e0'} |
PyPI | PYSEC-2022-93 | null | Tensorflow is an Open Source Machine Learning Framework. A malicious user can cause a use after free behavior when decoding PNG images. After `png::CommonFreeDecode(&decode)` gets called, the values of `decode.width` and `decode.height` are in an unspecified state. 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-24x4-6qmh-88qg', 'CVE-2022-23584'} | 2022-03-09T00:17:35.438139Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-24x4-6qmh-88qg', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/kernels/image/decode_image_op.cc#L339-L346', 'https://github.com/tensorflow/tensorflow/commit/e746adbfcfee15e9cfdb391ff746c765b99bdf9b'} | null | {'https://github.com/tensorflow/tensorflow/commit/e746adbfcfee15e9cfdb391ff746c765b99bdf9b'} | {'https://github.com/tensorflow/tensorflow/commit/e746adbfcfee15e9cfdb391ff746c765b99bdf9b'} |
PyPI | PYSEC-2021-859 | null | NLTK (Natural Language Toolkit) is a suite of open source Python modules, data sets, and tutorials supporting research and development in Natural Language Processing. Versions prior to 3.6.5 are vulnerable to regular expression denial of service (ReDoS) attacks. The vulnerability is present in PunktSentenceTokenizer, sent_tokenize and word_tokenize. Any users of this class, or these two functions, are vulnerable to the ReDoS attack. In short, a specifically crafted long input to any of these vulnerable functions will cause them to take a significant amount of execution time. If your program relies on any of the vulnerable functions for tokenizing unpredictable user input, then we would strongly recommend upgrading to a version of NLTK without the vulnerability. For users unable to upgrade the execution time can be bounded by limiting the maximum length of an input to any of the vulnerable functions. Our recommendation is to implement such a limit. | {'CVE-2021-43854', 'GHSA-f8m6-h2c7-8h9x'} | 2022-01-04T17:38:55.854845Z | 2021-12-23T18:15:00Z | null | null | null | {'https://github.com/nltk/nltk/issues/2866', 'https://github.com/nltk/nltk/security/advisories/GHSA-f8m6-h2c7-8h9x', 'https://github.com/nltk/nltk/pull/2869', 'https://github.com/nltk/nltk/commit/1405aad979c6b8080dbbc8e0858f89b2e3690341'} | null | {'https://github.com/nltk/nltk/commit/1405aad979c6b8080dbbc8e0858f89b2e3690341'} | {'https://github.com/nltk/nltk/commit/1405aad979c6b8080dbbc8e0858f89b2e3690341'} |
PyPI | GHSA-67j9-c52g-w2q9 | Authorization Bypass in I hate money | ### Impact
An authenticated member of one project can modify and delete members of another project, without knowledge of this other project's private code. This can be further exploited to access all bills of another project without knowledge of this other project's private code.
With the default configuration, anybody is allowed to create a new project. An attacker can create a new project and then use it to become authenticated and exploit this flaw. As such, the exposure is similar to an unauthenticated attack, because it is trivial to become authenticated.
### Patches
```diff
ihatemoney/models.py | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/ihatemoney/models.py b/ihatemoney/models.py
index fe7b519..5691c75 100644
--- a/ihatemoney/models.py
+++ b/ihatemoney/models.py
@@ -380,7 +380,7 @@ class Person(db.Model):
def get_by_name(self, name, project):
return (
Person.query.filter(Person.name == name)
- .filter(Project.id == project.id)
+ .filter(Person.project_id == project.id)
.one()
)
@@ -389,7 +389,7 @@ class Person(db.Model):
project = g.project
return (
Person.query.filter(Person.id == id)
- .filter(Project.id == project.id)
+ .filter(Person.project_id == project.id)
.one()
)
```
### Workarounds
To limit the impact, it is possible to disable public project creation by setting `ALLOW_PUBLIC_PROJECT_CREATION = False` in the configuration (see [documentation](https://ihatemoney.readthedocs.io/en/latest/configuration.html)). Existing users will still be able to exploit the flaw, but this will prevent an external attacker from creating a new project.
### For more information
`Person.query.get()` and `Person.query.get_by_name()` were mistakenly running a database join on the Project table without constraining the result.
As a result, `Person.query.get(42, "projectfoo")` would return the Person with id=42, even if it is not associated to the project "projectfoo". The only condition is that "projectfoo" must exist.
This flaw can be exploited in several places:
1) API: PUT requests to `/api/projects/<project>/members/<personID>` will succeed even though `<personID>` is not a member of `<project>`.
This allows an authenticated attacker to alter the state of a member (name, weight, activated) in any project. In addition, the altered member will no longer be associated with its original project but will be associated to the attacker project instead, breaking many features of IHateMoney. For instance, bills referencing the altered member will no longer be visible in the original project.
This causes an additional information disclosure and loss of integrity on bills: the attacker will now be able to see, edit and delete bills belonging to the altered member, because IHateMoney now believes that these bills are associated to the attacker project through the altered member.
For instance, assume that `Person(id=42)` is a member of project "targetProject", and that the attacker has access to another project "attackerProject" with the private code "attackerPassword". The attacker can modify `Person(id=42)` with this command:
$ curl -X PUT -d "name=Pwn3d&activated=1" --basic -u attackerProject:attackerPassword http://$SERVER/api/projects/attackerProject/members/42
The attacker can now see, edit and delete bills paid by `Person(id=42)` by simply browsing to http://$SERVER/attackerProject/
2) Editing a member through the web interface at `/<project>/members/<personID>/edit` will succeed even though `<personID>` is not a member of `<project>`.
This is very similar to the PUT exploit. Reusing the same example, the attacker needs to login to its "attackerProject" project with the private code "attackerPassword". It can then alter the state of `Person(id=42)` by accessing the edit form at the following URL:
http://$SERVER/attackerProject/members/42/edit
Again, as a result of the alteration, the altered member will become associated to the project "attackerProject", resulting in the same information disclosure and loss of integrity on bills.
3) API: DELETE requests to `/api/projects/<project>/members/<personID>` will similarly allow to delete the member `<personID>` even if it belongs to a different project than `<project>`.
$ curl -X DELETE --basic -u attackerProject:attackerPassword http://$SERVER/api/projects/attackerProject/members/42
The impact is less serious than with PUT, because DELETE only deactivates a member (it does not really delete it).
All these exploits require authentication: an attacker needs to know a valid project name and its associated "private code". Once this requirement is fullfilled, the attacker can exploit this flaw to alter the state of members in any other project, without needing to know the target project name or its private code.
`Person.query.get_by_name()` suffers from the same issue as `Person.query.get()`. It has an additional issue: if multiple Person objects with the same name exist (this is possible if they are associated to different projects), `get_by_name()` will crash with `MultipleResultsFound` because of the call to `one()`.
However, since `Person.query.get_by_name()` is currently not used anywhere in IHateMoney, the bug affecting this function has no impact and is not exploitable. | {'CVE-2020-15120'} | 2022-03-03T05:12:57.326270Z | 2020-07-27T17:47:52Z | MODERATE | null | {'CWE-863'} | {'https://github.com/spiral-project/ihatemoney/security/advisories/GHSA-67j9-c52g-w2q9', 'https://nvd.nist.gov/vuln/detail/CVE-2020-15120', 'https://github.com/spiral-project/ihatemoney/commit/8d77cf5d5646e1d2d8ded13f0660638f57e98471'} | null | {'https://github.com/spiral-project/ihatemoney/commit/8d77cf5d5646e1d2d8ded13f0660638f57e98471'} | {'https://github.com/spiral-project/ihatemoney/commit/8d77cf5d5646e1d2d8ded13f0660638f57e98471'} |
PyPI | PYSEC-2016-36 | null | The multifilesystem storage backend in Radicale before 1.1 allows remote attackers to read or write to arbitrary files via a crafted component name. | {'CVE-2015-8747'} | 2021-12-14T08:18:58.605498Z | 2016-02-03T18:59:00Z | null | null | null | {'https://github.com/Kozea/Radicale/pull/343', 'https://pypi.org/project/radicale', 'https://github.com/Unrud/Radicale/commit/bcaf452e516c02c9bed584a73736431c5e8831f1', 'http://lists.fedoraproject.org/pipermail/package-announce/2016-January/175776.html', 'http://www.openwall.com/lists/oss-security/2016/01/06/7', 'http://www.securityfocus.com/bid/80255', 'http://www.openwall.com/lists/oss-security/2016/01/05/7', 'http://www.debian.org/security/2016/dsa-3462', 'https://nvd.nist.gov/vuln/detail/CVE-2015-8747', 'http://lists.fedoraproject.org/pipermail/package-announce/2016-January/175738.html', 'http://www.openwall.com/lists/oss-security/2016/01/06/4'} | null | {'https://github.com/Unrud/Radicale/commit/bcaf452e516c02c9bed584a73736431c5e8831f1'} | {'https://github.com/Unrud/Radicale/commit/bcaf452e516c02c9bed584a73736431c5e8831f1'} |
PyPI | PYSEC-2021-635 | null | TensorFlow is an open source platform for machine learning. In affected versions the implementation of `SparseBinCount` is vulnerable to a heap OOB access. This is because of missing validation between the elements of the `values` argument and the shape of the sparse output. 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-41226', 'GHSA-374m-jm66-3vj8'} | 2021-12-09T06:35:11.266312Z | 2021-11-05T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/f410212e373eb2aec4c9e60bf3702eba99a38aba', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-374m-jm66-3vj8'} | null | {'https://github.com/tensorflow/tensorflow/commit/f410212e373eb2aec4c9e60bf3702eba99a38aba'} | {'https://github.com/tensorflow/tensorflow/commit/f410212e373eb2aec4c9e60bf3702eba99a38aba'} |
PyPI | PYSEC-2021-265 | null | TensorFlow is an end-to-end open source platform for machine learning. If a user does not provide a valid padding value to `tf.raw_ops.MatrixDiagPartOp`, then the code triggers a null pointer dereference (if input is empty) or produces invalid behavior, ignoring all values after the first. The [implementation](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/linalg/matrix_diag_op.cc#L89) reads the first value from a tensor buffer without first checking that the tensor has values to read from. We have patched the issue in GitHub commit 482da92095c4d48f8784b1f00dda4f81c28d2988. 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-37643', 'GHSA-fcwc-p4fc-c5cc'} | 2021-08-27T03:22:43.365129Z | 2021-08-12T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/482da92095c4d48f8784b1f00dda4f81c28d2988', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-fcwc-p4fc-c5cc'} | null | {'https://github.com/tensorflow/tensorflow/commit/482da92095c4d48f8784b1f00dda4f81c28d2988'} | {'https://github.com/tensorflow/tensorflow/commit/482da92095c4d48f8784b1f00dda4f81c28d2988'} |
PyPI | PYSEC-2020-320 | null | In Tensorflow before versions 1.15.4, 2.0.3, 2.1.2, 2.2.1 and 2.3.1, the `data_splits` argument of `tf.raw_ops.StringNGrams` lacks validation. This allows a user to pass values that can cause heap overflow errors and even leak contents of memory In the linked code snippet, all the binary strings after `ee ff` are contents from the memory stack. Since these can contain return addresses, this data leak can be used to defeat ASLR. The issue is patched in commit 0462de5b544ed4731aa2fb23946ac22c01856b80, and is released in TensorFlow versions 1.15.4, 2.0.3, 2.1.2, 2.2.1, or 2.3.1. | {'CVE-2020-15205', 'GHSA-g7p5-5759-qv46'} | 2021-12-09T06:35:14.101977Z | 2020-09-25T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-g7p5-5759-qv46', 'http://lists.opensuse.org/opensuse-security-announce/2020-10/msg00065.html', 'https://github.com/tensorflow/tensorflow/commit/0462de5b544ed4731aa2fb23946ac22c01856b80', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.3.1'} | null | {'https://github.com/tensorflow/tensorflow/commit/0462de5b544ed4731aa2fb23946ac22c01856b80'} | {'https://github.com/tensorflow/tensorflow/commit/0462de5b544ed4731aa2fb23946ac22c01856b80'} |
PyPI | PYSEC-2021-770 | 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 binary cwise operations that don't require broadcasting (e.g., gradients of binary cwise operations). The [implementation](https://github.com/tensorflow/tensorflow/blob/84d053187cb80d975ef2b9684d4b61981bca0c41/tensorflow/core/kernels/cwise_ops_common.h#L264) assumes that the two inputs have exactly the same number of elements but does not check that. Hence, when the eigen functor executes it triggers heap OOB reads and undefined behavior due to binding to nullptr. We have patched the issue in GitHub commit 93f428fd1768df147171ed674fee1fc5ab8309ec. 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-37659', 'GHSA-q3g3-h9r4-prrc'} | 2021-12-09T06:35:37.426472Z | 2021-08-12T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-q3g3-h9r4-prrc', 'https://github.com/tensorflow/tensorflow/commit/93f428fd1768df147171ed674fee1fc5ab8309ec'} | null | {'https://github.com/tensorflow/tensorflow/commit/93f428fd1768df147171ed674fee1fc5ab8309ec'} | {'https://github.com/tensorflow/tensorflow/commit/93f428fd1768df147171ed674fee1fc5ab8309ec'} |
PyPI | PYSEC-2021-320 | null | Wasmtime is an open source runtime for WebAssembly & WASI. In Wasmtime from version 0.19.0 and before version 0.30.0 there was a use-after-free bug when passing `externref`s from the host to guest Wasm content. To trigger the bug, you have to explicitly pass multiple `externref`s from the host to a Wasm instance at the same time, either by passing multiple `externref`s as arguments from host code to a Wasm function, or returning multiple `externref`s to Wasm from a multi-value return function defined in the host. If you do not have host code that matches one of these shapes, then you are not impacted. If Wasmtime's `VMExternRefActivationsTable` became filled to capacity after passing the first `externref` in, then passing in the second `externref` could trigger a garbage collection. However the first `externref` is not rooted until we pass control to Wasm, and therefore could be reclaimed by the collector if nothing else was holding a reference to it or otherwise keeping it alive. Then, when control was passed to Wasm after the garbage collection, Wasm could use the first `externref`, which at this point has already been freed. We have reason to believe that the effective impact of this bug is relatively small because usage of `externref` is currently quite rare. The bug has been fixed, and users should upgrade to Wasmtime 0.30.0. If you cannot upgrade Wasmtime yet, you can avoid the bug by disabling reference types support in Wasmtime by passing `false` to `wasmtime::Config::wasm_reference_types`. | {'GHSA-v4cp-h94r-m7xf', 'CVE-2021-39216'} | 2021-09-17T22:30:49.852358Z | 2021-09-17T20:15:00Z | null | null | null | {'https://github.com/bytecodealliance/wasmtime/commit/101998733b74624cbd348a2366d05760b40181f3', 'https://crates.io/crates/wasmtime', 'https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-v4cp-h94r-m7xf'} | null | {'https://github.com/bytecodealliance/wasmtime/commit/101998733b74624cbd348a2366d05760b40181f3'} | {'https://github.com/bytecodealliance/wasmtime/commit/101998733b74624cbd348a2366d05760b40181f3'} |
PyPI | GHSA-5fq8-3q2f-4m5g | Session key exposure through session list in Django User Sessions | ### Impact
The views provided by django-user-sessions allow users to terminate specific sessions. The session key is used to identify sessions, and thus included in the rendered HTML. In itself this is not a problem. However if the website has an XSS vulnerability, the session key could be extracted by the attacker and a session takeover could happen.
### Patches
Patch is under way.
### Workarounds
Remove the session_key from the template.
### References
_None._
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [Bouke/django-user-sessions](https://github.com/Bouke/django-user-sessions/issues)
* Email us at [bouke@haarsma.eu](mailto:bouke@haarsma.eu) | {'CVE-2020-5224'} | 2022-03-03T05:13:30.020312Z | 2020-01-24T19:56:59Z | LOW | null | {'CWE-287'} | {'https://github.com/Bouke/django-user-sessions/security/advisories/GHSA-5fq8-3q2f-4m5g', 'https://github.com/jazzband/django-user-sessions/commit/f0c4077e7d1436ba6d721af85cee89222ca5d2d9', 'https://nvd.nist.gov/vuln/detail/CVE-2020-5224'} | null | {'https://github.com/jazzband/django-user-sessions/commit/f0c4077e7d1436ba6d721af85cee89222ca5d2d9'} | {'https://github.com/jazzband/django-user-sessions/commit/f0c4077e7d1436ba6d721af85cee89222ca5d2d9'} |
PyPI | PYSEC-2021-95 | null | The aaugustin websockets library before 9.1 for Python has an Observable Timing Discrepancy on servers when HTTP Basic Authentication is enabled with basic_auth_protocol_factory(credentials=...). An attacker may be able to guess a password via a timing attack. | {'CVE-2021-33880', 'GHSA-8ch4-58qp-g3mp'} | 2021-06-09T05:01:36.173811Z | 2021-06-06T15:15:00Z | null | null | null | {'https://github.com/advisories/GHSA-8ch4-58qp-g3mp', 'https://github.com/aaugustin/websockets/commit/547a26b685d08cac0aa64e5e65f7867ac0ea9bc0'} | null | {'https://github.com/aaugustin/websockets/commit/547a26b685d08cac0aa64e5e65f7867ac0ea9bc0'} | {'https://github.com/aaugustin/websockets/commit/547a26b685d08cac0aa64e5e65f7867ac0ea9bc0'} |
PyPI | GHSA-jjr8-m8g8-p6wv | Null pointer dereference in TFLite's `Reshape` operator | ### Impact
The fix for [CVE-2020-15209](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-15209) missed the case when the target shape of `Reshape` operator is given by the elements of a 1-D tensor. As such, the [fix for the vulnerability](https://github.com/tensorflow/tensorflow/blob/9c1dc920d8ffb4893d6c9d27d1f039607b326743/tensorflow/lite/core/subgraph.cc#L1062-L1074) allowed passing a null-buffer-backed tensor with a 1D shape:
```cc
if (tensor->data.raw == nullptr && tensor->bytes > 0) {
if (registration.builtin_code == kTfLiteBuiltinReshape && i == 1) {
// In general, having a tensor here with no buffer will be an error.
// However, for the reshape operator, the second input tensor is only
// used for the shape, not for the data. Thus, null buffer is ok.
continue;
} else {
// In all other cases, we need to return an error as otherwise we will
// trigger a null pointer dereference (likely).
ReportError("Input tensor %d lacks data", tensor_index);
return kTfLiteError;
}
}
```
### Patches
We have patched the issue in GitHub commit [f8378920345f4f4604202d4ab15ef64b2aceaa16](https://github.com/tensorflow/tensorflow/commit/f8378920345f4f4604202d4ab15ef64b2aceaa16).
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-29592'} | 2022-03-03T05:13:19.001075Z | 2021-05-21T14:26:58Z | MODERATE | null | {'CWE-476'} | {'https://github.com/tensorflow/tensorflow/commit/f8378920345f4f4604202d4ab15ef64b2aceaa16', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-jjr8-m8g8-p6wv', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29592'} | null | {'https://github.com/tensorflow/tensorflow/commit/f8378920345f4f4604202d4ab15ef64b2aceaa16'} | {'https://github.com/tensorflow/tensorflow/commit/f8378920345f4f4604202d4ab15ef64b2aceaa16'} |
PyPI | GHSA-f78g-q7r4-9wcv | Division by 0 in `FractionalAvgPool` | ### Impact
An attacker can cause a runtime division by zero error and denial of service in `tf.raw_ops.FractionalAvgPool`:
```python
import tensorflow as tf
value = tf.constant([60], shape=[1, 1, 1, 1], dtype=tf.int32)
pooling_ratio = [1.0, 1.0000014345305555, 1.0, 1.0]
pseudo_random = False
overlapping = False
deterministic = False
seed = 0
seed2 = 0
tf.raw_ops.FractionalAvgPool(
value=value, pooling_ratio=pooling_ratio, pseudo_random=pseudo_random,
overlapping=overlapping, deterministic=deterministic, seed=seed, seed2=seed2)
```
This is because the [implementation](https://github.com/tensorflow/tensorflow/blob/acc8ee69f5f46f92a3f1f11230f49c6ac266f10c/tensorflow/core/kernels/fractional_avg_pool_op.cc#L85-L89) computes a divisor quantity by dividing two user controlled values:
```cc
for (int i = 0; i < tensor_in_and_out_dims; ++i) {
output_size[i] = static_cast<int>(std::floor(input_size[i] / pooling_ratio_[i]));
DCHECK_GT(output_size[i], 0);
}
```
The user controls the values of `input_size[i]` and `pooling_ratio_[i]` (via the `value.shape()` and `pooling_ratio` arguments). If the value in `input_size[i]` is smaller than the `pooling_ratio_[i]`, then the floor operation results in `output_size[i]` being 0. The `DCHECK_GT` line is a no-op outside of debug mode, so in released versions of TF this does not trigger.
Later, these computed values [are used as arguments](https://github.com/tensorflow/tensorflow/blob/acc8ee69f5f46f92a3f1f11230f49c6ac266f10c/tensorflow/core/kernels/fractional_avg_pool_op.cc#L96-L99) to [`GeneratePoolingSequence`](https://github.com/tensorflow/tensorflow/blob/acc8ee69f5f46f92a3f1f11230f49c6ac266f10c/tensorflow/core/kernels/fractional_pool_common.cc#L100-L108). There, the first computation is a division in a modulo operation:
```cc
std::vector<int64> GeneratePoolingSequence(int input_length, int output_length,
GuardedPhiloxRandom* generator,
bool pseudo_random) {
...
if (input_length % output_length == 0) {
diff = std::vector<int64>(output_length, input_length / output_length);
}
...
}
```
Since `output_length` can be 0, this results in runtime crashing.
### Patches
We have patched the issue in GitHub commit [548b5eaf23685d86f722233d8fbc21d0a4aecb96](https://github.com/tensorflow/tensorflow/commit/548b5eaf23685d86f722233d8fbc21d0a4aecb96).
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-29550'} | 2022-03-03T05:13:33.593364Z | 2021-05-21T14:23:41Z | LOW | null | {'CWE-369'} | {'https://github.com/tensorflow/tensorflow/commit/548b5eaf23685d86f722233d8fbc21d0a4aecb96', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29550', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-f78g-q7r4-9wcv'} | null | {'https://github.com/tensorflow/tensorflow/commit/548b5eaf23685d86f722233d8fbc21d0a4aecb96'} | {'https://github.com/tensorflow/tensorflow/commit/548b5eaf23685d86f722233d8fbc21d0a4aecb96'} |
PyPI | PYSEC-2022-145 | null | Tensorflow is an Open Source Machine Learning Framework. The Grappler optimizer in TensorFlow can be used to cause a denial of service by altering a `SavedModel` such that `IsSimplifiableReshape` would trigger `CHECK` failures. 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-23581', 'GHSA-fq86-3f29-px2c'} | 2022-03-09T00:18:28.561700Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/1fb27733f943295d874417630edd3b38b34ce082', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-fq86-3f29-px2c', 'https://github.com/tensorflow/tensorflow/commit/240655511cd3e701155f944a972db71b6c0b1bb6', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/grappler/optimizers/constant_folding.cc#L1687-L1742', 'https://github.com/tensorflow/tensorflow/commit/ebc1a2ffe5a7573d905e99bd0ee3568ee07c12c1'} | null | {'https://github.com/tensorflow/tensorflow/commit/1fb27733f943295d874417630edd3b38b34ce082', 'https://github.com/tensorflow/tensorflow/commit/240655511cd3e701155f944a972db71b6c0b1bb6', 'https://github.com/tensorflow/tensorflow/commit/ebc1a2ffe5a7573d905e99bd0ee3568ee07c12c1'} | {'https://github.com/tensorflow/tensorflow/commit/240655511cd3e701155f944a972db71b6c0b1bb6', 'https://github.com/tensorflow/tensorflow/commit/ebc1a2ffe5a7573d905e99bd0ee3568ee07c12c1', 'https://github.com/tensorflow/tensorflow/commit/1fb27733f943295d874417630edd3b38b34ce082'} |
PyPI | PYSEC-2021-459 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a `CHECK` fail in PNG encoding by providing an empty input tensor as the pixel data. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/e312e0791ce486a80c9d23110841525c6f7c3289/tensorflow/core/kernels/image/encode_png_op.cc#L57-L60) only validates that the total number of pixels in the image does not overflow. Thus, an attacker can send an empty matrix for encoding. However, if the tensor is empty, then the associated buffer is `nullptr`. Hence, when calling `png::WriteImageToBuffer`(https://github.com/tensorflow/tensorflow/blob/e312e0791ce486a80c9d23110841525c6f7c3289/tensorflow/core/kernels/image/encode_png_op.cc#L79-L93), the first argument (i.e., `image.flat<T>().data()`) is `NULL`. This then triggers the `CHECK_NOTNULL` in the first line of `png::WriteImageToBuffer`(https://github.com/tensorflow/tensorflow/blob/e312e0791ce486a80c9d23110841525c6f7c3289/tensorflow/core/lib/png/png_io.cc#L345-L349). Since `image` is null, this results in `abort` being called after printing the stacktrace. Effectively, this allows an attacker to mount a denial of service attack. 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-29531', 'GHSA-3qxp-qjq7-w4hf'} | 2021-12-09T06:34:48.199089Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/26eb323554ffccd173e8a79a8c05c15b685ae4d1', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-3qxp-qjq7-w4hf'} | null | {'https://github.com/tensorflow/tensorflow/commit/26eb323554ffccd173e8a79a8c05c15b685ae4d1'} | {'https://github.com/tensorflow/tensorflow/commit/26eb323554ffccd173e8a79a8c05c15b685ae4d1'} |
PyPI | GHSA-9697-98pf-4rw7 | Heap OOB in `UpperBound` and `LowerBound` | ### Impact
An attacker can read from outside of bounds of heap allocated data by sending specially crafted illegal arguments to `tf.raw_ops.UpperBound`:
```python
import tensorflow as tf
tf.raw_ops.UpperBound(
sorted_input=[1,2,3],
values=tf.constant(value=[[0,0,0],[1,1,1],[2,2,2]],dtype=tf.int64),
out_type=tf.int64)
```
The [implementation](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/core/kernels/searchsorted_op.cc#L85-L104) does not validate the rank of `sorted_input` argument:
```cc
void Compute(OpKernelContext* ctx) override {
const Tensor& sorted_inputs_t = ctx->input(0);
// ...
OP_REQUIRES(ctx, sorted_inputs_t.dim_size(0) == values_t.dim_size(0),
Status(error::INVALID_ARGUMENT,
"Leading dim_size of both tensors must match."));
// ...
if (output_t->dtype() == DT_INT32) {
OP_REQUIRES(ctx,
FastBoundsCheck(sorted_inputs_t.dim_size(1), ...));
// ...
}
```
As we access the first two dimensions of `sorted_inputs_t` tensor, it must have rank at least 2.
A similar issue occurs in `tf.raw_ops.LowerBound`.
### Patches
We have patched the issue in GitHub commit [42459e4273c2e47a3232cc16c4f4fff3b3a35c38](https://github.com/tensorflow/tensorflow/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.
### 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-37670'} | 2022-03-03T05:14:12.056672Z | 2021-08-25T14:41:44Z | MODERATE | null | {'CWE-125'} | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-9697-98pf-4rw7', 'https://nvd.nist.gov/vuln/detail/CVE-2021-37670', 'https://github.com/tensorflow/tensorflow/commit/42459e4273c2e47a3232cc16c4f4fff3b3a35c38'} | null | {'https://github.com/tensorflow/tensorflow/commit/42459e4273c2e47a3232cc16c4f4fff3b3a35c38'} | {'https://github.com/tensorflow/tensorflow/commit/42459e4273c2e47a3232cc16c4f4fff3b3a35c38'} |
PyPI | GHSA-5qw5-89mw-wcg2 | Out of bounds write in Tensorflow | ### Impact
TensorFlow is vulnerable to a heap OOB write in [Grappler](https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/grappler/costs/graph_properties.cc#L1132-L1141):
```cc
Status SetUnknownShape(const NodeDef* node, int output_port) {
shape_inference::ShapeHandle shape =
GetUnknownOutputShape(node, output_port);
InferenceContext* ctx = GetContext(node);
if (ctx == nullptr) {
return errors::InvalidArgument("Missing context");
}
ctx->set_output(output_port, shape);
return Status::OK();
}
```
The [`set_output`](https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/shape_inference.h#L394) function writes to an array at the specified index:
```cc
void set_output(int idx, ShapeHandle shape) { outputs_.at(idx) = shape; }
```
Hence, this gives a malicious user a write primitive.
### Patches
We have patched the issue in GitHub commit [97282c6d0d34476b6ba033f961590b783fa184cd](https://github.com/tensorflow/tensorflow/commit/97282c6d0d34476b6ba033f961590b783fa184cd).
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-23566'} | 2022-03-03T05:12:32.668904Z | 2022-02-09T23:55:43Z | HIGH | null | {'CWE-787'} | {'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/grappler/costs/graph_properties.cc#L1132-L1141', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/shape_inference.h#L394', 'https://github.com/tensorflow/tensorflow', 'https://github.com/tensorflow/tensorflow/commit/97282c6d0d34476b6ba033f961590b783fa184cd', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-5qw5-89mw-wcg2', 'https://nvd.nist.gov/vuln/detail/CVE-2022-23566'} | null | {'https://github.com/tensorflow/tensorflow/commit/97282c6d0d34476b6ba033f961590b783fa184cd'} | {'https://github.com/tensorflow/tensorflow/commit/97282c6d0d34476b6ba033f961590b783fa184cd'} |
PyPI | PYSEC-2022-85 | 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:17:34.416658Z | 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'} |
PyPI | GHSA-r2mj-8wgq-73m6 | XML External Entity Reference in Glances | 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'} | 2022-03-03T05:13:01.545369Z | 2021-08-09T20:43:14Z | MODERATE | null | {'CWE-611'} | {'https://github.com/nicolargo/glances/commit/85d5a6b4af31fcf785d5a61086cbbd166b40b07a', 'https://github.com/nicolargo/glances/issues/1025', 'https://snyk.io/vuln/SNYK-PYTHON-GLANCES-1311807', 'https://nvd.nist.gov/vuln/detail/CVE-2021-23418', 'https://github.com/nicolargo/glances', '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-2020-232 | null | In freewvs before 0.1.1, a user could create a large file that freewvs will try to read, which will terminate a scan process. This has been patched in 0.1.1. | {'GHSA-9cfv-9463-8gqv', 'CVE-2020-15100'} | 2021-08-27T03:22:04.199703Z | 2020-07-14T20:15:00Z | null | null | null | {'https://github.com/schokokeksorg/freewvs/security/advisories/GHSA-9cfv-9463-8gqv', 'https://github.com/schokokeksorg/freewvs/commit/18bbf2043e53f69e0119d24f8ae4edb274afb9b2'} | null | {'https://github.com/schokokeksorg/freewvs/commit/18bbf2043e53f69e0119d24f8ae4edb274afb9b2'} | {'https://github.com/schokokeksorg/freewvs/commit/18bbf2043e53f69e0119d24f8ae4edb274afb9b2'} |
PyPI | GHSA-c2jg-hw38-jrqq | Inconsistent Interpretation of HTTP Requests in twisted.web | The Twisted Web HTTP 1.1 server, located in the `twisted.web.http` module, parsed several HTTP request constructs more leniently than permitted by RFC 7230:
1. The Content-Length header value could have a `+` or `-` prefix.
2. Illegal characters were permitted in chunked extensions, such as the LF (`\n`) character.
3. Chunk lengths, which are expressed in hexadecimal format, could have a prefix of `0x`.
4. HTTP headers were stripped of all leading and trailing ASCII whitespace, rather than only space and HTAB (`\t`).
This non-conformant parsing can lead to desync if requests pass through multiple HTTP parsers, potentially resulting in HTTP request smuggling.
### Impact
You may be affected if:
1. You use Twisted Web's HTTP 1.1 server and/or proxy
2. You also pass requests through a different HTTP server and/or proxy
The specifics of the other HTTP parser matter. The original report notes that some versions of Apache Traffic Server and HAProxy have been vulnerable in the past. HTTP request smuggling may be a serious concern if you use a proxy to perform request validation or access control.
The Twisted Web client is not affected. The HTTP 2.0 server uses a different parser, so it is not affected.
### Patches
The issue has been addressed in Twisted 22.4.0rc1 and later.
### Workarounds
Other than upgrading Twisted, you could:
* Ensure any vulnerabilities in upstream proxies have been addressed, such as by upgrading them
* Filter malformed requests by other means, such as configuration of an upstream proxy
### Credits
This issue was initially reported by [Zhang Zeyu](https://github.com/zeyu2001). | {'CVE-2022-24801'} | 2022-05-04T04:03:05.300321Z | 2022-04-04T21:29:41Z | HIGH | null | {'CWE-444'} | {'https://github.com/twisted/twisted/security/advisories/GHSA-c2jg-hw38-jrqq', 'https://github.com/twisted/twisted/releases/tag/twisted-22.4.0rc1', 'https://nvd.nist.gov/vuln/detail/CVE-2022-24801', 'https://github.com/twisted/twisted', 'https://lists.debian.org/debian-lts-announce/2022/05/msg00003.html', 'https://github.com/twisted/twisted/commit/592217e951363d60e9cd99c5bbfd23d4615043ac'} | null | {'https://github.com/twisted/twisted/commit/592217e951363d60e9cd99c5bbfd23d4615043ac'} | {'https://github.com/twisted/twisted/commit/592217e951363d60e9cd99c5bbfd23d4615043ac'} |
PyPI | GHSA-2p25-55c9-h58q | Overflow/crash in `tf.tile` when tiling tensor is large | ### Impact
If `tf.tile` is called with a large input argument then the TensorFlow process will crash due to a `CHECK`-failure caused by an overflow.
```python
import tensorflow as tf
import numpy as np
tf.keras.backend.tile(x=np.ones((1,1,1)), n=[100000000,100000000, 100000000])
```
The number of elements in the output tensor is too much for the `int64_t` type and the overflow is detected via a `CHECK` statement. This aborts the process.
### Patches
We have patched the issue in GitHub commit [9294094df6fea79271778eb7e7ae1bad8b5ef98f](https://github.com/tensorflow/tensorflow/commit/9294094df6fea79271778eb7e7ae1bad8b5ef98f) (merging [#51138](https://github.com/tensorflow/tensorflow/pull/51138)).
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/46911). | {'CVE-2021-41198'} | 2022-03-03T05:14:18.019444Z | 2021-11-10T19:33:58Z | MODERATE | null | {'CWE-190'} | {'https://github.com/tensorflow/tensorflow/issues/46911', 'https://nvd.nist.gov/vuln/detail/CVE-2021-41198', 'https://github.com/tensorflow/tensorflow/commit/9294094df6fea79271778eb7e7ae1bad8b5ef98f', 'https://github.com/tensorflow/tensorflow', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-2p25-55c9-h58q'} | null | {'https://github.com/tensorflow/tensorflow/commit/9294094df6fea79271778eb7e7ae1bad8b5ef98f'} | {'https://github.com/tensorflow/tensorflow/commit/9294094df6fea79271778eb7e7ae1bad8b5ef98f'} |
PyPI | PYSEC-2021-232 | null | TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `DepthToSpace` TFLite operator is vulnerable to a division by zero error(https://github.com/tensorflow/tensorflow/blob/0d45ea1ca641b21b73bcf9c00e0179cda284e7e7/tensorflow/lite/kernels/depth_to_space.cc#L63-L69). An attacker can craft a model such that `params->block_size` is 0. 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-29595', 'GHSA-vf94-36g5-69v8'} | 2021-08-27T03:22:38.313497Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-vf94-36g5-69v8', 'https://github.com/tensorflow/tensorflow/commit/106d8f4fb89335a2c52d7c895b7a7485465ca8d9'} | null | {'https://github.com/tensorflow/tensorflow/commit/106d8f4fb89335a2c52d7c895b7a7485465ca8d9'} | {'https://github.com/tensorflow/tensorflow/commit/106d8f4fb89335a2c52d7c895b7a7485465ca8d9'} |
PyPI | PYSEC-2021-662 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a heap buffer overflow in `QuantizedReshape` by passing in invalid thresholds for the quantization. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/a324ac84e573fba362a5e53d4e74d5de6729933e/tensorflow/core/kernels/quantized_reshape_op.cc#L38-L55) assumes that the 2 arguments are always valid scalars and tries to access the numeric value directly. However, if any of these tensors is empty, then `.flat<T>()` is an empty buffer and accessing the element at position 0 results in 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. | {'CVE-2021-29536', 'GHSA-2gfx-95x2-5v3x'} | 2021-12-09T06:35:20.961529Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/a324ac84e573fba362a5e53d4e74d5de6729933e', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-2gfx-95x2-5v3x'} | null | {'https://github.com/tensorflow/tensorflow/commit/a324ac84e573fba362a5e53d4e74d5de6729933e'} | {'https://github.com/tensorflow/tensorflow/commit/a324ac84e573fba362a5e53d4e74d5de6729933e'} |
PyPI | PYSEC-2021-398 | null | TensorFlow is an open source platform for machine learning. In affected versions the shape inference functions for the `QuantizeAndDequantizeV*` operations can trigger a read outside of bounds of heap allocated array. 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-41205', 'GHSA-49rx-x2rw-pc6f'} | 2021-11-13T06:52:43.104468Z | 2021-11-05T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/7cf73a2274732c9d82af51c2bc2cf90d13cd7e6d', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-49rx-x2rw-pc6f'} | null | {'https://github.com/tensorflow/tensorflow/commit/7cf73a2274732c9d82af51c2bc2cf90d13cd7e6d'} | {'https://github.com/tensorflow/tensorflow/commit/7cf73a2274732c9d82af51c2bc2cf90d13cd7e6d'} |
PyPI | PYSEC-2021-727 | null | TensorFlow is an end-to-end open source platform for machine learning. The TFLite implementation of concatenation is vulnerable to an integer overflow issue(https://github.com/tensorflow/tensorflow/blob/7b7352a724b690b11bfaae2cd54bc3907daf6285/tensorflow/lite/kernels/concatenation.cc#L70-L76). An attacker can craft a model such that the dimensions of one of the concatenation input overflow the values of `int`. TFLite uses `int` to represent tensor dimensions, whereas TF uses `int64`. Hence, valid TF models can trigger an integer overflow when converted to TFLite format. 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-29601', 'GHSA-9c84-4hx6-xmm4'} | 2021-12-09T06:35:32.210068Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-9c84-4hx6-xmm4', 'https://github.com/tensorflow/tensorflow/commit/4253f96a58486ffe84b61c0415bb234a4632ee73'} | null | {'https://github.com/tensorflow/tensorflow/commit/4253f96a58486ffe84b61c0415bb234a4632ee73'} | {'https://github.com/tensorflow/tensorflow/commit/4253f96a58486ffe84b61c0415bb234a4632ee73'} |
PyPI | PYSEC-2013-19 | null | Cross-site scripting (XSS) vulnerability in the AdminURLFieldWidget widget in contrib/admin/widgets.py in Django 1.5.x before 1.5.2 and 1.6.x before 1.6 beta 2 allows remote attackers to inject arbitrary web script or HTML via a URLField. | {'CVE-2013-4249'} | 2021-07-15T02:22:08.907870Z | 2013-10-04T17:55:00Z | null | null | null | {'http://www.securitytracker.com/id/1028915', 'https://exchange.xforce.ibmcloud.com/vulnerabilities/86438', 'https://github.com/django/django/commit/90363e388c61874add3f3557ee654a996ec75d78', 'https://github.com/django/django/commit/cbe6d5568f4f5053ed7228ca3c3d0cce77cf9560', 'http://secunia.com/advisories/54476', 'https://www.djangoproject.com/weblog/2013/aug/13/security-releases-issued', 'http://seclists.org/oss-sec/2013/q3/369', 'http://seclists.org/oss-sec/2013/q3/411'} | null | {'https://github.com/django/django/commit/cbe6d5568f4f5053ed7228ca3c3d0cce77cf9560', 'https://github.com/django/django/commit/90363e388c61874add3f3557ee654a996ec75d78'} | {'https://github.com/django/django/commit/90363e388c61874add3f3557ee654a996ec75d78', 'https://github.com/django/django/commit/cbe6d5568f4f5053ed7228ca3c3d0cce77cf9560'} |
PyPI | GHSA-44qp-9wwf-734r | Heap overflow in Tensorflow | ### Impact
The [implementation of `SparseCountSparseOutput`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/count_ops.cc#L168-L273) is vulnerable to a heap overflow:
```python
import tensorflow as tf
import numpy as np
tf.raw_ops.SparseCountSparseOutput(
indices=[[-1,-1]],
values=[2],
dense_shape=[1, 1],
weights=[1],
binary_output=True,
minlength=-1,
maxlength=-1,
name=None)
```
### Patches
We have patched the issue in GitHub commits [2b7100d6cdff36aa21010a82269bc05a6d1cc74a](https://github.com/tensorflow/tensorflow/commit/2b7100d6cdff36aa21010a82269bc05a6d1cc74a) and [adbbabdb0d3abb3cdeac69e38a96de1d678b24b3](https://github.com/tensorflow/tensorflow/commit/adbbabdb0d3abb3cdeac69e38a96de1d678b24b3).
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 Faysal Hossain Shezan from University of Virginia. | {'CVE-2022-21740'} | 2022-03-03T05:13:33.901417Z | 2022-02-09T23:47:14Z | HIGH | null | {'CWE-120', 'CWE-787'} | {'https://github.com/tensorflow/tensorflow/commit/2b7100d6cdff36aa21010a82269bc05a6d1cc74a', 'https://github.com/tensorflow/tensorflow/commit/adbbabdb0d3abb3cdeac69e38a96de1d678b24b3', 'https://github.com/tensorflow/tensorflow', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-44qp-9wwf-734r', 'https://nvd.nist.gov/vuln/detail/CVE-2022-21740', 'https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/count_ops.cc#L168-L273'} | 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 | GHSA-m43c-649m-pm48 | Integer Overflow or Wraparound in OpenCV. | In opencv/modules/imgcodecs/src/utils.cpp, functions FillUniColor and FillUniGray do not check the input length, which can lead to integer overflow. If the image is from remote, may lead to remote code execution or denial of service. This affects Opencv 3.3 (corresponding with OpenCV-Python 3.3.0.9) and earlier. | {'CVE-2017-1000450'} | 2022-03-03T05:13:23.109916Z | 2021-10-12T22:03:32Z | HIGH | null | {'CWE-190'} | {'https://lists.debian.org/debian-lts-announce/2018/01/msg00008.html', 'https://github.com/opencv/opencv/pull/9726/commits/c58152d94ba878b2d7d76bcac59146312199b9eb', 'https://lists.debian.org/debian-lts-announce/2021/10/msg00028.html', 'https://nvd.nist.gov/vuln/detail/CVE-2017-1000450', 'https://github.com/blendin/pocs/blob/master/opencv/0.OOB_Write_FillUniColor', 'https://github.com/opencv/opencv/issues/9723', 'https://github.com/opencv/opencv-python', 'https://lists.debian.org/debian-lts-announce/2018/07/msg00030.html'} | null | {'https://github.com/opencv/opencv/pull/9726/commits/c58152d94ba878b2d7d76bcac59146312199b9eb'} | {'https://github.com/opencv/opencv/pull/9726/commits/c58152d94ba878b2d7d76bcac59146312199b9eb'} |
PyPI | PYSEC-2022-112 | null | Tensorflow is an Open Source Machine Learning Framework. The implementation of `StringNGrams` can be used to trigger a denial of service attack by causing an out of memory condition after an integer overflow. We are missing a validation on `pad_witdh` and that result in computing a negative value for `ngram_width` which is later used to allocate parts of the output. 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-98j8-c9q4-r38g', 'CVE-2022-21733'} | 2022-03-09T00:18:24.082433Z | 2022-02-03T12:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/f68fdab93fb7f4ddb4eb438c8fe052753c9413e8', 'https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/string_ngrams_op.cc#L29-L161', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-98j8-c9q4-r38g'} | null | {'https://github.com/tensorflow/tensorflow/commit/f68fdab93fb7f4ddb4eb438c8fe052753c9413e8'} | {'https://github.com/tensorflow/tensorflow/commit/f68fdab93fb7f4ddb4eb438c8fe052753c9413e8'} |
PyPI | PYSEC-2021-818 | null | TensorFlow is an open source platform for machine learning. In affected versions the shape inference code for `QuantizeV2` can trigger a read outside of bounds of heap allocated array. This occurs whenever `axis` is a negative value less than `-1`. In this case, we are accessing data before the start of a heap buffer. The code allows `axis` to be an optional argument (`s` would contain an `error::NOT_FOUND` error code). Otherwise, it assumes that `axis` is a valid index into the dimensions of the `input` tensor. If `axis` is less than `-1` then this results in a heap OOB read. The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, as this version is the only one that is also affected. | {'CVE-2021-41211', 'GHSA-cvgx-3v3q-m36c'} | 2021-12-09T06:35:42.767652Z | 2021-11-05T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/a0d64445116c43cf46a5666bd4eee28e7a82f244', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-cvgx-3v3q-m36c'} | null | {'https://github.com/tensorflow/tensorflow/commit/a0d64445116c43cf46a5666bd4eee28e7a82f244'} | {'https://github.com/tensorflow/tensorflow/commit/a0d64445116c43cf46a5666bd4eee28e7a82f244'} |
PyPI | GHSA-38rv-5jqc-m2cv | High severity vulnerability that affects recurly | The Recurly Client Python Library before 2.0.5, 2.1.16, 2.2.22, 2.3.1, 2.4.5, 2.5.1, 2.6.2 is vulnerable to a Server-Side Request Forgery vulnerability in the "Resource.get" method that could result in compromise of API keys or other critical resources. | {'CVE-2017-0906'} | 2022-03-03T05:14:15.050005Z | 2019-01-04T17:48:09Z | HIGH | null | {'CWE-918'} | {'https://github.com/advisories/GHSA-38rv-5jqc-m2cv', 'https://hackerone.com/reports/288635', 'https://dev.recurly.com/page/python-updates', 'https://github.com/recurly/recurly-client-python/commit/049c74699ce93cf126feff06d632ea63fba36742', 'https://nvd.nist.gov/vuln/detail/CVE-2017-0906'} | null | {'https://github.com/recurly/recurly-client-python/commit/049c74699ce93cf126feff06d632ea63fba36742'} | {'https://github.com/recurly/recurly-client-python/commit/049c74699ce93cf126feff06d632ea63fba36742'} |
PyPI | PYSEC-2017-21 | null | OpenStack Nova-LXD before 13.1.1 uses the wrong name for the veth pairs when applying Neutron security group rules for instances, which allows remote attackers to bypass intended security restrictions. | {'CVE-2017-5936'} | 2021-07-05T00:01:23.183236Z | 2017-04-12T22:59:00Z | null | null | null | {'https://bugs.launchpad.net/nova-lxd/+bug/1656847', 'http://www.securityfocus.com/bid/96182', 'http://www.ubuntu.com/usn/USN-3195-1', 'http://www.openwall.com/lists/oss-security/2017/02/09/3', 'https://github.com/openstack/nova-lxd/commit/1b76cefb92081efa1e88cd8f330253f857028bd2'} | null | {'https://github.com/openstack/nova-lxd/commit/1b76cefb92081efa1e88cd8f330253f857028bd2'} | {'https://github.com/openstack/nova-lxd/commit/1b76cefb92081efa1e88cd8f330253f857028bd2'} |
PyPI | GHSA-j7c4-2xj8-wm7r | Moderate severity vulnerability that affects kdcproxy | python-kdcproxy before 0.3.2 allows remote attackers to cause a denial of service via a large POST request. | {'CVE-2015-5159'} | 2022-03-03T05:12:56.901694Z | 2018-11-01T14:49:30Z | HIGH | null | {'CWE-20'} | {'https://bugzilla.redhat.com/show_bug.cgi?id=1245200', 'https://nvd.nist.gov/vuln/detail/CVE-2015-5159', 'https://github.com/latchset/kdcproxy', 'https://github.com/latchset/kdcproxy/commit/f274aa6787cb8b3ec1cc12c440a56665b7231882', 'https://github.com/advisories/GHSA-j7c4-2xj8-wm7r'} | null | {'https://github.com/latchset/kdcproxy/commit/f274aa6787cb8b3ec1cc12c440a56665b7231882'} | {'https://github.com/latchset/kdcproxy/commit/f274aa6787cb8b3ec1cc12c440a56665b7231882'} |
PyPI | GHSA-gcr6-rf47-jrgf | Loaded Databook of Tablib prone to python insertion resulting in command execution | An exploitable vulnerability exists in the Databook loading functionality of Tablib 0.11.4. A yaml loaded Databook can execute arbitrary python commands resulting in command execution. An attacker can insert python into loaded yaml to trigger this vulnerability. | {'CVE-2017-2810'} | 2022-04-26T18:17:04.335812Z | 2018-07-13T16:01:25Z | CRITICAL | null | null | {'https://github.com/jazzband/tablib', 'https://github.com/jazzband/tablib/commit/69abfc3ada5d754cb152119c0b4777043657cb6e', 'https://security.gentoo.org/glsa/201811-18', 'https://talosintelligence.com/vulnerability_reports/TALOS-2017-0307', 'http://www.securityfocus.com/bid/99076', 'https://nvd.nist.gov/vuln/detail/CVE-2017-2810'} | null | {'https://github.com/jazzband/tablib/commit/69abfc3ada5d754cb152119c0b4777043657cb6e'} | {'https://github.com/jazzband/tablib/commit/69abfc3ada5d754cb152119c0b4777043657cb6e'} |
PyPI | PYSEC-2021-249 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a heap buffer overflow in Eigen implementation of `tf.raw_ops.BandedTriangularSolve`. The implementation(https://github.com/tensorflow/tensorflow/blob/eccb7ec454e6617738554a255d77f08e60ee0808/tensorflow/core/kernels/linalg/banded_triangular_solve_op.cc#L269-L278) calls `ValidateInputTensors` for input validation but fails to validate that the two tensors are not empty. Furthermore, since `OP_REQUIRES` macro only stops execution of current function after setting `ctx->status()` to a non-OK value, callers of helper functions that use `OP_REQUIRES` must check value of `ctx->status()` before continuing. This doesn't happen in this op's implementation(https://github.com/tensorflow/tensorflow/blob/eccb7ec454e6617738554a255d77f08e60ee0808/tensorflow/core/kernels/linalg/banded_triangular_solve_op.cc#L219), hence the validation that is present is also not effective. 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-29612', 'GHSA-2xgj-xhgf-ggjv'} | 2021-08-27T03:22:41.356902Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-2xgj-xhgf-ggjv', 'https://github.com/tensorflow/tensorflow/commit/ba6822bd7b7324ba201a28b2f278c29a98edbef2', 'https://github.com/tensorflow/tensorflow/commit/0ab290774f91a23bebe30a358fde4e53ab4876a0'} | null | {'https://github.com/tensorflow/tensorflow/commit/0ab290774f91a23bebe30a358fde4e53ab4876a0', 'https://github.com/tensorflow/tensorflow/commit/ba6822bd7b7324ba201a28b2f278c29a98edbef2'} | {'https://github.com/tensorflow/tensorflow/commit/ba6822bd7b7324ba201a28b2f278c29a98edbef2', 'https://github.com/tensorflow/tensorflow/commit/0ab290774f91a23bebe30a358fde4e53ab4876a0'} |
PyPI | GHSA-vv2x-vrpj-qqpq | Cross-site scripting in Bleach | ### Impact
A [mutation XSS](https://cure53.de/fp170.pdf) affects users calling `bleach.clean` with all of:
* `svg` or `math` in the allowed tags
* `p` or `br` in allowed tags
* `style`, `title`, `noscript`, `script`, `textarea`, `noframes`, `iframe`, or `xmp` in allowed tags
* the keyword argument `strip_comments=False`
Note: none of the above tags are in the default allowed tags and `strip_comments` defaults to `True`.
### Patches
Users are encouraged to upgrade to bleach v3.3.0 or greater.
Note: bleach v3.3.0 introduces a breaking change to escape HTML comments by default.
### Workarounds
* modify `bleach.clean` calls to at least one of:
* not allow the `style`, `title`, `noscript`, `script`, `textarea`, `noframes`, `iframe`, or `xmp` tag
* not allow `svg` or `math` tags
* not allow `p` or `br` tags
* set `strip_comments=True`
* A strong [Content-Security-Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) without `unsafe-inline` and `unsafe-eval` [`script-src`s](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src)) will also help mitigate the risk.
### References
* https://bugzilla.mozilla.org/show_bug.cgi?id=1689399
* https://advisory.checkmarx.net/advisory/CX-2021-4303
* https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-23980
* https://cure53.de/fp170.pdf
### Credits
* Reported by [Yaniv Nizry](https://twitter.com/ynizry) from the CxSCA AppSec group at Checkmarx
* Additional eject tags not mentioned in the original advisory and the CSP mitigation line being truncated in the revised advisory reported by [Michał Bentkowski](https://twitter.com/SecurityMB) at Securitum
### For more information
If you have any questions or comments about this advisory:
* Open an issue at [https://github.com/mozilla/bleach/issues](https://github.com/mozilla/bleach/issues)
* Email us at [security@mozilla.org](mailto:security@mozilla.org) | {'CVE-2021-23980'} | 2022-03-03T05:13:57.582730Z | 2021-02-02T17:58:40Z | MODERATE | null | {'CWE-79'} | {'https://bugzilla.mozilla.org/show_bug.cgi?id=1689399', 'https://github.com/mozilla/bleach/blob/79b7a3c5e56a09d1d323a5006afa59b56162eb13/CHANGES#L4', 'https://github.com/mozilla/bleach/commit/79b7a3c5e56a09d1d323a5006afa59b56162eb13', 'https://pypi.org/project/bleach/', 'https://cure53.de/fp170.pdf', 'https://github.com/mozilla/bleach/security/advisories/GHSA-vv2x-vrpj-qqpq'} | null | {'https://github.com/mozilla/bleach/commit/79b7a3c5e56a09d1d323a5006afa59b56162eb13'} | {'https://github.com/mozilla/bleach/commit/79b7a3c5e56a09d1d323a5006afa59b56162eb13'} |
PyPI | PYSEC-2021-619 | null | TensorFlow is an open source platform for machine learning. In affected versions the shape inference functions for `SparseCountSparseOutput` can trigger a read outside of bounds of heap allocated array. 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-m342-ff57-4jcc', 'CVE-2021-41210'} | 2021-12-09T06:35:08.976231Z | 2021-11-05T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/701cfaca222a82afbeeb17496bd718baa65a67d2', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-m342-ff57-4jcc'} | null | {'https://github.com/tensorflow/tensorflow/commit/701cfaca222a82afbeeb17496bd718baa65a67d2'} | {'https://github.com/tensorflow/tensorflow/commit/701cfaca222a82afbeeb17496bd718baa65a67d2'} |
PyPI | PYSEC-2018-12 | null | An issue was discovered in lxml before 4.2.5. lxml/html/clean.py in the lxml.html.clean module does not remove javascript: URLs that use escaping, allowing a remote attacker to conduct XSS attacks, as demonstrated by "j a v a s c r i p t:" in Internet Explorer. This is a similar issue to CVE-2014-3146. | {'CVE-2018-19787'} | 2021-06-16T00:03:23.627691Z | 2018-12-02T10:29:00Z | null | null | null | {'https://github.com/lxml/lxml/commit/6be1d081b49c97cfd7b3fbd934a193b668629109', 'https://lists.debian.org/debian-lts-announce/2018/12/msg00001.html', 'https://lists.debian.org/debian-lts-announce/2020/11/msg00044.html', 'https://usn.ubuntu.com/3841-1/', 'https://usn.ubuntu.com/3841-2/'} | null | {'https://github.com/lxml/lxml/commit/6be1d081b49c97cfd7b3fbd934a193b668629109'} | {'https://github.com/lxml/lxml/commit/6be1d081b49c97cfd7b3fbd934a193b668629109'} |
PyPI | PYSEC-2020-94 | null | PySAML2 before 5.0.0 does not check that the signature in a SAML document is enveloped and thus signature wrapping is effective, i.e., it is affected by XML Signature Wrapping (XSW). The signature information and the node/object that is signed can be in different places and thus the signature verification will succeed, but the wrong data will be used. This specifically affects the verification of assertion that have been signed. | {'GHSA-qf7v-8hj3-4xw7', 'CVE-2020-5390'} | 2020-01-27T18:15:00Z | 2020-01-13T19:15:00Z | null | null | null | {'https://github.com/IdentityPython/pysaml2/commit/f27c7e7a7010f83380566a219fd6a290a00f2b6e', 'https://lists.debian.org/debian-lts-announce/2020/02/msg00025.html', 'https://usn.ubuntu.com/4245-1/', 'https://github.com/IdentityPython/pysaml2/releases/tag/v5.0.0', 'https://pypi.org/project/pysaml2/5.0.0/', 'https://github.com/IdentityPython/pysaml2/releases', 'https://github.com/IdentityPython/pysaml2/commit/5e9d5acbcd8ae45c4e736ac521fd2df5b1c62e25', 'https://www.debian.org/security/2020/dsa-4630', 'https://github.com/advisories/GHSA-qf7v-8hj3-4xw7'} | null | {'https://github.com/IdentityPython/pysaml2/commit/f27c7e7a7010f83380566a219fd6a290a00f2b6e', 'https://github.com/IdentityPython/pysaml2/commit/5e9d5acbcd8ae45c4e736ac521fd2df5b1c62e25'} | {'https://github.com/IdentityPython/pysaml2/commit/5e9d5acbcd8ae45c4e736ac521fd2df5b1c62e25', 'https://github.com/IdentityPython/pysaml2/commit/f27c7e7a7010f83380566a219fd6a290a00f2b6e'} |
PyPI | GHSA-9gjv-6qq6-v7qm | 2FA bypass through deleting devices in wagtail-2fa | ### Impact
Any user with access to the CMS can view and delete other users' 2FA devices by going to the correct path. The user does not require special permissions in order to do so. By deleting the other user's device they can disable the target user's 2FA devices and potentially compromise the account if they figure out their password.
### Patches
The problem has been patched in version 1.4.1.
### Workarounds
There is no workaround for this issue.
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [github.com/labd/wagtail-2fa](https://github.com/labd/wagtail-2fa)
* Email us at [security@labdigital.nl](mailto:security@labdigital.nl) | {'CVE-2020-5240'} | 2022-03-03T05:12:55.613973Z | 2020-03-13T21:18:55Z | HIGH | null | {'CWE-285'} | {'https://github.com/labd/wagtail-2fa/commit/ac23550d33b7436e90e3beea904647907eba5b74', 'https://nvd.nist.gov/vuln/detail/CVE-2020-5240', 'https://github.com/labd/wagtail-2fa/security/advisories/GHSA-9gjv-6qq6-v7qm'} | null | {'https://github.com/labd/wagtail-2fa/commit/ac23550d33b7436e90e3beea904647907eba5b74'} | {'https://github.com/labd/wagtail-2fa/commit/ac23550d33b7436e90e3beea904647907eba5b74'} |
PyPI | PYSEC-2021-530 | null | TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `DepthwiseConv` TFLite operator is vulnerable to a division by zero error(https://github.com/tensorflow/tensorflow/blob/1a8e885b864c818198a5b2c0cbbeca5a1e833bc8/tensorflow/lite/kernels/depthwise_conv.cc#L287-L288). An attacker can craft a model such that `input`'s fourth dimension would be 0. 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-rf3h-xgv5-2q39', 'CVE-2021-29602'} | 2021-12-09T06:34:59.232371Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/cbda3c6b2dbbd3fbdc482ff8c0170a78ec2e97d0', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-rf3h-xgv5-2q39'} | null | {'https://github.com/tensorflow/tensorflow/commit/cbda3c6b2dbbd3fbdc482ff8c0170a78ec2e97d0'} | {'https://github.com/tensorflow/tensorflow/commit/cbda3c6b2dbbd3fbdc482ff8c0170a78ec2e97d0'} |
PyPI | PYSEC-2021-160 | 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 `tf.raw_ops.AddManySparseToTensorsMap`. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/6f9896890c4c703ae0a0845394086e2e1e523299/tensorflow/core/kernels/sparse_tensors_map_ops.cc#L257) takes the values specified in `sparse_shape` as dimensions for the output shape. 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-2cpx-427x-q2c6', 'CVE-2021-29523'} | 2021-08-27T03:22:25.367237Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-2cpx-427x-q2c6'} | null | {'https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c'} | {'https://github.com/tensorflow/tensorflow/commit/69c68ecbb24dff3fa0e46da0d16c821a2dd22d7c'} |
PyPI | GHSA-vgv5-cxvh-vfxh | Arbitrary code execution in clickhouse-driver | clickhouse-driver before 0.1.5 allows a malicious clickhouse server to trigger a crash or execute arbitrary code (on a database client) via a crafted server response, due to a buffer overflow. | {'CVE-2020-26759'} | 2022-03-03T05:13:37.337736Z | 2021-04-07T20:50:57Z | CRITICAL | null | {'CWE-120'} | {'https://nvd.nist.gov/vuln/detail/CVE-2020-26759', 'https://github.com/mymarilyn/clickhouse-driver/commit/3e990547e064b8fca916b23a0f7d6fe8c63c7f6b', 'https://github.com/mymarilyn/clickhouse-driver/commit/d708ed548e1d6f254ba81a21de8ba543a53b5598'} | null | {'https://github.com/mymarilyn/clickhouse-driver/commit/3e990547e064b8fca916b23a0f7d6fe8c63c7f6b', 'https://github.com/mymarilyn/clickhouse-driver/commit/d708ed548e1d6f254ba81a21de8ba543a53b5598'} | {'https://github.com/mymarilyn/clickhouse-driver/commit/d708ed548e1d6f254ba81a21de8ba543a53b5598', 'https://github.com/mymarilyn/clickhouse-driver/commit/3e990547e064b8fca916b23a0f7d6fe8c63c7f6b'} |
PyPI | PYSEC-2021-475 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a segfault and denial of service via accessing data outside of bounds in `tf.raw_ops.QuantizedBatchNormWithGlobalNormalization`. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/55a97caa9e99c7f37a0bbbeb414dc55553d3ae7f/tensorflow/core/kernels/quantized_batch_norm_op.cc#L176-L189) assumes the inputs are not empty. If any of these inputs is empty, `.flat<T>()` is an empty buffer, so accessing the element at index 0 is accessing data outside of 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. | {'GHSA-4fg4-p75j-w5xj', 'CVE-2021-29547'} | 2021-12-09T06:34:50.647185Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-4fg4-p75j-w5xj', 'https://github.com/tensorflow/tensorflow/commit/d6ed5bcfe1dcab9e85a4d39931bd18d99018e75b'} | null | {'https://github.com/tensorflow/tensorflow/commit/d6ed5bcfe1dcab9e85a4d39931bd18d99018e75b'} | {'https://github.com/tensorflow/tensorflow/commit/d6ed5bcfe1dcab9e85a4d39931bd18d99018e75b'} |
PyPI | GHSA-pw3c-h7wp-cvhx | Improper Initialization in Pillow | Pillow is the friendly PIL (Python Imaging Library) fork. path_getbbox in path.c in Pillow before 9.0.0 improperly initializes ImagePath.Path. | {'CVE-2022-22815'} | 2022-05-05T16:20:59.030138Z | 2022-01-12T20:07:43Z | CRITICAL | null | {'CWE-665'} | {'https://github.com/python-pillow/Pillow/blob/c5d9223a8b5e9295d15b5a9b1ef1dae44c8499f3/src/path.c#L331', 'https://www.debian.org/security/2022/dsa-5053', 'https://pillow.readthedocs.io/en/stable/releasenotes/9.0.0.html#fixed-imagepath-path-array-handling', 'https://lists.debian.org/debian-lts-announce/2022/01/msg00018.html', 'https://nvd.nist.gov/vuln/detail/CVE-2022-22815', 'https://github.com/python-pillow/Pillow/commit/c48271ab354db49cdbd740bc45e13be4f0f7993c', 'https://github.com/python-pillow/Pillow'} | null | {'https://github.com/python-pillow/Pillow/commit/c48271ab354db49cdbd740bc45e13be4f0f7993c'} | {'https://github.com/python-pillow/Pillow/commit/c48271ab354db49cdbd740bc45e13be4f0f7993c'} |
PyPI | PYSEC-2022-169 | null | Waitress is a Web Server Gateway Interface server for Python 2 and 3. When using Waitress versions 2.1.0 and prior behind a proxy that does not properly validate the incoming HTTP request matches the RFC7230 standard, Waitress and the frontend proxy may disagree on where one request starts and where it ends. This would allow requests to be smuggled via the front-end proxy to waitress and later behavior. There are two classes of vulnerability that may lead to request smuggling that are addressed by this advisory: The use of Python's `int()` to parse strings into integers, leading to `+10` to be parsed as `10`, or `0x01` to be parsed as `1`, where as the standard specifies that the string should contain only digits or hex digits; and Waitress does not support chunk extensions, however it was discarding them without validating that they did not contain illegal characters. This vulnerability has been patched in Waitress 2.1.1. A workaround is available. When deploying a proxy in front of waitress, turning on any and all functionality to make sure that the request matches the RFC7230 standard. Certain proxy servers may not have this functionality though and users are encouraged to upgrade to the latest version of waitress instead. | {'CVE-2022-24761', 'GHSA-4f7p-27jc-3c36'} | 2022-03-28T18:41:52.426676Z | 2022-03-17T13:15:00Z | null | null | null | {'https://github.com/Pylons/waitress/commit/9e0b8c801e4d505c2ffc91b891af4ba48af715e0', 'https://github.com/Pylons/waitress/releases/tag/v2.1.1', 'https://github.com/Pylons/waitress/security/advisories/GHSA-4f7p-27jc-3c36'} | null | {'https://github.com/Pylons/waitress/commit/9e0b8c801e4d505c2ffc91b891af4ba48af715e0'} | {'https://github.com/Pylons/waitress/commit/9e0b8c801e4d505c2ffc91b891af4ba48af715e0'} |
PyPI | GHSA-pq64-v7f5-gqh8 | Regular Expression Denial of Service (ReDoS) in Pygments | In pygments 1.1+, fixed in 2.7.4, the lexers used to parse programming languages rely heavily on regular expressions. Some of the regular expressions have exponential or cubic worst-case complexity and are vulnerable to ReDoS. By crafting malicious input, an attacker can cause a denial of service. | {'CVE-2021-27291'} | 2022-03-03T05:13:50.070806Z | 2021-03-29T16:33:03Z | MODERATE | null | {'CWE-400'} | {'https://github.com/pygments/pygments/commit/2e7e8c4a7b318f4032493773732754e418279a14', 'https://www.debian.org/security/2021/dsa-4889', 'https://lists.debian.org/debian-lts-announce/2021/05/msg00003.html', 'https://www.debian.org/security/2021/dsa-4878', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/GSJRFHALQ7E3UV4FFMFU2YQ6LUDHAI55/', 'https://lists.debian.org/debian-lts-announce/2021/03/msg00024.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-27291', 'https://gist.github.com/b-c-ds/b1a2cc0c68a35c57188575eb496de5ce', 'https://lists.debian.org/debian-lts-announce/2021/05/msg00006.html', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/WSLD67LFGXOX2K5YNESSWAS4AGZIJTUQ/'} | null | {'https://github.com/pygments/pygments/commit/2e7e8c4a7b318f4032493773732754e418279a14'} | {'https://github.com/pygments/pygments/commit/2e7e8c4a7b318f4032493773732754e418279a14'} |
PyPI | PYSEC-2019-126 | null | ** DISPUTED ** In Supervisor through 4.0.2, an unauthenticated user can read log files or restart a service. Note: The maintainer responded that the affected component, inet_http_server, is not enabled by default but if the user enables it and does not set a password, Supervisor logs a warning message. The maintainer indicated the ability to run an open server will not be removed but an additional warning was added to the documentation. | {'CVE-2019-12105'} | 2019-09-17T22:15:00Z | 2019-09-10T17:15:00Z | null | null | null | {'https://github.com/Supervisor/supervisor/issues/1245', 'http://supervisord.org/configuration.html#inet-http-server-section-settings', 'https://github.com/Supervisor/supervisor/commit/4e334d9cf2a1daff685893e35e72398437df3dcb'} | null | {'https://github.com/Supervisor/supervisor/commit/4e334d9cf2a1daff685893e35e72398437df3dcb'} | {'https://github.com/Supervisor/supervisor/commit/4e334d9cf2a1daff685893e35e72398437df3dcb'} |
PyPI | GHSA-c7vm-f5p4-8fqh | Open redirect in Jupyter Notebook | [localhost](http://localhost:8888)
### Impact
_What kind of vulnerability is it? Who is impacted?_
Open redirect vulnerability - a maliciously crafted link to a notebook server could redirect the browser to a different website.
All notebook servers are technically affected, however, these maliciously crafted links can only be reasonably made for known notebook server hosts. A link to your notebook server may *appear* safe, but ultimately redirect to a spoofed server on the public internet.
### Patches
_Has the problem been patched? What versions should users upgrade to?_
Patched in notebook 6.1.5
### References
[OWASP page on open redirects](https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html)
### For more information
If you have any questions or comments about this advisory, or vulnerabilities to report, please email our security list [security@ipython.org](mailto:security@ipython.org).
Credit: zhuonan li of Alibaba Application Security Team | {'CVE-2020-26215'} | 2022-03-03T05:13:43.493471Z | 2020-11-18T21:06:36Z | MODERATE | null | {'CWE-601'} | {'https://nvd.nist.gov/vuln/detail/CVE-2020-26215', 'https://lists.debian.org/debian-lts-announce/2020/12/msg00004.html', 'https://github.com/jupyter/notebook/commit/3cec4bbe21756de9f0c4bccf18cf61d840314d74', 'https://github.com/jupyter/notebook/security/advisories/GHSA-c7vm-f5p4-8fqh'} | null | {'https://github.com/jupyter/notebook/commit/3cec4bbe21756de9f0c4bccf18cf61d840314d74'} | {'https://github.com/jupyter/notebook/commit/3cec4bbe21756de9f0c4bccf18cf61d840314d74'} |
PyPI | GHSA-8278-88vv-x98r | Execution of untrusted code through config file | ### Impact
It is possible to run arbitrary commands through the yaml.load() method. This could allow an attacker with local access to the host to run arbitrary code by running the application with a specially crafted YAML configuration file.
### Workarounds
Manually adjust yaml.load() to yaml.safe_load()
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [tenable/integration-jira-cloud](https://github.com/tenable/integration-jira-cloud/issues)
* Email us at [vulnreport@tenable.com](mailto:vulnreport@tenable.com) | {'CVE-2021-21371'} | 2022-03-03T05:14:11.571644Z | 2021-03-10T21:51:17Z | MODERATE | null | {'CWE-502'} | {'https://github.com/tenable/integration-jira-cloud/security/advisories/GHSA-8278-88vv-x98r', 'https://nvd.nist.gov/vuln/detail/CVE-2021-21371', 'https://github.com/tenable/integration-jira-cloud/commit/f8c2095fd529e664e7fa25403a0a4a85bb3907d0', 'https://pyyaml.docsforge.com/master/documentation/#loading-yaml', 'https://pypi.org/project/tenable-jira-cloud/'} | null | {'https://github.com/tenable/integration-jira-cloud/commit/f8c2095fd529e664e7fa25403a0a4a85bb3907d0'} | {'https://github.com/tenable/integration-jira-cloud/commit/f8c2095fd529e664e7fa25403a0a4a85bb3907d0'} |
PyPI | GHSA-9j2c-x8qm-qmjq | SQL injection in Tortoise ORM | ### Impact
Various forms of SQL injection has been found, for MySQL and when filtering or doing mass-updates on char/text fields.
SQLite & PostgreSQL was only affected when filtering with ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts)
### Patches
Please upgrade to 0.15.23+ or 0.16.6+
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [Github](https://github.com/tortoise/tortoise-orm/issues)
* Chat to us on [Gitter](https://gitter.im/tortoise/community) | {'CVE-2020-11010'} | 2022-03-03T05:13:53.716764Z | 2020-04-20T21:31:23Z | MODERATE | null | {'CWE-89'} | {'https://nvd.nist.gov/vuln/detail/CVE-2020-11010', 'https://github.com/tortoise/tortoise-orm/commit/91c364053e0ddf77edc5442914c6f049512678b3', 'https://github.com/tortoise/tortoise-orm/security/advisories/GHSA-9j2c-x8qm-qmjq'} | null | {'https://github.com/tortoise/tortoise-orm/commit/91c364053e0ddf77edc5442914c6f049512678b3'} | {'https://github.com/tortoise/tortoise-orm/commit/91c364053e0ddf77edc5442914c6f049512678b3'} |
PyPI | PYSEC-2017-99 | null | Directory traversal vulnerability in Cherry Music before 0.36.0 allows remote authenticated users to read arbitrary files via the "value" parameter to "download." | {'CVE-2015-8309'} | 2021-11-16T21:20:28.227902Z | 2017-03-27T15:59:00Z | null | null | null | {'http://www.fomori.org/cherrymusic/Changes.html', 'http://www.securityfocus.com/bid/97149', 'https://github.com/devsnd/cherrymusic/issues/598', 'https://github.com/devsnd/cherrymusic/commit/62dec34a1ea0741400dd6b6c660d303dcd651e86', 'https://www.exploit-db.com/exploits/40361/'} | null | {'https://github.com/devsnd/cherrymusic/commit/62dec34a1ea0741400dd6b6c660d303dcd651e86'} | {'https://github.com/devsnd/cherrymusic/commit/62dec34a1ea0741400dd6b6c660d303dcd651e86'} |
PyPI | GHSA-5phf-pp7p-vc2r | Using default SSLContext for HTTPS requests in an HTTPS proxy doesn't verify certificate hostname for proxy connection | ### Impact
Users who are using an HTTPS proxy to issue HTTPS requests and haven't configured their own SSLContext via `proxy_config`.
Only the default SSLContext is impacted.
### Patches
[urllib3 >=1.26.4 has the issue resolved](https://github.com/urllib3/urllib3/releases/tag/1.26.4). urllib3<1.26 is not impacted due to not supporting HTTPS requests via HTTPS proxies.
### Workarounds
Upgrading is recommended as this is a minor release and not likely to break current usage.
Configuring an `SSLContext` with `check_hostname=True` and passing via `proxy_config` instead of relying on the default `SSLContext`
### For more information
If you have any questions or comments about this advisory:
* Email us at [sethmichaellarson@gmail.com](mailto:sethmichaellarson@gmail.com) | {'CVE-2021-28363'} | 2022-03-03T05:11:25.072465Z | 2021-03-19T19:42:11Z | MODERATE | null | {'CWE-295'} | {'https://pypi.org/project/urllib3/1.26.4/', 'https://nvd.nist.gov/vuln/detail/CVE-2021-28363', 'https://github.com/urllib3/urllib3/releases/tag/1.26.4', 'https://github.com/urllib3/urllib3', 'https://github.com/urllib3/urllib3/commit/8d65ea1ecf6e2cdc27d42124e587c1b83a3118b0', 'https://www.oracle.com/security-alerts/cpuoct2021.html', 'https://security.gentoo.org/glsa/202107-36', 'https://github.com/urllib3/urllib3/blob/main/CHANGES.rst#1264-2021-03-15', 'https://github.com/urllib3/urllib3/security/advisories/GHSA-5phf-pp7p-vc2r', 'https://github.com/urllib3/urllib3/commits/main', 'https://github.com/pypa/advisory-db/tree/main/vulns/urllib3/PYSEC-2021-59.yaml', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/4S65ZQVZ2ODGB52IC7VJDBUK4M5INCXL/'} | null | {'https://github.com/urllib3/urllib3/commit/8d65ea1ecf6e2cdc27d42124e587c1b83a3118b0'} | {'https://github.com/urllib3/urllib3/commit/8d65ea1ecf6e2cdc27d42124e587c1b83a3118b0'} |
PyPI | GHSA-7257-96vg-qf6x | Remote Code Execution in Red Discord Bot | ### Impact
A RCE exploit has been discovered in the Streams module: this exploit allows Discord users with specifically crafted "going live" messages to inject code into the Streams module's going live message. By abusing this exploit, it's possible to perform destructive actions and/or access sensitive information.
### Patches
This critical exploit has been fixed on version ``3.3.12`` & ``3.4``.
### Workarounds
Unloading the Streams module with ``unload streams`` can render this exploit not accessible. We still highly recommend updating to ``3.3.12`` or ``3.4`` to completely patch this issue.
### References
* https://github.com/Cog-Creators/Red-DiscordBot/pull/4183
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [Cog-Creators/Red-DiscordBot](https://github.com/Cog-Creators/Red-DiscordBot)
* Over on our [Discord server](https://discord.gg/red) | {'CVE-2020-15147'} | 2022-03-03T05:13:02.222242Z | 2020-08-21T17:03:24Z | HIGH | null | {'CWE-94', 'CWE-74'} | {'https://github.com/Cog-Creators/Red-DiscordBot/security/advisories/GHSA-7257-96vg-qf6x', 'https://github.com/Cog-Creators/Red-DiscordBot/pull/4183/commits/e269ea0d3bc88417163c18431b1df38a9be92bfc', 'https://github.com/Cog-Creators/Red-DiscordBot/', 'https://github.com/Cog-Creators/Red-DiscordBot/pull/4183', 'https://nvd.nist.gov/vuln/detail/CVE-2020-15147'} | null | {'https://github.com/Cog-Creators/Red-DiscordBot/pull/4183/commits/e269ea0d3bc88417163c18431b1df38a9be92bfc'} | {'https://github.com/Cog-Creators/Red-DiscordBot/pull/4183/commits/e269ea0d3bc88417163c18431b1df38a9be92bfc'} |
PyPI | GHSA-fhpf-pp6p-55qc | Unsafe handling of user-specified cookies in treq | ### Impact
Treq's request methods (`treq.get`, `treq.post`, `HTTPClient.request`, `HTTPClient.get`, etc.) accept cookies as a dictionary, for example:
```py
treq.get('https://example.com/', cookies={'session': '1234'})
```
Such cookies are not bound to a single domain, and are therefore sent to *every* domain ("supercookies"). This can potentially cause sensitive information to leak upon an HTTP redirect to a different domain., e.g. should `https://example.com` redirect to `http://cloudstorageprovider.com` the latter will receive the cookie `session`.
### Patches
Treq 2021.1.0 and later bind cookies given to request methods (`treq.request`, `treq.get`, `HTTPClient.request`, `HTTPClient.get`, etc.) to the origin of the *url* parameter.
### Workarounds
Instead of passing a dictionary as the *cookies* argument, pass a `http.cookiejar.CookieJar` instance with properly domain- and scheme-scoped cookies in it:
```py
from http.cookiejar import CookieJar
from requests.cookies import create_cookie
jar = CookieJar()
jar.add_cookie(
create_cookie(
name='session',
value='1234',
domain='example.com',
secure=True,
),
)
client = HTTPClient(cookies=jar)
client.get('https://example.com/')
```
### References
* Originally reported at [huntr.dev](https://huntr.dev/bounties/3c9204fc-a3d1-4441-8599-924c5f57e7ae/?token=06d930e37046c914bcb037e85cc227dc7b510b475989fc69837566562ba899277d46b0fb4b1e21cdcb6ddc1b7d9b1ded632cf3a3551ecb89afca16a63b34641284b50479d5195bba2ac09b116f3dd4fad27f54404c2de922c05c8c8b744aec27bb4d4d198cb8b3abf479af0c2d5fbaa10412da7922594ac3eb39)
* A related issue in the handling of HTTP basic authentication was addressed in Twisted 22.1 ([GHSA-92x2-jw7w-xvvx](https://github.com/twisted/twisted/security/advisories/GHSA-92x2-jw7w-xvvx), CVE-2022-21712). | {'CVE-2022-23607'} | 2022-03-25T19:32:00.911969Z | 2022-02-01T00:43:38Z | MODERATE | null | {'CWE-601', 'CWE-200'} | {'https://nvd.nist.gov/vuln/detail/CVE-2022-23607', 'https://github.com/twisted/treq/commit/1da6022cc880bbcff59321abe02bf8498b89efb2', 'https://github.com/twisted/treq/security/advisories/GHSA-fhpf-pp6p-55qc', 'https://huntr.dev/bounties/3c9204fc-a3d1-4441-8599-924c5f57e7ae/?token=06d930e37046c914bcb037e85cc227dc7b510b475989fc69837566562ba899277d46b0fb4b1e21cdcb6ddc1b7d9b1ded632cf3a3551ecb89afca16a63b34641284b50479d5195bba2ac09b116f3dd4fad27f54404c2de922c05c8c8b744aec27bb4d4d198cb8b3abf479af0c2d5fbaa10412da7922594ac3eb39', 'https://lists.debian.org/debian-lts-announce/2022/03/msg00025.html', 'https://github.com/twisted/treq', 'https://github.com/twisted/treq/releases/tag/release-22.1.0'} | null | {'https://github.com/twisted/treq/commit/1da6022cc880bbcff59321abe02bf8498b89efb2'} | {'https://github.com/twisted/treq/commit/1da6022cc880bbcff59321abe02bf8498b89efb2'} |
PyPI | PYSEC-2021-567 | 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-12-09T06:35:03.596009Z | 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 | PYSEC-2020-137 | null | In TensorFlow Lite before versions 2.2.1 and 2.3.1, models using segment sum can trigger a write out bounds / segmentation fault if the segment ids are not sorted. Code assumes that the segment ids are in increasing order, using the last element of the tensor holding them to determine the dimensionality of output tensor. This results in allocating insufficient memory for the output tensor and in a write outside the bounds of the output array. This usually results in a segmentation fault, but depending on runtime conditions it can provide for a write gadget to be used in future memory corruption-based 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 sorted, 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. | {'CVE-2020-15214', 'GHSA-p2cq-cprg-frvm'} | 2020-10-01T18:36:00Z | 2020-09-25T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-p2cq-cprg-frvm', '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-772p-x54p-hjrv | Division by zero in `Conv3D` | ### Impact
A malicious user could trigger a division by 0 in `Conv3D` implementation:
```python
import tensorflow as tf
input_tensor = tf.constant([], shape=[0, 0, 0, 0, 0], dtype=tf.float32)
filter_tensor = tf.constant([], shape=[0, 0, 0, 0, 0], dtype=tf.float32)
tf.raw_ops.Conv3D(input=input_tensor, filter=filter_tensor, strides=[1, 56, 56, 56, 1], padding='VALID', data_format='NDHWC', dilations=[1, 1, 1, 23, 1])
```
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:
```cc
const int64 out_depth = filter.dim_size(4);
OP_REQUIRES(context, in_depth % filter_depth == 0, ...);
```
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:
```python
import tensorflow as tf
input_tensor = tf.constant([], shape=[2, 2, 2, 2, 0], dtype=tf.float32)
filter_tensor = tf.constant([], shape=[0, 0, 2, 6, 2], dtype=tf.float32)
tf.raw_ops.Conv3D(input=input_tensor, filter=filter_tensor, strides=[1, 56, 39, 34, 1], padding='VALID', data_format='NDHWC', dilations=[1, 1, 1, 1, 1])
```
The shape of the two tensors must follow the constraints specified in the [op description](https://www.tensorflow.org/api_docs/python/tf/raw_ops/Conv3D).
### Patches
We have patched the issue in GitHub commit [799f835a3dfa00a4d852defa29b15841eea9d64f](https://github.com/tensorflow/tensorflow/commit/799f835a3dfa00a4d852defa29b15841eea9d64f).
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-29517'} | 2022-03-03T05:13:42.855652Z | 2021-05-21T14:21:01Z | LOW | null | {'CWE-369'} | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-772p-x54p-hjrv', 'https://github.com/tensorflow/tensorflow/commit/799f835a3dfa00a4d852defa29b15841eea9d64f', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29517'} | null | {'https://github.com/tensorflow/tensorflow/commit/799f835a3dfa00a4d852defa29b15841eea9d64f'} | {'https://github.com/tensorflow/tensorflow/commit/799f835a3dfa00a4d852defa29b15841eea9d64f'} |
PyPI | PYSEC-2021-834 | null | TensorFlow is an open source platform for machine learning. In affected versions the `ImmutableConst` operation in TensorFlow can be tricked into reading arbitrary memory contents. This is because the `tstring` TensorFlow string class has a special case for memory mapped strings but the operation itself does not offer any support for this datatype. 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-41227', 'GHSA-j8c8-67vp-6mx7'} | 2021-12-09T06:35:45.274918Z | 2021-11-05T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/3712a2d3455e6ccb924daa5724a3652a86f6b585', 'https://github.com/tensorflow/tensorflow/commit/1cb6bb6c2a6019417c9adaf9e6843ba75ee2580b', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-j8c8-67vp-6mx7'} | null | {'https://github.com/tensorflow/tensorflow/commit/1cb6bb6c2a6019417c9adaf9e6843ba75ee2580b', 'https://github.com/tensorflow/tensorflow/commit/3712a2d3455e6ccb924daa5724a3652a86f6b585'} | {'https://github.com/tensorflow/tensorflow/commit/3712a2d3455e6ccb924daa5724a3652a86f6b585', 'https://github.com/tensorflow/tensorflow/commit/1cb6bb6c2a6019417c9adaf9e6843ba75ee2580b'} |
PyPI | PYSEC-2021-588 | null | TensorFlow is an end-to-end open source platform for machine learning. In affected versions most implementations of convolution operators in TensorFlow are affected by a division by 0 vulnerability where an attacker can trigger a denial of service via a crash. The shape inference [implementation](https://github.com/tensorflow/tensorflow/blob/460e000de3a83278fb00b61a16d161b1964f15f4/tensorflow/core/framework/common_shape_fns.cc#L577) is missing several validations before doing divisions and modulo operations. We have patched the issue in GitHub commit 8a793b5d7f59e37ac7f3cd0954a750a2fe76bad4. 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-37675', 'GHSA-9c8h-2mv3-49ww'} | 2021-12-09T06:35:05.402350Z | 2021-08-12T22:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/8a793b5d7f59e37ac7f3cd0954a750a2fe76bad4', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-9c8h-2mv3-49ww'} | null | {'https://github.com/tensorflow/tensorflow/commit/8a793b5d7f59e37ac7f3cd0954a750a2fe76bad4'} | {'https://github.com/tensorflow/tensorflow/commit/8a793b5d7f59e37ac7f3cd0954a750a2fe76bad4'} |
PyPI | GHSA-c6fh-56w7-fvjw | Integer overflow in Tensorflow | ### Impact
The [implementation of shape inference for `Dequantize`](https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/ops/array_ops.cc#L3001-L3034) is vulnerable to an integer overflow weakness:
```python
import tensorflow as tf
input = tf.constant([1,1],dtype=tf.qint32)
@tf.function
def test():
y = tf.raw_ops.Dequantize(
input=input,
min_range=[1.0],
max_range=[10.0],
mode='MIN_COMBINED',
narrow_range=False,
axis=2**31-1,
dtype=tf.bfloat16)
return y
test()
```
The `axis` argument can be `-1` (the default value for the optional argument) or any other positive value at most the number of dimensions of the input. Unfortunately, the upper bound is not checked, and, since the code computes `axis + 1`, an attacker can trigger an integer overflow:
```cc
int axis = -1;
Status s = c->GetAttr("axis", &axis);
// ...
if (axis < -1) {
return errors::InvalidArgument("axis should be at least -1, got ",
axis);
}
// ...
if (axis != -1) {
ShapeHandle input;
TF_RETURN_IF_ERROR(c->WithRankAtLeast(c->input(0), axis + 1, &input));
// ...
}
```
### Patches
We have patched the issue in GitHub commit [b64638ec5ccaa77b7c1eb90958e3d85ce381f91b](https://github.com/tensorflow/tensorflow/commit/b64638ec5ccaa77b7c1eb90958e3d85ce381f91b).
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-21727'} | 2022-03-03T05:13:17.721694Z | 2022-02-09T18:29:13Z | HIGH | null | {'CWE-190'} | {'https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/ops/array_ops.cc#L3001-L3034', 'https://github.com/tensorflow/tensorflow/', 'https://nvd.nist.gov/vuln/detail/CVE-2022-21727', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-c6fh-56w7-fvjw', 'https://github.com/tensorflow/tensorflow/commit/b64638ec5ccaa77b7c1eb90958e3d85ce381f91b'} | null | {'https://github.com/tensorflow/tensorflow/commit/b64638ec5ccaa77b7c1eb90958e3d85ce381f91b'} | {'https://github.com/tensorflow/tensorflow/commit/b64638ec5ccaa77b7c1eb90958e3d85ce381f91b'} |
PyPI | GHSA-9jjr-qqfp-ppwx | remote code execution via git repo provider | ### Impact
A remote code execution vulnerability has been identified in BinderHub, where providing BinderHub with maliciously crafted input could execute code in the BinderHub context, with the potential to egress credentials of the BinderHub deployment, including JupyterHub API tokens, kubernetes service accounts, and docker registry credentials. This may provide the ability to manipulate images and other user created pods in the deployment, with the potential to escalate to the host depending on the underlying kubernetes configuration.
### Patches
Patch below, or [on GitHub](https://github.com/jupyterhub/binderhub/commit/195caac172690456dcdc8cc7a6ca50e05abf8182.patch)
```diff
From 9f4043d9dddc1174920e687773f27b7933f48ab6 Mon Sep 17 00:00:00 2001
From: Riccardo Castellotti <rcastell@cern.ch>
Date: Thu, 19 Aug 2021 15:49:43 +0200
Subject: [PATCH] Explicitly separate git-ls-remote options from positional
arguments
---
binderhub/repoproviders.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/binderhub/repoproviders.py b/binderhub/repoproviders.py
index f33347b..5d4b87c 100755
--- a/binderhub/repoproviders.py
+++ b/binderhub/repoproviders.py
@@ -484,7 +484,7 @@ class GitRepoProvider(RepoProvider):
self.sha1_validate(self.unresolved_ref)
except ValueError:
# The ref is a head/tag and we resolve it using `git ls-remote`
- command = ["git", "ls-remote", self.repo, self.unresolved_ref]
+ command = ["git", "ls-remote", "--", self.repo, self.unresolved_ref]
result = subprocess.run(command, universal_newlines=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if result.returncode:
raise RuntimeError("Unable to run git ls-remote to get the `resolved_ref`: {}".format(result.stderr))
--
2.25.1
```
### Workarounds
Disable the git repo provider by specifying the `BinderHub.repo_providers` config, e.g.:
```python
from binderhub.repoproviders import (GitHubRepoProvider,
GitLabRepoProvider, GistRepoProvider,
ZenodoProvider, FigshareProvider, HydroshareProvider,
DataverseProvider)
c.BinderHub.repo_providers = {
'gh': GitHubRepoProvider,
'gist': GistRepoProvider,
'gl': GitLabRepoProvider,
'zenodo': ZenodoProvider,
'figshare': FigshareProvider,
'hydroshare': HydroshareProvider,
'dataverse': DataverseProvider,
}
```
### References
Credit: Jose Carlos Luna Duran (CERN) and Riccardo Castellotti (CERN).
### For more information
If you have any questions or comments about this advisory:
* Email us at [security@ipython.org](mailto:security@ipython.org)
| {'CVE-2021-39159'} | 2022-03-07T20:47:54.940121Z | 2021-08-30T16:16:58Z | CRITICAL | null | {'CWE-94'} | {'https://github.com/jupyterhub/binderhub/security/advisories/GHSA-9jjr-qqfp-ppwx', 'https://github.com/jupyterhub/binderhub', 'https://github.com/jupyterhub/binderhub/commit/195caac172690456dcdc8cc7a6ca50e05abf8182.patch', 'https://nvd.nist.gov/vuln/detail/CVE-2021-39159'} | null | {'https://github.com/jupyterhub/binderhub/commit/195caac172690456dcdc8cc7a6ca50e05abf8182'} | {'https://github.com/jupyterhub/binderhub/commit/195caac172690456dcdc8cc7a6ca50e05abf8182'} |
PyPI | GHSA-9hx2-hgq2-2g4f | Regular Expression Denial of Service (ReDoS) in Pillow | An issue was discovered in Pillow before 8.1.1. The PDF parser allows a regular expression DoS (ReDoS) attack via a crafted PDF file because of a catastrophic backtracking regex. | {'CVE-2021-25292'} | 2022-03-03T05:13:09.680069Z | 2021-03-29T16:35:46Z | MODERATE | null | {'CWE-400'} | {'https://pillow.readthedocs.io/en/stable/releasenotes/8.1.1.html', 'https://security.gentoo.org/glsa/202107-33', 'https://github.com/python-pillow/Pillow/commit/3bce145966374dd39ce58a6fc0083f8d1890719c', 'https://github.com/python-pillow/Pillow/', 'https://nvd.nist.gov/vuln/detail/CVE-2021-25292', 'https://github.com/python-pillow/Pillow/commit/6207b44ab1ff4a91d8ddc7579619876d0bb191a4'} | null | {'https://github.com/python-pillow/Pillow/commit/6207b44ab1ff4a91d8ddc7579619876d0bb191a4', 'https://github.com/python-pillow/Pillow/commit/3bce145966374dd39ce58a6fc0083f8d1890719c'} | {'https://github.com/python-pillow/Pillow/commit/6207b44ab1ff4a91d8ddc7579619876d0bb191a4', 'https://github.com/python-pillow/Pillow/commit/3bce145966374dd39ce58a6fc0083f8d1890719c'} |
PyPI | GHSA-qh9q-34h6-hcv9 | Directory traversal in mkdocs | The mkdocs 1.2.2 built-in dev-server allows directory traversal using the port 8000, enabling remote exploitation to obtain :sensitive information. | {'CVE-2021-40978'} | 2022-03-03T05:11:10.810939Z | 2021-10-12T18:48:24Z | HIGH | null | {'CWE-12', 'CWE-22'} | {'https://github.com/mkdocs/mkdocs/pull/2604/commits/cddc453c9d49298e60e7d56fb71130c151cbcbe5', 'https://github.com/nisdn/CVE-2021-40978', 'https://github.com/mkdocs/mkdocs', 'https://github.com/nisdn/CVE-2021-40978/issues/1', 'https://nvd.nist.gov/vuln/detail/CVE-2021-40978', 'https://github.com/mkdocs/mkdocs/releases/tag/1.2.3', 'https://github.com/mkdocs/mkdocs/issues/2601', 'https://github.com/mkdocs/mkdocs/pull/2604'} | null | {'https://github.com/mkdocs/mkdocs/pull/2604/commits/cddc453c9d49298e60e7d56fb71130c151cbcbe5'} | {'https://github.com/mkdocs/mkdocs/pull/2604/commits/cddc453c9d49298e60e7d56fb71130c151cbcbe5'} |
PyPI | PYSEC-2021-208 | 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/31bd5026304677faa8a0b77602c6154171b9aec1/tensorflow/core/kernels/image/draw_bounding_box_op.cc#L116-L130) assumes that the last element of `boxes` input is 4, as required by [the op](https://www.tensorflow.org/api_docs/python/tf/raw_ops/DrawBoundingBoxesV2). Since this is not checked attackers passing values less than 4 can write outside of bounds of heap allocated objects and cause memory corruption. If the last dimension in `boxes` is less than 4, accesses similar to `tboxes(b, bb, 3)` will access data outside of bounds. Further during code execution there are also writes to these indices. 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-29571', 'GHSA-whr9-vfh2-7hm6'} | 2021-08-27T03:22:34.015475Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/79865b542f9ffdc9caeb255631f7c56f1d4b6517', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-whr9-vfh2-7hm6'} | null | {'https://github.com/tensorflow/tensorflow/commit/79865b542f9ffdc9caeb255631f7c56f1d4b6517'} | {'https://github.com/tensorflow/tensorflow/commit/79865b542f9ffdc9caeb255631f7c56f1d4b6517'} |
PyPI | PYSEC-2021-658 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can force accesses outside the bounds of heap allocated arrays by passing in invalid tensor values to `tf.raw_ops.RaggedCross`. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/efea03b38fb8d3b81762237dc85e579cc5fc6e87/tensorflow/core/kernels/ragged_cross_op.cc#L456-L487) lacks validation for the user supplied arguments. Each of the above branches call a helper function after accessing array elements via a `*_list[next_*]` pattern, followed by incrementing the `next_*` index. However, as there is no validation that the `next_*` values are in the valid range for the corresponding `*_list` arrays, this results in heap OOB reads. 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-29532', 'GHSA-j47f-4232-hvv8'} | 2021-12-09T06:35:20.263925Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-j47f-4232-hvv8', 'https://github.com/tensorflow/tensorflow/commit/44b7f486c0143f68b56c34e2d01e146ee445134a'} | null | {'https://github.com/tensorflow/tensorflow/commit/44b7f486c0143f68b56c34e2d01e146ee445134a'} | {'https://github.com/tensorflow/tensorflow/commit/44b7f486c0143f68b56c34e2d01e146ee445134a'} |
PyPI | PYSEC-2021-17 | null | Multiple path traversal vulnerabilities exist in smbserver.py in Impacket through 0.9.22. An attacker that connects to a running smbserver instance can list and write to arbitrary files via ../ directory traversal. This could potentially be abused to achieve arbitrary code execution by replacing /etc/shadow or an SSH authorized key. | {'GHSA-mj63-64x7-57xf', 'CVE-2021-31800'} | 2021-09-01T08:19:03.897095Z | 2021-05-05T11:15:00Z | null | null | null | {'https://github.com/SecureAuthCorp/impacket/releases', 'https://github.com/SecureAuthCorp/impacket/blob/cb6d43a677c338db930bc4e9161620832c1ec624/impacket/smbserver.py#L2958', 'https://github.com/SecureAuthCorp/impacket/blob/cb6d43a677c338db930bc4e9161620832c1ec624/impacket/smbserver.py#L2008', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/IPXDPWCAPVX3UWYZ3N2T5OLBSBBUHJP6/', 'https://github.com/SecureAuthCorp/impacket/blob/cb6d43a677c338db930bc4e9161620832c1ec624/impacket/smbserver.py#L3485', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/KRV2C5DATXBHG6TF6CEEX54KZ75THQS3/', 'https://github.com/SecureAuthCorp/impacket/blob/cb6d43a677c338db930bc4e9161620832c1ec624/impacket/smbserver.py#L876', 'https://github.com/SecureAuthCorp/impacket/commit/49c643bf66620646884ed141c94e5fdd85bcdd2f', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/UF56LYB27LHEIFJTFHU3M75NMNNK2SCG/', 'https://github.com/advisories/GHSA-mj63-64x7-57xf'} | null | {'https://github.com/SecureAuthCorp/impacket/commit/49c643bf66620646884ed141c94e5fdd85bcdd2f'} | {'https://github.com/SecureAuthCorp/impacket/commit/49c643bf66620646884ed141c94e5fdd85bcdd2f'} |
PyPI | PYSEC-2021-822 | null | TensorFlow is an open source platform for machine learning. In affected versions the shape inference code for `DeserializeSparse` can trigger a null pointer dereference. This is because the shape inference function assumes that the `serialize_sparse` tensor is a tensor with positive rank (and having `3` as the last dimension). 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-x3v8-c8qx-3j3r', 'CVE-2021-41215'} | 2021-12-09T06:35:43.442119Z | 2021-11-05T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-x3v8-c8qx-3j3r', 'https://github.com/tensorflow/tensorflow/commit/d3738dd70f1c9ceb547258cbb82d853da8771850'} | null | {'https://github.com/tensorflow/tensorflow/commit/d3738dd70f1c9ceb547258cbb82d853da8771850'} | {'https://github.com/tensorflow/tensorflow/commit/d3738dd70f1c9ceb547258cbb82d853da8771850'} |
PyPI | PYSEC-2020-121 | null | In Tensorflow before version 2.3.1, the `SparseCountSparseOutput` implementation does not validate that the input arguments form a valid sparse tensor. In particular, there is no validation that the `indices` tensor has the same shape as the `values` one. The values in these tensors are always accessed in parallel. Thus, a shape mismatch can result in accesses outside the bounds of heap allocated buffers. The issue is patched in commit 3cbb917b4714766030b28eba9fb41bb97ce9ee02 and is released in TensorFlow version 2.3.1. | {'CVE-2020-15198', 'GHSA-jc87-6vpp-7ff3'} | 2021-09-01T08:19:33.154302Z | 2020-09-25T19:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-jc87-6vpp-7ff3', 'https://github.com/tensorflow/tensorflow/commit/3cbb917b4714766030b28eba9fb41bb97ce9ee02', '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 | GHSA-qh32-6jjc-qprm | Null pointer dereference in tensorflow-lite | ### Impact
A crafted TFLite model can force a node to have as input a tensor backed by a `nullptr` buffer. This can be achieved by changing a buffer index in the flatbuffer serialization to convert a read-only tensor to a read-write one. The runtime assumes that these buffers are written to before a possible read, hence they are initialized with `nullptr`:
https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/lite/core/subgraph.cc#L1224-L1227
However, by changing the buffer index for a tensor and implicitly converting that tensor to be a read-write one, as there is nothing in the model that writes to it, we get a null pointer dereference.
### Patches
We have patched the issue in 0b5662bc 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.
### 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 but was also discovered through variant analysis of [GHSA-cvpc-8phh-8f45](https://github.com/tensorflow/tensorflow/security/advisories/GHSA-cvpc-8phh-8f45). | {'CVE-2020-15209'} | 2022-03-03T05:13:59.726583Z | 2020-09-25T18:28:46Z | MODERATE | null | {'CWE-476'} | {'https://github.com/tensorflow/tensorflow/commit/0b5662bc2be13a8c8f044d925d87fb6e56247cd8', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-qh32-6jjc-qprm', 'http://lists.opensuse.org/opensuse-security-announce/2020-10/msg00065.html', 'https://github.com/tensorflow/tensorflow', 'https://nvd.nist.gov/vuln/detail/CVE-2020-15209', 'https://github.com/tensorflow/tensorflow/releases/tag/v2.3.1'} | null | {'https://github.com/tensorflow/tensorflow/commit/0b5662bc2be13a8c8f044d925d87fb6e56247cd8'} | {'https://github.com/tensorflow/tensorflow/commit/0b5662bc2be13a8c8f044d925d87fb6e56247cd8'} |
PyPI | PYSEC-2021-571 | 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.MatrixSetDiagV*`. 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 ff8894044dfae5568ecbf2ed514c1a37dc394f1b. 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-37658', 'GHSA-6p5r-g9mq-ggh2'} | 2021-12-09T06:35:03.923873Z | 2021-08-12T21:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/ff8894044dfae5568ecbf2ed514c1a37dc394f1b', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-6p5r-g9mq-ggh2'} | null | {'https://github.com/tensorflow/tensorflow/commit/ff8894044dfae5568ecbf2ed514c1a37dc394f1b'} | {'https://github.com/tensorflow/tensorflow/commit/ff8894044dfae5568ecbf2ed514c1a37dc394f1b'} |
PyPI | GHSA-3r7g-wrpr-j5g4 | Improper Authentication in django-mfa3 | ### Impact
django-mfa3 is a library that implements multi factor authentication for the django web framework. It achieves this by modifying the regular login view. Django however has a second login view for its admin area. This second login view was not modified, so the multi factor authentication can be bypassed.
You are affected if you have activated both django-mfa3 (< 0.5.0) and django.contrib.admin and have not taken any other measures to prevent users from accessing the admin login view.
### Patches
The issue has been fixed in django-mfa3 0.5.0.
### Workarounds
It is possible to work around the issue by overwriting the admin login route, e.g. by adding the following URL definition *before* the admin routes:
url('admin/login/', lambda request: redirect(settings.LOGIN_URL)
### References
- [django-mfa3 changelog](https://github.com/xi/django-mfa3/blob/main/CHANGES.md#050-2022-04-15)
| {'CVE-2022-24857'} | 2022-04-22T21:00:12.905217Z | 2022-04-22T20:48:28Z | HIGH | null | {'CWE-287'} | {'https://github.com/xi/django-mfa3/commit/32f656e22df120b84bdf010e014bb19bd97971de', 'https://github.com/xi/django-mfa3/blob/main/CHANGES.md#050-2022-04-15', 'https://nvd.nist.gov/vuln/detail/CVE-2022-24857', 'https://github.com/xi/django-mfa3', 'https://github.com/xi/django-mfa3/security/advisories/GHSA-3r7g-wrpr-j5g4'} | null | {'https://github.com/xi/django-mfa3/commit/32f656e22df120b84bdf010e014bb19bd97971de'} | {'https://github.com/xi/django-mfa3/commit/32f656e22df120b84bdf010e014bb19bd97971de'} |
PyPI | GHSA-vrcf-g539-x6h3 | Uncontrolled deserialization of a pickled object in rediswrapper allows attackers to execute arbitrary scripts | Uncontrolled deserialization of a pickled object in models.py in Frost Ming rediswrapper (aka Redis Wrapper) before 0.3.0 allows attackers to execute arbitrary scripts. | {'CVE-2019-17206'} | 2022-03-23T20:30:08.081246Z | 2019-11-20T01:37:13Z | CRITICAL | null | {'CWE-502'} | {'https://nvd.nist.gov/vuln/detail/CVE-2019-17206', 'https://github.com/frostming/rediswrapper/commit/748f60bafd857c24f65683426f665350e2c3f91b', 'https://github.com/frostming/rediswrapper/pull/1', 'https://github.com/frostming/rediswrapper', 'https://github.com/frostming/rediswrapper/compare/v0.2.1...v0.3.0', 'https://github.com/frostming/rediswrapper/releases/tag/v0.3.0'} | null | {'https://github.com/frostming/rediswrapper/commit/748f60bafd857c24f65683426f665350e2c3f91b'} | {'https://github.com/frostming/rediswrapper/commit/748f60bafd857c24f65683426f665350e2c3f91b'} |
PyPI | PYSEC-2022-128 | null | Tensorflow is an Open Source Machine Learning Framework. When decoding a resource handle tensor from protobuf, a TensorFlow process can encounter cases where a `CHECK` assertion is invalidated based on user controlled arguments. 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-8rcj-c8pj-v3m3', 'CVE-2022-23564'} | 2022-03-09T00:18:26.187094Z | 2022-02-04T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/14fea662350e7c26eb5fe1be2ac31704e5682ee6', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-8rcj-c8pj-v3m3'} | null | {'https://github.com/tensorflow/tensorflow/commit/14fea662350e7c26eb5fe1be2ac31704e5682ee6'} | {'https://github.com/tensorflow/tensorflow/commit/14fea662350e7c26eb5fe1be2ac31704e5682ee6'} |
PyPI | PYSEC-2017-37 | null | SaltStack Salt before 2016.3.8, 2016.11.x before 2016.11.8, and 2017.7.x before 2017.7.2 allows remote attackers to cause a denial of service via a crafted authentication request. | {'CVE-2017-14696'} | 2021-07-05T00:01:26.641829Z | 2017-10-24T17:29:00Z | null | null | null | {'https://github.com/saltstack/salt/commit/5f8b5e1a0f23fe0f2be5b3c3e04199b57a53db5b', 'http://lists.opensuse.org/opensuse-updates/2017-10/msg00075.html', 'https://bugzilla.redhat.com/show_bug.cgi?id=1500742', 'https://docs.saltstack.com/en/latest/topics/releases/2017.7.2.html', 'http://lists.opensuse.org/opensuse-updates/2017-10/msg00073.html', 'https://docs.saltstack.com/en/latest/topics/releases/2016.3.8.html', 'https://docs.saltstack.com/en/latest/topics/releases/2016.11.8.html'} | null | {'https://github.com/saltstack/salt/commit/5f8b5e1a0f23fe0f2be5b3c3e04199b57a53db5b'} | {'https://github.com/saltstack/salt/commit/5f8b5e1a0f23fe0f2be5b3c3e04199b57a53db5b'} |
PyPI | GHSA-43jf-985q-588j | Multiple `CHECK`-fails in `function.cc` in TensowFlow | ### Impact
A malicious user can cause a denial of service by altering a `SavedModel` such that [assertions in `function.cc`](https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/function.cc) would be falsified and crash the Python interpreter.
### Patches
We have patched the issue in GitHub commits [dcc21c7bc972b10b6fb95c2fb0f4ab5a59680ec2](https://github.com/tensorflow/tensorflow/commit/dcc21c7bc972b10b6fb95c2fb0f4ab5a59680ec2) and [3d89911481ba6ebe8c88c1c0b595412121e6c645](https://github.com/tensorflow/tensorflow/commit/3d89911481ba6ebe8c88c1c0b595412121e6c645).
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-23586'} | 2022-03-03T05:14:05.260639Z | 2022-02-09T23:27:08Z | MODERATE | null | {'CWE-617'} | {'https://github.com/tensorflow/tensorflow/commit/3d89911481ba6ebe8c88c1c0b595412121e6c645', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-43jf-985q-588j', 'https://github.com/tensorflow/tensorflow/commit/dcc21c7bc972b10b6fb95c2fb0f4ab5a59680ec2', 'https://github.com/tensorflow/tensorflow', 'https://github.com/tensorflow/tensorflow/blob/a1320ec1eac186da1d03f033109191f715b2b130/tensorflow/core/framework/function.cc', 'https://nvd.nist.gov/vuln/detail/CVE-2022-23586'} | null | {'https://github.com/tensorflow/tensorflow/commit/3d89911481ba6ebe8c88c1c0b595412121e6c645', 'https://github.com/tensorflow/tensorflow/commit/dcc21c7bc972b10b6fb95c2fb0f4ab5a59680ec2'} | {'https://github.com/tensorflow/tensorflow/commit/3d89911481ba6ebe8c88c1c0b595412121e6c645', 'https://github.com/tensorflow/tensorflow/commit/dcc21c7bc972b10b6fb95c2fb0f4ab5a59680ec2'} |
PyPI | PYSEC-2021-176 | null | TensorFlow is an end-to-end open source platform for machine learning. Calling `tf.raw_ops.ImmutableConst`(https://www.tensorflow.org/api_docs/python/tf/raw_ops/ImmutableConst) with a `dtype` of `tf.resource` or `tf.variant` results in a segfault in the implementation as code assumes that the tensor contents are pure scalars. We have patched the issue in 4f663d4b8f0bec1b48da6fa091a7d29609980fa4 and will release TensorFlow 2.5.0 containing the patch. TensorFlow nightly packages after this commit will also have the issue resolved. If using `tf.raw_ops.ImmutableConst` in code, you can prevent the segfault by inserting a filter for the `dtype` argument. | {'GHSA-g4h2-gqm3-c9wq', 'CVE-2021-29539'} | 2021-08-27T03:22:28.395200Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/commit/4f663d4b8f0bec1b48da6fa091a7d29609980fa4', 'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-g4h2-gqm3-c9wq'} | null | {'https://github.com/tensorflow/tensorflow/commit/4f663d4b8f0bec1b48da6fa091a7d29609980fa4'} | {'https://github.com/tensorflow/tensorflow/commit/4f663d4b8f0bec1b48da6fa091a7d29609980fa4'} |
PyPI | PYSEC-2021-526 | null | TensorFlow is an end-to-end open source platform for machine learning. The implementation of the `SVDF` TFLite operator is vulnerable to a division by zero error(https://github.com/tensorflow/tensorflow/blob/7f283ff806b2031f407db64c4d3edcda8fb9f9f5/tensorflow/lite/kernels/svdf.cc#L99-L102). An attacker can craft a model such that `params->rank` would be 0. 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-29598', 'GHSA-pmpr-55fj-r229'} | 2021-12-09T06:34:58.584252Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-pmpr-55fj-r229', 'https://github.com/tensorflow/tensorflow/commit/6841e522a3e7d48706a02e8819836e809f738682'} | null | {'https://github.com/tensorflow/tensorflow/commit/6841e522a3e7d48706a02e8819836e809f738682'} | {'https://github.com/tensorflow/tensorflow/commit/6841e522a3e7d48706a02e8819836e809f738682'} |
PyPI | GHSA-36vm-xw34-x4pj | CHECK-fail in `tf.raw_ops.IRFFT` | ### Impact
An attacker can cause a denial of service by exploiting a `CHECK`-failure coming from the implementation of `tf.raw_ops.IRFFT`:
```python
import tensorflow as tf
values = [-10.0] * 130
values[0] = -9.999999999999995
inputs = tf.constant(values, shape=[10, 13], dtype=tf.float32)
inputs = tf.cast(inputs, dtype=tf.complex64)
fft_length = tf.constant([0], shape=[1], dtype=tf.int32)
tf.raw_ops.IRFFT(input=inputs, fft_length=fft_length)
```
The above example causes Eigen code to operate on an empty matrix. This triggers on an assertion and causes program termination.
### Patches
We have patched the issue in GitHub commit [1c56f53be0b722ca657cbc7df461ed676c8642a2](https://github.com/tensorflow/tensorflow/commit/1c56f53be0b722ca657cbc7df461ed676c8642a2).
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-29562'} | 2022-03-03T05:13:05.634583Z | 2021-05-21T14:25:02Z | LOW | null | {'CWE-617'} | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-36vm-xw34-x4pj', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29562', 'https://github.com/tensorflow/tensorflow/commit/1c56f53be0b722ca657cbc7df461ed676c8642a2'} | null | {'https://github.com/tensorflow/tensorflow/commit/1c56f53be0b722ca657cbc7df461ed676c8642a2'} | {'https://github.com/tensorflow/tensorflow/commit/1c56f53be0b722ca657cbc7df461ed676c8642a2'} |
PyPI | PYSEC-2020-82 | null | libImaging/SgiRleDecode.c in Pillow before 6.2.2 has an SGI buffer overflow. | {'CVE-2020-5311'} | 2020-07-10T17:06:00Z | 2020-01-03T01:15:00Z | null | null | null | {'https://usn.ubuntu.com/4272-1/', 'https://www.debian.org/security/2020/dsa-4631', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/2MMU3WT2X64GS5WHDPKKC2WZA7UIIQ3A/', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/3DUMIBUYGJRAVJCTFUWBRLVQKOUTVX5P/', 'https://github.com/python-pillow/Pillow/commit/a79b65c47c7dc6fe623aadf09aa6192fc54548f3', 'https://access.redhat.com/errata/RHSA-2020:0580', 'https://pillow.readthedocs.io/en/stable/releasenotes/6.2.2.html', 'https://access.redhat.com/errata/RHSA-2020:0566'} | null | {'https://github.com/python-pillow/Pillow/commit/a79b65c47c7dc6fe623aadf09aa6192fc54548f3'} | {'https://github.com/python-pillow/Pillow/commit/a79b65c47c7dc6fe623aadf09aa6192fc54548f3'} |
PyPI | PYSEC-2019-130 | null | typed_ast 1.3.0 and 1.3.1 has a handle_keywordonly_args 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-19274', 'GHSA-m3jw-62m7-jjcm'} | 2020-03-14T02:15:00Z | 2019-11-26T15:15:00Z | null | null | null | {'https://github.com/python/cpython/commit/a4d78362397fc3bced6ea80fbc7b5f4827aec55e', 'https://github.com/advisories/GHSA-m3jw-62m7-jjcm', 'https://bugs.python.org/issue36495', 'https://github.com/python/cpython/commit/dcfcd146f8e6fc5c2fc16a4c192a0c5f5ca8c53c', '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 | GHSA-7r87-cj48-wj45 | Potential Captcha Validate Bypass in flask-session-captcha | ### Impact
flask-session-captcha is a package which allows users to extend Flask by adding an image based captcha stored in a server side session.
The `captcha.validate()` function would return `None` if passed no value (e.g. by submitting a request with an empty form).
If implementing users were checking the return value to be **False**, the captcha verification check could be bypassed.
Sample vulnerable code:
```python
if captcha.validate() == False:
... # abort
else:
... # do stuff
```
### Patches
A new version (1.2.1) is available that fixes the issue.
### Workarounds
Users can workaround the issue by not explicitly checking that the value is False.
Checking the return value less explicitly should still work.
```python
if not captcha.validate():
... # abort
else:
... # do stuff
```
```python
if captcha.validate():
... # do stuff
else:
... # abort
```
### References
https://github.com/Tethik/flask-session-captcha/pull/27
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [the github repo](https://github.com/Tethik/flask-session-captcha)
| {'CVE-2022-24880'} | 2022-04-27T18:31:59.848285Z | 2022-04-26T21:19:52Z | MODERATE | null | {'CWE-394', 'CWE-253', 'CWE-754'} | {'https://nvd.nist.gov/vuln/detail/CVE-2022-24880', 'https://github.com/Tethik/flask-session-captcha/commit/2811ae23a38d33b620fb7a07de8837c6d65c13e4', 'https://github.com/Tethik/flask-session-captcha/security/advisories/GHSA-7r87-cj48-wj45', 'https://github.com/Tethik/flask-session-captcha/releases/tag/v1.2.1', 'https://github.com/Tethik/flask-session-captcha/pull/27', 'https://github.com/Tethik/flask-session-captcha'} | null | {'https://github.com/Tethik/flask-session-captcha/commit/2811ae23a38d33b620fb7a07de8837c6d65c13e4'} | {'https://github.com/Tethik/flask-session-captcha/commit/2811ae23a38d33b620fb7a07de8837c6d65c13e4'} |
PyPI | PYSEC-2022-50 | null | Tensorflow is an Open Source Machine Learning Framework. The implementation of `Dequantize` does not fully validate the value of `axis` and can result in heap OOB accesses. The `axis` argument can be `-1` (the default value for the optional argument) or any other positive value at most the number of dimensions of the input. Unfortunately, the upper bound is not checked and this results in reading past the end of the array containing the dimensions of the input tensor. 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-23hm-7w47-xw72', 'CVE-2022-21726'} | 2022-03-09T00:17:30.059421Z | 2022-02-03T11:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-23hm-7w47-xw72', 'https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/dequantize_op.cc#L92-L153', 'https://github.com/tensorflow/tensorflow/commit/23968a8bf65b009120c43b5ebcceaf52dbc9e943'} | null | {'https://github.com/tensorflow/tensorflow/commit/23968a8bf65b009120c43b5ebcceaf52dbc9e943'} | {'https://github.com/tensorflow/tensorflow/commit/23968a8bf65b009120c43b5ebcceaf52dbc9e943'} |
PyPI | GHSA-3xv8-3j54-hgrp | Out-of-bounds read in Pillow | In libImaging/PcxDecode.c in Pillow before 6.2.3 and 7.x before 7.0.1, an out-of-bounds read can occur when reading PCX files where state->shuffle is instructed to read beyond state->buffer. | {'CVE-2020-10378'} | 2022-03-03T05:13:25.261642Z | 2021-11-03T18:04:53Z | MODERATE | null | {'CWE-125'} | {'https://github.com/python-pillow/Pillow/commits/master/src/libImaging', 'https://github.com/pypa/advisory-db/blob/7872b0a91b4d980f749e6d75a81f8cc1af32829f/vulns/pillow/PYSEC-2020-77.yaml', 'https://nvd.nist.gov/vuln/detail/CVE-2020-10378', 'https://github.com/python-pillow/Pillow/commit/6a83e4324738bb0452fbe8074a995b1c73f08de7#diff-9478f2787e3ae9668a15123b165c23ac', 'https://pillow.readthedocs.io/en/stable/releasenotes/6.2.3.html', '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/commit/6a83e4324738bb0452fbe8074a995b1c73f08de7#diff-9478f2787e3ae9668a15123b165c23ac'} | {'https://github.com/python-pillow/Pillow/commit/6a83e4324738bb0452fbe8074a995b1c73f08de7#diff-9478f2787e3ae9668a15123b165c23ac'} |
PyPI | GHSA-pmpr-55fj-r229 | Division by zero in TFLite's implementation of `SVDF` | ### Impact
The implementation of the `SVDF` TFLite operator is [vulnerable to a division by zero error](https://github.com/tensorflow/tensorflow/blob/7f283ff806b2031f407db64c4d3edcda8fb9f9f5/tensorflow/lite/kernels/svdf.cc#L99-L102):
```cc
const int rank = params->rank;
...
TF_LITE_ENSURE_EQ(context, num_filters % rank, 0);
```
An attacker can craft a model such that `params->rank` would be 0.
### Patches
We have patched the issue in GitHub commit [6841e522a3e7d48706a02e8819836e809f738682](https://github.com/tensorflow/tensorflow/commit/6841e522a3e7d48706a02e8819836e809f738682).
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-29598'} | 2022-03-03T05:13:07.745732Z | 2021-05-21T14:27:58Z | LOW | null | {'CWE-369'} | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-pmpr-55fj-r229', 'https://github.com/tensorflow/tensorflow/commit/6841e522a3e7d48706a02e8819836e809f738682', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29598'} | null | {'https://github.com/tensorflow/tensorflow/commit/6841e522a3e7d48706a02e8819836e809f738682'} | {'https://github.com/tensorflow/tensorflow/commit/6841e522a3e7d48706a02e8819836e809f738682'} |
PyPI | PYSEC-2021-463 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a heap buffer overflow in `QuantizedMul` by passing in invalid thresholds for the quantization. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/87cf4d3ea9949051e50ca3f071fc909538a51cd0/tensorflow/core/kernels/quantized_mul_op.cc#L287-L290) assumes that the 4 arguments are always valid scalars and tries to access the numeric value directly. However, if any of these tensors is empty, then `.flat<T>()` is an empty buffer and accessing the element at position 0 results in 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. | {'CVE-2021-29535', 'GHSA-m3f9-w3p3-p669'} | 2021-12-09T06:34:48.800365Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-m3f9-w3p3-p669', 'https://github.com/tensorflow/tensorflow/commit/efea03b38fb8d3b81762237dc85e579cc5fc6e87'} | null | {'https://github.com/tensorflow/tensorflow/commit/efea03b38fb8d3b81762237dc85e579cc5fc6e87'} | {'https://github.com/tensorflow/tensorflow/commit/efea03b38fb8d3b81762237dc85e579cc5fc6e87'} |
PyPI | PYSEC-2021-199 | null | TensorFlow is an end-to-end open source platform for machine learning. An attacker can cause a denial of service by exploiting a `CHECK`-failure coming from the implementation of `tf.raw_ops.IRFFT`. 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-29562', 'GHSA-36vm-xw34-x4pj'} | 2021-08-27T03:22:32.482991Z | 2021-05-14T20:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-36vm-xw34-x4pj', 'https://github.com/tensorflow/tensorflow/commit/1c56f53be0b722ca657cbc7df461ed676c8642a2'} | null | {'https://github.com/tensorflow/tensorflow/commit/1c56f53be0b722ca657cbc7df461ed676c8642a2'} | {'https://github.com/tensorflow/tensorflow/commit/1c56f53be0b722ca657cbc7df461ed676c8642a2'} |
PyPI | PYSEC-2021-414 | null | TensorFlow is an open source platform for machine learning. In affected versions the implementation of `SplitV` can trigger a segfault is an attacker supplies negative arguments. This occurs whenever `size_splits` contains more than one value and at least one value is negative. 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-cpf4-wx82-gxp6', 'CVE-2021-41222'} | 2021-11-13T06:52:45.470098Z | 2021-11-05T23:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-cpf4-wx82-gxp6', 'https://github.com/tensorflow/tensorflow/commit/25d622ffc432acc736b14ca3904177579e733cc6'} | null | {'https://github.com/tensorflow/tensorflow/commit/25d622ffc432acc736b14ca3904177579e733cc6'} | {'https://github.com/tensorflow/tensorflow/commit/25d622ffc432acc736b14ca3904177579e733cc6'} |
PyPI | PYSEC-2022-108 | null | Tensorflow is an Open Source Machine Learning Framework. The implementation of `UnravelIndex` is vulnerable to a division by zero caused by an integer overflow bug. 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-34f9-hjfq-rr8j', 'CVE-2022-21729'} | 2022-03-09T00:18:23.531782Z | 2022-02-03T13:15:00Z | null | null | null | {'https://github.com/tensorflow/tensorflow/security/advisories/GHSA-34f9-hjfq-rr8j', 'https://github.com/tensorflow/tensorflow/blob/5100e359aef5c8021f2e71c7b986420b85ce7b3d/tensorflow/core/kernels/unravel_index_op.cc#L36-L135', 'https://github.com/tensorflow/tensorflow/commit/58b34c6c8250983948b5a781b426f6aa01fd47af'} | null | {'https://github.com/tensorflow/tensorflow/commit/58b34c6c8250983948b5a781b426f6aa01fd47af'} | {'https://github.com/tensorflow/tensorflow/commit/58b34c6c8250983948b5a781b426f6aa01fd47af'} |
PyPI | PYSEC-2022-27 | null | twisted is an event-driven networking engine written in Python. In affected versions twisted exposes cookies and authorization headers when following cross-origin redirects. This issue is present in the `twited.web.RedirectAgent` and `twisted.web. BrowserLikeRedirectAgent` functions. Users are advised to upgrade. There are no known workarounds. | {'GHSA-92x2-jw7w-xvvx', 'CVE-2022-21712'} | 2022-02-15T06:31:29.205025Z | 2022-02-07T22:15:00Z | null | null | null | {'https://github.com/twisted/twisted/releases/tag/twisted-22.1.0', 'https://pypi.org/project/Twisted/', 'https://github.com/twisted/twisted/security/advisories/GHSA-92x2-jw7w-xvvx', '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'} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.