Skip to main content

md5_simd/
lib.rs

1#![doc = include_str!("../README.md")]
2#![cfg_attr(not(feature = "std"), no_std)]
3#![deny(unsafe_op_in_unsafe_fn)]
4#![deny(missing_docs)]
5
6extern crate alloc;
7
8#[cfg(feature = "std")]
9extern crate std;
10
11mod backend;
12mod compress;
13mod consts;
14mod core;
15mod engine;
16mod frame;
17mod md5;
18mod multibuf;
19mod simd;
20mod state;
21
22#[cfg(feature = "digest")]
23mod digest_compat;
24
25pub use backend::{available_backends, backend_name, is_portable_only};
26pub use engine::{Md5Engine, md5_many};
27pub use md5::{Md5, digest, digest_hex, etag_hex, hex_encode, hex_encode_digest, hex_encode_into};
28pub use simd::{runtime_lanes, simd_active, simd_lanes, simd_name};
29pub use state::Md5State;
30
31#[cfg(feature = "std")]
32pub use md5::{digest_reader, etag_hex_streaming};
33
34pub use consts::{K, S, STATE_INIT};
35
36#[cfg(feature = "digest")]
37pub use digest::{self, Digest};
38#[cfg(feature = "digest")]
39pub use digest_compat::{Md5 as DigestMd5, Md5Core};
40
41/// Hazmat: raw compress entry points (custom framing).
42pub use backend::hazmat;
43
44/// Software multi-buffer: pair-interleaved hashing for independent messages.
45pub use multibuf::{hash_pair, pair_path_active};
46
47/// MD5 compresses 64-byte blocks.
48pub const BLOCK_SIZE: usize = 64;
49
50/// MD5 produces a 16-byte digest.
51pub const DIGEST_LEN: usize = 16;
52
53/// Textbook-oracle one-shot (CI / differential). Ignores accelerated backends.
54#[inline]
55pub fn digest_portable(data: &[u8]) -> [u8; 16] {
56    backend::hash_textbook(data)
57}
58
59/// In-tree production-kernel one-shot (ignores `opt` / `force-portable`).
60#[inline]
61pub fn digest_opt_scalar(data: &[u8]) -> [u8; 16] {
62    backend::hash_in_tree(data)
63}
64
65#[cfg(test)]
66mod tests {
67    use super::*;
68    use alloc::vec::Vec;
69
70    #[test]
71    fn rfc_empty_and_abc() {
72        assert_eq!(hex_encode(&digest(b"")), "d41d8cd98f00b204e9800998ecf8427e");
73        assert_eq!(
74            hex_encode(&digest(b"abc")),
75            "900150983cd24fb0d6963f7d28e17f72"
76        );
77    }
78
79    #[test]
80    fn clone_finalize_pattern() {
81        let mut h = Md5::new();
82        h.update(b"message ");
83        let mid = h.clone().finalize();
84        h.update(b"digest");
85        assert_eq!(
86            hex_encode(&h.finalize()),
87            "f96b697d7cb7938d525a2f31aaf161d0"
88        );
89        assert_eq!(hex_encode(&mid), hex_encode(&digest(b"message ")));
90        assert_ne!(mid, digest(b"message digest"));
91    }
92
93    #[test]
94    fn all_kernels_agree() {
95        for len in [0usize, 1, 55, 56, 64, 100, 1024] {
96            let data: Vec<u8> = (0..len).map(|i| (i as u8).wrapping_mul(13)).collect();
97            let active = digest(&data);
98            let book = digest_portable(&data);
99            let tree = digest_opt_scalar(&data);
100            assert_eq!(active, book, "active==textbook len={len}");
101            assert_eq!(tree, book, "in-tree==textbook len={len}");
102        }
103    }
104
105    #[test]
106    fn finalize_reset_no_clone_semantics() {
107        let mut h = Md5::new();
108        h.update(b"abc");
109        let d1 = h.finalize_reset();
110        assert_eq!(hex_encode(&d1), "900150983cd24fb0d6963f7d28e17f72");
111        h.update(b"");
112        let d2 = h.finalize_reset();
113        assert_eq!(hex_encode(&d2), "d41d8cd98f00b204e9800998ecf8427e");
114    }
115
116    #[test]
117    fn hazmat_matches_update() {
118        let data: Vec<u8> = (0..256).map(|i| i as u8).collect();
119        let mut state = STATE_INIT;
120        hazmat::compress_blocks(&mut state, &data);
121        let mut h = Md5::new();
122        h.update(&data);
123        let via_md5 = h.finalize();
124        // Manual padding for 256-byte message: one 0x80 block with length.
125        let mut st = state;
126        let mut block = [0u8; 64];
127        block[0] = 0x80;
128        block[56..64].copy_from_slice(&(256u64 * 8).to_le_bytes());
129        hazmat::compress_block(&mut st, &block);
130        let mut out = [0u8; 16];
131        for (i, w) in st.iter().enumerate() {
132            out[i * 4..i * 4 + 4].copy_from_slice(&w.to_le_bytes());
133        }
134        assert_eq!(out, via_md5);
135    }
136
137    #[cfg(feature = "zeroize")]
138    #[test]
139    fn zeroize_clears_count() {
140        let mut h = Md5::new();
141        h.update(b"x");
142        h.zeroize();
143        assert_eq!(h.bytes_hashed(), 0);
144    }
145
146    #[cfg(feature = "digest")]
147    #[test]
148    fn digest_trait_roundtrip() {
149        use digest::Digest;
150        let mut h = DigestMd5::new();
151        Digest::update(&mut h, b"abc");
152        assert_eq!(
153            hex_encode(h.finalize().as_slice()),
154            "900150983cd24fb0d6963f7d28e17f72"
155        );
156    }
157}