bc_rand/
secure_random.rs

1use std::sync::Once;
2use rand::{rngs::StdRng, CryptoRng, RngCore, SeedableRng};
3use getrandom::getrandom;
4
5use crate::RandomNumberGenerator;
6
7// A wrapper for lazy RNG initialization and thread safety
8struct LazyStdRng {
9    rng: std::sync::Mutex<Option<StdRng>>,
10    init: Once,
11}
12
13impl LazyStdRng {
14    fn new() -> Self {
15        Self {
16            rng: std::sync::Mutex::new(None),
17            init: Once::new(),
18        }
19    }
20
21    fn get_rng(&self) -> std::sync::MutexGuard<'_, Option<StdRng>> {
22        self.init.call_once(|| {
23            let mut seed = [0u8; 32];
24            getrandom(&mut seed).expect("Failed to seed RNG");
25            let rng = StdRng::from_seed(seed);
26
27            let mut guard = self.rng.lock().expect("Mutex was poisoned");
28            *guard = Some(rng);
29        });
30
31        self.rng.lock().expect("Mutex was poisoned")
32    }
33}
34
35lazy_static::lazy_static! {
36    static ref LAZY_RNG: LazyStdRng = LazyStdRng::new();
37}
38
39/// Generate a vector of cryptographically strong random bytes of the given size.
40pub fn random_data(size: usize) -> Vec<u8> {
41    let mut rng_guard = LAZY_RNG.get_rng();
42    let rng = rng_guard.as_mut().expect("RNG was not initialized");
43    let mut data = vec![0u8; size];
44    rng.fill_bytes(&mut data);
45    data
46}
47
48/// Fill the given slice with cryptographically strong random bytes.
49pub fn fill_random_data(data: &mut [u8]) {
50    let mut rng_guard = LAZY_RNG.get_rng();
51    let rng = rng_guard.as_mut().expect("RNG was not initialized");
52    rng.fill_bytes(data);
53}
54
55pub fn next_u64() -> u64 {
56    let mut rng_guard = LAZY_RNG.get_rng();
57    let rng = rng_guard.as_mut().expect("RNG was not initialized");
58    rng.next_u64()
59}
60
61/// A random number generator that can be used as a source of cryptographically-strong
62/// randomness.
63#[derive(Debug, Clone)]
64pub struct SecureRandomNumberGenerator;
65
66impl RngCore for SecureRandomNumberGenerator {
67    fn next_u32(&mut self) -> u32 {
68        next_u64() as u32
69    }
70
71    fn next_u64(&mut self) -> u64 {
72        next_u64()
73    }
74
75    fn fill_bytes(&mut self, dest: &mut [u8]) {
76        fill_random_data(dest);
77    }
78
79    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
80        self.fill_bytes(dest);
81        Ok(())
82    }
83}
84
85impl CryptoRng for SecureRandomNumberGenerator {}
86
87impl RandomNumberGenerator for SecureRandomNumberGenerator {
88    fn random_data(&mut self, size: usize) -> Vec<u8> {
89        random_data(size)
90    }
91
92    fn fill_random_data(&mut self, data: &mut [u8]) {
93        fill_random_data(data);
94    }
95}
96
97#[cfg(test)]
98mod tests {
99    use super::*;
100
101    #[test]
102    fn test_random_data() {
103        let data1 = random_data(32);
104        let data2 = random_data(32);
105        let data3 = random_data(32);
106        assert_eq!(data1.len(), 32);
107        assert_ne!(data1, data2);
108        assert_ne!(data1, data3);
109    }
110}
bc_rand/secure_random.rs

bc_rand/
secure_random.rs
