1use std::collections::{HashMap, HashSet};
6use std::sync::{Arc, Mutex};
7
8use crate::crypt::Decryptor;
9use crate::error::{Error, Result};
10use crate::filters;
11use crate::lexer::{find, rfind, Cursor};
12use crate::object::{Dict, ObjRef, Object, Stream};
13
14type ObjStmIndex = Arc<Vec<(u32, usize)>>;
16
17#[derive(Debug, Clone, Copy)]
18enum XrefEntry {
19 Offset { offset: usize, gen: u16 },
21 InStream { stream_num: u32, index: u32 },
23}
24
25pub struct PdfFile {
29 data: Vec<u8>,
30 xref: HashMap<u32, XrefEntry>,
31 pub trailer: Dict,
32 pub decryptor: Option<Decryptor>,
33 encrypt_ref: Option<ObjRef>,
35 cache: Mutex<HashMap<u32, Arc<Object>>>,
36 objstm_cache: Mutex<HashMap<u32, ObjStmIndex>>,
38 objstm_data: Mutex<HashMap<u32, Arc<[u8]>>>,
39}
40
41impl PdfFile {
42 pub fn load(mut data: Vec<u8>, password: Option<&str>) -> Result<Self> {
43 let header =
45 find(&data, 0, b"%PDF-").ok_or_else(|| Error::Parse("no %PDF header".into()))?;
46 if header > 0 {
47 data.drain(..header);
48 }
49
50 let (xref, trailer) = match Self::read_xref_chain(&data) {
51 Ok(ok) if ok.1.contains("Root") => ok,
52 _ => Self::rebuild_by_scan(&data)?,
53 };
54
55 let mut file = Self {
56 data,
57 xref,
58 trailer,
59 decryptor: None,
60 encrypt_ref: None,
61 cache: Mutex::new(HashMap::new()),
62 objstm_cache: Mutex::new(HashMap::new()),
63 objstm_data: Mutex::new(HashMap::new()),
64 };
65
66 if !file.trailer.contains("Root") {
70 return Err(Error::Parse("trailer has no /Root".into()));
71 }
72
73 if let Some(enc) = file.trailer.get("Encrypt").cloned() {
74 file.encrypt_ref = enc.as_ref_id();
75 let enc_dict = file
76 .resolve(&enc)
77 .as_dict()
78 .cloned()
79 .ok_or_else(|| Error::Parse("encrypt entry is not a dictionary".into()))?;
80 let ids = file
81 .trailer
82 .get("ID")
83 .map(|o| file.resolve(o))
84 .and_then(|o| o.as_array().and_then(|a| a.first().cloned()))
85 .and_then(|o| o.as_string().map(<[u8]>::to_vec))
86 .unwrap_or_default();
87 let resolve = |o: &Object| file.resolve(o);
88 file.decryptor = Some(Decryptor::new(&enc_dict, &ids, password, &resolve)?);
89 file.cache.lock().unwrap().clear();
92 }
93
94 Ok(file)
95 }
96
97 pub fn data(&self) -> &[u8] {
98 &self.data
99 }
100
101 fn read_xref_chain(data: &[u8]) -> Result<(HashMap<u32, XrefEntry>, Dict)> {
104 let tail_start = data.len().saturating_sub(2048);
105 let sx = rfind(&data[tail_start..], b"startxref")
106 .map(|p| p + tail_start)
107 .ok_or_else(|| Error::Parse("no startxref".into()))?;
108 let mut c = Cursor::at(data, sx + b"startxref".len());
109 c.skip_ws();
110 let offset = match Cursor::parse_number(c.read_regular()) {
111 Some(Object::Int(i)) if i >= 0 => i as usize,
112 _ => return Err(Error::Parse("bad startxref offset".into())),
113 };
114
115 let mut xref = HashMap::new();
116 let mut trailer = Dict::new();
117 let mut visited = HashSet::new();
118 let mut queue = vec![offset];
119
120 while let Some(off) = queue.pop() {
121 if off >= data.len() || !visited.insert(off) {
122 continue;
123 }
124 let mut c = Cursor::at(data, off);
125 c.skip_ws();
126 if c.eat_keyword(b"xref") {
127 let section_trailer = Self::read_xref_table(&mut c, &mut xref)?;
128 if let Some(prev) = section_trailer.get("Prev").and_then(|o| o.as_int()) {
132 queue.insert(0, prev as usize);
133 }
134 if let Some(x) = section_trailer.get("XRefStm").and_then(|o| o.as_int()) {
135 queue.push(x as usize);
136 }
137 merge_trailer(&mut trailer, section_trailer);
138 } else {
139 let dict = Self::read_xref_stream(data, off, &mut xref)?;
140 if let Some(prev) = dict.get("Prev").and_then(|o| o.as_int()) {
141 queue.insert(0, prev as usize);
142 }
143 merge_trailer(&mut trailer, dict);
144 }
145 }
146 Ok((xref, trailer))
147 }
148
149 fn read_xref_table(c: &mut Cursor, xref: &mut HashMap<u32, XrefEntry>) -> Result<Dict> {
150 loop {
151 c.skip_ws();
152 if c.eat_keyword(b"trailer") {
153 c.skip_ws();
154 let t = c
155 .read_object()
156 .and_then(|o| o.as_dict().cloned())
157 .ok_or_else(|| Error::Parse("xref table without trailer dict".into()))?;
158 return Ok(t);
159 }
160 let start = match Cursor::parse_number(c.read_regular()) {
162 Some(Object::Int(i)) if i >= 0 => i as u32,
163 _ => return Err(Error::Parse("bad xref subsection".into())),
164 };
165 c.skip_ws();
166 let count = match Cursor::parse_number(c.read_regular()) {
167 Some(Object::Int(i)) if i >= 0 => i as u32,
168 _ => return Err(Error::Parse("bad xref subsection count".into())),
169 };
170 for i in 0..count {
171 c.skip_ws();
172 let f1 = Cursor::parse_number(c.read_regular()).and_then(|o| o.as_int());
173 c.skip_ws();
174 let f2 = Cursor::parse_number(c.read_regular()).and_then(|o| o.as_int());
175 c.skip_ws();
176 let kind = c.read_regular();
177 let (Some(offset), Some(gen)) = (f1, f2) else {
178 return Err(Error::Parse("bad xref entry".into()));
179 };
180 if kind == b"n" {
183 let Some(num) = start.checked_add(i) else {
184 continue;
185 };
186 xref.entry(num).or_insert(XrefEntry::Offset {
187 offset: offset as usize,
188 gen: gen.clamp(0, u16::MAX as i64) as u16,
189 });
190 }
191 }
192 }
193 }
194
195 fn read_xref_stream(
196 data: &[u8],
197 off: usize,
198 xref: &mut HashMap<u32, XrefEntry>,
199 ) -> Result<Dict> {
200 let mut c = Cursor::at(data, off);
201 c.skip_ws();
202 let _num = c.read_regular();
204 c.skip_ws();
205 let _gen = c.read_regular();
206 c.skip_ws();
207 if !c.eat_keyword(b"obj") {
208 return Err(Error::Parse(
209 "startxref points at neither table nor stream".into(),
210 ));
211 }
212 let obj = c
213 .read_object()
214 .ok_or_else(|| Error::Parse("empty xref stream object".into()))?;
215 let Object::Dict(dict) = obj else {
216 return Err(Error::Parse("xref stream object is not a stream".into()));
217 };
218 c.skip_ws();
219 if !c.eat_keyword(b"stream") {
220 return Err(Error::Parse("xref stream without stream body".into()));
221 }
222 let length = dict
223 .get("Length")
224 .and_then(|o| o.as_int())
225 .map(|l| l.max(0) as usize);
226 let Object::Stream(stream) = c.read_stream_data(dict, length) else {
227 unreachable!()
228 };
229
230 let no_resolve = |o: &Object| o.clone();
232 let decoded = filters::decode(&stream.dict, &stream.raw, &no_resolve)?;
233 let content = decoded.data;
234
235 let w: Vec<usize> = stream
236 .dict
237 .get("W")
238 .and_then(|o| o.as_array())
239 .map(|a| {
240 a.iter()
241 .filter_map(|o| o.as_int())
242 .map(|i| i.max(0) as usize)
243 .collect()
244 })
245 .unwrap_or_default();
246 if w.len() < 3 {
247 return Err(Error::Parse("xref stream missing /W".into()));
248 }
249 let row = w.iter().sum::<usize>();
250 if row == 0 {
251 return Err(Error::Parse("xref stream /W is all zero".into()));
252 }
253 let size = stream
254 .dict
255 .get("Size")
256 .and_then(|o| o.as_int())
257 .unwrap_or(0);
258 let index: Vec<i64> = stream
259 .dict
260 .get("Index")
261 .and_then(|o| o.as_array())
262 .map(|a| a.iter().filter_map(|o| o.as_int()).collect())
263 .unwrap_or_else(|| vec![0, size]);
264
265 let read_field =
266 |bytes: &[u8]| -> u64 { bytes.iter().fold(0u64, |acc, &b| (acc << 8) | b as u64) };
267
268 let mut rows = content.chunks_exact(row);
269 for pair in index.chunks(2) {
270 let [start, count] = pair else { break };
271 for i in 0..*count {
272 let Some(r) = rows.next() else { break };
273 let (t, rest) = r.split_at(w[0]);
274 let (f2, f3) = rest.split_at(w[1]);
275 let t = if w[0] == 0 { 1 } else { read_field(t) };
277 let f2 = read_field(f2);
278 let f3 = read_field(&f3[..w[2]]);
279 let num = (*start + i) as u32;
280 match t {
281 1 => {
282 xref.entry(num).or_insert(XrefEntry::Offset {
283 offset: f2 as usize,
284 gen: f3.min(u16::MAX as u64) as u16,
285 });
286 }
287 2 => {
288 xref.entry(num).or_insert(XrefEntry::InStream {
289 stream_num: f2 as u32,
290 index: f3 as u32,
291 });
292 }
293 _ => {} }
295 }
296 }
297 Ok(stream.dict)
298 }
299
300 fn rebuild_by_scan(data: &[u8]) -> Result<(HashMap<u32, XrefEntry>, Dict)> {
304 let mut xref = HashMap::new();
305 let mut objstms = Vec::new();
306 let mut pos = 0usize;
307 while let Some(hit) = find(data, pos, b"obj") {
308 pos = hit + 3;
309 if data
311 .get(hit + 3)
312 .is_some_and(|&b| crate::lexer::is_regular(b))
313 {
314 continue;
315 }
316 let mut i = hit;
318 let step_back_digits = |mut i: usize| -> Option<(usize, u64)> {
319 while i > 0 && crate::lexer::is_whitespace(data[i - 1]) {
320 i -= 1;
321 }
322 let end = i;
323 while i > 0 && data[i - 1].is_ascii_digit() {
324 i -= 1;
325 }
326 if i == end {
327 return None;
328 }
329 let v = std::str::from_utf8(&data[i..end])
330 .ok()?
331 .parse::<u64>()
332 .ok()?;
333 Some((i, v))
334 };
335 let Some((gi, gen)) = step_back_digits(i) else {
336 continue;
337 };
338 i = gi;
339 let Some((ni, num)) = step_back_digits(i) else {
340 continue;
341 };
342 if num > u32::MAX as u64 || gen > u16::MAX as u64 {
343 continue;
344 }
345 xref.insert(
346 num as u32,
347 XrefEntry::Offset {
348 offset: ni,
349 gen: gen as u16,
350 },
351 );
352 let mut c = Cursor::at(data, hit + 3);
354 c.skip_ws();
355 if let Some(Object::Dict(d)) = c.clone().read_object() {
356 if d.get("Type").and_then(|o| o.as_name()) == Some("ObjStm") {
357 objstms.push(num as u32);
358 }
359 }
360 }
361 if xref.is_empty() {
362 return Err(Error::Parse("no objects found in scan".into()));
363 }
364
365 let probe = PdfFile {
367 data: data.to_vec(),
368 xref: xref.clone(),
369 trailer: Dict::new(),
370 decryptor: None,
371 encrypt_ref: None,
372 cache: Mutex::new(HashMap::new()),
373 objstm_cache: Mutex::new(HashMap::new()),
374 objstm_data: Mutex::new(HashMap::new()),
375 };
376 for sn in objstms {
377 if let Ok(members) = probe.objstm_index(sn) {
378 for (i, (num, _)) in members.iter().enumerate() {
379 xref.entry(*num).or_insert(XrefEntry::InStream {
380 stream_num: sn,
381 index: i as u32,
382 });
383 }
384 }
385 }
386
387 let mut trailer = Dict::new();
389 let mut tpos = 0usize;
390 let mut last_trailer = None;
391 while let Some(hit) = find(data, tpos, b"trailer") {
392 tpos = hit + 7;
393 let mut c = Cursor::at(data, tpos);
394 c.skip_ws();
395 if let Some(Object::Dict(d)) = c.read_object() {
396 last_trailer = Some(d);
397 }
398 }
399 if let Some(t) = last_trailer {
400 merge_trailer(&mut trailer, t);
401 }
402 if !trailer.contains("Root") {
403 let probe = PdfFile {
404 xref: xref.clone(),
405 ..probe
406 };
407 let mut nums: Vec<u32> = xref.keys().copied().collect();
408 nums.sort_unstable();
409 for num in nums {
410 if let Object::Dict(d) | Object::Stream(Stream { dict: d, .. }) =
411 probe.get(num).as_ref()
412 {
413 if d.get("Type").and_then(|o| o.as_name()) == Some("Catalog") {
414 trailer.insert("Root", Object::Ref(ObjRef::new(num, 0)));
415 break;
416 }
417 }
418 }
419 }
420 Ok((xref, trailer))
421 }
422
423 pub fn get(&self, num: u32) -> Arc<Object> {
428 if let Some(hit) = self.cache.lock().unwrap().get(&num) {
429 return hit.clone();
430 }
431 let obj = Arc::new(self.load_object(num, &mut HashSet::new()));
432 self.cache.lock().unwrap().insert(num, obj.clone());
433 obj
434 }
435
436 pub fn resolve(&self, obj: &Object) -> Object {
438 let mut current = obj.clone();
439 let mut hops = 0;
440 while let Object::Ref(r) = current {
441 if hops > 32 {
442 return Object::Null;
443 }
444 hops += 1;
445 current = (*self.get(r.num)).clone();
446 }
447 current
448 }
449
450 fn load_object(&self, num: u32, in_flight: &mut HashSet<u32>) -> Object {
451 if !in_flight.insert(num) {
452 return Object::Null; }
454 let entry = match self.xref.get(&num) {
455 Some(e) => *e,
456 None => return Object::Null,
457 };
458 let obj = match entry {
459 XrefEntry::Offset { offset, gen } => self.load_at_offset(num, gen, offset, in_flight),
460 XrefEntry::InStream { stream_num, index } => {
461 self.load_from_objstm(stream_num, index, num, in_flight)
462 }
463 };
464 in_flight.remove(&num);
465 obj
466 }
467
468 fn load_at_offset(
469 &self,
470 num: u32,
471 gen: u16,
472 offset: usize,
473 in_flight: &mut HashSet<u32>,
474 ) -> Object {
475 if offset >= self.data.len() {
476 return Object::Null;
477 }
478 let mut c = Cursor::at(&self.data, offset);
479 c.skip_ws();
480 let n_tok = c.read_regular().to_vec();
481 c.skip_ws();
482 let _g = c.read_regular();
483 c.skip_ws();
484 if !c.eat_keyword(b"obj") {
485 return Object::Null;
486 }
487 match Cursor::parse_number(&n_tok) {
490 Some(Object::Int(n)) if n == num as i64 => {}
491 _ => return Object::Null,
492 }
493
494 let Some(mut obj) = c.read_object() else {
495 return Object::Null;
496 };
497
498 if let Object::Dict(dict) = obj {
499 c.skip_ws();
500 if c.eat_keyword(b"stream") {
501 let length = dict.get("Length").and_then(|len| match len {
502 Object::Int(i) => Some((*i).max(0) as usize),
503 Object::Ref(r) => self
504 .load_object(r.num, in_flight)
505 .as_int()
506 .map(|i| i.max(0) as usize),
507 _ => None,
508 });
509 obj = c.read_stream_data(dict, length);
510 } else {
511 obj = Object::Dict(dict);
512 }
513 }
514
515 self.decrypt_in_place(&mut obj, num, gen);
516 obj
517 }
518
519 fn decrypt_in_place(&self, obj: &mut Object, num: u32, gen: u16) {
520 let Some(dec) = &self.decryptor else { return };
521 if self.encrypt_ref.is_some_and(|r| r.num == num) {
522 return;
523 }
524 fn walk(obj: &mut Object, dec: &Decryptor, num: u32, gen: u16) {
525 match obj {
526 Object::String(s) => *s = dec.decrypt_string(num, gen, s),
527 Object::Array(items) => {
528 for i in items {
529 walk(i, dec, num, gen);
530 }
531 }
532 Object::Dict(d) => {
533 for v in d.0.values_mut() {
534 walk(v, dec, num, gen);
535 }
536 }
537 Object::Stream(s) => {
538 for v in s.dict.0.values_mut() {
539 walk(v, dec, num, gen);
540 }
541 let ty = s.dict.get("Type").and_then(|o| o.as_name());
544 if ty != Some("XRef") && dec.stream_needs_decrypt(ty) {
545 s.raw = dec.decrypt_stream(num, gen, &s.raw).into();
546 }
547 }
548 _ => {}
549 }
550 }
551 walk(obj, dec, num, gen);
552 }
553
554 fn objstm_index(&self, stream_num: u32) -> Result<ObjStmIndex> {
558 if let Some(hit) = self.objstm_cache.lock().unwrap().get(&stream_num) {
559 return Ok(hit.clone());
560 }
561 let container = self.get(stream_num);
562 let Object::Stream(stream) = container.as_ref() else {
563 return Err(Error::Parse(format!("object stream {stream_num} missing")));
564 };
565 let resolve = |o: &Object| self.resolve(o);
566 let decoded = filters::decode(&stream.dict, &stream.raw, &resolve)?;
567 let data: Arc<[u8]> = decoded.data.into();
568
569 let n = stream
570 .dict
571 .get("N")
572 .map(|o| self.resolve(o))
573 .and_then(|o| o.as_int())
574 .unwrap_or(0)
575 .max(0) as usize;
576 let first = stream
577 .dict
578 .get("First")
579 .map(|o| self.resolve(o))
580 .and_then(|o| o.as_int())
581 .unwrap_or(0)
582 .max(0) as usize;
583
584 let mut pairs = Vec::with_capacity(n);
585 let mut c = Cursor::new(&data);
586 for _ in 0..n {
587 c.skip_ws();
588 let num = Cursor::parse_number(c.read_regular()).and_then(|o| o.as_int());
589 c.skip_ws();
590 let off = Cursor::parse_number(c.read_regular()).and_then(|o| o.as_int());
591 let (Some(num), Some(off)) = (num, off) else {
592 break;
593 };
594 if num >= 0 && off >= 0 {
595 pairs.push((num as u32, first + off as usize));
596 }
597 }
598
599 let pairs = Arc::new(pairs);
600 self.objstm_cache
601 .lock()
602 .unwrap()
603 .insert(stream_num, pairs.clone());
604 self.objstm_data.lock().unwrap().insert(stream_num, data);
605 Ok(pairs)
606 }
607
608 fn load_from_objstm(
609 &self,
610 stream_num: u32,
611 index: u32,
612 expect_num: u32,
613 _in_flight: &mut HashSet<u32>,
614 ) -> Object {
615 let Ok(pairs) = self.objstm_index(stream_num) else {
616 return Object::Null;
617 };
618 let slot = pairs
621 .get(index as usize)
622 .filter(|(n, _)| *n == expect_num)
623 .or_else(|| pairs.iter().find(|(n, _)| *n == expect_num));
624 let Some(&(_, offset)) = slot else {
625 return Object::Null;
626 };
627 let data = self.objstm_data.lock().unwrap().get(&stream_num).cloned();
628 let Some(data) = data else {
629 return Object::Null;
630 };
631 let mut c = Cursor::at(&data, offset);
632 c.read_object().unwrap_or(Object::Null)
635 }
636
637 pub fn decode_stream(&self, stream: &Stream) -> Result<filters::Decoded> {
639 let resolve = |o: &Object| self.resolve(o);
640 filters::decode(&stream.dict, &stream.raw, &resolve)
641 }
642}
643
644fn merge_trailer(into: &mut Dict, from: Dict) {
646 for (k, v) in from.0 {
647 into.0.entry(k).or_insert(v);
648 }
649}
650
651#[cfg(test)]
652pub(crate) mod tests {
653 use super::*;
654
655 pub fn tiny_pdf() -> Vec<u8> {
657 let mut out: Vec<u8> = Vec::new();
658 let mut offsets = [0usize; 6];
659 out.extend_from_slice(b"%PDF-1.4\n");
660 let content = b"BT /F1 12 Tf 72 720 Td (Hi) Tj ET";
661 let objs: Vec<(usize, String)> = vec![
662 (1, "<< /Type /Catalog /Pages 2 0 R >>".into()),
663 (2, "<< /Type /Pages /Kids [3 0 R] /Count 1 >>".into()),
664 (
665 3,
666 "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R \
667 /Resources << /Font << /F1 5 0 R >> >> >>"
668 .into(),
669 ),
670 (
671 4,
672 format!(
673 "<< /Length {} >>\nstream\n{}\nendstream",
674 content.len(),
675 std::str::from_utf8(content).unwrap()
676 ),
677 ),
678 (
679 5,
680 "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>".into(),
681 ),
682 ];
683 for (num, body) in &objs {
684 offsets[*num] = out.len();
685 out.extend_from_slice(format!("{num} 0 obj\n{body}\nendobj\n").as_bytes());
686 }
687 let xref_at = out.len();
688 out.extend_from_slice(b"xref\n0 6\n0000000000 65535 f \n");
689 for offset in &offsets[1..6] {
690 out.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
691 }
692 out.extend_from_slice(b"trailer\n<< /Size 6 /Root 1 0 R >>\n");
693 out.extend_from_slice(format!("startxref\n{xref_at}\n%%EOF\n").as_bytes());
694 out
695 }
696
697 #[test]
698 fn loads_classic_xref() {
699 let file = PdfFile::load(tiny_pdf(), None).unwrap();
700 let root = file.trailer.get("Root").unwrap().as_ref_id().unwrap();
701 let cat = file.get(root.num);
702 assert_eq!(
703 cat.as_dict().unwrap().get("Type").unwrap().as_name(),
704 Some("Catalog")
705 );
706 let content = file.get(4);
707 let s = content.as_stream().unwrap();
708 let d = file.decode_stream(s).unwrap();
709 assert!(d.data.starts_with(b"BT"));
710 }
711
712 #[test]
713 fn survives_broken_startxref() {
714 let mut pdf = tiny_pdf();
715 let sx = rfind(&pdf, b"startxref").unwrap();
717 pdf[sx + 10] = b'9';
718 pdf[sx + 11] = b'9';
719 let file = PdfFile::load(pdf, None).unwrap();
720 assert!(file.trailer.contains("Root"));
721 assert!(file.get(3).as_dict().is_some());
722 }
723
724 #[test]
725 fn survives_junk_before_header() {
726 let mut pdf = b"GARBAGE BYTES ".to_vec();
727 pdf.extend_from_slice(&tiny_pdf());
728 let file = PdfFile::load(pdf, None).unwrap();
729 assert!(file.get(1).as_dict().is_some());
730 }
731
732 #[test]
733 fn wrong_length_falls_back_to_endstream_scan() {
734 let pdf = tiny_pdf();
735 let s = String::from_utf8(pdf)
736 .unwrap()
737 .replace("/Length 33", "/Length 4");
738 let file = PdfFile::load(s.into_bytes(), None).unwrap();
739 let content = file.get(4);
740 let stream = content.as_stream().unwrap();
741 assert!(stream.raw.starts_with(b"BT"));
742 assert!(stream.raw.ends_with(b"ET"));
743 }
744
745 #[test]
746 fn missing_object_is_null() {
747 let file = PdfFile::load(tiny_pdf(), None).unwrap();
748 assert!(file.get(99).is_null());
749 assert_eq!(file.resolve(&Object::Ref(ObjRef::new(99, 0))), Object::Null);
750 }
751}