use assert_cmd::Command;
use predicates::prelude::*;
use std::io::Write;
fn clean_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
pdf.extend_from_slice(
format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
pdf
}
fn warnings_only_corrupt_xref_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let offsets: Vec<usize> = {
let objects: &[&[u8]] = &[
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n",
b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n",
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
];
let mut offs = Vec::new();
for obj in objects {
offs.push(pdf.len());
pdf.extend_from_slice(obj);
}
offs
};
let xref_start = pdf.len();
pdf.extend_from_slice(format!("xref\n0 {}\n", offsets.len() + 1).as_bytes());
pdf.extend_from_slice(b"0000000000 65535 f \n");
for off in &offsets {
pdf.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
pdf.extend_from_slice(
format!(
"trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n",
offsets.len() + 1
)
.as_bytes(),
);
let xref_pos = pdf.windows(4).position(|w| w == b"xref").unwrap();
pdf[xref_pos + 2] = b'z';
pdf
}
fn corrupt_pdf_bytes() -> Vec<u8> {
b"%PDF-1.4\nthis is not a valid pdf at all\n%%EOF\n".to_vec()
}
fn corrupt_content_stream_pdf_bytes() -> Vec<u8> {
let payload: &[u8] = b"this is not valid zlib data at all";
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>\nendobj\n",
);
let off4 = pdf.len();
pdf.extend_from_slice(
format!(
"4 0 obj\n<< /Filter /FlateDecode /Length {} >>\nstream\n",
payload.len()
)
.as_bytes(),
);
pdf.extend_from_slice(payload);
pdf.extend_from_slice(b"\nendstream\nendobj\n");
let xref_start = pdf.len();
pdf.extend_from_slice(
format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n{off4:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
pdf
}
fn bomb_content_stream_pdf_bytes(decoded_len: usize) -> Vec<u8> {
let mut flate_dict = flpdf::Dictionary::new();
flate_dict.insert("Filter", flpdf::Object::Name(b"FlateDecode".to_vec()));
let encoded = flpdf::filters::encode_stream_data(&flate_dict, &vec![0u8; decoded_len]).unwrap();
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>\nendobj\n",
);
let off4 = pdf.len();
pdf.extend_from_slice(
format!(
"4 0 obj\n<< /Filter /FlateDecode /Length {} >>\nstream\n",
encoded.len()
)
.as_bytes(),
);
pdf.extend_from_slice(&encoded);
pdf.extend_from_slice(b"\nendstream\nendobj\n");
let xref_start = pdf.len();
pdf.extend_from_slice(
format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n{off4:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
pdf
}
fn missing_root_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [] /Count 0 >>\nendobj\n");
let xref_start = pdf.len();
pdf.extend_from_slice(
format!("xref\n0 3\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n")
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 3 >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
pdf
}
fn extension_level_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.7\n");
let off1 = pdf.len();
pdf.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Extensions << /ADBE << /BaseVersion /1.7 /ExtensionLevel 8 >> >> >>\nendobj\n",
);
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
pdf.extend_from_slice(
format!(
"xref\n0 4\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
pdf
}
fn linearized_obj1_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len();
pdf.extend_from_slice(
b"1 0 obj\n<< /Linearized 1 /L 0 /H [ 0 0 ] /O 4 /E 0 /N 1 /T 0 >>\nendobj\n",
);
let off2 = pdf.len();
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Catalog /Pages 3 0 R >>\nendobj\n");
let off3 = pdf.len();
pdf.extend_from_slice(b"3 0 obj\n<< /Type /Pages /Kids [4 0 R] /Count 1 >>\nendobj\n");
let off4 = pdf.len();
pdf.extend_from_slice(
b"4 0 obj\n<< /Type /Page /Parent 3 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len();
pdf.extend_from_slice(
format!(
"xref\n0 5\n0000000000 65535 f \n{off1:010} 00000 n \n{off2:010} 00000 n \n{off3:010} 00000 n \n{off4:010} 00000 n \n"
)
.as_bytes(),
);
pdf.extend_from_slice(
format!("trailer\n<< /Size 5 /Root 2 0 R >>\nstartxref\n{xref_start}\n%%EOF\n").as_bytes(),
);
pdf
}
#[test]
fn check_clean_pdf_exits_0() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&clean_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["--check", f.path().to_str().unwrap()])
.assert()
.code(0)
.stdout(predicate::str::contains("File is not encrypted\n"))
.stdout(predicate::str::contains("PDF check succeeded").not())
.stderr(predicate::str::is_empty());
}
#[test]
fn check_subcommand_clean_pdf_exits_0() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&clean_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["check", f.path().to_str().unwrap()])
.assert()
.code(0)
.stdout(predicate::str::contains("File is not encrypted\n"))
.stdout(predicate::str::contains("PDF check succeeded").not())
.stderr(predicate::str::is_empty());
}
#[test]
fn check_clean_pdf_emits_qpdf_block() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&clean_pdf_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", &path])
.assert()
.code(0)
.stdout(predicate::str::contains(format!("checking {path}\n")))
.stdout(predicate::str::contains("PDF Version: 1.4\n"))
.stdout(predicate::str::contains("File is not encrypted\n"))
.stdout(predicate::str::contains("File is not linearized\n"))
.stdout(predicate::str::contains(
"No syntax or stream encoding errors found; the file may still contain\nerrors that flpdf cannot detect\n",
))
.stdout(predicate::str::contains("PDF check succeeded").not());
}
#[test]
fn check_warnings_emit_block_without_trailing_line() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&warnings_only_corrupt_xref_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", "--repair", f.path().to_str().unwrap()])
.assert()
.code(3)
.stdout(predicate::str::contains("File is not encrypted\n"))
.stdout(predicate::str::contains("File is not linearized\n"))
.stdout(predicate::str::contains("No syntax or stream encoding errors found").not())
.stdout(predicate::str::contains("PDF check succeeded").not());
}
#[test]
fn check_appends_adobe_extension_level_to_version() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&extension_level_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", f.path().to_str().unwrap()])
.assert()
.code(0)
.stdout(predicate::str::contains(
"PDF Version: 1.7 extension level 8\n",
));
}
#[test]
fn check_linearized_pdf_reports_linearized_line() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&linearized_obj1_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", f.path().to_str().unwrap()])
.assert()
.code(3)
.stdout(predicate::str::contains("File is linearized\n"))
.stdout(predicate::str::contains("File is not linearized").not());
}
#[test]
fn check_warnings_only_pdf_exits_3() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&warnings_only_corrupt_xref_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["--check", "--repair", f.path().to_str().unwrap()])
.assert()
.code(3)
.stdout(predicate::str::contains("File is not encrypted\n"))
.stderr(predicate::str::contains("WARNING: "));
}
#[test]
fn check_subcommand_warnings_only_pdf_exits_3() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&warnings_only_corrupt_xref_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["check", "--repair", f.path().to_str().unwrap()])
.assert()
.code(3)
.stdout(predicate::str::contains("File is not encrypted\n"))
.stderr(predicate::str::contains("WARNING: "));
}
#[test]
fn check_warnings_use_qpdf_stderr_format() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&warnings_only_corrupt_xref_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", "--repair", &path])
.assert()
.code(3)
.stdout(predicate::str::contains("File is not encrypted\n"))
.stderr(predicate::str::contains(format!(
"WARNING: {path}: file is damaged\n"
)))
.stderr(predicate::str::contains(
"Attempting to reconstruct cross-reference table\n",
))
.stderr(predicate::str::contains(
"flpdf: operation succeeded with warnings\n",
))
.stderr(predicate::str::contains("warning: ").not());
}
#[test]
fn check_trigger_warning_carries_offset() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&warnings_only_corrupt_xref_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["--check", "--repair", &path])
.assert()
.code(3)
.stderr(
predicate::str::is_match(format!(
"WARNING: {} \\(offset \\d+\\): ",
regex::escape(&path)
))
.unwrap(),
)
.stderr(predicate::str::contains(format!("WARNING: {path} (offset")).count(1));
}
#[test]
fn check_corrupt_pdf_exits_2() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&corrupt_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["--check", f.path().to_str().unwrap()])
.assert()
.code(2);
}
#[test]
fn check_corrupt_content_stream_exits_2_without_clean_note() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&corrupt_content_stream_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", f.path().to_str().unwrap()])
.assert()
.code(2)
.stdout(predicate::str::contains("No syntax or stream encoding errors found").not())
.stderr(predicate::str::contains(
"errors while decoding content stream",
));
}
#[test]
fn check_error_diagnostics_use_qpdf_stderr_format() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&missing_root_pdf_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", &path])
.assert()
.code(2)
.stderr(predicate::str::contains(format!(
"flpdf: {path}: trailer is missing /Root\n"
)))
.stderr(predicate::str::contains("PDF check failed").not())
.stderr(predicate::str::contains("error: ").not())
.stdout(predicate::str::is_empty());
}
#[test]
fn fatal_open_error_includes_filename() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&corrupt_pdf_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", &path])
.assert()
.code(2)
.stderr(predicate::str::contains(format!("flpdf: {path}: ")));
}
#[test]
fn flpdf_progname_env_swaps_prefix() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&warnings_only_corrupt_xref_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env("FLPDF_PROGNAME", "qpdf")
.args(["--check", "--repair", &path])
.assert()
.code(3)
.stderr(predicate::str::contains(
"qpdf: operation succeeded with warnings\n",
))
.stderr(predicate::str::contains("flpdf:").not());
}
#[test]
fn flpdf_progname_empty_env_falls_back_to_default() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&warnings_only_corrupt_xref_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env("FLPDF_PROGNAME", "")
.args(["--check", "--repair", &path])
.assert()
.code(3)
.stderr(predicate::str::contains(
"flpdf: operation succeeded with warnings\n",
));
}
#[test]
fn flpdf_progname_env_swaps_prefix_on_fatal_error() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&corrupt_pdf_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env("FLPDF_PROGNAME", "qpdf")
.args(["--check", &path])
.assert()
.code(2)
.stderr(predicate::str::contains(format!("qpdf: {path}: ")))
.stderr(predicate::str::contains("flpdf:").not());
}
#[test]
fn check_subcommand_corrupt_pdf_exits_2() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&corrupt_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["check", f.path().to_str().unwrap()])
.assert()
.code(2);
}
#[test]
fn rewrite_repair_warnings_use_qpdf_stderr_format() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&warnings_only_corrupt_xref_bytes()).unwrap();
let path = f.path().to_str().unwrap().to_string();
let out = tempfile::NamedTempFile::new().unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["rewrite", "--repair", &path, out.path().to_str().unwrap()])
.assert()
.success()
.stderr(predicate::str::contains(format!(
"WARNING: {path}: file is damaged\n"
)))
.stderr(predicate::str::contains("warning: ").not());
}
#[test]
fn check_decode_memory_limit_bomb_warns_exit_3() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&bomb_content_stream_pdf_bytes(64 * 1024))
.unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args([
"--check",
"--decode-memory-limit",
"1024",
f.path().to_str().unwrap(),
])
.assert()
.code(3)
.stdout(predicate::str::contains("No syntax or stream encoding errors found").not())
.stderr(predicate::str::contains("decode-bomb guard"));
}
#[test]
fn check_no_limit_large_stream_exits_0() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&bomb_content_stream_pdf_bytes(64 * 1024))
.unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["--check", f.path().to_str().unwrap()])
.assert()
.code(0);
}
#[test]
fn check_subcommand_decode_memory_limit_bomb_warns_exit_3() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&bomb_content_stream_pdf_bytes(64 * 1024))
.unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args([
"check",
"--decode-memory-limit",
"1024",
f.path().to_str().unwrap(),
])
.assert()
.code(3)
.stderr(predicate::str::contains("decode-bomb guard"));
}
#[test]
fn check_decode_memory_limit_does_not_mask_corruption() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&corrupt_content_stream_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args([
"--check",
"--decode-memory-limit",
"1024",
f.path().to_str().unwrap(),
])
.assert()
.code(2)
.stderr(predicate::str::contains(
"errors while decoding content stream",
));
}
#[test]
fn decode_memory_limit_requires_check() {
let mut f = tempfile::NamedTempFile::new().unwrap();
f.write_all(&clean_pdf_bytes()).unwrap();
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.args(["--decode-memory-limit", "1024", f.path().to_str().unwrap()])
.assert()
.code(2)
.stderr(predicate::str::contains("--check"));
}
const WEAK_RC4_FIXTURE: &str = "../../tests/fixtures/encrypted/v2-rc4-128-r3.pdf";
#[test]
fn check_weak_rc4_correct_password_exits_0_as_inspection() {
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", "--password=user-v2", WEAK_RC4_FIXTURE])
.assert()
.code(0)
.stdout(predicate::str::contains(
"No syntax or stream encoding errors found",
))
.stderr(predicate::str::contains("weak crypto").not());
}
#[test]
fn check_subcommand_weak_rc4_correct_password_exits_0() {
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["check", "--password=user-v2", WEAK_RC4_FIXTURE])
.assert()
.code(0)
.stdout(predicate::str::contains(
"No syntax or stream encoding errors found",
))
.stderr(predicate::str::contains("weak crypto").not());
}
#[test]
fn check_weak_rc4_wrong_password_still_exits_2() {
let mut cmd = Command::cargo_bin("flpdf").unwrap();
cmd.env_remove("FLPDF_PROGNAME")
.args(["--check", "--password=wrong", WEAK_RC4_FIXTURE])
.assert()
.code(2);
}