use md5::Md5;
use sha1::Sha1;
use sha2::{Digest, Sha256, Sha512};
use sha3::{Shake256, digest::{ExtendableOutput, XofReader}};
use std::sync::{Mutex, OnceLock};
pub const BLAKE3_HASH_PREFIX: &str = "blake3:";
pub const SHA256_HASH_PREFIX: &str = "sha256:";
pub const DEFAULT_HASH_PREFIX: &str = BLAKE3_HASH_PREFIX;
pub const DEFAULT_COLLISION_THRESHOLD: u32 = 2;
pub trait HashProvider: Send + Sync {
fn hash(&self, content: &[u8]) -> String;
fn prefix(&self) -> &'static str;
fn hash_bytes(&self, content: &[u8]) -> [u8; 32] {
let hex = self.hash(content);
let mut out = [0u8; 32];
let bytes = hex.as_bytes();
for i in 0..32 {
out[i] = u8::from_str_radix(
std::str::from_utf8(&bytes[i * 2..i * 2 + 2]).unwrap_or("00"),
16,
)
.unwrap_or(0);
}
out
}
}
pub struct Blake3Provider;
impl HashProvider for Blake3Provider {
fn hash(&self, content: &[u8]) -> String {
blake3::hash(content).to_hex().to_string()
}
fn prefix(&self) -> &'static str {
BLAKE3_HASH_PREFIX
}
fn hash_bytes(&self, content: &[u8]) -> [u8; 32] {
*blake3::hash(content).as_bytes()
}
}
pub struct Sha256Provider;
impl HashProvider for Sha256Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Sha256::new();
hasher.update(content);
format!("{:x}", hasher.finalize())
}
fn prefix(&self) -> &'static str {
SHA256_HASH_PREFIX
}
fn hash_bytes(&self, content: &[u8]) -> [u8; 32] {
let mut hasher = Sha256::new();
hasher.update(content);
hasher.finalize().into()
}
}
pub struct Md5Provider;
impl HashProvider for Md5Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Md5::new();
hasher.update(content);
format!("{:x}", hasher.finalize())
}
fn prefix(&self) -> &'static str {
"md5:"
}
}
pub struct Sha1Provider;
impl HashProvider for Sha1Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Sha1::new();
hasher.update(content);
format!("{:x}", hasher.finalize())
}
fn prefix(&self) -> &'static str {
"sha1:"
}
}
pub struct Sha512Provider;
impl HashProvider for Sha512Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Sha512::new();
hasher.update(content);
format!("{:x}", hasher.finalize())
}
fn prefix(&self) -> &'static str {
"sha512:"
}
}
pub struct Shake256Provider {
bits: usize,
prefix_str: &'static str,
}
impl Shake256Provider {
pub fn new(bits: usize) -> Self {
let prefix_str: &'static str = Box::leak(
format!("custom-{}:", bits).into_boxed_str(),
);
Self { bits, prefix_str }
}
fn byte_len(&self) -> usize {
self.bits.div_ceil(8)
}
}
impl HashProvider for Shake256Provider {
fn hash(&self, content: &[u8]) -> String {
let mut hasher = Shake256::default();
sha3::digest::Update::update(&mut hasher, content);
let mut reader = hasher.finalize_xof();
let byte_len = self.byte_len();
let mut buf = vec![0u8; byte_len];
reader.read(&mut buf);
hex::encode(&buf)
}
fn prefix(&self) -> &'static str {
self.prefix_str
}
}
pub struct ProviderRegistry {
providers: Vec<(&'static str, Box<dyn HashProvider>)>,
}
impl ProviderRegistry {
fn new() -> Self {
Self {
providers: Vec::new(),
}
}
pub fn register(&mut self, provider: Box<dyn HashProvider>) {
let prefix = provider.prefix();
self.providers.push((prefix, provider));
}
pub fn get(&self, prefix: &str) -> Option<&dyn HashProvider> {
self.providers
.iter()
.find(|(p, _)| *p == prefix)
.map(|(_, provider)| provider.as_ref())
}
pub fn active(&self, active_prefix: &str) -> &dyn HashProvider {
self.get(active_prefix)
.unwrap_or_else(|| self.get(DEFAULT_HASH_PREFIX).expect("default provider must be registered"))
}
pub fn algorithms(&self) -> Vec<&'static str> {
self.providers.iter().map(|(p, _)| *p).collect()
}
}
pub fn global_registry() -> &'static Mutex<ProviderRegistry> {
static REGISTRY: OnceLock<Mutex<ProviderRegistry>> = OnceLock::new();
REGISTRY.get_or_init(|| {
let mut reg = ProviderRegistry::new();
reg.register(Box::new(Blake3Provider));
reg.register(Box::new(Sha256Provider));
reg.register(Box::new(Md5Provider));
reg.register(Box::new(Sha1Provider));
reg.register(Box::new(Sha512Provider));
Mutex::new(reg)
})
}
pub fn register_provider(provider: Box<dyn HashProvider>) {
let mut reg = global_registry().lock().unwrap();
reg.register(provider);
}
pub fn register_custom_provider(bits: usize) {
register_provider(Box::new(Shake256Provider::new(bits)));
}
pub const STRENGTH_HIERARCHY: &[&str] = &[
"md5:",
"sha1:",
"sha256:",
"blake3:",
"sha512:",
"custom-1024:",
];
pub fn next_stronger_algorithm(current: &str) -> &'static str {
if let Some(rest) = current.strip_prefix("custom-")
&& let Some(num_str) = rest.strip_suffix(':')
&& let Ok(n) = num_str.parse::<usize>() {
let doubled = n * 2;
return Box::leak(format!("custom-{}:", doubled).into_boxed_str());
}
let pos = STRENGTH_HIERARCHY.iter().position(|&algo| algo == current);
match pos {
Some(i) if i + 1 < STRENGTH_HIERARCHY.len() => STRENGTH_HIERARCHY[i + 1],
_ => DEFAULT_HASH_PREFIX,
}
}
pub fn list_algorithms() -> Vec<&'static str> {
let reg = global_registry().lock().unwrap();
reg.algorithms()
}
#[path = "hash_config.rs"]
mod hash_config;
#[allow(unused_imports)]
pub use hash_config::*;
#[cfg(test)]
#[path = "hash_tests.rs"]
mod tests;