#[path = "writer/object_streams.rs"]
pub(crate) mod object_streams;
pub use object_streams::ObjectStreamMode;
use crate::parser::Parser;
use crate::{filters, Dictionary, Object, ObjectRef, Pdf, Result, XrefForm, XrefOffset};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Read, Seek, Write};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum CompressStreams {
#[default]
Yes,
No,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StreamDataMode {
Preserve,
Uncompress,
Compress,
}
pub(crate) fn effective_stream_policy(options: &WriteOptions) -> Option<CompressStreams> {
if options.qdf {
return Some(CompressStreams::No);
}
match options.stream_data {
Some(StreamDataMode::Preserve) => None,
Some(StreamDataMode::Uncompress) => Some(CompressStreams::No),
Some(StreamDataMode::Compress) => Some(CompressStreams::Yes),
None => Some(options.compress_streams),
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub enum NewlineBeforeEndstream {
Yes,
No,
#[default]
Never,
}
#[non_exhaustive]
#[derive(Debug, Default, Clone)]
pub struct WriteOptions {
pub static_id: bool,
pub deterministic_id: bool,
pub static_aes_iv: bool,
pub min_version: Option<String>,
pub min_extension_level: Option<i64>,
pub force_version: Option<String>,
pub no_original_object_ids: bool,
pub full_rewrite: bool,
pub object_streams: ObjectStreamMode,
pub compress_streams: CompressStreams,
pub newline_before_endstream: NewlineBeforeEndstream,
pub qdf: bool,
pub stream_data: Option<StreamDataMode>,
pub recompress_flate: bool,
pub encrypt: Option<crate::encrypt_setup::EncryptParams>,
pub copy_encryption: Option<crate::encrypt_setup::CopyEncryptionSource>,
}
pub fn parse_pdf_version(v: &str) -> Option<(u8, u8)> {
let (major, minor) = v.split_once('.')?;
let major: u8 = major.parse().ok()?;
let minor: u8 = minor.parse().ok()?;
Some((major, minor))
}
pub(crate) fn force_version_below_1_5(options: &WriteOptions) -> bool {
options
.force_version
.as_deref()
.and_then(parse_pdf_version)
.is_some_and(|v| v < (1, 5))
}
pub fn effective_pdf_version<'a>(
source: &'a str,
options: &'a WriteOptions,
linearize: bool,
object_streams: bool,
) -> &'a str {
if let Some(ref forced) = options.force_version {
if parse_pdf_version(forced).is_some() {
return forced.as_str();
}
}
let Some(mut best) = parse_pdf_version(source) else {
return source;
};
if let Some(ref min_v) = options.min_version {
if let Some(min_parsed) = parse_pdf_version(min_v) {
if min_parsed > best {
best = min_parsed;
}
}
}
let enc_floor = encryption_version_floor(options);
if let Some((enc_ver, _)) = enc_floor {
if enc_ver > best {
best = enc_ver;
}
}
if object_streams {
let objstm_floor = (1u8, 5u8);
if objstm_floor > best {
best = objstm_floor;
}
}
if linearize {
let lin_floor = (1u8, 2u8);
if lin_floor > best {
best = lin_floor;
}
}
if parse_pdf_version(source) == Some(best) {
return source;
}
if let Some(ref min_v) = options.min_version {
if parse_pdf_version(min_v) == Some(best) {
return min_v.as_str();
}
}
if let Some((enc_ver, _)) = enc_floor {
if enc_ver == best {
return static_version_string(best);
}
}
if best == (1u8, 5u8) {
return "1.5";
}
"1.2"
}
fn encryption_version_floor(options: &WriteOptions) -> Option<((u8, u8), i64)> {
use crate::encrypt_setup::EncryptMethod;
if let Some(ref enc) = options.encrypt {
return Some(match enc.method {
EncryptMethod::V5R6Aes256 => ((1, 7), 8),
EncryptMethod::V5R5Aes256 => ((1, 7), 3),
EncryptMethod::V4Aes128 => ((1, 6), 0),
EncryptMethod::V4Rc4128 => ((1, 5), 0),
EncryptMethod::V2Rc4128 => ((1, 4), 0),
EncryptMethod::V1Rc440 => ((1, 3), 0),
});
}
if options.copy_encryption.is_some() {
return Some(((1, 6), 0));
}
None
}
fn static_version_string(v: (u8, u8)) -> &'static str {
match v {
(1, 3) => "1.3",
(1, 4) => "1.4",
(1, 5) => "1.5",
(1, 6) => "1.6",
(1, 7) => "1.7",
_ => "1.7",
}
}
pub fn effective_pdf_version_and_ext<'a>(
source: &'a str,
source_ext: i64,
options: &'a WriteOptions,
linearize: bool,
object_streams: bool,
) -> (&'a str, i64) {
let ver = effective_pdf_version(source, options, linearize, object_streams);
let ver_parsed = parse_pdf_version(ver);
let source_parsed = parse_pdf_version(source);
let min_parsed = options.min_version.as_deref().and_then(parse_pdf_version);
let forced = options
.force_version
.as_deref()
.and_then(parse_pdf_version)
.is_some();
let enc_floor = encryption_version_floor(options);
let source_contributes = !forced && ver_parsed.is_some() && ver_parsed == source_parsed;
let min_contributes = !forced && ver_parsed.is_some() && ver_parsed == min_parsed;
let enc_contributes =
!forced && ver_parsed.is_some() && enc_floor.map(|(v, _)| v) == ver_parsed;
let min_ext = options.min_extension_level.unwrap_or(0);
let enc_ext = enc_floor.map(|(_, e)| e).unwrap_or(0);
let mut ext = 0i64;
if source_contributes {
ext = ext.max(source_ext);
}
if min_contributes {
ext = ext.max(min_ext);
}
if enc_contributes {
ext = ext.max(enc_ext);
}
(ver, ext)
}
fn inject_adbe_extension<R: Read + Seek>(
pdf: &mut Pdf<R>,
version: &str,
extension_level: i64,
) -> Result<()> {
let Some(root_ref) = pdf.root_ref() else {
return Err(crate::Error::Missing("/Root"));
};
let catalog_obj = pdf.resolve(root_ref)?;
let Some(mut catalog) = catalog_obj.into_dict() else {
return Err(crate::Error::Unsupported(
"Catalog is not a dictionary".to_string(),
));
};
let mut extensions = match catalog.remove("Extensions") {
Some(Object::Dictionary(d)) => d,
Some(Object::Reference(r)) => pdf.resolve(r)?.into_dict().unwrap_or_default(),
_ => Dictionary::new(),
};
let mut adbe = Dictionary::new();
adbe.insert("BaseVersion", Object::Name(version.as_bytes().to_vec()));
adbe.insert("ExtensionLevel", Object::Integer(extension_level));
extensions.insert("ADBE", Object::Dictionary(adbe));
catalog.insert("Extensions", Object::Dictionary(extensions));
pdf.set_object(root_ref, Object::Dictionary(catalog));
Ok(())
}
fn strip_adbe_extension<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<()> {
let Some(root_ref) = pdf.root_ref() else {
return Ok(());
};
let catalog_obj = pdf.resolve(root_ref)?;
let Some(mut catalog) = catalog_obj.into_dict() else {
return Ok(());
};
let mut extensions = match catalog.remove("Extensions") {
Some(Object::Dictionary(d)) => d,
Some(Object::Reference(r)) => pdf.resolve(r)?.into_dict().unwrap_or_default(),
_ => return Ok(()),
};
if extensions.remove("ADBE").is_none() {
catalog.insert("Extensions", Object::Dictionary(extensions));
pdf.set_object(root_ref, Object::Dictionary(catalog));
return Ok(());
}
if extensions.iter().next().is_some() {
catalog.insert("Extensions", Object::Dictionary(extensions));
}
pdf.set_object(root_ref, Object::Dictionary(catalog));
Ok(())
}
pub(crate) const QPDF_BINARY_MARKER: &[u8] = b"%\xbf\xf7\xa2\xfe\n";
pub(crate) const QPDF_STATIC_ID: [u8; 16] = [
0x31, 0x41, 0x59, 0x26, 0x53, 0x58, 0x97, 0x93, 0x23, 0x84, 0x62, 0x64, 0x33, 0x83, 0x27, 0x95,
];
pub fn write_pdf<R: Read + Seek, W: Write>(pdf: &mut Pdf<R>, out: W) -> Result<()> {
write_pdf_with_options(pdf, out, &WriteOptions::default())
}
pub fn write_pdf_with_options<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
out: W,
options: &WriteOptions,
) -> Result<()> {
if options.full_rewrite {
return write_pdf_full_rewrite(pdf, out, options);
}
if options.deterministic_id {
return Err(crate::Error::Unsupported(
"deterministic-id requires a full rewrite".to_string(),
));
}
write_pdf_incremental(pdf, out, options)
}
struct ObjStmIncremental {
container: ObjectRef,
container_offset: usize,
compressed: BTreeMap<u32, (u32, u32)>,
}
fn write_pdf_incremental<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
mut out: W,
options: &WriteOptions,
) -> Result<()> {
let Some(root_ref) = pdf.root_ref() else {
return Err(crate::Error::Missing("/Root"));
};
let mut bytes = pdf.source_bytes()?;
#[cfg(debug_assertions)]
let (source_len, source_digest) = {
use md5::Digest as _;
let mut hasher = md5::Md5::new();
hasher.update(&bytes);
(bytes.len(), hasher.finalize())
};
if !bytes.ends_with(b"\n") {
bytes.push(b'\n');
}
let source_offsets = build_source_offsets(pdf.source_xref_offsets());
let source_xref_offsets = build_source_xref_offsets(pdf.source_xref_entries());
let (touched_object_refs, deleted_object_refs, touched_objstm_members) =
collect_touched_object_refs(pdf);
let empty_compressed: BTreeMap<u32, (u32, u32)> = BTreeMap::new();
let use_objstm = options.object_streams == ObjectStreamMode::Generate
&& matches!(pdf.last_xref_form(), XrefForm::Stream);
let mut objstm_inc: Option<ObjStmIncremental> = None;
let plain_touched: Vec<ObjectRef> = if use_objstm {
let (packable, plain_remaining) = partition_objstm_eligible(pdf, &touched_object_refs)?;
if packable.is_empty() {
touched_object_refs.clone()
} else {
let declared =
resolve_xref_stream_object_count(pdf.trailer().get("Size"), &source_xref_offsets);
let container = allocate_incremental_objstm_container(
&source_xref_offsets,
&touched_object_refs,
&deleted_object_refs,
declared,
)?;
let (container_offset, members) =
write_incremental_objstm(&mut bytes, pdf, container, &packable, options)?;
let mut compressed = BTreeMap::new();
for (r, idx) in members {
compressed.insert(r.number, (container.number, idx));
}
objstm_inc = Some(ObjStmIncremental {
container,
container_offset,
compressed,
});
plain_remaining
}
} else {
touched_object_refs.clone()
};
let mut xref_offsets = write_incremental_objects(&mut bytes, pdf, &plain_touched)?;
if let Some(oi) = &objstm_inc {
xref_offsets.insert(oi.container.number, (0, oi.container_offset));
}
let deleted_table_entries = build_deleted_table_entries(pdf, &deleted_object_refs);
let rewritten_stream_offsets =
write_updated_object_streams(&mut bytes, pdf, &touched_objstm_members)?;
xref_offsets.extend(rewritten_stream_offsets);
let final_offsets =
merge_source_and_touched_offsets(&source_offsets, &xref_offsets, &deleted_table_entries);
let final_xref_offsets = merge_source_and_touched_offsets_for_xref_stream(
&source_xref_offsets,
&xref_offsets,
&deleted_object_refs,
objstm_inc
.as_ref()
.map(|o| &o.compressed)
.unwrap_or(&empty_compressed),
);
let mut object_count = match pdf.last_xref_form() {
XrefForm::Table => resolve_object_count(pdf.trailer().get("Size"), &final_offsets),
XrefForm::Stream => {
resolve_xref_stream_object_count(pdf.trailer().get("Size"), &final_xref_offsets)
}
};
if let Some(oi) = &objstm_inc {
object_count = object_count.max(oi.container.number as usize + 1);
}
let xref_offset = match pdf.last_xref_form() {
XrefForm::Table => write_incremental_xref(&mut bytes, &final_offsets)?,
XrefForm::Stream => {
let xref_object_number = next_xref_stream_object_number(&final_xref_offsets)?;
object_count = object_count.max(xref_object_number as usize + 1);
let xref_offset = write_incremental_xref_stream(
&mut bytes,
pdf.trailer(),
&final_xref_offsets,
&root_ref,
xref_object_number,
object_count,
pdf.previous_xref_offset(),
)?;
xref_offset
}
};
write_incremental_trailer(
&mut bytes,
pdf,
&root_ref,
object_count,
pdf.previous_xref_offset(),
xref_offset,
options,
)?;
#[cfg(debug_assertions)]
{
use md5::Digest as _;
let mut hasher = md5::Md5::new();
hasher.update(bytes.get(..source_len).unwrap_or(&bytes));
debug_assert_eq!(
hasher.finalize(),
source_digest,
"incremental update must preserve the original source prefix byte-for-byte"
);
}
out.write_all(&bytes)?;
Ok(())
}
type RewrittenObjStmMembers = BTreeMap<ObjectRef, BTreeSet<ObjectRef>>;
fn collect_touched_object_refs<R: Read + Seek>(
pdf: &Pdf<R>,
) -> (Vec<ObjectRef>, Vec<ObjectRef>, RewrittenObjStmMembers) {
let mut touched = BTreeSet::new();
let mut deleted = BTreeSet::new();
let mut objstm_touched: BTreeMap<ObjectRef, BTreeSet<ObjectRef>> = BTreeMap::new();
for object_ref in pdf.deleted_object_refs() {
deleted.insert(object_ref);
}
for object_ref in pdf.dirty_object_refs() {
if deleted.contains(&object_ref) {
continue;
}
if let Some((stream_ref, _index)) = pdf.compressed_parent(object_ref) {
objstm_touched
.entry(stream_ref)
.or_default()
.insert(object_ref);
continue;
}
touched.insert(object_ref);
}
(
touched.into_iter().collect(),
deleted.into_iter().collect(),
objstm_touched,
)
}
fn partition_objstm_eligible<R: Read + Seek>(
pdf: &mut Pdf<R>,
touched: &[ObjectRef],
) -> Result<(Vec<ObjectRef>, Vec<ObjectRef>)> {
let ctx = object_streams::eligibility_context(pdf)?;
let mut packable = Vec::new();
let mut plain = Vec::new();
for &r in touched {
let obj = pdf.resolve_borrowed(r)?;
if object_streams::is_eligible_for_objstm(r, obj, &ctx) {
packable.push(r);
} else {
plain.push(r);
}
}
Ok((packable, plain))
}
#[derive(Clone, Copy)]
enum XrefTableEntry {
InUse { generation: u16, offset: usize },
Free { generation: u16, next: u32 },
}
fn write_incremental_objects<R: Read + Seek>(
bytes: &mut Vec<u8>,
pdf: &mut Pdf<R>,
touched_object_refs: &[ObjectRef],
) -> Result<BTreeMap<u32, (u16, usize)>> {
let mut updated_offsets = BTreeMap::new();
for object_ref in touched_object_refs {
let object = pdf.resolve_borrowed(*object_ref)?;
let Some(offset) = write_object(bytes, *object_ref, object)? else {
continue;
};
updated_offsets.insert(object_ref.number, (object_ref.generation, offset));
}
Ok(updated_offsets)
}
fn write_updated_object_streams<R: Read + Seek>(
bytes: &mut Vec<u8>,
pdf: &mut Pdf<R>,
members_by_stream: &RewrittenObjStmMembers,
) -> Result<BTreeMap<u32, (u16, usize)>> {
let mut updated_offsets = BTreeMap::new();
for (stream_ref, member_refs) in members_by_stream {
let stream_object = pdf.resolve(*stream_ref)?;
let Some(stream) = stream_object.into_stream() else {
return Err(crate::Error::Unsupported(format!(
"object {} is not an object stream",
stream_ref.number
)));
};
let (rebuilt_data, rebuilt_first) = rebuild_object_stream(&stream, member_refs, pdf)?;
let mut stream_dict = stream.dict.clone();
stream_dict.insert(
"First",
Object::Integer(i64::try_from(rebuilt_first).map_err(|_| {
crate::Error::Unsupported("object stream /First too large".to_string())
})?),
);
stream_dict.insert(
"Length",
Object::Integer(i64::try_from(rebuilt_data.len()).map_err(|_| {
crate::Error::Unsupported("object stream /Length too large".to_string())
})?),
);
let rebuilt_stream = Object::Stream(crate::Stream::new(stream_dict, rebuilt_data));
let offset = write_object(bytes, *stream_ref, &rebuilt_stream)?
.expect("writing object always returns an offset");
updated_offsets.insert(stream_ref.number, (stream_ref.generation, offset));
}
Ok(updated_offsets)
}
fn rebuild_object_stream<R: Read + Seek>(
stream: &crate::Stream,
updated_members: &BTreeSet<ObjectRef>,
pdf: &mut Pdf<R>,
) -> Result<(Vec<u8>, usize)> {
let stream_data = filters::decode_stream_data(&stream.dict, &stream.data)?;
let object_count = usize::try_from(parse_non_negative_i64(
stream
.dict
.get("N")
.ok_or(crate::Error::Missing("Object stream /N"))?,
"Object stream /N",
)?)
.map_err(|_| crate::Error::Unsupported("Object stream /N does not fit usize".to_string()))?;
let first = usize::try_from(parse_non_negative_i64(
stream
.dict
.get("First")
.ok_or(crate::Error::Missing("Object stream /First"))?,
"Object stream /First",
)?)
.map_err(|_| {
crate::Error::Unsupported("Object stream /First does not fit usize".to_string())
})?;
let mut header_parser = Parser::new(&stream_data);
let mut members = Vec::with_capacity(object_count);
for _ in 0..object_count {
let number = u32::try_from(parse_non_negative_i64_value(
header_parser.integer_for_indirect()?,
"object stream object number",
)?)
.map_err(|_| {
crate::Error::Unsupported("object stream object number does not fit u32".to_string())
})?;
let offset = usize::try_from(parse_non_negative_i64_value(
header_parser.integer_for_indirect()?,
"object stream object offset",
)?)
.map_err(|_| {
crate::Error::Unsupported("object stream object offset does not fit usize".to_string())
})?;
members.push((number, offset));
}
let mut decoded_members = Vec::with_capacity(object_count);
for (index, (number, offset)) in members.iter().enumerate() {
let start = first.checked_add(*offset).ok_or_else(|| {
crate::Error::Unsupported("object stream offset overflow".to_string())
})?;
let end = if index + 1 < members.len() {
first.checked_add(members[index + 1].1).ok_or_else(|| {
crate::Error::Unsupported("object stream offset overflow".to_string())
})?
} else {
stream_data.len()
};
if start > end || end > stream_data.len() {
return Err(crate::Error::parse(
0,
"compressed object offset out of range",
));
}
let object_ref = ObjectRef::new(*number, 0);
let object = if updated_members.contains(&object_ref) {
pdf.resolve(object_ref)?
} else {
let mut parser = Parser::new(&stream_data[start..end]);
parser.object()?
};
decoded_members.push((object_ref, object));
}
let mut header = Vec::new();
let mut body = Vec::new();
let mut object_offsets = Vec::with_capacity(decoded_members.len());
for (_, object) in &decoded_members {
object_offsets.push(body.len());
object.write_pdf(&mut body);
body.push(b'\n');
}
for ((object_ref, _), offset) in decoded_members.iter().zip(object_offsets.iter()) {
header.extend_from_slice(format!("{} {} ", object_ref.number, offset).as_bytes());
}
let rebuilt_first = header.len();
let mut rebuilt_data = header;
rebuilt_data.extend_from_slice(&body);
let encoded = filters::encode_stream_data(&stream.dict, &rebuilt_data)?;
Ok((encoded, rebuilt_first))
}
fn parse_non_negative_i64(value: &crate::Object, context: &str) -> Result<i64> {
let crate::Object::Integer(integer) = value else {
return Err(crate::Error::parse(0, format!("{context} is not integer")));
};
if *integer < 0 {
return Err(crate::Error::parse(0, format!("{context} is negative")));
}
Ok(*integer)
}
fn parse_non_negative_i64_value(value: i64, context: &str) -> Result<i64> {
if value < 0 {
return Err(crate::Error::parse(0, format!("{context} is negative")));
}
Ok(value)
}
fn write_object(
bytes: &mut Vec<u8>,
object_ref: ObjectRef,
object: &Object,
) -> Result<Option<usize>> {
let offset = bytes.len();
bytes.extend_from_slice(
format!("{} {} obj\n", object_ref.number, object_ref.generation).as_bytes(),
);
object.write_pdf(bytes);
bytes.extend_from_slice(b"\nendobj\n");
Ok(Some(offset))
}
fn merge_source_and_touched_offsets(
source_offsets: &BTreeMap<u32, (u16, usize)>,
touched_offsets: &BTreeMap<u32, (u16, usize)>,
deleted_entries: &BTreeMap<u32, (u16, u32)>,
) -> BTreeMap<u32, XrefTableEntry> {
let mut merged = source_offsets
.iter()
.map(|(number, (generation, offset))| {
(
*number,
XrefTableEntry::InUse {
generation: *generation,
offset: *offset,
},
)
})
.collect::<BTreeMap<_, _>>();
for (number, (generation, offset)) in touched_offsets {
merged.insert(
*number,
XrefTableEntry::InUse {
generation: *generation,
offset: *offset,
},
);
}
for (number, (generation, next)) in deleted_entries {
merged.insert(
*number,
XrefTableEntry::Free {
generation: *generation,
next: *next,
},
);
}
merged
}
fn merge_source_and_touched_offsets_for_xref_stream(
source_offsets: &BTreeMap<u32, (u16, XrefOffset)>,
touched_offsets: &BTreeMap<u32, (u16, usize)>,
deleted_object_refs: &[ObjectRef],
compressed_members: &BTreeMap<u32, (u32, u32)>,
) -> BTreeMap<u32, (u16, XrefOffset)> {
let mut merged = source_offsets.clone();
for (number, (generation, offset)) in touched_offsets {
merged.insert(*number, (*generation, XrefOffset::Offset(*offset as u64)));
}
for (number, (stream, index)) in compressed_members {
merged.insert(
*number,
(
0,
XrefOffset::Compressed {
stream: *stream,
index: *index,
},
),
);
}
for (number, (generation, next)) in build_deleted_entries(source_offsets, deleted_object_refs) {
merged.insert(number, (generation, XrefOffset::Free { next }));
}
merged
}
fn build_deleted_table_entries<R: Read + Seek>(
pdf: &Pdf<R>,
deleted_object_refs: &[ObjectRef],
) -> BTreeMap<u32, (u16, u32)> {
let source_offsets = build_source_xref_offsets(pdf.source_xref_entries());
build_deleted_entries(&source_offsets, deleted_object_refs)
}
fn build_deleted_entries(
source_offsets: &BTreeMap<u32, (u16, XrefOffset)>,
deleted_object_refs: &[ObjectRef],
) -> BTreeMap<u32, (u16, u32)> {
if deleted_object_refs.is_empty() {
return BTreeMap::new();
}
let mut deleted_refs = deleted_object_refs.to_vec();
deleted_refs.sort_by_key(|object_ref| object_ref.number);
deleted_refs.dedup_by_key(|object_ref| object_ref.number);
let mut entries = BTreeMap::new();
let first_deleted = deleted_refs[0].number;
entries.insert(0, (65535, first_deleted));
deleted_refs
.iter()
.enumerate()
.for_each(|(index, object_ref)| {
let next = deleted_refs
.get(index + 1)
.map(|next_ref| next_ref.number)
.unwrap_or_else(|| source_free_head(source_offsets));
entries.insert(
object_ref.number,
(
incremented_generation(current_generation(source_offsets, *object_ref)),
next,
),
);
});
entries
}
fn source_free_head(source_offsets: &BTreeMap<u32, (u16, XrefOffset)>) -> u32 {
match source_offsets.get(&0) {
Some((_, XrefOffset::Free { next })) => *next,
_ => 0,
}
}
fn current_generation(
source_offsets: &BTreeMap<u32, (u16, XrefOffset)>,
object_ref: ObjectRef,
) -> u16 {
source_offsets
.get(&object_ref.number)
.map(|(generation, _)| *generation)
.unwrap_or(object_ref.generation)
}
fn incremented_generation(generation: u16) -> u16 {
generation.saturating_add(1)
}
pub(crate) fn is_source_structural_container(obj: &Object) -> bool {
let Object::Stream(s) = obj else {
return false;
};
matches!(
s.dict.get("Type"),
Some(Object::Name(n)) if n.as_slice() == b"XRef" || n.as_slice() == b"ObjStm"
)
}
fn next_xref_stream_object_number(
source_offsets: &BTreeMap<u32, (u16, XrefOffset)>,
) -> Result<u32> {
source_offsets
.keys()
.copied()
.next_back()
.unwrap_or(0)
.checked_add(1)
.ok_or_else(|| crate::Error::Unsupported("xref object number does not fit u32".to_string()))
}
fn allocate_incremental_objstm_container(
source_offsets: &BTreeMap<u32, (u16, XrefOffset)>,
touched: &[ObjectRef],
deleted: &[ObjectRef],
declared_size: usize,
) -> Result<ObjectRef> {
let max_source = source_offsets.keys().copied().next_back().unwrap_or(0);
let max_touched = touched.iter().map(|r| r.number).max().unwrap_or(0);
let max_deleted = deleted.iter().map(|r| r.number).max().unwrap_or(0);
let declared_u32 = u32::try_from(declared_size.saturating_sub(1))
.map_err(|_| crate::Error::Unsupported("declared /Size does not fit u32".to_string()))?;
let base = max_source
.max(max_touched)
.max(max_deleted)
.max(declared_u32);
let number = base.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported("ObjStm container number does not fit u32".to_string())
})?;
Ok(ObjectRef::new(number, 0))
}
fn write_incremental_objstm<R: Read + Seek>(
bytes: &mut Vec<u8>,
pdf: &mut Pdf<R>,
container_ref: ObjectRef,
packable: &[ObjectRef],
options: &WriteOptions,
) -> Result<(usize, Vec<(ObjectRef, u32)>)> {
let body = object_streams::emit_objstm_body(pdf, packable)?;
let stream = object_streams::wrap_objstm_body(&body, options.compress_streams)?;
let offset = bytes.len();
write_object(bytes, container_ref, &Object::Stream(stream))?;
let members = packable
.iter()
.enumerate()
.map(|(i, &r)| (r, i as u32))
.collect();
Ok((offset, members))
}
fn build_source_xref_offsets(
source_offsets: BTreeMap<ObjectRef, XrefOffset>,
) -> BTreeMap<u32, (u16, XrefOffset)> {
let mut offsets = BTreeMap::new();
for (object_ref, xref_offset) in source_offsets {
offsets.insert(object_ref.number, (object_ref.generation, xref_offset));
}
offsets
}
fn build_source_offsets(entries: Vec<(ObjectRef, u64)>) -> BTreeMap<u32, (u16, usize)> {
let mut source_offsets = BTreeMap::new();
for (object_ref, xref_offset) in entries {
let next = source_offsets
.get(&object_ref.number)
.copied()
.map(|(generation, _)| generation)
.unwrap_or(0);
if object_ref.generation >= next {
source_offsets.insert(
object_ref.number,
(object_ref.generation, xref_offset as usize),
);
}
}
source_offsets
}
fn resolve_object_count(
declared_size: Option<&crate::Object>,
source_offsets: &BTreeMap<u32, XrefTableEntry>,
) -> usize {
let max_object_number = source_offsets.keys().next_back().copied().unwrap_or(0) as usize;
let declared = declared_size
.and_then(|size| match size {
crate::Object::Integer(value) => usize::try_from(*value).ok(),
_ => None,
})
.unwrap_or(0);
declared.max(max_object_number.saturating_add(1)).max(1)
}
fn resolve_xref_stream_object_count(
declared_size: Option<&crate::Object>,
source_offsets: &BTreeMap<u32, (u16, XrefOffset)>,
) -> usize {
let max_object_number = source_offsets.keys().next_back().copied().unwrap_or(0) as usize;
let declared = declared_size
.and_then(|size| match size {
crate::Object::Integer(value) => usize::try_from(*value).ok(),
_ => None,
})
.unwrap_or(0);
declared.max(max_object_number.saturating_add(1)).max(1)
}
fn write_incremental_xref(
bytes: &mut Vec<u8>,
source_offsets: &BTreeMap<u32, XrefTableEntry>,
) -> Result<usize> {
let xref_offset = bytes.len();
bytes.extend_from_slice(b"xref\n0 1\n");
let (free_generation, free_next) = match source_offsets.get(&0) {
Some(XrefTableEntry::Free { generation, next }) => (*generation, *next),
_ => (65535, 0),
};
bytes.extend_from_slice(format!("{free_next:010} {free_generation:05} f \n").as_bytes());
let mut object_numbers: Vec<u32> = source_offsets.keys().copied().filter(|n| *n > 0).collect();
if object_numbers.is_empty() {
return Ok(xref_offset);
}
object_numbers.sort_unstable();
let mut i = 0;
while i < object_numbers.len() {
let start = object_numbers[i];
let mut end = start;
while i + 1 < object_numbers.len() && object_numbers[i + 1] == end + 1 {
i += 1;
end = object_numbers[i];
}
let count = end - start + 1;
bytes.extend_from_slice(format!("{} {}\n", start, count).as_bytes());
for object_number in start..=end {
let entry = source_offsets.get(&object_number).ok_or_else(|| {
crate::Error::Unsupported(
"incremental xref subsection is missing object entry".to_string(),
)
})?;
match entry {
XrefTableEntry::InUse { generation, offset } => {
bytes.extend_from_slice(format!("{offset:010} {generation:05} n \n").as_bytes())
}
XrefTableEntry::Free { generation, next } => {
bytes.extend_from_slice(format!("{next:010} {generation:05} f \n").as_bytes())
}
}
}
i += 1;
}
Ok(xref_offset)
}
fn write_incremental_xref_stream(
bytes: &mut Vec<u8>,
trailer: &Dictionary,
source_offsets: &BTreeMap<u32, (u16, XrefOffset)>,
root_ref: &ObjectRef,
xref_object_number: u32,
object_count: usize,
previous_xref_offset: u64,
) -> Result<usize> {
let xref_offset = bytes.len();
if source_offsets.contains_key(&xref_object_number) {
return Err(crate::Error::Unsupported(format!(
"xref stream object number {} already exists",
xref_object_number
)));
}
let mut offsets = source_offsets.clone();
offsets.insert(0, (65535, XrefOffset::Free { next: 0 }));
offsets.insert(
xref_object_number,
(
0,
XrefOffset::Offset(u64::try_from(xref_offset).map_err(|_| {
crate::Error::Unsupported("xref stream object offset does not fit u64".to_string())
})?),
),
);
let mut object_numbers: Vec<u32> = offsets.keys().copied().collect();
object_numbers.sort_unstable();
let mut ranges = Vec::new();
let mut index = 0;
while index < object_numbers.len() {
let start = object_numbers[index];
let mut end = start;
while index + 1 < object_numbers.len() && object_numbers[index + 1] == end + 1 {
index += 1;
end = object_numbers[index];
}
ranges.push((start, end.saturating_sub(start).saturating_add(1)));
index += 1;
}
let stream_data = build_xref_stream_bytes(&offsets, &ranges)?;
let mut index_array = Vec::with_capacity(ranges.len() * 2);
for (start, count) in &ranges {
index_array.push(Object::Integer(i64::from(*start)));
index_array.push(Object::Integer(i64::from(*count)));
}
let size = i64::try_from(object_count)
.map_err(|_| crate::Error::Unsupported("xref stream /Size does not fit i64".to_string()))?;
let mut stream_dict = trailer.clone();
strip_incremental_trailer_keys(&mut stream_dict);
stream_dict.insert("Type", Object::Name(b"XRef".to_vec()));
stream_dict.insert("Size", Object::Integer(size));
stream_dict.insert(
"W",
Object::Array(vec![
Object::Integer(1),
Object::Integer(8),
Object::Integer(4),
]),
);
stream_dict.insert("Index", Object::Array(index_array));
stream_dict.insert("Root", Object::Reference(*root_ref));
stream_dict.insert(
"Length",
Object::Integer(i64::try_from(stream_data.len()).map_err(|_| {
crate::Error::Unsupported("xref stream /Length does not fit i64".to_string())
})?),
);
stream_dict.insert(
"Prev",
Object::Integer(previous_xref_offset.try_into().map_err(|_| {
crate::Error::Unsupported("startxref offset does not fit i64".to_string())
})?),
);
let xref_stream = Object::Stream(crate::Stream::new(stream_dict, stream_data));
write_object(bytes, ObjectRef::new(xref_object_number, 0), &xref_stream)?;
Ok(xref_offset)
}
fn build_xref_stream_bytes(
offsets: &BTreeMap<u32, (u16, XrefOffset)>,
ranges: &[(u32, u32)],
) -> Result<Vec<u8>> {
let mut stream_data = Vec::new();
for &(start, count) in ranges {
let end = start.checked_add(count).ok_or_else(|| {
crate::Error::Unsupported("xref stream range does not fit u32".to_string())
})?;
for object_number in start..end {
let (generation, xref_offset) = offsets.get(&object_number).ok_or_else(|| {
crate::Error::Unsupported(
"incremental xref stream is missing object entry".to_string(),
)
})?;
let object_type = match (object_number, xref_offset) {
(0, _) | (_, XrefOffset::Free { .. }) => 0,
(_, XrefOffset::Compressed { .. }) => 2,
_ => 1,
};
stream_data.push(object_type);
match xref_offset {
XrefOffset::Free { next } => {
stream_data.extend_from_slice(&(u64::from(*next).to_be_bytes()[0..8]));
stream_data.extend_from_slice(&u32::from(*generation).to_be_bytes()[0..4]);
}
XrefOffset::Offset(offset) => {
stream_data.extend_from_slice(&((*offset).to_be_bytes()[0..8]));
stream_data.extend_from_slice(&u32::from(*generation).to_be_bytes()[0..4]);
}
XrefOffset::Compressed { stream, index } => {
stream_data.extend_from_slice(&(u64::from(*stream).to_be_bytes()[0..8]));
stream_data.extend_from_slice(&u32::to_be_bytes(*index)[0..4]);
}
}
}
}
Ok(stream_data)
}
fn write_incremental_trailer<R: Read + Seek>(
bytes: &mut Vec<u8>,
pdf: &Pdf<R>,
root_ref: &ObjectRef,
object_count: usize,
previous_xref_offset: u64,
xref_offset: usize,
options: &WriteOptions,
) -> Result<()> {
let mut trailer = pdf.trailer().clone();
strip_xref_stream_trailer_keys(&mut trailer);
trailer.insert("Size", Object::Integer(object_count as i64));
trailer.insert("Root", Object::Reference(*root_ref));
trailer.insert(
"Prev",
Object::Integer(previous_xref_offset.try_into().map_err(|_| {
crate::Error::Unsupported("startxref offset does not fit i64".to_string())
})?),
);
if options.static_id {
apply_static_id(&mut trailer);
} else {
apply_random_id(&mut trailer);
}
bytes.extend_from_slice(b"trailer\n");
trailer.write_pdf(bytes);
bytes.extend_from_slice(format!("\nstartxref\n{xref_offset}\n%%EOF\n").as_bytes());
Ok(())
}
pub(crate) fn apply_static_id(trailer: &mut Dictionary) {
let pi_id = Object::String(QPDF_STATIC_ID.to_vec());
let first_id = match trailer.get("ID") {
Some(Object::Array(values))
if values.len() == 2
&& matches!(values[0], Object::String(_))
&& matches!(values[1], Object::String(_)) =>
{
values[0].clone()
}
_ => pi_id.clone(),
};
trailer.insert("ID", Object::Array(vec![first_id, pi_id]));
}
fn apply_deterministic_id_placeholder(trailer: &mut Dictionary) {
trailer.insert(
"ID",
Object::Array(vec![
Object::String(vec![0u8; 16]),
Object::String(vec![0u8; 16]),
]),
);
}
fn fresh_id_bytes() -> [u8; 16] {
use std::sync::atomic::{AtomicU64, Ordering};
static COUNTER: AtomicU64 = AtomicU64::new(0);
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let pid = std::process::id();
let seq = COUNTER.fetch_add(1, Ordering::Relaxed);
let mut hasher = md5::Md5::new();
use md5::Digest as _;
hasher.update(nanos.to_le_bytes());
hasher.update(pid.to_le_bytes());
hasher.update(seq.to_le_bytes());
hasher.finalize().into()
}
pub(crate) fn random_id_array(source_id: Option<&Object>) -> Object {
let first_id = match source_id {
Some(Object::Array(values))
if values.len() == 2
&& matches!(values[0], Object::String(_))
&& matches!(values[1], Object::String(_)) =>
{
values[0].clone()
}
_ => Object::String(fresh_id_bytes().to_vec()),
};
let second_id = Object::String(fresh_id_bytes().to_vec());
Object::Array(vec![first_id, second_id])
}
pub(crate) fn apply_random_id(trailer: &mut Dictionary) {
let id = random_id_array(trailer.get("ID"));
trailer.insert("ID", id);
}
fn strip_incremental_trailer_keys(trailer: &mut Dictionary) {
strip_xref_stream_trailer_keys(trailer);
trailer.remove("Prev");
}
fn remap_trailer_refs<M: crate::rewrite_renumber::NewNumberLookup>(
trailer: &mut Dictionary,
map: &M,
deleted: &[ObjectRef],
) -> Result<()> {
let to_remap: Vec<(Vec<u8>, ObjectRef)> = trailer
.iter()
.filter(|(key, _)| *key != b"Root" && *key != b"Encrypt")
.filter_map(|(key, value)| match value {
Object::Reference(r) => Some((key.to_vec(), *r)),
_ => None,
})
.collect();
for (key, old) in to_remap {
if deleted.contains(&old) {
trailer.remove(&key);
continue;
}
let new = map.new_for_original(old).ok_or_else(|| {
crate::Error::Unsupported(format!(
"renumber: trailer /{} reference {old} absent from map",
String::from_utf8_lossy(&key)
))
})?;
trailer.insert(key, Object::Reference(new));
}
for value in trailer.values_mut() {
if matches!(value, Object::Dictionary(_) | Object::Array(_)) {
crate::rewrite_renumber::renumber_refs_in_place(value, map)?;
}
}
Ok(())
}
fn strip_xref_stream_trailer_keys(trailer: &mut Dictionary) {
let has_xref_stream_markers = matches!(trailer.get("Type"), Some(Object::Name(type_name)) if type_name.as_slice() == b"XRef")
|| trailer.get("XRefStm").is_some()
|| trailer.get("W").is_some()
|| trailer.get("Index").is_some();
if !has_xref_stream_markers {
return;
}
for key in [
"Type",
"F",
"FFilter",
"FDecodeParms",
"W",
"Index",
"Length",
"Filter",
"DecodeParms",
"XRefStm",
] {
trailer.remove(key);
}
}
pub fn write_qdf<R: Read + Seek, W: Write>(pdf: &mut Pdf<R>, out: W) -> Result<()> {
let options = WriteOptions {
qdf: true,
full_rewrite: true,
..WriteOptions::default()
};
write_pdf_with_options(pdf, out, &options)
}
mod _writer_doc_anchor {}
#[derive(Debug, Clone, Copy)]
enum WriteCipher {
PerObject(crate::security::standard::ObjectKeyAlg),
FileKeyAes256,
}
struct EncryptionContext {
encrypt_dict: Dictionary,
file_key: Vec<u8>,
cipher: WriteCipher,
encrypt_ref: ObjectRef,
id0: Vec<u8>,
static_aes_iv: bool,
encrypt_metadata: bool,
metadata_ref: Option<ObjectRef>,
}
fn resolve_metadata_stream_ref<R: Read + Seek>(pdf: &mut Pdf<R>) -> Option<ObjectRef> {
let root = pdf.root_ref()?;
match pdf.resolve_borrowed(root).ok()? {
Object::Dictionary(dict) => dict.get_ref("Metadata"),
_ => None,
}
}
fn build_encryption_context<R: Read + Seek>(
pdf: &Pdf<R>,
options: &WriteOptions,
params: &crate::encrypt_setup::EncryptParams,
existing_max: u32,
metadata_ref: Option<ObjectRef>,
) -> Result<EncryptionContext> {
use crate::encrypt_setup::EncryptMethod;
use crate::security::standard::{
build_v1_v2_encrypt_dict, build_v4_encrypt_dict, ObjectKeyAlg, V1V2EncryptParams,
V4CryptMethod, V4EncryptParams,
};
let id0 = resolve_id0_for_encryption(pdf, options);
let (encrypt_dict, file_key, cipher) = match params.method {
EncryptMethod::V4Aes128 => {
let v4 = V4EncryptParams {
method: V4CryptMethod::Aes,
user_password: ¶ms.user_password,
owner_password: ¶ms.owner_password,
p: params.permissions.to_p_bits(),
id0: &id0,
encrypt_metadata: params.encrypt_metadata,
};
let (dict, key) = build_v4_encrypt_dict(&v4)?;
(dict, key, WriteCipher::PerObject(ObjectKeyAlg::Aes))
}
EncryptMethod::V5R6Aes256 => {
use crate::security::standard::{build_v5_r6_encrypt_dict, V5R6EncryptParams};
let secrets = generate_v5r6_secrets()?;
let v5 = V5R6EncryptParams {
user_password: ¶ms.user_password,
owner_password: ¶ms.owner_password,
p: params.permissions.to_p_bits(),
encrypt_metadata: params.encrypt_metadata,
};
let dict = build_v5_r6_encrypt_dict(&v5, &secrets);
(dict, secrets.file_key.to_vec(), WriteCipher::FileKeyAes256)
}
EncryptMethod::V5R5Aes256 => {
use crate::security::standard::{build_v5_r5_encrypt_dict, V5R6EncryptParams};
let secrets = generate_v5r6_secrets()?;
let v5 = V5R6EncryptParams {
user_password: ¶ms.user_password,
owner_password: ¶ms.owner_password,
p: params.permissions.to_p_bits(),
encrypt_metadata: params.encrypt_metadata,
};
let dict = build_v5_r5_encrypt_dict(&v5, &secrets);
(dict, secrets.file_key.to_vec(), WriteCipher::FileKeyAes256)
}
EncryptMethod::V1Rc440 => {
let v12 = V1V2EncryptParams {
v: 1,
r: 2,
length_bits: 40,
user_password: ¶ms.user_password,
owner_password: ¶ms.owner_password,
p: params.permissions.to_p_bits(),
id0: &id0,
};
let (dict, key) = build_v1_v2_encrypt_dict(&v12)?;
(dict, key, WriteCipher::PerObject(ObjectKeyAlg::Rc4))
}
EncryptMethod::V2Rc4128 => {
let v12 = V1V2EncryptParams {
v: 2,
r: 3,
length_bits: 128,
user_password: ¶ms.user_password,
owner_password: ¶ms.owner_password,
p: params.permissions.to_p_bits(),
id0: &id0,
};
let (dict, key) = build_v1_v2_encrypt_dict(&v12)?;
(dict, key, WriteCipher::PerObject(ObjectKeyAlg::Rc4))
}
EncryptMethod::V4Rc4128 => {
let v4 = V4EncryptParams {
method: V4CryptMethod::Rc4,
user_password: ¶ms.user_password,
owner_password: ¶ms.owner_password,
p: params.permissions.to_p_bits(),
id0: &id0,
encrypt_metadata: params.encrypt_metadata,
};
let (dict, key) = build_v4_encrypt_dict(&v4)?;
(dict, key, WriteCipher::PerObject(ObjectKeyAlg::Rc4))
}
};
let encrypt_num = existing_max.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite encrypt: /Encrypt object number overflows u32".to_string(),
)
})?;
Ok(EncryptionContext {
encrypt_dict,
file_key,
cipher,
encrypt_ref: ObjectRef::new(encrypt_num, 0),
id0,
static_aes_iv: options.static_aes_iv,
encrypt_metadata: params.encrypt_metadata,
metadata_ref: if params.encrypt_metadata {
None
} else {
metadata_ref
},
})
}
fn generate_v5r6_secrets() -> Result<crate::security::standard::V5R6Secrets> {
let mut buf = [0u8; 68];
getrandom::getrandom(&mut buf).map_err(|e| {
crate::Error::Unsupported(format!(
"OS CSPRNG (getrandom) unavailable for V=5 R=6 secret generation: {e}"
))
})?;
Ok(crate::security::standard::V5R6Secrets {
file_key: buf[0..32].try_into().unwrap(),
user_validation_salt: buf[32..40].try_into().unwrap(),
user_key_salt: buf[40..48].try_into().unwrap(),
owner_validation_salt: buf[48..56].try_into().unwrap(),
owner_key_salt: buf[56..64].try_into().unwrap(),
perms_random_tail: buf[64..68].try_into().unwrap(),
})
}
fn build_copy_encryption_context(
src: &crate::encrypt_setup::CopyEncryptionSource,
options: &WriteOptions,
existing_max: u32,
) -> Result<EncryptionContext> {
let encrypt_num = existing_max.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite copy-encryption: /Encrypt object number overflows u32".to_string(),
)
})?;
Ok(EncryptionContext {
encrypt_dict: src.encrypt_dict.clone(),
file_key: src.file_key.clone(),
cipher: WriteCipher::PerObject(src.object_key_alg),
encrypt_ref: ObjectRef::new(encrypt_num, 0),
id0: src.id0.clone(),
static_aes_iv: options.static_aes_iv,
encrypt_metadata: true,
metadata_ref: None,
})
}
fn resolve_id0_for_encryption<R: Read + Seek>(pdf: &Pdf<R>, options: &WriteOptions) -> Vec<u8> {
if let Some(Object::Array(values)) = pdf.trailer().get("ID") {
if values.len() == 2 {
if let Some(Object::String(bytes)) = values.first() {
if !bytes.is_empty() {
return bytes.clone();
}
}
}
}
if options.static_id {
QPDF_STATIC_ID.to_vec()
} else {
fresh_id_bytes().to_vec()
}
}
fn push_hex_lower(out: &mut Vec<u8>, bytes: &[u8]) {
const HEX: &[u8; 16] = b"0123456789abcdef";
for &byte in bytes {
out.push(HEX[(byte >> 4) as usize]);
out.push(HEX[(byte & 0x0f) as usize]);
}
}
pub(crate) const fn deterministic_id_array_len(id0_len: usize) -> usize {
1 + (1 + 2 * id0_len + 1) + (1 + 32 + 1) + 1
}
#[cfg_attr(not(test), allow(dead_code))]
pub(crate) const DETERMINISTIC_ID_ARRAY_LEN: usize = deterministic_id_array_len(16);
pub(crate) fn write_deterministic_id_array(out: &mut Vec<u8>, id0: &[u8], id1: &[u8; 16]) {
out.push(b'[');
for id in [id0, &id1[..]] {
out.push(b'<');
push_hex_lower(out, id);
out.push(b'>');
}
out.push(b']');
}
pub(crate) fn source_permanent_id(trailer: &Dictionary) -> Option<Vec<u8>> {
match trailer.get("ID") {
Some(Object::Array(values)) if values.len() == 2 => match (&values[0], &values[1]) {
(Object::String(first), Object::String(_)) if !first.is_empty() => Some(first.clone()),
_ => None,
},
_ => None,
}
}
pub(crate) fn deterministic_id_info_suffix<R: Read + Seek>(pdf: &mut Pdf<R>) -> Vec<u8> {
let info_obj = match pdf.trailer().get("Info").cloned() {
Some(info) => info,
None => return Vec::new(),
};
let info = match info_obj {
Object::Reference(reference) => match pdf.resolve(reference) {
Ok(resolved) => resolved,
Err(_) => return Vec::new(), },
other => other,
};
let Object::Dictionary(dict) = info else {
return Vec::new();
};
let mut suffix = Vec::new();
for (_key, value) in dict.iter() {
let resolved = match value {
Object::Reference(reference) => match pdf.resolve(*reference) {
Ok(resolved) => resolved,
Err(_) => continue, },
other => other.clone(),
};
if let Object::String(bytes) = resolved {
suffix.push(b' ');
suffix.extend_from_slice(&bytes);
}
}
suffix
}
pub(crate) fn compute_deterministic_id(
bytes: &[u8],
id_array_offset: usize,
info_suffix: &[u8],
source_id0: Option<&[u8]>,
) -> (Vec<u8>, [u8; 16]) {
use md5::Digest as _;
let det_data = md5::Md5::digest(&bytes[..=id_array_offset]);
let mut seed = Vec::with_capacity(32 + 6 + info_suffix.len());
push_hex_lower(&mut seed, det_data.as_slice());
seed.extend_from_slice(b" QPDF ");
seed.extend_from_slice(info_suffix);
let seed_hash_input = &seed[..seed.iter().position(|&b| b == 0).unwrap_or(seed.len())];
let id1: [u8; 16] = md5::Md5::digest(seed_hash_input).into();
let id0 = source_id0
.map(<[u8]>::to_vec)
.unwrap_or_else(|| id1.to_vec());
(id0, id1)
}
pub(crate) fn write_deterministic_id_inline(
out: &mut Vec<u8>,
info_suffix: &[u8],
source_id0: Option<&[u8]>,
) {
out.push(b'[');
let id_array_offset = out.len() - 1; let (id0, id1) = compute_deterministic_id(out, id_array_offset, info_suffix, source_id0);
for id in [id0.as_slice(), &id1[..]] {
out.push(b'<');
push_hex_lower(out, id);
out.push(b'>');
}
out.push(b']');
}
fn apply_encrypt_trailer_entries<R: Read + Seek>(
trailer: &mut Dictionary,
pdf: &Pdf<R>,
options: &WriteOptions,
encrypt_ctx: Option<&EncryptionContext>,
deterministic_id: bool,
) {
if let Some(ctx) = encrypt_ctx {
trailer.insert("Encrypt", Object::Reference(ctx.encrypt_ref));
let id1 = if options.static_id {
QPDF_STATIC_ID.to_vec()
} else {
fresh_id_bytes().to_vec()
};
trailer.insert(
"ID",
Object::Array(vec![Object::String(ctx.id0.clone()), Object::String(id1)]),
);
} else {
if pdf.is_encrypted() {
trailer.remove("Encrypt");
}
if deterministic_id {
apply_deterministic_id_placeholder(trailer);
} else if options.static_id {
apply_static_id(trailer);
} else {
apply_random_id(trailer);
}
}
}
fn encrypt_strings_in_object_for_writer(
object_ref: ObjectRef,
object: &mut Object,
ctx: &EncryptionContext,
) -> Result<()> {
use crate::security::standard::{
encrypt_strings_in_object, per_object_key, ObjectKeyAlg, StringEncryptCipher,
};
let mut iv_gen = || {
if ctx.static_aes_iv {
[0u8; 16]
} else {
let mut iv = [0u8; 16];
getrandom::getrandom(&mut iv)
.expect("OS CSPRNG (getrandom) must be available for AES IV generation");
iv
}
};
match ctx.cipher {
WriteCipher::PerObject(alg) => {
let per_obj_key = per_object_key(
&ctx.file_key,
object_ref.number,
u32::from(object_ref.generation),
alg,
);
match alg {
ObjectKeyAlg::Aes => {
let key_bytes: [u8; 16] = per_obj_key
.as_slice()
.try_into()
.expect("V=4 AES per-object key is exactly 16 bytes");
let cipher = StringEncryptCipher::Aes128 { key: &key_bytes };
encrypt_strings_in_object(
object_ref,
object,
cipher,
Some(ctx.encrypt_ref),
&mut iv_gen,
)
}
ObjectKeyAlg::Rc4 => {
let cipher = StringEncryptCipher::Rc4 {
key: per_obj_key.as_slice(),
};
encrypt_strings_in_object(
object_ref,
object,
cipher,
Some(ctx.encrypt_ref),
&mut iv_gen,
)
}
}
}
WriteCipher::FileKeyAes256 => {
let key_bytes: [u8; 32] = ctx.file_key.as_slice().try_into().map_err(|_| {
crate::Error::Unsupported("V=5 AES-256 file key is not 32 bytes".to_string())
})?;
let cipher = StringEncryptCipher::Aes256 { key: &key_bytes };
encrypt_strings_in_object(
object_ref,
object,
cipher,
Some(ctx.encrypt_ref),
&mut iv_gen,
)
}
}
}
fn encrypt_stream_payload_for_writer(
object_ref: ObjectRef,
stream: &mut crate::Stream,
ctx: &EncryptionContext,
) -> Result<()> {
use crate::security::standard::{
encrypt_cipher_bytes, per_object_key, ObjectKeyAlg, StringEncryptCipher,
};
let needs_aes_iv = matches!(
ctx.cipher,
WriteCipher::PerObject(ObjectKeyAlg::Aes) | WriteCipher::FileKeyAes256
);
let mut iv = [0u8; 16];
if needs_aes_iv && !ctx.static_aes_iv {
getrandom::getrandom(&mut iv).map_err(|e| {
crate::Error::Unsupported(format!(
"OS CSPRNG (getrandom) unavailable for AES IV generation: {e}"
))
})?;
}
match ctx.cipher {
WriteCipher::PerObject(alg) => {
let per_obj_key = per_object_key(
&ctx.file_key,
object_ref.number,
u32::from(object_ref.generation),
alg,
);
match alg {
ObjectKeyAlg::Aes => {
let key_bytes: [u8; 16] = per_obj_key
.as_slice()
.try_into()
.expect("V=4 AES per-object key is exactly 16 bytes");
let cipher = StringEncryptCipher::Aes128 { key: &key_bytes };
encrypt_cipher_bytes(&mut stream.data, cipher, &iv)?;
}
ObjectKeyAlg::Rc4 => {
let cipher = StringEncryptCipher::Rc4 {
key: per_obj_key.as_slice(),
};
encrypt_cipher_bytes(&mut stream.data, cipher, &iv)?;
}
}
}
WriteCipher::FileKeyAes256 => {
let key_bytes: [u8; 32] = ctx.file_key.as_slice().try_into().map_err(|_| {
crate::Error::Unsupported("V=5 AES-256 file key is not 32 bytes".to_string())
})?;
let cipher = StringEncryptCipher::Aes256 { key: &key_bytes };
encrypt_cipher_bytes(&mut stream.data, cipher, &iv)?;
}
}
let new_len = i64::try_from(stream.data.len()).map_err(|_| {
crate::Error::Unsupported("encrypted stream /Length overflows i64".to_string())
})?;
stream.dict.insert("Length", Object::Integer(new_len));
Ok(())
}
fn reencode_stream_for_compress(stream: crate::Stream, options: &WriteOptions) -> (Object, bool) {
let source_filter_is_lone_flate = is_lone_flate(stream.dict.get("Filter"));
let reencoded = match effective_stream_policy(options) {
Some(CompressStreams::Yes)
if source_filter_is_lone_flate
&& !options.recompress_flate
&& stream.dict.get("F").is_none() =>
{
let mut stream = stream;
let len = i64::try_from(stream.data.len()).unwrap_or(i64::MAX);
stream.dict.insert("Length", Object::Integer(len));
Object::Stream(stream)
}
Some(compress_policy) => apply_stream_compress_policy(&stream, compress_policy),
None => {
let mut stream = stream;
let len = i64::try_from(stream.data.len()).unwrap_or(i64::MAX);
stream.dict.insert("Length", Object::Integer(len));
Object::Stream(stream)
}
};
(reencoded, source_filter_is_lone_flate)
}
fn write_reencoded_object(
bytes: &mut Vec<u8>,
reencoded: &Object,
source_filter_is_lone_flate: bool,
options: &WriteOptions,
) {
match reencoded {
Object::Stream(s) => {
let refiltered = matches!(effective_stream_policy(options), Some(CompressStreams::Yes))
&& !source_filter_is_lone_flate
&& is_lone_flate(s.dict.get("Filter"));
write_stream_to_buf_qpdf_order(bytes, s, options.newline_before_endstream, refiltered);
}
other => other.write_pdf(bytes),
}
}
fn write_pdf_full_rewrite<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
out: W,
options: &WriteOptions,
) -> Result<()> {
let catalog_snapshot = pdf.root_ref().and_then(|r| {
let was_dirty = pdf.is_dirty(r);
pdf.resolve(r).ok().map(|catalog| (r, catalog, was_dirty))
});
let effective;
let options = if options.qdf && options.newline_before_endstream != NewlineBeforeEndstream::Yes
{
effective = WriteOptions {
newline_before_endstream: NewlineBeforeEndstream::Yes,
..options.clone()
};
&effective
} else {
options
};
let result = write_pdf_full_rewrite_inner(pdf, out, options);
if let Some((root_ref, original, was_dirty)) = catalog_snapshot {
pdf.set_object(root_ref, original);
if !was_dirty {
pdf.clear_dirty(root_ref);
}
}
result
}
fn write_pdf_full_rewrite_inner<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
mut out: W,
options: &WriteOptions,
) -> Result<()> {
let encrypting = options.encrypt.is_some() || options.copy_encryption.is_some();
let suppressed_options;
let options = if force_version_below_1_5(options)
&& (matches!(options.object_streams, ObjectStreamMode::Generate)
|| (!encrypting && matches!(options.object_streams, ObjectStreamMode::Preserve)))
{
suppressed_options = WriteOptions {
object_streams: ObjectStreamMode::Disable,
..options.clone()
};
&suppressed_options
} else {
options
};
{
let source_ver = pdf.version().to_string();
let source_ext = pdf.adobe_extension_level().unwrap_or(0);
let will_emit_objstm =
!options.qdf && matches!(options.object_streams, ObjectStreamMode::Generate);
let (eff_ver, eff_ext) = effective_pdf_version_and_ext(
&source_ver,
source_ext,
options,
false,
will_emit_objstm,
);
if eff_ext > 0 {
inject_adbe_extension(pdf, eff_ver, eff_ext)?;
} else if source_ext > 0 {
strip_adbe_extension(pdf)?;
}
}
if matches!(options.object_streams, ObjectStreamMode::Generate)
&& options.encrypt.is_none()
&& options.copy_encryption.is_none()
&& !options.qdf
{
return write_pdf_generate(pdf, out, options);
}
let Some(root_ref) = pdf.root_ref() else {
return Err(crate::Error::Missing("/Root"));
};
use crate::rewrite_renumber::CatalogFirstRenumber;
let renumber = CatalogFirstRenumber::build(pdf, true)?;
let new_root = renumber
.new_for_original(root_ref)
.ok_or_else(|| crate::Error::Unsupported("renumber: /Root absent from map".to_string()))?;
if options.deterministic_id && options.static_id {
return Err(crate::Error::Unsupported(
"deterministic_id and static_id are mutually exclusive".to_string(),
));
}
let mut version = effective_pdf_version(pdf.version(), options, false, false).to_owned();
if options.encrypt.is_some() && options.copy_encryption.is_some() {
return Err(crate::Error::Unsupported(
"encrypt and copy_encryption are mutually exclusive".to_string(),
));
}
if options.deterministic_id && encrypting {
return Err(crate::Error::Unsupported(
"the deterministic-id option is incompatible with encrypted output files".to_string(),
));
}
if encrypting && options.qdf {
return Err(crate::Error::Unsupported(
"--encrypt / --copy-encryption-from cannot be combined with --qdf \
(flpdf-9hc.4.9 walking skeleton)"
.to_string(),
));
}
let (det_id_source_id0, det_id_info_suffix): (Option<Vec<u8>>, Vec<u8>) =
if options.deterministic_id {
let id0 = source_permanent_id(pdf.trailer());
let suffix = deterministic_id_info_suffix(pdf);
(id0, suffix)
} else {
(None, Vec::new())
};
let planner_options;
let planner_config = if options.copy_encryption.is_some() {
planner_options = WriteOptions {
object_streams: ObjectStreamMode::Disable,
..options.clone()
};
object_streams::planner_config_from_options(&planner_options)
} else {
object_streams::planner_config_from_options(options)
};
let mut plan = object_streams::plan_object_streams(pdf, &planner_config)?;
for batch in &mut plan.batches {
batch.retain(|member| renumber.new_for_original(*member).is_some());
}
plan.batches.retain(|batch| !batch.is_empty());
let mut effective_xref_form = if plan.batches.is_empty() {
pdf.last_xref_form()
} else {
XrefForm::Stream
};
if options.qdf {
effective_xref_form = XrefForm::Table;
}
if options.copy_encryption.is_some() {
effective_xref_form = XrefForm::Table;
}
if force_version_below_1_5(options) && !encrypting {
effective_xref_form = XrefForm::Table;
}
if matches!(effective_xref_form, XrefForm::Stream)
&& parse_pdf_version(&version).is_none_or(|v| v < (1, 5))
{
version = "1.5".to_string();
}
if let Some(params) = options.encrypt.as_ref() {
use crate::encrypt_setup::EncryptMethod;
let floor = match params.method {
EncryptMethod::V1Rc440 => (1, 1),
EncryptMethod::V2Rc4128 => (1, 4),
EncryptMethod::V4Aes128 | EncryptMethod::V4Rc4128 => (1, 5),
EncryptMethod::V5R6Aes256 | EncryptMethod::V5R5Aes256 => (1, 7),
};
if parse_pdf_version(&version).is_none_or(|v| v < floor) {
version = format!("{}.{}", floor.0, floor.1);
}
} else if options.copy_encryption.is_some() {
if parse_pdf_version(&version).is_none_or(|v| v < (1, 5)) {
version = "1.5".to_string();
}
}
let renumbered: Vec<(ObjectRef, ObjectRef)> = renumber.pairs().collect();
let existing_max: u32 = u32::try_from(renumber.len()).map_err(|_| {
crate::Error::Unsupported("full-rewrite: renumbered object count overflows u32".to_string())
})?;
let container_refs: Vec<ObjectRef> = (1..=plan.batches.len())
.map(|i| {
existing_max
.checked_add(i as u32)
.map(|n| ObjectRef::new(n, 0))
})
.collect::<Option<Vec<_>>>()
.ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: ObjStm container number overflows u32".to_string(),
)
})?;
use std::collections::HashMap;
let mut member_to_batch: HashMap<ObjectRef, (u32, u32)> = HashMap::new();
let mut member_new_to_batch: HashMap<u32, (u32, u32)> = HashMap::new();
for (batch_idx, batch) in plan.batches.iter().enumerate() {
let container_num = container_refs[batch_idx].number;
for (idx_in_batch, &member_ref) in batch.iter().enumerate() {
member_to_batch.insert(member_ref, (container_num, idx_in_batch as u32));
let new = renumber.new_for_original(member_ref).ok_or_else(|| {
crate::Error::Unsupported("ObjStm member absent from renumber map".to_string())
})?;
member_new_to_batch.insert(new.number, (container_num, idx_in_batch as u32));
}
}
let metadata_ref = if options
.encrypt
.as_ref()
.is_some_and(|p| !p.encrypt_metadata)
{
resolve_metadata_stream_ref(pdf)
} else {
None
};
let encrypt_ctx: Option<EncryptionContext> = if let Some(ref params) = options.encrypt {
let containers_len = u32::try_from(plan.batches.len()).map_err(|_| {
crate::Error::Unsupported(
"full-rewrite encrypt: ObjStm batch count overflows u32".to_string(),
)
})?;
let base_for_encrypt = existing_max.checked_add(containers_len).ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite encrypt: /Encrypt object number overflows u32".to_string(),
)
})?;
Some(build_encryption_context(
pdf,
options,
params,
base_for_encrypt,
metadata_ref,
)?)
} else if let Some(ref src) = options.copy_encryption {
Some(build_copy_encryption_context(src, options, existing_max)?)
} else {
None
};
let skip_refs = pdf.deleted_object_refs();
let mut qdf_emission_renumber: HashMap<ObjectRef, ObjectRef> = HashMap::new();
let mut qdf_holder_map: HashMap<u32, u32> = HashMap::new();
if options.qdf {
let mut next_emission: u32 = 0;
for (cf_ref, old_ref) in &renumbered {
if Some(*old_ref) == pdf.encryption_ref() {
continue; }
if old_ref.number == 0 || skip_refs.contains(old_ref) {
continue; }
if member_to_batch.contains_key(old_ref) {
continue;
}
let is_real_stream = match pdf.resolve_borrowed(*old_ref)? {
Object::Stream(s) => {
let ty = s.dict.get("Type");
let is_structural = matches!(ty, Some(Object::Name(n))
if n.as_slice() == b"XRef" || n.as_slice() == b"ObjStm"); if is_structural {
None } else {
Some(true)
}
}
_ => Some(false),
};
let Some(is_stream) = is_real_stream else {
continue; };
next_emission = next_emission.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: QDF emission number overflows u32".to_string(),
)
})?; let emission_num = next_emission;
qdf_emission_renumber.insert(*old_ref, ObjectRef::new(emission_num, cf_ref.generation));
if is_stream {
next_emission = next_emission.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: QDF holder number overflows u32".to_string(),
)
})?; qdf_holder_map.insert(emission_num, next_emission);
}
}
}
let new_root = if options.qdf {
qdf_emission_renumber
.get(&root_ref)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(
"QDF emission: /Root absent from emission map".to_string(),
)
})? } else {
new_root
};
let mut bytes = Vec::new();
bytes.extend_from_slice(format!("%PDF-{version}\n").as_bytes());
bytes.extend_from_slice(QPDF_BINARY_MARKER);
if options.qdf {
bytes.extend_from_slice(b"%QDF-1.0\n");
bytes.extend_from_slice(b"\n");
}
let mut offsets = BTreeMap::<u32, (u16, usize)>::new();
for (new_ref, old_ref) in &renumbered {
if Some(*old_ref) == pdf.encryption_ref() {
continue;
}
if old_ref.number == 0 || skip_refs.contains(old_ref) {
continue;
}
if member_to_batch.contains_key(old_ref) {
continue;
}
let emit_ref = if options.qdf {
match qdf_emission_renumber.get(old_ref) {
Some(&r) => r,
None => continue, }
} else {
*new_ref
};
let mut object = pdf.resolve(*old_ref)?;
if options.qdf {
crate::rewrite_renumber::renumber_refs_in_place(&mut object, &qdf_emission_renumber)?;
} else {
crate::rewrite_renumber::renumber_refs_in_place(&mut object, &renumber)?;
}
if let Some(ctx) = &encrypt_ctx {
if emit_ref != ctx.encrypt_ref {
encrypt_strings_in_object_for_writer(emit_ref, &mut object, ctx)?;
}
}
if let Object::Stream(ref s) = object {
let ty = s.dict.get("Type");
let is_xref = matches!(ty, Some(Object::Name(n)) if n.as_slice() == b"XRef");
let is_objstm = matches!(ty, Some(Object::Name(n)) if n.as_slice() == b"ObjStm");
if is_xref || is_objstm {
continue;
}
}
if offsets.contains_key(&emit_ref.number) {
return Err(crate::Error::Unsupported(format!(
"duplicate object number {} in xref table",
emit_ref.number
)));
}
if options.qdf && !options.no_original_object_ids {
bytes.extend_from_slice(
format!(
"%% Original object ID: {} {}\n",
old_ref.number, old_ref.generation
)
.as_bytes(),
);
}
let emit_offset = bytes.len();
bytes.extend_from_slice(
format!("{} {} obj\n", emit_ref.number, emit_ref.generation).as_bytes(),
);
let mut qdf_holder_to_emit: Option<(u32, i64)> = None;
if let Object::Stream(stream) = object {
let (mut reencoded, source_filter_is_lone_flate) =
reencode_stream_for_compress(stream, options);
if let Some(ctx) = &encrypt_ctx {
if emit_ref != ctx.encrypt_ref {
if let Object::Stream(ref mut s) = reencoded {
if !ctx.encrypt_metadata && ctx.metadata_ref == Some(*old_ref) {
crate::security::standard::prepend_crypt_filter_to_stream_dict(
&mut s.dict,
b"Identity",
);
} else {
encrypt_stream_payload_for_writer(emit_ref, s, ctx)?;
}
}
}
}
if options.qdf {
if let Object::Stream(ref s) = reencoded {
let len_value = i64::try_from(on_disk_stream_len(
&s.data,
options.newline_before_endstream,
))
.unwrap_or(i64::MAX);
let holder_num =
qdf_holder_map
.get(&emit_ref.number)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"full-rewrite: QDF holder not found for stream at emission {}",
emit_ref.number
))
})?; qdf_holder_to_emit = Some((holder_num, len_value));
let mut holder_stream = s.clone();
holder_stream
.dict
.insert("Length", Object::Reference(ObjectRef::new(holder_num, 0)));
write_stream_to_buf_qdf(
&mut bytes,
&holder_stream,
options.newline_before_endstream,
);
} else {
reencoded.write_pdf_qdf(&mut bytes, 0);
}
} else {
write_reencoded_object(
&mut bytes,
&reencoded,
source_filter_is_lone_flate,
options,
);
}
} else if options.qdf {
object.write_pdf_qdf(&mut bytes, 0);
} else {
object.write_pdf(&mut bytes);
}
bytes.extend_from_slice(b"\nendobj\n");
if options.qdf {
bytes.push(b'\n');
}
offsets.insert(emit_ref.number, (emit_ref.generation, emit_offset));
if let Some((hnum, hlen)) = qdf_holder_to_emit {
let h_offset = bytes.len();
bytes.extend_from_slice(format!("{hnum} 0 obj\n{hlen}\nendobj\n").as_bytes());
bytes.push(b'\n'); offsets.insert(hnum, (0, h_offset));
}
}
for (batch_idx, batch) in plan.batches.iter().enumerate() {
let container_ref = container_refs[batch_idx];
let mut resolved: Vec<(ObjectRef, Object)> = Vec::with_capacity(batch.len());
for &old in batch {
let mut obj = pdf.resolve(old)?;
crate::rewrite_renumber::renumber_refs_in_place(&mut obj, &renumber)?;
let new = renumber.new_for_original(old).ok_or_else(|| {
crate::Error::Unsupported("ObjStm member absent from renumber map".to_string())
})?;
resolved.push((new, obj));
}
let body = object_streams::emit_objstm_body_from_resolved(&resolved)?;
let mut stream = object_streams::wrap_objstm_body(&body, options.compress_streams)?;
if let Some(ctx) = &encrypt_ctx {
encrypt_stream_payload_for_writer(container_ref, &mut stream, ctx)?;
}
let emit_offset = bytes.len();
bytes.extend_from_slice(format!("{} 0 obj\n", container_ref.number).as_bytes());
write_stream_to_buf(&mut bytes, &stream, options.newline_before_endstream);
bytes.extend_from_slice(b"\nendobj\n");
if options.qdf {
bytes.push(b'\n');
}
offsets.insert(container_ref.number, (0, emit_offset));
}
if let Some(ctx) = &encrypt_ctx {
let emit_offset = bytes.len();
bytes.extend_from_slice(format!("{} 0 obj\n", ctx.encrypt_ref.number).as_bytes());
Object::Dictionary(ctx.encrypt_dict.clone()).write_pdf(&mut bytes);
bytes.extend_from_slice(b"\nendobj\n");
offsets.insert(ctx.encrypt_ref.number, (0, emit_offset));
}
let xref_offset = bytes.len();
let max_object_number = offsets.keys().next_back().copied().unwrap_or(0);
let object_count: usize = max_object_number
.checked_add(1)
.and_then(|n| usize::try_from(n).ok())
.ok_or_else(|| {
crate::Error::Unsupported("full-rewrite: object count does not fit in u32".to_string())
})?;
match effective_xref_form {
XrefForm::Table => {
bytes.extend_from_slice(format!("xref\n0 {}\n", object_count).as_bytes());
bytes.extend_from_slice(b"0000000000 65535 f \n");
for number in 1..object_count {
match offsets.get(&(number as u32)) {
Some((generation, offset)) => bytes
.extend_from_slice(format!("{offset:010} {generation:05} n \n").as_bytes()),
None => bytes.extend_from_slice(b"0000000000 65535 f \n"),
}
}
let mut trailer = pdf.trailer().clone();
strip_incremental_trailer_keys(&mut trailer);
if options.qdf {
remap_trailer_refs(&mut trailer, &qdf_emission_renumber, &skip_refs)?;
} else {
remap_trailer_refs(&mut trailer, &renumber, &skip_refs)?;
}
trailer.insert("Size", Object::Integer(object_count as i64));
trailer.insert("Root", Object::Reference(new_root));
apply_encrypt_trailer_entries(
&mut trailer,
pdf,
options,
encrypt_ctx.as_ref(),
options.deterministic_id,
);
if options.qdf {
if options.deterministic_id {
let mut id_writer = |out: &mut Vec<u8>| {
write_deterministic_id_inline(
out,
&det_id_info_suffix,
det_id_source_id0.as_deref(),
)
};
write_qdf_trailer(&mut bytes, &trailer, Some(&mut id_writer));
} else {
write_qdf_trailer(&mut bytes, &trailer, None);
}
bytes.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
} else {
bytes.extend_from_slice(b"trailer ");
if options.deterministic_id {
let mut id_writer = |out: &mut Vec<u8>| {
write_deterministic_id_inline(
out,
&det_id_info_suffix,
det_id_source_id0.as_deref(),
)
};
trailer.write_pdf_trailer(&mut bytes, Some(&mut id_writer));
} else {
trailer.write_pdf_trailer(&mut bytes, None);
}
bytes.extend_from_slice(format!("\nstartxref\n{xref_offset}\n%%EOF\n").as_bytes());
}
}
XrefForm::Stream => {
let xref_object_number = object_count as u32;
let final_object_count = (xref_object_number as usize).saturating_add(1);
let mut xref_entries: BTreeMap<u32, (u16, XrefOffset)> = BTreeMap::new();
xref_entries.insert(0, (65535, XrefOffset::Free { next: 0 }));
for number in 1..xref_object_number {
if let Some(&(gen, off)) = offsets.get(&number) {
xref_entries.insert(
number,
(
gen,
XrefOffset::Offset(u64::try_from(off).map_err(|_| {
crate::Error::Unsupported(
"xref offset does not fit u64".to_string(),
)
})?),
),
);
} else if let Some(&(container_num, index_in_batch)) =
member_new_to_batch.get(&number)
{
xref_entries.insert(
number,
(
0,
XrefOffset::Compressed {
stream: container_num,
index: index_in_batch,
},
),
);
} else {
xref_entries.insert(number, (0, XrefOffset::Free { next: 0 }));
}
}
xref_entries.insert(
xref_object_number,
(
0,
XrefOffset::Offset(u64::try_from(xref_offset).map_err(|_| {
crate::Error::Unsupported("xref stream offset does not fit u64".to_string())
})?),
),
);
let ranges: Vec<(u32, u32)> = vec![(0, final_object_count as u32)];
let raw_xref_bytes = build_xref_stream_bytes(&xref_entries, &ranges)?;
let mut index_array = Vec::with_capacity(ranges.len() * 2);
for &(start, count) in &ranges {
index_array.push(Object::Integer(i64::from(start)));
index_array.push(Object::Integer(i64::from(count)));
}
let mut xref_dict = pdf.trailer().clone();
strip_incremental_trailer_keys(&mut xref_dict);
remap_trailer_refs(&mut xref_dict, &renumber, &skip_refs)?;
xref_dict.remove("Filter");
xref_dict.remove("DecodeParms");
xref_dict.remove("F");
xref_dict.remove("FFilter");
xref_dict.remove("FDecodeParms");
xref_dict.insert("Type", Object::Name(b"XRef".to_vec()));
xref_dict.insert("Size", Object::Integer(final_object_count as i64));
xref_dict.insert(
"W",
Object::Array(vec![
Object::Integer(1),
Object::Integer(8),
Object::Integer(4),
]),
);
xref_dict.insert("Index", Object::Array(index_array));
xref_dict.insert("Root", Object::Reference(new_root));
let stream_data = match options.compress_streams {
CompressStreams::Yes => {
let mut encode_dict = Dictionary::new();
encode_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
match filters::encode_stream_data(&encode_dict, &raw_xref_bytes) {
Ok(compressed) => {
xref_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
compressed
}
Err(_) => raw_xref_bytes,
}
}
CompressStreams::No => {
raw_xref_bytes
}
};
xref_dict.insert(
"Length",
Object::Integer(i64::try_from(stream_data.len()).map_err(|_| {
crate::Error::Unsupported("xref stream /Length does not fit i64".to_string())
})?),
);
apply_encrypt_trailer_entries(
&mut xref_dict,
pdf,
options,
encrypt_ctx.as_ref(),
options.deterministic_id,
);
let xref_stream = crate::Stream::new(xref_dict, stream_data);
bytes.extend_from_slice(format!("{xref_object_number} 0 obj\n").as_bytes());
if options.deterministic_id {
let mut id_writer = |out: &mut Vec<u8>| {
write_deterministic_id_inline(
out,
&det_id_info_suffix,
det_id_source_id0.as_deref(),
)
};
write_stream_to_buf_with_id_writer(
&mut bytes,
&xref_stream,
options.newline_before_endstream,
Some(&mut id_writer),
);
} else {
write_stream_to_buf(&mut bytes, &xref_stream, options.newline_before_endstream);
}
bytes.extend_from_slice(b"\nendobj\n");
bytes.extend_from_slice(format!("\nstartxref\n{xref_offset}\n%%EOF\n").as_bytes());
}
}
out.write_all(&bytes)?;
Ok(())
}
fn generate_invariant<T>(value: Option<T>, what: &str) -> Result<T> {
value.ok_or_else(|| crate::Error::Unsupported(format!("generate: {what}")))
}
fn write_pdf_generate<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
mut out: W,
options: &WriteOptions,
) -> Result<()> {
use crate::rewrite_renumber::{renumber_refs_in_place, GenerateRenumber};
use std::collections::HashSet;
let root_ref = pdf.root_ref().ok_or(crate::Error::Missing("/Root"))?;
let eligible = object_streams::compressible_objgens(pdf)?;
let groups = object_streams::even_split_into_streams(&eligible);
let renumber = GenerateRenumber::build(pdf, &groups, true)?;
let new_root = generate_invariant(
renumber.new_for_original(root_ref),
"/Root absent from renumber map",
)?;
struct ContainerPlan {
number: u32,
members: Vec<(ObjectRef, ObjectRef)>,
}
let mut member_set: HashSet<ObjectRef> = HashSet::new();
let mut member_xref: BTreeMap<u32, (u32, u32)> = BTreeMap::new();
let mut containers: Vec<ContainerPlan> = Vec::with_capacity(groups.len());
for (gi, group) in groups.iter().enumerate() {
let number = generate_invariant(
renumber.container_number(gi),
"ObjStm container group was never reached",
)?; let mut members: Vec<(ObjectRef, ObjectRef)> = group
.iter()
.map(|&old| {
let new = generate_invariant(
renumber.new_for_original(old),
"ObjStm member absent from renumber map",
)?; Ok((old, new))
})
.collect::<Result<Vec<_>>>()?;
members.sort_by_key(|&(_, new)| new.number);
for (index, &(old, new)) in members.iter().enumerate() {
member_set.insert(old);
let index = u32::try_from(index).unwrap_or(u32::MAX);
member_xref.insert(new.number, (number, index));
}
containers.push(ContainerPlan { number, members });
}
enum Emit {
Container(usize),
Plain(ObjectRef),
}
let mut emit: BTreeMap<u32, Emit> = BTreeMap::new();
for (new, old) in renumber.pairs() {
if member_set.contains(&old) {
continue;
}
emit.insert(new.number, Emit::Plain(old));
}
for (gi, c) in containers.iter().enumerate() {
generate_invariant(
emit.insert(c.number, Emit::Container(gi))
.is_none()
.then_some(()),
"container object number collides with a plain object",
)?; }
let version = effective_pdf_version(pdf.version(), options, false, true).to_owned();
let (det_id_source_id0, det_id_info_suffix): (Option<Vec<u8>>, Vec<u8>) =
if options.deterministic_id {
(
source_permanent_id(pdf.trailer()),
deterministic_id_info_suffix(pdf),
)
} else {
(None, Vec::new())
};
let mut bytes = Vec::new();
bytes.extend_from_slice(format!("%PDF-{version}\n").as_bytes());
bytes.extend_from_slice(QPDF_BINARY_MARKER);
let mut offsets: BTreeMap<u32, usize> = BTreeMap::new();
for (&number, what) in &emit {
let emit_offset = bytes.len();
bytes.extend_from_slice(format!("{number} 0 obj\n").as_bytes());
match what {
Emit::Plain(old) => {
let mut object = pdf.resolve(*old)?;
renumber_refs_in_place(&mut object, &renumber)?;
match object {
Object::Stream(stream) => {
let (reencoded, source_filter_is_lone_flate) =
reencode_stream_for_compress(stream, options);
write_reencoded_object(
&mut bytes,
&reencoded,
source_filter_is_lone_flate,
options,
);
}
other => other.write_pdf(&mut bytes),
}
}
Emit::Container(gi) => {
let plan = &containers[*gi];
let mut resolved: Vec<(ObjectRef, Object)> = Vec::with_capacity(plan.members.len());
for &(old, new) in &plan.members {
let mut obj = pdf.resolve(old)?;
renumber_refs_in_place(&mut obj, &renumber)?;
resolved.push((new, obj));
}
let body = object_streams::emit_objstm_body_from_resolved(&resolved)?;
let stream = object_streams::wrap_objstm_body(&body, options.compress_streams)?;
bytes.extend_from_slice(b"<< /Type /ObjStm /Length ");
bytes.extend_from_slice(stream.data.len().to_string().as_bytes());
if stream.dict.get("Filter").is_some() {
bytes.extend_from_slice(b" /Filter /FlateDecode");
}
bytes.extend_from_slice(
format!(" /N {} /First {} >>", body.n_members, body.first_offset).as_bytes(),
);
write_stream_payload(&mut bytes, &stream.data, options.newline_before_endstream);
}
}
bytes.extend_from_slice(b"\nendobj\n");
offsets.insert(number, emit_offset);
}
use crate::linearization::xref_stream;
let xref_offset = bytes.len();
let max_object_number = offsets
.keys()
.chain(member_xref.keys())
.copied()
.max()
.unwrap_or(0);
let xref_object_number = generate_invariant(
max_object_number.checked_add(1),
"xref stream number overflows u32",
)?; let size = generate_invariant(
xref_object_number.checked_add(1),
"xref /Size overflows u32",
)?;
let mut offs = offsets;
offs.insert(xref_object_number, xref_offset);
let entries = xref_stream::build_entries(&offs, &member_xref, 0, size);
let max_offset = xref_stream::max_entry_offset(&entries);
let max_ostream_index = member_xref
.values()
.map(|&(_, index)| u64::from(index))
.max()
.unwrap_or(0);
let widths =
xref_stream::second_pass_widths(max_offset, 0, max_object_number, max_ostream_index);
let payload = xref_stream::encode_payload(&entries, widths);
let mut skip_refs = pdf.deleted_object_refs();
let live: BTreeSet<ObjectRef> = pdf.live_object_refs().into_iter().collect();
for (_key, value) in pdf.trailer().iter() {
if let Object::Reference(r) = value {
if !live.contains(r) && !skip_refs.contains(r) {
skip_refs.push(*r);
}
}
}
let mut trailer = pdf.trailer().clone();
strip_incremental_trailer_keys(&mut trailer);
remap_trailer_refs(&mut trailer, &renumber, &skip_refs)?;
let info_ref = match trailer.get("Info") {
Some(Object::Reference(r)) => Some(*r),
_ => None,
};
let xref_ref = ObjectRef::new(xref_object_number, 0);
if options.deterministic_id {
let dict = xref_stream::XrefStreamDict {
widths,
index: None,
info: info_ref,
root: Some(new_root),
size,
prev: None,
id: None,
};
let mut id_writer = |out: &mut Vec<u8>| {
write_deterministic_id_inline(out, &det_id_info_suffix, det_id_source_id0.as_deref())
};
xref_stream::write_object_with_id_writer(
&mut bytes,
xref_ref,
&dict,
&payload,
&mut id_writer,
);
} else {
let mut id_trailer = Dictionary::new();
if let Some(id) = pdf.trailer().get("ID") {
id_trailer.insert("ID", id.clone());
}
apply_encrypt_trailer_entries(&mut id_trailer, pdf, options, None, false);
let (id0, id1): (Vec<u8>, Vec<u8>) = match id_trailer.get("ID") {
Some(Object::Array(arr)) if arr.len() == 2 => {
let take = |o: &Object| match o {
Object::String(s) => s.clone(),
_ => QPDF_STATIC_ID.to_vec(), };
(take(&arr[0]), take(&arr[1]))
}
_ => (QPDF_STATIC_ID.to_vec(), QPDF_STATIC_ID.to_vec()), };
let dict = xref_stream::XrefStreamDict {
widths,
index: None,
info: info_ref,
root: Some(new_root),
size,
prev: None,
id: Some((&id0, &id1)),
};
xref_stream::write_object(&mut bytes, xref_ref, &dict, &payload);
}
bytes.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
out.write_all(&bytes)?;
Ok(())
}
pub fn apply_stream_compress_policy(stream: &crate::Stream, policy: CompressStreams) -> Object {
let decoded = match filters::decode_stream_data(&stream.dict, &stream.data) {
Ok(d) => d,
Err(_) => {
let mut dict = stream.dict.clone();
dict.insert(
"Length",
Object::Integer(i64::try_from(stream.data.len()).unwrap_or(i64::MAX)),
);
return Object::Stream(crate::Stream::new(dict, stream.data.clone()));
}
};
let mut new_dict = stream.dict.clone();
new_dict.remove("Filter");
new_dict.remove("DecodeParms");
new_dict.remove("F");
new_dict.remove("FFilter");
new_dict.remove("FDecodeParms");
match policy {
CompressStreams::Yes => {
let mut encode_dict = Dictionary::new();
encode_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
let encoded = match filters::encode_stream_data(&encode_dict, &decoded) {
Ok(e) => e,
Err(_) => return Object::Stream(stream.clone()),
};
new_dict.insert("Filter", Object::Name(b"FlateDecode".to_vec()));
new_dict.insert(
"Length",
Object::Integer(i64::try_from(encoded.len()).unwrap_or(i64::MAX)),
);
Object::Stream(crate::Stream::new(new_dict, encoded))
}
CompressStreams::No => {
new_dict.insert(
"Length",
Object::Integer(i64::try_from(decoded.len()).unwrap_or(i64::MAX)),
);
Object::Stream(crate::Stream::new(new_dict, decoded))
}
}
}
pub(crate) fn is_lone_flate(filter: Option<&Object>) -> bool {
match filter {
Some(Object::Name(name)) => name.as_slice() == b"FlateDecode",
Some(Object::Array(items)) => {
matches!(items.as_slice(), [Object::Name(name)] if name.as_slice() == b"FlateDecode")
}
_ => false,
}
}
pub fn write_stream_to_buf(
buf: &mut Vec<u8>,
stream: &crate::Stream,
policy: NewlineBeforeEndstream,
) {
stream.dict.write_pdf(buf);
write_stream_payload(buf, &stream.data, policy);
}
pub(crate) fn write_stream_to_buf_with_id_writer(
buf: &mut Vec<u8>,
stream: &crate::Stream,
policy: NewlineBeforeEndstream,
id_writer: Option<crate::object::TrailerIdWriter>,
) {
stream.dict.write_pdf_with_id_writer(buf, id_writer);
write_stream_payload(buf, &stream.data, policy);
}
pub(crate) fn write_stream_to_buf_qpdf_order(
buf: &mut Vec<u8>,
stream: &crate::Stream,
policy: NewlineBeforeEndstream,
refiltered: bool,
) {
stream.dict.write_pdf_stream(buf, refiltered);
write_stream_payload(buf, &stream.data, policy);
}
pub(crate) fn write_preserved_stream(buf: &mut Vec<u8>, dict: &Dictionary, data: &[u8]) {
dict.write_pdf_stream(buf, false);
write_stream_payload(buf, data, NewlineBeforeEndstream::Never);
}
fn write_stream_payload(buf: &mut Vec<u8>, data: &[u8], policy: NewlineBeforeEndstream) {
buf.extend_from_slice(b"\nstream\n");
buf.extend_from_slice(data);
match policy {
NewlineBeforeEndstream::Yes => {
buf.push(b'\n');
}
NewlineBeforeEndstream::No => {
let ends_with_eol = data
.last()
.map(|&b| b == b'\n' || b == b'\r')
.unwrap_or(false);
if !ends_with_eol {
buf.push(b'\n');
}
}
NewlineBeforeEndstream::Never => {
}
}
buf.extend_from_slice(b"endstream");
}
fn on_disk_stream_len(data: &[u8], policy: NewlineBeforeEndstream) -> usize {
let n = data.len();
match policy {
NewlineBeforeEndstream::Yes => n + 1,
NewlineBeforeEndstream::No => {
let ends_with_eol = data
.last()
.map(|&b| b == b'\n' || b == b'\r')
.unwrap_or(false);
if ends_with_eol {
n
} else {
n + 1
}
}
NewlineBeforeEndstream::Never => n,
}
}
fn write_stream_to_buf_qdf(
buf: &mut Vec<u8>,
stream: &crate::Stream,
policy: NewlineBeforeEndstream,
) {
stream.dict.write_pdf_qdf(buf, 0);
write_stream_payload(buf, &stream.data, policy);
}
fn write_qdf_trailer(
bytes: &mut Vec<u8>,
trailer: &Dictionary,
id_writer: Option<crate::object::TrailerIdWriter>,
) {
bytes.extend_from_slice(b"trailer <<\n");
let mut id_value: Option<&Object> = None;
for (key, value) in trailer.iter() {
if key == b"ID" {
id_value = Some(value);
continue;
}
bytes.extend_from_slice(b" /");
crate::object::write_name_escaped(bytes, key);
bytes.push(b' ');
value.write_pdf(bytes);
bytes.push(b'\n');
}
if let Some(value) = id_value {
bytes.extend_from_slice(b" /ID ");
match id_writer {
Some(write_id) => write_id(bytes),
None => value.write_pdf(bytes),
}
bytes.push(b'\n');
}
bytes.extend_from_slice(b">>\n");
}
#[cfg(test)]
mod tests {
use super::*;
use crate::rewrite_renumber::CatalogFirstRenumber;
#[test]
fn remap_trailer_refs_remaps_live_and_drops_deleted() {
let map = CatalogFirstRenumber::from_pairs_for_test(&[
(ObjectRef::new(1, 0), ObjectRef::new(1, 0)),
(ObjectRef::new(10, 0), ObjectRef::new(3, 0)),
]);
let mut trailer = Dictionary::new();
trailer.insert("Root", Object::Reference(ObjectRef::new(1, 0)));
trailer.insert("Info", Object::Reference(ObjectRef::new(10, 0)));
trailer.insert("Meta", Object::Reference(ObjectRef::new(20, 0)));
trailer.insert("Size", Object::Integer(4));
let deleted = [ObjectRef::new(20, 0)];
remap_trailer_refs(&mut trailer, &map, &deleted).expect("remap");
assert_eq!(
trailer.get("Info"),
Some(&Object::Reference(ObjectRef::new(3, 0))),
"live /Info must be remapped to its new number"
);
assert!(
trailer.get("Meta").is_none(),
"/Meta pointing at a deleted object must be dropped, not remapped"
);
assert_eq!(
trailer.get("Root"),
Some(&Object::Reference(ObjectRef::new(1, 0)))
);
}
#[test]
fn remap_trailer_refs_errors_on_unmapped_live_ref() {
let map = CatalogFirstRenumber::from_pairs_for_test(&[(
ObjectRef::new(1, 0),
ObjectRef::new(1, 0),
)]);
let mut trailer = Dictionary::new();
trailer.insert("Info", Object::Reference(ObjectRef::new(99, 0)));
let err = remap_trailer_refs(&mut trailer, &map, &[]).unwrap_err();
assert!(matches!(err, crate::Error::Unsupported(_)));
}
fn id_array(d: &Dictionary) -> Vec<Object> {
match d.get("ID") {
Some(Object::Array(v)) => v.clone(),
other => panic!("expected /ID array, got {other:?}"),
}
}
#[test]
fn apply_static_id_preserves_first_when_both_elements_are_strings() {
let mut t = Dictionary::new();
t.insert(
"ID",
Object::Array(vec![
Object::String(b"permanent".to_vec()),
Object::String(b"changing".to_vec()),
]),
);
apply_static_id(&mut t);
let v = id_array(&t);
assert_eq!(
v[0],
Object::String(b"permanent".to_vec()),
"element 1 must be preserved when /ID is a 2-string array"
);
assert_eq!(v[1], Object::String(QPDF_STATIC_ID.to_vec()));
}
#[test]
fn apply_static_id_falls_back_when_second_element_is_not_a_string() {
let mut t = Dictionary::new();
t.insert(
"ID",
Object::Array(vec![
Object::String(b"permanent".to_vec()),
Object::Integer(123),
]),
);
apply_static_id(&mut t);
let v = id_array(&t);
assert_eq!(
v[0],
Object::String(QPDF_STATIC_ID.to_vec()),
"malformed second element must force element 1 to the constant"
);
assert_eq!(v[1], Object::String(QPDF_STATIC_ID.to_vec()));
}
#[test]
fn apply_static_id_falls_back_when_id_is_missing() {
let mut t = Dictionary::new();
apply_static_id(&mut t);
let v = id_array(&t);
assert_eq!(v[0], Object::String(QPDF_STATIC_ID.to_vec()));
assert_eq!(v[1], Object::String(QPDF_STATIC_ID.to_vec()));
}
fn str_bytes(o: &Object) -> &[u8] {
match o {
Object::String(s) => s.as_slice(),
other => panic!("expected /ID element to be a string, got {other:?}"),
}
}
#[test]
fn apply_random_id_first_save_generates_both_elements_fresh() {
let mut t = Dictionary::new();
apply_random_id(&mut t);
let v = id_array(&t);
assert_eq!(v.len(), 2);
let (e0, e1) = (str_bytes(&v[0]), str_bytes(&v[1]));
assert_eq!(e0.len(), 16, "element 1 must be 16 bytes");
assert_eq!(e1.len(), 16, "element 2 must be 16 bytes");
assert_ne!(
e0,
&QPDF_STATIC_ID[..],
"element 1 must not be the π constant"
);
assert_ne!(
e1,
&QPDF_STATIC_ID[..],
"element 2 must not be the π constant"
);
assert!(e0.iter().any(|&b| b != 0), "element 1 must not be all-zero");
assert!(e1.iter().any(|&b| b != 0), "element 2 must not be all-zero");
assert_ne!(
e0, e1,
"first-save elements must be independently generated"
);
}
#[test]
fn apply_random_id_varies_per_save() {
let mut a = Dictionary::new();
let mut b = Dictionary::new();
apply_random_id(&mut a);
apply_random_id(&mut b);
assert_ne!(id_array(&a), id_array(&b), "/ID must change on every save");
}
#[test]
fn apply_random_id_re_save_preserves_element1_rotates_element2() {
let mut first = Dictionary::new();
apply_random_id(&mut first);
let v1 = id_array(&first);
let perm = v1[0].clone();
let mut second = Dictionary::new();
second.insert("ID", Object::Array(v1.clone()));
apply_random_id(&mut second);
let v2 = id_array(&second);
assert_eq!(
v2[0], perm,
"element 1 (permanent id) must be preserved on re-save"
);
assert_ne!(
v2[1], v1[1],
"element 2 (changing id) must rotate on re-save"
);
}
#[test]
fn apply_random_id_regenerates_element1_when_source_id_is_malformed() {
let mut t = Dictionary::new();
t.insert(
"ID",
Object::Array(vec![
Object::String(b"would-be-permanent".to_vec()),
Object::Integer(123),
]),
);
apply_random_id(&mut t);
let v = id_array(&t);
assert_ne!(
v[0],
Object::String(b"would-be-permanent".to_vec()),
"malformed source /ID must not be trusted as permanent id"
);
assert_eq!(str_bytes(&v[0]).len(), 16);
assert_eq!(str_bytes(&v[1]).len(), 16);
}
fn det_id_options() -> WriteOptions {
WriteOptions {
full_rewrite: true,
deterministic_id: true,
..WriteOptions::default()
}
}
fn write_det_id(fixture: &[u8]) -> Vec<u8> {
let mut pdf = crate::Pdf::open_mem(fixture).expect("fixture must open");
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, &det_id_options())
.expect("deterministic-id write must succeed");
out
}
fn trailer_id_pair(output: &[u8]) -> (Vec<u8>, Vec<u8>) {
let pdf = crate::Pdf::open_mem(output).expect("output must re-open");
let id = pdf
.trailer()
.get("ID")
.and_then(Object::as_array)
.expect("trailer /ID must be an array");
let extract = |o: &Object| {
o.as_string()
.expect("/ID element must be a string")
.to_vec()
};
(extract(&id[0]), extract(&id[1]))
}
fn id_array_bracket_offset(output: &[u8]) -> usize {
let id = b"/ID";
let id_pos = output
.windows(id.len())
.rposition(|w| w == id)
.expect("output must contain /ID");
id_pos
+ output[id_pos..]
.iter()
.position(|&b| b == b'[')
.expect("/ID must be followed by an array")
}
fn expected_changing_id(output: &[u8], info_suffix: &[u8]) -> [u8; 16] {
use md5::Digest as _;
let bracket = id_array_bracket_offset(output);
let det_data = md5::Md5::digest(&output[..=bracket]);
let mut seed = Vec::new();
for byte in det_data.iter() {
seed.extend_from_slice(format!("{byte:02x}").as_bytes());
}
seed.extend_from_slice(b" QPDF ");
seed.extend_from_slice(info_suffix);
let truncated = &seed[..seed.iter().position(|&b| b == 0).unwrap_or(seed.len())];
md5::Md5::digest(truncated).into()
}
#[test]
fn deterministic_id_is_stable_and_matches_two_level_md5() {
let fixture = build_string_and_stream_fixture();
let o1 = write_det_id(&fixture);
let o2 = write_det_id(&fixture);
assert_eq!(
o1, o2,
"same input + deterministic_id must produce byte-identical output"
);
let (id0, id1) = trailer_id_pair(&o1);
let expected = expected_changing_id(&o1, b" TopSecretTitle").to_vec();
assert_eq!(
id1, expected,
"/ID[1] must be md5(det_data + \" QPDF \" + \" TopSecretTitle\")"
);
assert_eq!(id0, id1, "absent source /ID makes /ID[0] equal /ID[1]");
assert_ne!(id0.as_slice(), &QPDF_STATIC_ID[..]);
}
#[test]
fn deterministic_id_depends_on_content() {
let a = write_det_id(&build_string_and_stream_fixture());
let b = write_det_id(&build_metadata_fixture());
assert_ne!(
trailer_id_pair(&a).0,
trailer_id_pair(&b).0,
"different input content must yield a different deterministic /ID"
);
}
fn build_det_id_source(trailer_extra: &str, extra_objects: &[&str]) -> Vec<u8> {
let mut src = b"%PDF-1.4\n".to_vec();
let mut offsets = Vec::new();
offsets.push(src.len());
src.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offsets.push(src.len());
src.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
for obj in extra_objects {
offsets.push(src.len());
src.extend_from_slice(obj.as_bytes());
}
let startxref = src.len();
let count = offsets.len() + 1;
src.extend_from_slice(format!("xref\n0 {count}\n0000000000 65535 f \n").as_bytes());
for off in &offsets {
src.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
src.extend_from_slice(
format!(
"trailer\n<< /Size {count} /Root 1 0 R {trailer_extra} >>\n\
startxref\n{startxref}\n%%EOF\n"
)
.as_bytes(),
);
src
}
#[test]
fn deterministic_id_preserves_source_permanent_id() {
let src = build_det_id_source(
&format!("/ID [<{}><{}>]", "aa".repeat(16), "bb".repeat(16)),
&[],
);
let out = write_det_id(&src);
let (id0, id1) = trailer_id_pair(&out);
assert_eq!(
id0,
vec![0xAAu8; 16],
"/ID[0] must be preserved from the source"
);
assert_eq!(
id1,
expected_changing_id(&out, b"").to_vec(),
"/ID[1] must be the two-level deterministic digest"
);
assert_ne!(id0, id1, "permanent and changing identifiers must differ");
}
#[test]
fn deterministic_id_preserves_non_16_byte_source_id() {
let src = build_det_id_source(
&format!("/ID [<{}><{}>]", "aa".repeat(20), "bb".repeat(16)),
&[],
);
let out = write_det_id(&src);
let (id0, id1) = trailer_id_pair(&out);
assert_eq!(
id0,
vec![0xAAu8; 20],
"/ID[0] must be preserved verbatim (20 bytes)"
);
assert_eq!(id1.len(), 16, "/ID[1] is always a 16-byte digest");
assert_eq!(id1, expected_changing_id(&out, b"").to_vec());
assert_ne!(id0, id1);
}
#[test]
fn deterministic_id_ignores_non_string_array_source_id() {
let src = build_det_id_source("/ID [1 2]", &[]);
let out = write_det_id(&src);
let (id0, id1) = trailer_id_pair(&out);
assert_eq!(id0, id1, "non-string source /ID must not be preserved");
assert_eq!(id1, expected_changing_id(&out, b"").to_vec());
}
#[test]
fn deterministic_id_treats_empty_source_id0_as_absent() {
let src = build_det_id_source(&format!("/ID [<><{}>]", "bb".repeat(16)), &[]);
let out = write_det_id(&src);
let (id0, id1) = trailer_id_pair(&out);
assert_eq!(id0, id1, "empty source /ID[0] must fall back to /ID[1]");
assert_eq!(id1, expected_changing_id(&out, b"").to_vec());
}
#[test]
fn deterministic_id_seed_reads_inline_info_dictionary() {
let src = build_det_id_source("/Info << /Title (Inline) >>", &[]);
let out = write_det_id(&src);
assert_eq!(
trailer_id_pair(&out).1,
expected_changing_id(&out, b" Inline").to_vec(),
"an inline /Info dictionary must contribute to the seed"
);
}
#[test]
fn deterministic_id_ignores_non_dictionary_info() {
let src = build_det_id_source("/Info (not a dict)", &[]);
let out = write_det_id(&src);
assert_eq!(
trailer_id_pair(&out).1,
expected_changing_id(&out, b"").to_vec(),
"a non-dictionary /Info contributes nothing to the seed"
);
}
#[test]
fn deterministic_id_info_seed_changes_id() {
let a = write_det_id(&build_det_id_source(
"/Info 3 0 R",
&["3 0 obj\n<< /Title (Alpha) >>\nendobj\n"],
));
let b = write_det_id(&build_det_id_source(
"/Info 3 0 R",
&["3 0 obj\n<< /Title (Bravo) >>\nendobj\n"],
));
assert_ne!(
trailer_id_pair(&a).1,
trailer_id_pair(&b).1,
"different /Info string values must change /ID[1]"
);
assert_eq!(
trailer_id_pair(&a).1,
expected_changing_id(&a, b" Alpha").to_vec(),
"/Info /Title (Alpha) contributes \" Alpha\" to the seed"
);
}
#[test]
fn deterministic_id_info_seed_sorts_keys_skips_non_strings_and_unescapes() {
let src = build_det_id_source(
"/Info 3 0 R",
&["3 0 obj\n<< /Title (Hello\\)World) /Author (Bob) /Count 7 >>\nendobj\n"],
);
let out = write_det_id(&src);
let suffix = b" Bob Hello)World";
assert_eq!(
trailer_id_pair(&out).1,
expected_changing_id(&out, suffix).to_vec(),
"seed must use sorted keys, skip non-strings, and unescape values"
);
}
#[test]
fn deterministic_id_resolves_indirect_info_and_values() {
let src = build_det_id_source(
"/Info 3 0 R",
&[
"3 0 obj\n<< /Title 4 0 R >>\nendobj\n",
"4 0 obj\n(Indirect)\nendobj\n",
],
);
let out = write_det_id(&src);
assert_eq!(
trailer_id_pair(&out).1,
expected_changing_id(&out, b" Indirect").to_vec(),
"indirect /Info and indirect string value must be resolved into the seed"
);
}
#[test]
fn deterministic_id_empty_info_has_no_seed_suffix() {
let with_empty_info = write_det_id(&build_det_id_source(
"/Info 3 0 R",
&["3 0 obj\n<< /Count 7 >>\nendobj\n"],
));
assert_eq!(
trailer_id_pair(&with_empty_info).1,
expected_changing_id(&with_empty_info, b"").to_vec(),
"an /Info with no string entries contributes nothing to the seed"
);
}
#[test]
fn deterministic_id_truncates_seed_at_first_nul() {
let out = write_det_id(&build_det_id_source(
"/Info 3 0 R",
&["3 0 obj\n<< /Title <feff0041> >>\nendobj\n"],
));
assert_eq!(
trailer_id_pair(&out).1,
expected_changing_id(&out, b" \xfe\xff\x00A").to_vec(),
"/ID[1] must be md5 of the seed truncated at the first NUL"
);
use md5::Digest as _;
let bracket = id_array_bracket_offset(&out);
let det_data = md5::Md5::digest(&out[..=bracket]);
let mut full_seed = Vec::new();
for byte in det_data.iter() {
full_seed.extend_from_slice(format!("{byte:02x}").as_bytes());
}
full_seed.extend_from_slice(b" QPDF ");
full_seed.extend_from_slice(b" \xfe\xff\x00A");
let untruncated: [u8; 16] = md5::Md5::digest(&full_seed).into();
assert_ne!(
trailer_id_pair(&out).1,
untruncated.to_vec(),
"hashing the full (untruncated) seed must NOT match — the NUL cut is load-bearing"
);
}
#[test]
fn compute_deterministic_id_ignores_seed_bytes_after_first_nul() {
let bytes = b"anything[";
let offset = bytes.len() - 1; let a = compute_deterministic_id(bytes, offset, b" \xfe\xff\x00AAA", None);
let b = compute_deterministic_id(bytes, offset, b" \xfe\xff\x00BBB", None);
assert_eq!(
a.1, b.1,
"info_suffix bytes after the first NUL must not affect /ID[1]"
);
let c = compute_deterministic_id(bytes, offset, b" \xfd\xff\x00AAA", None);
assert_ne!(
a.1, c.1,
"info_suffix bytes before the first NUL must affect /ID[1]"
);
let d = compute_deterministic_id(bytes, offset, b" \xfe\xff", None);
assert_eq!(
a.1, d.1,
"truncating at the NUL must equal hashing the pre-NUL bytes alone"
);
}
#[test]
fn write_deterministic_id_inline_matches_placeholder_then_patch() {
let prefix =
b"%PDF-1.7\n1 0 obj<</X 1>>endobj\ntrailer << /Size 4 /Root 1 0 R /ID ".to_vec();
let mut inline = prefix.clone();
write_deterministic_id_inline(&mut inline, b"", None);
let id_array_offset = prefix.len();
let mut legacy_buf = prefix.clone();
write_deterministic_id_array(&mut legacy_buf, &[0u8; 16], &[0u8; 16]);
let (id0, id1) = compute_deterministic_id(&legacy_buf, id_array_offset, b"", None);
let mut expect = prefix.clone();
write_deterministic_id_array(&mut expect, &id0, &id1);
assert_eq!(
inline, expect,
"inline direct-write must equal placeholder+patch output"
);
let mut placeholder = prefix.clone();
write_deterministic_id_array(&mut placeholder, &[0u8; 16], &[0u8; 16]);
assert_ne!(
inline, placeholder,
"inline must write the real id, not the placeholder"
);
}
#[test]
fn write_deterministic_id_inline_preserves_source_permanent_id() {
let prefix =
b"%PDF-1.7\n1 0 obj<</X 1>>endobj\ntrailer << /Size 4 /Root 1 0 R /ID ".to_vec();
let src0 = [0xAAu8; 16];
let id_array_offset = prefix.len();
let mut legacy_buf = prefix.clone();
write_deterministic_id_array(&mut legacy_buf, &[0u8; 16], &[0u8; 16]);
let (id0, id1) =
compute_deterministic_id(&legacy_buf, id_array_offset, b"", Some(src0.as_slice()));
let mut expect = prefix.clone();
write_deterministic_id_array(&mut expect, &src0, &id1);
let mut inline = prefix.clone();
write_deterministic_id_inline(&mut inline, b"", Some(src0.as_slice()));
assert_eq!(
inline, expect,
"inline write with a source id must equal placeholder+patch output"
);
assert_eq!(
id0,
src0.to_vec(),
"/ID[0] must be the supplied permanent identifier"
);
assert_ne!(
id0, id1,
"permanent and changing identifiers must differ in general"
);
}
#[test]
fn write_pdf_with_id_writer_none_matches_write_pdf() {
let mut dict = Dictionary::new();
dict.insert("Size", Object::Integer(4));
dict.insert("Root", Object::reference(ObjectRef::new(1, 0)));
dict.insert(
"ID",
Object::Array(vec![
Object::String(vec![0xAB; 16]),
Object::String(vec![0xCD; 16]),
]),
);
let mut plain = Vec::new();
dict.write_pdf(&mut plain);
let mut via_none = Vec::new();
dict.write_pdf_with_id_writer(&mut via_none, None);
assert_eq!(
via_none, plain,
"write_pdf_with_id_writer(None) must equal write_pdf byte-for-byte"
);
}
#[test]
fn write_stream_to_buf_with_id_writer_none_matches_write_stream_to_buf() {
let mut dict = Dictionary::new();
dict.insert("Length", Object::Integer(3));
dict.insert(
"ID",
Object::Array(vec![
Object::String(vec![0xAB; 16]),
Object::String(vec![0xCD; 16]),
]),
);
let stream = crate::Stream::new(dict, b"abc".to_vec());
let mut expected = Vec::new();
write_stream_to_buf(&mut expected, &stream, NewlineBeforeEndstream::Yes);
let mut actual = Vec::new();
write_stream_to_buf_with_id_writer(&mut actual, &stream, NewlineBeforeEndstream::Yes, None);
assert_eq!(
actual, expected,
"write_stream_to_buf_with_id_writer(None) must equal write_stream_to_buf"
);
}
#[test]
fn write_pdf_with_id_writer_keys_on_name_not_byte_pattern() {
let mut decoy_value = b"/ID ".to_vec();
write_deterministic_id_array(&mut decoy_value, &[0u8; 16], &[0u8; 16]);
let mut dict = Dictionary::new();
dict.insert("AA", Object::String(decoy_value.clone()));
dict.insert(
"ID",
Object::Array(vec![
Object::String(vec![0u8; 16]),
Object::String(vec![0u8; 16]),
]),
);
let sentinel: &[u8] = b"[<DIGEST-FROM-CLOSURE>]";
let mut id_writer = |out: &mut Vec<u8>| out.extend_from_slice(sentinel);
let mut out = Vec::new();
dict.write_pdf_with_id_writer(&mut out, Some(&mut id_writer));
let mut decoy_serialized = Vec::new();
Object::String(decoy_value).write_pdf(&mut decoy_serialized);
assert!(
out.windows(decoy_serialized.len())
.any(|w| w == decoy_serialized.as_slice()),
"preserved decoy entry embedding /ID + placeholder must survive verbatim"
);
let id_token_pos = out
.windows(5)
.position(|w| w == b" /ID ")
.expect("real /ID key token must be present");
assert_eq!(
&out[id_token_pos + 5..id_token_pos + 5 + sentinel.len()],
sentinel,
"the real /ID value must be the closure output, not the stored array"
);
let sentinel_count = out
.windows(sentinel.len())
.filter(|w| *w == sentinel)
.count();
assert_eq!(sentinel_count, 1, "id_writer must run exactly once");
}
#[test]
fn deterministic_id_preserves_decoy_trailer_key_through_full_rewrite() {
let zeros = "00000000000000000000000000000000"; let src = build_det_id_source(&format!("/Probe [<{zeros}><{zeros}>]"), &[]);
let out = write_det_id(&src);
let reopened = crate::Pdf::open_mem(&out).expect("output must re-open");
let probe = reopened
.trailer()
.get("Probe")
.and_then(Object::as_array)
.expect("/Probe must be preserved as an array");
assert_eq!(probe.len(), 2, "/Probe array arity must be preserved");
for element in probe {
assert_eq!(
element
.as_string()
.expect("/Probe element must be a string"),
&[0u8; 16],
"/Probe must NOT be mis-patched — it stays the all-zero placeholder"
);
}
assert_ne!(
trailer_id_pair(&out).1,
vec![0u8; 16],
"the real /ID must be direct-written, not left as the zero placeholder"
);
assert_eq!(
trailer_id_pair(&out).1,
expected_changing_id(&out, b"").to_vec(),
"/ID[1] must be the two-level deterministic digest"
);
}
#[test]
fn classic_trailer_deterministic_id_preserves_decoy_anchor_literal() {
let zeros = "00000000000000000000000000000000"; let decoy_literal = format!("/ID [<{zeros}><{zeros}>]");
let src = build_det_id_source(&format!("/Decoy ({decoy_literal})"), &[]);
let out = write_det_id(&src);
assert!(
out.windows(b"trailer ".len()).any(|w| w == b"trailer "),
"classic deterministic-id output must use a classic `trailer` (Table xref form)"
);
assert!(
out.windows(decoy_literal.len())
.any(|window| window == decoy_literal.as_bytes()),
"the crafted /Decoy bytes (`/ID `+placeholder) must appear verbatim"
);
let reopened = crate::Pdf::open_mem(&out).expect("output must re-open");
let decoy = reopened
.trailer()
.get("Decoy")
.and_then(Object::as_string)
.expect("/Decoy must be preserved as a string");
assert_eq!(
decoy,
decoy_literal.as_bytes(),
"/Decoy must NOT be mis-patched — its `/ID `+placeholder bytes stay verbatim"
);
assert_ne!(
trailer_id_pair(&out).1,
vec![0u8; 16],
"the real /ID must be direct-written, not left as the zero placeholder"
);
assert_eq!(
trailer_id_pair(&out).1,
expected_changing_id(&out, b"").to_vec(),
"classic /ID[1] must be the two-level deterministic digest"
);
}
#[test]
fn classic_trailer_deterministic_id_is_direct_written_no_placeholder() {
let src = build_det_id_source("/Info 3 0 R", &["3 0 obj\n<< /Title (Doc) >>\nendobj\n"]);
let out = write_det_id(&src);
let mut placeholder = Vec::new();
write_deterministic_id_array(&mut placeholder, &[0u8; 16], &[0u8; 16]);
assert_eq!(placeholder.len(), 70, "placeholder must be 70 bytes");
assert!(
out.windows(placeholder.len())
.all(|window| window != placeholder.as_slice()),
"the all-zero /ID placeholder must not appear — /ID is direct-written"
);
let out2 = write_det_id(&src);
assert_eq!(
out, out2,
"classic-trailer deterministic-id output must be byte-stable"
);
let (id0, id1) = trailer_id_pair(&out);
assert_eq!(
id1,
expected_changing_id(&out, b" Doc").to_vec(),
"/ID[1] must be the two-level deterministic digest, not a placeholder"
);
assert_eq!(id0, id1, "absent source /ID makes /ID[0] equal /ID[1]");
assert_ne!(
id1,
vec![0u8; 16],
"/ID[1] must not be the zero placeholder"
);
}
fn write_qdf_det_id(fixture: &[u8]) -> Vec<u8> {
let opts = WriteOptions {
full_rewrite: true,
deterministic_id: true,
qdf: true,
..WriteOptions::default()
};
let mut pdf = crate::Pdf::open_mem(fixture).expect("fixture must open");
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, &opts).expect("qdf deterministic write");
out
}
#[test]
fn qdf_trailer_deterministic_id_is_direct_written_no_placeholder() {
let src = build_det_id_source("/Info 3 0 R", &["3 0 obj\n<< /Title (Doc) >>\nendobj\n"]);
let out = write_qdf_det_id(&src);
assert!(
out.windows(b"trailer ".len()).any(|w| w == b"trailer "),
"qdf output must use a classic `trailer` (Table xref form)"
);
let mut placeholder = Vec::new();
write_deterministic_id_array(&mut placeholder, &[0u8; 16], &[0u8; 16]);
assert_eq!(placeholder.len(), 70, "placeholder must be 70 bytes");
assert!(
out.windows(placeholder.len())
.all(|window| window != placeholder.as_slice()),
"the all-zero /ID placeholder must not appear — /ID is direct-written"
);
let out2 = write_qdf_det_id(&src);
assert_eq!(
out, out2,
"qdf-trailer deterministic-id output must be byte-stable"
);
let (id0, id1) = trailer_id_pair(&out);
assert_eq!(
id1,
expected_changing_id(&out, b" Doc").to_vec(),
"qdf /ID[1] must be the two-level deterministic digest, not a placeholder"
);
assert_eq!(id0, id1, "absent source /ID makes /ID[0] equal /ID[1]");
assert_ne!(
id1,
vec![0u8; 16],
"/ID[1] must not be the zero placeholder"
);
}
#[test]
fn qdf_trailer_deterministic_id_preserves_decoy_anchor_literal() {
let zeros = "00000000000000000000000000000000"; let decoy_literal = format!("/ID [<{zeros}><{zeros}>]");
let src = build_det_id_source(&format!("/Decoy ({decoy_literal})"), &[]);
let out = write_qdf_det_id(&src);
let reopened = crate::Pdf::open_mem(&out).expect("output must re-open");
let decoy = reopened
.trailer()
.get("Decoy")
.and_then(Object::as_string)
.expect("/Decoy must be preserved as a string");
assert_eq!(
decoy,
decoy_literal.as_bytes(),
"/Decoy must NOT be mis-patched — its `/ID `+placeholder bytes stay verbatim"
);
assert_ne!(
trailer_id_pair(&out).1,
vec![0u8; 16],
"the real /ID must be direct-written, not left as the zero placeholder"
);
assert_eq!(
trailer_id_pair(&out).1,
expected_changing_id(&out, b"").to_vec(),
"qdf /ID[1] must be the two-level deterministic digest"
);
}
#[test]
fn qdf_trailer_without_deterministic_id_serializes_stored_id() {
let src = build_det_id_source(
"/ID [<0102030405060708090a0b0c0d0e0f10><1112131415161718191a1b1c1d1e1f20>]",
&[],
);
let opts = WriteOptions {
full_rewrite: true,
qdf: true,
static_id: true,
..WriteOptions::default()
};
let write = |f: &[u8]| {
let mut pdf = crate::Pdf::open_mem(f).expect("fixture must open");
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, &opts).expect("qdf write");
out
};
let out = write(&src);
assert_eq!(out, write(&src), "static-id qdf output must be byte-stable");
assert!(
out.windows(b"trailer <<".len()).any(|w| w == b"trailer <<"),
"qdf output must use the multi-line `trailer <<` layout"
);
let (id0, id1) = trailer_id_pair(&out);
assert_eq!(
id0,
(1u8..=16).collect::<Vec<u8>>(),
"stored /ID[0] (source permanent id) must be serialized verbatim"
);
assert_eq!(
id1.as_slice(),
&QPDF_STATIC_ID[..],
"stored /ID[1] (qpdf static constant) must be serialized verbatim"
);
}
#[test]
fn deterministic_id_xref_stream_is_self_stable() {
let fixture = build_partition_fixture();
let opts = WriteOptions {
full_rewrite: true,
deterministic_id: true,
object_streams: ObjectStreamMode::Generate,
..WriteOptions::default()
};
let write = |f: &[u8]| {
let mut pdf = crate::Pdf::open_mem(f).expect("fixture must open");
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, &opts).expect("write");
out
};
let o1 = write(&fixture);
let o2 = write(&fixture);
assert_eq!(o1, o2, "xref-stream deterministic-id output must be stable");
let (id0, id1) = trailer_id_pair(&o1);
assert_eq!(
id1,
expected_changing_id(&o1, b"").to_vec(),
"xref-stream /ID[1] must match the two-level reconstruction"
);
assert_eq!(id0, id1, "absent source /ID makes /ID[0] equal /ID[1]");
}
#[test]
fn deterministic_id_preserve_xref_stream_form_is_self_stable() {
let fixture = build_xref_stream_fixture();
let opts = WriteOptions {
full_rewrite: true,
deterministic_id: true,
object_streams: ObjectStreamMode::Preserve,
..WriteOptions::default()
};
let write = |f: &[u8]| {
let mut pdf = crate::Pdf::open_mem(f).expect("xref-stream fixture must open");
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, &opts).expect("write");
out
};
let o1 = write(&fixture);
let o2 = write(&fixture);
assert_eq!(o1, o2, "xref-stream deterministic-id output must be stable");
let (id0, id1) = trailer_id_pair(&o1);
assert_eq!(
id1,
expected_changing_id(&o1, b"").to_vec(),
"xref-stream /ID[1] must match the two-level reconstruction"
);
assert_eq!(id0, id1, "absent source /ID makes /ID[0] equal /ID[1]");
}
#[test]
fn deterministic_id_and_static_id_are_mutually_exclusive() {
let fixture = build_partition_fixture();
let mut pdf = crate::Pdf::open_mem(&fixture).expect("fixture must open");
let opts = WriteOptions {
full_rewrite: true,
deterministic_id: true,
static_id: true,
..WriteOptions::default()
};
let err = write_pdf_with_options(&mut pdf, &mut Vec::new(), &opts).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m) if m.contains("mutually exclusive")),
"got {err:?}"
);
}
#[test]
fn deterministic_id_rejected_with_encryption() {
let fixture = build_partition_fixture();
let mut pdf = crate::Pdf::open_mem(&fixture).expect("fixture must open");
let opts = WriteOptions {
full_rewrite: true,
deterministic_id: true,
encrypt: Some(crate::encrypt_setup::EncryptParams::v4_aes128(
b"user".to_vec(),
b"owner".to_vec(),
)),
..WriteOptions::default()
};
let err = write_pdf_with_options(&mut pdf, &mut Vec::new(), &opts).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m)
if m == "the deterministic-id option is incompatible with encrypted output files"),
"got {err:?}"
);
}
#[test]
fn deterministic_id_requires_full_rewrite() {
let fixture = build_partition_fixture();
let mut pdf = crate::Pdf::open_mem(&fixture).expect("fixture must open");
let opts = WriteOptions {
deterministic_id: true,
..WriteOptions::default()
};
let err = write_pdf_with_options(&mut pdf, &mut Vec::new(), &opts).unwrap_err();
assert!(
matches!(err, crate::Error::Unsupported(ref m) if m.contains("requires a full rewrite")),
"got {err:?}"
);
}
fn build_partition_fixture() -> Vec<u8> {
let mut bytes = b"%PDF-1.4\n".to_vec();
let mut entries: Vec<(u32, u16, usize)> = Vec::new();
entries.push((1, 0, bytes.len()));
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
entries.push((2, 0, bytes.len()));
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
entries.push((3, 0, bytes.len()));
bytes.extend_from_slice(b"3 0 obj\n<< /Subtype /Marker /Value 42 >>\nendobj\n");
entries.push((4, 0, bytes.len()));
let stream_data = b"hello";
bytes.extend_from_slice(
format!("4 0 obj\n<< /Length {} >>\nstream\n", stream_data.len()).as_bytes(),
);
bytes.extend_from_slice(stream_data);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
entries.push((5, 1, bytes.len()));
bytes.extend_from_slice(b"5 1 obj\n<< /Subtype /OldGen /Value 7 >>\nendobj\n");
let startxref = bytes.len();
bytes.extend_from_slice(format!("xref\n0 {}\n", entries.len() + 1).as_bytes());
bytes.extend_from_slice(b"0000000000 65535 f \n");
for (_num, generation, offset) in &entries {
bytes.extend_from_slice(format!("{offset:010} {generation:05} n \n").as_bytes());
}
bytes.extend_from_slice(
format!(
"trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{startxref}\n%%EOF\n",
entries.len() + 1
)
.as_bytes(),
);
bytes
}
#[test]
fn partition_objstm_eligible_splits_packable_and_plain_in_order() {
let bytes = build_partition_fixture();
let mut pdf = crate::Pdf::open_mem(&bytes).expect("fixture must open");
let plain_dict = ObjectRef::new(3, 0);
let stream_ref = ObjectRef::new(4, 0);
let gen1_ref = ObjectRef::new(5, 1);
assert!(
matches!(
pdf.resolve_borrowed(plain_dict).unwrap(),
Object::Dictionary(_)
),
"obj 3 must resolve as a plain dictionary"
);
assert!(
matches!(pdf.resolve_borrowed(stream_ref).unwrap(), Object::Stream(_)),
"obj 4 must resolve as a stream"
);
assert!(
matches!(
pdf.resolve_borrowed(gen1_ref).unwrap(),
Object::Dictionary(_)
),
"obj 5 (gen 1) must resolve as a plain dictionary"
);
let touched = [stream_ref, plain_dict, gen1_ref];
let (packable, plain) =
partition_objstm_eligible(&mut pdf, &touched).expect("partition must succeed");
assert_eq!(
packable,
vec![plain_dict],
"only the generation-0 non-stream dict is ObjStm-packable"
);
assert_eq!(
plain,
vec![stream_ref, gen1_ref],
"stream and gen!=0 objects stay plain, in original order"
);
}
#[test]
fn allocate_incremental_objstm_container_clears_all_input_space() {
let source_offsets: BTreeMap<u32, (u16, XrefOffset)> = BTreeMap::from([
(4, (0, XrefOffset::Offset(100))),
(11, (0, XrefOffset::Offset(200))),
]);
let touched = vec![ObjectRef::new(7, 0), ObjectRef::new(9, 0)];
let deleted = vec![ObjectRef::new(15, 0), ObjectRef::new(3, 0)];
let container =
allocate_incremental_objstm_container(&source_offsets, &touched, &deleted, 0)
.expect("allocation must succeed");
assert_eq!(
container,
ObjectRef::new(16, 0),
"container number must be max(source,touched,deleted) + 1"
);
assert_eq!(container.generation, 0, "container generation must be 0");
}
#[test]
fn allocate_incremental_objstm_container_respects_declared_size() {
let source_offsets: BTreeMap<u32, (u16, XrefOffset)> =
BTreeMap::from([(2, (0, XrefOffset::Offset(50)))]);
let touched = vec![ObjectRef::new(1, 0)];
let deleted = vec![ObjectRef::new(3, 0)];
let container =
allocate_incremental_objstm_container(&source_offsets, &touched, &deleted, 30)
.expect("allocation must succeed");
assert_eq!(
container,
ObjectRef::new(30, 0),
"declared_size must dominate when it exceeds all input numbers"
);
}
#[test]
fn allocate_incremental_objstm_container_zero_inputs() {
let source_offsets: BTreeMap<u32, (u16, XrefOffset)> = BTreeMap::new();
let touched: Vec<ObjectRef> = Vec::new();
let deleted: Vec<ObjectRef> = Vec::new();
let container =
allocate_incremental_objstm_container(&source_offsets, &touched, &deleted, 0)
.expect("allocation must succeed");
assert_eq!(
container,
ObjectRef::new(1, 0),
"zero/empty inputs must yield the minimal container number 1"
);
}
#[test]
fn merge_source_and_touched_offsets_for_xref_stream_handles_compressed() {
let mut source_offsets: BTreeMap<u32, (u16, XrefOffset)> = BTreeMap::new();
source_offsets.insert(5, (0, XrefOffset::Offset(42)));
let mut touched: BTreeMap<u32, (u16, usize)> = BTreeMap::new();
touched.insert(7, (0, 100));
let deleted = vec![ObjectRef::new(5, 0)];
let mut compressed: BTreeMap<u32, (u32, u32)> = BTreeMap::new();
compressed.insert(9, (20, 3));
let merged = merge_source_and_touched_offsets_for_xref_stream(
&source_offsets,
&touched,
&deleted,
&compressed,
);
assert_eq!(
merged.get(&9),
Some(&(
0,
XrefOffset::Compressed {
stream: 20,
index: 3
}
)),
"compressed member must become a type-2 Compressed entry with generation 0"
);
assert_eq!(
merged.get(&7),
Some(&(0, XrefOffset::Offset(100))),
"plain touched entry must still become an Offset entry"
);
match merged.get(&5) {
Some((_, XrefOffset::Free { .. })) => {}
other => panic!("deleted ref must become a Free entry, got {other:?}"),
}
let mut source_only: BTreeMap<u32, (u16, XrefOffset)> = BTreeMap::new();
source_only.insert(11, (2, XrefOffset::Offset(999)));
let passthrough = merge_source_and_touched_offsets_for_xref_stream(
&source_only,
&BTreeMap::new(),
&[],
&BTreeMap::new(),
);
assert_eq!(
passthrough.get(&11),
Some(&(2, XrefOffset::Offset(999))),
"untouched source-only entry must pass through unchanged"
);
}
#[test]
fn merge_source_and_touched_offsets_for_xref_stream_overlap_precedence() {
let source_offsets: BTreeMap<u32, (u16, XrefOffset)> = BTreeMap::new();
let mut touched: BTreeMap<u32, (u16, usize)> = BTreeMap::new();
touched.insert(8, (0, 100));
let mut compressed_members: BTreeMap<u32, (u32, u32)> = BTreeMap::new();
compressed_members.insert(8, (20, 3));
compressed_members.insert(9, (21, 4));
let deleted = vec![ObjectRef::new(9, 0)];
let merged = merge_source_and_touched_offsets_for_xref_stream(
&source_offsets,
&touched,
&deleted,
&compressed_members,
);
assert_eq!(
merged.get(&8),
Some(&(
0,
XrefOffset::Compressed {
stream: 20,
index: 3
}
)),
"object in both touched and compressed must resolve to Compressed (compressed loop runs after touched)"
);
match merged.get(&9) {
Some((_, XrefOffset::Free { .. })) => {}
other => panic!(
"object in both compressed and deleted must resolve to Free (deleted loop runs last), got {other:?}"
),
}
}
fn append_xref_stream_entry(entries: &mut Vec<u8>, entry_type: u8, f1: u32, f2: u8) {
entries.push(entry_type);
entries.push((f1 >> 16) as u8);
entries.push((f1 >> 8) as u8);
entries.push(f1 as u8);
entries.push(f2);
}
fn build_xref_stream_fixture() -> Vec<u8> {
let mut bytes = b"%PDF-1.5\n".to_vec();
let mut offsets: Vec<(u32, usize)> = Vec::new();
offsets.push((1, bytes.len()));
bytes.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offsets.push((2, bytes.len()));
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
offsets.push((3, bytes.len()));
bytes.extend_from_slice(b"3 0 obj\n<< /Subtype /Marker /Value 42 >>\nendobj\n");
let xref_num: u32 = 4;
let total_size = xref_num + 1; let xref_offset = bytes.len();
let mut entries: Vec<u8> = Vec::new();
append_xref_stream_entry(&mut entries, 0, 0, 0); for (_num, off) in &offsets {
append_xref_stream_entry(&mut entries, 1, *off as u32, 0);
}
append_xref_stream_entry(&mut entries, 1, xref_offset as u32, 0);
bytes.extend_from_slice(
format!(
"{xref_num} 0 obj\n<< /Type /XRef /Size {total_size} /Root 1 0 R /W [1 3 1] /Index [0 {total_size}] /Length {} >>\nstream\n",
entries.len()
)
.as_bytes(),
);
bytes.extend_from_slice(&entries);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
bytes.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
bytes
}
#[test]
fn write_incremental_objstm_emits_container_and_member_index_map() {
let fixture = build_xref_stream_fixture();
let mut pdf = crate::Pdf::open_mem(&fixture).expect("xref-stream fixture must open");
let m0 = ObjectRef::new(2, 0); let m1 = ObjectRef::new(3, 0); assert!(
matches!(pdf.resolve_borrowed(m0).unwrap(), Object::Dictionary(_)),
"obj 2 must resolve from the xref stream as a plain dictionary"
);
assert!(
matches!(pdf.resolve_borrowed(m1).unwrap(), Object::Dictionary(_)),
"obj 3 must resolve from the xref stream as a plain dictionary"
);
let packable = [m0, m1];
let container_ref = ObjectRef::new(5, 0);
let options = WriteOptions::default();
let mut bytes: Vec<u8> = Vec::new();
bytes.extend_from_slice(b"%incremental-tail-marker\n");
let prefix_len = bytes.len();
let (container_offset, members) =
write_incremental_objstm(&mut bytes, &mut pdf, container_ref, &packable, &options)
.expect("write_incremental_objstm must succeed");
assert_eq!(
container_offset, prefix_len,
"container_offset must mark where the container object begins"
);
assert_eq!(
members,
vec![(m0, 0u32), (m1, 1u32)],
"members must be [(packable[0],0),(packable[1],1)] in packable order"
);
let container_bytes = &bytes[container_offset..];
let container_str = String::from_utf8_lossy(container_bytes);
assert!(
container_str.starts_with(&format!("{} 0 obj", container_ref.number)),
"container must open with `{} 0 obj`, got: {:?}",
container_ref.number,
&container_str[..container_str.len().min(32)]
);
assert!(
container_str.contains("/Type /ObjStm"),
"container dict must declare /Type /ObjStm"
);
assert!(
container_str.contains("/N 2"),
"container dict must declare /N 2 for the two packed members"
);
assert!(
container_str.contains("endobj"),
"container object must be terminated with endobj"
);
}
#[test]
fn static_aes_iv_forces_all_zero_ivs_for_streams_and_strings() {
use std::io::Cursor;
let fixture = build_string_and_stream_fixture();
let mut pdf = Pdf::open(Cursor::new(fixture.clone())).expect("open fixture");
let mut out = Vec::new();
let options = WriteOptions {
full_rewrite: true,
static_id: true,
static_aes_iv: true,
encrypt: Some(crate::encrypt_setup::EncryptParams::v4_aes128(
b"user".to_vec(),
b"owner".to_vec(),
)),
..WriteOptions::default()
};
write_pdf_with_options(&mut pdf, &mut out, &options).expect("encrypted write");
let mut pdf2 = Pdf::open(Cursor::new(fixture.clone())).unwrap();
let mut out2 = Vec::new();
write_pdf_with_options(&mut pdf2, &mut out2, &options).expect("encrypted write 2");
assert_eq!(
out, out2,
"static_id + static_aes_iv must produce byte-identical output on two runs"
);
const NEEDLE: &[u8] = b"\nstream\n";
let mut checked = 0usize;
let mut pos = 0usize;
while let Some(rel) = out[pos..].windows(NEEDLE.len()).position(|w| w == NEEDLE) {
let payload = pos + rel + NEEDLE.len();
let iv = &out[payload..payload + 16];
assert_eq!(
iv,
&[0u8; 16],
"static_aes_iv: stream payload at byte {payload} must begin with a zero AES IV, got {iv:02x?}"
);
checked += 1;
pos = payload;
}
assert!(
checked > 0,
"expected at least one encrypted stream to verify the static IV against"
);
}
#[test]
fn without_static_aes_iv_two_runs_differ() {
use std::io::Cursor;
let input = include_bytes!("../../../tests/fixtures/minimal.pdf").to_vec();
let encrypt_once = || {
let mut pdf = Pdf::open(Cursor::new(input.clone())).unwrap();
let mut out = Vec::new();
let options = WriteOptions {
full_rewrite: true,
encrypt: Some(crate::encrypt_setup::EncryptParams::v4_aes128(
b"user".to_vec(),
b"owner".to_vec(),
)),
..WriteOptions::default()
};
write_pdf_with_options(&mut pdf, &mut out, &options).unwrap();
out
};
let out1 = encrypt_once();
let out2 = encrypt_once();
assert_ne!(
out1, out2,
"without static_aes_iv + static_id the two encrypted outputs must differ (random /ID[1])"
);
}
fn build_string_and_stream_fixture() -> Vec<u8> {
let mut bytes = b"%PDF-1.7\n".to_vec();
let mut entries: Vec<(u32, u16, usize)> = Vec::new();
entries.push((1, 0, bytes.len()));
bytes.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Metadata 4 0 R >>\nendobj\n",
);
entries.push((2, 0, bytes.len()));
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
entries.push((3, 0, bytes.len()));
bytes.extend_from_slice(b"3 0 obj\n<< /Title (TopSecretTitle) >>\nendobj\n");
entries.push((4, 0, bytes.len()));
let stream_data = b"hello";
bytes.extend_from_slice(
format!("4 0 obj\n<< /Length {} >>\nstream\n", stream_data.len()).as_bytes(),
);
bytes.extend_from_slice(stream_data);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
let startxref = bytes.len();
bytes.extend_from_slice(format!("xref\n0 {}\n", entries.len() + 1).as_bytes());
bytes.extend_from_slice(b"0000000000 65535 f \n");
for (_num, generation, offset) in &entries {
bytes.extend_from_slice(format!("{offset:010} {generation:05} n \n").as_bytes());
}
bytes.extend_from_slice(
format!(
"trailer\n<< /Size {} /Root 1 0 R /Info 3 0 R >>\nstartxref\n{startxref}\n%%EOF\n",
entries.len() + 1
)
.as_bytes(),
);
bytes
}
fn resolve_title_and_stream<R: Read + Seek>(rt: &mut Pdf<R>) -> (Vec<u8>, Vec<u8>) {
let info_ref = match rt.trailer().get("Info") {
Some(Object::Reference(r)) => *r,
other => panic!("trailer /Info must be a reference, got {other:?}"),
};
let title = match rt.resolve(info_ref).expect("resolve /Info") {
Object::Dictionary(d) => match d.get("Title") {
Some(Object::String(s)) => s.clone(),
other => panic!("/Title must be a string, got {other:?}"),
},
other => panic!("/Info must be a dictionary, got {other:?}"),
};
let root_ref = rt.root_ref().expect("root_ref");
let metadata_ref = match rt.resolve(root_ref).expect("resolve /Root") {
Object::Dictionary(d) => match d.get("Metadata") {
Some(Object::Reference(r)) => *r,
other => panic!("Catalog /Metadata must be a reference, got {other:?}"),
},
other => panic!("/Root must be a dictionary, got {other:?}"),
};
let stream = match rt.resolve(metadata_ref).expect("resolve /Metadata") {
Object::Stream(s) => s.data,
other => panic!("/Metadata must be a stream, got {other:?}"),
};
(title, stream)
}
#[test]
fn v5_r6_encrypt_round_trips_string_and_stream_via_reader() {
use crate::PdfOpenOptions;
use std::io::Cursor;
let fixture = build_string_and_stream_fixture();
let mut pdf = Pdf::open(Cursor::new(fixture.clone())).expect("open fixture");
let mut out = Vec::new();
let options = WriteOptions {
full_rewrite: true,
compress_streams: CompressStreams::No,
encrypt: Some(crate::encrypt_setup::EncryptParams::v5_r6(
b"user-pw".to_vec(),
b"owner-pw".to_vec(),
)),
..WriteOptions::default()
};
write_pdf_with_options(&mut pdf, &mut out, &options).expect("V=5 R=6 encrypted write");
for pw in [b"user-pw".as_slice(), b"owner-pw".as_slice()] {
let label = String::from_utf8_lossy(pw).into_owned();
let mut rt = Pdf::open_with_options(
Cursor::new(out.clone()),
PdfOpenOptions {
password: pw.to_vec(),
..PdfOpenOptions::default()
},
)
.unwrap_or_else(|e| panic!("re-open of V=5 output with {label:?} failed: {e}"));
let (title, stream) = resolve_title_and_stream(&mut rt);
assert_eq!(
title.as_slice(),
b"TopSecretTitle",
"V=5 R=6 string must round-trip via reader for {label:?}"
);
assert_eq!(
stream.as_slice(),
b"hello",
"V=5 R=6 stream must round-trip via reader for {label:?}"
);
}
}
#[test]
fn v5_r5_encrypt_round_trips_string_and_stream_via_reader() {
use crate::PdfOpenOptions;
use std::io::Cursor;
let fixture = build_string_and_stream_fixture();
let mut pdf = Pdf::open(Cursor::new(fixture.clone())).expect("open fixture");
let mut out = Vec::new();
let options = WriteOptions {
full_rewrite: true,
compress_streams: CompressStreams::No,
encrypt: Some(crate::encrypt_setup::EncryptParams::v5_r5(
b"user-pw".to_vec(),
b"owner-pw".to_vec(),
)),
..WriteOptions::default()
};
write_pdf_with_options(&mut pdf, &mut out, &options).expect("V=5 R=5 encrypted write");
for pw in [b"user-pw".as_slice(), b"owner-pw".as_slice()] {
let label = String::from_utf8_lossy(pw).into_owned();
let mut rt = Pdf::open_with_options(
Cursor::new(out.clone()),
PdfOpenOptions {
password: pw.to_vec(),
allow_weak_crypto: true,
..PdfOpenOptions::default()
},
)
.unwrap_or_else(|e| panic!("re-open of V=5 R=5 output with {label:?} failed: {e}"));
let (title, stream) = resolve_title_and_stream(&mut rt);
assert_eq!(
title.as_slice(),
b"TopSecretTitle",
"V=5 R=5 string must round-trip via reader for {label:?}"
);
assert_eq!(
stream.as_slice(),
b"hello",
"V=5 R=5 stream must round-trip via reader for {label:?}"
);
}
}
#[test]
fn rc4_methods_round_trip_string_and_stream_via_reader() {
use crate::encrypt_setup::{EncryptMethod, EncryptParams};
use crate::PdfOpenOptions;
use std::io::Cursor;
let fixture = build_string_and_stream_fixture();
for method in [
EncryptMethod::V1Rc440,
EncryptMethod::V2Rc4128,
EncryptMethod::V4Rc4128,
] {
let mut pdf = Pdf::open(Cursor::new(fixture.clone())).expect("open fixture");
let mut out = Vec::new();
let options = WriteOptions {
full_rewrite: true,
compress_streams: CompressStreams::No,
encrypt: Some(EncryptParams::rc4(
method,
b"user-pw".to_vec(),
b"owner-pw".to_vec(),
)),
..WriteOptions::default()
};
write_pdf_with_options(&mut pdf, &mut out, &options)
.unwrap_or_else(|e| panic!("{method:?} encrypted write failed: {e}"));
for pw in [b"user-pw".as_slice(), b"owner-pw".as_slice()] {
let label = format!("{method:?}/{}", String::from_utf8_lossy(pw));
let mut rt = Pdf::open_with_options(
Cursor::new(out.clone()),
PdfOpenOptions {
password: pw.to_vec(),
allow_weak_crypto: true,
..PdfOpenOptions::default()
},
)
.unwrap_or_else(|e| panic!("re-open {label} failed: {e}"));
let (title, stream) = resolve_title_and_stream(&mut rt);
assert_eq!(
title.as_slice(),
b"TopSecretTitle",
"{label} string round-trip"
);
assert_eq!(stream.as_slice(), b"hello", "{label} stream round-trip");
}
}
}
#[test]
fn v4_encryption_floors_pdf_header_per_qpdf_table() {
use crate::encrypt_setup::{EncryptMethod, EncryptParams};
use std::io::Cursor;
let fixture = build_partition_fixture();
assert!(
fixture.starts_with(b"%PDF-1.4"),
"fixture must start at %PDF-1.4 for this test to be meaningful"
);
for (params, expected_prefix) in [
(
EncryptParams::v4_aes128(b"u".to_vec(), b"o".to_vec()),
b"%PDF-1.6".as_slice(),
),
(
EncryptParams::rc4(EncryptMethod::V4Rc4128, b"u".to_vec(), b"o".to_vec()),
b"%PDF-1.5".as_slice(),
),
] {
let method = params.method;
let mut pdf = Pdf::open(Cursor::new(fixture.clone())).unwrap();
let mut out = Vec::new();
let options = WriteOptions {
full_rewrite: true,
encrypt: Some(params),
..WriteOptions::default()
};
write_pdf_with_options(&mut pdf, &mut out, &options).expect("V=4 encrypted write");
assert!(
out.starts_with(expected_prefix),
"{method:?} must floor the header to {}, got {:?}",
String::from_utf8_lossy(expected_prefix),
String::from_utf8_lossy(&out[..out.len().min(12)])
);
}
}
fn build_metadata_fixture() -> Vec<u8> {
let mut bytes = b"%PDF-1.7\n".to_vec();
let mut entries: Vec<(u32, u16, usize)> = Vec::new();
entries.push((1, 0, bytes.len()));
bytes.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Metadata 4 0 R >>\nendobj\n",
);
entries.push((2, 0, bytes.len()));
bytes.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
entries.push((3, 0, bytes.len()));
bytes.extend_from_slice(b"3 0 obj\n<< /Subtype /Marker /Value 1 >>\nendobj\n");
entries.push((4, 0, bytes.len()));
let xmp: &[u8] =
b"<?xpacket?><x:xmpmeta>SECRET-XMP-MARKER</x:xmpmeta><?xpacket end=\"w\"?>";
bytes.extend_from_slice(
format!(
"4 0 obj\n<< /Type /Metadata /Subtype /XML /Length {} >>\nstream\n",
xmp.len()
)
.as_bytes(),
);
bytes.extend_from_slice(xmp);
bytes.extend_from_slice(b"\nendstream\nendobj\n");
let startxref = bytes.len();
bytes.extend_from_slice(format!("xref\n0 {}\n", entries.len() + 1).as_bytes());
bytes.extend_from_slice(b"0000000000 65535 f \n");
for (_num, generation, offset) in &entries {
bytes.extend_from_slice(format!("{offset:010} {generation:05} n \n").as_bytes());
}
bytes.extend_from_slice(
format!(
"trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{startxref}\n%%EOF\n",
entries.len() + 1
)
.as_bytes(),
);
bytes
}
#[test]
fn cleartext_metadata_exempts_metadata_stream_from_encryption() {
use std::io::Cursor;
const MARKER: &[u8] = b"SECRET-XMP-MARKER";
let fixture = build_metadata_fixture();
let contains = |hay: &[u8], needle: &[u8]| hay.windows(needle.len()).any(|w| w == needle);
let encrypt = |encrypt_metadata: bool| -> Vec<u8> {
let mut pdf = Pdf::open(Cursor::new(fixture.clone())).unwrap();
let mut out = Vec::new();
let mut params =
crate::encrypt_setup::EncryptParams::v4_aes128(b"u".to_vec(), b"o".to_vec());
params.encrypt_metadata = encrypt_metadata;
let options = WriteOptions {
full_rewrite: true,
compress_streams: CompressStreams::No,
encrypt: Some(params),
..WriteOptions::default()
};
write_pdf_with_options(&mut pdf, &mut out, &options).expect("encrypted write");
out
};
let enc = encrypt(true);
assert!(
!contains(&enc, MARKER),
"default encrypt must cipher the /Metadata stream"
);
let ct = encrypt(false);
assert!(
contains(&ct, MARKER),
"cleartext metadata must leave the XMP stream unencrypted"
);
assert!(
contains(&ct, b"/EncryptMetadata false"),
"the /Encrypt dict must carry /EncryptMetadata false"
);
assert!(
contains(&ct, b"/Crypt"),
"the exempt /Metadata stream must be tagged with a /Crypt filter"
);
}
#[test]
fn write_options_default_min_extension_level_is_none() {
let options = WriteOptions::default();
assert!(options.min_extension_level.is_none());
}
#[test]
fn write_options_min_extension_level_stores_and_returns_value() {
let options = WriteOptions {
min_extension_level: Some(8),
..Default::default()
};
assert_eq!(options.min_extension_level, Some(8));
}
#[test]
fn effective_pdf_version_and_ext_no_bump_when_min_unset() {
let options = WriteOptions::default();
let (v, e) = effective_pdf_version_and_ext("1.7", 0, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 0);
}
#[test]
fn effective_pdf_version_and_ext_pairwise_min_version_bump_resets_ext_to_source() {
let options = WriteOptions {
min_version: Some("1.7".into()),
min_extension_level: None,
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("1.3", 0, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 0);
}
#[test]
fn effective_pdf_version_and_ext_min_ext_wins_when_versions_equal() {
let options = WriteOptions {
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 0, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 8);
}
#[test]
fn effective_pdf_version_and_ext_source_ver_higher_resets_min_ext() {
let options = WriteOptions {
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("2.0", 0, &options, false, false);
assert_eq!(v, "2.0");
assert_eq!(e, 0);
}
#[test]
fn effective_pdf_version_and_ext_min_ver_bump_drops_source_ext() {
let options = WriteOptions {
min_version: Some("2.0".into()),
min_extension_level: None,
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 8, &options, false, false);
assert_eq!(v, "2.0");
assert_eq!(e, 0);
}
#[test]
fn effective_pdf_version_and_ext_min_ver_bump_replaces_source_ext_with_min_ext() {
let options = WriteOptions {
min_version: Some("2.0".into()),
min_extension_level: Some(3),
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 8, &options, false, false);
assert_eq!(v, "2.0");
assert_eq!(e, 3);
}
#[test]
fn effective_pdf_version_and_ext_floor_bump_drops_both_ext() {
let options = WriteOptions::default();
let (v, e) = effective_pdf_version_and_ext("1.3", 8, &options, false, true);
assert_eq!(v, "1.5");
assert_eq!(e, 0);
}
#[test]
fn encryption_version_floor_matches_qpdf_table() {
use crate::encrypt_setup::{EncryptMethod, EncryptParams};
for (method, expected) in [
(EncryptMethod::V5R6Aes256, ((1, 7), 8)),
(EncryptMethod::V5R5Aes256, ((1, 7), 3)),
(EncryptMethod::V4Aes128, ((1, 6), 0)),
(EncryptMethod::V4Rc4128, ((1, 5), 0)),
(EncryptMethod::V2Rc4128, ((1, 4), 0)),
(EncryptMethod::V1Rc440, ((1, 3), 0)),
] {
let mut params = EncryptParams::v4_aes128(vec![], vec![]);
params.method = method;
let options = WriteOptions {
encrypt: Some(params),
..WriteOptions::default()
};
assert_eq!(
encryption_version_floor(&options),
Some(expected),
"encryption floor for {method:?}"
);
}
}
#[test]
fn effective_pdf_version_folds_each_encryption_floor_arm() {
use crate::encrypt_setup::{EncryptMethod, EncryptParams};
for (method, expected) in [
(EncryptMethod::V1Rc440, "1.3"),
(EncryptMethod::V2Rc4128, "1.4"),
(EncryptMethod::V4Rc4128, "1.5"),
(EncryptMethod::V4Aes128, "1.6"),
(EncryptMethod::V5R5Aes256, "1.7"),
(EncryptMethod::V5R6Aes256, "1.7"),
] {
let mut params = EncryptParams::v4_aes128(vec![], vec![]);
params.method = method;
let options = WriteOptions {
encrypt: Some(params),
..WriteOptions::default()
};
assert_eq!(
effective_pdf_version("1.0", &options, false, false),
expected,
"effective_pdf_version for {method:?}"
);
}
}
#[test]
fn encryption_version_floor_none_when_no_encryption() {
let options = WriteOptions::default();
assert_eq!(encryption_version_floor(&options), None);
}
#[test]
fn effective_pdf_version_folds_encryption_floor_into_header() {
let options = WriteOptions {
encrypt: Some(crate::encrypt_setup::EncryptParams::v4_aes128(
vec![],
vec![],
)),
..WriteOptions::default()
};
assert_eq!(effective_pdf_version("1.3", &options, false, false), "1.6");
}
#[test]
fn effective_pdf_version_and_ext_v5_r6_encryption_contributes_ext() {
let options = WriteOptions {
encrypt: Some(crate::encrypt_setup::EncryptParams::v5_r6(vec![], vec![])),
..WriteOptions::default()
};
let (v, e) = effective_pdf_version_and_ext("1.3", 0, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 8);
}
#[test]
fn effective_pdf_version_and_ext_aes128_encryption_drops_stale_source_ext() {
let options = WriteOptions {
encrypt: Some(crate::encrypt_setup::EncryptParams::v4_aes128(
vec![],
vec![],
)),
..WriteOptions::default()
};
let (v, e) = effective_pdf_version_and_ext("1.3", 8, &options, false, false);
assert_eq!(v, "1.6");
assert_eq!(e, 0);
}
#[test]
fn effective_pdf_version_and_ext_encryption_and_source_tie_take_max_ext() {
let options = WriteOptions {
encrypt: Some(crate::encrypt_setup::EncryptParams::v5_r6(vec![], vec![])),
..WriteOptions::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 3, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 8);
}
#[test]
fn effective_pdf_version_and_ext_source_ext_wins_when_source_beats_encryption() {
let options = WriteOptions {
encrypt: Some(crate::encrypt_setup::EncryptParams::v4_aes128(
vec![],
vec![],
)),
..WriteOptions::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 8, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 8);
}
#[test]
fn effective_pdf_version_and_ext_force_version_drops_source_ext() {
let options = WriteOptions {
force_version: Some("1.7".into()),
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 8, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 0);
}
#[test]
fn effective_pdf_version_and_ext_force_version_drops_min_ext() {
let options = WriteOptions {
force_version: Some("1.7".into()),
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 0, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 0);
}
#[test]
fn effective_pdf_version_and_ext_invalid_force_version_is_ignored() {
let options = WriteOptions {
force_version: Some("not-a-version".into()),
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 8, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 8);
}
#[test]
fn effective_pdf_version_and_ext_source_ext_wins_when_versions_tie() {
let options = WriteOptions {
min_version: Some("1.7".into()),
min_extension_level: Some(0),
..Default::default()
};
let (v, e) = effective_pdf_version_and_ext("1.7", 8, &options, false, false);
assert_eq!(v, "1.7");
assert_eq!(e, 8);
}
fn build_ext_injection_source() -> Vec<u8> {
let mut src = b"%PDF-1.3\n".to_vec();
let mut offsets = Vec::new();
offsets.push(src.len());
src.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
offsets.push(src.len());
src.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
let startxref = src.len();
let count = offsets.len() + 1;
src.extend_from_slice(format!("xref\n0 {count}\n0000000000 65535 f \n").as_bytes());
for off in &offsets {
src.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
src.extend_from_slice(
format!(
"trailer\n<< /Size {count} /Root 1 0 R >>\n\
startxref\n{startxref}\n%%EOF\n"
)
.as_bytes(),
);
src
}
fn write_full_rewrite_with(source: &[u8], options: &WriteOptions) -> Vec<u8> {
let mut pdf = crate::Pdf::open_mem(source).expect("fixture must open");
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, options)
.expect("full-rewrite write must succeed");
out
}
#[test]
fn write_pdf_full_rewrite_injects_extensions_adbe_when_min_ext_gt_zero() {
let src = build_ext_injection_source();
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..WriteOptions::default()
};
let out = write_full_rewrite_with(&src, &options);
assert!(
out.starts_with(b"%PDF-1.7\n"),
"min_version=1.7 must raise the header; first 12 bytes: {:?}",
&out[..out.len().min(12)] );
let s = String::from_utf8_lossy(&out);
assert!(s.contains("/Extensions"), "Catalog must carry /Extensions");
assert!(s.contains("/ADBE"), "Extensions must carry /ADBE");
assert!(
s.contains("/BaseVersion /1.7"),
"ADBE must carry /BaseVersion /1.7"
);
assert!(
s.contains("/ExtensionLevel 8"),
"ADBE must carry /ExtensionLevel 8"
);
}
#[test]
fn write_pdf_full_rewrite_no_injection_when_min_ext_is_none() {
let src = build_ext_injection_source();
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: None,
..WriteOptions::default()
};
let out = write_full_rewrite_with(&src, &options);
assert!(out.starts_with(b"%PDF-1.7\n"));
let s = String::from_utf8_lossy(&out);
assert!(
!s.contains("/Extensions"),
"no min_extension_level → no /Extensions injection"
);
}
#[test]
fn write_pdf_full_rewrite_no_injection_when_min_ext_is_zero() {
let src = build_ext_injection_source();
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: Some(0),
..WriteOptions::default()
};
let out = write_full_rewrite_with(&src, &options);
assert!(out.starts_with(b"%PDF-1.7\n"));
let s = String::from_utf8_lossy(&out);
assert!(
!s.contains("/Extensions"),
"eff_ext == 0 → no /Extensions injection"
);
}
#[test]
fn write_pdf_full_rewrite_ext_injection_preserves_non_adbe_developer_prefix() {
let mut src = b"%PDF-1.3\n".to_vec();
let mut offsets = Vec::new();
offsets.push(src.len());
src.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R \
/Extensions << /XYZW << /BaseVersion /1.3 /ExtensionLevel 1 >> >> \
>>\nendobj\n",
);
offsets.push(src.len());
src.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
let startxref = src.len();
let count = offsets.len() + 1;
src.extend_from_slice(format!("xref\n0 {count}\n0000000000 65535 f \n").as_bytes());
for off in &offsets {
src.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
src.extend_from_slice(
format!(
"trailer\n<< /Size {count} /Root 1 0 R >>\n\
startxref\n{startxref}\n%%EOF\n"
)
.as_bytes(),
);
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..WriteOptions::default()
};
let out = write_full_rewrite_with(&src, &options);
let s = String::from_utf8_lossy(&out);
assert!(s.contains("/ADBE"), "injected /ADBE must appear");
assert!(
s.contains("/BaseVersion /1.7"),
"new /ADBE must carry the effective /BaseVersion"
);
assert!(
s.contains("/ExtensionLevel 8"),
"new /ADBE must carry the effective /ExtensionLevel"
);
assert!(
s.contains("/XYZW"),
"non-ADBE developer prefix must survive: {s}"
);
}
#[test]
fn write_pdf_full_rewrite_ext_injection_follows_indirect_extensions_ref() {
let mut src = b"%PDF-1.3\n".to_vec();
let mut offsets = Vec::new();
offsets.push(src.len());
src.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Extensions 3 0 R >>\nendobj\n",
);
offsets.push(src.len());
src.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
offsets.push(src.len());
src.extend_from_slice(
b"3 0 obj\n<< /ADBE << /BaseVersion /1.7 /ExtensionLevel 3 >> \
/ACRO << /BaseVersion /1.7 /ExtensionLevel 1 >> >>\nendobj\n",
);
let startxref = src.len();
let count = offsets.len() + 1;
src.extend_from_slice(format!("xref\n0 {count}\n0000000000 65535 f \n").as_bytes());
for off in &offsets {
src.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
src.extend_from_slice(
format!(
"trailer\n<< /Size {count} /Root 1 0 R >>\n\
startxref\n{startxref}\n%%EOF\n"
)
.as_bytes(),
);
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..WriteOptions::default()
};
let out = write_full_rewrite_with(&src, &options);
let s = String::from_utf8_lossy(&out);
assert!(
s.contains("/ExtensionLevel 8"),
"/ADBE must have been overwritten with the new level: {s}"
);
assert!(
!s.contains("/ExtensionLevel 3"),
"old /ADBE /ExtensionLevel 3 must not survive: {s}"
);
assert!(
s.contains("/ACRO"),
"non-ADBE developer prefix must survive: {s}"
);
}
fn build_ext_injection_source_with_adbe_1_3() -> Vec<u8> {
let mut src = b"%PDF-1.3\n".to_vec();
let mut offsets = Vec::new();
offsets.push(src.len());
src.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R \
/Extensions << /ADBE << /BaseVersion /1.3 /ExtensionLevel 8 >> >> \
>>\nendobj\n",
);
offsets.push(src.len());
src.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
let startxref = src.len();
let count = offsets.len() + 1;
src.extend_from_slice(format!("xref\n0 {count}\n0000000000 65535 f \n").as_bytes());
for off in &offsets {
src.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
src.extend_from_slice(
format!(
"trailer\n<< /Size {count} /Root 1 0 R >>\n\
startxref\n{startxref}\n%%EOF\n"
)
.as_bytes(),
);
src
}
#[test]
fn write_pdf_full_rewrite_generate_mode_strips_stale_adbe_on_floor_bump() {
let src = build_ext_injection_source_with_adbe_1_3();
{
let mut src_pdf = crate::Pdf::open_mem(&src).expect("source must open");
assert_eq!(
src_pdf.adobe_extension_level(),
Some(8),
"fixture must carry source ADBE ExtensionLevel 8"
);
}
let options = WriteOptions {
full_rewrite: true,
static_id: true,
object_streams: ObjectStreamMode::Generate,
..WriteOptions::default()
};
let out = write_full_rewrite_with(&src, &options);
assert!(
out.starts_with(b"%PDF-1.5\n"),
"ObjStm floor must bump the header to 1.5"
);
let mut reopened = crate::Pdf::open_mem_owned(out).expect("output must open");
assert_eq!(
reopened.adobe_extension_level(),
None,
"stale ADBE from source (BaseVersion 1.3) must not survive when the \
ObjStm floor drops the effective ext to 0"
);
}
#[test]
fn write_pdf_full_rewrite_generate_mode_strips_stale_adbe_via_indirect_ref_preserving_other_prefix(
) {
let mut src = b"%PDF-1.3\n".to_vec();
let mut offsets = Vec::new();
offsets.push(src.len());
src.extend_from_slice(
b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R /Extensions 3 0 R >>\nendobj\n",
);
offsets.push(src.len());
src.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Count 0 /Kids [] >>\nendobj\n");
offsets.push(src.len());
src.extend_from_slice(
b"3 0 obj\n<< /ADBE << /BaseVersion /1.3 /ExtensionLevel 8 >> \
/XYZW << /BaseVersion /1.3 /ExtensionLevel 1 >> >>\nendobj\n",
);
let startxref = src.len();
let count = offsets.len() + 1;
src.extend_from_slice(format!("xref\n0 {count}\n0000000000 65535 f \n").as_bytes());
for off in &offsets {
src.extend_from_slice(format!("{off:010} 00000 n \n").as_bytes());
}
src.extend_from_slice(
format!(
"trailer\n<< /Size {count} /Root 1 0 R >>\n\
startxref\n{startxref}\n%%EOF\n"
)
.as_bytes(),
);
{
let mut src_pdf = crate::Pdf::open_mem(&src).expect("source must open");
assert_eq!(
src_pdf.adobe_extension_level(),
Some(8),
"fixture must carry source ADBE ExtensionLevel 8 through an indirect ref"
);
}
let options = WriteOptions {
full_rewrite: true,
static_id: true,
object_streams: ObjectStreamMode::Generate,
..WriteOptions::default()
};
let out = write_full_rewrite_with(&src, &options);
assert!(
out.starts_with(b"%PDF-1.5\n"),
"ObjStm floor must bump the header to 1.5"
);
let mut reopened = crate::Pdf::open_mem_owned(out).expect("output must open");
assert_eq!(
reopened.adobe_extension_level(),
None,
"stale ADBE from source must be stripped when the ObjStm floor \
drops the effective ext to 0"
);
let root_ref = reopened.trailer().get_ref("Root").expect("Root ref");
let catalog_dict = reopened
.resolve(root_ref)
.expect("resolve root")
.into_dict()
.expect("root is dict");
let ext_dict = catalog_dict
.get("Extensions")
.expect("Extensions key survives strip")
.as_dict()
.expect("Extensions must be present as a direct dict after strip");
assert!(
ext_dict.get("ADBE").is_none(),
"ADBE must be gone: {ext_dict:?}"
);
assert!(
ext_dict.get("XYZW").is_some(),
"non-ADBE developer prefix must survive: {ext_dict:?}"
);
}
#[test]
fn write_pdf_full_rewrite_generate_mode_still_injects_extensions_adbe() {
let src = build_ext_injection_source();
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: Some(8),
object_streams: ObjectStreamMode::Generate,
..WriteOptions::default()
};
let out = write_full_rewrite_with(&src, &options);
assert!(out.starts_with(b"%PDF-1.7\n"), "header must raise to 1.7");
let mut reopened = crate::Pdf::open_mem_owned(out).expect("output must open");
assert_eq!(
reopened.adobe_extension_level(),
Some(8),
"generate-mode output must carry /Extensions /ADBE /ExtensionLevel 8"
);
}
#[test]
fn write_pdf_full_rewrite_does_not_dirty_caller_pdf_across_writes() {
let src = build_ext_injection_source();
let mut pdf = crate::Pdf::open_mem_owned(src).expect("open");
assert_eq!(pdf.adobe_extension_level(), None);
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..WriteOptions::default()
};
let mut out1 = Vec::new();
write_pdf_with_options(&mut pdf, &mut out1, &options).expect("first write");
assert_eq!(
pdf.adobe_extension_level(),
None,
"first write must not leak /Extensions into the caller's Pdf"
);
let mut out2 = Vec::new();
write_pdf_with_options(&mut pdf, &mut out2, &options).expect("second write");
assert_eq!(
out1, out2,
"back-to-back writes on the same Pdf must be byte-identical"
);
let mut reopened = crate::Pdf::open_mem_owned(out1).expect("reopen");
assert_eq!(
reopened.adobe_extension_level(),
Some(8),
"output must carry the requested ADBE"
);
}
#[test]
fn write_pdf_full_rewrite_does_not_leave_root_dirty_flag_set() {
let src = build_ext_injection_source();
let mut pdf = crate::Pdf::open_mem_owned(src).expect("open");
let root_ref = pdf.root_ref().expect("Root");
assert!(!pdf.is_dirty(root_ref), "Root must be clean pre-write");
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..WriteOptions::default()
};
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, &options).expect("write");
assert!(
!pdf.is_dirty(root_ref),
"Root dirty flag must be cleared after the full-rewrite restore"
);
}
#[test]
fn write_pdf_full_rewrite_preserves_pre_existing_root_dirty_flag() {
let src = build_ext_injection_source();
let mut pdf = crate::Pdf::open_mem_owned(src).expect("open");
let root_ref = pdf.root_ref().expect("Root");
let catalog = pdf.resolve(root_ref).expect("resolve root");
pdf.set_object(root_ref, catalog);
assert!(pdf.is_dirty(root_ref), "sanity: caller marked Root dirty");
let options = WriteOptions {
full_rewrite: true,
static_id: true,
min_version: Some("1.7".into()),
min_extension_level: Some(8),
..WriteOptions::default()
};
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, &options).expect("write");
assert!(
pdf.is_dirty(root_ref),
"pre-existing Root dirty flag must survive the full-rewrite restore"
);
}
#[test]
fn write_pdf_full_rewrite_v4_aes128_source_1_3_with_adbe_strips_stale_ext() {
let src = build_ext_injection_source_with_adbe_1_3();
let mut pdf = crate::Pdf::open_mem_owned(src).expect("open");
assert_eq!(pdf.adobe_extension_level(), Some(8));
let options = WriteOptions {
full_rewrite: true,
static_id: true,
static_aes_iv: true,
encrypt: Some(crate::encrypt_setup::EncryptParams::v4_aes128(
b"u".to_vec(),
b"o".to_vec(),
)),
..WriteOptions::default()
};
let mut out = Vec::new();
write_pdf_with_options(&mut pdf, &mut out, &options).expect("aes-128 encrypted write");
assert!(
out.starts_with(b"%PDF-1.6\n"),
"AES-128 must floor the header to 1.6, got {:?}",
String::from_utf8_lossy(&out[..out.len().min(12)])
);
let reopen_opts = crate::PdfOpenOptions {
password: b"u".to_vec(),
..Default::default()
};
let mut reopened =
crate::Pdf::open_mem_owned_with_options(out, reopen_opts).expect("reopen encrypted");
assert_eq!(
reopened.adobe_extension_level(),
None,
"stale /ADBE (BaseVersion 1.3) must be stripped by the encryption floor"
);
}
}