lib/std/hash/blake3/tests.rad 9.8 KiB raw
1
//! BLAKE3 official unkeyed vectors and streaming boundaries.
2
3
use std::bits;
4
use std::fmt;
5
use std::hash::blake3;
6
use std::mem;
7
use std::testing;
8
9
/// Compare the 32 digest bytes with a hexadecimal test vector.
10
fn expect(value: &blake3::Digest, expected: &[u8]) {
11
    let mut text: [u8; 64] = [0; 64];
12
    assert mem::eq(fmt::formatHex(&value.bytes[..], &mut text[..]), expected);
13
}
14
15
/// Check official vectors through chunk boundaries and unbalanced trees.
16
@test fn vectors() throws (testing::TestError) {
17
    let mut input: [u8; 102400] = [0; 102400];
18
    for i in 0 .. input.len {
19
        set input[i] = (i % 251) as u8;
20
    }
21
    expect(
22
        &blake3::digest(&input[.. 0]),
23
        "af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
24
    );
25
    expect(
26
        &blake3::digest(&input[.. 1]),
27
        "2d3adedff11b61f14c886e35afa036736dcd87a74d27b5c1510225d0f592e213"
28
    );
29
    expect(
30
        &blake3::digest(&input[.. 2]),
31
        "7b7015bb92cf0b318037702a6cdd81dee41224f734684c2c122cd6359cb1ee63"
32
    );
33
    expect(
34
        &blake3::digest(&input[.. 3]),
35
        "e1be4d7a8ab5560aa4199eea339849ba8e293d55ca0a81006726d184519e647f"
36
    );
37
    expect(
38
        &blake3::digest(&input[.. 4]),
39
        "f30f5ab28fe047904037f77b6da4fea1e27241c5d132638d8bedce9d40494f32"
40
    );
41
    expect(
42
        &blake3::digest(&input[.. 5]),
43
        "b40b44dfd97e7a84a996a91af8b85188c66c126940ba7aad2e7ae6b385402aa2"
44
    );
45
    expect(
46
        &blake3::digest(&input[.. 6]),
47
        "06c4e8ffb6872fad96f9aaca5eee1553eb62aed0ad7198cef42e87f6a616c844"
48
    );
49
    expect(
50
        &blake3::digest(&input[.. 7]),
51
        "3f8770f387faad08faa9d8414e9f449ac68e6ff0417f673f602a646a891419fe"
52
    );
53
    expect(
54
        &blake3::digest(&input[.. 8]),
55
        "2351207d04fc16ade43ccab08600939c7c1fa70a5c0aaca76063d04c3228eaeb"
56
    );
57
    expect(
58
        &blake3::digest(&input[.. 63]),
59
        "e9bc37a594daad83be9470df7f7b3798297c3d834ce80ba85d6e207627b7db7b"
60
    );
61
    expect(
62
        &blake3::digest(&input[.. 64]),
63
        "4eed7141ea4a5cd4b788606bd23f46e212af9cacebacdc7d1f4c6dc7f2511b98"
64
    );
65
    expect(
66
        &blake3::digest(&input[.. 65]),
67
        "de1e5fa0be70df6d2be8fffd0e99ceaa8eb6e8c93a63f2d8d1c30ecb6b263dee"
68
    );
69
    expect(
70
        &blake3::digest(&input[.. 127]),
71
        "d81293fda863f008c09e92fc382a81f5a0b4a1251cba1634016a0f86a6bd640d"
72
    );
73
    expect(
74
        &blake3::digest(&input[.. 128]),
75
        "f17e570564b26578c33bb7f44643f539624b05df1a76c81f30acd548c44b45ef"
76
    );
77
    expect(
78
        &blake3::digest(&input[.. 129]),
79
        "683aaae9f3c5ba37eaaf072aed0f9e30bac0865137bae68b1fde4ca2aebdcb12"
80
    );
81
    expect(
82
        &blake3::digest(&input[.. 1023]),
83
        "10108970eeda3eb932baac1428c7a2163b0e924c9a9e25b35bba72b28f70bd11"
84
    );
85
    expect(
86
        &blake3::digest(&input[.. 1024]),
87
        "42214739f095a406f3fc83deb889744ac00df831c10daa55189b5d121c855af7"
88
    );
89
    expect(
90
        &blake3::digest(&input[.. 1025]),
91
        "d00278ae47eb27b34faecf67b4fe263f82d5412916c1ffd97c8cb7fb814b8444"
92
    );
93
    expect(
94
        &blake3::digest(&input[.. 2048]),
95
        "e776b6028c7cd22a4d0ba182a8bf62205d2ef576467e838ed6f2529b85fba24a"
96
    );
97
    expect(
98
        &blake3::digest(&input[.. 2049]),
99
        "5f4d72f40d7a5f82b15ca2b2e44b1de3c2ef86c426c95c1af0b6879522563030"
100
    );
101
    expect(
102
        &blake3::digest(&input[.. 3072]),
103
        "b98cb0ff3623be03326b373de6b9095218513e64f1ee2edd2525c7ad1e5cffd2"
104
    );
105
    expect(
106
        &blake3::digest(&input[.. 3073]),
107
        "7124b49501012f81cc7f11ca069ec9226cecb8a2c850cfe644e327d22d3e1cd3"
108
    );
109
    expect(
110
        &blake3::digest(&input[.. 4096]),
111
        "015094013f57a5277b59d8475c0501042c0b642e531b0a1c8f58d2163229e969"
112
    );
113
    expect(
114
        &blake3::digest(&input[.. 4097]),
115
        "9b4052b38f1c5fc8b1f9ff7ac7b27cd242487b3d890d15c96a1c25b8aa0fb995"
116
    );
117
    expect(
118
        &blake3::digest(&input[.. 5120]),
119
        "9cadc15fed8b5d854562b26a9536d9707cadeda9b143978f319ab34230535833"
120
    );
121
    expect(
122
        &blake3::digest(&input[.. 5121]),
123
        "628bd2cb2004694adaab7bbd778a25df25c47b9d4155a55f8fbd79f2fe154cff"
124
    );
125
    expect(
126
        &blake3::digest(&input[.. 6144]),
127
        "3e2e5b74e048f3add6d21faab3f83aa44d3b2278afb83b80b3c35164ebeca205"
128
    );
129
    expect(
130
        &blake3::digest(&input[.. 6145]),
131
        "f1323a8631446cc50536a9f705ee5cb619424d46887f3c376c695b70e0f0507f"
132
    );
133
    expect(
134
        &blake3::digest(&input[.. 7168]),
135
        "61da957ec2499a95d6b8023e2b0e604ec7f6b50e80a9678b89d2628e99ada77a"
136
    );
137
    expect(
138
        &blake3::digest(&input[.. 7169]),
139
        "a003fc7a51754a9b3c7fae0367ab3d782dccf28855a03d435f8cfe74605e7817"
140
    );
141
    expect(
142
        &blake3::digest(&input[.. 8192]),
143
        "aae792484c8efe4f19e2ca7d371d8c467ffb10748d8a5a1ae579948f718a2a63"
144
    );
145
    expect(
146
        &blake3::digest(&input[.. 8193]),
147
        "bab6c09cb8ce8cf459261398d2e7aef35700bf488116ceb94a36d0f5f1b7bc3b"
148
    );
149
    expect(
150
        &blake3::digest(&input[.. 16384]),
151
        "f875d6646de28985646f34ee13be9a576fd515f76b5b0a26bb324735041ddde4"
152
    );
153
    expect(
154
        &blake3::digest(&input[.. 31744]),
155
        "62b6960e1a44bcc1eb1a611a8d6235b6b4b78f32e7abc4fb4c6cdcce94895c47"
156
    );
157
    expect(
158
        &blake3::digest(&input[.. 102400]),
159
        "bc3e3d41a1146b069abffad3c0d44860cf664390afce4d9661f7902e7943e085"
160
    );
161
}
162
163
/// Updates preserve partial blocks, final chunks, and subtree order.
164
@test fn streaming() throws (testing::TestError) {
165
    let mut input: [u8; 8193] = [0; 8193];
166
    for i in 0 .. input.len {
167
        set input[i] = (i % 251) as u8;
168
    }
169
    let lengths: [u32; 16] = [
170
        0, 1, 63, 64, 65, 1023, 1024, 1025, 2047, 2048, 2049, 3072, 4096, 4097, 8192, 8193
171
    ];
172
    let steps: [u32; 9] = [1, 63, 64, 65, 1023, 1024, 1025, 2048, 4096];
173
    for length in &lengths[..] {
174
        let expected = blake3::digest(&input[.. length]);
175
        for step in &steps[..] {
176
            let mut state = blake3::new();
177
            let mut offset: u32 = 0;
178
            while offset < length {
179
                let end = offset + step if offset + step < length else length;
180
                blake3::update(&mut state, &input[offset .. end]);
181
                blake3::update(&mut state, &[]);
182
                set offset = end;
183
            }
184
            let actual = blake3::finish(state);
185
            assert mem::eq(&actual.bytes[..], &expected.bytes[..]);
186
        }
187
    }
188
}
189
190
/// Input alignment preserves full blocks, partial blocks and chunk boundaries.
191
@test fn inputAlignment() throws (testing::TestError) {
192
    let mut input: [u8; 4097] = [0; 4097];
193
    let mut shifted: [u8; 4104] = [0; 4104];
194
    for i in 0 .. input.len {
195
        set input[i] = (i % 251) as u8;
196
    }
197
    for length in &[63 as u32, 64, 65, 1023, 1024, 1025, 4097] {
198
        let expected = blake3::digest(&input[.. length]);
199
        for offset in 0 .. 8 {
200
            try! mem::copy(
201
                &mut shifted[offset .. offset + length], &input[.. length]
202
            );
203
            let actual = blake3::digest(&shifted[offset .. offset + length]);
204
            assert mem::eq(&actual.bytes[..], &expected.bytes[..]);
205
        }
206
    }
207
}
208
209
/// Mix one scalar column with wrapping sums and fixed rotations.
210
fn mix(state: &mut [u32; 16], a: u32, b: u32, c: u32, d: u32, x: u32, y: u32) {
211
    set state[a] += state[b] + x;
212
    set state[d] = bits::rotateRight32(state[d] ^ state[a], 16);
213
    set state[c] += state[d];
214
    set state[b] = bits::rotateRight32(state[b] ^ state[c], 12);
215
    set state[a] += state[b] + y;
216
    set state[d] = bits::rotateRight32(state[d] ^ state[a], 8);
217
    set state[c] += state[d];
218
    set state[b] = bits::rotateRight32(state[b] ^ state[c], 7);
219
}
220
221
/// Compare single-block digests with scalar rounds and every partial length.
222
@test fn compressionBlocks() throws (testing::TestError) {
223
    let permutation: [u32; 16] = [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8];
224
    let mut seed: u32 = 0x12345678;
225
    for length in 0 .. 65 {
226
        let mut input: [u8; 64] = [0; 64];
227
        let mut words: [u32; 16] = [0; 16];
228
        for i in 0 .. length {
229
            set seed = seed * 1664525 + 1013904223;
230
            set input[i] = (seed >> 24) as u8;
231
        }
232
        for i in 0 .. 16 {
233
            set words[i] = mem::load32Le(&input[..], i * 4);
234
        }
235
        let mut state: [u32; 16] = [
236
            0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
237
            0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
238
            0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
239
            0, 0, length, 11,
240
        ];
241
        for _ in 0 .. 7 {
242
            for i in 0 .. 4 {
243
                mix(&mut state, i, i + 4, i + 8, i + 12, words[i * 2], words[i * 2 + 1]);
244
            }
245
            for i in 0 .. 4 {
246
                mix(
247
                    &mut state,
248
                    i,
249
                    (i + 1) % 4 + 4,
250
                    (i + 2) % 4 + 8,
251
                    (i + 3) % 4 + 12,
252
                    words[i * 2 + 8],
253
                    words[i * 2 + 9]
254
                );
255
            }
256
            let previous = words;
257
            for i in 0 .. 16 {
258
                set words[i] = previous[permutation[i]];
259
            }
260
        }
261
        let actual = blake3::digest(&input[.. length]);
262
        for i in 0 .. 8 {
263
            assert mem::load32Le(&actual.bytes[..], i * 4) == (state[i] ^ state[i + 8]);
264
        }
265
    }
266
}
267
268
/// A digest parses from its 64 hexadecimal digits and rejects other text.
269
@test fn parseDigest() throws (testing::TestError) {
270
    let text = "AF1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262";
271
    let parsed = try blake3::parse(text) catch {
272
        throw testing::TestError::Failed;
273
    };
274
    assert parsed == blake3::digest("");
275
    let invalid = [&text[.. 62], &text[.. 63], "", "g"];
276
    for candidate in invalid {
277
        let result = try? blake3::parse(candidate);
278
        assert result == nil;
279
    }
280
    let mut digit: [u8; 64] = [0; 64];
281
    try! mem::copy(&mut digit[..], text);
282
    set digit[63] = 'g';
283
    assert try? blake3::parse(&digit[..]) == nil;
284
}