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
|
RUSTSEC-2019-0019
|
HMAC-BLAKE2 algorithms compute incorrect results
|
When used in conjunction with the Hash-based Message Authentication Code (HMAC),
the BLAKE2b and BLAKE2s implementations in `blake2` crate versions prior to
v0.8.1 used an incorrect block size (32-bytes instead of 64-bytes for BLAKE2s,
and 64-bytes instead of 128-bytes for BLAKE2b), causing them to miscompute the
`MacResult`.
The v0.8.1 release of the `blake2` crate uses the correct block sizes.
Note that this advisory only impacts usage of BLAKE2 with HMAC, and does not
impact `Digest` functionality.
|
{'CVE-2019-16143'}
|
2021-10-19T22:14:35Z
|
2019-08-25T12:00:00Z
| null | null | null |
{'https://github.com/RustCrypto/MACs/issues/19', 'https://rustsec.org/advisories/RUSTSEC-2019-0019.html', 'https://crates.io/crates/blake2'}
| null |
crates.io
|
RUSTSEC-2020-0121
|
AtomicBox<T> implements Send/Sync for any `T: Sized`
|
Affected versions of this crate implements `Send`/`Sync` for `AtomicBox<T>` without requiring `T: Send`/`T: Sync`. This allows to create data races to `T: !Sync` and send `T: !Send` to another thread.
Such behavior breaks the compile-time thread safety guarantees of Rust, and allows users to incur undefined behavior using safe Rust (e.g. memory corruption from data race).
The flaw was corrected in commit 34c2b9e by adding trait bound `T: Send` to `Send` impl for `AtomicBox<T>` and trait bound `T: Sync` to `Sync` impl for `AtomicBox<T>`.
|
{'CVE-2020-36441'}
|
2021-10-19T22:14:35Z
|
2020-11-10T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0121.html', 'https://crates.io/crates/abox', 'https://github.com/SonicFrog/abox/issues/1'}
| null |
crates.io
|
RUSTSEC-2021-0097
|
SM2 Decryption Buffer Overflow
|
In order to decrypt SM2 encrypted data an application is expected to call the
API function `EVP_PKEY_decrypt()`. Typically an application will call this
function twice. The first time, on entry, the "out" parameter can be NULL and,
on exit, the "outlen" parameter is populated with the buffer size required to
hold the decrypted plaintext. The application can then allocate a sufficiently
sized buffer and call `EVP_PKEY_decrypt()` again, but this time passing a non-NULL
value for the "out" parameter.
A bug in the implementation of the SM2 decryption code means that the
calculation of the buffer size required to hold the plaintext returned by the
first call to `EVP_PKEY_decrypt()` can be smaller than the actual size required by
the second call. This can lead to a buffer overflow when `EVP_PKEY_decrypt()` is
called by the application a second time with a buffer that is too small.
A malicious attacker who is able present SM2 content for decryption to an
application could cause attacker chosen data to overflow the buffer by up to a
maximum of 62 bytes altering the contents of other data held after the
buffer, possibly changing application behaviour or causing the application to
crash. The location of the buffer is application dependent but is typically
heap allocated.
|
{'CVE-2021-3711'}
|
2021-10-19T22:14:35Z
|
2021-08-24T12:00:00Z
| null | null | null |
{'https://crates.io/crates/openssl-src', 'https://www.openssl.org/news/secadv/20210824.txt', 'https://rustsec.org/advisories/RUSTSEC-2021-0097.html'}
| null |
crates.io
|
RUSTSEC-2021-0078
|
Lenient `hyper` header parsing of `Content-Length` could allow request smuggling
|
`hyper`'s HTTP header parser accepted, according to RFC 7230, illegal contents inside `Content-Length` headers.
Due to this, upstream HTTP proxies that ignore the header may still forward them along if it chooses to ignore the error.
To be vulnerable, `hyper` must be used as an HTTP/1 server and using an HTTP proxy upstream that ignores the header's contents
but still forwards it. Due to all the factors that must line up, an attack exploiting this vulnerability is unlikely.
|
{'CVE-2021-32715', 'GHSA-f3pg-qwvg-p99c'}
|
2021-10-19T22:14:35Z
|
2021-07-07T12:00:00Z
| null | null | null |
{'https://github.com/hyperium/hyper/security/advisories/GHSA-f3pg-qwvg-p99c', 'https://rustsec.org/advisories/RUSTSEC-2021-0078.html', 'https://crates.io/crates/hyper'}
| null |
crates.io
|
RUSTSEC-2018-0005
|
Uncontrolled recursion leads to abort in deserialization
|
Affected versions of this crate did not properly check for recursion
while deserializing aliases.
This allows an attacker to make a YAML file with an alias referring
to itself causing an abort.
The flaw was corrected by checking the recursion depth.
| null |
2020-10-02T01:29:11Z
|
2018-09-17T12:00:00Z
| null | null | null |
{'https://github.com/dtolnay/serde-yaml/pull/105', 'https://crates.io/crates/serde_yaml', 'https://rustsec.org/advisories/RUSTSEC-2018-0005.html'}
| null |
crates.io
|
GHSA-g87r-23vw-7f87
|
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. update_hook has a use-after-free.
|
{'CVE-2021-45719'}
|
2022-01-06T20:20:42Z
|
2022-01-06T22:00:21Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/rusqlite/RUSTSEC-2021-0128.md', 'https://github.com/rusqlite/rusqlite/', 'https://rustsec.org/advisories/RUSTSEC-2021-0128.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45719'}
| null |
crates.io
|
GHSA-f3pg-qwvg-p99c
|
Lenient Parsing of Content-Length Header When Prefixed with Plus Sign
|
### Summary
hyper's HTTP/1 server code had a flaw that incorrectly parses and accepts requests with a `Content-Length` header with a prefixed plus sign, when it should have been rejected as illegal. This combined with an upstream HTTP proxy that doesn't parse such `Content-Length` headers, but forwards them, can result in "request smuggling" or "desync attacks".
### Vulnerability
The flaw exists in all prior versions of hyper, if built with [`rustc` v1.5.0 or newer](https://github.com/rust-lang/rust/pull/28826/commits/123a83326fb95366e94a3be1a74775df4db97739).
Example:
```
GET / HTTP/1.1
Host: example.com
Content-Length: +3
abc
```
This request gets accepted and hyper reads the body as abc. The request _should_ be rejected, according to RFC 7230, since the ABNF for `Content-Length` only allows for `DIGIT`s. This is due to using the `FromStr` implementation for `u64` in the standard library. By differing from the spec, it is possible to send requests like these to endpoints that have different HTTP implementations, with different interpretations of the payload semantics, and cause "desync attacks".
In this particular case, an upstream proxy would need to error when parsing the `Content-Length`, but _not_ reject the request (swallowing its own error), and forwarding the request as-is with the `Content-Length` still included. _Then_ the upstream proxy and hyper would disagree on the length of the request body. The combination of these factors would be extremely rare.
Read more about desync attacks: https://portswigger.net/research/http-desync-attacks-request-smuggling-reborn
### Impact
To determine if vulnerable, all these things must be true:
- **Using hyper as an HTTP server**. While the lenient decoder also exists in the client, a vulnerability does not exist around _responses_.
- **Using HTTP/1**. The HTTP/2 code uses a stricter parser.
- **Using a vulnerable HTTP proxy upstream to hyper**. If an upstream proxy correctly rejects the illegal `Content-Length` header, *OR* can parse the length with the plus sign, the desync attack cannot succeed.
### Patches
We have released the following patch versions:
- v0.14.10 (to be released when this advisor is published)
### Workarounds
Besides upgrading hyper, you can take the following options:
- Reject requests manually that contain a plus sign prefix in the `Content-Length` header.
- Ensure any upstream proxy handles `Content-Length` headers with a plus sign prefix.
### Credits
This issue was initially reported by [Mattias Grenfeldt](https://grenfeldt.dev/) and Asta Olofsson.
|
{'CVE-2021-32715'}
|
2021-09-07T21:49:21Z
|
2021-07-12T16:54:20Z
|
LOW
| null |
{'CWE-444'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-32715', 'https://github.com/rust-lang/rust/pull/28826/commits/123a83326fb95366e94a3be1a74775df4db97739', 'https://rustsec.org/advisories/RUSTSEC-2021-0078.html', 'https://github.com/hyperium/hyper/security/advisories/GHSA-f3pg-qwvg-p99c', 'https://github.com/hyperium/hyper'}
| null |
crates.io
|
RUSTSEC-2020-0033
|
Matrix::new() drops uninitialized memory
|
`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-10-19T22:14:35Z
|
2020-08-25T12:00:00Z
| null | null | null |
{'https://crates.io/crates/alg_ds', 'https://gitlab.com/dvshapkin/alg-ds/-/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2020-0033.html'}
| null |
crates.io
|
GHSA-m833-jv95-mfjh
|
Memory safety violation in crayon
|
An issue was discovered in the crayon crate through 2020-08-31 for Rust. A TOCTOU issue has a resultant memory safety violation via HandleLike.
|
{'CVE-2020-35889'}
|
2021-08-19T20:56:31Z
|
2021-08-25T20:48:50Z
|
HIGH
| null |
{'CWE-367'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0037.html', 'https://github.com/shawnscode/crayon', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35889', 'https://github.com/shawnscode/crayon/issues/87'}
| null |
crates.io
|
GHSA-rmff-f8w9-c9rm
|
Data races in max7301
|
The `ImmediateIO` and `TransactionalIO` types implement `Sync` for all contained
`Expander<EI>` types regardless of if the `Expander` itself is safe to use
across threads.
As the `IO` types allow retrieving the `Expander`, this can lead to non-thread
safe types being sent across threads as part of the `Expander` leading to data
races.
|
{'CVE-2020-36472'}
|
2021-08-18T19:14:45Z
|
2021-08-25T20:59:22Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/edarc/max7301/commit/0a1da873ddb29bca926bad8301f8d7ab8aa97c52', 'https://github.com/edarc/max7301', 'https://rustsec.org/advisories/RUSTSEC-2020-0152.html', 'https://github.com/edarc/max7301/issues/1', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36472'}
| null |
crates.io
|
GHSA-xrg3-hmf3-rvgw
|
Path Traversal in rust-embed
|
An issue was discovered in the rust-embed crate before 6.3.0 for Rust. A ../ directory traversal can sometimes occur in debug mode.
|
{'CVE-2021-45712'}
|
2022-01-07T16:10:23Z
|
2022-01-06T22:03:56Z
|
HIGH
| null |
{'CWE-22'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-45712', 'https://github.com/pyros2097/rust-embed/issues/159', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/rust-embed/RUSTSEC-2021-0126.md', 'https://rustsec.org/advisories/RUSTSEC-2021-0126.html', 'https://github.com/pyros2097/rust-embed'}
| null |
crates.io
|
RUSTSEC-2021-0003
|
Buffer overflow in SmallVec::insert_many
|
A bug in the `SmallVec::insert_many` method caused it to allocate a buffer that was smaller than needed. It then wrote past the end of the buffer, causing a buffer overflow and memory corruption on the heap.
This bug was only triggered if the iterator passed to `insert_many` yielded more items than the lower bound returned from its `size_hint` method.
The flaw was corrected in smallvec 0.6.14 and 1.6.1, by ensuring that additional space is always reserved for each item inserted. The fix also simplified the implementation of `insert_many` to use less unsafe code, so it is easier to verify its correctness.
Thank you to Yechan Bae (@Qwaz) and the Rust group at Georgia Tech’s SSLab for finding and reporting this bug.
|
{'CVE-2021-25900'}
|
2021-10-19T22:14:35Z
|
2021-01-08T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0003.html', 'https://crates.io/crates/smallvec', 'https://github.com/servo/rust-smallvec/issues/252'}
| null |
crates.io
|
GHSA-hpcx-3pw8-g3j2
|
Free of uninitialized memory in telemetry
|
An issue was discovered in the telemetry crate through 0.1.2 for Rust. There is a drop of uninitialized memory if a value.clone() call panics within misc::vec_with_size().
|
{'CVE-2021-29937'}
|
2021-08-19T17:09:26Z
|
2021-08-25T20:54:22Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://github.com/Yoric/telemetry.rs/issues/45', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29937', 'https://github.com/Yoric/telemetry.rs', 'https://github.com/Yoric/telemetry.rs/commit/2820cf12f2e08645fd6d1f15b4a90a54d6082a81', 'https://rustsec.org/advisories/RUSTSEC-2021-0046.html'}
| null |
crates.io
|
RUSTSEC-2019-0035
|
Unaligned memory access
|
Affected versions of this crate violated alignment when casting byte slices to
integer slices, resulting in undefined behavior.
The flaw was corrected by Ralf Jung and Diggory Hardy.
|
{'GHSA-mmc9-pwm7-qj5w', 'CVE-2020-25576'}
|
2021-10-19T22:14:35Z
|
2019-04-19T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0035.html', 'https://github.com/rust-random/rand/blob/master/rand_core/CHANGELOG.md#050---2019-06-06', 'https://crates.io/crates/rand_core'}
| null |
crates.io
|
RUSTSEC-2020-0048
|
Use-after-free in BodyStream due to lack of pinning
|
Affected versions of this crate did not require the buffer wrapped in `BodyStream` 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 trait `MessageBody` require `Unpin`
and making `poll_next()` function accept `Pin<&mut Self>` instead of `&mut self`.
|
{'CVE-2020-35901'}
|
2021-10-19T22:14:35Z
|
2020-01-24T12:00:00Z
| null | null | null |
{'https://github.com/actix/actix-web/issues/1321', 'https://rustsec.org/advisories/RUSTSEC-2020-0048.html', 'https://crates.io/crates/actix-http'}
| null |
crates.io
|
GHSA-g4w7-3qr8-5623
|
Improper type usage in rusqlite
|
An issue was discovered in the rusqlite crate before 0.23.0 for Rust. Memory safety can be violated via the repr(Rust) type.
|
{'CVE-2020-35872'}
|
2021-08-19T21:18:44Z
|
2021-08-25T20:47:01Z
|
CRITICAL
| null |
{'CWE-351'}
|
{'https://github.com/rusqlite/rusqlite/releases/tag/0.23.0', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35872', 'https://rustsec.org/advisories/RUSTSEC-2020-0014.html', 'https://github.com/rusqlite/rusqlite/commit/71b2f5187b0cbace3f8b6ff53432ff2ca0defcf0', 'https://github.com/rusqlite/rusqlite'}
| null |
crates.io
|
GHSA-gf93-h79q-6jjv
|
Incorrect implementation of the Streebog hash functions in streebog
|
An issue was discovered in the streebog crate before 0.8.0 for Rust. The Streebog hash function can produce the wrong answer.
|
{'CVE-2019-25006'}
|
2021-08-19T21:20:49Z
|
2021-08-25T20:45:41Z
|
HIGH
| null |
{'CWE-327'}
|
{'https://github.com/RustCrypto/hashes/pull/91', 'https://nvd.nist.gov/vuln/detail/CVE-2019-25006', 'https://rustsec.org/advisories/RUSTSEC-2019-0030.html', 'https://github.com/RustCrypto/hashes/tree/master/streebog'}
| null |
crates.io
|
RUSTSEC-2021-0054
|
Archives may contain uninitialized memory
|
`rkyv` is a serialization framework that writes struct-compatible memory to be stored or
transmitted. During serialization, struct padding bytes and unused enum bytes may not be
initialized. These bytes may be written to disk or sent over unsecured channels.
|
{'CVE-2021-31919'}
|
2021-10-19T22:14:35Z
|
2021-04-28T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0054.html', 'https://crates.io/crates/rkyv', 'https://github.com/djkoloski/rkyv/issues/113'}
| null |
crates.io
|
RUSTSEC-2022-0001
|
lmdb is unmaintained, use lmdb-rkv instead
|
The lmdb crate hasn't had any updates since August 2018.
Mozilla's [lmdb-rkv](https://github.com/mozilla/lmdb-rs) fork of the crate has received additional maintenance work beyond that and is the best available replacement.
| null |
2022-01-05T16:02:27Z
|
2022-01-05T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2022-0001.html', 'https://crates.io/crates/lmdb', 'https://github.com/danburkert/lmdb-rs'}
| null |
crates.io
|
RUSTSEC-2021-0111
|
Memory Safety Issue when using `patch` or `merge` on `state` and assign the result back to `state`
|
Affected versions of this crate maintains references to memory that might have been freed already.
If affects the following two `tremor-script` language constructs:
* A [Merge](https://www.tremor.rs/docs/tremor-script/index#merge) where we assign the result back to the target expression
and the expression to be merged needs to reference the `event`:
```
let state = merge state of event end;
```
* A [Patch](https://www.tremor.rs/docs/tremor-script/index#patch) where we assign the result back to the target expression
and the patch operations used need to reference the `event`:
```
let state = patch state of insert event.key => event.value end;
```
For constructs like this (it doesnt matter what is references in the expression to be merged or the patch operations) an optimization
was applied to manipulate the target value in-place, instead of cloning it.
Our `Value` struct which underpins all event data in `tremor-script`, is representing as borrowed strings `beef::Cow<'lifetime, str>`
that reference the actual `Vec<u8>` the event is based upon. We keep the raw byte-array next to the event structure inside our `Event` struct as a self-referential struct,
so we make sure that the structured `Value` and its references are valid across its whole lifetime.
The optimization was considered safe as long as it was only possible to merge or patche `event` data or static data.
When `state` was introduced to `tremor-script` a new possibility existed, to keep `Value` data around for longer than the lifetime of an event.
If `event` data is merged or patched into `state` without cloning `state` first, it can still reference keys or values from
the previous event, which will now be invalid. This allows access to those already freed regions of memory and to get their content out over the wire.
## Workaround
If an upgrade is not possible, a possible workaround is to avoid the optimization
by introducing a temporary variable and not immediately reassigning to `state`:
```
let tmp = merge state of event end;
let state = tmp
```
## Fix
The flaw was corrected in `tremor-script` version 0.11.6 via commit [1a2efcd](https://github.com/tremor-rs/tremor-runtime/commit/1a2efcdbe68e5e7fd0a05836ac32d2cde78a0b2e) by removing the optimization
and always clone the target expression of a [Merge](https://www.tremor.rs/docs/tremor-script/index#merge) or [Patch](https://www.tremor.rs/docs/tremor-script/index#patch.
| null |
2021-09-18T18:10:57Z
|
2021-09-16T12:00:00Z
| null | null | null |
{'https://github.com/tremor-rs/tremor-runtime/pull/1217', 'https://rustsec.org/advisories/RUSTSEC-2021-0111.html', 'https://crates.io/crates/tremor-script'}
| null |
crates.io
|
GHSA-8xw8-mmqv-frqq
|
fake-static allows converting any reference into a `'static` reference
|
fake-static allows converting a reference with any lifetime into
a reference with `'static` lifetime without the `unsafe` keyword.
Internally, this crate does not use unsafe code, it instead
exploits a soundness bug in rustc
| null |
2021-08-18T21:41:18Z
|
2021-08-25T20:55:33Z
|
HIGH
| null |
{'CWE-657'}
|
{'https://github.com/NieDzejkob/fake-static', 'https://rustsec.org/advisories/RUSTSEC-2020-0013', 'https://github.com/rust-lang/rust/issues/25860'}
| null |
crates.io
|
RUSTSEC-2022-0017
|
`array!` macro is unsound when its length is impure constant
|
Affected versions of this crate did substitute the array length provided by an user at compile-time multiple times.
When an impure constant expression is passed as an array length (such as a result of an impure procedural macro), this can result in the initialization of an array with uninitialized types, which in turn can allow an attacker to execute arbitrary code.
The flaw was corrected in commit [d5b63f72](https://gitlab.com/KonradBorowski/array-macro/-/commit/d5b63f72090f3809c21ac28f9cfd84f12559bf7d) by making sure that array length is substituted just once.
| null |
2022-04-27T19:05:18Z
|
2022-04-27T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2022-0017.html', 'https://crates.io/crates/array-macro', 'https://gitlab.com/KonradBorowski/array-macro/-/issues/5'}
| null |
crates.io
|
RUSTSEC-2021-0042
|
insert_many can drop elements twice on panic
|
Affected versions of `insert_many` used `ptr::copy` to move over items in a
vector to make space before inserting, duplicating their ownership. It then
iterated over a provided `Iterator` to insert the new items.
If the iterator's `.next()` method panics then the vector would drop the same
elements twice.
|
{'CVE-2021-29933'}
|
2021-10-19T22:14:35Z
|
2021-01-26T12:00:00Z
| null | null | null |
{'https://github.com/rphmeier/insert_many/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0042.html', 'https://crates.io/crates/insert_many'}
| null |
crates.io
|
RUSTSEC-2021-0107
|
Miner fails to get block template when a cell used as a cell dep has been destroyed.
|
## Impact
The RPC get_block_template fails when a cell has been used as a cell dep and an input in the different transactions.
Say cell C is used as a dep group in the transaction A, and is destroyed in the transaction B.
The node adds transaction A first, then B into the transaction pool. They are both valid. But when generating the block template, if the fee rate of B is higher, it comes before A, which will invalidate A. Currently the RPC get_block_template will fail instead of dropping A.
## Patch
First, the get_block_template should not fail but dropping the conflict transactions.
Then we can propose solution to this issue. Here is an example. When a transaction is added to the pool, the pool must consider it depending on all the transactions which dep cell (direct or indirect via dep group) has been destroyed in this transaction. Because future transactions using the destroyed cells as dep will be rejected, the spending transaction only need to wait for all the existing dep transactions on chain.
## Workaround
Submit transaction B when A is already on chain.
Let B depend on A explicitly, there are several solutions:
a. Add any output cell on A as a dep cell or input in B.
b. Merge A and B. CKB allows using the same cell as both dep and input in the same transaction.
Ensure the fee rate of B is less than A so A always has higher priority.
|
{'GHSA-v666-6w97-pcwm'}
|
2021-09-10T15:50:27Z
|
2021-07-25T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0107.html', 'https://github.com/nervosnetwork/ckb/security/advisories/GHSA-v666-6w97-pcwm', 'https://crates.io/crates/ckb'}
| null |
crates.io
|
RUSTSEC-2020-0009
|
`read_scalar` and `read_scalar_at` allow transmuting values without `unsafe` blocks
|
The `read_scalar` and `read_scalar_at` functions are unsound
because they allow transmuting values without `unsafe` blocks.
The following example shows how to create a dangling reference:
```
fn main() {
#[derive(Copy, Clone, PartialEq, Debug)]
struct S(&'static str);
impl flatbuffers::EndianScalar for S {
fn to_little_endian(self) -> Self { self }
fn from_little_endian(self) -> Self { self }
}
println!("{:?}", flatbuffers::read_scalar::<S>(&[1; std::mem::size_of::<S>()]));
}
```
|
{'CVE-2020-35864'}
|
2021-10-19T22:14:35Z
|
2020-04-11T12:00:00Z
| null | null | null |
{'https://crates.io/crates/flatbuffers', 'https://github.com/google/flatbuffers/issues/5825', 'https://rustsec.org/advisories/RUSTSEC-2020-0009.html'}
| null |
crates.io
|
RUSTSEC-2021-0015
|
`Sectors::get` accesses unclaimed/uninitialized memory
|
Affected versions of this crate arbitrarily calls `Vec::set_len` to increase length of a vector without claiming more memory for the vector. Affected versions of this crate
also calls user-provided `Read` on the uninitialized memory of the vector that was
extended with `Vec::set_len`.
This can overwrite active entities in adjacent heap memory and seems to be a major security issue. Also, calling user-provided `Read` on uninitialized memory is defined as UB in Rust.
|
{'CVE-2021-26951'}
|
2021-10-19T22:14:35Z
|
2021-01-06T12:00:00Z
| null | null | null |
{'https://crates.io/crates/calamine', 'https://github.com/tafia/calamine/issues/199', 'https://rustsec.org/advisories/RUSTSEC-2021-0015.html'}
| null |
crates.io
|
GHSA-r43h-gmrm-h5c9
|
Access of Uninitialized Pointer in linked-hash-map
|
An issue was discovered in the linked-hash-map crate before 0.5.3 for Rust. It creates an uninitialized NonNull pointer, which violates a non-null constraint.
|
{'CVE-2020-25573'}
|
2021-08-19T21:21:41Z
|
2021-08-25T20:45:09Z
|
CRITICAL
| null |
{'CWE-824'}
|
{'https://github.com/contain-rs/linked-hash-map', 'https://nvd.nist.gov/vuln/detail/CVE-2020-25573', 'https://rustsec.org/advisories/RUSTSEC-2020-0026.html', 'https://github.com/contain-rs/linked-hash-map/pull/100'}
| null |
crates.io
|
GHSA-cw98-cx2m-9qqg
|
Denial of Service in ckb
|
An issue was discovered in the ckb crate before 0.40.0 for Rust. Attackers can cause a denial of service (Nervos CKB blockchain node crash) via a dead call that is used as a DepGroup.
|
{'CVE-2021-45700'}
|
2022-01-07T17:53:19Z
|
2022-01-06T22:10:08Z
|
HIGH
| null |
{'CWE-400'}
|
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/ckb/RUSTSEC-2021-0109.md', 'https://github.com/nervosnetwork/ckb', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45700', 'https://rustsec.org/advisories/RUSTSEC-2021-0109.html'}
| null |
crates.io
|
GHSA-37jj-wp7g-7wj4
|
Read of uninitialized memory in cdr
|
An issue was discovered in Deserializer::read_vec in the cdr crate before 0.2.4 for Rust. A user-provided Read implementation can gain access to the old contents of newly allocated heap memory, violating soundness.
|
{'CVE-2021-26305'}
|
2021-08-19T17:53:09Z
|
2021-08-25T20:53:12Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0012.html', 'https://github.com/hrektts/cdr-rs', 'https://nvd.nist.gov/vuln/detail/CVE-2021-26305', 'https://github.com/hrektts/cdr-rs/issues/10'}
| null |
crates.io
|
RUSTSEC-2019-0023
|
Cloned interners may read already dropped strings
|
Affected versions of this crate did not clone contained strings when an interner is cloned.
Interners have raw pointers to the contained strings, and they keep pointing the strings which the old interner owns, after the interner is cloned.
If a new cloned interner is alive and the old original interner is dead, the new interner has dangling pointers to the old interner's storage, which is already dropped.
This allows an attacker to read the already freed memory.
The dangling pointers are used by the interners to check a string is already interned.
An attacker can do brute force attack to get the data pointed by the dangling pointer.
The flaw was corrected by <https://github.com/Robbepop/string-interner/pull/10>.
This patch implements `Clone` manually to the interner type, so that the internal raw pointers always point the strings owned by the same interner.
PR #10 was also backported to the 0.6 release line in
<https://github.com/Robbepop/string-interner/pull/14> and was released in 0.6.4.
|
{'CVE-2019-16882'}
|
2021-10-19T22:14:35Z
|
2019-08-24T12:00:00Z
| null | null | null |
{'https://crates.io/crates/string-interner', 'https://github.com/Robbepop/string-interner/issues/9', 'https://rustsec.org/advisories/RUSTSEC-2019-0023.html'}
| null |
crates.io
|
GHSA-83mx-573x-5rw9
|
Null pointer deference in openssl-src
|
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. All OpenSSL 1.1.1 versions are affected by this issue. Users of these versions should upgrade to OpenSSL 1.1.1k. OpenSSL 1.0.2 is not impacted by this issue. Fixed in OpenSSL 1.1.1k (Affected 1.1.1-1.1.1j).
|
{'CVE-2021-3449'}
|
2021-08-19T17:21:40Z
|
2021-08-25T20:54:02Z
|
MODERATE
| null |
{'CWE-476'}
|
{'https://cert-portal.siemens.com/productcert/pdf/ssa-389290.pdf', 'https://lists.debian.org/debian-lts-announce/2021/08/msg00029.html', 'https://www.tenable.com/security/tns-2021-09', 'https://www.oracle.com/security-alerts/cpuoct2021.html', 'https://www.oracle.com//security-alerts/cpujul2021.html', 'https://security.netapp.com/advisory/ntap-20210326-0006/', 'https://tools.cisco.com/security/center/content/CiscoSecurityAdvisory/cisco-sa-openssl-2021-GHY28dJd', 'https://cert-portal.siemens.com/productcert/pdf/ssa-772220.pdf', 'https://www.tenable.com/security/tns-2021-10', 'https://security.netapp.com/advisory/ntap-20210513-0002/', 'https://git.openssl.org/gitweb/?p=openssl.git;a=commitdiff;h=fb9fa6b51defd48157eeb207f52181f735d96148', 'https://kc.mcafee.com/corporate/index?page=content&id=SB10356', 'https://www.tenable.com/security/tns-2021-05', 'https://www.oracle.com/security-alerts/cpuApr2021.html', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/CCBFLLVQVILIVGZMBJL3IXZGKWQISYNP/', 'http://www.openwall.com/lists/oss-security/2021/03/27/2', 'https://github.com/alexcrichton/openssl-src-rs', 'http://www.openwall.com/lists/oss-security/2021/03/27/1', 'https://www.oracle.com/security-alerts/cpuapr2022.html', 'http://www.openwall.com/lists/oss-security/2021/03/28/3', 'https://www.debian.org/security/2021/dsa-4875', 'https://kb.pulsesecure.net/articles/Pulse_Security_Advisories/SA44845', 'https://rustsec.org/advisories/RUSTSEC-2021-0055', 'http://www.openwall.com/lists/oss-security/2021/03/28/4', 'https://psirt.global.sonicwall.com/vuln-detail/SNWLID-2021-0013', 'https://www.openssl.org/news/secadv/20210325.txt', 'https://www.tenable.com/security/tns-2021-06', 'https://security.FreeBSD.org/advisories/FreeBSD-SA-21:07.openssl.asc', 'https://security.gentoo.org/glsa/202103-03', 'https://nvd.nist.gov/vuln/detail/CVE-2021-3449'}
| null |
crates.io
|
RUSTSEC-2020-0029
|
Allows viewing and modifying arbitrary structs as bytes
|
Affected versions of rgb crate allow viewing and modifying data of any type `T` wrapped in `RGB<T>` as bytes,
and do not correctly constrain `RGB<T>` and other wrapper structures to the types for which it is safe to do so.
Safety violation possible for a type wrapped in `RGB<T>` and similar wrapper structures:
* If `T` contains padding, viewing it as bytes may lead to exposure of contents of uninitialized memory.
* If `T` contains a pointer, modifying it as bytes may lead to dereferencing of arbitrary pointers.
* Any safety and/or validity invariants for `T` may be violated.
The issue was resolved by requiring all types wrapped in structures provided by RGB crate to implement an unsafe marker trait.
|
{'CVE-2020-25016'}
|
2021-10-19T22:14:35Z
|
2020-06-14T12:00:00Z
| null | null | null |
{'https://crates.io/crates/rgb', 'https://rustsec.org/advisories/RUSTSEC-2020-0029.html', 'https://github.com/kornelski/rust-rgb/issues/35'}
| null |
crates.io
|
GHSA-6gvc-4jvj-pwq4
|
Use after free in libpulse-binding
|
An issue was discovered in the libpulse-binding crate before 2.5.0 for Rust. proplist::Iterator can cause a use-after-free.
|
{'CVE-2018-25001'}
|
2021-09-27T15:46:50Z
|
2021-08-30T16:22:34Z
|
MODERATE
| null |
{'CWE-416'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2018-25001', 'https://github.com/jnqnfe/pulse-binding-rust', 'https://rustsec.org/advisories/RUSTSEC-2018-0020.html'}
| null |
crates.io
|
GHSA-v4cp-h94r-m7xf
|
Use after free passing `externref`s to Wasm in Wasmtime
|
### Impact
There was a use-after-free bug when passing `externref`s from the host to guest Wasm content.
To trigger the bug, you have to explicitly pass multiple `externref`s from the host to a Wasm instance at the same time, either by
* passing multiple `externref`s as arguments from host code to a Wasm function,
* or returning multiple `externref`s to Wasm from a multi-value return function defined in the host.
If you do not have host code that matches one of these shapes, then you are not impacted.
If Wasmtime's [`VMExternRefActivationsTable`](https://github.com/bytecodealliance/wasmtime/blob/37c094faf53f1b356aab3c79d451395e4f7edb34/crates/runtime/src/externref.rs#L493) became filled to capacity after passing the first `externref` in, then passing in the second `externref` could trigger a garbage collection. However the first `externref` is not rooted until we pass control to Wasm, and therefore could be reclaimed by the collector if nothing else was holding a reference to it or otherwise keeping it alive. Then, when control was passed to Wasm after the garbage collection, Wasm could use the first `externref`, which at this point has already been freed.
We have reason to believe that the effective impact of this bug is relatively small because usage of `externref` is currently quite rare.
### Patches
The bug has been fixed, and users should upgrade to Wasmtime 0.30.0.
Additionally, we have updated [our primary `externref` fuzz target](https://github.com/bytecodealliance/wasmtime/blob/37c094faf53f1b356aab3c79d451395e4f7edb34/fuzz/fuzz_targets/table_ops.rs) such that it better exercises these code paths and we can have greater confidence in their correctness going forward.
### Workarounds
If you cannot upgrade Wasmtime yet, you can avoid the bug by disabling reference types support in Wasmtime by passing `false` to [`wasmtime::Config::wasm_reference_types`](https://docs.rs/wasmtime/0.29.0/wasmtime/struct.Config.html#method.wasm_reference_types).
### References
* [The reference types Wasm proposal, which introduces `externref`](https://github.com/WebAssembly/reference-types/)
### For more information
If you have any questions or comments about this advisory:
* Reach out to us on [the Bytecode Alliance Zulip chat](https://bytecodealliance.zulipchat.com/#narrow/stream/217126-wasmtime)
* Open an issue in [the `bytecodealliance/wasmtime` repository](https://github.com/bytecodealliance/wasmtime/)
|
{'CVE-2021-39216'}
|
2021-09-17T20:05:21Z
|
2021-09-20T19:54:05Z
|
MODERATE
| null |
{'CWE-416'}
|
{'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/WAVBRYDDUIY2ZR3K3FO4BVYJKIMJ5TP7/', 'https://github.com/bytecodealliance/wasmtime/commit/101998733b74624cbd348a2366d05760b40181f3', 'https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-v4cp-h94r-m7xf', 'https://github.com/bytecodealliance/wasmtime', 'https://crates.io/crates/wasmtime', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/Z2Z33FTXFQ6EOINVEQIP4DFBG53G5XIY/', 'https://nvd.nist.gov/vuln/detail/CVE-2021-39216'}
| null |
crates.io
|
RUSTSEC-2021-0127
|
serde_cbor is unmaintained
|
The `serde_cbor` crate is unmaintained. The author has archived the github repository.
Alternatives proposed by the author:
* [`ciborium`](https://crates.io/crates/ciborium)
* [`minicbor`](https://crates.io/crates/minicbor)
| null |
2021-12-01T14:04:55Z
|
2021-08-15T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0127.html', 'https://crates.io/crates/serde_cbor', 'https://github.com/pyfisch/cbor'}
| null |
crates.io
|
GHSA-7cqg-8449-rmfv
|
Observable Discrepancy in libsecp256k1-rs
|
A timing vulnerability in the Scalar::check_overflow function in Parity libsecp256k1-rs before 0.3.1 potentially allows an attacker to leak information via a side-channel attack.
|
{'CVE-2019-20399'}
|
2021-07-27T15:21:02Z
|
2021-08-25T21:01:27Z
|
MODERATE
| null |
{'CWE-203', 'CWE-362'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-20399', 'https://github.com/paritytech/libsecp256k1/commit/11ba23a9766a5079918cd9f515bc100bc8164b50'}
| null |
crates.io
|
RUSTSEC-2021-0062
|
project abandoned; migrate to the `aes-siv` crate
|
The Miscreant project has been abandoned and archived.
The Rust implementation has been adapted into the new `aes-siv` crate which
implements both the AES-CMAC-SIV and AES-PMAC-SIV constructions:
<https://github.com/RustCrypto/AEADs/tree/master/aes-siv>
Please migrate to the `aes-siv` crate.
Alternatively see the `aes-gcm-siv` crate for a newer, faster construction
which provides similar properties:
<https://github.com/RustCrypto/AEADs/tree/master/aes-gcm-siv>
| null |
2021-05-03T19:05:09Z
|
2021-02-28T12:00:00Z
| null | null | null |
{'https://github.com/miscreant/miscreant.rs/commit/5d921f579e0c2b9960d472cf377b8487d97fbcec', 'https://rustsec.org/advisories/RUSTSEC-2021-0062.html', 'https://crates.io/crates/miscreant'}
| null |
crates.io
|
GHSA-wp34-mqw5-jj85
|
Use after free in nano_arena
|
An issue was discovered in the nano_arena crate before 0.5.2 for Rust. There is an aliasing violation in split_at because two mutable references can exist for the same element, if Borrow<Idx> behaves in certain ways. This can have a resultant out-of-bounds write or use-after-free.
|
{'CVE-2021-28032'}
|
2021-08-19T17:23:52Z
|
2021-08-25T20:52:00Z
|
CRITICAL
| null |
{'CWE-416'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0031.html', 'https://github.com/bennetthardwick/nano-arena/issues/1', 'https://github.com/bennetthardwick/nano-arena', 'https://nvd.nist.gov/vuln/detail/CVE-2021-28032'}
| null |
crates.io
|
RUSTSEC-2019-0003
|
Out of Memory in stream::read_raw_bytes_into()
|
Affected versions of this crate called Vec::reserve() on user-supplied input.
This allows an attacker to cause an Out of Memory condition while calling the
vulnerable method on untrusted data.
|
{'CVE-2019-15544'}
|
2021-10-19T22:14:35Z
|
2019-06-08T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0003.html', 'https://crates.io/crates/protobuf', 'https://github.com/stepancheg/rust-protobuf/issues/411'}
| null |
crates.io
|
RUSTSEC-2020-0091
|
Dangling reference in `access::Map` with Constant
|
Using the `arc_swap::access::Map` with the `Constant` test helper (or with
user-provided implementation of the `Access` trait) could sometimes lead to the
map returning dangling references.
Replaced by implementation without `unsafe`, at the cost of added `Clone` bound
on the closure and small penalty on performance.
|
{'CVE-2020-35711'}
|
2021-10-19T22:14:35Z
|
2020-12-10T12:00:00Z
| null | null | null |
{'https://crates.io/crates/arc-swap', 'https://github.com/vorner/arc-swap/issues/45', 'https://rustsec.org/advisories/RUSTSEC-2020-0091.html'}
| null |
crates.io
|
GHSA-jqpv-jm4m-86j9
|
Use After Free in libpulse-binding
|
An issue was discovered in the libpulse-binding crate before 1.2.1 for Rust. get_context can cause a use-after-free.
|
{'CVE-2018-25028'}
|
2022-01-06T18:29:31Z
|
2022-01-06T22:17:50Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://rustsec.org/advisories/RUSTSEC-2018-0021.html', 'https://github.com/jnqnfe/pulse-binding-rust', 'https://nvd.nist.gov/vuln/detail/CVE-2018-25028', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/libpulse-binding/RUSTSEC-2018-0021.md'}
| null |
crates.io
|
GHSA-qpgv-g792-wh6x
|
Uncontrolled Resource Consumption in parse_duration
|
An issue was discovered in the parse_duration crate through 2021-03-18 for Rust. It allows attackers to cause a denial of service (CPU and memory consumption) via a duration string with a large exponent.
|
{'CVE-2021-29932'}
|
2021-08-19T17:21:25Z
|
2021-08-25T20:54:04Z
|
HIGH
| null |
{'CWE-400'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0041.html', 'https://github.com/zeta12ti/parse_duration/issues/21', 'https://github.com/zeta12ti/parse_duration', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29932'}
| null |
crates.io
|
GHSA-66p5-j55p-32r9
|
smallvec creates uninitialized value of any type
|
Affected versions of this crate called `mem::uninitialized()` to create values of a user-supplied type `T`.
This is unsound e.g. if `T` is a reference type (which must be non-null and thus may not remain uninitialized).
The flaw was corrected by avoiding the use of `mem::uninitialized()`, using `MaybeUninit` instead.
| null |
2021-08-06T16:36:54Z
|
2021-08-25T21:00:25Z
|
MODERATE
| null |
{'CWE-457'}
|
{'https://rustsec.org/advisories/RUSTSEC-2018-0018.html', 'https://github.com/servo/rust-smallvec/pull/162', 'https://github.com/servo/rust-smallvec', 'https://github.com/servo/rust-smallvec/issues/126'}
| null |
crates.io
|
RUSTSEC-2021-0035
|
`quinn` invalidly assumes the memory layout of std::net::SocketAddr
|
The [`quinn`](https://crates.io/crates/quinn) crate has assumed `std::net::SocketAddrV4`
and `std::net::SocketAddrV6` have the same memory layout as the system C representation
`sockaddr`. It has simply casted the pointers to convert the socket addresses to the
system representation. The standard library does not say anything about the memory
layout, and this will cause invalid memory access if the standard library
changes the implementation. No warnings or errors will be emitted once the
change happens.
|
{'CVE-2021-28036'}
|
2021-10-19T22:14:35Z
|
2021-03-04T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0035.html', 'https://github.com/quinn-rs/quinn/issues/968', 'https://crates.io/crates/quinn'}
| null |
crates.io
|
RUSTSEC-2019-0015
|
Flaw in generativity allows out-of-bounds access
|
Affected versions of this crate did not properly implement the generativity,
because the invariant lifetimes were not necessarily `drop`ped.
This allows an attacker to mix up two arenas, using indices created from one
arena with another one. This might lead to an out-of-bounds read or write
access into the memory reserved for the arena.
The flaw was corrected by implementing generativity correctly in version 0.4.0.
|
{'CVE-2019-16139'}
|
2021-10-19T22:14:35Z
|
2019-05-21T12:00:00Z
| null | null | null |
{'https://crates.io/crates/compact_arena', 'https://rustsec.org/advisories/RUSTSEC-2019-0015.html', 'https://github.com/llogiq/compact_arena/issues/22'}
| null |
crates.io
|
RUSTSEC-2020-0068
|
Unexpected panic in multihash `from_slice` parsing code
|
In versions prior 0.11.3 it's possible to make `from_slice` panic by feeding it certain malformed input.
It's never documented that `from_slice` (and `from_bytes` which wraps it) can panic, and its' return type (`Result<Self, DecodeError>`) suggests otherwise.
In practice, `from_slice`/`from_bytes` is frequently used in networking code (for example [in rust-libp2p](https://github.com/libp2p/rust-libp2p/blob/7b415d5e7040e45c541f76f2c409e63d4d3249c6/core/src/peer_id.rs#L89)) and is being called with unsanitized data from untrusted sources.
This can allow attackers to cause DoS by causing an unexpected `panic` in the network client's code.
|
{'CVE-2020-35909'}
|
2021-10-19T22:14:35Z
|
2020-11-08T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0068.html', 'https://crates.io/crates/multihash', 'https://github.com/multiformats/rust-multihash/pull/72'}
| null |
crates.io
|
RUSTSEC-2020-0087
|
TryMutex<T> allows sending non-Send type across threads
|
Affected versions of this crate unconditionally implemented Sync trait for `TryMutex<T>` type.
This allows users to put non-Send `T` type in `TryMutex` and send it to another thread, which can cause a data race.
The flaw was corrected in the 0.3.0 release by adding `T: Send` bound for the Sync trait implementation.
|
{'CVE-2020-35924'}
|
2021-10-19T22:14:35Z
|
2020-11-17T12:00:00Z
| null | null | null |
{'https://crates.io/crates/try-mutex', 'https://github.com/mpdn/try-mutex/issues/2', 'https://rustsec.org/advisories/RUSTSEC-2020-0087.html'}
| null |
crates.io
|
GHSA-4x25-pvhw-5224
|
Algorithms compute incorrect results in blake2
|
An issue was discovered in the blake2 crate before 0.8.1 for Rust. The BLAKE2b and BLAKE2s algorithms, when used with HMAC, produce incorrect results because the block sizes are half of the required sizes.
|
{'CVE-2019-16143'}
|
2021-08-19T21:22:54Z
|
2021-08-25T20:44:20Z
|
HIGH
| null |
{'CWE-327'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-16143', 'https://github.com/RustCrypto/MACs/issues/19', 'https://rustsec.org/advisories/RUSTSEC-2019-0019.html', 'https://github.com/RustCrypto/hashes/tree/master/blake2'}
| null |
crates.io
|
GHSA-wxjf-9f4g-3v44
|
Data races in noise_search
|
Affected versions of the `noise_search` crate unconditionally implement Send/Sync for `MvccRwLock`.
This can lead to data races when types that are either `!Send` or `!Sync` (e.g. `Rc<T>`, `Arc<Cell<_>>`) are contained inside `MvccRwLock` and sent across thread boundaries. The data races can potentially lead to memory corruption (as demonstrated in the PoC from the original report issue).
Also, safe APIs of `MvccRwLock` allow aliasing violations by allowing `&T` and `LockResult<MutexGuard<Box<T>>>` to co-exist in conflicting lifetime regions. The APIs of `MvccRwLock` should either be marked as `unsafe` or `MbccRwLock` should be changed to private or pub(crate).
|
{'CVE-2020-36461'}
|
2021-08-24T18:02:25Z
|
2021-08-25T20:56:05Z
|
MODERATE
| null |
{'CWE-77', 'CWE-362'}
|
{'https://github.com/pipedown/noise/issues/72', 'https://rustsec.org/advisories/RUSTSEC-2020-0141.html', 'https://github.com/pipedown/noise', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36461'}
| null |
crates.io
|
GHSA-r57r-j98g-587f
|
Pointer dereference in nanorand
|
An issue was discovered in the nanorand crate before 0.6.1 for Rust. There can be multiple mutable references to the same object because the TlsWyRand Deref implementation dereferences a raw pointer.
|
{'CVE-2021-45705'}
|
2022-01-07T18:29:44Z
|
2022-01-06T22:08:56Z
|
CRITICAL
| null | null |
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/nanorand/RUSTSEC-2021-0114.md', 'https://github.com/Absolucy/nanorand-rs/issues/28', 'https://github.com/Absolucy/nanorand-rs', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45705', 'https://rustsec.org/advisories/RUSTSEC-2021-0114.html'}
| null |
crates.io
|
RUSTSEC-2021-0023
|
Incorrect check on buffer length when seeding RNGs
|
Summary: rand_core::le::read_u32_into and read_u64_into have incorrect checks on the source buffer length, allowing the destination buffer to be under-filled.
Implications: some downstream RNGs, including Hc128Rng (but not the more widely used ChaCha*Rng), allow seeding using the SeedableRng::from_seed trait-function with too short keys.
|
{'CVE-2021-27378'}
|
2021-10-19T22:14:35Z
|
2021-02-12T12:00:00Z
| null | null | null |
{'https://github.com/rust-random/rand/pull/1096', 'https://rustsec.org/advisories/RUSTSEC-2021-0023.html', 'https://crates.io/crates/rand_core'}
| null |
crates.io
|
GHSA-j35p-q24r-5367
|
Dep Group Remote Memory Exhaustion (Denial of Service) in ckb
|
### Impact
A remote attacker could exploit this vulnerability to exhaust ckb process memory of an affected node.
### Patches
Upgrade to 0.43.1 or later.
### References
After resolving the outpoints of one dep group, we put the corresponding content into a vec ( https://github.com/nervosnetwork/ckb/blob/v0.42.0/util/types/src/core/cell.rs#L600-L617 ), there is a vulnerability to a memory dos attack because there is no determination of whether the outpoints is duplicated.
PoC:
```
before send dos tx rss:
105700
after rss:
2306932
```
DoS cost: 25.6 KB * 150 + dep_tx out_points capacity ( 36 * 150 * 100 = 540000 ) = 4380000 CKB
Send 50 dos_tx, memory exhausted: (25.6 KB * 150 * 100) * 50 = 19.2 GB
| null |
2022-04-22T20:23:04Z
|
2022-04-22T20:23:04Z
|
HIGH
| null | null |
{'https://github.com/nervosnetwork/ckb/blob/v0.42.0/util/types/src/core/cell.rs#L600-L617', 'https://github.com/nervosnetwork/ckb', 'https://github.com/nervosnetwork/ckb/security/advisories/GHSA-j35p-q24r-5367'}
| null |
crates.io
|
RUSTSEC-2021-0131
|
Integer overflow in the bundled Brotli C library
|
A buffer overflow exists in the Brotli library versions prior to 1.0.8 where an attacker controlling the input length of a "one-shot" decompression request to a script can trigger a crash, which happens when copying over chunks of data larger than 2 GiB.
An updated version of `brotli-sys` has not been released. If one cannot update the C library, its authors recommend to use the "streaming" API as opposed to the "one-shot" API, and impose chunk size limits.
In Rust the issue can be mitigated by migrating to the `brotli` crate, which provides a Rust implementation of Brotli compression and decompression that is not affected by this issue.
|
{'CVE-2020-8927'}
|
2021-12-21T20:51:30Z
|
2021-12-20T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0131.html', 'https://github.com/bitemyapp/brotli2-rs/issues/45', 'https://github.com/google/brotli/releases/tag/v1.0.9', 'https://crates.io/crates/brotli-sys'}
| null |
crates.io
|
GHSA-773q-5334-5gf9
|
Memory over-allocation in evm-core
|
Prior to the patch, when executing specific EVM opcodes related
to memory operations that use `evm_core::Memory::copy_large`, the
crate can over-allocate memory when it is not needed, making it
possible for an attacker to perform denial-of-service attack.
The flaw was corrected in commit `19ade85`.
| null |
2021-08-18T21:38:27Z
|
2021-08-25T20:55:36Z
|
MODERATE
| null |
{'CWE-789'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0066.html', 'https://github.com/rust-blockchain/evm/commit/19ade85', 'https://github.com/rust-blockchain/evm'}
| null |
crates.io
|
RUSTSEC-2018-0009
|
MsQueue and SegQueue suffer from double-free
|
Even if an element is popped from a queue, crossbeam would run its
destructor inside the epoch-based garbage collector. This is a source
of double frees.
The flaw was corrected by wrapping elements inside queues in a
`ManuallyDrop`.
Thanks to @c0gent for reporting the issue.
|
{'CVE-2018-20996'}
|
2021-10-19T22:14:35Z
|
2018-12-09T12:00:00Z
| null | null | null |
{'https://crates.io/crates/crossbeam', 'https://rustsec.org/advisories/RUSTSEC-2018-0009.html', 'https://github.com/crossbeam-rs/crossbeam-epoch/issues/82'}
| null |
crates.io
|
RUSTSEC-2021-0074
|
Incorrect handling of embedded SVG and MathML leads to mutation XSS
|
Affected versions of this crate did not account for namespace-related parsing
differences between HTML, SVG, and MathML. Even if the `svg` and `math` elements
are not allowed, the underlying HTML parser still treats them differently.
Running cleanup without accounting for these differing namespaces resulted in an "impossible"
DOM, which appeared "safe" when examining the DOM tree, but when serialized and deserialized,
could be exploited to inject abitrary markup.
To exploit this, the application using this library must allow a tag that is parsed as raw text in HTML.
These [elements] are:
* title
* textarea
* xmp
* iframe
* noembed
* noframes
* plaintext
* noscript
* style
* script
Applications that do not explicitly allow any of these tags should not be affected, since none are allowed by default.
[elements]: https://github.com/servo/html5ever/blob/57eb334c0ffccc6f88d563419f0fbeef6ff5741c/html5ever/src/tree_builder/rules.rs
|
{'CVE-2021-38193'}
|
2021-11-06T20:37:35Z
|
2021-07-08T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0074.html', 'https://crates.io/crates/ammonia', 'https://github.com/rust-ammonia/ammonia/pull/142'}
| null |
crates.io
|
RUSTSEC-2020-0101
|
conquer-once's OnceCell lacks Send bound for its Sync trait.
|
Affected versions of `conquer-once` implements `Sync` for its `OnceCell` type
without restricting it to `Send`able types.
This allows non-`Send` but `Sync` types such as `MutexGuard` to be sent across
threads leading to undefined behavior and memory corruption in concurrent
programs.
The issue was fixed by adding a `Send` constraint to `OnceCell`.
|
{'CVE-2020-36208'}
|
2021-10-19T22:14:35Z
|
2020-12-22T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0101.html', 'https://crates.io/crates/conquer-once', 'https://github.com/oliver-giersch/conquer-once/issues/3'}
| null |
crates.io
|
RUSTSEC-2020-0044
|
Unsafe Send implementation in Atom allows data races
|
The `atom` crate contains a security issue revolving around its implementation
of the Send trait. It incorrectly allows any arbitrary type to be sent across
threads potentially leading to use-after-free issues through memory races.
|
{'CVE-2020-35897'}
|
2021-10-19T22:14:35Z
|
2020-09-21T12:00:00Z
| null | null | null |
{'https://crates.io/crates/atom', 'https://github.com/slide-rs/atom/issues/13', 'https://rustsec.org/advisories/RUSTSEC-2020-0044.html'}
| null |
crates.io
|
GHSA-79wf-qcqv-r22r
|
Remote code execution in better-macro
|
An issue was discovered in the better-macro crate through 2021-07-22 for Rust. It intentionally demonstrates that remote attackers can execute arbitrary code via proc-macros, and otherwise has no legitimate purpose.
|
{'CVE-2021-38196'}
|
2021-08-18T21:21:03Z
|
2021-08-25T20:56:00Z
|
HIGH
| null |
{'CWE-94', 'CWE-78'}
|
{'https://github.com/raycar5/better-macro', 'https://nvd.nist.gov/vuln/detail/CVE-2021-38196', 'https://github.com/raycar5/better-macro/blob/24ff1702397b9c19bbfa4c660e2316cd77d3b900/src/lib.rs#L36-L38', 'https://rustsec.org/advisories/RUSTSEC-2021-0077.html'}
| null |
crates.io
|
GHSA-xr7r-88qv-q7hm
|
Out of bounds write in serde_cbor
|
An issue was discovered in the serde_cbor crate before 0.10.2 for Rust. The CBOR deserializer can cause stack consumption via nested semantic tags.
|
{'CVE-2019-25001'}
|
2021-08-19T21:20:43Z
|
2021-08-25T20:45:51Z
|
HIGH
| null |
{'CWE-787'}
|
{'https://rustsec.org/advisories/RUSTSEC-2019-0025.html', 'https://github.com/pyfisch/cbor/releases/tag/v0.10.2', 'https://github.com/pyfisch/cbor', 'https://nvd.nist.gov/vuln/detail/CVE-2019-25001'}
| null |
crates.io
|
RUSTSEC-2020-0156
|
Observable Discrepancy in libsecp256k1-rs
|
A timing vulnerability in the Scalar::check_overflow function in Parity libsecp256k1-rs before 0.3.1 potentially allows an attacker to leak information via a side-channel attack.
|
{'CVE-2019-20399', 'GHSA-7cqg-8449-rmfv'}
|
2021-09-10T16:03:52Z
|
2020-01-22T12:00:00Z
| null | null | null |
{'https://nvd.nist.gov/vuln/detail/CVE-2019-20399', 'https://rustsec.org/advisories/RUSTSEC-2020-0156.html', 'https://crates.io/crates/libsecp256k1-rs'}
| null |
crates.io
|
GHSA-3vjm-36rr-7qrq
|
NULL Pointer Dereference in cbox
|
An issue was discovered in the cbox crate through 2020-03-19 for Rust. The CBox API allows dereferencing raw pointers without a requirement for unsafe code.
|
{'CVE-2020-35860'}
|
2021-08-19T21:18:36Z
|
2021-08-25T20:47:16Z
|
CRITICAL
| null |
{'CWE-476'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0005.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35860', 'https://github.com/TomBebbington/cbox-rs/issues/2', 'https://github.com/TomBebbington/cbox-rs'}
| null |
crates.io
|
RUSTSEC-2020-0013
|
fake-static allows converting any reference into a `'static` reference
|
fake-static allows converting a reference with any lifetime into
a reference with `'static` lifetime without the `unsafe` keyword.
Internally, this crate does not use unsafe code, it instead
exploits a soundness bug in rustc:
https://github.com/rust-lang/rust/issues/25860
| null |
2021-01-14T17:57:27Z
|
2020-04-24T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0013.html', 'https://crates.io/crates/fake-static'}
| null |
crates.io
|
RUSTSEC-2021-0058
|
Null pointer deref in `X509_issuer_and_serial_hash()`
|
The OpenSSL public API function `X509_issuer_and_serial_hash()` attempts to
create a unique hash value based on the issuer and serial number data contained
within an X509 certificate. However it fails to correctly handle any errors
that may occur while parsing the issuer field (which might occur if the issuer
field is maliciously constructed). This may subsequently result in a NULL
pointer deref and a crash leading to a potential denial of service attack.
The function `X509_issuer_and_serial_hash()` is never directly called by OpenSSL
itself so applications are only vulnerable if they use this function directly
and they use it on certificates that may have been obtained from untrusted
sources.
|
{'CVE-2021-23841'}
|
2021-10-19T22:14:35Z
|
2021-05-01T12:00:00Z
| null | null | null |
{'https://crates.io/crates/openssl-src', 'https://www.openssl.org/news/secadv/20210216.txt', 'https://rustsec.org/advisories/RUSTSEC-2021-0058.html'}
| null |
crates.io
|
GHSA-ghpq-vjxw-ch5w
|
Use after free in libpulse-binding
|
### Overview
Version 1.2.1 of the `libpulse-binding` Rust crate, released on the 15th of June 2018, fixed a pair of use-after-free issues with the objects returned by the `get_format_info` and `get_context` methods of `Stream` objects. These objects were mistakenly being constructed without setting an important flag to prevent destruction of the underlying C objects they reference upon their own destruction.
This advisory is being written retrospectively, having previously only been noted in the changelog. No CVE assignment was sought.
### Patches
Users are required to update to version 1.2.1 or newer.
Versions older than 1.2.1 have been yanked from crates.io. This was believed to have already been done at the time of the 1.2.1 release, but upon double checking now they were found to still be available, so has been done now (22nd October 2020).
| null |
2021-08-18T20:41:10Z
|
2021-08-25T20:56:52Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://rustsec.org/advisories/RUSTSEC-2018-0021.html', 'https://github.com/jnqnfe/pulse-binding-rust/security/advisories/GHSA-ghpq-vjxw-ch5w', 'https://github.com/jnqnfe/pulse-binding-rust'}
| null |
crates.io
|
GHSA-wrvc-72w7-xpmj
|
Incorrect Comparison in sodiumoxide
|
An issue was discovered in the sodiumoxide crate before 0.2.5 for Rust. generichash::Digest::eq compares itself to itself and thus has degenerate security properties.
|
{'CVE-2019-25002'}
|
2021-08-19T21:20:40Z
|
2021-08-25T20:45:54Z
|
CRITICAL
| null |
{'CWE-697'}
|
{'https://github.com/sodiumoxide/sodiumoxide/pull/381/commits/fae052b834b097ced9a89a8fff8466e18f383070', 'https://github.com/sodiumoxide/sodiumoxide/pull/381', 'https://nvd.nist.gov/vuln/detail/CVE-2019-25002', 'https://github.com/sodiumoxide/sodiumoxide', 'https://rustsec.org/advisories/RUSTSEC-2019-0026.html'}
| null |
crates.io
|
RUSTSEC-2020-0140
|
`Shared` can cause a data race
|
`Shared` data structure in `model` crate implements `Send` and `Sync` traits regardless of the inner type.
This allows safe Rust code to trigger a data race, which is undefined behavior in Rust.
Users are advised to treat `Shared` as an unsafe type.
It should not be used outside of the testing context,
and care must be taken so that the testing code does not have a data race
besides a race condition that is expected to be caught by the test.
Check [the Rustonomicon](https://doc.rust-lang.org/nomicon/races.html) for the difference between
a data race and a general race condition.
|
{'CVE-2020-36460'}
|
2021-10-19T22:14:35Z
|
2020-11-10T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0140.html', 'https://github.com/spacejam/model/issues/3', 'https://crates.io/crates/model'}
| null |
crates.io
|
RUSTSEC-2020-0005
|
CBox API allows to de-reference raw pointers without `unsafe` code
|
`CBox` and `CSemiBox` are part of the public API of the cbox crate
and they allow to create smart pointers from raw pointers and de-reference
them without the need of `unsafe` code.
|
{'CVE-2020-35860'}
|
2021-10-19T22:14:35Z
|
2020-03-19T12:00:00Z
| null | null | null |
{'https://crates.io/crates/cbox', 'https://github.com/TomBebbington/cbox-rs/issues/2', 'https://rustsec.org/advisories/RUSTSEC-2020-0005.html'}
| null |
crates.io
|
GHSA-xwxc-j97j-84gf
|
Race condition in Parc
|
In the affected versions of this crate, `LockWeak<T>` unconditionally implemented `Send` with no trait bounds on `T`. `LockWeak<T>` doesn't own `T` and only provides `&T`.
This allows concurrent access to a non-Sync `T`, which can cause undefined behavior like data races.
| null |
2021-08-09T17:05:10Z
|
2021-08-25T21:00:03Z
|
MODERATE
| null |
{'CWE-362'}
|
{'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-2020-0117
|
QueueSender<T>/QueueReceiver<T>: Send/Sync impls need `T: Send`
|
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-10-19T22:14:35Z
|
2020-11-24T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0117.html', 'https://github.com/longshorej/conqueue/issues/9', 'https://crates.io/crates/conqueue'}
| null |
crates.io
|
RUSTSEC-2020-0052
|
Undefined Behavior in bounded channel
|
The affected version of this crate's the `bounded` channel incorrectly assumes that `Vec::from_iter` has allocated capacity that same as the number of iterator elements. `Vec::from_iter` does not actually guarantee that and may allocate extra memory. The destructor of the `bounded` channel reconstructs `Vec` from the raw pointer based on the incorrect assumes described above. This is unsound and causing deallocation with the incorrect capacity when `Vec::from_iter` has allocated different sizes with the number of iterator elements.
|
{'CVE-2020-35904', 'GHSA-v5m7-53cv-f3hx', 'CVE-2020-15254'}
|
2021-01-04T17:02:59Z
|
2020-06-26T12:00:00Z
| null | null | null |
{'https://github.com/crossbeam-rs/crossbeam/pull/533', 'https://crates.io/crates/crossbeam-channel', 'https://rustsec.org/advisories/RUSTSEC-2020-0052.html'}
| null |
crates.io
|
RUSTSEC-2021-0019
|
Multiple soundness issues
|
## Calls `std::str::from_utf8_unchecked()` without any checks
The function `xcb::xproto::GetAtomNameReply::name()` calls
`std::str::from_utf8_unchecked()` on the raw bytes that were received from the
X11 server without any validity checks. The X11 server only prevents interior
null bytes, but otherwise allows any X11 client to create an atom for arbitrary
bytes.
This issue is tracked here: https://github.com/rust-x-bindings/rust-xcb/issues/96
## `xcb::xproto::GetPropertyReply::value()` allows arbitrary return types
The function `xcb::xproto::GetPropertyReply::value()` returns a slice of type
`T` where `T` is an unconstrained type parameter. The raw bytes received from
the X11 server are interpreted as the requested type.
The users of the `xcb` crate are advised to only call this function with the
intended types. These are `u8`, `u16`, and `u32`.
This issue is tracked here: https://github.com/rust-x-bindings/rust-xcb/issues/95
## Out of bounds read in `xcb::xproto::change_property()`
`xcb::xproto::change_property` has (among others) the arguments `format: u8` and
`data: &[T]`. The intended use is one of the following cases:
- `format = 8` and `T = u8`
- `format = 16` and `T = u16`
- `format = 32` and `T = u32`
However, this constraint is not enforced. For example, it is possible to call
the function with `format = 32` and `T = u8`. In this case, a read beyond the
end of the `data` slice is performed and the bytes are sent to the X11 server.
The users of the `xcb` crate are advised to only call this function with one of
the intended argument combinations.
This issue is tracked here: https://github.com/rust-x-bindings/rust-xcb/issues/94
## 'Safe' wrapper around `std::mem::transmute()`
The function `xcb::base::cast_event()` takes a reference to a
`xcb::base::GenericEvent` and returns a reference to an arbitrary type, as
requested by the caller (or found via type interference). The function is
implemented as a direct call to `std::mem::transmute()`. Since the return type
is not constrained, this allows transmution to an incorrect type or a type that
is larger than the X11 event that was passed in.
X11 events are mostly always 32 bytes large and this function works as intended.
Users are advised to only cast to the event structs provided by the `xcb` crate
(and hope for the best).
This issue is tracked here: https://github.com/rust-x-bindings/rust-xcb/issues/78
|
{'CVE-2021-26957', 'CVE-2021-26958', 'CVE-2021-26955', 'CVE-2021-26956'}
|
2022-03-06T11:11:48Z
|
2021-02-04T12:00:00Z
| null | null | null |
{'https://crates.io/crates/xcb', 'https://github.com/RustSec/advisory-db/issues/653', 'https://rustsec.org/advisories/RUSTSEC-2021-0019.html', 'https://github.com/rust-x-bindings/rust-xcb/issues/96', 'https://github.com/rust-x-bindings/rust-xcb/issues/94', 'https://github.com/rust-x-bindings/rust-xcb/issues/78', 'https://github.com/rust-x-bindings/rust-xcb/issues/95'}
| null |
crates.io
|
GHSA-5pg8-h4gv-m3p8
|
Null pointer deference in fltk
|
An issue was discovered in the fltk crate before 0.15.3 for Rust. There is a NULL pointer dereference during attempted use of a multi label type if the image is nonexistent.
|
{'CVE-2021-28306'}
|
2021-08-19T17:22:27Z
|
2021-08-25T20:53:56Z
|
HIGH
| null |
{'CWE-476'}
|
{'https://github.com/MoAlyousef/fltk-rs/issues/519', 'https://github.com/MoAlyousef/fltk-rs', 'https://rustsec.org/advisories/RUSTSEC-2021-0038.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-28306'}
| null |
crates.io
|
GHSA-fhv4-fx3v-77w6
|
quinn invalidly assumes the memory layout of std::net::SocketAddr
|
An issue was discovered in the quinn crate for Rust. It may have invalid memory access for certain versions of the standard library because it relies on a direct cast of std::net::SocketAddrV4 and std::net::SocketAddrV6 data structures.
|
{'CVE-2021-28036'}
|
2021-08-19T17:25:47Z
|
2021-08-25T20:52:05Z
|
HIGH
| null |
{'CWE-119'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-28036', 'https://github.com/quinn-rs/quinn', 'https://github.com/quinn-rs/quinn/issues/968', 'https://rustsec.org/advisories/RUSTSEC-2021-0035.html'}
| null |
crates.io
|
RUSTSEC-2021-0018
|
insert_slice_clone can double drop if Clone panics.
|
Affected versions of this crate used `ptr::copy` when inserting into the middle
of a `Vec`. When ownership was temporarily duplicated during this copy, it calls
the clone method of a user provided element.
This issue can result in an element being double-freed if the clone call panics.
Commit `20cb73d` fixed this issue by adding a `set_len(0)` call before
operating on the vector to avoid dropping the elements during a panic.
|
{'CVE-2021-26954'}
|
2021-10-19T22:14:35Z
|
2021-02-03T12:00:00Z
| null | null | null |
{'https://crates.io/crates/qwutils', 'https://rustsec.org/advisories/RUSTSEC-2021-0018.html', 'https://github.com/qwertz19281/rust_utils/issues/3'}
| null |
crates.io
|
GHSA-75cq-g75g-rxff
|
use-after-free vulnerability in Rust array-queue
|
An issue was discovered in the array-queue crate through 2020-09-26 for Rust. A pop_back() call may lead to a use-after-free.
|
{'CVE-2020-35900'}
|
2021-08-18T22:36:31Z
|
2021-08-25T21:00:43Z
|
MODERATE
| null |
{'CWE-416'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0047.html', 'https://github.com/raviqqe/array-queue/issues/2', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35900', 'https://github.com/raviqqe/array-queue'}
| null |
crates.io
|
GHSA-64gv-qg2v-vxv6
|
Array size is not checked in sized-chunks
|
An issue was discovered in the sized-chunks crate through 0.6.2 for Rust. In the Chunk implementation, the array size is not checked when constructed with From<InlineArray<A, T>>.
|
{'CVE-2020-25793'}
|
2021-08-19T21:21:48Z
|
2021-08-25T20:45:04Z
|
HIGH
| null |
{'CWE-129'}
|
{'https://github.com/bodil/sized-chunks', 'https://nvd.nist.gov/vuln/detail/CVE-2020-25793', 'https://rustsec.org/advisories/RUSTSEC-2020-0041.html', 'https://github.com/bodil/sized-chunks/issues/11'}
| null |
crates.io
|
RUSTSEC-2020-0116
|
PinSlab<T> and Unordered<T, S> need bounds on their Send/Sync traits
|
Affected versions of this crate unconditionally implemented `Send` & `Sync` for types `PinSlab<T>` & `Unordered<T, S>`. This allows sending non-Send types to other threads and concurrently accessing non-Sync types from multiple threads.
This can result in a data race & memory corruption when types that provide internal mutability without synchronization are contained within `PinSlab<T>` or `Unordered<T, S>` and accessed concurrently from multiple threads.
The flaw was corrected in commits 92f40b4 & 6a6c367 by adding trait bound `T: Send` to `Send` impls for `PinSlab<T>` & `Unordered<T, S>` and adding `T: Sync` to `Sync` impls for `PinSlab<T>` & `Unordered<T, S>`.
|
{'CVE-2020-36436'}
|
2021-10-19T22:14:35Z
|
2020-11-15T12:00:00Z
| null | null | null |
{'https://crates.io/crates/unicycle', 'https://rustsec.org/advisories/RUSTSEC-2020-0116.html', 'https://github.com/udoprog/unicycle/issues/8'}
| null |
crates.io
|
GHSA-jf43-3v8j-qwwr
|
Data races in multiqueue
|
Affected versions of multiqueue unconditionally implemented `Send` for types used in queue implementations (`InnerSend<RW, T>`, `InnerRecv<RW, T>`, `FutInnerSend<RW, T>`, `FutInnerRecv<RW, T>`).
This allows users to send non-Send types to other threads, which can lead to data race bugs or other undefined behavior.
| null |
2021-08-09T17:20:06Z
|
2021-08-25T20:59:56Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0143.html', 'https://github.com/schets/multiqueue/issues/31', 'https://github.com/schets/multiqueue'}
| null |
crates.io
|
GHSA-8mjx-h23h-w2pg
|
Double free in stack_dst
|
An issue was discovered in the stack_dst crate before 0.6.1 for Rust. Because of the push_inner behavior, a double free can occur upon a val.clone() panic.
|
{'CVE-2021-28034'}
|
2021-08-30T21:56:32Z
|
2021-09-01T18:30:44Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://github.com/thepowersgang/stack_dst-rs', 'https://nvd.nist.gov/vuln/detail/CVE-2021-28034', 'https://rustsec.org/advisories/RUSTSEC-2021-0033.html', 'https://github.com/thepowersgang/stack_dst-rs/commit/2a4d53809e3000f40085f2b229b6b1a33759881d'}
| null |
crates.io
|
GHSA-jpwg-6gf5-5vh9
|
Out of bounds write in reorder
|
An issue was discovered in the reorder crate through 1.1.0 for Rust. swap_index can return uninitialized values if an iterator returns a len() that is too large.
|
{'CVE-2021-29942'}
|
2021-08-19T17:17:03Z
|
2021-08-25T20:54:10Z
|
HIGH
| null |
{'CWE-787'}
|
{'https://github.com/tiby312/reorder', 'https://github.com/tiby312/reorder/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0050.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29942'}
| null |
crates.io
|
RUSTSEC-2020-0141
|
MvccRwLock allows data races & aliasing violations
|
Affected versions of this crate unconditionally implement Send/Sync for `MvccRwLock`.
This can lead to data races when types that are either `!Send` or `!Sync` (e.g. `Rc<T>`, `Arc<Cell<_>>`) are contained inside `MvccRwLock` and sent across thread boundaries. The data races can potentially lead to memory corruption (as demonstrated in the PoC from the original report issue).
Also, safe APIs of `MvccRwLock` allow aliasing violations by allowing `&T` and `LockResult<MutexGuard<Box<T>>>` to co-exist in conflicting lifetime regions. The APIs of `MvccRwLock` should either be marked as `unsafe` or `MbccRwLock` should be changed to private or pub(crate).
|
{'CVE-2020-36461'}
|
2021-10-19T22:14:35Z
|
2020-12-10T12:00:00Z
| null | null | null |
{'https://github.com/pipedown/noise/issues/72', 'https://crates.io/crates/noise_search', 'https://rustsec.org/advisories/RUSTSEC-2020-0141.html'}
| null |
crates.io
|
GHSA-8gf5-q9p9-wvmc
|
Data race in atomic-option
|
An issue was discovered in the atomic-option crate through 2020-10-31 for Rust. Because AtomicOption<T> implements Sync unconditionally, a data race can occur.
|
{'CVE-2020-36219'}
|
2021-08-19T18:48:32Z
|
2021-08-25T20:51:42Z
|
MODERATE
| null |
{'CWE-662'}
|
{'https://github.com/reem/rust-atomic-option/issues/4', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36219', 'https://github.com/reem/rust-atomic-option', 'https://rustsec.org/advisories/RUSTSEC-2020-0113.html'}
| null |
crates.io
|
GHSA-fc7x-2cmc-8j2g
|
Incorrect hash in sha2
|
An issue was discovered in the sha2 crate 0.9.7 before 0.9.8 for Rust. Hashes of long messages may be incorrect when the AVX2-accelerated backend is used.
|
{'CVE-2021-45696'}
|
2022-01-07T17:57:49Z
|
2022-01-06T22:10:26Z
|
CRITICAL
| null | null |
{'https://nvd.nist.gov/vuln/detail/CVE-2021-45696', 'https://github.com/RustCrypto/hashes', 'https://rustsec.org/advisories/RUSTSEC-2021-0100.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/sha2/RUSTSEC-2021-0100.md'}
| null |
crates.io
|
RUSTSEC-2020-0004
|
sigstack allocation bug can cause memory corruption or leak
|
An embedding using affected versions of lucet-runtime configured to use
non-default Wasm globals sizes of more than 4KiB, or compiled in debug mode
without optimizations, could leak data from the signal handler stack to guest
programs. This can potentially cause data from the embedding host to leak to
guest programs or cause corruption of guest program memory.
This flaw was resolved by correcting the sigstack allocation logic.
|
{'CVE-2020-35859'}
|
2021-10-19T22:14:35Z
|
2020-01-24T12:00:00Z
| null | null | null |
{'https://github.com/bytecodealliance/lucet/pull/401', 'https://crates.io/crates/lucet-runtime-internals', 'https://rustsec.org/advisories/RUSTSEC-2020-0004.html'}
| null |
crates.io
|
RUSTSEC-2021-0059
|
`aesni` has been merged into the `aes` crate
|
Please use the `aes` crate going forward. The new repository location is at:
<https://github.com/RustCrypto/block-ciphers/tree/master/aes>
AES-NI is now autodetected at runtime on `i686`/`x86-64` platforms.
If AES-NI is not present, the `aes` crate will fallback to a constant-time
portable software implementation.
To prevent this fallback (and have absence of AES-NI result in an illegal
instruction crash instead), continue to pass the same RUSTFLAGS which were
previously required for the `aesni` crate to compile:
```
RUSTFLAGS=-Ctarget-feature=+aes,+ssse3
```
| null |
2021-05-04T01:28:43Z
|
2021-04-29T12:00:00Z
| null | null | null |
{'https://crates.io/crates/aesni', 'https://rustsec.org/advisories/RUSTSEC-2021-0059.html', 'https://github.com/RustCrypto/block-ciphers/pull/200'}
| null |
crates.io
|
GHSA-q879-9g95-56mx
|
Wrong type for `Linker`-define functions when used across two `Engine`s
|
### Impact
As a Rust library the `wasmtime` crate clearly marks which functions are safe and which are `unsafe`, guaranteeing that if consumers never use `unsafe` then it should not be possible to have memory unsafety issues in their embeddings of Wasmtime. An issue was discovered in the safe API of `Linker::func_*` APIs. These APIs were previously not sound when one `Engine` was used to create the `Linker` and then a different `Engine` was used to create a `Store` and then the `Linker` was used to instantiate a module into that `Store`. Cross-`Engine` usage of functions is not supported in Wasmtime and this can result in type confusion of function pointers, resulting in being able to safely call a function with the wrong type.
Triggering this bug requires using at least two `Engine` values in an embedding and then additionally using two different values with a `Linker` (one at the creation time of the `Linker` and another when instantiating a module with the `Linker`).
It's expected that usage of more-than-one `Engine` in an embedding is relatively rare since an `Engine` is intended to be a globally shared resource, so the expectation is that the impact of this issue is relatively small.
The fix implemented is to change this behavior to `panic!()` in Rust instead of silently allowing it. Using different `Engine` instances with a `Linker` is a programmer bug that `wasmtime` catches at runtime.
### Patches
This bug has been patched and users should upgrade to Wasmtime version 0.30.0.
### Workarounds
If you cannot upgrade Wasmtime and are using more than one `Engine` in your embedding it's recommended to instead use only one `Engine` for the entire program if possible. An `Engine` is designed to be a globally shared resource that is suitable to have only one for the lifetime of an entire process. If using multiple `Engine`s is required then code should be audited to ensure that `Linker` is only used with one `Engine`.
### For more information
If you have any questions or comments about this advisory:
* Reach out to us on [the Bytecode Alliance Zulip chat](https://bytecodealliance.zulipchat.com/#narrow/stream/217126-wasmtime)
* Open an issue in [the `bytecodealliance/wasmtime` repository](https://github.com/bytecodealliance/wasmtime/)
|
{'CVE-2021-39219'}
|
2021-09-17T20:07:13Z
|
2021-09-20T19:54:26Z
|
MODERATE
| null |
{'CWE-843'}
|
{'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/WAVBRYDDUIY2ZR3K3FO4BVYJKIMJ5TP7/', 'https://github.com/bytecodealliance/wasmtime', 'https://nvd.nist.gov/vuln/detail/CVE-2021-39219', 'https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-q879-9g95-56mx', 'https://crates.io/crates/wasmtime', 'https://github.com/bytecodealliance/wasmtime/commit/b39f087414f27ae40c44449ed5d1154e03449bff', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/Z2Z33FTXFQ6EOINVEQIP4DFBG53G5XIY/'}
| null |
crates.io
|
RUSTSEC-2020-0157
|
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).
|
{'GHSA-mm4m-qg48-f7wc', 'CVE-2020-13759'}
|
2021-09-10T15:50:27Z
|
2020-06-02T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0157.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-13759', 'https://crates.io/crates/vm-memory'}
| null |
crates.io
|
GHSA-jrcf-4jp8-m28v
|
miow invalidly assumes the memory layout of std::net::SocketAddr
|
An issue was discovered in the miow crate before 0.3.6 for Rust. It has false expectations about the std::net::SocketAddr memory representation.
|
{'CVE-2020-35921'}
|
2021-08-19T18:54:07Z
|
2021-08-25T20:50:35Z
|
MODERATE
| null |
{'CWE-188'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-35921', 'https://github.com/yoshuawuyts/miow/issues/38', 'https://github.com/yoshuawuyts/miow/pull/39', 'https://rustsec.org/advisories/RUSTSEC-2020-0080.html', 'https://github.com/yoshuawuyts/miow'}
| null |
crates.io
|
GHSA-cm8g-544f-p9x9
|
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_collation has a use-after-free.
|
{'CVE-2021-45716'}
|
2022-01-07T16:13:53Z
|
2022-01-06T22:03:16Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/rusqlite/RUSTSEC-2021-0128.md', 'https://rustsec.org/advisories/RUSTSEC-2021-0128.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45716', 'https://github.com/rusqlite/rusqlite'}
| null |
crates.io
|
RUSTSEC-2020-0012
|
Relies on undefined behavior of `char::from_u32_unchecked`
|
The Windows implementation of this crate relied on the behavior of
`std::char::from_u32_unchecked` when its safety clause is violated.
Even though this worked with Rust versions up to 1.42 (at least),
that behavior could change with any new Rust version, possibly leading
a security issue.
The flaw was corrected in version 2.0.0.
|
{'CVE-2020-35865'}
|
2021-10-19T22:14:35Z
|
2020-04-24T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0012.html', 'https://crates.io/crates/os_str_bytes', 'https://github.com/dylni/os_str_bytes/pull/1'}
| null |
crates.io
|
GHSA-xvcg-2q82-r87j
|
Panic mishandled in libpulse-binding
|
An issue was discovered in the libpulse-binding crate before 2.6.0 for Rust. It mishandles a panic that crosses a Foreign Function Interface (FFI) boundary.
|
{'CVE-2019-25055'}
|
2022-01-07T16:25:11Z
|
2022-01-06T22:18:19Z
|
HIGH
| null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0038.html', 'https://github.com/jnqnfe/pulse-binding-rust', 'https://nvd.nist.gov/vuln/detail/CVE-2019-25055', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/libpulse-binding/RUSTSEC-2019-0038.md'}
| null |
crates.io
|
GHSA-m9m5-cg5h-r582
|
Improper random number generation in nanorand
|
An issue was discovered in the nanorand crate before 0.5.1 for Rust. It caused any random number generator (even ChaCha) to return all zeroes because integer truncation was mishandled.
|
{'CVE-2020-35926'}
|
2021-08-19T18:55:41Z
|
2021-08-25T20:50:24Z
|
CRITICAL
| null |
{'CWE-338'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0089.html', 'https://github.com/Absolucy/nanorand-rs', 'https://twitter.com/aspenluxxxy/status/1336684692284772352', 'https://github.com/Absolucy/nanorand-rs/commit/5ba218ac29df4786b002d7d12b47fa0c04a331f2', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35926'}
| null |
crates.io
|
RUSTSEC-2020-0100
|
Double free when calling `sys_info::disk_info` from multiple threads
|
Affected versions of `sys-info` use a static, global, list to store temporary disk information while running. The function that cleans up this list,
`DFCleanup`, assumes a single threaded environment and will try to free the same memory twice in a multithreaded environment.
This results in consistent double-frees and segfaults when calling `sys_info::disk_info` from multiple threads at once.
The issue was fixed by moving the global variable into a local scope.
## Safer Alternatives:
- [`sysinfo`](https://crates.io/crates/sysinfo)
|
{'CVE-2020-36434'}
|
2021-10-19T22:14:35Z
|
2020-05-31T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0100.html', 'https://crates.io/crates/sys-info', 'https://github.com/FillZpp/sys-info-rs/issues/63'}
| null |
crates.io
|
GHSA-5vwc-r48g-wj6c
|
Exposure of Resource to Wrong Sphere in abomonation
|
An issue was discovered in the abomonation crate through 2021-10-17 for Rust. Because transmute operations are insufficiently constrained, there can be an information leak or ASLR bypass.
|
{'CVE-2021-45708'}
|
2022-01-07T18:26:56Z
|
2022-01-06T22:08:22Z
|
HIGH
| null |
{'CWE-668'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0120.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/abomonation/RUSTSEC-2021-0120.md', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45708', 'https://github.com/TimelyDataflow/abomonation', 'https://github.com/TimelyDataflow/abomonation/issues/23'}
| null |
crates.io
|
GHSA-mh6h-f25p-98f8
|
Uncontrolled memory consumption in protobuf
|
An issue was discovered in the protobuf crate before 2.6.0 for Rust. Attackers can exhaust all memory via Vec::reserve calls.
|
{'CVE-2019-15544'}
|
2021-08-19T21:23:35Z
|
2021-08-25T20:44:05Z
|
HIGH
| null |
{'CWE-770'}
|
{'https://github.com/stepancheg/rust-protobuf/issues/411', 'https://lists.apache.org/thread.html/rd64381fb8f92d640c1975dc50dcdf1b8512e02a2a7b20292d3565cae@%3Cissues.hbase.apache.org%3E', 'https://rustsec.org/advisories/RUSTSEC-2019-0003.html', 'https://nvd.nist.gov/vuln/detail/CVE-2019-15544', 'https://lists.apache.org/thread.html/r00097d0b5b6164ea428554007121d5dc1f88ba2af7b9e977a10572cd@%3Cdev.hbase.apache.org%3E', 'https://lists.apache.org/thread.html/r7fed8dd9bee494094e7011cf3c2ab75bd8754ea314c6734688c42932@%3Ccommon-issues.hadoop.apache.org%3E', 'https://github.com/stepancheg/rust-protobuf', 'https://lists.apache.org/thread.html/r4ef574a5621b0e670a3ce641e9922543e34f22bf4c9ee9584aa67fcf@%3Cissues.hbase.apache.org%3E'}
| null |
crates.io
|
RUSTSEC-2020-0045
|
bespoke Cell implementation allows obtaining several mutable references to the same data
|
The custom implementation of a Cell primitive in the affected versions of this crate
does not keep track of mutable references to the underlying data.
This allows obtaining several mutable references to the same object
which may result in arbitrary memory corruption, most likely use-after-free.
The flaw was corrected by switching from a bespoke `Cell<T>` implementation to `Rc<RefCell<T>>`.
|
{'CVE-2020-35898'}
|
2021-10-19T22:14:35Z
|
2020-01-08T12:00:00Z
| null | null | null |
{'https://github.com/actix/actix-net/issues/160', 'https://crates.io/crates/actix-utils', 'https://rustsec.org/advisories/RUSTSEC-2020-0045.html'}
| null |
crates.io
|
RUSTSEC-2019-0038
|
Fix for UB in failure to catch panics crossing FFI boundaries
|
Affected versions of this crate failed to catch panics crossing FFI boundaries via callbacks, which
is a form of UB. This flaw was corrected by [this commit][1] which was included in version 2.6.0.
[1]: https://github.com/jnqnfe/pulse-binding-rust/commit/7fd282aef7787577c385aed88cb25d004b85f494
| null |
2020-10-25T19:19:23Z
|
2019-03-10T12:00:00Z
| null | null | null |
{'https://github.com/jnqnfe/pulse-binding-rust/commit/7fd282aef7787577c385aed88cb25d004b85f494', 'https://crates.io/crates/libpulse-binding', 'https://rustsec.org/advisories/RUSTSEC-2019-0038.html'}
| null |
crates.io
|
GHSA-vfqx-hv88-f9cv
|
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 get_or_insert upon a panic of a user-provided f function.
|
{'CVE-2021-30456'}
|
2021-08-19T17:04:13Z
|
2021-08-25T20:55:22Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-30456', 'https://github.com/andrewhickman/id-map/issues/3', 'https://github.com/andrewhickman/id-map', 'https://rustsec.org/advisories/RUSTSEC-2021-0052.html'}
| null |
crates.io
|
RUSTSEC-2021-0130
|
Use after free in lru crate
|
Lru crate has use after free vulnerability.
Lru crate has two functions for getting an iterator. Both iterators give
references to key and value. Calling specific functions, like pop(), will remove
and free the value, and but it's still possible to access the reference of value
which is already dropped causing use after free.
| null |
2021-12-21T15:50:24Z
|
2021-12-21T12:00:00Z
| null | null | null |
{'https://github.com/jeromefroe/lru-rs/issues/120', 'https://crates.io/crates/lru', 'https://rustsec.org/advisories/RUSTSEC-2021-0130.html'}
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.