use crate::Error;
use aes::Aes256;
use cbc::cipher::{block_padding::NoPadding, BlockDecryptMut, KeyIvInit};
use md5::{Digest as _, Md5};
use rc4::{consts::U16, KeyInit, Rc4, StreamCipher};
use sha2::Sha256;
type Aes256CbcDec = cbc::Decryptor<Aes256>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PekKey {
bytes: [u8; 16],
}
impl PekKey {
pub fn new(bytes: [u8; 16]) -> Self {
PekKey { bytes }
}
pub fn bytes(&self) -> &[u8; 16] {
&self.bytes
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct PekList {
pub version: u8,
pub keys: Vec<PekKey>,
}
impl PekList {
pub fn key_for(&self, index: u32) -> Option<PekKey> {
self.keys.get(index as usize).copied()
}
}
pub fn unwrap_peklist(bootkey: &[u8; 16], peklist_bytes: &[u8]) -> Result<PekList, Error> {
if peklist_bytes.len() < 8 + 16 + 1 {
return Err(Error::Crypto(format!(
"PEKLIST too short ({} bytes)",
peklist_bytes.len()
)));
}
let version = peklist_bytes[0];
let key_material: &[u8; 16] = peklist_bytes[8..24]
.try_into()
.expect("length checked above");
let ciphertext = &peklist_bytes[24..];
let plaintext = match version {
3 => decrypt_rev3(bootkey, key_material, ciphertext)?,
2 => decrypt_rev2(bootkey, key_material, ciphertext),
other => return Err(Error::Crypto(format!("unknown PEK version {other:#04x}"))),
};
PekList::parse_plaintext(&plaintext).map(|mut l| {
l.version = version;
l
})
}
fn decrypt_rev3(
bootkey: &[u8; 16],
key_material: &[u8; 16],
ciphertext: &[u8],
) -> Result<Vec<u8>, Error> {
if ciphertext.is_empty() || ciphertext.len() % 16 != 0 {
return Err(Error::Crypto(format!(
"revision-3 ciphertext length {} is not a multiple of 16",
ciphertext.len()
)));
}
let mut hasher = Sha256::new();
hasher.update(bootkey);
for _ in 0..1000 {
hasher.update(key_material);
}
let tmp_key = hasher.finalize();
let mut buf = ciphertext.to_vec();
Aes256CbcDec::new(tmp_key.as_slice().into(), key_material.into())
.decrypt_padded_mut::<NoPadding>(&mut buf)
.map_err(|e| Error::Crypto(format!("AES-256-CBC decrypt failed: {e}")))?;
Ok(buf)
}
fn decrypt_rev2(bootkey: &[u8; 16], key_material: &[u8; 16], ciphertext: &[u8]) -> Vec<u8> {
let mut hasher = Md5::new();
hasher.update(bootkey);
for _ in 0..1000 {
hasher.update(key_material);
}
let tmp_key = hasher.finalize();
let mut buf = ciphertext.to_vec();
let mut cipher: Rc4<U16> = Rc4::new(tmp_key.as_slice().into());
cipher.apply_keystream(&mut buf);
buf
}
impl PekList {
pub fn parse_plaintext(plaintext: &[u8]) -> Result<Self, Error> {
if plaintext.len() < 32 + 20 {
return Err(Error::Crypto(format!(
"PEK plaintext too short ({} bytes, need at least 52)",
plaintext.len()
)));
}
let body_len = plaintext.len() - 32;
let count = body_len / 20;
let consumed = count * 20;
if plaintext[32 + consumed..].iter().any(|&b| b != 0) {
return Err(Error::Crypto(format!(
"PEK plaintext has {} non-zero trailing bytes past the last entry — likely wrong unwrap or torn buffer",
body_len - consumed
)));
}
let mut keys = Vec::with_capacity(count);
for i in 0..count {
let off = 32 + i * 20;
let mut k = [0u8; 16];
k.copy_from_slice(&plaintext[off + 4..off + 20]);
keys.push(PekKey::new(k));
}
Ok(PekList { version: 0, keys })
}
}
#[cfg(test)]
mod tests {
use super::*;
use aes::cipher::{block_padding::NoPadding, BlockEncryptMut, KeyIvInit};
type Aes256CbcEnc = cbc::Encryptor<Aes256>;
#[test]
fn parse_plaintext_reads_two_keys() {
let mut pt = vec![0u8; 32];
for i in 0..2u32 {
pt.extend_from_slice(&i.to_le_bytes());
pt.extend_from_slice(&[i as u8; 16]);
}
let list = PekList::parse_plaintext(&pt).unwrap();
assert_eq!(list.keys.len(), 2);
assert_eq!(list.keys[0].bytes(), &[0u8; 16]);
assert_eq!(list.keys[1].bytes(), &[1u8; 16]);
assert_eq!(list.key_for(1), Some(PekKey::new([1u8; 16])));
assert_eq!(list.key_for(2), None);
}
#[test]
fn parse_plaintext_rejects_short() {
assert!(matches!(
PekList::parse_plaintext(&[0u8; 30]).unwrap_err(),
Error::Crypto(_)
));
}
#[test]
fn parse_plaintext_accepts_zero_padded_tail() {
let mut pt = vec![0u8; 32];
pt.extend_from_slice(&0u32.to_le_bytes());
pt.extend_from_slice(&[0xEE; 16]);
pt.extend_from_slice(&[0u8; 12]); let list = PekList::parse_plaintext(&pt).unwrap();
assert_eq!(list.keys.len(), 1);
assert_eq!(list.keys[0].bytes(), &[0xEE; 16]);
}
#[test]
fn parse_plaintext_rejects_nonzero_ragged_tail() {
let mut pt = vec![0u8; 32];
pt.extend_from_slice(&0u32.to_le_bytes());
pt.extend_from_slice(&[0xEE; 16]);
pt.push(0x42); assert!(matches!(
PekList::parse_plaintext(&pt).unwrap_err(),
Error::Crypto(_)
));
}
#[test]
fn unwrap_peklist_reports_unknown_revision() {
let mut blob = vec![0u8; 32];
blob[0] = 42;
let err = unwrap_peklist(&[0u8; 16], &blob).unwrap_err();
assert!(format!("{err}").contains("unknown PEK version"));
}
#[test]
fn unwrap_peklist_rev3_roundtrip() {
let bootkey = [0xABu8; 16];
let salt = [0x11u8; 16];
let mut plaintext = vec![0u8; 32];
for i in 0..2u32 {
plaintext.extend_from_slice(&i.to_le_bytes());
plaintext.extend_from_slice(&[0xC0u8 + i as u8; 16]);
}
while plaintext.len() % 16 != 0 {
plaintext.push(0);
}
let mut hasher = Sha256::new();
hasher.update(bootkey);
for _ in 0..1000 {
hasher.update(salt);
}
let key = hasher.finalize();
let mut ct = plaintext.clone();
let ct_len = ct.len();
Aes256CbcEnc::new(key.as_slice().into(), &salt.into())
.encrypt_padded_mut::<NoPadding>(&mut ct, ct_len)
.unwrap();
let mut blob = vec![0u8; 8];
blob[0] = 3;
blob.extend_from_slice(&salt);
blob.extend_from_slice(&ct);
let list = unwrap_peklist(&bootkey, &blob).unwrap();
assert_eq!(list.version, 3);
assert_eq!(list.keys.len(), 2);
assert_eq!(list.keys[0].bytes(), &[0xC0u8; 16]);
assert_eq!(list.keys[1].bytes(), &[0xC1u8; 16]);
}
#[test]
fn unwrap_peklist_rev2_roundtrip() {
use md5::{Digest, Md5};
let bootkey = [0x33u8; 16];
let salt = [0x77u8; 16];
let mut plaintext = vec![0u8; 32];
plaintext.extend_from_slice(&0u32.to_le_bytes());
plaintext.extend_from_slice(&[0xEFu8; 16]);
let mut hasher = Md5::new();
hasher.update(bootkey);
for _ in 0..1000 {
hasher.update(salt);
}
let key = hasher.finalize();
let mut ct = plaintext.clone();
let mut cipher: Rc4<U16> = Rc4::new(key.as_slice().into());
cipher.apply_keystream(&mut ct);
let mut blob = vec![0u8; 8];
blob[0] = 2;
blob.extend_from_slice(&salt);
blob.extend_from_slice(&ct);
let list = unwrap_peklist(&bootkey, &blob).unwrap();
assert_eq!(list.version, 2);
assert_eq!(list.keys.len(), 1);
assert_eq!(list.keys[0].bytes(), &[0xEFu8; 16]);
}
}