pub mod blob;
pub mod crypto;
pub mod masterkey;
pub use blob::DpapiBlob;
pub use masterkey::{MasterKey, MasterKeyFile};
#[derive(Debug, thiserror::Error)]
pub enum DpapiError {
#[error("parse: {0}")]
Parse(String),
#[error("unsupported algorithm: {0}")]
Unsupported(String),
#[error("CBC decryption failed")]
Decrypt,
#[error("masterkey HMAC verification failed (wrong password/SID?)")]
HmacMismatch,
}
pub fn unlock_masterkey(
masterkey_file: &[u8],
password: &str,
sid: &str,
) -> Result<[u8; 64], DpapiError> {
let mkf = MasterKeyFile::parse(masterkey_file)?;
let mk = mkf
.master_key
.ok_or_else(|| DpapiError::Parse("file has no masterkey subfield".into()))?;
let candidates: [&[u8]; 3] = [
&masterkey::derive_local_prekey(password, sid),
&masterkey::derive_domain_prekey_md4(password, sid),
&masterkey::derive_domain_prekey_protected(password, sid),
];
let mut last_err = DpapiError::HmacMismatch;
for pwdkey in candidates {
match mk.decrypt_with_key(pwdkey) {
Ok(k) => return Ok(k),
Err(e) => last_err = e,
}
}
Err(last_err)
}
#[cfg(test)]
mod integration {
use super::*;
#[test]
#[ignore = "needs a real masterkey file (see VALIDATION STATUS)"]
fn test_real_masterkey() {
let Ok(path) = std::env::var("DPAPI_MK_FILE") else {
return;
};
let pw = std::env::var("DPAPI_MK_PASSWORD").expect("DPAPI_MK_PASSWORD");
let sid = std::env::var("DPAPI_MK_SID").expect("DPAPI_MK_SID");
let bytes = std::fs::read(&path).expect("read masterkey file");
let key = unlock_masterkey(&bytes, &pw, &sid).expect("decrypt masterkey");
let hexkey: String = key.iter().map(|b| format!("{b:02x}")).collect();
eprintln!("[dpapi] recovered masterkey: {hexkey}");
if let Ok(expected) = std::env::var("DPAPI_MK_EXPECTED") {
assert_eq!(
hexkey,
expected.to_lowercase(),
"masterkey mismatch vs oracle"
);
}
}
#[test]
#[ignore = "needs a real masterkey file + externally derived pwdkey"]
fn test_real_masterkey_with_pwdkey() {
let Ok(path) = std::env::var("DPAPI_MK_FILE") else {
return;
};
let key_hex = std::env::var("DPAPI_MK_PWDKEY").expect("DPAPI_MK_PWDKEY");
let pwdkey: Vec<u8> = (0..key_hex.len())
.step_by(2)
.map(|i| u8::from_str_radix(&key_hex[i..i + 2], 16).unwrap())
.collect();
let bytes = std::fs::read(&path).expect("read masterkey file");
let mkf = MasterKeyFile::parse(&bytes).expect("parse mk file");
let mk = mkf.master_key.expect("mk file has no MasterKey subfield");
let key = mk.decrypt_with_key(&pwdkey).expect("decrypt with key");
let hexkey: String = key.iter().map(|b| format!("{b:02x}")).collect();
eprintln!("[dpapi] guid = {}", mkf.guid);
eprintln!("[dpapi] recovered masterkey: {hexkey}");
if let Ok(expected) = std::env::var("DPAPI_MK_EXPECTED") {
assert_eq!(
hexkey,
expected.trim_start_matches("0x").to_lowercase(),
"masterkey mismatch vs oracle"
);
}
}
}