From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/md-5/src/compress.rs | 165 ++++++++++++++++++++++++++++++++++++++++++++ vendor/md-5/src/lib.rs | 139 +++++++++++++++++++++++++++++++++++++ 2 files changed, 304 insertions(+) create mode 100644 vendor/md-5/src/compress.rs create mode 100644 vendor/md-5/src/lib.rs (limited to 'vendor/md-5/src') diff --git a/vendor/md-5/src/compress.rs b/vendor/md-5/src/compress.rs new file mode 100644 index 000000000..46857038e --- /dev/null +++ b/vendor/md-5/src/compress.rs @@ -0,0 +1,165 @@ +#![allow(clippy::many_single_char_names, clippy::unreadable_literal)] +use core::convert::TryInto; + +const RC: [u32; 64] = [ + // round 1 + 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, + 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, + // round 2 + 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, + 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, + // round 3 + 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, + 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, + // round 4 + 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, + 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391, +]; + +#[inline(always)] +fn op_f(w: u32, x: u32, y: u32, z: u32, m: u32, c: u32, s: u32) -> u32 { + ((x & y) | (!x & z)) + .wrapping_add(w) + .wrapping_add(m) + .wrapping_add(c) + .rotate_left(s) + .wrapping_add(x) +} +#[inline(always)] +fn op_g(w: u32, x: u32, y: u32, z: u32, m: u32, c: u32, s: u32) -> u32 { + ((x & z) | (y & !z)) + .wrapping_add(w) + .wrapping_add(m) + .wrapping_add(c) + .rotate_left(s) + .wrapping_add(x) +} + +#[inline(always)] +fn op_h(w: u32, x: u32, y: u32, z: u32, m: u32, c: u32, s: u32) -> u32 { + (x ^ y ^ z) + .wrapping_add(w) + .wrapping_add(m) + .wrapping_add(c) + .rotate_left(s) + .wrapping_add(x) +} + +#[inline(always)] +fn op_i(w: u32, x: u32, y: u32, z: u32, m: u32, c: u32, s: u32) -> u32 { + (y ^ (x | !z)) + .wrapping_add(w) + .wrapping_add(m) + .wrapping_add(c) + .rotate_left(s) + .wrapping_add(x) +} + +#[inline] +pub fn compress_block(state: &mut [u32; 4], input: &[u8; 64]) { + let mut a = state[0]; + let mut b = state[1]; + let mut c = state[2]; + let mut d = state[3]; + + let mut data = [0u32; 16]; + for (o, chunk) in data.iter_mut().zip(input.chunks_exact(4)) { + *o = u32::from_le_bytes(chunk.try_into().unwrap()); + } + + // round 1 + a = op_f(a, b, c, d, data[0], RC[0], 7); + d = op_f(d, a, b, c, data[1], RC[1], 12); + c = op_f(c, d, a, b, data[2], RC[2], 17); + b = op_f(b, c, d, a, data[3], RC[3], 22); + + a = op_f(a, b, c, d, data[4], RC[4], 7); + d = op_f(d, a, b, c, data[5], RC[5], 12); + c = op_f(c, d, a, b, data[6], RC[6], 17); + b = op_f(b, c, d, a, data[7], RC[7], 22); + + a = op_f(a, b, c, d, data[8], RC[8], 7); + d = op_f(d, a, b, c, data[9], RC[9], 12); + c = op_f(c, d, a, b, data[10], RC[10], 17); + b = op_f(b, c, d, a, data[11], RC[11], 22); + + a = op_f(a, b, c, d, data[12], RC[12], 7); + d = op_f(d, a, b, c, data[13], RC[13], 12); + c = op_f(c, d, a, b, data[14], RC[14], 17); + b = op_f(b, c, d, a, data[15], RC[15], 22); + + // round 2 + a = op_g(a, b, c, d, data[1], RC[16], 5); + d = op_g(d, a, b, c, data[6], RC[17], 9); + c = op_g(c, d, a, b, data[11], RC[18], 14); + b = op_g(b, c, d, a, data[0], RC[19], 20); + + a = op_g(a, b, c, d, data[5], RC[20], 5); + d = op_g(d, a, b, c, data[10], RC[21], 9); + c = op_g(c, d, a, b, data[15], RC[22], 14); + b = op_g(b, c, d, a, data[4], RC[23], 20); + + a = op_g(a, b, c, d, data[9], RC[24], 5); + d = op_g(d, a, b, c, data[14], RC[25], 9); + c = op_g(c, d, a, b, data[3], RC[26], 14); + b = op_g(b, c, d, a, data[8], RC[27], 20); + + a = op_g(a, b, c, d, data[13], RC[28], 5); + d = op_g(d, a, b, c, data[2], RC[29], 9); + c = op_g(c, d, a, b, data[7], RC[30], 14); + b = op_g(b, c, d, a, data[12], RC[31], 20); + + // round 3 + a = op_h(a, b, c, d, data[5], RC[32], 4); + d = op_h(d, a, b, c, data[8], RC[33], 11); + c = op_h(c, d, a, b, data[11], RC[34], 16); + b = op_h(b, c, d, a, data[14], RC[35], 23); + + a = op_h(a, b, c, d, data[1], RC[36], 4); + d = op_h(d, a, b, c, data[4], RC[37], 11); + c = op_h(c, d, a, b, data[7], RC[38], 16); + b = op_h(b, c, d, a, data[10], RC[39], 23); + + a = op_h(a, b, c, d, data[13], RC[40], 4); + d = op_h(d, a, b, c, data[0], RC[41], 11); + c = op_h(c, d, a, b, data[3], RC[42], 16); + b = op_h(b, c, d, a, data[6], RC[43], 23); + + a = op_h(a, b, c, d, data[9], RC[44], 4); + d = op_h(d, a, b, c, data[12], RC[45], 11); + c = op_h(c, d, a, b, data[15], RC[46], 16); + b = op_h(b, c, d, a, data[2], RC[47], 23); + + // round 4 + a = op_i(a, b, c, d, data[0], RC[48], 6); + d = op_i(d, a, b, c, data[7], RC[49], 10); + c = op_i(c, d, a, b, data[14], RC[50], 15); + b = op_i(b, c, d, a, data[5], RC[51], 21); + + a = op_i(a, b, c, d, data[12], RC[52], 6); + d = op_i(d, a, b, c, data[3], RC[53], 10); + c = op_i(c, d, a, b, data[10], RC[54], 15); + b = op_i(b, c, d, a, data[1], RC[55], 21); + + a = op_i(a, b, c, d, data[8], RC[56], 6); + d = op_i(d, a, b, c, data[15], RC[57], 10); + c = op_i(c, d, a, b, data[6], RC[58], 15); + b = op_i(b, c, d, a, data[13], RC[59], 21); + + a = op_i(a, b, c, d, data[4], RC[60], 6); + d = op_i(d, a, b, c, data[11], RC[61], 10); + c = op_i(c, d, a, b, data[2], RC[62], 15); + b = op_i(b, c, d, a, data[9], RC[63], 21); + + state[0] = state[0].wrapping_add(a); + state[1] = state[1].wrapping_add(b); + state[2] = state[2].wrapping_add(c); + state[3] = state[3].wrapping_add(d); +} + +#[inline] +pub fn compress(state: &mut [u32; 4], blocks: &[[u8; 64]]) { + for block in blocks { + compress_block(state, block) + } +} diff --git a/vendor/md-5/src/lib.rs b/vendor/md-5/src/lib.rs new file mode 100644 index 000000000..fadaf5192 --- /dev/null +++ b/vendor/md-5/src/lib.rs @@ -0,0 +1,139 @@ +//! An implementation of the [MD5][1] cryptographic hash algorithm. +//! +//! # Usage +//! +//! ```rust +//! use md5::{Md5, Digest}; +//! use hex_literal::hex; +//! +//! // create a Md5 hasher instance +//! let mut hasher = Md5::new(); +//! +//! // process input message +//! hasher.update(b"hello world"); +//! +//! // acquire hash digest in the form of GenericArray, +//! // which in this case is equivalent to [u8; 16] +//! let result = hasher.finalize(); +//! assert_eq!(result[..], hex!("5eb63bbbe01eeed093cb22bb8f5acdc3")); +//! ``` +//! +//! Also see [RustCrypto/hashes][2] readme. +//! +//! [1]: https://en.wikipedia.org/wiki/MD5 +//! [2]: https://github.com/RustCrypto/hashes + +#![no_std] +#![doc( + html_logo_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg", + html_favicon_url = "https://raw.githubusercontent.com/RustCrypto/media/6ee8e381/logo.svg", + html_root_url = "https://docs.rs/md-5/0.10.0" +)] +#![warn(missing_docs, rust_2018_idioms)] + +#[cfg(feature = "asm")] +extern crate md5_asm as compress; + +#[cfg(not(feature = "asm"))] +mod compress; + +pub use digest::{self, Digest}; + +use compress::compress; + +use core::{fmt, slice::from_ref}; +use digest::{ + block_buffer::Eager, + core_api::{ + AlgorithmName, Block, BlockSizeUser, Buffer, BufferKindUser, CoreWrapper, FixedOutputCore, + OutputSizeUser, Reset, UpdateCore, + }, + generic_array::typenum::{Unsigned, U16, U64}, + HashMarker, Output, +}; +/// Core MD5 hasher state. +#[derive(Clone)] +pub struct Md5Core { + block_len: u64, + state: [u32; 4], +} + +impl HashMarker for Md5Core {} + +impl BlockSizeUser for Md5Core { + type BlockSize = U64; +} + +impl BufferKindUser for Md5Core { + type BufferKind = Eager; +} + +impl OutputSizeUser for Md5Core { + type OutputSize = U16; +} + +impl UpdateCore for Md5Core { + #[inline] + fn update_blocks(&mut self, blocks: &[Block]) { + self.block_len = self.block_len.wrapping_add(blocks.len() as u64); + compress(&mut self.state, convert(blocks)) + } +} + +impl FixedOutputCore for Md5Core { + #[inline] + fn finalize_fixed_core(&mut self, buffer: &mut Buffer, out: &mut Output) { + let bit_len = self + .block_len + .wrapping_mul(Self::BlockSize::U64) + .wrapping_add(buffer.get_pos() as u64) + .wrapping_mul(8); + let mut s = self.state; + buffer.len64_padding_le(bit_len, |b| compress(&mut s, convert(from_ref(b)))); + for (chunk, v) in out.chunks_exact_mut(4).zip(s.iter()) { + chunk.copy_from_slice(&v.to_le_bytes()); + } + } +} + +impl Default for Md5Core { + #[inline] + fn default() -> Self { + Self { + block_len: 0, + state: [0x6745_2301, 0xEFCD_AB89, 0x98BA_DCFE, 0x1032_5476], + } + } +} + +impl Reset for Md5Core { + #[inline] + fn reset(&mut self) { + *self = Default::default(); + } +} + +impl AlgorithmName for Md5Core { + fn write_alg_name(f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("Md5") + } +} + +impl fmt::Debug for Md5Core { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("Md5Core { ... }") + } +} + +/// MD5 hasher state. +pub type Md5 = CoreWrapper; + +const BLOCK_SIZE: usize = ::BlockSize::USIZE; + +#[inline(always)] +fn convert(blocks: &[Block]) -> &[[u8; BLOCK_SIZE]] { + // SAFETY: GenericArray and [u8; 64] have + // exactly the same memory layout + let p = blocks.as_ptr() as *const [u8; BLOCK_SIZE]; + unsafe { core::slice::from_raw_parts(p, blocks.len()) } +} -- cgit v1.2.3