#![allow(dead_code)]
use crate::error::{EncryptedError, Result};
use crate::security::primitives::{md5, rc4, sha256, sha384, sha512};
use crate::{Object, ObjectRef};
use aes::{Aes128, Aes256};
use cbc::cipher::{block_padding::NoPadding, BlockDecryptMut, BlockEncryptMut, KeyIvInit};
use cbc::{Decryptor, Encryptor};
pub(crate) const PASSWORD_PADDING: [u8; 32] = [
0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, 0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08,
0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80, 0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A,
];
pub(crate) struct StandardHandlerInputs<'a> {
pub v: i64,
pub r: i64,
pub length_bits: i64,
pub p: i32,
pub id0: &'a [u8],
pub u: &'a [u8; 32],
pub o: &'a [u8; 32],
pub encrypt_metadata: bool,
}
pub(crate) struct StandardHandlerR5Inputs<'a> {
pub u: &'a [u8; 48],
pub o: &'a [u8; 48],
pub ue: &'a [u8; 32],
pub oe: &'a [u8; 32],
}
fn pad_password(password: &[u8]) -> [u8; 32] {
let mut out = [0u8; 32];
let pw_len = password.len().min(32);
out[..pw_len].copy_from_slice(&password[..pw_len]);
if pw_len < 32 {
let pad_needed = 32 - pw_len;
out[pw_len..].copy_from_slice(&PASSWORD_PADDING[..pad_needed]);
}
out
}
fn validate_inputs(inputs: &StandardHandlerInputs<'_>) -> Result<usize> {
if inputs.v != 1 && inputs.v != 2 {
return Err(EncryptedError::UnsupportedHandler {
filter: "Standard".into(),
v: inputs.v,
r: inputs.r,
cfm: None,
}
.into());
}
if inputs.r != 2 && inputs.r != 3 {
return Err(EncryptedError::UnsupportedHandler {
filter: "Standard".into(),
v: inputs.v,
r: inputs.r,
cfm: None,
}
.into());
}
if inputs.v == 1 && (inputs.r != 2 || inputs.length_bits != 40) {
return Err(EncryptedError::UnsupportedHandler {
filter: "Standard".into(),
v: inputs.v,
r: inputs.r,
cfm: None,
}
.into());
}
if inputs.r == 2 && inputs.length_bits != 40 {
return Err(EncryptedError::UnsupportedHandler {
filter: "Standard".into(),
v: inputs.v,
r: inputs.r,
cfm: None,
}
.into());
}
if inputs.length_bits < 40 || inputs.length_bits > 128 || inputs.length_bits % 8 != 0 {
return Err(EncryptedError::Malformed {
reason: format!(
"/Length {} is invalid; must be a multiple of 8 between 40 and 128",
inputs.length_bits
),
}
.into());
}
Ok((inputs.length_bits / 8) as usize)
}
fn validate_v4_inputs(inputs: &StandardHandlerInputs<'_>) -> Result<usize> {
if inputs.v != 4 || inputs.r != 4 || inputs.length_bits != 128 {
return Err(EncryptedError::UnsupportedHandler {
filter: "Standard".into(),
v: inputs.v,
r: inputs.r,
cfm: None,
}
.into());
}
Ok(16)
}
fn r5_salted_hash(password: &[u8], salt: &[u8], extra: &[u8]) -> [u8; 32] {
let password = &password[..password.len().min(127)];
let mut input = Vec::with_capacity(password.len() + salt.len() + extra.len());
input.extend_from_slice(password);
input.extend_from_slice(salt);
input.extend_from_slice(extra);
sha256(&input)
}
fn aes256_cbc_zero_iv_unwrap(encrypted_key: &[u8; 32], aes_key: &[u8; 32]) -> Result<Vec<u8>> {
let iv = [0u8; 16];
let mut ciphertext = encrypted_key.to_vec();
let dec = <Decryptor<Aes256> as KeyIvInit>::new(aes_key.into(), (&iv).into());
dec.decrypt_padded_mut::<NoPadding>(&mut ciphertext)
.map_err(|_| EncryptedError::Malformed {
reason: "invalid V=5 encrypted file-key entry".into(),
})?;
Ok(ciphertext)
}
fn decrypt_r5_file_key(
password: &[u8],
entry: &[u8; 48],
encrypted_key: &[u8; 32],
extra: &[u8],
) -> Result<Vec<u8>> {
let validation_salt = &entry[32..40];
let key_salt = &entry[40..48];
let validation_hash = r5_salted_hash(password, validation_salt, extra);
if validation_hash[..] != entry[..32] {
return Err(EncryptedError::BadPassword.into());
}
let aes_key = r5_salted_hash(password, key_salt, extra);
aes256_cbc_zero_iv_unwrap(encrypted_key, &aes_key)
}
fn r6_password_hash(password: &[u8], salt: &[u8], extra: &[u8]) -> [u8; 32] {
let password = &password[..password.len().min(127)];
let mut input = Vec::with_capacity(password.len() + salt.len() + extra.len());
input.extend_from_slice(password);
input.extend_from_slice(salt);
input.extend_from_slice(extra);
let mut key = sha256(&input).to_vec();
let mut round_number = 0usize;
loop {
round_number += 1;
let mut k1 = Vec::with_capacity(password.len() + key.len() + extra.len());
k1.extend_from_slice(password);
k1.extend_from_slice(&key);
k1.extend_from_slice(extra);
let mut e = Vec::with_capacity(k1.len() * 64);
for _ in 0..64 {
e.extend_from_slice(&k1);
}
let mut aes_key = [0u8; 16];
aes_key.copy_from_slice(&key[..16]);
let mut iv = [0u8; 16];
iv.copy_from_slice(&key[16..32]);
let enc = <Encryptor<Aes128> as KeyIvInit>::new((&aes_key).into(), (&iv).into());
enc.encrypt_padded_mut::<NoPadding>(&mut e, k1.len() * 64)
.expect("R=6 hash input repeated 64 times is block-aligned");
let e_mod_3 = e[..16]
.iter()
.fold(0u16, |acc, byte| acc + u16::from(*byte))
% 3;
key = match e_mod_3 {
0 => sha256(&e).to_vec(),
1 => sha384(&e).to_vec(),
_ => sha512(&e).to_vec(),
};
if round_number >= 64
&& usize::from(*e.last().expect("R=6 E is non-empty")) <= round_number - 32
{
let mut out = [0u8; 32];
out.copy_from_slice(&key[..32]);
return out;
}
}
}
fn decrypt_r6_file_key(
password: &[u8],
entry: &[u8; 48],
encrypted_key: &[u8; 32],
extra: &[u8],
) -> Result<Vec<u8>> {
let validation_salt = &entry[32..40];
let key_salt = &entry[40..48];
let validation_hash = r6_password_hash(password, validation_salt, extra);
if validation_hash[..] != entry[..32] {
return Err(EncryptedError::BadPassword.into());
}
let aes_key = r6_password_hash(password, key_salt, extra);
aes256_cbc_zero_iv_unwrap(encrypted_key, &aes_key)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum CryptFilterMethod {
V2,
AesV2,
Identity,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct CryptFilter {
pub name: String,
pub cfm: CryptFilterMethod,
pub length_bits: Option<i64>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum CryptFilterRef<'a> {
Identity,
Named(&'a CryptFilter),
}
#[derive(Debug, Clone)]
pub(crate) struct V4UseSiteSelectors {
pub stm_f: Option<String>,
pub str_f: Option<String>,
pub eff: Option<String>,
}
impl V4UseSiteSelectors {
pub(crate) fn eff_or_stm(&self) -> Option<&str> {
self.eff.as_deref().or(self.stm_f.as_deref())
}
}
pub(crate) fn compute_file_key(
password: &[u8],
inputs: &StandardHandlerInputs<'_>,
) -> Result<Vec<u8>> {
let n = validate_inputs(inputs)?;
let padded = pad_password(password);
let p_le = inputs.p.to_le_bytes();
let mut md5_input = Vec::with_capacity(32 + 32 + 4 + inputs.id0.len() + 4);
md5_input.extend_from_slice(&padded);
md5_input.extend_from_slice(inputs.o);
md5_input.extend_from_slice(&p_le);
md5_input.extend_from_slice(inputs.id0);
if inputs.r >= 4 && !inputs.encrypt_metadata {
md5_input.extend_from_slice(&[0xFF, 0xFF, 0xFF, 0xFF]);
}
let mut digest = md5(&md5_input);
if inputs.r >= 3 {
for _ in 0..50 {
digest = md5(&digest[..n]);
}
}
Ok(digest[..n].to_vec())
}
pub(crate) fn compute_file_key_v4(
password: &[u8],
inputs: &StandardHandlerInputs<'_>,
) -> Result<Vec<u8>> {
let _n = validate_v4_inputs(inputs)?;
let n = 16usize; let padded = pad_password(password);
let p_le = inputs.p.to_le_bytes();
let mut md5_input = Vec::with_capacity(32 + 32 + 4 + inputs.id0.len() + 4);
md5_input.extend_from_slice(&padded);
md5_input.extend_from_slice(inputs.o);
md5_input.extend_from_slice(&p_le);
md5_input.extend_from_slice(inputs.id0);
if !inputs.encrypt_metadata {
md5_input.extend_from_slice(&[0xFF, 0xFF, 0xFF, 0xFF]);
}
let mut digest = md5(&md5_input);
for _ in 0..50 {
digest = md5(&digest[..n]);
}
Ok(digest[..n].to_vec())
}
pub(crate) fn check_user_password_r5(
password: &[u8],
inputs: &StandardHandlerR5Inputs<'_>,
) -> Result<Vec<u8>> {
decrypt_r5_file_key(password, inputs.u, inputs.ue, &[])
}
pub(crate) fn check_owner_password_r5(
password: &[u8],
inputs: &StandardHandlerR5Inputs<'_>,
) -> Result<Vec<u8>> {
decrypt_r5_file_key(password, inputs.o, inputs.oe, inputs.u)
}
pub(crate) fn check_user_password_r6(
password: &[u8],
inputs: &StandardHandlerR5Inputs<'_>,
) -> Result<Vec<u8>> {
decrypt_r6_file_key(password, inputs.u, inputs.ue, &[])
}
pub(crate) fn check_owner_password_r6(
password: &[u8],
inputs: &StandardHandlerR5Inputs<'_>,
) -> Result<Vec<u8>> {
decrypt_r6_file_key(password, inputs.o, inputs.oe, inputs.u)
}
pub(crate) fn select_crypt_filter<'a>(
cf_table: &'a std::collections::HashMap<String, CryptFilter>,
name: Option<&str>,
) -> Result<CryptFilterRef<'a>> {
match name {
None | Some("Identity") => Ok(CryptFilterRef::Identity),
Some(n) => match cf_table.get(n) {
Some(cf) => Ok(CryptFilterRef::Named(cf)),
None => Err(EncryptedError::Malformed {
reason: format!("/CF entry '{}' not found", n),
}
.into()),
},
}
}
pub(crate) fn cfm_to_object_key_alg(cfm: CryptFilterMethod) -> Option<ObjectKeyAlg> {
match cfm {
CryptFilterMethod::V2 => Some(ObjectKeyAlg::Rc4),
CryptFilterMethod::AesV2 => Some(ObjectKeyAlg::Aes),
CryptFilterMethod::Identity => None,
}
}
pub(crate) fn check_user_password(
password: &[u8],
inputs: &StandardHandlerInputs<'_>,
) -> Result<Vec<u8>> {
let file_key = compute_file_key(password, inputs)?;
if inputs.r == 2 {
let mut encrypted = PASSWORD_PADDING;
rc4(&file_key, &mut encrypted)?;
if encrypted[..] != inputs.u[..] {
return Err(EncryptedError::BadPassword.into());
}
} else {
let mut md5_input = Vec::with_capacity(32 + inputs.id0.len());
md5_input.extend_from_slice(&PASSWORD_PADDING);
md5_input.extend_from_slice(inputs.id0);
let digest = md5(&md5_input);
let mut data = digest;
rc4(&file_key, &mut data)?;
for i in 1u8..=19 {
let xor_key: Vec<u8> = file_key.iter().map(|&b| b ^ i).collect();
rc4(&xor_key, &mut data)?;
}
if data[..] != inputs.u[..16] {
return Err(EncryptedError::BadPassword.into());
}
}
Ok(file_key)
}
pub(crate) fn check_user_password_v4(
password: &[u8],
inputs: &StandardHandlerInputs<'_>,
) -> Result<Vec<u8>> {
let file_key = compute_file_key_v4(password, inputs)?;
let mut md5_input = Vec::with_capacity(32 + inputs.id0.len());
md5_input.extend_from_slice(&PASSWORD_PADDING);
md5_input.extend_from_slice(inputs.id0);
let digest = md5(&md5_input);
let mut data = digest;
rc4(&file_key, &mut data)?;
for i in 1u8..=19 {
let xor_key: Vec<u8> = file_key.iter().map(|&b| b ^ i).collect();
rc4(&xor_key, &mut data)?;
}
if data[..] != inputs.u[..16] {
return Err(EncryptedError::BadPassword.into());
}
Ok(file_key)
}
pub(crate) fn check_owner_password(
password: &[u8],
inputs: &StandardHandlerInputs<'_>,
) -> Result<Vec<u8>> {
let n = validate_inputs(inputs)?;
let padded_owner = pad_password(password);
let mut digest = md5(&padded_owner);
if inputs.r >= 3 {
for _ in 0..50 {
digest = md5(&digest);
}
}
let rc4_key = &digest[..n];
let mut candidate = *inputs.o;
if inputs.r == 2 {
rc4(rc4_key, &mut candidate)?;
} else {
for i in (0u8..=19).rev() {
let xor_key: Vec<u8> = rc4_key.iter().map(|&b| b ^ i).collect();
rc4(&xor_key, &mut candidate)?;
}
}
check_user_password(&candidate, inputs)
}
pub(crate) fn check_owner_password_v4(
password: &[u8],
inputs: &StandardHandlerInputs<'_>,
) -> Result<Vec<u8>> {
let n = validate_v4_inputs(inputs)?;
let padded_owner = pad_password(password);
let mut digest = md5(&padded_owner);
for _ in 0..50 {
digest = md5(&digest);
}
let rc4_key = &digest[..n];
let mut candidate = *inputs.o;
for i in (0u8..=19).rev() {
let xor_key: Vec<u8> = rc4_key.iter().map(|&b| b ^ i).collect();
rc4(&xor_key, &mut candidate)?;
}
check_user_password_v4(&candidate, inputs)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ObjectKeyAlg {
Rc4,
Aes,
}
#[derive(Debug, Clone, Copy)]
pub(crate) enum StringCipher<'a> {
Identity,
Rc4 { key: &'a [u8] },
Aes128 { key: &'a [u8; 16] },
Aes256 { key: &'a [u8; 32] },
}
pub(crate) fn decrypt_strings_in_object(
object_ref: ObjectRef,
object: &mut Object,
cipher: StringCipher<'_>,
encrypt_ref: Option<ObjectRef>,
) -> Result<()> {
if Some(object_ref) == encrypt_ref {
return Ok(());
}
decrypt_strings_in_value(object, cipher)
}
fn decrypt_strings_in_value(object: &mut Object, cipher: StringCipher<'_>) -> Result<()> {
match object {
Object::String(bytes) => decrypt_cipher_bytes(bytes, cipher),
Object::Array(values) => {
for value in values {
decrypt_strings_in_value(value, cipher)?;
}
Ok(())
}
Object::Dictionary(dict) => {
for value in dict.values_mut() {
decrypt_strings_in_value(value, cipher)?;
}
Ok(())
}
Object::Stream(stream) => {
for value in stream.dict.values_mut() {
decrypt_strings_in_value(value, cipher)?;
}
Ok(())
}
Object::Null
| Object::Boolean(_)
| Object::Integer(_)
| Object::Real(_)
| Object::Name(_)
| Object::Reference(_) => Ok(()),
}
}
pub(crate) fn decrypt_cipher_bytes(bytes: &mut Vec<u8>, cipher: StringCipher<'_>) -> Result<()> {
match cipher {
StringCipher::Identity => Ok(()),
StringCipher::Rc4 { key } => rc4(key, bytes).map_err(Into::into),
StringCipher::Aes128 { key } => {
let Some((iv, ciphertext)) = bytes.split_first_chunk::<16>() else {
return Err(EncryptedError::Malformed {
reason: "AES string is missing its 16-byte IV".into(),
}
.into());
};
let mut decrypted = ciphertext.to_vec();
crate::security::primitives::aes128_cbc_decrypt(key, iv, &mut decrypted)?;
*bytes = decrypted;
Ok(())
}
StringCipher::Aes256 { key } => {
let Some((iv, ciphertext)) = bytes.split_first_chunk::<16>() else {
return Err(EncryptedError::Malformed {
reason: "AES string is missing its 16-byte IV".into(),
}
.into());
};
let mut decrypted = ciphertext.to_vec();
crate::security::primitives::aes256_cbc_decrypt(key, iv, &mut decrypted)?;
*bytes = decrypted;
Ok(())
}
}
}
pub(crate) fn per_object_key(file_key: &[u8], obj: u32, gen: u32, alg: ObjectKeyAlg) -> Vec<u8> {
let n = file_key.len();
let mut md5_input = Vec::with_capacity(n + 9);
md5_input.extend_from_slice(file_key);
let obj_le = obj.to_le_bytes();
md5_input.extend_from_slice(&obj_le[..3]);
let gen_le = gen.to_le_bytes();
md5_input.extend_from_slice(&gen_le[..2]);
if alg == ObjectKeyAlg::Aes {
md5_input.extend_from_slice(&[0x73, 0x41, 0x6C, 0x54]);
}
let digest = md5(&md5_input);
let out_len = (n + 5).min(16);
digest[..out_len].to_vec()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{Dictionary, Object, ObjectRef, Stream};
fn from_hex(s: &str) -> Vec<u8> {
assert_eq!(s.len() % 2, 0, "hex string length must be even");
(0..s.len())
.step_by(2)
.map(|i| u8::from_str_radix(&s[i..i + 2], 16).expect("invalid hex digit"))
.collect()
}
fn hex32(s: &str) -> [u8; 32] {
let v = from_hex(s);
assert_eq!(v.len(), 32, "expected 32-byte hex string");
let mut out = [0u8; 32];
out.copy_from_slice(&v);
out
}
fn hex48(s: &str) -> [u8; 48] {
let v = from_hex(s);
assert_eq!(v.len(), 48, "expected 48-byte hex string");
let mut out = [0u8; 48];
out.copy_from_slice(&v);
out
}
fn aes128_string(key: &[u8; 16], iv: &[u8; 16], plaintext: &[u8]) -> Vec<u8> {
let enc = <Encryptor<Aes128> as KeyIvInit>::new(key.into(), iv.into());
let mut buf = plaintext.to_vec();
let msg_len = buf.len();
buf.resize(msg_len + 16, 0);
let ciphertext = enc
.encrypt_padded_mut::<cbc::cipher::block_padding::Pkcs7>(&mut buf, msg_len)
.unwrap();
let mut out = iv.to_vec();
out.extend_from_slice(ciphertext);
out
}
fn aes256_string(key: &[u8; 32], iv: &[u8; 16], plaintext: &[u8]) -> Vec<u8> {
let enc = <Encryptor<Aes256> as KeyIvInit>::new(key.into(), iv.into());
let mut buf = plaintext.to_vec();
let msg_len = buf.len();
buf.resize(msg_len + 16, 0);
let ciphertext = enc
.encrypt_padded_mut::<cbc::cipher::block_padding::Pkcs7>(&mut buf, msg_len)
.unwrap();
let mut out = iv.to_vec();
out.extend_from_slice(ciphertext);
out
}
#[test]
fn decrypt_strings_descends_into_nested_arrays_dicts_and_stream_dicts() {
let key = b"Key";
let mut nested = b"nested".to_vec();
rc4(key, &mut nested).unwrap();
let mut in_dict = b"in dict".to_vec();
rc4(key, &mut in_dict).unwrap();
let mut in_stream_dict = b"in stream dict".to_vec();
rc4(key, &mut in_stream_dict).unwrap();
let mut inner = Dictionary::new();
inner.insert("S", Object::String(in_dict));
let mut stream_dict = Dictionary::new();
stream_dict.insert("Title", Object::String(in_stream_dict));
let mut object = Object::Array(vec![
Object::String(nested),
Object::Dictionary(inner),
Object::Stream(Stream::new(
stream_dict,
b"encrypted stream bytes stay raw".to_vec(),
)),
]);
decrypt_strings_in_object(
ObjectRef::new(7, 0),
&mut object,
StringCipher::Rc4 { key },
None,
)
.unwrap();
let Object::Array(values) = object else {
panic!("expected array");
};
assert_eq!(values[0], Object::String(b"nested".to_vec()));
let Object::Dictionary(dict) = &values[1] else {
panic!("expected dictionary");
};
assert_eq!(dict.get("S"), Some(&Object::String(b"in dict".to_vec())));
let Object::Stream(stream) = &values[2] else {
panic!("expected stream");
};
assert_eq!(
stream.dict.get("Title"),
Some(&Object::String(b"in stream dict".to_vec()))
);
assert_eq!(stream.data, b"encrypted stream bytes stay raw");
}
#[test]
fn decrypt_strings_skips_encrypt_object_subtree() {
let key = b"Key";
let mut secret = b"must stay encrypted".to_vec();
rc4(key, &mut secret).unwrap();
let encrypted = secret.clone();
let mut dict = Dictionary::new();
dict.insert("O", Object::String(secret));
let mut object = Object::Dictionary(dict);
decrypt_strings_in_object(
ObjectRef::new(5, 0),
&mut object,
StringCipher::Rc4 { key },
Some(ObjectRef::new(5, 0)),
)
.unwrap();
let Object::Dictionary(dict) = object else {
panic!("expected dictionary");
};
assert_eq!(dict.get("O"), Some(&Object::String(encrypted)));
}
#[test]
fn decrypt_strings_handles_rc4_aes128_and_v5_aes256_string_bytes() {
let rc4_key = b"Key";
let mut rc4_string = b"Plaintext".to_vec();
rc4(rc4_key, &mut rc4_string).unwrap();
let mut rc4_object = Object::String(rc4_string);
decrypt_strings_in_object(
ObjectRef::new(10, 0),
&mut rc4_object,
StringCipher::Rc4 { key: rc4_key },
None,
)
.unwrap();
assert_eq!(rc4_object, Object::String(b"Plaintext".to_vec()));
let aes128_key = [0x11; 16];
let aes128_iv = [0x22; 16];
let mut aes128_object = Object::String(aes128_string(&aes128_key, &aes128_iv, b"AES V2"));
decrypt_strings_in_object(
ObjectRef::new(11, 0),
&mut aes128_object,
StringCipher::Aes128 { key: &aes128_key },
None,
)
.unwrap();
assert_eq!(aes128_object, Object::String(b"AES V2".to_vec()));
let aes256_key = [0x33; 32];
let aes256_iv = [0x44; 16];
let mut aes256_object = Object::String(aes256_string(&aes256_key, &aes256_iv, b"AES V5"));
decrypt_strings_in_object(
ObjectRef::new(12, 0),
&mut aes256_object,
StringCipher::Aes256 { key: &aes256_key },
None,
)
.unwrap();
assert_eq!(aes256_object, Object::String(b"AES V5".to_vec()));
}
#[test]
fn pad_password_empty() {
let padded = pad_password(b"");
assert_eq!(padded, PASSWORD_PADDING);
}
#[test]
fn pad_password_short() {
let padded = pad_password(b"abc");
assert_eq!(&padded[..3], b"abc");
assert_eq!(&padded[3..], &PASSWORD_PADDING[..29]);
}
#[test]
fn pad_password_exactly_32() {
let pw = [0xAAu8; 32];
let padded = pad_password(&pw);
assert_eq!(padded, pw);
}
#[test]
fn pad_password_too_long() {
let pw = [0xBBu8; 64];
let padded = pad_password(&pw);
assert_eq!(padded, [0xBBu8; 32]);
}
#[test]
fn password_padding_constant() {
assert_eq!(PASSWORD_PADDING[0], 0x28);
assert_eq!(PASSWORD_PADDING[1], 0xBF);
assert_eq!(PASSWORD_PADDING[31], 0x7A);
assert_eq!(PASSWORD_PADDING.len(), 32);
}
const ID0: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
const P: i32 = -3904;
const TC1_O: &str = "2055c756c72e1ad702608e8196acad447ad32d17cff583235f6dd15fed7dab67";
const TC1_U: &str = "d6f15ab11e0082d3e78e9bdd4aa356df7951447b42d3ec90675f8fed125839a0";
const TC1_KEY: &str = "f784f642f1";
const TC2_O: &str = "36451bd39d753b7c1d10922c28e6665aa4f3353fb0348b536893e3b1db5c579b";
const TC2_U: &str = "09be6cfeca2ef2692f8000d3ca083f2d00000000000000000000000000000000";
const TC2_KEY: &str = "b452d605afa4725e7ff5cef2d62f9871";
const TC3_O: &str = "94e8094419662a774442fb072e3d9f19e9d130ec09a4d0061e78fe920f7ab62f";
const TC3_U: &str = "13f520c882d052bf57b416b747c13979bded7ea31240fe41928852aca3894c49";
const TC3_KEY: &str = "7fca5cfcc5";
const TC4_O: &str = "6ef3764ad26cfe3cab68706fc26c9413d80d47b053374529a32e1405eeba42c1";
const TC4_U: &str = "89ee68e273e9403df45997e914885f0900000000000000000000000000000000";
const TC4_KEY: &str = "1b7300df56bf77f869b3bf5345aad08c";
#[test]
fn alg2_v1_r2_empty_password() {
let o = hex32(TC1_O);
let u = hex32(TC1_U);
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 40,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = compute_file_key(b"", &inputs).unwrap();
assert_eq!(key, from_hex(TC1_KEY), "TC1: wrong file key");
assert_eq!(key.len(), 5);
}
#[test]
fn alg2_v2_r3_empty_password() {
let o = hex32(TC2_O);
let u = hex32(TC2_U);
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = compute_file_key(b"", &inputs).unwrap();
assert_eq!(key, from_hex(TC2_KEY), "TC2: wrong file key");
assert_eq!(key.len(), 16);
}
#[test]
fn alg2_v1_r2_with_password() {
let o = hex32(TC3_O);
let u = hex32(TC3_U);
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 40,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = compute_file_key(b"user", &inputs).unwrap();
assert_eq!(key, from_hex(TC3_KEY), "TC3: wrong file key");
}
#[test]
fn alg2_v2_r3_with_password() {
let o = hex32(TC4_O);
let u = hex32(TC4_U);
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = compute_file_key(b"secret", &inputs).unwrap();
assert_eq!(key, from_hex(TC4_KEY), "TC4: wrong file key");
}
#[test]
fn alg6_v1_r2_correct_user_password() {
let o = hex32(TC1_O);
let u = hex32(TC1_U);
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 40,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = check_user_password(b"", &inputs).unwrap();
assert_eq!(
key,
from_hex(TC1_KEY),
"TC1 user: wrong key returned on success"
);
}
#[test]
fn alg6_v1_r2_wrong_user_password() {
let o = hex32(TC1_O);
let u = hex32(TC1_U);
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 40,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = check_user_password(b"wrongpassword", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::BadPassword)
),
"expected BadPassword, got: {err:?}"
);
}
#[test]
fn alg6_v2_r3_correct_user_password() {
let o = hex32(TC2_O);
let u = hex32(TC2_U);
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = check_user_password(b"", &inputs).unwrap();
assert_eq!(
key,
from_hex(TC2_KEY),
"TC2 user: wrong key returned on success"
);
}
#[test]
fn alg6_v2_r3_wrong_user_password() {
let o = hex32(TC2_O);
let u = hex32(TC2_U);
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = check_user_password(b"notthepassword", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::BadPassword)
),
"expected BadPassword, got: {err:?}"
);
}
#[test]
fn alg6_v1_r2_named_user_password() {
let o = hex32(TC3_O);
let u = hex32(TC3_U);
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 40,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = check_user_password(b"user", &inputs).unwrap();
assert_eq!(key, from_hex(TC3_KEY));
}
#[test]
fn alg6_v2_r3_named_user_password() {
let o = hex32(TC4_O);
let u = hex32(TC4_U);
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = check_user_password(b"secret", &inputs).unwrap();
assert_eq!(key, from_hex(TC4_KEY));
}
#[test]
fn alg7_v1_r2_correct_owner_password() {
let o = hex32(TC1_O);
let u = hex32(TC1_U);
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 40,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = check_owner_password(b"", &inputs).unwrap();
assert_eq!(
key,
from_hex(TC1_KEY),
"TC1 owner: wrong key returned on success"
);
}
#[test]
fn alg7_v1_r2_wrong_owner_password() {
let o = hex32(TC1_O);
let u = hex32(TC1_U);
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 40,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = check_owner_password(b"wrongowner", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::BadPassword)
),
"expected BadPassword, got: {err:?}"
);
}
#[test]
fn alg7_v2_r3_correct_owner_password() {
let o = hex32(TC2_O);
let u = hex32(TC2_U);
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = check_owner_password(b"", &inputs).unwrap();
assert_eq!(
key,
from_hex(TC2_KEY),
"TC2 owner: wrong key returned on success"
);
}
#[test]
fn alg7_v2_r3_wrong_owner_password() {
let o = hex32(TC2_O);
let u = hex32(TC2_U);
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = check_owner_password(b"badowner", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::BadPassword)
),
"expected BadPassword, got: {err:?}"
);
}
#[test]
fn alg7_v1_r2_named_owner_password() {
let o = hex32(TC3_O);
let u = hex32(TC3_U);
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 40,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = check_owner_password(b"owner", &inputs).unwrap();
assert_eq!(key, from_hex(TC3_KEY), "TC3 owner: wrong key");
}
#[test]
fn alg7_v2_r3_named_owner_password() {
let o = hex32(TC4_O);
let u = hex32(TC4_U);
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = check_owner_password(b"ownerpass", &inputs).unwrap();
assert_eq!(key, from_hex(TC4_KEY), "TC4 owner: wrong key");
}
#[test]
fn invalid_v_returns_unsupported() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 3, r: 3,
length_bits: 128,
p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(
crate::error::EncryptedError::UnsupportedHandler { .. }
)
),
"expected UnsupportedHandler, got: {err:?}"
);
}
#[test]
fn invalid_length_returns_malformed() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 33, p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::Malformed { .. })
),
"expected Malformed, got: {err:?}"
);
}
#[test]
fn length_out_of_range_returns_malformed() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 2,
r: 3,
length_bits: 256, p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::Malformed { .. })
),
"expected Malformed for length 256, got: {err:?}"
);
}
#[test]
fn v1_with_wrong_r_returns_unsupported() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 1,
r: 3, length_bits: 40,
p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(
crate::error::EncryptedError::UnsupportedHandler { .. }
)
),
"expected UnsupportedHandler for V=1/R=3, got: {err:?}"
);
}
#[test]
fn v1_with_wrong_length_returns_unsupported() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 1,
r: 2,
length_bits: 128, p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(
crate::error::EncryptedError::UnsupportedHandler { .. }
)
),
"expected UnsupportedHandler for V=1/Length=128, got: {err:?}"
);
}
#[test]
fn alg3_owner_key_iteration_uses_full_digest_for_short_keys() {
let seed = pad_password(b"");
let mut full = md5(&seed);
let mut truncated = full;
for _ in 0..50 {
full = md5(&full);
truncated = md5(&truncated[..5]);
}
assert_ne!(
&full[..5],
&truncated[..5],
"owner-key 50× loop must feed full digest back, not digest[..n]; \
if these match by accident, the regression guard is ineffective"
);
}
#[test]
fn v2_r2_with_long_length_returns_unsupported() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 2,
r: 2,
length_bits: 128, p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(
crate::error::EncryptedError::UnsupportedHandler { .. }
)
),
"expected UnsupportedHandler for V=2/R=2/Length=128, got: {err:?}"
);
}
#[test]
fn r4_returns_unsupported() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 2,
r: 4, length_bits: 128,
p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(
crate::error::EncryptedError::UnsupportedHandler { .. }
)
),
"expected UnsupportedHandler for R=4, got: {err:?}"
);
}
#[test]
fn alg1_rc4_n5_obj1_gen0() {
let file_key = [0x01u8; 5];
let got = per_object_key(&file_key, 1, 0, ObjectKeyAlg::Rc4);
assert_eq!(got, from_hex("95803393a09e46bab004"), "TC-A1-1 mismatch");
assert_eq!(got.len(), 10);
}
#[test]
fn alg1_rc4_n16_obj12345_gen0() {
let file_key = [0xABu8; 16];
let got = per_object_key(&file_key, 12345, 0, ObjectKeyAlg::Rc4);
assert_eq!(
got,
from_hex("dbb723a2f63dcced70058cf3059453be"),
"TC-A1-2 mismatch"
);
assert_eq!(got.len(), 16);
}
#[test]
fn alg1_aes_n16_obj10_gen0() {
let file_key = [0x42u8; 16];
let got = per_object_key(&file_key, 10, 0, ObjectKeyAlg::Aes);
assert_eq!(
got,
from_hex("4c7ad328a68a6acb8b81f68c86756b7a"),
"TC-A1-3 mismatch"
);
assert_eq!(got.len(), 16);
}
#[test]
fn alg1_aes_n5_obj10_gen0() {
let file_key = [0x42u8; 5];
let got = per_object_key(&file_key, 10, 0, ObjectKeyAlg::Aes);
assert_eq!(got, from_hex("e41cdfa1db13fbaeed00"), "TC-A1-4 mismatch");
assert_eq!(got.len(), 10);
}
#[test]
fn alg1_rc4_boundary_max_obj_gen() {
let file_key = [0x00u8; 8];
let got = per_object_key(&file_key, 0xFFFF_FFFF, 0xFFFF_FFFF, ObjectKeyAlg::Rc4);
assert_eq!(
got,
from_hex("f828745fe049a5667e00a34f50"),
"TC-A1-5 mismatch"
);
assert_eq!(got.len(), 13);
}
#[test]
fn alg1_rc4_n14_cap_at_16() {
let file_key = [0x55u8; 14];
let got = per_object_key(&file_key, 5, 2, ObjectKeyAlg::Rc4);
assert_eq!(
got,
from_hex("5e17e430553c51ee690d0d37ddc6b33e"),
"TC-A1-6 mismatch"
);
assert_eq!(got.len(), 16, "output must be capped at 16");
}
#[test]
fn compute_file_key_v4_empty_password_encrypt_metadata_true() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 4,
r: 4,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = compute_file_key_v4(b"", &inputs).unwrap();
assert_eq!(
key,
from_hex("b6bfe1cc3cede324f6d00115f6f22801"),
"TC5: wrong file key for V=4 R=4 empty pw encrypt_metadata=true"
);
assert_eq!(key.len(), 16);
}
#[test]
fn compute_file_key_v4_empty_password_encrypt_metadata_false() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 4,
r: 4,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: false,
};
let key = compute_file_key_v4(b"", &inputs).unwrap();
assert_eq!(
key,
from_hex("08a258e623f388621234efcf1e86489d"),
"TC6: wrong file key for V=4 R=4 empty pw encrypt_metadata=false"
);
assert_eq!(key.len(), 16);
assert_ne!(
key,
from_hex("b6bfe1cc3cede324f6d00115f6f22801"),
"TC6: encrypt_metadata=false must produce a different key than encrypt_metadata=true"
);
}
#[test]
fn compute_file_key_v4_with_password() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 4,
r: 4,
length_bits: 128,
p: P,
id0: &ID0,
u: &u,
o: &o,
encrypt_metadata: true,
};
let key = compute_file_key_v4(b"secret", &inputs).unwrap();
assert_eq!(
key,
from_hex("6e3b6cc29b8afaf34a03d43a08d67bbb"),
"TC7: wrong file key for V=4 R=4 pw='secret'"
);
}
#[test]
fn compute_file_key_v4_rejects_r3() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 4,
r: 3, length_bits: 128,
p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key_v4(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(
crate::error::EncryptedError::UnsupportedHandler { .. }
)
),
"expected UnsupportedHandler for V=4/R=3, got: {err:?}"
);
}
#[test]
fn compute_file_key_v4_rejects_wrong_length() {
let o = [0u8; 32];
let u = [0u8; 32];
let inputs = StandardHandlerInputs {
v: 4,
r: 4,
length_bits: 40, p: -1,
id0: &[],
u: &u,
o: &o,
encrypt_metadata: true,
};
let err = compute_file_key_v4(b"", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(
crate::error::EncryptedError::UnsupportedHandler { .. }
)
),
"expected UnsupportedHandler for V=4/R=4/Length=40, got: {err:?}"
);
}
struct R5Fixture {
u: [u8; 48],
o: [u8; 48],
ue: [u8; 32],
oe: [u8; 32],
}
impl R5Fixture {
fn inputs(&self) -> StandardHandlerR5Inputs<'_> {
StandardHandlerR5Inputs {
u: &self.u,
o: &self.o,
ue: &self.ue,
oe: &self.oe,
}
}
}
fn r5_fixture() -> R5Fixture {
R5Fixture {
u: hex48(
"97e87734dfa9d2a69a7e7326ce3fabd944a3e718602d1bc4171df8a2736c6cbe\
00112233445566778899aabbccddeeff",
),
o: hex48(
"d95e9aa87833363eccce3e1ba1161b87fcc36c3a2e144b199ddd543db3ad480a\
102132435465768798a9bacbdcedfe0f",
),
ue: hex32("08030d6f64d3cf8bc22a9ec592a44da03b019659444bbb14111ea6f021b3bdac"),
oe: hex32("f8e5af968015e82307b0f2c725cb2641a22dd792ec33c4b104fd5d685f2bba41"),
}
}
fn r5_long_password_fixture() -> R5Fixture {
R5Fixture {
u: hex48(
"d39d90631a68ed50a791f40f2d19d45959b7caa339c4c16b43e01863732d43ee\
01020304050607081112131415161718",
),
o: [0u8; 48],
ue: hex32("74c028775d1a6223f4c4f12f6bd57c325de66fd8eac481d80f7eb5313354db40"),
oe: [0u8; 32],
}
}
#[test]
fn check_user_password_r5_returns_file_key() {
let fixture = r5_fixture();
let inputs = fixture.inputs();
let file_key = check_user_password_r5(b"userpass", &inputs).unwrap();
assert_eq!(
file_key,
from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
);
}
#[test]
fn check_owner_password_r5_returns_file_key() {
let fixture = r5_fixture();
let inputs = fixture.inputs();
let file_key = check_owner_password_r5(b"ownerpass", &inputs).unwrap();
assert_eq!(
file_key,
from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
);
}
#[test]
fn check_user_password_r5_rejects_wrong_password() {
let fixture = r5_fixture();
let inputs = fixture.inputs();
let err = check_user_password_r5(b"wrong", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::BadPassword)
),
"expected BadPassword for wrong R=5 user password, got: {err:?}"
);
}
#[test]
fn check_user_password_r5_truncates_password_to_127_bytes() {
let fixture = r5_long_password_fixture();
let inputs = fixture.inputs();
let mut password = vec![b'a'; 127];
password.extend_from_slice(b"zzz");
let file_key = check_user_password_r5(&password, &inputs).unwrap();
assert_eq!(
file_key,
from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
);
}
struct R6Fixture {
u: [u8; 48],
o: [u8; 48],
ue: [u8; 32],
oe: [u8; 32],
}
impl R6Fixture {
fn inputs(&self) -> StandardHandlerR5Inputs<'_> {
StandardHandlerR5Inputs {
u: &self.u,
o: &self.o,
ue: &self.ue,
oe: &self.oe,
}
}
}
fn r6_fixture() -> R6Fixture {
R6Fixture {
u: hex48(
"6ce813242d7505a42af6eb24292ac1fe9c8de1a21f598c5205b39d9e9a5ba7bf\
00112233445566778899aabbccddeeff",
),
o: hex48(
"b03bdf6b914364dcdecf182d4cc04bacff9e9a38ea5fd1af31acd59c654495e1\
102132435465768798a9bacbdcedfe0f",
),
ue: hex32("4ca56fc060201d966373508e0d5970b65f7581d8f6ff46ee6a3755b623b8379b"),
oe: hex32("b2ee22084804dbe76635580e7caeb3ba9069d40184ae4ec16eee7aca91d05936"),
}
}
#[test]
fn r6_password_hash_matches_algorithm_2b_kat() {
let salt = from_hex("0102030405060708");
assert_eq!(
r6_password_hash(b"password", &salt, &[]),
hex32("22d08d1860cb92edcadda1451a4aebb49c1873722bbfca2aef1a7e5f51e69935")
);
}
#[test]
fn r6_password_hash_uses_owner_extra_data() {
let fixture = r6_fixture();
let salt = from_hex("1021324354657687");
assert_eq!(
r6_password_hash(b"ownerpass", &salt, &fixture.u),
hex32("b03bdf6b914364dcdecf182d4cc04bacff9e9a38ea5fd1af31acd59c654495e1")
);
}
#[test]
fn r6_password_hash_truncates_password_to_127_bytes() {
let salt = from_hex("0102030405060708");
let mut password = vec![b'a'; 127];
password.extend_from_slice(b"zzz");
assert_eq!(
r6_password_hash(&password, &salt, b"extra"),
hex32("87d58b9b16c2aacf4cb477fa9b5cb57b4b7f6b34d6cfb051b5b35c92a772e723")
);
}
#[test]
fn check_user_password_r6_returns_file_key() {
let fixture = r6_fixture();
let inputs = fixture.inputs();
let file_key = check_user_password_r6(b"userpass", &inputs).unwrap();
assert_eq!(
file_key,
from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
);
}
#[test]
fn check_owner_password_r6_returns_file_key() {
let fixture = r6_fixture();
let inputs = fixture.inputs();
let file_key = check_owner_password_r6(b"ownerpass", &inputs).unwrap();
assert_eq!(
file_key,
from_hex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
);
}
#[test]
fn check_user_password_r6_rejects_wrong_password() {
let fixture = r6_fixture();
let inputs = fixture.inputs();
let err = check_user_password_r6(b"wrong", &inputs).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::BadPassword)
),
"expected BadPassword for wrong R=6 user password, got: {err:?}"
);
}
fn make_cf_table() -> std::collections::HashMap<String, CryptFilter> {
let mut table = std::collections::HashMap::new();
table.insert(
"StdCF".to_string(),
CryptFilter {
name: "StdCF".to_string(),
cfm: CryptFilterMethod::AesV2,
length_bits: Some(128),
},
);
table.insert(
"RC4CF".to_string(),
CryptFilter {
name: "RC4CF".to_string(),
cfm: CryptFilterMethod::V2,
length_bits: None,
},
);
table
}
#[test]
fn select_crypt_filter_none_is_identity() {
let table = make_cf_table();
let result = select_crypt_filter(&table, None).unwrap();
assert_eq!(result, CryptFilterRef::Identity);
}
#[test]
fn select_crypt_filter_identity_name_is_identity() {
let table = make_cf_table();
let result = select_crypt_filter(&table, Some("Identity")).unwrap();
assert_eq!(result, CryptFilterRef::Identity);
}
#[test]
fn select_crypt_filter_known_name_returns_named() {
let table = make_cf_table();
let result = select_crypt_filter(&table, Some("StdCF")).unwrap();
match result {
CryptFilterRef::Named(cf) => {
assert_eq!(cf.name, "StdCF");
assert_eq!(cf.cfm, CryptFilterMethod::AesV2);
}
CryptFilterRef::Identity => panic!("expected Named, got Identity"),
}
}
#[test]
fn select_crypt_filter_missing_name_returns_malformed() {
let table = make_cf_table();
let err = select_crypt_filter(&table, Some("Missing")).unwrap_err();
assert!(
matches!(
err,
crate::error::Error::Encrypted(crate::error::EncryptedError::Malformed { .. })
),
"expected Malformed for missing CF entry, got: {err:?}"
);
}
#[test]
fn cfm_v2_maps_to_rc4() {
assert_eq!(
cfm_to_object_key_alg(CryptFilterMethod::V2),
Some(ObjectKeyAlg::Rc4)
);
}
#[test]
fn cfm_aesv2_maps_to_aes() {
assert_eq!(
cfm_to_object_key_alg(CryptFilterMethod::AesV2),
Some(ObjectKeyAlg::Aes)
);
}
#[test]
fn cfm_identity_maps_to_none() {
assert_eq!(cfm_to_object_key_alg(CryptFilterMethod::Identity), None);
}
#[test]
fn v4_use_site_selectors_dispatch() {
let table = make_cf_table();
let selectors = V4UseSiteSelectors {
stm_f: Some("StdCF".to_string()),
str_f: None,
eff: Some("Missing".to_string()),
};
let stm = select_crypt_filter(&table, selectors.stm_f.as_deref()).unwrap();
match stm {
CryptFilterRef::Named(cf) => {
assert_eq!(cf.name, "StdCF");
assert_eq!(cf.cfm, CryptFilterMethod::AesV2);
}
CryptFilterRef::Identity => panic!("stm_f: expected Named, got Identity"),
}
let str = select_crypt_filter(&table, selectors.str_f.as_deref()).unwrap();
assert_eq!(
str,
CryptFilterRef::Identity,
"str_f: None must yield Identity"
);
let eff_err = select_crypt_filter(&table, selectors.eff.as_deref()).unwrap_err();
assert!(
matches!(
eff_err,
crate::error::Error::Encrypted(crate::error::EncryptedError::Malformed { .. })
),
"eff: missing name must yield Malformed, got: {eff_err:?}"
);
}
#[test]
fn v4_eff_absent_falls_back_to_stm_f() {
let table = make_cf_table();
let selectors = V4UseSiteSelectors {
stm_f: Some("StdCF".to_string()),
str_f: Some("StdCF".to_string()),
eff: None,
};
let eff_name = selectors.eff_or_stm();
assert_eq!(
eff_name,
Some("StdCF"),
"eff absent must fall back to stm_f"
);
let resolved = select_crypt_filter(&table, eff_name).unwrap();
match resolved {
CryptFilterRef::Named(cf) => {
assert_eq!(cf.name, "StdCF", "EFF fallback must resolve to StdCF entry");
assert_eq!(cf.cfm, CryptFilterMethod::AesV2);
}
CryptFilterRef::Identity => panic!(
"EFF=None with StmF=StdCF must NOT short-circuit to Identity; \
that would leave encrypted embedded files as plaintext"
),
}
}
#[test]
fn v4_eff_and_stm_both_absent_resolve_to_identity() {
let table = make_cf_table();
let selectors = V4UseSiteSelectors {
stm_f: None,
str_f: None,
eff: None,
};
assert_eq!(selectors.eff_or_stm(), None);
let resolved = select_crypt_filter(&table, selectors.eff_or_stm()).unwrap();
assert_eq!(resolved, CryptFilterRef::Identity);
}
#[test]
fn v4_eff_present_overrides_stm_f() {
let selectors = V4UseSiteSelectors {
stm_f: Some("StdCF".to_string()),
str_f: None,
eff: Some("OtherCF".to_string()),
};
assert_eq!(selectors.eff_or_stm(), Some("OtherCF"));
}
}