Skip to main content

libc_rs/
rand.rs

1//! Kernel cryptographic entropy (`getrandom`) syscall wrappers.
2
3use crate::errno::{EINTR, EIO, Errno, SysResult};
4use crate::raw::{nr, syscall3};
5
6/// Do not block if the entropy pool is not yet initialized.
7pub const GRND_NONBLOCK: u32 = 0x01;
8/// Draw from the `/dev/random` pool flag.
9pub const GRND_RANDOM: u32 = 0x02;
10
11/// Fills up to `out.len()` bytes of `out` using the kernel `getrandom` syscall.
12pub fn getrandom(out: &mut [u8], flags: u32) -> SysResult<usize> {
13    if out.is_empty() {
14        return Ok(0);
15    }
16    // SAFETY: `out` is a valid mutable byte slice of length `out.len()`.
17    unsafe {
18        syscall3(
19            nr::GETRANDOM,
20            out.as_mut_ptr() as usize,
21            out.len(),
22            flags as usize,
23        )
24    }
25}
26
27/// Fills `out` completely with cryptographic random bytes, retrying on `EINTR`
28/// and handling partial fills.
29pub fn fill_random(mut out: &mut [u8]) -> SysResult<()> {
30    while !out.is_empty() {
31        match getrandom(out, 0) {
32            Ok(0) => return Err(Errno(EIO)),
33            Ok(n) if n <= out.len() => {
34                out = &mut out[n..];
35            }
36            Ok(_) => return Err(Errno(EIO)),
37            Err(e) if e.raw() == EINTR => continue,
38            Err(e) => return Err(e),
39        }
40    }
41    Ok(())
42}
43
44#[cfg(test)]
45mod tests {
46    use core::sync::atomic::{AtomicUsize, Ordering};
47
48    use super::*;
49    use crate::raw::with_mock_syscall;
50
51    #[test]
52    fn fill_random_retries_eintr_and_short_reads() {
53        static STEP: AtomicUsize = AtomicUsize::new(0);
54        STEP.store(0, Ordering::SeqCst);
55
56        let mut buf = [0u8; 8];
57        with_mock_syscall(
58            |sysno, args| {
59                assert_eq!(sysno, nr::GETRANDOM);
60                let ptr = args[0] as *mut u8;
61                let len = args[1];
62                assert_eq!(args[2], 0);
63                match STEP.fetch_add(1, Ordering::SeqCst) {
64                    0 => Err(Errno(EINTR)),
65                    1 => {
66                        assert_eq!(len, 8);
67                        // SAFETY: `ptr` points to the start of `buf` (8 bytes).
68                        unsafe {
69                            core::ptr::write_bytes(ptr, 0xAA, 3);
70                        }
71                        Ok(3)
72                    }
73                    _ => {
74                        assert_eq!(len, 5);
75                        // SAFETY: `ptr` points to `buf[3..8]` (5 bytes).
76                        unsafe {
77                            core::ptr::write_bytes(ptr, 0xBB, 5);
78                        }
79                        Ok(5)
80                    }
81                }
82            },
83            || fill_random(&mut buf).unwrap(),
84        );
85        assert_eq!(buf, [0xAA, 0xAA, 0xAA, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB]);
86    }
87}