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-0040
|
Obstack generates unaligned references
|
Obstack generates unaligned references for types that require a large alignment.
|
{'CVE-2020-35894'}
|
2021-10-19T22:14:35Z
|
2020-09-03T12:00:00Z
| null | null | null |
{'https://github.com/petertodd/rust-obstack/issues/4', 'https://rustsec.org/advisories/RUSTSEC-2020-0040.html', 'https://crates.io/crates/obstack'}
| null |
crates.io
|
RUSTSEC-2020-0105
|
Update unsound DrainFilter and RString::retain
|
Affected versions of this crate contained code from the Rust standard library that contained soundness bugs rust-lang/rust#60977 (double drop) & rust-lang/rust#78498 (create invalid utf-8 string).
The flaw was corrected in v0.9.1 by making a similar fix to the one made in the Rust standard library.
|
{'CVE-2020-36213', 'CVE-2020-36212'}
|
2021-10-19T22:14:35Z
|
2020-12-21T12:00:00Z
| null | null | null |
{'https://crates.io/crates/abi_stable', 'https://github.com/rodrimati1992/abi_stable_crates/issues/44', 'https://rustsec.org/advisories/RUSTSEC-2020-0105.html'}
| null |
crates.io
|
GHSA-2v78-j59h-fmpf
|
Heap overflow or corruption in safe-transmute
|
An issue was discovered in the safe-transmute crate before 0.10.1 for Rust. A constructor's arguments are in the wrong order, causing heap memory corruption.
|
{'CVE-2018-21000'}
|
2021-08-19T21:24:31Z
|
2021-08-25T20:43:23Z
|
CRITICAL
| null |
{'CWE-119'}
|
{'https://github.com/nabijaczleweli/safe-transmute-rs/pull/36', 'https://github.com/nabijaczleweli/safe-transmute-rs', 'https://nvd.nist.gov/vuln/detail/CVE-2018-21000', 'https://rustsec.org/advisories/RUSTSEC-2018-0013.html'}
| null |
crates.io
|
RUSTSEC-2021-0070
|
VecStorage Deserialize Allows Violation of Length Invariant
|
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`.
This flaw was corrected in commit [`5bff536`](https://github.com/dimforge/nalgebra/commit/5bff5368bf38ddfa31416e4ae9897b163031a513) by returning an error during deserialization if the number of elements does not exactly match the expected size.
|
{'CVE-2021-38190'}
|
2021-11-06T20:37:35Z
|
2021-06-06T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0070.html', 'https://crates.io/crates/nalgebra', 'https://github.com/dimforge/nalgebra/issues/883'}
| null |
crates.io
|
RUSTSEC-2021-0135
|
Improper validation of Windows paths could lead to directory traversal attack
|
`tower_http::services::fs::ServeDir` didn't correctly validate Windows paths
meaning paths like `/foo/bar/c:/windows/web/screen/img101.png` would be allowed
and respond with the contents of `c:/windows/web/screen/img101.png`. Thus users
could potentially read files anywhere on the filesystem.
This only impacts Windows. Linux and other unix likes are not impacted by this.
See [tower-http#204] for more details.
[tower-http#204]: https://github.com/tower-rs/tower-http/pull/204
| null |
2022-01-22T15:22:46Z
|
2021-01-21T12:00:00Z
| null | null | null |
{'https://crates.io/crates/tower-http', 'https://rustsec.org/advisories/RUSTSEC-2021-0135.html', 'https://github.com/tower-rs/tower-http/pull/204'}
| null |
crates.io
|
GHSA-wcvp-r8j8-47pc
|
Double free in toodee
|
An issue was discovered in the toodee crate before 0.3.0 for Rust. Row insertion can cause a double free upon an iterator panic.
|
{'CVE-2021-28028'}
|
2021-08-30T21:56:42Z
|
2021-09-01T18:30:35Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0028.html', 'https://github.com/antonmarsden/toodee', 'https://nvd.nist.gov/vuln/detail/CVE-2021-28028'}
| null |
crates.io
|
GHSA-rccq-j2m7-8fwr
|
Double-free in id-map
|
An issue was discovered in the id-map crate through 2021-02-26 for Rust. A double free can occur in remove_set upon a panic in a Drop impl.
|
{'CVE-2021-30457'}
|
2021-08-19T17:04:15Z
|
2021-08-25T20:55:14Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://github.com/andrewhickman/id-map/issues/3', 'https://rustsec.org/advisories/RUSTSEC-2021-0052.html', 'https://github.com/andrewhickman/id-map', 'https://nvd.nist.gov/vuln/detail/CVE-2021-30457'}
| null |
crates.io
|
RUSTSEC-2021-0027
|
Loading a bgzip block can write out of bounds if size overflows.
|
Affected versions of `bam` set the length of an internal buffer using
`self.compressed.set_len(block_size - HEADER_SIZE - MIN_EXTRA_SIZE)` and then
wrote into it. While `block_size` was constrained to a proper maximum, when it
was too small the subtraction could overflow negatively to a large number past
the capacity of `self.compressed`.
This can result in memory corruption in the form of writing out of bounds when
loading a `bgzip` file with a small `block_size`.
Commit `061eee38d4` fixed this issue by checking for the underflow when setting
the buffer size.
|
{'CVE-2021-28027'}
|
2021-10-19T22:14:35Z
|
2021-01-07T12:00:00Z
| null | null | null |
{'https://gitlab.com/tprodanov/bam/-/issues/4', 'https://rustsec.org/advisories/RUSTSEC-2021-0027.html', 'https://crates.io/crates/bam'}
| null |
crates.io
|
RUSTSEC-2016-0003
|
HTTP download and execution allows MitM RCE
|
The build script in the portaudio crate will attempt to download via HTTP
the portaudio source and build it.
A Mallory in the middle can intercept the download with their own archive
and get RCE.
|
{'CVE-2016-10933'}
|
2021-10-19T22:14:35Z
|
2016-08-01T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2016-0003.html', 'https://crates.io/crates/portaudio', 'https://github.com/RustAudio/rust-portaudio/issues/144'}
| null |
crates.io
|
GHSA-3r3g-g73x-g593
|
Improper Verification of Cryptographic Signature in coreos
|
### Impact
coreos-installer fails to correctly verify GPG signatures when decompressing gzip-compressed artifacts. This allows bypass of signature verification in cases where coreos-installer decompresses a downloaded OS image, allowing an attacker who can modify the OS image to compromise a newly-installed system.
Default installations from ISO or PXE media in Fedora CoreOS, RHEL CoreOS, and RHEL for Edge are **not** affected, as coreos-installer installs from an OS image shipped as part of the install media.
These flows are affected:
1. Installing with `--image-file`, `--image-url`, or `coreos.inst.image_url`. For example, if a user has a local mirror of installation images, an attacker could replace an image with a gzip-compressed alternative (even if the file extension is `.xz`). The result:
```
$ coreos-installer install --image-url http://localhost:8080/image.xz /dev/loop0
Downloading image from http://localhost:8080/image.xz
Downloading signature from http://localhost:8080/image.xz.sig
> Read disk 749.9 MiB/749.9 MiB (100%)
gpg: Signature made Mon 20 Sep 2021 02:41:50 PM EDT
gpg: using RSA key 8C5BA6990BDB26E19F2A1A801161AE6945719A39
gpg: BAD signature from "Fedora (34) <fedora-34-primary@fedoraproject.org>" [ultimate]
Install complete.
```
Notice that GPG reports a bad signature, but coreos-installer continues anyway. Automation that relies on coreos-installer's exit status will not notice either.
2. `coreos-installer download --decompress --image-url`:
```
$ coreos-installer download --decompress --image-url http://localhost:8080/image.xz
> Read disk 749.9 MiB/749.9 MiB (100%)
gpg: Signature made Mon 20 Sep 2021 02:41:50 PM EDT
gpg: using RSA key 8C5BA6990BDB26E19F2A1A801161AE6945719A39
gpg: BAD signature from "Fedora (34) <fedora-34-primary@fedoraproject.org>" [ultimate]
./image
```
Again, coreos-installer reports success.
3. Installing with default parameters, when **not** installing from the image built into live ISO or PXE media, if the hosting service is compromised or if an active attacker gains control of the HTTPS response.
4. `coreos-installer download --decompress` if the hosting service is compromised or if an active attacker gains control of the HTTPS response.
### Patches
The vulnerability is [fixed](https://github.com/coreos/coreos-installer/pull/659) in coreos-installer 0.10.1.
### Workarounds
For `coreos-installer download`, do not use the `-d` or `--decompress` options.
For `coreos-installer install`, manually inspect the stderr output. If `BAD signature` appears, do not boot from the target disk. Note, however, that some OS services may have already accessed data on the compromised disk.
### References
For more information, see [PR 655](https://github.com/coreos/coreos-installer/pull/655).
### For more information
If you have any questions or comments about this advisory, [open an issue in coreos-installer](https://github.com/coreos/coreos-installer/issues/new/choose) or email the CoreOS [development mailing list](https://lists.fedoraproject.org/archives/list/coreos@lists.fedoraproject.org/).
|
{'CVE-2021-20319'}
|
2022-03-15T00:15:58Z
|
2021-10-12T16:06:47Z
|
HIGH
| null |
{'CWE-347'}
|
{'https://github.com/coreos/coreos-installer', 'https://nvd.nist.gov/vuln/detail/CVE-2021-20319', 'https://github.com/coreos/coreos-installer/pull/655', 'https://github.com/coreos/coreos-installer/security/advisories/GHSA-3r3g-g73x-g593', 'https://bugzilla.redhat.com/show_bug.cgi?id=2011862', 'https://github.com/coreos/coreos-installer/pull/659/commits/ad243c6f0eff2835b2da56ca5f7f33af76253c89'}
| null |
crates.io
|
RUSTSEC-2020-0083
|
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://crates.io/crates/safe_app', 'https://github.com/maidsafe/sn_client/pull/1267', 'https://rustsec.org/advisories/RUSTSEC-2020-0083.html'}
| null |
crates.io
|
RUSTSEC-2020-0129
|
ShmWriter allows sending non-Send type across threads
|
Affected versions of this crate implement `Send` for `ShmWriter<H>` without requiring `H: Send`. This allows users to send `H: !Send` to other threads, which can potentially lead to data races and undefined behavior.
|
{'CVE-2020-36449'}
|
2021-10-19T22:14:35Z
|
2020-12-18T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0129.html', 'https://github.com/motoras/kekbit/issues/34', 'https://crates.io/crates/kekbit'}
| null |
crates.io
|
RUSTSEC-2019-0011
|
Flaw in offset_of and span_of causes SIGILL, drops uninitialized memory of arbitrary type on panic in client code
|
Affected versions of this crate caused traps and/or memory unsafety by zero-initializing references.
They also could lead to uninitialized memory being dropped if the field for which the offset is requested was behind a deref coercion, and that deref coercion caused a panic.
The flaw was corrected by using `MaybeUninit`.
|
{'CVE-2019-15553'}
|
2021-10-19T22:14:35Z
|
2019-07-16T12:00:00Z
| null | null | null |
{'https://github.com/Gilnaa/memoffset/issues/9#issuecomment-505461490', 'https://crates.io/crates/memoffset', 'https://rustsec.org/advisories/RUSTSEC-2019-0011.html'}
| null |
crates.io
|
RUSTSEC-2021-0031
|
split_at allows obtaining multiple mutable references to the same data
|
Affected versions of this crate assumed that `Borrow<Idx>` was guaranteed to
return the same value on `.borrow()`. The borrowed index value was used to
retrieve a mutable reference to a value.
If the `Borrow<Idx>` implementation returned a different index, the split arena
would allow retrieving the index as a mutable reference creating two mutable
references to the same element. This violates Rust's aliasing rules and allows
for memory safety issues such as writing out of bounds and use-after-frees.
The flaw was corrected in commit `6b83f9d` by storing the `.borrow()` value in
a temporary variable.
|
{'CVE-2021-28032'}
|
2021-10-19T22:14:35Z
|
2021-01-31T12:00:00Z
| null | null | null |
{'https://crates.io/crates/nano_arena', 'https://github.com/bennetthardwick/nano-arena/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0031.html'}
| null |
crates.io
|
RUSTSEC-2020-0095
|
difference is unmaintained
|
The author of the `difference` crate is unresponsive.
Maintained alternatives:
- [`dissimilar`](https://crates.io/crates/dissimilar)
- [`similar`](https://crates.io/crates/similar)
- [`treediff`](https://crates.io/crates/treediff)
- [`diffus`](https://crates.io/crates/diffus)
| null |
2021-01-24T19:50:18Z
|
2020-12-20T12:00:00Z
| null | null | null |
{'https://crates.io/crates/difference', 'https://github.com/johannhof/difference.rs/issues/45', 'https://rustsec.org/advisories/RUSTSEC-2020-0095.html'}
| null |
crates.io
|
RUSTSEC-2019-0007
|
Processing of maliciously crafted length fields causes memory allocation SIGABRTs
|
Affected versions of this crate tried to preallocate a vector for an arbitrary amount of bytes announced by the ASN.1-DER length field without further checks.
This allows an attacker to trigger a SIGABRT by creating length fields that announce more bytes than the allocator can provide.
The flaw was corrected by not preallocating memory.
|
{'CVE-2019-15549'}
|
2021-10-19T22:14:35Z
|
2019-06-13T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0007.html', 'https://github.com/KizzyCode/asn1_der/issues/1', 'https://crates.io/crates/asn1_der'}
| null |
crates.io
|
RUSTSEC-2021-0066
|
Denial of service on EVM execution due to memory over-allocation
|
Prior to the patch, when executing specific EVM opcodes related
to memory operations that use `evm_core::Memory::copy_large`, the
crate can over-allocate memory when it is not needed, making it
possible for an attacker to perform denial-of-service attack.
The flaw was corrected in commit `19ade85`.
| null |
2021-05-12T01:59:58Z
|
2021-05-11T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0066.html', 'https://crates.io/crates/evm-core', 'https://github.com/rust-blockchain/evm'}
| null |
crates.io
|
GHSA-862g-9h5m-m3qv
|
coreos-installer < 0.10.0 writes world-readable Ignition config to installed system
|
### Impact
On systems installed with coreos-installer before 0.10.0, the user-provided Ignition config was written to `/boot/ignition/config.ign` with world-readable permissions, granting unprivileged users access to any secrets included in the config.
Default configurations of Fedora CoreOS and RHEL CoreOS do not include any unprivileged user accounts. In addition, instances launched from a cloud image, and systems provisioned with the `ignition.config.url` kernel argument, do not use the `config.ign` file and are unaffected.
### Patches
coreos-installer 0.10.0 and later [writes](https://github.com/coreos/coreos-installer/pull/571) the Ignition config with restricted permissions.
### Workarounds
On Fedora CoreOS systems installed from version 34.20210711.3.0 (stable), 34.20210711.2.0 (testing), 34.20210711.1.1 (next) and later, the `/boot/ignition` directory and its contents are removed after provisioning is complete. All Fedora CoreOS systems that have updated to these versions or later have automatically removed the `/boot/ignition` directory and no action is required.
On other systems, `/boot/ignition/config.ign` can be removed manually, as it is not used after provisioning is complete:
```
sudo mount -o remount,rw /boot
sudo rm -rf /boot/ignition
```
### References
For more information, see https://github.com/coreos/fedora-coreos-tracker/issues/889.
### For more information
If you have any questions or comments about this advisory, [open an issue in coreos-installer](https://github.com/coreos/coreos-installer/issues/new/choose) or email the CoreOS [development mailing list](https://lists.fedoraproject.org/archives/list/coreos@lists.fedoraproject.org/).
|
{'CVE-2021-3917'}
|
2021-11-04T17:11:09Z
|
2021-11-08T18:01:13Z
|
LOW
| null | null |
{'https://github.com/coreos/coreos-installer/commit/2a36405339c87b16ed6c76e91ad5b76638fbdb0c', 'https://github.com/coreos/coreos-installer/releases/tag/v0.10.0', 'https://github.com/coreos/coreos-installer/security/advisories/GHSA-862g-9h5m-m3qv', 'https://github.com/coreos/coreos-installer/'}
| null |
crates.io
|
GHSA-x3mh-jvjw-3xwx
|
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. In the OpenSSL 1.0.2 version the public key is not parsed during initial parsing of the certificate which makes it slightly harder to trigger the infinite loop. However any operation which requires the public key from the certificate will trigger the infinite loop. In particular the attacker can use a self-signed certificate to trigger the loop during verification of the certificate signature. This issue affects OpenSSL versions 1.0.2, 1.1.1 and 3.0. It was addressed in the releases of 1.1.1n and 3.0.2 on the 15th March 2022. Fixed in OpenSSL 3.0.2 (Affected 3.0.0,3.0.1). Fixed in OpenSSL 1.1.1n (Affected 1.1.1-1.1.1m). Fixed in OpenSSL 1.0.2zd (Affected 1.0.2-1.0.2zc).
|
{'CVE-2022-0778'}
|
2022-05-03T20:40:34Z
|
2022-03-16T00:00:45Z
|
HIGH
| null |
{'CWE-835'}
|
{'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/GDB3GQVJPXJE7X5C5JN6JAA4XUDWD6E6/', 'https://git.openssl.org/gitweb/?p=openssl.git;a=commitdiff;h=a466912611aa6cbdf550cd10601390e587451246', 'https://www.tenable.com/security/tns-2022-09', 'https://nvd.nist.gov/vuln/detail/CVE-2022-0778', 'https://psirt.global.sonicwall.com/vuln-detail/SNWLID-2022-0002', 'https://lists.debian.org/debian-lts-announce/2022/03/msg00024.html', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/323SNN6ZX7PRJJWP2BUAFLPUAE42XWLZ/', 'https://git.openssl.org/gitweb/?p=openssl.git;a=commitdiff;h=3118eb64934499d93db3230748a452351d1d9a65', 'https://www.debian.org/security/2022/dsa-5103', 'https://www.openssl.org/news/secadv/20220315.txt', 'https://lists.debian.org/debian-lts-announce/2022/03/msg00023.html', 'https://www.tenable.com/security/tns-2022-07', 'https://www.tenable.com/security/tns-2022-08', 'https://rustsec.org/advisories/RUSTSEC-2022-0014.html', 'https://www.tenable.com/security/tns-2022-06', 'https://www.oracle.com/security-alerts/cpuapr2022.html', 'https://security.netapp.com/advisory/ntap-20220321-0002/', 'https://git.openssl.org/gitweb/?p=openssl.git;a=commitdiff;h=380085481c64de749a6dd25cdf0bcf4360b30f83', 'https://security.netapp.com/advisory/ntap-20220429-0005/', 'https://lists.fedoraproject.org/archives/list/package-announce@lists.fedoraproject.org/message/W6K3PR542DXWLEFFMFIDMME4CWMHJRMG/'}
| null |
crates.io
|
RUSTSEC-2021-0123
|
Converting `NSString` to a String Truncates at Null Bytes
|
Methods of [`NSString`] for conversion to a string may return a partial result.
Since they call [`CStr::from_ptr`] on a pointer to the string buffer, the
string is terminated at the first null byte, which might not be the end of the
string.
In addition to the vulnerable functions listed for this issue, the
implementations of [`Display`], [`PartialEq`], [`PartialOrd`], and [`ToString`]
for [`NSString`] are also affected, since they call those functions.
## Impact
Since [`NSString`] is commonly used as the type for paths by the [Foundation]
framework, null byte truncation might allow for easily bypassing file extension
checks. For example, if a file name is provided by a user and validated to have
one of a specific set of extensions, with validation taking place before
truncation, an attacker can add an accepted extension after a null byte (e.g.,
`file.exe\0.txt`). After truncation, the file name used by the application
would be `file.exe`.
It would be better to generate unique names for files, instead of using
user-provided names, but not all applications take this approach.
## Example:
```rust
let string = NSString::from_str("null\0byte");
println!("{}", string);
```
That example only prints the string "null".
[`CStr::from_ptr`]: https://doc.rust-lang.org/std/ffi/struct.CStr.html#method.from_ptr
[`Display`]: https://doc.rust-lang.org/std/fmt/trait.Display.html
[Foundation]: https://developer.apple.com/documentation/foundation
[`NSString`]: https://docs.rs/fruity/0.2.0/fruity/foundation/struct.NSString.html
[`PartialEq`]: https://doc.rust-lang.org/std/cmp/trait.PartialEq.html
[`PartialOrd`]: https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html
[`ToString`]: https://doc.rust-lang.org/std/string/trait.ToString.html
|
{'CVE-2021-43620'}
|
2022-04-19T00:03:30Z
|
2021-11-14T12:00:00Z
| null | null | null |
{'https://github.com/nvzqz/fruity/issues/14', 'https://crates.io/crates/fruity', 'https://rustsec.org/advisories/RUSTSEC-2021-0123.html'}
| null |
crates.io
|
RUSTSEC-2021-0089
|
Optional `Deserialize` implementations lacking validation
|
When activating the non-default feature `serialize`, most structs implement
`serde::Deserialize` without sufficient validation. This allows breaking
invariants in safe code, leading to:
* Undefined behavior in `as_string()` methods (which use
`std::str::from_utf8_unchecked()` internally).
* Panics due to failed assertions.
See https://github.com/gz/rust-cpuid/issues/43.
| null |
2021-08-22T09:43:52Z
|
2021-01-20T12:00:00Z
| null | null | null |
{'https://crates.io/crates/raw-cpuid', 'https://rustsec.org/advisories/RUSTSEC-2021-0089.html', 'https://github.com/gz/rust-cpuid/issues/43'}
| null |
crates.io
|
GHSA-cv7x-6rc6-pq5v
|
Double free in containers
|
An issue was discovered in the containers crate before 0.9.11 for Rust. When a panic occurs, a util::{mutate,mutate2} double drop can be performed.
|
{'CVE-2021-25907'}
|
2021-08-19T18:40:39Z
|
2021-08-25T20:53:05Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0010.html', 'https://github.com/strake/containers.rs', 'https://github.com/strake/containers.rs/issues/2', 'https://nvd.nist.gov/vuln/detail/CVE-2021-25907'}
| null |
crates.io
|
GHSA-mp6f-p9gp-vpj9
|
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 pair().
|
{'CVE-2020-25792'}
|
2021-08-19T21:20:31Z
|
2021-08-25T20:46:06Z
|
HIGH
| null |
{'CWE-129'}
|
{'https://github.com/bodil/sized-chunks', 'https://rustsec.org/advisories/RUSTSEC-2020-0041.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-25792', 'https://github.com/bodil/sized-chunks/issues/11'}
| null |
crates.io
|
RUSTSEC-2019-0027
|
Flaw in Scalar::check_overflow allows side-channel timing attack
|
Versions of `libsecp256k1` prior to `0.3.1` did not execute
Scalar::check_overflow in constant time.
This allows an attacker to potentially leak information via a timing attack.
The flaw was corrected by modifying Scalar::check_overflow to execute in
constant time.
|
{'CVE-2019-25003'}
|
2021-10-19T22:14:35Z
|
2019-10-14T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2019-0027.html', 'https://crates.io/crates/libsecp256k1'}
| null |
crates.io
|
GHSA-55m5-whcv-c49c
|
Use of Uninitialized Resource in smallvec
|
An issue was discovered in the smallvec crate before 0.6.13 for Rust. It can create an uninitialized value of any type, including a reference type.
|
{'CVE-2018-25023'}
|
2022-01-06T18:40:05Z
|
2022-01-06T22:20:28Z
|
HIGH
| null |
{'CWE-908'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2018-25023', 'https://rustsec.org/advisories/RUSTSEC-2018-0018.html', 'https://github.com/servo/rust-smallvec', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/smallvec/RUSTSEC-2018-0018.md'}
| null |
crates.io
|
GHSA-rg4m-gww5-7p47
|
Free of uninitialized memory in adtensor
|
An issue was discovered in the adtensor crate through 0.0.3 for Rust. There is a drop of uninitialized memory via the FromIterator implementation for Vector and Matrix.
|
{'CVE-2021-29936'}
|
2021-08-19T17:14:41Z
|
2021-08-25T20:54:18Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://github.com/charles-r-earp/adtensor', 'https://rustsec.org/advisories/RUSTSEC-2021-0045.html', 'https://github.com/charles-r-earp/adtensor/issues/4', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29936'}
| null |
crates.io
|
RUSTSEC-2021-0011
|
EventList's From<EventList> conversions can double drop on panic.
|
Affected versions of this crate read from a container using `ptr::read` in
`From<EventList>`, and then call a user specified `Into<Event>` function.
This issue can result in a double-free if the user provided function panics.
|
{'CVE-2021-25908'}
|
2021-10-19T22:14:35Z
|
2021-01-04T12:00:00Z
| null | null | null |
{'https://crates.io/crates/fil-ocl', 'https://rustsec.org/advisories/RUSTSEC-2021-0011.html', 'https://github.com/cogciprocate/ocl/issues/194'}
| null |
crates.io
|
GHSA-w7j2-35mf-95p7
|
Incorrect check on buffer length in rand_core
|
An issue was discovered in the rand_core crate before 0.6.2 for Rust. Because `read_u32_into` and `read_u64_into` mishandle certain buffer-length checks, a random number generator may be seeded with too little data. The vulnerability was introduced in v0.6.0. The advisory doesn't apply to earlier minor version numbers.
|
{'CVE-2021-27378'}
|
2022-04-29T17:25:01Z
|
2021-08-25T20:52:16Z
|
CRITICAL
| null |
{'CWE-330'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0023.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-27378', 'https://github.com/rust-random/rand/compare/0.6.0...rand_core-0.6.2#diff-f41b3dfa5ce28f3bee390d327c50621e141cf3569921f8e9ca15ccfcf25263a9R19', 'https://github.com/rust-random/rand/compare/0.6.0...rand_core-0.6.2#diff-f41b3dfa5ce28f3bee390d327c50621e141cf3569921f8e9ca15ccfcf25263a9R28', 'https://github.com/rust-random/rand/pull/1096', 'https://github.com/rust-random/rand'}
| null |
crates.io
|
RUSTSEC-2020-0148
|
Multiple soundness issues in `Ptr`
|
Affected versions of this crate have the following issues:
1. `Ptr` implements `Send` and `Sync` for all types, this can lead to data
races by sending non-thread safe types across threads.
2. `Ptr::get` violates mutable alias rules by returning multiple mutable
references to the same object.
3. `Ptr::write` uses non-atomic writes to the underlying pointer. This means
that when used across threads it can lead to data races.
|
{'CVE-2020-36466', 'CVE-2020-36467', 'CVE-2020-36468'}
|
2021-10-19T22:14:35Z
|
2020-12-10T12:00:00Z
| null | null | null |
{'https://crates.io/crates/cgc', 'https://github.com/playXE/cgc/issues/5', 'https://rustsec.org/advisories/RUSTSEC-2020-0148.html'}
| null |
crates.io
|
RUSTSEC-2021-0103
|
Partial read is incorrect in molecule
|
Anyone who uses total_size(..) function to partial read the length of any FixVec will get an incorrect result, due to an incorrect implementation. This has been resolved in the 0.7.2 release.
|
{'GHSA-82hm-vh7g-hrh9'}
|
2021-09-10T16:10:58Z
|
2021-07-30T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0103.html', 'https://crates.io/crates/molecule', 'https://github.com/nervosnetwork/molecule/security/advisories/GHSA-82hm-vh7g-hrh9'}
| null |
crates.io
|
GHSA-7j44-fv4x-79g9
|
Improper Input Validation in once_cell
|
An issue was discovered in the once_cell crate before 1.0.1 for Rust. There is a panic during initialization of Lazy.
|
{'CVE-2019-16141'}
|
2021-08-19T21:22:57Z
|
2021-08-25T20:44:18Z
|
MODERATE
| null |
{'CWE-20'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-16141', 'https://github.com/matklad/once_cell/issues/46', 'https://rustsec.org/advisories/RUSTSEC-2019-0017.html', 'https://github.com/matklad/once_cell'}
| null |
crates.io
|
RUSTSEC-2021-0046
|
misc::vec_with_size() can drop uninitialized memory if clone panics
|
`misc::vec_with_size` creates a vector of the provided `size` and immediately
calls `vec.set_len(size)` on it, initially filling it with uninitialized memory.
It then inserts elements using `vec[i] = value.clone()`.
If the `value.clone()` call panics, uninitialized items in the vector will be
dropped leading to undefined behavior.
|
{'CVE-2021-29937'}
|
2021-10-19T22:14:35Z
|
2021-02-17T12:00:00Z
| null | null | null |
{'https://github.com/Yoric/telemetry.rs/issues/45', 'https://rustsec.org/advisories/RUSTSEC-2021-0046.html', 'https://crates.io/crates/telemetry'}
| null |
crates.io
|
RUSTSEC-2022-0013
|
Regexes with large repetitions on empty sub-expressions take a very long time to parse
|
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][1], 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.
[1]: https://www.rust-lang.org/policies/security
|
{'CVE-2022-24713'}
|
2022-03-08T15:14:30Z
|
2022-03-08T12:00:00Z
| null | null | null |
{'https://groups.google.com/g/rustlang-security-announcements/c/NcNNL1Jq7Yw', 'https://crates.io/crates/regex', 'https://rustsec.org/advisories/RUSTSEC-2022-0013.html'}
| null |
crates.io
|
GHSA-w47j-hqpf-qw9w
|
Out of bounds read in lazy-init
|
An issue was discovered in the lazy-init crate through 2021-01-17 for Rust. Lazy lacks a Send bound, leading to a data race.
|
{'CVE-2021-25901'}
|
2021-08-19T18:45:15Z
|
2021-08-25T20:52:59Z
|
MODERATE
| null |
{'CWE-125'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-25901', 'https://rustsec.org/advisories/RUSTSEC-2021-0004.html', 'https://github.com/khuey/lazy-init', 'https://github.com/khuey/lazy-init/issues/9'}
| null |
crates.io
|
GHSA-p9gf-gmfv-398m
|
Double free in slice_deque
|
An issue was discovered in the slice-deque crate through 2021-02-19 for Rust. A double drop can occur in SliceDeque::drain_filter upon a panic in a predicate function.
|
{'CVE-2021-29938'}
|
2021-08-19T17:14:58Z
|
2021-08-25T20:54:16Z
|
HIGH
| null |
{'CWE-415'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-29938', 'https://github.com/gnzlbg/slice_deque', 'https://github.com/gnzlbg/slice_deque/issues/90', 'https://rustsec.org/advisories/RUSTSEC-2021-0047.html'}
| null |
crates.io
|
GHSA-vpw8-43wm-rxw5
|
Double free in endian_trait
|
An issue was discovered in the endian_trait crate through 2021-01-04 for Rust. A double drop can occur when a user-provided Endian impl panics.
|
{'CVE-2021-29929'}
|
2021-08-19T17:21:10Z
|
2021-08-25T20:54:06Z
|
HIGH
| null |
{'CWE-415'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0039.html', 'https://nvd.nist.gov/vuln/detail/CVE-2021-29929', 'https://gitlab.com/myrrlyn/endian_trait', 'https://gitlab.com/myrrlyn/endian_trait/-/issues/1'}
| null |
crates.io
|
RUSTSEC-2021-0115
|
`#[zeroize(drop)]` doesn't implement `Drop` for `enum`s
|
Affected versions of this crate did not implement `Drop` when `#[zeroize(drop)]` was used on an `enum`.
This can result in memory not being zeroed out after dropping it, which is exactly what is intended when adding this attribute.
The flaw was corrected in version 1.2 and `#[zeroize(drop)]` on `enum`s now properly implements `Drop`.
| null |
2021-10-12T15:24:09Z
|
2021-09-24T12:00:00Z
| null | null | null |
{'https://github.com/iqlusioninc/crates/issues/876', 'https://rustsec.org/advisories/RUSTSEC-2021-0115.html', 'https://crates.io/crates/zeroize_derive'}
| null |
crates.io
|
GHSA-v5m7-53cv-f3hx
|
Undefined Behavior crossbeam-channel
|
### Impact
The affected version of this crate's the `bounded` channel incorrectly assumes that `Vec::from_iter` has allocated capacity that same as the number of iterator elements. `Vec::from_iter` does not actually guarantee that and may allocate extra memory. The destructor of the `bounded` channel reconstructs `Vec` from the raw pointer based on the incorrect assumes described above. This is unsound and causing deallocation with the incorrect capacity when `Vec::from_iter` has allocated different sizes with the number of iterator elements.
### Patches
This has been fixed in crossbeam-channel 0.4.4.
We recommend users to upgrade to 0.4.4.
### References
See https://github.com/crossbeam-rs/crossbeam/pull/533, https://github.com/crossbeam-rs/crossbeam/issues/539, and https://github.com/RustSec/advisory-db/pull/425 for more details.
|
{'CVE-2020-15254'}
|
2021-08-18T20:38:06Z
|
2021-08-25T21:01:13Z
|
HIGH
| null |
{'CWE-119'}
|
{'https://github.com/crossbeam-rs/crossbeam', 'https://nvd.nist.gov/vuln/detail/CVE-2020-15254', 'https://rustsec.org/advisories/RUSTSEC-2020-0052.html', 'https://github.com/crossbeam-rs/crossbeam/security/advisories/GHSA-v5m7-53cv-f3hx', 'https://github.com/crossbeam-rs/crossbeam/pull/533', 'https://github.com/RustSec/advisory-db/pull/425', 'https://github.com/crossbeam-rs/crossbeam/issues/539'}
| null |
crates.io
|
GHSA-j52m-489x-v634
|
Double free in linea
|
An issue was discovered in the linea crate through 0.9.4 for Rust. There is double free in the Matrix::zip_elements method.
|
{'CVE-2019-16880'}
|
2021-08-19T21:23:06Z
|
2021-08-25T20:44:13Z
|
CRITICAL
| null |
{'CWE-415'}
|
{'https://github.com/strake/linea.rs/issues/2', 'https://github.com/strake/linea.rs', 'https://nvd.nist.gov/vuln/detail/CVE-2019-16880', 'https://rustsec.org/advisories/RUSTSEC-2019-0021.html'}
| null |
crates.io
|
GHSA-vjrq-cg9x-rfjp
|
Improper Input Validation in cookie
|
An issue was discovered in the cookie crate before 0.7.6 for Rust. Large integers in the Max-Age of a cookie cause a panic.
|
{'CVE-2017-18589'}
|
2021-08-19T21:25:22Z
|
2021-08-25T20:43:02Z
|
HIGH
| null |
{'CWE-20'}
|
{'https://github.com/alexcrichton/cookie-rs/pull/86', 'https://rustsec.org/advisories/RUSTSEC-2017-0005.html', 'https://nvd.nist.gov/vuln/detail/CVE-2017-18589', 'https://github.com/alexcrichton/cookie-rs'}
| null |
crates.io
|
GHSA-49fq-pw77-6qxj
|
Use after free in string-interner
|
An issue was discovered in the string-interner crate before 0.7.1 for Rust. It allows attackers to read from memory locations associated with dangling pointers, because of a cloning flaw.
|
{'CVE-2019-16882'}
|
2021-08-19T21:23:01Z
|
2021-08-25T20:44:15Z
|
HIGH
| null |
{'CWE-416'}
|
{'https://github.com/Robbepop/string-interner/issues/9', 'https://github.com/Robbepop/string-interner', 'https://nvd.nist.gov/vuln/detail/CVE-2019-16882', 'https://rustsec.org/advisories/RUSTSEC-2019-0023.html'}
| null |
crates.io
|
RUSTSEC-2022-0005
|
crate has been renamed to `ftdi-embedded-hal`
|
This crate has been renamed from `ftd2xx-embedded-hal` to `ftdi-embedded-hal`.
The new repository location is:
<https://github.com/ftdi-rs/ftdi-embedded-hal>
| null |
2022-01-22T18:27:42Z
|
2022-01-22T12:00:00Z
| null | null | null |
{'https://github.com/newAM/ftd2xx-embedded-hal/pull/40', 'https://crates.io/crates/ftd2xx-embedded-hal', 'https://rustsec.org/advisories/RUSTSEC-2022-0005.html'}
| null |
crates.io
|
RUSTSEC-2021-0050
|
swap_index can write out of bounds and return uninitialized memory
|
`swap_index` takes an iterator and swaps the items with their corresponding
indexes. It reserves capacity and sets the length of the vector based on the
`.len()` method of the iterator.
If the `len()` returned by the iterator is larger than the actual number of
elements yielded, then `swap_index` creates a vector containing uninitialized
members. If the `len()` returned by the iterator is smaller than the actual
number of members yielded, then `swap_index` can write out of bounds past
its allocated vector.
As noted by the Rust documentation, [`len()`](https://doc.rust-lang.org/std/iter/trait.ExactSizeIterator.html#method.len)
and `size_hint()` are primarily meant for optimization and incorrect values
from their implementations should not lead to memory safety violations.
# Patch
A new version crate was pushed that marks this function as unsafe.
reorder = "1.1.0"
Previous versions have also been yanked from crates.io.
|
{'CVE-2021-29941', 'CVE-2021-29942'}
|
2021-10-19T22:14:35Z
|
2021-02-24T12:00:00Z
| null | null | null |
{'https://crates.io/crates/reorder', 'https://github.com/tiby312/reorder/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2021-0050.html'}
| null |
crates.io
|
RUSTSEC-2020-0109
|
stderr is unmaintained; use eprintln instead
|
The `stderr` crate is no longer maintained by its current owner.
The author recommends using the `eprintln` macro from the standard library as a
replacement.
| null |
2021-01-20T19:29:04Z
|
2020-12-22T12:00:00Z
| null | null | null |
{'https://crates.io/crates/stderr', 'https://rustsec.org/advisories/RUSTSEC-2020-0109.html', 'https://github.com/biluohc/stderr/issues/5'}
| null |
crates.io
|
GHSA-3933-wvjf-pcvc
|
Out of bounds access in lucet-runtime-internals
|
An issue was discovered in the lucet-runtime-internals crate before 0.5.1 for Rust. It mishandles sigstack allocation. Guest programs may be able to obtain sensitive information, or guest programs can experience memory corruption.
|
{'CVE-2020-35859'}
|
2021-08-19T21:19:58Z
|
2021-08-25T20:46:16Z
|
CRITICAL
| null |
{'CWE-125', 'CWE-787'}
|
{'https://github.com/bytecodealliance/lucet/pull/401', 'https://github.com/fastly/lucet', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35859', 'https://rustsec.org/advisories/RUSTSEC-2020-0004.html'}
| null |
crates.io
|
GHSA-mmc9-pwm7-qj5w
|
Unaligned memory access in rand_core
|
### Impact
Affected versions of this crate violated alignment when casting byte slices to integer slices, resulting in undefined behavior. `rand_core::BlockRng::next_u64` and `rand_core::BlockRng::fill_bytes` are affected.
### Patches
The flaw was corrected by Ralf Jung and Diggory Hardy for `rand_core >= 0.4.2`.
### Workarounds
None.
### References
See [Rand's changelog](https://github.com/rust-random/rand/blob/master/rand_core/CHANGELOG.md#050---2019-06-06).
### For more information
If you have any questions or comments about this advisory, [open an issue in the Rand repository](https://github.com/rust-random/rand/issues/new/choose).
|
{'CVE-2020-25576'}
|
2021-08-18T20:45:24Z
|
2021-08-25T20:56:50Z
|
CRITICAL
| null |
{'CWE-704'}
|
{'https://github.com/rust-random/rand/security/advisories/GHSA-mmc9-pwm7-qj5w', 'https://github.com/rust-random/rand/blob/master/rand_core/CHANGELOG.md#050---2019-06-06', 'https://github.com/rust-random/rand', 'https://rustsec.org/advisories/RUSTSEC-2019-0035.html'}
| null |
crates.io
|
GHSA-7j36-gc4r-9x3r
|
Out of bounds access in compact_arena
|
An issue was discovered in the compact_arena crate before 0.4.0 for Rust. Generativity is mishandled, leading to an out-of-bounds write or read.
|
{'CVE-2019-16139'}
|
2021-08-19T21:22:37Z
|
2021-08-25T20:44:48Z
|
CRITICAL
| null |
{'CWE-125', 'CWE-787'}
|
{'https://github.com/llogiq/compact_arena', 'https://rustsec.org/advisories/RUSTSEC-2019-0015.html', 'https://nvd.nist.gov/vuln/detail/CVE-2019-16139', 'https://github.com/llogiq/compact_arena/issues/22'}
| null |
crates.io
|
GHSA-686h-j8r8-wmfm
|
Data races in rcu_cell
|
Affected versions of this crate unconditionally implement Send/Sync for `RcuCell<T>`.
This allows users to send `T: !Send` to other threads (while `T` enclosed within `RcuCell<T>`), and allows users to concurrently access `T: !Sync` by using the APIs of `RcuCell<T>` that provide access to `&T`.
This can result in memory corruption caused by data races.
|
{'CVE-2020-36451'}
|
2021-08-24T17:53:47Z
|
2021-08-25T20:57:14Z
|
HIGH
| null |
{'CWE-77', 'CWE-362'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0131.html', 'https://github.com/Xudong-Huang/rcu_cell', 'https://github.com/Xudong-Huang/rcu_cell/pull/4', 'https://github.com/Xudong-Huang/rcu_cell/issues/3', 'https://github.com/Xudong-Huang/rcu_cell/pull/4/commits/1faf18eee11f14969b77ae0f76dcd9ebd437d0c2', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36451'}
| null |
crates.io
|
RUSTSEC-2021-0007
|
`Frame::copy_from_raw_parts` can lead to segfault without `unsafe`
|
`fn Frame::copy_from_raw_parts()` is a safe API that can take a
raw pointer and dereference it. It is possible to read arbitrary memory address
with an arbitrarily fed pointer. This allows the safe API to access & read
arbitrary address in memory. Feeding an invalid memory address pointer to
the API may also cause the program to segfault.
The flaw was corrected in https://github.com/rust-av/rust-av/pull/137,
by removing the API `fn Frame::copy_from_raw_parts()`.
|
{'CVE-2021-25904'}
|
2021-10-19T22:14:35Z
|
2021-01-07T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0007.html', 'https://github.com/rust-av/rust-av/issues/136', 'https://crates.io/crates/av-data'}
| null |
crates.io
|
RUSTSEC-2020-0037
|
Misbehaving `HandleLike` implementation can lead to memory safety violation
|
Unsafe code in `ObjectPool` has time-of-check to time-of-use (TOCTOU) bug that
can eventually lead to a memory safety violation. `ObjectPool` and `HandlePool`
implicitly assumes that `HandleLike` trait methods are pure, i.e., they always
return the same value. However, this assumption is unsound since `HandleLike`
is a safe, public trait that allows a custom implementation.
|
{'CVE-2020-35889'}
|
2021-10-19T22:14:35Z
|
2020-08-31T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0037.html', 'https://crates.io/crates/crayon', 'https://github.com/shawnscode/crayon/issues/87'}
| null |
crates.io
|
GHSA-64j8-7gp2-xjx5
|
Data races in try-mutex
|
An issue was discovered in the try-mutex crate before 0.3.0 for Rust. TryMutex<T> allows cross-thread sending of a non-Send type.
|
{'CVE-2020-35924'}
|
2021-08-19T18:54:53Z
|
2021-08-25T20:50:28Z
|
MODERATE
| null |
{'CWE-787'}
|
{'https://github.com/mpdn/try-mutex', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35924', 'https://github.com/mpdn/try-mutex/issues/2', 'https://rustsec.org/advisories/RUSTSEC-2020-0087.html'}
| null |
crates.io
|
GHSA-vh4p-6j7g-f4j9
|
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 MappedRwLockReadGuard unsoundness.
|
{'CVE-2020-35911'}
|
2021-08-19T20:49:28Z
|
2021-08-25T20:49:56Z
|
MODERATE
| null |
{'CWE-362'}
|
{'https://github.com/Amanieu/parking_lot', 'https://rustsec.org/advisories/RUSTSEC-2020-0070.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35911', 'https://github.com/Amanieu/parking_lot/pull/262'}
| null |
crates.io
|
RUSTSEC-2018-0001
|
An integer underflow could lead to panic
|
A mistake in error handling in untrusted before 0.6.2 could lead to an integer
underflow and panic if a user of the crate didn't properly check for errors
returned by untrusted.
Combination of these two programming errors (one in untrusted and another by
user of this crate) could lead to a panic and maybe a denial of service of
affected software.
The error in untrusted is fixed in release 0.6.2 released 2018-06-21. It's also
advisable that users of untrusted check for their sources for cases where errors
returned by untrusted are not handled correctly.
|
{'CVE-2018-20989'}
|
2021-10-19T22:14:35Z
|
2018-06-21T12:00:00Z
| null | null | null |
{'https://crates.io/crates/untrusted', 'https://github.com/briansmith/untrusted/pull/20', 'https://rustsec.org/advisories/RUSTSEC-2018-0001.html'}
| null |
crates.io
|
RUSTSEC-2021-0093
|
Data race in crossbeam-deque
|
In the affected version of this crate, the result of the race condition is that one or more tasks in the worker queue can be popped twice instead of other tasks that are forgotten and never popped. If tasks are allocated on the heap, this can cause double free and a memory leak. If not, this still can cause a logical bug.
Crates using `Stealer::steal`, `Stealer::steal_batch`, or `Stealer::steal_batch_and_pop` are affected by this issue.
Credits to @kmaork for discovering, reporting and fixing the bug.
|
{'GHSA-pqqp-xmhj-wgcw', 'CVE-2021-32810'}
|
2021-10-19T22:14:35Z
|
2021-07-30T12:00:00Z
| null | null | null |
{'https://github.com/crossbeam-rs/crossbeam/security/advisories/GHSA-pqqp-xmhj-wgcw', 'https://rustsec.org/advisories/RUSTSEC-2021-0093.html', 'https://crates.io/crates/crossbeam-deque'}
| null |
crates.io
|
RUSTSEC-2020-0125
|
convec::ConVec<T> unconditionally implements Send/Sync
|
Affected versions of this crate unconditionally implement Send/Sync for `ConVec<T>`.
This allows users to insert `T` that is not Send or not Sync.
This allows users to create data races by using non-Send types like `Arc<Cell<_>>` or `Rc<_>` as `T` in `ConVec<T>`. It is also possible to create data races by using types like `Cell<_>` or `RefCell<_>` as `T` (types that are `Send` but not `Sync`).
Such data races can lead to memory corruption.
|
{'CVE-2020-36445'}
|
2021-10-19T22:14:35Z
|
2020-11-24T12:00:00Z
| null | null | null |
{'https://github.com/krl/convec/issues/2', 'https://crates.io/crates/convec', 'https://rustsec.org/advisories/RUSTSEC-2020-0125.html'}
| null |
crates.io
|
GHSA-fhvj-7f9p-w788
|
Buffer overflow in arr
|
An issue was discovered in the arr crate through 2020-08-25 for Rust. There is a buffer overflow in Index and IndexMut.
|
{'CVE-2020-35887'}
|
2021-08-19T20:56:25Z
|
2021-08-25T20:48:54Z
|
CRITICAL
| null |
{'CWE-120'}
|
{'https://github.com/sjep/array', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35887', 'https://github.com/sjep/array/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2020-0034.html'}
| null |
crates.io
|
RUSTSEC-2020-0060
|
futures_task::waker may cause a use-after-free if used on a type that isn't 'static
|
Affected versions of the crate did not properly implement a `'static` lifetime bound on the `waker` function.
This resulted in a use-after-free if `Waker::wake()` is called after original data had been dropped.
The flaw was corrected by adding `'static` lifetime bound to the data `waker` takes.
|
{'CVE-2020-35906'}
|
2021-10-19T22:14:35Z
|
2020-09-04T12:00:00Z
| null | null | null |
{'https://crates.io/crates/futures-task', 'https://rustsec.org/advisories/RUSTSEC-2020-0060.html', 'https://github.com/rust-lang/futures-rs/pull/2206'}
| null |
crates.io
|
GHSA-qc84-gqf4-9926
|
Improper Restriction of Operations within the Bounds of a Memory Buffer and Race Condition in crossbeam-utils
|
### Impact
The affected version of this crate incorrectly assumed that the alignment of `{i,u}64` was always the same as `Atomic{I,U}64`.
However, the alignment of `{i,u}64` on a 32-bit target can be smaller than `Atomic{I,U}64`.
This can cause the following problems:
- Unaligned memory accesses
- Data race
Crates using `fetch_*` methods with `AtomicCell<{i,u}64>` are affected by this issue.
32-bit targets without `Atomic{I,U}64` and 64-bit targets are not affected by this issue.
32-bit targets with `Atomic{I,U}64` and `{i,u}64` have the same alignment are also not affected by this issue.
The following is a complete list of the builtin targets that may be affected. (last update: nightly-2022-02-11)
- armv7-apple-ios (tier 3)
- armv7s-apple-ios (tier 3)
- i386-apple-ios (tier 3)
- i586-unknown-linux-gnu
- i586-unknown-linux-musl
- i686-apple-darwin (tier 3)
- i686-linux-android
- i686-unknown-freebsd
- i686-unknown-haiku (tier 3)
- i686-unknown-linux-gnu
- i686-unknown-linux-musl
- i686-unknown-netbsd (tier 3)
- i686-unknown-openbsd (tier 3)
- i686-wrs-vxworks (tier 3)
([script to get list](https://gist.github.com/taiki-e/3c7891e8c5f5e0cbcb44d7396aabfe10))
### Patches
This has been fixed in crossbeam-utils 0.8.7.
Affected 0.8.x releases have been yanked.
### References
https://github.com/crossbeam-rs/crossbeam/pull/781
|
{'CVE-2022-23639'}
|
2022-02-25T15:42:42Z
|
2022-02-16T22:36:21Z
|
CRITICAL
| null |
{'CWE-119', 'CWE-362'}
|
{'https://github.com/crossbeam-rs/crossbeam', 'https://github.com/crossbeam-rs/crossbeam/pull/781', 'https://github.com/crossbeam-rs/crossbeam/security/advisories/GHSA-qc84-gqf4-9926', 'https://nvd.nist.gov/vuln/detail/CVE-2022-23639', 'https://github.com/crossbeam-rs/crossbeam/releases/tag/crossbeam-utils-0.8.7'}
| null |
crates.io
|
GHSA-c5hx-w945-j4pq
|
Memory flaw in zeroize_derive
|
An issue was discovered in the zeroize_derive crate before 1.1.1 for Rust. Dropped memory is not zeroed out for an enum.
|
{'CVE-2021-45706'}
|
2022-01-07T18:29:04Z
|
2022-01-06T22:08:33Z
|
CRITICAL
| null | null |
{'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/zeroize_derive/RUSTSEC-2021-0115.md', 'https://github.com/iqlusioninc/crates/issues/876', 'https://rustsec.org/advisories/RUSTSEC-2021-0115.html', 'https://github.com/RustCrypto/utils/tree/master/zeroize/derive', 'https://nvd.nist.gov/vuln/detail/CVE-2021-45706'}
| null |
crates.io
|
GHSA-2jfv-g3fh-xq3v
|
Excessive memory usage in tokio-rustls
|
An issue was discovered in the tokio-rustls crate before 0.13.1 for Rust. Excessive memory usage may occur when data arrives quickly.
|
{'CVE-2020-35875'}
|
2021-08-19T21:19:01Z
|
2021-08-25T20:46:54Z
|
HIGH
| null |
{'CWE-400'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0019.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35875', 'https://github.com/tokio-rs/tls', 'https://github.com/tokio-rs/tls/pull/14'}
| null |
crates.io
|
GHSA-h5wh-7h2j-h999
|
Exposure of Resource to Wrong Sphere in Simple-Wayland-HotKey-Daemon
|
SWHKD 1.1.5 consumes the keyboard events of unintended users. This could potentially cause an information leak, but is usually a denial of functionality.
|
{'CVE-2022-27817'}
|
2022-04-26T13:04:22Z
|
2022-04-15T00:00:40Z
|
MODERATE
| null |
{'CWE-668'}
|
{'https://www.openwall.com/lists/oss-security/2022/04/14/1', 'https://nvd.nist.gov/vuln/detail/CVE-2022-27817', 'https://github.com/waycrate/swhkd', 'https://github.com/waycrate/swhkd/releases'}
| null |
crates.io
|
RUSTSEC-2020-0099
|
Aovec<T> lacks bound on its Send and Sync traits allowing data races
|
`aovec::Aovec<T>` is a vector type that implements `Send` and `Sync` 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-36207'}
|
2021-10-19T22:14:35Z
|
2020-12-10T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0099.html', 'https://crates.io/crates/aovec'}
| null |
crates.io
|
RUSTSEC-2020-0133
|
Queue<T> should have a Send bound on its Send/Sync traits
|
Affected versions of this crate unconditionally implements `Send`/`Sync` for `Queue<T>`.
This allows (1) creating data races to a `T: !Sync` and (2) sending `T: !Send` to other threads, resulting in memory corruption or other undefined behavior.
|
{'CVE-2020-36453'}
|
2021-10-19T22:14:35Z
|
2020-11-15T12:00:00Z
| null | null | null |
{'https://crates.io/crates/scottqueue', 'https://github.com/rossdylan/rust-scottqueue/issues/1', 'https://rustsec.org/advisories/RUSTSEC-2020-0133.html'}
| null |
crates.io
|
GHSA-v2ch-fc8f-qm33
|
Use of Uninitialized Resource in bite.
|
An issue was discovered in the bite crate through 2020-12-31 for Rust. read::BiteReadExpandedExt::read_framed_max may read from uninitialized memory locations.
|
{'CVE-2020-36511'}
|
2022-01-07T16:24:37Z
|
2022-01-06T22:16:57Z
|
HIGH
| null |
{'CWE-908'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36511', 'https://rustsec.org/advisories/RUSTSEC-2020-0153.html', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/bite/RUSTSEC-2020-0153.md', 'https://github.com/hinaria/bite'}
| null |
crates.io
|
GHSA-2xpg-3hx4-fm9r
|
Out of bounds read in xcb
|
An issue was discovered in the xcb crate through 2021-02-04 for Rust. It has a soundness violation because there is an out-of-bounds read in xcb::xproto::change_property(), as demonstrated by a format=32 T=u8 situation where out-of-bounds bytes are sent to an X server.
|
{'CVE-2021-26957'}
|
2021-08-19T17:44:08Z
|
2021-08-25T20:53:20Z
|
CRITICAL
| null |
{'CWE-125'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0019.html', 'https://github.com/RustSec/advisory-db/issues/653', 'https://github.com/rtbo/rust-xcb', 'https://nvd.nist.gov/vuln/detail/CVE-2021-26957'}
| null |
crates.io
|
RUSTSEC-2020-0076
|
crate has been renamed to `sn_routing`
|
This crate has been renamed from `routing` to `sn_routing`.
The new repository location is:
<https://github.com/maidsafe/sn_routing>
| null |
2020-12-02T17:59:27Z
|
2020-11-02T12:00:00Z
| null | null | null |
{'https://github.com/maidsafe/sn_routing/pull/2190', 'https://rustsec.org/advisories/RUSTSEC-2020-0076.html', 'https://crates.io/crates/routing'}
| null |
crates.io
|
RUSTSEC-2017-0005
|
Large cookie Max-Age values can cause a denial of service
|
Affected versions of this crate use the `time` crate and the method
`Duration::seconds` to parse the `Max-Age` duration cookie setting. This method
will panic if the value is greater than 2^64/1000 and less than or equal to
2^64, which can result in denial of service for a client or server.
This flaw was corrected by explicitly checking for the `Max-Age` being in this
integer range and clamping the value to the maximum duration value.
|
{'CVE-2017-18589'}
|
2021-10-19T22:14:35Z
|
2017-05-06T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2017-0005.html', 'https://crates.io/crates/cookie', 'https://github.com/alexcrichton/cookie-rs/pull/86'}
| null |
crates.io
|
RUSTSEC-2020-0021
|
rio allows a use-after-free buffer access when a future is leaked
|
When a `rio::Completion` is leaked, its drop code will not run. The drop code
is responsible for waiting until the kernel completes the I/O operation into, or
out of, the buffer borrowed by `rio::Completion`. Leaking the struct will allow
one to access and/or drop the buffer, which can lead to a use-after-free,
data races or leaking secrets.
Upstream is not interested in fixing the issue.
|
{'CVE-2020-35876'}
|
2021-10-19T22:14:35Z
|
2020-05-11T12:00:00Z
| null | null | null |
{'https://crates.io/crates/rio', 'https://github.com/spacejam/rio/issues/11', 'https://rustsec.org/advisories/RUSTSEC-2020-0021.html'}
| null |
crates.io
|
RUSTSEC-2018-0017
|
`tempdir` crate has been deprecated; use `tempfile` instead
|
The [`tempdir`](https://crates.io/crates/tempdir) crate has been deprecated
and the functionality is merged into [`tempfile`](https://crates.io/crates/tempfile).
| null |
2020-10-02T01:29:11Z
|
2018-02-13T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2018-0017.html', 'https://github.com/rust-lang-deprecated/tempdir/pull/46', 'https://crates.io/crates/tempdir'}
| null |
crates.io
|
RUSTSEC-2021-0085
|
'Read' on uninitialized memory may cause UB
|
Affected versions of this crate passes an uninitialized buffer to a user-provided `Read` implementation. The crate currently contains 4 occurrences of such cases.
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:23:35Z
|
2021-01-03T12:00:00Z
| null | null | null |
{'https://github.com/binast/binjs-ref/issues/460', 'https://crates.io/crates/binjs_io', 'https://rustsec.org/advisories/RUSTSEC-2021-0085.html'}
| null |
crates.io
|
GHSA-p4jg-pccf-h82c
|
Insecure Temporary File in SWHKD
|
SWHKD is a display protocol-independent hotkey daemon made in Rust. In SWHKD versions 1.1.5 and prior, SWHKD uses the /tmp/swhkd.pid pathname. As /tmp is accessible to all users, there can be an information leak or denial of service. No known workarounds exist. A patch is available on the `1.1.0` branch of the repository.
|
{'CVE-2022-27815'}
|
2022-04-06T23:57:05Z
|
2022-03-31T00:00:24Z
|
CRITICAL
| null |
{'CWE-377'}
|
{'http://www.openwall.com/lists/oss-security/2022/04/14/1', 'https://nvd.nist.gov/vuln/detail/CVE-2022-27815', 'https://github.com/waycrate/swhkd', 'https://github.com/waycrate/swhkd/commit/e661a4940df78fbb7b52c622ac4ae6a3a7f7d8aa', 'https://github.com/waycrate/swhkd/releases'}
| null |
crates.io
|
GHSA-g4xg-fxmg-vcg5
|
OS command injection in ripgrep
|
ripgrep before 13 on Windows allows attackers to trigger execution of arbitrary programs from the current working directory via the -z/--search-zip or --pre flag.
|
{'CVE-2021-3013'}
|
2021-09-07T21:16:08Z
|
2021-08-05T19:31:55Z
|
CRITICAL
| null |
{'CWE-78'}
|
{'https://rustsec.org/advisories/RUSTSEC-2021-0071.html', 'https://github.com/BurntSushi/ripgrep/blob/master/CHANGELOG.md#1300-2021-06-12', 'https://github.com/BurntSushi/ripgrep/blob/master/CHANGELOG.md', 'https://nvd.nist.gov/vuln/detail/CVE-2021-3013', 'https://github.com/BurntSushi/ripgrep', 'https://github.com/BurntSushi/ripgrep/blob/e48a17e1891e1ea9dd06ba0e48d5fb140ca7c0c4/CHANGELOG.md'}
| null |
crates.io
|
GHSA-96w3-p368-4h8c
|
Use after free in internment
|
An issue was discovered in the internment crate through 2020-05-28 for Rust. ArcIntern::drop has a race condition and resultant use-after-free.
|
{'CVE-2020-35874'}
|
2021-08-19T21:19:06Z
|
2021-08-25T20:46:51Z
|
HIGH
| null |
{'CWE-362'}
|
{'https://github.com/droundy/internment/issues/11', 'https://rustsec.org/advisories/RUSTSEC-2020-0017.html', 'https://github.com/droundy/internment', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35874'}
| null |
crates.io
|
RUSTSEC-2018-0016
|
quickersort is deprecated and unmaintained
|
The author of the `quickersort` crate has deprecated it and does not recommend using it anymore.
Everything in it has been incorporated into [std::sort_unstable] in the standard library as of Rust 1.20.
[std::sort_unstable]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.sort_unstable
| null |
2020-10-02T01:29:11Z
|
2018-06-30T12:00:00Z
| null | null | null |
{'https://crates.io/crates/quickersort', 'https://github.com/notriddle/quickersort/commit/0bc164366315801f0c6b31f4081b7df9fc894076', 'https://rustsec.org/advisories/RUSTSEC-2018-0016.html'}
| null |
crates.io
|
RUSTSEC-2021-0084
|
`Read` on uninitialized buffer can cause UB (impl of `ReadKVExt`)
|
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:20:01Z
|
2021-01-03T12:00:00Z
| null | null | null |
{'https://crates.io/crates/bronzedb-protocol', 'https://rustsec.org/advisories/RUSTSEC-2021-0084.html', 'https://github.com/Hexilee/BronzeDB/issues/1'}
| null |
crates.io
|
GHSA-36xw-hgfv-jwm7
|
Uninitialized memory drop in arr
|
An issue was discovered in the arr crate through 2020-08-25 for Rust. Uninitialized memory is dropped by Array::new_from_template.
|
{'CVE-2020-35888'}
|
2021-08-19T21:06:43Z
|
2021-08-25T20:48:36Z
|
CRITICAL
| null |
{'CWE-908'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0034.html', 'https://github.com/sjep/array', 'https://github.com/sjep/array/issues/1', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35888'}
| null |
crates.io
|
GHSA-v666-6w97-pcwm
|
Miner fails to get block template when a cell used as a cell dep has been destroyed.
|
### Impact
The RPC `get_block_template` fails when a cell has been used as a cell dep and an input in the different transactions.
Say cell C is used as a dep group in the transaction A, and is destroyed in the transaction B.
The node adds transaction A first, then B into the transaction pool. They are both valid. But when generating the block template, if the fee rate of B is higher, it comes before A, which will invalidate A. Currently the RPC `get_block_template` will fail instead of dropping A.
### Patch
First, the `get_block_template` should not fail but dropping the conflict transactions.
Then we can propose solution to this issue. Here is an example. When a transaction is added to the pool, the pool must consider it depending on all the transactions which dep cell (direct or indirect via dep group) has been destroyed in this transaction. Because future transactions using the destroyed cells as dep will be rejected, the spending transaction only need to wait for all the existing dep transactions on chain.
### Workaround
1. Submit transaction B when A is already on chain.
2. Let B depend on A explicitly, there are several solutions:
* a. Add any output cell on A as a dep cell or input in B.
* b. Merge A and B. CKB allows using the same cell as both dep and input in the same transaction.
3. Ensure the fee rate of B is less than A so A always has higher priority.
| null |
2021-08-02T21:55:20Z
|
2021-08-25T21:01:21Z
|
HIGH
| null |
{'CWE-367'}
|
{'https://github.com/nervosnetwork/ckb/security/advisories/GHSA-v666-6w97-pcwm'}
| null |
crates.io
|
RUSTSEC-2017-0004
|
Integer overflow leads to heap-based buffer overflow in encode_config_buf
|
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-10-19T22:14:35Z
|
2017-05-03T12:00:00Z
| null | null | null |
{'https://github.com/alicemaz/rust-base64/commit/24ead980daf11ba563e4fb2516187a56a71ad319', 'https://crates.io/crates/base64', 'https://rustsec.org/advisories/RUSTSEC-2017-0004.html'}
| null |
crates.io
|
RUSTSEC-2020-0020
|
`stb_truetype` crate has been deprecated; use `ttf-parser` instead
|
This crate was maintained for use in rusttype which has switched to use [ttf-parser](https://crates.io/crates/ttf-parser)
| null |
2020-10-02T01:29:11Z
|
2020-04-18T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0020.html', 'https://gitlab.redox-os.org/redox-os/stb_truetype-rs/-/commit/f1f5be4794e87bfc80a4255bc3f23ed75dd77645', 'https://crates.io/crates/stb_truetype'}
| null |
crates.io
|
GHSA-qrwc-jxf5-g8x6
|
Out of bounds read in ordnung
|
An issue was discovered in the ordnung crate through 2020-09-03 for Rust. compact::Vec violates memory safety via out-of-bounds access for large capacity.
|
{'CVE-2020-35890'}
|
2021-08-19T21:06:35Z
|
2021-08-25T20:48:40Z
|
HIGH
| null |
{'CWE-125'}
|
{'https://github.com/maciejhirsz/ordnung', 'https://github.com/maciejhirsz/ordnung/issues/8', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35890', 'https://rustsec.org/advisories/RUSTSEC-2020-0038.html'}
| null |
crates.io
|
GHSA-6q5w-m3c5-rv95
|
Data races in rusqlite
|
An issue was discovered in the rusqlite crate before 0.23.0 for Rust. Memory safety can be violated via VTab / VTabCursor.
|
{'CVE-2020-35866'}
|
2021-08-19T21:08:01Z
|
2021-08-25T20:47:59Z
|
CRITICAL
| null |
{'CWE-362'}
|
{'https://github.com/rusqlite/rusqlite/releases/tag/0.23.0', 'https://rustsec.org/advisories/RUSTSEC-2020-0014.html', 'https://github.com/rusqlite/rusqlite/commit/c9ef5bd63cad5c0c123344c072b490a1a9bcbe1f', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35866', 'https://github.com/rusqlite/rusqlite'}
| null |
crates.io
|
RUSTSEC-2020-0098
|
UsbContext trait did not require implementers to be Send and Sync.
|
Affected versions of `rusb` did not require `UsbContext` to implement `Send`
and `Sync`. However, through `Device` and `DeviceHandle` it is possible to use
`UsbContext`s across threads.
This issue allows non-thread safe `UsbContext` types to be used concurrently
leading to data races and memory corruption.
The issue was fixed by adding `Send` and `Sync` bounds to `UsbContext`.
|
{'CVE-2020-36206'}
|
2021-10-19T22:14:35Z
|
2020-12-18T12:00:00Z
| null | null | null |
{'https://github.com/a1ien/rusb/issues/44', 'https://rustsec.org/advisories/RUSTSEC-2020-0098.html', 'https://crates.io/crates/rusb'}
| null |
crates.io
|
RUSTSEC-2020-0132
|
`FixedCapacityDequeLike::clone()` can cause dropping uninitialized memory
|
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-10-19T22:14:35Z
|
2020-12-31T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0132.html', 'https://crates.io/crates/array-tools', 'https://github.com/L117/array-tools/issues/2'}
| null |
crates.io
|
RUSTSEC-2020-0077
|
memmap is unmaintained
|
The author of the `memmap` crate is unresponsive.
Maintained alternatives:
- [`mapr`](https://github.com/filecoin-project/mapr)
- [`memmap2`](https://github.com/RazrFalcon/memmap2-rs)
| null |
2020-12-02T19:15:42Z
|
2020-12-02T12:00:00Z
| null | null | null |
{'https://github.com/danburkert/memmap-rs/issues/90', 'https://rustsec.org/advisories/RUSTSEC-2020-0077.html', 'https://crates.io/crates/memmap'}
| null |
crates.io
|
GHSA-g489-xrw3-3v8w
|
Data races in aovec
|
An issue was discovered in the aovec crate through 2020-12-10 for Rust. Because Aovec<T> does not have bounds on its Send trait or Sync trait, a data race and memory corruption can occur.
|
{'CVE-2020-36207'}
|
2021-08-19T18:51:25Z
|
2021-08-25T20:50:46Z
|
HIGH
| null |
{'CWE-662', 'CWE-787'}
|
{'https://github.com/krl/aovec', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36207', 'https://rustsec.org/advisories/RUSTSEC-2020-0099.html'}
| null |
crates.io
|
GHSA-mc36-5m36-hjh5
|
Data races in slock
|
An issue was discovered in the slock crate through 2020-11-17 for Rust. Slock<T> unconditionally implements Send and Sync.
|
{'CVE-2020-36455'}
|
2021-08-18T20:21:54Z
|
2021-08-25T20:58:00Z
|
HIGH
| null |
{'CWE-77', 'CWE-362'}
|
{'https://github.com/BrokenLamp/slock-rs', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/slock/RUSTSEC-2020-0135.md', 'https://github.com/BrokenLamp/slock-rs/issues/2', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36455', 'https://rustsec.org/advisories/RUSTSEC-2020-0135.html'}
| null |
crates.io
|
RUSTSEC-2020-0124
|
ArcGuard's Send and Sync should have bounds on RC
|
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-10-19T22:14:35Z
|
2020-12-08T12:00:00Z
| null | null | null |
{'https://github.com/google/rust-async-coap/issues/33', 'https://crates.io/crates/async-coap', 'https://rustsec.org/advisories/RUSTSEC-2020-0124.html'}
| null |
crates.io
|
GHSA-3227-r97m-8j95
|
Relative Path Traversal in afire serve_static
|
### Impact
This vulnerability effects the built-in afire serve_static extension allowing paths containing `//....` to bypass the previous path sanitation and request files in higher directories that should not be accessible.
### Patches
The issue has been fixed in [afire 1.1.0](https://crates.io/crates/afire/1.1.0).
If you can, just update to the newest version of afire.
### Workarounds
If you can't update afire you can simply disallow paths containing `/..` with the following middleware.
Make sure this is the last middleware added to the server so it runs first, stopping the bad requests.
```rust
use afire::prelude::*;
struct PathTraversalFix;
impl Middleware for PathTraversalFix {
fn pre(&self, req: Request) -> MiddleRequest {
if req.path.replace("\\", "/").contains("/..") {
return MiddleRequest::Send(
Response::new()
.status(400)
.text("Paths containing `..` are not allowed"),
);
}
MiddleRequest::Continue
}
}
```
```rust
let mut server = Server::new(host, port);
PathTraversalFix.attach(&mut server);
```
### References
You can read about the new changes to afire in 1.1.0 [here](https://connorcode.com/writing/afire/update-3)
### For more information
If you have any questions or comments about this advisory you can email me or message me on discord.
[[https://connorcode.com/contact](https://connorcode.com/contact)]
| null |
2022-04-22T20:16:45Z
|
2022-04-22T20:16:45Z
|
HIGH
| null |
{'CWE-34', 'CWE-22'}
|
{'https://github.com/Basicprogrammer10/afire/releases/tag/v1.1.0', 'https://github.com/Basicprogrammer10/afire/security/advisories/GHSA-3227-r97m-8j95', 'https://github.com/Basicprogrammer10/afire/commit/da7904c04f82e1cb43cc42eaf6a1dba072b5c921', 'https://github.com/Basicprogrammer10/afire'}
| null |
crates.io
|
RUSTSEC-2020-0061
|
futures_task::noop_waker_ref can segfault due to dereferencing a NULL pointer
|
Affected versions of the crate used a `UnsafeCell` in thread-local storage to return a noop waker reference,
assuming that the reference would never be returned from another thread.
This resulted in a segmentation fault crash if `Waker::wake_by_ref()` was called on a waker returned from another thread due to
it attempting to dereference a pointer that wasn't accessible from the main thread.
Reproduction Example (from issue):
```rust
use futures_task::noop_waker_ref;
fn main() {
let waker = std::thread::spawn(|| noop_waker_ref()).join().unwrap();
waker.wake_by_ref();
}
```
The flaw was corrected by using a `OnceCell::Lazy<>` wrapper around the noop waker instead of thread-local storage.
|
{'CVE-2020-35907'}
|
2021-10-19T22:14:35Z
|
2020-05-03T12:00:00Z
| null | null | null |
{'https://github.com/rust-lang/futures-rs/issues/2091', 'https://rustsec.org/advisories/RUSTSEC-2020-0061.html', 'https://crates.io/crates/futures-task'}
| null |
crates.io
|
GHSA-69vj-xx27-g45w
|
Data race in eventio
|
An issue was discovered in Input<R> in the eventio crate before 0.5.1 for Rust. Because a non-Send type can be sent to a different thread, a data race and memory corruption can occur.
|
{'CVE-2020-36216'}
|
2021-08-19T18:47:45Z
|
2021-08-25T20:51:49Z
|
MODERATE
| null |
{'CWE-662', 'CWE-787'}
|
{'https://github.com/petabi/eventio/issues/33', 'https://nvd.nist.gov/vuln/detail/CVE-2020-36216', 'https://rustsec.org/advisories/RUSTSEC-2020-0108.html', 'https://github.com/petabi/eventio'}
| null |
crates.io
|
RUSTSEC-2021-0092
|
Deserialization functions pass uninitialized memory to user-provided Read
|
Affected versions of this crate passed an uninitialized buffer to a
user-provided `Read` instance in:
* `deserialize_binary`
* `deserialize_string`
* `deserialize_extension_others`
* `deserialize_string_primitive`
This can result in safe `Read` implementations reading from the uninitialized
buffer leading to undefined behavior.
| null |
2021-08-22T01:41:04Z
|
2021-01-26T12:00:00Z
| null | null | null |
{'https://crates.io/crates/messagepack-rs', 'https://rustsec.org/advisories/RUSTSEC-2021-0092.html', 'https://github.com/otake84/messagepack-rs/issues/2'}
| null |
crates.io
|
GHSA-v935-pqmr-g8v9
|
Unexpected panics in num-bigint
|
### Impact
Two scenarios were reported where `BigInt` and `BigUint` multiplication may unexpectedly panic.
- The internal `mac3` function did not expect the possibility of non-empty all-zero inputs, leading to an `unwrap()` panic.
- A buffer was allocated with less capacity than needed for an intermediate result, leading to an assertion panic.
Rust panics can either cause stack unwinding or program abort, depending on the application configuration. In some settings, an unexpected panic may constitute a denial-of-service vulnerability.
### Patches
Both problems were introduced in version 0.4.1, and are fixed in version 0.4.3.
### For more information
If you have any questions or comments about this advisory, please open an issue in the [num-bigint](https://github.com/rust-num/num-bigint) repo.
### Acknowledgements
Thanks to Guido Vranken and Arvid Norberg for privately reporting these issues to the author.
### References
* [GHSA-v935-pqmr-g8v9](https://github.com/rust-num/num-bigint/security/advisories/GHSA-v935-pqmr-g8v9)
* [num-bigint#228](https://github.com/rust-num/num-bigint/pull/228)
| null |
2021-11-03T15:02:32Z
|
2021-11-03T17:36:04Z
|
MODERATE
| null |
{'CWE-131', 'CWE-20'}
|
{'https://github.com/rust-num/num-bigint/pull/228', 'https://github.com/rust-num/num-bigint', 'https://github.com/rust-num/num-bigint/security/advisories/GHSA-v935-pqmr-g8v9'}
| null |
crates.io
|
RUSTSEC-2020-0036
|
failure is officially deprecated/unmaintained
|
The `failure` crate is officially end-of-life: it has been marked as deprecated
by the former maintainer, who has announced that there will be no updates or
maintenance work on it going forward.
The following are some suggested actively developed alternatives to switch to:
- [`anyhow`](https://crates.io/crates/anyhow)
- [`eyre`](https://crates.io/crates/eyre)
- [`fehler`](https://crates.io/crates/fehler)
- [`snafu`](https://crates.io/crates/snafu)
- [`thiserror`](https://crates.io/crates/thiserror)
|
{'CVE-2020-25575'}
|
2021-10-19T22:14:35Z
|
2020-05-02T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2020-0036.html', 'https://crates.io/crates/failure', 'https://github.com/rust-lang-nursery/failure/pull/347'}
| null |
crates.io
|
GHSA-x7vr-c387-8w57
|
Integer Overflow/Infinite Loop in the http crate
|
An issue was discovered in the http crate before 0.1.20 for Rust. An integer overflow in HeaderMap::reserve() could result in denial of service (e.g., an infinite loop).
|
{'CVE-2020-25574'}
|
2021-08-18T21:33:41Z
|
2021-08-25T21:01:31Z
|
HIGH
| null |
{'CWE-190', 'CWE-835'}
|
{'https://github.com/hyperium/http', 'https://nvd.nist.gov/vuln/detail/CVE-2020-25574', 'https://github.com/hyperium/http/issues/352', 'https://rustsec.org/advisories/RUSTSEC-2019-0033.html'}
| null |
crates.io
|
GHSA-hxw9-jxqw-jc8j
|
Data races in dces
|
An issue was discovered in the dces crate through 2020-12-09 for Rust. The World type is marked as Send but lacks bounds on its EntityStore and ComponentStore. This allows non-thread safe `EntityStore` and `ComponentStore`s to be sent
across threads and cause data races.
|
{'CVE-2020-36459'}
|
2021-08-24T18:21:21Z
|
2021-08-25T20:58:05Z
|
HIGH
| null |
{'CWE-77', 'CWE-362'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2020-36459', 'https://raw.githubusercontent.com/rustsec/advisory-db/main/crates/dces/RUSTSEC-2020-0139.md', 'https://rustsec.org/advisories/RUSTSEC-2020-0139.html', 'https://gitlab.redox-os.org/redox-os/dces-rust', 'https://gitlab.redox-os.org/redox-os/dces-rust/-/issues/8'}
| null |
crates.io
|
RUSTSEC-2021-0006
|
Exposes internally used raw pointer
|
Affected versions of this crate dereference a raw pointer that can be modified
without using `unsafe` code.
|
{'CVE-2021-25903'}
|
2021-10-19T22:14:35Z
|
2021-01-01T12:00:00Z
| null | null | null |
{'https://rustsec.org/advisories/RUSTSEC-2021-0006.html', 'https://crates.io/crates/cache', 'https://github.com/krl/cache/issues/2'}
| null |
crates.io
|
GHSA-9wgh-vjj7-7433
|
Mutable reference with immutable provenance in image
|
An issue was discovered in the image crate before 0.23.12 for Rust. A Mutable reference has immutable provenance. (In the case of LLVM, the IR may be always correct.)
|
{'CVE-2020-35916'}
|
2021-08-19T20:49:50Z
|
2021-08-25T20:49:54Z
|
MODERATE
| null |
{'CWE-400'}
|
{'https://rustsec.org/advisories/RUSTSEC-2020-0073.html', 'https://nvd.nist.gov/vuln/detail/CVE-2020-35916', 'https://github.com/image-rs/image', 'https://github.com/image-rs/image/issues/1357'}
| null |
crates.io
|
GHSA-w5cr-frph-hw7f
|
Use of uninitialized buffer in rkyv
|
An issue was discovered in the rkyv crate before 0.6.0 for Rust. When an archive is created via serialization, the archive content may contain uninitialized values of certain parts of a struct.
|
{'CVE-2021-31919'}
|
2021-05-25T20:52:53Z
|
2021-08-25T21:01:50Z
|
HIGH
| null |
{'CWE-908'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2021-31919', 'https://github.com/djkoloski/rkyv/commit/f141b560523a20557db6540576d153010bd18712', 'https://rustsec.org/advisories/RUSTSEC-2021-0054.html', 'https://github.com/djkoloski/rkyv/commit/9c65ae9c2c67dd949b5c3aba9b8eba6da802ab7e'}
| null |
crates.io
|
RUSTSEC-2019-0030
|
Incorrect implementation of the Streebog hash functions
|
Internal `update-sigma` function was implemented incorrectly and depending on
`debug-assertions` it could've caused an incorrect result or panic for certain
inputs.
|
{'CVE-2019-25006', 'CVE-2019-25007', 'CVE-2020-25575'}
|
2021-01-04T17:02:59Z
|
2019-10-06T12:00:00Z
| null | null | null |
{'https://crates.io/crates/streebog', 'https://github.com/RustCrypto/hashes/pull/91', 'https://rustsec.org/advisories/RUSTSEC-2019-0030.html'}
| null |
crates.io
|
GHSA-5hp8-35wj-m525
|
Uncontrolled recursion in ammonia
|
An issue was discovered in the ammonia crate before 2.1.0 for Rust. There is uncontrolled recursion during HTML DOM tree serialization.
|
{'CVE-2019-15542'}
|
2021-08-19T21:23:38Z
|
2021-08-25T20:44:03Z
|
HIGH
| null |
{'CWE-674'}
|
{'https://nvd.nist.gov/vuln/detail/CVE-2019-15542', 'https://rustsec.org/advisories/RUSTSEC-2019-0001.html', 'https://github.com/rust-ammonia/ammonia/blob/master/CHANGELOG.md#210', 'https://github.com/rust-ammonia/ammonia'}
| null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.