Skip to main content

md5_many/
lib.rs

1#![no_std]
2#![deny(unsafe_op_in_unsafe_fn)]
3#![warn(missing_docs)]
4//! High-throughput MD5 with portable multi-buffer SIMD.
5//!
6//! `md5-many` keeps the standard single-stream MD5 API separate from its
7//! SIMD batch engine. A single MD5 stream has a dependency from one 64-byte
8//! block to the next, while independent messages can occupy independent SIMD
9//! lanes. On x86-64 the batch scheduler combines 8-way AVX2 or 16-way AVX-512
10//! native kernels with interleaved dual- and triple-batch kernels to expose
11//! additional instruction-level parallelism.
12//!
13//! MD5 is cryptographically broken and must not be used for signatures,
14//! password hashing, or adversarial integrity. This crate targets legacy
15//! interoperability and non-adversarial checksumming workloads.
16
17#[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")]
34/// RustCrypto block-level compatibility API.
35pub mod block_api;
36
37#[cfg(feature = "digest")]
38pub use digest::{self, Digest};
39
40#[cfg(feature = "digest")]
41digest::buffer_fixed!(
42    /// Streaming MD5 hasher compatible with RustCrypto's `digest` traits.
43    pub struct Md5(block_api::Md5Core);
44    impl: BaseFixedTraits AlgorithmName Default Clone HashMarker Reset FixedOutputReset;
45);
46
47/// A raw 128-bit MD5 digest.
48pub type Md5Digest = [u8; 16];
49
50pub use incremental::Md5State;
51
52/// Compute the MD5 digest of a single byte slice.
53///
54/// On x86-64 this uses the optimized scalar compressor and may select an
55/// XMM-width AVX-512VL single-stream backend on supported Intel CPUs.
56/// Little-endian AArch64 uses a hand-scheduled integer compressor; other
57/// targets use the portable Rust compressor. For independent-message SIMD
58/// batching, use [`Md5Many`] or [`md5_many`].
59#[must_use]
60pub fn md5(input: &[u8]) -> Md5Digest {
61    scalar::hash(input)
62}
63
64/// Runtime-dispatched batch MD5 engine.
65///
66/// Construct this once and reuse it so CPU feature detection is not repeated.
67#[derive(Clone, Copy, Debug)]
68pub struct Md5Many {
69    level: fearless_simd::Level,
70}
71
72impl Md5Many {
73    /// Detect the best SIMD level available on the current process.
74    #[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    /// Construct a batch engine from an already-detected Fearless SIMD level.
81    #[must_use]
82    pub const fn from_level(level: fearless_simd::Level) -> Self {
83        Self { level }
84    }
85
86    /// Return the native number of `u32` SIMD lanes used by this engine.
87    ///
88    /// AVX-512 is 16 lanes, AVX2 is 8 lanes, and SSE4.2/NEON/WASM use 4 lanes.
89    #[must_use]
90    pub const fn lanes(self) -> usize {
91        simd::lanes_with_level(self.level)
92    }
93
94    /// Hash many independent messages into `outputs`.
95    ///
96    /// Equal-length groups use specialized whole-stream SIMD kernels. Mixed
97    /// groups process their common full-block prefix at SIMD speed and only
98    /// diverge for the tail; skewed groups may be repartitioned to avoid
99    /// wasting lanes on already-finished messages.
100    ///
101    /// # Panics
102    ///
103    /// Panics if `outputs` is shorter than `inputs`.
104    pub fn hash_many(self, inputs: &[&[u8]], outputs: &mut [Md5Digest]) {
105        simd::hash_many_with_level(self.level, inputs, outputs);
106    }
107
108    /// Increment several independent MD5 streams in parallel.
109    ///
110    /// Each `inputs[i]` is appended to `states[i]`. Complete 64-byte blocks
111    /// are compacted into SIMD lanes even when chunk lengths differ, while
112    /// partial blocks remain buffered in the corresponding [`Md5State`].
113    ///
114    /// # Panics
115    ///
116    /// Panics if `states` and `inputs` have different lengths.
117    pub fn update_many(self, states: &mut [Md5State], inputs: &[&[u8]]) {
118        incremental::update_many_with_level(self.level, states, inputs);
119    }
120
121    /// Finalize several incremental MD5 streams in parallel.
122    ///
123    /// Finalization is non-destructive: the states are not modified and may
124    /// receive more data afterwards. Padding blocks are batched through the
125    /// multi-buffer compressor where profitable.
126    ///
127    /// # Panics
128    ///
129    /// Panics if `outputs` is shorter than `states`.
130    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/// Hash many independent messages using runtime SIMD detection.
143///
144/// For repeated calls, prefer constructing [`Md5Many`] once and reusing it.
145///
146/// # Panics
147///
148/// Panics if `outputs` is shorter than `inputs`.
149#[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            // Exercise both sides of the two-message one-block crossover.
398            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        // Covers repeated dual-batch scheduling beyond one native pair.
534        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        // Alternating short/long messages forces the no-alloc skew planner to
546        // repartition each dual candidate, then scatter digests back to the
547        // caller's original order.
548        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        // Finalization is a snapshot rather than a consuming operation.
627        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        // The first update is deliberately lockstep and leaves a partial
678        // block in every stream. The second update diverges lane-by-lane and
679        // must fall back to the general compaction scheduler without losing
680        // the buffered prefix.
681        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            // Three exactly block-aligned updates exercise the native/dual/
740            // triple stateful kernels directly. The remaining uneven chunks
741            // verify that the same states transition back through buffered
742            // incremental scheduling before interleaved finalization.
743            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}