.githooks/
compiler/
kernel/
lib/
examples/
std/
arch/
bits/
char/
collections/
fs/
hash/
blake3/
tests.rad
9.8 KiB
blake3.rad
8.5 KiB
blake3.ras
3.0 KiB
lang/
mem/
sys/
arch.rad
68 B
bits.rad
1.6 KiB
char.rad
1.5 KiB
collections.rad
39 B
fmt.rad
11.6 KiB
fs.rad
11.0 KiB
hash.rad
41 B
intrinsics.rad
467 B
io.rad
1.7 KiB
lang.rad
335 B
mem.rad
12.0 KiB
mem.ras
919 B
process.rad
6.2 KiB
std.manifest
4.9 KiB
std.rad
349 B
sys.rad
1.0 KiB
testing.rad
2.4 KiB
tests.rad
26.6 KiB
vec.rad
3.2 KiB
scripts/
seed/
sublime/
test/
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
lib/std/hash/blake3/tests.rad
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 | } |