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

use super::*;
use rand::prelude::*;

#[derive(Clone, Copy, Debug, Default)]
pub struct VeilidRng;

impl CryptoRng for VeilidRng {}

impl RngCore for VeilidRng {
    fn next_u32(&mut self) -> u32 {
        get_random_u32()
    }

    fn next_u64(&mut self) -> u64 {
        get_random_u64()
    }

    fn fill_bytes(&mut self, dest: &mut [u8]) {
        random_bytes(dest);
    }

    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> {
        random_bytes(dest);
        Ok(())
    }
}

cfg_if! {
    if #[cfg(target_arch = "wasm32")] {
        use js_sys::Math;

        pub fn random_bytes(dest: &mut [u8]) {
            let len = dest.len();
            let u32len = len / 4;
            let remlen = len % 4;

            for n in 0..u32len {
                let r = (Math::random() * (u32::max_value() as f64)) as u32;

                dest[n * 4 + 0] = (r & 0xFF) as u8;
                dest[n * 4 + 1] = ((r >> 8) & 0xFF) as u8;
                dest[n * 4 + 2] = ((r >> 16) & 0xFF) as u8;
                dest[n * 4 + 3] = ((r >> 24) & 0xFF) as u8;
            }
            if remlen > 0 {
                let r = (Math::random() * (u32::max_value() as f64)) as u32;
                for n in 0..remlen {
                    dest[u32len * 4 + n] = ((r >> (n * 8)) & 0xFF) as u8;
                }
            }
        }

        pub fn get_random_u32() -> u32 {
            (Math::random() * (u32::max_value() as f64)) as u32
        }

        pub fn get_random_u64() -> u64 {
            let v1: u32 = get_random_u32();
            let v2: u32 = get_random_u32();
            ((v1 as u64) << 32) | ((v2 as u32) as u64)
        }

    } else {

        pub fn random_bytes(dest: &mut [u8]) {
            let mut rng = rand::thread_rng();
            rng.fill_bytes(dest);
        }

        pub fn get_random_u32() -> u32 {
            let mut rng = rand::thread_rng();
            rng.next_u32()
        }

        pub fn get_random_u64() -> u64 {
            let mut rng = rand::thread_rng();
            rng.next_u64()
        }
    }
}