1use crate::error::{Error, Result};
8use zeroize::Zeroizing;
9
10#[cfg(test)]
11use super::EncryptionInfoLimits;
12use super::{CryptBudget, CryptLimits, EncryptionInfoBudget};
13use crate::resource::ResourceOperation;
14
15const 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#[derive(Debug, Clone)]
110pub struct AgileEncryptionInfo {
111 pub key_data: KeyData,
113 pub data_integrity: DataIntegrity,
115 pub key_encryptors: Vec<KeyEncryptor>,
117}
118
119#[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#[derive(Debug, Clone)]
134pub struct DataIntegrity {
135 pub encrypted_hmac_key: Vec<u8>,
136 pub encrypted_hmac_value: Vec<u8>,
137}
138
139#[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
235pub 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 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 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 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
295fn 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 let mut h = Zeroizing::new(hash_algorithm.digest(&[salt, &password_bytes]));
319
320 for i in 0u32..spin_count {
322 h = Zeroizing::new(hash_algorithm.digest(&[&i.to_le_bytes(), &h]));
323 }
324
325 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
333pub(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
342pub fn verify_password_agile(password: &str, encryptor: &KeyEncryptor) -> Result<Vec<u8>> {
347 verify_password_agile_with_limits(password, encryptor, CryptLimits::default())
348}
349
350pub 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
367pub(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 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 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 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 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 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 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 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
445pub(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
486pub 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
532pub 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
540pub 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 let mut key_data_salt = [0u8; 16];
564 let mut encryptor_salt = [0u8; 16];
565 let mut secret_key = Zeroizing::new([0u8; 32]); 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 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 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 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 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 let encrypted_content = encrypt_segments(data, &*secret_key, &key_data)?;
643
644 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
660fn 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
680fn 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
696fn 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
745fn 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 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 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 left.len() == right.len() && bool::from(left.ct_eq(right))
911}
912
913fn 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
922fn 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
930fn 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
940const 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 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!!!!"; 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 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 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 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); 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 let original_data = b"This is a test ZIP file content for encryption roundtrip";
1377
1378 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 let encrypted = encrypt_segments(original_data, &key, &key_data).unwrap();
1394
1395 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 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 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 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 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}