Most recent entries from all

EUVD-2026-159975

fkie_cve-2024-43806

Rustix is a set of safe Rust bindings to POSIX-ish APIs. When using `rustix::fs::Dir` using the `linux_raw` backend, it's possible for the iterator to "get stuck" when an IO error is encountered. Combined with a memory over-allocation issue in `rustix::fs::Dir::read_more`, this can cause quick and unbounded memory explosion (gigabytes in a few seconds if used on a hot path) and eventually lead to an OOM crash of the application. The symptoms were initially discovered in https://github.com/imsnif/bandwhich/issues/284. That post has lots of details of our investigation. Full details can be read on the GHSA-c827-hfw6-qwvm repo advisory. If a program tries to access a directory with its file descriptor after the file has been unlinked (or any other action that leaves the `Dir` iterator in the stuck state), and the implementation does not break after seeing an error, it can cause a memory explosion. As an example, Linux's various virtual file systems (e.g. `/proc`, `/sys`) can contain directories that spontaneously pop in and out of existence. Attempting to iterate over them using `rustix::fs::Dir` directly or indirectly (e.g. with the `procfs` crate) can trigger this fault condition if the implementation decides to continue on errors. An attacker knowledgeable about the implementation details of a vulnerable target can therefore try to trigger this fault condition via any one or a combination of several available APIs. If successful, the application host will quickly run out of…

GHSA-c827-hfw6-qwvm — rustix's `rustix::fs::Dir` iterator with the `linux_raw` backend can cause memory explosion

Affected: crates.io: rustix

### Summary

When using `rustix::fs::Dir` using the `linux_raw` backend, it's possible for the iterator to "get stuck" when an IO error is encountered. Combined with a memory over-allocation issue in `rustix::fs::Dir::read_more`, this can cause quick and unbounded memory explosion (gigabytes in a few seconds if used on a hot path) and eventually lead to an OOM crash of the application.

### Details

#### Discovery

The symptoms were initially discovered in https://github.com/imsnif/bandwhich/issues/284. That post has lots of details of our investigation. See [this post](https://github.com/imsnif/bandwhich/issues/284#issuecomment-1754321993) and the [Discord thread](https://discord.com/channels/273534239310479360/1161137828395237556) for details.

#### Diagnosis

This issue is caused by the combination of two independent bugs:

1. Stuck iterator - The `rustix::fs::Dir` iterator can fail to halt after encountering an IO error, causing the caller to be stuck in an infinite loop. 2. Memory over-allocation - `Dir::read_more` incorrectly grows the read buffer unconditionally each time it is called, regardless of necessity.

Since `<Dir as Iterator>::next` calls `Dir::read`, which in turn calls `Dir::read_more`, this means an IO error encountered during reading a directory can lead to rapid and unbounded growth of memory use.

### PoC

```rust fn main() -> Result<(), Box<dyn std::error::Error>> { // create a directory, get a FD to it, then unlink the directory but keep the FD…

msrc_CVE-2024-43806 — `rustix::fs::Dir` iterator with the `linux_raw` backend can cause memory explosion

msrc_CVE-2024-43806

openSUSE-SU-2024:14354-1 — rage-encryption-0.10.0+0-3.1 on GA media

rage-encryption-0.10.0+0-3.1 on GA media

SUSE-SU-2024:3404-1 — Security update for rage-encryption

Security update for rage-encryption

UBUNTU-CVE-2024-43806

Affected: Ubuntu:24.04:LTS: rust-rustix, Ubuntu:25.10: rust-rustix, Ubuntu:26.04:LTS: rust-rustix