ecosystem
stringclasses 14
values | vuln_id
stringlengths 10
19
| summary
stringlengths 4
267
⌀ | details
stringlengths 9
13.5k
| aliases
stringlengths 17
144
⌀ | modified_date
stringdate 2010-05-27 05:47:00
2022-05-10 08:46:52
| published_date
stringdate 2005-12-31 05:00:00
2022-05-10 08:46:50
| severity
stringclasses 5
values | score
float64 0
10
⌀ | cwe_id
stringclasses 988
values | refs
stringlengths 30
17.7k
⌀ | introduced
stringlengths 75
4.26k
⌀ |
|---|---|---|---|---|---|---|---|---|---|---|---|
crates.io
|
GHSA-x4qm-mcjq-v2gf
|
Overflow in prost-types
|
An issue was discovered in the prost-types crate before 0.8.0 for Rust. An overflow can occur during conversion from Timestamp to SystemTime.
|
{'CVE-2021-38192'}
|
2021-08-18T21:29:54Z
|
2021-08-25T20:55:53Z
|
HIGH
| null |
{'CWE-190', 'CWE-120'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-38192', 'https://github.com/tokio-rs/prost/issues/438', 'https://github.com/tokio-rs/prost/tree/master/prost-types', 'https://rustsec.org/advisories/RUSTSEC-2021-0073.html'}
| null |
crates.io
|
GHSA-pf3p-x6qj-6j7q
|
mio invalidly assumes the memory layout of std::net::SocketAddr
|
An issue was discovered in the mio crate before 0.7.6 for Rust. It has false expectations about the std::net::SocketAddr memory representation.
|
{'CVE-2020-35922'}
|
2021-08-19T18:54:14Z
|
2021-08-25T20:50:33Z
|
MODERATE
| null |
{'CWE-188'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0081.html', 'https://github.com/tokio-rs/mio', 'https://github.com/tokio-rs/mio/issues/1386', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35922'}
| null |
crates.io
|
RUSTSEC-2020-0084
|
crate has been superseded by `sn_client`
|
This crate has been superseded by `sn_client`.
The new repository location is:
<https://github.com/maidsafe/sn_client>
| null |
2020-12-07T17:22:02Z
|
2020-12-07T12:00:00Z
| null | null | null |
{'https://github.com/maidsafe/sn_client/pull/1267', 'https://crates.io/crates/safe_authenticator', 'https://rustsec.org/advisories/RUSTSEC-2020-0084.html'}
| null |
crates.io
|
RUSTSEC-2019-0016
|
Use-after-free in buffer conversion implementation
|
The From<Buffer> implementation for Vec<u8> was not properly implemented,
returning a vector backed by freed memory. This could lead to memory corruption
or be exploited to cause undefined behavior.
A fix was published in version 0.1.3.
|
{'CVE-2019-16140'}
|
2021-10-19T22:14:35Z
|
2019-09-01T12:00:00Z
| null | null | null |
{'https://github.com/sagebind/isahc/issues/2', 'https://crates.io/crates/chttp', 'https://rustsec.org/advisories/RUSTSEC-2019-0016.html'}
| null |
crates.io
|
RUSTSEC-2021-0020
|
Multiple Transfer-Encoding headers misinterprets request payload
|
hyper's HTTP server code had a flaw that incorrectly understands some requests
with multiple transfer-encoding headers to have a chunked payload, when it
should have been rejected as illegal. This combined with an upstream HTTP proxy
that understands the request payload boundary differently can result in
"request smuggling" or "desync attacks".
|
{'CVE-2021-21299', 'GHSA-6hfq-h8hq-87mf'}
|
2021-10-19T22:14:35Z
|
2021-02-05T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0020.html', 'https://github.com/hyperium/hyper/security/advisories/GHSA-6hfq-h8hq-87mf', 'https://crates.io/crates/hyper'}
| null |
crates.io
|
GHSA-4xj5-vv9x-63jp
|
Data races in concread
|
An issue was discovered in the concread crate before 0.2.6 for Rust. Attackers can cause an ARCache<K,V> data race by sending types that do not implement Send/Sync.
|
{'CVE-2020-35928'}
|
2021-08-19T18:56:22Z
|
2021-08-25T20:50:22Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/kanidm/concread/issues/48', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35928', 'https://rustsec.org/advisories/RUSTSEC-2020-0092.html', 'https://github.com/kanidm/concread'}
| null |
crates.io
|
RUSTSEC-2016-0004
|
libusb is unmaintained; use rusb instead
|
The `libusb` crate has not seen a release since September 2016, and its author
is unresponsive.
The `rusb` crate is a maintained fork:
https://github.com/a1ien/rusb
| null |
2020-10-02T01:29:11Z
|
2016-09-10T12:00:00Z
| null | null | null |
{'https://github.com/dcuddeback/libusb-rs/issues/33', 'https://crates.io/crates/libusb', 'https://rustsec.org/advisories/RUSTSEC-2016-0004.html'}
| null |
crates.io
|
RUSTSEC-2021-0077
|
`better-macro` has deliberate RCE to prove a point
|
[better-macro](https://crates.io/crates/better-macro) is a fake crate which is
"Proving A Point" that proc-macros can run arbitrary code. This is not a particularly
novel or interesting observation.
It currently opens `https://github.com/raycar5/better-macro/blob/master/doc/hi.md`
which doesn't appear to have any malicious content, but there's no guarantee that
will remain the case.
This crate has no useful functionality, and should not be used.
|
{'CVE-2021-38196'}
|
2021-11-06T20:37:35Z
|
2021-07-22T12:00:00Z
| null | null | null |
{'https://github.com/raycar5/better-macro/blob/24ff1702397b9c19bbfa4c660e2316cd77d3b900/src/lib.rs#L36-L38', 'https://crates.io/crates/better-macro', 'https://rustsec.org/advisories/RUSTSEC-2021-0077.html'}
| null |
crates.io
|
GHSA-gx73-2498-r55c
|
Unsound casting in flatbuffers
|
An issue was discovered in the flatbuffers crate before 0.6.1 for Rust. Arbitrary bytes can be reinterpreted as a bool, defeating soundness.
|
{'CVE-2019-25004'}
|
2021-08-19T21:19:36Z
|
2021-08-25T20:46:49Z
|
CRITICAL
| null |
{'CWE-704'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-25004', 'https://rustsec.org/advisories/RUSTSEC-2019-0028.html', 'https://github.com/google/flatbuffers/issues/5530', 'https://github.com/google/flatbuffers'}
| null |
crates.io
|
RUSTSEC-2021-0098
|
Read buffer overruns processing ASN.1 strings
|
ASN.1 strings are represented internally within OpenSSL as an ASN1_STRING
structure which contains a buffer holding the string data and a field holding
the buffer length. This contrasts with normal C strings which are represented as
a buffer for the string data which is terminated with a NUL (0) byte.
Although not a strict requirement, ASN.1 strings that are parsed using OpenSSL's
own "d2i" functions (and other similar parsing functions) as well as any string
whose value has been set with the ASN1_STRING_set() function will additionally
NUL terminate the byte array in the ASN1_STRING structure.
However, it is possible for applications to directly construct valid ASN1_STRING
structures which do not NUL terminate the byte array by directly setting the
"data" and "length" fields in the ASN1_STRING array. This can also happen by
using the `ASN1_STRING_set0()` function.
Numerous OpenSSL functions that print ASN.1 data have been found to assume that
the ASN1_STRING byte array will be NUL terminated, even though this is not
guaranteed for strings that have been directly constructed. Where an application
requests an ASN.1 structure to be printed, and where that ASN.1 structure
contains ASN1_STRINGs that have been directly constructed by the application
without NUL terminating the "data" field, then a read buffer overrun can occur.
The same thing can also occur during name constraints processing of certificates
(for example if a certificate has been directly constructed by the application
instead of loading it via the OpenSSL parsing functions, and the certificate
contains non NUL terminated ASN1_STRING structures). It can also occur in the
`X509_get1_email()`, `X509_REQ_get1_email()` and `X509_get1_ocsp()` functions.
If a malicious actor can cause an application to directly construct an
ASN1_STRING and then process it through one of the affected OpenSSL functions
then this issue could be hit. This might result in a crash (causing a Denial of
Service attack). It could also result in the disclosure of private memory
contents (such as private keys, or sensitive plaintext).
|
{'CVE-2021-3712'}
|
2021-10-19T22:14:35Z
|
2021-08-24T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0098.html', 'https://crates.io/crates/openssl-src', 'https://www.openssl.org/news/secadv/20210824.txt'}
| null |
crates.io
|
RUSTSEC-2021-0132
|
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.
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.
|
{'CVE-2020-8927'}
|
2021-12-21T22:27:44Z
|
2021-12-20T12:00:00Z
| null | null | null |
{'https://crates.io/crates/compu-brotli-sys', 'https://rustsec.org/advisories/RUSTSEC-2021-0132.html', 'https://github.com/google/brotli/releases/tag/v1.0.9'}
| null |
crates.io
|
RUSTSEC-2020-0047
|
array_queue pop_back() may cause a use-after-free
|
array_queue implements a circular queue that wraps around an array. However, it
fails to properly index into the array in the `pop_back` function allowing the
reading of previously dropped or uninitialized memory.
|
{'CVE-2020-35900'}
|
2021-10-19T22:14:35Z
|
2020-09-26T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0047.html', 'https://github.com/raviqqe/array-queue/issues/2', 'https://crates.io/crates/array-queue'}
| null |
crates.io
|
RUSTSEC-2020-0102
|
LateStatic has incorrect Sync bound
|
Affected versions of this crate implemented `Sync` for `LateStatic` with `T: Send`, so that it is possible to create a data race to a type `T: Send + !Sync` (e.g. `Cell<T>`).
This can result in a memory corruption or other kinds of undefined behavior.
The flaw was corrected in commit 11f396c by replacing the `T: Send` bound to `T: Sync` bound in the `Sync` impl for `LateStatic<T>`.
|
{'CVE-2020-36209'}
|
2021-10-19T22:14:35Z
|
2020-11-10T12:00:00Z
| null | null | null |
{'https://github.com/Richard-W/late-static/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2020-0102.html', 'https://crates.io/crates/late-static'}
| null |
crates.io
|
GHSA-p2q9-9cq6-h3jw
|
Out of bounds read in Ozone
|
An issue was discovered in the ozone crate through 2020-07-04 for Rust. Memory safety is violated because of out-of-bounds access.
|
{'CVE-2020-35877'}
|
2021-08-19T21:08:51Z
|
2021-08-25T20:47:46Z
|
CRITICAL
| null |
{'CWE-119'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-35877', 'https://rustsec.org/advisories/RUSTSEC-2020-0022.html', 'https://github.com/bqv/ozone'}
| null |
crates.io
|
RUSTSEC-2020-0010
|
tiberius is unmaintained
|
The author of `tiberius` has archived the GitHub repository and left the
following note:
> I do not have the time to overhaul the library and do not intend to further
> maintain the 0.3 version relying on the old futures ecosystem.
Suggested alternatives are:
- [`odbc`](https://crates.io/crates/odbc)
- [`sqlx`](https://github.com/launchbadge/sqlx/issues/116) (forthcoming)
| null |
2020-10-02T01:29:11Z
|
2020-02-28T12:00:00Z
| null | null | null |
{'https://crates.io/crates/tiberius', 'https://rustsec.org/advisories/RUSTSEC-2020-0010.html', 'https://github.com/RustSec/advisory-db/issues/261'}
| null |
crates.io
|
GHSA-jqjj-r4qp-x2gh
|
Use of Uninitialized Resource in messagepack-rs.
|
An issue was discovered in the messagepack-rs crate through 2021-01-26 for Rust. deserialize_string_primitive may read from uninitialized memory locations.
|
{'CVE-2021-45693'}
|
2022-01-07T16:25:54Z
|
2022-01-06T22:12:42Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0092.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45693', 'https://github.com/otake84/messagepack-rs', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/messagepack-rs/RUSTSEC-2021-0092.md'}
| null |
crates.io
|
GHSA-r2x6-vrxx-jgv4
|
Data races in multiqueue
|
An issue was discovered in the multiqueue crate through 2020-12-25 for Rust. There are unconditional implementations of Send for InnerSend<RW, T>, InnerRecv<RW, T>, FutInnerSend<RW, T>, and FutInnerRecv<RW, T>.
|
{'CVE-2020-36463'}
|
2021-08-18T20:19:20Z
|
2021-08-25T20:58:07Z
|
HIGH
| null |
{'CWE-77', 'CWE-362'}
|
{'https://github.com/schets/multiqueue', 'https://rustsec.org/advisories/RUSTSEC-2020-0143.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36463', 'https://github.com/schets/multiqueue/issues/31', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/multiqueue/RUSTSEC-2020-0143.md'}
| null |
crates.io
|
RUSTSEC-2020-0155
|
`Read` on uninitialized buffer in `fill_buf()` and `read_up_to()`
|
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-22T01:32:53Z
|
2020-12-27T12:00:00Z
| null | null | null |
{'https://crates.io/crates/acc_reader', 'https://github.com/netvl/acc_reader/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2020-0155.html'}
| null |
crates.io
|
GHSA-955p-rc5h-hg6h
|
Double free in arenavec
|
An issue was discovered in the arenavec crate through 2021-01-12 for Rust. A double drop can sometimes occur upon a panic in T::drop().
|
{'CVE-2021-29931'}
|
2021-08-19T17:08:56Z
|
2021-08-25T20:55:04Z
|
HIGH
| null |
{'CWE-415'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-29931', 'https://github.com/ibabushkin/arenavec', 'https://github.com/ibabushkin/arenavec/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0040.html'}
| null |
crates.io
|
RUSTSEC-2020-0006
|
Flaw in `realloc` allows reading unknown memory
|
When `realloc`ing, if we allocate new space, we need to copy the old
allocation's bytes into the new space. There are `old_size` number of bytes in
the old allocation, but we were accidentally copying `new_size` number of bytes,
which could lead to copying bytes into the realloc'd space from past the chunk
that we're bump allocating out of, from unknown memory.
If an attacker can cause `realloc`s, and can read the `realoc`ed data back,
this could allow them to read things from other regions of memory that they
shouldn't be able to. For example, if some crypto keys happened to live in
memory right after a chunk we were bump allocating out of, this could allow
the attacker to read the crypto keys.
Beyond just fixing the bug and adding a regression test, I've also taken two
additional steps:
1. While we were already running the testsuite under `valgrind` in CI, because
`valgrind` exits with the same code that the program did, if there are
invalid reads/writes that happen not to trigger a segfault, the program can
still exit OK and we will be none the wiser. I've enabled the
`--error-exitcode=1` flag for `valgrind` in CI so that tests eagerly fail
in these scenarios.
2. I've written a quickcheck test to exercise `realloc`. Without the bug fix
in this patch, this quickcheck immediately triggers invalid reads when run
under `valgrind`. We didn't previously have quickchecks that exercised
`realloc` because `realloc` isn't publicly exposed directly, and instead
can only be indirectly called. This new quickcheck test exercises `realloc`
via `bumpalo::collections::Vec::resize` and
`bumpalo::collections::Vec::shrink_to_fit` calls.
|
{'CVE-2020-35861'}
|
2021-10-19T22:14:35Z
|
2020-03-24T12:00:00Z
| null | null | null |
{'https://crates.io/crates/bumpalo', 'https://rustsec.org/advisories/RUSTSEC-2020-0006.html', 'https://github.com/fitzgen/bumpalo/issues/69'}
| null |
crates.io
|
GHSA-vq23-5h4f-vwpv
|
Update unsound DrainFilter and RString::retain
|
An issue was discovered in the abi_stable crate before 0.9.1 for Rust. DrainFilter lacks soundness because of a double drop.
|
{'CVE-2020-36212'}
|
2021-07-26T17:17:19Z
|
2021-08-25T21:01:35Z
|
HIGH
| null |
{'CWE-672'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36212', 'https://github.com/rodrimati1992/abi_stable_crates/issues/44', 'https://rustsec.org/advisories/RUSTSEC-2020-0105.html'}
| null |
crates.io
|
RUSTSEC-2020-0143
|
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.
|
{'CVE-2020-36463'}
|
2021-10-19T22:14:35Z
|
2020-12-25T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0143.html', 'https://github.com/schets/multiqueue/issues/31', 'https://crates.io/crates/multiqueue'}
| null |
crates.io
|
GHSA-64wv-8vwp-xgw2
|
Use of Uninitialized Resource in ash.
|
An issue was discovered in the ash crate before 0.33.1 for Rust. util::read_spv may read from uninitialized memory locations.
|
{'CVE-2021-45688'}
|
2022-01-07T17:19:25Z
|
2022-01-06T22:13:02Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0090.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/ash/RUSTSEC-2021-0090.md', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45688', 'https://github.com/MaikKlein/ash'}
| null |
crates.io
|
RUSTSEC-2021-0108
|
Remote memory exhaustion in ckb
|
In the ckb sync protocol, SyncState maintains a HashMap called 'misbehavior' that keeps a score of a peer's violations of the protocol. This HashMap is keyed to PeerIndex (an alias for SessionId), and entries are never removed from it. SessionId is an integer that increases monotonically with every new connection.
A remote attacker can manipulate this HashMap to grow forever, resulting in degraded performance and ultimately a panic on allocation failure or being killed by the OS, depending on the platform.
This is a critical severity security bug. It could be exploited to create a targeted or network-wide denial of service, to reduce the hash power of the network as part of a 51% attack, and perhaps in other creative ways.
|
{'GHSA-48vq-8jqv-gm6f'}
|
2021-09-10T15:52:06Z
|
2021-07-25T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0108.html', 'https://crates.io/crates/ckb', 'https://github.com/nervosnetwork/ckb/security/advisories/GHSA-48vq-8jqv-gm6f'}
| null |
crates.io
|
RUSTSEC-2022-0018
|
Timing attack
|
Affecting versions did not compare tokens in constant time, which could make it possible for an attacker to guess the 2fa token of a user.
This has been fixed by using using the crate constant_time_eq for comparison.
|
{'CVE-2022-29185'}
|
2022-05-09T18:08:13Z
|
2022-05-09T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2022-0018.html', 'https://crates.io/crates/totp-rs', 'https://github.com/constantoine/totp-rs/security/advisories/GHSA-8vxv-2g8p-2249'}
| null |
crates.io
|
GHSA-799f-r78p-gq9c
|
Use of Uninitialized Resource in acc_reader.
|
An issue was discovered in the acc_reader crate through 2020-12-27 for Rust. read_up_to may read from uninitialized memory locations.
|
{'CVE-2020-36513'}
|
2022-01-07T16:22:24Z
|
2022-01-06T22:17:38Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36513', 'https://github.com/netvl/acc_reader', 'https://rustsec.org/advisories/RUSTSEC-2020-0155.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/acc_reader/RUSTSEC-2020-0155.md'}
| null |
crates.io
|
RUSTSEC-2020-0051
|
Obsolete versions of the `rustsec` crate do not support the new V3 advisory format
|
If you are seeing this message, you are running an obsolete version of
`cargo-audit` which does not support the new V3 advisory format.
These versions are end-of-life.
This advisory is a notice that that it will soon be unable to parse the
advisory database.
Please upgrade `cargo-audit` to a newer release.
| null |
2020-10-02T01:29:11Z
|
2020-10-01T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0051.html', 'https://github.com/RustSec/advisory-db/issues/414', 'https://crates.io/crates/rustsec'}
| null |
crates.io
|
GHSA-jwph-qp5h-f9wj
|
Data races in bunch
|
An issue was discovered in the bunch crate through 2020-11-12 for Rust.
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-08-24T18:33:33Z
|
2021-08-25T20:59:18Z
|
HIGH
| null |
{'CWE-77', 'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0130.html', 'https://github.com/krl/bunch', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36450', 'https://github.com/krl/bunch/issues/1', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/bunch/RUSTSEC-2020-0130.md'}
| null |
crates.io
|
RUSTSEC-2020-0114
|
`Demuxer` can carry non-Send types across thread boundaries
|
In the affected versions of this crate, `Demuxer<T>` unconditionally implemented `Send` with no trait bounds on `T`.
This allows sending a non-Send type `T` across thread boundaries, which can cause undefined behavior like unlocking a mutex from a thread that didn't lock the mutex, or memory corruption from data race.
The flaw was corrected in commit 0562cbf by adding a `T: Send` bound to the `Send` impl for `Demuxer<T>`.
|
{'CVE-2020-36220'}
|
2021-10-19T22:14:35Z
|
2020-12-22T12:00:00Z
| null | null | null |
{'https://crates.io/crates/va-ts', 'https://rustsec.org/advisories/RUSTSEC-2020-0114.html', 'https://github.com/video-audio/va-ts/issues/4'}
| null |
crates.io
|
GHSA-m7w4-8wp8-m2xq
|
Data races in beef
|
An issue was discovered in the beef crate before 0.5.0 for Rust.
Affected versions of this crate did not have a `T: Sync` bound in the `Send` impl for `Cow<'_, T, U>`. This allows users to create data races by making `Cow` contain types that are (Send && !Sync) like `Cell<_>` or `RefCell<_>`.
Such data races can lead to memory corruption.
The flaw was corrected in commit d1c7658 by adding trait bounds `T: Sync` and `T::Owned: Send` to the `Send` impl for `Cow<'_, T, U>`.
|
{'CVE-2020-36442'}
|
2021-08-24T18:35:48Z
|
2021-08-25T20:59:08Z
|
HIGH
| null |
{'CWE-119', 'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0122.html', 'https://github.com/maciejhirsz/beef/issues/37', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36442', 'https://github.com/maciejhirsz/beef'}
| null |
crates.io
|
RUSTSEC-2018-0010
|
Use after free in CMS Signing
|
Affected versions of the OpenSSL crate used structures after they'd been freed.
|
{'CVE-2018-20997'}
|
2021-10-19T22:14:35Z
|
2018-06-01T12:00:00Z
| null | null | null |
{'https://github.com/sfackler/rust-openssl/pull/942', 'https://crates.io/crates/openssl', 'https://rustsec.org/advisories/RUSTSEC-2018-0010.html'}
| null |
crates.io
|
RUSTSEC-2021-0082
|
vec-const attempts to construct a Vec from a pointer to a const slice
|
Affected versions of this crate claimed to construct a const `Vec` with nonzero length and capacity, but that cannot be done because such a `Vec` requires a pointer from an allocator.
The implementation was later changed to just construct a `std::borrow::Cow`.
| null |
2021-10-17T22:19:40Z
|
2021-08-14T12:00:00Z
| null | null | null |
{'https://github.com/Eolu/vec-const/issues/1#issuecomment-898908241', 'https://crates.io/crates/vec-const', 'https://rustsec.org/advisories/RUSTSEC-2021-0082.html'}
| null |
crates.io
|
RUSTSEC-2021-0128
|
Incorrect Lifetime Bounds on Closures in `rusqlite`
|
The lifetime bound on several closure-accepting `rusqlite` functions (specifically, functions which register a callback to be later invoked by SQLite) was too relaxed. If a closure referencing borrowed values on the stack is was passed to one of these functions, it could allow Rust code to access objects on the stack after they have been dropped.
The impacted functions are:
- Under `cfg(feature = "functions")`: `Connection::create_scalar_function`, `Connection::create_aggregate_function` and `Connection::create_window_function`.
- Under `cfg(feature = "hooks")`: `Connection::commit_hook`, `Connection::rollback_hook` and `Connection::update_hook`.
- Under `cfg(feature = "collation")`: `Connection::create_collation`.
The issue exists in all `0.25.*` versions prior to `0.25.4`, and all `0.26.*` versions prior to 0.26.2 (specifically: `0.25.0`, `0.25.1`, `0.25.2`, `0.25.3`, `0.26.0`, and `0.26.1`).
The fix is available in versions `0.26.2` and newer, and also has been back-ported to `0.25.4`. As it does not exist in `0.24.*`, all affected versions should have an upgrade path to a semver-compatible release.
| null |
2021-12-09T00:29:19Z
|
2021-12-07T12:00:00Z
| null | null | null |
{'https://github.com/rusqlite/rusqlite/issues/1048', 'https://rustsec.org/advisories/RUSTSEC-2021-0128.html', 'https://crates.io/crates/rusqlite'}
| null |
crates.io
|
GHSA-xp6v-qx65-4pp7
|
Data races in gfwx
|
An issue was discovered in the gfwx crate before 0.3.0 for Rust. Because ImageChunkMut does not have bounds on its Send trait or Sync trait, a data race and memory corruption can occur.
|
{'CVE-2020-36211'}
|
2021-08-19T18:53:42Z
|
2021-08-25T20:50:39Z
|
HIGH
| null |
{'CWE-662', 'CWE-787'}
|
{'https://github.com/Devolutions/gfwx-rs', 'https://rustsec.org/advisories/RUSTSEC-2020-0104.html', 'https://github.com/Devolutions/gfwx-rs/issues/7', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36211'}
| null |
crates.io
|
RUSTSEC-2017-0002
|
headers containing newline characters can split messages
|
Serializing of headers to the socket did not filter the values for newline bytes (`\r` or `\n`),
which allowed for header values to split a request or response. People would not likely include
newlines in the headers in their own applications, so the way for most people to exploit this
is if an application constructs headers based on unsanitized user input.
This issue was fixed by replacing all newline characters with a space during serialization of
a header value.
|
{'CVE-2017-18587'}
|
2021-10-19T22:14:35Z
|
2017-01-23T12:00:00Z
| null | null | null |
{'https://github.com/hyperium/hyper/wiki/Security-001', 'https://rustsec.org/advisories/RUSTSEC-2017-0002.html', 'https://crates.io/crates/hyper'}
| null |
crates.io
|
RUSTSEC-2020-0026
|
linked-hash-map creates uninitialized NonNull pointer
|
Affected versions of this crate called `mem::uninitialized()` to create a `NonNull<T>`,
which is undefined behavior.
The flaw was corrected by avoiding the use of `mem::uninitialized()`.
|
{'CVE-2020-25573'}
|
2021-10-19T22:14:35Z
|
2020-06-23T12:00:00Z
| null | null | null |
{'https://github.com/contain-rs/linked-hash-map/pull/100', 'https://rustsec.org/advisories/RUSTSEC-2020-0026.html', 'https://crates.io/crates/linked-hash-map'}
| null |
crates.io
|
GHSA-6rhx-hqxm-8p36
|
Double free in http
|
An issue was discovered in the http crate before 0.1.20 for Rust. The HeaderMap::Drain API can use a raw pointer, defeating soundness.
|
{'CVE-2019-25009'}
|
2021-08-19T21:19:45Z
|
2021-08-25T20:46:44Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-25009', 'https://rustsec.org/advisories/RUSTSEC-2019-0034.html'}
| null |
crates.io
|
GHSA-xpwj-7v8q-mcgj
|
Static imports inside dynamically imported modules do not adhere to permission checks
|
### Impact
Modules that are dynamically imported through `import()` or `new Worker` might have been able to bypass network and file system permission checks when statically importing other modules. In Deno 1.5.x and 1.6.x only programs dynamically importing (especially transitively) untrusted code are affected. In Deno 1.7.x all programs importing (especially transitively) untrusted code are affected.
In effect an attacker in control of a (possibly remote) module in a programs module graph has been able to, **irrespective of permissions**:
1. initiate GET requests to arbitrary URLs on the internet (including LAN) and possibly read (parts of) the contents of these resources.
2. check for existence of arbitrary paths on the file system, and possibly read (parts of) the contents of these files.
In Deno 1.5.x (October 27th, 2020) and Deno 1.6.x (December 8th, 2020) the attacker module had to have been granted permissions to load dynamically through the network / fs read permission. Since Deno 1.7.x (January 19th, 2021) this vulnerability was able to be exploited in a fully sandboxed isolate (without any permissions). This vulnerability was not present in releases prior to 1.5.0.
Arbitrary non-GET requests, control over request headers, or file system writes are not possible through this vulnerability. Users of the `deno_core`, `deno_runtime`, or other `deno_*` crates are not affected. This is a Deno CLI only vulnerability.
We are relatively confident this was not abused in the wild, as by default Deno prints out a green "Download" message when remote imports are downloaded, and this would have caused suspicion if it occurred in the middle of a programs execution. This message can be silenced with the `--quiet` flag.
### Patches
The vulnerability has been patched in Deno release 1.10.2. You can upgrade to the latest Deno version by running the `deno upgrade` command. The release is available through all official download channels.
### Workarounds
There is no workaround for this issue.
### For more information
If you have any questions or comments about this advisory:
* Open an issue on [the issue tracker](https://github.com/denoland/deno)
* Discuss on [Discord](https://discord.gg/deno)
|
{'CVE-2021-32619'}
|
2021-09-23T21:13:15Z
|
2021-09-23T23:18:03Z
|
CRITICAL
| null |
{'CWE-285'}
|
{'https://github.com/denoland/deno', 'https://nvd.nist.gov/vuln/detail/CVE-2021-32619', 'https://github.com/denoland/deno/security/advisories/GHSA-xpwj-7v8q-mcgj'}
| null |
crates.io
|
GHSA-vw5m-qw2r-m923
|
Use of Uninitialized Resource in messagepack-rs.
|
An issue was discovered in the messagepack-rs crate through 2021-01-26 for Rust. deserialize_binary may read from uninitialized memory locations.
|
{'CVE-2021-45690'}
|
2022-01-07T17:13:28Z
|
2022-01-06T22:11:46Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0092.html', 'https://github.com/otake84/messagepack-rs', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45690', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/messagepack-rs/RUSTSEC-2021-0092.md'}
| null |
crates.io
|
RUSTSEC-2020-0134
|
`LockWeak<T>` allows to create data race to `T`.
|
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.
|
{'CVE-2020-36454'}
|
2021-10-19T22:14:35Z
|
2020-11-14T12:00:00Z
| null | null | null |
{'https://crates.io/crates/parc', 'https://github.com/hyyking/rustracts/pull/6', 'https://rustsec.org/advisories/RUSTSEC-2020-0134.html'}
| null |
crates.io
|
GHSA-gppw-3h6h-v6q2
|
Data race in internment
|
An issue was discovered in the internment crate before 0.4.2 for Rust. There is a data race that can cause memory corruption because of the unconditional implementation of Sync for Intern<T>.
|
{'CVE-2021-28037'}
|
2021-08-19T17:26:00Z
|
2021-08-25T20:52:08Z
|
CRITICAL
| null |
{'CWE-362'}
|
{'https://github.com/droundy/internment/issues/20', 'https://github.com/droundy/internment', 'https://rustsec.org/advisories/RUSTSEC-2021-0036.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-28037'}
| null |
crates.io
|
RUSTSEC-2020-0071
|
Potential segfault in the time crate
|
### Impact
Unix-like operating systems may segfault due to dereferencing a dangling pointer in specific circumstances. This requires an environment variable to be set in a different thread than the affected functions. This may occur without the user's knowledge, notably in a third-party library.
The affected functions from time 0.2.7 through 0.2.22 are:
- `time::UtcOffset::local_offset_at`
- `time::UtcOffset::try_local_offset_at`
- `time::UtcOffset::current_local_offset`
- `time::UtcOffset::try_current_local_offset`
- `time::OffsetDateTime::now_local`
- `time::OffsetDateTime::try_now_local`
The affected functions in time 0.1 (all versions) are:
- `at`
- `at_utc`
- `now`
Non-Unix targets (including Windows and wasm) are unaffected.
### Patches
Pending a proper fix, the internal method that determines the local offset has been modified to always return `None` on the affected operating systems. This has the effect of returning an `Err` on the `try_*` methods and `UTC` on the non-`try_*` methods.
Users and library authors with time in their dependency tree should perform `cargo update`, which will pull in the updated, unaffected code.
Users of time 0.1 do not have a patch and should upgrade to an unaffected version: time 0.2.23 or greater or the 0.3 series.
### Workarounds
No workarounds are known.
### References
time-rs/time#293
|
{'CVE-2020-26235'}
|
2022-04-18T01:32:20Z
|
2020-11-18T12:00:00Z
| null | null | null |
{'https://github.com/time-rs/time/issues/293', 'https://crates.io/crates/time', 'https://rustsec.org/advisories/RUSTSEC-2020-0071.html'}
| null |
crates.io
|
GHSA-jphw-p3m6-pj3c
|
Data races in multiqueue2
|
An issue was discovered in the multiqueue2 crate before 0.1.7 for Rust. Because a non-Send type can be sent to a different thread, a data race can occur.
|
{'CVE-2020-36214'}
|
2021-08-19T18:47:21Z
|
2021-08-25T20:51:54Z
|
MODERATE
| null |
{'CWE-662'}
|
{'https://github.com/abbychau/multiqueue2/issues/10', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36214', 'https://rustsec.org/advisories/RUSTSEC-2020-0106.html', 'https://github.com/abbychau/multiqueue2'}
| null |
crates.io
|
GHSA-gvcp-948f-8f2p
|
Use of Uninitialized Resource in libp2p-deflate
|
An issue was discovered in the libp2p-deflate crate before 0.27.1 for Rust. An uninitialized buffer is passed to AsyncRead::poll_read(), which is a user-provided trait function.
|
{'CVE-2020-36443'}
|
2021-08-18T19:04:08Z
|
2021-08-25T20:59:04Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36443', 'https://rustsec.org/advisories/RUSTSEC-2020-0123.html', 'https://github.com/libp2p/rust-libp2p'}
| null |
crates.io
|
GHSA-g4h2-4wvh-grc5
|
Uncontrolled Resource Consumption in simple_asn1
|
An issue was discovered in the simple_asn1 crate 0.6.0 before 0.6.1 for Rust. There is a panic if UTCTime data, supplied by a remote attacker, has a second character greater than 0x7f.
|
{'CVE-2021-45711'}
|
2022-01-07T18:25:29Z
|
2022-01-06T22:05:05Z
|
HIGH
| null |
{'CWE-400'}
|
{'https://github.com/acw/simple_asn1/issues/27', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45711', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/simple_asn1/RUSTSEC-2021-0125.md', 'https://github.com/acw/simple_asn1', 'https://rustsec.org/advisories/RUSTSEC-2021-0125.html'}
| null |
crates.io
|
RUSTSEC-2020-0122
|
beef::Cow lacks a Sync bound on its Send trait allowing for data races
|
Affected versions of this crate did not have a `T: Sync` bound in the `Send` impl for `Cow<'_, T, U>`. This allows users to create data races by making `Cow` contain types that are (Send && !Sync) like `Cell<_>` or `RefCell<_>`.
Such data races can lead to memory corruption.
The flaw was corrected in commit d1c7658 by adding trait bounds `T: Sync` and `T::Owned: Send` to the `Send` impl for `Cow<'_, T, U>`.
|
{'CVE-2020-36442'}
|
2021-10-19T22:14:35Z
|
2020-10-28T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0122.html', 'https://crates.io/crates/beef', 'https://github.com/maciejhirsz/beef/issues/37'}
| null |
crates.io
|
RUSTSEC-2020-0088
|
MPMCConsumer/Producer allows sending non-Send type across threads
|
Affected versions of this crate unconditionally implemented `Sync` and `Send` traits for `MPMCConsumer` and `MPMCProducer` types.
This allows users to send types that do not implement `Send` trait across thread boundaries, which can cause a data race.
The flaw was corrected in the 2.0.1 release by adding `T: Send` bound to affected Sync/Send trait implementations.
|
{'CVE-2020-35925'}
|
2021-10-19T22:14:35Z
|
2020-11-29T12:00:00Z
| null | null | null |
{'https://github.com/johnshaw/magnetic/issues/9', 'https://rustsec.org/advisories/RUSTSEC-2020-0088.html', 'https://crates.io/crates/magnetic'}
| null |
crates.io
|
GHSA-9j8q-m9x5-9g6j
|
Data races in async-coap
|
An issue was discovered in the async-coap crate through 2020-12-08 for Rust.
Affected versions of this crate implement Send/Sync for `ArcGuard<RC, T>` with no trait bounds on `RC`. This allows users to send `RC: !Send` to other threads and also allows users to concurrently access `Rc: !Sync` from multiple threads.
This can result in memory corruption from data race or other undefined behavior caused by sending `T: !Send` to other threads (e.g. dropping `MutexGuard<T>` in another thread that didn't lock its mutex).
|
{'CVE-2020-36444'}
|
2021-08-24T18:52:16Z
|
2021-08-25T20:59:11Z
|
HIGH
| null |
{'CWE-119', 'CWE-362'}
|
{'https://github.com/google/rust-async-coap/issues/33', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36444', 'https://rustsec.org/advisories/RUSTSEC-2020-0124.html', 'https://github.com/google/rust-async-coap'}
| null |
crates.io
|
RUSTSEC-2020-0067
|
crate has been renamed to `qp2p`
|
This crate has been renamed from `quic-p2p` to `qp2p`.
The new repository location is:
<https://github.com/maidsafe/qp2p>
| null |
2020-11-02T14:50:19Z
|
2020-11-02T12:00:00Z
| null | null | null |
{'https://github.com/maidsafe/qp2p/pull/141', 'https://rustsec.org/advisories/RUSTSEC-2020-0067.html', 'https://crates.io/crates/quic-p2p'}
| null |
crates.io
|
GHSA-w428-f65r-h4q2
|
Deserialization of Untrusted Data in rust-cpuid
|
An issue was discovered in the raw-cpuid crate before 9.1.1 for Rust. If the serialize feature is used (which is not the the default), a Deserialize operation may lack sufficient validation, leading to memory corruption or a panic.
|
{'CVE-2021-45687'}
|
2022-01-07T17:23:21Z
|
2022-01-06T22:13:12Z
|
CRITICAL
| null |
{'CWE-502'}
|
{'https://github.com/gz/rust-cpuid', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45687', 'https://rustsec.org/advisories/RUSTSEC-2021-0089.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/raw-cpuid/RUSTSEC-2021-0089.md'}
| null |
crates.io
|
GHSA-5325-xw5m-phm3
|
Cross-site Scripting in ammonia
|
An issue was discovered in the ammonia crate before 3.1.0 for Rust. XSS can occur because the parsing differences for HTML, SVG, and MathML are mishandled, a similar issue to CVE-2020-26870.
|
{'CVE-2021-38193'}
|
2021-08-18T21:28:38Z
|
2021-08-25T20:55:56Z
|
MODERATE
| null |
{'CWE-79'}
|
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/ammonia/RUSTSEC-2021-0074.md', 'https://github.com/rust-ammonia/ammonia/pull/142', 'https://github.com/rust-ammonia/ammonia', 'https://rustsec.org/advisories/RUSTSEC-2021-0074.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-38193'}
| null |
crates.io
|
RUSTSEC-2018-0006
|
Uncontrolled recursion leads to abort in deserialization
|
Affected versions of this crate did not prevent deep recursion while
deserializing data structures.
This allows an attacker to make a YAML file with deeply nested structures
that causes an abort while deserializing it.
The flaw was corrected by checking the recursion depth.
Note: `clap 2.33` is not affected by this because it uses `yaml-rust`
in a way that doesn't trigger the vulnerability. More specifically:
1. The input to the YAML parser is always trusted - is included at compile
time via `include_str!`.
2. The nesting level is never deep enough to trigger the overflow in practice
(at most 5).
|
{'CVE-2018-20993'}
|
2021-10-19T22:14:35Z
|
2018-09-17T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2018-0006.html', 'https://github.com/chyh1990/yaml-rust/pull/109', 'https://crates.io/crates/yaml-rust'}
| null |
crates.io
|
RUSTSEC-2021-0094
|
Window can read out of bounds if Read instance returns more bytes than buffer size
|
`rdiff` performs a diff of two provided strings or files. As part of its reading
code it uses the return value of a `Read` instance to set the length of
its internal character vector.
If the `Read` implementation claims that it has read more bytes than the length
of the provided buffer, the length of the vector will be set to longer than its
capacity. This causes `rdiff` APIs to return uninitialized memory in its API
methods.
| null |
2021-08-22T01:46:40Z
|
2021-02-03T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0094.html', 'https://github.com/dyule/rdiff/issues/3', 'https://crates.io/crates/rdiff'}
| null |
crates.io
|
GHSA-x67x-vg9m-65c3
|
Integer overflow in base64
|
Affected versions of this crate suffered from an integer overflow bug when
calculating the size of a buffer to use when encoding base64 using the
`encode_config_buf` and `encode_config` functions. If the input string
was large, this would cause a buffer to be allocated that was too small.
Since this function writes to the buffer using unsafe code, it would
allow an attacker to write beyond the buffer, causing memory corruption
and possibly the execution of arbitrary code.
This flaw was corrected by using checked arithmetic to calculate
the size of the buffer.
|
{'CVE-2017-1000430'}
|
2021-08-19T17:02:46Z
|
2021-08-25T20:55:27Z
|
CRITICAL
| null |
{'CWE-119'}
|
{'https://github.com/alicemaz/rust-base64', 'https://nvd.nist.gov/vuln/detail/CVE-2017-1000430', 'https://github.com/alicemaz/rust-base64/commit/24ead980daf11ba563e4fb2516187a56a71ad319', 'https://rustsec.org/advisories/RUSTSEC-2017-0004'}
| null |
crates.io
|
GHSA-8fgg-5v78-6g76
|
Deserializing an array can free uninitialized memory in byte_struct
|
Byte_struct stack and unpack structure as raw bytes with packed or bit field layout. An issue was discovered in the byte_struct crate before 0.6.1 for Rust. There can be a drop of uninitialized memory if a certain deserialization method panics.
|
{'CVE-2021-28033'}
|
2022-05-04T03:04:59Z
|
2021-08-25T20:52:03Z
|
CRITICAL
| null |
{'CWE-908', 'CWE-119'}
|
{'https://github.com/wwylele/byte-struct-rs', 'https://nvd.nist.gov/vuln/detail/CVE-2021-28033', 'https://github.com/wwylele/byte-struct-rs/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0032.html'}
| null |
crates.io
|
GHSA-9mp7-45qh-r8j8
|
Use of Uninitialized Resource in columnar.
|
An issue was discovered in the columnar crate through 2021-01-07 for Rust. ColumnarReadExt::read_typed_vec may read from uninitialized memory locations.
|
{'CVE-2021-45685'}
|
2022-01-07T17:34:40Z
|
2022-01-06T22:13:46Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0087.html', 'https://github.com/frankmcsherry/columnar.git', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45685', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/columnar/RUSTSEC-2021-0087.md'}
| null |
crates.io
|
GHSA-3w8g-xr3f-2mp8
|
Out of bounds write in nalgebra
|
The `Deserialize` implementation for `VecStorage` did not maintain the invariant that the number of elements must equal `nrows * ncols`. Deserialization of specially crafted inputs could allow memory access beyond allocation of the vector.
This flaw was introduced in v0.11.0 ([`086e6e`](https://github.com/dimforge/nalgebra/commit/086e6e719f53fecba6dadad2e953a487976387f5)) due to the addition of an automatically derived implementation of `Deserialize` for `MatrixVec`. `MatrixVec` was later renamed to `VecStorage` in v0.16.13 ([`0f66403`](https://github.com/dimforge/nalgebra/commit/0f66403cbbe9eeac15cedd8a906c0d6a3d8841f2)) and continued to use the automatically derived implementation of `Deserialize`.
|
{'CVE-2021-38190'}
|
2021-08-24T18:08:59Z
|
2021-08-25T20:55:49Z
|
CRITICAL
| null |
{'CWE-787', 'CWE-119'}
|
{'https://github.com/dimforge/nalgebra/blob/dev/CHANGELOG.md#0270', 'https://nvd.nist.gov/vuln/detail/CVE-2021-38190', 'https://github.com/dimforge/nalgebra/commit/a803271fcce75b7c151e92aa099dfa546db4adc5', 'https://github.com/dimforge/nalgebra/issues/883', 'https://rustsec.org/advisories/RUSTSEC-2021-0070.html', 'https://github.com/dimforge/nalgebra/pull/889', 'https://github.com/dimforge/nalgebra'}
| null |
crates.io
|
RUSTSEC-2020-0030
|
Missing sanitazion in mozwire allows local file overwrite of files ending in .conf
|
The client software downloaded a list of servers from mozilla's servers and created local files named
after the hostname field in the json document.
No verification of the content of the string was made, and it could therefore have included '../' leading to path traversal.
This allows an attacker in control of mozilla's servers to overwrite/create local files named .conf.
The flaw was corrected by sanitizing the hostname field.
|
{'CVE-2020-35883'}
|
2021-10-19T22:14:35Z
|
2020-08-18T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0030.html', 'https://crates.io/crates/mozwire', 'https://github.com/NilsIrl/MozWire/issues/14'}
| null |
crates.io
|
RUSTSEC-2019-0036
|
Type confusion if __private_get_type_id__ is overridden
|
Safe Rust code can implement malfunctioning `__private_get_type_id__` and cause
type confusion when downcasting, which is an undefined behavior.
Users who derive `Fail` trait are not affected.
|
{'CVE-2019-25010', 'CVE-2020-25575'}
|
2021-10-19T22:14:35Z
|
2019-11-13T12:00:00Z
| null | null | null |
{'https://github.com/rust-lang-nursery/failure/issues/336', 'https://crates.io/crates/failure', 'https://rustsec.org/advisories/RUSTSEC-2019-0036.html'}
| null |
crates.io
|
GHSA-8hfj-xrj2-pm22
|
Certificate check bypass in openssl-src
|
The X509_V_FLAG_X509_STRICT flag enables additional security checks of the certificates present in a certificate chain. It is not set by default. Starting from OpenSSL version 1.1.1h a check to disallow certificates in the chain that have explicitly encoded elliptic curve parameters was added as an additional strict check. An error in the implementation of this check meant that the result of a previous check to confirm that certificates in the chain are valid CA certificates was overwritten. This effectively bypasses the check that non-CA certificates must not be able to issue other certificates. If a "purpose" has been configured then there is a subsequent opportunity for checks that the certificate is a valid CA. All of the named "purpose" values implemented in libcrypto perform this check. Therefore, where a purpose is set the certificate chain will still be rejected even when the strict flag has been used. A purpose is set by default in libssl client and server certificate verification routines, but it can be overridden or removed by an application. In order to be affected, an application must explicitly set the X509_V_FLAG_X509_STRICT verification flag and either not set a purpose for the certificate verification or, in the case of TLS client or server applications, override the default purpose. OpenSSL versions 1.1.1h and newer 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.1h-1.1.1j).
|
{'CVE-2021-3450'}
|
2021-08-19T17:22:00Z
|
2021-08-25T20:54:00Z
|
HIGH
| null |
{'CWE-295'}
|
{'https://cert-portal.siemens.com/productcert/pdf/ssa-389290.pdf', '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://www.tenable.com/security/tns-2021-08', 'https://mta.openssl.org/pipermail/openssl-announce/2021-March/000198.html', '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', '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://kb.pulsesecure.net/articles/Pulse_Security_Advisories/SA44845', 'http://www.openwall.com/lists/oss-security/2021/03/28/4', 'https://nvd.nist.gov/vuln/detail/CVE-2021-3450', 'https://psirt.global.sonicwall.com/vuln-detail/SNWLID-2021-0013', 'https://www.openssl.org/news/secadv/20210325.txt', 'https://git.openssl.org/gitweb/?p=openssl.git;a=commitdiff;h=2a40b7bc7b94dd7de897a74571e7024f0cf0d63b', 'https://rustsec.org/advisories/RUSTSEC-2021-0056.html', 'https://security.FreeBSD.org/advisories/FreeBSD-SA-21:07.openssl.asc', 'https://security.gentoo.org/glsa/202103-03'}
| null |
crates.io
|
GHSA-jq65-29v4-4x35
|
Null pointer deference in openssl-src
|
Server or client applications that call the SSL_check_chain() function during or after a TLS 1.3 handshake may crash due to a NULL pointer dereference as a result of incorrect handling of the "signature_algorithms_cert" TLS extension. The crash occurs if an invalid or unrecognised signature algorithm is received from the peer. This could be exploited by a malicious peer in a Denial of Service attack. OpenSSL version 1.1.1d, 1.1.1e, and 1.1.1f are affected by this issue. This issue did not affect OpenSSL versions prior to 1.1.1d. Fixed in OpenSSL 1.1.1g (Affected 1.1.1d-1.1.1f).
|
{'CVE-2020-1967'}
|
2021-08-19T21:21:21Z
|
2021-08-25T20:45:15Z
|
HIGH
| null |
{'CWE-476'}
|
{'https://www.oracle.com/security-alerts/cpujul2020.html', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/DDHOAATPWJCXRNFMJ2SASDBBNU5RJONY/', 'http://lists.opensuse.org/opensuse-security-announce/2020-07/msg00011.html', 'https://www.debian.org/security/2020/dsa-4661', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/EXDDAOWSAIEFQNBHWYE6PPYFV4QXGMCD/', 'https://www.oracle.com/security-alerts/cpuoct2021.html', 'http://www.openwall.com/lists/oss-security/2020/04/22/2', 'https://www.oracle.com//security-alerts/cpujul2021.html', 'https://lists.apache.org/thread.html/r66ea9c436da150683432db5fbc8beb8ae01886c6459ac30c2cea7345@%3Cdev.tomcat.apache.org%3E', 'http://seclists.org/fulldisclosure/2020/May/5', 'http://lists.opensuse.org/opensuse-security-announce/2020-07/msg00004.html', 'https://github.com/irsl/CVE-2020-1967', 'https://security.netapp.com/advisory/ntap-20200717-0004/', 'https://lists.apache.org/thread.html/r9a41e304992ce6aec6585a87842b4f2e692604f5c892c37e3b0587ee@%3Cdev.tomcat.apache.org%3E', 'https://www.synology.com/security/advisory/Synology_SA_20_05_OpenSSL', 'https://www.synology.com/security/advisory/Synology_SA_20_05', 'https://www.tenable.com/security/tns-2021-10', 'https://www.openssl.org/news/secadv/20200421.txt', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/XVEP3LAK4JSPRXFO4QF4GG2IVXADV3SO/', 'https://security.FreeBSD.org/advisories/FreeBSD-SA-20:11.openssl.asc', 'https://git.openssl.org/gitweb/?p=openssl.git;a=commitdiff;h=eb563247aef3e83dda7679c43f9649270462e5b1', 'https://www.tenable.com/security/tns-2020-04', 'https://security.gentoo.org/glsa/202004-10', 'https://www.tenable.com/security/tns-2020-11', 'https://security.netapp.com/advisory/ntap-20200424-0003/', 'https://www.oracle.com/security-alerts/cpujan2021.html', 'https://kb.pulsesecure.net/articles/Pulse_Security_Advisories/SA44440', 'http://packetstormsecurity.com/files/157527/OpenSSL-signature_algorithms_cert-Denial-Of-Service.html', 'https://www.oracle.com/security-alerts/cpuApr2021.html', 'https://rustsec.org/advisories/RUSTSEC-2020-0015.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-1967', 'https://lists.apache.org/thread.html/r94d6ac3f010a38fccf4f432b12180a13fa1cf303559bd805648c9064@%3Cdev.tomcat.apache.org%3E', 'https://www.tenable.com/security/tns-2020-03', 'https://www.oracle.com/security-alerts/cpuoct2020.html'}
| null |
crates.io
|
GHSA-mp6r-fgw2-rxfx
|
Multiple soundness issues
|
An issue was discovered in the xcb crate through 2021-02-04 for Rust. It has a soundness violation because bytes from an X server can be interpreted as any data type returned by xcb::xproto::GetPropertyReply::value.
|
{'CVE-2021-26956'}
|
2021-08-19T17:35:46Z
|
2021-08-25T20:53:27Z
|
CRITICAL
| null |
{'CWE-657'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-26956', 'https://rustsec.org/advisories/RUSTSEC-2021-0019.html', 'https://github.com/RustSec/advisory-db/issues/653', 'https://github.com/rtbo/rust-xcb'}
| null |
crates.io
|
RUSTSEC-2021-0112
|
`Read` on uninitialized buffer may cause UB ('tectonic_xdv' crate)
|
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.
The problem was fixed in commit `cdff034` by zero-initializing the buffer before passing it to a user-provided `Read` implementation.
| null |
2021-09-18T21:35:48Z
|
2021-02-17T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0112.html', 'https://crates.io/crates/tectonic_xdv', 'https://github.com/tectonic-typesetting/tectonic/issues/752'}
| null |
crates.io
|
GHSA-369h-pjr2-6wrh
|
Uncontrolled recursion in trust-dns-proto
|
An issue was discovered in the trust-dns-proto crate before 0.5.0-alpha.3 for Rust. There is infinite recursion because DNS message compression is mishandled.
|
{'CVE-2018-20994'}
|
2021-08-19T21:24:41Z
|
2021-08-25T20:43:16Z
|
HIGH
| null |
{'CWE-674'}
|
{'https://github.com/bluejekyll/trust-dns', 'https://nvd.nist.gov/vuln/detail/CVE-2018-20994', 'https://rustsec.org/advisories/RUSTSEC-2018-0007.html'}
| null |
crates.io
|
RUSTSEC-2021-0057
|
Integer overflow in CipherUpdate
|
Calls to `EVP_CipherUpdate`, `EVP_EncryptUpdate` and `EVP_DecryptUpdate` may overflow
the output length argument in some cases where the input length is close to the
maximum permissable length for an integer on the platform. In such cases the
return value from the function call will be 1 (indicating success), but the
output length value will be negative. This could cause applications to behave
incorrectly or crash.
|
{'CVE-2021-23840'}
|
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-0057.html'}
| null |
crates.io
|
RUSTSEC-2022-0002
|
Unsoundness in `dashmap` references
|
Reference returned by some methods of `Ref` (and similar types) may outlive the `Ref` and escape the lock.
This causes undefined behavior and may result in a segfault.
More information in [`dashmap#167`](https://github.com/xacrimon/dashmap/issues/167) issue.
| null |
2022-02-06T17:02:38Z
|
2022-01-10T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2022-0002.html', 'https://github.com/xacrimon/dashmap/issues/167', 'https://crates.io/crates/dashmap'}
| null |
crates.io
|
RUSTSEC-2020-0159
|
Potential segfault in `localtime_r` invocations
|
### Impact
Unix-like operating systems may segfault due to dereferencing a dangling pointer in specific circumstances. This requires an environment variable to be set in a different thread than the affected functions. This may occur without the user's knowledge, notably in a third-party library.
### Workarounds
No workarounds are known.
### References
- [time-rs/time#293](https://github.com/time-rs/time/issues/293)
| null |
2021-10-18T16:19:09Z
|
2020-11-10T12:00:00Z
| null | null | null |
{'https://github.com/chronotope/chrono/issues/499', 'https://crates.io/crates/chrono', 'https://rustsec.org/advisories/RUSTSEC-2020-0159.html'}
| null |
crates.io
|
GHSA-w9vv-q986-vj7x
|
Out of bounds read in uu_od
|
An issue was discovered in PartialReader in the uu_od crate before 0.0.4 for Rust. Attackers can read the contents of uninitialized memory locations via a user-provided Read operation.
|
{'CVE-2021-29934'}
|
2021-08-19T17:09:13Z
|
2021-08-25T20:54:24Z
|
HIGH
| null |
{'CWE-125'}
|
{'https://github.com/uutils/coreutils/issues/1729', 'https://rustsec.org/advisories/RUSTSEC-2021-0043.html', 'https://github.com/uutils/coreutils', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29934'}
| null |
crates.io
|
RUSTSEC-2021-0104
|
File exposure in pleaser
|
pleaser before 0.4 allows a local unprivileged attacker to gain knowledge about the existence of files or directories in privileged locations via the search_path function, the --check option, or the -d option.
|
{'CVE-2021-31153', 'GHSA-f3fg-5j9p-vchc'}
|
2021-09-10T16:01:55Z
|
2021-05-27T12:00:00Z
| null | null | null |
{'https://crates.io/crates/pleaser', 'https://nvd.nist.gov/vuln/detail/CVE-2021-31153', 'https://rustsec.org/advisories/RUSTSEC-2021-0104.html'}
| null |
crates.io
|
GHSA-jrf8-cmgg-gv2m
|
Error on unsupported architectures in raw-cpuid
|
An issue was discovered in the raw-cpuid crate before 9.0.0 for Rust. It allows __cpuid_count() calls even if the processor does not support the CPUID instruction, which is unsound and causes a deterministic crash.
|
{'CVE-2021-26307'}
|
2021-08-19T18:02:32Z
|
2021-08-25T20:53:07Z
|
MODERATE
| null |
{'CWE-657'}
|
{'https://github.com/RustSec/advisory-db/pull/614', 'https://nvd.nist.gov/vuln/detail/CVE-2021-26307', 'https://rustsec.org/advisories/RUSTSEC-2021-0013.html', 'https://github.com/gz/rust-cpuid/issues/40', 'https://github.com/gz/rust-cpuid'}
| null |
crates.io
|
GHSA-8rc5-mr4f-m243
|
Use after free in rio
|
An issue was discovered in the rio crate through 2020-05-11 for Rust. A struct can be leaked, allowing attackers to obtain sensitive information, cause a use-after-free, or cause a data race.
|
{'CVE-2020-35876'}
|
2021-08-19T21:18:55Z
|
2021-08-25T20:46:57Z
|
CRITICAL
| null |
{'CWE-772', 'CWE-416'}
|
{'https://github.com/spacejam/rio', 'https://github.com/spacejam/rio/pull/31', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35876', 'https://github.com/spacejam/rio/issues/11', 'https://rustsec.org/advisories/RUSTSEC-2020-0021.html'}
| null |
crates.io
|
RUSTSEC-2022-0014
|
Infinite loop in `BN_mod_sqrt()` reachable when parsing certificates
|
The `BN_mod_sqrt()` function, which computes a modular square root, contains
a bug that can cause it to loop forever for non-prime moduli.
Internally this function is used when parsing certificates that contain
elliptic curve public keys in compressed form or explicit elliptic curve
parameters with a base point encoded in compressed form.
It is possible to trigger the infinite loop by crafting a certificate that
has invalid explicit curve parameters.
Since certificate parsing happens prior to verification of the certificate
signature, any process that parses an externally supplied certificate may thus
be subject to a denial of service attack. The infinite loop can also be
reached when parsing crafted private keys as they can contain explicit
elliptic curve parameters.
Thus vulnerable situations include:
- TLS clients consuming server certificates
- TLS servers consuming client certificates
- Hosting providers taking certificates or private keys from customers
- Certificate authorities parsing certification requests from subscribers
- Anything else which parses ASN.1 elliptic curve parameters
Also any other applications that use the `BN_mod_sqrt()` where the attacker
can control the parameter values are vulnerable to this DoS issue.
|
{'CVE-2022-0778'}
|
2022-03-16T14:05:15Z
|
2022-03-15T12:00:00Z
| null | null | null |
{'https://www.openssl.org/news/secadv/20220315.txt', 'https://crates.io/crates/openssl-src', 'https://rustsec.org/advisories/RUSTSEC-2022-0014.html'}
| null |
crates.io
|
RUSTSEC-2021-0041
|
Denial of service through parsing payloads with too big exponent
|
The `parse_duration::parse` function allows for parsing duration strings with exponents like `5e5s` where under the hood, the [`BigInt` type along with the `pow` function are used for such payloads](https://github.com/zeta12ti/parse_duration/blob/26940ab5cd4e3a9d6bd97aa101f8d4bbfd18ee8c/src/parse.rs#L335). Passing an arbitrarily big exponent makes the `parse_duration::parse` function to process the payload for a very long time taking up CPU and memory.
This allows an attacker to cause a DoS if the `parse_duration::parse` function is used to process untrusted input.
|
{'CVE-2021-29932', 'CAN-2021-1000007'}
|
2021-10-19T22:14:35Z
|
2021-03-18T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0041.html', 'https://github.com/zeta12ti/parse_duration/issues/21', 'https://crates.io/crates/parse_duration'}
| null |
crates.io
|
GHSA-m5pq-gvj9-9vr8
|
Regular expression denial of service in Rust's regex crate
|
> This is a cross-post of [the official security advisory][advisory]. The official advisory contains a signed version with our PGP key, as well.
[advisory]: https://groups.google.com/g/rustlang-security-announcements/c/NcNNL1Jq7Yw
The Rust Security Response WG was notified that the `regex` crate did not properly limit the complexity of the regular expressions (regex) it parses. An attacker could use this security issue to perform a denial of service, by sending a specially crafted regex to a service accepting untrusted regexes. No known vulnerability is present when parsing untrusted input with trusted regexes.
This issue has been assigned CVE-2022-24713. The severity of this vulnerability is "high" when the `regex` crate is used to parse untrusted regexes. Other uses of the `regex` crate are not affected by this vulnerability.
## Overview
The `regex` crate features built-in mitigations to prevent denial of service attacks caused by untrusted regexes, or untrusted input matched by trusted regexes. Those (tunable) mitigations already provide sane defaults to prevent attacks. This guarantee is documented and it's considered part of the crate's API.
Unfortunately a bug was discovered in the mitigations designed to prevent untrusted regexes to take an arbitrary amount of time during parsing, and it's possible to craft regexes that bypass such mitigations. This makes it possible to perform denial of service attacks by sending specially crafted regexes to services accepting user-controlled, untrusted regexes.
## Affected versions
All versions of the `regex` crate before or equal to 1.5.4 are affected by this issue. The fix is include starting from `regex` 1.5.5.
## Mitigations
We recommend everyone accepting user-controlled regexes to upgrade immediately to the latest version of the `regex` crate.
Unfortunately there is no fixed set of problematic regexes, as there are practically infinite regexes that could be crafted to exploit this vulnerability. Because of this, we do not recommend denying known problematic regexes.
## Acknowledgements
We want to thank Addison Crump for responsibly disclosing this to us according to the [Rust security policy](https://www.rust-lang.org/policies/security), and for helping review the fix.
We also want to thank Andrew Gallant for developing the fix, and Pietro Albini for coordinating the disclosure and writing this advisory.
|
{'CVE-2022-24713'}
|
2022-03-11T19:58:44Z
|
2022-03-08T20:00:36Z
|
HIGH
| null |
{'CWE-400'}
|
{'https://www.debian.org/security/2022/dsa-5113', 'https://groups.google.com/g/rustlang-security-announcements/c/NcNNL1Jq7Yw', 'https://nvd.nist.gov/vuln/detail/CVE-2022-24713', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/JANLZ3JXWJR7FSHE57K66UIZUIJZI67T/', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/O3YB7CURSG64CIPCDPNMGPE4UU24AB6H/', 'https://lists.debian.org/debian-lts-announce/2022/04/msg00009.html', 'https://lists.debian.org/debian-lts-announce/2022/04/msg00003.html', 'https://github.com/rust-lang/regex/', 'https://www.debian.org/security/2022/dsa-5118', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/PDOWTHNVGBOP2HN27PUFIGRYNSNDTYRJ/', 'https://github.com/rust-lang/regex/commit/ae70b41d4f46641dbc45c7a4f87954aea356283e', 'https://github.com/rust-lang/regex/security/advisories/GHSA-m5pq-gvj9-9vr8'}
| null |
crates.io
|
RUSTSEC-2021-0016
|
`IoReader::read()`: user-provided `Read` on uninitialized buffer may cause UB
|
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.
The flaw was fixed in commit 599313b by zero-initializing the buffer (via `self.buf.resize(len, 0)`) before passing it to `Read`.
|
{'CVE-2021-26952'}
|
2021-10-19T22:14:35Z
|
2021-01-26T12:00:00Z
| null | null | null |
{'https://github.com/andrewhickman/ms3d/issues/1', 'https://crates.io/crates/ms3d', 'https://rustsec.org/advisories/RUSTSEC-2021-0016.html'}
| null |
crates.io
|
GHSA-vqx7-pw4r-29rr
|
Out of bounds read in bumpalo
|
An issue was discovered in the bumpalo crate before 3.2.1 for Rust. The realloc feature allows the reading of unknown memory. Attackers can potentially read cryptographic keys.
|
{'CVE-2020-35861'}
|
2021-08-19T21:18:29Z
|
2021-08-25T20:47:13Z
|
HIGH
| null |
{'CWE-125'}
|
{'https://github.com/fitzgen/bumpalo/issues/69', 'https://github.com/fitzgen/bumpalo', 'https://rustsec.org/advisories/RUSTSEC-2020-0006.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35861'}
| null |
crates.io
|
GHSA-rqgx-hpg4-456r
|
Use-after-free in actix-codec
|
An issue was discovered in the actix-codec crate before 0.3.0-beta.1 for Rust. There is a use-after-free in Framed.
|
{'CVE-2020-35902'}
|
2021-08-19T20:50:52Z
|
2021-08-25T20:49:45Z
|
CRITICAL
| null |
{'CWE-416'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0049.html', 'https://github.com/actix/actix-net', 'https://github.com/actix/actix-net/issues/91', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35902'}
| null |
crates.io
|
RUSTSEC-2019-0020
|
fix unsound APIs that could lead to UB
|
Affected versions of this crate API could use uninitialized memory with some APIs in special
cases, like use the API in none generator context. This could lead to UB.
The flaw was corrected by <https://github.com/Xudong-Huang/generator-rs/issues/9>
<https://github.com/Xudong-Huang/generator-rs/issues/11>
<https://github.com/Xudong-Huang/generator-rs/issues/13>
<https://github.com/Xudong-Huang/generator-rs/issues/14>
This patch fixes all those issues above.
|
{'CVE-2019-16144'}
|
2021-10-19T22:14:35Z
|
2019-09-06T12:00:00Z
| null | null | null |
{'https://github.com/Xudong-Huang/generator-rs/issues/9', 'https://rustsec.org/advisories/RUSTSEC-2019-0020.html', 'https://crates.io/crates/generator'}
| null |
crates.io
|
RUSTSEC-2020-0118
|
Future<T> lacks bounds on Send and Sync.
|
`tiny_future` contains a light-weight implementation of `Future`s. The `Future`
type it has lacked bound on its `Send` and `Sync` traits.
This allows for a bug where non-thread safe types such as `Cell` can be used in
`Future`s and cause data races in concurrent programs.
The flaw was corrected in commit `c791919` by adding trait bounds to `Future`'s
`Send` and `Sync`.
|
{'CVE-2020-36438'}
|
2021-10-19T22:14:35Z
|
2020-12-08T12:00:00Z
| null | null | null |
{'https://github.com/KizzyCode/tiny_future/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2020-0118.html', 'https://crates.io/crates/tiny_future'}
| null |
crates.io
|
GHSA-3cgf-9m6x-pwwr
|
Data races in rusqlite
|
An issue was discovered in the rusqlite crate before 0.23.0 for Rust. Memory safety can be violated via UnlockNotification.
|
{'CVE-2020-35868'}
|
2021-08-19T21:08:22Z
|
2021-08-25T20:47:50Z
|
CRITICAL
| null |
{'CWE-362'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-35868', 'https://github.com/rusqlite/rusqlite/releases/tag/0.23.0', 'https://rustsec.org/advisories/RUSTSEC-2020-0014.html', 'https://github.com/rusqlite/rusqlite/commit/45fd77ee43c38eea4d6f4e2e56c1667a55ec654f', 'https://github.com/rusqlite/rusqlite'}
| null |
crates.io
|
RUSTSEC-2020-0056
|
stdweb is unmaintained
|
The author of the `stdweb` crate is unresponsive.
Maintained alternatives:
- [`wasm-bindgen`](https://github.com/rustwasm/wasm-bindgen)
- [`js-sys`](https://github.com/rustwasm/wasm-bindgen/tree/master/crates/js-sys)
- [`web-sys`](https://github.com/rustwasm/wasm-bindgen/tree/master/crates/web-sys)
| null |
2020-10-25T18:57:46Z
|
2020-05-04T12:00:00Z
| null | null | null |
{'https://crates.io/crates/stdweb', 'https://github.com/koute/stdweb/issues/403', 'https://rustsec.org/advisories/RUSTSEC-2020-0056.html'}
| null |
crates.io
|
GHSA-3mf3-2gv9-h39j
|
Uninitialized buffer use in marc
|
An issue was discovered in the marc crate before 2.0.0 for Rust. A user-provided Read implementation can gain access to the old contents of newly allocated memory, violating soundness.
|
{'CVE-2021-26308'}
|
2021-08-19T17:52:28Z
|
2021-08-25T20:53:14Z
|
HIGH
| null |
{'CWE-908'}
|
{'https://github.com/blackbeam/rust-marc', 'https://nvd.nist.gov/vuln/detail/CVE-2021-26308', 'https://rustsec.org/advisories/RUSTSEC-2021-0014.html', 'https://github.com/blackbeam/rust-marc/issues/7'}
| null |
crates.io
|
RUSTSEC-2020-0113
|
AtomicOption should have Send + Sync bound on its type argument.
|
In the affected versions of this crate,
`AtomicOption<T>` unconditionally implements `Sync`.
This allows programmers to move non-Sync types across thread boundaries (e.g. `Rc<T>`, `Arc<Cell<T>>`), which can lead to data races and undefined behavior.
It is also possible to send non-Send types like `std::sync::MutexGuard` to other threads, which can lead to undefined behavior.
|
{'CVE-2020-36219'}
|
2021-10-19T22:14:35Z
|
2020-10-31T12:00:00Z
| null | null | null |
{'https://github.com/reem/rust-atomic-option/issues/4', 'https://crates.io/crates/atomic-option', 'https://rustsec.org/advisories/RUSTSEC-2020-0113.html'}
| null |
crates.io
|
GHSA-6wp2-fw3v-mfmc
|
Memory corruption in array-tools
|
An issue was discovered in the array-tools crate before 0.3.2 for Rust. Affected versions of this crate don't guard against panics, so that partially uninitialized buffer is dropped when user-provided `T::clone()` panics in `FixedCapacityDequeLike<T, A>::clone()`. This causes memory corruption.
|
{'CVE-2020-36452'}
|
2021-08-24T18:54:26Z
|
2021-08-25T20:57:19Z
|
CRITICAL
| null |
{'CWE-908', 'CWE-909'}
|
{'https://github.com/L117/array-tools', 'https://github.com/L117/array-tools/issues/2', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36452', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/array-tools/RUSTSEC-2020-0132.md', 'https://rustsec.org/advisories/RUSTSEC-2020-0132.html'}
| null |
crates.io
|
GHSA-w65j-g6c7-g3m4
|
Multiple memory safety issues in actix-web
|
Affected versions contain multiple memory safety issues, such as:
- Unsoundly coercing immutable references to mutable references
- Unsoundly extending lifetimes of strings
- Adding the `Send` marker trait to objects that cannot be safely sent between threads
This may result in a variety of memory corruption scenarios, most likely use-after-free.
A signficant refactoring effort has been conducted to resolve these issues.
| null |
2021-08-24T19:13:30Z
|
2021-08-25T20:42:50Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/actix/actix-web/issues/289', 'https://github.com/actix/actix-web', 'https://rustsec.org/advisories/RUSTSEC-2018-0019'}
| null |
crates.io
|
RUSTSEC-2020-0001
|
Stack overflow when resolving additional records from MX or SRV null targets
|
There's a stack overflow leading to a crash and potential DOS when processing
additional records for return of MX or SRV record types from the server.
This is only possible when a zone is configured with a null target for MX or SRV records, i.e. '.'.
Example effected zone record:
```text
no-service 86400 IN MX 0 .
```
Prior to 0.16.0 the additional record processing was not supported by trust-dns-server. There
Are no known issues with upgrading from 0.16 or 0.17 to 0.18.1. The remidy should be to upgrade to
0.18.1. If unable to do so, MX, SRV or other record types with a target to the null type, should be avoided.
|
{'CVE-2020-35857'}
|
2021-10-19T22:14:35Z
|
2020-01-06T12:00:00Z
| null | null | null |
{'https://github.com/bluejekyll/trust-dns/issues/980', 'https://crates.io/crates/trust-dns-server', 'https://rustsec.org/advisories/RUSTSEC-2020-0001.html'}
| null |
crates.io
|
RUSTSEC-2020-0144
|
lzw is unmaintained
|
The author of the `lzw` crate is unresponsive.
Maintained alternatives:
- [`weezl`](https://crates.io/crates/weezl)
| null |
2021-02-10T18:27:15Z
|
2020-02-10T12:00:00Z
| null | null | null |
{'https://github.com/nwin/lzw/issues/2', 'https://crates.io/crates/lzw', 'https://rustsec.org/advisories/RUSTSEC-2020-0144.html'}
| null |
crates.io
|
GHSA-5hpj-m323-cphm
|
Double free in through
|
An issue was discovered in the through crate through 2021-02-18 for Rust. There is a double free (in through and through_and) upon a panic of the map function.
|
{'CVE-2021-29940'}
|
2021-08-19T17:15:33Z
|
2021-08-25T20:54:12Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://github.com/gretchenfrage/through', 'https://github.com/gretchenfrage/through/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0049.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29940'}
| null |
crates.io
|
RUSTSEC-2021-0119
|
Out-of-bounds write in nix::unistd::getgrouplist
|
On certain platforms, if a user has more than 16 groups, the
`nix::unistd::getgrouplist` function will call the libc `getgrouplist`
function with a length parameter greater than the size of the buffer it
provides, resulting in an out-of-bounds write and memory corruption.
The libc `getgrouplist` function takes an in/out parameter `ngroups`
specifying the size of the group buffer. When the buffer is too small to
hold all of the reqested user's group memberships, some libc
implementations, including glibc and Solaris libc, will modify `ngroups`
to indicate the actual number of groups for the user, in addition to
returning an error. The version of `nix::unistd::getgrouplist` in nix
0.16.0 and up will resize the buffer to twice its size, but will not
read or modify the `ngroups` variable. Thus, if the user has more than
twice as many groups as the initial buffer size of 8, the next call to
`getgrouplist` will then write past the end of the buffer.
The issue would require editing /etc/groups to exploit, which is usually
only editable by the root user.
| null |
2021-10-08T16:17:22Z
|
2021-09-27T12:00:00Z
| null | null | null |
{'https://github.com/nix-rust/nix/issues/1541', 'https://rustsec.org/advisories/RUSTSEC-2021-0119.html', 'https://crates.io/crates/nix'}
| null |
crates.io
|
RUSTSEC-2022-0009
|
Failure to verify the public key of a `SignedEnvelope` against the `PeerId` in a `PeerRecord`
|
Affected versions of this crate did not check that the public key the signature was created with matches the peer ID of the peer record.
Any combination was considered valid.
This allows an attacker to republish an existing `PeerRecord` with a different `PeerId`.
| null |
2022-02-07T14:18:27Z
|
2022-02-07T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2022-0009.html', 'https://crates.io/crates/libp2p-core'}
| null |
crates.io
|
RUSTSEC-2018-0021
|
Use-after-free with objects returned by `Stream`'s `get_format_info` and `get_context` methods
|
Affected versions contained 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.
|
{'GHSA-ghpq-vjxw-ch5w'}
|
2021-06-09T01:07:22Z
|
2018-06-15T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2018-0021.html', 'https://github.com/jnqnfe/pulse-binding-rust/security/advisories/GHSA-ghpq-vjxw-ch5w', 'https://crates.io/crates/libpulse-binding'}
| null |
crates.io
|
GHSA-327x-39hh-65wf
|
Out of bounds write in arenavec
|
An issue was discovered in the arenavec crate through 0.1.1. A drop of uninitialized memory can sometimes occur upon a panic in T::default().
|
{'CVE-2021-29930'}
|
2021-08-19T17:04:41Z
|
2021-08-25T20:55:09Z
|
HIGH
| null |
{'CWE-787'}
|
{'https://github.com/ibabushkin/arenavec', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29930', 'https://github.com/ibabushkin/arenavec/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0040.html'}
| null |
crates.io
|
GHSA-h6xw-mghq-7523
|
Unsafe parsing in SWHKD
|
SWHKD 1.1.5 allows unsafe parsing via the -c option. An information leak might occur but there is a simple denial of service (memory exhaustion) upon an attempt to parse a large or infinite file (such as a block or character device).
|
{'CVE-2022-27819'}
|
2022-04-15T16:14:51Z
|
2022-04-08T00:00:24Z
|
MODERATE
| null |
{'CWE-400'}
|
{'http://www.openwall.com/lists/oss-security/2022/04/14/1', 'https://github.com/waycrate/swhkd/commit/b4e6dc76f4845ab03104187a42ac6d1bbc1e0021', 'https://github.com/waycrate/swhkd', 'https://github.com/waycrate/swhkd/releases/tag/1.1.7', 'https://nvd.nist.gov/vuln/detail/CVE-2022-27819', 'https://github.com/waycrate/swhkd/releases'}
| null |
crates.io
|
GHSA-6p3c-v8vc-c244
|
The `total_size` function for partial read the length of any `FixVec` is incorrect in molecule.
|
An issue was discovered in the molecule crate before 0.7.2 for Rust. A FixVec partial read has an incorrect result.
|
{'CVE-2021-45697'}
|
2022-01-07T17:57:26Z
|
2022-01-06T22:10:34Z
|
CRITICAL
| null | null |
{'https://nvd.nist.gov/vuln/detail/CVE-2021-45697', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/molecule/RUSTSEC-2021-0103.md', 'https://github.com/nervosnetwork/molecule', 'https://github.com/nervosnetwork/molecule/pull/49', 'https://rustsec.org/advisories/RUSTSEC-2021-0103.html'}
| null |
crates.io
|
GHSA-3hj2-hh36-hv9v
|
Data race in va-ts
|
An issue was discovered in the va-ts crate before 0.0.4 for Rust. Because Demuxer<T> omits a required T: Send bound, a data race and memory corruption can occur.
|
{'CVE-2020-36220'}
|
2021-08-19T18:47:06Z
|
2021-08-25T20:51:56Z
|
MODERATE
| null |
{'CWE-667', 'CWE-662', 'CWE-787'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0114.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36220', 'https://github.com/video-audio/va-ts', 'https://github.com/video-audio/va-ts/issues/4'}
| null |
crates.io
|
RUSTSEC-2020-0017
|
Use after free in ArcIntern::drop
|
`ArcIntern::drop` has a race condition where it can release memory
which is about to get another user. The new user will get a reference
to freed memory.
This was fixed by serializing access to an interned object while it
is being deallocated.
Versions prior to 0.3.12 used stronger locking which avoided the problem.
|
{'CVE-2020-35874'}
|
2021-10-19T22:14:35Z
|
2020-05-28T12:00:00Z
| null | null | null |
{'https://github.com/droundy/internment/issues/11', 'https://rustsec.org/advisories/RUSTSEC-2020-0017.html', 'https://crates.io/crates/internment'}
| null |
crates.io
|
GHSA-4vr9-8cjf-vf9c
|
Async-h1 request smuggling possible with long unread bodies
|
### Impact
This vulnerability affects any webserver that uses async-h1 behind a reverse proxy, including all such Tide applications.
If the server does not read the body of a request which is longer than some buffer length, async-h1 will attempt to read a subsequent request from the body content starting at that offset into the body.
One way to exploit this vulnerability would be for an adversary to craft a request such that the body contains a request that would not be noticed by a reverse proxy, allowing it to forge forwarded/x-forwarded headers. If an application trusted the authenticity of these headers, it could be misled by the smuggled request.
Another potential concern with this vulnerability is that if a reverse proxy is sending multiple http clients' requests along the same keep-alive connection, it would be possible for the smuggled request to specify a long content and capture another user's request in its body. This content could be captured in a post request to an endpoint that allows the content to be subsequently retrieved by the adversary.
### Patches
This has been addressed in async-h1 2.3.0 and previous versions have been yanked.
### Workarounds
none
### References
https://github.com/http-rs/async-h1/releases/tag/v2.3.0
### For more information
If you have any questions or comments about this advisory:
* Open an issue in [async-h1](https://github.com/http-rs/async-h1)
* Contact a core team member on [zulip](https://http-rs.zulip-chat.com) or [discord](https://discord.gg/x2gKzst)
|
{'CVE-2020-26281'}
|
2021-10-08T22:14:28Z
|
2021-10-12T16:00:37Z
|
MODERATE
| null |
{'CWE-444'}
|
{'https://github.com/http-rs/async-h1/security/advisories/GHSA-4vr9-8cjf-vf9c', 'https://github.com/http-rs/async-h1', 'https://nvd.nist.gov/vuln/detail/CVE-2020-26281', 'https://github.com/http-rs/async-h1/releases/tag/v2.3.0'}
| null |
crates.io
|
GHSA-4q4x-67hx-5mpg
|
Failure to properly verify ed25519 signatures in libp2p-core
|
An issue was discovered in the libp2p-core crate before 0.8.1 for Rust. Attackers can spoof ed25519 signatures.
|
{'CVE-2019-15545'}
|
2021-08-19T21:23:31Z
|
2021-08-25T20:44:08Z
|
HIGH
| null |
{'CWE-347'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-15545', 'https://rustsec.org/advisories/RUSTSEC-2019-0004.html', 'https://github.com/libp2p/rust-libp2p'}
| null |
crates.io
|
RUSTSEC-2020-0152
|
ImmediateIO and TransactionalIO can cause data races
|
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-10-19T22:14:35Z
|
2020-12-18T12:00:00Z
| null | null | null |
{'https://crates.io/crates/max7301', 'https://rustsec.org/advisories/RUSTSEC-2020-0152.html', 'https://github.com/edarc/max7301/issues/1'}
| null |
crates.io
|
GHSA-j42v-6wpm-r847
|
Data races in thex
|
An issue was discovered in the thex crate through 2020-12-08 for Rust. Thex<T> allows cross-thread data races of non-Send types.
|
{'CVE-2020-35927'}
|
2021-08-19T18:55:21Z
|
2021-08-25T20:50:26Z
|
MODERATE
| null |
{'CWE-662'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0090.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35927'}
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.