#[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/output.rs"]
pub(crate) mod output;
#[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;
#[path = "writer/write_object.rs"]
pub(crate) mod write_object;
use crate::qpdf_obj_gen::QpdfObjGen;
pub(crate) use object::{ObjectWriterEmission, StreamDictionaryOptions};
pub use object_streams::ObjectStreamMode;
use output::{OutputSink, OutputTarget};
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, PasswordWriteNotice,
};
use crate::linearization::writer::write_linearized_for_pdf_writer;
use crate::pdf_version::{parse_qpdf_writer_version, PdfVersion, QpdfVersionParts};
use crate::pipeline::{flate::Flate, Pipeline, PipelineError, PipelineResult};
use crate::{Error, ObjectHandle, ObjectRef, Pdf, Result, XrefEntry};
use std::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;
const QPDF_OUTPUT_PIPELINE: &str = "qpdf output";
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 {
identifier: Option<&'static str>,
writer: Box<dyn Write>,
},
Pipeline(Box<dyn Pipeline>),
}
fn stdio_sink_failure(identifier: Option<&'static str>, source: &io::Error) -> Option<Error> {
identifier.map(|identifier| {
Error::SystemBytes(
format!(
"{identifier}: Pl_StdioFile::write: {}",
crate::qutil::strerror_text(source)
)
.into_bytes(),
)
})
}
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 OutputTarget for WriterOutputSink<'_> {
fn write_chunk(&mut self, bytes: &[u8]) -> io::Result<usize> {
self.write(bytes)
}
fn finish_segment(&mut self) -> Result<()> {
match self.output {
WriterOutput::Memory(_) => Ok(()),
WriterOutput::Writer { .. } => {
self.flush()?;
Ok(())
}
WriterOutput::Pipeline(pipeline) => pipeline.finish().map_err(Into::into),
}
}
fn finish_document(&mut self) -> Result<()> {
self.finish_output()
}
}
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 { identifier, writer } => match writer.write(bytes) {
Ok(count) => Ok(count),
Err(error) => {
self.failure = stdio_sink_failure(*identifier, &error);
Err(error)
}
},
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 { identifier, writer } => match writer.flush() {
Ok(()) => Ok(()),
Err(error) => {
self.failure = stdio_sink_failure(*identifier, &error);
Err(error)
}
},
}
}
}
impl WriterOutput {
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(crate) fn encryption_parameters(&self) -> Option<&EncryptParams> {
self.settings.encryption_parameters.as_ref()
}
pub fn normalize_encryption_passwords(
&mut self,
password_mode: PasswordMode,
) -> Result<Vec<PasswordWriteNotice>> {
let Some(params) = self.settings.encryption_parameters.as_mut() else {
return Ok(Vec::new());
};
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_notice) = crate::encryption::password::password_bytes_for_write(
¶ms.user_password,
password_mode,
revision,
)?;
let (owner_password, owner_notice) = crate::encryption::password::password_bytes_for_write(
¶ms.owner_password,
password_mode,
revision,
)?;
params.user_password = user_password;
params.owner_password = owner_password;
Ok(vec![user_notice, owner_notice])
}
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
}
}
pub(crate) 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 {
identifier: Some(QPDF_OUTPUT_PIPELINE),
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 {
identifier: None,
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,
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.pdf.root_handle()?;
let mut setup = build_writer_setup(self.pdf, &options)?;
self.write_started = true;
let special_streams = initialize_special_streams(self.pdf, &options)?;
let effective_object_streams = effective_object_stream_mode(&options);
if effective_object_streams == ObjectStreamMode::Generate {
let compressible = object_streams::compressible_objgens_qpdf_plan(self.pdf)?;
let generated_object_stream_count =
object_streams::even_split_into_streams(&compressible.eligible).len();
setup.generated_compressible = Some(compressible);
for _ in 0..generated_object_stream_count {
let placeholder = self
.pdf
.make_indirect_from_object_handle(ObjectHandle::null())?;
let source = placeholder.object_ref().ok_or_else(|| {
Error::Internal(
"generated ObjStm placeholder has no source identity".to_string(),
)
})?; setup.generated_object_stream_sources.push(source);
}
}
if self.settings.linearization && special_streams.is_none() {
crate::pages::repair::prepare_for_optimization(self.pdf)?;
}
self.pdf.get_object_count()?;
crate::writer::configure_progress_for_pdf(
self.pdf,
&options,
0,
self.settings.linearization,
)?;
prepare_file_for_write(self.pdf)?;
if options.deterministic_id && options.static_id && options.encryption_generated_id {
return Err(deterministic_id_after_id_generation());
}
let result = if self.settings.linearization {
options.qdf = false;
let pass1_path = self.settings.linearization_pass1_filename.as_deref();
let output = self
.output
.as_mut()
.expect("output was checked before writing");
let mut target = WriterOutputSink::new(output);
match write_linearized_for_pdf_writer(
self.pdf,
&options,
pass1_path,
setup,
special_streams.as_ref(),
&mut target,
) {
Ok(result) => result,
Err(error) => return Err(target.take_failure().unwrap_or(error)),
}
} else {
let output = self
.output
.as_mut()
.expect("output was checked before writing");
let mut target = WriterOutputSink::new(output);
let emission = {
let mut sink = OutputSink::new(&mut target);
match emit_canonical_pdf_with_special_streams(
self.pdf,
&mut sink,
&options,
special_streams.as_ref(),
setup,
) {
Ok(result) => sink.finish_document().map(|()| result),
Err(error) => Err(error),
}
};
match emission {
Ok(result) => result,
Err(error) => return Err(target.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.decode_level = DecodeLevel::None;
options.compress_streams = crate::CompressStreams::No;
options.stream_data = None;
}
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 uses_deterministic_id(&options)
&& (options.encrypt.is_some() || options.copy_encryption.is_some())
{
return Err(deterministic_id_encryption_error(&options));
}
options.encryption_generated_id =
options.encrypt.is_some() || options.copy_encryption.is_some();
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 encryption_generated_id: bool,
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>,
}
#[derive(Debug, Default)]
pub(crate) struct SpecialStreams {
pages: Vec<QpdfObjGen>,
page_seq: HashMap<QpdfObjGen, u32>,
contents_seq: HashMap<QpdfObjGen, u32>,
normalized_streams_raw: BTreeSet<QpdfObjGen>,
pub(crate) content_container_refs: BTreeSet<QpdfObjGen>,
content_container_seq: HashMap<QpdfObjGen, u32>,
}
#[derive(Debug, Default)]
pub(crate) struct LiveContentStreamState {
pub(crate) page_sequences: BTreeMap<QpdfObjGen, usize>,
pub(crate) contents_sequences: BTreeMap<QpdfObjGen, usize>,
pub(crate) normalized_streams: BTreeSet<QpdfObjGen>,
}
impl SpecialStreams {
pub(crate) fn normalized_streams_raw(&self) -> &BTreeSet<QpdfObjGen> {
&self.normalized_streams_raw
}
pub(crate) fn live_content_stream_state(&self) -> LiveContentStreamState {
let to_btreemap = |map: &HashMap<QpdfObjGen, u32>| -> BTreeMap<QpdfObjGen, usize> {
map.iter()
.map(|(&object_gen, &sequence)| (object_gen, sequence as usize))
.collect()
};
LiveContentStreamState {
page_sequences: to_btreemap(&self.page_seq),
contents_sequences: to_btreemap(&self.contents_seq),
normalized_streams: self.normalized_streams_raw.clone(),
}
}
}
fn initialize_special_streams<R: Read + Seek>(
pdf: &mut Pdf<R>,
options: &WriterOptions,
) -> Result<Option<SpecialStreams>> {
if !(options.qdf || options.content_normalization || options.decode_level != DecodeLevel::None)
{
return Ok(None);
}
let pages = crate::PageDocumentHelper::new(pdf).get_all_page_handles()?;
let mut streams = SpecialStreams {
pages: Vec::with_capacity(pages.len()),
page_seq: HashMap::with_capacity(pages.len()),
contents_seq: HashMap::new(),
normalized_streams_raw: BTreeSet::new(),
content_container_refs: BTreeSet::new(),
content_container_seq: HashMap::new(),
};
for (index, page) in pages.iter().enumerate() {
let page_object_gen = page
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.ok_or_else(|| Error::Internal("qpdf page list contains a direct page".into()))?;
let sequence = u32::try_from(index)
.ok()
.and_then(|index| index.checked_add(1))
.ok_or_else(|| Error::Internal("page sequence overflows u32".into()))?;
streams.pages.push(page_object_gen);
streams.page_seq.insert(page_object_gen, sequence);
for content_gen in collect_content_stream_qpdf_obj_gens(page)? {
streams.contents_seq.insert(content_gen, sequence);
streams.normalized_streams_raw.insert(content_gen);
}
if options.qdf || options.content_normalization {
let mut content_containers = BTreeSet::new();
collect_content_container_qpdf_obj_gens(page, &mut content_containers)?;
for container in content_containers {
streams.content_container_refs.insert(container);
streams.content_container_seq.insert(container, sequence);
}
}
}
Ok(Some(streams))
}
pub(crate) const fn uses_deterministic_id(options: &WriterOptions) -> bool {
options.deterministic_id && !options.static_id
}
pub(crate) fn prepare_file_for_write<R: Read + Seek>(pdf: &mut Pdf<R>) -> Result<()> {
pdf.fix_dangling_references()?;
let root = pdf.root_handle()?;
let extensions = root.try_get_key(b"/Extensions")?;
if !extensions.try_is_dictionary()? {
return Ok(());
}
let extensions = if extensions.is_indirect() {
let direct = extensions.shallow_copy()?;
root.replace_key(b"/Extensions", direct.clone())?;
direct
} else {
extensions
};
if extensions.try_has_key(b"/ADBE")? {
let mut adbe = extensions.try_get_key(b"/ADBE")?;
if adbe.is_indirect() {
adbe.make_direct(false)?;
extensions.replace_key(b"/ADBE", adbe)?;
}
}
Ok(())
}
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))
}
fn effective_object_stream_mode(options: &WriterOptions) -> ObjectStreamMode {
let encrypting = options.encrypt.is_some() || options.copy_encryption.is_some();
if force_version_below_1_5(options)
&& (matches!(options.object_streams, ObjectStreamMode::Generate)
|| (!encrypting && matches!(options.object_streams, ObjectStreamMode::Preserve)))
{
ObjectStreamMode::Disable
} else {
options.object_streams
}
}
pub(crate) fn effective_pdf_version<'a>(
source: &'a str,
options: &'a WriterOptions,
object_streams: bool,
) -> &'a str {
effective_pdf_version_and_ext(source, 0, options, 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 revision == 5 {
PdfVersion::new(1, 7, 3)
} else if revision == 4 {
if version >= 4 {
PdfVersion::new(1, 6, 0)
} else {
PdfVersion::new(1, 5, 0)
}
} else if revision == 3 {
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,
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, object_streams)
}
}
}
fn effective_pdf_version_and_ext_without_force<'a>(
source: &'a str,
source_ext: i64,
options: &'a WriterOptions,
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);
}
best.map(|version| (version.raw, version.extension_level))
.unwrap_or((source, 0))
}
pub(crate) fn effective_pdf_version_and_ext_with_encryption<'a>(
source: &'a str,
source_ext: i64,
options: &'a WriterOptions,
object_streams: bool,
encryption: Option<&EncryptionParameters>,
) -> (&'a str, i64) {
let (raw, extension_level) =
effective_pdf_version_and_ext(source, source_ext, options, object_streams);
let Some(encryption) = encryption else {
return (raw, extension_level);
};
let (encryption_version, encryption_extension) = if encryption.encryption_r >= 6 {
("1.7", 8)
} else if encryption.encryption_r == 5 {
("1.7", 3)
} else if encryption.encryption_r == 4 {
match encryption.cipher {
WriteCipher::PerObject(crate::encryption::standard::ObjectKeyAlg::Rc4) => ("1.5", 0),
WriteCipher::PerObject(crate::encryption::standard::ObjectKeyAlg::Aes)
| WriteCipher::FileKeyAes256 => ("1.6", 0),
}
} else if encryption.encryption_r == 3 {
("1.4", 0)
} else {
("1.3", 0)
};
let mut effective = None;
update_effective_pdf_version(&mut effective, raw, extension_level);
update_effective_pdf_version(&mut effective, encryption_version, encryption_extension);
effective
.map(|version| (version.raw, version.extension_level))
.unwrap_or((raw, extension_level))
}
pub(crate) const QPDF_BINARY_MARKER: &[u8] = b"%\xbf\xf7\xa2\xfe\n";
pub(crate) const PCLM_HEADER_MARKER: &[u8] = b"%PCLm 1.0\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,
}
#[derive(Clone)]
pub(crate) struct EncryptionParameters {
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) id0: Vec<u8>,
pub(crate) static_aes_iv: bool,
pub(crate) encrypt_metadata: bool,
pub(crate) metadata_ref: Option<ObjectRef>,
}
impl EncryptionParameters {
pub(crate) fn into_context(self, encrypt_ref: ObjectRef) -> EncryptionContext {
EncryptionContext {
encrypt_dict: self.encrypt_dict,
file_key: self.file_key,
cipher: self.cipher,
encryption_v: self.encryption_v,
encryption_r: self.encryption_r,
encrypt_ref,
id0: self.id0,
static_aes_iv: self.static_aes_iv,
encrypt_metadata: self.encrypt_metadata,
metadata_ref: self.metadata_ref,
}
}
}
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_parameters(
options: &WriterOptions,
params: &crate::encryption::EncryptParams,
metadata_ref: Option<ObjectRef>,
id0: &[u8],
) -> Result<EncryptionParameters> {
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)
}
};
Ok(EncryptionParameters {
encrypt_dict,
file_key,
cipher,
encryption_v,
encryption_r,
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_parameters(
src: &crate::encryption::CopyEncryptionSource,
options: &WriterOptions,
metadata_ref: Option<ObjectRef>,
) -> Result<EncryptionParameters> {
let (encrypt_dict, encryption_v, encryption_r, cipher, file_key) =
canonical_copy_encryption(src)?;
let encrypt_metadata = copy_encryption_encrypts_metadata_from_dict(&encrypt_dict);
Ok(EncryptionParameters {
encrypt_dict,
file_key,
cipher,
encryption_v,
encryption_r,
id0: src.id0.clone(),
static_aes_iv: options.static_aes_iv,
encrypt_metadata,
metadata_ref: if encrypt_metadata { None } else { metadata_ref },
})
}
pub(crate) struct WriterSetupState {
pub(crate) generated_id: Option<ObjectHandle>,
pub(crate) encryption_parameters: Option<EncryptionParameters>,
pub(crate) source_object_stream_data: BTreeMap<u32, u32>,
pub(crate) generated_compressible: Option<object_streams::CompressiblePlan>,
pub(crate) generated_object_stream_sources: Vec<ObjectRef>,
}
pub(crate) fn build_writer_setup<R: Read + Seek>(
pdf: &mut Pdf<R>,
options: &WriterOptions,
) -> Result<WriterSetupState> {
let mut source_object_stream_data = BTreeMap::new();
if options.object_streams == ObjectStreamMode::Preserve {
pdf.get_object_stream_data(&mut source_object_stream_data);
}
let encrypting = options.encrypt.is_some() || options.copy_encryption.is_some();
if uses_deterministic_id(options) && encrypting {
return Err(deterministic_id_encryption_error(options));
}
let generated_id = if uses_deterministic_id(options) {
None
} else if let Some(source) = options.copy_encryption.as_ref() {
let generated = generate_id_handle(None, options.static_id);
let id1 = generated
.as_array()
.and_then(|values| values.get(1).and_then(ObjectHandle::as_string))
.unwrap_or_else(|| source.id0.clone());
Some(ObjectHandle::array(vec![
ObjectHandle::string(source.id0.clone()),
ObjectHandle::string(id1),
]))
} else {
let source_id0 = source_permanent_id_handle(&pdf.trailer())?;
Some(generate_id_handle(source_id0.as_deref(), options.static_id))
};
let encryption_parameters = if let Some(params) = options.encrypt.as_ref() {
let id0 = generated_id
.as_ref()
.and_then(ObjectHandle::as_array)
.and_then(|values| values.first().and_then(ObjectHandle::as_string))
.ok_or_else(|| {
Error::Unsupported("writer setup: generated encryption ID is malformed".into())
})?; let metadata_ref = if params.encrypt_metadata {
None
} else {
resolve_metadata_stream_ref(pdf)?
};
Some(build_encryption_parameters(
options,
params,
metadata_ref,
&id0,
)?) } else if let Some(source) = options.copy_encryption.as_ref() {
let metadata_ref = if copy_encryption_encrypts_metadata_from_dict(&source.encrypt_dict) {
None
} else {
resolve_metadata_stream_ref(pdf)?
};
Some(build_copy_encryption_parameters(
source,
options,
metadata_ref,
)?)
} else {
None
};
Ok(WriterSetupState {
generated_id,
encryption_parameters,
source_object_stream_data,
generated_compressible: None,
generated_object_stream_sources: Vec::new(),
})
}
fn canonical_copy_encryption(
src: &crate::encryption::CopyEncryptionSource,
) -> Result<(ObjectHandle, i32, i32, WriteCipher, Vec<u8>)> {
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 if let Some(length_bits) = src.writer_length_bits {
length_bits
} else {
let key_len = copy_integer_as_int(&src.encrypt_dict, "Length")? / 8;
key_len * 8
};
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 file_key = if version >= 5 {
src.file_key.clone()
} else {
let o_param = crate::encryption::standard::v_lt_5_32_byte_parameter(&o);
let u_param = crate::encryption::standard::v_lt_5_32_byte_parameter(&u);
crate::encryption::standard::compute_encryption_key_from_password(
&src.padded_user_password,
&crate::encryption::standard::StandardHandlerInputs {
v: version,
r: revision,
length_bits,
p,
id0: &src.id0,
u: &u_param,
o: &o_param,
encrypt_metadata,
},
)?
};
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, file_key))
}
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_integer_as_int(dict: &ObjectHandle, key: &str) -> Result<i64> {
let key = format!("/{key}");
Ok(i64::from(
dict.try_get_key(key.as_bytes())?
.try_get_int_value_as_int()?,
))
}
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) fn source_permanent_id_handle(trailer: &ObjectHandle) -> Result<Option<Vec<u8>>> {
if !trailer.try_has_key(b"/ID")? {
return Ok(None);
}
let id = trailer.try_get_key(b"/ID")?;
source_permanent_id_value_handle(&id)
}
pub(crate) fn source_permanent_id_value_handle(id: &ObjectHandle) -> Result<Option<Vec<u8>>> {
let first = id.try_get_array_item(0)?;
let value = first.try_get_string_value()?;
Ok((!value.is_empty()).then_some(value))
}
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_from_digest(
det_data: [u8; 16],
info_suffix: &[u8],
source_id0: Option<&[u8]>,
) -> (Vec<u8>, [u8; 16]) {
use md5::Digest as _;
let mut seed = Vec::with_capacity(32 + 6 + info_suffix.len());
push_hex_lower(&mut seed, &det_data);
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 OutputSink<'_>,
info_suffix: &[u8],
source_id0: Option<&[u8]>,
) -> Result<()> {
use md5::Digest as _;
out.write_bytes(b"[")?;
out.suspend_digest();
let output_digest = out.take_digest()?;
let seed = output::deterministic_id_second_seed(&output_digest, info_suffix)?;
let id1: [u8; 16] = md5::Md5::digest(&seed).into();
let id0 = source_id0.unwrap_or(&id1);
crate::pdf_syntax::write_hex_string(out, id0)?;
crate::pdf_syntax::write_hex_string(out, &id1)?;
out.write_bytes(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 crate::writer::object::TRIMMED_TRAILER_KEYS {
trailer.remove_key(key);
}
if trailer.try_has_key(b"/Size")? {
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)
}
#[cfg(test)]
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)
}
struct OutputSinkPipeline<'output, 'sink> {
out: &'output mut OutputSink<'sink>,
failure: &'output mut Option<Error>,
}
impl Pipeline for OutputSinkPipeline<'_, '_> {
fn identifier(&self) -> &str {
"writer stream output"
}
fn write(&mut self, data: &[u8]) -> PipelineResult<()> {
match self.out.write_bytes(data) {
Ok(()) => Ok(()),
Err(error) => {
if self.failure.is_none() {
*self.failure = Some(error);
}
Err(PipelineError::runtime("writer output sink failed"))
}
}
}
fn finish(&mut self) -> PipelineResult<()> {
Ok(())
}
}
fn pipe_writer_stream_payload(
out: &mut OutputSink<'_>,
data: &[u8],
object_ref: ObjectRef,
ctx: &EncryptionContext,
encrypt_stream: bool,
explicit_iv: Option<[u8; 16]>,
) -> Result<()> {
let explicit_iv = explicit_iv.or_else(|| {
(ctx.static_aes_iv && cipher_needs_aes_iv(ctx.cipher))
.then(crate::pipeline::aes::static_initialization_vector)
});
let mut sink_failure = None;
let pipeline_result = {
let mut sink = OutputSinkPipeline {
out,
failure: &mut sink_failure,
};
let mut count = crate::pipeline::count::Count::new("writer stream count", &mut sink);
if !encrypt_stream {
run_writer_pipeline(&mut count, data)
} else {
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)
}
}
}
})
}
};
let finish_result = out.finish_segment();
if let Some(error) = sink_failure {
return Err(error);
}
pipeline_result?;
finish_result
}
pub(crate) fn write_stream_payload_with_pipeline(
out: &mut OutputSink<'_>,
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 OutputSink<'_>,
data: &[u8],
policy: NewlineBeforeEndstream,
qdf_mode: bool,
object_ref: ObjectRef,
ctx: &EncryptionContext,
encrypt_stream: bool,
explicit_iv: Option<[u8; 16]>,
) -> Result<bool> {
out.write_bytes(b"\nstream\n")?;
pipe_writer_stream_payload(out, data, object_ref, ctx, encrypt_stream, explicit_iv)?;
let last_byte = data.last().copied().unwrap_or(0);
let add_newline = match policy {
NewlineBeforeEndstream::Yes => true,
NewlineBeforeEndstream::Never => qdf_mode && last_byte != b'\n',
};
if add_newline {
out.write_bytes(b"\n")?;
}
out.write_bytes(b"endstream")?;
Ok(add_newline)
}
#[cfg(test)]
pub(crate) fn emit_canonical_pdf<R: Read + Seek, W: Write>(
pdf: &mut Pdf<R>,
mut out: W,
options: &WriterOptions,
) -> Result<WriterResult> {
struct BorrowedWriterTarget<'a>(&'a mut dyn Write);
impl OutputTarget for BorrowedWriterTarget<'_> {
fn write_chunk(&mut self, bytes: &[u8]) -> io::Result<usize> {
self.0.write(bytes)
}
fn finish_segment(&mut self) -> Result<()> {
self.0.flush().map_err(Error::Io)
}
fn finish_document(&mut self) -> Result<()> {
self.0.flush().map_err(Error::Io)
}
}
let setup = build_writer_setup(pdf, options)?;
let special_streams = initialize_special_streams(pdf, options);
let mut target = BorrowedWriterTarget(&mut out);
let mut sink = OutputSink::new(&mut target);
match special_streams {
Ok(special_streams) => emit_canonical_pdf_with_special_streams(
pdf,
&mut sink,
options,
special_streams.as_ref(),
setup,
),
Err(error) => Err(error),
}
}
fn emit_canonical_pdf_with_special_streams<R: Read + Seek>(
pdf: &mut Pdf<R>,
out: &mut OutputSink<'_>,
options: &WriterOptions,
special_streams: Option<&SpecialStreams>,
setup: WriterSetupState,
) -> Result<WriterResult> {
emit_canonical_pdf_inner(pdf, out, options, special_streams, setup)
}
fn emit_canonical_pdf_inner<R: Read + Seek>(
pdf: &mut Pdf<R>,
out: &mut OutputSink<'_>,
options: &WriterOptions,
special_streams: Option<&SpecialStreams>,
setup: WriterSetupState,
) -> Result<WriterResult> {
let WriterSetupState {
generated_id,
encryption_parameters,
source_object_stream_data,
generated_compressible,
generated_object_stream_sources,
} = setup;
let effective_object_streams = effective_object_stream_mode(options);
let suppressed_options;
let options = if effective_object_streams != options.object_streams {
suppressed_options = WriterOptions {
object_streams: effective_object_streams,
..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(),
));
}
plain::write_plain(
pdf,
out,
options,
generated_id.as_ref(),
encryption_parameters,
&source_object_stream_data,
special_streams,
generated_compressible.as_ref(),
&generated_object_stream_sources,
)
}
fn collect_content_container_qpdf_obj_gens(
page: &ObjectHandle,
containers: &mut BTreeSet<QpdfObjGen>,
) -> Result<()> {
let page_object_gen = page
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.ok_or_else(|| Error::Internal("qpdf page list contains a direct page".into()))?;
let contents = page.try_get_key(b"/Contents")?;
if contents.type_code()? == 10 {
if !contents
.qpdf_obj_gen()
.is_some_and(|object_gen| object_gen.is_indirect())
{
containers.insert(page_object_gen);
}
return Ok(());
}
if !contents.try_is_array()? {
return Ok(());
}
containers.insert(
contents
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.unwrap_or(page_object_gen),
);
Ok(())
}
pub(crate) fn collect_content_stream_qpdf_obj_gens(page: &ObjectHandle) -> Result<Vec<QpdfObjGen>> {
let contents = page.try_get_key(b"/Contents")?;
if contents.type_code()? == 10 {
return Ok(contents
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
.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 let Some(object_gen) = item
.qpdf_obj_gen()
.filter(|object_gen| object_gen.is_indirect())
{
refs.push(object_gen);
}
}
Ok(refs)
}
#[cfg(test)]
mod final_handle_writer_tests {
use super::*;
use crate::encryption::standard::ObjectKeyAlg;
use crate::encryption::CopyEncryptionSource;
use crate::pipeline::{PipelineError, PipelineResult};
use crate::writer::object::TrailerKind;
use std::io::{self, Cursor, Write};
#[test]
fn plain_route_consumes_the_prepared_generated_id() {
let mut pdf = Pdf::empty().expect("empty PDF");
let generated_id = ObjectHandle::array(vec![
ObjectHandle::string(b"setup-id-0".to_vec()),
ObjectHandle::string(b"setup-id-1".to_vec()),
]);
let setup = WriterSetupState {
generated_id: Some(generated_id),
encryption_parameters: None,
source_object_stream_data: BTreeMap::new(),
generated_compressible: None,
generated_object_stream_sources: Vec::new(),
};
let mut output = Vec::new();
output::with_buffer_sink(&mut output, |out| {
emit_canonical_pdf_inner(&mut pdf, out, &WriterOptions::default(), None, setup)
})
.expect("plain writer route succeeds");
assert!(
output
.windows(b"<73657475702d69642d30>".len())
.any(|window| window == b"<73657475702d69642d30>"),
"plain route must emit the ID prepared by the shared writer setup"
);
}
#[test]
fn missing_source_id_emits_qpdf_copy_accessor_warning_chain() {
let mut pdf = Pdf::empty().expect("empty PDF supplies a warning context");
let id = pdf.trailer_key_handle(b"ID");
let _ = source_permanent_id_value_handle(&id);
let messages: Vec<_> = pdf
.repair_diagnostics()
.entries()
.iter()
.map(|entry| String::from_utf8_lossy(entry.what_bytes()).into_owned())
.collect();
assert_eq!(
messages.len(),
2,
"qpdf copy path must warn for both accessors"
);
assert!(messages[0]
.contains("operation for array attempted on object of type null: returning null"));
assert!(messages[1].contains(
"null returned from invalid array access: operation for string attempted on object of type null: returning empty string"
));
}
#[test]
fn generate_planning_rejects_a_missing_setup_snapshot() {
let mut pdf = Pdf::open(std::io::Cursor::new(
include_bytes!("../../../tests/fixtures/compat/one-page-no-ext.pdf").to_vec(),
))
.expect("open specialized Generate fixture");
let setup = WriterSetupState {
generated_id: Some(generate_id_handle(None, true)),
encryption_parameters: None,
source_object_stream_data: BTreeMap::new(),
generated_compressible: None,
generated_object_stream_sources: Vec::new(),
};
let options = WriterOptions {
object_streams: ObjectStreamMode::Generate,
preserve_unreferenced_objects: true,
extra_header_text: "% specialized-live-queue\n".to_string(),
static_id: true,
..WriterOptions::default()
};
let error = output::with_buffer_sink(&mut Vec::new(), |out| {
emit_canonical_pdf_inner(&mut pdf, out, &options, None, setup)
})
.expect_err("Generate planning must require the setup snapshot");
assert!(
matches!(&error, Error::Internal(message)
if message == "Generate object-stream planning requires the writer setup snapshot"),
"unexpected error: {error}"
);
}
struct AlwaysFailingOutput;
impl Write for AlwaysFailingOutput {
fn write(&mut self, _bytes: &[u8]) -> io::Result<usize> {
Err(io::Error::other("writer test output failure"))
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
struct FinishFailingPipeline {
writes: Rc<std::cell::Cell<usize>>,
finishes: Rc<std::cell::Cell<usize>>,
}
impl Pipeline for FinishFailingPipeline {
fn identifier(&self) -> &str {
"writer test finish failure"
}
fn write(&mut self, _data: &[u8]) -> PipelineResult<()> {
self.writes.set(self.writes.get() + 1);
Ok(())
}
fn finish(&mut self) -> PipelineResult<()> {
self.finishes.set(self.finishes.get() + 1);
Err(PipelineError::runtime(
"writer stream segment finish failure",
))
}
}
#[test]
fn writer_pipeline_surfaces_a_segment_finish_failure_after_writing() {
let writes = Rc::new(std::cell::Cell::new(0));
let finishes = Rc::new(std::cell::Cell::new(0));
let mut pipeline = FinishFailingPipeline {
writes: Rc::clone(&writes),
finishes: Rc::clone(&finishes),
};
assert_eq!(pipeline.identifier(), "writer test finish failure");
let error = run_writer_pipeline(&mut pipeline, b"stream payload")
.expect_err("a segment finish failure must escape the writer pipeline");
assert!(error
.to_string()
.contains("writer stream segment finish failure"));
assert_eq!(writes.get(), 1, "the segment payload was written once");
assert_eq!(finishes.get(), 1, "the segment was finished once");
}
fn stream_encryption_context(
cipher: WriteCipher,
file_key: Vec<u8>,
static_aes_iv: bool,
) -> EncryptionContext {
EncryptionContext {
encrypt_dict: ObjectHandle::dictionary(Vec::new()),
file_key,
cipher,
encryption_v: match cipher {
WriteCipher::FileKeyAes256 => 5,
WriteCipher::PerObject(ObjectKeyAlg::Aes) => 4,
WriteCipher::PerObject(ObjectKeyAlg::Rc4) => 2,
},
encryption_r: match cipher {
WriteCipher::FileKeyAes256 => 6,
WriteCipher::PerObject(ObjectKeyAlg::Aes) => 4,
WriteCipher::PerObject(ObjectKeyAlg::Rc4) => 3,
},
encrypt_ref: ObjectRef::new(99, 0),
id0: b"id".to_vec(),
static_aes_iv,
encrypt_metadata: true,
metadata_ref: None,
}
}
#[test]
fn stream_pipeline_covers_plain_empty_key_rc4_and_aes_stage_routes() {
let data = b"stream payload";
let mut plain = Vec::new();
output::with_buffer_sink(&mut plain, |out| {
pipe_writer_stream_payload(
out,
data,
ObjectRef::new(3, 0),
&stream_encryption_context(
WriteCipher::PerObject(ObjectKeyAlg::Rc4),
Vec::new(),
true,
),
false,
None,
)
})
.expect("disabled stream encryption leaves payload plain");
assert_eq!(plain, data);
let mut empty_file_key = Vec::new();
output::with_buffer_sink(&mut empty_file_key, |out| {
pipe_writer_stream_payload(
out,
data,
ObjectRef::new(3, 0),
&stream_encryption_context(WriteCipher::FileKeyAes256, Vec::new(), true),
true,
None,
)
})
.expect("an empty V5 file key uses the cleartext pipeline fallback");
assert_eq!(empty_file_key, data);
for (static_aes_iv, explicit_iv) in [(true, Some([4; 16])), (false, None)] {
let mut short_aes = Vec::new();
let error = output::with_buffer_sink(&mut short_aes, |out| {
pipe_writer_stream_payload(
out,
data,
ObjectRef::new(3, 0),
&stream_encryption_context(
WriteCipher::FileKeyAes256,
vec![1; 15],
static_aes_iv,
),
true,
explicit_iv,
)
})
.expect_err("a short AES key must be rejected by the encryption pipeline");
assert!(error.to_string().contains("at least 16"));
}
let mut rc4 = Vec::new();
output::with_buffer_sink(&mut rc4, |out| {
pipe_writer_stream_payload(
out,
data,
ObjectRef::new(3, 0),
&stream_encryption_context(
WriteCipher::PerObject(ObjectKeyAlg::Rc4),
vec![1; 5],
true,
),
true,
None,
)
})
.expect("RC4 stage writes ciphertext");
assert_eq!(rc4.len(), data.len());
assert_ne!(rc4, data);
for explicit_iv in [Some([2; 16]), None] {
let mut aes = Vec::new();
output::with_buffer_sink(&mut aes, |out| {
pipe_writer_stream_payload(
out,
data,
ObjectRef::new(3, 0),
&stream_encryption_context(
WriteCipher::PerObject(ObjectKeyAlg::Aes),
vec![1; 16],
explicit_iv.is_some(),
),
true,
explicit_iv,
)
})
.expect("AES stage writes IV-prefixed ciphertext");
assert!(aes.len() >= 32);
assert_ne!(&aes[..data.len()], data);
}
let mut aes256 = Vec::new();
output::with_buffer_sink(&mut aes256, |out| {
pipe_writer_stream_payload(
out,
data,
ObjectRef::new(3, 0),
&stream_encryption_context(WriteCipher::FileKeyAes256, vec![1; 32], true),
true,
Some([3; 16]),
)
})
.expect("AES-256 stage writes IV-prefixed ciphertext");
assert!(aes256.len() >= 32);
assert_ne!(&aes256[..data.len()], data);
}
#[test]
fn output_sink_pipeline_reports_its_stage_identity() {
let mut bytes = Vec::new();
let mut out = OutputSink::new(&mut bytes);
let mut failure = None;
let mut pipeline = OutputSinkPipeline {
out: &mut out,
failure: &mut failure,
};
assert_eq!(pipeline.identifier(), "writer stream output");
pipeline
.finish()
.expect("sink tail has no nested finish work");
}
fn shared_trailer_contract_fixture(
) -> (Pdf<Cursor<Vec<u8>>>, ObjectHandle, ObjectRef, ObjectRef) {
let pdf = Pdf::empty().expect("empty PDF for trailer fixture");
let root = pdf
.make_indirect_from_object_handle(ObjectHandle::integer(2))
.expect("indirect root fixture");
let encrypt = pdf
.make_indirect_from_object_handle(ObjectHandle::integer(3))
.expect("indirect encryption fixture");
let root_ref = root.object_ref().expect("root object reference");
let encrypt_ref = encrypt.object_ref().expect("encryption object reference");
let trailer = ObjectHandle::dictionary(vec![
(b"/Info".to_vec(), ObjectHandle::integer(1)),
(b"/Name".to_vec(), ObjectHandle::name(b"N".to_vec())),
(b"/CustomRef".to_vec(), root.clone()),
(b"/Root".to_vec(), root),
(b"/Size".to_vec(), ObjectHandle::integer(99)),
(b"/NullEntry".to_vec(), ObjectHandle::null()),
(
b"/ID".to_vec(),
ObjectHandle::array(vec![
ObjectHandle::string(b"id0".to_vec()),
ObjectHandle::string(b"id1".to_vec()),
]),
),
(b"/Encrypt".to_vec(), encrypt),
]);
(pdf, trailer, root_ref, encrypt_ref)
}
#[test]
fn shared_trailer_contract_emits_normal_qdf_and_linearized_forms() {
let (_pdf, trailer, root_ref, encrypt_ref) = shared_trailer_contract_fixture();
let map = |object_ref| Ok(object_ref);
let removed = BTreeSet::new();
let mut normal = Vec::new();
output::with_buffer_sink(&mut normal, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::Normal { size: 6 },
false,
false,
None,
&map,
&removed,
true,
)
})
.expect("normal shared trailer succeeds");
assert_eq!(
normal,
format!(
"trailer << /CustomRef {} 0 R /Info 1 /Name /N /Root {} 0 R /Size 6 /ID [<696430><696431>] /Encrypt {} 0 R >>",
root_ref.number, root_ref.number, encrypt_ref.number
)
.as_bytes()
);
let mut qdf = Vec::new();
output::with_buffer_sink(&mut qdf, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::Normal { size: 6 },
false,
true,
None,
&map,
&removed,
true,
)
})
.expect("QDF shared trailer succeeds");
assert_eq!(
qdf,
format!(
"trailer <<\n /CustomRef {} 0 R\n /Info 1\n /Name /N\n /Root {} 0 R\n /Size 6\n /ID [<696430><696431>] /Encrypt {} 0 R\n>>\n",
root_ref.number, root_ref.number, encrypt_ref.number
)
.as_bytes()
);
let mut first = Vec::new();
output::with_buffer_sink(&mut first, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::LinearizedFirst { size: 6, prev: 123 },
false,
false,
None,
&map,
&removed,
true,
)
})
.expect("linearized first trailer succeeds");
let first_text = String::from_utf8(first).expect("trailer is UTF-8");
let prev_start = first_text.find("/Prev ").expect("/Prev is present") + 6;
assert_eq!(
&first_text.as_bytes()[prev_start..prev_start + 21],
b"123 "
);
assert!(first_text.ends_with(&format!(
" /ID [<696430><696431>] /Encrypt {} 0 R >>",
encrypt_ref.number
)));
let mut second = b"<< /Type /XRef".to_vec();
output::with_buffer_sink(&mut second, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::LinearizedSecond { size: 6 },
true,
false,
None,
&map,
&removed,
true,
)
})
.expect("linearized second xref trailer succeeds");
assert_eq!(second, b"<< /Type /XRef /Size 6 /ID [<696430><696431>] >>");
}
#[test]
fn shared_trailer_contract_qdf_xref_stream_omits_trailer_keyword_but_keeps_newline() {
let (_pdf, trailer, root_ref, encrypt_ref) = shared_trailer_contract_fixture();
let map = |object_ref| Ok(object_ref);
let removed = BTreeSet::new();
let mut output = b"<< /Type /XRef".to_vec();
output::with_buffer_sink(&mut output, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::Normal { size: 6 },
true,
true,
None,
&map,
&removed,
true,
)
})
.expect("QDF xref-stream-embedded trailer succeeds");
assert_eq!(
output,
format!(
"<< /Type /XRef\n /CustomRef {} 0 R\n /Info 1\n /Name /N\n /Root {} 0 R\n /Size 6\n /ID [<696430><696431>] /Encrypt {} 0 R\n>>\n",
root_ref.number, root_ref.number, encrypt_ref.number
)
.as_bytes()
);
}
#[test]
fn linearized_second_trailer_synthesizes_a_missing_size_like_qpdf() {
let (_pdf, trailer, _root_ref, _encrypt_ref) = shared_trailer_contract_fixture();
trailer.remove_key(b"/Size");
let mut output = Vec::new();
output::with_buffer_sink(&mut output, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::LinearizedSecond { size: 9 },
false,
false,
None,
&|object_ref| Ok(object_ref), &BTreeSet::new(),
true,
)
})
.expect("linearized second trailer succeeds without source /Size");
assert_eq!(output, b"trailer << /Size 9 /ID [<696430><696431>] >>");
let mut qdf_output = Vec::new();
output::with_buffer_sink(&mut qdf_output, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::LinearizedSecond { size: 9 },
false,
true,
None,
&|object_ref| Ok(object_ref), &BTreeSet::new(),
true,
)
})
.expect("QDF linearized second trailer succeeds without source /Size");
assert_eq!(
qdf_output,
b"trailer <<\n /Size 9\n /ID [<696430><696431>]\n>>\n"
);
}
#[test]
fn shared_trailer_contract_preserves_writer_owned_keys_and_id_writer() {
let (_pdf, trailer, root_ref, encrypt_ref) = shared_trailer_contract_fixture();
let map = |object_ref: ObjectRef| -> Result<ObjectRef> {
Ok(ObjectRef::new(object_ref.number + 100, 0))
};
let removed = BTreeSet::new();
let mut output = Vec::new();
let mut id_writer = |out: &mut OutputSink<'_>| out.write_bytes(b"[<custom>]");
output::with_buffer_sink(&mut output, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::Normal { size: 7 },
false,
false,
Some(&mut id_writer),
&map,
&removed,
true,
)
})
.expect("writer-owned trailer values survive filtering");
let text = String::from_utf8(output).expect("trailer is UTF-8");
assert!(!text.contains("/NullEntry"));
assert!(text.contains(&format!("/Root {} 0 R", root_ref.number)));
assert!(text.contains(&format!(
"/ID [<custom>] /Encrypt {} 0 R",
encrypt_ref.number
)));
}
#[test]
fn shared_trailer_contract_rejects_reserved_and_non_dictionary_handles() {
let reserved = ObjectHandle::new_reserved_direct();
let error = output::with_buffer_sink(&mut Vec::new(), |out| {
reserved.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::Normal { size: 1 },
false,
false,
None,
&|object_ref| Ok(object_ref), &BTreeSet::new(),
true,
)
})
.expect_err("reserved trailer handle must fail");
assert!(matches!(error, Error::System(message) if message.contains("reserved")));
let scalar = ObjectHandle::integer(1);
let mut output = Vec::new();
output::with_buffer_sink(&mut output, |out| {
scalar.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::Normal { size: 1 },
false,
false,
None,
&|object_ref| Ok(object_ref), &BTreeSet::new(),
true,
)
})
.expect("non-dictionary trailer is emitted as an empty shell");
assert_eq!(output, b"trailer << >>");
}
#[test]
fn shared_trailer_contract_maps_a_direct_qdf_root() {
let trailer = ObjectHandle::dictionary(vec![
(
b"/Root".to_vec(),
ObjectHandle::dictionary(vec![(b"/Pages".to_vec(), ObjectHandle::integer(3))]),
),
(b"/Size".to_vec(), ObjectHandle::integer(1)),
]);
let map = |object_ref: ObjectRef| -> Result<ObjectRef> {
Ok(ObjectRef::new(object_ref.number + 100, 0))
};
let mut output = Vec::new();
output::with_buffer_sink(&mut output, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::Normal { size: 1 },
false,
true,
None,
&map,
&BTreeSet::new(),
true,
)
})
.expect("direct QDF Catalog is emitted");
let text = String::from_utf8(output).expect("trailer is UTF-8");
assert!(text.contains("/Pages 3"));
}
#[test]
fn shared_trailer_contract_filters_a_removed_reference() {
let pdf = Pdf::empty().expect("empty PDF for removed-reference test");
let custom = pdf
.make_indirect_from_object_handle(ObjectHandle::integer(3))
.expect("indirect custom trailer value");
let custom_ref = custom.object_ref().expect("custom object reference");
let trailer = ObjectHandle::dictionary(vec![
(b"/CustomRef".to_vec(), custom),
(b"/Size".to_vec(), ObjectHandle::integer(2)),
]);
let mut output = Vec::new();
output::with_buffer_sink(&mut output, |out| {
trailer.write_trailer_with_ref_map_and_kind(
out,
TrailerKind::Normal { size: 2 },
false,
false,
None,
&|object_ref| Ok(object_ref), &[custom_ref].into_iter().collect(),
true,
)
})
.expect("removed trailer reference is filtered");
assert!(!String::from_utf8(output)
.expect("trailer is UTF-8")
.contains("/CustomRef"));
}
#[test]
fn prepare_file_for_write_fixes_dangling_cache_before_catalog_directization() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/one-page-ext-indirect.pdf").to_vec(),
))
.expect("indirect Extensions fixture opens");
assert!(!pdf.dangling_references_fixed());
prepare_file_for_write(&mut pdf).expect("writer preparation succeeds");
assert!(
pdf.dangling_references_fixed(),
"fixDanglingReferences must resolve the source xref before Catalog work"
);
let root = pdf.root_handle().expect("Catalog remains available");
assert!(
root.try_get_key(b"/Extensions")
.expect("read prepared Extensions")
.is_direct(),
"an indirect Extensions dictionary must be direct on the live Catalog"
);
}
#[test]
fn prepare_file_for_write_directizes_an_indirect_adbe_child() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/one-page-ext-indirect.pdf").to_vec(),
))
.expect("indirect Extensions fixture opens");
let root = pdf.root_handle().expect("Catalog exists");
let extensions = root
.try_get_key(b"/Extensions")
.expect("read source Extensions");
let adbe = extensions.try_get_key(b"/ADBE").expect("read source ADBE");
let indirect_adbe = pdf
.make_indirect_from_object_handle(adbe)
.expect("promote ADBE to an indirect object");
extensions
.replace_key(b"/ADBE", indirect_adbe)
.expect("install indirect ADBE");
prepare_file_for_write(&mut pdf).expect("writer preparation succeeds");
let root = pdf.root_handle().expect("Catalog remains available");
let extensions = root
.try_get_key(b"/Extensions")
.expect("read prepared Extensions");
assert!(extensions.is_direct());
assert!(
extensions
.try_get_key(b"/ADBE")
.expect("read prepared ADBE")
.is_direct(),
"an indirect ADBE value must be made direct by prepareFileForWrite"
);
}
#[test]
fn prepare_file_for_write_survives_a_later_emission_failure() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/one-page-ext-indirect.pdf").to_vec(),
))
.expect("indirect Extensions fixture opens");
let mut writer = PdfWriter::new(&mut pdf);
let mut output = AlwaysFailingOutput;
assert!(output.flush().is_ok());
writer
.set_output_writer(output)
.expect("install failing output");
assert!(writer.write().is_err(), "the output sink must fail");
let root = pdf.root_handle().expect("Catalog remains available");
assert!(
root.try_get_key(b"/Extensions")
.expect("read prepared Extensions after failure")
.is_direct(),
"a later write failure must not restore the pre-prepare indirect graph"
);
}
#[test]
fn write_reports_qpdf_logic_error_for_deterministic_id_with_preserved_encryption() {
for (static_id, expected_message, dangling_refs_fixed_expected) in [
(
false,
"INTERNAL ERROR: QPDFWriter::generateID has no data for deterministic ID",
false,
),
(
true,
"Deterministic ID computation enabled after ID generation has already occurred.",
true,
),
] {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/encrypted-recovered-eol.pdf")
.to_vec(),
))
.expect("encrypted, reconstructed-xref fixture opens with its empty password");
assert!(
!pdf.dangling_references_fixed(),
"static_id={static_id}: opening must not eagerly fix dangling references"
);
let mut writer = PdfWriter::new(&mut pdf);
writer.set_static_id(static_id);
writer.set_deterministic_id(true);
writer
.set_output_writer(Vec::new())
.expect("install an in-memory output sink");
let error = writer
.write()
.expect_err("deterministic ID with preserved encryption must fail");
assert!(
matches!(error, Error::Internal(ref message) if message.starts_with(expected_message)),
"static_id={static_id}: unexpected error {error:?}"
);
assert_eq!(
pdf.dangling_references_fixed(),
dangling_refs_fixed_expected,
"static_id={static_id}: qpdf's getObjectCount() dangling-reference fixup runs \
before the static-ID pushMD5Pipeline failure, but before the non-static-ID \
generateID failure, which happens earlier still, inside doWriteSetup"
);
}
}
#[test]
fn deterministic_id_fails_even_when_a_forced_version_disables_the_encryption() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/encrypted-recovered-eol.pdf").to_vec(),
))
.expect("encrypted, reconstructed-xref fixture opens with its empty password");
let mut writer = PdfWriter::new(&mut pdf);
writer.set_static_id(true);
writer.set_deterministic_id(true);
writer.force_pdf_version("1.3", 0);
writer
.set_output_writer(Vec::new())
.expect("install an in-memory output sink");
let error = writer
.write()
.expect_err("a forced version must not let deterministic ID through");
assert!(
matches!(
error,
Error::Internal(ref message)
if message.starts_with(
"Deterministic ID computation enabled after ID generation has already occurred."
)
),
"unexpected error {error:?}"
);
}
#[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 malformed_v4_aes256_parameters_use_the_r4_aes_floor() {
let encryption = EncryptionParameters {
encrypt_dict: ObjectHandle::dictionary(Vec::new()),
file_key: vec![1; 32],
cipher: WriteCipher::FileKeyAes256,
encryption_v: 4,
encryption_r: 4,
id0: b"id".to_vec(),
static_aes_iv: true,
encrypt_metadata: true,
metadata_ref: None,
};
assert_eq!(
effective_pdf_version_and_ext_with_encryption(
"1.4",
0,
&WriterOptions::default(),
false,
Some(&encryption),
),
("1.6", 0)
);
}
#[test]
fn encryption_version_floor_is_keyed_on_revision_like_qpdf() {
for (v, r, cipher, expected) in [
(1, 4, WriteCipher::PerObject(ObjectKeyAlg::Rc4), ("1.5", 0)),
(1, 5, WriteCipher::PerObject(ObjectKeyAlg::Rc4), ("1.7", 3)),
(1, 6, WriteCipher::PerObject(ObjectKeyAlg::Rc4), ("1.7", 8)),
(2, 4, WriteCipher::PerObject(ObjectKeyAlg::Rc4), ("1.5", 0)),
(4, 3, WriteCipher::PerObject(ObjectKeyAlg::Aes), ("1.4", 0)),
(4, 4, WriteCipher::PerObject(ObjectKeyAlg::Aes), ("1.6", 0)),
(4, 4, WriteCipher::PerObject(ObjectKeyAlg::Rc4), ("1.5", 0)),
(4, 5, WriteCipher::PerObject(ObjectKeyAlg::Aes), ("1.7", 3)),
(4, 6, WriteCipher::PerObject(ObjectKeyAlg::Aes), ("1.7", 8)),
(5, 3, WriteCipher::FileKeyAes256, ("1.4", 0)),
(5, 4, WriteCipher::FileKeyAes256, ("1.6", 0)),
(5, 5, WriteCipher::FileKeyAes256, ("1.7", 3)),
(5, 6, WriteCipher::FileKeyAes256, ("1.7", 8)),
] {
let encryption = EncryptionParameters {
encrypt_dict: ObjectHandle::dictionary(Vec::new()),
file_key: vec![1; 32],
cipher,
encryption_v: v,
encryption_r: r,
id0: b"id".to_vec(),
static_aes_iv: true,
encrypt_metadata: true,
metadata_ref: None,
};
assert_eq!(
effective_pdf_version_and_ext_with_encryption(
"1.3",
0,
&WriterOptions::default(),
false,
Some(&encryption),
),
expected,
"V={v} R={r} must use qpdf's R-keyed floor"
);
}
}
#[test]
fn effective_version_preserves_a_lower_source_version() {
let options = WriterOptions::default();
assert_eq!(effective_pdf_version("1.1", &options, false), "1.1");
}
#[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),
("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),
("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),
("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),
("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),
("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)),
]),
writer_length_bits: None,
file_key: vec![0; 16],
padded_user_password: Vec::new(),
id0: vec![0; 16],
object_key_alg: ObjectKeyAlg::Rc4,
}),
..WriterOptions::default()
};
assert_eq!(encryption_shape(&options), Some((4, 4, true)));
}
#[test]
fn canonical_writer_rejects_mutually_exclusive_encryption_modes() {
let mut pdf = Pdf::empty().expect("empty PDF");
let options = WriterOptions {
encrypt: Some(EncryptParams::v4_aes128(b"user", b"owner")),
copy_encryption: Some(CopyEncryptionSource {
encrypt_dict: ObjectHandle::dictionary(vec![
(b"/V".to_vec(), ObjectHandle::integer(4)),
(b"/R".to_vec(), ObjectHandle::integer(4)),
]),
writer_length_bits: None,
file_key: vec![0; 16],
padded_user_password: Vec::new(),
id0: vec![0; 16],
object_key_alg: ObjectKeyAlg::Rc4,
}),
..WriterOptions::default()
};
let setup = WriterSetupState {
generated_id: None,
encryption_parameters: None,
source_object_stream_data: BTreeMap::new(),
generated_compressible: None,
generated_object_stream_sources: Vec::new(),
};
let error = output::with_buffer_sink(&mut Vec::new(), |out| {
emit_canonical_pdf_inner(&mut pdf, out, &options, None, setup)
})
.expect_err("encrypt and copy_encryption must not be combined");
assert!(error.to_string().contains("mutually exclusive"));
}
#[test]
fn job_writer_password_normalization_covers_each_encryption_revision() {
let mut empty = WriterConfiguration::default();
assert_eq!(
empty
.normalize_encryption_passwords(PasswordMode::Bytes)
.unwrap(),
Vec::<PasswordWriteNotice>::new()
);
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(),
vec![PasswordWriteNotice::None, PasswordWriteNotice::None]
);
}
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(),
vec![PasswordWriteNotice::None, PasswordWriteNotice::None]
);
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 job_writer_password_normalization_reports_owner_password_errors() {
let mut configuration = WriterConfiguration::default();
configuration.set_encryption_parameters(EncryptParams::v4_aes128(
"café".as_bytes().to_vec(),
b"bad\xff".to_vec(),
));
let error = configuration
.normalize_encryption_passwords(PasswordMode::Unicode)
.expect_err("an invalid owner password must fail Unicode normalization");
assert!(matches!(
error,
crate::Error::System(message)
if message == "supplied password is not valid UTF-8"
));
}
#[test]
fn writer_setup_shares_encryption_parameters_across_route_slots() {
let mut pdf = Pdf::empty().expect("empty PDF for writer setup");
let options = WriterOptions {
encrypt: Some(EncryptParams::v4_aes128(b"user", b"owner")),
..WriterOptions::default()
};
let setup = build_writer_setup(&mut pdf, &options).expect("setup succeeds");
let parameters = setup
.encryption_parameters
.as_ref()
.expect("explicit encryption builds one shared parameter state");
let standard = parameters.clone().into_context(ObjectRef::new(7, 0));
let linearized = parameters.clone().into_context(ObjectRef::new(12, 0));
assert_eq!(standard.encrypt_ref, ObjectRef::new(7, 0));
assert_eq!(linearized.encrypt_ref, ObjectRef::new(12, 0));
assert_eq!(standard.id0, linearized.id0);
assert_eq!(standard.file_key, linearized.file_key);
assert_eq!(standard.encryption_v, linearized.encryption_v);
assert_eq!(standard.encryption_r, linearized.encryption_r);
assert_eq!(
standard
.encrypt_dict
.try_get_key(b"/V")
.unwrap()
.try_as_integer()
.unwrap(),
linearized
.encrypt_dict
.try_get_key(b"/V")
.unwrap()
.try_as_integer()
.unwrap()
);
}
#[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)),
]),
writer_length_bits: None,
file_key: vec![0; 16],
padded_user_password: Vec::new(),
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])),
]),
writer_length_bits: None,
file_key: vec![0; 32],
padded_user_password: Vec::new(),
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 copied_negative_length_is_out_of_range() {
let source = CopyEncryptionSource {
encrypt_dict: ObjectHandle::dictionary(vec![
(b"/V".to_vec(), ObjectHandle::integer(2)),
(b"/R".to_vec(), ObjectHandle::integer(3)),
(b"/Length".to_vec(), ObjectHandle::integer(-8)),
(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])),
]),
writer_length_bits: None,
file_key: vec![0; 16],
padded_user_password: b"user".to_vec(),
id0: vec![0; 16],
object_key_alg: ObjectKeyAlg::Rc4,
};
let error = canonical_copy_encryption(&source)
.expect_err("a negative /Length has no valid key length");
assert!(
matches!(&error, crate::Error::System(message) if message.contains("-8")),
"unexpected error: {error}"
);
}
#[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_string()
.contains("error decoding stream data for object")
&& entry.message_string().contains("zlib stream error")
}),
"qpdf reports the invalid deflate initialization as a stream warning"
);
assert!(
pdf.repair_diagnostics().entries().iter().any(|entry| {
entry
.message_string()
.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);
page_handle.try_is_scalar().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 output = write_qpdf_to_memory(&mut pdf, |writer| {
writer.set_pclm(true);
writer.set_static_id(true);
})
.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 pclm_deterministic_route_emits_source_and_synthetic_streams_with_requested_framing() {
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);
page_handle.try_is_scalar().expect("page resolves");
let replacement = page_handle.shallow_copy().expect("page is copyable");
let source_stream = pdf
.new_stream_with_data(Rc::new(b"source-payload".to_vec()))
.expect("source stream");
let image = pdf
.new_stream_with_data(Rc::new(b"image".to_vec()))
.expect("image stream");
replacement
.replace_key(b"/ExtraStream", source_stream)
.expect("attach source stream");
replacement
.replace_key(
b"/Resources",
ObjectHandle::dictionary(vec![(
b"/XObject".to_vec(),
ObjectHandle::dictionary(vec![(b"/Im0".to_vec(), image)]),
)]),
)
.expect("attach page image");
pdf.replace_object(page, replacement).expect("replace page");
let output = write_qpdf_to_memory(&mut pdf, |writer| {
writer.set_pclm(true);
writer.set_deterministic_id(true);
writer.set_extra_header_text("%coverage-header");
writer.set_newline_before_endstream(true);
})
.expect("PCLm deterministic route succeeds");
assert!(output.starts_with(b"%PDF-1.4\n%PCLm 1.0\n%coverage-header\n"));
assert!(output
.windows(b"source-payload\nendstream".len())
.any(|window| window == b"source-payload\nendstream"));
assert!(output
.windows(b"q /image Do Q\n".len())
.any(|window| window == b"q /image Do Q\n"));
assert!(output
.windows(b"/ID [".len())
.any(|window| window == b"/ID ["));
}
#[test]
fn direct_page_content_stream_marks_the_page_as_its_emission_container() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/direct-root-one-page.pdf").to_vec(),
))
.expect("minimal fixture must open");
let page = crate::pages::page_refs(&mut pdf).expect("page refs")[0];
let direct_stream = ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(1))]),
Rc::new(b"q".to_vec()),
);
let page_handle = pdf.get_object_handle(page);
page_handle
.replace_key(b"/Contents", direct_stream)
.expect("install direct page content stream");
let mut containers = BTreeSet::new();
collect_content_container_qpdf_obj_gens(&page_handle, &mut containers)
.expect("collect direct content container");
assert_eq!(
containers,
[QpdfObjGen::from_valid_object_ref_for_test(page)]
.into_iter()
.collect()
);
}
#[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 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 special_stream_setup_populates_qpdf_page_content_and_normalization_maps() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/qdf-contents-ref-array.pdf").to_vec(),
))
.expect("contents-array fixture");
let options = WriterOptions {
qdf: true,
content_normalization: true,
..WriterOptions::default()
};
let streams = initialize_special_streams(&mut pdf, &options)
.expect("special-stream setup succeeds")
.expect("qdf setup must create a snapshot");
let page = QpdfObjGen::new(3, 0);
assert_eq!(streams.pages, vec![page]);
assert_eq!(streams.page_seq.get(&page), Some(&1));
assert_eq!(streams.contents_seq.get(&QpdfObjGen::new(6, 0)), Some(&1));
assert_eq!(streams.contents_seq.get(&QpdfObjGen::new(7, 0)), Some(&1));
assert!(streams
.normalized_streams_raw()
.contains(&QpdfObjGen::new(6, 0)));
assert!(streams
.normalized_streams_raw()
.contains(&QpdfObjGen::new(7, 0)));
assert!(streams
.content_container_refs
.contains(&QpdfObjGen::new(5, 0)));
}
#[test]
fn special_stream_setup_accepts_raw_page_identity() {
let mut pdf = Pdf::empty().expect("empty PDF");
let page_tree = pdf
.root_handle()
.expect("Catalog")
.try_get_key(b"/Pages")
.expect("page tree");
let raw_page_ref = ObjectRef::new(5, 65_535);
let raw_contents_ref = ObjectRef::new(6, 65_535);
let raw_contents = pdf.get_object_handle_by_raw_identity(6, 65_535);
pdf.replace_object(
raw_contents_ref,
ObjectHandle::stream(
ObjectHandle::dictionary(vec![(b"/Length".to_vec(), ObjectHandle::integer(4))]),
Rc::new(b"q Q\n".to_vec()),
),
)
.expect("install raw content stream");
let raw_page = pdf.get_object_handle_by_raw_identity(5, 65_535);
pdf.replace_object(
raw_page_ref,
ObjectHandle::dictionary(vec![
(b"/Type".to_vec(), ObjectHandle::name(b"Page".to_vec())),
(b"/Parent".to_vec(), page_tree.clone()),
(
b"/MediaBox".to_vec(),
ObjectHandle::array(vec![
ObjectHandle::integer(0),
ObjectHandle::integer(0),
ObjectHandle::integer(612),
ObjectHandle::integer(792),
]),
),
(b"/Contents".to_vec(), raw_contents),
]),
)
.expect("install raw page");
page_tree
.replace_key(b"/Kids", ObjectHandle::array(vec![raw_page]))
.expect("attach raw page");
page_tree
.replace_key(b"/Count", ObjectHandle::integer(1))
.expect("set page count");
let options = WriterOptions {
qdf: true,
content_normalization: true,
decode_level: DecodeLevel::All,
..WriterOptions::default()
};
let streams = initialize_special_streams(&mut pdf, &options)
.expect("writer setup must preserve raw identity")
.expect("QDF creates the special-stream snapshot");
let page_gen = QpdfObjGen::new(5, 65_535);
let content_gen = QpdfObjGen::new(6, 65_535);
assert_eq!(streams.pages, vec![page_gen]);
assert_eq!(streams.page_seq.get(&page_gen), Some(&1));
assert_eq!(streams.contents_seq.get(&content_gen), Some(&1));
assert!(streams.normalized_streams_raw().contains(&content_gen));
}
#[test]
fn special_stream_setup_includes_a_non_stream_contents_array_member() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/qdf-contents-non-stream-member.pdf")
.to_vec(),
))
.expect("non-stream-member fixture");
let options = WriterOptions {
qdf: true,
..WriterOptions::default()
};
let streams = initialize_special_streams(&mut pdf, &options)
.expect("special-stream setup succeeds")
.expect("qdf setup must create a snapshot");
let page = QpdfObjGen::new(3, 0);
let stream_member = QpdfObjGen::new(5, 0);
let non_stream_member = QpdfObjGen::new(4, 0);
assert_eq!(streams.pages, vec![page]);
assert_eq!(streams.contents_seq.get(&stream_member), Some(&1));
assert_eq!(
streams.contents_seq.get(&non_stream_member),
Some(&1),
"a non-stream /Contents array member must still get a page-sequence entry, like qpdf"
);
assert!(streams.normalized_streams_raw().contains(&stream_member));
assert!(
streams
.normalized_streams_raw()
.contains(&non_stream_member),
"a non-stream /Contents array member must still be in normalized_streams, like qpdf"
);
}
#[test]
fn special_stream_setup_repairs_decode_only_without_enabling_container_markers() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/qdf-contents-ref-array.pdf").to_vec(),
))
.expect("contents-array fixture");
let options = WriterOptions {
decode_level: DecodeLevel::Generalized,
..WriterOptions::default()
};
let streams = initialize_special_streams(&mut pdf, &options)
.expect("decode-only setup succeeds")
.expect("decode-only setup must repair and snapshot pages");
assert_eq!(streams.pages, vec![QpdfObjGen::new(3, 0)]);
assert_eq!(streams.page_seq.get(&QpdfObjGen::new(3, 0)), Some(&1));
assert!(streams
.normalized_streams_raw()
.contains(&QpdfObjGen::new(6, 0)));
assert!(streams
.normalized_streams_raw()
.contains(&QpdfObjGen::new(7, 0)));
assert!(streams.content_container_refs.is_empty());
}
#[test]
fn direct_canonical_writer_propagates_special_stream_setup_failure() {
let mut pdf = Pdf::empty().expect("empty PDF");
pdf.trailer().remove_key(b"/Root");
let options = WriterOptions {
qdf: true,
..WriterOptions::default()
};
let result = emit_canonical_pdf(&mut pdf, Vec::new(), &options);
assert!(matches!(result, Err(Error::Missing("/Root"))));
}
#[test]
fn root_object_emission_reconciles_shared_extensions_like_qpdf() {
let extensions = ObjectHandle::dictionary(vec![
(b"/ADBE".to_vec(), ObjectHandle::dictionary(vec![])),
(b"/ACME".to_vec(), ObjectHandle::integer(1)),
]);
let root = ObjectHandle::dictionary(vec![(b"/Extensions".to_vec(), extensions.clone())]);
let map = |object_ref| Ok(object_ref);
let removed = BTreeSet::new();
let mut output = Vec::new();
output::with_buffer_sink(&mut output, |out| {
root.unparse_root_object_with_ref_map_and_removed(out, &map, &removed, "1.7", 8, true)
})
.expect("root output succeeds");
assert_eq!(
extensions
.try_get_key(b"/ADBE")
.unwrap()
.try_get_key(b"/ExtensionLevel")
.unwrap()
.try_as_integer()
.unwrap(),
Some(8)
);
output.clear();
output::with_buffer_sink(&mut output, |out| {
root.unparse_root_object_with_ref_map_and_removed(out, &map, &removed, "1.7", 0, true)
})
.expect("root output succeeds");
assert!(extensions.try_get_key(b"/ADBE").unwrap().is_null());
assert_eq!(
extensions
.try_get_key(b"/ACME")
.unwrap()
.try_as_integer()
.unwrap(),
Some(1)
);
}
#[test]
fn root_object_emission_failure_retains_shared_extensions_reconciliation() {
let extensions =
ObjectHandle::dictionary(vec![(b"/ACME".to_vec(), ObjectHandle::integer(1))]);
let root = ObjectHandle::dictionary(vec![
(b"/Extensions".to_vec(), extensions.clone()),
(
b"/Pages".to_vec(),
ObjectHandle::new_indirect_unresolved(ObjectRef::new(2, 0), -1),
),
]);
let map = |_| Err(Error::Internal("test reference mapping failure".into()));
let result = output::with_buffer_sink(&mut Vec::new(), |out| {
root.unparse_root_object_with_ref_map_and_removed(
out,
&map,
&BTreeSet::new(),
"1.7",
8,
true,
)
});
assert!(result.is_err());
assert_eq!(
extensions
.try_get_key(b"/ADBE")
.unwrap()
.try_get_key(b"/ExtensionLevel")
.unwrap()
.try_as_integer()
.unwrap(),
Some(8)
);
}
#[test]
fn root_object_emission_injects_adbe_without_mutating_live_catalog() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/one-page-no-ext.pdf").to_vec(),
))
.expect("no-extension fixture");
let root = pdf.root_handle().expect("Catalog handle");
assert!(root
.try_get_key(b"/Extensions")
.expect("source Extensions")
.is_null());
let mut output = Vec::new();
let map = |object_ref| Ok(object_ref);
let removed = BTreeSet::new();
output::with_buffer_sink(&mut output, |out| {
root.unparse_root_object_with_ref_map_and_removed(out, &map, &removed, "1.7", 8, true)
})
.expect("root output succeeds");
assert!(output
.windows(b"/ADBE".len())
.any(|window| window == b"/ADBE"));
assert!(output
.windows(b"/BaseVersion /1.7".len())
.any(|window| window == b"/BaseVersion /1.7"));
assert!(output
.windows(b"/ExtensionLevel 8".len())
.any(|window| window == b"/ExtensionLevel 8"));
assert!(
root.try_get_key(b"/Extensions")
.expect("live Extensions")
.is_null(),
"output-only ADBE reconciliation must not mutate the live Catalog"
);
}
#[test]
fn plain_adbe_output_failure_keeps_the_live_catalog_unmodified() {
let mut pdf = Pdf::open(Cursor::new(
include_bytes!("../../../tests/fixtures/compat/one-page-no-ext.pdf").to_vec(),
))
.expect("no-extension fixture");
let mut writer = PdfWriter::new(&mut pdf);
writer.set_minimum_pdf_version("1.7", 8);
writer
.set_output_writer(AlwaysFailingOutput)
.expect("install failing output");
assert!(writer.write().is_err(), "the output sink must fail");
let root = pdf.root_handle().expect("Catalog remains available");
assert!(
root.try_get_key(b"/Extensions")
.expect("live Extensions")
.is_null(),
"a failed plain write must not leave output-only ADBE on the live Catalog"
);
}
#[test]
fn qdf_generate_prepares_modified_stream_only_during_emission() {
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));
page.try_is_scalar().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");
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,
"non-linearized planning must not prepare the modified stream payload"
);
}
#[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"
);
}
}