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
41pub use backend::hazmat;
43
44pub use multibuf::{hash_pair, pair_path_active};
46
47pub const BLOCK_SIZE: usize = 64;
49
50pub const DIGEST_LEN: usize = 16;
52
53#[inline]
55pub fn digest_portable(data: &[u8]) -> [u8; 16] {
56 backend::hash_textbook(data)
57}
58
59#[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 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}