TQRG/raw-osv-data huggingface dataset:
Vulnerability: GHSA-8fxw-76px-3rxv
Summary: Memory leak in Tensorflow
Aliases: CVE-2020-15192
Severity: MODERATE
CWE: CWE-20
Published: 2020-09-25T18:28:17Z

### Impact
If a user passes a list of strings to `dlpack.to_dlpack` there is a memory leak following an expected validation failure:
https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/c/eager/dlpack.cc#L100-L104

The allocated memory is from
https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/c/eager/dlpack.cc#L256

The issue occurs because the `status` argument during validation failures is not properly checked:
https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/c/eager/dlpack.cc#L265-L267

Since each of the above methods can return an error status, the `status` value must be checked before continuing.

### Patches
We have patched the issue in 22e07fb204386768e5bcbea563641ea11f96ceb8 and will release a patch release for all affected versions.

We recommend users to upgrade to TensorFlow 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 discovered during variant analysis of [GHSA-rjjg-hgv6-h69v](https://github.com/tensorflow/tensorflow/security/advisories/GHSA-rjjg-hgv6-h69v).
Vulnerability: PYSEC-2022-158
Aliases: GHSA-fpcp-9h7m-ffpx, CVE-2022-23595
Published: 2022-02-04T23:15:00Z

Tensorflow is an Open Source Machine Learning Framework. When building an XLA compilation cache, if default settings are used, TensorFlow triggers a null pointer dereference. In the default scenario, all devices are allowed, so `flr->config_proto` is `nullptr`. 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.
Vulnerability: PYSEC-2021-444
Aliases: GHSA-84mw-34w6-2q43, CVE-2021-29516
Published: 2021-05-14T20:15:00Z

TensorFlow is an end-to-end open source platform for machine learning. Calling `tf.raw_ops.RaggedTensorToVariant` with arguments specifying an invalid ragged tensor results in a null pointer dereference. The implementation of `RaggedTensorToVariant` operations(https://github.com/tensorflow/tensorflow/blob/904b3926ed1c6c70380d5313d282d248a776baa1/tensorflow/core/kernels/ragged_tensor_to_variant_op.cc#L39-L40) does not validate that the ragged tensor argument is non-empty. Since `batched_ragged` contains no elements, `batched_ragged.splits` is a null vector, thus `batched_ragged.splits(0)` will result in dereferencing `nullptr`. 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.
Vulnerability: PYSEC-2022-77
Aliases: CVE-2022-23568, GHSA-6445-fm66-fvq2
Published: 2022-02-03T12:15:00Z

Tensorflow is an Open Source Machine Learning Framework. The implementation of `AddManySparseToTensorsMap` is vulnerable to an integer overflow which results in a `CHECK`-fail when building new `TensorShape` objects (so, an assert failure based denial of service). We are missing some validation on the shapes of the input tensors as well as directly constructing a large `TensorShape` with user-provided dimensions. 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.
Vulnerability: GHSA-frxx-2m33-6wcr
Summary: Improper Restriction of Operations within the Bounds of a Memory Buffer in Google TensorFlow
Aliases: CVE-2018-8825
Severity: HIGH
CWE: CWE-119
Published: 2019-04-24T16:11:30Z

Google TensorFlow 1.7 and below is affected by: Buffer Overflow. The impact is: execute arbitrary code (local).
Vulnerability: GHSA-2rcm-phc9-3945
Summary: Moderate severity vulnerability that affects pyopenssl
Aliases: CVE-2018-1000808
Severity: MODERATE
CWE: CWE-404
Published: 2018-10-10T16:10:23Z

Python Cryptographic Authority pyopenssl version Before 17.5.0 contains a CWE - 401 : Failure to Release Memory Before Removing Last Reference vulnerability in PKCS #12 Store that can result in Denial of service if memory runs low or is exhausted. This attack appear to be exploitable via Depends upon calling application, however it could be as simple as initiating a TLS connection. Anything that would cause the calling application to reload certificates from a PKCS #12 store.. This vulnerability appears to have been fixed in 17.5.0.
Vulnerability: PYSEC-2019-117
Aliases: CVE-2019-17626
Published: 2019-10-16T12:15:00Z

ReportLab through 3.5.26 allows remote code execution because of toColor(eval(arg)) in colors.py, as demonstrated by a crafted XML document with '<span color="' followed by arbitrary Python code.
Vulnerability: GHSA-f5gc-p5m3-v347
Summary: XXE in petl
Severity: LOW
CWE: CWE-611
Published: 2020-12-02T18:28:30Z

### Impact
Information Disclosure

### Summary

[petl](https://github.com/petl-developers/petl) is a Python library that provides functions for extraction, transformation, and loading (ETL) of data.

petl before 1.68, in some configurations, allows resolution of entities in XML input.

An attacker who is able to submit XML input to an application using petl can disclose arbitrary files on the file system in the context of the user under which the application is running.

### Affected Applications

Applications that:

- accept attacker-supplied XML input that is processed using petl < 1.68
- return the response generated by petl back to the attacker
- configure lxml as the underlying XML processing library used by petl
- have read privileges in filesystem files with sensitive information

### Mitigation
Update to petl >= 1.68

### Workarounds

- Assure there is no user/external access to the application using [petl](https://github.com/petl-developers/petl)
- Assure your application is not using the function [fromxml()](https://petl.readthedocs.io/en/stable/io.html#petl.io.xml.fromxml)

### References
- https://github.com/nvn1729/advisories/blob/master/cve-2020-29128.md
- https://github.com/petl-developers/petl/pull/527
- https://github.com/petl-developers/petl/releases/tag/v1.6.8
- https://petl.readthedocs.io/en/stable/changes.html
- https://owasp.org/www-community/vulnerabilities/XML_External_Entity_(XXE)_Processing

### For more information
If you have any questions or comments about this advisory:
* Add a comment in the Github [issue](https://github.com/petl-developers/petl/pull/527)

Thaks to Naveen Sunkavally.
Vulnerability: PYSEC-2012-2
Aliases: CVE-2012-3442
Published: 2012-07-31T17:55:00Z

The (1) django.http.HttpResponseRedirect and (2) django.http.HttpResponsePermanentRedirect classes in Django before 1.3.2 and 1.4.x before 1.4.1 do not validate the scheme of a redirect target, which might allow remote attackers to conduct cross-site scripting (XSS) attacks via a data: URL.
Vulnerability: GHSA-634c-v2xv-ffpg
Summary: Out-of-bounds Write in OpenCV
Aliases: CVE-2017-14136
Severity: MODERATE
CWE: CWE-787
Published: 2021-10-12T22:02:51Z

OpenCV (Open Source Computer Vision Library) 3.3 (corresponding to OpenCV-Python 3.3.0.9) has an out-of-bounds write error in the function FillColorRow1 in utils.cpp when reading an image file by using cv::imread. NOTE: this vulnerability exists because of an incomplete fix for CVE-2017-12597.
Vulnerability: PYSEC-2008-5
Aliases: CVE-2008-3328
Published: 2008-07-27T22:41:00Z

Cross-site scripting (XSS) vulnerability in the wiki engine in Trac before 0.10.5 allows remote attackers to inject arbitrary web script or HTML via unknown vectors.
Vulnerability: PYSEC-2020-151
Aliases: GHSA-f97h-2pfx-f59f, CVE-2020-7695, SNYK-PYTHON-UVICORN-570471
Published: 2020-07-27T12:15:00Z

Uvicorn before 0.11.7 is vulnerable to HTTP response splitting. CRLF sequences are not escaped in the value of HTTP headers. Attackers can exploit this to add arbitrary headers to HTTP responses, or even return an arbitrary response body, whenever crafted input is used to construct HTTP headers.
Vulnerability: PYSEC-2018-23
Aliases: CVE-2018-1000807, GHSA-p28m-34f6-967q
Published: 2018-10-08T15:29:00Z

Python Cryptographic Authority pyopenssl version prior to version 17.5.0 contains a CWE-416: Use After Free vulnerability in X509 object handling that can result in Use after free can lead to possible denial of service or remote code execution.. This attack appear to be exploitable via Depends on the calling application and if it retains a reference to the memory.. This vulnerability appears to have been fixed in 17.5.0.
Vulnerability: PYSEC-2022-98
Aliases: CVE-2022-23589, GHSA-9px9-73fg-3fqp
Published: 2022-02-04T23:15:00Z

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.
Vulnerability: PYSEC-2021-151
Aliases: CVE-2021-29514, GHSA-8h46-5m9h-7553
Published: 2021-05-14T20:15:00Z

TensorFlow is an end-to-end open source platform for machine learning. If the `splits` argument of `RaggedBincount` does not specify a valid `SparseTensor`(https://www.tensorflow.org/api_docs/python/tf/sparse/SparseTensor), then an attacker can trigger a heap buffer overflow. This will cause a read from outside the bounds of the `splits` tensor buffer in the implementation of the `RaggedBincount` op(https://github.com/tensorflow/tensorflow/blob/8b677d79167799f71c42fd3fa074476e0295413a/tensorflow/core/kernels/bincount_op.cc#L430-L446). Before the `for` loop, `batch_idx` is set to 0. The attacker sets `splits(0)` to be 7, hence the `while` loop does not execute and `batch_idx` remains 0. This then results in writing to `out(-1, bin)`, which is before the heap allocated buffer for the output tensor. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2 and TensorFlow 2.3.3, as these are also affected.
Vulnerability: PYSEC-2021-501
Aliases: GHSA-9vpm-rcf4-9wqw, CVE-2021-29573
Published: 2021-05-14T20:15:00Z

TensorFlow is an end-to-end open source platform for machine learning. The implementation of `tf.raw_ops.MaxPoolGradWithArgmax` is vulnerable to a division by 0. The implementation(https://github.com/tensorflow/tensorflow/blob/279bab6efa22752a2827621b7edb56a730233bd8/tensorflow/core/kernels/maxpooling_op.cc#L1033-L1034) fails to validate that the batch dimension of the tensor is non-zero, before dividing by this quantity. 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.
Vulnerability: GHSA-cjvr-mfj7-j4j8
Summary: Incorrect Authorization and Exposure of Sensitive Information to an Unauthorized Actor in scrapy
Aliases: CVE-2022-0577
Severity: MODERATE
CWE: CWE-863, CWE-200
Published: 2022-03-01T22:12:47Z

### Impact

If you manually define cookies on a [`Request`](https://docs.scrapy.org/en/latest/topics/request-response.html#scrapy.http.Request) object, and that `Request` object gets a redirect response, the new `Request` object scheduled to follow the redirect keeps those user-defined cookies, regardless of the target domain.

### Patches

Upgrade to Scrapy 2.6.0, which resets cookies when creating `Request` objects to follow redirects¹, and drops the ``Cookie`` header if manually-defined if the redirect target URL domain name does not match the source URL domain name².

If you are using Scrapy 1.8 or a lower version, and upgrading to Scrapy 2.6.0 is not an option, you may upgrade to Scrapy 1.8.2 instead.

¹ At that point the original, user-set cookies have been processed by the cookie middleware into the global or request-specific cookiejar, with their domain restricted to the domain of the original URL, so when the cookie middleware processes the new (redirect) request it will incorporate those cookies into the new request as long as the domain of the new request matches the domain of the original request.

² This prevents cookie leaks to unintended domains even if the cookies middleware is not used.

### Workarounds

If you cannot upgrade, set your cookies using a list of dictionaries instead of a single dictionary, as described in the [`Request` documentation](https://docs.scrapy.org/en/latest/topics/request-response.html#scrapy.http.Request), and set the right domain for each cookie.

Alternatively, you can [disable cookies altogether](https://docs.scrapy.org/en/latest/topics/downloader-middleware.html#std-setting-COOKIES_ENABLED), or [limit target domains](https://docs.scrapy.org/en/latest/topics/spiders.html#scrapy.spiders.Spider.allowed_domains) to domains that you trust with all your user-set cookies.

### References
* Originally reported at [huntr.dev](https://huntr.dev/bounties/3da527b1-2348-4f69-9e88-2e11a96ac585/)

### For more information

If you have any questions or comments about this advisory:
* [Open an issue](https://github.com/scrapy/scrapy/issues)
* [Email us](mailto:opensource@zyte.com)
Vulnerability: GHSA-92vm-mxjf-jqf3
Summary: Improper Verification of Cryptographic Signature in starkbank-ecdsa
Aliases: CVE-2021-43572
Severity: CRITICAL
CWE: CWE-347
Published: 2021-11-10T20:41:39Z

The `verify` function in the Stark Bank Python ECDSA library (starkbank-ecdsa) 2.0.0 fails to check that the signature is non-zero, which allows attackers to forge signatures on arbitrary messages.
Vulnerability: GHSA-pwqf-9h7j-7mv8
Summary: Incorrect threshold signature computation in TUF
Aliases: CVE-2020-6174
Severity: CRITICAL
CWE: CWE-347
Published: 2020-08-21T16:25:26Z

### Impact
Metadadata signature verification, as used in `tuf.client.updater`, counted each of multiple signatures with identical authorized keyids  separately towards the threshold. Therefore, an attacker with access to a valid signing key could create multiple valid signatures in order to meet the minimum threshold of keys before the metadata was considered valid.

The tuf maintainers would like to thank Erik MacLean of Analog Devices, Inc. for reporting this issue.

### Patches
A [fix](https://github.com/theupdateframework/tuf/pull/974) is available in version [0.12.2](https://github.com/theupdateframework/tuf/releases/tag/v0.12.2) or newer.

### Workarounds
No workarounds are known for this issue.

### References
* [CVE-2020-6174](https://nvd.nist.gov/vuln/detail/CVE-2020-6174)
* Pull request resolving the issue [PR 974](https://github.com/theupdateframework/tuf/pull/974)
Vulnerability: PYSEC-2021-385
Aliases: CVE-2021-39182, GHSA-35m5-8cvj-8783
Published: 2021-11-08T15:15:00Z

EnroCrypt is a Python module for encryption and hashing. Prior to version 1.1.4, EnroCrypt used the MD5 hashing algorithm in the hashing file. Beginners who are unfamiliar with hashes can face problems as MD5 is considered an insecure hashing algorithm. The vulnerability is patched in v1.1.4 of the product. As a workaround, users can remove the `MD5` hashing function from the file `hashing.py`.
Vulnerability: PYSEC-2021-30
Aliases: CVE-2021-32561
Published: 2021-05-11T14:15:00Z

OctoPrint before 1.6.0 allows XSS because API error messages include the values of input parameters.
Vulnerability: GHSA-gwcx-jrx4-92w2
Summary: Segfault in `simplifyBroadcast` in Tensorflow
Aliases: CVE-2022-23593
Severity: HIGH
CWE: CWE-754
Published: 2022-02-09T23:32:08Z

### Impact
The [`simplifyBroadcast` function in the MLIR-TFRT infrastructure in TensorFlow](https://github.com/tensorflow/tensorflow/blob/274df9b02330b790aa8de1cee164b70f72b9b244/tensorflow/compiler/mlir/tfrt/jit/transforms/tf_cpurt_symbolic_shape_optimization.cc#L149-L205) is vulnerable to a segfault (hence, denial of service), if called with scalar shapes.

```cc 
  size_t maxRank = 0;
  for (auto shape : llvm::enumerate(shapes)) {
    auto found_shape = analysis.dimensionsForShapeTensor(shape.value());
    if (!found_shape) return {};
    shapes_found.push_back(*found_shape);
    maxRank = std::max(maxRank, found_shape->size());
  }   

  SmallVector<const ShapeComponentAnalysis::SymbolicDimension*>
      joined_dimensions(maxRank);
```

If all shapes are scalar, then `maxRank` is 0, so we build an empty `SmallVector`.

### Patches
We have patched the issue in GitHub commit [35f0fabb4c178253a964d7aabdbb15c6a398b69a](https://github.com/tensorflow/tensorflow/commit/35f0fabb4c178253a964d7aabdbb15c6a398b69a).

The fix will be included in TensorFlow 2.8.0. This is the only affected version.

### For more information
Please consult [our security guide](https://github.com/tensorflow/tensorflow/blob/master/SECURITY.md) for more information regarding the security model and how to contact us with issues and questions.
Vulnerability: PYSEC-2017-47
Aliases: CVE-2015-5607
Published: 2017-09-20T16:29:00Z

Cross-site request forgery in the REST API in IPython 2 and 3.
Vulnerability: GHSA-jcxv-2j3h-mg59
Summary: Improper Restriction of Operations within the Bounds of a Memory Buffer in OpenCV
Aliases: CVE-2017-17760
Severity: MODERATE
CWE: CWE-119
Published: 2021-10-12T22:03:09Z

OpenCV 3.3.1 (corresponding with opencv-python and opencv-contrib-python 3.3.1.11) has a Buffer Overflow in the cv::PxMDecoder::readData function in grfmt_pxm.cpp, because an incorrect size value is used.
Vulnerability: GHSA-6w9p-88qg-p3g3
Summary: Cross-site Scripting in CKAN
Aliases: CVE-2021-25967
Severity: MODERATE
CWE: CWE-79
Published: 2021-12-03T20:44:48Z

In CKAN, versions 2.9.0 to 2.9.3 are affected by a stored XSS vulnerability via SVG file upload of users’ profile picture. This allows low privileged application users to store malicious scripts in their profile picture. These scripts are executed in a victim’s browser when they open the malicious profile picture
Vulnerability: PYSEC-2021-690
Aliases: CVE-2021-29564, GHSA-75f6-78jr-4656
Published: 2021-05-14T20:15:00Z

TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a null pointer dereference in the implementation of `tf.raw_ops.EditDistance`. This is because the implementation(https://github.com/tensorflow/tensorflow/blob/79865b542f9ffdc9caeb255631f7c56f1d4b6517/tensorflow/core/kernels/edit_distance_op.cc#L103-L159) has incomplete validation of the input parameters. 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.
Vulnerability: GHSA-rcx2-m7jp-p9wj
Summary: Moderate severity vulnerability that affects notebook
Aliases: CVE-2019-10856
Severity: MODERATE
CWE: CWE-601
Published: 2019-04-09T19:47:27Z

In Jupyter Notebook before 5.7.8, an open redirect can occur via an empty netloc. This issue exists because of an incomplete fix for CVE-2019-10255.
Vulnerability: PYSEC-2016-5
Aliases: CVE-2016-0740, GHSA-hggx-3h72-49ww
Published: 2016-04-13T16:59:00Z

Buffer overflow in the ImagingLibTiffDecode function in libImaging/TiffDecode.c in Pillow before 3.1.1 allows remote attackers to overwrite memory via a crafted TIFF file.
Vulnerability: PYSEC-2019-140
Aliases: CVE-2019-14806, GHSA-gq9m-qvpx-68hc
Published: 2019-08-09T15:15:00Z

Pallets Werkzeug before 0.15.3, when used with Docker, has insufficient debugger PIN randomness because Docker containers share the same machine id.
Vulnerability: PYSEC-2022-20
Aliases: GHSA-6cw3-g6wv-c2xv, CVE-2022-23833
Published: 2022-02-03T02:15:00Z

An issue was discovered in MultiPartParser in Django 2.2 before 2.2.27, 3.2 before 3.2.12, and 4.0 before 4.0.2. Passing certain inputs to multipart forms could result in an infinite loop when parsing files.
Vulnerability: GHSA-qc53-44cj-vfvx
Summary: Denial of Service in Tensorflow
Aliases: CVE-2020-15197
Severity: MODERATE
CWE: CWE-20, CWE-617
Published: 2020-09-25T18:28:30Z

### Impact
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 rank 2. This tensor must be a matrix because code assumes its elements are accessed as elements of a matrix:
https://github.com/tensorflow/tensorflow/blob/0e68f4d3295eb0281a517c3662f6698992b7b2cf/tensorflow/core/kernels/count_ops.cc#L185

However, malicious users can pass in tensors of different rank, resulting in a `CHECK` assertion failure and a crash. This can be used to cause denial of service in serving installations, if users are allowed to control the components of the input sparse tensor.

### Patches
We have patched the issue in 3cbb917b4714766030b28eba9fb41bb97ce9ee02 and will release a patch release.

We recommend users to upgrade to TensorFlow 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 is a variant of [GHSA-p5f8-gfw5-33w4](https://github.com/tensorflow/tensorflow/security/advisories/GHSA-p5f8-gfw5-33w4)
Vulnerability: PYSEC-2021-413
Aliases: CVE-2021-41221, GHSA-cqv6-3phm-hcwx
Published: 2021-11-05T23:15:00Z

TensorFlow is an open source platform for machine learning. In affected versions the shape inference code for the `Cudnn*` operations in TensorFlow can be tricked into accessing invalid memory, via a heap buffer overflow. This occurs because the ranks of the `input`, `input_h` and `input_c` parameters are not validated, but code assumes they have certain values. The fix will be included in TensorFlow 2.7.0. We will also cherrypick this commit on TensorFlow 2.6.1, TensorFlow 2.5.2, and TensorFlow 2.4.4, as these are also affected and still in supported range.
Vulnerability: GHSA-xf8c-3cgx-fcwm
Summary: Improper Access Control in novajoin
Aliases: CVE-2019-10138
Severity: HIGH
CWE: CWE-284
Published: 2020-03-12T16:54:06Z

A flaw was discovered in the python-novajoin plugin, all versions up to, excluding 1.1.1, for Red Hat OpenStack Platform. The novajoin API lacked sufficient access control, allowing any keystone authenticated user to generate FreeIPA tokens.
Vulnerability: GHSA-6cw3-g6wv-c2xv
Summary: Infinite Loop in Django
Aliases: CVE-2022-23833
Severity: HIGH
CWE: CWE-835
Published: 2022-02-04T00:00:26Z

An issue was discovered in MultiPartParser in Django 2.2 before 2.2.27, 3.2 before 3.2.12, and 4.0 before 4.0.2. Passing certain inputs to multipart forms could result in an infinite loop when parsing files.
Vulnerability: PYSEC-2014-57
Aliases: CVE-2013-4193
Published: 2014-03-11T19:37:00Z

typeswidget.py in Plone 2.1 through 4.1, 4.2.x through 4.2.5, and 4.3.x through 4.3.1 does not properly enforce the immutable setting on unspecified content edit forms, which allows remote attackers to hide fields on the forms via a crafted URL.
Vulnerability: PYSEC-2005-1
Aliases: CVE-2005-4644
Published: 2005-12-31T05:00:00Z

Cross-site scripting (XSS) vulnerability in the HTML WikiProcessor in Edgewall Trac 0.9.2 allows remote attackers to inject arbitrary web script or HTML via javascript in the SRC attribute of an IMG tag.
Vulnerability: PYSEC-2021-556
Aliases: CVE-2021-37643, GHSA-fcwc-p4fc-c5cc
Published: 2021-08-12T19:15:00Z

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.
Vulnerability: PYSEC-2021-106
Aliases: GHSA-wv5p-gmmv-wh9v, CVE-2021-20178
Published: 2021-05-26T12:15:00Z

A flaw was found in ansible module where credentials are disclosed in the console log by default and not protected by the security feature when using the bitbucket_pipeline_variable module. This flaw allows an attacker to steal bitbucket_pipeline credentials. The highest threat from this vulnerability is to confidentiality.
Vulnerability: PYSEC-2018-74
Aliases: GHSA-vxp9-wv2f-wqmw, CVE-2018-8021
Published: 2018-11-07T14:29:00Z

Versions of Superset prior to 0.23 used an unsafe load method from the pickle library to deserialize data leading to possible remote code execution. Note Superset 0.23 was released prior to any Superset release under the Apache Software Foundation.
Vulnerability: PYSEC-2020-106
Aliases: CVE-2020-25592
Published: 2020-11-06T08:15:00Z

In SaltStack Salt through 3002, salt-netapi improperly validates eauth credentials and tokens. A user can bypass authentication and invoke Salt SSH.
Vulnerability: PYSEC-2021-805
Aliases: GHSA-prcg-wp5q-rv7p, CVE-2021-41197
Published: 2021-11-05T20:15:00Z

TensorFlow is an open source platform for machine learning. In affected versions TensorFlow allows tensor to have a large number of dimensions and each dimension can be as large as desired. However, the total number of elements in a tensor must fit within an `int64_t`. If an overflow occurs, `MultiplyWithoutOverflow` would return a negative result. In the majority of TensorFlow codebase this then results in a `CHECK`-failure. Newer constructs exist which return a `Status` instead of crashing the binary. This is similar to CVE-2021-29584. 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.
Vulnerability: PYSEC-2010-14
Aliases: CVE-2010-0667
Published: 2010-02-26T19:30:00Z

MoinMoin 1.9 before 1.9.1 does not perform the expected clearing of the sys.argv array in situations where the GATEWAY_INTERFACE environment variable is set, which allows remote attackers to obtain sensitive information via unspecified vectors.
Vulnerability: PYSEC-2019-141
Aliases: CVE-2018-16876
Published: 2019-01-03T15:29:00Z

ansible before versions 2.5.14, 2.6.11, 2.7.5 is vulnerable to a information disclosure flaw in vvv+ mode with no_log on that can lead to leakage of sensible data.
Vulnerability: PYSEC-2016-4
Aliases: CVE-2016-6298
Published: 2016-09-01T23:59:00Z

The _Rsa15 class in the RSA 1.5 algorithm implementation in jwa.py in jwcrypto before 0.3.2 lacks the Random Filling protection mechanism, which makes it easier for remote attackers to obtain cleartext data via a Million Message Attack (MMA).
Vulnerability: PYSEC-2022-21
Aliases: CVE-2022-23599, GHSA-g4c2-ghfg-g5rh
Published: 2022-01-28T22:15:00Z

Products.ATContentTypes are the core content types for Plone 2.1 - 4.3. Versions of Plone that are dependent on Products.ATContentTypes prior to version 3.0.6 are vulnerable to reflected cross site scripting and open redirect when an attacker can get a compromised version of the image_view_fullscreen page in a cache, for example in Varnish. The technique is known as cache poisoning. Any later visitor can get redirected when clicking on a link on this page. Usually only anonymous users are affected, but this depends on the user's cache settings. Version 3.0.6 of Products.ATContentTypes has been released with a fix. This version works on Plone 5.2, Python 2 only. As a workaround, make sure the image_view_fullscreen page is not stored in the cache. More information about the vulnerability and cvmitigation measures is available in the GitHub Security Advisory.
Vulnerability: PYSEC-2021-412
Aliases: GHSA-gpfh-jvf9-7wg5, CVE-2021-41220
Published: 2021-11-05T23:15:00Z

TensorFlow is an open source platform for machine learning. In affected versions the async implementation of `CollectiveReduceV2` suffers from a memory leak and a use after free. This occurs due to the asynchronous computation and the fact that objects that have been `std::move()`d from are still accessed. 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.
Vulnerability: GHSA-7xc5-ggpp-g249
Summary: Server-Side Template Injection in pwntools
Aliases: CVE-2020-28468
Severity: CRITICAL
CWE: CWE-74
Published: 2021-04-20T16:13:24Z

This affects the package pwntools before 4.3.1. The shellcraft generator for affected versions of this module are vulnerable to Server-Side Template Injection (SSTI), which can lead to remote code execution.
Vulnerability: GHSA-3wvg-mj6g-m9cv
Summary: Uncontrolled Resource Consumption
Aliases: CVE-2021-27922
Severity: HIGH
CWE: CWE-400
Published: 2021-03-18T19:55:21Z

Pillow before 8.1.1 allows attackers to cause a denial of service (memory consumption) because the reported size of a contained image is not properly checked for an ICNS container, and thus an attempted memory allocation can be very large.
Vulnerability: GHSA-pqrv-8r2f-7278
Summary: Crash due to erroneous `StatusOr` in TensorFlow
Aliases: CVE-2022-23590
Severity: MODERATE
CWE: CWE-754
Published: 2022-02-09T23:29:38Z

### Impact
A `GraphDef` from a TensorFlow `SavedModel` can be maliciously altered to cause a TensorFlow process to crash due to encountering [a `StatusOr` value that is an error and forcibly extracting the value from it](https://github.com/tensorflow/tensorflow/blob/274df9b02330b790aa8de1cee164b70f72b9b244/tensorflow/core/graph/graph.cc#L560-L567):

```cc
  if (op_reg_data->type_ctor != nullptr) {
    VLOG(3) << "AddNode: found type constructor for " << node_def.name();
    const auto ctor_type =
        full_type::SpecializeType(AttrSlice(node_def), op_reg_data->op_def);
    const FullTypeDef ctor_typedef = ctor_type.ValueOrDie();
    if (ctor_typedef.type_id() != TFT_UNSET) {
      *(node_def.mutable_experimental_type()) = ctor_typedef;
    }
  }
```   
      
If `ctor_type` is an error status, `ValueOrDie` results in a crash.
        
### Patches
We have patched the issue in GitHub commit [955059813cc325dc1db5e2daa6221271406d4439](https://github.com/tensorflow/tensorflow/commit/955059813cc325dc1db5e2daa6221271406d4439).
  
We have patched the issue in multiple GitHub commits and these will be included in TensorFlow 2.8.0 and TensorFlow 2.7.1, as both are affected.

### 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.
Vulnerability: PYSEC-2014-56
Aliases: CVE-2013-4192
Published: 2014-03-11T19:37:00Z

sendto.py in Plone 2.1 through 4.1, 4.2.x through 4.2.5, and 4.3.x through 4.3.1 allows remote authenticated users to spoof emails via unspecified vectors.
Vulnerability: PYSEC-2021-557
Aliases: GHSA-27j5-4p9v-pp67, CVE-2021-37644
Published: 2021-08-12T21:15:00Z

TensorFlow is an end-to-end open source platform for machine learning. In affected versions providing a negative element to `num_elements` list argument of `tf.raw_ops.TensorListReserve` causes the runtime to abort the process due to reallocating a `std::vector` to have a negative number of elements. The [implementation](https://github.com/tensorflow/tensorflow/blob/8d72537c6abf5a44103b57b9c2e22c14f5f49698/tensorflow/core/kernels/list_kernels.cc#L312) calls `std::vector.resize()` with the new size controlled by input given by the user, without checking that this input is valid. We have patched the issue in GitHub commit 8a6e874437670045e6c7dc6154c7412b4a2135e2. 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.
Vulnerability: GHSA-jrh2-hc4r-7jwx
Summary: Directory-traversal in Django
Aliases: CVE-2021-45452
Severity: MODERATE
CWE: CWE-22
Published: 2022-01-12T19:21:04Z

Storage.save in Django 2.2 before 2.2.26, 3.2 before 3.2.11, and 4.0 before 4.0.1 allows directory traversal if crafted filenames are directly passed to it.
Vulnerability: PYSEC-2021-107
Aliases: CVE-2021-3447
Published: 2021-04-01T18:15:00Z

A flaw was found in several ansible modules, where parameters containing credentials, such as secrets, were being logged in plain-text on managed nodes, as well as being made visible on the controller node when run in verbose mode. These parameters were not protected by the no_log feature. An attacker can take advantage of this information to steal those credentials, provided when they have access to the log files containing them. The highest threat from this vulnerability is to data confidentiality. This flaw affects Red Hat Ansible Automation Platform in versions before 1.2.2 and Ansible Tower in versions before 3.8.2.
Vulnerability: PYSEC-2018-75
Aliases: CVE-2018-1000167
Published: 2018-04-18T19:29:00Z

OISF suricata-update version 1.0.0a1 contains an Insecure Deserialization vulnerability in the insecure yaml.load-Function as used in the following files: config.py:136, config.py:142, sources.py:99 and sources.py:131. The "list-sources"-command is affected by this bug. that can result in Remote Code Execution(even as root if suricata-update is called by root). This attack appears to be exploitable via a specially crafted yaml-file at https://www.openinfosecfoundation.org/rules/index.yaml. This vulnerability appears to have been fixed in 1.0.0b1.
Vulnerability: GHSA-4365-fhm5-qcrx
Summary: Maliciously Crafted Model Archive Can Lead To Arbitrary File Write
Aliases: CVE-2021-41127
Severity: HIGH
CWE: CWE-23, CWE-22
Published: 2021-10-22T16:19:13Z

### Impact
An Archive Extraction (Zip Slip) vulnerability in the functionality that allows a user to load a trained model archive in Rasa 2.8.9 and older allows an attacker arbitrary write capability within specific directories using a malicious crafted archive file.

### Patches
The vulnerability is fixed in Rasa 2.8.10

### Workarounds
Mitigating steps for vulnerable end users are to ensure that they do not upload untrusted model files, and restrict CLI or API endpoint access where a malicious actor could target a deployed Rasa instance.

### For more information
If you have any questions or comments about this advisory:
* Email [the Rasa Security Team](mailto:security@rasa.com)
Vulnerability: PYSEC-2020-107
Aliases: CVE-2020-13092
Published: 2020-05-15T19:15:00Z

** DISPUTED ** scikit-learn (aka sklearn) through 0.23.0 can unserialize and execute commands from an untrusted file that is passed to the joblib.load() function, if __reduce__ makes an os.system call. NOTE: third parties dispute this issue because the joblib.load() function is documented as unsafe and it is the user's responsibility to use the function in a secure manner.
Vulnerability: PYSEC-2010-15
Aliases: CVE-2010-0668
Published: 2010-02-26T19:30:00Z

Unspecified vulnerability in MoinMoin 1.5.x through 1.7.x, 1.8.x before 1.8.7, and 1.9.x before 1.9.2 has unknown impact and attack vectors, related to configurations that have a non-empty superuser list, the xmlrpc action enabled, the SyncPages action enabled, or OpenID configured.
Vulnerability: GHSA-624f-cqvr-3qw4
Summary: URL Redirection to Untrusted Site ('Open Redirect') in Flask-AppBuilder
Aliases: CVE-2021-32805
Severity: HIGH
CWE: CWE-601
Published: 2021-09-08T21:11:14Z

### Impact
If using Flask-AppBuilder OAuth, an attacker can share a carefully crafted URL with a trusted domain for an application built with Flask-AppBuilder, this URL can redirect a user to a malicious site. This is an open redirect vulnerability 

### Patches
Install Flask-AppBuilder 3.2.2 or above

### Workarounds
Filter HTTP traffic containing `?next={next-site}` where the `next-site` domain is different from the application you are protecting
Vulnerability: PYSEC-2021-804
Aliases: GHSA-m539-j985-hcr8, CVE-2021-41196
Published: 2021-11-05T20:15:00Z

TensorFlow is an open source platform for machine learning. In affected versions the Keras pooling layers can trigger a segfault if the size of the pool is 0 or if a dimension is negative. This is due to the TensorFlow's implementation of pooling operations where the values in the sliding window are not checked to be strictly positive. 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.
Vulnerability: PYSEC-2021-31
Aliases: CVE-2021-21376, GHSA-gfp2-w5jm-955q
Published: 2021-03-23T16:15:00Z

OMERO.web is open source Django-based software for managing microscopy imaging. OMERO.web before version 5.9.0 loads various information about the current user such as their id, name and the groups they are in, and these are available on the main webclient pages. This represents an information exposure vulnerability. Some additional information being loaded is not used by the webclient and is being removed in this release. This is fixed in version 5.9.0.
Vulnerability: PYSEC-2021-384
Aliases: CVE-2021-41194, GHSA-5xvc-vgmp-jgc3
Published: 2021-10-28T20:15:00Z

FirstUseAuthenticator is a JupyterHub authenticator that helps new users set their password on their first login to JupyterHub. When JupyterHub is used with FirstUseAuthenticator, a vulnerability in versions prior to 1.0.0 allows unauthorized access to any user's account if `create_users=True` and the username is known or guessed. One may upgrade to version 1.0.0 or apply a patch manually to mitigate the vulnerability. For those who cannot upgrade, there is no complete workaround, but a partial mitigation exists. One can disable user creation with `c.FirstUseAuthenticator.create_users = False`, which will only allow login with fully normalized usernames for already existing users prior to jupyterhub-firstuserauthenticator 1.0.0. If any users have never logged in with their normalized username (i.e. lowercase), they will still be vulnerable until a patch or upgrade occurs.
Vulnerability: GHSA-3qpr-7rmg-73v8
Summary: Moderate severity vulnerability that affects Plone and Zope2
Aliases: CVE-2012-5507
Severity: MODERATE
CWE: CWE-362
Published: 2018-07-23T19:51:02Z

AccessControl/AuthEncoding.py in Zope before 2.13.19, as used in Plone before 4.2.3 and 4.3 before beta 1, allows remote attackers to obtain passwords via vectors involving timing discrepancies in password validation.
Vulnerability: GHSA-hwfp-hg2m-9vr2
Summary: Integer overflow in pywin32
Aliases: CVE-2021-32559
Severity: MODERATE
CWE: CWE-190
Published: 2021-08-09T20:43:44Z

An integer overflow exists in pywin32 prior to version b301 when adding an access control entry (ACE) to an access control list (ACL) that would cause the size to be greater than 65535 bytes. An attacker who successfully exploited this vulnerability could crash the vulnerable process.
Vulnerability: PYSEC-2017-46
Aliases: CVE-2015-4707
Published: 2017-09-20T18:29:00Z

Cross-site scripting (XSS) vulnerability in IPython before 3.2 allows remote attackers to inject arbitrary web script or HTML via vectors involving JSON error messages and the /api/notebooks path.
Vulnerability: GHSA-5vq5-pg3r-9ph3
Summary: Path Traversal in Zope
Aliases: CVE-2021-32674
Severity: HIGH
CWE: CWE-12, CWE-22
Published: 2021-06-10T17:22:08Z

Zope is an open-source web application server. This advisory extends the previous advisory at https://github.com/zopefoundation/Zope/security/advisories/GHSA-5pr9-v234-jw36 with additional cases of TAL expression traversal vulnerabilities. Most Python modules are not available for using in TAL expressions that you can add through-the-web, for example in Zope Page Templates. This restriction avoids file system access, for example via the 'os' module. But some of the untrusted modules are available indirectly through Python modules that are available for direct use. By default, you need to have the Manager role to add or edit Zope Page Templates through the web. Only sites that allow untrusted users to add/edit Zope Page Templates through the web are at risk. The problem has been fixed in Zope 5.2.1 and 4.6.1. The workaround is the same as for https://github.com/zopefoundation/Zope/security/advisories/GHSA-5pr9-v234-jw36: A site administrator can restrict adding/editing Zope Page Templates through the web using the standard Zope user/role permission mechanisms. Untrusted users should not be assigned the Zope Manager role and adding/editing Zope Page Templates through the web should be restricted to trusted users only.
Vulnerability: GHSA-7wgr-7666-7pwj
Summary: Path Traversal in openapi-python-client
Aliases: CVE-2020-15141
Severity: LOW
CWE: CWE-22
Published: 2020-08-20T14:38:13Z

### Impact
Path traversal vulnerability. If a user generated a client using a maliciously crafted OpenAPI document, it is possible for generated files to be placed in arbitrary locations on disk.

Giving this a CVSS score of 3.0 (Low) with CVSS:3.0/AV:N/AC:H/PR:L/UI:R/S:C/C:N/I:L/A:N/E:P/RL:U/RC:C

### Patches
A fix is being worked on for version 0.5.3

### Workarounds
Inspect OpenAPI documents before generating clients for them.

### For more information
If you have any questions or comments about this advisory:
* Open an issue in [openapi-python-client](https://github.com/triaxtec/openapi-python-client/issues)
* Email us at [danthony@triaxtec.com](mailto:danthony@triaxtec.com)
Vulnerability: PYSEC-2021-691
Aliases: GHSA-r6pg-pjwc-j585, CVE-2021-29565
Published: 2021-05-14T20:15:00Z

TensorFlow is an end-to-end open source platform for machine learning. An attacker can trigger a null pointer dereference in the implementation of `tf.raw_ops.SparseFillEmptyRows`. This is because of missing validation(https://github.com/tensorflow/tensorflow/blob/fdc82089d206e281c628a93771336bf87863d5e8/tensorflow/core/kernels/sparse_fill_empty_rows_op.cc#L230-L231) that was covered under a `TODO`. If the `dense_shape` tensor is empty, then `dense_shape_t.vec<>()` would cause a null pointer dereference in the implementation of the op. 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.
Vulnerability: PYSEC-2022-159
Aliases: CVE-2022-0577, GHSA-cjvr-mfj7-j4j8
Published: 2022-03-02T04:15:00Z

Exposure of Sensitive Information to an Unauthorized Actor in GitHub repository scrapy/scrapy prior to 2.6.1.
Vulnerability: PYSEC-2018-116
Aliases: CVE-2018-12104
Published: 2018-06-17T20:29:00Z

Cross-site scripting (XSS) vulnerability in Airbnb Knowledge Repo 0.7.4 allows remote attackers to inject arbitrary web scripts or HTML via the post comments functionality, as demonstrated by the post/posts/new_report.kp URI.
Vulnerability: PYSEC-2021-445
Aliases: GHSA-772p-x54p-hjrv, CVE-2021-29517
Published: 2021-05-14T20:15:00Z

TensorFlow is an end-to-end open source platform for machine learning. A malicious user could trigger a division by 0 in `Conv3D` implementation. The implementation(https://github.com/tensorflow/tensorflow/blob/42033603003965bffac51ae171b51801565e002d/tensorflow/core/kernels/conv_ops_3d.cc#L143-L145) does a modulo operation based on user controlled input. Thus, when `filter` has a 0 as the fifth element, this results in a division by 0. Additionally, if the shape of the two tensors is not valid, an Eigen assertion can be triggered, resulting in a program crash. The fix will be included in TensorFlow 2.5.0. We will also cherrypick this commit on TensorFlow 2.4.2, TensorFlow 2.3.3, TensorFlow 2.2.3 and TensorFlow 2.1.4, as these are also affected and still in supported range.
Vulnerability: GHSA-jr9p-r423-9m2r
Summary: Vulnerability in markdown2
Aliases: CVE-2021-26813
Severity: HIGH
Published: 2021-06-02T21:44:28Z

markdown2 >=1.0.1.18, fixed in 2.4.0, is affected by a regular expression denial of service vulnerability. If an attacker provides a malicious string, it can make markdown2 processing difficult or delayed for an extended period of time.
Vulnerability: PYSEC-2022-76
Aliases: GHSA-rrx2-r989-2c43, CVE-2022-23567
Published: 2022-02-03T12:15:00Z

Tensorflow is an Open Source Machine Learning Framework. The implementations of `Sparse*Cwise*` ops are vulnerable to integer overflows. These can be used to trigger large allocations (so, OOM based denial of service) or `CHECK`-fails when building new `TensorShape` objects (so, assert failures based denial of service). We are missing some validation on the shapes of the input tensors as well as directly constructing a large `TensorShape` with user-provided dimensions. 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.
Vulnerability: PYSEC-2019-116
Aliases: GHSA-vrcf-g539-x6h3, CVE-2019-17206
Published: 2019-10-05T23:15:00Z

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.
Vulnerability: PYSEC-2012-3
Aliases: CVE-2012-3443
Published: 2012-07-31T17:55:00Z

The django.forms.ImageField class in the form system in Django before 1.3.2 and 1.4.x before 1.4.1 completely decompresses image data during image validation, which allows remote attackers to cause a denial of service (memory consumption) by uploading an image file.
Vulnerability: PYSEC-2008-4
Aliases: CVE-2008-2951
Published: 2008-07-27T22:41:00Z

Open redirect vulnerability in the search script in Trac before 0.10.5 allows remote attackers to redirect users to arbitrary web sites and conduct phishing attacks via a URL in the q parameter, possibly related to the quickjump function.
Vulnerability: PYSEC-2021-853
Aliases: GHSA-q34h-97wf-8r8j, CVE-2021-43837
Published: 2021-12-16T19:15:00Z

vault-cli is a configurable command-line interface tool (and python library) to interact with Hashicorp Vault. In versions before 3.0.0 vault-cli features the ability for rendering templated values. When a secret starts with the prefix `!template!`, vault-cli interprets the rest of the contents of the secret as a Jinja2 template. Jinja2 is a powerful templating engine and is not designed to safely render arbitrary templates. An attacker controlling a jinja2 template rendered on a machine can trigger arbitrary code, making this a Remote Code Execution (RCE) risk. If the content of the vault can be completely trusted, then this is not a problem. Otherwise, if your threat model includes cases where an attacker can manipulate a secret value read from the vault using vault-cli, then this vulnerability may impact you. In 3.0.0, the code related to interpreting vault templated secrets has been removed entirely. Users are advised to upgrade as soon as possible. For users unable to upgrade a workaround does exist. Using the environment variable `VAULT_CLI_RENDER=false` or the flag `--no-render` (placed between `vault-cli` and the subcommand, e.g. `vault-cli --no-render get-all`) or adding `render: false` to the vault-cli configuration yaml file disables rendering and removes the vulnerability. Using the python library, you can use: `vault_cli.get_client(render=False)` when creating your client to get a client that will not render templated secrets and thus operates securely.