| 1 |
use core::mem::MaybeUninit; |
| 2 |
use getrandom::{fill, fill_uninit}; |
| 3 |
|
| 4 |
#[cfg(all(feature = "wasm_js", target_arch = "wasm32", target_os = "unknown"))] |
| 5 |
use wasm_bindgen_test::wasm_bindgen_test as test; |
| 6 |
|
| 7 |
#[test] |
| 8 |
fn test_zero() { |
| 9 |
// Test that APIs are happy with zero-length requests |
| 10 |
fill(&mut [0u8; 0]).unwrap(); |
| 11 |
let res = fill_uninit(&mut []).unwrap(); |
| 12 |
assert!(res.is_empty()); |
| 13 |
} |
| 14 |
|
| 15 |
trait DiffBits: Sized { |
| 16 |
fn diff_bits(ab: (&Self, &Self)) -> usize; |
| 17 |
} |
| 18 |
|
| 19 |
impl DiffBits for u8 { |
| 20 |
fn diff_bits((a, b): (&Self, &Self)) -> usize { |
| 21 |
(a ^ b).count_ones() as usize |
| 22 |
} |
| 23 |
} |
| 24 |
|
| 25 |
impl DiffBits for u32 { |
| 26 |
fn diff_bits((a, b): (&Self, &Self)) -> usize { |
| 27 |
(a ^ b).count_ones() as usize |
| 28 |
} |
| 29 |
} |
| 30 |
|
| 31 |
impl DiffBits for u64 { |
| 32 |
fn diff_bits((a, b): (&Self, &Self)) -> usize { |
| 33 |
(a ^ b).count_ones() as usize |
| 34 |
} |
| 35 |
} |
| 36 |
|
| 37 |
// Return the number of bits in which s1 and s2 differ |
| 38 |
fn num_diff_bits<T: DiffBits>(s1: &[T], s2: &[T]) -> usize { |
| 39 |
assert_eq!(s1.len(), s2.len()); |
| 40 |
s1.iter().zip(s2.iter()).map(T::diff_bits).sum() |
| 41 |
} |
| 42 |
|
| 43 |
// TODO: use `[const { MaybeUninit::uninit() }; N]` after MSRV is bumped to 1.79+ |
| 44 |
// or `MaybeUninit::uninit_array` |
| 45 |
fn uninit_vec(n: usize) -> Vec<MaybeUninit<u8>> { |
| 46 |
vec![MaybeUninit::uninit(); n] |
| 47 |
} |
| 48 |
|
| 49 |
// Tests the quality of calling getrandom on two large buffers |
| 50 |
#[test] |
| 51 |
fn test_diff() { |
| 52 |
const N: usize = 1000; |
| 53 |
let mut v1 = [0u8; N]; |
| 54 |
let mut v2 = [0u8; N]; |
| 55 |
fill(&mut v1).unwrap(); |
| 56 |
fill(&mut v2).unwrap(); |
| 57 |
|
| 58 |
let mut t1 = uninit_vec(N); |
| 59 |
let mut t2 = uninit_vec(N); |
| 60 |
let r1 = fill_uninit(&mut t1).unwrap(); |
| 61 |
let r2 = fill_uninit(&mut t2).unwrap(); |
| 62 |
assert_eq!(r1.len(), N); |
| 63 |
assert_eq!(r2.len(), N); |
| 64 |
|
| 65 |
// Between 3.5 and 4.5 bits per byte should differ. Probability of failure: |
| 66 |
// ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500] |
| 67 |
let d1 = num_diff_bits(&v1, &v2); |
| 68 |
assert!(d1 > 3500); |
| 69 |
assert!(d1 < 4500); |
| 70 |
let d2 = num_diff_bits(r1, r2); |
| 71 |
assert!(d2 > 3500); |
| 72 |
assert!(d2 < 4500); |
| 73 |
} |
| 74 |
|
| 75 |
#[test] |
| 76 |
fn test_diff_u32() { |
| 77 |
const N: usize = 1000 / 4; |
| 78 |
let mut v1 = [0u32; N]; |
| 79 |
let mut v2 = [0u32; N]; |
| 80 |
for v in v1.iter_mut() { |
| 81 |
*v = getrandom::u32().unwrap(); |
| 82 |
} |
| 83 |
for v in v2.iter_mut() { |
| 84 |
*v = getrandom::u32().unwrap(); |
| 85 |
} |
| 86 |
|
| 87 |
// Between 3.5 and 4.5 bits per byte should differ. Probability of failure: |
| 88 |
// ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500] |
| 89 |
let d1 = num_diff_bits(&v1, &v2); |
| 90 |
assert!(d1 > 3500); |
| 91 |
assert!(d1 < 4500); |
| 92 |
} |
| 93 |
|
| 94 |
#[test] |
| 95 |
fn test_diff_u64() { |
| 96 |
const N: usize = 1000 / 8; |
| 97 |
let mut v1 = [0u64; N]; |
| 98 |
let mut v2 = [0u64; N]; |
| 99 |
for v in v1.iter_mut() { |
| 100 |
*v = getrandom::u64().unwrap(); |
| 101 |
} |
| 102 |
for v in v2.iter_mut() { |
| 103 |
*v = getrandom::u64().unwrap(); |
| 104 |
} |
| 105 |
|
| 106 |
// Between 3.5 and 4.5 bits per byte should differ. Probability of failure: |
| 107 |
// ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500] |
| 108 |
let d1 = num_diff_bits(&v1, &v2); |
| 109 |
assert!(d1 > 3500); |
| 110 |
assert!(d1 < 4500); |
| 111 |
} |
| 112 |
|
| 113 |
#[test] |
| 114 |
fn test_small() { |
| 115 |
const N: usize = 64; |
| 116 |
// For each buffer size, get at least 256 bytes and check that between |
| 117 |
// 3 and 5 bits per byte differ. Probability of failure: |
| 118 |
// ~ 2^(-91) = 64 * 2 * CDF[BinomialDistribution[8*256, 0.5], 3*256] |
| 119 |
for size in 1..=N { |
| 120 |
let mut num_bytes = 0; |
| 121 |
let mut diff_bits = 0; |
| 122 |
while num_bytes < 256 { |
| 123 |
let mut buf1 = [0u8; N]; |
| 124 |
let mut buf2 = [0u8; N]; |
| 125 |
|
| 126 |
let s1 = &mut buf1[..size]; |
| 127 |
let s2 = &mut buf2[..size]; |
| 128 |
|
| 129 |
fill(s1).unwrap(); |
| 130 |
fill(s2).unwrap(); |
| 131 |
|
| 132 |
num_bytes += size; |
| 133 |
diff_bits += num_diff_bits(s1, s2); |
| 134 |
} |
| 135 |
assert!(diff_bits > 3 * num_bytes); |
| 136 |
assert!(diff_bits < 5 * num_bytes); |
| 137 |
} |
| 138 |
} |
| 139 |
|
| 140 |
// Tests the quality of calling getrandom repeatedly on small buffers |
| 141 |
#[test] |
| 142 |
fn test_small_uninit() { |
| 143 |
const N: usize = 64; |
| 144 |
// For each buffer size, get at least 256 bytes and check that between |
| 145 |
// 3 and 5 bits per byte differ. Probability of failure: |
| 146 |
// ~ 2^(-91) = 64 * 2 * CDF[BinomialDistribution[8*256, 0.5], 3*256] |
| 147 |
for size in 1..=N { |
| 148 |
let mut num_bytes = 0; |
| 149 |
let mut diff_bits = 0; |
| 150 |
while num_bytes < 256 { |
| 151 |
let mut buf1 = uninit_vec(N); |
| 152 |
let mut buf2 = uninit_vec(N); |
| 153 |
|
| 154 |
let s1 = &mut buf1[..size]; |
| 155 |
let s2 = &mut buf2[..size]; |
| 156 |
|
| 157 |
let r1 = fill_uninit(s1).unwrap(); |
| 158 |
let r2 = fill_uninit(s2).unwrap(); |
| 159 |
assert_eq!(r1.len(), size); |
| 160 |
assert_eq!(r2.len(), size); |
| 161 |
|
| 162 |
num_bytes += size; |
| 163 |
diff_bits += num_diff_bits(r1, r2); |
| 164 |
} |
| 165 |
assert!(diff_bits > 3 * num_bytes); |
| 166 |
assert!(diff_bits < 5 * num_bytes); |
| 167 |
} |
| 168 |
} |
| 169 |
|
| 170 |
#[test] |
| 171 |
fn test_huge() { |
| 172 |
let mut huge = [0u8; 100_000]; |
| 173 |
fill(&mut huge).unwrap(); |
| 174 |
} |
| 175 |
|
| 176 |
#[test] |
| 177 |
fn test_huge_uninit() { |
| 178 |
const N: usize = 100_000; |
| 179 |
let mut huge = uninit_vec(N); |
| 180 |
let res = fill_uninit(&mut huge).unwrap(); |
| 181 |
assert_eq!(res.len(), N); |
| 182 |
} |
| 183 |
|
| 184 |
#[test] |
| 185 |
#[cfg_attr( |
| 186 |
target_arch = "wasm32", |
| 187 |
ignore = "The thread API always fails/panics on WASM" |
| 188 |
)] |
| 189 |
fn test_multithreading() { |
| 190 |
extern crate std; |
| 191 |
use std::{sync::mpsc::channel, thread, vec}; |
| 192 |
|
| 193 |
let mut txs = vec![]; |
| 194 |
for _ in 0..20 { |
| 195 |
let (tx, rx) = channel(); |
| 196 |
txs.push(tx); |
| 197 |
|
| 198 |
thread::spawn(move || { |
| 199 |
// wait until all the tasks are ready to go. |
| 200 |
rx.recv().unwrap(); |
| 201 |
let mut v = [0u8; 1000]; |
| 202 |
|
| 203 |
for _ in 0..100 { |
| 204 |
fill(&mut v).unwrap(); |
| 205 |
thread::yield_now(); |
| 206 |
} |
| 207 |
}); |
| 208 |
} |
| 209 |
|
| 210 |
// start all the tasks |
| 211 |
for tx in txs.iter() { |
| 212 |
tx.send(()).unwrap(); |
| 213 |
} |
| 214 |
} |
| 215 |
|
| 216 |
#[cfg(getrandom_backend = "custom")] |
| 217 |
mod custom { |
| 218 |
use getrandom::Error; |
| 219 |
|
| 220 |
struct Xoshiro128PlusPlus { |
| 221 |
s: [u32; 4], |
| 222 |
} |
| 223 |
|
| 224 |
impl Xoshiro128PlusPlus { |
| 225 |
fn new(mut seed: u64) -> Self { |
| 226 |
const PHI: u64 = 0x9e3779b97f4a7c15; |
| 227 |
let mut s = [0u32; 4]; |
| 228 |
for val in s.iter_mut() { |
| 229 |
seed = seed.wrapping_add(PHI); |
| 230 |
let mut z = seed; |
| 231 |
z = (z ^ (z >> 30)).wrapping_mul(0xbf58476d1ce4e5b9); |
| 232 |
z = (z ^ (z >> 27)).wrapping_mul(0x94d049bb133111eb); |
| 233 |
z = z ^ (z >> 31); |
| 234 |
*val = z as u32; |
| 235 |
} |
| 236 |
Self { s } |
| 237 |
} |
| 238 |
|
| 239 |
fn next_u32(&mut self) -> u32 { |
| 240 |
let res = self.s[0] |
| 241 |
.wrapping_add(self.s[3]) |
| 242 |
.rotate_left(7) |
| 243 |
.wrapping_add(self.s[0]); |
| 244 |
|
| 245 |
let t = self.s[1] << 9; |
| 246 |
|
| 247 |
self.s[2] ^= self.s[0]; |
| 248 |
self.s[3] ^= self.s[1]; |
| 249 |
self.s[1] ^= self.s[2]; |
| 250 |
self.s[0] ^= self.s[3]; |
| 251 |
|
| 252 |
self.s[2] ^= t; |
| 253 |
|
| 254 |
self.s[3] = self.s[3].rotate_left(11); |
| 255 |
|
| 256 |
res |
| 257 |
} |
| 258 |
} |
| 259 |
|
| 260 |
// This implementation uses current timestamp as a PRNG seed. |
| 261 |
// |
| 262 |
// WARNING: this custom implementation is for testing purposes ONLY! |
| 263 |
#[no_mangle] |
| 264 |
unsafe extern "Rust" fn __getrandom_v03_custom(dest: *mut u8, len: usize) -> Result<(), Error> { |
| 265 |
use std::time::{SystemTime, UNIX_EPOCH}; |
| 266 |
|
| 267 |
assert_ne!(len, 0); |
| 268 |
|
| 269 |
if len == 142 { |
| 270 |
return Err(Error::new_custom(142)); |
| 271 |
} |
| 272 |
|
| 273 |
let dest_u32 = dest.cast::<u32>(); |
| 274 |
let ts = SystemTime::now().duration_since(UNIX_EPOCH).unwrap(); |
| 275 |
let mut rng = Xoshiro128PlusPlus::new(ts.as_nanos() as u64); |
| 276 |
for i in 0..len / 4 { |
| 277 |
let val = rng.next_u32(); |
| 278 |
core::ptr::write_unaligned(dest_u32.add(i), val); |
| 279 |
} |
| 280 |
if len % 4 != 0 { |
| 281 |
let start = 4 * (len / 4); |
| 282 |
for i in start..len { |
| 283 |
let val = rng.next_u32(); |
| 284 |
core::ptr::write_unaligned(dest.add(i), val as u8); |
| 285 |
} |
| 286 |
} |
| 287 |
Ok(()) |
| 288 |
} |
| 289 |
|
| 290 |
// Test that enabling the custom feature indeed uses the custom implementation |
| 291 |
#[test] |
| 292 |
fn test_custom() { |
| 293 |
let mut buf = [0u8; 142]; |
| 294 |
let res = getrandom::fill(&mut buf); |
| 295 |
assert!(res.is_err()); |
| 296 |
} |
| 297 |
} |