use crate::identify::Candidate;
pub struct HexBucket {
pub chars: usize,
pub base_confidence: f32,
pub common: &'static [(u32, &'static str)],
pub rare: &'static [(u32, &'static str)],
}
pub static BUCKETS: &[HexBucket] = &[
HexBucket {
chars: 8,
base_confidence: 0.30,
common: &[(11500, "CRC32 (hashcat wants hash:salt)")],
rare: &[],
},
HexBucket {
chars: 16,
base_confidence: 0.42,
common: &[(200, "MySQL323"), (3000, "LM")],
rare: &[],
},
HexBucket {
chars: 32,
base_confidence: 0.48,
common: &[(0, "MD5"), (1000, "NTLM"), (900, "MD4")],
rare: &[(2600, "md5(md5($pass))")],
},
HexBucket {
chars: 40,
base_confidence: 0.55,
common: &[(100, "SHA-1"), (6000, "RIPEMD-160")],
rare: &[(300, "MySQL4.1/MySQL5"), (4500, "sha1(sha1($pass))")],
},
HexBucket {
chars: 56,
base_confidence: 0.55,
common: &[(1300, "SHA-224")],
rare: &[(17300, "SHA3-224"), (17700, "Keccak-224")],
},
HexBucket {
chars: 64,
base_confidence: 0.50,
common: &[
(1400, "SHA-256"),
(17400, "SHA3-256"),
(17800, "Keccak-256"),
],
rare: &[(6900, "GOST R 34.11-94"), (11700, "Streebog-256")],
},
HexBucket {
chars: 96,
base_confidence: 0.60,
common: &[(10800, "SHA-384")],
rare: &[(17500, "SHA3-384"), (17900, "Keccak-384")],
},
HexBucket {
chars: 128,
base_confidence: 0.48,
common: &[(1700, "SHA-512"), (6100, "Whirlpool")],
rare: &[
(17600, "SHA3-512"),
(18000, "Keccak-512"),
(11800, "Streebog-512"),
],
},
];
pub fn is_hex(s: &str) -> bool {
!s.is_empty() && s.bytes().all(|b| b.is_ascii_hexdigit())
}
fn is_degenerate(s: &str) -> bool {
if s.len() < 16 {
return false; }
let mut seen = [false; 256];
let mut distinct = 0u32;
for b in s.bytes().map(|b| b.to_ascii_lowercase()) {
if !std::mem::replace(&mut seen[b as usize], true) {
distinct += 1;
}
}
distinct < 4
}
pub fn classify(s: &str, include_rare: bool) -> Vec<Candidate> {
if !is_hex(s) || is_degenerate(s) {
return Vec::new();
}
let Some(bucket) = BUCKETS.iter().find(|b| b.chars == s.len()) else {
return Vec::new();
};
let mut out = Vec::new();
let mut rank = 0usize;
let mut push = |mode: u32, name: &'static str, rank: usize| {
out.push(Candidate {
mode,
name,
confidence: (bucket.base_confidence - rank as f32 * 0.08).max(0.05),
});
};
for (mode, name) in bucket.common {
push(*mode, name, rank);
rank += 1;
}
if include_rare {
for (mode, name) in bucket.rare {
push(*mode, name, rank);
rank += 1;
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn hexn(len: usize) -> String {
"0123456789abcdef".chars().cycle().take(len).collect()
}
#[test]
fn rejects_non_hex_and_unknown_lengths() {
assert!(classify("nothex!!", false).is_empty());
assert!(classify("", false).is_empty());
assert!(classify(&hexn(31), false).is_empty()); }
#[test]
fn degenerate_hex_is_rejected() {
assert!(classify(&"0".repeat(32), true).is_empty()); assert!(classify(&"f".repeat(40), true).is_empty()); assert!(classify(&"0f".repeat(16), true).is_empty()); assert!(!classify("8743b52063cd84097a65d1633f5c74f5", false).is_empty()); }
#[test]
fn md5_ranks_above_ntlm_above_md4() {
let c = classify(&hexn(32), false);
assert_eq!(
c.iter().map(|x| x.mode).collect::<Vec<_>>(),
vec![0, 1000, 900]
);
assert!(c[0].confidence > c[1].confidence);
assert!(c[1].confidence > c[2].confidence);
}
#[test]
fn nothing_here_reads_as_certain() {
for len in [8, 16, 32, 40, 56, 64, 96, 128] {
for c in classify(&hexn(len), true) {
assert!(c.confidence < 0.85, "hex mode {} claimed certainty", c.mode);
}
}
}
#[test]
fn rare_is_gated_by_include_rare() {
let common = classify(&hexn(64), false);
let all = classify(&hexn(64), true);
assert!(all.len() > common.len());
assert!(all.iter().any(|c| c.mode == 6900)); assert!(!common.iter().any(|c| c.mode == 6900));
}
#[test]
fn uppercase_hex_is_accepted() {
assert!(is_hex("8743B52063CD84097A65D1633F5C74F5"));
}
}