1#![no_std]
2#![deny(unsafe_op_in_unsafe_fn)]
3#![warn(missing_docs)]
4#[cfg(feature = "std")]
18extern crate std;
19
20mod consts;
21mod incremental;
22mod scalar;
23#[cfg(all(target_arch = "aarch64", target_endian = "little"))]
24mod scalar_aarch64;
25#[cfg(target_arch = "x86_64")]
26mod scalar_x86_64;
27#[cfg(target_arch = "x86_64")]
28mod scalar_x86_64_avx512;
29#[cfg(target_arch = "x86_64")]
30mod scalar_x86_64_dual;
31mod simd;
32
33#[cfg(feature = "digest")]
34pub mod block_api;
36
37#[cfg(feature = "digest")]
38pub use digest::{self, Digest};
39
40#[cfg(feature = "digest")]
41digest::buffer_fixed!(
42 pub struct Md5(block_api::Md5Core);
44 impl: BaseFixedTraits AlgorithmName Default Clone HashMarker Reset FixedOutputReset;
45);
46
47pub type Md5Digest = [u8; 16];
49
50pub use incremental::Md5State;
51
52#[must_use]
60pub fn md5(input: &[u8]) -> Md5Digest {
61 scalar::hash(input)
62}
63
64#[derive(Clone, Copy, Debug)]
68pub struct Md5Many {
69 level: fearless_simd::Level,
70}
71
72impl Md5Many {
73 #[cfg(any(feature = "std", target_arch = "wasm32"))]
75 #[must_use]
76 pub fn new() -> Self {
77 Self::from_level(fearless_simd::Level::new())
78 }
79
80 #[must_use]
82 pub const fn from_level(level: fearless_simd::Level) -> Self {
83 Self { level }
84 }
85
86 #[must_use]
90 pub const fn lanes(self) -> usize {
91 simd::lanes_with_level(self.level)
92 }
93
94 pub fn hash_many(self, inputs: &[&[u8]], outputs: &mut [Md5Digest]) {
105 simd::hash_many_with_level(self.level, inputs, outputs);
106 }
107
108 pub fn update_many(self, states: &mut [Md5State], inputs: &[&[u8]]) {
118 incremental::update_many_with_level(self.level, states, inputs);
119 }
120
121 pub fn finalize_many(self, states: &[Md5State], outputs: &mut [Md5Digest]) {
131 incremental::finalize_many_with_level(self.level, states, outputs);
132 }
133}
134
135#[cfg(any(feature = "std", target_arch = "wasm32"))]
136impl Default for Md5Many {
137 fn default() -> Self {
138 Self::new()
139 }
140}
141
142#[cfg(any(feature = "std", target_arch = "wasm32"))]
150pub fn md5_many(inputs: &[&[u8]], outputs: &mut [Md5Digest]) {
151 Md5Many::new().hash_many(inputs, outputs);
152}
153
154#[cfg(test)]
155mod tests {
156 use super::*;
157 use md5::Md5 as ReferenceMd5;
158
159 fn reference(input: &[u8]) -> Md5Digest {
160 let out = <ReferenceMd5 as md5::Digest>::digest(input);
161 out.as_slice().try_into().expect("MD5 is 16 bytes")
162 }
163
164 #[test]
165 fn rfc_vectors() {
166 let vectors: &[(&[u8], [u8; 16])] = &[
167 (b"", hex_literal::hex!("d41d8cd98f00b204e9800998ecf8427e")),
168 (b"a", hex_literal::hex!("0cc175b9c0f1b6a831c399e269772661")),
169 (
170 b"abc",
171 hex_literal::hex!("900150983cd24fb0d6963f7d28e17f72"),
172 ),
173 (
174 b"message digest",
175 hex_literal::hex!("f96b697d7cb7938d525a2f31aaf161d0"),
176 ),
177 (
178 b"abcdefghijklmnopqrstuvwxyz",
179 hex_literal::hex!("c3fcd3d76192e4007dfb496cca67e13b"),
180 ),
181 ];
182 for (input, expected) in vectors {
183 assert_eq!(md5(input), *expected);
184 }
185 }
186
187 #[test]
188 fn boundary_lengths_match_reference() {
189 let mut data = [0u8; 257];
190 for (index, byte) in data.iter_mut().enumerate() {
191 *byte = index as u8;
192 }
193 for len in 0..=data.len() {
194 assert_eq!(md5(&data[..len]), reference(&data[..len]), "len={len}");
195 }
196 }
197
198 #[cfg(any(feature = "std", target_arch = "wasm32"))]
199 #[test]
200 fn many_equal_length_matches_reference() {
201 let messages: [[u8; 192]; 13] = core::array::from_fn(|message| {
202 core::array::from_fn(|byte| (message * 31 + byte * 17) as u8)
203 });
204 let inputs: [&[u8]; 13] = core::array::from_fn(|i| messages[i].as_slice());
205 let mut outputs = [[0u8; 16]; 13];
206
207 let engine = Md5Many::new();
208 engine.hash_many(&inputs, &mut outputs);
209 for (input, output) in inputs.iter().zip(outputs) {
210 assert_eq!(output, reference(input));
211 }
212 }
213
214 #[cfg(any(feature = "std", target_arch = "wasm32"))]
215 #[test]
216 fn many_equal_length_lane_counts_match_reference() {
217 let storage: [[u8; 193]; 16] =
218 core::array::from_fn(|lane| core::array::from_fn(|i| (lane * 37 + i * 13) as u8));
219 let engine = Md5Many::new();
220
221 for active in 2..=16 {
222 let inputs = &storage[..active];
223 let inputs: std::vec::Vec<&[u8]> = inputs.iter().map(<[u8; 193]>::as_slice).collect();
224 let mut outputs = std::vec![[0u8; 16]; active];
225 engine.hash_many(&inputs, &mut outputs);
226 for lane in 0..active {
227 assert_eq!(
228 outputs[lane],
229 reference(inputs[lane]),
230 "active={active}, lane={lane}"
231 );
232 }
233 }
234 }
235
236 #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
237 #[test]
238 fn avx512_padding_boundaries_match_reference() {
239 let engine = Md5Many::new();
240 if engine.lanes() < 16 {
241 return;
242 }
243
244 let storage: [[u8; 129]; 16] =
245 core::array::from_fn(|lane| core::array::from_fn(|i| (lane * 23 + i * 5) as u8));
246 for len in [0, 1, 55, 56, 63, 64, 65, 119, 120, 127, 128, 129] {
247 let inputs: [&[u8]; 16] = core::array::from_fn(|lane| &storage[lane][..len]);
248 let mut outputs = [[0u8; 16]; 16];
249 engine.hash_many(&inputs, &mut outputs);
250 for lane in 0..16 {
251 assert_eq!(
252 outputs[lane],
253 reference(inputs[lane]),
254 "lane={lane}, len={len}"
255 );
256 }
257 }
258 }
259
260 #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
261 #[test]
262 fn avx512_small_batch_crossover_matches_reference() {
263 let engine = Md5Many::new();
264 if engine.lanes() < 16 {
265 return;
266 }
267
268 let storage: [[u8; 1216]; 8] =
269 core::array::from_fn(|lane| core::array::from_fn(|i| (lane * 41 + i * 7) as u8));
270
271 for active in [2usize, 4, 8] {
272 for len in [512usize, 513, 1024] {
273 let inputs: std::vec::Vec<&[u8]> = storage[..active]
274 .iter()
275 .map(|input| &input[..len])
276 .collect();
277 let mut outputs = std::vec![[0u8; 16]; active];
278 engine.hash_many(&inputs, &mut outputs);
279 for lane in 0..active {
280 assert_eq!(
281 outputs[lane],
282 reference(inputs[lane]),
283 "equal active={active}, lane={lane}, len={len}"
284 );
285 }
286 }
287
288 let inputs: std::vec::Vec<&[u8]> = storage[..active]
289 .iter()
290 .enumerate()
291 .map(|(lane, input)| &input[..512 + lane * 73])
292 .collect();
293 let mut outputs = std::vec![[0u8; 16]; active];
294 engine.hash_many(&inputs, &mut outputs);
295 for lane in 0..active {
296 assert_eq!(
297 outputs[lane],
298 reference(inputs[lane]),
299 "mixed active={active}, lane={lane}"
300 );
301 }
302 }
303 }
304
305 #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
306 #[test]
307 fn x86_triple_batches_match_reference() {
308 let detected = fearless_simd::Level::new();
309
310 if let Some(avx2) = detected.as_avx2() {
311 let engine = Md5Many::from_level(fearless_simd::Level::Avx2(avx2));
312 for mixed in [false, true] {
313 let storage: std::vec::Vec<std::vec::Vec<u8>> = (0..24)
314 .map(|lane| {
315 let len = if mixed { 4096 - lane * 8 } else { 4096 };
316 (0..len).map(|i| (lane * 31 + i * 11) as u8).collect()
317 })
318 .collect();
319 let inputs: std::vec::Vec<&[u8]> =
320 storage.iter().map(std::vec::Vec::as_slice).collect();
321 let mut outputs = std::vec![[0u8; 16]; inputs.len()];
322 engine.hash_many(&inputs, &mut outputs);
323 for (lane, (input, output)) in inputs.iter().zip(&outputs).enumerate() {
324 assert_eq!(*output, reference(input), "avx2 mixed={mixed} lane={lane}");
325 }
326 }
327 }
328
329 if let Some(avx512) = detected.as_avx512() {
330 let engine = Md5Many::from_level(fearless_simd::Level::Avx512(avx512));
331 for mixed in [false, true] {
332 let storage: std::vec::Vec<std::vec::Vec<u8>> = (0..48)
333 .map(|lane| {
334 let len = if mixed { 4096 - lane * 4 } else { 4096 };
335 (0..len).map(|i| (lane * 17 + i * 13) as u8).collect()
336 })
337 .collect();
338 let inputs: std::vec::Vec<&[u8]> =
339 storage.iter().map(std::vec::Vec::as_slice).collect();
340 let mut outputs = std::vec![[0u8; 16]; inputs.len()];
341 engine.hash_many(&inputs, &mut outputs);
342 for (lane, (input, output)) in inputs.iter().zip(&outputs).enumerate() {
343 assert_eq!(
344 *output,
345 reference(input),
346 "avx512 mixed={mixed} lane={lane}"
347 );
348 }
349 }
350 }
351 }
352
353 #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
354 #[test]
355 fn x86_partial_batch_boundaries_match_reference() {
356 fn check_counts(engine: Md5Many, counts: &[usize], base_len: usize) {
357 let equal_storage: std::vec::Vec<std::vec::Vec<u8>> = (0..64)
358 .map(|lane| (0..base_len).map(|i| (lane * 41 + i * 17) as u8).collect())
359 .collect();
360 let mixed_storage: std::vec::Vec<std::vec::Vec<u8>> = (0..64)
361 .map(|lane| {
362 let len = base_len - (lane % 13) * 7;
363 (0..len).map(|i| (lane * 23 + i * 29) as u8).collect()
364 })
365 .collect();
366
367 for &count in counts {
368 for (kind, storage) in [("equal", &equal_storage), ("mixed", &mixed_storage)] {
369 let inputs: std::vec::Vec<&[u8]> = storage[..count]
370 .iter()
371 .map(std::vec::Vec::as_slice)
372 .collect();
373 let mut outputs = std::vec![[0u8; 16]; count];
374 engine.hash_many(&inputs, &mut outputs);
375 for (lane, (input, output)) in inputs.iter().zip(&outputs).enumerate() {
376 assert_eq!(
377 *output,
378 reference(input),
379 "{kind} count={count} lane={lane}"
380 );
381 }
382 }
383 }
384 }
385
386 let detected = fearless_simd::Level::new();
387 if let Some(avx2) = detected.as_avx2() {
388 let engine = Md5Many::from_level(fearless_simd::Level::Avx2(avx2));
389 check_counts(
390 engine,
391 &[
392 2, 3, 8, 9, 15, 16, 17, 23, 24, 25, 26, 31, 32, 49, 50, 55, 56, 63, 64,
393 ],
394 257,
395 );
396
397 for len in [55usize, 56] {
399 let storage = [std::vec![0x35u8; len], std::vec![0xa7u8; len]];
400 let inputs = [storage[0].as_slice(), storage[1].as_slice()];
401 let mut outputs = [[0u8; 16]; 2];
402 engine.hash_many(&inputs, &mut outputs);
403 for lane in 0..2 {
404 assert_eq!(
405 outputs[lane],
406 reference(inputs[lane]),
407 "len={len} lane={lane}"
408 );
409 }
410 }
411 }
412
413 if let Some(avx512) = detected.as_avx512() {
414 let engine = Md5Many::from_level(fearless_simd::Level::Avx512(avx512));
415 check_counts(
416 engine,
417 &[8, 9, 16, 17, 31, 32, 33, 47, 48, 49, 50, 56, 63, 64],
418 2048,
419 );
420 }
421 }
422
423 #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
424 #[test]
425 fn x86_underfilled_skew_batches_match_reference() {
426 fn check(engine: Md5Many, count: usize, short_count: usize) {
427 let storage: std::vec::Vec<std::vec::Vec<u8>> = (0..count)
428 .map(|lane| {
429 let len = if lane < short_count { 129 } else { 4097 };
430 (0..len).map(|i| (lane * 47 + i * 19) as u8).collect()
431 })
432 .collect();
433 let inputs: std::vec::Vec<&[u8]> =
434 storage.iter().map(std::vec::Vec::as_slice).collect();
435 let mut outputs = std::vec![[0u8; 16]; count];
436 engine.hash_many(&inputs, &mut outputs);
437 for (lane, (input, output)) in inputs.iter().zip(&outputs).enumerate() {
438 assert_eq!(
439 *output,
440 reference(input),
441 "count={count} short_count={short_count} lane={lane}"
442 );
443 }
444 }
445
446 let detected = fearless_simd::Level::new();
447 if let Some(avx2) = detected.as_avx2() {
448 let engine = Md5Many::from_level(fearless_simd::Level::Avx2(avx2));
449 for (count, short_count) in
450 [(3, 2), (9, 4), (15, 7), (17, 8), (23, 8), (26, 8), (31, 15)]
451 {
452 check(engine, count, short_count);
453 }
454 }
455 if let Some(avx512) = detected.as_avx512() {
456 let engine = Md5Many::from_level(fearless_simd::Level::Avx512(avx512));
457 for (count, short_count) in [
458 (3, 2),
459 (4, 2),
460 (4, 3),
461 (5, 3),
462 (6, 4),
463 (7, 5),
464 (8, 6),
465 (17, 8),
466 (31, 15),
467 (33, 16),
468 (47, 16),
469 (50, 16),
470 (57, 16),
471 (63, 31),
472 ] {
473 check(engine, count, short_count);
474 }
475 }
476 }
477
478 #[cfg(any(feature = "std", target_arch = "wasm32"))]
479 #[test]
480 fn many_padding_boundaries_match_reference() {
481 let storage: [[u8; 129]; 8] =
482 core::array::from_fn(|lane| core::array::from_fn(|i| (lane * 19 + i * 7) as u8));
483
484 for len in [0, 1, 55, 56, 63, 64, 65, 119, 120, 127, 128, 129] {
485 let inputs: [&[u8]; 8] = core::array::from_fn(|lane| &storage[lane][..len]);
486 let mut outputs = [[0u8; 16]; 8];
487 Md5Many::new().hash_many(&inputs, &mut outputs);
488 for lane in 0..8 {
489 assert_eq!(
490 outputs[lane],
491 reference(inputs[lane]),
492 "lane={lane}, len={len}"
493 );
494 }
495 }
496 }
497
498 #[cfg(any(feature = "std", target_arch = "wasm32"))]
499 #[test]
500 fn many_mixed_lengths_are_correct() {
501 let a = b"".as_slice();
502 let b = b"abc".as_slice();
503 let c = [0x5au8; 65];
504 let d = [0xa5u8; 130];
505 let inputs: [&[u8]; 4] = [a, b, &c, &d];
506 let mut outputs = [[0u8; 16]; 4];
507 Md5Many::new().hash_many(&inputs, &mut outputs);
508 for i in 0..inputs.len() {
509 assert_eq!(outputs[i], reference(inputs[i]));
510 }
511 }
512
513 #[cfg(any(feature = "std", target_arch = "wasm32"))]
514 #[test]
515 fn many_mixed_lengths_cross_multiple_block_counts() {
516 let storage: [[u8; 321]; 8] =
517 core::array::from_fn(|lane| core::array::from_fn(|i| (lane * 43 + i * 11) as u8));
518 let lengths = [0usize, 3, 55, 64, 119, 128, 193, 321];
519 let inputs: [&[u8]; 8] = core::array::from_fn(|lane| &storage[lane][..lengths[lane]]);
520 let mut outputs = [[0u8; 16]; 8];
521
522 Md5Many::new().hash_many(&inputs, &mut outputs);
523 for lane in 0..inputs.len() {
524 assert_eq!(outputs[lane], reference(inputs[lane]), "lane={lane}");
525 }
526 }
527
528 #[cfg(feature = "std")]
529 #[test]
530 fn large_dual_batches_and_skew_partition_match_reference() {
531 let engine = Md5Many::new();
532
533 let equal_storage: std::vec::Vec<std::vec::Vec<u8>> = (0..64)
535 .map(|lane| (0..1025).map(|i| (lane * 29 + i * 7) as u8).collect())
536 .collect();
537 let equal_inputs: std::vec::Vec<&[u8]> =
538 equal_storage.iter().map(std::vec::Vec::as_slice).collect();
539 let mut outputs = std::vec![[0u8; 16]; equal_inputs.len()];
540 engine.hash_many(&equal_inputs, &mut outputs);
541 for (lane, (input, output)) in equal_inputs.iter().zip(&outputs).enumerate() {
542 assert_eq!(*output, reference(input), "equal lane={lane}");
543 }
544
545 let mixed_storage: std::vec::Vec<std::vec::Vec<u8>> = (0..64)
549 .map(|lane| {
550 let len = if lane % 2 == 0 { 1024 } else { 16 * 1024 };
551 (0..len).map(|i| (lane * 17 + i * 11) as u8).collect()
552 })
553 .collect();
554 let mixed_inputs: std::vec::Vec<&[u8]> =
555 mixed_storage.iter().map(std::vec::Vec::as_slice).collect();
556 outputs.fill([0u8; 16]);
557 engine.hash_many(&mixed_inputs, &mut outputs);
558 for (lane, (input, output)) in mixed_inputs.iter().zip(&outputs).enumerate() {
559 assert_eq!(*output, reference(input), "mixed lane={lane}");
560 }
561 }
562
563 #[test]
564 fn incremental_single_state_boundaries_match_reference() {
565 let data: [u8; 321] = core::array::from_fn(|i| (i * 37 + 11) as u8);
566 for len in 0..=data.len() {
567 let mut state = Md5State::new();
568 let split1 = core::cmp::min(len, 31);
569 let split2 = core::cmp::min(len, 97);
570 state.update(&data[..split1]);
571 state.update(&data[split1..split2]);
572 state.update(&data[split2..len]);
573 assert_eq!(state.finalize(), reference(&data[..len]), "len={len}");
574 assert_eq!(state.bytes_hashed(), len as u64);
575 }
576 }
577
578 #[cfg(any(feature = "std", target_arch = "wasm32"))]
579 #[test]
580 fn incremental_many_mixed_chunks_match_reference() {
581 let engine = Md5Many::new();
582 let storage: std::vec::Vec<std::vec::Vec<u8>> = (0..37)
583 .map(|lane| {
584 let len = (lane * 431 + 57) % 5001;
585 (0..len).map(|i| (lane * 53 + i * 19) as u8).collect()
586 })
587 .collect();
588 let mut states = std::vec![Md5State::new(); storage.len()];
589 let mut offsets = std::vec![0usize; storage.len()];
590 let mut round = 0usize;
591
592 while offsets
593 .iter()
594 .zip(&storage)
595 .any(|(&offset, message)| offset < message.len())
596 {
597 let chunks: std::vec::Vec<&[u8]> = storage
598 .iter()
599 .enumerate()
600 .map(|(lane, message)| {
601 let start = offsets[lane];
602 let remaining = message.len() - start;
603 let proposed = 1 + ((round * 17 + lane * 29) % 172);
604 let take = core::cmp::min(remaining, proposed);
605 &message[start..start + take]
606 })
607 .collect();
608
609 engine.update_many(&mut states, &chunks);
610 for lane in 0..storage.len() {
611 offsets[lane] += chunks[lane].len();
612 }
613 round += 1;
614 }
615
616 let mut outputs = std::vec![[0u8; 16]; states.len()];
617 engine.finalize_many(&states, &mut outputs);
618 for lane in 0..storage.len() {
619 assert_eq!(
620 outputs[lane],
621 reference(&storage[lane]),
622 "mixed incremental lane={lane}"
623 );
624 }
625
626 let suffixes: std::vec::Vec<std::vec::Vec<u8>> = (0..states.len())
628 .map(|lane| std::vec![(lane as u8).wrapping_mul(7); lane % 91])
629 .collect();
630 let suffix_refs: std::vec::Vec<&[u8]> =
631 suffixes.iter().map(std::vec::Vec::as_slice).collect();
632 engine.update_many(&mut states, &suffix_refs);
633 engine.finalize_many(&states, &mut outputs);
634 for lane in 0..storage.len() {
635 let mut expected = storage[lane].clone();
636 expected.extend_from_slice(&suffixes[lane]);
637 assert_eq!(
638 outputs[lane],
639 reference(&expected),
640 "post-finalize incremental lane={lane}"
641 );
642 }
643 }
644
645 #[cfg(any(feature = "std", target_arch = "wasm32"))]
646 #[test]
647 fn incremental_many_partial_block_completion_matches_reference() {
648 let engine = Md5Many::new();
649 let storage: [[u8; 129]; 16] =
650 core::array::from_fn(|lane| core::array::from_fn(|i| (lane * 23 + i * 41) as u8));
651 let mut states = [Md5State::new(); 16];
652
653 let first: [&[u8]; 16] = core::array::from_fn(|lane| &storage[lane][..31]);
654 engine.update_many(&mut states, &first);
655 let second: [&[u8]; 16] = core::array::from_fn(|lane| &storage[lane][31..64]);
656 engine.update_many(&mut states, &second);
657 let third: [&[u8]; 16] = core::array::from_fn(|lane| &storage[lane][64..129]);
658 engine.update_many(&mut states, &third);
659
660 let mut outputs = [[0u8; 16]; 16];
661 engine.finalize_many(&states, &mut outputs);
662 for lane in 0..16 {
663 assert_eq!(outputs[lane], reference(&storage[lane]), "lane={lane}");
664 }
665 }
666
667 #[cfg(feature = "std")]
668 #[test]
669 fn incremental_many_lockstep_then_mixed_matches_reference() {
670 let engine = Md5Many::new();
671 let lanes = engine.lanes();
672 let storage: std::vec::Vec<std::vec::Vec<u8>> = (0..lanes)
673 .map(|lane| (0..257).map(|i| (lane * 31 + i * 43 + 7) as u8).collect())
674 .collect();
675 let mut states = std::vec![Md5State::new(); lanes];
676
677 let first: std::vec::Vec<&[u8]> = storage.iter().map(|message| &message[..47]).collect();
682 engine.update_many(&mut states, &first);
683
684 let second_lengths: std::vec::Vec<usize> =
685 (0..lanes).map(|lane| 1 + ((lane * 37) % 173)).collect();
686 let second: std::vec::Vec<&[u8]> = storage
687 .iter()
688 .zip(&second_lengths)
689 .map(|(message, &len)| &message[47..47 + len])
690 .collect();
691 engine.update_many(&mut states, &second);
692
693 let mut outputs = std::vec![[0u8; 16]; lanes];
694 engine.finalize_many(&states, &mut outputs);
695 for lane in 0..lanes {
696 let len = 47 + second_lengths[lane];
697 assert_eq!(
698 outputs[lane],
699 reference(&storage[lane][..len]),
700 "lane={lane}, len={len}"
701 );
702 }
703 }
704
705 #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
706 #[test]
707 fn incremental_avx512_stateful_kernel_matches_reference() {
708 let detected = fearless_simd::Level::new();
709 let Some(avx512) = detected.as_avx512() else {
710 return;
711 };
712
713 let engine = Md5Many::from_level(fearless_simd::Level::Avx512(avx512));
714 let storage: [[u8; 521]; 16] =
715 core::array::from_fn(|lane| core::array::from_fn(|i| (lane * 59 + i * 17) as u8));
716 let mut states = [Md5State::new(); 16];
717
718 for (start, end) in [(0, 17), (17, 64), (64, 129), (129, 257), (257, 521)] {
719 let inputs: [&[u8]; 16] = core::array::from_fn(|lane| &storage[lane][start..end]);
720 engine.update_many(&mut states, &inputs);
721 }
722
723 let mut outputs = [[0u8; 16]; 16];
724 engine.finalize_many(&states, &mut outputs);
725 for lane in 0..16 {
726 assert_eq!(outputs[lane], reference(&storage[lane]), "lane={lane}");
727 }
728 }
729
730 #[cfg(all(feature = "std", any(target_arch = "x86", target_arch = "x86_64")))]
731 #[test]
732 fn incremental_x86_interleaved_groups_match_reference() {
733 fn check(engine: Md5Many, count: usize) {
734 let storage: std::vec::Vec<std::vec::Vec<u8>> = (0..count)
735 .map(|lane| (0..521).map(|i| (lane * 71 + i * 23 + 5) as u8).collect())
736 .collect();
737 let mut states = std::vec![Md5State::new(); count];
738
739 for (start, end) in [
744 (0, 64),
745 (64, 128),
746 (128, 192),
747 (192, 239),
748 (239, 320),
749 (320, 521),
750 ] {
751 let inputs: std::vec::Vec<&[u8]> =
752 storage.iter().map(|message| &message[start..end]).collect();
753 engine.update_many(&mut states, &inputs);
754 }
755
756 let mut outputs = std::vec![[0u8; 16]; count];
757 engine.finalize_many(&states, &mut outputs);
758 for lane in 0..count {
759 assert_eq!(
760 outputs[lane],
761 reference(&storage[lane]),
762 "count={count} lane={lane}"
763 );
764 }
765 }
766
767 let detected = fearless_simd::Level::new();
768 if let Some(avx2) = detected.as_avx2() {
769 let engine = Md5Many::from_level(fearless_simd::Level::Avx2(avx2));
770 check(engine, 16);
771 check(engine, 24);
772 }
773 if let Some(avx512) = detected.as_avx512() {
774 let engine = Md5Many::from_level(fearless_simd::Level::Avx512(avx512));
775 check(engine, 32);
776 check(engine, 48);
777 }
778 }
779
780 #[cfg(any(feature = "std", target_arch = "wasm32"))]
781 proptest::proptest! {
782 #![proptest_config(proptest::test_runner::Config::with_cases(64))]
783
784 #[test]
785 fn random_batches_match_reference(
786 messages in proptest::collection::vec(
787 proptest::collection::vec(proptest::prelude::any::<u8>(), 0..513),
788 0..65,
789 )
790 ) {
791 let inputs: std::vec::Vec<&[u8]> = messages.iter().map(std::vec::Vec::as_slice).collect();
792 let mut outputs = std::vec![[0u8; 16]; inputs.len()];
793 Md5Many::new().hash_many(&inputs, &mut outputs);
794 for (input, output) in inputs.iter().zip(outputs) {
795 proptest::prop_assert_eq!(output, reference(input));
796 }
797 }
798 }
799
800 #[cfg(feature = "digest")]
801 #[test]
802 fn digest_trait_compatibility() {
803 let mut hasher = Md5::new();
804 hasher.update(b"fearless");
805 hasher.update(b" md5");
806 let got = hasher.finalize();
807 assert_eq!(got.as_slice(), reference(b"fearless md5"));
808 }
809
810 #[cfg(feature = "digest")]
811 #[test]
812 fn digest_streaming_multiblock_matches_reference() {
813 let data: [u8; 4097] = core::array::from_fn(|i| (i * 29 + 7) as u8);
814 let mut hasher = Md5::new();
815 hasher.update(&data[..13]);
816 hasher.update(&data[13..4013]);
817 hasher.update(&data[4013..]);
818 let got = hasher.finalize();
819 assert_eq!(got.as_slice(), reference(&data));
820 }
821}