Use Edition 2024, MSRV 1.85

.github/workflows/tests.yml

@@ -23,7 +23,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-24.04, windows-2022]
-        toolchain: [nightly, beta, stable, "1.63"]
+        toolchain: [nightly, beta, stable, "1.85"]
         # Only Test macOS on stable to reduce macOS CI jobs
         include:
           # aarch64-apple-darwin.
@@ -340,7 +340,7 @@ jobs:
       - uses: actions/checkout@v5
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.82
+          toolchain: 1.85
           targets: wasm32-wasip1,wasm32-wasip2
       - name: Install Wasmtime
         run: |

CHANGELOG.md

@@ -9,7 +9,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - `RawOsError` type alias [#739]
 
+### Changed
+- Use Edition 2024 and MSRV 1.85 [#749]
+
 [#739]: https://github.com/rust-random/getrandom/pull/739
+[#749]: https://github.com/rust-random/getrandom/pull/749
 
 ## [0.3.4] - 2025-10-14
 

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "getrandom"
 version = "0.3.4"
-edition = "2021"
-rust-version = "1.63" # Sync tests.yml and README.md.
+edition = "2024"
+rust-version = "1.85" # Sync tests.yml and README.md.
 authors = ["The Rand Project Developers"]
 license = "MIT OR Apache-2.0"
 description = "A small cross-platform library for retrieving random data from system source"

README.md

@@ -159,7 +159,7 @@ Next, you need to define an `extern` function with the following signature:
 ```rust
 use getrandom::Error;
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
@@ -189,7 +189,7 @@ fn my_entropy_source(buf: &mut [u8]) -> Result<(), getrandom::Error> {
     Ok(())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
@@ -302,7 +302,7 @@ RUSTFLAGS="-Zsanitizer=memory" cargo test -Zbuild-std --target=x86_64-unknown-li
 
 ## Minimum Supported Rust Version
 
-This crate requires Rust 1.63 or later.
+This crate requires Rust 1.85 or later.
 
 ## License
 

benches/buffer.rs

@@ -2,7 +2,7 @@
 extern crate test;
 
 use std::{
-    mem::{size_of, MaybeUninit},
+    mem::{MaybeUninit, size_of},
     slice,
 };
 

nopanic_check/Cargo.toml

@@ -2,7 +2,7 @@
 name = "nopanic_check"
 description = "Helper crate for checking that getrandom implementation does not contain potential panics"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 publish = false
 
 [workspace]

nopanic_check/src/lib.rs

@@ -4,27 +4,27 @@
 #[cfg(not(any(test, all(target_arch = "wasm32", target_env = "p2"))))]
 #[panic_handler]
 fn panic(_info: &core::panic::PanicInfo) -> ! {
-    extern "C" {
+    unsafe extern "C" {
         fn panic_nonexistent() -> !;
     }
     unsafe { panic_nonexistent() }
 }
 
-#[no_mangle]
-pub extern "C" fn getrandom_wrapper(buf_ptr: *mut u8, buf_len: usize) -> u32 {
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn getrandom_wrapper(buf_ptr: *mut u8, buf_len: usize) -> u32 {
     let buf = unsafe { core::slice::from_raw_parts_mut(buf_ptr.cast(), buf_len) };
     let res = getrandom::fill_uninit(buf).map(|_| ());
     unsafe { core::mem::transmute(res) }
 }
 
 #[cfg(getrandom_backend = "custom")]
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
 ) -> Result<(), getrandom::Error> {
     for i in 0..len {
-        core::ptr::write(dest.add(i), i as u8);
+        unsafe { core::ptr::write(dest.add(i), i as u8) };
     }
     Ok(())
 }

src/backends/custom.rs

@@ -6,7 +6,7 @@ pub use crate::util::{inner_u32, inner_u64};
 
 #[inline]
 pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    extern "Rust" {
+    unsafe extern "Rust" {
         fn __getrandom_v03_custom(dest: *mut u8, len: usize) -> Result<(), Error>;
     }
     unsafe { __getrandom_v03_custom(dest.as_mut_ptr().cast(), dest.len()) }

src/backends/efi_rng.rs

@@ -2,7 +2,7 @@
 use crate::Error;
 use core::{
     mem::MaybeUninit,
-    ptr::{self, null_mut, NonNull},
+    ptr::{self, NonNull, null_mut},
     sync::atomic::{AtomicPtr, Ordering::Relaxed},
 };
 use r_efi::{

src/backends/esp_idf.rs

@@ -4,7 +4,7 @@ use core::{ffi::c_void, mem::MaybeUninit};
 
 pub use crate::util::{inner_u32, inner_u64};
 
-extern "C" {
+unsafe extern "C" {
     fn esp_fill_random(buf: *mut c_void, len: usize) -> u32;
 }
 

src/backends/fuchsia.rs

@@ -5,7 +5,7 @@ use core::mem::MaybeUninit;
 pub use crate::util::{inner_u32, inner_u64};
 
 #[link(name = "zircon")]
-extern "C" {
+unsafe extern "C" {
     fn zx_cprng_draw(buffer: *mut u8, length: usize);
 }
 

src/backends/hermit.rs

@@ -2,7 +2,7 @@
 use crate::Error;
 use core::mem::MaybeUninit;
 
-extern "C" {
+unsafe extern "C" {
     fn sys_read_entropy(buffer: *mut u8, length: usize, flags: u32) -> isize;
     // Note that `sys_secure_rand32/64` are implemented using `sys_read_entropy`:
     // https://github.com/hermit-os/kernel/blob/430da84/src/syscalls/entropy.rs#L62-L104

src/backends/linux_android_with_fallback.rs

@@ -3,7 +3,7 @@ use super::{sanitizer, use_file};
 use crate::Error;
 use core::{
     ffi::c_void,
-    mem::{transmute, MaybeUninit},
+    mem::{MaybeUninit, transmute},
     ptr::NonNull,
     sync::atomic::{AtomicPtr, Ordering},
 };

src/backends/linux_raw.rs

@@ -20,95 +20,109 @@ unsafe fn getrandom_syscall(buf: *mut u8, buflen: usize, flags: u32) -> isize {
             // Theoretically, we could detect thumb mode in the build script, but several
             // register moves are cheap enough compared to the syscall cost, so we do not
             // bother with it.
-            core::arch::asm!(
-                "mov {tmp}, r7",
-                // TODO(MSRV-1.82): replace with `nr = const __NR_getrandom,`
-                "mov r7, #384",
-                "svc 0",
-                "mov r7, {tmp}",
-                tmp = out(reg) _,
-                inlateout("r0") buf => r0,
-                in("r1") buflen,
-                in("r2") flags,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "mov {tmp}, r7",
+                    // TODO(MSRV-1.82): replace with `nr = const __NR_getrandom,`
+                    "mov r7, #384",
+                    "svc 0",
+                    "mov r7, {tmp}",
+                    tmp = out(reg) _,
+                    inlateout("r0") buf => r0,
+                    in("r1") buflen,
+                    in("r2") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(target_arch = "aarch64")] {
             // TODO(MSRV-1.78): Also check `any(target_abi = "", target_abi = "ilp32")` above.
             // According to the ILP32 patch for the kernel that hasn't yet
             // been merged into the mainline, "AARCH64/ILP32 ABI uses standard
             // syscall table [...] with the exceptions listed below," where
             // getrandom is not mentioned as an exception.
             const __NR_getrandom: u32 = 278;
-            core::arch::asm!(
-                "svc 0",
-                in("x8") __NR_getrandom,
-                inlateout("x0") buf => r0,
-                in("x1") buflen,
-                in("x2") flags,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "svc 0",
+                    in("x8") __NR_getrandom,
+                    inlateout("x0") buf => r0,
+                    in("x1") buflen,
+                    in("x2") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(target_arch = "loongarch64")] {
             // TODO(MSRV-1.78): Also check `any(target_abi = "", target_abi = "ilp32")` above.
             const __NR_getrandom: u32 = 278;
-            core::arch::asm!(
-                "syscall 0",
-                in("$a7") __NR_getrandom,
-                inlateout("$a0") buf => r0,
-                in("$a1") buflen,
-                in("$a2") flags,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "syscall 0",
+                    in("$a7") __NR_getrandom,
+                    inlateout("$a0") buf => r0,
+                    in("$a1") buflen,
+                    in("$a2") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(any(target_arch = "riscv32", target_arch = "riscv64"))] {
             const __NR_getrandom: u32 = 278;
-            core::arch::asm!(
-                "ecall",
-                in("a7") __NR_getrandom,
-                inlateout("a0") buf => r0,
-                in("a1") buflen,
-                in("a2") flags,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "ecall",
+                    in("a7") __NR_getrandom,
+                    inlateout("a0") buf => r0,
+                    in("a1") buflen,
+                    in("a2") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(target_arch = "s390x")] {
             const __NR_getrandom: u32 = 349;
-            core::arch::asm!(
-                "svc 0",
-                in("r1") __NR_getrandom,
-                inlateout("r2") buf => r0,
-                in("r3") buflen,
-                in("r4") flags,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "svc 0",
+                    in("r1") __NR_getrandom,
+                    inlateout("r2") buf => r0,
+                    in("r3") buflen,
+                    in("r4") flags,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(target_arch = "x86")] {
             const __NR_getrandom: u32 = 355;
             // `int 0x80` is famously slow, but implementing vDSO is too complex
             // and `sysenter`/`syscall` have their own portability issues,
             // so we use the simple "legacy" way of doing syscalls.
-            core::arch::asm!(
-                "int $$0x80",
-                in("eax") __NR_getrandom,
-                in("ebx") buf,
-                in("ecx") buflen,
-                in("edx") flags,
-                lateout("eax") r0,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "int $$0x80",
+                    in("eax") __NR_getrandom,
+                    in("ebx") buf,
+                    in("ecx") buflen,
+                    in("edx") flags,
+                    lateout("eax") r0,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else if #[cfg(target_arch = "x86_64")] {
             // TODO(MSRV-1.78): Add `any(target_abi = "", target_abi = "x32")` above.
             const __X32_SYSCALL_BIT: u32 = 0x40000000;
             const OFFSET: u32 = if cfg!(target_pointer_width = "32") { __X32_SYSCALL_BIT } else { 0 };
             const __NR_getrandom: u32 = OFFSET + 318;
 
-            core::arch::asm!(
-                "syscall",
-                in("rax") __NR_getrandom,
-                in("rdi") buf,
-                in("rsi") buflen,
-                in("rdx") flags,
-                lateout("rax") r0,
-                lateout("rcx") _,
-                lateout("r11") _,
-                options(nostack, preserves_flags)
-            );
+            unsafe {
+                core::arch::asm!(
+                    "syscall",
+                    in("rax") __NR_getrandom,
+                    in("rdi") buf,
+                    in("rsi") buflen,
+                    in("rdx") flags,
+                    lateout("rax") r0,
+                    lateout("rcx") _,
+                    lateout("r11") _,
+                    options(nostack, preserves_flags)
+                );
+            }
         } else {
             compile_error!("`linux_raw` backend does not support this target arch");
         }