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-2020-0059
|
MutexGuard::map can cause a data race in safe code
|
Affected versions of the crate had a Send/Sync implementation for MappedMutexGuard that only considered variance on T, while MappedMutexGuard dereferenced to U.
This could of led to data races in safe Rust code when a closure used in MutexGuard::map() returns U that is unrelated to T.
The issue was fixed by fixing `Send` and `Sync` implementations, and by adding a `PhantomData<&'a mut U>` marker to the `MappedMutexGuard` type to tell the compiler that the guard is over
U too.
|
{'CVE-2020-35905'}
|
2021-10-19T22:14:35Z
|
2020-10-22T12:00:00Z
| null | null | null |
{'https://crates.io/crates/futures-util', 'https://rustsec.org/advisories/RUSTSEC-2020-0059.html', 'https://github.com/rust-lang/futures-rs/issues/2239'}
| null |
crates.io
|
RUSTSEC-2019-0024
|
Test advisory with associated example crate
|
This is a test advisory useful for verifying RustSec tooling and vulnerability
detection pipelines are working correctly. Aside from the fact that it is filed
against an example crate, it is otherwise considered by the Advisory Database
itself to be a normal security advisory.
It's filed against `rustsec-example-crate`, an otherwise completely empty crate
with no functionality or code, which has two releases:
- [v0.0.1] - *vulnerable* according to this advisory
- [v1.0.0] - *patched* by this advisory
(Technically there is a third release, v0.0.0, which is yanked, but otherwise
identical to the v0.0.1 release)
[v0.0.1]: https://crates.io/crates/rustsec-example-crate/0.0.1
[v1.0.0]: https://crates.io/crates/rustsec-example-crate/1.0.0
| null |
2020-10-02T01:29:11Z
|
2019-10-08T12:00:00Z
| null | null | null |
{'https://github.com/RustSec/advisory-db/issues/158', 'https://rustsec.org/advisories/RUSTSEC-2019-0024.html', 'https://crates.io/crates/rustsec-example-crate'}
| null |
crates.io
|
RUSTSEC-2021-0012
|
Reading uninitialized memory can cause UB (`Deserializer::read_vec`)
|
`Deserializer::read_vec()` created an uninitialized buffer and passes it to a user-provided `Read` implementation (`Deserializer.reader.read_exact()`).
Passing an uninitialized buffer to an arbitrary `Read` implementation is currently defined as undefined behavior in Rust. Official documentation for the `Read` trait explains the following: "It is your responsibility to make sure that buf is initialized before calling read. Calling read with an uninitialized buf (of the kind one obtains via MaybeUninit<T>) is not safe, and can lead to undefined behavior."
The flaw was corrected in commit ce310f7 by zero-initializing the newly allocated buffer before handing it to `Deserializer.reader.read_exact()`.
|
{'CVE-2021-26305'}
|
2021-10-19T22:14:35Z
|
2021-01-02T12:00:00Z
| null | null | null |
{'https://crates.io/crates/cdr', 'https://rustsec.org/advisories/RUSTSEC-2021-0012.html', 'https://github.com/hrektts/cdr-rs/issues/10'}
| null |
crates.io
|
GHSA-7cjc-hvxf-gqh7
|
Use after free and double free in bitvec
|
An issue was discovered in the bitvec crate before 0.17.4 for Rust. BitVec to BitBox conversion leads to a use-after-free or double free.
|
{'CVE-2020-35862'}
|
2021-08-19T21:18:16Z
|
2021-08-25T20:47:39Z
|
CRITICAL
| null |
{'CWE-416', 'CWE-415'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0007.html', 'https://github.com/myrrlyn/bitvec/issues/55', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35862', 'https://github.com/myrrlyn/bitvec'}
| null |
crates.io
|
GHSA-9qj6-4rfq-vm84
|
Out-of-bounds Write in actix-web
|
An issue was discovered in the actix-web crate before 0.7.15 for Rust. It can unsoundly coerce an immutable reference into a mutable reference, leading to memory corruption.
|
{'CVE-2018-25024'}
|
2022-01-06T18:38:16Z
|
2022-01-06T22:20:41Z
|
CRITICAL
| null |
{'CWE-787'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2018-25024', 'https://github.com/actix/actix-web.git', '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
|
RUSTSEC-2021-0045
|
FromIterator implementation for Vector/Matrix can drop uninitialized memory
|
The `FromIterator<T>` methods for `Vector` and `Matrix` rely on the type
parameter `N` to allocate space in the iterable.
If the passed in `N` type parameter is larger than the number of items returned
by the iterator, it can lead to uninitialized memory being left in the
`Vector` or `Matrix` type which gets dropped.
|
{'CVE-2021-29936'}
|
2021-10-19T22:14:35Z
|
2021-01-11T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0045.html', 'https://crates.io/crates/adtensor', 'https://github.com/charles-r-earp/adtensor/issues/4'}
| null |
crates.io
|
RUSTSEC-2022-0010
|
enum_map macro can cause UB when `Enum` trait is incorrectly implemented
|
Affected versions of this crate did not properly check the length of an enum when using `enum_map!` macro, trusting user-provided length.
When the `LENGTH` in the `Enum` trait does not match the array length in the `EnumArray` trait, this can result in the initialization of the enum map with uninitialized types, which in turn can allow an attacker to execute arbitrary code.
This problem can only occur with a manual implementation of the Enum trait, it will never occur for enums that use `#[derive(Enum)]`.
Example code that triggers this vulnerability looks like this:
```rust
enum E {
A,
B,
C,
}
impl Enum for E {
const LENGTH: usize = 2;
fn from_usize(value: usize) -> E {
match value {
0 => E::A,
1 => E::B,
2 => E::C,
_ => unimplemented!(),
}
}
fn into_usize(self) -> usize {
self as usize
}
}
impl<V> EnumArray<V> for E {
type Array = [V; 3];
}
let _map: EnumMap<E, String> = enum_map! { _ => "Hello, world!".into() };
```
The flaw was corrected in commit [b824e23](https://gitlab.com/KonradBorowski/enum-map/-/commit/b824e232f2fb47837740070096ac253df8e80dfc) by putting `LENGTH` property on sealed trait for macro to read.
| null |
2022-02-18T22:15:59Z
|
2022-02-17T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2022-0010.html', 'https://gitlab.com/KonradBorowski/enum-map/-/blob/master/CHANGELOG.md#version-202', 'https://crates.io/crates/enum-map'}
| null |
crates.io
|
GHSA-9p9m-9xww-qjcx
|
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 unit().
|
{'CVE-2020-25791'}
|
2021-08-19T21:21:44Z
|
2021-08-25T20:45:06Z
|
HIGH
| null |
{'CWE-129'}
|
{'https://github.com/bodil/sized-chunks', 'https://nvd.nist.gov/vuln/detail/CVE-2020-25791', 'https://rustsec.org/advisories/RUSTSEC-2020-0041.html', 'https://github.com/bodil/sized-chunks/issues/11'}
| null |
crates.io
|
RUSTSEC-2021-0100
|
Miscomputed results when using AVX2 backend
|
The v0.9.7 release of the `sha2` crate introduced a new AVX2-accelerated
backend which was automatically enabled for all x86/x86_64 CPUs where AVX2
support was autodetected at runtime.
This backend was buggy and would miscompute results for long messages
(i.e. messages spanning multiple SHA blocks).
The crate has since been yanked, but any users who upgraded to v0.9.7 should
immediately upgrade to v0.9.8 and recompute any hashes which were previously
computed by v0.9.7.
| null |
2021-09-09T16:22:48Z
|
2021-09-08T12:00:00Z
| null | null | null |
{'https://crates.io/crates/sha2', 'https://github.com/RustCrypto/hashes/pull/314', 'https://rustsec.org/advisories/RUSTSEC-2021-0100.html'}
| null |
crates.io
|
GHSA-rw2c-c256-3r53
|
Data races in hashconsing
|
An issue was discovered in the hashconsing crate before 1.1.0 for Rust. Because HConsed does not have bounds on its Send trait or Sync trait, memory corruption can occur.
|
{'CVE-2020-36215'}
|
2021-08-19T18:47:26Z
|
2021-08-25T20:51:52Z
|
HIGH
| null |
{'CWE-662', 'CWE-787'}
|
{'https://github.com/AdrienChampion/hashconsing', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36215', 'https://rustsec.org/advisories/RUSTSEC-2020-0107.html', 'https://github.com/AdrienChampion/hashconsing/issues/1'}
| null |
crates.io
|
GHSA-j8qq-58cr-8cc7
|
Out of bounds read in bra
|
Buffered Random Access (BRA) provides easy random memory access to a sequential source of data in Rust. This is achieved by greedily retaining all memory read from a given source. Buffered Random Access (BRA) provides easy random memory access to a sequential source of data in Rust. An issue was discovered in the bra crate before 0.1.1 for Rust. It lacks soundness because it can read uninitialized memory.
|
{'CVE-2021-25905'}
|
2022-05-05T00:44:22Z
|
2021-08-25T20:52:53Z
|
CRITICAL
| null |
{'CWE-908', 'CWE-125'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-25905', 'https://github.com/Enet4/bra-rs', 'https://rustsec.org/advisories/RUSTSEC-2021-0008.html', 'https://github.com/Enet4/bra-rs/issues/1'}
| null |
crates.io
|
RUSTSEC-2020-0018
|
crate has been renamed to `block-cipher`
|
This crate has been renamed from `block-cipher-trait` to `block-cipher`.
The new repository location is at:
<https://github.com/RustCrypto/traits/tree/master/block-cipher>
| null |
2020-10-02T01:29:11Z
|
2020-05-26T12:00:00Z
| null | null | null |
{'https://github.com/RustCrypto/traits/pull/139', 'https://rustsec.org/advisories/RUSTSEC-2020-0018.html', 'https://crates.io/crates/block-cipher-trait'}
| null |
crates.io
|
RUSTSEC-2022-0006
|
Data race in `Iter` and `IterMut`
|
In the affected version of this crate, `{Iter, IterMut}::next` used a weaker memory ordering when loading values than what was required, exposing a potential data race
when iterating over a `ThreadLocal`'s values.
Crates using `Iter::next`, or `IterMut::next` are affected by this issue.
| null |
2022-01-24T14:39:43Z
|
2022-01-23T12:00:00Z
| null | null | null |
{'https://github.com/Amanieu/thread_local-rs/issues/33', 'https://rustsec.org/advisories/RUSTSEC-2022-0006.html', 'https://crates.io/crates/thread_local'}
| null |
crates.io
|
GHSA-q2gj-9r85-p832
|
Data races in rulinalg
|
An issue was discovered in the rulinalg crate through 2020-02-11 for Rust. There are incorrect lifetime-boundary definitions for RowMut::raw_slice and RowMut::raw_slice_mut.
|
{'CVE-2020-35879'}
|
2021-08-19T21:06:56Z
|
2021-08-25T20:48:09Z
|
CRITICAL
| null |
{'CWE-362'}
|
{'https://github.com/AtheMathmo/rulinalg', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35879', 'https://github.com/AtheMathmo/rulinalg/issues/201', 'https://rustsec.org/advisories/RUSTSEC-2020-0023.html'}
| null |
crates.io
|
RUSTSEC-2021-0053
|
'merge_sort::merge()' crashes with double-free for `T: Drop`
|
In the affected versions of this crate, `merge_sort::merge()` wildly duplicates and drops ownership of `T` without guarding against double-free. Due to such implementation,
simply invoking `merge_sort::merge()` on `Vec<T: Drop>` can cause **double free** bugs.
|
{'CVE-2021-31996'}
|
2021-11-06T20:37:35Z
|
2021-03-07T12:00:00Z
| null | null | null |
{'https://github.com/AbrarNitk/algorithmica/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0053.html', 'https://crates.io/crates/algorithmica'}
| null |
crates.io
|
RUSTSEC-2021-0116
|
`BinaryArray` does not perform bound checks on reading values and offsets
|
`BinaryArray` performs insufficient validation on creation, which allows out-of-bounds reads in safe code.
| null |
2021-12-22T21:15:54Z
|
2021-09-14T12:00:00Z
| null | null | null |
{'https://github.com/apache/arrow-rs/issues/773', 'https://rustsec.org/advisories/RUSTSEC-2021-0116.html', 'https://github.com/apache/arrow-rs/issues/772', 'https://crates.io/crates/arrow'}
| null |
crates.io
|
GHSA-3288-cwgw-ch86
|
Unchecked Return Value in xcb
|
An issue was discovered in the xcb crate through 2021-02-04 for Rust. It has a soundness violation because xcb::xproto::GetAtomNameReply::name() calls std::str::from_utf8_unchecked() on unvalidated bytes from an X server.
|
{'CVE-2021-26955'}
|
2021-08-19T17:44:05Z
|
2021-08-25T20:53:22Z
|
CRITICAL
| null |
{'CWE-252'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0019.html', 'https://github.com/RustSec/advisory-db/issues/653', 'https://nvd.nist.gov/vuln/detail/CVE-2021-26955', 'https://github.com/rtbo/rust-xcb'}
| null |
crates.io
|
GHSA-xmr7-v725-2jjr
|
XSS in comrak
|
An issue was discovered in the comrak crate before 0.9.1 for Rust. XSS can occur because the protection mechanism for data: and javascript: URIs is case-sensitive, allowing (for example) Data: to be used in an attack.
|
{'CVE-2021-27671'}
|
2021-08-19T17:34:25Z
|
2021-08-25T20:52:12Z
|
MODERATE
| null |
{'CWE-79'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0026.html', 'https://github.com/kivikakk/comrak', 'https://github.com/kivikakk/comrak/releases/tag/0.9.1', 'https://nvd.nist.gov/vuln/detail/CVE-2021-27671'}
| null |
crates.io
|
GHSA-fgfm-hqjw-3265
|
Out-of-bounds Write in actix-web
|
An issue was discovered in the actix-web crate before 0.7.15 for Rust. It can unsoundly extend the lifetime of a string, leading to memory corruption.
|
{'CVE-2018-25025'}
|
2022-01-06T18:35:59Z
|
2022-01-06T22:18:46Z
|
CRITICAL
| null |
{'CWE-787'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2018-25025', 'https://github.com/actix/actix-web.git', '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
|
RUSTSEC-2019-0032
|
crust repo has been archived; use libp2p instead
|
** The `crust` crate repo was archived with no warning or explanation.**
Given that it was archived with no warning or successor, there's not an
official replacement but [`rust-libp2p`](https://github.com/libp2p/rust-libp2p)
looks like it's got a similar feature set and is actively maintained.
| null |
2020-10-02T01:29:11Z
|
2019-11-21T12:00:00Z
| null | null | null |
{'https://github.com/maidsafe/crust', 'https://rustsec.org/advisories/RUSTSEC-2019-0032.html', 'https://crates.io/crates/crust'}
| null |
crates.io
|
RUSTSEC-2021-0004
|
Missing Send bound for Lazy
|
All current versions of this crate allow causing data races in safe code.
The flaw will be fixed in the next release.
|
{'CVE-2021-25901'}
|
2021-10-19T22:14:35Z
|
2021-01-17T12:00:00Z
| null | null | null |
{'https://crates.io/crates/lazy-init', 'https://rustsec.org/advisories/RUSTSEC-2021-0004.html', 'https://github.com/khuey/lazy-init/issues/9'}
| null |
crates.io
|
GHSA-69gw-hgj3-45m7
|
Memory corruption in smallvec
|
An issue was discovered in the smallvec crate before 0.6.10 for Rust. There is memory corruption for certain grow attempts with less than the current capacity.
|
{'CVE-2019-15554'}
|
2021-08-19T21:23:44Z
|
2021-08-25T20:43:58Z
|
CRITICAL
| null |
{'CWE-787'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-15554', 'https://github.com/servo/rust-smallvec', 'https://github.com/servo/rust-smallvec/issues/149', 'https://rustsec.org/advisories/RUSTSEC-2019-0012.html'}
| null |
crates.io
|
GHSA-w4cc-pc2h-whcj
|
Out-of-bounds Write in derive-com-impl
|
An issue was discovered in the derive-com-impl crate before 0.1.2 for Rust. An invalid reference (and memory corruption) can occur because AddRef might not be called before returning a pointer.
|
{'CVE-2021-45681'}
|
2022-01-07T16:17:28Z
|
2022-01-06T22:16:10Z
|
HIGH
| null |
{'CWE-787'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-45681', 'https://rustsec.org/advisories/RUSTSEC-2021-0083.html', 'https://github.com/connicpu/com-impl', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/derive-com-impl/RUSTSEC-2021-0083.md'}
| null |
crates.io
|
RUSTSEC-2020-0034
|
Multiple security issues including data race, buffer overflow, and uninitialized memory drop
|
`arr` crate contains multiple security issues. Specifically,
1. It incorrectly implements Sync/Send bounds, which allows to smuggle non-Sync/Send types across the thread boundary.
2. `Index` and `IndexMut` implementation does not check the array bound.
3. `Array::new_from_template()` drops uninitialized memory.
|
{'CVE-2020-35886', 'CVE-2020-35887', 'CVE-2020-35888'}
|
2021-01-31T04:02:50Z
|
2020-08-25T12:00:00Z
| null | null | null |
{'https://github.com/sjep/array/issues/1', 'https://crates.io/crates/arr', 'https://rustsec.org/advisories/RUSTSEC-2020-0034.html'}
| null |
crates.io
|
GHSA-hvqc-pc78-x9wh
|
Soundness issue in raw-cpuid
|
An issue was discovered in the raw-cpuid crate before 9.0.0 for Rust. It has unsound transmute calls within as_string() methods.
|
{'CVE-2021-26306'}
|
2021-08-19T18:02:19Z
|
2021-08-25T20:53:10Z
|
HIGH
| null |
{'CWE-198'}
|
{'https://github.com/RustSec/advisory-db/pull/614', 'https://rustsec.org/advisories/RUSTSEC-2021-0013.html', 'https://github.com/gz/rust-cpuid/issues/40', 'https://nvd.nist.gov/vuln/detail/CVE-2021-26306', 'https://github.com/gz/rust-cpuid'}
| null |
crates.io
|
RUSTSEC-2021-0090
|
Reading on uninitialized memory may cause UB ( `util::read_spv()` )
|
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.
| null |
2021-08-23T12:04:28Z
|
2021-01-07T12:00:00Z
| null | null | null |
{'https://crates.io/crates/ash', 'https://github.com/MaikKlein/ash/issues/354', 'https://rustsec.org/advisories/RUSTSEC-2021-0090.html'}
| null |
crates.io
|
GHSA-cwvc-87xq-pc5m
|
Out-of-bounds Write and Race Condition in metrics-util
|
An issue was discovered in the metrics-util crate before 0.7.0 for Rust. There is a data race and memory corruption because AtomicBucket<T> unconditionally implements the Send and Sync traits.
|
{'CVE-2021-45704'}
|
2022-01-07T17:39:55Z
|
2022-01-06T22:08:43Z
|
HIGH
| null |
{'CWE-787', 'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0113.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/metrics-util/RUSTSEC-2021-0113.md', 'https://github.com/metrics-rs/metrics', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45704'}
| null |
crates.io
|
GHSA-gffv-5hr2-f9gj
|
Incorrect results in orion
|
An issue was discovered in the orion crate before 0.11.2 for Rust. reset() calls cause incorrect results.
|
{'CVE-2018-20999'}
|
2021-08-19T21:24:37Z
|
2021-08-25T20:43:18Z
|
HIGH
| null |
{'CWE-682'}
|
{'https://rustsec.org/advisories/RUSTSEC-2018-0012.html', 'https://github.com/brycx/orion', 'https://nvd.nist.gov/vuln/detail/CVE-2018-20999', 'https://github.com/brycx/orion/issues/46'}
| null |
crates.io
|
GHSA-f6g6-54hm-fhxv
|
Data races in libsbc
|
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-08-18T19:58:56Z
|
2021-08-25T20:59:02Z
|
HIGH
| null |
{'CWE-119', 'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0120.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36440', 'https://github.com/mvertescher/libsbc-rs/commit/a34d6e1', 'https://github.com/mvertescher/libsbc-rs'}
| null |
crates.io
|
RUSTSEC-2018-0002
|
Links in archives can overwrite any existing file
|
When unpacking a tarball with the `unpack_in`-family of functions it's intended
that only files within the specified directory are able to be written. Tarballs
with hard links or symlinks, however, can be used to overwrite any file on the
filesystem.
Tarballs can contain multiple entries for the same file. A tarball which first
contains an entry for a hard link or symlink pointing to any file on the
filesystem will have the link created, and then afterwards if the same file is
listed in the tarball the hard link will be rewritten and any file can be
rewritten on the filesystem.
This has been fixed in https://github.com/alexcrichton/tar-rs/pull/156 and is
published as `tar` 0.4.16. Thanks to Max Justicz for discovering this and
emailing about the issue!
|
{'CVE-2018-20990'}
|
2021-10-19T22:14:35Z
|
2018-06-29T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2018-0002.html', 'https://github.com/alexcrichton/tar-rs/pull/156', 'https://crates.io/crates/tar'}
| null |
crates.io
|
RUSTSEC-2020-0063
|
crate has been renamed to `safe-nd`
|
This crate has been renamed from `safe-nd` to `sn_data_types`.
The new repository location is:
<https://github.com/maidsafe/sn_data_types>
| null |
2020-11-02T14:43:36Z
|
2020-11-02T12:00:00Z
| null | null | null |
{'https://crates.io/crates/safe-nd', 'https://github.com/maidsafe/sn_data_types/pull/218', 'https://rustsec.org/advisories/RUSTSEC-2020-0063.html'}
| null |
crates.io
|
GHSA-mm7v-vpv8-xfc3
|
Double free in smallvec
|
An issue was discovered in the smallvec crate before 0.6.10 for Rust. There is a double free for certain grow attempts with the current capacity.
|
{'CVE-2019-15551'}
|
2021-08-19T21:22:23Z
|
2021-08-25T20:44:59Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://rustsec.org/advisories/RUSTSEC-2019-0009.html', 'https://github.com/servo/rust-smallvec/issues/148', 'https://nvd.nist.gov/vuln/detail/CVE-2019-15551', 'https://github.com/servo/rust-smallvec'}
| null |
crates.io
|
RUSTSEC-2020-0126
|
SyncChannel<T> can move 'T: !Send' to other threads
|
Affected versions of this crate unconditionally implement Send/Sync for `SyncChannel<T>`.
`SyncChannel<T>` doesn't provide access to `&T` but merely serves as a channel that consumes and returns owned `T`.
Users can create UB in safe Rust by sending `T: !Send` to other threads with `SyncChannel::send/recv` APIs. Using `T = Arc<Cell<_>` allows to create data races (which can lead to memory corruption), and using `T = MutexGuard<T>` allows to unlock a mutex from a thread that didn't lock the mutex.
|
{'CVE-2020-36446'}
|
2021-10-19T22:14:35Z
|
2020-11-15T12:00:00Z
| null | null | null |
{'https://github.com/kitsuneninetails/signal-rust/issues/2', 'https://rustsec.org/advisories/RUSTSEC-2020-0126.html', 'https://crates.io/crates/signal-simple'}
| null |
crates.io
|
GHSA-4hjg-cx88-g9f9
|
Data races in futures-intrusive
|
An issue was discovered in the futures-intrusive crate before 0.4.0 for Rust. GenericMutexGuard allows cross-thread data races of non-Sync types.
|
{'CVE-2020-35915'}
|
2021-08-19T20:49:04Z
|
2021-08-25T20:49:58Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/Matthias247/futures-intrusive', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35915', 'https://rustsec.org/advisories/RUSTSEC-2020-0072.html', 'https://github.com/Matthias247/futures-intrusive/issues/53'}
| null |
crates.io
|
GHSA-hpqh-2wqx-7qp5
|
Memory access due to code generation flaw in Cranelift module
|
There is a bug in 0.73.0 of the Cranelift x64 backend that can create a scenario that could result in a potential sandbox escape in a WebAssembly module. Users of versions 0.73.0 of Cranelift should upgrade to either 0.73.1 or 0.74 to remediate this vulnerability. Users of Cranelift prior to 0.73.0 should update to 0.73.1 or 0.74 if they were not using the old default backend.
### Description
This bug was introduced in the new backend on 2020-09-08 and first included in a release on 2020-09-30, but the new backend was not the default prior to 0.73.0. The recently-released version 0.73.0 with default settings, and prior versions with an explicit build flag to select the new backend, are vulnerable. The bug in question performs a sign-extend instead of a zero-extend on a value loaded from the stack, under a specific set of circumstances. If those circumstances occur, the bug could allow access to memory addresses up to 2GiB before the start of the heap allocated for the WebAssembly module.
If the heap bound is larger than 2GiB, then it would be possible to read memory from a computable range dependent on the size of the heap's bound.
The impact of this bug is highly dependent on heap implementation; specifically:
* if the heap has bounds checks, and
* does not rely exclusively on guard pages, and
* the heap bound is 2GiB or smaller
then this bug cannot be used to reach memory from another WebAssembly module heap.
The impact of the vulnerability is mitigated if there is no memory mapped in the range accessible using this bug, for example, if there is a 2 GiB guard region before the WebAssembly module heap.
The bug in question performs a sign-extend instead of a zero-extend on a value loaded from the stack when the register allocator reloads a spilled integer value narrower than 64 bits. This interacts poorly with another optimization: the instruction selector elides a 32-to-64-bit zero-extend operator when we know that an instruction producing a 32-bit value actually zeros the upper 32 bits of its destination register. Hence, we rely on these zeroed bits, but the type of the value is still i32, and the spill/reload reconstitutes those bits as the sign extension of the i32’s MSB.
The issue would thus occur when:
* An i32 value is greater than or equal to 0x8000_0000;
* The value is spilled and reloaded by the register allocator due to high register pressure in the program between the value’s definition and its use;
* The value is produced by an instruction that we know to be "special" in that it zeroes the upper 32 bits of its destination: add, sub, mul, and, or;
* The value is then zero-extended to 64 bits;
* The resulting 64-bit value is used.
Under these circumstances there is a potential sandbox escape when the i32 value is a pointer. The usual code emitted for heap accesses zero-extends the WebAssembly heap address, adds it to a 64-bit heap base, and accesses the resulting address. If the zero-extend becomes a sign-extend, the module could reach backward and access memory up to 2GiB before the start of its heap.
This bug was identified by developers at Fastly following a report from Javier Cabrera Arteaga, KTH Royal Institute of Technology, with support from project Trustful of Stiftelsen för Strategisk Forskning. In addition to supporting the analysis and remediation of this vulnerability, Fastly will publish a related Fastly Security Advisory at [https://www.fastly.com/security-advisories](https://www.fastly.com/security-advisories).
In addition to assessing the nature of the code generation bug in Cranelift, we have also determined that under specific circumstances, both Lucet and Wasmtime using this version of Cranelift may be exploitable.
### General Impact to Lucet
Lucet inherits the heap address computation and bounds-checks of Cranelift, which it uses as its backend code generator. Of particular importance specifically is the address-space layout used by Lucet. In the default configuration for Lucet, only a single module is running, and therefore it is not possible to access memory from another module.
By default, the open source implementation of Lucet uses a maximum heap size of 4 GiB, and an instance slot size of 8 GiB, when invoking an instance from the lucet-wasi command-line tool. These settings are within the range of vulnerability described above, but only a single instance is running, so there is no other instance to read. When embedding the runtime (for example, in a long-running daemon), the default for the heap size as described in the source is 1MB; with this setting, the runtime is not vulnerable.
Lucet allocates its WebAssembly module instances into "instance slots", which are contiguous zones of virtual address space that contain the VM context at the bottom, the WebAssembly heap in the next page after that, a guard region in the middle, and other data at the top: the stack and the globals.
If the instance slot size is less than (max heap) + 2GiB, then the lowest accessible address using the bug will overlap with the prior instance’s heap. If the size of VM context + stack + globals is greater than (4GiB - heap limit), then the highest accessible address using the bug will overlap with this critical data. If neither of these conditions are true, the bug should only result in an access to the prior instance’s guard region.
Generally, if the limit is between 2GiB and 4GiB - ~1MB (depending on stack/global size) and the instance slot size is less than 6GiB, the configuration is vulnerable. If the limit is greater than 4GiB - ~1MB, the configuration is vulnerable regardless of instance slot size. Otherwise, the configuration is not vulnerable.
### General Impact on Wasmtime
In Wasmtime, the same Cranelift heap address computations and heap types are used as above. The memory layout, however, is slightly different, with different outcomes:
* With the mmap implementation impact is mitigated probabilistically if ASLR is enabled.
* With the pooling allocator, the vulnerability only exists if a memory reservation size lower than the default of 6GB is used.
With the default mmap-based instance memory implementation, Wasmtime uses mmap() to allocate a block of memory large enough for the heap and guard region, as specified in its configuration. If the underlying OS implements ASLR (modern Linux, macOS and Windows do) then this address will be randomized, and the region below it will (probabilistically) be free. Hence, the bug is mitigated probabilistically in the default configuration if ASLR is enabled.
If using the pooling allocator, the vulnerability exists if instance memory size (`memory_reservation_size` in InstanceLimit) is strictly less than 6GiB (4 GiB + 2 GiB of guard pages). The default is 6GiB, so the vulnerability is masked in the default pooling allocator configuration.
|
{'CVE-2021-32629'}
|
2022-04-26T18:11:37Z
|
2021-08-25T21:01:55Z
|
HIGH
| null |
{'CWE-125'}
|
{'https://github.com/bytecodealliance/wasmtime/commit/95559c01aaa7c061088a433040f31e8291fb09d0', 'https://github.com/bytecodealliance/wasmtime/tree/main/cranelift', 'https://crates.io/crates/cranelift-codegen', 'https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-hpqh-2wqx-7qp5', 'https://github.com/RustSec/advisory-db/blob/main/crates/cranelift-codegen/RUSTSEC-2021-0067.md', 'https://www.fastly.com/security-advisories/memory-access-due-to-code-generation-flaw-in-cranelift-module', 'https://nvd.nist.gov/vuln/detail/CVE-2021-32629'}
| null |
crates.io
|
RUSTSEC-2021-0028
|
Multiple memory safety issues in insert_row
|
When inserting rows from an iterator at a particular index, `toodee` would shift
items over, duplicating their ownership. The space reserved for the new elements
was based on the `len()` returned by the `ExactSizeIterator`.
This could result in elements in the array being freed twice if the iterator
panics. Uninitialized or previously freed elements could also be exposed if the
`len()` didn't match the number of elements.
These issues were fixed in commit `ced70c17` by temporarily setting the length
of the array smaller while processing it and adding assertions on the number
of elements returned by the iterator.
|
{'CVE-2021-28029', 'CVE-2021-28028'}
|
2021-03-19T21:21:58Z
|
2021-02-19T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0028.html', 'https://github.com/antonmarsden/toodee/issues/13', 'https://crates.io/crates/toodee'}
| null |
crates.io
|
GHSA-j79j-cx3h-g27h
|
Out of bounds write in traitobject
|
An issue was discovered in the traitobject crate through 2020-06-01 for Rust. It has false expectations about fat pointers, possibly causing memory corruption in, for example, Rust 2.x.
|
{'CVE-2020-35881'}
|
2021-08-19T21:07:57Z
|
2021-08-25T20:48:02Z
|
CRITICAL
| null |
{'CWE-787'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0027.html', 'https://github.com/reem/rust-traitobject', 'https://github.com/reem/rust-traitobject/issues/7', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35881'}
| null |
crates.io
|
GHSA-mcrf-7hf9-f6q5
|
Unchecked vector pre-allocation
|
Affected versions of this crate pre-allocate memory on deserializing raw
buffers without checking whether there is sufficient data available.
This allows an attacker to do denial-of-service attacks by sending small
msgpack messages that allocate gigabytes of memory.
| null |
2021-08-06T19:28:40Z
|
2021-08-25T21:00:09Z
|
MODERATE
| null |
{'CWE-400'}
|
{'https://github.com/3Hren/msgpack-rust', 'https://github.com/3Hren/msgpack-rust/issues/151', 'https://rustsec.org/advisories/RUSTSEC-2017-0006.html'}
| null |
crates.io
|
RUSTSEC-2019-0008
|
Flaw in string parsing can lead to crashes due to invalid memory access.
|
The affected version of this crate did not guard against accessing memory
beyond the range of its input data. A pointer cast to read the data into
a 256-bit register could lead to a segmentation fault when the end plus
the 32 bytes (256 bit) read would overlap into the next page during string
parsing.
```
page | ... page 1 ... | ... page 2 ... |
data | x[n * 32 byte]xx__ | |
access | ..][ 32 byte ] | |
segflt | [ 32 | byte ] |
```
This allows an attacker to eventually crash a service.
The flaw was corrected by using a padding buffer for the last read from the
input. So that we are we never read over the boundary of the input data.
|
{'CVE-2019-15550'}
|
2021-10-19T22:14:35Z
|
2019-06-24T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0008.html', 'https://github.com/Licenser/simdjson-rs/pull/27', 'https://crates.io/crates/simd-json'}
| null |
crates.io
|
RUSTSEC-2020-0075
|
Unexpected panic when decoding tokens
|
Prior to `0.10.0` it was possible to have both decoding functions panic unexpectedly,
by supplying tokens with an incorrect base62 encoding.
The documentation stated that an error should have been reported instead.
|
{'CVE-2020-35918'}
|
2021-10-19T22:14:35Z
|
2020-11-29T12:00:00Z
| null | null | null |
{'https://github.com/return/branca/issues/24', 'https://rustsec.org/advisories/RUSTSEC-2020-0075.html', 'https://crates.io/crates/branca'}
| null |
crates.io
|
RUSTSEC-2020-0130
|
Bunch<T> unconditionally implements Send/Sync
|
Affected versions of this crate unconditionally implements `Send`/`Sync` for `Bunch<T>`.
This allows users to insert `T: !Sync` to `Bunch<T>`. It is possible to create a data race to a `T: !Sync` by invoking the `Bunch::get()` API (which returns `&T`) from multiple threads. It is also possible to send `T: !Send` to other threads by inserting `T` inside `Bunch<T>` and sending `Bunch<T>` to another thread, allowing to create a data race by inserting types like `T = Rc<_>`.
Such data races can lead to memory corruption.
|
{'CVE-2020-36450'}
|
2021-10-19T22:14:35Z
|
2020-11-12T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0130.html', 'https://github.com/krl/bunch/issues/1', 'https://crates.io/crates/bunch'}
| null |
crates.io
|
GHSA-pphf-f93w-gc84
|
Data race in may_queue
|
An issue was discovered in the may_queue crate through 2020-11-10 for Rust. Because Queue does not have bounds on its Send trait or Sync trait, memory corruption can occur.
|
{'CVE-2020-36217'}
|
2021-08-19T18:48:04Z
|
2021-08-25T20:51:47Z
|
MODERATE
| null |
{'CWE-662', 'CWE-787'}
|
{'https://github.com/Xudong-Huang/may/issues/88', 'https://github.com/Xudong-Huang/may', 'https://rustsec.org/advisories/RUSTSEC-2020-0111.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36217'}
| null |
crates.io
|
GHSA-vhfr-v4w9-45v8
|
Improper Input Validation in renderdoc
|
An issue was discovered in the renderdoc crate before 0.5.0 for Rust. Multiple exposed methods take self by immutable reference, which is incompatible with a multi-threaded application.
|
{'CVE-2019-16142'}
|
2021-08-19T21:22:34Z
|
2021-08-25T20:44:51Z
|
HIGH
| null |
{'CWE-20'}
|
{'https://github.com/ebkalderon/renderdoc-rs/pull/32', 'https://github.com/ebkalderon/renderdoc-rs', 'https://rustsec.org/advisories/RUSTSEC-2019-0018.html', 'https://nvd.nist.gov/vuln/detail/CVE-2019-16142'}
| null |
crates.io
|
GHSA-wq8f-46ww-6c2h
|
Integer underflow in untrusted
|
An issue was discovered in the untrusted crate before 0.6.2 for Rust. Error handling can trigger an integer underflow and panic.
|
{'CVE-2018-20989'}
|
2021-08-19T21:24:20Z
|
2021-08-25T20:43:49Z
|
HIGH
| null |
{'CWE-191'}
|
{'https://rustsec.org/advisories/RUSTSEC-2018-0001.html', 'https://nvd.nist.gov/vuln/detail/CVE-2018-20989', 'https://github.com/briansmith/untrusted/pull/20', 'https://github.com/briansmith/untrusted'}
| null |
crates.io
|
RUSTSEC-2020-0022
|
Ozone contains several memory safety issues
|
Ozone contains several memory safety issues including [out-of-bound access](https://github.com/bqv/ozone/blob/e21f948b0178ab305f644118f18d87a838c618e0/src/buffer.rs#L38-L48)
and dropping of [uninitialized memory](https://github.com/bqv/ozone/blob/e21f948b0178ab305f644118f18d87a838c618e0/src/map.rs#L94-L101).
|
{'CVE-2020-35877', 'CVE-2020-35878'}
|
2021-10-19T22:14:35Z
|
2020-07-04T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0022.html', 'https://crates.io/crates/ozone'}
| null |
crates.io
|
GHSA-qj3v-q2vj-4c8h
|
Calculation error in ark-r1cs-std
|
An issue was discovered in the ark-r1cs-std crate before 0.3.1 for Rust. It does not enforce any constraints in the FieldVar::mul_by_inverse method. Thus, a prover can produce a proof that is unsound but is nonetheless verified.
|
{'CVE-2021-38194'}
|
2021-08-18T21:27:27Z
|
2021-08-25T20:55:58Z
|
CRITICAL
| null |
{'CWE-682'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0075.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-38194', 'https://github.com/arkworks-rs/r1cs-std/pull/70', 'https://github.com/arkworks-rs/r1cs-std', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/ark-r1cs-std/RUSTSEC-2021-0075.md'}
| null |
crates.io
|
RUSTSEC-2017-0006
|
Unchecked vector pre-allocation
|
Affected versions of this crate pre-allocate memory on deserializing raw
buffers without checking whether there is sufficient data available.
This allows an attacker to do denial-of-service attacks by sending small
msgpack messages that allocate gigabytes of memory.
| null |
2020-10-02T01:29:11Z
|
2017-11-21T12:00:00Z
| null | null | null |
{'https://github.com/3Hren/msgpack-rust/issues/151', 'https://crates.io/crates/rmpv', 'https://rustsec.org/advisories/RUSTSEC-2017-0006.html'}
| null |
crates.io
|
GHSA-686f-ch3r-xwmh
|
Data races in unicycle
|
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-08-24T17:47:59Z
|
2021-08-25T20:58:17Z
|
HIGH
| null |
{'CWE-119', 'CWE-362'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36436', 'https://github.com/udoprog/unicycle/commit/6a6c367a0c25f86f998fa315ea90c328f685b194', 'https://github.com/udoprog/unicycle', 'https://github.com/udoprog/unicycle/commit/92f40b4a2c671553dfa96feacff0265206c44ce5', 'https://rustsec.org/advisories/RUSTSEC-2020-0116.html', 'https://github.com/udoprog/unicycle/issues/8'}
| null |
crates.io
|
GHSA-9mxw-4856-9cm5
|
Data races in rusb
|
An issue was discovered in the rusb crate before 0.7.0 for Rust. Because of a lack of Send and Sync bounds, a data race and memory corruption can occur.
|
{'CVE-2020-36206'}
|
2021-08-19T18:51:05Z
|
2021-08-25T20:50:51Z
|
HIGH
| null |
{'CWE-662', 'CWE-787'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36206', 'https://rustsec.org/advisories/RUSTSEC-2020-0098.html', 'https://github.com/a1ien/rusb', 'https://github.com/a1ien/rusb/issues/44'}
| null |
crates.io
|
GHSA-39vw-qp34-rmwf
|
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 |
2021-08-06T17:45:03Z
|
2021-08-25T21:00:18Z
|
MODERATE
| null |
{'CWE-674'}
|
{'https://rustsec.org/advisories/RUSTSEC-2018-0005.html', 'https://github.com/dtolnay/serde-yaml', 'https://github.com/dtolnay/serde-yaml/pull/105'}
| null |
crates.io
|
GHSA-v7q4-97x4-4qw2
|
Use of Uninitialized Resource in truetype
|
An issue was discovered in the truetype crate before 0.30.1 for Rust. Attackers can read the contents of uninitialized memory locations via a user-provided Read operation within Tape::take_bytes.
|
{'CVE-2021-28030'}
|
2021-08-19T17:22:46Z
|
2021-08-25T20:51:58Z
|
HIGH
| null |
{'CWE-908'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-28030', 'https://github.com/bodoni/truetype/issues/11', 'https://rustsec.org/advisories/RUSTSEC-2021-0029.html', 'https://github.com/bodoni/truetype'}
| null |
crates.io
|
RUSTSEC-2021-0086
|
`Read` on uninitialized buffer may cause UB ( `read_entry()` )
|
Affected versions of this crate passes an uninitialized buffer to a user-provided `Read` implementation.
There are two of such cases (`go_offset_log::read_entry()` & `offset_log::read_entry()`).
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.
| null |
2021-08-22T01:25:44Z
|
2021-01-07T12:00:00Z
| null | null | null |
{'https://crates.io/crates/flumedb', 'https://rustsec.org/advisories/RUSTSEC-2021-0086.html', 'https://github.com/sunrise-choir/flumedb-rs/issues/10'}
| null |
crates.io
|
RUSTSEC-2018-0014
|
chan is end-of-life; use crossbeam-channel instead
|
**`chan` has reached its end-of-life and is now deprecated.**
The intended successor of this crate is
[`crossbeam-channel`](https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-channel).
Its API is strikingly similar, but comes with a much better `select!` macro,
better performance, a better test suite and an all-around better
implementation.
| null |
2020-10-02T01:29:11Z
|
2018-07-31T12:00:00Z
| null | null | null |
{'https://github.com/BurntSushi/chan/commit/0a5c0d4ad4adc90a54ee04a427389acf2e157275', 'https://rustsec.org/advisories/RUSTSEC-2018-0014.html', 'https://crates.io/crates/chan'}
| null |
crates.io
|
RUSTSEC-2021-0069
|
SMTP command injection in body
|
Affected versions of lettre allowed SMTP command injection through an attacker's controlled message body. The module for escaping lines starting with a period wouldn't catch a period that was placed after a double CRLF sequence, allowing the attacker to end the current message and write arbitrary SMTP commands after it.
The flaw is fixed by correctly handling consecutive CRLF sequences.
|
{'GHSA-qc36-q22q-cjw3', 'CVE-2021-38189'}
|
2021-10-19T19:56:47Z
|
2021-05-22T12:00:00Z
| null | null | null |
{'https://crates.io/crates/lettre', 'https://rustsec.org/advisories/RUSTSEC-2021-0069.html', 'https://github.com/lettre/lettre/pull/627/commits/93458d01fed0ec81c0e7b4e98e6f35961356fae2'}
| null |
crates.io
|
RUSTSEC-2019-0028
|
Unsound `impl Follow for bool`
|
The implementation of `impl Follow for bool` allows to reinterpret arbitrary bytes as a `bool`.
In Rust `bool` has stringent requirements for its in-memory representation. Use of this function
allows to violate these requirements and invoke undefined behaviour in safe code.
|
{'CVE-2019-25004'}
|
2021-10-19T22:14:35Z
|
2019-10-20T12:00:00Z
| null | null | null |
{'https://crates.io/crates/flatbuffers', 'https://rustsec.org/advisories/RUSTSEC-2019-0028.html', 'https://github.com/google/flatbuffers/issues/5530'}
| null |
crates.io
|
GHSA-x54v-qxxr-93qc
|
Missing release of memory in sized-chunks
|
An issue was discovered in the sized-chunks crate through 0.6.2 for Rust. In the Chunk implementation, insert_from can have a memory-safety issue upon a panic.
|
{'CVE-2020-25795'}
|
2021-08-19T21:21:52Z
|
2021-08-25T20:45:01Z
|
HIGH
| null |
{'CWE-401'}
|
{'https://github.com/bodil/sized-chunks', 'https://rustsec.org/advisories/RUSTSEC-2020-0041.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-25795', 'https://github.com/bodil/sized-chunks/issues/11'}
| null |
crates.io
|
RUSTSEC-2021-0049
|
`through` and `through_and` causes a double free if the map function panics
|
`through` and `through_and` take a mutable reference as well as a mapping
function to change the provided reference. They do this by calling `ptr::read`
on the reference which duplicates ownership and then calling the mapping
function.
If the mapping function panics, both the original object and the one
duplicated by `ptr::read` get dropped, causing a double free.
|
{'CVE-2021-29940'}
|
2021-10-19T22:14:35Z
|
2021-02-18T12:00:00Z
| null | null | null |
{'https://github.com/gretchenfrage/through/issues/1', 'https://crates.io/crates/through', 'https://rustsec.org/advisories/RUSTSEC-2021-0049.html'}
| null |
crates.io
|
GHSA-2rxc-8f9w-fjq8
|
Window may read from uninitialized memory locations in rdiff
|
An issue was discovered in the rdiff crate through 2021-02-03 for Rust. Window may read from uninitialized memory locations.
|
{'CVE-2021-45694'}
|
2022-01-07T18:25:00Z
|
2022-01-06T22:14:13Z
|
HIGH
| null |
{'CWE-908'}
|
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/rdiff/RUSTSEC-2021-0094.md', 'https://rustsec.org/advisories/RUSTSEC-2021-0094.html', 'https://github.com/dyule/rdiff', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45694'}
| null |
crates.io
|
RUSTSEC-2020-0147
|
rulinalg is unmaintained, use nalgebra instead
|
The `rulinalg` crate is no longer maintained, use [nalgebra](https://crates.io/crates/nalgebra)
instead.
| null |
2021-03-04T13:58:02Z
|
2020-02-11T12:00:00Z
| null | null | null |
{'https://github.com/AtheMathmo/rulinalg/issues/201#issuecomment-584749313', 'https://crates.io/crates/rulinalg', 'https://rustsec.org/advisories/RUSTSEC-2020-0147.html'}
| null |
crates.io
|
RUSTSEC-2020-0002
|
Parsing a specially crafted message can result in a stack overflow
|
Affected versions of this crate contained a bug in which decoding untrusted
input could overflow the stack.
On architectures with stack probes (like x86), this can be used for denial of
service attacks, while on architectures without stack probes (like ARM)
overflowing the stack is unsound and can result in potential memory corruption
(or even RCE).
The flaw was quickly corrected by @danburkert and released in version 0.6.1.
|
{'CVE-2020-35858'}
|
2021-10-19T22:14:35Z
|
2020-01-16T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0002.html', 'https://github.com/danburkert/prost/issues/267', 'https://crates.io/crates/prost'}
| null |
crates.io
|
RUSTSEC-2020-0151
|
Generators can cause data races if non-Send types are used in their generator functions
|
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-10-19T22:14:35Z
|
2020-11-16T12:00:00Z
| null | null | null |
{'https://github.com/Xudong-Huang/generator-rs/issues/27', 'https://crates.io/crates/generator', 'https://rustsec.org/advisories/RUSTSEC-2020-0151.html'}
| null |
crates.io
|
RUSTSEC-2020-0014
|
Various memory safety issues
|
Several memory safety issues have been uncovered in an audit of
rusqlite.
See https://github.com/rusqlite/rusqlite/releases/tag/0.23.0 for a complete list.
|
{'CVE-2020-35873', 'CVE-2020-35868', 'CVE-2020-35870', 'CVE-2020-35867', 'CVE-2020-35872', 'CVE-2020-35871', 'CVE-2020-35869', 'CVE-2020-35866'}
|
2021-01-04T17:02:59Z
|
2020-04-23T12:00:00Z
| null | null | null |
{'https://github.com/rusqlite/rusqlite/releases/tag/0.23.0', 'https://rustsec.org/advisories/RUSTSEC-2020-0014.html', 'https://crates.io/crates/rusqlite'}
| null |
crates.io
|
RUSTSEC-2021-0008
|
reading on uninitialized buffer can cause UB (`impl<R> BufRead for GreedyAccessReader<R>`)
|
Affected versions of this crate creates an uninitialized buffer and passes it to user-provided `Read` implementation.
This is unsound, because it allows safe Rust code to exhibit an undefined behavior (read from uninitialized memory).
The flaw was corrected in version 0.1.1 by zero-initializing a newly allocated buffer
before handing it to a user-provided `Read` implementation.
|
{'CVE-2021-25905'}
|
2021-10-19T22:14:35Z
|
2021-01-02T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0008.html', 'https://crates.io/crates/bra', 'https://github.com/Enet4/bra-rs/issues/1'}
| null |
crates.io
|
GHSA-hf79-8hjp-rrvq
|
Use After Free in lucet
|
### Impact
There is a bug in the main branch of Lucet's `lucet-runtime` that allows a use-after-free in an `Instance` object that could result in memory corruption, data race, or other related issues. This bug was introduced early in the development of Lucet and is present in all releases. As a result of this bug, and dependent on the memory backing for the `Instance` objects, it is possible to trigger a use-after-free when the `Instance` is dropped.
### Patches
Users should upgrade to the `main` branch of the Lucet repository. Lucet does not provide versioned releases on crates.io.
### Workarounds
There is no way to remediate this vulnerability without upgrading.
### Description
Lucet uses a "pool" allocator for new WebAssembly instances that are created. This pool allocator manages everything from the linear memory of the wasm instance, the runtime stack for async switching, as well as the memory behind the Instance itself. `Instances` are referred to via an `InstanceHandle` type which will, on drop, release the memory backing the Instance back to the pool.
When an Instance is dropped, the fields of the `Instance` are destructed top-to-bottom, however when the `alloc: Alloc` field is destructed, the memory backing the `Instance` is released back to the pool before the destructors of the remaining fields are run. If another thread allocates the same memory from the pool while these destructors are still running, a race condition occurs that can lead to use-after-free errors.
The bug was corrected by changing how the `InstanceHandle` destructor operates to ensure that the memory backing an Instance is only returned to the pool once the `Instance` has been completely destroyed.
This security advisory has been assigned CVE-2021-43790.
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [lucet repository](https://github.com/bytecodealliance/lucet)
* Email [the lucet team](mailto:lucet@fastly.com)
* See the [Bytecode Alliance security policy](https://bytecodealliance.org/security)
|
{'CVE-2021-43790'}
|
2021-11-30T22:05:58Z
|
2021-11-30T22:20:36Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://github.com/bytecodealliance/lucet/security/advisories/GHSA-hf79-8hjp-rrvq', 'https://github.com/bytecodealliance/lucet', 'https://crates.io/crates/lucet-runtime', 'https://nvd.nist.gov/vuln/detail/CVE-2021-43790', 'https://github.com/bytecodealliance/lucet/commit/7c7757c772fb709c61b1442bcc1e1fbee97bf4a8'}
| null |
crates.io
|
RUSTSEC-2020-0106
|
Queues allow non-Send types to be sent to other threads, allowing data races
|
Affected versions of this crate 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.
The flaw was corrected in v0.1.7 by adding `T: Send` bound to to the `Send` impl of four data types explained above.
|
{'CVE-2020-36214'}
|
2021-10-19T22:14:35Z
|
2020-12-19T12:00:00Z
| null | null | null |
{'https://github.com/abbychau/multiqueue2/issues/10', 'https://rustsec.org/advisories/RUSTSEC-2020-0106.html', 'https://crates.io/crates/multiqueue2'}
| null |
crates.io
|
RUSTSEC-2020-0043
|
Insufficient size checks in outgoing buffer in ws allows remote attacker to run the process out of memory
|
Affected versions of this crate did not properly check and cap the growth of the outgoing buffer.
This allows a remote attacker to take down the process by growing the buffer of their (single) connection until the process runs out of memory it can allocate and is killed.
The flaw was corrected in the [`parity-ws` fork](https://crates.io/crates/parity-ws) (>=0.10.0) by [disconnecting a client when the buffer runs full](https://github.com/housleyjk/ws-rs/pull/328).
|
{'CVE-2020-35896'}
|
2021-10-19T22:14:35Z
|
2020-09-25T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0043.html', 'https://github.com/housleyjk/ws-rs/issues/291', 'https://crates.io/crates/ws'}
| null |
crates.io
|
GHSA-cx4j-fxr7-jxg8
|
Double free in glsl-layout
|
An issue was discovered in the glsl-layout crate before 0.4.0 for Rust. When a panic occurs, map_array can perform a double drop.
|
{'CVE-2021-25902'}
|
2021-08-19T18:43:30Z
|
2021-08-25T20:53:01Z
|
HIGH
| null |
{'CWE-415'}
|
{'https://github.com/rustgd/glsl-layout', 'https://rustsec.org/advisories/RUSTSEC-2021-0005.html', 'https://github.com/rustgd/glsl-layout/pull/10', 'https://nvd.nist.gov/vuln/detail/CVE-2021-25902'}
| null |
crates.io
|
GHSA-hr52-f9vp-582c
|
Use of Uninitialized Resource in messagepack-rs.
|
An issue was discovered in the messagepack-rs crate through 2021-01-26 for Rust. deserialize_extension_others may read from uninitialized memory locations.
|
{'CVE-2021-45692'}
|
2022-01-07T16:30:51Z
|
2022-01-06T22:12:28Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/messagepack-rs/RUSTSEC-2021-0092.md', 'https://rustsec.org/advisories/RUSTSEC-2021-0092.html', 'https://github.com/otake84/messagepack-rs', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45692'}
| null |
crates.io
|
GHSA-m2pf-hprp-3vqm
|
Use after free in image
|
An issue was discovered in the image crate before 0.21.3 for Rust, affecting the HDR image format decoder. Vec::set_len is called on an uninitialized vector, leading to a use-after-free and arbitrary code execution.
|
{'CVE-2019-16138'}
|
2021-08-19T21:22:44Z
|
2021-08-25T20:44:43Z
|
CRITICAL
| null |
{'CWE-416'}
|
{'https://github.com/image-rs/image/pull/985', 'https://nvd.nist.gov/vuln/detail/CVE-2019-16138', 'https://github.com/image-rs/image', 'https://rustsec.org/advisories/RUSTSEC-2019-0014.html'}
| null |
crates.io
|
RUSTSEC-2021-0073
|
Conversion from `prost_types::Timestamp` to `SystemTime` can cause an overflow and panic
|
Affected versions of this crate contained a bug in which untrusted input could cause an overflow and panic when converting a `Timestamp` to `SystemTime`.
It is recommended to upgrade to `prost-types` v0.8 and switch the usage of `From<Timestamp> for SystemTime` to `TryFrom<Timestamp> for SystemTime`.
See [#438] for more information.
[#438]: https://github.com/tokio-rs/prost/issues/438
|
{'CVE-2021-38192'}
|
2021-11-06T20:37:35Z
|
2021-07-08T12:00:00Z
| null | null | null |
{'https://crates.io/crates/prost-types', 'https://github.com/tokio-rs/prost/issues/438', 'https://rustsec.org/advisories/RUSTSEC-2021-0073.html'}
| null |
crates.io
|
RUSTSEC-2020-0038
|
Memory safety issues in `compact::Vec`
|
`compact::Vec` contains multiple memory safety issues.
1. It mishandles large capacity and causes out-of-bound access in 32-bit / allocator layout mismatch in 64-bit.
2. `remove()` is not panic-safe and causes double-free when an index larger than the length is provided.
|
{'CVE-2020-35890', 'CVE-2020-35891'}
|
2021-10-19T22:14:35Z
|
2020-09-03T12:00:00Z
| null | null | null |
{'https://crates.io/crates/ordnung', 'https://github.com/maciejhirsz/ordnung/issues/8', 'https://rustsec.org/advisories/RUSTSEC-2020-0038.html'}
| null |
crates.io
|
GHSA-gv73-9mwv-fwgq
|
Out of bounds write in prost
|
An issue was discovered in the prost crate before 0.6.1 for Rust. There is stack consumption via a crafted message, causing a denial of service (e.g., x86) or possibly remote code execution (e.g., ARM).
|
{'CVE-2020-35858'}
|
2021-08-19T21:20:08Z
|
2021-08-25T20:46:11Z
|
CRITICAL
| null |
{'CWE-787'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0002.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35858', 'https://github.com/danburkert/prost', 'https://github.com/danburkert/prost/issues/267'}
| null |
crates.io
|
RUSTSEC-2021-0024
|
crate has been renamed to `sn_api`
|
This crate has been renamed from `safe-api` to `sn_api`.
The new repository location is:
<https://github.com/maidsafe/sn_api>
| null |
2021-02-15T16:43:30Z
|
2021-02-15T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0024.html', 'https://github.com/maidsafe/sn_api/pull/619', 'https://crates.io/crates/safe-api'}
| null |
crates.io
|
RUSTSEC-2019-0012
|
Memory corruption in SmallVec::grow()
|
Attempting to call `grow` on a spilled SmallVec with a value less than the current capacity causes corruption of memory allocator data structures.
An attacker that controls the value passed to `grow` may exploit this flaw to obtain memory contents or gain remote code execution.
Credits to @ehuss for discovering, reporting and fixing the bug.
|
{'CVE-2019-15554'}
|
2021-10-19T22:14:35Z
|
2019-07-19T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0012.html', 'https://github.com/servo/rust-smallvec/issues/149', 'https://crates.io/crates/smallvec'}
| null |
crates.io
|
RUSTSEC-2020-0080
|
`miow` invalidly assumes the memory layout of std::net::SocketAddr
|
The [`miow`](https://crates.io/crates/miow) 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-2020-35921'}
|
2021-10-19T22:14:35Z
|
2020-11-13T12:00:00Z
| null | null | null |
{'https://github.com/yoshuawuyts/miow/issues/38', 'https://crates.io/crates/miow', 'https://rustsec.org/advisories/RUSTSEC-2020-0080.html'}
| null |
crates.io
|
GHSA-gx5w-rrhp-f436
|
XSS in mdBook
|
> This is a cross-post of [the official security advisory][ml]. The official post contains a signed version with our PGP key, as well.
[ml]: https://groups.google.com/g/rustlang-security-announcements/c/3-sO6of29O0
The Rust Security Response Working Group was recently notified of a security issue affecting the search feature of mdBook, which could allow an attacker to execute arbitrary JavaScript code on the page.
The CVE for this vulnerability is [CVE-2020-26297](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-26297).
## Overview
The search feature of mdBook (introduced in version 0.1.4) was affected by a cross site scripting vulnerability that allowed an attacker to execute arbitrary JavaScript code on an user's browser by tricking the user into typing a malicious search query, or tricking the user into clicking a link to the search page with the malicious search query prefilled.
mdBook 0.4.5 fixes the vulnerability by properly escaping the search query.
## Mitigations
Owners of websites built with mdBook have to upgrade to mdBook 0.4.5 or greater and rebuild their website contents with it. It's possible to install mdBook 0.4.5 on the local system with:
```
cargo install mdbook --version 0.4.5 --force
```
## Acknowledgements
Thanks to Kamil Vavra for responsibly disclosing the vulnerability to us according to [our security policy](https://www.rust-lang.org/policies/security).
## Timeline of events
All times are listed in UTC.
- 2020-12-30 20:14 - The issue is reported to the Rust Security Response WG
- 2020-12-30 20:32 - The issue is acknowledged and the investigation began
- 2020-12-30 21:21 - Found the cause of the vulnerability and prepared the patch
- 2021-01-04 15:00 - Patched version released and vulnerability disclosed
|
{'CVE-2020-26297'}
|
2021-08-18T21:06:53Z
|
2021-08-25T20:56:20Z
|
HIGH
| null |
{'CWE-79'}
|
{'https://github.com/rust-lang/mdBook/blob/master/CHANGELOG.md#mdbook-045', 'https://nvd.nist.gov/vuln/detail/CVE-2020-26297', 'https://rustsec.org/advisories/RUSTSEC-2021-0001.html', 'https://github.com/rust-lang/mdBook/security/advisories/GHSA-gx5w-rrhp-f436', 'https://github.com/rust-lang/mdBook/commit/32abeef088e98327ca0dfccdad92e84afa9d2e9b', 'https://github.com/rust-lang/mdBook', 'https://groups.google.com/g/rustlang-security-announcements/c/3-sO6of29O0'}
| null |
crates.io
|
RUSTSEC-2021-0032
|
Deserializing an array can drop uninitialized memory on panic
|
The `read_bytes_default_le` function for `[T; n]` arrays, used to deserialize
arrays of `T` from bytes created a `[T; n]` array with `std::mem::uninitialized`
and then called `T`'s deserialization method.
If `T`'s deserialization method panicked, the uninitialized memory could drop
invalid objects.
This flaw was corrected in `a535678` by removing the unsafe block and using
a `.map` function to deserialize each element of the array instead.
|
{'CVE-2021-28033'}
|
2021-10-19T22:14:35Z
|
2021-03-01T12:00:00Z
| null | null | null |
{'https://github.com/wwylele/byte-struct-rs/issues/1', 'https://crates.io/crates/byte_struct', 'https://rustsec.org/advisories/RUSTSEC-2021-0032.html'}
| null |
crates.io
|
GHSA-c9h5-hf8r-m97x
|
Dangling reference in flatbuffers
|
An issue was discovered in the flatbuffers crate through 2020-04-11 for Rust. read_scalar (and read_scalar_at) can transmute values without unsafe blocks.
|
{'CVE-2020-35864'}
|
2021-08-19T21:18:24Z
|
2021-08-25T20:47:36Z
|
HIGH
| null |
{'CWE-704'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-35864', 'https://github.com/google/flatbuffers/issues/5825', 'https://github.com/google/flatbuffers', 'https://rustsec.org/advisories/RUSTSEC-2020-0009.html'}
| null |
crates.io
|
RUSTSEC-2020-0079
|
`socket2` invalidly assumes the memory layout of std::net::SocketAddr
|
The [`socket2`](https://crates.io/crates/socket2) 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-2020-35920'}
|
2021-10-19T22:14:35Z
|
2020-11-06T12:00:00Z
| null | null | null |
{'https://crates.io/crates/socket2', 'https://rustsec.org/advisories/RUSTSEC-2020-0079.html', 'https://github.com/rust-lang/socket2-rs/issues/119'}
| null |
crates.io
|
RUSTSEC-2019-0004
|
Failure to properly verify ed25519 signatures makes any signature valid
|
Affected versions of this crate did not properly verify ed25519 signatures.
Any signature with a correct length was considered valid.
This allows an attacker to impersonate any node identity.
|
{'CVE-2019-15545'}
|
2021-10-19T22:14:35Z
|
2019-05-15T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0004.html', 'https://crates.io/crates/libp2p-core'}
| null |
crates.io
|
GHSA-ppj3-7jw3-8vc4
|
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 MappedMutexGuard unsoundness.
|
{'CVE-2020-35910'}
|
2021-08-19T20:53:30Z
|
2021-08-25T20:49:35Z
|
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-35910'}
| null |
crates.io
|
RUSTSEC-2020-0096
|
TreeFocus lacks bounds on its Send and Sync traits
|
Affected versions of `im` contains `TreeFocus` that unconditionally implements `Send` and `Sync`.
This allows a data race in safe Rust code if `TreeFocus` is extracted from `Focus` type.
Typical users that only use `Focus` type are not affected.
|
{'CVE-2020-36204'}
|
2021-10-19T22:14:35Z
|
2020-11-09T12:00:00Z
| null | null | null |
{'https://github.com/bodil/im-rs/issues/157', 'https://rustsec.org/advisories/RUSTSEC-2020-0096.html', 'https://crates.io/crates/im'}
| null |
crates.io
|
GHSA-fqq2-xp7m-xvm8
|
Data race in ruspiro-singleton
|
`Singleton<T>` is meant to be a static object that can be initialized lazily. In
order to satisfy the requirement that `static` items must implement `Sync`,
`Singleton` implemented both `Sync` and `Send` unconditionally.
This allows for a bug where non-`Sync` types such as `Cell` can be used in
singletons and cause data races in concurrent programs.
The flaw was corrected in commit `b0d2bd20e` by adding trait bounds, requiring
the contaiend type to implement `Sync`.
|
{'CVE-2020-36435'}
|
2021-08-24T17:45:32Z
|
2021-08-25T20:58:19Z
|
HIGH
| null |
{'CWE-119', 'CWE-362'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36435', 'https://rustsec.org/advisories/RUSTSEC-2020-0115.html', 'https://github.com/RusPiRo/ruspiro-singleton/pull/11', 'https://github.com/RusPiRo/ruspiro-singleton/issues/10', 'https://github.com/RusPiRo/ruspiro-singleton', 'https://github.com/RusPiRo/ruspiro-singleton/commit/b0d2bd20eb40b9cbc2958b981ba2dcd9e6f9396e'}
| null |
crates.io
|
RUSTSEC-2021-0120
|
abomonation transmutes &T to and from &[u8] without sufficient constraints
|
This transmute is at the core of the abomonation crates. It's so easy to use it to violate alignment requirements that no test in the crate's test suite passes under miri.
The use of this transmute in serialization/deserialization also incorrectly assumes that the layout of a repr(Rust) type is stable.
This transmute can also disclose both the contents of padding bytes which may be an information leak and the contents of pointers, which may be used to defeat ASLR.
| null |
2021-10-17T21:33:02Z
|
2021-10-17T12:00:00Z
| null | null | null |
{'https://crates.io/crates/abomonation', 'https://github.com/TimelyDataflow/abomonation/issues/23', 'https://rustsec.org/advisories/RUSTSEC-2021-0120.html'}
| null |
crates.io
|
RUSTSEC-2021-0065
|
anymap is unmaintained.
|
The `anymap` crate does not appear to be maintained, and the most recent
published version 0.12.1 includes a soundness bug. This has been
[fixed](https://github.com/chris-morgan/anymap/pull/32) a few years ago, but
was never released.
|
{'CVE-2021-38187'}
|
2021-11-06T20:37:35Z
|
2021-05-07T12:00:00Z
| null | null | null |
{'https://crates.io/crates/anymap', 'https://github.com/chris-morgan/anymap/issues/37', 'https://rustsec.org/advisories/RUSTSEC-2021-0065.html'}
| null |
crates.io
|
RUSTSEC-2018-0018
|
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 |
2020-10-02T01:29:11Z
|
2018-09-25T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2018-0018.html', 'https://crates.io/crates/smallvec', 'https://github.com/servo/rust-smallvec/issues/126'}
| null |
crates.io
|
RUSTSEC-2021-0081
|
Potential request smuggling capabilities due to lack of input validation
|
Affected versions of this crate did not properly detect invalid requests that could allow HTTP/1 request smuggling (HRS) attacks when running alongside a vulnerable front-end proxy server. This can result in leaked internal and/or user data, including credentials, when the front-end proxy is also vulnerable.
Popular front-end proxies and load balancers already mitigate HRS attacks so it is recommended that they are also kept up to date; check your specific set up. You should upgrade even if the front-end proxy receives exclusively HTTP/2 traffic and connects to the back-end using HTTP/1; several downgrade attacks are known that can also expose HRS vulnerabilities.
|
{'CVE-2021-38512'}
|
2021-10-19T22:14:35Z
|
2021-06-16T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0081.html', 'https://crates.io/crates/actix-http'}
| null |
crates.io
|
GHSA-2r6q-6c8c-g762
|
Data races in toolshed
|
An issue was discovered in the toolshed crate through 2020-11-15 for Rust. In CopyCell<T>, the Send trait lacks bounds on the contained type.
|
{'CVE-2020-36456'}
|
2021-08-18T20:21:02Z
|
2021-08-25T20:58:03Z
|
HIGH
| null |
{'CWE-77', 'CWE-362'}
|
{'https://github.com/ratel-rust/toolshed', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36456', 'https://github.com/ratel-rust/toolshed/issues/12', 'https://rustsec.org/advisories/RUSTSEC-2020-0136.html'}
| null |
crates.io
|
RUSTSEC-2018-0013
|
Vec-to-vec transmutations could lead to heap overflow/corruption
|
Affected versions of this crate switched the length and capacity arguments in the Vec::from_raw_parts() constructor,
which could lead to memory corruption or data leakage.
The flaw was corrected by using the constructor correctly.
|
{'CVE-2018-21000'}
|
2021-10-19T22:14:35Z
|
2018-11-27T12:00:00Z
| null | null | null |
{'https://github.com/nabijaczleweli/safe-transmute-rs/pull/36', 'https://rustsec.org/advisories/RUSTSEC-2018-0013.html', 'https://crates.io/crates/safe-transmute'}
| null |
crates.io
|
GHSA-83r8-p8v6-6gfm
|
Slock<T> allows sending non-Send types across thread boundaries
|
`Slock<T>` unconditionally implements `Send`/`Sync`.
Affected versions of this crate allows sending non-Send types to other threads,
which can lead to data races and memory corruption due to the data race.
| null |
2021-08-06T17:28:42Z
|
2021-08-25T21:00:20Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/BrokenLamp/slock-rs', 'https://rustsec.org/advisories/RUSTSEC-2020-0135.html', 'https://github.com/BrokenLamp/slock-rs/issues/2'}
| null |
crates.io
|
RUSTSEC-2020-0025
|
bigint is unmaintained, use uint instead
|
The `bigint` crate is not maintained any more and contains several known bugs (including a soundness bug);
use [`uint`](https://crates.io/crates/uint) instead.
|
{'CVE-2020-35880'}
|
2021-10-19T22:14:35Z
|
2020-05-07T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0025.html', 'https://github.com/paritytech/bigint/commit/7e71521a61b009afc94c91135353102658550d42', 'https://crates.io/crates/bigint'}
| null |
crates.io
|
RUSTSEC-2020-0160
|
Threshold value is ignored (all shares are n=3)
|
Affected versions of this crate did not properly calculate secret shares requirements.
This reduces the security of the algorithm by restricting the crate to always
using a threshold value of three, rather than a configurable limit.
The flaw was corrected by correctly configuring the threshold.
| null |
2021-12-27T19:42:26Z
|
2020-01-21T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0160.html', 'https://github.com/Nebulosus/shamir/issues/3', 'https://crates.io/crates/shamir'}
| null |
crates.io
|
RUSTSEC-2017-0001
|
scalarmult() vulnerable to degenerate public keys
|
The `scalarmult()` function included in previous versions of this crate
accepted all-zero public keys, for which the resulting Diffie-Hellman shared
secret will always be zero regardless of the private key used.
This issue was fixed by checking for this class of keys and rejecting them
if they are used.
|
{'CVE-2017-1000168'}
|
2021-10-19T22:14:35Z
|
2017-01-26T12:00:00Z
| null | null | null |
{'https://github.com/dnaq/sodiumoxide/issues/154', 'https://rustsec.org/advisories/RUSTSEC-2017-0001.html', 'https://crates.io/crates/sodiumoxide'}
| null |
crates.io
|
RUSTSEC-2021-0039
|
panic in user-provided `Endian` impl triggers double drop of T
|
Affected versions of the crate does not guard against panic from user-provided impl of `Endian` trait, which is a safe trait that users can implement.
If a user-provided implementation of the `Endian` trait panics, double-drop is triggered due to the duplicated ownership of `T` created by `ptr::read()`.
Double-drop (or double free) can cause memory corruption in the heap.
|
{'CVE-2021-29929'}
|
2021-10-19T22:14:35Z
|
2021-01-04T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0039.html', 'https://crates.io/crates/endian_trait', 'https://gitlab.com/myrrlyn/endian_trait/-/issues/1'}
| null |
crates.io
|
RUSTSEC-2020-0072
|
GenericMutexGuard allows data races of non-Sync types across threads
|
`GenericMutexGuard<T>` was given the `Sync` auto trait as long as `T` is `Send`
due to its contained members. However, since the guard is supposed to represent
an **acquired lock** and allows concurrent access to the underlying data from
different threads, it should only be `Sync` when the underlying data is.
This is a soundness issue and allows data races, potentially leading to crashes
and segfaults from safe Rust code.
The flaw was corrected by adding a `T: Send + Sync` bound for
`GenericMutexGuard`'s `Sync` trait.
This bug is [similar to one](https://github.com/rust-lang/rust/issues/41622) in
`std::sync::Mutex`.
|
{'CVE-2020-35915'}
|
2021-10-19T22:14:35Z
|
2020-10-31T12:00:00Z
| null | null | null |
{'https://github.com/Matthias247/futures-intrusive/issues/53', 'https://rustsec.org/advisories/RUSTSEC-2020-0072.html', 'https://crates.io/crates/futures-intrusive'}
| null |
crates.io
|
GHSA-hhw2-pqhf-vmx2
|
Use after free in actix-utils
|
An issue was discovered in the actix-utils crate before 2.0.0 for Rust. The Cell implementation allows obtaining more than one mutable reference to the same data.
|
{'CVE-2020-35898'}
|
2021-08-19T20:53:53Z
|
2021-08-25T20:49:09Z
|
CRITICAL
| null |
{'CWE-416'}
|
{'https://github.com/actix/actix-net/issues/160', 'https://rustsec.org/advisories/RUSTSEC-2020-0045.html', 'https://github.com/actix/actix-net', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35898'}
| null |
crates.io
|
RUSTSEC-2020-0137
|
AtomicBox<T> lacks bound on its Send and Sync traits allowing data races
|
`AtomicBox<T>` is a `Box` type designed to be used across threads, however, it
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-10-19T22:14:35Z
|
2020-11-10T12:00:00Z
| null | null | null |
{'https://crates.io/crates/lever', 'https://github.com/vertexclique/lever/issues/15', 'https://rustsec.org/advisories/RUSTSEC-2020-0137.html'}
| null |
crates.io
|
GHSA-f9xr-3m55-5q2v
|
Data races in cgc
|
An issue was discovered in the cgc crate through 2020-12-10 for Rust. Ptr implements Send and Sync for all types.
|
{'CVE-2020-36466'}
|
2021-08-18T21:15:49Z
|
2021-08-25T20:56:14Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/playXE/cgc', 'https://github.com/playXE/cgc/issues/5', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36466', 'https://rustsec.org/advisories/RUSTSEC-2020-0148.html'}
| null |
crates.io
|
GHSA-24g6-5rx7-58wj
|
Missing Initialization of Resource in pnet
|
An issue was discovered in the pnet crate before 0.27.2 for Rust. There is a segmentation fault (upon attempted dereference of an uninitialized descriptor) because of an erroneous IcmpTransportChannelIterator compiler optimization.
|
{'CVE-2019-25054'}
|
2022-01-07T16:13:36Z
|
2022-01-06T22:18:07Z
|
HIGH
| null |
{'CWE-909'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-25054', 'https://github.com/libpnet/libpnet/', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/pnet/RUSTSEC-2019-0037.md', 'https://rustsec.org/advisories/RUSTSEC-2019-0037.html'}
| null |
crates.io
|
RUSTSEC-2020-0064
|
crate has been renamed to `sn_ffi_utils`
|
This crate has been renamed from `ffi_utils` to `sn_ffi_utils`.
The new repository location is:
<https://github.com/maidsafe/sn_ffi_utils>
| null |
2020-11-02T14:45:15Z
|
2020-11-02T12:00:00Z
| null | null | null |
{'https://github.com/maidsafe/sn_ffi_utils/pull/45', 'https://rustsec.org/advisories/RUSTSEC-2020-0064.html', 'https://crates.io/crates/ffi_utils'}
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.