dimpl 0.6.2

DTLS 1.2/1.3 implementation (Sans‑IO, Sync)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Seedable random number generator for deterministic testing.
//!
//! When a seed is provided via [`Config::rng_seed`], all non-cryptographic
//! randomness will be deterministic. This is useful for testing and debugging.

use rand::distr::{Distribution, StandardUniform};
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};

/// A random number generator that can be seeded for deterministic behavior.
///
/// When created with a seed, it produces deterministic random values.
/// When created without a seed, it uses the thread-local random generator.
pub struct SeededRng {
    inner: Option<StdRng>,
}

impl SeededRng {
    /// Create a new RNG with an optional seed.
    ///
    /// If `seed` is `Some`, the RNG will produce deterministic values.
    /// If `seed` is `None`, it will use the thread-local random generator.
    pub fn new(seed: Option<u64>) -> Self {
        let inner = seed.map(StdRng::seed_from_u64);
        Self { inner }
    }

    /// Generate a random value of type T.
    pub fn random<T>(&mut self) -> T
    where
        StandardUniform: Distribution<T>,
    {
        match self.inner.as_mut() {
            Some(rng) => rng.random(),
            None => rand::random(),
        }
    }
}

impl std::fmt::Debug for SeededRng {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let is_seeded = self.inner.is_some();
        f.debug_struct("SeededRng")
            .field("seeded", &is_seeded)
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn seeded_rng_is_deterministic() {
        let mut rng1 = SeededRng::new(Some(12345));
        let mut rng2 = SeededRng::new(Some(12345));

        let values1: [u8; 10] = [
            rng1.random(),
            rng1.random(),
            rng1.random(),
            rng1.random(),
            rng1.random(),
            rng1.random(),
            rng1.random(),
            rng1.random(),
            rng1.random(),
            rng1.random(),
        ];

        let values2: [u8; 10] = [
            rng2.random(),
            rng2.random(),
            rng2.random(),
            rng2.random(),
            rng2.random(),
            rng2.random(),
            rng2.random(),
            rng2.random(),
            rng2.random(),
            rng2.random(),
        ];

        assert_eq!(values1, values2, "Same seed should produce same values");
    }

    #[test]
    fn different_seeds_produce_different_values() {
        let mut rng1 = SeededRng::new(Some(12345));
        let mut rng2 = SeededRng::new(Some(54321));

        let value1: u64 = rng1.random();
        let value2: u64 = rng2.random();

        assert_ne!(
            value1, value2,
            "Different seeds should produce different values"
        );
    }
}