use super::*;
use odf_crypto::{classify, AllocationSite};
#[test]
fn the_command_definition_is_internally_consistent() {
cli().debug_assert();
}
#[test]
fn derived_output_inserts_before_the_extension() {
assert_eq!(
derived_output(Path::new("report.odt"), "decrypted"),
PathBuf::from("report.decrypted.odt")
);
assert_eq!(
derived_output(Path::new("/tmp/a/report.ods"), "encrypted"),
PathBuf::from("/tmp/a/report.encrypted.ods")
);
}
#[test]
fn derived_output_appends_when_there_is_no_extension() {
assert_eq!(
derived_output(Path::new("report"), "decrypted"),
PathBuf::from("report.decrypted")
);
}
#[test]
fn derived_output_keeps_a_dotted_stem() {
assert_eq!(
derived_output(Path::new("a.b.odt"), "decrypted"),
PathBuf::from("a.b.decrypted.odt")
);
}
#[test]
fn first_line_strips_one_trailing_newline_and_no_more() {
assert_eq!(first_line("hunter2\n"), "hunter2");
assert_eq!(first_line("hunter2\r\n"), "hunter2");
assert_eq!(first_line("hunter2"), "hunter2");
assert_eq!(first_line("hunter2\nignored\n"), "hunter2");
assert_eq!(first_line("hunter2 \n"), "hunter2 ");
assert_eq!(first_line(""), "");
}
#[test]
fn exit_codes_separate_try_again_from_wrong_file() {
assert_eq!(
decrypt_exit(&DecryptError::WrongPassword),
EX_WRONG_PASSWORD
);
assert_eq!(decrypt_exit(&DecryptError::NotEncrypted), EX_REFUSED);
assert_ne!(EX_WRONG_PASSWORD, EX_REFUSED);
}
#[test]
fn exit_codes_map_each_error_class() {
assert_eq!(detect_exit(&DetectError::NotZip), EX_NOT_ODF);
assert_eq!(detect_exit(&DetectError::MissingManifest), EX_NOT_ODF);
assert_eq!(
detect_exit(&DetectError::Inconsistent(String::new())),
EX_REFUSED
);
assert_eq!(detect_exit(&DetectError::Zip(String::new())), EX_MALFORMED);
assert_eq!(
decrypt_exit(&DecryptError::Classify(DetectError::NotZip)),
EX_NOT_ODF
);
assert_eq!(decrypt_exit(&DecryptError::UnsupportedPgp), EX_REFUSED);
assert_eq!(
decrypt_exit(&DecryptError::Inflate(String::new())),
EX_MALFORMED
);
assert_eq!(
decrypt_exit(&DecryptError::Internal(String::new())),
EX_INTERNAL
);
assert_eq!(encrypt_exit(&EncryptError::AlreadyEncrypted), EX_REFUSED);
assert_eq!(
encrypt_exit(&EncryptError::Classify(DetectError::MissingManifest)),
EX_NOT_ODF
);
assert_eq!(
encrypt_exit(&EncryptError::Internal(String::new())),
EX_INTERNAL
);
assert_eq!(
encrypt_exit(&EncryptError::Random(String::new())),
EX_INTERNAL
);
}
#[test]
fn exactly_one_password_source_is_accepted() {
let two = cli().try_get_matches_from([
"odf-crypto",
"decrypt",
"f.odt",
"--password-stdin",
"--password-env",
"PW",
]);
assert!(two.is_err(), "two password sources must be rejected");
for one in [
vec!["odf-crypto", "decrypt", "f.odt", "--password-stdin"],
vec!["odf-crypto", "decrypt", "f.odt", "--password-env", "PW"],
vec!["odf-crypto", "decrypt", "f.odt", "--password-file", "p"],
vec!["odf-crypto", "decrypt", "f.odt"],
] {
assert!(
cli().try_get_matches_from(&one).is_ok(),
"{one:?} must parse"
);
}
}
#[test]
fn the_equals_form_parses() {
let m = cli()
.try_get_matches_from(["odf-crypto", "decrypt", "f.odt", "--output=x.odt"])
.expect("--flag=value must parse");
let sub = m.subcommand_matches("decrypt").expect("decrypt");
assert_eq!(
sub.get_one::<String>("output").map(String::as_str),
Some("x.odt")
);
}
#[test]
fn the_password_argument_is_hidden_but_recognised() {
let m = cli()
.try_get_matches_from(["odf-crypto", "decrypt", "f.odt", "--password", "secret"])
.expect("the trap argument must parse");
let sub = m.subcommand_matches("decrypt").expect("decrypt");
assert_eq!(
sub.get_one::<String>(PASSWORD_TRAP).map(String::as_str),
Some("secret")
);
assert_eq!(cmd_crypt(sub, Direction::Decrypt), EX_USAGE);
}
#[test]
fn no_help_output_ever_offers_a_password_value_argument() {
let mut cmd = cli();
let mut texts = vec![cmd.render_long_help().to_string()];
for name in ["classify", "decrypt", "encrypt"] {
texts.push(
cmd.find_subcommand_mut(name)
.expect("subcommand")
.render_long_help()
.to_string(),
);
}
for text in texts {
for line in text.lines() {
let t = line.trim_start();
assert!(
!(t.starts_with("--password ") || t.starts_with("--password=")),
"a `--password <VALUE>` option must never be defined in help: {line:?}"
);
}
}
}
#[test]
fn help_advertises_the_three_real_password_sources() {
let mut cmd = cli();
for name in ["decrypt", "encrypt"] {
let text = cmd
.find_subcommand_mut(name)
.expect("subcommand")
.render_long_help()
.to_string();
for flag in ["--password-env", "--password-file", "--password-stdin"] {
assert!(text.contains(flag), "{name} help must offer {flag}");
}
}
}
#[test]
fn classification_json_is_valid_json_for_a_real_golden() {
let bytes = include_bytes!("../../tests/goldens/lo-wholesome-gcm-argon2.odt");
let c = classify(bytes).expect("golden classifies");
let v: serde_json::Value =
serde_json::from_str(&classification_json(&c)).expect("must be valid JSON");
assert_eq!(v["mode"], "wholesome");
assert_eq!(v["encrypted"], true);
assert_eq!(v["cipher"], "AES-GCM (W3C)");
assert_eq!(v["kdf"], "Argon2id t=3 m=65536KiB p=4");
assert_eq!(v["key_size"], 32);
assert_eq!(v["odf_version"], "1.4");
}
#[test]
fn classification_json_nulls_the_row_fields_when_plain() {
let bytes = include_bytes!("../../tests/goldens/lo-unencrypted.odt");
let c = classify(bytes).expect("golden classifies");
let v: serde_json::Value =
serde_json::from_str(&classification_json(&c)).expect("must be valid JSON");
assert_eq!(v["encrypted"], false);
assert!(v["cipher"].is_null());
assert!(v["key_size"].is_null());
}
#[test]
fn human_output_reports_plain_as_an_answer_not_a_failure() {
let bytes = include_bytes!("../../tests/goldens/lo-unencrypted.odt");
let c = classify(bytes).expect("golden classifies");
let text = classification_human(&c);
assert!(text.contains("mode: plain"));
assert!(text.contains("encrypted: no"));
assert!(!text.contains("cipher:"));
}
#[test]
fn human_output_names_the_algorithm_tuple() {
let bytes = include_bytes!("../../tests/goldens/aoo-blowfish-pbkdf2.odt");
let c = classify(bytes).expect("golden classifies");
let text = classification_human(&c);
assert!(text.contains("mode: per-entry"));
assert!(text.contains("Blowfish-CFB"));
assert!(text.contains("PBKDF2 iterations="));
}
#[test]
fn host_capacity_is_not_reported_as_a_damaged_document() {
assert_eq!(
decrypt_exit(&DecryptError::HostCannotAllocate {
site: AllocationSite::MemberPlaintext,
requested_bytes: 1 << 30
}),
EX_HOST_CAPACITY
);
assert_eq!(
encrypt_exit(&EncryptError::HostCannotAllocate {
requested_bytes: 1 << 30
}),
EX_HOST_CAPACITY
);
assert_ne!(
decrypt_exit(&DecryptError::HostCannotAllocate {
site: AllocationSite::MemberPlaintext,
requested_bytes: 1 << 30
}),
EX_MALFORMED,
"a host memory failure must never read as a damaged document"
);
}
#[test]
fn the_detect_exit_map_is_the_documented_one() {
for (e, want) in [
(DetectError::NotZip, EX_NOT_ODF),
(DetectError::MissingManifest, EX_NOT_ODF),
(DetectError::Inconsistent(String::new()), EX_REFUSED),
(DetectError::Zip(String::new()), EX_MALFORMED),
(DetectError::Io(std::io::Error::other("cancelled")), EX_IO),
] {
assert_eq!(detect_exit(&e), want, "{e:?}");
}
}
#[test]
fn the_decrypt_exit_map_is_the_documented_one() {
for (e, want) in [
(
DecryptError::Classify(DetectError::MissingManifest),
EX_NOT_ODF,
),
(
DecryptError::Classify(DetectError::Zip(String::new())),
EX_MALFORMED,
),
(DecryptError::WrongPassword, EX_WRONG_PASSWORD),
(DecryptError::NotEncrypted, EX_REFUSED),
(DecryptError::Odf12Fatal, EX_REFUSED),
(DecryptError::UnsupportedPgp, EX_REFUSED),
(DecryptError::EmptyPassword, EX_REFUSED),
(
DecryptError::BadParameters(odf_crypto::BadParameter::NoMember { row: 0 }),
EX_MALFORMED,
),
(DecryptError::Inflate(String::new()), EX_MALFORMED),
(DecryptError::Zip(String::new()), EX_MALFORMED),
(DecryptError::Internal(String::new()), EX_INTERNAL),
(
DecryptError::HostCannotAllocate {
site: AllocationSite::CipherBuffer,
requested_bytes: 1 << 40,
},
EX_HOST_CAPACITY,
),
(DecryptError::OutputLimit { limit: 1 }, EX_REFUSED),
(DecryptError::Io(std::io::Error::other("cancelled")), EX_IO),
] {
assert_eq!(decrypt_exit(&e), want, "{e:?}");
}
}
#[test]
fn the_encrypt_exit_map_is_the_documented_one() {
let params = Argon2Params::new(0, 65536, 1)
.expect_err("t = 0 is below ARGON2_MIN_T_COST and must be refused");
for (e, want) in [
(EncryptError::Classify(DetectError::NotZip), EX_NOT_ODF),
(EncryptError::AlreadyEncrypted, EX_REFUSED),
(EncryptError::PartiallyEncrypted, EX_REFUSED),
(EncryptError::Odf12Fatal, EX_REFUSED),
(EncryptError::EmptyPassword, EX_REFUSED),
(EncryptError::Mimetype(String::new()), EX_MALFORMED),
(EncryptError::Deflate(String::new()), EX_MALFORMED),
(EncryptError::Zip(String::new()), EX_MALFORMED),
(params, EX_USAGE),
(EncryptError::Random(String::new()), EX_INTERNAL),
(EncryptError::Internal(String::new()), EX_INTERNAL),
(
EncryptError::HostCannotAllocate {
requested_bytes: 1 << 40,
},
EX_HOST_CAPACITY,
),
(EncryptError::Io(std::io::Error::other("cancelled")), EX_IO),
] {
assert_eq!(encrypt_exit(&e), want, "{e:?}");
}
}
#[test]
fn the_reencrypt_exit_map_is_the_documented_one() {
for (e, want) in [
(
ReencryptError::Decrypt(DecryptError::WrongPassword),
EX_WRONG_PASSWORD,
),
(
ReencryptError::Encrypt(EncryptError::EmptyPassword),
EX_REFUSED,
),
(ReencryptError::PartiallyEncrypted, EX_REFUSED),
(ReencryptError::UnexpectedStreams, EX_REFUSED),
(
ReencryptError::Io(std::io::Error::other("cancelled")),
EX_IO,
),
] {
assert_eq!(reencrypt_exit(&e), want, "{e:?}");
}
}