bumpalo

Version	Released
`3.20.3` unknown	May 22, 2026
`3.20.2` unknown	Feb 19, 2026
`3.20.1` unknown	Feb 18, 2026
`3.20.0` unknown yanked	Feb 18, 2026
`3.19.1` unknown	Dec 16, 2025
`3.19.0` unknown	Jun 24, 2025
`3.18.1` unknown	Jun 05, 2025
`3.18.0` unknown yanked	Jun 05, 2025
`3.17.0` unknown	Jan 28, 2025
`3.16.0` unknown	Apr 08, 2024
`3.15.4` unknown	Mar 07, 2024
`3.15.3` unknown	Feb 22, 2024
`3.15.2` unknown	Feb 21, 2024
`3.15.1` unknown	Feb 20, 2024
`3.15.0` unknown yanked	Feb 15, 2024
`3.14.0` unknown	Sep 14, 2023
`3.13.0` unknown	May 22, 2023
`3.12.2` unknown	May 09, 2023
`3.12.1` unknown yanked	Apr 21, 2023
`3.12.0` unknown	Jan 17, 2023
`3.11.1` unknown	Oct 18, 2022
`3.11.0` unknown 1 CVE	Aug 17, 2022
`3.10.0` unknown 1 CVE	Jun 01, 2022
`3.9.1` unknown 1 CVE	Jan 06, 2022
`3.9.0` unknown 1 CVE	Jan 06, 2022
`3.8.0` unknown 1 CVE	Oct 19, 2021
`3.7.1` unknown 1 CVE	Sep 17, 2021
`3.7.0` unknown 1 CVE	May 28, 2021
`3.6.1` unknown 1 CVE	Feb 18, 2021
`3.6.0` unknown 1 CVE	Jan 29, 2021
`3.5.0` unknown 1 CVE	Jan 23, 2021
`3.4.0` unknown 1 CVE	Jun 01, 2020
`3.3.0` unknown 1 CVE	May 13, 2020
`3.2.1` unknown 1 CVE	Mar 24, 2020
`3.2.0` unknown yanked 2 CVEs	Feb 07, 2020
`3.1.2` unknown yanked 2 CVEs	Jan 07, 2020
`3.1.1` unknown yanked 2 CVEs	Jan 03, 2020
`3.1.0` unknown yanked 2 CVEs	Dec 27, 2019
`3.0.0` unknown yanked 2 CVEs	Dec 20, 2019
`2.6.0` unknown 1 CVE	Aug 19, 2019
`2.5.0` unknown 1 CVE	Jul 01, 2019
`2.4.3` unknown 1 CVE	May 20, 2019
`2.4.2` unknown 1 CVE	May 17, 2019
`2.4.1` unknown 1 CVE	Apr 19, 2019
`2.4.0` unknown 1 CVE	Apr 19, 2019
`2.3.0` unknown 1 CVE	Mar 26, 2019
`2.2.2` unknown 1 CVE	Mar 18, 2019
`2.2.1` unknown yanked 1 CVE	Mar 18, 2019
`2.2.0` unknown yanked 1 CVE	Mar 16, 2019
`2.1.0` unknown 1 CVE	Feb 12, 2019

3.20.3 unknown

May 22, 2026

3.20.2 unknown

Feb 19, 2026

3.20.1 unknown

Feb 18, 2026

3.20.0 unknown yanked

Feb 18, 2026

3.19.1 unknown

Dec 16, 2025

3.19.0 unknown

Jun 24, 2025

3.18.1 unknown

Jun 05, 2025

3.18.0 unknown yanked

Jun 05, 2025

3.17.0 unknown

Jan 28, 2025

3.16.0 unknown

Apr 08, 2024

3.15.4 unknown

Mar 07, 2024

3.15.3 unknown

Feb 22, 2024

3.15.2 unknown

Feb 21, 2024

3.15.1 unknown

Feb 20, 2024

3.15.0 unknown yanked

Feb 15, 2024

3.14.0 unknown

Sep 14, 2023

3.13.0 unknown

May 22, 2023

3.12.2 unknown

May 09, 2023

3.12.1 unknown yanked

Apr 21, 2023

3.12.0 unknown

Jan 17, 2023

3.11.1 unknown

Oct 18, 2022

3.11.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Aug 17, 2022

