Skip to main content

sheetkit_core/crypt/
agile.rs

1//! Agile Encryption (Office 2010+).
2//!
3//! This is the modern encryption format for Office documents. It uses
4//! AES-256-CBC for encryption and SHA-512 for key derivation with a
5//! configurable spin count (typically 100,000 iterations).
6
7use crate::error::{Error, Result};
8use zeroize::Zeroizing;
9
10#[cfg(test)]
11use super::EncryptionInfoLimits;
12use super::{CryptBudget, CryptLimits, EncryptionInfoBudget};
13use crate::resource::ResourceOperation;
14
15/// Segment size for Agile Encryption data processing.
16const SEGMENT_SIZE: usize = 4096;
17const PASSWORD_KEY_ENCRYPTOR_URI: &str =
18    "http://schemas.microsoft.com/office/2006/keyEncryptor/password";
19
20#[derive(Clone, Copy, Debug, PartialEq, Eq)]
21enum HashAlgorithm {
22    Sha1,
23    Sha256,
24    Sha384,
25    Sha512,
26}
27
28impl HashAlgorithm {
29    fn parse(value: &str, hash_size: u32) -> Result<Self> {
30        let algorithm = match value.to_ascii_uppercase().replace('-', "").as_str() {
31            "SHA1" => Self::Sha1,
32            "SHA256" => Self::Sha256,
33            "SHA384" => Self::Sha384,
34            "SHA512" => Self::Sha512,
35            _ => {
36                return Err(Error::UnsupportedEncryption(format!(
37                    "hash algorithm {value}"
38                )))
39            }
40        };
41        if hash_size as usize != algorithm.output_size() {
42            return Err(Error::UnsupportedEncryption(format!(
43                "hash size {hash_size} does not match {value}"
44            )));
45        }
46        Ok(algorithm)
47    }
48
49    fn output_size(self) -> usize {
50        match self {
51            Self::Sha1 => 20,
52            Self::Sha256 => 32,
53            Self::Sha384 => 48,
54            Self::Sha512 => 64,
55        }
56    }
57
58    fn digest(self, parts: &[&[u8]]) -> Vec<u8> {
59        use sha1::Digest as _;
60        macro_rules! digest {
61            ($ty:ty) => {{
62                let mut hasher = <$ty>::new();
63                for part in parts {
64                    hasher.update(part);
65                }
66                hasher.finalize().to_vec()
67            }};
68        }
69        match self {
70            Self::Sha1 => digest!(sha1::Sha1),
71            Self::Sha256 => digest!(sha2::Sha256),
72            Self::Sha384 => digest!(sha2::Sha384),
73            Self::Sha512 => digest!(sha2::Sha512),
74        }
75    }
76
77    fn hmac(self, key: &[u8], data: &[u8]) -> Result<Vec<u8>> {
78        use hmac::{Hmac, Mac};
79        macro_rules! hmac {
80            ($ty:ty) => {{
81                let mut mac = Hmac::<$ty>::new_from_slice(key)
82                    .map_err(|e| Error::Internal(format!("HMAC init: {e}")))?;
83                mac.update(data);
84                mac.finalize().into_bytes().to_vec()
85            }};
86        }
87        Ok(match self {
88            Self::Sha1 => hmac!(sha1::Sha1),
89            Self::Sha256 => hmac!(sha2::Sha256),
90            Self::Sha384 => hmac!(sha2::Sha384),
91            Self::Sha512 => hmac!(sha2::Sha512),
92        })
93    }
94}
95
96fn validate_cipher(cipher: &str, chaining: &str, key_bits: u32, block_size: u32) -> Result<usize> {
97    if cipher != "AES" || chaining != "ChainingModeCBC" || block_size != 16 {
98        return Err(Error::UnsupportedEncryption(format!(
99            "{cipher}/{chaining} with block size {block_size}"
100        )));
101    }
102    match key_bits {
103        128 | 192 | 256 => Ok((key_bits / 8) as usize),
104        _ => Err(Error::UnsupportedEncryption(format!("AES-{key_bits}"))),
105    }
106}
107
108/// Parsed Agile EncryptionInfo from the XML portion of the EncryptionInfo stream.
109#[derive(Debug, Clone)]
110pub struct AgileEncryptionInfo {
111    /// Key data parameters for encrypting/decrypting the package data.
112    pub key_data: KeyData,
113    /// HMAC data integrity values.
114    pub data_integrity: DataIntegrity,
115    /// Password-based key encryptors.
116    pub key_encryptors: Vec<KeyEncryptor>,
117}
118
119/// Key data parameters.
120#[derive(Debug, Clone)]
121pub struct KeyData {
122    pub salt_size: u32,
123    pub block_size: u32,
124    pub key_bits: u32,
125    pub hash_size: u32,
126    pub cipher_algorithm: String,
127    pub cipher_chaining: String,
128    pub hash_algorithm: String,
129    pub salt_value: Vec<u8>,
130}
131
132/// Data integrity values (encrypted HMAC key and value).
133#[derive(Debug, Clone)]
134pub struct DataIntegrity {
135    pub encrypted_hmac_key: Vec<u8>,
136    pub encrypted_hmac_value: Vec<u8>,
137}
138
139/// Password-based key encryptor parameters.
140#[derive(Debug, Clone)]
141pub struct KeyEncryptor {
142    pub spin_count: u32,
143    pub salt_size: u32,
144    pub block_size: u32,
145    pub key_bits: u32,
146    pub hash_size: u32,
147    pub cipher_algorithm: String,
148    pub cipher_chaining: String,
149    pub hash_algorithm: String,
150    pub salt_value: Vec<u8>,
151    pub encrypted_verifier_hash_input: Vec<u8>,
152    pub encrypted_verifier_hash_value: Vec<u8>,
153    pub encrypted_key_value: Vec<u8>,
154}
155
156pub(crate) fn parse_agile_encryption_info_with_budget(
157    xml_data: &[u8],
158    budget: &mut EncryptionInfoBudget,
159) -> Result<AgileEncryptionInfo> {
160    use quick_xml::events::Event;
161    use quick_xml::Reader;
162
163    let mut reader = Reader::from_reader(xml_data);
164    reader.config_mut().trim_text(true);
165
166    let mut key_data: Option<KeyData> = None;
167    let mut data_integrity: Option<DataIntegrity> = None;
168    let mut key_encryptors: Vec<KeyEncryptor> = Vec::new();
169    let mut password_context = false;
170
171    let mut buf = Vec::new();
172    loop {
173        match reader.read_event_into(&mut buf) {
174            Ok(Event::Empty(ref e)) | Ok(Event::Start(ref e)) => {
175                budget.charge_element()?;
176                let qualified_name = e.name();
177                let name = qualified_name.as_ref();
178
179                if name == b"keyData" {
180                    key_data = Some(parse_key_data_attrs(e, budget)?);
181                } else if name == b"dataIntegrity" {
182                    data_integrity = Some(parse_data_integrity_attrs(e, budget)?);
183                } else if name == b"keyEncryptor" {
184                    password_context =
185                        attribute_eq(e, b"uri", PASSWORD_KEY_ENCRYPTOR_URI.as_bytes());
186                } else if password_context
187                    && (name.ends_with(b"encryptedKey") || name == b"p:encryptedKey")
188                {
189                    key_encryptors.push(parse_key_encryptor_attrs(e, budget)?);
190                }
191            }
192            Ok(Event::End(ref e)) if e.name().as_ref() == b"keyEncryptor" => {
193                password_context = false;
194            }
195            Ok(Event::Eof) => break,
196            Err(e) => {
197                return Err(Error::XmlParse(format!(
198                    "EncryptionInfo XML parse error: {e}"
199                )));
200            }
201            _ => {}
202        }
203        buf.clear();
204    }
205
206    let key_data = key_data.ok_or_else(|| {
207        Error::Internal("missing keyData element in EncryptionInfo XML".to_string())
208    })?;
209    let data_integrity = data_integrity.ok_or_else(|| {
210        Error::Internal("missing dataIntegrity element in EncryptionInfo XML".to_string())
211    })?;
212
213    Ok(AgileEncryptionInfo {
214        key_data,
215        data_integrity,
216        key_encryptors,
217    })
218}
219
220#[cfg(test)]
221fn parse_agile_encryption_info(xml_data: &[u8]) -> Result<AgileEncryptionInfo> {
222    parse_agile_encryption_info_with_limits(xml_data, EncryptionInfoLimits::default())
223}
224
225#[cfg(test)]
226fn parse_agile_encryption_info_with_limits(
227    xml_data: &[u8],
228    limits: EncryptionInfoLimits,
229) -> Result<AgileEncryptionInfo> {
230    let mut budget = EncryptionInfoBudget::new(limits)?;
231    budget.check_input(xml_data.len() as u64)?;
232    parse_agile_encryption_info_with_budget(xml_data, &mut budget)
233}
234
235/// Serialize AgileEncryptionInfo back to XML.
236pub fn serialize_agile_encryption_info(info: &AgileEncryptionInfo) -> Result<String> {
237    use base64::Engine;
238    let b64 = base64::engine::general_purpose::STANDARD;
239
240    let key_data = &info.key_data;
241    let di = &info.data_integrity;
242
243    let mut xml = String::from(r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>"#);
244    xml.push('\r');
245    xml.push('\n');
246    xml.push_str(r#"<encryption xmlns="http://schemas.microsoft.com/office/2006/encryption" xmlns:p="http://schemas.microsoft.com/office/2006/keyEncryptor/password">"#);
247
248    // keyData
249    xml.push_str(&format!(
250        r#"<keyData saltSize="{}" blockSize="{}" keyBits="{}" hashSize="{}" cipherAlgorithm="{}" cipherChaining="{}" hashAlgorithm="{}" saltValue="{}"/>"#,
251        key_data.salt_size,
252        key_data.block_size,
253        key_data.key_bits,
254        key_data.hash_size,
255        key_data.cipher_algorithm,
256        key_data.cipher_chaining,
257        key_data.hash_algorithm,
258        b64.encode(&key_data.salt_value),
259    ));
260
261    // dataIntegrity
262    xml.push_str(&format!(
263        r#"<dataIntegrity encryptedHmacKey="{}" encryptedHmacValue="{}"/>"#,
264        b64.encode(&di.encrypted_hmac_key),
265        b64.encode(&di.encrypted_hmac_value),
266    ));
267
268    // keyEncryptors
269    xml.push_str("<keyEncryptors>");
270    for enc in &info.key_encryptors {
271        xml.push_str(r#"<keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password">"#);
272        xml.push_str(&format!(
273            r#"<p:encryptedKey spinCount="{}" saltSize="{}" blockSize="{}" keyBits="{}" hashSize="{}" cipherAlgorithm="{}" cipherChaining="{}" hashAlgorithm="{}" saltValue="{}" encryptedVerifierHashInput="{}" encryptedVerifierHashValue="{}" encryptedKeyValue="{}"/>"#,
274            enc.spin_count,
275            enc.salt_size,
276            enc.block_size,
277            enc.key_bits,
278            enc.hash_size,
279            enc.cipher_algorithm,
280            enc.cipher_chaining,
281            enc.hash_algorithm,
282            b64.encode(&enc.salt_value),
283            b64.encode(&enc.encrypted_verifier_hash_input),
284            b64.encode(&enc.encrypted_verifier_hash_value),
285            b64.encode(&enc.encrypted_key_value),
286        ));
287        xml.push_str("</keyEncryptor>");
288    }
289    xml.push_str("</keyEncryptors>");
290    xml.push_str("</encryption>");
291
292    Ok(xml)
293}
294
295/// Derive a key using the Agile Encryption key derivation algorithm.
296///
297/// 1. H0 = Hash(salt || password_utf16le)
298/// 2. Hi = Hash(i_le_bytes || H_{i-1}) for i in 0..spin_count
299/// 3. H_final = Hash(H || block_key)
300/// 4. Truncate or pad (with 0x36) to key_bits/8 bytes
301fn derive_key_agile(
302    password: &str,
303    salt: &[u8],
304    spin_count: u32,
305    key_bits: u32,
306    block_key: &[u8],
307    hash_algorithm: HashAlgorithm,
308) -> Result<Zeroizing<Vec<u8>>> {
309    let key_length = usize::try_from(key_bits / 8)
310        .map_err(|_| Error::UnsupportedEncryption(format!("key size {key_bits}")))?;
311    if !matches!(key_bits, 128 | 192 | 256) {
312        return Err(Error::UnsupportedEncryption(format!("key size {key_bits}")));
313    }
314
315    let password_bytes = utf16le_password(password);
316
317    // H0 = SHA512(salt || password)
318    let mut h = Zeroizing::new(hash_algorithm.digest(&[salt, &password_bytes]));
319
320    // Hi = SHA512(i || H_{i-1}); each replaced intermediate is wiped on drop.
321    for i in 0u32..spin_count {
322        h = Zeroizing::new(hash_algorithm.digest(&[&i.to_le_bytes(), &h]));
323    }
324
325    // H_final = SHA512(H || blockKey)
326    let derived = Zeroizing::new(hash_algorithm.digest(&[&h, block_key]));
327    let mut key = Zeroizing::new(Vec::with_capacity(key_length));
328    key.extend_from_slice(&derived[..derived.len().min(key_length)]);
329    key.resize(key_length, 0x36);
330    Ok(key)
331}
332
333/// Encode a password as UTF-16LE into a buffer that is wiped on drop.
334pub(crate) fn utf16le_password(password: &str) -> Zeroizing<Vec<u8>> {
335    let mut bytes = Zeroizing::new(Vec::with_capacity(password.encode_utf16().count() * 2));
336    for unit in password.encode_utf16() {
337        bytes.extend_from_slice(&unit.to_le_bytes());
338    }
339    bytes
340}
341
342/// Verify a password against Agile Encryption encryptor data.
343/// Returns the decrypted secret key, sized for the password encryptor's
344/// `keyBits`, on success. Packages whose `keyData` uses a different AES key
345/// size are handled by [`crate::crypt::decrypt_xlsx`].
346pub fn verify_password_agile(password: &str, encryptor: &KeyEncryptor) -> Result<Vec<u8>> {
347    verify_password_agile_with_limits(password, encryptor, CryptLimits::default())
348}
349
350/// Verify an Agile password using explicit finite KDF limits.
351pub fn verify_password_agile_with_limits(
352    password: &str,
353    encryptor: &KeyEncryptor,
354    limits: CryptLimits,
355) -> Result<Vec<u8>> {
356    let mut budget = CryptBudget::new(ResourceOperation::Decrypt, limits)?;
357    let (_, key_len) = password_encryptor_parameters(encryptor)?;
358    let secret_key = unwrap_secret_key_agile_with_budget(password, encryptor, &mut budget)?;
359    if secret_key.len() < key_len {
360        return Err(Error::UnsupportedEncryption(
361            "encrypted key value is shorter than the encryptor key size".into(),
362        ));
363    }
364    Ok(secret_key[..key_len].to_vec())
365}
366
367/// Verify the password and return the complete unwrapped `encryptedKeyValue`
368/// plaintext. The package key size is governed by `keyData`, not by the
369/// password encryptor, so callers size it with [`package_key`].
370pub(crate) fn unwrap_secret_key_agile_with_budget(
371    password: &str,
372    encryptor: &KeyEncryptor,
373    budget: &mut CryptBudget,
374) -> Result<Zeroizing<Vec<u8>>> {
375    let (hash, _) = password_encryptor_parameters(encryptor)?;
376    budget.reserve_kdf(u64::from(encryptor.spin_count), 3)?;
377    // Derive key for verifier hash input
378    let key_verifier_input = derive_key_agile(
379        password,
380        &encryptor.salt_value,
381        encryptor.spin_count,
382        encryptor.key_bits,
383        super::block_keys::VERIFIER_HASH_INPUT,
384        hash,
385    )?;
386
387    // Derive key for verifier hash value
388    let key_verifier_value = derive_key_agile(
389        password,
390        &encryptor.salt_value,
391        encryptor.spin_count,
392        encryptor.key_bits,
393        super::block_keys::VERIFIER_HASH_VALUE,
394        hash,
395    )?;
396
397    // Decrypt verifier hash input
398    let decrypted_input = Zeroizing::new(aes_cbc_decrypt(
399        &key_verifier_input,
400        &encryptor.salt_value,
401        &encryptor.encrypted_verifier_hash_input,
402    )?);
403
404    // Compute hash of decrypted input
405    if decrypted_input.len() < encryptor.salt_size as usize {
406        return Err(Error::IncorrectPassword);
407    }
408    let expected_hash =
409        Zeroizing::new(hash.digest(&[&decrypted_input[..encryptor.salt_size as usize]]));
410
411    // Decrypt verifier hash value
412    let decrypted_hash = Zeroizing::new(aes_cbc_decrypt(
413        &key_verifier_value,
414        &encryptor.salt_value,
415        &encryptor.encrypted_verifier_hash_value,
416    )?);
417
418    // Compare hashes
419    let hash_size = encryptor.hash_size as usize;
420    if decrypted_hash.len() < hash_size || expected_hash.len() < hash_size {
421        return Err(Error::IncorrectPassword);
422    }
423    if !constant_time_eq(&expected_hash[..hash_size], &decrypted_hash[..hash_size]) {
424        return Err(Error::IncorrectPassword);
425    }
426
427    // Decrypt the actual secret key
428    let key_for_key = derive_key_agile(
429        password,
430        &encryptor.salt_value,
431        encryptor.spin_count,
432        encryptor.key_bits,
433        super::block_keys::KEY_VALUE,
434        hash,
435    )?;
436
437    let secret_key = Zeroizing::new(aes_cbc_decrypt(
438        &key_for_key,
439        &encryptor.salt_value,
440        &encryptor.encrypted_key_value,
441    )?);
442    Ok(secret_key)
443}
444
445/// Size an unwrapped secret key for the package cipher described by `keyData`.
446pub(crate) fn package_key(secret_key: &[u8], key_data: &KeyData) -> Result<Zeroizing<Vec<u8>>> {
447    let key_len = validate_cipher(
448        &key_data.cipher_algorithm,
449        &key_data.cipher_chaining,
450        key_data.key_bits,
451        key_data.block_size,
452    )?;
453    if secret_key.len() < key_len {
454        return Err(Error::UnsupportedEncryption(
455            "encrypted key value is shorter than the keyData key size".into(),
456        ));
457    }
458    Ok(Zeroizing::new(secret_key[..key_len].to_vec()))
459}
460
461pub(crate) fn validate_password_encryptor(encryptor: &KeyEncryptor) -> Result<()> {
462    password_encryptor_parameters(encryptor).map(|_| ())
463}
464
465fn password_encryptor_parameters(encryptor: &KeyEncryptor) -> Result<(HashAlgorithm, usize)> {
466    let hash = HashAlgorithm::parse(&encryptor.hash_algorithm, encryptor.hash_size)?;
467    let key_len = validate_cipher(
468        &encryptor.cipher_algorithm,
469        &encryptor.cipher_chaining,
470        encryptor.key_bits,
471        encryptor.block_size,
472    )?;
473    if encryptor.salt_size != encryptor.block_size
474        || encryptor.salt_value.len() != encryptor.salt_size as usize
475        || encryptor.encrypted_verifier_hash_input.is_empty()
476        || encryptor.encrypted_verifier_hash_value.is_empty()
477        || encryptor.encrypted_key_value.is_empty()
478    {
479        return Err(Error::UnsupportedEncryption(
480            "invalid password encryptor fields".into(),
481        ));
482    }
483    Ok((hash, key_len))
484}
485
486/// Decrypt the EncryptedPackage using Agile Encryption (AES-256-CBC, per-segment IV).
487pub fn decrypt_package_agile(
488    encrypted_data: &[u8],
489    key: &[u8],
490    key_data: &KeyData,
491) -> Result<Vec<u8>> {
492    validate_key_data(key_data, key)?;
493    if encrypted_data.len() < 8 {
494        return Err(Error::Internal(
495            "EncryptedPackage too short for size prefix".to_string(),
496        ));
497    }
498
499    let original_size = usize::try_from(u64::from_le_bytes(
500        encrypted_data[..8]
501            .try_into()
502            .map_err(|_| Error::Internal("invalid size prefix".into()))?,
503    ))
504    .map_err(|_| Error::Internal("EncryptedPackage size exceeds platform limits".into()))?;
505    let encrypted_content = &encrypted_data[8..];
506    if original_size > encrypted_content.len() {
507        return Err(Error::Internal(
508            "EncryptedPackage size exceeds encrypted content".into(),
509        ));
510    }
511
512    let mut decrypted = Vec::with_capacity(original_size);
513
514    for (segment_index, chunk) in encrypted_content.chunks(SEGMENT_SIZE).enumerate() {
515        let iv = generate_iv(
516            &key_data.salt_value,
517            &(segment_index as u32).to_le_bytes(),
518            key_data.block_size,
519            HashAlgorithm::parse(&key_data.hash_algorithm, key_data.hash_size)?,
520        )?;
521        let decrypted_chunk = aes_cbc_decrypt(key, &iv, chunk)?;
522        decrypted.extend_from_slice(&decrypted_chunk);
523    }
524
525    if decrypted.len() < original_size {
526        return Err(Error::Internal("EncryptedPackage is truncated".into()));
527    }
528    decrypted.truncate(original_size);
529    Ok(decrypted)
530}
531
532/// Encrypt ZIP data using Agile Encryption and return (encrypted_package_with_size_prefix, info).
533pub fn encrypt_package_agile(
534    data: &[u8],
535    password: &str,
536) -> Result<(Vec<u8>, AgileEncryptionInfo)> {
537    encrypt_package_agile_with_limits(data, password, CryptLimits::default())
538}
539
540/// Encrypt package bytes using explicit finite KDF limits.
541pub fn encrypt_package_agile_with_limits(
542    data: &[u8],
543    password: &str,
544    limits: CryptLimits,
545) -> Result<(Vec<u8>, AgileEncryptionInfo)> {
546    let mut budget = CryptBudget::new(ResourceOperation::Encrypt, limits)?;
547    budget.check_encrypted_package(data.len() as u64)?;
548    let result = encrypt_package_agile_with_budget(data, password, &mut budget)?;
549    budget.check_encrypted_package(result.0.len() as u64)?;
550    Ok(result)
551}
552
553pub(crate) fn encrypt_package_agile_with_budget(
554    data: &[u8],
555    password: &str,
556    budget: &mut CryptBudget,
557) -> Result<(Vec<u8>, AgileEncryptionInfo)> {
558    use rand::Rng;
559
560    let mut rng = rand::thread_rng();
561
562    // Generate random values
563    let mut key_data_salt = [0u8; 16];
564    let mut encryptor_salt = [0u8; 16];
565    let mut secret_key = Zeroizing::new([0u8; 32]); // AES-256
566    let mut verifier_hash_input = Zeroizing::new([0u8; 16]);
567
568    rng.fill(&mut key_data_salt);
569    rng.fill(&mut encryptor_salt);
570    rng.fill(&mut *secret_key);
571    rng.fill(&mut *verifier_hash_input);
572
573    let spin_count = 100_000u32;
574    budget.reserve_kdf(u64::from(spin_count), 3)?;
575
576    // Build KeyData
577    let key_data = KeyData {
578        salt_size: 16,
579        block_size: 16,
580        key_bits: 256,
581        hash_size: 64,
582        cipher_algorithm: "AES".to_string(),
583        cipher_chaining: "ChainingModeCBC".to_string(),
584        hash_algorithm: "SHA512".to_string(),
585        salt_value: key_data_salt.to_vec(),
586    };
587    let hash = HashAlgorithm::Sha512;
588
589    // Encrypt verifier hash input
590    let key_vi = derive_key_agile(
591        password,
592        &encryptor_salt,
593        spin_count,
594        256,
595        super::block_keys::VERIFIER_HASH_INPUT,
596        hash,
597    )?;
598    let encrypted_verifier_hash_input =
599        aes_cbc_encrypt(&key_vi, &encryptor_salt, &*verifier_hash_input)?;
600
601    // Compute and encrypt verifier hash value
602    let verifier_hash_value = Zeroizing::new(hash.digest(&[&*verifier_hash_input]));
603
604    let key_vv = derive_key_agile(
605        password,
606        &encryptor_salt,
607        spin_count,
608        256,
609        super::block_keys::VERIFIER_HASH_VALUE,
610        hash,
611    )?;
612    let encrypted_verifier_hash_value =
613        aes_cbc_encrypt(&key_vv, &encryptor_salt, &verifier_hash_value)?;
614
615    // Encrypt secret key
616    let key_kv = derive_key_agile(
617        password,
618        &encryptor_salt,
619        spin_count,
620        256,
621        super::block_keys::KEY_VALUE,
622        hash,
623    )?;
624    let encrypted_key_value = aes_cbc_encrypt(&key_kv, &encryptor_salt, &*secret_key)?;
625
626    let encryptor = KeyEncryptor {
627        spin_count,
628        salt_size: 16,
629        block_size: 16,
630        key_bits: 256,
631        hash_size: 64,
632        cipher_algorithm: "AES".to_string(),
633        cipher_chaining: "ChainingModeCBC".to_string(),
634        hash_algorithm: "SHA512".to_string(),
635        salt_value: encryptor_salt.to_vec(),
636        encrypted_verifier_hash_input,
637        encrypted_verifier_hash_value,
638        encrypted_key_value,
639    };
640
641    // Encrypt data in segments
642    let encrypted_content = encrypt_segments(data, &*secret_key, &key_data)?;
643
644    // Build the EncryptedPackage: size prefix + encrypted content
645    let mut encrypted_package = Vec::with_capacity(8 + encrypted_content.len());
646    encrypted_package.extend_from_slice(&(data.len() as u64).to_le_bytes());
647    encrypted_package.extend_from_slice(&encrypted_content);
648
649    let data_integrity = create_data_integrity(&encrypted_package, &*secret_key, &key_data)?;
650
651    let encryption_info = AgileEncryptionInfo {
652        key_data,
653        data_integrity,
654        key_encryptors: vec![encryptor],
655    };
656
657    Ok((encrypted_package, encryption_info))
658}
659
660/// Encrypt data in 4096-byte segments with per-segment IVs.
661fn encrypt_segments(data: &[u8], key: &[u8], key_data: &KeyData) -> Result<Vec<u8>> {
662    validate_key_data(key_data, key)?;
663    let hash = HashAlgorithm::parse(&key_data.hash_algorithm, key_data.hash_size)?;
664    let mut result = Vec::new();
665
666    for (segment_index, chunk) in data.chunks(SEGMENT_SIZE).enumerate() {
667        let iv = generate_iv(
668            &key_data.salt_value,
669            &(segment_index as u32).to_le_bytes(),
670            key_data.block_size,
671            hash,
672        )?;
673        let encrypted = aes_cbc_encrypt(key, &iv, chunk)?;
674        result.extend_from_slice(&encrypted);
675    }
676
677    Ok(result)
678}
679
680/// Generate a per-segment IV: Hash(salt || segment_index)[..block_size].
681fn generate_iv(
682    salt: &[u8],
683    block_key: &[u8],
684    block_size: u32,
685    hash: HashAlgorithm,
686) -> Result<Vec<u8>> {
687    let block_size = block_size as usize;
688    if block_size != 16 || block_size > hash.output_size() {
689        return Err(Error::UnsupportedEncryption(format!(
690            "invalid block size {block_size}"
691        )));
692    }
693    Ok(hash.digest(&[salt, block_key])[..block_size].to_vec())
694}
695
696/// AES-CBC decryption.
697fn aes_cbc_decrypt(key: &[u8], iv: &[u8], data: &[u8]) -> Result<Vec<u8>> {
698    use aes::cipher::KeyIvInit;
699    use cbc::cipher::BlockDecryptMut;
700
701    if data.is_empty() || !data.len().is_multiple_of(16) || iv.len() != 16 {
702        return Err(Error::Internal("invalid AES-CBC input length".into()));
703    }
704    let padded = data.to_vec();
705    let iv_arr = iv;
706
707    match key.len() {
708        16 => {
709            type Aes128Cbc = cbc::Decryptor<aes::Aes128>;
710            let mut buf = padded;
711            let decryptor = Aes128Cbc::new_from_slices(key, iv_arr)
712                .map_err(|e| Error::Internal(format!("AES-128-CBC init: {e}")))?;
713            decryptor
714                .decrypt_padded_mut::<cbc::cipher::block_padding::NoPadding>(&mut buf)
715                .map_err(|e| Error::Internal(format!("AES-128-CBC decrypt: {e}")))?;
716            Ok(buf)
717        }
718        24 => {
719            type Aes192Cbc = cbc::Decryptor<aes::Aes192>;
720            let mut buf = padded;
721            let decryptor = Aes192Cbc::new_from_slices(key, iv_arr)
722                .map_err(|e| Error::Internal(format!("AES-192-CBC init: {e}")))?;
723            decryptor
724                .decrypt_padded_mut::<cbc::cipher::block_padding::NoPadding>(&mut buf)
725                .map_err(|e| Error::Internal(format!("AES-192-CBC decrypt: {e}")))?;
726            Ok(buf)
727        }
728        32 => {
729            type Aes256Cbc = cbc::Decryptor<aes::Aes256>;
730            let mut buf = padded;
731            let decryptor = Aes256Cbc::new_from_slices(key, iv_arr)
732                .map_err(|e| Error::Internal(format!("AES-256-CBC init: {e}")))?;
733            decryptor
734                .decrypt_padded_mut::<cbc::cipher::block_padding::NoPadding>(&mut buf)
735                .map_err(|e| Error::Internal(format!("AES-256-CBC decrypt: {e}")))?;
736            Ok(buf)
737        }
738        _ => Err(Error::Internal(format!(
739            "unsupported AES key length: {}",
740            key.len()
741        ))),
742    }
743}
744
745/// AES-CBC encryption.
746fn aes_cbc_encrypt(key: &[u8], iv: &[u8], data: &[u8]) -> Result<Vec<u8>> {
747    use aes::cipher::KeyIvInit;
748    use cbc::cipher::BlockEncryptMut;
749
750    let block_size = 16;
751    // Pad data to block size boundary
752    let pad_len = if !data.len().is_multiple_of(block_size) {
753        block_size - data.len() % block_size
754    } else {
755        0
756    };
757    let mut buf = Vec::with_capacity(data.len() + pad_len);
758    buf.extend_from_slice(data);
759    buf.resize(data.len() + pad_len, 0);
760
761    if iv.len() != 16 {
762        return Err(Error::Internal("invalid AES-CBC IV length".into()));
763    }
764    let iv_arr = iv;
765
766    match key.len() {
767        16 => {
768            type Aes128Cbc = cbc::Encryptor<aes::Aes128>;
769            let encryptor = Aes128Cbc::new_from_slices(key, iv_arr)
770                .map_err(|e| Error::Internal(format!("AES-128-CBC init: {e}")))?;
771            let result = encryptor
772                .encrypt_padded_mut::<cbc::cipher::block_padding::NoPadding>(
773                    &mut buf,
774                    data.len() + pad_len,
775                )
776                .map_err(|e| Error::Internal(format!("AES-128-CBC encrypt: {e}")))?;
777            Ok(result.to_vec())
778        }
779        24 => {
780            type Aes192Cbc = cbc::Encryptor<aes::Aes192>;
781            let encryptor = Aes192Cbc::new_from_slices(key, iv_arr)
782                .map_err(|e| Error::Internal(format!("AES-192-CBC init: {e}")))?;
783            let result = encryptor
784                .encrypt_padded_mut::<cbc::cipher::block_padding::NoPadding>(
785                    &mut buf,
786                    data.len() + pad_len,
787                )
788                .map_err(|e| Error::Internal(format!("AES-192-CBC encrypt: {e}")))?;
789            Ok(result.to_vec())
790        }
791        32 => {
792            type Aes256Cbc = cbc::Encryptor<aes::Aes256>;
793            let encryptor = Aes256Cbc::new_from_slices(key, iv_arr)
794                .map_err(|e| Error::Internal(format!("AES-256-CBC init: {e}")))?;
795            let result = encryptor
796                .encrypt_padded_mut::<cbc::cipher::block_padding::NoPadding>(
797                    &mut buf,
798                    data.len() + pad_len,
799                )
800                .map_err(|e| Error::Internal(format!("AES-256-CBC encrypt: {e}")))?;
801            Ok(result.to_vec())
802        }
803        _ => Err(Error::Internal(format!(
804            "unsupported AES key length: {}",
805            key.len()
806        ))),
807    }
808}
809
810fn validate_key_data(key_data: &KeyData, key: &[u8]) -> Result<()> {
811    let expected_key_len = validate_cipher(
812        &key_data.cipher_algorithm,
813        &key_data.cipher_chaining,
814        key_data.key_bits,
815        key_data.block_size,
816    )?;
817    HashAlgorithm::parse(&key_data.hash_algorithm, key_data.hash_size)?;
818    if key.len() != expected_key_len || key_data.salt_value.len() != key_data.salt_size as usize {
819        return Err(Error::UnsupportedEncryption(
820            "invalid keyData key or salt size".into(),
821        ));
822    }
823    Ok(())
824}
825
826fn create_data_integrity(
827    package: &[u8],
828    secret_key: &[u8],
829    key_data: &KeyData,
830) -> Result<DataIntegrity> {
831    validate_key_data(key_data, secret_key)?;
832    let hash = HashAlgorithm::parse(&key_data.hash_algorithm, key_data.hash_size)?;
833    let hmac_key = Zeroizing::new(generate_random_bytes(hash.output_size()));
834    let hmac_value = hash.hmac(&hmac_key, package)?;
835    let key_iv = generate_iv(
836        &key_data.salt_value,
837        super::block_keys::HMAC_KEY,
838        key_data.block_size,
839        hash,
840    )?;
841    let value_iv = generate_iv(
842        &key_data.salt_value,
843        super::block_keys::HMAC_VALUE,
844        key_data.block_size,
845        hash,
846    )?;
847    Ok(DataIntegrity {
848        encrypted_hmac_key: aes_cbc_encrypt(secret_key, &key_iv, &hmac_key)?,
849        encrypted_hmac_value: aes_cbc_encrypt(secret_key, &value_iv, &hmac_value)?,
850    })
851}
852
853pub fn verify_data_integrity(
854    package: &[u8],
855    secret_key: &[u8],
856    key_data: &KeyData,
857    integrity: &DataIntegrity,
858) -> Result<()> {
859    validate_key_data(key_data, secret_key)?;
860    let hash = HashAlgorithm::parse(&key_data.hash_algorithm, key_data.hash_size)?;
861    let key_iv = generate_iv(
862        &key_data.salt_value,
863        super::block_keys::HMAC_KEY,
864        key_data.block_size,
865        hash,
866    )?;
867    let value_iv = generate_iv(
868        &key_data.salt_value,
869        super::block_keys::HMAC_VALUE,
870        key_data.block_size,
871        hash,
872    )?;
873    let hmac_key = Zeroizing::new(aes_cbc_decrypt(
874        secret_key,
875        &key_iv,
876        &integrity.encrypted_hmac_key,
877    )?);
878    let hmac_value = aes_cbc_decrypt(secret_key, &value_iv, &integrity.encrypted_hmac_value)?;
879    let value_len = hash.output_size();
880    if !has_zero_padding(&hmac_value, value_len) {
881        return Err(Error::Internal(
882            "Agile data integrity value has invalid length or padding".into(),
883        ));
884    }
885
886    // Office uses hashSize keys, while the published specification describes
887    // saltSize keys. Accept both encodings without guessing from trailing data.
888    let mut verified = false;
889    for key_len in [value_len, key_data.salt_size as usize] {
890        if has_zero_padding(&hmac_key, key_len) {
891            let expected = hash.hmac(&hmac_key[..key_len], package)?;
892            verified |= constant_time_eq(&expected, &hmac_value[..value_len]);
893        }
894    }
895    if !verified {
896        return Err(Error::Internal(
897            "Agile data integrity verification failed".into(),
898        ));
899    }
900    Ok(())
901}
902
903fn has_zero_padding(value: &[u8], logical_len: usize) -> bool {
904    value.len() >= logical_len && value[logical_len..].iter().all(|byte| *byte == 0)
905}
906
907fn constant_time_eq(left: &[u8], right: &[u8]) -> bool {
908    use subtle::ConstantTimeEq;
909    // Slice lengths are public; contents are compared in constant time.
910    left.len() == right.len() && bool::from(left.ct_eq(right))
911}
912
913/// Generate random bytes.
914fn generate_random_bytes(len: usize) -> Vec<u8> {
915    use rand::Rng;
916    let mut rng = rand::thread_rng();
917    let mut buf = vec![0u8; len];
918    rng.fill(&mut buf[..]);
919    buf
920}
921
922// -- XML attribute parsing helpers --
923
924fn attribute_eq(e: &quick_xml::events::BytesStart<'_>, name: &[u8], expected: &[u8]) -> bool {
925    e.attributes()
926        .flatten()
927        .any(|attr| attr.key.as_ref() == name && attr.value.as_ref() == expected)
928}
929
930/// Parse an unsigned decimal EncryptionInfo attribute, rejecting malformed
931/// values instead of silently treating them as zero.
932fn parse_u32_attribute(name: &str, value: &[u8]) -> Result<u32> {
933    std::str::from_utf8(value)
934        .ok()
935        .filter(|text| !text.is_empty() && text.bytes().all(|byte| byte.is_ascii_digit()))
936        .and_then(|text| text.parse().ok())
937        .ok_or_else(|| Error::Internal(format!("invalid EncryptionInfo {name} attribute")))
938}
939
940/// ECMA-376 / MS-OFFCRYPTO bound the `saltSize` attribute to 1..=65536.
941const SALT_SIZE_RANGE: std::ops::RangeInclusive<u32> = 1..=65_536;
942
943fn validate_salt_size(element: &str, salt_size: u32) -> Result<()> {
944    if SALT_SIZE_RANGE.contains(&salt_size) {
945        Ok(())
946    } else {
947        Err(Error::UnsupportedEncryption(format!(
948            "{element} saltSize {salt_size} is outside 1..=65536"
949        )))
950    }
951}
952
953fn retain_string_attribute(value: &[u8], budget: &mut EncryptionInfoBudget) -> Result<String> {
954    let value = std::str::from_utf8(value)
955        .map_err(|_| Error::Internal("invalid EncryptionInfo attribute".to_string()))?;
956    budget.reserve_decoded_attributes(value.len() as u64)?;
957    Ok(value.to_owned())
958}
959
960fn decode_base64_attribute(value: &[u8], budget: &mut EncryptionInfoBudget) -> Result<Vec<u8>> {
961    use base64::Engine;
962
963    let padding = value.iter().rev().take_while(|byte| **byte == b'=').count();
964    let decoded_len = value
965        .len()
966        .saturating_add(3)
967        .checked_div(4)
968        .unwrap_or(0)
969        .saturating_mul(3)
970        .saturating_sub(padding.min(2));
971    budget.reserve_decoded_attributes(decoded_len as u64)?;
972    base64::engine::general_purpose::STANDARD
973        .decode(value)
974        .map_err(|_| Error::Internal("invalid base64 EncryptionInfo attribute".to_string()))
975}
976
977fn parse_key_data_attrs(
978    e: &quick_xml::events::BytesStart<'_>,
979    budget: &mut EncryptionInfoBudget,
980) -> Result<KeyData> {
981    let mut kd = KeyData {
982        salt_size: 0,
983        block_size: 0,
984        key_bits: 0,
985        hash_size: 0,
986        cipher_algorithm: String::new(),
987        cipher_chaining: String::new(),
988        hash_algorithm: String::new(),
989        salt_value: Vec::new(),
990    };
991
992    for attr in e.attributes().flatten() {
993        let value = attr.value.as_ref();
994        match attr.key.as_ref() {
995            b"saltSize" => kd.salt_size = parse_u32_attribute("saltSize", value)?,
996            b"blockSize" => kd.block_size = parse_u32_attribute("blockSize", value)?,
997            b"keyBits" => kd.key_bits = parse_u32_attribute("keyBits", value)?,
998            b"hashSize" => kd.hash_size = parse_u32_attribute("hashSize", value)?,
999            b"cipherAlgorithm" => kd.cipher_algorithm = retain_string_attribute(value, budget)?,
1000            b"cipherChaining" => kd.cipher_chaining = retain_string_attribute(value, budget)?,
1001            b"hashAlgorithm" => kd.hash_algorithm = retain_string_attribute(value, budget)?,
1002            b"saltValue" => kd.salt_value = decode_base64_attribute(value, budget)?,
1003            _ => {}
1004        }
1005    }
1006    validate_salt_size("keyData", kd.salt_size)?;
1007    Ok(kd)
1008}
1009
1010fn parse_data_integrity_attrs(
1011    e: &quick_xml::events::BytesStart<'_>,
1012    budget: &mut EncryptionInfoBudget,
1013) -> Result<DataIntegrity> {
1014    let mut di = DataIntegrity {
1015        encrypted_hmac_key: Vec::new(),
1016        encrypted_hmac_value: Vec::new(),
1017    };
1018
1019    for attr in e.attributes().flatten() {
1020        let value = attr.value.as_ref();
1021        match attr.key.as_ref() {
1022            b"encryptedHmacKey" => {
1023                di.encrypted_hmac_key = decode_base64_attribute(value, budget)?;
1024            }
1025            b"encryptedHmacValue" => {
1026                di.encrypted_hmac_value = decode_base64_attribute(value, budget)?;
1027            }
1028            _ => {}
1029        }
1030    }
1031    Ok(di)
1032}
1033
1034fn parse_key_encryptor_attrs(
1035    e: &quick_xml::events::BytesStart<'_>,
1036    budget: &mut EncryptionInfoBudget,
1037) -> Result<KeyEncryptor> {
1038    let mut ke = KeyEncryptor {
1039        spin_count: 0,
1040        salt_size: 0,
1041        block_size: 0,
1042        key_bits: 0,
1043        hash_size: 0,
1044        cipher_algorithm: String::new(),
1045        cipher_chaining: String::new(),
1046        hash_algorithm: String::new(),
1047        salt_value: Vec::new(),
1048        encrypted_verifier_hash_input: Vec::new(),
1049        encrypted_verifier_hash_value: Vec::new(),
1050        encrypted_key_value: Vec::new(),
1051    };
1052
1053    for attr in e.attributes().flatten() {
1054        let value = attr.value.as_ref();
1055        match attr.key.as_ref() {
1056            b"spinCount" => ke.spin_count = parse_u32_attribute("spinCount", value)?,
1057            b"saltSize" => ke.salt_size = parse_u32_attribute("saltSize", value)?,
1058            b"blockSize" => ke.block_size = parse_u32_attribute("blockSize", value)?,
1059            b"keyBits" => ke.key_bits = parse_u32_attribute("keyBits", value)?,
1060            b"hashSize" => ke.hash_size = parse_u32_attribute("hashSize", value)?,
1061            b"cipherAlgorithm" => ke.cipher_algorithm = retain_string_attribute(value, budget)?,
1062            b"cipherChaining" => ke.cipher_chaining = retain_string_attribute(value, budget)?,
1063            b"hashAlgorithm" => ke.hash_algorithm = retain_string_attribute(value, budget)?,
1064            b"saltValue" => ke.salt_value = decode_base64_attribute(value, budget)?,
1065            b"encryptedVerifierHashInput" => {
1066                ke.encrypted_verifier_hash_input = decode_base64_attribute(value, budget)?;
1067            }
1068            b"encryptedVerifierHashValue" => {
1069                ke.encrypted_verifier_hash_value = decode_base64_attribute(value, budget)?;
1070            }
1071            b"encryptedKeyValue" => {
1072                ke.encrypted_key_value = decode_base64_attribute(value, budget)?;
1073            }
1074            _ => {}
1075        }
1076    }
1077    validate_salt_size("encryptedKey", ke.salt_size)?;
1078    Ok(ke)
1079}
1080
1081#[cfg(test)]
1082#[allow(clippy::explicit_counter_loop)]
1083mod tests {
1084    use super::*;
1085    use crate::resource::{ResourceDimension, ResourceStage};
1086
1087    fn minimal_encryption_info(extra: &str) -> Vec<u8> {
1088        format!(
1089            r#"<encryption><keyData saltSize="16" blockSize="16" keyBits="256" hashSize="64" cipherAlgorithm="AES" cipherChaining="ChainingModeCBC" hashAlgorithm="SHA512" saltValue="AAAAAAAAAAAAAAAAAAAAAA=="/><dataIntegrity encryptedHmacKey="AA==" encryptedHmacValue="AA=="/>{extra}</encryption>"#
1090        )
1091        .into_bytes()
1092    }
1093
1094    #[test]
1095    fn encryption_info_element_limit_accepts_exact_and_rejects_plus_one() {
1096        let xml = minimal_encryption_info("");
1097        let exact = EncryptionInfoLimits {
1098            element_count: 3,
1099            ..EncryptionInfoLimits::default()
1100        };
1101        parse_agile_encryption_info_with_limits(&xml, exact).unwrap();
1102
1103        let rejected = EncryptionInfoLimits {
1104            element_count: 2,
1105            ..EncryptionInfoLimits::default()
1106        };
1107        let error = parse_agile_encryption_info_with_limits(&xml, rejected).unwrap_err();
1108        let metadata = error.resource_metadata().expect("resource metadata");
1109        assert_eq!(metadata.dimension(), ResourceDimension::NodeCount);
1110        assert_eq!(metadata.limit(), 2);
1111        assert_eq!(metadata.observed(), 3);
1112        assert_eq!(metadata.stage(), Some(ResourceStage::Parse));
1113    }
1114
1115    #[test]
1116    fn encryption_info_decoded_attribute_limit_rejects_before_decode() {
1117        let xml = minimal_encryption_info("");
1118        let calibrated =
1119            parse_agile_encryption_info_with_limits(&xml, EncryptionInfoLimits::default()).unwrap();
1120        let retained = calibrated.key_data.cipher_algorithm.len()
1121            + calibrated.key_data.cipher_chaining.len()
1122            + calibrated.key_data.hash_algorithm.len()
1123            + calibrated.key_data.salt_value.len()
1124            + calibrated.data_integrity.encrypted_hmac_key.len()
1125            + calibrated.data_integrity.encrypted_hmac_value.len();
1126
1127        parse_agile_encryption_info_with_limits(
1128            &xml,
1129            EncryptionInfoLimits {
1130                decoded_attribute_bytes: retained as u64,
1131                ..EncryptionInfoLimits::default()
1132            },
1133        )
1134        .unwrap();
1135        let error = parse_agile_encryption_info_with_limits(
1136            &xml,
1137            EncryptionInfoLimits {
1138                decoded_attribute_bytes: retained as u64 - 1,
1139                ..EncryptionInfoLimits::default()
1140            },
1141        )
1142        .unwrap_err();
1143        let metadata = error.resource_metadata().expect("resource metadata");
1144        assert_eq!(metadata.dimension(), ResourceDimension::RetainedBytes);
1145        assert_eq!(metadata.limit(), retained as u64 - 1);
1146        assert!(metadata.observed() > metadata.limit());
1147        assert_eq!(metadata.stage(), Some(ResourceStage::Decode));
1148    }
1149
1150    #[test]
1151    fn test_derive_key_agile_produces_correct_length() {
1152        let salt = vec![0u8; 16];
1153        // Use a small spin count for test speed
1154        let key = derive_key_agile(
1155            "password",
1156            &salt,
1157            10,
1158            256,
1159            super::super::block_keys::KEY_VALUE,
1160            HashAlgorithm::Sha512,
1161        )
1162        .unwrap();
1163        assert_eq!(key.len(), 32);
1164    }
1165
1166    #[test]
1167    fn test_derive_key_agile_deterministic() {
1168        let salt = vec![42u8; 16];
1169        let key1 = derive_key_agile(
1170            "test",
1171            &salt,
1172            10,
1173            256,
1174            super::super::block_keys::KEY_VALUE,
1175            HashAlgorithm::Sha512,
1176        )
1177        .unwrap();
1178        let key2 = derive_key_agile(
1179            "test",
1180            &salt,
1181            10,
1182            256,
1183            super::super::block_keys::KEY_VALUE,
1184            HashAlgorithm::Sha512,
1185        )
1186        .unwrap();
1187        assert_eq!(key1, key2);
1188    }
1189
1190    #[test]
1191    fn test_derive_key_agile_different_passwords() {
1192        let salt = vec![1u8; 16];
1193        let key1 = derive_key_agile(
1194            "pass1",
1195            &salt,
1196            10,
1197            256,
1198            super::super::block_keys::KEY_VALUE,
1199            HashAlgorithm::Sha512,
1200        )
1201        .unwrap();
1202        let key2 = derive_key_agile(
1203            "pass2",
1204            &salt,
1205            10,
1206            256,
1207            super::super::block_keys::KEY_VALUE,
1208            HashAlgorithm::Sha512,
1209        )
1210        .unwrap();
1211        assert_ne!(key1, key2);
1212    }
1213
1214    #[test]
1215    fn test_aes_cbc_encrypt_decrypt_roundtrip() {
1216        let key = [0x42u8; 32];
1217        let iv = [0x00u8; 16];
1218        let plaintext = b"Hello, World! This is a test!!!!"; // 32 bytes, aligned to block size
1219
1220        let ciphertext = aes_cbc_encrypt(&key, &iv, plaintext).unwrap();
1221        assert_ne!(ciphertext, plaintext.to_vec());
1222
1223        let decrypted = aes_cbc_decrypt(&key, &iv, &ciphertext).unwrap();
1224        assert_eq!(&decrypted[..plaintext.len()], plaintext);
1225    }
1226
1227    #[test]
1228    fn test_segment_encrypt_decrypt_roundtrip() {
1229        let key = [0x42u8; 32];
1230        let key_data = KeyData {
1231            salt_size: 16,
1232            block_size: 16,
1233            key_bits: 256,
1234            hash_size: 64,
1235            cipher_algorithm: "AES".to_string(),
1236            cipher_chaining: "ChainingModeCBC".to_string(),
1237            hash_algorithm: "SHA512".to_string(),
1238            salt_value: vec![0u8; 16],
1239        };
1240
1241        // Create data spanning multiple segments
1242        let data = vec![0xABu8; SEGMENT_SIZE * 2 + 100];
1243
1244        let encrypted = encrypt_segments(&data, &key, &key_data).unwrap();
1245        let decrypted = decrypt_package_agile_inner(&encrypted, &key, &key_data, data.len());
1246
1247        assert_eq!(decrypted, data);
1248    }
1249
1250    /// Decrypt raw encrypted content (no size prefix) for testing.
1251    fn decrypt_package_agile_inner(
1252        encrypted_content: &[u8],
1253        key: &[u8],
1254        key_data: &KeyData,
1255        original_size: usize,
1256    ) -> Vec<u8> {
1257        let mut decrypted = Vec::with_capacity(original_size);
1258        let mut segment_index = 0u32;
1259
1260        for chunk in encrypted_content.chunks(SEGMENT_SIZE) {
1261            let iv = generate_iv(
1262                &key_data.salt_value,
1263                &segment_index.to_le_bytes(),
1264                key_data.block_size,
1265                HashAlgorithm::Sha512,
1266            )
1267            .unwrap();
1268            let decrypted_chunk = aes_cbc_decrypt(key, &iv, chunk).unwrap();
1269            decrypted.extend_from_slice(&decrypted_chunk);
1270            segment_index += 1;
1271        }
1272
1273        decrypted.truncate(original_size);
1274        decrypted
1275    }
1276
1277    #[test]
1278    fn test_parse_agile_encryption_info_xml() {
1279        let xml = br#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
1280<encryption xmlns="http://schemas.microsoft.com/office/2006/encryption"
1281            xmlns:p="http://schemas.microsoft.com/office/2006/keyEncryptor/password">
1282    <keyData saltSize="16" blockSize="16" keyBits="256"
1283             hashSize="64" cipherAlgorithm="AES"
1284             cipherChaining="ChainingModeCBC"
1285             hashAlgorithm="SHA512"
1286             saltValue="AAAAAAAAAAAAAAAAAAAAAA=="/>
1287    <dataIntegrity encryptedHmacKey="AAAAAAAAAAAAAAAAAAAAAA=="
1288                   encryptedHmacValue="AAAAAAAAAAAAAAAAAAAAAA=="/>
1289    <keyEncryptors>
1290        <keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password">
1291            <p:encryptedKey spinCount="100000"
1292                            saltSize="16" blockSize="16" keyBits="256" hashSize="64"
1293                            cipherAlgorithm="AES" cipherChaining="ChainingModeCBC"
1294                            hashAlgorithm="SHA512"
1295                            saltValue="AAAAAAAAAAAAAAAAAAAAAA=="
1296                            encryptedVerifierHashInput="AAAAAAAAAAAAAAAAAAAAAA=="
1297                            encryptedVerifierHashValue="AAAAAAAAAAAAAAAAAAAAAA=="
1298                            encryptedKeyValue="AAAAAAAAAAAAAAAAAAAAAA=="/>
1299        </keyEncryptor>
1300    </keyEncryptors>
1301</encryption>"#;
1302
1303        let info = parse_agile_encryption_info(xml).unwrap();
1304        assert_eq!(info.key_data.key_bits, 256);
1305        assert_eq!(info.key_data.hash_algorithm, "SHA512");
1306        assert_eq!(info.key_data.cipher_algorithm, "AES");
1307        assert_eq!(info.key_encryptors.len(), 1);
1308        assert_eq!(info.key_encryptors[0].spin_count, 100000);
1309    }
1310
1311    #[test]
1312    fn test_serialize_agile_encryption_info_roundtrip() {
1313        let info = AgileEncryptionInfo {
1314            key_data: KeyData {
1315                salt_size: 16,
1316                block_size: 16,
1317                key_bits: 256,
1318                hash_size: 64,
1319                cipher_algorithm: "AES".to_string(),
1320                cipher_chaining: "ChainingModeCBC".to_string(),
1321                hash_algorithm: "SHA512".to_string(),
1322                salt_value: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
1323            },
1324            data_integrity: DataIntegrity {
1325                encrypted_hmac_key: vec![0u8; 64],
1326                encrypted_hmac_value: vec![0u8; 64],
1327            },
1328            key_encryptors: vec![KeyEncryptor {
1329                spin_count: 100_000,
1330                salt_size: 16,
1331                block_size: 16,
1332                key_bits: 256,
1333                hash_size: 64,
1334                cipher_algorithm: "AES".to_string(),
1335                cipher_chaining: "ChainingModeCBC".to_string(),
1336                hash_algorithm: "SHA512".to_string(),
1337                salt_value: vec![0u8; 16],
1338                encrypted_verifier_hash_input: vec![0u8; 32],
1339                encrypted_verifier_hash_value: vec![0u8; 64],
1340                encrypted_key_value: vec![0u8; 32],
1341            }],
1342        };
1343
1344        let xml = serialize_agile_encryption_info(&info).unwrap();
1345        assert!(xml.contains("keyData"));
1346        assert!(xml.contains("dataIntegrity"));
1347        assert!(xml.contains("p:encryptedKey"));
1348        assert!(xml.contains("spinCount=\"100000\""));
1349
1350        // Parse it back
1351        // Skip the XML declaration line
1352        let xml_body = xml.split('\n').skip(1).collect::<Vec<_>>().join("\n");
1353        let parsed = parse_agile_encryption_info(xml_body.as_bytes()).unwrap();
1354        assert_eq!(parsed.key_data.key_bits, 256);
1355        assert_eq!(parsed.key_encryptors.len(), 1);
1356        assert_eq!(parsed.key_encryptors[0].spin_count, 100_000);
1357    }
1358
1359    #[test]
1360    fn test_hmac_sha512() {
1361        let key = b"test key";
1362        let data = b"test data";
1363        let hmac1 = HashAlgorithm::Sha512.hmac(key, data).unwrap();
1364        let hmac2 = HashAlgorithm::Sha512.hmac(key, data).unwrap();
1365        assert_eq!(hmac1, hmac2);
1366        assert_eq!(hmac1.len(), 64); // SHA-512 output is 64 bytes
1367
1368        // Different data produces different HMAC
1369        let hmac3 = HashAlgorithm::Sha512.hmac(key, b"other data").unwrap();
1370        assert_ne!(hmac1, hmac3);
1371    }
1372
1373    #[test]
1374    fn test_full_encrypt_decrypt_roundtrip() {
1375        // Use small spin count for test speed
1376        let original_data = b"This is a test ZIP file content for encryption roundtrip";
1377
1378        // We can't easily test the full pipeline with 100K iterations,
1379        // so test the segment encrypt/decrypt and the full API separately.
1380        let key = [0x42u8; 32];
1381        let key_data = KeyData {
1382            salt_size: 16,
1383            block_size: 16,
1384            key_bits: 256,
1385            hash_size: 64,
1386            cipher_algorithm: "AES".to_string(),
1387            cipher_chaining: "ChainingModeCBC".to_string(),
1388            hash_algorithm: "SHA512".to_string(),
1389            salt_value: vec![0u8; 16],
1390        };
1391
1392        // Encrypt
1393        let encrypted = encrypt_segments(original_data, &key, &key_data).unwrap();
1394
1395        // Build the encrypted package with size prefix
1396        let mut package = Vec::new();
1397        package.extend_from_slice(&(original_data.len() as u64).to_le_bytes());
1398        package.extend_from_slice(&encrypted);
1399
1400        // Decrypt
1401        let decrypted = decrypt_package_agile(&package, &key, &key_data).unwrap();
1402        assert_eq!(decrypted, original_data);
1403    }
1404
1405    #[test]
1406    fn hash_dispatch_and_iv_vectors() {
1407        assert_eq!(
1408            HashAlgorithm::Sha1.digest(&[b"abc"]),
1409            vec![
1410                0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a, 0xba, 0x3e, 0x25, 0x71, 0x78, 0x50,
1411                0xc2, 0x6c, 0x9c, 0xd0, 0xd8, 0x9d
1412            ]
1413        );
1414        assert!(HashAlgorithm::parse("SHA1", 64).is_err());
1415        assert!(HashAlgorithm::parse("MD5", 16).is_err());
1416
1417        let iv = generate_iv(
1418            b"0123456789abcdef",
1419            &7u32.to_le_bytes(),
1420            16,
1421            HashAlgorithm::Sha1,
1422        )
1423        .unwrap();
1424        assert_eq!(
1425            iv,
1426            vec![
1427                0xda, 0x3b, 0x7b, 0x6f, 0xca, 0x68, 0xac, 0x62, 0x60, 0xdf, 0xe0, 0x6e, 0x9c, 0xb5,
1428                0x80, 0x7a
1429            ]
1430        );
1431    }
1432
1433    #[test]
1434    fn parses_password_encryptor_after_certificate_encryptor() {
1435        let xml = br#"<encryption>
1436          <keyData saltSize="16" blockSize="16" keyBits="128" hashSize="20"
1437            cipherAlgorithm="AES" cipherChaining="ChainingModeCBC" hashAlgorithm="SHA1"
1438            saltValue="AAAAAAAAAAAAAAAAAAAAAA=="/>
1439          <dataIntegrity encryptedHmacKey="AAAAAAAAAAAAAAAAAAAAAA=="
1440            encryptedHmacValue="AAAAAAAAAAAAAAAAAAAAAA=="/>
1441          <keyEncryptors>
1442            <keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/certificate">
1443              <c:encryptedKey encryptedKeyValue="AQID"/>
1444            </keyEncryptor>
1445            <keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password">
1446              <p:encryptedKey spinCount="1" saltSize="16" blockSize="16" keyBits="128"
1447                hashSize="20" cipherAlgorithm="AES" cipherChaining="ChainingModeCBC"
1448                hashAlgorithm="SHA1" saltValue="AAAAAAAAAAAAAAAAAAAAAA=="
1449                encryptedVerifierHashInput="AAAAAAAAAAAAAAAAAAAAAA=="
1450                encryptedVerifierHashValue="AAAAAAAAAAAAAAAAAAAAAAAAAAA="
1451                encryptedKeyValue="AAAAAAAAAAAAAAAAAAAAAA=="/>
1452            </keyEncryptor>
1453          </keyEncryptors>
1454        </encryption>"#;
1455        let info = parse_agile_encryption_info(xml).unwrap();
1456        assert_eq!(info.key_encryptors.len(), 1);
1457        assert_eq!(info.key_encryptors[0].hash_algorithm, "SHA1");
1458    }
1459
1460    #[test]
1461    fn data_integrity_covers_size_ciphertext_and_hmac_fields() {
1462        let key = [0x42; 16];
1463        let key_data = KeyData {
1464            salt_size: 16,
1465            block_size: 16,
1466            key_bits: 128,
1467            hash_size: 20,
1468            cipher_algorithm: "AES".into(),
1469            cipher_chaining: "ChainingModeCBC".into(),
1470            hash_algorithm: "SHA1".into(),
1471            salt_value: vec![0x11; 16],
1472        };
1473        let mut package = (5u64).to_le_bytes().to_vec();
1474        package.extend_from_slice(&[0x33; 16]);
1475        let integrity = create_data_integrity(&package, &key, &key_data).unwrap();
1476        assert_eq!(integrity.encrypted_hmac_key.len(), 32);
1477        assert_eq!(integrity.encrypted_hmac_value.len(), 32);
1478        verify_data_integrity(&package, &key, &key_data, &integrity).unwrap();
1479
1480        for index in [0, 8] {
1481            let mut tampered = package.clone();
1482            tampered[index] ^= 1;
1483            assert!(verify_data_integrity(&tampered, &key, &key_data, &integrity).is_err());
1484        }
1485        let mut tampered_integrity = integrity.clone();
1486        tampered_integrity.encrypted_hmac_value[0] ^= 1;
1487        assert!(verify_data_integrity(&package, &key, &key_data, &tampered_integrity).is_err());
1488        tampered_integrity = integrity.clone();
1489        tampered_integrity.encrypted_hmac_key[0] ^= 1;
1490        assert!(verify_data_integrity(&package, &key, &key_data, &tampered_integrity).is_err());
1491    }
1492
1493    #[test]
1494    fn generated_package_password_and_integrity_roundtrip() {
1495        let plaintext = b"PK\x03\x04agile roundtrip";
1496        let (package, info) = encrypt_package_agile(plaintext, "secret").unwrap();
1497        let key = verify_password_agile("secret", &info.key_encryptors[0]).unwrap();
1498        verify_data_integrity(&package, &key, &info.key_data, &info.data_integrity).unwrap();
1499        assert_eq!(
1500            decrypt_package_agile(&package, &key, &info.key_data).unwrap(),
1501            plaintext
1502        );
1503        assert!(matches!(
1504            verify_password_agile("wrong", &info.key_encryptors[0]),
1505            Err(Error::IncorrectPassword)
1506        ));
1507    }
1508
1509    fn deterministic_agile_vector(hash: HashAlgorithm) -> (Vec<u8>, AgileEncryptionInfo, Vec<u8>) {
1510        let hash_size = hash.output_size() as u32;
1511        let hash_algorithm = match hash {
1512            HashAlgorithm::Sha1 => "SHA1",
1513            HashAlgorithm::Sha256 => "SHA256",
1514            HashAlgorithm::Sha384 => "SHA384",
1515            HashAlgorithm::Sha512 => "SHA512",
1516        };
1517        let key_data = KeyData {
1518            salt_size: 16,
1519            block_size: 16,
1520            key_bits: 128,
1521            hash_size,
1522            cipher_algorithm: "AES".into(),
1523            cipher_chaining: "ChainingModeCBC".into(),
1524            hash_algorithm: hash_algorithm.into(),
1525            salt_value: (0x10..0x20).collect(),
1526        };
1527        let encryptor_salt: Vec<u8> = (0x20..0x30).collect();
1528        let secret_key: Vec<u8> = (0x30..0x40).collect();
1529        let verifier_input: Vec<u8> = (0x40..0x50).collect();
1530        let password = "correct horse battery staple";
1531        let spin_count = 3;
1532
1533        let encryptor = KeyEncryptor {
1534            spin_count,
1535            salt_size: 16,
1536            block_size: 16,
1537            key_bits: 128,
1538            hash_size,
1539            cipher_algorithm: "AES".into(),
1540            cipher_chaining: "ChainingModeCBC".into(),
1541            hash_algorithm: hash_algorithm.into(),
1542            salt_value: encryptor_salt.clone(),
1543            encrypted_verifier_hash_input: aes_cbc_encrypt(
1544                &derive_key_agile(
1545                    password,
1546                    &encryptor_salt,
1547                    spin_count,
1548                    128,
1549                    super::super::block_keys::VERIFIER_HASH_INPUT,
1550                    hash,
1551                )
1552                .unwrap(),
1553                &encryptor_salt,
1554                &verifier_input,
1555            )
1556            .unwrap(),
1557            encrypted_verifier_hash_value: aes_cbc_encrypt(
1558                &derive_key_agile(
1559                    password,
1560                    &encryptor_salt,
1561                    spin_count,
1562                    128,
1563                    super::super::block_keys::VERIFIER_HASH_VALUE,
1564                    hash,
1565                )
1566                .unwrap(),
1567                &encryptor_salt,
1568                &hash.digest(&[&verifier_input]),
1569            )
1570            .unwrap(),
1571            encrypted_key_value: aes_cbc_encrypt(
1572                &derive_key_agile(
1573                    password,
1574                    &encryptor_salt,
1575                    spin_count,
1576                    128,
1577                    super::super::block_keys::KEY_VALUE,
1578                    hash,
1579                )
1580                .unwrap(),
1581                &encryptor_salt,
1582                &secret_key,
1583            )
1584            .unwrap(),
1585        };
1586        let mut plaintext = b"PK\x03\x04 deterministic agile package ".to_vec();
1587        plaintext.extend(std::iter::repeat_n(b'x', SEGMENT_SIZE + 17));
1588        let mut package = (plaintext.len() as u64).to_le_bytes().to_vec();
1589        package.extend(encrypt_segments(&plaintext, &secret_key, &key_data).unwrap());
1590
1591        let hmac_key: Vec<u8> = (0x50..).take(hash.output_size()).collect();
1592        let data_integrity = DataIntegrity {
1593            encrypted_hmac_key: aes_cbc_encrypt(
1594                &secret_key,
1595                &generate_iv(
1596                    &key_data.salt_value,
1597                    super::super::block_keys::HMAC_KEY,
1598                    key_data.block_size,
1599                    hash,
1600                )
1601                .unwrap(),
1602                &hmac_key,
1603            )
1604            .unwrap(),
1605            encrypted_hmac_value: aes_cbc_encrypt(
1606                &secret_key,
1607                &generate_iv(
1608                    &key_data.salt_value,
1609                    super::super::block_keys::HMAC_VALUE,
1610                    key_data.block_size,
1611                    hash,
1612                )
1613                .unwrap(),
1614                &hash.hmac(&hmac_key, &package).unwrap(),
1615            )
1616            .unwrap(),
1617        };
1618        (
1619            package,
1620            AgileEncryptionInfo {
1621                key_data,
1622                data_integrity,
1623                key_encryptors: vec![encryptor],
1624            },
1625            plaintext,
1626        )
1627    }
1628
1629    #[test]
1630    fn decrypts_and_authenticates_all_agile_hash_variants() {
1631        for hash in [
1632            HashAlgorithm::Sha1,
1633            HashAlgorithm::Sha256,
1634            HashAlgorithm::Sha384,
1635            HashAlgorithm::Sha512,
1636        ] {
1637            let (package, info, plaintext) = deterministic_agile_vector(hash);
1638            let encryptor = &info.key_encryptors[0];
1639            let key = verify_password_agile("correct horse battery staple", encryptor).unwrap();
1640            verify_data_integrity(&package, &key, &info.key_data, &info.data_integrity).unwrap();
1641            assert_eq!(
1642                decrypt_package_agile(&package, &key, &info.key_data).unwrap(),
1643                plaintext
1644            );
1645            assert!(matches!(
1646                verify_password_agile("wrong password", encryptor),
1647                Err(Error::IncorrectPassword)
1648            ));
1649
1650            let mut tampered_package = package.clone();
1651            tampered_package[8] ^= 1;
1652            assert!(verify_data_integrity(
1653                &tampered_package,
1654                &key,
1655                &info.key_data,
1656                &info.data_integrity
1657            )
1658            .is_err());
1659
1660            let mut tampered_integrity = info.data_integrity.clone();
1661            tampered_integrity.encrypted_hmac_value[0] ^= 1;
1662            assert!(
1663                verify_data_integrity(&package, &key, &info.key_data, &tampered_integrity).is_err()
1664            );
1665        }
1666    }
1667
1668    /// Build a container whose password encryptor and package key use
1669    /// independent AES key sizes, written through the crate's CFB writer.
1670    fn mixed_key_size_container(
1671        encryptor_key_bits: u32,
1672        package_key_bits: u32,
1673        plaintext: &[u8],
1674    ) -> (AgileEncryptionInfo, Vec<u8>) {
1675        let hash = HashAlgorithm::Sha512;
1676        let password = "mixed sizes";
1677        let spin_count = 3;
1678        let encryptor_salt: Vec<u8> = (0x20..0x30).collect();
1679        let secret_key: Vec<u8> = (0x30..).take(package_key_bits as usize / 8).collect();
1680        let verifier_input: Vec<u8> = (0x40..0x50).collect();
1681        let key_data = KeyData {
1682            salt_size: 16,
1683            block_size: 16,
1684            key_bits: package_key_bits,
1685            hash_size: 64,
1686            cipher_algorithm: "AES".into(),
1687            cipher_chaining: "ChainingModeCBC".into(),
1688            hash_algorithm: "SHA512".into(),
1689            salt_value: (0x10..0x20).collect(),
1690        };
1691        let wrap = |block_key: &[u8], data: &[u8]| {
1692            let key = derive_key_agile(
1693                password,
1694                &encryptor_salt,
1695                spin_count,
1696                encryptor_key_bits,
1697                block_key,
1698                hash,
1699            )
1700            .unwrap();
1701            aes_cbc_encrypt(&key, &encryptor_salt, data).unwrap()
1702        };
1703        let encryptor = KeyEncryptor {
1704            spin_count,
1705            salt_size: 16,
1706            block_size: 16,
1707            key_bits: encryptor_key_bits,
1708            hash_size: 64,
1709            cipher_algorithm: "AES".into(),
1710            cipher_chaining: "ChainingModeCBC".into(),
1711            hash_algorithm: "SHA512".into(),
1712            salt_value: encryptor_salt.clone(),
1713            encrypted_verifier_hash_input: wrap(
1714                super::super::block_keys::VERIFIER_HASH_INPUT,
1715                &verifier_input,
1716            ),
1717            encrypted_verifier_hash_value: wrap(
1718                super::super::block_keys::VERIFIER_HASH_VALUE,
1719                &hash.digest(&[&verifier_input]),
1720            ),
1721            encrypted_key_value: wrap(super::super::block_keys::KEY_VALUE, &secret_key),
1722        };
1723        let mut package = (plaintext.len() as u64).to_le_bytes().to_vec();
1724        package.extend(encrypt_segments(plaintext, &secret_key, &key_data).unwrap());
1725        let data_integrity = create_data_integrity(&package, &secret_key, &key_data).unwrap();
1726        let info = AgileEncryptionInfo {
1727            key_data,
1728            data_integrity,
1729            key_encryptors: vec![encryptor],
1730        };
1731        (info, package)
1732    }
1733
1734    fn encryption_info_with(key_data_salt_size: &str, spin_count: &str) -> Vec<u8> {
1735        format!(
1736            r#"<encryption><keyData saltSize="{key_data_salt_size}" blockSize="16" keyBits="256" hashSize="64" cipherAlgorithm="AES" cipherChaining="ChainingModeCBC" hashAlgorithm="SHA512" saltValue="AAAAAAAAAAAAAAAAAAAAAA=="/><dataIntegrity encryptedHmacKey="AA==" encryptedHmacValue="AA=="/><keyEncryptors><keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password"><p:encryptedKey spinCount="{spin_count}" saltSize="16" blockSize="16" keyBits="256" hashSize="64" cipherAlgorithm="AES" cipherChaining="ChainingModeCBC" hashAlgorithm="SHA512" saltValue="AAAAAAAAAAAAAAAAAAAAAA==" encryptedVerifierHashInput="AA==" encryptedVerifierHashValue="AA==" encryptedKeyValue="AA=="/></keyEncryptor></keyEncryptors></encryption>"#
1737        )
1738        .into_bytes()
1739    }
1740
1741    #[test]
1742    fn malformed_numeric_attributes_are_rejected_not_zeroed() {
1743        let parsed = parse_agile_encryption_info(&encryption_info_with("16", "100000")).unwrap();
1744        assert_eq!(parsed.key_encryptors[0].spin_count, 100_000);
1745
1746        for spin_count in ["", "abc", "-1", "+5", "1e5", " 5", "4294967296"] {
1747            let result = parse_agile_encryption_info(&encryption_info_with("16", spin_count));
1748            assert!(result.is_err(), "spinCount {spin_count:?} must be rejected");
1749        }
1750        for salt_size in ["sixteen", "16.0", "0x10"] {
1751            let result = parse_agile_encryption_info(&encryption_info_with(salt_size, "1"));
1752            assert!(result.is_err(), "saltSize {salt_size:?} must be rejected");
1753        }
1754    }
1755
1756    #[test]
1757    fn salt_size_must_be_within_specification_range() {
1758        for salt_size in ["0", "65537", "4294967295"] {
1759            let error = parse_agile_encryption_info(&encryption_info_with(salt_size, "1"))
1760                .expect_err("out-of-range saltSize must be rejected");
1761            assert!(matches!(error, Error::UnsupportedEncryption(_)), "{error}");
1762        }
1763        for salt_size in ["1", "65536"] {
1764            let parsed = parse_agile_encryption_info(&encryption_info_with(salt_size, "1"))
1765                .expect("in-range saltSize parses");
1766            assert_eq!(parsed.key_data.salt_size, salt_size.parse::<u32>().unwrap());
1767        }
1768        let encryptor_out_of_range = String::from_utf8(encryption_info_with("16", "1"))
1769            .unwrap()
1770            .replace(
1771                r#"spinCount="1" saltSize="16""#,
1772                r#"spinCount="1" saltSize="0""#,
1773            );
1774        assert!(matches!(
1775            parse_agile_encryption_info(encryptor_out_of_range.as_bytes()),
1776            Err(Error::UnsupportedEncryption(_))
1777        ));
1778    }
1779
1780    #[test]
1781    fn constant_time_eq_matches_slice_equality() {
1782        assert!(constant_time_eq(b"abc", b"abc"));
1783        assert!(constant_time_eq(b"", b""));
1784        assert!(!constant_time_eq(b"abc", b"abd"));
1785        assert!(!constant_time_eq(b"abc", b"ab"));
1786    }
1787
1788    #[test]
1789    fn decrypts_mixed_password_and_package_key_sizes() {
1790        let mut plaintext = b"PK\x03\x04 mixed key sizes ".to_vec();
1791        plaintext.extend(std::iter::repeat_n(b'y', SEGMENT_SIZE + 5));
1792        for (encryptor_bits, package_bits) in [(128, 256), (256, 128), (192, 256), (256, 192)] {
1793            let (info, package) =
1794                mixed_key_size_container(encryptor_bits, package_bits, &plaintext);
1795            let container = super::super::cfb_io::write_cfb_streams(&info, &package).unwrap();
1796            let decrypted =
1797                super::super::decrypt_xlsx(&container, "mixed sizes").unwrap_or_else(|error| {
1798                    panic!("AES-{encryptor_bits} wrap / AES-{package_bits} package: {error}")
1799                });
1800            assert_eq!(decrypted, plaintext);
1801            assert!(matches!(
1802                super::super::decrypt_xlsx(&container, "wrong"),
1803                Err(Error::IncorrectPassword)
1804            ));
1805
1806            // Integrity must still be enforced with the package-sized key.
1807            let mut tampered = package.clone();
1808            tampered[8] ^= 1;
1809            let tampered = super::super::cfb_io::write_cfb_streams(&info, &tampered).unwrap();
1810            let error = super::super::decrypt_xlsx(&tampered, "mixed sizes").unwrap_err();
1811            assert!(
1812                error.to_string().contains("integrity"),
1813                "unexpected error: {error}"
1814            );
1815        }
1816    }
1817
1818    #[test]
1819    fn decrypts_independent_fixed_agile_hash_vectors() {
1820        use base64::Engine;
1821
1822        struct Vector {
1823            algorithm: &'static str,
1824            hash_size: u32,
1825            verifier_input: &'static str,
1826            verifier_hash: &'static str,
1827            encrypted_key: &'static str,
1828            package: &'static str,
1829            hmac_key: &'static str,
1830            hmac_value: &'static str,
1831        }
1832
1833        // Generated independently with Python hashlib/hmac and OpenSSL 3.6.3
1834        // AES-CBC from the MS-OFFCRYPTO Agile derivation procedure.
1835        let vectors = [
1836            Vector {
1837                algorithm: "SHA1",
1838                hash_size: 20,
1839                verifier_input: "LPesWa5gJXU6F36RRsb7pw==",
1840                verifier_hash: "hbKym57nkI8B9Dt8FJ35uk0do1BHaebCSRCj9qOevkc=",
1841                encrypted_key: "cVf73NcAwn8b8k0rD4MRaw==",
1842                package: "HQAAAAAAAADcNX58VY7FvJ9zrMGJQSu3rC32zaBbMzaeZYoK2fW6lw==",
1843                hmac_key: "cokst1GSTFV1I+36ijSQ58QEEaqwKaoG/p/8zEYg7W8=",
1844                hmac_value: "Uaj+/hcqe51kUHfmeVdfT+D8KPr90xqjkRLtysvQSrc=",
1845            },
1846            Vector {
1847                algorithm: "SHA256",
1848                hash_size: 32,
1849                verifier_input: "uf/wC2EyRwoIjsAZmyBHgA==",
1850                verifier_hash: "WunyS6GevYmXymbYWklhwmE+X36XWv7uPAyt00+dQ/g=",
1851                encrypted_key: "aOHFsocUbK6NB062FZFjRA==",
1852                package: "HQAAAAAAAACzIQZDZGFqwswdpWy2G6UhMtteUlYG2LEB3Pri5jWbBQ==",
1853                hmac_key: "ac8Gte/w4X+MHgFIw8Gr0POjFOMqweDdXZPrJ8H8ihM=",
1854                hmac_value: "E2rvI36dITc56SBGgeryai6Qo8k8qZuDnrpS+xbN0HU=",
1855            },
1856            Vector {
1857                algorithm: "SHA384",
1858                hash_size: 48,
1859                verifier_input: "hF46yNgIbarHOPPUIniAAA==",
1860                verifier_hash: "P9dsL9URWSXVQJnibMc/2e9iltYeyV/YvZb9PcWfD36lkRY5bIh+db+EoLqug1+8",
1861                encrypted_key: "iFmqheH2XB7i35xvShS/5A==",
1862                package: "HQAAAAAAAABYeImSz8OdwUC1dJ94kU7hVrQB0SfLDdyT0jeLDYxpCQ==",
1863                hmac_key: "uWHm9XgmWbp/vbWmylz3k4oK+PM6XbU7CEm+wG2VeNMHwGjIMsJ5kXlTUCVGgNyj",
1864                hmac_value: "jFRsga1ZKMIQGs0XjXYzxso/Xz0WuaKwFHfK16jlOT8pmtdnqW5OBuvWP2B5mlOC",
1865            },
1866            Vector {
1867                algorithm: "SHA512",
1868                hash_size: 64,
1869                verifier_input: "wdgPdXWpGqp2IYgK99NiGg==",
1870                verifier_hash: "TYcmVMXS+7IK1J+jxPhuhGgD3OEM047slC+Y7MpRo5MWRft0/yfNQBo2EkMhYAa1TcPl9+6kHjZBUwMRh3wNlQ==",
1871                encrypted_key: "b+6qEojktO/JlBKkc1zLLg==",
1872                package: "HQAAAAAAAAByWleTxijyGj9rTxmTn10I6GtjBup1orC5hjWW7t2FSA==",
1873                hmac_key: "qR5vt7/zXZExwHHYufqPBDPFEUzOMX5hEo3g/7ECx0x/VeHEcdc+W6A+iBw75iHsJqNo8bpOhA9FS+3XA9h7FA==",
1874                hmac_value: "Eb6evYJYzw3sOb4xO7M5ofDIFWI7GmVZ/3Ve6P3b/a2SFhxyE3SDcnMO/eugqrMFhgJ2DKt1OEafR5JPH4EgSQ==",
1875            },
1876        ];
1877        let decode = |value: &str| {
1878            base64::engine::general_purpose::STANDARD
1879                .decode(value)
1880                .unwrap()
1881        };
1882        let plaintext = b"PK\x03\x04 independent agile vector";
1883
1884        for vector in vectors {
1885            let key_data = KeyData {
1886                salt_size: 16,
1887                block_size: 16,
1888                key_bits: 128,
1889                hash_size: vector.hash_size,
1890                cipher_algorithm: "AES".into(),
1891                cipher_chaining: "ChainingModeCBC".into(),
1892                hash_algorithm: vector.algorithm.into(),
1893                salt_value: (0x10..0x20).collect(),
1894            };
1895            let encryptor = KeyEncryptor {
1896                spin_count: 3,
1897                salt_size: 16,
1898                block_size: 16,
1899                key_bits: 128,
1900                hash_size: vector.hash_size,
1901                cipher_algorithm: "AES".into(),
1902                cipher_chaining: "ChainingModeCBC".into(),
1903                hash_algorithm: vector.algorithm.into(),
1904                salt_value: (0x20..0x30).collect(),
1905                encrypted_verifier_hash_input: decode(vector.verifier_input),
1906                encrypted_verifier_hash_value: decode(vector.verifier_hash),
1907                encrypted_key_value: decode(vector.encrypted_key),
1908            };
1909            let package = decode(vector.package);
1910            let integrity = DataIntegrity {
1911                encrypted_hmac_key: decode(vector.hmac_key),
1912                encrypted_hmac_value: decode(vector.hmac_value),
1913            };
1914
1915            let key = verify_password_agile("correct horse battery staple", &encryptor).unwrap();
1916            assert_eq!(key, (0x30..0x40).collect::<Vec<_>>());
1917            verify_data_integrity(&package, &key, &key_data, &integrity).unwrap();
1918            assert_eq!(
1919                &decrypt_package_agile(&package, &key, &key_data).unwrap(),
1920                plaintext
1921            );
1922        }
1923    }
1924}