#[path = "writer/encrypted_strings.rs"]
pub(crate) mod encrypted_strings;
#[path = "writer/encryption_state.rs"]
pub(crate) mod encryption_state;
#[path = "writer/object.rs"]
pub(crate) mod object;
#[path = "writer/object_streams/mod.rs"]
pub(crate) mod object_streams;
#[path = "writer/pclm.rs"]
pub(crate) mod pclm;
#[path = "writer/plain/mod.rs"]
pub(crate) mod plain;
#[path = "writer/rewrite_renumber.rs"]
pub(crate) mod rewrite_renumber;
#[path = "writer/serialize.rs"]
pub(crate) mod serialize;
mod settings;
pub(crate) use object::ObjectWriterEmission;
pub use object_streams::ObjectStreamMode;
pub use serialize::write_stream_to_buf;
pub use settings::DecodeLevel;
use settings::WriterSettings;
#[cfg(test)]
pub(crate) fn write_qpdf_to_memory<R, F>(pdf: &mut Pdf<R>, configure: F) -> Result<Vec<u8>>
where
R: Read + Seek + 'static,
F: FnOnce(&mut PdfWriter<'_, R>),
{
let mut writer = PdfWriter::new(pdf);
configure(&mut writer);
writer.set_output_memory()?;
writer.write()?;
writer.get_buffer()
}
use crate::encryption::{CopyEncryptionSource, EncryptMethod, EncryptParams, PasswordMode};
use crate::linearization::writer::write_linearized_for_pdf_writer;
use crate::pdf_version::{parse_qpdf_writer_version, PdfVersion, QpdfVersionParts, PDF_1_5};
use crate::pipeline::{flate::Flate, Pipeline, PlString};
use crate::{Error, ObjectHandle, ObjectRef, Pdf, Result, XrefEntry, XrefForm};
use std::cell::{Cell, RefCell};
use std::collections::{BTreeMap, BTreeSet, HashMap};
use std::fmt;
use std::fs::File;
use std::io::{self, BufWriter, Read, Seek, Write};
use std::path::{Path, PathBuf};
use std::rc::Rc;
struct QpdfFileWriter {
output: BufWriter<File>,
}
impl QpdfFileWriter {
const BUFFER_SIZE: usize = 4096;
fn new(file: File) -> Self {
Self {
output: BufWriter::with_capacity(Self::BUFFER_SIZE, file),
}
}
}
impl Write for QpdfFileWriter {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
self.output.write(bytes)
}
fn flush(&mut self) -> io::Result<()> {
match self.output.flush() {
Err(error) if error.raw_os_error() == Some(9) => {
Err(error)
}
Ok(()) | Err(_) => Ok(()),
}
}
}
enum WriterOutput {
Memory(Option<Vec<u8>>),
Writer(Box<dyn Write>),
Pipeline(Box<dyn Pipeline>),
}
struct WriterOutputSink<'a> {
output: &'a mut WriterOutput,
failure: Option<Error>,
}
impl<'a> WriterOutputSink<'a> {
fn new(output: &'a mut WriterOutput) -> Self {
Self {
output,
failure: None,
}
}
fn finish_output(&mut self) -> Result<()> {
self.flush()?;
match self.output {
WriterOutput::Memory(_) | WriterOutput::Writer(_) => Ok(()),
WriterOutput::Pipeline(pipeline) => {
pipeline.finish()?;
Ok(())
}
}
}
fn take_failure(&mut self) -> Option<Error> {
self.failure.take()
}
}
impl Write for WriterOutputSink<'_> {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
match self.output {
WriterOutput::Memory(buffer) => {
buffer.get_or_insert_with(Vec::new).extend_from_slice(bytes);
Ok(bytes.len())
}
WriterOutput::Writer(writer) => writer.write(bytes),
WriterOutput::Pipeline(pipeline) => match pipeline.write(bytes) {
Ok(()) => Ok(bytes.len()),
Err(error) => {
let failure: Error = error.into();
let message = failure.to_string();
self.failure = Some(failure);
Err(std::io::Error::other(message))
}
},
}
}
fn flush(&mut self) -> std::io::Result<()> {
match self.output {
WriterOutput::Memory(_) | WriterOutput::Pipeline(_) => Ok(()),
WriterOutput::Writer(writer) => writer.flush(),
}
}
}
impl WriterOutput {
fn write_complete(&mut self, bytes: Vec<u8>) -> Result<()> {
match self {
Self::Memory(buffer) => {
*buffer = Some(bytes);
Ok(())
}
Self::Writer(writer) => {
writer.write_all(&bytes)?;
writer.flush()?;
Ok(())
}
Self::Pipeline(pipeline) => {
pipeline.write(&bytes)?;
pipeline.finish()?;
Ok(())
}
}
}
fn take_memory(&mut self) -> Result<Vec<u8>> {
match self {
Self::Memory(buffer) => buffer.take().ok_or_else(|| {
Error::Unsupported("get_buffer is only available once after a memory write".into())
}),
Self::Writer(_) | Self::Pipeline(_) => Err(Error::Unsupported(
"get_buffer requires a successful memory output".into(),
)),
}
}
}
pub struct PdfWriter<'pdf, R: Read + Seek + 'static> {
pdf: &'pdf mut Pdf<R>,
settings: WriterSettings,
output: Option<WriterOutput>,
write_started: bool,
write_succeeded: bool,
result: Option<WriterResult>,
}
#[derive(Debug, Clone, Default)]
pub struct WriterConfiguration {
settings: WriterSettings,
}
impl WriterConfiguration {
pub fn set_object_stream_mode(&mut self, mode: ObjectStreamMode) {
self.settings.object_stream_mode = mode;
}
pub fn set_stream_data_mode(&mut self, mode: StreamDataMode) {
self.settings.stream_data_mode = None;
match mode {
StreamDataMode::Preserve => {
self.settings.decode_level = DecodeLevel::None;
self.settings.compress_streams = false;
}
StreamDataMode::Uncompress => {
self.settings.decode_level =
self.settings.decode_level.max(DecodeLevel::Generalized);
self.settings.compress_streams = false;
}
StreamDataMode::Compress => {
self.settings.decode_level =
self.settings.decode_level.max(DecodeLevel::Generalized);
self.settings.compress_streams = true;
}
}
self.settings.decode_level_set = true;
self.settings.compress_streams_set = true;
}
pub fn set_compress_streams(&mut self, value: bool) {
self.settings.compress_streams = value;
self.settings.compress_streams_set = true;
}
pub fn set_decode_level(&mut self, level: DecodeLevel) {
self.settings.decode_level = level;
self.settings.decode_level_set = true;
}
pub fn set_recompress_flate(&mut self, value: bool) {
self.settings.recompress_flate = value;
}
pub fn set_compression_level(&mut self, level: i32) {
self.settings.compression_level = Some(level);
}
pub fn set_content_normalization(&mut self, value: bool) {
self.settings.content_normalization = value;
self.settings.content_normalization_set = true;
}
pub fn set_qdf_mode(&mut self, value: bool) {
self.settings.qdf_mode = value;
}
pub fn set_preserve_unreferenced_objects(&mut self, value: bool) {
self.settings.preserve_unreferenced_objects = value;
}
pub fn set_newline_before_endstream(&mut self, value: bool) {
self.settings.newline_before_endstream = if value {
NewlineBeforeEndstream::Yes
} else {
NewlineBeforeEndstream::Never
};
}
pub fn set_minimum_pdf_version(&mut self, version: impl Into<String>, extension_level: i64) {
update_minimum_pdf_version(
&mut self.settings.minimum_pdf_version,
version.into(),
extension_level,
);
}
pub fn force_pdf_version(&mut self, version: impl Into<String>, extension_level: i64) {
self.settings.forced_pdf_version = Some((version.into(), extension_level));
}
pub fn set_extra_header_text(&mut self, text: impl Into<String>) {
let mut text = text.into();
if !text.is_empty() && !text.ends_with('\n') {
text.push('\n');
}
self.settings.extra_header_text = text;
}
pub fn set_deterministic_id(&mut self, value: bool) {
self.settings.deterministic_id = value;
}
pub fn set_static_id(&mut self, value: bool) {
self.settings.static_id = value;
}
pub fn set_static_aes_iv(&mut self, value: bool) {
self.settings.static_aes_iv = value;
}
pub fn set_suppress_original_object_ids(&mut self, value: bool) {
self.settings.suppress_original_object_ids = value;
}
pub fn set_preserve_encryption(&mut self, value: bool) {
self.settings.preserve_encryption = value;
}
pub fn set_encryption_parameters(&mut self, params: EncryptParams) {
self.settings.encryption_parameters = Some(params);
self.settings.copy_encryption = None;
}
pub(crate) fn clear_encryption_parameters(&mut self) {
self.settings.encryption_parameters = None;
self.settings.copy_encryption = None;
}
pub fn normalize_encryption_passwords(&mut self, password_mode: PasswordMode) -> Result<usize> {
let Some(params) = self.settings.encryption_parameters.as_mut() else {
return Ok(0);
};
let revision = match params.method {
EncryptMethod::V1Rc440 => 2,
EncryptMethod::V2Rc4128 => 3,
EncryptMethod::V4Aes128 | EncryptMethod::V4Rc4128 => 4,
EncryptMethod::V5R5Aes256 => 5,
EncryptMethod::V5R6Aes256 => 6,
};
let (user_password, user_warning) = crate::encryption::password::password_bytes_for_write(
¶ms.user_password,
password_mode,
revision,
)?;
let (owner_password, owner_warning) =
crate::encryption::password::password_bytes_for_write(
¶ms.owner_password,
password_mode,
revision,
)?;
params.user_password = user_password;
params.owner_password = owner_password;
Ok(usize::from(user_warning) + usize::from(owner_warning))
}
pub fn copy_encryption_parameters(&mut self, source: CopyEncryptionSource) {
self.settings.copy_encryption = Some(source);
self.settings.encryption_parameters = None;
}
pub fn set_linearization(&mut self, value: bool) {
self.settings.linearization = value;
if value {
self.settings.pclm = false;
}
}
pub fn set_linearization_pass1_filename(&mut self, path: impl Into<PathBuf>) {
self.settings.linearization_pass1_filename = Some(path.into());
}
pub fn apply_to<R: Read + Seek + 'static>(&self, writer: &mut PdfWriter<'_, R>) {
writer.settings = self.settings.clone();
}
#[must_use]
pub const fn decode_level(&self) -> DecodeLevel {
self.settings.decode_level
}
#[must_use]
pub const fn preserves_unreferenced_objects(&self) -> bool {
self.settings.preserve_unreferenced_objects
}
}
fn update_minimum_pdf_version(
current: &mut Option<(String, i64)>,
version: String,
extension_level: i64,
) {
let Some(candidate) = crate::pdf_version::parse_qpdf_writer_version(&version) else {
return;
};
match current {
None => *current = Some((version, extension_level)),
Some((current_version, current_extension_level)) => {
match crate::pdf_version::parse_qpdf_writer_version(current_version) {
Some(current_parsed) => {
if candidate > current_parsed {
*current_version = version;
*current_extension_level = extension_level;
} else if candidate == current_parsed
&& extension_level > *current_extension_level
{
*current_extension_level = extension_level;
}
}
None => {
*current_version = version;
*current_extension_level = extension_level;
}
}
}
}
}
impl<'pdf, R: Read + Seek + 'static> PdfWriter<'pdf, R> {
pub fn new(pdf: &'pdf mut Pdf<R>) -> Self {
Self {
pdf,
settings: WriterSettings::default(),
output: None,
write_started: false,
write_succeeded: false,
result: None,
}
}
fn ensure_output_unconfigured(&self) -> Result<()> {
if self.output.is_some() || self.write_started {
return Err(Error::Unsupported(
"PdfWriter output can be configured only once".into(),
));
}
Ok(())
}
pub fn set_output_file(&mut self, path: impl AsRef<Path>) -> Result<()> {
self.ensure_output_unconfigured()?;
let path = path.as_ref();
let file = File::options()
.read(true)
.write(true)
.create(true)
.truncate(true)
.open(path)
.map_err(|error| Error::file_io("open", path.to_path_buf(), error))?;
self.output = Some(WriterOutput::Writer(Box::new(QpdfFileWriter::new(file))));
Ok(())
}
pub fn set_output_writer<W: Write + 'static>(&mut self, writer: W) -> Result<()> {
self.ensure_output_unconfigured()?;
self.output = Some(WriterOutput::Writer(Box::new(writer)));
Ok(())
}
pub fn set_output_memory(&mut self) -> Result<()> {
self.ensure_output_unconfigured()?;
self.output = Some(WriterOutput::Memory(None));
Ok(())
}
pub fn set_output_pipeline<P: Pipeline + 'static>(&mut self, pipeline: P) -> Result<()> {
self.ensure_output_unconfigured()?;
self.output = Some(WriterOutput::Pipeline(Box::new(pipeline)));
Ok(())
}
pub fn get_buffer(&mut self) -> Result<Vec<u8>> {
if !self.write_succeeded {
return Err(Error::Unsupported(
"get_buffer requires a successful write".into(),
));
}
self.output
.as_mut()
.ok_or_else(|| Error::Unsupported("get_buffer requires a memory output".into()))?
.take_memory()
}
pub fn set_object_stream_mode(&mut self, mode: ObjectStreamMode) {
self.settings.object_stream_mode = mode;
}
pub fn set_stream_data_mode(&mut self, mode: StreamDataMode) {
self.settings.stream_data_mode = None;
match mode {
StreamDataMode::Preserve => {
self.settings.decode_level = DecodeLevel::None;
self.settings.compress_streams = false;
}
StreamDataMode::Uncompress => {
self.settings.decode_level =
self.settings.decode_level.max(DecodeLevel::Generalized);
self.settings.compress_streams = false;
}
StreamDataMode::Compress => {
self.settings.decode_level =
self.settings.decode_level.max(DecodeLevel::Generalized);
self.settings.compress_streams = true;
}
}
self.settings.decode_level_set = true;
self.settings.compress_streams_set = true;
}
pub fn set_compress_streams(&mut self, value: bool) {
self.settings.compress_streams = value;
self.settings.compress_streams_set = true;
}
pub fn set_decode_level(&mut self, level: DecodeLevel) {
self.settings.decode_level = level;
self.settings.decode_level_set = true;
}
pub fn set_recompress_flate(&mut self, value: bool) {
self.settings.recompress_flate = value;
}
pub fn set_compression_level(&mut self, level: i32) {
self.settings.compression_level = Some(level);
}
pub fn set_content_normalization(&mut self, value: bool) {
self.settings.content_normalization = value;
self.settings.content_normalization_set = true;
}
pub fn set_qdf_mode(&mut self, value: bool) {
self.settings.qdf_mode = value;
}
pub fn set_preserve_unreferenced_objects(&mut self, value: bool) {
self.settings.preserve_unreferenced_objects = value;
}
pub fn set_newline_before_endstream(&mut self, value: bool) {
self.settings.newline_before_endstream = if value {
NewlineBeforeEndstream::Yes
} else {
NewlineBeforeEndstream::Never
};
}
pub fn set_minimum_pdf_version(&mut self, version: impl Into<String>, extension_level: i64) {
update_minimum_pdf_version(
&mut self.settings.minimum_pdf_version,
version.into(),
extension_level,
);
}
pub fn force_pdf_version(&mut self, version: impl Into<String>, extension_level: i64) {
let version = version.into();
self.settings.forced_pdf_version = Some((version, extension_level));
}
pub fn set_extra_header_text(&mut self, text: impl Into<String>) {
let mut text = text.into();
if !text.is_empty() && !text.ends_with('\n') {
text.push('\n');
}
self.settings.extra_header_text = text;
}
pub fn set_deterministic_id(&mut self, value: bool) {
self.settings.deterministic_id = value;
}
pub fn set_static_id(&mut self, value: bool) {
self.settings.static_id = value;
}
pub fn set_static_aes_iv(&mut self, value: bool) {
self.settings.static_aes_iv = value;
}
pub fn set_suppress_original_object_ids(&mut self, value: bool) {
self.settings.suppress_original_object_ids = value;
}
pub fn set_preserve_encryption(&mut self, value: bool) {
self.settings.preserve_encryption = value;
}
pub fn set_encryption_parameters(&mut self, params: EncryptParams) {
self.settings.encryption_parameters = Some(params);
self.settings.copy_encryption = None;
}
pub fn copy_encryption_parameters(&mut self, source: CopyEncryptionSource) {
self.settings.copy_encryption = Some(source);
self.settings.encryption_parameters = None;
}
pub fn set_linearization(&mut self, value: bool) {
self.settings.linearization = value;
if value {
self.settings.pclm = false;
}
}
pub fn set_linearization_pass1_filename(&mut self, path: impl Into<PathBuf>) {
self.settings.linearization_pass1_filename = Some(path.into());
}
pub fn set_pclm(&mut self, value: bool) {
self.settings.pclm = value;
if value {
self.settings.linearization = false;
}
}
pub fn register_progress_reporter(
&mut self,
reporter: Box<dyn FnMut(u8) -> crate::Result<()> + 'static>,
) {
self.settings.progress_reporter = Some(ProgressReporter::new(reporter));
}
pub fn get_final_version(&mut self) -> Result<String> {
let options = self.prepared_write_options()?;
Ok(effective_pdf_version(
self.pdf.version(),
&options,
self.settings.linearization,
matches!(self.settings.object_stream_mode, ObjectStreamMode::Generate),
)
.to_owned())
}
pub fn write(&mut self) -> Result<()> {
if self.write_started {
return Err(Error::Unsupported(
"PdfWriter::write may be called only once".into(),
));
}
if self.output.is_none() {
return Err(Error::Unsupported(
"PdfWriter::write requires an output sink".into(),
));
}
self.validate_supported_settings()?;
let mut options = self.prepared_write_options()?;
if let Some(level) = options.compression_level {
if level >= 0 {
Flate::set_compression_level(level)?;
}
}
self.write_started = true;
if options.qdf || options.content_normalization || options.decode_level != DecodeLevel::None
{
crate::PageDocumentHelper::new(self.pdf).get_all_pages()?;
}
crate::writer::configure_progress_for_pdf(
self.pdf,
&options,
0,
self.settings.linearization,
)?; let result = if self.settings.linearization {
options.qdf = false;
let pass1_path = self.settings.linearization_pass1_filename.as_deref();
let (mut document, result) =
write_linearized_for_pdf_writer(self.pdf, &options, pass1_path)?;
document.back_patch()?;
self.output
.as_mut()
.expect("output was checked before writing")
.write_complete(document.bytes)?;
result
} else {
let output = self
.output
.as_mut()
.expect("output was checked before writing");
let mut sink = WriterOutputSink::new(output);
match emit_canonical_pdf(self.pdf, &mut sink, &options) {
Ok(result) => {
sink.finish_output()?;
result
}
Err(error) => return Err(sink.take_failure().unwrap_or(error)),
}
};
report_progress_finished(&options)?;
self.result = Some(result);
self.write_succeeded = true;
Ok(())
}
pub fn get_renumbered_obj_gen(&self, source: ObjectRef) -> Result<Option<ObjectRef>> {
self.ensure_write_succeeded()?;
Ok(self
.result
.as_ref()
.expect("successful writes retain their result")
.old_to_new
.get(&source)
.copied())
}
pub fn get_written_xref_table(&self) -> Result<BTreeMap<ObjectRef, XrefEntry>> {
self.ensure_write_succeeded()?;
Ok(self
.result
.as_ref()
.expect("successful writes retain their result")
.written_xref
.clone())
}
pub fn validate_supported_settings(&self) -> Result<()> {
Ok(())
}
fn prepared_write_options(&mut self) -> Result<WriterOptions> {
let mut options = self.settings.to_write_options();
if self.settings.linearization {
options.qdf = false;
}
if options.pclm {
options.encrypt = None;
options.copy_encryption = None;
options.qdf = false;
options.content_normalization = false;
options.decode_level = DecodeLevel::None;
options.compress_streams = crate::CompressStreams::No;
options.stream_data = None;
options.object_streams = ObjectStreamMode::Disable;
}
let can_preserve = self.settings.preserve_encryption
&& self.pdf.is_encrypted()
&& options.encrypt.is_none()
&& options.copy_encryption.is_none()
&& !options.qdf
&& !options.content_normalization
&& options.decode_level == DecodeLevel::None
&& !self.settings.pclm;
if can_preserve {
options.copy_encryption = self.pdf.writer_copy_encryption_source()?;
}
if options.deterministic_id
&& (options.encrypt.is_some() || options.copy_encryption.is_some())
{
return Err(deterministic_id_encryption_error(&options));
}
if forced_version_disables_encryption(&options) {
options.encrypt = None;
options.copy_encryption = None;
}
Ok(options)
}
fn ensure_write_succeeded(&self) -> Result<()> {
if !self.write_succeeded {
return Err(Error::Unsupported(
"writer result queries require a successful write".into(),
));
}
Ok(())
}
}
fn forced_version_disables_encryption(options: &WriterOptions) -> bool {
let Some(forced) = options
.force_version
.as_deref()
.filter(|version| !version.is_empty())
.and_then(crate::pdf_version::parse_qpdf_writer_version)
else {
return false;
};
let Some((version, revision, use_aes)) = encryption_shape(options) else {
return false;
};
let v = QpdfVersionParts::new(1, 3);
if forced < v {
return true;
}
let v = QpdfVersionParts::new(1, 4);
if forced < v && (version > 1 || revision > 2) {
return true;
}
let v = QpdfVersionParts::new(1, 5);
if forced < v && (version > 2 || revision > 3) {
return true;
}
let v = QpdfVersionParts::new(1, 6);
if forced < v && use_aes {
return true;
}
let v = QpdfVersionParts::new(1, 7);
(forced < v || (forced == v && options.force_extension_level.unwrap_or(0) < 3))
&& (version >= 5 || revision >= 5)
}
fn encryption_shape(options: &WriterOptions) -> Option<(i64, i64, bool)> {
if let Some(params) = options.encrypt.as_ref() {
use crate::encryption::EncryptMethod;
return Some(match params.method {
EncryptMethod::V1Rc440 => (1, 2, false),
EncryptMethod::V2Rc4128 => (2, 3, false),
EncryptMethod::V4Rc4128 => (4, 4, false),
EncryptMethod::V4Aes128 => (4, 4, true),
EncryptMethod::V5R5Aes256 => (5, 5, true),
EncryptMethod::V5R6Aes256 => (5, 6, true),
});
}
let source = options.copy_encryption.as_ref()?;
let version = source
.encrypt_dict
.try_get_key(b"/V")
.ok()?
.try_as_integer()
.ok()??;
let revision = source
.encrypt_dict
.try_get_key(b"/R")
.ok()?
.try_as_integer()
.ok()??;
Some((version, revision, version >= 4))
}
#[derive(Clone, Debug, Default)]
pub(crate) struct WriterResult {
pub(crate) old_to_new: BTreeMap<ObjectRef, ObjectRef>,
pub(crate) written_xref: BTreeMap<ObjectRef, XrefEntry>,
}
impl WriterResult {
pub(crate) fn new(
old_to_new: BTreeMap<ObjectRef, ObjectRef>,
written_xref: BTreeMap<ObjectRef, XrefEntry>,
) -> Self {
Self {
old_to_new,
written_xref,
}
}
}
#[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: &WriterOptions) -> Option<CompressStreams> {
if options.qdf && !options.qdf_stream_policy_precomputed {
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,
#[default]
Never,
}
#[cfg(any(test, feature = "qpdf-zlib-compat"))]
#[doc(hidden)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct V5Randomness {
pub file_key: [u8; 32],
pub user_validation_salt: [u8; 8],
pub user_key_salt: [u8; 8],
pub owner_validation_salt: [u8; 8],
pub owner_key_salt: [u8; 8],
pub perms_random_tail: [u8; 4],
}
#[cfg(any(test, feature = "qpdf-zlib-compat"))]
impl V5Randomness {
#[must_use]
pub fn from_bytes(bytes: [u8; 68]) -> Self {
Self {
file_key: std::array::from_fn(|index| bytes[index]),
user_validation_salt: std::array::from_fn(|index| bytes[32 + index]),
user_key_salt: std::array::from_fn(|index| bytes[40 + index]),
owner_validation_salt: std::array::from_fn(|index| bytes[48 + index]),
owner_key_salt: std::array::from_fn(|index| bytes[56 + index]),
perms_random_tail: std::array::from_fn(|index| bytes[64 + index]),
}
}
}
type ProgressCallback = Box<dyn FnMut(u8) -> crate::Result<()> + 'static>;
type SharedProgressCallback = Rc<RefCell<ProgressCallback>>;
type SharedProgressState = Rc<RefCell<ProgressStateInner>>;
#[derive(Clone)]
pub(crate) struct ProgressReporter {
callback: SharedProgressCallback,
state: SharedProgressState,
}
impl ProgressReporter {
pub(crate) fn new(reporter: Box<dyn FnMut(u8) -> crate::Result<()> + 'static>) -> Self {
Self {
callback: Rc::new(RefCell::new(reporter)),
state: Rc::new(RefCell::new(ProgressStateInner::default())),
}
}
pub(crate) fn report(&self, percent: u8) -> crate::Result<()> {
(self.callback.borrow_mut())(percent)
}
pub(crate) fn configure(&self, events_expected: usize) {
*self.state.borrow_mut() = ProgressStateInner {
events_expected: events_expected.max(1),
..ProgressStateInner::default()
};
}
pub(crate) fn indicate(&self, decrement: bool, finished: bool) -> crate::Result<()> {
let progress = {
let mut state = self.state.borrow_mut();
if decrement {
state.events_seen = state.events_seen.saturating_sub(1);
return Ok(());
}
state.events_seen = state.events_seen.saturating_add(1);
let progress = if finished {
Some(100)
} else if state.events_seen >= state.next_progress_report {
Some(if state.next_progress_report == 0 {
0
} else {
let scaled = state.events_seen.saturating_mul(100) / state.events_expected;
1_u8.saturating_add(u8::try_from(scaled.min(98)).unwrap_or(98))
})
} else {
None
};
let increment = (state.events_expected / 100).max(1);
while state.events_seen >= state.next_progress_report {
state.next_progress_report = state.next_progress_report.saturating_add(increment);
}
progress
};
if let Some(progress) = progress {
self.report(progress)?;
}
Ok(())
}
}
impl fmt::Debug for ProgressReporter {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("ProgressReporter(..)")
}
}
#[derive(Debug)]
struct ProgressStateInner {
events_expected: usize,
events_seen: usize,
next_progress_report: usize,
}
impl Default for ProgressStateInner {
fn default() -> Self {
Self {
events_expected: 1,
events_seen: 0,
next_progress_report: 0,
}
}
}
#[derive(Debug, Default, Clone)]
pub(crate) struct WriterOptions {
pub decode_level: DecodeLevel,
pub content_normalization: bool,
pub static_id: bool,
pub deterministic_id: bool,
pub static_aes_iv: bool,
#[cfg(any(test, feature = "qpdf-zlib-compat"))]
#[doc(hidden)]
pub v5_randomness: Option<V5Randomness>,
pub min_version: Option<String>,
pub min_extension_level: Option<i64>,
pub force_version: Option<String>,
pub force_extension_level: Option<i64>,
pub extra_header_text: String,
pub no_original_object_ids: bool,
pub object_streams: ObjectStreamMode,
pub preserve_unreferenced_objects: bool,
pub compress_streams: CompressStreams,
pub newline_before_endstream: NewlineBeforeEndstream,
pub qdf: bool,
pub(crate) qdf_stream_policy_precomputed: bool,
pub stream_data: Option<StreamDataMode>,
pub recompress_flate: bool,
pub compression_level: Option<i32>,
pub encrypt: Option<crate::encryption::EncryptParams>,
pub copy_encryption: Option<crate::encryption::CopyEncryptionSource>,
pub pclm: bool,
pub(crate) progress_reporter: Option<ProgressReporter>,
}
pub(crate) const fn uses_deterministic_id(options: &WriterOptions) -> bool {
options.deterministic_id && !options.static_id
}
pub(crate) fn configure_progress_for_pdf<R: Read + Seek>(
pdf: &mut Pdf<R>,
options: &WriterOptions,
additional_objects: usize,
linearized: bool,
) -> Result<()> {
if options.progress_reporter.is_none() {
return Ok(());
}
let object_count = usize::try_from(pdf.get_object_count()?).map_err(|_| {
crate::Error::Unsupported("PdfWriter progress object count does not fit usize".into())
})?;
configure_progress(
options,
object_count.saturating_add(additional_objects),
linearized,
);
Ok(())
}
pub(crate) fn configure_progress(options: &WriterOptions, object_count: usize, linearized: bool) {
if let Some(reporter) = options.progress_reporter.as_ref() {
reporter.configure(object_count.saturating_mul(if linearized { 2 } else { 1 }));
} }
pub(crate) fn report_progress_event(options: &WriterOptions) -> Result<()> {
if let Some(reporter) = options.progress_reporter.as_ref() {
reporter.indicate(false, false)?;
}
Ok(())
}
pub(crate) fn decrement_progress_event(options: &WriterOptions) -> Result<()> {
if let Some(reporter) = options.progress_reporter.as_ref() {
reporter.indicate(true, false)?;
}
Ok(())
}
pub(crate) fn report_progress_finished(options: &WriterOptions) -> Result<()> {
if let Some(reporter) = options.progress_reporter.as_ref() {
reporter.indicate(false, true)?;
}
Ok(())
}
pub(crate) fn force_version_below_1_5(options: &WriterOptions) -> bool {
options
.force_version
.as_deref()
.filter(|version| !version.is_empty())
.and_then(parse_qpdf_writer_version)
.is_some_and(|version| version < QpdfVersionParts::new(1, 5))
}
pub(crate) fn effective_pdf_version<'a>(
source: &'a str,
options: &'a WriterOptions,
linearize: bool,
object_streams: bool,
) -> &'a str {
effective_pdf_version_and_ext(source, 0, options, linearize, object_streams).0
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct EffectivePdfVersion<'a> {
raw: &'a str,
parsed: QpdfVersionParts,
extension_level: i64,
}
fn update_effective_pdf_version<'a>(
current: &mut Option<EffectivePdfVersion<'a>>,
raw: &'a str,
extension_level: i64,
) {
let Some(parsed) = parse_qpdf_writer_version(raw) else {
return;
};
match current.as_mut() {
None => {
*current = Some(EffectivePdfVersion {
raw,
parsed,
extension_level,
});
}
Some(existing) => {
if parsed > existing.parsed {
existing.raw = raw;
existing.parsed = parsed;
existing.extension_level = extension_level;
} else if parsed == existing.parsed && extension_level > existing.extension_level {
existing.extension_level = extension_level;
}
}
}
}
fn encryption_version_floor(options: &WriterOptions) -> Option<PdfVersion> {
use crate::encryption::EncryptMethod;
if let Some(ref enc) = options.encrypt {
return Some(match enc.method {
EncryptMethod::V5R6Aes256 => PdfVersion::new(1, 7, 8),
EncryptMethod::V5R5Aes256 => PdfVersion::new(1, 7, 3),
EncryptMethod::V4Aes128 => PdfVersion::new(1, 6, 0),
EncryptMethod::V4Rc4128 => PdfVersion::new(1, 5, 0),
EncryptMethod::V2Rc4128 => PdfVersion::new(1, 4, 0),
EncryptMethod::V1Rc440 => PdfVersion::new(1, 3, 0),
});
}
if let Some(source) = options.copy_encryption.as_ref() {
let version = source
.encrypt_dict
.try_get_key(b"/V")
.ok()?
.try_as_integer()
.ok()??;
let revision = source
.encrypt_dict
.try_get_key(b"/R")
.ok()?
.try_as_integer()
.ok()??;
return Some(if revision >= 6 {
PdfVersion::new(1, 7, 8)
} else if version >= 5 && revision >= 5 {
PdfVersion::new(1, 7, 3)
} else if version == 4 || revision >= 4 {
PdfVersion::new(1, 6, 0)
} else if revision >= 3 || version == 2 {
PdfVersion::new(1, 4, 0)
} else {
PdfVersion::new(1, 3, 0)
});
}
None
}
fn forced_pdf_version_pair(options: &WriterOptions) -> Option<(&str, i64)> {
let forced = options
.force_version
.as_deref()
.filter(|version| !version.is_empty())?;
parse_qpdf_writer_version(forced)?;
Some((forced, options.force_extension_level.unwrap_or(0)))
}
pub(crate) fn effective_pdf_version_and_ext<'a>(
source: &'a str,
source_ext: i64,
options: &'a WriterOptions,
linearize: bool,
object_streams: bool,
) -> (&'a str, i64) {
match forced_pdf_version_pair(options) {
Some(pair) => pair,
None => effective_pdf_version_and_ext_without_force(
source,
source_ext,
options,
linearize,
object_streams,
),
}
}
fn effective_pdf_version_and_ext_without_force<'a>(
source: &'a str,
source_ext: i64,
options: &'a WriterOptions,
linearize: bool,
object_streams: bool,
) -> (&'a str, i64) {
if parse_qpdf_writer_version(source).is_none() {
return (source, 0);
}
let mut best = None;
if let Some(encryption_floor) = encryption_version_floor(options) {
let raw = encryption_floor.static_version_str().unwrap_or("1.7");
update_effective_pdf_version(&mut best, raw, encryption_floor.extension_level());
}
update_effective_pdf_version(&mut best, source, source_ext);
if let Some(min_v) = options
.min_version
.as_deref()
.filter(|version| !version.is_empty())
{
update_effective_pdf_version(&mut best, min_v, options.min_extension_level.unwrap_or(0));
}
if object_streams {
update_effective_pdf_version(&mut best, "1.5", 0);
}
if linearize {
update_effective_pdf_version(&mut best, "1.2", 0);
}
best.map(|version| (version.raw, version.extension_level))
.unwrap_or((source, 0))
}
pub(crate) fn inject_adbe_extension<R: Read + Seek>(
pdf: &mut Pdf<R>,
version: &str,
extension_level: i64,
) -> Result<()> {
let (root_ref, catalog) = writer_catalog_copy(pdf)?;
let raw_extensions = catalog.try_get_key(b"/Extensions")?;
let extensions = if let Some(entries) = raw_extensions.try_as_dictionary()? {
ObjectHandle::dictionary(entries.into_iter().collect())
} else {
ObjectHandle::dictionary(Vec::new())
};
let mut adbe = extensions.try_get_key(b"/ADBE")?;
if adbe.is_indirect() {
adbe.make_direct(false)?;
extensions.replace_key(b"/ADBE", adbe.clone())?;
}
let preserves_existing = adbe.try_as_dictionary()?.is_some()
&& adbe
.try_get_key(b"/BaseVersion")?
.try_is_name_and_equals(version.as_bytes())?
&& adbe.try_get_key(b"/ExtensionLevel")?.try_as_integer()? == Some(extension_level);
if !preserves_existing {
let replacement = ObjectHandle::dictionary(vec![
(
b"/BaseVersion".to_vec(),
ObjectHandle::name(version.as_bytes().to_vec()),
),
(
b"/ExtensionLevel".to_vec(),
ObjectHandle::integer(extension_level),
),
]);
extensions.replace_key(b"/ADBE", replacement)?;
}
catalog.replace_key(b"/Extensions", extensions)?;
replace_writer_catalog(pdf, root_ref, catalog)?;
Ok(())
}
pub(crate) fn strip_adbe_extension<R: Read + Seek>(
pdf: &mut Pdf<R>,
version: &str,
extension_level: i64,
) -> Result<()> {
let (root_ref, catalog) = writer_catalog_copy(pdf)?;
let raw_extensions = catalog.try_get_key(b"/Extensions")?;
let Some(entries) = raw_extensions.try_as_dictionary()? else {
return Ok(());
};
let extensions_was_indirect = raw_extensions.is_indirect();
let extensions = ObjectHandle::dictionary(entries.into_iter().collect());
let keys = extensions.try_get_keys()?;
if !keys.contains(b"/ADBE".as_slice()) {
return Ok(());
}
let has_other = keys.iter().any(|key| key.as_slice() != b"/ADBE");
if has_other {
let mut adbe = extensions.try_get_key(b"/ADBE")?;
let adbe_was_indirect = adbe.is_indirect();
if adbe_was_indirect {
adbe.make_direct(false)?;
extensions.replace_key(b"/ADBE", adbe.clone())?;
}
let valid_adbe = adbe.try_as_dictionary()?.is_some()
&& adbe
.try_get_key(b"/BaseVersion")?
.try_is_name_and_equals(version.as_bytes())?
&& adbe.try_get_key(b"/ExtensionLevel")?.try_as_integer()? == Some(extension_level);
if valid_adbe {
if extensions_was_indirect || adbe_was_indirect {
catalog.replace_key(b"/Extensions", extensions)?;
replace_writer_catalog(pdf, root_ref, catalog)?;
}
return Ok(());
}
}
extensions.remove_key(b"/ADBE");
if extensions.try_get_keys()?.is_empty() {
catalog.remove_key(b"/Extensions");
} else {
catalog.replace_key(b"/Extensions", extensions)?;
}
replace_writer_catalog(pdf, root_ref, catalog)?;
Ok(())
}
fn writer_catalog_copy<R: Read + Seek>(
pdf: &mut Pdf<R>,
) -> Result<(Option<ObjectRef>, ObjectHandle)> {
let source = pdf.root_handle()?;
let root_ref = source.object_ref();
let entries = source
.try_as_dictionary()?
.ok_or_else(|| crate::Error::Unsupported("Catalog is not a dictionary".to_string()))?;
let catalog = ObjectHandle::dictionary(entries.into_iter().collect());
Ok((root_ref, catalog))
}
fn replace_writer_catalog<R: Read + Seek>(
pdf: &mut Pdf<R>,
root_ref: Option<ObjectRef>,
catalog: ObjectHandle,
) -> Result<()> {
if let Some(root_ref) = root_ref {
pdf.replace_object(root_ref, catalog).map(|_| ())?;
return Ok(());
}
let root = pdf.root_handle()?;
root.share_value_state_with(&catalog)?;
pdf.mark_object_handle_dirty(&root)
}
pub(crate) struct CatalogExtensionsSnapshot {
root_ref: ObjectRef,
extensions: Option<ObjectHandle>,
was_dirty: bool,
}
pub(crate) fn record_catalog_snapshot_dirty_baseline<R: Read + Seek + 'static>(
pdf: &Pdf<R>,
snapshot: &mut Option<CatalogExtensionsSnapshot>,
) {
if let Some(snapshot) = snapshot {
snapshot.was_dirty |= pdf.is_dirty(snapshot.root_ref);
}
}
pub(crate) fn snapshot_catalog_extensions<R: Read + Seek>(
pdf: &mut Pdf<R>,
) -> Result<Option<CatalogExtensionsSnapshot>> {
let catalog = pdf.root_handle()?;
let Some(root_ref) = catalog.object_ref() else {
return Ok(None);
};
let was_dirty = pdf.is_dirty(root_ref);
let extensions = catalog
.try_as_dictionary()?
.and_then(|dict| dict.get(b"/Extensions".as_slice()).cloned());
Ok(Some(CatalogExtensionsSnapshot {
root_ref,
extensions,
was_dirty,
}))
}
pub(crate) fn restore_catalog_extensions<R: Read + Seek>(
pdf: &mut Pdf<R>,
snapshot: Option<CatalogExtensionsSnapshot>,
) -> Result<()> {
let Some(snapshot) = snapshot else {
return Ok(());
};
let (_, catalog) = writer_catalog_copy(pdf)?;
let current_extensions = catalog
.try_as_dictionary()?
.and_then(|dict| dict.get(b"/Extensions".as_slice()).cloned());
let extensions_changed = match (&snapshot.extensions, ¤t_extensions) {
(None, None) => false,
(Some(before), Some(after)) => !before.is_same_object_as(after),
_ => true,
};
if extensions_changed || (!snapshot.was_dirty && pdf.is_dirty(snapshot.root_ref)) {
match snapshot.extensions {
Some(extensions) => catalog.restore_key_raw(b"/Extensions", extensions)?,
None => catalog.remove_key(b"/Extensions"),
}
pdf.replace_object(snapshot.root_ref, catalog)?;
}
if !snapshot.was_dirty {
pdf.clear_dirty(snapshot.root_ref);
}
Ok(())
}
fn catalog_has_extensions_adbe<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<bool> {
let catalog = pdf.root_handle()?;
if !catalog.try_has_key(b"/Extensions")? {
return Ok(false);
}
let extensions = catalog.try_get_key(b"/Extensions")?;
if extensions.try_as_dictionary()?.is_none() {
return Ok(false);
}
Ok(extensions.try_get_keys()?.contains(b"/ADBE".as_slice()))
}
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,
];
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()
}
mod _writer_doc_anchor {}
#[derive(Debug, Clone, Copy)]
pub(crate) enum WriteCipher {
PerObject(crate::encryption::standard::ObjectKeyAlg),
FileKeyAes256,
}
pub(crate) struct EncryptionContext {
pub(crate) encrypt_dict: ObjectHandle,
pub(crate) file_key: Vec<u8>,
pub(crate) cipher: WriteCipher,
pub(crate) encryption_v: i32,
pub(crate) encryption_r: i32,
pub(crate) encrypt_ref: ObjectRef,
pub(crate) id0: Vec<u8>,
pub(crate) static_aes_iv: bool,
pub(crate) encrypt_metadata: bool,
pub(crate) metadata_ref: Option<ObjectRef>,
}
pub(crate) fn resolve_metadata_stream_ref<R: Read + Seek>(
pdf: &mut Pdf<R>,
) -> Result<Option<ObjectRef>> {
let root_handle = pdf.root_handle()?;
let metadata = root_handle.try_get_key(b"/Metadata")?;
Ok(metadata.object_ref())
}
pub(crate) fn build_encryption_context(
options: &WriterOptions,
params: &crate::encryption::EncryptParams,
existing_max: u32,
metadata_ref: Option<ObjectRef>,
id0: &[u8],
) -> Result<EncryptionContext> {
use crate::encryption::standard::{
build_v1_v2_encrypt_dict, build_v4_encrypt_dict, ObjectKeyAlg, V1V2EncryptParams,
V4CryptMethod, V4EncryptParams,
};
use crate::encryption::EncryptMethod;
let id0 = id0.to_vec();
let (encrypt_dict, file_key, cipher, encryption_v, encryption_r) = 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), 4, 4)
}
EncryptMethod::V5R6Aes256 => {
use crate::encryption::standard::{build_v5_r6_encrypt_dict, V5R6EncryptParams};
let secrets = generate_v5r6_secrets(options)?;
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,
5,
6,
)
}
EncryptMethod::V5R5Aes256 => {
use crate::encryption::standard::{build_v5_r5_encrypt_dict, V5R6EncryptParams};
let secrets = generate_v5r6_secrets(options)?;
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,
5,
5,
)
}
EncryptMethod::V1Rc440 => {
let v12 = V1V2EncryptParams {
v: 1,
r: 2,
length_bits: 40,
user_password: ¶ms.user_password,
owner_password: ¶ms.owner_password,
p: params.r2_permissions.to_p_bits(),
id0: &id0,
};
let (dict, key) = build_v1_v2_encrypt_dict(&v12)?;
(dict, key, WriteCipher::PerObject(ObjectKeyAlg::Rc4), 1, 2)
}
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), 2, 3)
}
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), 4, 4)
}
};
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,
encryption_v,
encryption_r,
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(
_options: &WriterOptions,
) -> Result<crate::encryption::standard::V5R6Secrets> {
#[cfg(any(test, feature = "qpdf-zlib-compat"))]
if let Some(randomness) = _options.v5_randomness {
return Ok(crate::encryption::standard::V5R6Secrets {
file_key: randomness.file_key,
user_validation_salt: randomness.user_validation_salt,
user_key_salt: randomness.user_key_salt,
owner_validation_salt: randomness.owner_validation_salt,
owner_key_salt: randomness.owner_key_salt,
perms_random_tail: randomness.perms_random_tail,
});
}
let mut buf = [0u8; 68];
getrandom::fill(&mut buf).map_err(|e| {
crate::Error::Unsupported(format!(
"OS CSPRNG (getrandom) unavailable for V=5 R=6 secret generation: {e}"
))
})?;
Ok(crate::encryption::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(),
})
}
pub(crate) fn build_copy_encryption_context(
src: &crate::encryption::CopyEncryptionSource,
options: &WriterOptions,
existing_max: u32,
metadata_ref: Option<ObjectRef>,
) -> Result<EncryptionContext> {
let (encrypt_dict, encryption_v, encryption_r, cipher) = canonical_copy_encryption(src)?;
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(),
)
})?;
let encrypt_metadata = copy_encryption_encrypts_metadata_from_dict(&encrypt_dict);
Ok(EncryptionContext {
encrypt_dict,
file_key: src.file_key.clone(),
cipher,
encryption_v,
encryption_r,
encrypt_ref: ObjectRef::new(encrypt_num, 0),
id0: src.id0.clone(),
static_aes_iv: options.static_aes_iv,
encrypt_metadata,
metadata_ref: if encrypt_metadata { None } else { metadata_ref },
})
}
fn canonical_copy_encryption(
src: &crate::encryption::CopyEncryptionSource,
) -> Result<(ObjectHandle, i32, i32, WriteCipher)> {
use crate::encryption::standard::ObjectKeyAlg;
let version = copy_integer(&src.encrypt_dict, "V")?;
let revision = copy_integer(&src.encrypt_dict, "R")?;
let version_i32 = i32::try_from(version).map_err(|_| {
crate::Error::Unsupported(format!("copy-encryption /V is out of range: {version}"))
})?;
let revision_i32 = i32::try_from(revision).map_err(|_| {
crate::Error::Unsupported(format!("copy-encryption /R is out of range: {revision}"))
})?;
let length_bits = if version == 1 {
40
} else {
copy_integer(&src.encrypt_dict, "Length")?
};
if !(40..=256).contains(&length_bits) || length_bits % 8 != 0 {
return Err(crate::Error::Unsupported(format!(
"copy-encryption /Length is invalid: {length_bits} bits"
)));
}
let expected_key_len = if version >= 5 {
if version != 5 || !matches!(revision, 5 | 6) || length_bits != 256 {
return Err(crate::Error::Unsupported(format!(
"unsupported copy-encryption Standard handler V={version} R={revision} Length={length_bits}"
)));
}
32
} else {
if !matches!(version, 1 | 2 | 4)
|| (version == 1 && revision != 2)
|| (version == 2 && !matches!(revision, 2 | 3))
|| (version == 4 && revision != 4)
{
return Err(crate::Error::Unsupported(format!(
"unsupported copy-encryption Standard handler V={version} R={revision}"
)));
}
usize::try_from(length_bits / 8).map_err(|_| {
crate::Error::Unsupported("copy-encryption key length overflows usize".into())
})?
};
if src.file_key.len() != expected_key_len {
return Err(crate::Error::Unsupported(format!(
"copy-encryption V={version} R={revision} file key must be {expected_key_len} bytes; got {}",
src.file_key.len()
)));
}
let p = crate::encryption::qpdf_permission_i32(copy_integer(&src.encrypt_dict, "P")?);
let o = copy_string(&src.encrypt_dict, "O")?;
let u = copy_string(&src.encrypt_dict, "U")?;
let encrypt_metadata = copy_encryption_encrypts_metadata_from_dict(&src.encrypt_dict);
let mut entries = vec![
(b"Filter".to_vec(), ObjectHandle::name(b"Standard".to_vec())),
(b"V".to_vec(), ObjectHandle::integer(version)),
(b"Length".to_vec(), ObjectHandle::integer(length_bits)),
(b"R".to_vec(), ObjectHandle::integer(revision)),
(b"P".to_vec(), ObjectHandle::integer(i64::from(p))),
(b"O".to_vec(), ObjectHandle::string(o)),
(b"U".to_vec(), ObjectHandle::string(u)),
];
let cipher = if version >= 5 {
let oe = copy_string(&src.encrypt_dict, "OE")?;
let ue = copy_string(&src.encrypt_dict, "UE")?;
let perms = copy_string(&src.encrypt_dict, "Perms")?;
entries.push((b"OE".to_vec(), ObjectHandle::string(oe)));
entries.push((b"UE".to_vec(), ObjectHandle::string(ue)));
entries.push((b"Perms".to_vec(), ObjectHandle::string(perms)));
let (cf, stm_f, str_f) = standard_crypt_filter(b"AESV3", 32);
entries.push((b"CF".to_vec(), cf));
entries.push((b"StmF".to_vec(), stm_f));
entries.push((b"StrF".to_vec(), str_f));
WriteCipher::FileKeyAes256
} else if version == 4 {
let (cf, stm_f, str_f) = standard_crypt_filter(b"AESV2", 16);
entries.push((b"CF".to_vec(), cf));
entries.push((b"StmF".to_vec(), stm_f));
entries.push((b"StrF".to_vec(), str_f));
WriteCipher::PerObject(ObjectKeyAlg::Aes)
} else {
WriteCipher::PerObject(ObjectKeyAlg::Rc4)
};
if revision >= 4 && !encrypt_metadata {
entries.push((b"EncryptMetadata".to_vec(), ObjectHandle::boolean(false)));
}
let dict = ObjectHandle::dictionary(entries);
Ok((dict, version_i32, revision_i32, cipher))
}
fn copy_integer(dict: &ObjectHandle, key: &str) -> Result<i64> {
let key = format!("/{key}");
dict.try_get_key(key.as_bytes())?
.try_as_integer()?
.ok_or_else(|| {
crate::Error::Unsupported(format!("copy-encryption /{key} must be an integer"))
})
}
fn copy_string(dict: &ObjectHandle, key: &str) -> Result<Vec<u8>> {
let key = format!("/{key}");
dict.try_get_key(key.as_bytes())?
.as_string()
.ok_or_else(|| {
crate::Error::Unsupported(format!("copy-encryption /{key} must be a string"))
})
}
fn standard_crypt_filter(cfm: &[u8], length: i64) -> (ObjectHandle, ObjectHandle, ObjectHandle) {
let std_cf = ObjectHandle::dictionary(vec![
(
b"AuthEvent".to_vec(),
ObjectHandle::name(b"DocOpen".to_vec()),
),
(b"CFM".to_vec(), ObjectHandle::name(cfm.to_vec())),
(b"Length".to_vec(), ObjectHandle::integer(length)),
]);
(
ObjectHandle::dictionary(vec![(b"StdCF".to_vec(), std_cf)]),
ObjectHandle::name(b"StdCF".to_vec()),
ObjectHandle::name(b"StdCF".to_vec()),
)
}
pub(crate) fn copy_encryption_encrypts_metadata(
src: &crate::encryption::CopyEncryptionSource,
) -> bool {
copy_encryption_encrypts_metadata_from_dict(&src.encrypt_dict)
}
fn copy_encryption_encrypts_metadata_from_dict(dict: &ObjectHandle) -> bool {
dict.try_get_key(b"/EncryptMetadata")
.ok()
.and_then(|value| value.as_boolean())
.unwrap_or(true)
}
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
}
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_handle(trailer: &ObjectHandle) -> Option<Vec<u8>> {
let id = trailer.try_get_key(b"/ID").ok()?;
source_permanent_id_value_handle(&id)
}
pub(crate) fn source_permanent_id_value_handle(id: &ObjectHandle) -> Option<Vec<u8>> {
let first = id.try_array_item(0).ok()??;
first.try_dereference().ok()?;
match first.as_string() {
Some(bytes) if !bytes.is_empty() => Some(bytes),
_ => None,
}
}
pub(crate) fn generate_id_handle(source_id0: Option<&[u8]>, static_id: bool) -> ObjectHandle {
let changing_id = if static_id {
QPDF_STATIC_ID.to_vec()
} else {
fresh_id_bytes().to_vec()
};
let permanent_id = source_id0
.filter(|id0| !id0.is_empty())
.map(<[u8]>::to_vec)
.unwrap_or_else(|| changing_id.clone());
ObjectHandle::array(vec![
ObjectHandle::string(permanent_id),
ObjectHandle::string(changing_id),
])
}
pub(crate) fn generate_id_without_data() -> crate::Error {
crate::Error::Internal(
"INTERNAL ERROR: QPDFWriter::generateID has no data for deterministic ID. This may happen if deterministic ID and file encryption are requested together."
.to_string(),
)
}
pub(crate) fn deterministic_id_after_id_generation() -> crate::Error {
crate::Error::Internal(
"Deterministic ID computation enabled after ID generation has already occurred."
.to_string(),
)
}
pub(crate) fn deterministic_id_encryption_error(options: &WriterOptions) -> crate::Error {
if options.static_id {
deterministic_id_after_id_generation()
} else {
generate_id_without_data()
}
}
pub(crate) fn deterministic_id_info_suffix<R: Read + Seek>(pdf: &mut Pdf<R>) -> Vec<u8> {
let trailer = pdf.trailer();
let info = match trailer.try_get_key(b"/Info") {
Ok(info) => info,
Err(_) => return Vec::new(), };
let dict = match info.try_as_dictionary() {
Ok(Some(dict)) => dict,
Ok(None) => return Vec::new(),
Err(_) => return Vec::new(), };
let mut suffix = Vec::new();
for (_key, value) in dict {
if value.try_dereference().is_err() {
continue; }
if let Some(bytes) = value.as_string() {
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_handle_entries<R: Read + Seek>(
trailer: &ObjectHandle,
pdf: &mut Pdf<R>,
options: &WriterOptions,
encrypt_ctx: Option<&EncryptionContext>,
deterministic_id: bool,
generated_id: Option<&ObjectHandle>,
) -> Result<()> {
if let Some(ctx) = encrypt_ctx {
trailer.replace_key(b"/Encrypt", pdf.get_object_handle(ctx.encrypt_ref))?; if let Some(id) = generated_id {
trailer.replace_key(b"/ID", id.shallow_copy()?)?;
} else {
let id1 = if options.static_id {
QPDF_STATIC_ID.to_vec()
} else {
fresh_id_bytes().to_vec()
};
trailer.replace_key(
b"/ID",
ObjectHandle::array(vec![
ObjectHandle::string(ctx.id0.clone()),
ObjectHandle::string(id1),
]),
)?; }
} else {
if pdf.is_encrypted() {
trailer.remove_key(b"/Encrypt");
}
if deterministic_id {
trailer.replace_key(
b"/ID",
ObjectHandle::array(vec![
ObjectHandle::string(vec![0; 16]),
ObjectHandle::string(vec![0; 16]),
]),
)?; } else if let Some(id) = generated_id {
trailer.replace_key(b"/ID", id.shallow_copy()?)?;
} else {
return Err(crate::Error::Unsupported(
"writer trailer is missing its generated /ID".to_string(),
));
}
}
Ok(())
}
#[allow(clippy::too_many_arguments)] fn build_writer_trailer_handle<R: Read + Seek>(
pdf: &mut Pdf<R>,
size: usize,
root: Option<ObjectRef>,
direct_root: Option<&ObjectHandle>,
options: &WriterOptions,
encrypt_ctx: Option<&EncryptionContext>,
deterministic_id: bool,
generated_id: Option<&ObjectHandle>,
) -> Result<ObjectHandle> {
let trailer = pdf.trailer().unsafe_shallow_copy()?;
for key in [b"/ID".as_slice(), b"/Encrypt", b"/Prev"] {
trailer.remove_key(key);
}
for key in [
b"/Type".as_slice(),
b"/F",
b"/FFilter",
b"/FDecodeParms",
b"/W",
b"/Index",
b"/Length",
b"/Filter",
b"/DecodeParms",
b"/XRefStm",
] {
trailer.remove_key(key);
}
trailer.replace_key(
b"/Size",
ObjectHandle::integer(i64::try_from(size).map_err(|_| {
crate::Error::Unsupported("writer trailer /Size does not fit in i64".to_string())
})?), )?; let root = match (root, direct_root) {
(Some(root), None) => pdf.get_object_handle(root),
(None, Some(root)) => root.clone(),
_ => {
return Err(crate::Error::Unsupported(
"writer trailer Catalog root form is inconsistent".to_string(),
));
}
};
trailer.replace_key(b"/Root", root)?; apply_encrypt_trailer_handle_entries(
&trailer,
pdf,
options,
encrypt_ctx,
deterministic_id,
generated_id,
)?; Ok(trailer)
}
fn source_objstm_container_for_batch(
batch: &[ObjectRef],
source_xref_entries: &BTreeMap<ObjectRef, XrefEntry>,
) -> Option<ObjectRef> {
batch
.iter()
.find_map(|member| match source_xref_entries.get(member) {
Some(XrefEntry::Compressed { stream, .. }) => Some(ObjectRef::new(*stream, 0)),
Some(XrefEntry::Free { .. } | XrefEntry::Uncompressed { .. }) | None => None,
})
}
fn remap_source_objstm_extends(
extends: ObjectRef,
source_container_to_batch: &HashMap<ObjectRef, usize>,
container_refs: &[ObjectRef],
qdf: bool,
qdf_emission_renumber: &HashMap<ObjectRef, ObjectRef>,
renumber: &dyn crate::writer::rewrite_renumber::NewNumberLookup,
) -> Option<ObjectRef> {
source_container_to_batch
.get(&extends)
.and_then(|batch_idx| container_refs.get(*batch_idx).copied())
.or_else(|| {
if qdf {
qdf_emission_renumber.get(&extends).copied()
} else {
renumber.new_for_original(extends)
}
})
}
pub(crate) fn cipher_needs_aes_iv(cipher: WriteCipher) -> bool {
use crate::encryption::standard::ObjectKeyAlg;
matches!(
cipher,
WriteCipher::PerObject(ObjectKeyAlg::Aes) | WriteCipher::FileKeyAes256
)
}
fn writer_has_current_data_key(ctx: &EncryptionContext) -> bool {
match ctx.cipher {
WriteCipher::PerObject(_) => true,
WriteCipher::FileKeyAes256 => !ctx.file_key.is_empty(),
}
}
pub(crate) fn adjust_aes_stream_length(
length: &mut usize,
ctx: &EncryptionContext,
encrypt_stream: bool,
) -> Result<()> {
if encrypt_stream && writer_has_current_data_key(ctx) && cipher_needs_aes_iv(ctx.cipher) {
let padding = 32 - (*length & 0xf);
*length = (*length).checked_add(padding).ok_or_else(|| {
crate::Error::Unsupported("encrypted stream /Length overflows usize".to_string())
})?; }
Ok(())
}
fn run_writer_pipeline(pipeline: &mut dyn Pipeline, data: &[u8]) -> Result<()> {
let write_result = pipeline.write(data);
let finish_result = pipeline.finish();
if let Err(error) = write_result {
return Err(error.into());
}
finish_result.map_err(Into::into)
}
fn pipe_writer_stream_payload(
out: &mut Vec<u8>,
data: &[u8],
object_ref: ObjectRef,
ctx: &EncryptionContext,
encrypt_stream: bool,
explicit_iv: Option<[u8; 16]>,
) -> Result<u8> {
let mut sink = PlString::new("writer stream output", None, out);
let mut count = crate::pipeline::count::Count::new("writer stream count", &mut sink);
let explicit_iv = explicit_iv.or_else(|| {
(ctx.static_aes_iv && cipher_needs_aes_iv(ctx.cipher))
.then(crate::pipeline::aes::static_initialization_vector)
});
if !encrypt_stream {
run_writer_pipeline(&mut count, data)?;
return Ok(count.last_byte());
}
let mut state = encryption_state::WriterEncryptionState::new(
true,
ctx.file_key.clone(),
cipher_needs_aes_iv(ctx.cipher),
ctx.encryption_v,
ctx.encryption_r,
);
state.with_object_data_key(object_ref.number, None, |state| {
let key = state.current_data_key().ok_or_else(|| {
crate::Error::Internal(
"QPDFWriter stream encryption data key was not initialized".to_string(),
)
})?; if key.is_empty() {
run_writer_pipeline(&mut count, data)?;
return Ok(());
}
match ctx.cipher {
WriteCipher::PerObject(crate::encryption::standard::ObjectKeyAlg::Rc4) => {
let mut stage =
crate::pipeline::rc4::PlRc4::new("rc4 stream encryption", &mut count, key)?;
run_writer_pipeline(&mut stage, data)
}
WriteCipher::PerObject(crate::encryption::standard::ObjectKeyAlg::Aes)
| WriteCipher::FileKeyAes256 => {
if let Some(iv) = explicit_iv {
count.write(&iv)?;
let mut stage = crate::pipeline::aes::PlAesPdf::new_encrypt(
"aes stream encryption",
&mut count,
key,
)?;
stage.set_iv(&iv)?;
run_writer_pipeline(&mut stage, data)
} else {
let mut stage = crate::pipeline::aes::PlAesPdf::new_encrypt(
"aes stream encryption",
&mut count,
key,
)?; run_writer_pipeline(&mut stage, data)
}
}
}
})?;
Ok(count.last_byte())
}
pub(crate) fn write_stream_payload_with_pipeline(
out: &mut Vec<u8>,
data: &[u8],
policy: NewlineBeforeEndstream,
object_ref: ObjectRef,
ctx: &EncryptionContext,
encrypt_stream: bool,
explicit_iv: Option<[u8; 16]>,
) -> Result<bool> {
write_stream_payload_with_pipeline_qdf(
out,
data,
policy,
false,
object_ref,
ctx,
encrypt_stream,
explicit_iv,
)
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn write_stream_payload_with_pipeline_qdf(
out: &mut Vec<u8>,
data: &[u8],
policy: NewlineBeforeEndstream,
qdf_mode: bool,
object_ref: ObjectRef,
ctx: &EncryptionContext,
encrypt_stream: bool,
explicit_iv: Option<[u8; 16]>,
) -> Result<bool> {
out.extend_from_slice(b"\nstream\n");
let last_byte =
pipe_writer_stream_payload(out, data, object_ref, ctx, encrypt_stream, explicit_iv)?;
let add_newline = match policy {
NewlineBeforeEndstream::Yes => true,
NewlineBeforeEndstream::Never => qdf_mode && last_byte != b'\n',
};
if add_newline {
out.push(b'\n');
}
out.extend_from_slice(b"endstream");
Ok(add_newline)
}
fn write_objstm_dictionary(
out: &mut Vec<u8>,
stream_length: usize,
compressed: bool,
member_count: usize,
first_offset: usize,
extends: Option<ObjectRef>,
) {
out.extend_from_slice(b"<< /Type /ObjStm");
out.extend_from_slice(format!(" /Length {stream_length}").as_bytes());
if compressed {
out.extend_from_slice(b" /Filter /FlateDecode");
}
out.extend_from_slice(format!(" /N {member_count} /First {first_offset}").as_bytes());
if let Some(extends) = extends {
out.extend_from_slice(
format!(" /Extends {} {} R", extends.number, extends.generation).as_bytes(),
);
}
out.extend_from_slice(b" >>");
}
fn write_qdf_objstm_dictionary(
out: &mut Vec<u8>,
stream_length: usize,
member_count: usize,
first_offset: usize,
extends: Option<ObjectRef>,
) {
out.extend_from_slice(b"<<\n /Type /ObjStm\n");
out.extend_from_slice(format!(" /Length {stream_length}\n").as_bytes());
out.extend_from_slice(format!(" /N {member_count}\n").as_bytes());
out.extend_from_slice(format!(" /First {first_offset}\n").as_bytes());
if let Some(extends) = extends {
out.extend_from_slice(
format!(" /Extends {} {} R\n", extends.number, extends.generation).as_bytes(),
);
}
out.extend_from_slice(b">>");
}
pub(crate) fn emit_canonical_pdf<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
out: W,
options: &WriterOptions,
) -> Result<WriterResult> {
let catalog_snapshot = snapshot_catalog_extensions(pdf)?;
let direct_catalog_snapshot = if catalog_snapshot.is_none() {
let root = pdf.root_handle()?;
let extensions = root
.try_as_dictionary()?
.and_then(|entries| entries.get(b"/Extensions".as_slice()).cloned());
Some((root, extensions))
} else {
None
};
let result = emit_canonical_pdf_inner(pdf, out, options);
if let Some(snapshot) = catalog_snapshot {
restore_catalog_extensions(pdf, Some(snapshot))?;
}
if let Some((root, original_extensions)) = direct_catalog_snapshot {
let current_extensions = root
.try_as_dictionary()?
.and_then(|entries| entries.get(b"/Extensions".as_slice()).cloned());
let changed = match (&original_extensions, ¤t_extensions) {
(None, None) => false,
(Some(before), Some(after)) => !before.is_same_object_as(after),
_ => true,
};
if changed {
match original_extensions {
Some(extensions) => root.restore_key_raw(b"/Extensions", extensions)?,
None => root.remove_key(b"/Extensions"),
}
}
}
result
}
fn write_pclm<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
mut out: W,
options: &WriterOptions,
) -> Result<WriterResult> {
let deterministic_id = uses_deterministic_id(options);
let plan = pclm::Plan::build(pdf)?;
let version = effective_pdf_version(pdf.version(), options, false, false);
let mut bytes = Vec::new();
bytes.extend_from_slice(format!("%PDF-{version}\n%PCLm 1.0\n").as_bytes());
bytes.extend_from_slice(options.extra_header_text.as_bytes());
if !options.extra_header_text.is_empty() && !options.extra_header_text.ends_with('\n') {
bytes.push(b'\n');
}
let mut offsets = BTreeMap::<u32, (u16, usize)>::new();
let mut emitted_old_to_new = BTreeMap::<ObjectRef, ObjectRef>::new();
let removed: BTreeSet<_> = pdf.deleted_object_refs().into_iter().collect();
for item in &plan.items {
match *item {
pclm::Item::Source { source, output } => {
let source_handle = pdf.get_object_handle(source);
pdf.resolve(&source_handle)?;
let offset = bytes.len();
bytes.extend_from_slice(format!("{} 0 obj\n", output.number).as_bytes());
let map = |object_ref| {
plan.old_to_new.get(&object_ref).copied().ok_or_else(|| {
crate::Error::Unsupported(format!(
"PCLm reference {object_ref} absent from renumber map"
))
}) };
if source_handle.as_stream_dict().is_some() {
let data = source_handle.get_raw_stream_data()?;
source_handle.write_stream_body_with_ref_map_and_removed_and_length(
&mut bytes,
false,
&map,
&removed,
data.len(),
)?; serialize::write_stream_payload(
&mut bytes,
data.as_ref(),
options.newline_before_endstream,
);
} else {
source_handle
.write_object_with_ref_map_and_removed(&mut bytes, &map, &removed)?;
}
bytes.extend_from_slice(b"\nendobj\n");
offsets.insert(output.number, (0, offset));
emitted_old_to_new.insert(source, output);
}
pclm::Item::Synthetic { output } => {
let payload = b"q /image Do Q\n".to_vec();
let stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(
b"Length".to_vec(),
ObjectHandle::integer(payload.len() as i64),
)]),
Rc::new(payload),
);
let offset = bytes.len();
bytes.extend_from_slice(format!("{} 0 obj\n", output.number).as_bytes());
write_stream_to_buf(&mut bytes, &stream, options.newline_before_endstream)?;
bytes.extend_from_slice(b"\nendobj\n");
offsets.insert(output.number, (0, offset));
}
}
report_progress_event(options)?;
}
let max_object_number = offsets.keys().next_back().copied().unwrap_or(0);
let object_count = usize::try_from(max_object_number)
.ok()
.and_then(|number| number.checked_add(1))
.ok_or_else(|| {
crate::Error::Unsupported("PCLm object count does not fit in usize".to_string())
})?;
let mut written_xref = BTreeMap::<ObjectRef, XrefEntry>::new();
let xref_offset = bytes.len();
bytes.extend_from_slice(format!("xref\n0 {object_count}\n").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());
written_xref.insert(
ObjectRef::new(number as u32, 0),
XrefEntry::Uncompressed {
offset: u64::try_from(*offset).map_err(|_| {
crate::Error::Unsupported("PCLm xref offset does not fit u64".into())
})?,
},
);
}
None => bytes.extend_from_slice(b"0000000000 65535 f \n"), }
}
let late_trailer_refs = RefCell::new(HashMap::<ObjectRef, ObjectRef>::new());
let next_late_trailer_number = Cell::new(u32::try_from(object_count).map_err(|_| {
crate::Error::Unsupported("PCLm trailer object number does not fit in u32".to_string())
})?);
let trailer_map = |object_ref: ObjectRef| {
if let Some(output) = plan.old_to_new.get(&object_ref).copied() {
return Ok(output);
}
if let Some(output) = late_trailer_refs.borrow().get(&object_ref).copied() {
return Ok(output);
}
let output_number = next_late_trailer_number.get();
let next_number = output_number.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported("PCLm trailer object number overflow".to_string())
})?;
let output = ObjectRef::new(output_number, 0);
late_trailer_refs.borrow_mut().insert(object_ref, output);
next_late_trailer_number.set(next_number);
Ok(output)
};
match plan.root {
None => {
let root = plan.direct_root.as_ref().ok_or_else(|| {
crate::Error::Unsupported("PCLm Catalog root is inconsistent".into())
})?; let id_handle = pdf.trailer_key_handle(b"ID");
let source_id0 = source_permanent_id_value_handle(&id_handle);
let generated_id = (!deterministic_id)
.then(|| generate_id_handle(source_id0.as_deref(), options.static_id));
let trailer = build_writer_trailer_handle(
pdf,
object_count,
None,
Some(root),
options,
None,
deterministic_id,
generated_id.as_ref(),
)?; if deterministic_id {
let info_suffix = deterministic_id_info_suffix(pdf);
let mut id_writer = |out: &mut Vec<u8>| {
write_deterministic_id_inline(out, &info_suffix, source_id0.as_deref())
};
trailer.write_trailer_with_ref_map(
&mut bytes,
false,
false,
Some(&mut id_writer),
&trailer_map,
&removed,
true,
)?; } else {
trailer.write_trailer_with_ref_map(
&mut bytes,
false,
false,
None,
&trailer_map,
&removed,
true,
)?; }
}
Some(root) => {
let id_handle = pdf.trailer_key_handle(b"ID");
let source_id0 = source_permanent_id_value_handle(&id_handle);
let generated_id = (!deterministic_id)
.then(|| generate_id_handle(source_id0.as_deref(), options.static_id));
let trailer = build_writer_trailer_handle(
pdf,
object_count,
Some(root),
None,
options,
None,
deterministic_id,
generated_id.as_ref(),
)?; if deterministic_id {
let info_suffix = deterministic_id_info_suffix(pdf);
let mut id_writer = |out: &mut Vec<u8>| {
write_deterministic_id_inline(out, &info_suffix, source_id0.as_deref())
};
trailer.write_trailer_with_ref_map(
&mut bytes,
false,
false,
Some(&mut id_writer),
&trailer_map,
&removed,
true,
)?; } else {
trailer.write_trailer_with_ref_map(
&mut bytes,
false,
false,
None,
&trailer_map,
&removed,
true,
)?; }
}
}
bytes.extend_from_slice(format!("\nstartxref\n{xref_offset}\n%%EOF\n").as_bytes());
out.write_all(&bytes)?;
Ok(WriterResult::new(emitted_old_to_new, written_xref))
}
fn emit_canonical_pdf_inner<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
mut out: W,
options: &WriterOptions,
) -> Result<WriterResult> {
let deterministic_id = uses_deterministic_id(options);
let encrypting = options.encrypt.is_some() || options.copy_encryption.is_some();
let requested_object_streams = options.object_streams;
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 = WriterOptions {
object_streams: ObjectStreamMode::Disable,
..options.clone()
};
&suppressed_options
} else {
options
};
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 source_ver = pdf.version().to_string();
let source_ext = pdf.adobe_extension_level()?.unwrap_or(0);
let will_emit_objstm = 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 catalog_has_extensions_adbe(pdf)? {
strip_adbe_extension(pdf, eff_ver, eff_ext)?;
}
}
if options.pclm {
return write_pclm(pdf, out, options);
}
if plain::eligible(pdf.is_encrypted(), options, requested_object_streams) {
return plain::write_plain(pdf, out, options);
}
let root_ref = pdf.root_ref();
let root_handle = if root_ref.is_none() {
let root_candidate = pdf.trailer_key_handle(b"Root");
if root_candidate.is_null() {
return Err(crate::Error::Missing("/Root"));
}
Some(pdf.root_handle()?)
} else {
None
};
use crate::writer::rewrite_renumber::CanonicalCatalogFirstRenumber;
let suppress_null_values = true;
let removed_refs: BTreeSet<ObjectRef> = pdf.deleted_object_refs().into_iter().collect();
let qdf_page_refs = if options.qdf
|| options.content_normalization
|| options.decode_level != DecodeLevel::None
{
Some(crate::PageDocumentHelper::new(pdf).get_all_pages()?)
} else {
None
};
let normalized_stream_refs: BTreeSet<ObjectRef> = if options.content_normalization {
let mut refs = BTreeSet::new();
let page_refs = qdf_page_refs
.as_ref()
.expect("content normalization prepares page references");
for page_ref in page_refs {
refs.extend(collect_content_stream_refs(pdf, *page_ref)?);
}
refs
} else {
BTreeSet::new()
};
let cached_stream_outputs: RefCell<BTreeMap<ObjectRef, plain::plan::CachedStreamOutput>> =
RefCell::new(BTreeMap::new());
let stream_parameters_removed = |handle: &ObjectHandle| {
if let Some(source) = handle.object_ref() {
if let Some(parameters_removed) = cached_stream_outputs
.borrow()
.get(&source)
.map(|cached| cached.parameters_removed)
{
return Ok(parameters_removed); }
let (dict, data, refiltered, parameters_removed) =
plain::body::canonical_stream_output_for_rewrite_with_status(
handle,
options,
normalized_stream_refs.contains(&source),
)?; cached_stream_outputs.borrow_mut().insert(
source,
plain::plan::CachedStreamOutput {
dict,
data,
refiltered,
parameters_removed,
fingerprint: plain::plan::stream_cache_fingerprint(handle)?,
},
);
return Ok(parameters_removed);
}
plain::body::canonical_stream_will_be_refiltered(handle, options)
};
let renumber = CanonicalCatalogFirstRenumber::build_qpdf_with_stream_policy(
pdf,
true,
options.preserve_unreferenced_objects,
&removed_refs,
Some(&stream_parameters_removed),
)?;
let mut version = effective_pdf_version(pdf.version(), options, false, false).to_owned();
let (det_id_source_id0, det_id_info_suffix): (Option<Vec<u8>>, Vec<u8>) = if deterministic_id {
let id_handle = pdf.trailer_key_handle(b"ID");
let id0 = source_permanent_id_value_handle(&id_handle);
let suffix = deterministic_id_info_suffix(pdf);
(id0, suffix)
} else {
(None, Vec::new())
};
let planner_options;
let copy_generate = options.copy_encryption.is_some()
&& options.object_streams == ObjectStreamMode::Generate
&& !options.qdf;
let planner_config = if options.copy_encryption.is_some() && !copy_generate {
planner_options = WriterOptions {
object_streams: ObjectStreamMode::Disable,
..options.clone()
};
object_streams::planner_config_from_options(&planner_options)
} else {
object_streams::planner_config_from_options(options)
};
let generated_reachable = if options.preserve_unreferenced_objects
&& planner_config.mode == ObjectStreamMode::Generate
{
Some(
object_streams::compressible_objgens_qpdf_plan(pdf)?
.eligible
.into_iter()
.collect::<BTreeSet<_>>(),
)
} else {
None
};
let mut plan = object_streams::plan_object_streams_with_reachability(
pdf,
&planner_config,
generated_reachable.as_ref(),
)?;
for batch in &mut plan.batches {
batch.retain(|member| renumber.new_for_original(*member).is_some());
}
plan.batches.retain(|batch| !batch.is_empty());
object_streams::filter_objstm_batches_for_output(pdf, &mut plan.batches, false, encrypting)?;
let qpdf_generate_standard = !options.qdf
&& options.object_streams == ObjectStreamMode::Generate
&& !plan.batches.is_empty();
let mut qpdf_generate_removed_refs = removed_refs.clone();
if qpdf_generate_standard {
qpdf_generate_removed_refs.extend(plan.removed_refs.iter().copied());
}
let source_xref_entries = pdf.source_xref_entries();
let source_container_for_batch: Vec<Option<ObjectRef>> =
if options.object_streams == ObjectStreamMode::Preserve {
plan.batches
.iter()
.map(|batch| source_objstm_container_for_batch(batch, &source_xref_entries))
.collect()
} else {
vec![None; plan.batches.len()]
};
let qpdf_preserve_source_objstm =
options.object_streams == ObjectStreamMode::Preserve && !plan.batches.is_empty();
let mut effective_xref_form = if plan.batches.is_empty() {
pdf.last_xref_form()
} else {
XrefForm::Stream
};
if options.qdf && plan.batches.is_empty() {
effective_xref_form = XrefForm::Table;
}
if options.copy_encryption.is_some() && !copy_generate {
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_qpdf_writer_version(&version)
.is_none_or(|current| current < QpdfVersionParts::new(1, 5))
{
version = "1.5".to_string();
}
if let Some(params) = options.encrypt.as_ref() {
use crate::encryption::EncryptMethod;
let floor = match params.method {
EncryptMethod::V1Rc440 => PdfVersion::new(1, 3, 0),
EncryptMethod::V2Rc4128 => PdfVersion::new(1, 4, 0),
EncryptMethod::V4Aes128 => PdfVersion::new(1, 6, 0),
EncryptMethod::V4Rc4128 => PDF_1_5,
EncryptMethod::V5R6Aes256 | EncryptMethod::V5R5Aes256 => PdfVersion::new(1, 7, 0),
};
let floor_parts = QpdfVersionParts::new(i32::from(floor.major()), i32::from(floor.minor()));
if parse_qpdf_writer_version(&version).is_none_or(|current| current < floor_parts) {
version = floor.get_version().0;
}
}
if (options.qdf || qpdf_generate_standard || qpdf_preserve_source_objstm)
&& !plan.batches.is_empty()
{
for batch in &mut plan.batches {
batch.sort_unstable_by_key(|member| (member.number, member.generation));
}
}
use crate::writer::object_streams::ObjectStreamGroup;
use crate::writer::rewrite_renumber::{NewNumberLookup, ObjectStreamRenumber};
let object_stream_groups = if qpdf_preserve_source_objstm {
plan.batches
.iter()
.enumerate()
.map(|(batch_index, members)| {
let source = source_container_for_batch
.get(batch_index)
.copied()
.flatten()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"source-backed Preserve ObjStm batch {batch_index} has no source container"
))
})?; Ok(ObjectStreamGroup::SourceBacked {
source,
members: members.clone(),
})
})
.collect::<Result<Vec<_>>>()?
} else {
plan.batches
.iter()
.cloned()
.map(|members| ObjectStreamGroup::Synthetic { members })
.collect::<Vec<_>>()
};
let object_stream_renumber = if (options.qdf && !plan.batches.is_empty())
|| qpdf_generate_standard
|| qpdf_preserve_source_objstm
{
let numbering_removed_refs = if qpdf_generate_standard {
&qpdf_generate_removed_refs
} else {
&removed_refs
};
Some(ObjectStreamRenumber::build_with_stream_policy(
pdf,
&object_stream_groups,
true,
numbering_removed_refs,
options.preserve_unreferenced_objects,
Some(&stream_parameters_removed),
)?) } else {
None
};
let renumbered: Vec<(ObjectRef, ObjectRef)> =
if let Some(object_stream_renumber) = object_stream_renumber.as_ref() {
let mut pairs = object_stream_renumber.pairs().collect::<Vec<_>>();
pairs.sort_unstable_by_key(|(new_ref, _)| (new_ref.number, new_ref.generation));
pairs
} else {
renumber.pairs().collect()
};
let renumber_lookup: &dyn NewNumberLookup = object_stream_renumber
.as_ref()
.map(|renumber| renumber as &dyn NewNumberLookup)
.unwrap_or(&renumber);
let new_root = root_ref.and_then(|root_ref| renumber_lookup.new_for_original(root_ref));
if root_ref.is_some() && new_root.is_none() {
return Err(crate::Error::Unsupported(
"renumber: /Root absent from map".to_string(),
));
}
let existing_max: u32 = u32::try_from(renumber.len()).map_err(|_| {
crate::Error::Unsupported("full-rewrite: renumbered object count overflows u32".to_string())
})?;
let mut container_refs: Vec<ObjectRef> = if options.qdf {
if plan.batches.is_empty() {
Vec::new()
} else {
vec![ObjectRef::new(0, 0); plan.batches.len()]
}
} else if qpdf_generate_standard || qpdf_preserve_source_objstm {
let refs = (0..plan.batches.len())
.map(|group_index| {
object_stream_renumber
.as_ref()
.and_then(|renumber| renumber.container_number(group_index))
.map(|number| ObjectRef::new(number, 0))
})
.collect::<Option<Vec<_>>>();
refs.ok_or_else(|| {
crate::Error::Internal(
"generated ObjStm group was not assigned a container number".to_string(),
)
})? } else {
(1..=plan.batches.len())
.map(|i| {
let number = existing_max.checked_add(i as u32)?;
Some(ObjectRef::new(number, 0))
})
.collect::<Option<Vec<_>>>()
.ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: ObjStm container number overflows u32".to_string(),
)
})? };
let compact_body_max = renumbered
.iter()
.map(|(new_ref, _)| new_ref.number)
.chain(container_refs.iter().map(|container| container.number))
.max()
.unwrap_or(0);
let mut member_batch_index = BTreeMap::<ObjectRef, usize>::new();
for (batch_idx, batch) in plan.batches.iter().enumerate() {
for &member_ref in batch {
member_batch_index.insert(member_ref, batch_idx);
}
}
let source_container_to_batch: HashMap<ObjectRef, usize> = source_container_for_batch
.iter()
.enumerate()
.filter_map(|(batch_idx, source)| source.map(|source| (source, batch_idx)))
.collect();
let metadata_ref = if options
.encrypt
.as_ref()
.is_some_and(|p| !p.encrypt_metadata)
|| options
.copy_encryption
.as_ref()
.is_some_and(|source| !copy_encryption_encrypts_metadata(source))
{
resolve_metadata_stream_ref(pdf)?
} else {
None
};
let skip_refs = if qpdf_generate_standard {
&qpdf_generate_removed_refs
} else {
&removed_refs
};
let skip_ref_set: BTreeSet<ObjectRef> = skip_refs.iter().copied().collect();
let mut qdf_emission_renumber: HashMap<ObjectRef, ObjectRef> = HashMap::new();
let mut qdf_holder_map: HashMap<u32, u32> = HashMap::new();
let mut qdf_max_emission: u32 = 0;
if options.qdf {
let mut next_emission = 0_u32;
let mut assigned_batches = vec![false; plan.batches.len()];
for (cf_ref, old_ref) in &renumbered {
if old_ref.number == 0 || skip_refs.contains(old_ref) {
continue; }
let batch_idx = source_container_to_batch
.get(old_ref)
.or_else(|| member_batch_index.get(old_ref))
.copied();
if let Some(batch_idx) = batch_idx {
if !assigned_batches[batch_idx] {
next_emission = next_emission.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: QDF emission number overflows u32".to_string(),
)
})?; container_refs[batch_idx] = ObjectRef::new(next_emission, 0);
assigned_batches[batch_idx] = true;
if let Some(source) = source_container_for_batch[batch_idx] {
qdf_emission_renumber.insert(source, container_refs[batch_idx]);
}
for member in &plan.batches[batch_idx] {
next_emission = next_emission.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: QDF emission number overflows u32".to_string(),
)
})?; qdf_emission_renumber.insert(*member, ObjectRef::new(next_emission, 0));
}
}
continue;
}
let object_handle = pdf.get_object_handle(*old_ref);
pdf.resolve(&object_handle)?;
let is_real_stream = if object_handle.as_stream_dict().is_some() {
let is_structural = object_handle.try_is_stream_of_type(b"XRef", b"")?;
if is_structural {
None } else {
Some(true)
}
} else {
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);
}
}
qdf_max_emission = next_emission;
}
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));
}
}
for (&member_ref, &(container_num, index)) in &member_to_batch {
let member_number = if options.qdf {
qdf_emission_renumber
.get(&member_ref)
.ok_or_else(|| {
crate::Error::Unsupported(
"QDF ObjStm member absent from emission map".to_string(),
)
})?
.number
} else {
renumber_lookup
.new_for_original(member_ref)
.ok_or_else(|| {
crate::Error::Unsupported("ObjStm member absent from renumber map".to_string())
})?
.number
};
member_new_to_batch.insert(member_number, (container_num, index));
}
let generated_id = if deterministic_id {
if encrypting {
return Err(generate_id_without_data());
}
None
} else if options.copy_encryption.is_some() {
None
} else {
let id_handle = pdf.trailer_key_handle(b"ID");
let source_id0 = source_permanent_id_value_handle(&id_handle);
Some(generate_id_handle(source_id0.as_deref(), options.static_id))
};
let encrypt_ctx: Option<EncryptionContext> = if let Some(ref params) = options.encrypt {
let base_for_encrypt = if options.qdf {
qdf_max_emission
} else {
compact_body_max
};
let id0 = generated_id
.as_ref()
.and_then(ObjectHandle::as_array)
.and_then(|values| values.first().and_then(ObjectHandle::as_string))
.ok_or_else(|| {
crate::Error::Unsupported(
"full-rewrite: ordinary/static ID generator returned an invalid /ID array"
.to_string(),
)
})?; let context =
build_encryption_context(options, params, base_for_encrypt, metadata_ref, &id0);
Some(context?)
} else if let Some(ref src) = options.copy_encryption {
let base_for_encrypt = if options.qdf {
qdf_max_emission
} else {
compact_body_max
};
Some(build_copy_encryption_context(
src,
options,
base_for_encrypt,
metadata_ref,
)?)
} else {
None
};
let mut encrypted_strings = encrypt_ctx
.as_ref()
.map(encrypted_strings::EncryptedStringEmitter::from_context);
let (page_seq, contents_seq, content_container_refs): (
HashMap<ObjectRef, u32>,
HashMap<ObjectRef, u32>,
BTreeSet<ObjectRef>,
) = if options.qdf || options.content_normalization {
let mut page_seq: HashMap<ObjectRef, u32> = HashMap::new();
let mut contents_seq: HashMap<ObjectRef, u32> = HashMap::new();
let mut content_container_refs = BTreeSet::new();
let page_refs = qdf_page_refs
.as_ref()
.expect("qdf_page_refs is Some whenever options.qdf || options.content_normalization");
for (idx, page_ref) in page_refs.iter().enumerate() {
let seq = (idx as u32).saturating_add(1);
if options.qdf {
page_seq.insert(*page_ref, seq);
}
for content_ref in collect_content_stream_refs(pdf, *page_ref)? {
contents_seq.insert(content_ref, seq);
}
collect_content_container_refs(pdf, *page_ref, &mut content_container_refs)?;
}
(page_seq, contents_seq, content_container_refs)
} else {
(HashMap::new(), HashMap::new(), BTreeSet::new())
};
let new_root = if let Some(root_ref) = root_ref {
if options.qdf {
Some(
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
}
} else {
None
};
let mut bytes = Vec::new();
bytes.extend_from_slice(format!("%PDF-{version}\n").as_bytes());
if options.pclm {
bytes.extend_from_slice(b"%PCLm 1.0\n"); } else {
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");
}
bytes.extend_from_slice(options.extra_header_text.as_bytes());
let mut offsets = BTreeMap::<u32, (u16, usize)>::new();
let mut emitted_old_to_new = BTreeMap::<ObjectRef, ObjectRef>::new();
let qdf_body_start = bytes.len();
let merge_objstm_chunks = (options.qdf && !plan.batches.is_empty())
|| qpdf_generate_standard
|| qpdf_preserve_source_objstm;
let mut qdf_main_chunks = BTreeMap::<ObjectRef, (usize, usize)>::new();
let mut qdf_container_chunks = BTreeMap::<usize, (usize, usize)>::new();
for (new_ref, old_ref) in &renumbered {
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 object_handle = pdf.get_object_handle(*old_ref);
pdf.resolve(&object_handle)?;
let is_stream = object_handle.as_stream_dict().is_some();
let content_container = content_container_refs.contains(old_ref);
let is_rebuilt_objstm = qpdf_preserve_source_objstm
&& source_container_to_batch.contains_key(old_ref)
&& object_handle.try_is_stream_of_type(b"ObjStm", b"")?;
if is_stream && (object_handle.try_is_stream_of_type(b"XRef", b"")? || is_rebuilt_objstm) {
continue; }
if offsets.contains_key(&emit_ref.number) {
return Err(crate::Error::Unsupported(format!(
"duplicate object number {} in xref table",
emit_ref.number
)));
}
let qdf_chunk_start = bytes.len();
if options.qdf {
if let Some(&seq) = page_seq.get(old_ref) {
bytes.extend_from_slice(format!("%% Page {seq}\n").as_bytes());
}
if let Some(&seq) = contents_seq.get(old_ref) {
bytes.extend_from_slice(format!("%% Contents for page {seq}\n").as_bytes());
}
}
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, bool)> = None;
let map = |object_ref: ObjectRef| {
if options.qdf {
qdf_emission_renumber
.get(&object_ref)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"full-rewrite: QDF reference {object_ref} absent from emission map"
))
}) } else {
renumber_lookup.new_for_original(object_ref).ok_or_else(|| {
crate::Error::Unsupported(format!(
"full-rewrite: reference {object_ref} absent from renumber map"
))
}) }
};
let removed_refs: BTreeSet<ObjectRef> = skip_refs.iter().copied().collect();
if content_container {
if let Some(emitter) = encrypted_strings.as_mut() {
emitter.write_handle_content_container_with_ref_map(
&mut bytes,
emit_ref,
None,
&object_handle,
options,
&map,
&removed_refs,
)?; } else {
plain::body::emit_content_container_from_handle_with_ref_map(
&object_handle,
options,
&mut bytes,
&map,
&removed_refs,
)?; }
} else if is_stream {
let cached = cached_stream_outputs
.borrow_mut()
.remove(old_ref)
.map(|cached| (cached.dict, cached.data, cached.refiltered));
let (stream_dict, stream_data, refiltered) = if let Some(cached) = cached {
cached
} else {
plain::body::canonical_stream_output_for_rewrite(
&object_handle,
options,
options.content_normalization && contents_seq.contains_key(old_ref),
)? };
let stream_encryption = encrypt_ctx
.as_ref()
.filter(|ctx| emit_ref != ctx.encrypt_ref);
let encrypt_stream = stream_encryption
.is_some_and(|ctx| ctx.encrypt_metadata || ctx.metadata_ref != Some(*old_ref));
let stream_dict = stream_dict;
let mut stream_length = stream_data.len();
if let Some(ctx) = stream_encryption {
adjust_aes_stream_length(&mut stream_length, ctx, encrypt_stream)?;
}
stream_dict.replace_key(
b"/Length",
ObjectHandle::integer(i64::try_from(stream_length).map_err(|_| {
crate::Error::Unsupported("stream /Length does not fit in i64".to_string())
})?), )?;
let holder_ref = if options.qdf {
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
))
})?; Some(ObjectRef::new(holder_num, 0))
} else {
None
};
let stream_options =
encrypted_strings::StreamDictOptions::new(options.qdf, refiltered, encrypt_stream);
if let Some(emitter) = encrypted_strings.as_mut() {
emitter.write_handle_stream_dict_with_ref_map(
&mut bytes,
emit_ref,
None,
&stream_dict,
stream_options,
&map,
&removed_refs,
holder_ref,
)?; } else if options.qdf {
stream_dict.write_stream_body_qdf_with_ref_map_and_removed_and_length(
&mut bytes,
0,
&map,
&removed_refs,
holder_ref,
)?; } else {
stream_dict.write_stream_body_with_ref_map_and_removed(
&mut bytes,
refiltered,
&map,
&removed_refs,
)?; }
let added_newline = if let Some(ctx) = stream_encryption {
write_stream_payload_with_pipeline_qdf(
&mut bytes,
&stream_data,
options.newline_before_endstream,
options.qdf,
emit_ref,
ctx,
encrypt_stream,
None,
)? } else {
serialize::write_stream_payload_with_qdf(
&mut bytes,
&stream_data,
options.newline_before_endstream,
options.qdf,
);
serialize::framing_adds_newline_with_qdf(
&stream_data,
options.newline_before_endstream,
options.qdf,
)
};
if let Some(holder_ref) = holder_ref {
qdf_holder_to_emit = Some((
holder_ref.number,
i64::try_from(stream_length).unwrap_or(i64::MAX),
added_newline,
));
}
} else {
if let Some(emitter) = encrypted_strings.as_mut() {
emitter.write_handle_object_with_ref_map(
&mut bytes,
emit_ref,
None,
&object_handle,
options.qdf,
&map,
&removed_refs,
)?; } else if options.qdf {
object_handle.write_object_qdf_with_ref_map_and_removed(
&mut bytes,
0,
&map,
&removed_refs,
)?; } else {
object_handle.write_object_with_ref_map_and_removed(
&mut bytes,
&map,
&removed_refs,
)?; }
}
bytes.extend_from_slice(b"\nendobj\n");
if options.qdf {
bytes.push(b'\n');
}
offsets.insert(emit_ref.number, (emit_ref.generation, emit_offset));
emitted_old_to_new.insert(*old_ref, ObjectRef::new(emit_ref.number, 0));
report_progress_event(options)?;
if let Some((hnum, hlen, ignore_newline)) = qdf_holder_to_emit {
if ignore_newline {
bytes.extend_from_slice(b"%QDF: ignore_newline\n");
}
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));
}
if merge_objstm_chunks {
qdf_main_chunks.insert(*old_ref, (qdf_chunk_start, bytes.len()));
}
}
for (batch_idx, batch) in plan.batches.iter().enumerate() {
let container_ref = container_refs[batch_idx];
let mut handles = Vec::with_capacity(batch.len());
for &old in batch {
let handle = pdf.get_object_handle(old);
pdf.resolve(&handle)?;
let new = if options.qdf {
qdf_emission_renumber
.get(&old)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(
"QDF ObjStm member absent from emission map".to_string(),
)
})?
} else {
renumber_lookup
.new_for_original(old)
.ok_or_else(|| {
crate::Error::Unsupported(
"ObjStm member absent from renumber map".to_string(),
)
})?
};
emitted_old_to_new.insert(old, ObjectRef::new(new.number, 0));
handles.push((new, handle));
}
let removed_refs: BTreeSet<ObjectRef> = skip_refs.iter().copied().collect();
let map = |object_ref: ObjectRef| {
if options.qdf {
qdf_emission_renumber
.get(&object_ref)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"full-rewrite: QDF ObjStm reference {object_ref} absent from emission map"
))
})
} else {
renumber_lookup.new_for_original(object_ref).ok_or_else(|| {
crate::Error::Unsupported(format!(
"full-rewrite: ObjStm reference {object_ref} absent from renumber map"
))
}) }
};
let mut qdf_first_member_body_offset = None;
let mut qdf_marker_starts = Vec::new();
let mut qdf_marker_lengths = Vec::new();
let emit_objstm_body = if options.qdf {
object_streams::emit_objstm_body_from_handles_with_writer_qdf
} else {
object_streams::emit_objstm_body_from_handles_with_writer
};
let mut body = emit_objstm_body(&handles, &mut |out, member_index, member_ref, handle| {
if options.qdf {
let marker_start = out.len();
out.extend_from_slice(
format!(
"%% Object stream: object {}, index {}",
member_ref.number, member_index
)
.as_bytes(),
);
if !options.no_original_object_ids {
if let Some(original) = handle.object_ref() {
out.extend_from_slice(
format!("; original object ID: {}", original.number).as_bytes(),
);
if original.generation != 0 {
out.extend_from_slice(format!(" {}", original.generation).as_bytes());
}
} }
out.push(b'\n');
qdf_first_member_body_offset.get_or_insert(out.len());
qdf_marker_starts.push(marker_start);
qdf_marker_lengths.push(out.len() - marker_start);
}
let result = if options.qdf {
if let Some(original) = handle.object_ref() {
if let Some(&seq) = page_seq.get(&original) {
out.extend_from_slice(format!("%% Page {seq}\n").as_bytes());
}
} handle.write_object_qdf_with_ref_map_and_removed(out, 0, &map, &removed_refs)
} else {
handle.write_object_with_ref_map_and_removed(out, &map, &removed_refs)
}; if result.is_ok() {
report_progress_event(options)?;
} result
})?; if options.qdf {
let first_marker_len = qdf_marker_lengths.first().copied().ok_or_else(|| {
crate::Error::Internal("QDF ObjStm marker lengths are empty".to_string())
})?; let objects_section = body.bytes.split_off(body.first_offset);
let mut pair_table = Vec::new();
for (index, ((new_ref, _), (&marker_start, &marker_len))) in handles
.iter()
.zip(qdf_marker_starts.iter().zip(qdf_marker_lengths.iter()))
.enumerate()
{
if index != 0 {
pair_table.push(b'\n');
}
let offset = marker_start
.checked_add(marker_len)
.and_then(|end| end.checked_sub(first_marker_len))
.ok_or_else(|| {
crate::Error::Unsupported(
"QDF ObjStm member offset overflows usize".to_string(),
)
})?; let _ = write!(pair_table, "{} {}", new_ref.number, offset);
}
pair_table.push(b'\n');
body.first_offset = pair_table.len();
pair_table.extend_from_slice(&objects_section);
body.bytes = pair_table;
}
let objstm_compression = if options.qdf {
CompressStreams::No
} else {
options.compress_streams
};
let extends = if let Some(source_container) = source_container_for_batch[batch_idx] {
let source_handle = pdf.get_object_handle(source_container);
pdf.resolve(&source_handle)?;
let extends = source_handle
.as_stream_dict()
.map(|dict| dict.try_get_key(b"/Extends"))
.transpose()?
.and_then(|handle| handle.object_ref());
extends.map(|extends| {
remap_source_objstm_extends(
extends,
&source_container_to_batch,
&container_refs,
options.qdf,
&qdf_emission_renumber,
renumber_lookup, )
})
} else {
None
}
.flatten();
let (stream_handle, stream_data) =
object_streams::wrap_objstm_body_as_handle(&body, objstm_compression, extends)?;
let objstm_first = if options.qdf {
body.first_offset
.checked_add(qdf_first_member_body_offset.unwrap_or(0))
.ok_or_else(|| {
crate::Error::Unsupported("QDF ObjStm /First overflows usize".to_string())
})?
} else {
body.first_offset
};
let stream_dict = stream_handle.as_stream_dict().ok_or_else(|| {
crate::Error::Internal("ObjStm handle lost its stream dictionary".to_string())
})?; let mut stream_length = stream_data.len();
if let Some(ctx) = &encrypt_ctx {
adjust_aes_stream_length(&mut stream_length, ctx, true)?;
}
stream_dict.replace_key(
b"/Length",
ObjectHandle::integer(i64::try_from(stream_length).map_err(|_| {
crate::Error::Unsupported(
"encrypted ObjStm /Length does not fit in i64".to_string(),
)
})?), )?;
let emit_offset = bytes.len();
bytes.extend_from_slice(format!("{} 0 obj\n", container_ref.number).as_bytes());
if let Some(ctx) = &encrypt_ctx {
if options.qdf {
write_qdf_objstm_dictionary(
&mut bytes,
stream_length,
body.n_members,
objstm_first,
extends,
);
} else {
write_objstm_dictionary(
&mut bytes,
stream_length,
matches!(objstm_compression, CompressStreams::Yes),
body.n_members,
objstm_first,
extends,
);
}
write_stream_payload_with_pipeline(
&mut bytes,
&stream_data,
options.newline_before_endstream,
container_ref,
ctx,
true,
None,
)?; } else if options.qdf {
write_qdf_objstm_dictionary(
&mut bytes,
stream_length,
body.n_members,
objstm_first,
extends,
);
serialize::write_stream_payload_with_qdf(
&mut bytes,
&stream_data,
options.newline_before_endstream,
true,
);
} else {
write_objstm_dictionary(
&mut bytes,
stream_length,
matches!(objstm_compression, CompressStreams::Yes),
body.n_members,
objstm_first,
extends,
);
serialize::write_stream_payload(
&mut bytes,
&stream_data,
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 merge_objstm_chunks {
qdf_container_chunks.insert(batch_idx, (emit_offset, bytes.len()));
}
}
if merge_objstm_chunks {
let original_bytes = bytes.clone();
let mut merged_body = Vec::new();
let mut chunk_transforms = Vec::<(usize, usize, usize)>::new();
let mut appended_batches = BTreeSet::new();
let mut append_chunk = |old_start: usize, old_end: usize| {
let new_start = qdf_body_start + merged_body.len();
merged_body.extend_from_slice(&original_bytes[old_start..old_end]);
chunk_transforms.push((old_start, old_end, new_start));
};
for (_, old_ref) in &renumbered {
let batch_idx = source_container_to_batch
.get(old_ref)
.or_else(|| member_batch_index.get(old_ref))
.copied();
if let Some(batch_idx) = batch_idx {
if appended_batches.insert(batch_idx) {
if let Some(&(start, end)) = qdf_container_chunks.get(&batch_idx) {
append_chunk(start, end);
}
}
} else if let Some(&(start, end)) = qdf_main_chunks.get(old_ref) {
append_chunk(start, end);
}
}
for batch_idx in 0..plan.batches.len() {
if appended_batches.insert(batch_idx) {
let &(start, end) = qdf_container_chunks.get(&batch_idx).ok_or_else(|| {
crate::Error::Internal(
"QDF ObjStm container chunk missing during merge".to_string(),
)
})?;
append_chunk(start, end);
}
}
bytes.truncate(qdf_body_start);
bytes.extend_from_slice(&merged_body);
for (_, offset) in offsets.values_mut() {
let old_offset = *offset;
let Some(&(old_start, _, new_start)) = chunk_transforms
.iter()
.find(|(start, end, _)| old_offset >= *start && old_offset < *end)
else {
return Err(crate::Error::Internal(
"ObjStm body offset missing during merge".to_string(),
));
};
*offset = new_start + (old_offset - old_start);
}
}
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());
let encrypt_handle = ctx.encrypt_dict_handle();
encrypted_strings::write_encryption_dictionary_handle(&mut bytes, &encrypt_handle)?;
bytes.extend_from_slice(b"\nendobj\n");
if options.qdf {
bytes.push(b'\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())
})?;
let mut written_xref = BTreeMap::<ObjectRef, XrefEntry>::new();
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"),
}
}
for number in 1..object_count {
let object_number = number as u32;
if let Some(&(_generation, offset)) = offsets.get(&object_number) {
written_xref.insert(
ObjectRef::new(object_number, 0),
XrefEntry::Uncompressed {
offset: u64::try_from(offset).map_err(|_| {
crate::Error::Unsupported(
"xref offset does not fit u64".to_string(),
)
})?,
},
);
} }
let trailer = build_writer_trailer_handle(
pdf,
object_count,
new_root,
root_handle.as_ref(),
options,
encrypt_ctx.as_ref(),
deterministic_id,
generated_id.as_ref(),
)?; let trailer_map = |object_ref: ObjectRef| {
if options.qdf {
qdf_emission_renumber
.get(&object_ref)
.copied()
.ok_or_else(|| {
crate::Error::Unsupported(format!(
"full-rewrite: QDF trailer reference {object_ref} absent from emission map"
))
}) } else {
renumber_lookup.new_for_original(object_ref).ok_or_else(|| {
crate::Error::Unsupported(format!(
"full-rewrite: trailer reference {object_ref} absent from renumber map"
))
}) }
};
if options.qdf {
if 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_trailer_with_ref_map(
&mut bytes,
false,
true,
Some(&mut id_writer),
&trailer_map,
&skip_ref_set,
suppress_null_values,
)?;
} else {
trailer.write_trailer_with_ref_map(
&mut bytes,
false,
true,
None,
&trailer_map,
&skip_ref_set,
suppress_null_values,
)?;
}
bytes.extend_from_slice(format!("startxref\n{xref_offset}\n%%EOF\n").as_bytes());
} else {
if 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_trailer_with_ref_map(
&mut bytes,
false,
false,
Some(&mut id_writer),
&trailer_map,
&skip_ref_set,
suppress_null_values,
)?;
} else {
trailer.write_trailer_with_ref_map(
&mut bytes,
false,
false,
None,
&trailer_map,
&skip_ref_set,
suppress_null_values,
)?;
}
bytes.extend_from_slice(format!("\nstartxref\n{xref_offset}\n%%EOF\n").as_bytes());
}
}
XrefForm::Stream => {
let xref_size = object_count.checked_add(1).ok_or_else(|| {
crate::Error::Unsupported("full-rewrite: xref-stream /Size overflows usize".into())
})?;
let old_to_new: HashMap<ObjectRef, ObjectRef> = if options.qdf {
qdf_emission_renumber.clone()
} else {
renumbered
.iter()
.map(|(new_ref, old_ref)| (*old_ref, *new_ref))
.collect()
};
let layout = plain::xref::BodyLayout {
uncompressed: offsets.clone(),
compressed: member_new_to_batch
.iter()
.map(|(&number, &(container, index))| {
(number, plain::xref::CompressedLocation { container, index })
})
.collect(),
};
let trailer_handle = build_writer_trailer_handle(
pdf,
xref_size,
new_root,
root_handle.as_ref(),
options,
encrypt_ctx.as_ref(),
deterministic_id,
generated_id.as_ref(),
)?; let id = if deterministic_id {
plain::xref::IdPlan::Deterministic {
source_id0: det_id_source_id0.clone(),
info_suffix: det_id_info_suffix.clone(),
}
} else {
plain::xref::IdPlan::Materialized {
value: plain::xref::materialized_id_handle(
&trailer_handle.try_get_key(b"/ID")?,
)?, }
};
let trailer_map = |object_ref: ObjectRef| {
old_to_new.get(&object_ref).copied().ok_or_else(|| {
crate::Error::Unsupported(format!(
"full-rewrite: direct /Root reference {object_ref} absent from renumber map"
))
}) };
let direct_root = if new_root.is_none() {
let root = trailer_handle.try_get_key(b"/Root")?;
let mut direct_root = Vec::new();
if options.qdf {
root.write_object_qdf_with_ref_map_and_removed(
&mut direct_root,
0,
&trailer_map,
&skip_ref_set,
)?; } else {
root.write_object_with_ref_map_and_removed(
&mut direct_root,
&trailer_map,
&skip_ref_set,
)?; }
Some(direct_root)
} else {
None
};
let trailer = plain::xref::TrailerPlan {
form: XrefForm::Stream,
canonical_entries: plain::plan::canonical_trailer_entries_with_visibility(
pdf,
&old_to_new,
&skip_ref_set,
suppress_null_values,
)?, root: new_root,
direct_root,
id,
encrypt: encrypt_ctx.as_ref().map(|ctx| ctx.encrypt_ref),
structural_filtered: !options.qdf
&& matches!(options.compress_streams, CompressStreams::Yes),
qdf: options.qdf,
};
written_xref = plain::xref::append_xref_and_trailer(&mut bytes, &layout, &trailer)?;
}
}
out.write_all(&bytes)?;
Ok(WriterResult::new(emitted_old_to_new, written_xref))
}
fn collect_content_container_refs<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
containers: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
let page_handle = pdf.get_object_handle(page_ref);
pdf.resolve(&page_handle)?;
let contents = page_handle.try_get_key(b"/Contents")?;
if contents.type_code()? == 10 {
if contents.object_ref().is_none() {
containers.insert(page_ref);
}
return Ok(());
}
if contents.try_as_array()?.is_none() {
return Ok(());
}
containers.insert(contents.object_ref().unwrap_or(page_ref));
Ok(())
}
pub(crate) fn collect_content_stream_refs<R: Read + Seek>(
pdf: &mut Pdf<R>,
page_ref: ObjectRef,
) -> Result<Vec<ObjectRef>> {
let page_handle = pdf.get_object_handle(page_ref);
pdf.resolve(&page_handle)?;
let contents = page_handle.try_get_key(b"/Contents")?;
if contents.type_code()? == 10 {
return Ok(contents.object_ref().into_iter().collect());
}
let Some(items) = contents.try_as_array()? else {
return Ok(Vec::new());
};
let mut refs = Vec::with_capacity(items.len());
for item in items {
if item.type_code()? == 10 {
if let Some(object_ref) = item.object_ref() {
refs.push(object_ref);
}
}
}
Ok(refs)
}
#[cfg(test)]
mod final_handle_writer_tests {
use super::*;
use crate::encryption::standard::ObjectKeyAlg;
use crate::encryption::CopyEncryptionSource;
use std::io::Cursor;
#[test]
fn minimum_version_replaces_an_unusable_existing_internal_value() {
let mut current = Some(("2147483648".to_string(), 0));
update_minimum_pdf_version(&mut current, "1.7".to_string(), 0);
assert_eq!(current, Some(("1.7".to_string(), 0)));
let mut current = Some(("1.4".to_string(), 0));
update_minimum_pdf_version(&mut current, "1.7".to_string(), 0);
assert_eq!(current, Some(("1.7".to_string(), 0)));
let mut current = Some(("1.7".to_string(), 1));
update_minimum_pdf_version(&mut current, "1.7".to_string(), 2);
assert_eq!(current, Some(("1.7".to_string(), 2)));
}
#[test]
fn minimum_version_numeric_tie_keeps_incumbent_raw_version() {
let mut current = Some(("1.7".to_string(), 0));
update_minimum_pdf_version(&mut current, "1.7x".to_string(), 2);
assert_eq!(current, Some(("1.7".to_string(), 2)));
}
#[test]
fn forced_raw_version_uses_qpdf_encryption_compatibility_floors() {
for (params, forced_version) in [
(
EncryptParams::rc4(EncryptMethod::V1Rc440, b"u", b"o"),
"1.2",
),
(
EncryptParams::rc4(EncryptMethod::V2Rc4128, b"u", b"o"),
"1.3",
),
(
EncryptParams::rc4(EncryptMethod::V4Rc4128, b"u", b"o"),
"1.4",
),
(EncryptParams::v4_aes128(b"u", b"o"), "1.5"),
(EncryptParams::v5_r6(b"u", b"o"), "1.7"),
] {
let options = WriterOptions {
encrypt: Some(params),
force_version: Some(forced_version.to_string()),
..WriterOptions::default()
};
assert!(
forced_version_disables_encryption(&options),
"forced version {forced_version} must disable its incompatible encryption"
);
}
}
#[test]
fn effective_version_applies_the_linearize_floor_to_a_lower_source() {
let options = WriterOptions::default();
assert_eq!(effective_pdf_version("1.1", &options, true, false), "1.2");
}
#[test]
fn effective_version_pair_keeps_incumbent_raw_version_when_extension_level_wins_tie() {
let options = WriterOptions {
min_version: Some("1.7x".to_owned()),
min_extension_level: Some(2),
..WriterOptions::default()
};
assert_eq!(
effective_pdf_version_and_ext("1.7", 0, &options, false, false),
("1.7", 2)
);
}
#[test]
fn effective_version_pair_takes_the_minimum_s_raw_version_on_an_outright_numeric_win() {
let options = WriterOptions {
min_version: Some("1.7x".to_owned()),
min_extension_level: Some(2),
..WriterOptions::default()
};
assert_eq!(
effective_pdf_version_and_ext("1.3", 0, &options, false, false),
("1.7x", 2)
);
}
#[test]
fn effective_version_pair_keeps_forced_raw_version_and_extension() {
let options = WriterOptions {
force_version: Some("1.7x".to_owned()),
force_extension_level: Some(2),
..WriterOptions::default()
};
assert_eq!(
effective_pdf_version_and_ext("1.3", 0, &options, true, true),
("1.7x", 2)
);
}
#[test]
fn effective_version_pair_ignores_an_overflowing_minimum() {
let options = WriterOptions {
min_version: Some("2147483648".to_owned()),
min_extension_level: Some(2),
..WriterOptions::default()
};
assert_eq!(
effective_pdf_version_and_ext("1.7", 0, &options, false, false),
("1.7", 0)
);
}
#[test]
fn effective_version_pair_falls_back_for_an_overflowing_source() {
let options = WriterOptions::default();
assert_eq!(
effective_pdf_version_and_ext("2147483648", 0, &options, false, false),
("2147483648", 0)
);
}
#[test]
fn encryption_shape_reads_copy_encryption_handles() {
let options = WriterOptions {
copy_encryption: Some(CopyEncryptionSource {
encrypt_dict: ObjectHandle::dictionary(vec![
(b"/V".to_vec(), ObjectHandle::integer(4)),
(b"/R".to_vec(), ObjectHandle::integer(4)),
]),
file_key: vec![0; 16],
id0: vec![0; 16],
object_key_alg: ObjectKeyAlg::Rc4,
}),
..WriterOptions::default()
};
assert_eq!(encryption_shape(&options), Some((4, 4, true)));
}
#[test]
fn job_writer_password_normalization_covers_each_encryption_revision() {
let mut empty = WriterConfiguration::default();
assert_eq!(
empty
.normalize_encryption_passwords(PasswordMode::Bytes)
.unwrap(),
0
);
for params in [
EncryptParams::rc4(EncryptMethod::V1Rc440, b"u", b"o"),
EncryptParams::rc4(EncryptMethod::V2Rc4128, b"u", b"o"),
EncryptParams::rc4(EncryptMethod::V4Rc4128, b"u", b"o"),
EncryptParams::v4_aes128(b"u", b"o"),
EncryptParams::v5_r5(b"u", b"o"),
EncryptParams::v5_r6(b"u", b"o"),
] {
let mut configuration = WriterConfiguration::default();
configuration.set_encryption_parameters(params);
assert_eq!(
configuration
.normalize_encryption_passwords(PasswordMode::Bytes)
.unwrap(),
0
);
}
let mut invalid = WriterConfiguration::default();
invalid.set_encryption_parameters(EncryptParams::v5_r6(b"75", b"not-hex"));
assert_eq!(
invalid
.normalize_encryption_passwords(PasswordMode::HexBytes)
.unwrap(),
0
);
let params = invalid
.settings
.encryption_parameters
.as_ref()
.expect("hex password parameters remain configured");
assert_eq!(params.user_password, vec![0x75]);
assert_eq!(params.owner_password, vec![0xe0]);
}
#[test]
fn copied_v4_encryption_preserves_the_cleartext_metadata_flag() {
let source = CopyEncryptionSource {
encrypt_dict: ObjectHandle::dictionary(vec![
(b"/V".to_vec(), ObjectHandle::integer(4)),
(b"/R".to_vec(), ObjectHandle::integer(4)),
(b"/Length".to_vec(), ObjectHandle::integer(128)),
(b"/P".to_vec(), ObjectHandle::integer(-4)),
(b"/O".to_vec(), ObjectHandle::string(vec![1; 32])),
(b"/U".to_vec(), ObjectHandle::string(vec![2; 32])),
(b"/EncryptMetadata".to_vec(), ObjectHandle::boolean(false)),
]),
file_key: vec![0; 16],
id0: vec![0; 16],
object_key_alg: ObjectKeyAlg::Rc4,
};
let (dictionary, _, _, _) =
canonical_copy_encryption(&source).expect("valid V=4 copy-encryption source");
assert_eq!(
dictionary
.try_get_key(b"/EncryptMetadata")
.expect("metadata flag")
.as_boolean(),
Some(false)
);
}
#[test]
fn copied_unsigned_permission_value_wraps_like_qpdf() {
let source = CopyEncryptionSource {
encrypt_dict: ObjectHandle::dictionary(vec![
(b"/V".to_vec(), ObjectHandle::integer(5)),
(b"/R".to_vec(), ObjectHandle::integer(6)),
(b"/Length".to_vec(), ObjectHandle::integer(256)),
(b"/P".to_vec(), ObjectHandle::integer(4_294_967_292)),
(b"/O".to_vec(), ObjectHandle::string(vec![1; 48])),
(b"/U".to_vec(), ObjectHandle::string(vec![2; 48])),
(b"/OE".to_vec(), ObjectHandle::string(vec![3; 32])),
(b"/UE".to_vec(), ObjectHandle::string(vec![4; 32])),
(b"/Perms".to_vec(), ObjectHandle::string(vec![5; 16])),
]),
file_key: vec![0; 32],
id0: vec![0; 16],
object_key_alg: ObjectKeyAlg::Aes,
};
let (dictionary, _, _, _) =
canonical_copy_encryption(&source).expect("positive /P copy source");
assert_eq!(
dictionary
.try_get_key(b"/P")
.expect("copied /P")
.as_integer(),
Some(-4)
);
}
#[test]
fn copy_integer_reports_a_non_integer_or_missing_value() {
let dictionary = ObjectHandle::dictionary(vec![(
b"/V".to_vec(),
ObjectHandle::string(b"not-an-integer".to_vec()),
)]);
let error = copy_integer(&dictionary, "V").expect_err("wrong type is rejected");
assert!(error.to_string().contains("must be an integer"));
let error = copy_integer(&dictionary, "R").expect_err("missing key is rejected");
assert!(error.to_string().contains("must be an integer"));
}
#[test]
fn pdf_writer_compression_level_changes_recompressed_output() {
let _guard = crate::pipeline::flate::lock_compression_level_for_tests();
fn rewrite(level: i32) -> Vec<u8> {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/lone-flate-l9.pdf").to_vec(),
))
.expect("fixture must open");
let mut writer = PdfWriter::new(&mut pdf);
writer.set_static_id(true);
writer.set_recompress_flate(true);
writer.set_compression_level(level);
writer.set_output_memory().expect("memory output");
writer.write().expect("writer succeeds");
writer.get_buffer().expect("memory buffer")
}
let level_one = rewrite(1);
let level_nine = rewrite(9);
let _default_level = rewrite(-1);
crate::pipeline::flate::Flate::set_compression_level(-1).expect("reset level");
assert_ne!(
level_one, level_nine,
"PdfWriter compression level must affect recompressed output"
);
}
#[test]
fn pdf_writer_reprocesses_an_invalid_compression_level_without_filtering() {
let _guard = crate::pipeline::flate::lock_compression_level_for_tests();
struct CompressionLevelReset;
impl Drop for CompressionLevelReset {
fn drop(&mut self) {
let _ = crate::pipeline::flate::Flate::set_compression_level(-1);
}
}
let _reset = CompressionLevelReset;
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/one-page.pdf").to_vec(),
))
.expect("fixture must open");
let mut writer = PdfWriter::new(&mut pdf);
writer.set_recompress_flate(true);
writer.set_compression_level(10);
assert!(
writer.get_final_version().is_ok(),
"get_final_version must not evaluate the configured compression level"
);
writer.set_output_memory().expect("memory output");
writer
.write()
.expect("qpdf retries an invalid level with an unfiltered stream");
let output = writer.get_buffer().expect("memory output buffer");
assert!(
!output.is_empty(),
"the recovered writer must produce output"
);
assert!(
!output
.windows(b"/Filter /FlateDecode".len())
.any(|window| window == b"/Filter /FlateDecode"),
"the failed compression attempt must leave the stream unfiltered"
);
assert!(
pdf.repair_diagnostics().entries().iter().any(|entry| {
entry
.message
.contains("error decoding stream data for object")
&& entry.message.contains("zlib stream error")
}),
"qpdf reports the invalid deflate initialization as a stream warning"
);
assert!(
pdf.repair_diagnostics().entries().iter().any(|entry| {
entry
.message
.contains("stream will be re-processed without filtering")
}),
"qpdf reports the raw retry after the invalid compression level"
);
}
#[test]
fn get_final_version_does_not_leak_compression_level_into_a_later_writer() {
let _guard = crate::pipeline::flate::lock_compression_level_for_tests();
crate::pipeline::flate::Flate::set_compression_level(-1).expect("reset level");
fn rewrite_at_default_level() -> Vec<u8> {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/lone-flate-l9.pdf").to_vec(),
))
.expect("fixture must open");
let mut writer = PdfWriter::new(&mut pdf);
writer.set_static_id(true);
writer.set_recompress_flate(true);
writer.set_output_memory().expect("memory output");
writer.write().expect("writer succeeds");
writer.get_buffer().expect("memory buffer")
}
let baseline = rewrite_at_default_level();
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/lone-flate-l9.pdf").to_vec(),
))
.expect("fixture must open");
let mut inspected_writer = PdfWriter::new(&mut pdf);
inspected_writer.set_compression_level(1);
let _ = inspected_writer
.get_final_version()
.expect("get_final_version succeeds without touching Flate state");
let after_inspection = rewrite_at_default_level();
assert_eq!(
baseline, after_inspection,
"querying get_final_version on one writer must not change another \
default writer's compressed output"
);
}
#[test]
fn pclm_emits_a_synthetic_stream_for_a_page_xobject() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/direct-root-one-page.pdf").to_vec(),
))
.expect("fixture must open");
let page = crate::pages::page_refs(&mut pdf).expect("page refs")[0];
let page_handle = pdf.get_object_handle(page);
pdf.resolve(&page_handle).expect("page resolves");
let replacement = page_handle.shallow_copy().expect("page is copyable");
let image = pdf
.new_stream_with_data(Rc::new(b"image".to_vec()))
.expect("image stream");
let resources = ObjectHandle::dictionary(vec![(
b"/XObject".to_vec(),
ObjectHandle::dictionary(vec![(b"/Im0".to_vec(), image)]),
)]);
replacement
.replace_key(b"/Resources", resources)
.expect("replace page resources");
pdf.replace_object(page, replacement).expect("replace page");
let mut output = Vec::new();
write_pclm(&mut pdf, &mut output, &WriterOptions::default()).expect("PCLm writer succeeds");
assert!(output
.windows(b"q /image Do Q\n".len())
.any(|window| { window == b"q /image Do Q\n" }));
}
#[test]
fn first_page_xref_count_rejects_param_dict_above_size() {
assert_eq!(
crate::linearization::writer::first_page_xref_object_count(10, 3)
.expect("valid param-dict slot"),
7
);
let error = crate::linearization::writer::first_page_xref_object_count(10, 11)
.expect_err("param-dict slot beyond /Size must be rejected");
assert!(matches!(
error,
Error::Unsupported(message)
if message.contains("param-dict object number")
&& message.contains("exceeds /Size")
));
}
#[test]
fn direct_root_catalog_extension_restore_accepts_a_missing_snapshot() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/direct-root-one-page.pdf").to_vec(),
))
.expect("direct-root fixture");
let snapshot = snapshot_catalog_extensions(&mut pdf).expect("snapshot direct root");
assert!(
snapshot.is_none(),
"an inline Catalog has no restoration snapshot"
);
restore_catalog_extensions(&mut pdf, snapshot).expect("restore absent snapshot");
}
#[test]
fn source_objstm_extends_remaps_to_preserved_or_fallback_container() {
let extends = ObjectRef::new(4, 0);
let fallback = ObjectRef::new(7, 0);
let missing = ObjectRef::new(8, 0);
let mut source_container_to_batch = HashMap::new();
source_container_to_batch.insert(extends, 1);
let container_refs = vec![ObjectRef::new(20, 0), ObjectRef::new(21, 0)];
let mut qdf_emission_renumber = HashMap::new();
qdf_emission_renumber.insert(fallback, ObjectRef::new(30, 0));
let mut ordinary_renumber = HashMap::new();
ordinary_renumber.insert(fallback, ObjectRef::new(31, 0));
assert_eq!(
remap_source_objstm_extends(
extends,
&source_container_to_batch,
&container_refs,
false,
&qdf_emission_renumber,
&ordinary_renumber,
),
Some(ObjectRef::new(21, 0))
);
assert_eq!(
remap_source_objstm_extends(
fallback,
&source_container_to_batch,
&container_refs,
true,
&qdf_emission_renumber,
&ordinary_renumber,
),
Some(ObjectRef::new(30, 0))
);
assert_eq!(
remap_source_objstm_extends(
fallback,
&source_container_to_batch,
&container_refs,
false,
&qdf_emission_renumber,
&ordinary_renumber,
),
Some(ObjectRef::new(31, 0))
);
assert_eq!(
remap_source_objstm_extends(
missing,
&source_container_to_batch,
&container_refs,
false,
&qdf_emission_renumber,
&ordinary_renumber,
),
None
);
}
#[test]
fn qdf_generate_reuses_modified_stream_parameters_between_plans() {
struct CountEofTokenFilter {
eof_calls: Rc<std::cell::Cell<usize>>,
}
impl crate::token_filter::TokenFilter for CountEofTokenFilter {
fn handle_token(
&mut self,
token: &crate::tokenizer::Token,
output: &mut crate::token_filter::TokenFilterOutput<'_>,
) -> crate::pipeline::PipelineResult<()> {
output.write_token(token)
}
fn handle_eof(
&mut self,
_output: &mut crate::token_filter::TokenFilterOutput<'_>,
) -> crate::pipeline::PipelineResult<()> {
self.eof_calls.set(self.eof_calls.get() + 1);
Ok(())
}
}
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/one-page.pdf").to_vec(),
))
.expect("one-page fixture");
let page = pdf.get_object_handle(ObjectRef::new(3, 0));
pdf.resolve(&page).expect("page resolves");
let content = page.try_get_key(b"/Contents").expect("page contents");
let eof_calls = Rc::new(std::cell::Cell::new(0));
content
.add_token_filter(Rc::new(RefCell::new(CountEofTokenFilter {
eof_calls: Rc::clone(&eof_calls),
})))
.expect("register token filter");
pdf.mark_object_handle_dirty(&content)
.expect("mark modified content");
let mut writer = PdfWriter::new(&mut pdf);
writer.set_qdf_mode(true);
writer.set_object_stream_mode(ObjectStreamMode::Generate);
writer.set_static_id(true);
writer.set_output_memory().expect("memory output");
writer
.write()
.expect("QDF Generate must reuse modified stream parameters");
assert!(!writer.get_buffer().expect("written buffer").is_empty());
assert_eq!(
eof_calls.get(),
1,
"the modified stream must be prepared once across both planning walks"
);
}
#[test]
fn qdf_writer_does_not_invoke_a_retry_provider_during_graph_planning() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/minimal.pdf").to_vec(),
))
.expect("minimal fixture");
let calls = Rc::new(RefCell::new(Vec::new()));
let calls_for_provider = Rc::clone(&calls);
let stream = pdf.new_stream().expect("provider stream");
stream
.replace_stream_data_with_retry_callback(
move |pipeline, suppress_warnings, will_retry| {
calls_for_provider
.borrow_mut()
.push((suppress_warnings, will_retry));
if will_retry {
return Ok(false);
}
pipeline.write(b"salad").map_err(Error::from)?;
pipeline.finish().map_err(Error::from)?;
Ok(true)
},
Some(ObjectHandle::null()),
Some(ObjectHandle::null()),
)
.expect("register retry provider");
pdf.trailer()
.replace_key(b"/Streams", ObjectHandle::array(vec![stream]))
.expect("attach provider stream to live trailer");
let mut writer = PdfWriter::new(&mut pdf);
writer.set_qdf_mode(true);
writer.set_static_id(true);
writer.set_output_memory().expect("memory output");
writer.write().expect("QDF writer succeeds");
assert!(!writer.get_buffer().expect("written buffer").is_empty());
assert_eq!(
*calls.borrow(),
vec![(false, true), (false, false)],
"provider calls must be limited to qpdf's writer retry loop"
);
}
}