use crate::cache::{CacheEntry, ObjectCache};
use crate::error::EncryptedError;
use crate::parser::{parse_indirect_object, Parser};
use crate::security::password::{normalize_password, PasswordMode};
use crate::security::standard::{
check_owner_password, check_owner_password_r5, check_owner_password_r6,
check_owner_password_v4, check_user_password, check_user_password_r5, check_user_password_r6,
check_user_password_v4, decrypt_cipher_bytes, decrypt_strings_in_object, per_object_key,
ObjectKeyAlg, StandardHandlerInputs, StandardHandlerR5Inputs, StringCipher,
};
use crate::{
load_xref_and_trailer, load_xref_and_trailer_with_repair, Diagnostic, Diagnostics, Dictionary,
Error, Object, ObjectRef, Result, XrefForm, XrefOffset,
};
use std::collections::{BTreeMap, BTreeSet};
use std::io::{Cursor, Read, Seek, SeekFrom};
pub struct Pdf<R: Read + Seek> {
reader: R,
version: String,
trailer: Dictionary,
startxref: u64,
last_xref_form: XrefForm,
repair_diagnostics: Diagnostics,
cache: ObjectCache,
compressed_member_parents: BTreeMap<ObjectRef, (ObjectRef, u32)>,
source_xref_offsets: Vec<(ObjectRef, u64)>,
source_xref_entries: BTreeMap<ObjectRef, XrefOffset>,
encryption: Option<EncryptionState>,
}
#[derive(Debug, Clone)]
struct EncryptionState {
file_key: Vec<u8>,
stream_mode: EncryptionMode,
string_mode: EncryptionMode,
crypt_filters: BTreeMap<Vec<u8>, EncryptionMode>,
encrypt_metadata: bool,
encrypt_ref: Option<ObjectRef>,
weak_crypto: bool,
permissions: Permissions,
user_password_matched: bool,
owner_password_matched: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Permissions {
raw: i32,
}
impl Permissions {
fn new(raw: i32) -> Self {
Self { raw }
}
pub fn raw(self) -> i32 {
self.raw
}
pub fn can_print(self) -> bool {
self.has_bit(0x0004)
}
pub fn can_modify(self) -> bool {
self.has_bit(0x0008)
}
pub fn can_copy(self) -> bool {
self.has_bit(0x0010)
}
pub fn can_annotate(self) -> bool {
self.has_bit(0x0020)
}
pub fn can_fill_forms(self) -> bool {
self.has_bit(0x0100)
}
pub fn can_extract_for_accessibility(self) -> bool {
self.has_bit(0x0200)
}
pub fn can_assemble(self) -> bool {
self.has_bit(0x0400)
}
pub fn can_print_high_quality(self) -> bool {
self.has_bit(0x0800)
}
fn has_bit(self, bit: u32) -> bool {
(self.raw as u32) & bit != 0
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum EncryptionMode {
Rc4,
Aes128,
Identity,
Aes256,
}
impl EncryptionMode {
fn qpdf_name(self) -> &'static str {
match self {
EncryptionMode::Rc4 => "RC4",
EncryptionMode::Aes128 => "AESv2",
EncryptionMode::Aes256 => "AESv3",
EncryptionMode::Identity => "none",
}
}
}
#[derive(Debug, Clone)]
pub struct EncryptionInfo {
pub v: i64,
pub r: i64,
pub length_bits: i64,
pub filter: String,
pub permissions: Permissions,
pub encrypt_metadata: bool,
pub stream_method: &'static str,
pub string_method: &'static str,
pub eff_method: Option<&'static str>,
pub named_crypt_filters: Vec<(String, &'static str)>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct PdfOpenOptions {
pub repair: bool,
pub password: Vec<u8>,
pub password_mode: PasswordMode,
pub allow_weak_crypto: bool,
pub password_is_hex_key: bool,
}
impl<R: Read + Seek> Pdf<R> {
pub fn open(reader: R) -> Result<Self> {
Self::open_with_options(reader, PdfOpenOptions::default())
}
pub fn open_with_repair(reader: R) -> Result<Self> {
Self::open_with_options(
reader,
PdfOpenOptions {
repair: true,
..PdfOpenOptions::default()
},
)
}
pub fn open_best_effort(reader: R) -> Result<Self> {
Self::open_with_repair(reader)
}
pub fn open_with_options(reader: R, options: PdfOpenOptions) -> Result<Self> {
Self::open_with_repair_mode(reader, options)
}
pub fn repair_diagnostics(&self) -> &Diagnostics {
&self.repair_diagnostics
}
pub fn is_encrypted(&self) -> bool {
self.encryption.is_some()
}
pub(crate) fn encryption_ref(&self) -> Option<ObjectRef> {
self.encryption
.as_ref()
.and_then(|encryption| encryption.encrypt_ref)
}
pub fn uses_weak_crypto(&self) -> bool {
self.encryption
.as_ref()
.is_some_and(|encryption| encryption.weak_crypto)
}
pub fn permissions(&self) -> Option<Permissions> {
self.encryption
.as_ref()
.map(|encryption| encryption.permissions)
}
pub fn user_password_matched(&self) -> bool {
self.encryption
.as_ref()
.is_some_and(|encryption| encryption.user_password_matched)
}
pub fn owner_password_matched(&self) -> bool {
self.encryption
.as_ref()
.is_some_and(|encryption| encryption.owner_password_matched)
}
pub fn encryption_file_key(&self) -> Option<&[u8]> {
self.encryption
.as_ref()
.map(|encryption| encryption.file_key.as_slice())
}
pub fn encryption_info(&mut self) -> Result<Option<EncryptionInfo>> {
if self.encryption.is_none() {
return Ok(None);
}
let Some(encrypt) = self.encrypt_dictionary()? else {
return Ok(None);
};
let v = required_integer(&encrypt, "V")?;
let r = required_integer(&encrypt, "R")?;
let filter = required_name(&encrypt, "Filter")?.to_string();
let length_bits = match encrypt.get("Length") {
Some(Object::Integer(value)) => *value,
_ if v >= 5 => 256,
_ => 40,
};
let eff_selector = crypt_filter_selector(&encrypt, "EFF")?;
let encryption = self
.encryption
.as_ref()
.expect("checked is_some above; authenticate_if_encrypted set it");
let permissions = encryption.permissions;
let encrypt_metadata = encryption.encrypt_metadata;
let stream_method = encryption.stream_mode.qpdf_name();
let string_method = encryption.string_mode.qpdf_name();
let eff_method = eff_selector.and_then(|selector| {
if selector == "Identity" {
Some(EncryptionMode::Identity.qpdf_name())
} else {
encryption
.crypt_filters
.get(selector.as_bytes())
.map(|mode| mode.qpdf_name())
}
});
let named_crypt_filters = encryption
.crypt_filters
.iter()
.map(|(name, mode)| (String::from_utf8_lossy(name).into_owned(), mode.qpdf_name()))
.collect();
Ok(Some(EncryptionInfo {
v,
r,
length_bits,
filter,
permissions,
encrypt_metadata,
stream_method,
string_method,
eff_method,
named_crypt_filters,
}))
}
fn open_with_repair_mode(mut reader: R, options: PdfOpenOptions) -> Result<Self> {
let loaded = if options.repair {
load_xref_and_trailer_with_repair(&mut reader, options.repair)?
} else {
load_xref_and_trailer(&mut reader)?
};
let source_xref_entries = loaded.entries.clone();
let source_xref_offsets = loaded
.entries
.iter()
.filter_map(|(object_ref, offset)| match offset {
crate::XrefOffset::Free { .. } => None,
crate::XrefOffset::Offset(offset) => Some((*object_ref, *offset)),
crate::XrefOffset::Compressed { .. } => None,
})
.collect();
let cache = ObjectCache::from_offsets(&loaded.entries);
let mut pdf = Self {
reader,
version: loaded.version,
trailer: loaded.trailer,
startxref: loaded.startxref,
last_xref_form: loaded.last_xref_form,
repair_diagnostics: loaded.repair_diagnostics,
cache,
compressed_member_parents: BTreeMap::new(),
source_xref_offsets,
source_xref_entries,
encryption: None,
};
pdf.authenticate_if_encrypted(&options)?;
Ok(pdf)
}
fn authenticate_if_encrypted(&mut self, options: &PdfOpenOptions) -> Result<()> {
let encrypt_ref = self.trailer().get_ref("Encrypt");
let Some(encrypt) = self.encrypt_dictionary()? else {
return Ok(());
};
let revision = required_revision(&encrypt)?;
let permissions = Permissions::new(required_permissions(&encrypt)?);
let crypt_filters = crypt_filter_modes(&encrypt, revision)?;
let password = if options.password_is_hex_key {
Vec::new()
} else {
normalize_password(&options.password, options.password_mode, revision)?
};
let (
file_key,
stream_mode,
string_mode,
encrypt_metadata,
weak_crypto,
user_password_matched,
owner_password_matched,
) = if options.password_is_hex_key {
let file_key = decode_hex_file_key(&options.password)?;
let (stream_mode, string_mode, encrypt_metadata, weak_crypto) =
if matches!(revision, 5 | 6) {
let (stream_mode, string_mode) = standard_r5_or_r6_modes(&encrypt)?;
let encrypt_metadata = encrypt_metadata_flag(&encrypt)?;
(stream_mode, string_mode, encrypt_metadata, revision == 5)
} else {
let inputs = standard_handler_inputs(&encrypt, self.trailer())?;
let (stream_mode, string_mode) = standard_v4_or_legacy_modes(&encrypt)?;
let weak_crypto = matches!(stream_mode, EncryptionMode::Rc4)
|| matches!(string_mode, EncryptionMode::Rc4)
|| crypt_filters
.values()
.any(|mode| matches!(mode, EncryptionMode::Rc4));
(
stream_mode,
string_mode,
inputs.encrypt_metadata,
weak_crypto,
)
};
if weak_crypto && !options.allow_weak_crypto {
return Err(EncryptedError::WeakCryptoNotAllowed.into());
}
(
file_key,
stream_mode,
string_mode,
encrypt_metadata,
weak_crypto,
false,
false,
)
} else if matches!(revision, 5 | 6) {
let inputs =
standard_handler_r5_inputs(&encrypt).map_err(map_uo_length_to_bad_password)?;
let (stream_mode, string_mode) = standard_r5_or_r6_modes(&encrypt)?;
let encrypt_metadata = encrypt_metadata_flag(&encrypt)?;
let weak_crypto = revision == 5;
let user_attempt = if revision == 5 {
check_user_password_r5(&password, &inputs)
} else {
check_user_password_r6(&password, &inputs)
};
let owner_attempt = if revision == 5 {
check_owner_password_r5(&password, &inputs)
} else {
check_owner_password_r6(&password, &inputs)
};
let user_password_matched = user_attempt.is_ok();
let owner_password_matched = owner_attempt.is_ok();
let file_key = match (user_attempt, owner_attempt) {
(Ok(key), _) => key,
(Err(_), Ok(key)) => key,
(Err(user_err), Err(_owner_err)) => return Err(user_err),
};
if weak_crypto && !options.allow_weak_crypto {
return Err(EncryptedError::WeakCryptoNotAllowed.into());
}
(
file_key,
stream_mode,
string_mode,
encrypt_metadata,
weak_crypto,
user_password_matched,
owner_password_matched,
)
} else {
let inputs = standard_handler_inputs(&encrypt, self.trailer())?;
let (stream_mode, string_mode) = standard_v4_or_legacy_modes(&encrypt)?;
let encrypt_metadata = inputs.encrypt_metadata;
let weak_crypto = matches!(stream_mode, EncryptionMode::Rc4)
|| matches!(string_mode, EncryptionMode::Rc4)
|| crypt_filters
.values()
.any(|mode| matches!(mode, EncryptionMode::Rc4));
let v4_path = inputs.v == 4 && inputs.r == 4;
let user_attempt = if v4_path {
check_user_password_v4(&password, &inputs)
} else {
check_user_password(&password, &inputs)
};
let owner_attempt = if v4_path {
check_owner_password_v4(&password, &inputs)
} else {
check_owner_password(&password, &inputs)
};
let user_password_matched = user_attempt.is_ok();
let owner_password_matched = owner_attempt.is_ok();
let file_key = match (user_attempt, owner_attempt) {
(Ok(key), _) => key,
(Err(_), Ok(key)) => key,
(Err(user_err), Err(_owner_err)) => return Err(user_err),
};
if weak_crypto && !options.allow_weak_crypto {
return Err(EncryptedError::WeakCryptoNotAllowed.into());
}
(
file_key,
stream_mode,
string_mode,
encrypt_metadata,
weak_crypto,
user_password_matched,
owner_password_matched,
)
};
let r6_perms_warning = if revision == 6 {
r6_perms_warning(&encrypt, &file_key, permissions, encrypt_metadata)?
} else {
None
};
self.encryption = Some(EncryptionState {
file_key,
stream_mode,
string_mode,
crypt_filters,
encrypt_metadata,
encrypt_ref,
weak_crypto,
permissions,
user_password_matched,
owner_password_matched,
});
if let Some(warning) = r6_perms_warning {
self.repair_diagnostics
.push(Diagnostic::warning(warning, None));
}
Ok(())
}
fn encrypt_dictionary(&mut self) -> Result<Option<Dictionary>> {
match self.trailer().get("Encrypt").cloned() {
None => Ok(None),
Some(Object::Dictionary(dict)) => Ok(Some(dict)),
Some(Object::Reference(object_ref)) => match self.resolve(object_ref)? {
Object::Dictionary(dict) => Ok(Some(dict)),
_ => Err(EncryptedError::Malformed {
reason: "/Encrypt object is not a dictionary".into(),
}
.into()),
},
Some(_) => Err(EncryptedError::Malformed {
reason: "/Encrypt entry is not a dictionary or reference".into(),
}
.into()),
}
}
pub fn version(&self) -> &str {
&self.version
}
pub fn trailer(&self) -> &Dictionary {
&self.trailer
}
pub(crate) fn startxref(&self) -> u64 {
self.startxref
}
pub(crate) fn previous_xref_offset(&self) -> u64 {
self.startxref()
}
pub(crate) fn last_xref_form(&self) -> XrefForm {
self.last_xref_form
}
pub(crate) fn source_xref_offsets(&self) -> Vec<(ObjectRef, u64)> {
self.source_xref_offsets.clone()
}
pub(crate) fn source_xref_entries(&self) -> BTreeMap<ObjectRef, XrefOffset> {
self.source_xref_entries.clone()
}
pub(crate) fn compressed_parent(&self, object_ref: ObjectRef) -> Option<(ObjectRef, u32)> {
self.compressed_member_parents.get(&object_ref).copied()
}
pub fn set_object(&mut self, object_ref: ObjectRef, object: Object) {
if let Some(CacheEntry::Compressed { stream, index }) =
self.cache.entry(object_ref).cloned()
{
let stream_ref = ObjectRef::new(stream, 0);
let (parent_ref, parent_index) = self
.compressed_parent_for_entry(stream_ref, index)
.unwrap_or((stream_ref, index));
self.compressed_member_parents
.insert(object_ref, (parent_ref, parent_index));
}
self.cache.set_resolved(object_ref, object);
}
pub fn delete_object(&mut self, object_ref: ObjectRef) {
if object_ref.number == 0
|| matches!(
self.cache.entry(object_ref),
Some(CacheEntry::Deleted | CacheEntry::Missing)
)
{
return;
}
self.cache.set_deleted(object_ref);
}
pub(crate) fn source_bytes(&mut self) -> Result<Vec<u8>> {
self.reader.seek(SeekFrom::Start(0))?;
let mut bytes = Vec::new();
self.reader.read_to_end(&mut bytes)?;
Ok(bytes)
}
pub fn resolved_count(&self) -> usize {
self.cache.resolved_count()
}
pub(crate) fn resolved_object_refs(&self) -> Vec<ObjectRef> {
self.cache
.entries()
.iter()
.filter_map(|(object_ref, entry)| {
if matches!(entry, crate::cache::CacheEntry::Resolved(_)) {
Some(*object_ref)
} else {
None
}
})
.collect()
}
pub(crate) fn deleted_object_refs(&self) -> Vec<ObjectRef> {
self.cache.deleted_refs()
}
pub fn object_refs(&self) -> Vec<ObjectRef> {
self.cache.object_refs()
}
pub fn live_object_refs(&self) -> Vec<ObjectRef> {
self.cache
.entries()
.iter()
.filter_map(|(object_ref, entry)| match entry {
crate::cache::CacheEntry::Deleted
| crate::cache::CacheEntry::Missing
| crate::cache::CacheEntry::Reserved => None,
_ => Some(*object_ref),
})
.collect()
}
pub fn root_ref(&self) -> Option<ObjectRef> {
self.trailer.get_ref("Root")
}
pub fn linearized_hint_ref(&mut self) -> Result<Option<ObjectRef>> {
let candidate = ObjectRef::new(1, 0);
let object = self.resolve(candidate)?;
let Object::Dictionary(dict) = object else {
return Ok(None);
};
let Some(linearized) = dict.get("Linearized") else {
return Ok(None);
};
Ok(match linearized {
Object::Integer(value) if *value > 0 => Some(candidate),
Object::Real(value) if value.is_finite() && *value > 0.0 => Some(candidate),
Object::Boolean(value) if *value => Some(candidate),
_ => None,
})
}
pub fn resolve(&mut self, object_ref: ObjectRef) -> Result<Object> {
match self.cache.entry(object_ref).cloned() {
Some(CacheEntry::Resolved(object)) => Ok(object),
Some(CacheEntry::Unresolved { offset }) => {
self.reader.seek(SeekFrom::Start(offset))?;
let mut bytes = Vec::new();
self.reader.read_to_end(&mut bytes)?;
let (parsed_ref, object) = parse_indirect_object(&bytes)?;
if parsed_ref != object_ref {
return Ok(Object::Null);
}
let object = self.decrypt_resolved_object(object_ref, object)?;
self.cache.set_resolved(object_ref, object.clone());
Ok(object)
}
Some(CacheEntry::Compressed { stream, index }) => {
self.resolve_compressed_entry(object_ref, stream, index)
}
Some(CacheEntry::Missing | CacheEntry::Deleted) | None => Ok(Object::Null),
Some(CacheEntry::Reserved) => Ok(Object::Null),
}
}
fn resolve_compressed_entry(
&mut self,
object_ref: ObjectRef,
stream: u32,
index: u32,
) -> Result<Object> {
let stream_ref = ObjectRef::new(stream, 0);
let stream_object = match self.cache.entry(stream_ref).cloned() {
Some(CacheEntry::Resolved(object)) => object,
Some(CacheEntry::Unresolved { offset }) => {
self.reader.seek(SeekFrom::Start(offset))?;
let mut bytes = Vec::new();
self.reader.read_to_end(&mut bytes)?;
let (parsed_ref, object) = parse_indirect_object(&bytes)?;
if parsed_ref != stream_ref {
return Ok(Object::Null);
}
let object = self.decrypt_resolved_object(stream_ref, object)?;
self.cache.set_resolved(stream_ref, object.clone());
object
}
Some(CacheEntry::Compressed { .. }) => return Ok(Object::Null),
Some(CacheEntry::Missing | CacheEntry::Deleted) | None => return Ok(Object::Null),
Some(CacheEntry::Reserved) => return Ok(Object::Null),
};
let Object::Stream(stream_object) = stream_object else {
return Ok(Object::Null);
};
let (parent_ref, parent_index, object) =
self.parse_object_stream_chain_entry(stream_ref, &stream_object, index)?;
let object = self.decrypt_resolved_object(object_ref, object)?;
self.compressed_member_parents
.insert(object_ref, (parent_ref, parent_index));
self.cache.set_resolved(object_ref, object.clone());
Ok(object)
}
fn decrypt_resolved_object(&self, object_ref: ObjectRef, mut object: Object) -> Result<Object> {
let Some(encryption) = &self.encryption else {
return Ok(object);
};
if Some(object_ref) == encryption.encrypt_ref {
return Ok(object);
}
decrypt_object_strings(
object_ref,
&mut object,
encryption.string_mode,
&encryption.file_key,
encryption.encrypt_ref,
)?;
if let Object::Stream(stream) = &mut object {
if !encryption.encrypt_metadata && is_metadata_stream(&stream.dict) {
return Ok(object);
}
if stream_has_explicit_crypt_filter(&stream.dict) {
apply_explicit_crypt_filters(object_ref, stream, encryption)?;
} else {
decrypt_stream_bytes(
object_ref,
&mut stream.data,
encryption.stream_mode,
&encryption.file_key,
)?;
}
}
Ok(object)
}
fn parse_object_stream_chain_entry(
&mut self,
stream_ref: ObjectRef,
stream_object: &crate::Stream,
target_index: u32,
) -> Result<(ObjectRef, u32, Object)> {
let (member_stream_ref, member_index, member_stream) =
self.object_stream_chain_member(stream_ref, stream_object, target_index)?;
let object = parse_object_stream_entry(&member_stream, member_index)?;
Ok((member_stream_ref, member_index, object))
}
fn compressed_parent_for_entry(
&mut self,
stream_ref: ObjectRef,
target_index: u32,
) -> Result<(ObjectRef, u32)> {
let stream_object = self.resolve(stream_ref)?;
let Object::Stream(stream_object) = stream_object else {
return Err(Error::parse(0, "compressed parent is not an object stream"));
};
let (parent_ref, parent_index, _) =
self.object_stream_chain_member(stream_ref, &stream_object, target_index)?;
Ok((parent_ref, parent_index))
}
fn object_stream_chain_member(
&mut self,
stream_ref: ObjectRef,
stream_object: &crate::Stream,
target_index: u32,
) -> Result<(ObjectRef, u32, crate::Stream)> {
let mut streams = Vec::new();
self.collect_object_stream_chain(
stream_ref,
stream_object,
&mut streams,
&mut BTreeSet::new(),
)?;
let target_index = usize::try_from(target_index)
.map_err(|_| Error::parse(0, "compressed object index does not fit usize"))?;
let mut remaining = target_index;
for (member_stream_ref, member_stream) in streams {
let member_count = object_stream_count(&member_stream)?;
if remaining < member_count {
let member_index = u32::try_from(remaining)
.map_err(|_| Error::parse(0, "compressed object index does not fit u32"))?;
return Ok((member_stream_ref, member_index, member_stream));
}
remaining -= member_count;
}
Err(Error::parse(
0,
"compressed object index out of range for object stream chain",
))
}
fn collect_object_stream_chain(
&mut self,
stream_ref: ObjectRef,
stream_object: &crate::Stream,
streams: &mut Vec<(ObjectRef, crate::Stream)>,
seen: &mut BTreeSet<ObjectRef>,
) -> Result<()> {
if !seen.insert(stream_ref) {
return Err(Error::parse(0, "object stream /Extends cycle"));
}
if let Some(parent_ref) = stream_object.dict.get_ref("Extends") {
let parent_object = self.resolve(parent_ref)?;
let Object::Stream(parent_stream) = parent_object else {
return Err(Error::parse(0, "object stream /Extends is not a stream"));
};
self.collect_object_stream_chain(parent_ref, &parent_stream, streams, seen)?;
}
streams.push((stream_ref, stream_object.clone()));
Ok(())
}
}
impl<'a> Pdf<Cursor<&'a [u8]>> {
pub fn open_mem(bytes: &'a [u8]) -> crate::Result<Self> {
Self::open(Cursor::new(bytes))
}
pub fn open_mem_with_options(bytes: &'a [u8], options: PdfOpenOptions) -> crate::Result<Self> {
Self::open_with_options(Cursor::new(bytes), options)
}
}
impl Pdf<Cursor<Vec<u8>>> {
pub fn open_mem_owned(bytes: Vec<u8>) -> crate::Result<Self> {
Self::open(Cursor::new(bytes))
}
pub fn open_mem_owned_with_options(
bytes: Vec<u8>,
options: PdfOpenOptions,
) -> crate::Result<Self> {
Self::open_with_options(Cursor::new(bytes), options)
}
}
fn decrypt_object_strings(
object_ref: ObjectRef,
object: &mut Object,
mode: EncryptionMode,
file_key: &[u8],
encrypt_ref: Option<ObjectRef>,
) -> Result<()> {
match mode {
EncryptionMode::Rc4 => {
let key = per_object_key(
file_key,
object_ref.number,
u32::from(object_ref.generation),
ObjectKeyAlg::Rc4,
);
decrypt_strings_in_object(
object_ref,
object,
StringCipher::Rc4 { key: &key },
encrypt_ref,
)
}
EncryptionMode::Aes128 => {
let key = per_object_key(
file_key,
object_ref.number,
u32::from(object_ref.generation),
ObjectKeyAlg::Aes,
);
let key = aes128_object_key(&key)?;
decrypt_strings_in_object(
object_ref,
object,
StringCipher::Aes128 { key: &key },
encrypt_ref,
)
}
EncryptionMode::Identity => Ok(()),
EncryptionMode::Aes256 => {
let key = aes256_file_key(file_key)?;
decrypt_strings_in_object(
object_ref,
object,
StringCipher::Aes256 { key: &key },
encrypt_ref,
)
}
}
}
fn decrypt_stream_bytes(
object_ref: ObjectRef,
bytes: &mut Vec<u8>,
mode: EncryptionMode,
file_key: &[u8],
) -> Result<()> {
match mode {
EncryptionMode::Rc4 => {
let key = per_object_key(
file_key,
object_ref.number,
u32::from(object_ref.generation),
ObjectKeyAlg::Rc4,
);
decrypt_cipher_bytes(bytes, StringCipher::Rc4 { key: &key })
}
EncryptionMode::Aes128 => {
let key = per_object_key(
file_key,
object_ref.number,
u32::from(object_ref.generation),
ObjectKeyAlg::Aes,
);
let key = aes128_object_key(&key)?;
decrypt_cipher_bytes(bytes, StringCipher::Aes128 { key: &key })
}
EncryptionMode::Identity => Ok(()),
EncryptionMode::Aes256 => {
let key = aes256_file_key(file_key)?;
decrypt_cipher_bytes(bytes, StringCipher::Aes256 { key: &key })
}
}
}
fn apply_explicit_crypt_filters(
object_ref: ObjectRef,
stream: &mut crate::Stream,
encryption: &EncryptionState,
) -> Result<()> {
let decoded = crate::filters::decode_stream_data_with_crypt_filter(
&stream.dict,
&stream.data,
|decode_params, bytes| {
let mode = explicit_crypt_mode(encryption, decode_params)?;
let mut decrypted = bytes.to_vec();
decrypt_stream_bytes(object_ref, &mut decrypted, mode, &encryption.file_key)?;
Ok(decrypted)
},
)?;
stream.data = decoded;
stream.dict.remove("Filter");
stream.dict.remove("DecodeParms");
Ok(())
}
fn explicit_crypt_mode(
encryption: &EncryptionState,
decode_params: Option<&Object>,
) -> Result<EncryptionMode> {
let Some(Object::Dictionary(params)) = decode_params else {
return Ok(EncryptionMode::Identity);
};
let name: &[u8] = match params.get("Name") {
None => return Ok(EncryptionMode::Identity),
Some(Object::Name(name)) => name.as_slice(),
Some(_) => {
return Err(EncryptedError::Malformed {
reason: "/Crypt /DecodeParms /Name is not a name".into(),
}
.into())
}
};
if name == b"Identity" {
return Ok(EncryptionMode::Identity);
}
encryption.crypt_filters.get(name).copied().ok_or_else(|| {
EncryptedError::Malformed {
reason: format!("/CF entry '{}' not found", String::from_utf8_lossy(name)),
}
.into()
})
}
fn stream_has_explicit_crypt_filter(dict: &Dictionary) -> bool {
match dict.get("Filter") {
Some(Object::Name(name)) => name == b"Crypt",
Some(Object::Array(filters)) => filters
.iter()
.any(|filter| matches!(filter, Object::Name(name) if name == b"Crypt")),
_ => false,
}
}
fn is_metadata_stream(dict: &Dictionary) -> bool {
matches!(dict.get("Type"), Some(Object::Name(name)) if name.as_slice() == b"Metadata")
}
fn aes256_file_key(file_key: &[u8]) -> Result<[u8; 32]> {
file_key.try_into().map_err(|_| {
EncryptedError::Malformed {
reason: "AES-256 file key is not 32 bytes".into(),
}
.into()
})
}
fn aes128_object_key(key: &[u8]) -> Result<[u8; 16]> {
key.try_into().map_err(|_| {
EncryptedError::Malformed {
reason: "AES-128 object key is not 16 bytes".into(),
}
.into()
})
}
pub(crate) fn parse_object_stream_entry(
stream_object: &crate::Stream,
target_index: u32,
) -> Result<Object> {
let stream_data = crate::filters::decode_stream_data(&stream_object.dict, &stream_object.data)?;
let stream_object_count = object_stream_count(stream_object)?;
let stream_data_first = parse_non_negative_i64(
stream_object
.dict
.get("First")
.ok_or(Error::Missing("Object stream /First"))?,
"Object stream /First",
)?;
let object_count = stream_object_count;
let first = usize::try_from(stream_data_first)
.map_err(|_| Error::parse(0, "Object stream /First does not fit usize"))?;
let mut header_parser = Parser::new(&stream_data);
let mut object_offsets = Vec::with_capacity(object_count);
for _ in 0..object_count {
let _object_number = parse_non_negative_u64(
header_parser.integer_for_indirect()?,
"object stream object number",
)?;
let object_offset = parse_non_negative_u64(
header_parser.integer_for_indirect()?,
"object stream object offset",
)?;
object_offsets.push(object_offset);
}
let target_index = usize::try_from(target_index)
.map_err(|_| Error::parse(0, "compressed object index does not fit usize"))?;
if target_index >= object_offsets.len() {
return Err(Error::parse(
0,
"compressed object index out of range for this stream",
));
}
let start = first
.checked_add(
usize::try_from(object_offsets[target_index])
.map_err(|_| Error::parse(0, "object stream offset does not fit usize"))?,
)
.ok_or_else(|| Error::parse(0, "compressed object offset overflow"))?;
if start > stream_data.len() {
return Err(Error::parse(0, "compressed object offset out of range"));
}
let mut object_parser = Parser::new(&stream_data[start..]);
object_parser.object()
}
fn standard_handler_inputs<'a>(
encrypt: &'a Dictionary,
trailer: &'a Dictionary,
) -> Result<StandardHandlerInputs<'a>> {
let filter = required_name(encrypt, "Filter")?;
let v = required_integer(encrypt, "V")?;
let r = required_integer(encrypt, "R")?;
if filter != "Standard" || !matches!((v, r), (1 | 2, 2 | 3) | (4, 4)) {
return Err(EncryptedError::UnsupportedHandler {
filter: filter.to_string(),
v,
r,
cfm: crypt_filter_method(encrypt),
}
.into());
}
let length_bits = match encrypt.get("Length") {
Some(Object::Integer(value)) => *value,
Some(_) => {
return Err(EncryptedError::Malformed {
reason: "/Length entry is not an integer".into(),
}
.into())
}
None => 40,
};
let p = required_permissions(encrypt)?;
let u = required_32_byte_string(encrypt, "U")?;
let o = required_32_byte_string(encrypt, "O")?;
let id0 = first_file_id(trailer)?;
let encrypt_metadata = encrypt_metadata_flag(encrypt)?;
Ok(StandardHandlerInputs {
v,
r,
length_bits,
p,
id0,
u,
o,
encrypt_metadata,
})
}
fn map_uo_length_to_bad_password(err: Error) -> Error {
match &err {
Error::Encrypted(EncryptedError::Malformed { reason })
if reason == "/U entry is not 48 bytes" || reason == "/O entry is not 48 bytes" =>
{
EncryptedError::BadPassword.into()
}
_ => err,
}
}
fn decode_hex_file_key(raw: &[u8]) -> Result<Vec<u8>> {
let trimmed: Vec<u8> = raw
.iter()
.copied()
.filter(|b| !b.is_ascii_whitespace())
.collect();
let key = hex::decode(&trimmed).map_err(|err| EncryptedError::Malformed {
reason: format!("--password-is-hex-key: --password is not valid hex ({err})"),
})?;
if key.len() > 32 {
return Err(EncryptedError::Malformed {
reason: format!(
"--password-is-hex-key: decoded key is {} bytes; \
the Standard security handler key is at most 32 bytes",
key.len()
),
}
.into());
}
Ok(key)
}
fn standard_handler_r5_inputs(encrypt: &Dictionary) -> Result<StandardHandlerR5Inputs<'_>> {
let filter = required_name(encrypt, "Filter")?;
let v = required_integer(encrypt, "V")?;
let r = required_integer(encrypt, "R")?;
if filter != "Standard" || v != 5 || !matches!(r, 5 | 6) {
return Err(EncryptedError::UnsupportedHandler {
filter: filter.to_string(),
v,
r,
cfm: crypt_filter_method(encrypt),
}
.into());
}
Ok(StandardHandlerR5Inputs {
u: required_48_byte_string(encrypt, "U")?,
o: required_48_byte_string(encrypt, "O")?,
ue: required_32_byte_string(encrypt, "UE")?,
oe: required_32_byte_string(encrypt, "OE")?,
})
}
fn encrypt_metadata_flag(encrypt: &Dictionary) -> Result<bool> {
match encrypt.get("EncryptMetadata") {
Some(Object::Boolean(value)) => Ok(*value),
Some(_) => Err(EncryptedError::Malformed {
reason: "/EncryptMetadata entry is not a boolean".into(),
}
.into()),
None => Ok(true),
}
}
fn required_permissions(encrypt: &Dictionary) -> Result<i32> {
i32::try_from(required_integer(encrypt, "P")?).map_err(|_| {
EncryptedError::Malformed {
reason: "/P entry is out of i32 range".into(),
}
.into()
})
}
fn r6_perms_warning(
encrypt: &Dictionary,
file_key: &[u8],
permissions: Permissions,
encrypt_metadata: bool,
) -> Result<Option<String>> {
let Some(perms) = encrypt.get("Perms") else {
return Ok(None);
};
let Object::String(bytes) = perms else {
return Ok(Some("R=6 /Perms entry is not a string".into()));
};
let Ok(mut block) = <[u8; 16]>::try_from(bytes.as_slice()) else {
return Ok(Some("R=6 /Perms entry is not 16 bytes".into()));
};
let Ok(file_key) = <&[u8; 32]>::try_from(file_key) else {
return Ok(Some(
"R=6 /Perms cannot be verified with non-256-bit file key".into(),
));
};
crate::security::primitives::aes256_ecb_decrypt_block(file_key, &mut block);
let perms_p = i32::from_le_bytes(block[..4].try_into().expect("slice length checked"));
let perms_metadata = match block[8] {
b'T' => true,
b'F' => false,
_ => {
return Ok(Some(
"R=6 /Perms encrypted-metadata flag is not T or F".into(),
))
}
};
if perms_p != permissions.raw() {
return Ok(Some(format!(
"R=6 /Perms permissions value {perms_p} does not match /P {}",
permissions.raw()
)));
}
if block[4..8] != [0xff; 4] {
return Ok(Some("R=6 /Perms reserved bytes are invalid".into()));
}
if perms_metadata != encrypt_metadata {
return Ok(Some(
"R=6 /Perms encrypted-metadata flag does not match /EncryptMetadata".into(),
));
}
if &block[9..12] != b"adb" {
return Ok(Some("R=6 /Perms magic bytes are not 'adb'".into()));
}
Ok(None)
}
fn required_revision(encrypt: &Dictionary) -> Result<i64> {
required_integer(encrypt, "R")
}
fn standard_v4_or_legacy_modes(encrypt: &Dictionary) -> Result<(EncryptionMode, EncryptionMode)> {
if required_integer(encrypt, "V").ok() != Some(4) {
return Ok((EncryptionMode::Rc4, EncryptionMode::Rc4));
}
Ok((
v4_mode_for_selector(encrypt, crypt_filter_selector(encrypt, "StmF")?)?,
v4_mode_for_selector(encrypt, crypt_filter_selector(encrypt, "StrF")?)?,
))
}
fn standard_r5_or_r6_modes(encrypt: &Dictionary) -> Result<(EncryptionMode, EncryptionMode)> {
Ok((
r5_or_r6_mode_for_selector(encrypt, crypt_filter_selector(encrypt, "StmF")?)?,
r5_or_r6_mode_for_selector(encrypt, crypt_filter_selector(encrypt, "StrF")?)?,
))
}
fn v4_mode_for_selector(encrypt: &Dictionary, selector: Option<String>) -> Result<EncryptionMode> {
let Some(selector) = selector else {
return Ok(EncryptionMode::Identity);
};
if selector == "Identity" {
return Ok(EncryptionMode::Identity);
}
let cfm = crypt_filter_method_for_name(encrypt, &selector)?.unwrap_or_else(|| "V2".into());
match cfm.as_str() {
"V2" => Ok(EncryptionMode::Rc4),
"AESV2" => Ok(EncryptionMode::Aes128),
"Identity" => Ok(EncryptionMode::Identity),
_ => unsupported_crypt_filter(encrypt, Some(cfm)),
}
}
fn r5_or_r6_mode_for_selector(
encrypt: &Dictionary,
selector: Option<String>,
) -> Result<EncryptionMode> {
let Some(selector) = selector else {
return Ok(EncryptionMode::Aes256);
};
if selector == "Identity" {
return Ok(EncryptionMode::Identity);
}
let cfm = crypt_filter_method_for_name(encrypt, &selector)?.unwrap_or_else(|| "AESV3".into());
match cfm.as_str() {
"AESV3" => Ok(EncryptionMode::Aes256),
"Identity" => Ok(EncryptionMode::Identity),
_ => unsupported_crypt_filter(encrypt, Some(cfm)),
}
}
fn crypt_filter_selector(encrypt: &Dictionary, key: &str) -> Result<Option<String>> {
match encrypt.get(key) {
None => Ok(None),
Some(Object::Name(name)) => Ok(Some(String::from_utf8_lossy(name).to_string())),
Some(_) => Err(EncryptedError::Malformed {
reason: format!("/{key} entry is not a name"),
}
.into()),
}
}
fn crypt_filter_method_for_name(encrypt: &Dictionary, name: &str) -> Result<Option<String>> {
let Some(Object::Dictionary(cf)) = encrypt.get("CF") else {
return Err(EncryptedError::Malformed {
reason: format!("/CF entry '{name}' not found"),
}
.into());
};
let Some(Object::Dictionary(filter)) = cf.get(name) else {
return Err(EncryptedError::Malformed {
reason: format!("/CF entry '{name}' not found"),
}
.into());
};
match filter.get("CFM") {
None => Ok(None),
Some(Object::Name(cfm)) => Ok(Some(String::from_utf8_lossy(cfm).to_string())),
Some(_) => Err(EncryptedError::Malformed {
reason: format!("/CF/{name}/CFM entry is not a name"),
}
.into()),
}
}
fn crypt_filter_modes(
encrypt: &Dictionary,
revision: i64,
) -> Result<BTreeMap<Vec<u8>, EncryptionMode>> {
let mut modes = BTreeMap::new();
let Some(Object::Dictionary(cf)) = encrypt.get("CF") else {
return Ok(modes);
};
for (name, value) in cf.iter() {
let Object::Dictionary(filter) = value else {
return Err(EncryptedError::Malformed {
reason: format!(
"/CF entry '{}' is not a dictionary",
String::from_utf8_lossy(name)
),
}
.into());
};
let cfm = match filter.get("CFM") {
None if revision >= 5 => "AESV3".to_string(),
None => "V2".to_string(),
Some(Object::Name(cfm)) => String::from_utf8_lossy(cfm).to_string(),
Some(_) => {
return Err(EncryptedError::Malformed {
reason: format!(
"/CF/{}/CFM entry is not a name",
String::from_utf8_lossy(name)
),
}
.into())
}
};
let mode = match (revision, cfm.as_str()) {
(_, "Identity") => EncryptionMode::Identity,
(5 | 6, "AESV3") => EncryptionMode::Aes256,
(5 | 6, _) => unsupported_crypt_filter(encrypt, Some(cfm))?,
(_, "V2") => EncryptionMode::Rc4,
(_, "AESV2") => EncryptionMode::Aes128,
(_, _) => unsupported_crypt_filter(encrypt, Some(cfm))?,
};
modes.insert(name.to_vec(), mode);
}
Ok(modes)
}
fn unsupported_crypt_filter<T>(encrypt: &Dictionary, cfm: Option<String>) -> Result<T> {
Err(EncryptedError::UnsupportedHandler {
filter: required_name(encrypt, "Filter")?.to_string(),
v: required_integer(encrypt, "V")?,
r: required_integer(encrypt, "R")?,
cfm,
}
.into())
}
fn required_integer(dict: &Dictionary, key: &'static str) -> Result<i64> {
match dict.get(key) {
Some(Object::Integer(value)) => Ok(*value),
Some(_) => Err(EncryptedError::Malformed {
reason: format!("/{key} entry is not an integer"),
}
.into()),
None => Err(EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
.into()),
}
}
fn required_name<'a>(dict: &'a Dictionary, key: &'static str) -> Result<&'a str> {
match dict.get(key) {
Some(Object::Name(name)) => std::str::from_utf8(name).map_err(|_| {
EncryptedError::Malformed {
reason: format!("/{key} entry is not valid UTF-8"),
}
.into()
}),
Some(_) => Err(EncryptedError::Malformed {
reason: format!("/{key} entry is not a name"),
}
.into()),
None => Err(EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
.into()),
}
}
fn required_32_byte_string<'a>(dict: &'a Dictionary, key: &'static str) -> Result<&'a [u8; 32]> {
match dict.get(key) {
Some(Object::String(bytes)) => bytes.as_slice().try_into().map_err(|_| {
EncryptedError::Malformed {
reason: format!("/{key} entry is not 32 bytes"),
}
.into()
}),
Some(_) => Err(EncryptedError::Malformed {
reason: format!("/{key} entry is not a string"),
}
.into()),
None => Err(EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
.into()),
}
}
fn required_48_byte_string<'a>(dict: &'a Dictionary, key: &'static str) -> Result<&'a [u8; 48]> {
match dict.get(key) {
Some(Object::String(bytes)) => bytes.as_slice().try_into().map_err(|_| {
EncryptedError::Malformed {
reason: format!("/{key} entry is not 48 bytes"),
}
.into()
}),
Some(_) => Err(EncryptedError::Malformed {
reason: format!("/{key} entry is not a string"),
}
.into()),
None => Err(EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
.into()),
}
}
fn first_file_id(trailer: &Dictionary) -> Result<&[u8]> {
match trailer.get("ID") {
Some(Object::Array(ids)) => match ids.first() {
Some(Object::String(id0)) => Ok(id0),
Some(_) => Err(EncryptedError::Malformed {
reason: "/ID first entry is not a string".into(),
}
.into()),
None => Err(EncryptedError::Malformed {
reason: "/ID array is empty".into(),
}
.into()),
},
Some(_) => Err(EncryptedError::Malformed {
reason: "/ID entry is not an array".into(),
}
.into()),
None => Err(EncryptedError::Malformed {
reason: "missing /ID entry".into(),
}
.into()),
}
}
fn crypt_filter_method(encrypt: &Dictionary) -> Option<String> {
let Some(Object::Dictionary(cf)) = encrypt.get("CF") else {
return None;
};
let Object::Dictionary(std_cf) = cf.get("StdCF")? else {
return None;
};
let Object::Name(cfm) = std_cf.get("CFM")? else {
return None;
};
Some(String::from_utf8_lossy(cfm).to_string())
}
pub(crate) fn object_stream_count(stream_object: &crate::Stream) -> Result<usize> {
usize::try_from(parse_non_negative_i64(
stream_object
.dict
.get("N")
.ok_or(Error::Missing("Object stream /N"))?,
"Object stream /N",
)?)
.map_err(|_| Error::parse(0, "Object stream /N does not fit usize"))
}
fn parse_non_negative_i64(value: &crate::Object, context: &str) -> Result<i64> {
let crate::Object::Integer(integer) = value else {
return Err(Error::parse(0, format!("{context} is not integer")));
};
if *integer < 0 {
return Err(Error::parse(0, format!("{context} is negative")));
}
Ok(*integer)
}
fn parse_non_negative_u64(value: i64, context: &str) -> Result<u64> {
if value < 0 {
return Err(Error::parse(0, format!("{context} is negative")));
}
Ok(value as u64)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::pages::page_refs;
fn minimal_pdf_bytes() -> Vec<u8> {
let mut pdf = Vec::new();
pdf.extend_from_slice(b"%PDF-1.4\n");
let off1 = pdf.len() as u64;
pdf.extend_from_slice(b"1 0 obj\n<< /Type /Catalog /Pages 2 0 R >>\nendobj\n");
let off2 = pdf.len() as u64;
pdf.extend_from_slice(b"2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n");
let off3 = pdf.len() as u64;
pdf.extend_from_slice(
b"3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] >>\nendobj\n",
);
let xref_start = pdf.len() as u64;
let xref = format!(
"xref\n0 4\n0000000000 65535 f \n{:010} 00000 n \n{:010} 00000 n \n{:010} 00000 n \n",
off1, off2, off3,
);
pdf.extend_from_slice(xref.as_bytes());
let trailer =
format!("trailer\n<< /Size 4 /Root 1 0 R >>\nstartxref\n{xref_start}\n%%EOF\n");
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
#[test]
fn open_mem_owned_opens_minimal_pdf() {
let bytes = minimal_pdf_bytes();
let mut pdf = Pdf::open_mem_owned(bytes).expect("open_mem_owned should succeed");
let refs = page_refs(&mut pdf).expect("page_refs should succeed");
assert_eq!(refs.len(), 1, "expected 1 page");
assert_eq!(
pdf.root_ref(),
Some(ObjectRef::new(1, 0)),
"expected root at 1 0 R"
);
}
#[test]
fn open_mem_opens_minimal_pdf() {
let bytes = minimal_pdf_bytes();
let mut pdf = Pdf::open_mem(&bytes).expect("open_mem should succeed");
let refs = page_refs(&mut pdf).expect("page_refs should succeed");
assert_eq!(refs.len(), 1, "expected 1 page");
assert_eq!(
pdf.root_ref(),
Some(ObjectRef::new(1, 0)),
"expected root at 1 0 R"
);
}
#[test]
fn open_mem_owned_matches_cursor_open() {
let bytes = minimal_pdf_bytes();
let mut pdf_cursor =
Pdf::open(Cursor::new(bytes.clone())).expect("Cursor::new open should succeed");
let refs_cursor = page_refs(&mut pdf_cursor).expect("page_refs from cursor");
let root_cursor = pdf_cursor.root_ref();
let mut pdf_owned = Pdf::open_mem_owned(bytes).expect("open_mem_owned should succeed");
let refs_owned = page_refs(&mut pdf_owned).expect("page_refs from open_mem_owned");
let root_owned = pdf_owned.root_ref();
assert_eq!(
refs_cursor, refs_owned,
"page refs from Cursor::new vs open_mem_owned must match"
);
assert_eq!(
root_cursor, root_owned,
"root ref from Cursor::new vs open_mem_owned must match"
);
}
#[test]
fn open_mem_matches_cursor_open() {
let bytes = minimal_pdf_bytes();
let mut pdf_cursor =
Pdf::open(Cursor::new(bytes.clone())).expect("Cursor::new open should succeed");
let refs_cursor = page_refs(&mut pdf_cursor).expect("page_refs from cursor");
let root_cursor = pdf_cursor.root_ref();
let mut pdf_mem = Pdf::open_mem(&bytes).expect("open_mem should succeed");
let refs_mem = page_refs(&mut pdf_mem).expect("page_refs from open_mem");
let root_mem = pdf_mem.root_ref();
assert_eq!(
refs_cursor, refs_mem,
"page refs from Cursor::new vs open_mem must match"
);
assert_eq!(
root_cursor, root_mem,
"root ref from Cursor::new vs open_mem must match"
);
}
#[test]
fn open_mem_owned_with_options_accepts_repair_flag() {
let bytes = minimal_pdf_bytes();
let opts = PdfOpenOptions {
repair: true,
..PdfOpenOptions::default()
};
let mut pdf =
Pdf::open_mem_owned_with_options(bytes, opts).expect("open_mem_owned_with_options");
let refs = page_refs(&mut pdf).expect("page_refs");
assert_eq!(refs.len(), 1);
}
#[test]
fn open_mem_with_options_accepts_repair_flag() {
let bytes = minimal_pdf_bytes();
let opts = PdfOpenOptions {
repair: true,
..PdfOpenOptions::default()
};
let mut pdf = Pdf::open_mem_with_options(&bytes, opts).expect("open_mem_with_options");
let refs = page_refs(&mut pdf).expect("page_refs");
assert_eq!(refs.len(), 1);
}
}