sodalite 0.4.0

Tweetnacl in pure rust with no std dependency
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#![cfg(test)]

extern crate core;
extern crate rand;
extern crate tweetnacl;

use self::rand::{Rng, RngCore};

fn prob_test<T: FnMut()>(ct: u64, mut t: T) {
    for _ in 0..ct {
        t();
    }
}

#[test]
fn hashblock() {
    let mut rng = rand::thread_rng();
    prob_test(10, || {
        // 1 KiB, arbitrary
        let len = rng.gen_range(core::usize::MIN, 1024);
        let mut back = [0u8; 1024];
        let b = &mut back[0..len];
        rng.fill_bytes(b);

        let mut hash1 = [0u8; 64];
        let v1 = super::hashblocks(&mut hash1, b);

        let mut hash2 = [0u8; 64];
        let v2 = tweetnacl::hashblocks_sha512(&mut hash2, b);

        assert_eq!(&hash1[..], &hash2[..]);
        assert_eq!(v1, v2);
    })
}

#[test]
fn mod_l() {
    let mut rng = rand::thread_rng();

    prob_test(10, || {
        let mut r = [0u8; 32];
        let mut x = [0i64; 64];

        rng.fill_bytes(&mut r[..]);
        for v in x.iter_mut() {
            *v = rng.gen::<u16>() as i64;
        }

        let mut r2 = r;
        let mut x2 = x;

        super::mod_l(&mut r, &mut x);
        tweetnacl::mod_l(&mut r2, &mut x2);

        assert_eq!(&r[..], &r2[..]);
        assert_eq!(&x[..], &x2[..])
    })
}

#[test]
fn core_salsa20() {
    let mut rng = rand::thread_rng();

    prob_test(10, || {
        let mut inx = [0u8; 16];
        rng.fill_bytes(&mut inx);

        let mut k = [0u8; 32];
        rng.fill_bytes(&mut k);

        let mut c = [0u8; 16];
        rng.fill_bytes(&mut c);

        let mut out1 = [0u8; 64];
        super::core_salsa20(&mut out1, &inx, &k, &c);
        let mut out2 = [0u8; 64];
        tweetnacl::core_salsa20(&mut out2, &inx, &k, &c);
        assert_eq!(&out1[..], &out2[..]);
    })
}

#[test]
fn core_hsalsa20() {
    let mut rng = rand::thread_rng();

    prob_test(10, || {
        let mut inx = [0u8; 16];
        rng.fill_bytes(&mut inx);

        let mut k = [0u8; 32];
        rng.fill_bytes(&mut k);

        let mut c = [0u8; 16];
        rng.fill_bytes(&mut c);

        let mut out1 = [0u8; 32];
        super::core_hsalsa20(&mut out1, &inx, &k, &c);
        let mut out2 = [0u8; 32];
        tweetnacl::core_hsalsa20(&mut out2, &inx, &k, &c);
        assert_eq!(&out1[..], &out2[..]);
    })
}

#[test]
fn stream_salsa20_xor() {
    let mut rng = rand::thread_rng();

    prob_test(10, || {
        let mut inx = [0u8; 16];
        rng.fill_bytes(&mut inx);

        let mut n = [0u8; 8];
        rng.fill_bytes(&mut n);

        let mut c = [0u8; 32];
        rng.fill_bytes(&mut c);

        // 1024 is arbitrary
        let b = rng.gen_range(0, 1024);
        let mut out1_b = [0u8; 1024];
        let mut out2_b = [0u8; 1024];

        let out1 = &mut out1_b[0..b];
        super::stream_salsa20_xor(out1, None, &n, &c);
        let out2 = &mut out2_b[0..b];
        tweetnacl::stream_salsa20_xor(out2, None, &n, &c);
        assert_eq!(&out1[..], &out2[..]);
    })
}

#[test]
fn scalarmult() {
    let mut rng = rand::thread_rng();

    prob_test(10, || {
        let mut p = [0u8; 32];
        rng.fill_bytes(&mut p);

        let mut q1 = [0u8; 32];
        super::scalarmult_base(&mut q1, &p);
        let mut q2 = [0u8; 32];
        tweetnacl::scalarmult_base(&mut q2, &p);
        assert_eq!(&q1[..], &q2[..]);
    })
}