use std::io::{Cursor, Read, Write};
use zip::write::SimpleFileOptions;
use zip::{ZipArchive, ZipWriter};
use crate::classify::classify;
use crate::decrypt::{
classification_metadata_unchanged, decrypt, decrypt_with_limits, AllocationSite, DecryptError,
};
use crate::test_support::{
append_stored_member, load_golden, load_ladder_fixture, pgp_two_row_zip, read_member,
zip_namelist, NONASCII_PASSWORD, PASSWORD,
};
use crate::{BadParameter, Kdf, ManifestField, MemberFault, Mode, Primitive};
#[test]
fn s1_unencrypted_is_not_encrypted() {
let err = decrypt(&load_golden("lo-unencrypted.odt"), PASSWORD).unwrap_err();
assert!(matches!(err, DecryptError::NotEncrypted));
}
#[test]
fn s1_empty_password() {
let err = decrypt(&load_golden("lo-unencrypted.odt"), "").unwrap_err();
assert!(matches!(err, DecryptError::EmptyPassword));
}
#[test]
fn s1_pgp_zip_unsupported() {
let zip = pgp_two_row_zip();
let class = classify(&zip).expect("pgp zip classifies");
assert!(
!class.pgp_keys.is_empty(),
"pgp_keys from first entry KeyInfo"
);
let err = decrypt(&zip, PASSWORD).unwrap_err();
assert!(matches!(err, DecryptError::UnsupportedPgp));
}
#[test]
fn odf12_fatal_encrypted_package_is_refused() {
let blob = append_stored_member(&load_golden("lo-legacy-aes-cbc.odt"), "extra.bin", b"nope");
let class = classify(&blob).expect("fixture classifies");
assert!(
class.odf12_fatal,
"unlisted root stream on ODF 1.2 must be fatal"
);
assert_eq!(class.mode, Mode::PerEntry);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::Odf12Fatal
));
}
#[test]
fn pre_12_unexpected_stream_still_decrypts() {
let blob = append_stored_member(
&load_golden("aoo-blowfish-pbkdf2.odt"),
"extra.bin",
b"nope",
);
let class = classify(&blob).expect("fixture classifies");
assert!(class.has_unexpected_streams);
assert!(
!class.odf12_fatal,
"no ODF >= 1.2 root version, so not fatal"
);
decrypt(&blob, PASSWORD).expect("ODF 1.1 unexpected streams are not fatal");
}
#[test]
fn s1_goldens_have_empty_pgp_keys() {
for name in [
"lo-unencrypted.odt",
"aoo-blowfish-pbkdf2.odt",
"lo-odf11-nonascii-password.odt",
"lo-legacy-aes-cbc.odt",
"lo-wholesome-gcm-argon2.odt",
] {
let class = classify(&load_golden(name)).expect(name);
assert!(class.pgp_keys.is_empty(), "{name}");
}
}
fn assert_well_formed_xml(body: &[u8]) {
let mut reader = quick_xml::Reader::from_reader(body);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_event_into(&mut buf) {
Ok(quick_xml::events::Event::Eof) => break,
Ok(_) => {}
Err(e) => panic!("malformed XML: {e}"),
}
}
}
fn assert_decrypts_to_plain(golden: &str, password: &str) {
let input = load_golden(golden);
let before = classify(&input).expect("input classifies");
let out = decrypt(&input, password).expect("decrypt");
let after = classify(&out).expect("output classifies");
assert_eq!(after.mode, Mode::Plain);
assert!(after.encrypted_entries.is_empty());
assert!(classification_metadata_unchanged(&before, &after));
let manifest_bytes = read_member(&out, "META-INF/manifest.xml");
let mf = String::from_utf8_lossy(&manifest_bytes);
assert!(!mf.contains("encryption-data"), "{golden}");
assert!(!mf.contains("manifest:size"), "{golden}");
assert_eq!(zip_namelist(&input), zip_namelist(&out), "{golden} members");
for row in &before.encrypted_entries {
if row.path == "encrypted-package" {
continue;
}
let body = read_member(&out, &row.path);
assert_eq!(body.len() as i64, row.size, "{} {}", golden, row.path);
if row.path.ends_with(".xml") || row.path.ends_with(".rdf") {
assert_well_formed_xml(&body);
}
}
}
#[test]
fn s2_blowfish_golden() {
assert_decrypts_to_plain("aoo-blowfish-pbkdf2.odt", PASSWORD);
let err = decrypt(&load_golden("aoo-blowfish-pbkdf2.odt"), "wrong").unwrap_err();
assert!(matches!(err, DecryptError::WrongPassword));
}
#[test]
fn s2_nonascii_password_golden() {
assert_decrypts_to_plain("lo-odf11-nonascii-password.odt", NONASCII_PASSWORD);
let err = decrypt(&load_golden("lo-odf11-nonascii-password.odt"), "wrong").unwrap_err();
assert!(matches!(err, DecryptError::WrongPassword));
}
#[test]
fn s3_aes_cbc_golden() {
assert_decrypts_to_plain("lo-legacy-aes-cbc.odt", PASSWORD);
let err = decrypt(&load_golden("lo-legacy-aes-cbc.odt"), "wrong").unwrap_err();
assert!(matches!(err, DecryptError::WrongPassword));
}
#[test]
fn s4_wholesome_gcm_golden() {
let input = load_golden("lo-wholesome-gcm-argon2.odt");
let before = classify(&input).unwrap();
let out = decrypt(&input, PASSWORD).expect("wholesome decrypt");
let after = classify(&out).unwrap();
assert_eq!(after.mode, Mode::Plain);
assert!(after.encrypted_entries.is_empty());
assert!(zip_namelist(&out).iter().any(|n| n == "content.xml"));
let row = before
.encrypted_entries
.iter()
.find(|e| e.path == "encrypted-package")
.unwrap();
assert_eq!(out.len() as i64, row.size);
let err = decrypt(&input, "wrong").unwrap_err();
assert!(matches!(err, DecryptError::WrongPassword));
}
type Rewrite = fn(&[u8]) -> Vec<u8>;
fn mutate_zip(
golden: &str,
member: Option<&str>,
member_mut: Option<Rewrite>,
manifest_fn: Option<Rewrite>,
) -> Vec<u8> {
mutate_bytes(&load_golden(golden), member, member_mut, manifest_fn)
}
fn mutate_bytes(
input: &[u8],
member: Option<&str>,
member_mut: Option<Rewrite>,
manifest_fn: Option<Rewrite>,
) -> Vec<u8> {
let mut src = ZipArchive::new(Cursor::new(input)).unwrap();
let mut buf = Vec::new();
let mut out = ZipWriter::new(Cursor::new(&mut buf));
for i in 0..src.len() {
let mut file = src.by_index(i).unwrap();
let name = file.name().unwrap().to_string();
let method = file.compression();
let mut body = Vec::new();
file.read_to_end(&mut body).unwrap();
if let (Some(want), Some(f)) = (member, member_mut) {
if name == want {
body = f(&body);
}
}
if name == "META-INF/manifest.xml" {
if let Some(f) = manifest_fn {
body = f(&body);
}
}
out.start_file(
&name,
SimpleFileOptions::default().compression_method(method),
)
.unwrap();
out.write_all(&body).unwrap();
}
out.finish().unwrap();
buf
}
fn flip_checksum_manifest(xml: &[u8]) -> Vec<u8> {
let s = String::from_utf8_lossy(xml);
let marker = "checksum=\"";
let Some(start) = s.find(marker) else {
return xml.to_vec();
};
let b64_start = start + marker.len();
let mut owned = s.into_owned().into_bytes();
owned[b64_start] ^= 1;
owned
}
#[test]
fn s5_constructed_negatives() {
let blob = mutate_zip(
"aoo-blowfish-pbkdf2.odt",
Some("content.xml"),
Some(|b| b[..b.len().saturating_sub(64)].to_vec()),
None,
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::Inflate(_)
));
let blob = mutate_zip(
"aoo-blowfish-pbkdf2.odt",
None,
None,
Some(flip_checksum_manifest),
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::WrongPassword
));
let blob = mutate_zip(
"aoo-blowfish-pbkdf2.odt",
Some("content.xml"),
Some(|b| {
let mut v = b.to_vec();
v[0] ^= 1;
v
}),
None,
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::WrongPassword
));
let blob = mutate_zip(
"lo-legacy-aes-cbc.odt",
None,
None,
Some(flip_checksum_manifest),
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::WrongPassword
));
let blob = mutate_zip(
"lo-legacy-aes-cbc.odt",
Some("content.xml"),
Some(|b| b[..b.len() - 1].to_vec()),
None,
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::BadParameters(_)
));
let blob = mutate_zip(
"lo-legacy-aes-cbc.odt",
Some("content.xml"),
Some(|b| {
let mut v = b.to_vec();
let last = v.len() - 1;
v[last] ^= 0xff;
v
}),
None,
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::WrongPassword
));
let blob = mutate_zip(
"lo-wholesome-gcm-argon2.odt",
Some("encrypted-package"),
Some(|b| {
let mut v = b.to_vec();
let last = v.len() - 1;
v[last] ^= 1;
v
}),
None,
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::WrongPassword
));
let blob = mutate_zip(
"lo-wholesome-gcm-argon2.odt",
Some("encrypted-package"),
Some(|b| b[..20].to_vec()),
None,
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::BadParameters(_)
));
let blob = mutate_zip(
"lo-wholesome-gcm-argon2.odt",
Some("encrypted-package"),
Some(|b| {
let mut v = b.to_vec();
v[0] ^= 1;
v
}),
None,
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::BadParameters(_)
));
let blob = mutate_zip(
"lo-wholesome-gcm-argon2.odt",
Some("encrypted-package"),
Some(|b| {
let mut v = b.to_vec();
v[40] ^= 1;
v
}),
None,
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::WrongPassword
));
}
fn rewrite_kdf_key_size(xml: &str, to: &str) -> String {
let mut out = String::with_capacity(xml.len());
let mut rest = xml;
while let Some(pos) = rest.find("<manifest:key-derivation") {
let (head, tail) = rest.split_at(pos);
out.push_str(head);
let end = tail.find("/>").map(|e| e + 2).unwrap_or(tail.len());
let (elem, after) = tail.split_at(end);
out.push_str(&elem.replace(
"manifest:key-size=\"32\"",
&format!("manifest:key-size=\"{to}\""),
));
rest = after;
}
out.push_str(rest);
out
}
fn reencrypt_cbc_as_aes128(golden: &str) -> Vec<u8> {
use aes::{Aes128, Aes256};
use cbc::cipher::{BlockDecryptMut, BlockEncryptMut, KeyIvInit};
use pbkdf2::pbkdf2_hmac;
use sha1::Sha1;
use sha2::{Digest, Sha256};
let input = load_golden(golden);
let class = classify(&input).unwrap();
let start = Sha256::digest(PASSWORD.as_bytes()).to_vec();
let mut bodies: std::collections::HashMap<String, Vec<u8>> = Default::default();
for row in &class.encrypted_entries {
let (salt, iters) = match &row.kdf {
Kdf::Pbkdf2 { iterations, salt } => (salt.clone(), *iterations as u32),
other => panic!("expected PBKDF2, got {other:?}"),
};
let mut k32 = vec![0u8; 32];
pbkdf2_hmac::<Sha1>(&start, &salt, iters, &mut k32);
let mut buf = read_member(&input, &row.path);
let mut dec = cbc::Decryptor::<Aes256>::new_from_slices(&k32, &row.iv).unwrap();
for chunk in buf.chunks_mut(16) {
dec.decrypt_block_mut(cbc::cipher::Block::<Aes256>::from_mut_slice(chunk));
}
let pad = *buf.last().unwrap() as usize;
buf.truncate(buf.len() - pad);
let mut k16 = vec![0u8; 16];
pbkdf2_hmac::<Sha1>(&start, &salt, iters, &mut k16);
let padlen = 16 - (buf.len() % 16);
buf.resize(buf.len() + padlen - 1, 0);
buf.push(padlen as u8);
let mut enc = cbc::Encryptor::<Aes128>::new_from_slices(&k16, &row.iv).unwrap();
for chunk in buf.chunks_mut(16) {
enc.encrypt_block_mut(cbc::cipher::Block::<Aes128>::from_mut_slice(chunk));
}
bodies.insert(row.path.clone(), buf);
}
let manifest = String::from_utf8(read_member(&input, "META-INF/manifest.xml")).unwrap();
let manifest = rewrite_kdf_key_size(&manifest.replace("#aes256-cbc", "#aes128-cbc"), "16");
let mut src = ZipArchive::new(Cursor::new(&input)).unwrap();
let mut buf = Vec::new();
let mut out = ZipWriter::new(Cursor::new(&mut buf));
for i in 0..src.len() {
let mut file = src.by_index(i).unwrap();
let name = file.name().unwrap().to_string();
let method = file.compression();
let mut body = Vec::new();
file.read_to_end(&mut body).unwrap();
let body = if name == "META-INF/manifest.xml" {
manifest.clone().into_bytes()
} else {
bodies.get(&name).cloned().unwrap_or(body)
};
out.start_file(
&name,
SimpleFileOptions::default().compression_method(method),
)
.unwrap();
out.write_all(&body).unwrap();
}
out.finish().unwrap();
buf
}
#[test]
fn s3_aes128_cbc_decrypts_rather_than_being_refused() {
let bytes = reencrypt_cbc_as_aes128("lo-legacy-aes-cbc.odt");
let before = classify(&bytes).unwrap();
assert!(!before.encrypted_entries.is_empty());
assert!(
before
.encrypted_entries
.iter()
.all(|e| e.derived_key_len == 16),
"fixture must derive 16-byte keys"
);
let out = decrypt(&bytes, PASSWORD).expect("AES-128 package must decrypt");
let after = classify(&out).unwrap();
assert_eq!(after.mode, Mode::Plain);
assert!(after.encrypted_entries.is_empty());
let want = decrypt(&load_golden("lo-legacy-aes-cbc.odt"), PASSWORD).unwrap();
for path in ["content.xml", "styles.xml", "meta.xml"] {
assert_eq!(read_member(&out, path), read_member(&want, path), "{path}");
}
assert!(matches!(
decrypt(&bytes, "wrong").unwrap_err(),
DecryptError::WrongPassword
));
}
fn add_size_to_self_closing_entry(xml: &[u8]) -> Vec<u8> {
String::from_utf8_lossy(xml)
.replacen(
"<manifest:file-entry manifest:full-path=\"Configurations2/\"",
"<manifest:file-entry manifest:size=\"99\" manifest:full-path=\"Configurations2/\"",
1,
)
.into_bytes()
}
#[test]
fn s2_manifest_size_stripped_from_self_closing_entry() {
let bytes = mutate_zip(
"aoo-blowfish-pbkdf2.odt",
None,
None,
Some(add_size_to_self_closing_entry),
);
let fixture = String::from_utf8(read_member(&bytes, "META-INF/manifest.xml")).unwrap();
assert!(
fixture.contains("manifest:size=\"99\""),
"fixture must carry the attribute it is testing"
);
let out = decrypt(&bytes, PASSWORD).unwrap();
let mf = String::from_utf8(read_member(&out, "META-INF/manifest.xml")).unwrap();
assert!(
!mf.contains("manifest:size"),
"manifest:size must be dropped from self-closing entries too:\n{mf}"
);
assert_eq!(classify(&out).unwrap().mode, Mode::Plain);
}
#[test]
fn truncated_deflate_stream_errors_rather_than_returning_partial_output() {
use miniz_oxide::inflate::decompress_slice_iter_to_slice;
let data: Vec<u8> = (0..4096u32).map(|i| (i % 251) as u8).collect();
let compressed = miniz_oxide::deflate::compress_to_vec(&data, 6);
let mut slot = vec![0u8; data.len()];
assert_eq!(
decompress_slice_iter_to_slice(&mut slot, std::iter::once(&compressed[..]), false, true)
.unwrap(),
data.len()
);
assert_eq!(slot, data);
for cut in [1usize, 4, 16] {
let truncated = &compressed[..compressed.len() - cut];
let mut slot = vec![0u8; data.len()];
assert!(
decompress_slice_iter_to_slice(&mut slot, std::iter::once(truncated), false, true)
.is_err(),
"a stream truncated by {cut} B must be an error, not a short success"
);
}
}
fn rewrite_manifest_size(xml: &[u8], from: &str, to: &str) -> Vec<u8> {
let before = format!("manifest:size=\"{from}\"");
let after = format!("manifest:size=\"{to}\"");
let s = String::from_utf8_lossy(xml);
assert!(s.contains(&before), "fixture must carry {before}");
s.replace(&before, &after).into_bytes()
}
#[test]
fn hostile_manifest_size_is_refused_before_allocating() {
let bytes = mutate_zip(
"lo-wholesome-gcm-argon2.odt",
None,
None,
Some(|xml| rewrite_manifest_size(xml, "6977", "9000000000")),
);
let class = classify(&bytes).expect("classify passes manifest:size through");
assert!(
class
.encrypted_entries
.iter()
.any(|e| e.size == 9_000_000_000),
"fixture must carry the hostile size"
);
match decrypt(&bytes, PASSWORD) {
Err(DecryptError::BadParameters(BadParameter::OutOfRange {
field: ManifestField::Size,
got,
..
})) => assert_eq!(got, 9_000_000_000),
other => panic!("expected the manifest:size refusal, got {other:?}"),
}
}
#[test]
fn overstated_manifest_size_is_rejected_rather_than_zero_padded() {
let bytes = mutate_zip(
"lo-wholesome-gcm-argon2.odt",
None,
None,
Some(|xml| rewrite_manifest_size(xml, "6977", "7000")),
);
match decrypt(&bytes, PASSWORD) {
Err(DecryptError::Inflate(msg)) => assert!(
msg.contains("6977") && msg.contains("7000"),
"message should name both lengths: {msg}"
),
other => panic!("expected Inflate, got {other:?}"),
}
}
fn set_argon2_lanes_to_overflow(xml: &[u8]) -> Vec<u8> {
String::from_utf8_lossy(xml)
.replace(
"loext:argon2-lanes=\"4\"",
"loext:argon2-lanes=\"536870912\"",
)
.into_bytes()
}
fn set_argon2_memory_to_2gib(xml: &[u8]) -> Vec<u8> {
String::from_utf8_lossy(xml)
.replace(
"loext:argon2-memory=\"65536\"",
"loext:argon2-memory=\"2147483647\"",
)
.into_bytes()
}
fn set_argon2_memory_below_lanes(xml: &[u8]) -> Vec<u8> {
String::from_utf8_lossy(xml)
.replace("loext:argon2-memory=\"65536\"", "loext:argon2-memory=\"1\"")
.into_bytes()
}
#[test]
fn argon2_hostile_parameters_are_bad_parameters_not_a_panic() {
for (label, rewrite) in [
(
"lanes 2^29 (overflows Params::new's m < 8p test)",
set_argon2_lanes_to_overflow as Rewrite,
),
(
"memory 2 GiB KiB (~2 TiB of blocks)",
set_argon2_memory_to_2gib,
),
(
"memory 1 KiB (below 8 * lanes)",
set_argon2_memory_below_lanes,
),
] {
let blob = mutate_zip("lo-wholesome-gcm-argon2.odt", None, None, Some(rewrite));
let class = classify(&blob).unwrap_or_else(|e| panic!("{label}: {e}"));
assert_eq!(class.mode, Mode::Wholesome, "{label}");
assert!(
matches!(class.encrypted_entries[0].kdf, Kdf::Argon2id { .. }),
"{label}: fixture must still carry an Argon2id row"
);
let err = decrypt(&blob, PASSWORD).unwrap_err();
assert!(
matches!(err, DecryptError::BadParameters(_)),
"{label}: expected BadParameters, got {err:?}"
);
}
}
#[test]
fn hostile_derived_key_len_is_refused_before_allocating() {
fn huge_key_size(xml: &[u8]) -> Vec<u8> {
rewrite_kdf_key_size(std::str::from_utf8(xml).unwrap(), "2000000000").into_bytes()
}
let bytes = mutate_zip("lo-legacy-aes-cbc.odt", None, None, Some(huge_key_size));
let class = classify(&bytes).expect("classify passes the manifest key-size through");
assert!(
class
.encrypted_entries
.iter()
.all(|e| e.derived_key_len == 2_000_000_000),
"fixture must carry the hostile key-size"
);
match decrypt(&bytes, PASSWORD) {
Err(DecryptError::BadParameters(BadParameter::KeySizeForCipher { got, .. })) => {
assert_eq!(got, 2_000_000_000)
}
other => panic!("expected the key-size refusal, got {other:?}"),
}
}
fn set_pbkdf2_iterations(xml: &[u8], value: &str) -> Vec<u8> {
String::from_utf8_lossy(xml)
.replace(
"manifest:iteration-count=\"100000\"",
&format!("manifest:iteration-count=\"{value}\""),
)
.into_bytes()
}
#[test]
fn hostile_pbkdf2_iterations_are_bad_parameters_not_a_hang() {
let blob = mutate_zip(
"lo-legacy-aes-cbc.odt",
None,
None,
Some(|xml| set_pbkdf2_iterations(xml, "2147483647")),
);
let class = classify(&blob).expect("classify passes iteration-count through");
assert!(
class.encrypted_entries.iter().any(|e| matches!(
e.kdf,
Kdf::Pbkdf2 {
iterations: 2_147_483_647,
..
}
)),
"fixture must carry hostile iteration count"
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::BadParameters(_)
));
}
#[test]
fn pbkdf2_zero_iterations_is_bad_parameters() {
let blob = mutate_zip(
"lo-legacy-aes-cbc.odt",
None,
None,
Some(|xml| set_pbkdf2_iterations(xml, "0")),
);
let class = classify(&blob).expect("classify still accepts a complete row with 0 iterations");
assert!(
class
.encrypted_entries
.iter()
.any(|e| matches!(e.kdf, Kdf::Pbkdf2 { iterations: 0, .. })),
"fixture must carry iteration-count 0"
);
assert!(matches!(
decrypt(&blob, PASSWORD).unwrap_err(),
DecryptError::BadParameters(_)
));
}
#[test]
fn encrypted_entry_count_ceiling_refuses_without_running_kdf() {
assert!(super::ensure_encrypted_entry_count(1, 1).is_ok());
let err = super::ensure_encrypted_entry_count(2, 1).unwrap_err();
assert_eq!(
err.to_string(),
DecryptError::BadParameters(BadParameter::OutOfRange {
field: ManifestField::EncryptedEntries,
got: 2,
min: 0,
max: 1,
})
.to_string()
);
assert!(matches!(
err,
DecryptError::BadParameters(BadParameter::OutOfRange {
field: ManifestField::EncryptedEntries,
got: 2,
max: 1,
..
})
));
}
#[test]
fn gcm_iv_tag_only_frame_is_not_rejected_as_too_short() {
fn iv_tag_only_member(_body: &[u8]) -> Vec<u8> {
let input = load_golden("lo-wholesome-gcm-argon2.odt");
let iv = classify(&input)
.unwrap()
.encrypted_entries
.into_iter()
.find(|e| e.path == "encrypted-package")
.unwrap()
.iv;
let mut frame = vec![0u8; crate::limits::AES_GCM_IV_LEN + crate::limits::AES_GCM_TAG_LEN];
frame[..crate::limits::AES_GCM_IV_LEN].copy_from_slice(&iv);
frame
}
let blob = mutate_zip(
"lo-wholesome-gcm-argon2.odt",
Some("encrypted-package"),
Some(iv_tag_only_member),
None,
);
let err = decrypt(&blob, PASSWORD).unwrap_err();
assert!(
!matches!(
err,
DecryptError::BadParameters(BadParameter::Member(MemberFault::ShorterThanIvAndTag))
),
"IV||tag-only member must reach the cipher, not BadParameters: {err:?}"
);
}
#[test]
fn an_empty_member_inflates_to_nothing() {
use std::io::Read as _;
let compressed = miniz_oxide::deflate::compress_to_vec(&[], 6);
let mut inflate = crate::stream::InflateReader::new(&compressed[..], 0, u64::MAX).unwrap();
let mut out = Vec::new();
inflate
.read_to_end(&mut out)
.expect("an empty member must inflate to nothing, not error");
assert!(out.is_empty());
}
#[test]
fn a_zero_size_refuses_a_stream_that_has_content() {
use std::io::Read as _;
let compressed = miniz_oxide::deflate::compress_to_vec(b"not empty", 6);
let mut inflate = crate::stream::InflateReader::new(&compressed[..], 0, u64::MAX).unwrap();
let err = inflate.read_to_end(&mut Vec::new()).unwrap_err();
assert!(
matches!(
crate::stream::Fault::take(err),
Ok(crate::stream::Fault::Inflate(_))
),
"a non-empty stream must not pass as a zero-size member"
);
}
#[test]
fn zero_is_a_legal_manifest_size_and_negative_is_not() {
assert_eq!(
crate::decrypt::inflated_len(0).expect("0 must be in range"),
0
);
assert!(matches!(
crate::decrypt::inflated_len(-1),
Err(DecryptError::BadParameters(_))
));
}
#[test]
#[ignore = "host-capacity-dependent: passes only when the host has under ~1 GiB free at call time; not reliably true on a well-provisioned machine or CI runner"]
fn argon2_block_buffer_reports_host_capacity_not_an_abort() {
let salt = [0u8; 16];
let mut out = [0u8; 32];
let result = crate::kdf::derive_argon2id(
b"start-key-bytes-are-arbitrary-for-this-probe",
&salt,
1, crate::limits::ARGON2_MAX_M_COST_KIB_READ as i32, 1, &crate::DecryptLimits::default(), &mut out,
);
let requested_bytes = match result {
Err(crate::kdf::KdfError::HostCannotAllocate { requested_bytes }) => requested_bytes,
other => panic!(
"expected KdfError::HostCannotAllocate on this host; got {other:?} instead \
-- this machine had enough free memory to satisfy a 1 GiB Argon2 request, \
so the failure path was not exercised here"
),
};
assert_eq!(requested_bytes, 1 << 30, "1 GiB of Argon2 blocks");
}
#[test]
fn a_host_capacity_failure_is_not_a_bad_parameter() {
let mapped = crate::decrypt::kdf_error(crate::kdf::KdfError::HostCannotAllocate {
requested_bytes: 1 << 30,
});
assert!(
matches!(
mapped,
DecryptError::HostCannotAllocate {
site: AllocationSite::KeyDerivation,
requested_bytes: 1_073_741_824
}
),
"host capacity must not collapse into BadParameters, got {mapped:?}"
);
let reason = BadParameter::OutOfRange {
field: ManifestField::Argon2(crate::Argon2Axis::T),
got: 0,
min: 1,
max: 10,
};
let params = crate::decrypt::kdf_error(crate::kdf::KdfError::Params(reason));
assert!(matches!(params, DecryptError::BadParameters(r) if r == reason));
}
#[test]
fn try_reserve_exact_refuses_an_impossible_request() {
for site in [
AllocationSite::MemberPlaintext,
AllocationSite::PackagePlaintext,
AllocationSite::DerivedKey,
AllocationSite::CipherBuffer,
] {
let got = crate::decrypt::try_zeroed(usize::MAX, site);
assert!(
matches!(
got,
Err(DecryptError::HostCannotAllocate { site: s, requested_bytes })
if s == site && requested_bytes == usize::MAX
),
"{site:?} must return, and must carry its own site, got {got:?}"
);
}
}
#[test]
fn a_fallible_allocation_that_succeeds_is_exact_and_filled() {
let zeroed = crate::decrypt::try_zeroed(64, AllocationSite::DerivedKey)
.expect("64 bytes is not a host-capacity failure");
assert_eq!(zeroed.len(), 64);
assert!(zeroed.iter().all(|b| *b == 0));
assert_eq!(zeroed.capacity(), 64);
}
#[test]
fn every_allocation_site_renders_distinctly() {
let sites = [
AllocationSite::KeyDerivation,
AllocationSite::DerivedKey,
AllocationSite::MemberPlaintext,
AllocationSite::PackagePlaintext,
AllocationSite::CipherBuffer,
];
let mut seen: Vec<String> = sites.iter().map(|s| s.to_string()).collect();
seen.sort();
let before = seen.len();
seen.dedup();
assert_eq!(seen.len(), before, "two sites render the same: {seen:?}");
let e = DecryptError::HostCannotAllocate {
site: AllocationSite::MemberPlaintext,
requested_bytes: 4096,
};
assert_eq!(
e.to_string(),
"host could not allocate 4096 bytes for a decrypted package member"
);
}
fn complete_per_entry_manifest() -> String {
format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<manifest:manifest xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0" manifest:version="1.2">
<manifest:file-entry manifest:full-path="/" manifest:version="1.2" manifest:media-type="{mime}"/>
<manifest:file-entry manifest:full-path="content.xml" manifest:media-type="text/xml" manifest:size="64">
<manifest:encryption-data manifest:checksum-type="{sha1_1k}" manifest:checksum="{b64}">
<manifest:algorithm manifest:algorithm-name="{aes}" manifest:initialisation-vector="{b64}"/>
<manifest:start-key-generation manifest:start-key-generation-name="{sha1}"/>
<manifest:key-derivation manifest:key-derivation-name="{pbkdf2}" manifest:salt="{b64}" manifest:iteration-count="1024" manifest:key-size="32"/>
</manifest:encryption-data>
</manifest:file-entry>
</manifest:manifest>
"#,
mime = crate::test_support::MIME_TEXT,
sha1_1k = crate::uris::SHA1_1K_NAME,
aes = crate::uris::AES256_URL,
sha1 = crate::uris::SHA1_NAME,
pbkdf2 = crate::uris::PBKDF2_NAME,
b64 = crate::test_support::B64,
)
}
#[test]
fn classify_accepting_a_manifest_implies_the_rewrite_accepts_it() {
let base = complete_per_entry_manifest();
assert!(
!crate::manifest::parse_manifest(base.as_bytes()).is_empty(),
"baseline manifest must yield rows, or this test proves nothing"
);
assert!(crate::decrypt::strip_manifest(base.as_bytes()).is_ok());
let injections = [
"<x/>",
"</x>",
"<x>",
"<a/></a>",
"<a></a>",
"<a/><a/>",
"<!--c-->",
"<?pi?>",
"<a/></b>",
"</a>",
"<a></b>",
"&",
"<![CDATA[]]>",
"<a/>t",
"</manifest:manifest>",
"<manifest:file-entry/>",
"]]>",
"<!DOCTYPE m>",
];
let mut candidates: Vec<String> = Vec::new();
for i in 0..base.len() {
if base.is_char_boundary(i) {
candidates.push(base[..i].to_string());
}
}
for (i, _) in base.match_indices('>') {
for inj in injections {
let mut m = String::with_capacity(base.len() + inj.len());
m.push_str(&base[..=i]);
m.push_str(inj);
m.push_str(&base[i + 1..]);
candidates.push(m);
}
}
let mut antecedent_true = 0usize;
let mut strip_refused = 0usize;
for m in &candidates {
let rows_exist = !crate::manifest::parse_manifest(m.as_bytes()).is_empty();
let strip_ok = crate::decrypt::strip_manifest(m.as_bytes()).is_ok();
if !strip_ok {
strip_refused += 1;
}
if rows_exist {
antecedent_true += 1;
assert!(
strip_ok,
"REACHABLE: classify accepts this manifest and the rewrite refuses it, \
so DecryptError::Zip can carry unbounded document text and must now be \
elided (see its rustdoc). Manifest:\n{m}"
);
}
}
assert!(
antecedent_true > 100,
"too few mutations kept classify happy ({antecedent_true}); corpus is not exercising the implication"
);
assert!(
strip_refused > 100,
"too few mutations made the rewrite refuse ({strip_refused}); corpus is not hostile enough"
);
}
#[test]
fn the_pbkdf2_ceiling_is_nists_figure_not_a_round_exponent() {
assert_eq!(
crate::limits::PBKDF2_MAX_ITER,
10_000_000,
"NIST SP 800-132 5.2's own example; `1 << 23` = 8_388_608 refused it. Pinning the exact value also pins that it is above the 600_000 LibreOffice writes -- clippy rejects that as a separate assertion, because both sides are consts and it is decided at compile time."
);
}
#[test]
fn the_default_limits_accept_every_real_libreoffice_golden() {
for name in [
"lo-wholesome-gcm-argon2.odt",
"lo-legacy-aes-cbc.odt",
"aoo-blowfish-pbkdf2.odt",
"lo-opens-our-encrypt-output.odt",
] {
let pw = if name.contains("nonascii") {
NONASCII_PASSWORD
} else {
PASSWORD
};
decrypt(&load_golden(name), pw)
.unwrap_or_else(|e| panic!("{name}: default limits must open real output: {e}"));
}
}
#[test]
fn a_raised_ceiling_opens_what_the_default_refuses() {
fn set_argon2_t_to_12(xml: &[u8]) -> Vec<u8> {
String::from_utf8_lossy(xml)
.replace(
"loext:argon2-iterations=\"3\"",
"loext:argon2-iterations=\"12\"",
)
.into_bytes()
}
let blob = mutate_zip(
"lo-wholesome-gcm-argon2.odt",
None,
None,
Some(set_argon2_t_to_12 as Rewrite),
);
let class = classify(&blob).expect("still classifies");
assert!(matches!(
class.encrypted_entries[0].kdf,
Kdf::Argon2id { t: 12, .. }
));
let err = decrypt(&blob, PASSWORD).expect_err("12 is above the default ceiling of 10");
assert!(
matches!(err, DecryptError::BadParameters(_)),
"a ceiling of ours is BadParameters, got {err:?}"
);
let err = decrypt_with_limits(
&blob,
PASSWORD,
crate::DecryptLimits::default().with_argon2_max_t(16),
)
.expect_err("the rewritten manifest cannot actually decrypt");
assert!(
matches!(err, DecryptError::WrongPassword),
"raising the ceiling must let the derivation run, got {err:?}"
);
}
#[test]
fn permissive_still_defers_to_the_cipher_and_the_host() {
let l = crate::DecryptLimits::PERMISSIVE;
assert_eq!(l.argon2_max_t, i32::MAX as u32);
assert_eq!(l.argon2_max_m_kib, i32::MAX as u32);
let salt = [0u8; 16];
let mut out = [0u8; 32];
let err = crate::kdf::derive_argon2id(b"probe", &salt, 1, 8, 4, &l, &mut out)
.expect_err("m = 8 with p = 4 is below argon2's own m >= 8p");
assert!(
matches!(
err,
crate::kdf::KdfError::Params(BadParameter::CipherRejects {
field: ManifestField::Argon2(crate::Argon2Axis::MKib),
by: Primitive::Argon2,
got: 8,
min: 32,
..
})
),
"{err:?}"
);
}
#[test]
fn a_salt_under_eight_bytes_is_refused_before_the_kdf() {
let mut out = [0u8; 32];
let err = crate::kdf::derive_argon2id(
b"probe",
&[0u8; 7],
1,
8,
1,
&crate::DecryptLimits::default(),
&mut out,
)
.expect_err("a 7-byte salt is below argon2's floor");
assert!(
matches!(
err,
crate::kdf::KdfError::Params(BadParameter::CipherRejects {
field: ManifestField::SaltLen,
by: Primitive::Argon2,
got: 7,
min: 8,
..
})
),
"{err:?}"
);
}
#[test]
fn the_lanes_refusal_names_whose_bound_it_was() {
let salt = [0u8; 16];
let derive = |p: i32, l: &crate::DecryptLimits| {
let mut out = [0u8; 32];
crate::kdf::derive_argon2id(b"probe", &salt, 1, 1024, p, l, &mut out)
};
let ours = derive(17, &crate::DecryptLimits::default());
assert!(
matches!(
ours,
Err(crate::kdf::KdfError::Params(BadParameter::OutOfRange {
field: ManifestField::Argon2(crate::Argon2Axis::P),
got: 17,
max: 16,
..
}))
),
"{ours:?}"
);
let argon2s = derive(0x0100_0000, &crate::DecryptLimits::PERMISSIVE);
assert!(
matches!(
argon2s,
Err(crate::kdf::KdfError::Params(BadParameter::CipherRejects {
by: Primitive::Argon2,
got: 0x0100_0000,
max: 0x00FF_FFFF,
..
}))
),
"{argon2s:?}"
);
let negative = derive(-3, &crate::DecryptLimits::default());
assert!(
matches!(
negative,
Err(crate::kdf::KdfError::Params(BadParameter::OutOfRange {
got: -3,
..
}))
),
"{negative:?}"
);
}
#[test]
fn a_missing_member_is_named_by_index_and_carries_no_path() {
let hostile = format!("evil-{}-path", "X".repeat(1 << 20));
let blob = {
let mut w = ZipWriter::new(Cursor::new(Vec::new()));
w.start_file("mimetype", SimpleFileOptions::default())
.unwrap();
w.write_all(b"application/vnd.oasis.opendocument.text")
.unwrap();
w.finish().unwrap().into_inner()
};
let mut archive = ZipArchive::new(Cursor::new(blob)).unwrap();
let err =
crate::decrypt::member_for_archive(&mut archive, &hostile, crate::decrypt::no_member(3))
.expect_err("no member has that name");
assert!(matches!(
err,
DecryptError::BadParameters(BadParameter::NoMember { row: 3 })
));
for rendered in [err.to_string(), format!("{err:?}")] {
assert!(
!rendered.contains("XXXX"),
"{}",
&rendered[..80.min(rendered.len())]
);
assert!(!rendered.contains("evil"), "{rendered}");
assert!(rendered.len() < 200, "{}", rendered.len());
}
}
#[test]
fn the_defaults_are_the_constants() {
let d = crate::DecryptLimits::default();
assert_eq!(d.argon2_max_t, 10);
assert_eq!(d.argon2_max_m_kib, 1 << 20);
assert_eq!(d.argon2_max_p, 16);
assert_eq!(d.pbkdf2_max_iter, 10_000_000);
}
#[test]
fn every_decrypt_error_variant_is_accounted_for_in_the_cli_exit_map() {
fn accounted_for(e: &DecryptError) {
match e {
DecryptError::Classify(_) => (),
DecryptError::NotEncrypted => (),
DecryptError::EmptyPassword => (),
DecryptError::UnsupportedPgp => (),
DecryptError::Odf12Fatal => (),
DecryptError::WrongPassword => (),
DecryptError::BadParameters(_) => (),
DecryptError::Internal(_) => (),
DecryptError::HostCannotAllocate { .. } => (),
DecryptError::Inflate(_) => (),
DecryptError::Zip(_) => (),
DecryptError::OutputLimit { .. } => (),
DecryptError::Io(_) => (),
}
}
accounted_for(&DecryptError::NotEncrypted);
}
#[test]
fn screen_matches_what_the_cipher_accepts() {
use crate::types::Cipher;
use aes::{Aes128, Aes192, Aes256};
use aes_gcm::aead::consts::U12;
use aes_gcm::{AesGcm, KeyInit};
use blowfish::Blowfish;
use cfb_mode::cipher::KeyIvInit;
for n in 0i32..=80 {
let k = vec![0u8; n as usize];
let actual = |c: Cipher| match c {
Cipher::AesGcmW3c => {
AesGcm::<Aes128, U12>::new_from_slice(&k).is_ok()
|| AesGcm::<Aes192, U12>::new_from_slice(&k).is_ok()
|| AesGcm::<Aes256, U12>::new_from_slice(&k).is_ok()
}
Cipher::AesCbcW3c => {
cbc::Decryptor::<Aes128>::new_from_slices(&k, &[0u8; 16]).is_ok()
|| cbc::Decryptor::<Aes192>::new_from_slices(&k, &[0u8; 16]).is_ok()
|| cbc::Decryptor::<Aes256>::new_from_slices(&k, &[0u8; 16]).is_ok()
}
Cipher::BlowfishCfb8 => {
cfb_mode::BufDecryptor::<Blowfish>::new_from_slices(&k, &[0u8; 8]).is_ok()
}
};
for c in [Cipher::AesGcmW3c, Cipher::AesCbcW3c, Cipher::BlowfishCfb8] {
assert_eq!(
crate::decrypt::cipher_accepts_key_len(c, n),
actual(c),
"screen and cipher disagree for {c:?} at key length {n}"
);
}
}
}
#[test]
fn key_length_is_screened_before_the_kdf_runs() {
let bytes = mutate_zip(
"lo-legacy-aes-cbc.odt",
None,
None,
Some(|xml: &[u8]| {
let s = rewrite_kdf_key_size(std::str::from_utf8(xml).unwrap(), "64");
set_pbkdf2_iterations(s.as_bytes(), "2147483647")
}),
);
let class = classify(&bytes).expect("classify passes both values through");
assert!(
class
.encrypted_entries
.iter()
.all(|e| e.derived_key_len == 64),
"fixture must carry the incompatible key-size"
);
match decrypt(&bytes, PASSWORD) {
Err(DecryptError::BadParameters(BadParameter::KeySizeForCipher { got: 64, .. })) => {}
other => panic!(
"expected the key-size refusal, got {other:?} -- an iteration refusal \
means the KDF was reached first and the screen did not run"
),
}
}
#[test]
fn every_pre_key_fault_is_decided_in_the_screen() {
use crate::decrypt::screen_before_deriving;
use crate::types::{Checksum, Cipher, EntryEncryption, StartKeyAlg};
fn row(cipher: Cipher, iv: Vec<u8>, key_len: i32) -> EntryEncryption {
EntryEncryption {
path: "encrypted-package".into(),
cipher,
kdf: Kdf::Pbkdf2 {
iterations: 100_000,
salt: vec![0u8; 16],
},
start_key: StartKeyAlg::Sha256,
checksum: Checksum::None,
size: 64,
iv,
derived_key_len: key_len,
}
}
let gcm_ok = vec![0u8; 12];
let mut body = gcm_ok.clone();
body.extend_from_slice(&[0u8; 16]);
assert!(screen_before_deriving(&row(Cipher::AesGcmW3c, gcm_ok.clone(), 32), &body).is_ok());
let iv = |by, got: i64, want: i64| BadParameter::CipherRejects {
field: ManifestField::IvLen,
by,
got,
min: want,
max: want,
};
let cases: Vec<(BadParameter, EntryEncryption, Vec<u8>)> = vec![
(
BadParameter::KeySizeForCipher {
got: 64,
cipher: Cipher::AesGcmW3c,
},
row(Cipher::AesGcmW3c, gcm_ok.clone(), 64),
body.clone(),
),
(
iv(Primitive::AesGcm, 11, 12),
row(Cipher::AesGcmW3c, vec![0u8; 11], 32),
body.clone(),
),
(
BadParameter::Member(MemberFault::ShorterThanIvAndTag),
row(Cipher::AesGcmW3c, gcm_ok.clone(), 32),
vec![0u8; 20],
),
(
BadParameter::Member(MemberFault::IvMismatch),
row(Cipher::AesGcmW3c, vec![9u8; 12], 32),
body.clone(),
),
(
iv(Primitive::AesCbc, 15, 16),
row(Cipher::AesCbcW3c, vec![0u8; 15], 32),
vec![0u8; 32],
),
(
BadParameter::Member(MemberFault::NotBlockMultiple),
row(Cipher::AesCbcW3c, vec![0u8; 16], 32),
vec![0u8; 31],
),
(
iv(Primitive::Blowfish, 7, 8),
row(Cipher::BlowfishCfb8, vec![0u8; 7], 16),
vec![0u8; 32],
),
];
for (expected, r, blob) in cases {
match screen_before_deriving(&r, &blob) {
Err(DecryptError::BadParameters(got)) => assert_eq!(got, expected),
other => panic!("expected {expected:?} to be screened, got {other:?}"),
}
}
}
const LADDER_RUNGS: [&str; 3] = [
"ladder-staroffice-utf8.odt",
"ladder-forced-sha256.odt",
"ladder-staroffice-ms1252.odt",
];
#[test]
fn each_ladder_rung_decrypts_to_what_the_golden_does() {
let want = decrypt(
&load_golden("lo-odf11-nonascii-password.odt"),
NONASCII_PASSWORD,
)
.expect("golden decrypts");
for name in LADDER_RUNGS {
let got = decrypt(&load_ladder_fixture(name), NONASCII_PASSWORD)
.unwrap_or_else(|e| panic!("{name}: LibreOffice opens this; got {e:?}"));
assert_eq!(got, want, "{name}");
}
}
#[test]
fn the_ladder_does_not_rescue_a_wrong_password() {
for name in LADDER_RUNGS {
let err = decrypt(&load_ladder_fixture(name), "wrong").unwrap_err();
assert!(
matches!(err, DecryptError::WrongPassword),
"{name}: {err:?}"
);
}
}
#[test]
fn a_key_on_no_rung_is_a_wrong_password() {
let err = decrypt(
&load_ladder_fixture("ladder-not-a-rung.odt"),
NONASCII_PASSWORD,
)
.unwrap_err();
assert!(matches!(err, DecryptError::WrongPassword), "{err:?}");
}
#[test]
fn a_sha256_row_does_not_walk_the_ladder() {
fn declare_sha256(xml: &[u8]) -> Vec<u8> {
String::from_utf8_lossy(xml)
.replace(
"<manifest:key-derivation ",
"<manifest:start-key-generation manifest:start-key-generation-name=\"http://www.w3.org/2000/09/xmldsig#sha256\" manifest:key-size=\"32\"/><manifest:key-derivation ",
)
.into_bytes()
}
let blob = mutate_bytes(
&load_ladder_fixture("ladder-staroffice-utf8.odt"),
None,
None,
Some(declare_sha256),
);
let class = classify(&blob).expect("classifies");
assert!(class
.encrypted_entries
.iter()
.all(|r| r.start_key == crate::StartKeyAlg::Sha256));
let err = decrypt(&blob, NONASCII_PASSWORD).unwrap_err();
assert!(matches!(err, DecryptError::WrongPassword), "{err:?}");
}
#[test]
fn an_unlatched_package_decrypts_with_its_password() {
let pkg = crate::test_support::unlatched_package();
let class = classify(&pkg).expect("classifies");
assert_eq!(class.mode, Mode::PerEntry);
assert!(
!class.package_encrypted,
"no row on content.xml, so no latch"
);
assert!(
class.has_non_encrypted_entries,
"content.xml is a plain stream row"
);
let want = decrypt(&load_golden("lo-legacy-aes-cbc.odt"), PASSWORD).unwrap();
let got = decrypt(&pkg, PASSWORD).expect("decrypts");
for member in ["content.xml", "styles.xml", "settings.xml", "meta.xml"] {
assert_eq!(
read_member(&got, member),
read_member(&want, member),
"{member}"
);
}
let err = decrypt(&pkg, "wrong").unwrap_err();
assert!(matches!(err, DecryptError::WrongPassword), "{err:?}");
}
fn declared_output(bytes: &[u8]) -> u64 {
let class = classify(bytes).unwrap();
let rows: Vec<_> = match class.mode {
Mode::Wholesome => class.wholesome_row().into_iter().collect(),
_ => class.encrypted_entries.iter().collect(),
};
rows.iter().map(|r| u64::try_from(r.size).unwrap()).sum()
}
#[test]
fn max_output_bytes_is_inclusive_in_both_modes() {
for name in ["lo-wholesome-gcm-argon2.odt", "lo-legacy-aes-cbc.odt"] {
let bytes = load_golden(name);
let n = declared_output(&bytes);
assert!(n > 0, "{name}");
let at = crate::DecryptLimits::default().with_max_output_bytes(n);
decrypt_with_limits(&bytes, PASSWORD, at).unwrap_or_else(|e| panic!("{name}: {e:?}"));
let under = at.with_max_output_bytes(n - 1);
let err = decrypt_with_limits(&bytes, PASSWORD, under).unwrap_err();
assert!(
matches!(err, DecryptError::OutputLimit { limit } if limit == n - 1),
"{name}: {err:?}"
);
}
}
#[test]
fn max_output_bytes_is_screened_before_derivation() {
let bytes = load_golden("lo-legacy-aes-cbc.odt");
let limits = crate::DecryptLimits::default().with_max_output_bytes(0);
let err = decrypt_with_limits(&bytes, "not the password", limits).unwrap_err();
assert!(matches!(err, DecryptError::OutputLimit { .. }), "{err:?}");
}
const RC9_DECRYPT_SHA256: &[(&str, &str, &str)] = &[
(
"goldens/aoo-blowfish-pbkdf2.odt",
"PASSWORD",
"002922efaa0a8cf3ace01b5126f929a1554d4d8241555dd1481a8cf593db71b9",
),
(
"goldens/lo-legacy-aes-cbc-image.odt",
"PASSWORD",
"a73047d500a8679ef56b9ec54c0ab60b56c3f3b9b6b786b8bea3d55db7cf6b41",
),
(
"goldens/lo-legacy-aes-cbc.odt",
"PASSWORD",
"22de9ef3b590d90f40dcaa62b3c60971ee0b296da90d412fef90c48f9326da3c",
),
(
"goldens/lo-odf11-nonascii-password.odt",
"NONASCII_PASSWORD",
"fc5ef0ff39da211eac0ae0ef58f9c52c336a6d8bea99bfd3b5ca9fc7fc9cfe26",
),
(
"goldens/lo-opens-our-encrypt-output.odt",
"PASSWORD",
"7ac5e81e7207b42e0939c50fad59f82da3af4f680c0220c436df5db1199e07b5",
),
(
"goldens/lo-wholesome-gcm-argon2.odt",
"PASSWORD",
"49465b813861a7e53b17f511dd7403db44a3053a0df89a77dd5a19e2aa2681da",
),
(
"ladder/ladder-forced-sha256.odt",
"NONASCII_PASSWORD",
"fc5ef0ff39da211eac0ae0ef58f9c52c336a6d8bea99bfd3b5ca9fc7fc9cfe26",
),
(
"ladder/ladder-staroffice-ms1252.odt",
"NONASCII_PASSWORD",
"fc5ef0ff39da211eac0ae0ef58f9c52c336a6d8bea99bfd3b5ca9fc7fc9cfe26",
),
(
"ladder/ladder-staroffice-utf8.odt",
"NONASCII_PASSWORD",
"fc5ef0ff39da211eac0ae0ef58f9c52c336a6d8bea99bfd3b5ca9fc7fc9cfe26",
),
(
"artifacts/argon2-1-1024-1.odt",
"PASSWORD",
"7ac5e81e7207b42e0939c50fad59f82da3af4f680c0220c436df5db1199e07b5",
),
(
"artifacts/argon2-above-lo-default.odt",
"PASSWORD",
"7ac5e81e7207b42e0939c50fad59f82da3af4f680c0220c436df5db1199e07b5",
),
(
"artifacts/argon2-floor-1-8-1.odt",
"PASSWORD",
"7ac5e81e7207b42e0939c50fad59f82da3af4f680c0220c436df5db1199e07b5",
),
(
"artifacts/argon2-lanes-only.odt",
"PASSWORD",
"7ac5e81e7207b42e0939c50fad59f82da3af4f680c0220c436df5db1199e07b5",
),
(
"artifacts/wholesome-default.odt",
"PASSWORD",
"7ac5e81e7207b42e0939c50fad59f82da3af4f680c0220c436df5db1199e07b5",
),
(
"artifacts/wholesome-nonascii-password.odt",
"NONASCII_PASSWORD",
"7ac5e81e7207b42e0939c50fad59f82da3af4f680c0220c436df5db1199e07b5",
),
];
#[test]
fn whole_buffer_decrypt_returns_rc9_bytes() {
use sha2::{Digest as _, Sha256};
let root = crate::test_support::goldens_dir();
for (path, pw, want) in RC9_DECRYPT_SHA256 {
let (dir, name) = path.split_once('/').unwrap();
let bytes = std::fs::read(root.with_file_name(dir).join(name)).unwrap();
let pw = if *pw == "PASSWORD" {
PASSWORD
} else {
NONASCII_PASSWORD
};
let out = decrypt(&bytes, pw).unwrap_or_else(|e| panic!("{path}: {e:?}"));
let got: String = Sha256::digest(&out)
.iter()
.map(|b| format!("{b:02x}"))
.collect();
assert_eq!(&got, want, "{path}");
}
assert!(RC9_DECRYPT_SHA256.len() >= 15);
}