dryoc/
utils.rs

1/// Increments `bytes` in constant time, representing a large little-endian
2/// integer; equivalent to `sodium_increment`.
3#[inline]
4pub fn increment_bytes(bytes: &mut [u8]) {
5    let mut carry: u16 = 1;
6    for b in bytes {
7        carry += *b as u16;
8        *b = (carry & 0xff) as u8;
9        carry >>= 8;
10    }
11}
12
13/// Convenience wrapper for [`increment_bytes`]. Functionally equivalent to
14/// `sodium_increment`.
15pub fn sodium_increment(bytes: &mut [u8]) {
16    increment_bytes(bytes)
17}
18
19#[inline]
20pub(crate) fn xor_buf(out: &mut [u8], in_: &[u8]) {
21    let len = std::cmp::min(out.len(), in_.len());
22    for i in 0..len {
23        out[i] ^= in_[i];
24    }
25}
26
27#[inline]
28pub(crate) fn load_u64_le(bytes: &[u8]) -> u64 {
29    (bytes[0] as u64)
30        | ((bytes[1] as u64) << 8)
31        | ((bytes[2] as u64) << 16)
32        | ((bytes[3] as u64) << 24)
33        | ((bytes[4] as u64) << 32)
34        | ((bytes[5] as u64) << 40)
35        | ((bytes[6] as u64) << 48)
36        | ((bytes[7] as u64) << 56)
37}
38
39#[inline]
40pub(crate) fn load_u32_le(bytes: &[u8]) -> u32 {
41    (bytes[0] as u32)
42        | ((bytes[1] as u32) << 8)
43        | ((bytes[2] as u32) << 16)
44        | ((bytes[3] as u32) << 24)
45}
46
47#[inline]
48pub(crate) fn rotr64(x: u64, b: u32) -> u64 {
49    x.rotate_right(b)
50}
51
52#[inline]
53pub(crate) fn pad16(n: usize) -> usize {
54    (0x10 - (n % 16)) & 0xf
55}
56
57#[cfg(test)]
58mod tests {
59    use rand::TryRngCore;
60
61    use super::*;
62
63    #[test]
64    fn test_increment_bytes() {
65        let mut b = [0];
66
67        increment_bytes(&mut b);
68        assert_eq!(b, [1]);
69        increment_bytes(&mut b);
70        assert_eq!(b, [2]);
71
72        let mut b = [0xff];
73
74        increment_bytes(&mut b);
75        assert_eq!(b, [0]);
76        increment_bytes(&mut b);
77        assert_eq!(b, [1]);
78
79        let mut b = [0xff, 0];
80
81        increment_bytes(&mut b);
82        assert_eq!(b, [0, 1]);
83        increment_bytes(&mut b);
84        assert_eq!(b, [1, 1]);
85        increment_bytes(&mut b);
86        assert_eq!(b, [2, 1]);
87    }
88
89    #[test]
90    fn test_xor_buf() {
91        let mut a = [0];
92        let b = [0];
93
94        xor_buf(&mut a, &b);
95        assert_eq!([0], a);
96
97        let mut a = [1];
98        let b = [0];
99
100        xor_buf(&mut a, &b);
101        assert_eq!([1], a);
102
103        let mut a = [1, 1, 1];
104        let b = [0];
105
106        xor_buf(&mut a, &b);
107        assert_eq!([1, 1, 1], a);
108
109        let mut a = [1, 1, 1];
110        let b = [0];
111
112        xor_buf(&mut a, &b);
113        assert_eq!([1, 1, 1], a);
114
115        let mut a = [1, 1, 1];
116        let b = [0, 1, 1];
117
118        xor_buf(&mut a, &b);
119        assert_eq!([1, 0, 0], a);
120    }
121
122    #[test]
123    fn test_sodium_increment() {
124        use libsodium_sys::sodium_increment as so_sodium_increment;
125        use rand_core::OsRng;
126
127        use crate::rng::copy_randombytes;
128
129        for _ in 0..20 {
130            let rand_usize = (OsRng.try_next_u32().unwrap() % 1000) as usize;
131            let mut data = vec![0u8; rand_usize];
132            copy_randombytes(&mut data);
133
134            let mut data_copy = data.clone();
135
136            sodium_increment(&mut data);
137
138            unsafe { so_sodium_increment(data_copy.as_mut_ptr(), data_copy.len()) };
139
140            assert_eq!(data, data_copy);
141        }
142    }
143
144    #[test]
145    fn test_pad16() {
146        assert_eq!(pad16(0), 0);
147        assert_eq!(pad16(1), 15);
148        assert_eq!(pad16(2), 14);
149        assert_eq!(pad16(15), 1);
150        assert_eq!(pad16(16), 0);
151        assert_eq!(pad16(17), 15);
152        assert_eq!(pad16(32), 0);
153        assert_eq!(pad16(33), 15);
154    }
155}
dryoc/utils.rs

dryoc/
utils.rs
