irox_tools/hash/
md5.rs

1// SPDX-License-Identifier: MIT
2// Copyright 2025 IROX Contributors
3//
4
5//!
6//! Bog standard implementation of MD5 / RFC1321.
7//!
8//! *THIS SHOULD NOT BE USED FOR ANYTHING SECURITY RELATED*
9
10use crate::buf::U32ArrayBuf;
11use crate::hash::{HashAlgorithm, HashDigest};
12use crate::u32::ToU32Array;
13use core::ops::{BitAnd, BitOr, BitXor, Not};
14use irox_bits::{Error, MutBits, WriteToLEBits};
15
16pub const BLOCK_SIZE: usize = 64;
17pub const OUTPUT_SIZE: usize = 16;
18
19static SHIFT_AMOUNTS: [u32; 64] = [
20    7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9,
21    14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15,
22    21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
23];
24
25static KONSTANTS: [u32; 64] = [
26    0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
27    0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
28    0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
29    0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
30    0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
31    0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
32    0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
33    0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
34];
35
36///
37/// Implementation of [RFC 1321](https://datatracker.ietf.org/doc/html/rfc1321) based on the [Wikipedia](https://en.wikipedia.org/wiki/MD5#Algorithm) algorithm
38///
39///
40/// **THIS SHOULD NOT BE USED FOR ANYTHING SECURITY RELATED**
41#[derive(Clone)]
42pub struct MD5 {
43    written_length: u64,
44    a0: u32,
45    b0: u32,
46    c0: u32,
47    d0: u32,
48    buf: U32ArrayBuf<16>,
49}
50
51impl Default for MD5 {
52    fn default() -> Self {
53        Self {
54            written_length: 0,
55            buf: Default::default(),
56            a0: 0x67452301,
57            b0: 0xefcdab89,
58            c0: 0x98badcfe,
59            d0: 0x10325476,
60        }
61    }
62}
63
64impl MD5 {
65    fn try_chomp(&mut self) {
66        if !self.buf.is_full() {
67            return;
68        }
69        let words: [u32; 16] = self.buf.take_le_buf();
70
71        let mut a = self.a0;
72        let mut b = self.b0;
73        let mut c = self.c0;
74        let mut d = self.d0;
75        for i in 0..=63 {
76            let mut f: u32 = 0;
77            let mut g: u32 = 0;
78            match i {
79                0..=15 => {
80                    f = b.bitand(c).bitor(b.not().bitand(d));
81                    g = i;
82                }
83                16..=31 => {
84                    f = d.bitand(b).bitor(d.not().bitand(c));
85                    g = i.wrapping_mul(5).wrapping_add(1).bitand(0xF);
86                }
87                32..=47 => {
88                    f = b.bitxor(c).bitxor(d);
89                    g = i.wrapping_mul(3).wrapping_add(5).bitand(0xF);
90                }
91                48..=63 => {
92                    f = c.bitxor(b.bitor(d.not()));
93                    g = i.wrapping_mul(7).bitand(0xF);
94                }
95                _ => {
96                    // unreachable.
97                }
98            };
99            let i = i as usize;
100            let k = KONSTANTS.get(i).copied().unwrap_or_default();
101            let m = words.get(g as usize).copied().unwrap_or_default();
102            f = f.wrapping_add(a).wrapping_add(k).wrapping_add(m);
103            a = d;
104            d = c;
105            c = b;
106            b = b.wrapping_add(f.rotate_left(SHIFT_AMOUNTS.get(i).copied().unwrap_or_default()));
107        }
108
109        self.a0 = self.a0.wrapping_add(a);
110        self.b0 = self.b0.wrapping_add(b);
111        self.c0 = self.c0.wrapping_add(c);
112        self.d0 = self.d0.wrapping_add(d);
113    }
114
115    ///
116    /// Finishes the hash and returns the result.
117    pub fn finish(mut self) -> u128 {
118        let mut modlen64 = (self.written_length & 0x3F) as usize;
119        let mut pad: usize = 0;
120        if modlen64 >= 56 {
121            // append 64 bits/8 bytes;
122            pad += BLOCK_SIZE - modlen64;
123            modlen64 = 0;
124        }
125        pad += 56 - modlen64;
126        let _ = self.buf.write_le_u8(0x80);
127        pad -= 1;
128        for _ in 0..pad {
129            self.try_chomp();
130            let _ = self.buf.write_le_u8(0);
131        }
132        let [a, b] = (self.written_length << 3).to_u32_array();
133        let _ = self.buf.write_le_u32(b.swap_bytes());
134        let _ = self.buf.write_le_u32(a.swap_bytes());
135        self.try_chomp();
136        // assert_eq!(0, self.buf.len(), "Buffer length wasn't zeroed!");
137        let mut out = [0u8; 16];
138        let o = &mut out.as_mut_slice();
139        let _ = self.a0.write_le_to(o);
140        let _ = self.b0.write_le_to(o);
141        let _ = self.c0.write_le_to(o);
142        let _ = self.d0.write_le_to(o);
143        u128::from_be_bytes(out)
144    }
145
146    ///
147    /// Appends the bytes to the internal buffer.  NOTE: You must call 'finish' to get the final result.
148    pub fn write(&mut self, mut bytes: &[u8]) {
149        // for b in bytes {
150        //     let _ = self.buf.push_back(*b);
151        //     self.written_length += 1;
152        //     self.try_chomp();
153        // }
154
155        let align = self.buf.rem_align();
156        if align < 4 && align < bytes.len() {
157            let (a, b) = bytes.split_at(self.buf.rem_align());
158            bytes = b;
159            for val in a {
160                let _ = self.buf.write_le_u8(*val);
161                self.written_length += 1;
162                if self.buf.is_full() {
163                    self.try_chomp();
164                }
165            }
166        }
167        let mut chunks = bytes.chunks_exact(4);
168        for c in chunks.by_ref() {
169            let _ = self
170                .buf
171                .push_prim(u32::from_le_bytes(c.try_into().unwrap_or_default()));
172            self.written_length += 4;
173
174            self.try_chomp();
175        }
176        for b in chunks.remainder() {
177            let _ = self.buf.write_le_u8(*b);
178            self.written_length += 1;
179            self.try_chomp();
180        }
181    }
182
183    ///
184    /// Hashes the provided bytes.
185    pub fn hash(mut self, bytes: &[u8]) -> u128 {
186        self.write(bytes);
187        self.finish()
188    }
189}
190
191impl MutBits for MD5 {
192    fn write_u8(&mut self, val: u8) -> Result<(), Error> {
193        self.write(&[val]);
194        Ok(())
195    }
196}
197
198impl HashDigest<BLOCK_SIZE, OUTPUT_SIZE> for MD5 {
199    fn write(&mut self, bytes: &[u8]) {
200        MD5::write(self, bytes)
201    }
202
203    fn hash(self, bytes: &[u8]) -> [u8; OUTPUT_SIZE] {
204        MD5::hash(self, bytes).to_be_bytes() as [u8; OUTPUT_SIZE]
205    }
206
207    fn finish(self) -> [u8; OUTPUT_SIZE] {
208        MD5::finish(self).to_be_bytes() as [u8; OUTPUT_SIZE]
209    }
210
211    fn algorithm() -> HashAlgorithm {
212        HashAlgorithm::MD5
213    }
214}
215
216#[cfg(test)]
217mod test {
218    use crate::hash::MD5;
219
220    #[test]
221    pub fn test_md5() {
222        assert_eq_hex!(
223            0xd41d8cd98f00b204e9800998ecf8427e,
224            MD5::default().hash("".as_bytes())
225        );
226        assert_eq_hex!(
227            0x0cc175b9c0f1b6a831c399e269772661,
228            MD5::default().hash("a".as_bytes())
229        );
230        assert_eq_hex!(
231            0x900150983cd24fb0d6963f7d28e17f72,
232            MD5::default().hash("abc".as_bytes())
233        );
234        assert_eq_hex!(
235            0xf96b697d7cb7938d525a2f31aaf161d0,
236            MD5::default().hash("message digest".as_bytes())
237        );
238        assert_eq_hex!(
239            0xc3fcd3d76192e4007dfb496cca67e13b,
240            MD5::default().hash("abcdefghijklmnopqrstuvwxyz".as_bytes())
241        );
242        assert_eq_hex!(
243            0xd174ab98d277d9f5a5611c2c9f419d9f,
244            MD5::default()
245                .hash("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".as_bytes())
246        );
247        assert_eq_hex!(
248            0x7f7bfd348709deeaace19e3f535f8c54,
249            MD5::default().hash(
250                "0123456789012345678901234567890123456789012345678901234567890123".as_bytes()
251            )
252        );
253        assert_eq_hex!(
254            0x57edf4a22be3c955ac49da2e2107b67a,
255            MD5::default().hash(
256                "12345678901234567890123456789012345678901234567890123456789012345678901234567890"
257                    .as_bytes()
258            )
259        );
260        assert_eq_hex!(
261            0x9e107d9d372bb6826bd81d3542a419d6,
262            MD5::default().hash("The quick brown fox jumps over the lazy dog".as_bytes())
263        );
264        assert_eq_hex!(
265            0xe4d909c290d0fb1ca068ffaddf22cbd0,
266            MD5::default().hash("The quick brown fox jumps over the lazy dog.".as_bytes())
267        );
268    }
269}
irox_tools/hash/md5.rs

irox_tools/hash/
md5.rs
