use super::crypt_filters::{crypt_filter_modes_from_handle, interpret_cf_selector_from_handle};
use super::password::{decode_hex, password_bytes_for_read, PasswordMode};
use super::permissions::Permissions;
use super::standard::{
check_owner_password_r5, check_owner_password_r6, check_owner_password_v4_with_user_password,
check_owner_password_with_user_password, check_user_password, check_user_password_r5,
check_user_password_r6, check_user_password_v4, StandardHandlerInputs, StandardHandlerR5Inputs,
};
use crate::encryption::standard::{decrypt_cipher_bytes, StringCipher};
use crate::error::{EncryptedError, Result};
use crate::pipeline::aes::PlAesPdf;
use crate::qpdf_obj_gen::QpdfObjGen;
use crate::{ObjectHandle, ObjectRef};
use std::collections::BTreeMap;
#[derive(Debug, Clone)]
pub(crate) struct EncryptionState {
pub(crate) file_key: Vec<u8>,
pub(crate) encryption_v: i64,
pub(crate) cf_stream: EncryptionMode,
pub(crate) cf_string: EncryptionMode,
pub(crate) crypt_filters: BTreeMap<Vec<u8>, EncryptionMode>,
pub(crate) encrypt_metadata: bool,
pub(crate) encrypt_ref: Option<ObjectRef>,
pub(crate) weak_crypto: bool,
pub(crate) permissions: Permissions,
pub(crate) id0: Option<Vec<u8>>,
pub(crate) user_password_matched: bool,
pub(crate) owner_password_matched: bool,
pub(crate) user_password: Vec<u8>,
pub(crate) cached_object_encryption_key: Vec<u8>,
pub(crate) cached_key_og: Option<QpdfObjGen>,
}
type MethodChoice = (Option<bool>, bool);
impl EncryptionState {
pub(crate) fn select_method(method: EncryptionMode, encryption_v: i64) -> MethodChoice {
if encryption_v < 4 {
return (Some(false), false);
}
match method {
EncryptionMode::Identity => (None, false),
EncryptionMode::Aes128 | EncryptionMode::Aes256 => (Some(true), false),
EncryptionMode::Rc4 => (Some(false), false),
EncryptionMode::Unknown => {
(Some(true), true)
}
}
}
pub(crate) fn string_method(&self) -> MethodChoice {
let (method, encryption_v) = (self.cf_string, self.encryption_v);
Self::select_method(method, encryption_v)
}
pub(crate) fn commit_string_method(&mut self) {
if self.cf_string == EncryptionMode::Unknown {
self.cf_string = EncryptionMode::Aes128;
}
}
#[allow(dead_code)]
pub(crate) fn decrypt_object_string(
&mut self,
object_ref: ObjectRef,
bytes: &mut Vec<u8>,
use_aes: Option<bool>,
) -> Result<()> {
self.decrypt_object_string_qpdf_obj_gen(
QpdfObjGen::try_from_object_ref(object_ref)?,
bytes,
use_aes,
)
}
pub(crate) fn decrypt_object_string_qpdf_obj_gen(
&mut self,
object_gen: QpdfObjGen,
bytes: &mut Vec<u8>,
use_aes: Option<bool>,
) -> Result<()> {
if let Some(use_aes) = use_aes {
let key = self.key_for_qpdf_obj_gen(object_gen, use_aes).to_vec();
if !use_aes {
decrypt_cipher_bytes(bytes, StringCipher::Rc4 { key: &key })?;
} else if let Ok(key) = <&[u8; 32]>::try_from(key.as_slice()) {
decrypt_cipher_bytes(bytes, StringCipher::Aes256 { key })?;
} else if let Ok(key) = aes192_object_key(&key) {
decrypt_cipher_bytes(bytes, StringCipher::Aes192 { key: &key })?;
} else {
let key = aes128_object_key(&key)?;
decrypt_cipher_bytes(bytes, StringCipher::Aes128 { key: &key })?;
}
}
Ok(())
}
pub(crate) fn stream_method(&self, method: Option<EncryptionMode>) -> MethodChoice {
let (method, encryption_v) = (method.unwrap_or(self.cf_stream), self.encryption_v);
Self::select_method(method, encryption_v)
}
pub(crate) fn commit_stream_method(&mut self, method: Option<EncryptionMode>) {
if method.unwrap_or(self.cf_stream) == EncryptionMode::Unknown {
self.cf_stream = EncryptionMode::Aes128;
}
}
#[cfg(test)]
#[allow(dead_code)]
pub(crate) fn key_for_object(&mut self, og: ObjectRef, use_aes: bool) -> &[u8] {
self.key_for_qpdf_obj_gen(QpdfObjGen::from_valid_object_ref_for_test(og), use_aes)
}
pub(crate) fn key_for_qpdf_obj_gen(&mut self, og: QpdfObjGen, use_aes: bool) -> &[u8] {
if self.cached_key_og != Some(og) {
self.cached_object_encryption_key =
crate::encryption::primitives::compute_data_key_qpdf_obj_gen(
&self.file_key,
i64::from(og.get_obj()),
i64::from(og.get_gen()),
use_aes,
self.encryption_v,
);
self.cached_key_og = Some(og);
}
&self.cached_object_encryption_key
}
}
pub(crate) fn aes128_object_key(key: &[u8]) -> Result<[u8; 16]> {
match key.len() {
16 => key.try_into().map_err(|_| unreachable!("length checked")),
len if len > 16 && len != 24 && len != 32 => {
let mut object_key = [0u8; 16];
object_key.copy_from_slice(&key[..16]);
Ok(object_key)
}
_ => Err(EncryptedError::Malformed {
reason: "AES-128 object key is not 16 bytes".into(),
}
.into()),
}
}
pub(crate) fn aes192_object_key(key: &[u8]) -> Result<[u8; 24]> {
key.try_into().map_err(|_| {
EncryptedError::Malformed {
reason: "AES-192 object key is not 24 bytes".into(),
}
.into()
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum EncryptionMode {
Rc4,
Aes128,
Identity,
Aes256,
Unknown,
}
impl EncryptionMode {
pub(crate) fn qpdf_name(self) -> &'static str {
match self {
Self::Rc4 => "RC4",
Self::Aes128 => "AESv2",
Self::Aes256 => "AESv3",
Self::Identity => "none",
Self::Unknown => "unknown",
}
}
}
#[derive(Debug, Clone)]
pub(crate) struct EncryptionInspectionState {
pub(crate) v: i64,
pub(crate) r: i64,
pub(crate) length_bits: i64,
pub(crate) permissions: Permissions,
pub(crate) cf_stream: EncryptionMode,
pub(crate) cf_string: EncryptionMode,
pub(crate) crypt_filters: BTreeMap<Vec<u8>, EncryptionMode>,
pub(crate) stream_method: &'static str,
pub(crate) string_method: &'static str,
pub(crate) eff_method: &'static str,
pub(crate) user_password: Vec<u8>,
pub(crate) user_password_matched: bool,
pub(crate) owner_password_matched: bool,
pub(crate) weak_crypto: bool,
}
struct StandardHandlerInputsOwned {
v: i64,
r: i64,
length_bits: i64,
p: i32,
id0: Vec<u8>,
u: [u8; 32],
o: [u8; 32],
encrypt_metadata: bool,
}
impl StandardHandlerInputsOwned {
fn borrowed(&self) -> StandardHandlerInputs<'_> {
StandardHandlerInputs {
v: self.v,
r: self.r,
length_bits: self.length_bits,
p: self.p,
id0: &self.id0,
u: &self.u,
o: &self.o,
encrypt_metadata: self.encrypt_metadata,
}
}
}
struct StandardHandlerR5InputsOwned {
u: [u8; 48],
o: [u8; 48],
ue: [u8; 32],
oe: [u8; 32],
}
impl StandardHandlerR5InputsOwned {
fn borrowed(&self) -> StandardHandlerR5Inputs<'_> {
StandardHandlerR5Inputs {
u: &self.u,
o: &self.o,
ue: &self.ue,
oe: &self.oe,
}
}
}
pub(crate) fn parse_inspection_state(encrypt: &ObjectHandle) -> Result<EncryptionInspectionState> {
let v = required_version_from_handle(encrypt)?;
let r = required_revision_from_handle(encrypt)?;
let permissions = Permissions::new(required_permissions_from_handle(encrypt)?);
required_name_from_handle(encrypt, "Filter")?;
let length = encrypt.try_get_key(b"/Length")?;
let length_bits = effective_length_bits(v, &length)?;
encrypt_metadata_flag_from_handle(encrypt)?;
let crypt_filters = crypt_filter_modes_from_handle(encrypt, v)?;
let (cf_stream, cf_string, cf_file) = if matches!(v, 4 | 5) {
let stream =
interpret_cf_selector_from_handle(&crypt_filters, &encrypt.try_get_key(b"/StmF")?)?;
let string =
interpret_cf_selector_from_handle(&crypt_filters, &encrypt.try_get_key(b"/StrF")?)?;
let eff = encrypt.try_get_key(b"/EFF")?;
let file = if eff.try_as_name()?.is_some() {
interpret_cf_selector_from_handle(&crypt_filters, &eff)?
} else {
stream
};
(stream, string, file)
} else {
(
EncryptionMode::Identity,
EncryptionMode::Identity,
EncryptionMode::Identity,
)
};
let (stream_method, string_method, eff_method) = if matches!(v, 4 | 5) {
(
cf_stream.qpdf_name(),
cf_string.qpdf_name(),
cf_file.qpdf_name(),
)
} else {
("none", "none", "none")
};
let effective = |cf: EncryptionMode| {
if v >= 4 {
cf
} else {
EncryptionMode::Rc4
}
};
let rc4_in_use = matches!(effective(cf_stream), EncryptionMode::Rc4)
|| matches!(effective(cf_string), EncryptionMode::Rc4)
|| crypt_filters
.values()
.any(|mode| matches!(mode, EncryptionMode::Rc4));
let weak_crypto = if v == 5 {
r == 5 || rc4_in_use
} else {
rc4_in_use
};
Ok(EncryptionInspectionState {
v,
r,
length_bits,
permissions,
cf_stream,
cf_string,
crypt_filters,
stream_method,
string_method,
eff_method,
user_password: Vec::new(),
user_password_matched: false,
owner_password_matched: false,
weak_crypto,
})
}
pub(crate) struct AuthenticationResult {
pub(crate) state: EncryptionState,
pub(crate) perms_warning: Option<String>,
}
pub(crate) fn authenticate(
encrypt: &ObjectHandle,
inspection: &EncryptionInspectionState,
id: &ObjectHandle,
encrypt_ref: Option<ObjectRef>,
password: &[u8],
password_mode: PasswordMode,
password_is_hex_key: bool,
) -> Result<AuthenticationResult> {
let raw_password = password;
let parsed = inspection;
let revision = parsed.r;
let version = parsed.v;
let permissions = parsed.permissions;
let cf_stream = parsed.cf_stream;
let cf_string = parsed.cf_string;
let crypt_filters = parsed.crypt_filters.clone();
let effective = |cf: EncryptionMode| {
if version >= 4 {
cf
} else {
EncryptionMode::Rc4
}
};
let rc4_in_use = || {
matches!(effective(cf_stream), EncryptionMode::Rc4)
|| matches!(effective(cf_string), EncryptionMode::Rc4)
|| crypt_filters
.values()
.any(|mode| matches!(mode, EncryptionMode::Rc4))
};
let password = if password_is_hex_key {
Vec::new()
} else {
password_bytes_for_read(password, password_mode)?
};
let (
file_key,
encrypt_metadata,
weak_crypto,
user_password_matched,
owner_password_matched,
user_password,
id0,
) = if password_is_hex_key {
let file_key = decode_hex_file_key(raw_password)?;
let (encrypt_metadata, weak_crypto, id0) = if version == 5 {
let encrypt_metadata = encrypt_metadata_flag_from_handle(encrypt)?;
(encrypt_metadata, revision == 5 || rc4_in_use(), None)
} else {
let id0 = first_file_id_handle(id)?;
let inputs = standard_handler_inputs_from_handle(encrypt, &id0)?;
let borrowed = inputs.borrowed();
(borrowed.encrypt_metadata, rc4_in_use(), Some(id0))
};
(
file_key,
encrypt_metadata,
weak_crypto,
false,
false,
Vec::new(),
id0,
)
} else if version == 5 {
let inputs = standard_handler_r5_inputs_from_handle(encrypt)
.map_err(map_uo_length_to_bad_password)?;
let encrypt_metadata = encrypt_metadata_flag_from_handle(encrypt)?;
let inputs = inputs.borrowed();
let weak_crypto = revision == 5 || rc4_in_use();
let user_attempt = if revision >= 6 {
check_user_password_r6(&password, &inputs)
} else {
check_user_password_r5(&password, &inputs)
};
let owner_attempt = if revision >= 6 {
check_owner_password_r6(&password, &inputs)
} else {
check_owner_password_r5(&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),
};
let user_password = if user_password_matched {
password.clone()
} else {
Vec::new()
};
(
file_key,
encrypt_metadata,
weak_crypto,
user_password_matched,
owner_password_matched,
user_password,
None,
)
} else {
let id0 = first_file_id_handle(id)?;
let inputs = standard_handler_inputs_from_handle(encrypt, &id0)?;
let borrowed = inputs.borrowed();
let encrypt_metadata = borrowed.encrypt_metadata;
let weak_crypto = rc4_in_use();
let v4_path = inputs.v == 4 && inputs.r == 4;
let user_attempt = if v4_path {
check_user_password_v4(&password, &borrowed)
} else {
check_user_password(&password, &borrowed)
};
let owner_attempt = if v4_path {
check_owner_password_v4_with_user_password(&password, &borrowed)
} else {
check_owner_password_with_user_password(&password, &borrowed)
};
let user_password_matched = user_attempt.is_ok();
let owner_password_matched = owner_attempt.is_ok();
let (file_key, user_password) = match (user_attempt, owner_attempt) {
(Ok(key), _) => (key, password.clone()),
(Err(_), Ok((key, recovered))) => (key, recovered),
(Err(user_err), Err(_owner_err)) => return Err(user_err),
};
(
file_key,
encrypt_metadata,
weak_crypto,
user_password_matched,
owner_password_matched,
user_password,
Some(id0),
)
};
let perms_warning = if revision == 6 && !password_is_hex_key {
r6_perms_warning_from_handle(encrypt, &file_key, permissions, encrypt_metadata)?
} else {
None
};
Ok(AuthenticationResult {
state: EncryptionState {
file_key,
encryption_v: version,
cf_stream,
cf_string,
crypt_filters,
encrypt_metadata,
encrypt_ref,
weak_crypto,
permissions,
id0,
user_password_matched,
owner_password_matched,
user_password,
cached_object_encryption_key: Vec::new(),
cached_key_og: None,
},
perms_warning,
})
}
fn standard_handler_inputs_from_handle(
encrypt: &ObjectHandle,
id0: &[u8],
) -> Result<StandardHandlerInputsOwned> {
let v = required_integer_from_handle(encrypt, "V")?;
let r = required_integer_from_handle(encrypt, "R")?;
let length = encrypt.try_get_key(b"/Length")?;
let length_bits = effective_length_bits(v, &length)?;
let p = required_permissions_from_handle(encrypt)?;
let u = required_v_lt_5_32_byte_string_from_handle(encrypt, "U")?;
let o = required_v_lt_5_32_byte_string_from_handle(encrypt, "O")?;
let encrypt_metadata = encrypt_metadata_flag_from_handle(encrypt)?;
Ok(StandardHandlerInputsOwned {
v,
r,
length_bits,
p,
id0: id0.to_vec(),
u,
o,
encrypt_metadata,
})
}
pub(crate) fn effective_length_bits(v: i64, length: &ObjectHandle) -> Result<i64> {
if v <= 1 {
return Ok(40);
}
if v == 4 {
return Ok(128);
}
if v == 5 {
return Ok(256);
}
match length.try_as_integer()? {
Some(value) if (40..=128).contains(&value) && value % 8 == 0 => Ok(value),
_ => Ok(128),
}
}
fn standard_handler_r5_inputs_from_handle(
encrypt: &ObjectHandle,
) -> Result<StandardHandlerR5InputsOwned> {
Ok(StandardHandlerR5InputsOwned {
u: required_48_byte_string_from_handle(encrypt, "U")?,
o: required_48_byte_string_from_handle(encrypt, "O")?,
ue: required_32_byte_string_from_handle(encrypt, "UE")?,
oe: required_32_byte_string_from_handle(encrypt, "OE")?,
})
}
fn map_uo_length_to_bad_password(err: crate::Error) -> crate::Error {
match &err {
crate::Error::Encrypted(crate::error::EncryptedError::Malformed { reason })
if reason == "/U entry is not 48 bytes" || reason == "/O entry is not 48 bytes" =>
{
crate::error::EncryptedError::BadPassword.into()
}
_ => err,
}
}
fn decode_hex_file_key(raw: &[u8]) -> Result<Vec<u8>> {
Ok(decode_hex(raw))
}
fn required_integer_from_handle(dict: &ObjectHandle, key: &'static str) -> Result<i64> {
let key_name = format!("/{key}");
let value = dict.try_get_key(key_name.as_bytes())?;
match value.try_as_integer()? {
Some(value) => Ok(value),
None if value.is_null() => Err(crate::error::EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
.into()),
None => Err(crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not an integer"),
}
.into()),
}
}
fn required_revision_from_handle(encrypt: &ObjectHandle) -> Result<i64> {
required_integer_from_handle(encrypt, "R")
}
fn required_version_from_handle(encrypt: &ObjectHandle) -> Result<i64> {
required_integer_from_handle(encrypt, "V")
}
fn required_name_from_handle(dict: &ObjectHandle, key: &'static str) -> Result<String> {
let key_name = format!("/{key}");
let value = dict.try_get_key(key_name.as_bytes())?;
match value.try_as_name()? {
Some(name) => String::from_utf8(name).map_err(|_| {
crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not valid UTF-8"),
}
.into()
}),
None if value.is_null() => Err(crate::error::EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
.into()),
None => Err(crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not a name"),
}
.into()),
}
}
fn required_32_byte_string_from_handle(dict: &ObjectHandle, key: &'static str) -> Result<[u8; 32]> {
let key_name = format!("/{key}");
let value = dict.try_get_key(key_name.as_bytes())?;
let Some(bytes) = value.try_as_string()? else {
return Err(if value.is_null() {
crate::error::EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
} else {
crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not a string"),
}
}
.into());
};
bytes.as_slice().try_into().map_err(|_| {
crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not 32 bytes"),
}
.into()
})
}
fn required_v_lt_5_32_byte_string_from_handle(
dict: &ObjectHandle,
key: &'static str,
) -> Result<[u8; 32]> {
let key_name = format!("/{key}");
let value = dict.try_get_key(key_name.as_bytes())?;
let Some(bytes) = value.try_as_string()? else {
return Err(if value.is_null() {
crate::error::EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
} else {
crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not a string"),
}
}
.into());
};
if bytes.len() > 32 {
return Err(crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not 32 bytes"),
}
.into());
}
let mut padded = [0; 32];
padded[..bytes.len()].copy_from_slice(&bytes);
Ok(padded)
}
fn required_48_byte_string_from_handle(dict: &ObjectHandle, key: &'static str) -> Result<[u8; 48]> {
let key_name = format!("/{key}");
let value = dict.try_get_key(key_name.as_bytes())?;
let Some(bytes) = value.try_as_string()? else {
return Err(if value.is_null() {
crate::error::EncryptedError::Malformed {
reason: format!("missing /{key} entry"),
}
} else {
crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not a string"),
}
}
.into());
};
if bytes.len() < 48 {
return Err(crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not 48 bytes"),
}
.into());
}
bytes[..48].try_into().map_err(|_| {
crate::error::EncryptedError::Malformed {
reason: format!("/{key} entry is not 48 bytes"),
}
.into()
})
}
fn encrypt_metadata_flag_from_handle(encrypt: &ObjectHandle) -> Result<bool> {
let value = encrypt.try_get_key(b"/EncryptMetadata")?;
Ok(value.try_get_value_as_bool()?.unwrap_or(true))
}
fn required_permissions_from_handle(encrypt: &ObjectHandle) -> Result<i32> {
Ok(crate::encryption::qpdf_permission_i32(
required_integer_from_handle(encrypt, "P")?,
))
}
fn r6_perms_warning_from_handle(
encrypt: &ObjectHandle,
file_key: &[u8],
permissions: Permissions,
encrypt_metadata: bool,
) -> Result<Option<String>> {
let Some(entries) = encrypt.try_as_dictionary()? else {
return Ok(None);
};
let Some(perms) = entries.get(b"/Perms".as_slice()).cloned() else {
return Ok(None);
};
let Some(bytes) = perms.try_as_string()? else {
return Ok(Some("R=6 /Perms entry is not a string".into()));
};
let Ok(bytes) = <[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(),
));
};
let decrypted = PlAesPdf::process_to_vec_without_padding(
"AES /Perms decryption",
false,
&bytes,
file_key,
1,
None,
)?; let block: [u8; 16] = decrypted
.try_into()
.expect("qpdf AES /Perms processing returns one decrypted 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)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct FirstFileId {
pub(crate) value: Vec<u8>,
pub(crate) valid: bool,
}
pub(crate) fn first_file_id_handle_with_status(id: &ObjectHandle) -> Result<FirstFileId> {
let Some(ids) = id.try_as_array()? else {
return Ok(FirstFileId {
value: Vec::new(),
valid: false,
});
};
if ids.len() != 2 {
return Ok(FirstFileId {
value: Vec::new(),
valid: false,
});
}
let first = &ids[0];
first.try_dereference()?;
let Some(value) = first.as_string() else {
return Ok(FirstFileId {
value: Vec::new(),
valid: false,
});
};
Ok(FirstFileId { value, valid: true })
}
pub(crate) fn first_file_id_handle(id: &ObjectHandle) -> Result<Vec<u8>> {
Ok(first_file_id_handle_with_status(id)?.value)
}
#[cfg(test)]
mod tests {
use super::{
decode_hex_file_key, parse_inspection_state, required_v_lt_5_32_byte_string_from_handle,
};
use crate::ObjectHandle;
#[test]
fn v2_missing_length_uses_qpdf_128_bit_fallback() {
let encrypt = ObjectHandle::dictionary(vec![
(
b"/Filter".to_vec(),
ObjectHandle::name(b"Standard".to_vec()),
),
(b"/V".to_vec(), ObjectHandle::integer(2)),
(b"/R".to_vec(), ObjectHandle::integer(3)),
(b"/P".to_vec(), ObjectHandle::integer(-4)),
]);
let state = parse_inspection_state(&encrypt).expect("parse encryption dictionary");
assert_eq!(state.length_bits, 128);
}
#[test]
fn v4_r5_aes_is_not_weak_before_authentication() {
let aes_filter = ObjectHandle::dictionary(vec![(
b"/CFM".to_vec(),
ObjectHandle::name(b"AESV2".to_vec()),
)]);
let encrypt = ObjectHandle::dictionary(vec![
(
b"/Filter".to_vec(),
ObjectHandle::name(b"Standard".to_vec()),
),
(b"/V".to_vec(), ObjectHandle::integer(4)),
(b"/R".to_vec(), ObjectHandle::integer(5)),
(b"/P".to_vec(), ObjectHandle::integer(-4)),
(b"/Length".to_vec(), ObjectHandle::integer(128)),
(
b"/CF".to_vec(),
ObjectHandle::dictionary(vec![(b"/StdCF".to_vec(), aes_filter)]),
),
(b"/StmF".to_vec(), ObjectHandle::name(b"StdCF".to_vec())),
(b"/StrF".to_vec(), ObjectHandle::name(b"StdCF".to_vec())),
]);
let state = parse_inspection_state(&encrypt).expect("parse encryption dictionary");
assert_eq!((state.v, state.r), (4, 5));
assert!(
!state.weak_crypto,
"V=4/R=5 with AES filters must not be classified weak"
);
}
#[test]
fn v5_r5_stays_weak_before_authentication() {
let aes_filter = ObjectHandle::dictionary(vec![
(b"/CFM".to_vec(), ObjectHandle::name(b"AESV3".to_vec())),
(b"/Length".to_vec(), ObjectHandle::integer(32)),
]);
let encrypt = ObjectHandle::dictionary(vec![
(
b"/Filter".to_vec(),
ObjectHandle::name(b"Standard".to_vec()),
),
(b"/V".to_vec(), ObjectHandle::integer(5)),
(b"/R".to_vec(), ObjectHandle::integer(5)),
(b"/P".to_vec(), ObjectHandle::integer(-4)),
(
b"/CF".to_vec(),
ObjectHandle::dictionary(vec![(b"/StdCF".to_vec(), aes_filter)]),
),
(b"/StmF".to_vec(), ObjectHandle::name(b"StdCF".to_vec())),
(b"/StrF".to_vec(), ObjectHandle::name(b"StdCF".to_vec())),
]);
let state = parse_inspection_state(&encrypt).expect("parse encryption dictionary");
assert!(state.weak_crypto, "V=5/R=5 must stay weak");
}
#[test]
fn positive_unsigned_permission_value_wraps_like_qpdf() {
let encrypt = ObjectHandle::dictionary(vec![
(
b"/Filter".to_vec(),
ObjectHandle::name(b"Standard".to_vec()),
),
(b"/V".to_vec(), ObjectHandle::integer(2)),
(b"/R".to_vec(), ObjectHandle::integer(3)),
(b"/P".to_vec(), ObjectHandle::integer(4_294_967_292)),
]);
let state = parse_inspection_state(&encrypt).expect("parse positive /P");
assert_eq!(state.permissions.raw(), -4);
}
#[test]
fn raw_key_hex_decoding_matches_qpdf_ignored_characters_and_odd_nibbles() {
assert_eq!(decode_hex_file_key(b"zA-1").unwrap(), vec![0xa1]);
assert_eq!(decode_hex_file_key(b"F").unwrap(), vec![0xf0]);
}
#[test]
fn v_lt_5_short_standard_entry_is_nul_padded_like_qpdf() {
let short_u = vec![
0x82, 0xf8, 0x58, 0xc9, 0x56, 0xfc, 0x27, 0xa1, 0xd0, 0x51, 0xb0, 0x9b, 0xfb, 0x19,
0xb7, 0x2,
];
let encrypt = ObjectHandle::dictionary(vec![(
b"/U".to_vec(),
ObjectHandle::string(short_u.clone()),
)]);
let padded = required_v_lt_5_32_byte_string_from_handle(&encrypt, "U")
.expect("qpdf pads a short V<5 /U entry with NUL bytes");
assert_eq!(&padded[..short_u.len()], short_u.as_slice());
assert_eq!(&padded[short_u.len()..], &[0; 32 - 16]);
}
#[test]
fn v_lt_5_missing_standard_entry_is_malformed() {
let encrypt = ObjectHandle::dictionary(Vec::new());
let error = required_v_lt_5_32_byte_string_from_handle(&encrypt, "U")
.expect_err("missing /U must remain malformed");
assert!(matches!(
error,
crate::Error::Encrypted(crate::error::EncryptedError::Malformed { reason })
if reason == "missing /U entry"
));
}
#[test]
fn v_lt_5_non_string_standard_entry_is_malformed() {
let encrypt = ObjectHandle::dictionary(vec![(b"/U".to_vec(), ObjectHandle::integer(1))]);
let error = required_v_lt_5_32_byte_string_from_handle(&encrypt, "U")
.expect_err("non-string /U must remain malformed");
assert!(matches!(
error,
crate::Error::Encrypted(crate::error::EncryptedError::Malformed { reason })
if reason == "/U entry is not a string"
));
}
#[test]
fn v_lt_5_overlength_standard_entry_is_malformed() {
let encrypt =
ObjectHandle::dictionary(vec![(b"/U".to_vec(), ObjectHandle::string(vec![0; 33]))]);
let error = required_v_lt_5_32_byte_string_from_handle(&encrypt, "U")
.expect_err("overlength /U must remain malformed");
assert!(matches!(
error,
crate::Error::Encrypted(crate::error::EncryptedError::Malformed { reason })
if reason == "/U entry is not 32 bytes"
));
}
}