3.10.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Jun 01, 2022

3.9.1 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Jan 06, 2022

3.9.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Jan 06, 2022

3.8.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Oct 19, 2021

3.7.1 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Sep 17, 2021

3.7.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

May 28, 2021

3.6.1 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Feb 18, 2021

3.6.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Jan 29, 2021

3.5.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Jan 23, 2021

3.4.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Jun 01, 2020

3.3.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

May 13, 2020

3.2.1 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 24, 2020

3.2.0 unknown yanked

2 CVEs

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

CVE-2020-35861 GHSA-vqx7-pw4r-29rr RUSTSEC-2020-0006 Aug 25, 2021

Out of bounds read in bumpalo

7.5 / 10

High

Network Low None None Unchanged High None None

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.

Fixed in


          3.2.1

References

Updated Nov 08, 2023 · Source: OSV.dev

Feb 07, 2020

3.1.2 unknown yanked

2 CVEs

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

CVE-2020-35861 GHSA-vqx7-pw4r-29rr RUSTSEC-2020-0006 Aug 25, 2021

Out of bounds read in bumpalo

7.5 / 10

High

Network Low None None Unchanged High None None

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.

Fixed in


          3.2.1

References

Updated Nov 08, 2023 · Source: OSV.dev

Jan 07, 2020

3.1.1 unknown yanked

2 CVEs

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

CVE-2020-35861 GHSA-vqx7-pw4r-29rr RUSTSEC-2020-0006 Aug 25, 2021

Out of bounds read in bumpalo

7.5 / 10

High

Network Low None None Unchanged High None None

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.

Fixed in


          3.2.1

References

Updated Nov 08, 2023 · Source: OSV.dev

Jan 03, 2020

3.1.0 unknown yanked

2 CVEs

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

CVE-2020-35861 GHSA-vqx7-pw4r-29rr RUSTSEC-2020-0006 Aug 25, 2021

Out of bounds read in bumpalo

7.5 / 10

High

Network Low None None Unchanged High None None

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.

Fixed in


          3.2.1

References

Updated Nov 08, 2023 · Source: OSV.dev

Dec 27, 2019

3.0.0 unknown yanked

2 CVEs

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

CVE-2020-35861 GHSA-vqx7-pw4r-29rr RUSTSEC-2020-0006 Aug 25, 2021

Out of bounds read in bumpalo

7.5 / 10

High

Network Low None None Unchanged High None None

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.

Fixed in


          3.2.1

References

Updated Nov 08, 2023 · Source: OSV.dev

Dec 20, 2019

2.6.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Aug 19, 2019

2.5.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Jul 01, 2019

2.4.3 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

May 20, 2019

2.4.2 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

May 17, 2019

2.4.1 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Apr 19, 2019

2.4.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Apr 19, 2019

2.3.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 26, 2019

2.2.2 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 18, 2019

2.2.1 unknown yanked

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 18, 2019

2.2.0 unknown yanked

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Mar 16, 2019

2.1.0 unknown

1 CVE

GHSA-f85w-wvc7-crwc RUSTSEC-2022-0078 Jan 20, 2023

bumpalo has use-after-free due to a lifetime error in `Vec::into_iter()`

Medium

In affected versions of this crate, the lifetime of the iterator produced by Vec::into_iter() is not constrained to the lifetime of the Bump that allocated the vector's memory. Using the iterator after the Bump is dropped causes use-after-free accesses.

The following example demonstrates memory corruption arising from a misuse of this unsoundness.

use bumpalo::{collections::Vec, Bump};

fn main() {
    let bump = Bump::new();
    let mut vec = Vec::new_in(&bump);
    vec.extend([0x01u8; 32]);
    let into_iter = vec.into_iter();
    drop(bump);

    for _ in 0..100 {
        let reuse_bump = Bump::new();
        let _reuse_alloc = reuse_bump.alloc([0x41u8; 10]);
    }

    for x in into_iter {
        print!("0x{:02x} ", x);
    }
    println!();
}

The issue was corrected in version 3.11.1 by adding a lifetime to the IntoIter type, and updating the signature of Vec::into_iter() to constrain this lifetime.

Fixed in


          3.11.1

References

Updated Sep 10, 2026 · Source: OSV.dev

Feb 12, 2019

Activity

Details