use crate::crypto::{CipherAlgo, HashAlgo};
use crate::DpapiError;
fn u32le(b: &[u8], o: usize) -> Option<u32> {
Some(u32::from_le_bytes(b.get(o..o + 4)?.try_into().ok()?))
}
fn u64le(b: &[u8], o: usize) -> Option<u64> {
Some(u64::from_le_bytes(b.get(o..o + 8)?.try_into().ok()?))
}
#[derive(Debug, Clone)]
pub struct MasterKeyFile {
pub guid: String,
pub master_key: Option<MasterKey>,
}
impl MasterKeyFile {
pub fn parse(data: &[u8]) -> Result<Self, DpapiError> {
if data.len() < 128 {
return Err(DpapiError::Parse("masterkey file too short".into()));
}
let guid_units: Vec<u16> = data[12..12 + 72]
.chunks_exact(2)
.map(|c| u16::from_le_bytes([c[0], c[1]]))
.collect();
let guid = String::from_utf16_lossy(&guid_units)
.trim_end_matches('\0')
.to_string();
let mk_len = u64le(data, 96).ok_or_else(|| DpapiError::Parse("mk len".into()))? as usize;
let master_key = if mk_len > 0 {
let start = 128usize;
let end = start
.checked_add(mk_len)
.filter(|&e| e <= data.len())
.ok_or_else(|| DpapiError::Parse("mk subfield out of bounds".into()))?;
Some(MasterKey::parse(&data[start..end])?)
} else {
None
};
Ok(MasterKeyFile { guid, master_key })
}
}
#[derive(Debug, Clone)]
pub struct MasterKey {
pub salt: [u8; 16],
pub rounds: u32,
pub hash_algo: HashAlgo,
pub cipher_algo: CipherAlgo,
pub ciphertext: Vec<u8>,
}
impl MasterKey {
pub fn parse(data: &[u8]) -> Result<Self, DpapiError> {
if data.len() < 32 {
return Err(DpapiError::Parse("masterkey subfield too short".into()));
}
let salt: [u8; 16] = data[4..20].try_into().unwrap();
let rounds = u32le(data, 20).unwrap();
let hash_id = u32le(data, 24).unwrap();
let crypt_id = u32le(data, 28).unwrap();
let hash_algo = HashAlgo::from_alg_id(hash_id)
.ok_or_else(|| DpapiError::Unsupported(format!("hash alg 0x{hash_id:04x}")))?;
let cipher_algo = CipherAlgo::from_alg_id(crypt_id)
.ok_or_else(|| DpapiError::Unsupported(format!("cipher alg 0x{crypt_id:04x}")))?;
Ok(MasterKey {
salt,
rounds,
hash_algo,
cipher_algo,
ciphertext: data[32..].to_vec(),
})
}
pub fn decrypt_with_key(&self, pwdkey: &[u8]) -> Result<[u8; 64], DpapiError> {
let key_len = self.cipher_algo.key_len();
let iv_len = self.cipher_algo.iv_len();
let derived = crate::crypto::ms_derive_key(
self.hash_algo,
pwdkey,
&self.salt,
self.rounds,
key_len + iv_len,
);
let clear = self
.cipher_algo
.cbc_decrypt_nopad(&derived[..key_len], &derived[key_len..], &self.ciphertext)
.ok_or(DpapiError::Decrypt)?;
let dlen = self.hash_algo.digest_len();
if clear.len() < 16 + dlen + 64 {
return Err(DpapiError::Decrypt);
}
let hmac_salt = &clear[..16];
let stored = &clear[16..16 + dlen];
let masterkey: [u8; 64] = clear[clear.len() - 64..].try_into().unwrap();
let hmac1 = self.hash_algo.hmac(pwdkey, hmac_salt);
let computed = self.hash_algo.hmac(&hmac1, &masterkey);
if computed == stored {
Ok(masterkey)
} else {
Err(DpapiError::HmacMismatch)
}
}
pub fn decrypt_with_password(&self, password: &str, sid: &str) -> Result<[u8; 64], DpapiError> {
let pwdkey = derive_local_prekey(password, sid);
self.decrypt_with_key(&pwdkey)
}
}
pub fn derive_local_prekey(password: &str, sid: &str) -> [u8; 20] {
use sha1::{Digest, Sha1};
let pw16: Vec<u8> = password.encode_utf16().flat_map(u16::to_le_bytes).collect();
let pwdhash = Sha1::digest(&pw16);
let mut sid16: Vec<u8> = sid.encode_utf16().flat_map(u16::to_le_bytes).collect();
sid16.extend_from_slice(&[0, 0]); crate::crypto::hmac_sha1(&pwdhash, &sid16)
}
pub fn derive_domain_prekey_md4(password: &str, sid: &str) -> [u8; 20] {
let pw16: Vec<u8> = password.encode_utf16().flat_map(u16::to_le_bytes).collect();
let nt = crate::crypto::md4(&pw16);
let mut sid16: Vec<u8> = sid.encode_utf16().flat_map(u16::to_le_bytes).collect();
sid16.extend_from_slice(&[0, 0]);
crate::crypto::hmac_sha1(&nt, &sid16)
}
pub fn derive_domain_prekey_protected(password: &str, sid: &str) -> [u8; 20] {
let pw16: Vec<u8> = password.encode_utf16().flat_map(u16::to_le_bytes).collect();
let nt = crate::crypto::md4(&pw16);
let sid16: Vec<u8> = sid.encode_utf16().flat_map(u16::to_le_bytes).collect();
let tmp1 = crate::crypto::pbkdf2_sha256(&nt, &sid16, 10000, 32);
let tmp2 = crate::crypto::pbkdf2_sha256(&tmp1, &sid16, 1, 32);
let mut sid16_nul: Vec<u8> = sid.encode_utf16().flat_map(u16::to_le_bytes).collect();
sid16_nul.extend_from_slice(&[0, 0]);
crate::crypto::hmac_sha1(&tmp2[..16], &sid16_nul)
}
#[cfg(test)]
mod tests {
use super::*;
fn hex(b: &[u8]) -> String {
b.iter().fold(String::with_capacity(b.len() * 2), |mut s, x| {
use std::fmt::Write;
write!(s, "{x:02x}").unwrap();
s
})
}
fn hex_decode(s: &str) -> Vec<u8> {
(0..s.len())
.step_by(2)
.map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
.collect()
}
const KAT_MK_SUBFIELD: [u8; 176] = [
0x02, 0x00, 0x00, 0x00, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a,
0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x40, 0x1f, 0x00, 0x00, 0x0e, 0x80, 0x00, 0x00, 0x10, 0x66,
0x00, 0x00, 0xc6, 0x29, 0x59, 0x58, 0xdb, 0x97, 0x1f, 0xe7, 0x63, 0x89, 0x60, 0x79, 0x12,
0xc2, 0x57, 0x8e, 0x1f, 0xa2, 0x8b, 0x02, 0xe7, 0x99, 0x97, 0x63, 0x85, 0xe7, 0x93, 0x37,
0xbd, 0xf4, 0x14, 0xd4, 0x08, 0x0c, 0x00, 0x70, 0xc9, 0xc3, 0x1d, 0x67, 0x5c, 0x71, 0xcb,
0x3f, 0x83, 0xfe, 0xb2, 0x20, 0x73, 0x85, 0xae, 0x04, 0x9c, 0x3a, 0xd1, 0x4a, 0x47, 0x4c,
0x97, 0xf6, 0xf2, 0x24, 0x1a, 0x92, 0xd6, 0xae, 0xf7, 0xcf, 0x58, 0xb1, 0x25, 0xf2, 0x2a,
0x34, 0xf8, 0xe9, 0x5b, 0x65, 0xb7, 0xaa, 0x63, 0xdf, 0x37, 0x5c, 0xd0, 0xed, 0x5d, 0x59,
0xa6, 0x11, 0x1f, 0x24, 0xa5, 0xd8, 0xf5, 0xde, 0xdf, 0xca, 0x4f, 0x88, 0x7b, 0x19, 0x45,
0xb3, 0xf5, 0x32, 0x38, 0xb9, 0xa0, 0x0e, 0xcc, 0xae, 0x0a, 0x2b, 0x8f, 0x06, 0x9a, 0xf3,
0x30, 0xc4, 0x7c, 0x3e, 0xbc, 0xcb, 0x44, 0x57, 0x75, 0xe1, 0xfd, 0xc3, 0x11, 0x95, 0xc7,
0xdf, 0xb8, 0x09, 0xd6, 0xbc, 0xed, 0xf3, 0x73, 0xbf, 0xa9, 0x99,
];
const KAT_PASSWORD: &str = "SyntheticTestPassword-DoNotUse-2026";
const KAT_SID: &str = "S-1-5-21-1111111111-2222222222-3333333333-1000";
const KAT_PWDKEY_PROTECTED: &str = "e71d3b00909db78ad315f60171cf4f0873ecb9fe";
const KAT_MASTERKEY: &str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
#[test]
fn derive_domain_prekey_protected_matches_impacket_synthetic() {
assert_eq!(
hex(&derive_domain_prekey_protected(KAT_PASSWORD, KAT_SID)),
KAT_PWDKEY_PROTECTED
);
}
#[test]
fn decrypt_with_key_end_to_end_synthetic() {
let mk = MasterKey::parse(&KAT_MK_SUBFIELD).expect("parse mk subfield");
let pwdkey = hex_decode(KAT_PWDKEY_PROTECTED);
let out = mk.decrypt_with_key(&pwdkey).expect("decrypt with key");
assert_eq!(hex(&out), KAT_MASTERKEY);
}
#[test]
fn unlock_masterkey_end_to_end_synthetic() {
let mut file = vec![0u8; 128];
file[96..104].copy_from_slice(&(KAT_MK_SUBFIELD.len() as u64).to_le_bytes());
file.extend_from_slice(&KAT_MK_SUBFIELD);
let out = crate::unlock_masterkey(&file, KAT_PASSWORD, KAT_SID).expect("unlock synthetic MK");
assert_eq!(hex(&out), KAT_MASTERKEY);
}
#[test]
fn parses_header_guid_and_subfield_lengths() {
let mut f = vec![0u8; 128];
f[0] = 2; let guid = "{DEADBEEF-0000-0000-0000-000000000000}";
let g16: Vec<u8> = guid.encode_utf16().flat_map(u16::to_le_bytes).collect();
f[12..12 + g16.len()].copy_from_slice(&g16);
f[96..104].copy_from_slice(&48u64.to_le_bytes());
let mut mk = vec![0u8; 32];
mk[0] = 2;
mk[20..24].copy_from_slice(&8000u32.to_le_bytes());
mk[24..28].copy_from_slice(&0x800eu32.to_le_bytes()); mk[28..32].copy_from_slice(&0x6610u32.to_le_bytes()); mk.extend_from_slice(&[0xAB; 16]);
f.extend_from_slice(&mk);
let parsed = MasterKeyFile::parse(&f).unwrap();
assert!(parsed.guid.starts_with("{DEADBEEF"));
let k = parsed.master_key.unwrap();
assert_eq!(k.rounds, 8000);
assert_eq!(k.hash_algo, HashAlgo::Sha512);
assert_eq!(k.cipher_algo, CipherAlgo::Aes256);
assert_eq!(k.ciphertext, vec![0xAB; 16]);
}
#[test]
fn prekey_is_deterministic_and_20_bytes() {
let a = derive_local_prekey("Passw0rd!", "S-1-5-21-1-2-3-1001");
let b = derive_local_prekey("Passw0rd!", "S-1-5-21-1-2-3-1001");
assert_eq!(a, b);
assert_ne!(a, derive_local_prekey("Passw0rd!", "S-1-5-21-1-2-3-1002"));
}
#[test]
fn rejects_short_and_bad_alg() {
assert!(MasterKeyFile::parse(&[0u8; 10]).is_err());
let mut mk = vec![0u8; 32];
mk[24..28].copy_from_slice(&0xDEADu32.to_le_bytes()); assert!(matches!(
MasterKey::parse(&mk),
Err(DpapiError::Unsupported(_))
));
}
}