ecosystem
stringclasses 14
values | vuln_id
stringlengths 10
19
| summary
stringlengths 4
267
⌀ | details
stringlengths 9
13.5k
| aliases
stringlengths 17
144
⌀ | modified_date
stringdate 2010-05-27 05:47:00
2022-05-10 08:46:52
| published_date
stringdate 2005-12-31 05:00:00
2022-05-10 08:46:50
| severity
stringclasses 5
values | score
float64 0
10
⌀ | cwe_id
stringclasses 988
values | refs
stringlengths 30
17.7k
⌀ | introduced
stringlengths 75
4.26k
⌀ |
|---|---|---|---|---|---|---|---|---|---|---|---|
crates.io
|
GHSA-838h-jqp6-cf2f
|
Sandbox bypass leading to arbitrary code execution in Deno
|
### Impact
The versions of Deno between release 1.18.0 and 1.20.2 (inclusive) are vulnerable to an attack where a malicious actor controlling the code executed in a Deno runtime could bypass permission checks and execute arbitrary shell code.
There is **no** evidence that this vulnerability has been exploited in the wild.
This vulnerability does **not** affect users of Deno Deploy.
### Patches
The vulnerability has been patched in Deno 1.20.3.
### Workarounds
There is no workaround. All users are recommended to upgrade to 1.20.3 immediately
---
The cause of this error was that certain FFI operations did not correctly check for permissions. The issue was fixed in [this](https://github.com/denoland/deno/pull/14115) pull request.
|
{'CVE-2022-24783'}
|
2022-05-02T19:39:05Z
|
2022-03-29T22:10:10Z
|
CRITICAL
| null |
{'CWE-269'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2022-24783', 'https://github.com/denoland/deno/pull/14115', 'https://github.com/denoland/deno/security/advisories/GHSA-838h-jqp6-cf2f', 'https://github.com/denoland/deno', 'https://github.com/denoland/deno/releases/tag/v1.20.3'}
| null |
crates.io
|
RUSTSEC-2018-0008
|
Bug in SliceDeque::move_head_unchecked allows read of corrupted memory
|
Affected versions of this crate did not properly update the
head and tail of the deque when inserting and removing elements from the front
if, before insertion or removal, the tail of the deque was in the mirrored
memory region, and if, after insertion or removal, the head of the deque is
exactly at the beginning of the mirrored memory region.
An attacker that controls both element insertion and removal into the deque
could put it in a corrupted state. Once the deque enters such an state, its head
and tail are corrupted, but in bounds of the allocated memory. This can result
in partial reads and writes, reads of uninitialized memory, reads of memory
containing previously dropped objects, etc. An attacker could exploit this to
alter program execution.
The flaw was corrected by properly updating the head and tail of the deque in
this case.
|
{'CVE-2018-20995'}
|
2021-10-19T22:14:35Z
|
2018-12-05T12:00:00Z
| null | null | null |
{'https://github.com/gnzlbg/slice_deque/issues/57', 'https://rustsec.org/advisories/RUSTSEC-2018-0008.html', 'https://crates.io/crates/slice-deque'}
| null |
crates.io
|
RUSTSEC-2021-0075
|
Flaw in `FieldVar::mul_by_inverse` allows unsound R1CS constraint systems
|
Versions `0.2.0` to `0.3.0` of ark-r1cs-std did not enforce any constraints in the `FieldVar::mul_by_inverse` method, allowing a malicious prover to produce an unsound proof that passes all verifier checks.
This method was used primarily in scalar multiplication for [`short_weierstrass::ProjectiveVar`](https://docs.rs/ark-r1cs-std/0.3.0/ark_r1cs_std/groups/curves/short_weierstrass/struct.ProjectiveVar.html).
This bug was fixed in commit `47ddbaa`, and was released as part of version `0.3.1` on `crates.io`.
|
{'CVE-2021-38194'}
|
2021-11-06T20:37:35Z
|
2021-07-08T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0075.html', 'https://github.com/arkworks-rs/r1cs-std/pull/70', 'https://crates.io/crates/ark-r1cs-std'}
| null |
crates.io
|
GHSA-c9rv-3jmq-527w
|
Unexpected panic when decoding tokens in branca
|
An issue was discovered in the branca crate before 0.10.0 for Rust. Decoding tokens (with invalid base62 data) can panic.
|
{'CVE-2020-35918'}
|
2021-08-19T20:50:27Z
|
2021-08-25T20:49:50Z
|
MODERATE
| null |
{'CWE-20'}
|
{'https://github.com/tuupola/branca-spec/issues/22', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35918', 'https://github.com/return/branca', 'https://github.com/return/branca/issues/24', 'https://rustsec.org/advisories/RUSTSEC-2020-0075.html'}
| null |
crates.io
|
GHSA-h45v-vgvp-3h5v
|
Out-of-bounds write in stack
|
An issue was discovered in the stack crate before 0.3.1 for Rust. ArrayVec has an out-of-bounds write via element insertion.
|
{'CVE-2020-35895'}
|
2021-08-19T20:53:42Z
|
2021-08-25T20:49:13Z
|
CRITICAL
| null |
{'CWE-787'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0042.html', 'https://github.com/arcnmx/stack-rs/issues/4', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35895', 'https://github.com/arcnmx/stack-rs'}
| null |
crates.io
|
GHSA-5xg3-j2j6-rcx4
|
Relative Path Traversal in git-delta
|
git-delta before 0.8.3 on Windows resolves an executable's pathname as a relative path from the current directory.
|
{'CVE-2021-36376'}
|
2021-09-09T16:46:42Z
|
2021-08-25T21:01:39Z
|
HIGH
| null |
{'CWE-427', 'CWE-23'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-36376', 'https://vuln.ryotak.me/advisories/54', 'https://github.com/dandavison/delta/releases/tag/0.8.3', 'https://github.com/dandavison/delta', 'https://github.com/dandavison/delta/commit/f01846bd443aaf92fdd5ac20f461beac3f6ee3fd'}
| null |
crates.io
|
RUSTSEC-2016-0006
|
`cassandra` crate is unmaintained; use `cassandra-cpp` instead
|
The `cassandra` crate has not seen a release since December 2016, and its author
is unresponsive.
The `cassandra-cpp` crate is a maintained fork:
https://github.com/Metaswitch/cassandra-rs
| null |
2020-10-02T01:29:11Z
|
2016-12-15T12:00:00Z
| null | null | null |
{'https://crates.io/crates/cassandra', 'https://rustsec.org/advisories/RUSTSEC-2016-0006.html', 'https://github.com/tupshin/cassandra-rs/issues/52'}
| null |
crates.io
|
GHSA-h352-g5vw-3926
|
Improper Input Validation in fruity
|
An issue was discovered in the fruity crate through 0.2.0 for Rust. Security-relevant validation of filename extensions is plausibly affected. Methods of NSString for conversion to a string may return a partial result. Because they call CStr::from_ptr on a pointer to the string buffer, the string is terminated at the first '\0' byte, which might not be the end of the string.
|
{'CVE-2021-43620'}
|
2021-11-19T13:24:04Z
|
2021-11-16T17:26:47Z
|
HIGH
| null |
{'CWE-20'}
|
{'https://github.com/nvzqz/fruity/issues/14', 'https://rustsec.org/advisories/RUSTSEC-2021-0123.html', 'https://github.com/rustsec/advisory-db/pull/1102', 'https://github.com/nvzqz/fruity', 'https://nvd.nist.gov/vuln/detail/CVE-2021-43620'}
| null |
crates.io
|
RUSTSEC-2021-0022
|
Use-after-free in `subscript_next` and `subscript_prev` wrappers
|
Affected versions of this crate had an unsound implementation which could pass
a pointer to freed memory to `ydb_subscript_next_st` and
`ydb_subscript_prev_st` if the variable and subscripts did not have enough
memory allocated on the first call to hold the next variable in the database.
For example, the following code had undefined behavior:
```rust
let mut key = Key::variable(String::from("a"));
Key::variable("averylongkeywithlotsofletters")
.set_st(YDB_NOTTP, Vec::new(), b"some val")
.unwrap();
key.sub_next_self_st(YDB_NOTTP, Vec::new()).unwrap();
```
`yottadb` has no reverse-dependencies on crates.io and there are no known
instances of this API being used incorrectly in practice. The fix is backwards
compatible.
The flaw was corrected by recalculating the pointer each time it was reallocated.
|
{'CVE-2021-27377'}
|
2021-10-19T22:14:35Z
|
2021-02-09T12:00:00Z
| null | null | null |
{'https://gitlab.com/YottaDB/Lang/YDBRust/-/issues/40', 'https://rustsec.org/advisories/RUSTSEC-2021-0022.html', 'https://crates.io/crates/yottadb'}
| null |
crates.io
|
GHSA-vcw4-8ph6-7vw8
|
Use after free in Rocket
|
An issue was discovered in the rocket crate before 0.4.7 for Rust. uri::Formatter can have a use-after-free if a user-provided function panics.
|
{'CVE-2021-29935'}
|
2021-08-19T17:09:45Z
|
2021-08-25T20:54:20Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://github.com/SergioBenitez/Rocket', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29935', 'https://github.com/SergioBenitez/Rocket/issues/1534', 'https://rustsec.org/advisories/RUSTSEC-2021-0044.html'}
| null |
crates.io
|
RUSTSEC-2019-0014
|
Flaw in interface may drop uninitialized instance of arbitrary types
|
Affected versions of this crate would call `Vec::set_len` on an uninitialized
vector with user-provided type parameter, in an interface of the HDR image
format decoder. They would then also call other code that could panic before
initializing all instances.
This could run Drop implementations on uninitialized types, equivalent to
use-after-free, and allow an attacker arbitrary code execution.
Two different fixes were applied. It is possible to conserve the interface by
ensuring proper initialization before calling `Vec::set_len`. Drop is no longer
called in case of panic, though.
Starting from version `0.22`, a breaking change to the interface requires
callers to pre-allocate the output buffer and pass a mutable slice instead,
avoiding all unsafe code.
|
{'CVE-2019-16138'}
|
2021-10-19T22:14:35Z
|
2019-08-21T12:00:00Z
| null | null | null |
{'https://github.com/image-rs/image/pull/985', 'https://crates.io/crates/image', 'https://rustsec.org/advisories/RUSTSEC-2019-0014.html'}
| null |
crates.io
|
GHSA-4cww-f7w5-x525
|
Stack consumption in trust-dns-server
|
An issue was discovered in the trust-dns-server crate before 0.18.1 for Rust. DNS MX and SRV null targets are mishandled, causing stack consumption.
|
{'CVE-2020-35857'}
|
2021-08-19T21:20:03Z
|
2021-08-25T20:46:13Z
|
HIGH
| null |
{'CWE-400'}
|
{'https://github.com/bluejekyll/trust-dns/issues/980', 'https://github.com/bluejekyll/trust-dns', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35857', 'https://rustsec.org/advisories/RUSTSEC-2020-0001.html'}
| null |
crates.io
|
RUSTSEC-2020-0069
|
Argument injection in sendmail transport
|
Affected versions of lettre allowed argument injection
to the sendmail command. It was possible, using forged `to` addresses,
to pass arbitrary arguments to the sendmail executable.
Depending on the implementation (original sendmail, postfix, exim, etc.)
it could be possible in some cases to write email data into arbitrary files (using sendmail's
logging features).
The flaw is corrected by modifying the executed command to stop parsing arguments
before passing the destination addresses.
NOTE: This vulnerability only affects the `sendmail` transport. Others, including `smtp`, are not
affected.
This vulnerability was reported by vin01.
|
{'CVE-2020-28247'}
|
2021-10-19T22:14:35Z
|
2020-11-11T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0069.html', 'https://crates.io/crates/lettre', 'https://github.com/lettre/lettre/pull/508/commits/bbe7cc5381c5380b54fb8bbb4f77a3725917ff0b'}
| null |
crates.io
|
RUSTSEC-2020-0086
|
crate has been renamed to `sn_client`
|
This crate has been renamed from `safe_core` to `sn_client`.
The new repository location is:
<https://github.com/maidsafe/sn_client>
| null |
2020-12-07T17:22:02Z
|
2020-12-07T12:00:00Z
| null | null | null |
{'https://crates.io/crates/safe_core', 'https://rustsec.org/advisories/RUSTSEC-2020-0086.html', 'https://github.com/maidsafe/sn_client/pull/1267'}
| null |
crates.io
|
GHSA-wqxc-qrq4-w5v4
|
Update unsound DrainFilter and RString::retain
|
An issue was discovered in the abi_stable crate before 0.9.1 for Rust. A retain call can create an invalid UTF-8 string, violating soundness.
|
{'CVE-2020-36213'}
|
2021-07-26T17:18:54Z
|
2021-08-25T21:01:33Z
|
HIGH
| null |
{'CWE-172'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36213', 'https://github.com/rodrimati1992/abi_stable_crates/issues/44', 'https://rustsec.org/advisories/RUSTSEC-2020-0105.html'}
| null |
crates.io
|
GHSA-8gmx-cpcg-f8h5
|
Double-free in id-map
|
An issue was discovered in the id-map crate through 2021-02-26 for Rust. A double free can occur in IdMap::clone_from upon a .clone panic.
|
{'CVE-2021-30455'}
|
2021-08-19T17:04:17Z
|
2021-08-25T20:55:11Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://github.com/andrewhickman/id-map/issues/3', 'https://nvd.nist.gov/vuln/detail/CVE-2021-30455', 'https://github.com/andrewhickman/id-map', 'https://rustsec.org/advisories/RUSTSEC-2021-0052.html'}
| null |
crates.io
|
RUSTSEC-2021-0034
|
office is unmaintained, use calamine instead
|
The `office` crate is unmaintained. Use [calamine](https://crates.io/crates/calamine)
for reading excel files.
Contact the `office` author for ownership of the package name.
| null |
2021-03-03T18:06:07Z
|
2021-02-04T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0034.html', 'https://github.com/RustSec/advisory-db/issues/742#issuecomment-773313783', 'https://crates.io/crates/office'}
| null |
crates.io
|
GHSA-368f-29c3-4f2r
|
Data race in conqueue
|
Affected versions of this crate unconditionally implemented `Send`/`Sync` for `QueueSender<T>`,
allowing to send non-Send `T` to other threads by invoking `(&QueueSender<T>).send()`.
This fails to prevent users from creating data races by sending types like `Rc<T>` or `Arc<Cell<T>>` to other threads, which can lead to memory corruption.
The flaw was corrected in commit 1e462c3 by imposing `T: Send` to both `Send`/`Sync` impls for `QueueSender<T>`/`QueueReceiver<T>`.
|
{'CVE-2020-36437'}
|
2021-08-24T18:26:21Z
|
2021-08-25T20:58:50Z
|
HIGH
| null |
{'CWE-119', 'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0117.html', 'https://github.com/longshorej/conqueue', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36437'}
| null |
crates.io
|
RUSTSEC-2019-0002
|
Bug in SliceDeque::move_head_unchecked corrupts its memory
|
Affected versions of this crate entered a corrupted state if
`mem::size_of::<T>() % allocation_granularity() != 0` and a specific allocation
pattern was used: sufficiently shifting the deque elements over the mirrored
page boundary.
This allows an attacker that controls controls both element insertion and
removal to corrupt the deque, such that reading elements from it would read
bytes corresponding to other elements in the deque. (e.g. a read of T could read
some bytes from one value and some bytes from an adjacent one, resulting in a T
whose value representation is not meaningful). This is undefined behavior.
The flaw was corrected by using a pair of pointers to track the head and tail of
the deque instead of a pair of indices. This pair of pointers are represented
using a Rust slice.
|
{'CVE-2019-15543'}
|
2021-10-19T22:14:35Z
|
2019-05-07T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0002.html', 'https://github.com/gnzlbg/slice_deque/issues/57', 'https://crates.io/crates/slice-deque'}
| null |
crates.io
|
GHSA-9pp4-8p8v-g78w
|
Data races in lever
|
An issue was discovered in the lever crate before 0.1.1 for Rust. AtomicBox<T> implements the Send and Sync traits for all types T. This allows non-Send types such as Rc and non-Sync types such as Cell to be used across thread boundaries which can trigger undefined behavior and memory corruption.
|
{'CVE-2020-36457'}
|
2021-08-18T20:22:32Z
|
2021-08-25T20:57:26Z
|
HIGH
| null |
{'CWE-77', 'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0137.html', 'https://github.com/vertexclique/lever', 'https://github.com/vertexclique/lever/issues/15', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36457'}
| null |
crates.io
|
RUSTSEC-2020-0090
|
Thex<T> allows data races of non-Send types across threads
|
`thex::Thex<T>` implements `Sync` for all types `T`. However, it is missing a
bound for `T: Send`.
This allows non-Send types such as `Rc` to be sent across thread boundaries
which can trigger undefined behavior and memory corruption.
|
{'CVE-2020-35927'}
|
2021-10-19T22:14:35Z
|
2020-12-08T12:00:00Z
| null | null | null |
{'https://crates.io/crates/thex', 'https://rustsec.org/advisories/RUSTSEC-2020-0090.html'}
| null |
crates.io
|
GHSA-g4vj-x7v9-h82m
|
Overflow in libsecp256k1
|
An issue was discovered in the libsecp256k1 crate before 0.5.0 for Rust. It can verify an invalid signature because it allows the R or S parameter to be larger than the curve order, aka an overflow.
|
{'CVE-2021-38195'}
|
2021-08-18T21:20:32Z
|
2021-08-25T20:56:03Z
|
CRITICAL
| null |
{'CWE-190', 'CWE-347'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0076.html', 'https://github.com/paritytech/libsecp256k1', 'https://nvd.nist.gov/vuln/detail/CVE-2021-38195', 'https://github.com/paritytech/libsecp256k1/pull/67'}
| null |
crates.io
|
RUSTSEC-2021-0126
|
RustEmbed generated `get` method allows for directory traversal when reading files from disk
|
When running in debug mode and the `debug-embed` (off by default) feature is
not enabled, the generated `get` method does not check that the input path is
a child of the folder given.
This allows attackers to read arbitrary files in the file system if they have
control over the filename given. The following code will print the contents of
your `/etc/passwd` if adjusted with a correct number of `../`s depending on
where it is run from.
```rust
#[derive(rust_embed::RustEmbed)]
#[folder = "src/"]
pub struct Asset;
fn main() {
let d = Asset::get("../../../etc/passwd").unwrap().data;
println!("{}", String::from_utf8_lossy(&d));
}
```
The flaw was corrected by canonicalizing the input filename and ensuring that
it starts with the canonicalized folder path.
| null |
2021-11-29T18:32:40Z
|
2021-11-29T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0126.html', 'https://github.com/pyros2097/rust-embed/issues/159', 'https://crates.io/crates/rust-embed'}
| null |
crates.io
|
GHSA-3837-87vh-xq3w
|
Data race in v9
|
v9 is a slim data engine for Data Oriented Design. An issue was discovered in the v9 crate through 2020-12-18 for Rust. There is an unconditional implementation of Sync for SyncRef<T>.
|
{'CVE-2020-36447'}
|
2022-05-04T03:16:59Z
|
2021-08-25T20:57:07Z
|
HIGH
| null |
{'CWE-77'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0127.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36447', 'https://github.com/purpleposeidon/v9/issues/1', 'https://github.com/purpleposeidon/v9', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/v9/RUSTSEC-2020-0127.md'}
| null |
crates.io
|
RUSTSEC-2021-0063
|
XSS in `comrak`
|
[comrak](https://github.com/kivikakk/comrak) operates by default in a "safe"
mode of operation where unsafe content, such as arbitrary raw HTML or URLs with
non-standard schemes, are not permitted in the output. This is per the
reference GFM implementation, [cmark-gfm](https://github.com/github/cmark).
Ampersands were not being correctly escaped in link targets, making it possible
to fashion unsafe URLs using schemes like `data:` or `javascript:` by entering
them as HTML entities, e.g. `data:`. The intended
behaviour, demonstrated upstream, is that these should be escaped and therefore
harmless, but this behaviour was broken in comrak.
|
{'CVE-2021-38186'}
|
2021-11-06T20:37:35Z
|
2021-05-04T12:00:00Z
| null | null | null |
{'https://github.com/kivikakk/comrak/releases/tag/0.10.1', 'https://crates.io/crates/comrak', 'https://rustsec.org/advisories/RUSTSEC-2021-0063.html'}
| null |
crates.io
|
RUSTSEC-2020-0028
|
`LocalRequest::clone` creates multiple mutable references to the same object
|
The affected version of `rocket` contains a `Clone` trait implementation of
`LocalRequest` that reuses the pointer to inner `Request` object.
This causes data race in rare combinations of APIs if the original and the
cloned objects are modified at the same time.
|
{'CVE-2020-35882'}
|
2021-10-19T22:14:35Z
|
2020-05-27T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0028.html', 'https://crates.io/crates/rocket', 'https://github.com/SergioBenitez/Rocket/issues/1312'}
| null |
crates.io
|
GHSA-3vv3-frrq-6486
|
Use of Uninitialized Resource in alg_ds
|
An issue was discovered in the alg_ds crate through 2020-08-25 for Rust. `Matrix::new()` internally calls `Matrix::fill_with()` which uses `*ptr = value` pattern to initialize the buffer. This pattern assumes that there is an initialized struct at the address and drops it, which results in dropping of uninitialized struct.
|
{'CVE-2020-36432'}
|
2021-08-24T19:10:18Z
|
2021-08-25T20:59:20Z
|
CRITICAL
| null |
{'CWE-908', 'CWE-665'}
|
{'https://gitlab.com/dvshapkin/alg-ds', 'https://rustsec.org/advisories/RUSTSEC-2020-0033.html', 'https://gitlab.com/dvshapkin/alg-ds/-/issues/1', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36432'}
| null |
crates.io
|
GHSA-whc7-5p35-4ww2
|
Use after free in actix-service
|
An issue was discovered in the actix-service crate before 1.0.6 for Rust. The Cell implementation allows obtaining more than one mutable reference to the same data.
|
{'CVE-2020-35899'}
|
2021-08-19T20:54:21Z
|
2021-08-25T20:49:06Z
|
MODERATE
| null |
{'CWE-416'}
|
{'https://github.com/actix/actix-net/pull/158', 'https://rustsec.org/advisories/RUSTSEC-2020-0046.html', 'https://github.com/actix/actix-net', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35899'}
| null |
crates.io
|
GHSA-fqpx-cq8x-9wp4
|
Unaligned references in sized-chunks
|
An issue was discovered in the sized-chunks crate through 0.6.2 for Rust. In the InlineArray implementation, an unaligned reference may be generated for a type that has a large alignment requirement.
|
{'CVE-2020-25796'}
|
2021-08-19T21:20:35Z
|
2021-08-25T20:46:03Z
|
HIGH
| null |
{'CWE-129'}
|
{'https://github.com/bodil/sized-chunks', 'https://rustsec.org/advisories/RUSTSEC-2020-0041.html', 'https://github.com/bodil/sized-chunks/issues/11', 'https://nvd.nist.gov/vuln/detail/CVE-2020-25796'}
| null |
crates.io
|
GHSA-hj9h-wrgg-hgmx
|
Data races in lock_api
|
An issue was discovered in the lock_api crate before 0.4.2 for Rust. A data race can occur because of RwLockReadGuard unsoundness.
|
{'CVE-2020-35913'}
|
2021-08-19T18:59:37Z
|
2021-08-25T20:50:02Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/Amanieu/parking_lot', 'https://rustsec.org/advisories/RUSTSEC-2020-0070.html', 'https://github.com/Amanieu/parking_lot/pull/262', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35913'}
| null |
crates.io
|
RUSTSEC-2019-0022
|
Stream callback function is not unwind safe
|
Affected versions of this crate is not panic safe within callback functions `stream_callback` and `stream_finished_callback`.
The call to user-provided closure might panic before a `mem::forget` call, which then causes a use after free that grants attacker to control the callback function pointer.
This allows an attacker to construct an arbitrary code execution .
The flaw was reported by Phosphorus15.
|
{'CVE-2019-16881'}
|
2021-10-19T22:14:35Z
|
2019-09-14T12:00:00Z
| null | null | null |
{'https://crates.io/crates/portaudio-rs', 'https://rustsec.org/advisories/RUSTSEC-2019-0022.html', 'https://github.com/mvdnes/portaudio-rs/issues/20'}
| null |
crates.io
|
GHSA-9xjr-m6f3-v5wm
|
HTTPS MitM vulnerability due to lack of hostname verification
|
An issue was discovered in the hyper crate before 0.9.4 for Rust on Windows. There is an HTTPS man-in-the-middle vulnerability because hostname verification was omitted.
|
{'CVE-2016-10932'}
|
2021-08-19T21:25:12Z
|
2021-08-25T20:43:06Z
|
MODERATE
| null |
{'CWE-347'}
|
{'https://github.com/hyperium/hyper/blob/master/CHANGELOG.md#v094-2016-05-09', 'https://nvd.nist.gov/vuln/detail/CVE-2016-10932', 'https://rustsec.org/advisories/RUSTSEC-2016-0002.html'}
| null |
crates.io
|
GHSA-5h46-h7hh-c6x9
|
Integer Overflow in Chunked Transfer-Encoding
|
### Summary
hyper's HTTP server and client code had a flaw that could trigger an integer overflow when decoding chunk sizes that are too big. This allows possible data loss, or if combined with an upstream HTTP proxy that allows chunk sizes larger than hyper does, can result in "request smuggling" or "desync attacks".
### Vulnerability
Example:
```
GET / HTTP/1.1
Host: example.com
Transfer-Encoding: chunked
f0000000000000003
abc
0
```
hyper only reads the rightmost 64-bit integer as the chunk size. So it reads `f0000000000000003` as `3`. A loss of data can occur since hyper would then read only 3 bytes of the body. Additionally, an HTTP request smuggling vulnerability would occur if using a proxy which instead has prefix truncation in the chunk size, or that understands larger than 64-bit chunk sizes.
Read more about desync attacks: https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn
### Impact
To determine if vulnerable to _data loss_, these things must be true:
- **Using HTTP/1.1.** Since HTTP/2 does not use chunked encoding, it is not vulnerable.
- **Using hyper as a server or client.** The body would be improperly truncated in either case.
- **Users send requests or responses with chunk sizes greater than 18 exabytes**.
To determine if vulnerable to _desync attacks_, these things must be true:
- **Using an upstream proxy that allows chunks sizes larger than 64-bit.** If the proxy rejects chunk sizes that are too large, that request won't be forwarded to hyper.
### Patches
We have released the following patch versions:
- v0.14.10 (to be released when this advisory is published)
### Workarounds
Besides upgrading hyper, you can take the following options:
- Reject requests manually that contain a `Transfer-Encoding` header.
- Ensure any upstream proxy rejects `Transfer-Encoding` chunk sizes greater than what fits in 64-bit unsigned integers.
### Credits
This issue was initially reported by [Mattias Grenfeldt](https://grenfeldt.dev/) and Asta Olofsson.
|
{'CVE-2021-32714'}
|
2021-09-07T21:47:36Z
|
2021-07-12T16:55:37Z
|
MODERATE
| null |
{'CWE-190'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-32714', 'https://github.com/hyperium/hyper/security/advisories/GHSA-5h46-h7hh-c6x9', 'https://rustsec.org/advisories/RUSTSEC-2021-0079.html', 'https://github.com/hyperium/hyper'}
| null |
crates.io
|
GHSA-9658-c26v-7qvf
|
Use-after-free in yottadb
|
An issue was discovered in the yottadb crate before 1.2.0 for Rust. For some memory-allocation patterns, ydb_subscript_next_st and ydb_subscript_prev_st have a use-after-free.
|
{'CVE-2021-27377'}
|
2021-08-19T16:50:37Z
|
2021-08-25T20:55:30Z
|
CRITICAL
| null |
{'CWE-416'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0022.html', 'https://gitlab.com/YottaDB/Lang/YDBRust', 'https://gitlab.com/YottaDB/Lang/YDBRust/-/issues/40', 'https://nvd.nist.gov/vuln/detail/CVE-2021-27377'}
| null |
crates.io
|
RUSTSEC-2021-0014
|
Record::read : Custom `Read` on uninitialized buffer may cause UB
|
Affected versions of this crate passes an uninitialized buffer to a user-provided `Read` implementation. (`Record::read()`)
Arbitrary `Read` implementations can read from the uninitialized buffer (memory exposure) and also can return incorrect number of bytes written to the buffer.
Reading from uninitialized memory produces undefined values that can quickly invoke undefined behavior.
This flaw was fixed in commit 6299af0 by zero-initializing the newly allocated memory (via `data.resize(len, 0)`) instead of exposing uninitialized memory (`unsafe { data.set_len(len) }`).
|
{'CVE-2021-26308'}
|
2021-10-19T22:14:35Z
|
2021-01-26T12:00:00Z
| null | null | null |
{'https://crates.io/crates/marc', 'https://rustsec.org/advisories/RUSTSEC-2021-0014.html', 'https://github.com/blackbeam/rust-marc/issues/7'}
| null |
crates.io
|
GHSA-8gjm-h3xj-mp6w
|
RPC call failure in ckb
|
An issue was discovered in the ckb crate before 0.40.0 for Rust. A get_block_template RPC call may fail in situations where it is supposed to select a Nervos CKB blockchain transaction with a higher fee rate than another transaction.
|
{'CVE-2021-45698'}
|
2022-01-07T17:55:53Z
|
2022-01-06T22:10:43Z
|
CRITICAL
| null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0107.html', 'https://github.com/nervosnetwork/ckb', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/ckb/RUSTSEC-2021-0107.md', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45698'}
| null |
crates.io
|
GHSA-5wg8-7c9q-794v
|
Data races in lock_api
|
An issue was discovered in the lock_api crate before 0.4.2 for Rust. A data race can occur because of MappedRwLockWriteGuard unsoundness.
|
{'CVE-2020-35912'}
|
2021-08-19T18:59:40Z
|
2021-08-25T20:50:00Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/Amanieu/parking_lot', 'https://rustsec.org/advisories/RUSTSEC-2020-0070.html', 'https://github.com/Amanieu/parking_lot/pull/262', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35912'}
| null |
crates.io
|
GHSA-gjrj-9rj4-pgwx
|
DoS Vulnerability from Upstream Actix Web Issues
|
### Impact
This vulnerability affects all users of the `perseus deploy` functionality who have not exported their sites to static files. If you are using the inbuilt Perseus server in production, there is a memory leak in Actix Web stemming from [this upstream issue](https://github.com/actix/actix-web/issues/1780) which can allow even a single user to cause the process to exhaust its memory on low-memory servers by continuously reloading the page. Note that this issue does not affect all Actix Web applications, but rather results from certain usage patterns which appear to be present in Perseus' server mechanics.
### Patches
This vulnerability is addressed in all versions after Perseus `v0.3.0-beta.21`, which temporarily discontinues the use of `perseus-actix-web` (until the upstream bug is fixed) and switches to `perseus-warp` instead, which utilizes [Warp](https://github.com/seanmonstar/warp).
Additionally, as of Perseus `v0.3.0-beta.22`, the Actix Web integration has been upgraded to use the latest unstable beta version of Actix Web, which appears to partially resolve this issue (the severity of the memory leak is reduced). However, due to the instability of this version, the default integration will remain Warp for now, and a warning will appear if you attempt to use the Actix Web integration.
<details>
<summary>Using the Actix Web integration</summary>
If the instability of the latest beta version of Actix Web is not a concern for you, you can use this integration by adding `-i actix-web` to `perseus serve` and the like. This will print a warning about instability, and will then operate with the beta version. Please report any failures in functionality that are not security-related to the Perseus team by [opening an issue on the repository](https://github.com/arctic-hen7/perseus/issues/new/choose).
Note however that switching to the Warp integration requires no code changes whatsoever unless you've ejected, so there are very few disadvantages to this change.
</details>
### Workarounds
Due to significant infrastructural changes within other Perseus packages that were needed to support Warp, this integration is not backward-compatible with any previous version of Perseus, meaning there are no easily feasible workarounds. If you're only in development though, this vulnerability is irrelevant until you push to production.
### CVE Status
Due to GitHub's requirements, a CVE can't be issued for this security advisory because the issue is technically one with Actix Web (though it's only in combination with certain mechanics in the Perseus server that this problem arises).
### References
See [this upstream issue](https://github.com/actix/actix-web/issues/1780) in Actix Web.
### For more information
If you have any questions or comments about this advisory:
* Open an issue on this repository
* Email me at [arctic_hen7@pm.me](mailto:arctic_hen7@pm.me)
| null |
2021-12-17T19:33:49Z
|
2021-12-15T22:51:07Z
|
HIGH
| null | null |
{'https://github.com/arctic-hen7/perseus', 'https://github.com/arctic-hen7/perseus/security/advisories/GHSA-gjrj-9rj4-pgwx', 'https://github.com/actix/actix-web/issues/1780'}
| null |
crates.io
|
GHSA-7x36-h62w-vw65
|
Out-of-bounds Write in actix-web
|
An issue was discovered in the actix-web crate before 0.7.15 for Rust. It can add the Send marker trait to an object that cannot be sent between threads safely, leading to memory corruption.
|
{'CVE-2018-25026'}
|
2022-01-06T18:34:36Z
|
2022-01-06T22:18:58Z
|
CRITICAL
| null |
{'CWE-787'}
|
{'https://github.com/actix/actix-web.git', 'https://nvd.nist.gov/vuln/detail/CVE-2018-25026', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/actix-web/RUSTSEC-2018-0019.md', 'https://rustsec.org/advisories/RUSTSEC-2018-0019.html'}
| null |
crates.io
|
GHSA-vjmg-pc8h-p6p8
|
Out of bounds read in fltk
|
An issue was discovered in the fltk crate before 0.15.3 for Rust. There is an out-of bounds read because the pixmap constructor lacks pixmap input validation.
|
{'CVE-2021-28308'}
|
2021-08-19T17:22:11Z
|
2021-08-25T20:53:58Z
|
CRITICAL
| null |
{'CWE-125'}
|
{'https://github.com/MoAlyousef/fltk-rs/issues/519', 'https://nvd.nist.gov/vuln/detail/CVE-2021-28308', 'https://rustsec.org/advisories/RUSTSEC-2021-0038.html', 'https://github.com/MoAlyousef/fltk-rs'}
| null |
crates.io
|
GHSA-rh7x-ppxx-p34c
|
Insufficient size checks in ws
|
An issue was discovered in the ws crate through 2020-09-25 for Rust. The outgoing buffer is not properly limited, leading to a remote memory-consumption attack.
|
{'CVE-2020-35896'}
|
2021-08-19T20:53:37Z
|
2021-08-25T20:49:32Z
|
HIGH
| null |
{'CWE-400'}
|
{'https://github.com/housleyjk/ws-rs', 'https://rustsec.org/advisories/RUSTSEC-2020-0043.html', 'https://github.com/housleyjk/ws-rs/issues/291', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35896'}
| null |
crates.io
|
RUSTSEC-2020-0008
|
Flaw in hyper allows request smuggling by sending a body in GET requests
|
Vulnerable versions of hyper allow GET requests to have bodies, even if there is
no Transfer-Encoding or Content-Length header. As per the HTTP 1.1
specification, such requests do not have bodies, so the body will be interpreted
as a separate HTTP request.
This allows an attacker who can control the body and method of an HTTP request
made by hyper to inject a request with headers that would not otherwise be
allowed, as demonstrated by sending a malformed HTTP request from a Substrate
runtime. This allows bypassing CORS restrictions. In combination with other
vulnerabilities, such as an exploitable web server listening on loopback, it may
allow remote code execution.
The flaw was corrected in hyper version 0.12.34.
|
{'CVE-2020-35863'}
|
2021-10-19T22:14:35Z
|
2020-03-19T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0008.html', 'https://github.com/hyperium/hyper/issues/1925', 'https://crates.io/crates/hyper'}
| null |
crates.io
|
RUSTSEC-2021-0043
|
PartialReader passes uninitialized memory to user-provided Read
|
Affected versions of this crate passed an uniniitalized buffer to a
user-provided `Read` instance in `PartialReader::read`.
This can result in safe `Read` implementations reading from the uninitialized
buffer leading to undefined behavior.
The flaw was fixed in commit [`39d62c6`](https://github.com/uutils/coreutils/commit/39d62c6c1f809022c903180471c10fde6ecd12d1)
by zero-initializing the passed buffer.
|
{'CVE-2021-29934'}
|
2021-10-19T22:14:35Z
|
2021-02-17T12:00:00Z
| null | null | null |
{'https://github.com/uutils/coreutils/issues/1729', 'https://rustsec.org/advisories/RUSTSEC-2021-0043.html', 'https://crates.io/crates/uu_od'}
| null |
crates.io
|
RUSTSEC-2022-0016
|
Use after free with `externref`s and epoch interruption in Wasmtime
|
[Use after free with `externref`s and epoch interruption in Wasmtime](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-gwc9-348x-qwv2)
|
{'CVE-2022-24791'}
|
2022-03-31T22:54:54Z
|
2022-03-31T12:00:00Z
| null | null | null |
{'https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-gwc9-348x-qwv2', 'https://crates.io/crates/wasmtime', 'https://rustsec.org/advisories/RUSTSEC-2022-0016.html'}
| null |
crates.io
|
GHSA-48vq-8jqv-gm6f
|
Remote memory exhaustion in ckb
|
In the ckb sync protocol, SyncState maintains a HashMap called 'misbehavior' that keeps a score of a peer's violations of the protocol. This HashMap is keyed to PeerIndex (an alias for SessionId), and entries are never removed from it. SessionId is an integer that increases monotonically with every new connection.
A remote attacker can manipulate this HashMap to grow forever, resulting in degraded performance and ultimately a panic on allocation failure or being killed by the OS, depending on the platform.
This is a critical severity security bug. It could be exploited to create a targeted or network-wide denial of service, to reduce the hash power of the network as part of a 51% attack, and perhaps in other creative ways.
An attack is trivial:
1. connect to another node
2. send an invalid sync protocol request, such as `SendHeaders` for non-consecutive blocks
3. disconnect
4. repeat
| null |
2021-08-02T21:53:41Z
|
2021-08-25T21:01:23Z
|
HIGH
| null |
{'CWE-400'}
|
{'https://github.com/nervosnetwork/ckb/security/advisories/GHSA-48vq-8jqv-gm6f'}
| null |
crates.io
|
GHSA-gmv4-vmx3-x9f3
|
Data races in lock_api
|
An issue was discovered in the lock_api crate before 0.4.2 for Rust. A data race can occur because of RwLockWriteGuard unsoundness.
|
{'CVE-2020-35914'}
|
2021-08-19T20:52:14Z
|
2021-08-25T20:49:37Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/Amanieu/parking_lot', 'https://rustsec.org/advisories/RUSTSEC-2020-0070.html', 'https://github.com/Amanieu/parking_lot/pull/262', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35914'}
| null |
crates.io
|
GHSA-cgmg-2v6m-fjg7
|
Free of uninitialized memory in autorand
|
An issue was discovered in the autorand crate before 0.2.3 for Rust. Because of impl Random on arrays, uninitialized memory can be dropped when a panic occurs, leading to memory corruption.
|
{'CVE-2020-36210'}
|
2021-08-19T18:53:20Z
|
2021-08-25T20:50:41Z
|
HIGH
| null |
{'CWE-908'}
|
{'https://github.com/mersinvald/autorand-rs/issues/5', 'https://rustsec.org/advisories/RUSTSEC-2020-0103.html', 'https://github.com/mersinvald/autorand-rs', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36210'}
| null |
crates.io
|
RUSTSEC-2021-0106
|
Uncontrolled Search Path Element in sharkdp/bat
|
bat on windows before 0.18.2 executes programs named less.exe from the current working directory. This can lead to unintended code execution.
|
{'GHSA-p24j-h477-76q3', 'CVE-2021-36753'}
|
2021-09-10T16:11:09Z
|
2021-07-15T12:00:00Z
| null | null | null |
{'https://nvd.nist.gov/vuln/detail/CVE-2021-36753', 'https://rustsec.org/advisories/RUSTSEC-2021-0106.html', 'https://crates.io/crates/bat'}
| null |
crates.io
|
RUSTSEC-2021-0055
|
NULL pointer deref in signature_algorithms processing
|
An OpenSSL TLS server may crash if sent a maliciously crafted renegotiation
ClientHello message from a client. If a TLSv1.2 renegotiation ClientHello omits
the signature_algorithms extension (where it was present in the initial
ClientHello), but includes a signature_algorithms_cert extension then a NULL
pointer dereference will result, leading to a crash and a denial of service
attack.
A server is only vulnerable if it has TLSv1.2 and renegotiation enabled (which
is the default configuration). OpenSSL TLS clients are not impacted by this
issue.
|
{'CVE-2021-3449'}
|
2021-10-19T22:14:35Z
|
2021-05-01T12:00:00Z
| null | null | null |
{'https://crates.io/crates/openssl-src', 'https://rustsec.org/advisories/RUSTSEC-2021-0055.html', 'https://www.openssl.org/news/secadv/20210325.txt'}
| null |
crates.io
|
GHSA-4qr3-m7ww-hh9g
|
Use After Free in rusqlite
|
An issue was discovered in the rusqlite crate 0.25.x before 0.25.4 and 0.26.x before 0.26.2 for Rust. commit_hook has a use-after-free.
|
{'CVE-2021-45717'}
|
2022-01-06T20:21:05Z
|
2022-01-06T22:01:40Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/rusqlite/RUSTSEC-2021-0128.md', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45717', 'https://rustsec.org/advisories/RUSTSEC-2021-0128.html', 'https://github.com/rusqlite/rusqlite'}
| null |
crates.io
|
RUSTSEC-2021-0110
|
Multiple Vulnerabilities in Wasmtime
|
* [Use after free passing `externref`s to Wasm in
Wasmtime](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-v4cp-h94r-m7xf)
* [Out-of-bounds read/write and invalid free with `externref`s and GC safepoints
in
Wasmtime](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-4873-36h9-wv49)
* [Wrong type for `Linker`-define functions when used across two
`Engine`s](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-q879-9g95-56mx)
|
{'CVE-2021-39219', 'CVE-2021-39216', 'CVE-2021-39218'}
|
2021-10-19T22:14:35Z
|
2021-09-17T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0110.html', 'https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-v4cp-h94r-m7xf', 'https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-q879-9g95-56mx', 'https://crates.io/crates/wasmtime', 'https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-4873-36h9-wv49'}
| null |
crates.io
|
GHSA-29v7-3v4c-gf38
|
Data races in parc
|
An issue was discovered in the parc crate through 2020-11-14 for Rust. LockWeak<T> has an unconditional implementation of Send without trait bounds on T.
|
{'CVE-2020-36454'}
|
2021-08-18T20:23:35Z
|
2021-08-25T20:57:24Z
|
HIGH
| null |
{'CWE-119', 'CWE-362'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36454', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/parc/RUSTSEC-2020-0134.md', 'https://github.com/hyyking/rustracts/pull/6', 'https://rustsec.org/advisories/RUSTSEC-2020-0134.html', 'https://github.com/hyyking/rustracts/tree/master/parc'}
| null |
crates.io
|
RUSTSEC-2019-0034
|
HeaderMap::Drain API is unsound
|
Affected versions of this crate incorrectly used raw pointer,
which introduced unsoundness in its public safe API.
[Failing to drop the Drain struct causes double-free](https://github.com/hyperium/http/issues/354),
and [it is possible to violate Rust's alias rule and cause data race with Drain's Iterator implementation](https://github.com/hyperium/http/issues/355).
The flaw was corrected in 0.1.20 release of `http` crate.
|
{'CVE-2019-25009'}
|
2021-10-19T22:14:35Z
|
2019-11-16T12:00:00Z
| null | null | null |
{'https://crates.io/crates/http', 'https://rustsec.org/advisories/RUSTSEC-2019-0034.html'}
| null |
crates.io
|
RUSTSEC-2020-0049
|
Use-after-free in Framed due to lack of pinning
|
Affected versions of this crate did not require the buffer wrapped in `Framed` to be pinned,
but treated it as if it had a fixed location in memory. This may result in a use-after-free.
The flaw was corrected by making the affected functions accept `Pin<&mut Self>` instead of `&mut self`.
|
{'CVE-2020-35902'}
|
2021-10-19T22:14:35Z
|
2020-01-30T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0049.html', 'https://crates.io/crates/actix-codec', 'https://github.com/actix/actix-net/issues/91'}
| null |
crates.io
|
RUSTSEC-2021-0002
|
interfaces2 is unmaintained, use interfaces instead
|
The `interfaces2` crate is not maintained any more;
use [`interfaces`](https://crates.io/crates/interfaces) instead.
| null |
2021-01-06T16:07:19Z
|
2021-01-04T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0002.html', 'https://github.com/aep/interfaces-rs', 'https://crates.io/crates/interfaces2'}
| null |
crates.io
|
RUSTSEC-2020-0032
|
StrcCtx deallocates a memory region that it doesn't own
|
`StrcCtx` deallocate a memory region that it doesn't own when `StrcCtx` is created without using `StrcCtx::new`.
This can introduce memory safety issues such as double-free and use-after-free to client programs.
|
{'CVE-2020-35885'}
|
2021-10-19T22:14:35Z
|
2020-08-20T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0032.html', 'https://github.com/pigeonhands/rust-arch/issues/2', 'https://crates.io/crates/alpm-rs'}
| null |
crates.io
|
GHSA-r88h-6987-g79f
|
Data races on syncpool
|
Affected versions of this crate unconditionally implements `Send` for `Bucket2`. This allows sending non-Send types to other threads.
This can lead to data races when non Send types like `Cell<T>` or `Rc<T>` are contained inside `Bucket2` and sent across thread boundaries. The data races can potentially lead to memory corruption (as demonstrated in the PoC from the original report issue).
The flaw was corrected in commit 15b2828 by adding a `T: Send` bound to the `Send` impl of `Bucket2<T>`.
| null |
2021-08-18T23:32:42Z
|
2021-08-25T21:00:28Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/Chopinsky/byte_buffer/issues/2', 'https://rustsec.org/advisories/RUSTSEC-2020-0142.html', 'https://github.com/Chopinsky/byte_buffer/tree/master/syncpool', 'https://github.com/RustSec/advisory-db/blob/main/crates/syncpool/RUSTSEC-2020-0142.md'}
| null |
crates.io
|
GHSA-fvhr-7j8m-3cvc
|
Data races in appendix
|
The `appendix` crate implements a key-value mapping data structure called
`Index<K, V>` that is stored on disk. The crate allows for any type to inhabit
the generic `K` and `V` type parameters and implements Send and Sync for them
unconditionally.
Using a type that is not marked as `Send` or `Sync` with `Index` can allow it
to be used across multiple threads leading to data races. Additionally using
reference types for the keys or values will lead to the segmentation faults
in the crate's code.
|
{'CVE-2020-36469'}
|
2021-08-24T19:08:25Z
|
2021-08-25T20:57:02Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/krl/appendix/issues/6', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36469', 'https://github.com/krl/appendix', 'https://rustsec.org/advisories/RUSTSEC-2020-0149.html'}
| null |
crates.io
|
GHSA-cw4j-cf6c-mmfv
|
Use of Uninitialized Resource in binjs_io.
|
An issue was discovered in the binjs_io crate through 2021-01-03 for Rust. The Read method may read from uninitialized memory locations.
|
{'CVE-2021-45683'}
|
2022-01-07T17:36:37Z
|
2022-01-06T22:14:24Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-45683', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/binjs_io/RUSTSEC-2021-0085.md', 'https://rustsec.org/advisories/RUSTSEC-2021-0085.html', 'https://github.com/Yoric/binjs-ref'}
| null |
crates.io
|
RUSTSEC-2021-0096
|
spirv_headers is unmaintained, use spirv instead
|
Because of versioning issues; the `spirv_headers` crate is unmaintained. Use [spirv](https://crates.io/crates/spirv)
for parsing spirv files.
| null |
2021-08-23T14:34:15Z
|
2021-08-16T12:00:00Z
| null | null | null |
{'https://github.com/gfx-rs/rspirv/issues/197', 'https://crates.io/crates/spirv_headers', 'https://rustsec.org/advisories/RUSTSEC-2021-0096.html'}
| null |
crates.io
|
RUSTSEC-2021-0079
|
Integer overflow in `hyper`'s parsing of the `Transfer-Encoding` header leads to data loss
|
When decoding chunk sizes that are too large, `hyper`'s code would encounter an integer overflow. Depending on the situation,
this could lead to data loss from an incorrect total size, or in rarer cases, a request smuggling attack.
To be vulnerable, you must be using `hyper` for any HTTP/1 purpose, including as a client or server, and consumers must send
requests or responses that specify a chunk size greater than 18 exabytes. For a possible request smuggling attack to be possible,
any upstream proxies must accept a chunk size greater than 64 bits.
|
{'CVE-2021-32714', 'GHSA-5h46-h7hh-c6x9'}
|
2021-10-19T22:14:35Z
|
2021-07-07T12:00:00Z
| null | null | null |
{'https://github.com/hyperium/hyper/security/advisories/GHSA-5h46-h7hh-c6x9', 'https://rustsec.org/advisories/RUSTSEC-2021-0079.html', 'https://crates.io/crates/hyper'}
| null |
crates.io
|
RUSTSEC-2018-0004
|
Malicious input could cause uninitialized memory to be exposed
|
Affected versions of Claxon made an invalid assumption about the decode buffer
size being a multiple of a value read from the bitstream. This could cause parts
of the decode buffer to not be overwritten. If the decode buffer was newly
allocated and uninitialized, this uninitialized memory could be exposed.
This allows an attacker to observe parts of the uninitialized memory in the
decoded audio stream.
The flaw was corrected by checking that the value read from the bitstream divides
the decode buffer size, and returning a format error if it does not. If an error
is returned, the decode buffer is not exposed. Regression tests and an
additional fuzzer have been added to prevent similar flaws in the future.
|
{'CVE-2018-20992'}
|
2021-10-19T22:14:35Z
|
2018-08-25T12:00:00Z
| null | null | null |
{'https://crates.io/crates/claxon', 'https://github.com/ruuda/claxon/commit/8f28ec275e412dd3af4f3cda460605512faf332c', 'https://rustsec.org/advisories/RUSTSEC-2018-0004.html'}
| null |
crates.io
|
GHSA-hr3c-6mmp-6m39
|
Memory corruption slice-deque
|
An issue was discovered in the slice-deque crate before 0.1.16 for Rust. move_head_unchecked allows memory corruption because deque updates are mishandled.
|
{'CVE-2018-20995'}
|
2021-08-19T21:25:30Z
|
2021-08-25T20:42:57Z
|
CRITICAL
| null |
{'CWE-119'}
|
{'https://github.com/gnzlbg/slice_deque', 'https://rustsec.org/advisories/RUSTSEC-2018-0008.html', 'https://nvd.nist.gov/vuln/detail/CVE-2018-20995'}
| null |
crates.io
|
GHSA-m8h8-v6jh-c762
|
Incorrect buffer size in crossbeam-channel
|
An issue was discovered in the crossbeam-channel crate before 0.4.4 for Rust. It has incorrect expectations about the relationship between the memory allocation and how many iterator elements there are.
|
{'CVE-2020-35904'}
|
2021-08-19T20:51:01Z
|
2021-08-25T20:49:43Z
|
MODERATE
| null |
{'CWE-131'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-35904', 'https://github.com/crossbeam-rs/crossbeam/pull/533', 'https://rustsec.org/advisories/RUSTSEC-2020-0052.html', 'https://github.com/crossbeam-rs/crossbeam'}
| null |
crates.io
|
RUSTSEC-2020-0065
|
crate has been renamed to `sn_fake_clock`
|
This crate has been renamed from `fake_clock` to `sn_fake_clock`.
The new repository location is:
<https://github.com/maidsafe/sn_fake_clock>
| null |
2020-11-02T14:46:33Z
|
2020-11-02T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0065.html', 'https://github.com/maidsafe/sn_fake_clock/pull/38', 'https://crates.io/crates/fake_clock'}
| null |
crates.io
|
RUSTSEC-2019-0018
|
Internally mutating methods take immutable ref self
|
Affected versions of this crate exposed several methods which took `self` by
immutable reference, despite the requesting the RenderDoc API to set a mutable
value internally.
This is technically unsound and calling these methods from multiple threads
without synchronization could lead to unexpected and unpredictable behavior.
The flaw was corrected in release 0.5.0.
|
{'CVE-2019-16142'}
|
2021-10-19T22:14:35Z
|
2019-09-02T12:00:00Z
| null | null | null |
{'https://github.com/ebkalderon/renderdoc-rs/pull/32', 'https://crates.io/crates/renderdoc', 'https://rustsec.org/advisories/RUSTSEC-2019-0018.html'}
| null |
crates.io
|
RUSTSEC-2020-0120
|
`Decoder<R>` can carry `R: !Send` to other threads
|
Affected versions of this crate implements `Send` for `Decoder<R>` for any `R: Read`. This allows `Decoder<R>` to contain `R: !Send` and carry (move) it to another thread.
This can result in undefined behavior such as memory corruption from data race on `R`, or dropping `R = MutexGuard<_>` from a thread that didn't lock the mutex.
The flaw was corrected in commit a34d6e1 by adding trait bound `R: Send` to the `Send` impl for `Decoder<R>`.
|
{'CVE-2020-36440'}
|
2021-10-19T22:14:35Z
|
2020-11-10T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0120.html', 'https://github.com/mvertescher/libsbc-rs/issues/4', 'https://crates.io/crates/libsbc'}
| null |
crates.io
|
GHSA-4wj3-p7hj-cvx8
|
Double free in ordnung
|
An issue was discovered in the ordnung crate through 2020-09-03 for Rust. compact::Vec violates memory safety via a remove() double free.
|
{'CVE-2020-35891'}
|
2021-08-19T21:06:30Z
|
2021-08-25T20:48:47Z
|
HIGH
| null |
{'CWE-415'}
|
{'https://github.com/maciejhirsz/ordnung', 'https://github.com/maciejhirsz/ordnung/issues/8', 'https://rustsec.org/advisories/RUSTSEC-2020-0038.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35891'}
| null |
crates.io
|
RUSTSEC-2020-0073
|
Mutable reference with immutable provenance
|
A mutable reference to a struct was constructed by dereferencing a pointer
obtained from `slice::as_ptr`. Instead, `slice::as_mut_ptr` should have been
called on the mutable slice argument. The former performs an implicit reborrow
as an immutable shared reference which does not allow writing through the
derived pointer.
There is no evidence for miscompilation, exploitable or otherwise, caused by
this bug. [Further investigation on Zulip][Zulip] suggests that the unoptimized
generated LLVM IR does not contain any UB itself, effectively mitigating
further effects.
[Zulip]: https://rust-lang.zulipchat.com/#narrow/stream/146229-wg-secure-code/topic/Implications.20of.20using.20.60slice.3A.3Aas_ptr.60.20for.20mutable.20access/near/216499472
|
{'CVE-2020-35916'}
|
2021-10-19T22:14:35Z
|
2020-11-12T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0073.html', 'https://crates.io/crates/image', 'https://github.com/image-rs/image/issues/1357'}
| null |
crates.io
|
GHSA-92cx-4xm7-jr9m
|
Use After Free in rusqlite
|
An issue was discovered in the rusqlite crate 0.25.x before 0.25.4 and 0.26.x before 0.26.2 for Rust. create_scalar_function has a use-after-free.
|
{'CVE-2021-45713'}
|
2022-01-07T16:09:58Z
|
2022-01-06T22:02:56Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-45713', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/rusqlite/RUSTSEC-2021-0128.md', 'https://rustsec.org/advisories/RUSTSEC-2021-0128.html', 'https://github.com/rusqlite/rusqlite'}
| null |
crates.io
|
GHSA-39xg-8p43-h76x
|
Data races in reffers
|
An issue was discovered in the reffers crate through 2020-12-01 for Rust. ARefss can contain a !Send,!Sync object, leading to a data race and memory corruption.
|
{'CVE-2020-36203'}
|
2021-08-19T18:49:46Z
|
2021-08-25T20:51:40Z
|
MODERATE
| null |
{'CWE-787', 'CWE-362'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36203', 'https://rustsec.org/advisories/RUSTSEC-2020-0094.html', 'https://github.com/diwic/reffers-rs/issues/7', 'https://github.com/diwic/reffers-rs'}
| null |
crates.io
|
RUSTSEC-2020-0136
|
CopyCell lacks bounds on its Send trait allowing for data races
|
`CopyCell<T>` is a `Cell`-like type that is implemented for any type `T` that
is `Copy`able. It's `Send` trait has no bounds on the contained type.
As not all `Copy`able types are thread safe, for example non-mutable references
implement the `Copy` trait, it is possible to send references to types with
interior mutability such as `Cell` across threads and cause data races.
|
{'CVE-2020-36456'}
|
2021-10-19T22:14:35Z
|
2020-11-15T12:00:00Z
| null | null | null |
{'https://crates.io/crates/toolshed', 'https://github.com/ratel-rust/toolshed/issues/12', 'https://rustsec.org/advisories/RUSTSEC-2020-0136.html'}
| null |
crates.io
|
GHSA-h3qr-rq2j-74w4
|
HTTP Request Smuggling in hyper
|
An issue was discovered in the hyper crate before 0.12.34 for Rust. HTTP request smuggling can occur. Remote code execution can occur in certain situations with an HTTP server on the loopback interface.
|
{'CVE-2020-35863'}
|
2021-08-19T21:20:11Z
|
2021-08-25T20:46:08Z
|
CRITICAL
| null |
{'CWE-444'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0008.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35863', 'https://github.com/hyperium/hyper', 'https://github.com/hyperium/hyper/issues/1925'}
| null |
crates.io
|
GHSA-v362-2895-h9r2
|
Use After Free in lru
|
An issue was discovered in the lru crate before 0.7.1 for Rust. The iterators have a use-after-free, as demonstrated by an access after a pop operation.
|
{'CVE-2021-45720'}
|
2022-01-07T20:44:44Z
|
2022-01-07T22:37:01Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/lru/RUSTSEC-2021-0130.md', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45720', 'https://github.com/jeromefroe/lru-rs.git', 'https://rustsec.org/advisories/RUSTSEC-2021-0130.html'}
| null |
crates.io
|
RUSTSEC-2021-0038
|
Multiple memory safety issues
|
Affected versions contain multiple memory safety issues, such as:
- Setting a multi label type where an image doesn't exist would lead to a NULL pointer dereference.
- Setting a window icon using a non-raster image (which FLTK rasterizes lazily) would lead to a NULL dereference.
- Pixmap constructor would not check for correct pixmaps which could lead to out-of bound reads.
|
{'CVE-2021-28306', 'CVE-2021-28308', 'CVE-2021-28307'}
|
2021-03-19T21:21:58Z
|
2021-03-06T12:00:00Z
| null | null | null |
{'https://github.com/MoAlyousef/fltk-rs/issues/519', 'https://crates.io/crates/fltk', 'https://rustsec.org/advisories/RUSTSEC-2021-0038.html'}
| null |
crates.io
|
GHSA-28ph-f7gx-fqj8
|
Data races in rusqlite
|
An issue was discovered in the rusqlite crate before 0.23.0 for Rust. Memory safety can be violated via create_module.
|
{'CVE-2020-35867'}
|
2021-08-19T21:08:12Z
|
2021-08-25T20:47:57Z
|
CRITICAL
| null |
{'CWE-362'}
|
{'https://github.com/rusqlite/rusqlite/releases/tag/0.23.0', 'https://rustsec.org/advisories/RUSTSEC-2020-0014.html', 'https://github.com/rusqlite/rusqlite/commit/3c6b57fe1b2cc87e7ebecde43dd836ffb1c4ea5c', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35867', 'https://github.com/rusqlite/rusqlite'}
| null |
crates.io
|
RUSTSEC-2020-0024
|
Improper uniqueness verification of signature threshold
|
The tough library, prior to 0.7.1, does not properly verify the uniqueness of
keys in the signatures provided to meet the threshold of cryptographic
signatures. It allows someone with access to a valid signing key to create
multiple valid signatures in order to circumvent TUF requiring a minimum
threshold of unique keys before the metadata is considered valid.
AWS would like to thank Erick Tryzelaar of the Google Fuchsia Team for
reporting this issue.
A fix is available in version 0.7.1.
CVE-2020-6174 is assigned to the same issue in the TUF reference
implementation.
If you have any questions or comments about this advisory, contact AWS Security
at aws-security@amazon.com.
|
{'CVE-2020-15093', 'GHSA-5q2r-92f9-4m49'}
|
2021-10-19T22:14:35Z
|
2020-07-09T12:00:00Z
| null | null | null |
{'https://github.com/awslabs/tough/security/advisories/GHSA-5q2r-92f9-4m49', 'https://crates.io/crates/tough', 'https://rustsec.org/advisories/RUSTSEC-2020-0024.html'}
| null |
crates.io
|
GHSA-r98r-j25q-rmpr
|
Type confusion in failure
|
An issue was discovered in the failure crate through 2019-11-13 for Rust. Type confusion can occur when __private_get_type_id__ is overridden.
|
{'CVE-2019-25010'}
|
2021-08-19T21:19:54Z
|
2021-08-25T20:46:38Z
|
CRITICAL
| null |
{'CWE-843'}
|
{'https://github.com/rust-lang-nursery/failure/issues/336', 'https://github.com/rust-lang-nursery/failure', 'https://rustsec.org/advisories/RUSTSEC-2019-0036.html', 'https://nvd.nist.gov/vuln/detail/CVE-2019-25010'}
| null |
crates.io
|
RUSTSEC-2020-0161
|
`array!` macro is unsound in presence of traits that implement methods it calls internally
|
Affected versions of this crate called some methods using auto-ref. The affected code looked like this.
```rust
let mut arr = $crate::__core::mem::MaybeUninit::uninit();
let mut vec = $crate::__ArrayVec::<T>::new(arr.as_mut_ptr() as *mut T);
```
In this case, the problem is that `as_mut_ptr` is a method of `&mut MaybeUninit`, not `MaybeUninit`. This made it possible for traits to hijack the method calls in order to cause unsoundness.
```rust
trait AsMutPtr<T> {
fn as_mut_ptr(&self) -> *mut T;
}
impl<T> AsMutPtr<T> for std::mem::MaybeUninit<T> {
fn as_mut_ptr(&self) -> *mut T {
std::ptr::null_mut()
}
}
array![0; 1];
```
The flaw was corrected by explicitly referencing variables in macro body in order to avoid auto-ref.
| null |
2022-01-21T17:52:31Z
|
2020-05-07T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0161.html', 'https://crates.io/crates/array-macro', 'https://gitlab.com/KonradBorowski/array-macro/-/commit/01940637dd8f3bfeeee3faf9639fa9ae52f19f4d'}
| null |
crates.io
|
GHSA-w3g5-2848-2v8r
|
Data races in generator
|
The `Generator` type is an iterable which uses a generator function that yields
values. In affected versions of the crate, the provided function yielding values
had no `Send` bounds despite the `Generator` itself implementing `Send`.
The generator function lacking a `Send` bound means that types that are
dangerous to send across threads such as `Rc` could be sent as part of a
generator, potentially leading to data races.
This flaw was fixed in commit [`f7d120a3b`](https://github.com/Xudong-Huang/generator-rs/commit/f7d120a3b724d06a7b623d0a4306acf8f78cb4f0)
by enforcing that the generator function be bound by `Send`.
|
{'CVE-2020-36471'}
|
2021-08-24T18:04:25Z
|
2021-08-25T20:57:05Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/Xudong-Huang/generator-rs/issues/27', 'https://rustsec.org/advisories/RUSTSEC-2020-0151.html', 'https://github.com/Xudong-Huang/generator-rs', 'https://github.com/Xudong-Huang/generator-rs/commit/f7d120a3b724d06a7b623d0a4306acf8f78cb4f0', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36471'}
| null |
crates.io
|
RUSTSEC-2021-0080
|
Links in archive can create arbitrary directories
|
When unpacking a tarball that contains a symlink the `tar` crate may create
directories outside of the directory it's supposed to unpack into.
The function errors when it's trying to create a file, but the folders are
already created at this point.
```rust
use std::{io, io::Result};
use tar::{Archive, Builder, EntryType, Header};
fn main() -> Result<()> {
let mut buf = Vec::new();
{
let mut builder = Builder::new(&mut buf);
// symlink: parent -> ..
let mut header = Header::new_gnu();
header.set_path("symlink")?;
header.set_link_name("..")?;
header.set_entry_type(EntryType::Symlink);
header.set_size(0);
header.set_cksum();
builder.append(&header, io::empty())?;
// file: symlink/exploit/foo/bar
let mut header = Header::new_gnu();
header.set_path("symlink/exploit/foo/bar")?;
header.set_size(0);
header.set_cksum();
builder.append(&header, io::empty())?;
builder.finish()?;
};
Archive::new(&*buf).unpack("demo")
}
```
This has been fixed in https://github.com/alexcrichton/tar-rs/pull/259 and is
published as `tar` 0.4.36. Thanks to Martin Michaelis (@mgjm) for discovering
and reporting this, and Nikhil Benesch (@benesch) for the fix!
|
{'CVE-2021-38511'}
|
2021-10-19T22:14:35Z
|
2021-07-19T12:00:00Z
| null | null | null |
{'https://github.com/alexcrichton/tar-rs/issues/238', 'https://crates.io/crates/tar', 'https://rustsec.org/advisories/RUSTSEC-2021-0080.html'}
| null |
crates.io
|
GHSA-2grh-hm3w-w7hv
|
Race condition in tokio
|
An issue was discovered in the tokio crate before 1.8.1 for Rust. Upon a JoinHandle::abort, a Task may be dropped in the wrong thread.
|
{'CVE-2021-38191'}
|
2021-08-18T21:30:23Z
|
2021-08-25T20:55:51Z
|
MODERATE
| null |
{'CWE-366', 'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0072.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/tokio/RUSTSEC-2021-0072.md', 'https://nvd.nist.gov/vuln/detail/CVE-2021-38191', 'https://github.com/tokio-rs/tokio/issues/3929', 'https://github.com/tokio-rs/tokio'}
| null |
crates.io
|
RUSTSEC-2018-0012
|
Flaw in streaming state reset() functions can create incorrect results.
|
Affected versions of this crate did not properly reset a streaming state.
Resetting a streaming state, without finalising it first, creates incorrect results.
The flaw was corrected by not first checking if the state had already been reset, when calling reset().
|
{'CVE-2018-20999'}
|
2021-10-19T22:14:35Z
|
2018-12-20T12:00:00Z
| null | null | null |
{'https://crates.io/crates/orion', 'https://rustsec.org/advisories/RUSTSEC-2018-0012.html', 'https://github.com/brycx/orion/issues/46'}
| null |
crates.io
|
RUSTSEC-2019-0021
|
`Matrix::zip_elements` causes double free
|
Affected versions of this crate did not properly implements the `Matrix::zip_elements` method, which causes an double free when the given trait implementation might panic.
This allows an attacker to corrupt or take control of the memory.
The flaw was corrected by Phosphorus15.
|
{'CVE-2019-16880'}
|
2021-10-19T22:14:35Z
|
2019-09-14T12:00:00Z
| null | null | null |
{'https://github.com/strake/linea.rs/issues/2', 'https://rustsec.org/advisories/RUSTSEC-2019-0021.html', 'https://crates.io/crates/linea'}
| null |
crates.io
|
GHSA-2gxj-qrp2-53jv
|
Incorrect reliance on Trait memory layout in mopa
|
An issue was discovered in the mopa crate through 2021-06-01 for Rust. It incorrectly relies on Trait memory layout, possibly leading to future occurrences of arbitrary code execution or ASLR bypass.
|
{'CVE-2021-45695'}
|
2022-01-07T18:24:36Z
|
2022-01-06T22:11:11Z
|
CRITICAL
| null | null |
{'https://github.com/chris-morgan/mopa', 'https://rustsec.org/advisories/RUSTSEC-2021-0095.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/mopa/RUSTSEC-2021-0095.md', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45695'}
| null |
crates.io
|
GHSA-pwhf-7427-9vv2
|
Non-atomic writes in cgc
|
An issue was discovered in the cgc crate through 2020-12-10 for Rust. Ptr::write performs non-atomic write operations on an underlying pointer.
|
{'CVE-2020-36468'}
|
2021-08-18T20:39:03Z
|
2021-08-25T20:56:57Z
|
MODERATE
| null |
{'CWE-657'}
|
{'https://github.com/playXE/cgc', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/cgc/RUSTSEC-2020-0148.md', 'https://github.com/playXE/cgc/issues/5', 'https://rustsec.org/advisories/RUSTSEC-2020-0148.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36468'}
| null |
crates.io
|
RUSTSEC-2020-0119
|
ReadTicket and WriteTicket should only be sendable when T is Send
|
Affected versions of this crate unconditionally implemented `Send` for `ReadTicket<T>` & `WriteTicket<T>`.
This allows to send non-Send `T` to other threads.
This can allows creating data races by cloning types with internal mutability and sending them to other threads (as `T` of `ReadTicket<T>`/`WriteTicket<T>`). Such data races can cause memory corruption or other undefined behavior.
The flaw was corrected in commit a986a93 by adding `T: Send` bounds to `Send` impls of `ReadTicket<T>`/`WriteTicket<T>`.
|
{'CVE-2020-36439'}
|
2021-10-19T22:14:35Z
|
2020-11-17T12:00:00Z
| null | null | null |
{'https://crates.io/crates/ticketed_lock', 'https://rustsec.org/advisories/RUSTSEC-2020-0119.html', 'https://github.com/kvark/ticketed_lock/issues/7'}
| null |
crates.io
|
GHSA-mm4m-qg48-f7wc
|
Improper Synchronization and Race Condition in vm-memory
|
rust-vmm vm-memory before 0.1.1 and 0.2.x before 0.2.1 allows attackers to cause a denial of service (loss of IP networking) because read_obj and write_obj do not properly access memory. This affects aarch64 (with musl or glibc) and x86_64 (with musl).
|
{'CVE-2020-13759'}
|
2021-07-26T20:45:48Z
|
2021-08-25T21:01:29Z
|
HIGH
| null |
{'CWE-662', 'CWE-362'}
|
{'https://github.com/rust-vmm/vm-memory/releases/tag/v0.2.1', 'https://nvd.nist.gov/vuln/detail/CVE-2020-13759', 'https://github.com/rust-vmm/vm-memory/releases/tag/v0.1.1', 'https://github.com/rust-vmm/vm-memory/issues/93'}
| null |
crates.io
|
GHSA-jv2r-jx6q-89jg
|
Use of Uninitialized Resource in bronzedb-protocol.
|
An issue was discovered in the bronzedb-protocol crate through 2021-01-03 for Rust. ReadKVExt may read from uninitialized memory locations.
|
{'CVE-2021-45682'}
|
2022-01-07T16:16:57Z
|
2022-01-06T22:16:32Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://github.com/Hexilee/BronzeDB', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45682', 'https://rustsec.org/advisories/RUSTSEC-2021-0084.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/bronzedb-protocol/RUSTSEC-2021-0084.md'}
| null |
crates.io
|
GHSA-566x-hhrf-qf8m
|
Use after free in ordered-float
|
An issue was discovered in the ordered-float crate before 1.1.1 and 2.x before 2.0.1 for Rust. A NotNan value can contain a NaN.
|
{'CVE-2020-35923'}
|
2021-08-19T18:54:34Z
|
2021-08-25T20:50:30Z
|
MODERATE
| null |
{'CWE-416'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0082.html', 'https://github.com/reem/rust-ordered-float', 'https://github.com/reem/rust-ordered-float/pull/71', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35923'}
| null |
crates.io
|
GHSA-29hg-r7c7-54fr
|
Double free in insert_many
|
An issue was discovered in the insert_many crate through 2021-01-26 for Rust. Elements may be dropped twice if a .next() method panics.
|
{'CVE-2021-29933'}
|
2021-08-19T17:05:09Z
|
2021-08-25T20:55:06Z
|
HIGH
| null |
{'CWE-415'}
|
{'https://github.com/rphmeier/insert_many/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0042.html', 'https://github.com/rphmeier/insert_many', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29933'}
| null |
crates.io
|
GHSA-w9r2-qrpm-4rmj
|
Data race in disrustor
|
An issue was discovered in the disrustor crate through 2020-12-17 for Rust. RingBuffer doe not properly limit the number of mutable references.
|
{'CVE-2020-36470'}
|
2021-08-18T20:36:20Z
|
2021-08-25T20:56:59Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36470', 'https://rustsec.org/advisories/RUSTSEC-2020-0150.html', 'https://github.com/sklose/disrustor/issues/1', 'https://github.com/sklose/disrustor'}
| null |
crates.io
|
RUSTSEC-2021-0017
|
`Read` on uninitialized buffer may cause UB (`impl Walue for Vec<u8>`)
|
Affected versions of this crate passes an uninitialized buffer to a user-provided `Read` implementation.
Arbitrary `Read` implementations can read from the uninitialized buffer (memory exposure) and also can return incorrect number of bytes written to the buffer.
Reading from uninitialized memory produces undefined values that can quickly invoke undefined behavior.
This flaw was fixed in commit 8026286 by zero-initializing the buffer before handing to a user-provided `Read`.
|
{'CVE-2021-26953'}
|
2021-10-19T22:14:35Z
|
2021-01-30T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0017.html', 'https://github.com/bodoni/postscript/issues/1', 'https://crates.io/crates/postscript'}
| null |
crates.io
|
GHSA-hxjf-h2mh-r6hj
|
Use After Free in libpulse-binding
|
An issue was discovered in the libpulse-binding crate before 1.2.1 for Rust. get_format_info can cause a use-after-free.
|
{'CVE-2018-25027'}
|
2022-01-06T18:32:15Z
|
2022-01-06T22:20:12Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2018-25027', 'https://github.com/jnqnfe/pulse-binding-rust', 'https://rustsec.org/advisories/RUSTSEC-2018-0021.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/libpulse-binding/RUSTSEC-2018-0021.md'}
| null |
crates.io
|
RUSTSEC-2021-0105
|
Relative Path Traversal in git-delta
|
git-delta before 0.8.3 on Windows resolves an executable's pathname as a relative path from the current directory.
|
{'CVE-2021-36376', 'GHSA-5xg3-j2j6-rcx4'}
|
2021-09-10T16:04:49Z
|
2021-07-12T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0105.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-36376', 'https://crates.io/crates/git-delta'}
| null |
crates.io
|
GHSA-qxjq-v4wf-ppvh
|
Out of bounds read in dync
|
An issue was discovered in the dync crate before 0.5.0 for Rust. VecCopy allows misaligned element access because u8 is not always the type in question.
|
{'CVE-2020-35903'}
|
2021-08-19T20:50:45Z
|
2021-08-25T20:49:47Z
|
MODERATE
| null |
{'CWE-125'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-35903', 'https://rustsec.org/advisories/RUSTSEC-2020-0050.html', 'https://github.com/elrnv/dync', 'https://github.com/elrnv/dync/issues/4'}
| null |
crates.io
|
GHSA-9hfg-pxr6-q4vp
|
Use of a Broken or Risky Cryptographic Algorithm in crypto2
|
An issue was discovered in the crypto2 crate through 2021-10-08 for Rust. During Chacha20 encryption and decryption, an unaligned read of a u32 may occur.
|
{'CVE-2021-45709'}
|
2022-01-07T18:25:56Z
|
2022-01-06T22:04:51Z
|
CRITICAL
| null |
{'CWE-327'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0121.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/crypto2/RUSTSEC-2021-0121.md', 'https://github.com/shadowsocks/crypto2', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45709'}
| null |
crates.io
|
RUSTSEC-2021-0040
|
panic safety: double drop or uninitialized drop of T upon panic
|
Affected versions of this crate did not guard against potential panics that may happen from user-provided functions `T::default()` and `T::drop()`.
Panic within `T::default()` leads to dropping uninitialized `T`, when it is invoked from `common::Slice::<T, H>::new()`.
Panic within `T::drop()` leads to double drop of `T`, when it is invoked either from `common::SliceVec::<T, H>::resize_with()` or `common::SliceVec::<T, H>::resize()`
Either case causes memory corruption in the heap memory.
|
{'CVE-2021-29931', 'CVE-2021-29930'}
|
2021-10-19T22:14:35Z
|
2021-01-12T12:00:00Z
| null | null | null |
{'https://crates.io/crates/arenavec', 'https://github.com/ibabushkin/arenavec/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0040.html'}
| null |
crates.io
|
RUSTSEC-2022-0015
|
pty is unmaintained
|
The repository hasn't received any updates since Jun 25, 2017 and the author is unresponsive.
Maintained alternatives include:
* [`tokio-pty-process`](https://crates.io/crates/tokio-pty-process)
* [`pty-process`](https://crates.io/crates/pty-process)
| null |
2022-03-22T14:52:42Z
|
2022-03-22T12:00:00Z
| null | null | null |
{'https://crates.io/crates/pty', 'https://github.com/hibariya/pty-rs/issues/19', 'https://rustsec.org/advisories/RUSTSEC-2022-0015.html'}
| null |
crates.io
|
GHSA-hrjm-c879-pp86
|
Side-channel timing attack in libsecp256k1
|
An issue was discovered in the libsecp256k1 crate before 0.3.1 for Rust. Scalar::check_overflow allows a timing side-channel attack; consequently, attackers can obtain sensitive information.
|
{'CVE-2019-25003'}
|
2021-08-19T21:19:40Z
|
2021-08-25T20:46:46Z
|
HIGH
| null |
{'CWE-208'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-25003', 'https://rustsec.org/advisories/RUSTSEC-2019-0027.html', 'https://github.com/paritytech/libsecp256k1', 'https://github.com/paritytech/libsecp256k1/commit/11ba23a9766a5079918cd9f515bc100bc8164b50'}
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.