#[path = "writer/object_streams.rs"]
pub(crate) mod object_streams;
pub use object_streams::ObjectStreamMode;
use crate::parser::Parser;
use crate::signatures::{signature_rewrite_impact, SignatureWriteMode};
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)]
pub enum NewlineBeforeEndstream {
#[default]
Yes,
No,
}
#[non_exhaustive]
#[derive(Debug, Default, Clone)]
pub struct WriteOptions {
pub static_id: bool,
pub static_aes_iv: bool,
pub min_version: Option<String>,
pub force_version: Option<String>,
pub no_original_object_ids: bool,
pub full_rewrite: bool,
pub allow_signed_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 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 fn effective_pdf_version<'a>(
source: &'a str,
options: &'a WriteOptions,
linearize: 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;
}
}
}
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();
}
}
"1.2"
}
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);
}
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)
}
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 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 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 {}
fn refuse_signed_full_rewrite<R: Read + Seek>(
pdf: &mut Pdf<R>,
options: &WriteOptions,
) -> Result<()> {
if options.allow_signed_full_rewrite {
return Ok(());
}
let impact = signature_rewrite_impact(pdf, SignatureWriteMode::FullRewrite)?;
if !impact.invalidates_signatures {
return Ok(());
}
let mut fields: Vec<String> = match pdf.signatures() {
Ok(signatures) => signatures
.into_iter()
.map(|signature| {
if signature.field_name.is_empty() {
format!("{}", signature.field_ref)
} else {
signature.field_name
}
})
.collect(),
Err(_) => Vec::new(),
};
fields.sort();
fields.dedup();
if fields.is_empty() {
fields = impact
.signed_object_refs
.into_iter()
.map(|object_ref| format!("{object_ref}"))
.collect();
}
let field_list = fields.join(", ");
let message = format!(
"refusing full rewrite of signed PDF because it would invalidate signature field(s): \
{field_list}. Use --remove-restrictions to explicitly allow invalidating signatures, \
or use an incremental rewrite that preserves signed byte ranges."
);
Err(crate::Error::Signed { fields, message })
}
#[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 apply_encrypt_trailer_entries<R: Read + Seek>(
trailer: &mut Dictionary,
pdf: &Pdf<R>,
options: &WriteOptions,
encrypt_ctx: Option<&EncryptionContext>,
) {
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 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 write_pdf_full_rewrite<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"));
};
refuse_signed_full_rewrite(pdf, options)?;
let mut version = effective_pdf_version(pdf.version(), options, 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(),
));
}
let encrypting = options.encrypt.is_some() || options.copy_encryption.is_some();
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 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 plan = object_streams::plan_object_streams(pdf, &planner_config)?;
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 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 mut object_refs = pdf.object_refs();
object_refs.sort_by_key(|r| (r.number, r.generation));
let existing_max: u32 = object_refs.iter().map(|r| r.number).max().unwrap_or(0);
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();
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 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
};
use std::collections::HashSet;
let mut existing_holders: HashSet<u32> = HashSet::new();
if options.qdf {
for object_ref in &object_refs {
if Some(*object_ref) == pdf.encryption_ref() || member_to_batch.contains_key(object_ref)
{
continue;
}
if let Ok(Object::Stream(s)) = pdf.resolve_borrowed(*object_ref) {
if let Some(Object::Reference(r)) = s.dict.get("Length") {
existing_holders.insert(r.number);
}
}
}
}
let mut length_holders: BTreeMap<u32, i64> = BTreeMap::new();
let mut next_holder_offset: u32 = plan.batches.len() as u32;
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();
let qdf_skip_refs: std::collections::HashSet<ObjectRef> = if options.qdf {
pdf.deleted_object_refs().into_iter().collect()
} else {
std::collections::HashSet::new()
};
for object_ref in &object_refs {
if Some(*object_ref) == pdf.encryption_ref() {
continue;
}
if options.qdf && (object_ref.number == 0 || qdf_skip_refs.contains(object_ref)) {
continue;
}
if member_to_batch.contains_key(object_ref) {
continue;
}
if options.qdf && existing_holders.contains(&object_ref.number) {
continue;
}
let mut object = pdf.resolve(*object_ref)?;
if let Some(ctx) = &encrypt_ctx {
if *object_ref != ctx.encrypt_ref {
encrypt_strings_in_object_for_writer(*object_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(&object_ref.number) {
return Err(crate::Error::Unsupported(format!(
"duplicate object number {} in xref table",
object_ref.number
)));
}
if options.qdf && !options.no_original_object_ids {
bytes.extend_from_slice(
format!(
"%% Original object ID: {} {}\n",
object_ref.number, object_ref.generation
)
.as_bytes(),
);
}
let emit_offset = bytes.len();
bytes.extend_from_slice(
format!("{} {} obj\n", object_ref.number, object_ref.generation).as_bytes(),
);
if let Object::Stream(stream) = object {
let prior_holder = match stream.dict.get("Length") {
Some(Object::Reference(r)) if existing_holders.contains(&r.number) => {
Some(r.number)
}
_ => None,
};
let mut reencoded = match effective_stream_policy(options) {
Some(compress_policy) => apply_stream_compress_policy(&stream, compress_policy),
None => Object::Stream(stream),
};
if let Some(ctx) = &encrypt_ctx {
if *object_ref != ctx.encrypt_ref {
if let Object::Stream(ref mut s) = reencoded {
if !ctx.encrypt_metadata && ctx.metadata_ref == Some(*object_ref) {
crate::security::standard::prepend_crypt_filter_to_stream_dict(
&mut s.dict,
b"Identity",
);
} else {
encrypt_stream_payload_for_writer(*object_ref, s, ctx)?;
}
}
}
}
if let Object::Stream(ref s) = reencoded {
if options.qdf {
let len_value = i64::try_from(on_disk_stream_len(
&s.data,
options.newline_before_endstream,
))
.unwrap_or(i64::MAX);
let holder = match prior_holder {
Some(h) => h,
None => {
next_holder_offset =
next_holder_offset.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: QDF length-holder number overflows u32"
.to_string(),
)
})?;
existing_max
.checked_add(next_holder_offset)
.ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: QDF length-holder number overflows u32"
.to_string(),
)
})?
}
};
if let Some(prev) = length_holders.insert(holder, len_value) {
if prev != len_value {
return Err(crate::Error::Unsupported(format!(
"full-rewrite: QDF length-holder {holder} reused with conflicting lengths ({prev} vs {len_value})"
)));
}
}
let mut holder_stream = s.clone();
holder_stream
.dict
.insert("Length", Object::Reference(ObjectRef::new(holder, 0)));
write_stream_to_buf_qdf(
&mut bytes,
&holder_stream,
options.newline_before_endstream,
);
} else {
write_stream_to_buf(&mut bytes, s, options.newline_before_endstream);
}
} else if options.qdf {
reencoded.write_pdf_qdf(&mut bytes, 0);
} else {
reencoded.write_pdf(&mut bytes);
}
} 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(object_ref.number, (object_ref.generation, emit_offset));
}
for (batch_idx, batch) in plan.batches.iter().enumerate() {
let container_ref = container_refs[batch_idx];
let body = object_streams::emit_objstm_body(pdf, batch)?;
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));
}
for (holder, len_value) in &length_holders {
if offsets.contains_key(holder) {
return Err(crate::Error::Unsupported(format!(
"full-rewrite: QDF length-holder number {holder} collides with an existing object"
)));
}
let emit_offset = bytes.len();
bytes.extend_from_slice(format!("{holder} 0 obj\n{len_value}\nendobj\n").as_bytes());
if options.qdf {
bytes.push(b'\n');
}
offsets.insert(*holder, (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);
trailer.insert("Size", Object::Integer(object_count as i64));
trailer.insert("Root", Object::Reference(root_ref));
apply_encrypt_trailer_entries(&mut trailer, pdf, options, encrypt_ctx.as_ref());
if options.qdf {
write_qdf_trailer(&mut bytes, &trailer);
bytes.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
} else {
bytes.extend_from_slice(b"trailer\n");
trailer.write_pdf(&mut bytes);
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_to_batch.get(&ObjectRef::new(number, 0))
{
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);
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(root_ref));
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());
let xref_stream = crate::Stream::new(xref_dict, stream_data);
bytes.extend_from_slice(format!("{xref_object_number} 0 obj\n").as_bytes());
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(())
}
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(_) => {
return Object::Stream(stream.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 fn write_stream_to_buf(
buf: &mut Vec<u8>,
stream: &crate::Stream,
policy: NewlineBeforeEndstream,
) {
stream.dict.write_pdf(buf);
buf.extend_from_slice(b"\nstream\n");
buf.extend_from_slice(&stream.data);
match policy {
NewlineBeforeEndstream::Yes => {
buf.push(b'\n');
}
NewlineBeforeEndstream::No => {
let ends_with_eol = stream
.data
.last()
.map(|&b| b == b'\n' || b == b'\r')
.unwrap_or(false);
if !ends_with_eol {
buf.push(b'\n');
}
}
}
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
}
}
}
}
fn write_stream_to_buf_qdf(
buf: &mut Vec<u8>,
stream: &crate::Stream,
policy: NewlineBeforeEndstream,
) {
stream.dict.write_pdf_qdf(buf, 0);
buf.extend_from_slice(b"\nstream\n");
buf.extend_from_slice(&stream.data);
match policy {
NewlineBeforeEndstream::Yes => {
buf.push(b'\n');
}
NewlineBeforeEndstream::No => {
let ends_with_eol = stream
.data
.last()
.map(|&b| b == b'\n' || b == b'\r')
.unwrap_or(false);
if !ends_with_eol {
buf.push(b'\n');
}
}
}
buf.extend_from_slice(b"endstream");
}
fn write_qdf_trailer(bytes: &mut Vec<u8>, trailer: &Dictionary) {
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 ");
value.write_pdf(bytes);
bytes.push(b'\n');
}
bytes.extend_from_slice(b">>\n");
}
#[cfg(test)]
mod tests {
use super::*;
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 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_partition_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 >>\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
}
#[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 obj3 = rt.resolve(ObjectRef::new(3, 0)).expect("resolve obj 3");
let dict = match obj3 {
Object::Dictionary(d) => d,
other => panic!("obj 3 must be a dictionary, got {other:?}"),
};
match dict.get("Title") {
Some(Object::String(s)) => assert_eq!(
s.as_slice(),
b"TopSecretTitle",
"V=5 R=6 string must round-trip via reader for {label:?}"
),
other => panic!("/Title must be a string, got {other:?}"),
}
let obj4 = rt.resolve(ObjectRef::new(4, 0)).expect("resolve obj 4");
match obj4 {
Object::Stream(s) => assert_eq!(
s.data.as_slice(),
b"hello",
"V=5 R=6 stream must round-trip via reader for {label:?}"
),
other => panic!("obj 4 must be a stream, got {other:?}"),
}
}
}
#[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 obj3 = rt.resolve(ObjectRef::new(3, 0)).expect("resolve obj 3");
let dict = match obj3 {
Object::Dictionary(d) => d,
other => panic!("obj 3 must be a dictionary, got {other:?}"),
};
match dict.get("Title") {
Some(Object::String(s)) => assert_eq!(
s.as_slice(),
b"TopSecretTitle",
"V=5 R=5 string must round-trip via reader for {label:?}"
),
other => panic!("/Title must be a string, got {other:?}"),
}
let obj4 = rt.resolve(ObjectRef::new(4, 0)).expect("resolve obj 4");
match obj4 {
Object::Stream(s) => assert_eq!(
s.data.as_slice(),
b"hello",
"V=5 R=5 stream must round-trip via reader for {label:?}"
),
other => panic!("obj 4 must be a stream, got {other:?}"),
}
}
}
#[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 obj3 = rt.resolve(ObjectRef::new(3, 0)).expect("resolve obj 3");
let dict = match obj3 {
Object::Dictionary(d) => d,
other => panic!("obj 3 must be a dict, got {other:?}"),
};
match dict.get("Title") {
Some(Object::String(s)) => {
assert_eq!(s.as_slice(), b"TopSecretTitle", "{label} string round-trip")
}
other => panic!("/Title must be a string, got {other:?}"),
}
let obj4 = rt.resolve(ObjectRef::new(4, 0)).expect("resolve obj 4");
match obj4 {
Object::Stream(s) => {
assert_eq!(s.data.as_slice(), b"hello", "{label} stream round-trip")
}
other => panic!("obj 4 must be a stream, got {other:?}"),
}
}
}
}
#[test]
fn v4_encryption_floors_pdf_header_to_1_5() {
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 in [
EncryptParams::v4_aes128(b"u".to_vec(), b"o".to_vec()),
EncryptParams::rc4(EncryptMethod::V4Rc4128, b"u".to_vec(), b"o".to_vec()),
] {
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(b"%PDF-1.5"),
"V=4 encryption must floor the header to 1.5, got {:?}",
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"
);
}
}