use crate::filters::decode_stream_data;
use crate::pages::page_refs;
use crate::{Object, ObjectRef, Pdf};
use std::fmt;
use std::io::{BufReader, Read, Seek};
#[derive(Debug)]
pub enum LinearizationCheckError {
NotLinearized,
InvalidParam { message: String },
Io(Box<dyn std::error::Error + Send + Sync>),
}
impl fmt::Display for LinearizationCheckError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
LinearizationCheckError::NotLinearized => {
write!(
f,
"not a linearized PDF: the first object in the file has no /Linearized key"
)
}
LinearizationCheckError::InvalidParam { message } => {
write!(f, "linearization check failed: {message}")
}
LinearizationCheckError::Io(e) => write!(f, "I/O error: {e}"),
}
}
}
impl std::error::Error for LinearizationCheckError {}
impl From<crate::Error> for LinearizationCheckError {
fn from(e: crate::Error) -> Self {
LinearizationCheckError::Io(Box::new(e))
}
}
impl From<std::io::Error> for LinearizationCheckError {
fn from(e: std::io::Error) -> Self {
LinearizationCheckError::Io(Box::new(e))
}
}
pub type CheckResult = std::result::Result<(), LinearizationCheckError>;
macro_rules! fail {
($($arg:tt)*) => {
return Err(LinearizationCheckError::InvalidParam {
message: format!($($arg)*),
})
};
}
fn as_u64(obj: &Object, key: &str) -> std::result::Result<u64, LinearizationCheckError> {
match obj {
Object::Integer(n) if *n >= 0 => Ok(*n as u64),
Object::Real(r) if r.is_finite() && *r >= 0.0 && r.fract() == 0.0 => Ok(*r as u64),
other => Err(LinearizationCheckError::InvalidParam {
message: format!(
"/{key} is not a non-negative integer (got {})",
debug_obj(other)
),
}),
}
}
fn is_pdf_whitespace(b: u8) -> bool {
matches!(b, b'\0' | b'\t' | b'\n' | b'\x0c' | b'\r' | b' ')
}
fn debug_obj(obj: &Object) -> String {
let mut buf = Vec::new();
obj.write_pdf(&mut buf);
String::from_utf8_lossy(&buf).into_owned()
}
pub fn check_linearization<R: Read + Seek>(pdf: &mut Pdf<R>, file_bytes: &[u8]) -> CheckResult {
let file_len = file_bytes.len() as u64;
let first_obj_ref =
find_first_object_ref(file_bytes).ok_or(LinearizationCheckError::NotLinearized)?;
let first_obj = pdf
.resolve(first_obj_ref)
.map_err(LinearizationCheckError::from)?;
let Object::Dictionary(param_dict) = first_obj else {
return Err(LinearizationCheckError::NotLinearized);
};
let Some(linearized_val) = param_dict.get("Linearized") else {
return Err(LinearizationCheckError::NotLinearized);
};
match linearized_val {
Object::Integer(n) if *n > 0 => {}
Object::Real(r) if r.is_finite() && *r > 0.0 => {}
_ => return Err(LinearizationCheckError::NotLinearized),
}
let l_obj = param_dict.get("L").cloned().unwrap_or(Object::Null);
let l_val = as_u64(&l_obj, "L")?;
if l_val != file_len {
fail!("/L ({l_val}) does not match file length ({file_len})");
}
let n_obj = param_dict.get("N").cloned().unwrap_or(Object::Null);
let n_val = as_u64(&n_obj, "N")?;
let page_count = page_refs(pdf)
.map_err(|e| LinearizationCheckError::Io(Box::new(e)))?
.len() as u64;
if n_val != page_count {
fail!("/N ({n_val}) does not match page count ({page_count})");
}
let o_obj = param_dict.get("O").cloned().unwrap_or(Object::Null);
let o_num = as_u64(&o_obj, "O")?;
let o_num_u32 = u32::try_from(o_num).map_err(|_| LinearizationCheckError::InvalidParam {
message: format!("/O ({o_num}) does not fit in u32 — invalid object number"),
})?;
let o_ref = ObjectRef::new(o_num_u32, 0);
let o_object = pdf.resolve(o_ref).map_err(LinearizationCheckError::from)?;
match &o_object {
Object::Dictionary(d) => {
if let Some(Object::Name(type_name)) = d.get("Type") {
if type_name != b"Page" {
fail!(
"/O ({o_num}) points to an object with /Type /{} instead of /Page",
String::from_utf8_lossy(type_name)
);
}
} else if d.get("Parent").is_none() && d.get("MediaBox").is_none() {
fail!(
"/O ({o_num}) points to a dictionary with no /Type, /Parent or /MediaBox \
— does not look like a Page object"
);
}
}
Object::Null => {
fail!("/O ({o_num}) refers to a non-existent object");
}
_ => {
fail!("/O ({o_num}) does not refer to a dictionary");
}
}
let h_obj = param_dict.get("H").cloned().unwrap_or(Object::Null);
let (h_offset, h_length) = match &h_obj {
Object::Array(arr) if arr.len() >= 2 => {
let off = as_u64(&arr[0], "H[0]")?;
let len = as_u64(&arr[1], "H[1]")?;
(off, len)
}
_ => {
fail!("/H is missing or has unexpected format (expected [offset length])");
}
};
if h_offset >= file_len {
fail!("/H[0] offset ({h_offset}) is beyond file length ({file_len})");
}
if h_offset.saturating_add(h_length) > file_len {
fail!("/H[0]+/H[1] ({h_offset}+{h_length}) extends beyond file length ({file_len})");
}
check_hint_stream_at_offset(pdf, file_bytes, h_offset as usize, h_length)?;
let e_obj = param_dict.get("E").cloned().unwrap_or(Object::Null);
let e_val = as_u64(&e_obj, "E")?;
if e_val >= file_len {
fail!("/E ({e_val}) must be less than file length ({file_len})");
}
let t_obj = param_dict.get("T").cloned().unwrap_or(Object::Null);
let t_val = as_u64(&t_obj, "T")?;
let t_usize = usize::try_from(t_val).map_err(|_| LinearizationCheckError::InvalidParam {
message: format!("/T ({t_val}) does not fit in platform usize"),
})?;
if t_usize
.checked_add(4)
.is_none_or(|end| end > file_bytes.len())
{
fail!("/T ({t_val}) is too close to end of file to contain xref keyword");
}
const T_BACKSCAN_WINDOW: usize = 32;
let search_start = t_usize.saturating_sub(T_BACKSCAN_WINDOW);
let window_end = (t_usize + 4).min(file_bytes.len());
let window = &file_bytes[search_start..window_end];
let xref_pos = window.windows(4).enumerate().find_map(|(i, w)| {
if w != b"xref" {
return None;
}
let absolute = search_start + i;
let prev_ok = absolute == 0 || is_pdf_whitespace(file_bytes[absolute - 1]);
let next = absolute + 4;
let next_ok = next >= file_bytes.len() || is_pdf_whitespace(file_bytes[next]);
if prev_ok && next_ok {
Some(absolute)
} else {
None
}
});
let Some(xref_pos) = xref_pos else {
fail!(
"/T ({t_val}) is not within the last cross-reference section \
(no xref keyword token found in the backscan window before /T)"
);
};
let first_entry_pos = parse_xref_first_entry_pos(file_bytes, xref_pos).ok_or_else(|| {
LinearizationCheckError::InvalidParam {
message: format!(
"/T ({t_val}) backscan found `xref` at byte {xref_pos}, but the \
subsection header (`<start> <count>\\n`) is malformed or truncated"
),
}
})?;
if t_usize < xref_pos || t_usize >= first_entry_pos {
fail!(
"/T ({t_val}) is outside the xref subsection header range \
[{xref_pos}, {first_entry_pos}) — must point at the `xref` keyword \
or inside its subsection header line, not into the entries"
);
}
Ok(())
}
fn parse_xref_first_entry_pos(file_bytes: &[u8], xref_pos: usize) -> Option<usize> {
let mut i = xref_pos.checked_add(4)?;
while i < file_bytes.len() && is_pdf_whitespace(file_bytes[i]) {
i += 1;
}
let digits1_start = i;
while i < file_bytes.len() && file_bytes[i].is_ascii_digit() {
i += 1;
}
if i == digits1_start {
return None;
}
if i >= file_bytes.len() || file_bytes[i] != b' ' {
return None;
}
i += 1;
let digits2_start = i;
while i < file_bytes.len() && file_bytes[i].is_ascii_digit() {
i += 1;
}
if i == digits2_start {
return None;
}
if i >= file_bytes.len() || !is_pdf_whitespace(file_bytes[i]) {
return None;
}
while i < file_bytes.len() && is_pdf_whitespace(file_bytes[i]) {
i += 1;
}
Some(i)
}
fn check_hint_stream_at_offset<R: Read + Seek>(
pdf: &mut Pdf<R>,
file_bytes: &[u8],
offset: usize,
expected_h_length: u64,
) -> CheckResult {
const SCAN_WINDOW: usize = 64;
let scan_end = (offset + SCAN_WINDOW).min(file_bytes.len());
let window = &file_bytes[offset..scan_end];
let Some((obj_num, obj_gen)) = parse_obj_header_at(window) else {
fail!(
"/H[0] offset ({offset}) does not point at an indirect object header \
(expected `N G obj`)"
);
};
let endobj_pos = file_bytes[offset..]
.windows(b"endobj".len())
.position(|w| w == b"endobj")
.map(|p| offset + p);
let Some(endobj_pos) = endobj_pos else {
fail!(
"hint stream object {obj_num} {obj_gen} (at /H[0] offset {offset}) has no endobj keyword"
);
};
let mut actual_end = endobj_pos + b"endobj".len();
if actual_end < file_bytes.len() && file_bytes[actual_end] == b'\n' {
actual_end += 1;
}
let actual_length = (actual_end - offset) as u64;
if actual_length != expected_h_length {
fail!(
"/H[1] ({expected_h_length}) does not match the actual hint stream byte length \
({actual_length}) measured from offset {offset} to endobj"
);
}
let hint_ref = ObjectRef::new(obj_num, obj_gen);
let hint_obj = pdf
.resolve(hint_ref)
.map_err(LinearizationCheckError::from)?;
match hint_obj {
Object::Stream(stream) => {
decode_stream_data(&stream.dict, &stream.data).map_err(|e| {
LinearizationCheckError::InvalidParam {
message: format!(
"hint stream (object {obj_num} {obj_gen}) could not be decoded: {e}"
),
}
})?;
}
Object::Null => {
fail!(
"hint stream object {obj_num} {obj_gen} (at /H[0] offset {offset}) does not exist"
);
}
_ => {
fail!(
"hint stream object {obj_num} {obj_gen} (at /H[0] offset {offset}) is not a stream"
);
}
}
Ok(())
}
fn find_first_object_ref(file_bytes: &[u8]) -> Option<ObjectRef> {
let mut i = 0;
while i + 3 <= file_bytes.len() {
let pos_in_slice = file_bytes[i..].windows(3).position(|w| w == b"obj")?;
let abs = i + pos_in_slice;
let preceded_by_ws = abs
.checked_sub(1)
.and_then(|p| file_bytes.get(p))
.is_some_and(|&b| is_pdf_whitespace(b));
if preceded_by_ws {
let line_start = file_bytes[..abs]
.iter()
.rposition(|&b| matches!(b, b'\n' | b'\r'))
.map_or(0, |p| p + 1);
let mut start = line_start;
while start < abs && is_pdf_whitespace(file_bytes[start]) {
start += 1;
}
let not_in_comment = file_bytes.get(start) != Some(&b'%');
if not_in_comment {
if let Some((num, gen)) = parse_obj_header_at(&file_bytes[start..]) {
return Some(ObjectRef::new(num, gen));
}
}
}
i = abs + 3;
}
None
}
fn parse_obj_header_at(window: &[u8]) -> Option<(u32, u16)> {
let mut i = 0;
while i < window.len() && is_pdf_whitespace(window[i]) {
i += 1;
}
let num_start = i;
while i < window.len() && window[i].is_ascii_digit() {
i += 1;
}
if i == num_start {
return None;
}
let obj_num: u32 = std::str::from_utf8(&window[num_start..i])
.ok()?
.parse()
.ok()?;
if i >= window.len() || !is_pdf_whitespace(window[i]) {
return None;
}
while i < window.len() && is_pdf_whitespace(window[i]) {
i += 1;
}
let gen_start = i;
while i < window.len() && window[i].is_ascii_digit() {
i += 1;
}
if i == gen_start {
return None;
}
let obj_gen: u16 = std::str::from_utf8(&window[gen_start..i])
.ok()?
.parse()
.ok()?;
if i >= window.len() || !is_pdf_whitespace(window[i]) {
return None;
}
while i < window.len() && is_pdf_whitespace(window[i]) {
i += 1;
}
if window.get(i..i + 3) != Some(b"obj") {
return None;
}
i += 3;
match window.get(i) {
None => {}
Some(&b) if is_pdf_whitespace(b) => {}
_ => return None,
}
Some((obj_num, obj_gen))
}
pub fn check_linearization_bytes(file_bytes: &[u8]) -> CheckResult {
use std::io::Cursor;
let mut pdf = Pdf::open(Cursor::new(file_bytes.to_vec()))
.map_err(|e| LinearizationCheckError::Io(Box::new(e)))?;
check_linearization(&mut pdf, file_bytes)
}
pub fn check_linearization_path(
path: &std::path::Path,
) -> std::result::Result<(), LinearizationCheckError> {
let file_bytes = std::fs::read(path)?;
let mut pdf = Pdf::open(BufReader::new(std::io::Cursor::new(file_bytes.clone())))
.map_err(|e| LinearizationCheckError::Io(Box::new(e)))?;
check_linearization(&mut pdf, &file_bytes)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::linearization::plan::LinearizationPlan;
use crate::linearization::renumber::RenumberMap;
use crate::linearization::writer::write_linearized;
use crate::writer::WriteOptions;
use std::io::Cursor;
fn tiny_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{}\n%%EOF\n",
xref_start
);
pdf.extend_from_slice(trailer.as_bytes());
pdf
}
fn build_linearized_bytes() -> Vec<u8> {
let raw = tiny_pdf_bytes();
let mut pdf = Pdf::open(Cursor::new(raw.clone())).unwrap();
let plan = LinearizationPlan::from_pdf(&mut pdf).unwrap();
let renumber = RenumberMap::from_plan(&plan);
let mut pdf2 = Pdf::open(Cursor::new(raw)).unwrap();
let mut doc =
write_linearized(&plan, &renumber, &mut pdf2, &WriteOptions::default()).unwrap();
doc.back_patch().unwrap();
doc.bytes
}
#[test]
fn check_linearized_bytes_passes() {
let bytes = build_linearized_bytes();
let result = check_linearization_bytes(&bytes);
assert!(
result.is_ok(),
"check should pass on well-formed linearized output: {result:?}"
);
}
#[test]
fn non_linearized_pdf_is_rejected() {
let bytes = tiny_pdf_bytes();
let result = check_linearization_bytes(&bytes);
assert!(
matches!(result, Err(LinearizationCheckError::NotLinearized)),
"non-linearized PDF must yield NotLinearized, got {result:?}"
);
}
#[test]
fn tampered_l_is_rejected() {
let mut bytes = build_linearized_bytes();
let needle = b"/L 0";
if let Some(pos) = bytes.windows(needle.len()).position(|w| w == needle) {
let val_start = pos + 3; let val_end = val_start + 10;
bytes[val_end - 1] = if bytes[val_end - 1] == b'9' {
b'0'
} else {
bytes[val_end - 1] + 1
};
}
let result = check_linearization_bytes(&bytes);
assert!(
matches!(result, Err(LinearizationCheckError::InvalidParam { .. })),
"tampered /L must yield InvalidParam, got {result:?}"
);
}
#[test]
fn as_u64_rejects_fractional_real() {
let frac = Object::Real(1.9);
assert!(
matches!(
as_u64(&frac, "N"),
Err(LinearizationCheckError::InvalidParam { .. })
),
"Real(1.9) must not be silently truncated to 1"
);
}
#[test]
fn as_u64_accepts_integer_valued_real() {
let exact = Object::Real(42.0);
assert_eq!(as_u64(&exact, "N").unwrap(), 42, "Real(42.0) is exact");
}
#[test]
fn parse_obj_header_accepts_zero_generation() {
assert_eq!(parse_obj_header_at(b"3 0 obj\n<<>>"), Some((3, 0)));
}
#[test]
fn parse_obj_header_accepts_non_zero_generation() {
assert_eq!(parse_obj_header_at(b"42 7 obj\n<<>>"), Some((42, 7)));
}
#[test]
fn parse_obj_header_rejects_partial_match() {
assert_eq!(parse_obj_header_at(b"123 4 not_an_obj\n"), None);
assert_eq!(parse_obj_header_at(b"123 4"), None);
assert_eq!(parse_obj_header_at(b"not digits"), None);
}
#[test]
fn parse_obj_header_skips_leading_whitespace() {
assert_eq!(parse_obj_header_at(b" \n5 0 obj\n"), Some((5, 0)));
}
#[test]
fn parse_xref_first_entry_pos_basic() {
let bytes = b"xref\n0 4\n0000000000 65535 f \n";
assert_eq!(parse_xref_first_entry_pos(bytes, 0), Some(9));
}
#[test]
fn parse_xref_first_entry_pos_with_offset() {
let bytes = b"prefix\nxref\n12 100\n0000000000 ...";
let xref_pos = bytes.windows(4).position(|w| w == b"xref").unwrap();
let expected_first_entry = xref_pos + 12;
assert_eq!(
parse_xref_first_entry_pos(bytes, xref_pos),
Some(expected_first_entry)
);
}
#[test]
fn parse_xref_first_entry_pos_rejects_malformed() {
assert_eq!(parse_xref_first_entry_pos(b"xrefjunk", 0), None);
assert_eq!(parse_xref_first_entry_pos(b"xref\n0\n", 0), None);
assert_eq!(parse_xref_first_entry_pos(b"xref\n0 ", 0), None);
}
#[test]
fn find_first_object_ref_returns_object_number_and_generation() {
let bytes: &[u8] = b"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n12 7 obj\n<< /Linearized 1 >>\n";
let r = find_first_object_ref(bytes).expect("expected an object ref");
assert_eq!(r.number, 12);
assert_eq!(r.generation, 7);
}
#[test]
fn find_first_object_ref_handles_zero_generation() {
let bytes: &[u8] = b"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n3 0 obj\n";
let r = find_first_object_ref(bytes).expect("expected an object ref");
assert_eq!(r.number, 3);
assert_eq!(r.generation, 0);
}
#[test]
fn find_first_object_ref_returns_none_on_missing_obj() {
assert_eq!(find_first_object_ref(b"%PDF-1.7\nxref\n0 0\n"), None);
}
#[test]
fn find_first_object_ref_skips_comment_lines_that_look_like_obj_headers() {
let bytes: &[u8] = b"%PDF-1.7\n% example: 12 7 obj inside comment\n3 0 obj\n<<>>\n";
let r = find_first_object_ref(bytes).expect("expected an object ref");
assert_eq!(r.number, 3);
assert_eq!(r.generation, 0);
}
#[test]
fn find_first_object_ref_rejects_word_object_in_content_stream() {
let bytes: &[u8] = b"%PDF-1.7\nq 12 7 object\nQ\n5 0 obj\n";
let r = find_first_object_ref(bytes).expect("expected an object ref");
assert_eq!(r.number, 5);
assert_eq!(r.generation, 0);
}
#[test]
fn parse_obj_header_rejects_object_word() {
assert_eq!(parse_obj_header_at(b"12 7 object"), None);
}
#[test]
fn parse_obj_header_accepts_obj_followed_by_eof() {
assert_eq!(parse_obj_header_at(b"12 7 obj"), Some((12, 7)));
}
#[test]
fn parse_obj_header_accepts_tab_between_number_and_generation() {
assert_eq!(parse_obj_header_at(b"12\t7 obj"), Some((12, 7)));
}
#[test]
fn parse_obj_header_accepts_tab_before_obj_keyword() {
assert_eq!(parse_obj_header_at(b"12 7\tobj"), Some((12, 7)));
}
#[test]
fn parse_obj_header_accepts_multiple_spaces_between_tokens() {
assert_eq!(parse_obj_header_at(b"12 7 obj"), Some((12, 7)));
}
#[test]
fn find_first_object_ref_accepts_tab_separated_header() {
let bytes: &[u8] = b"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n3\t0\tobj\n";
let r = find_first_object_ref(bytes).expect("expected an object ref");
assert_eq!(r.number, 3);
assert_eq!(r.generation, 0);
}
#[test]
fn find_first_object_ref_accepts_multispace_separated_header() {
let bytes: &[u8] = b"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n12 7 obj\n";
let r = find_first_object_ref(bytes).expect("expected an object ref");
assert_eq!(r.number, 12);
assert_eq!(r.generation, 7);
}
}