///|
let max_file_bytes : Int32 = 32 * 1024 * 1024
///|
priv struct Document {
pdf : @pdf.PdfDocument
generations : Map[Int32, Int32]
mut decoded_bytes : Int32
outline_budget : Ref[Int32]
fonts : Map[Int32, FontData]
decoded_streams : Map[Int32, Bytes]
mut content_bytes : Int32
mut form_calls : Int32
}
///|
fn read_document(data : Bytes) -> Document raise GuardError {
if data.length() > max_file_bytes {
raise Unsupported("PDF exceeds the 32 MiB input limit")
}
let xref = @pdfreader.pdf_read_startxref_position(data) catch {
_ => raise Invalid("missing or invalid startxref")
}
if xref < 0 || xref >= data.length() {
raise Invalid("startxref outside the PDF")
}
let marker = data.get_view(start=xref, end=xref + 4)
let (pdf, decoded_bytes) = if marker is Some(bytes) && bytes == b"xref" {
(read_classic_document(data, xref), 0)
} else {
read_stream_document(data, xref)
}
if pdf.is_encrypted() {
raise Unsupported("encrypted PDF")
}
if pdf.object_count() > 50_000 {
raise Unsupported("PDF exceeds the object count limit")
}
let generations : Map[Int32, Int32] = Map([])
for entry in pdf.parsed_object_entries() {
generations.set(entry.0, entry.1)
}
{
pdf,
generations,
decoded_bytes,
outline_budget: Ref(16 * 1024 * 1024),
fonts: Map([]),
decoded_streams: Map([]),
content_bytes: 0,
form_calls: 0,
}
}
///|
fn check_trailer(trailer : @syntax.PdfObject) -> Unit raise GuardError {
if field(trailer, b"Prev") is Some(_) || field(trailer, b"XRefStm") is Some(_) {
raise Unsupported("incremental PDF or hybrid cross-reference data")
}
if field(trailer, b"Encrypt") is Some(_) {
raise Unsupported("encrypted PDF")
}
}
///|
fn read_classic_document(
data : Bytes,
xref : Int32,
) -> @pdf.PdfDocument raise GuardError {
let cursor = @pdfcore.byte_cursor_of_view(data[xref:])
let (entries, trailer) = try {
let entries = @pdfreader.pdf_cursor_read_classic_xref_entries(cursor)
(entries, @pdfreader.pdf_cursor_read_trailer_dictionary(cursor))
} catch {
_ =>
raise Invalid("cannot read the classic cross-reference table or trailer")
}
if entries.length() > 50_000 {
raise Unsupported("PDF exceeds the object count limit")
}
check_trailer(trailer)
@pdf.pdf_read_classic_document_from_bytes(data) catch {
_ =>
raise Invalid(
"cannot read PDF objects or cross-reference data with pdflite",
)
}
}
///|
fn Document::reference(
self : Document,
value : @syntax.PdfObject,
) -> ObjectRef? {
match value {
PdfIndirect(number) =>
self.generations.get(number).map(generation => { number, generation, })
_ => None
}
}
///|
fn Document::resolve(
self : Document,
value : @syntax.PdfObject,
) -> @syntax.PdfObject raise GuardError {
match value {
PdfIndirect(number) => {
if !self.generations.contains(number) {
raise Invalid("unresolved PDF object \{number}")
}
match self.pdf.lookup_object_or_null(number) {
PdfIndirect(_) => raise Unsupported("indirect-to-indirect PDF object")
resolved => resolved
}
}
_ => value
}
}
///|
fn field(
value : @syntax.PdfObject,
key : Bytes,
) -> @syntax.PdfObject? raise GuardError {
let items = match value {
PdfDictionary(items) => items
PdfStreamObject(stream) => return field(stream.dictionary, key)
_ => raise Invalid("expected PDF dictionary at /\{name_string(key)}")
}
let mut found = None
for entry in items {
if pdf_name_payload(entry.0) == key {
if found is Some(_) {
raise Invalid("duplicate /\{name_string(key)} in PDF dictionary")
}
found = Some(entry.1)
}
}
found
}
///|
fn required_field(
value : @syntax.PdfObject,
key : Bytes,
) -> @syntax.PdfObject raise GuardError {
match field(value, key) {
Some(result) => result
None => raise Invalid("missing /\{name_string(key)} in PDF dictionary")
}
}
///|
fn Document::name(
self : Document,
item : @syntax.PdfObject,
) -> Bytes raise GuardError {
match self.resolve(item) {
PdfNameObject(n) => pdf_name_payload(n).to_owned()
_ => raise Invalid("expected a PDF name")
}
}
///|
fn Document::array(
self : Document,
item : @syntax.PdfObject,
) -> Array[@syntax.PdfObject] raise GuardError {
match self.resolve(item) {
PdfArray(entries) => entries
_ => raise Invalid("expected a PDF array")
}
}
///|
fn Document::int(
self : Document,
item : @syntax.PdfObject,
) -> Int32 raise GuardError {
match self.resolve(item) {
PdfInteger(n) => n
_ => raise Invalid("expected a PDF integer")
}
}
///|
fn Document::number(
self : Document,
item : @syntax.PdfObject,
) -> Double raise GuardError {
let n = match self.resolve(item) {
PdfInteger(n) => n.to_double()
PdfReal(n) | PdfExactReal(n) => n
_ => raise Invalid("expected a PDF number")
}
if !n.is_finite() || n.abs() > 1_000_000.0 {
raise Unsupported("PDF number exceeds the supported coordinate range")
}
n
}
///|
fn inflate_bounded(bytes : Bytes, limit : Int32) -> Bytes raise GuardError {
let data : BytesView = bytes[:]
let decoder = @zlib.Decoder()
let buffer = @buffer.Buffer()
let chunk : FixedArray[Byte] = FixedArray::make(16384, b'\x00')
let mut pos = 0
while !decoder.is_finished() {
ignore(
decoder.step_into(data[pos:], chunk, end=true) catch {
_ => raise Invalid("invalid FlateDecode stream")
},
)
let produced = decoder.last_produced()
let consumed = decoder.last_consumed()
if produced > limit - buffer.length() {
raise Unsupported("decoded stream exceeds its size limit")
}
for i in 0.. Bytes raise GuardError {
if raw is PdfIndirect(number) &&
self.decoded_streams.get(number) is Some(cached) {
if cached.length() > limit {
raise Unsupported("decoded stream exceeds its size limit")
}
return cached
}
let stream = self.resolve(raw)
if !(stream is PdfStreamObject(_)) {
raise Invalid("expected a PDF stream for text, font or CMap data")
}
let bytes = stream.stream_bytes() catch {
_ => raise Invalid("cannot read PDF stream bytes")
}
let filter = match field(stream, b"Filter") {
None => None
Some(item) =>
match self.resolve(item) {
PdfNull => None
PdfNameObject(name) => Some(pdf_name_payload(name).to_owned())
PdfArray(items) if items.length() == 1 => Some(self.name(items[0]))
_ => raise Unsupported("unsupported PDF stream filter chain")
}
}
if field(stream, b"DecodeParms") is Some(parameters) {
let params = match self.resolve(parameters) {
PdfArray(items) if items.length() == 1 => self.resolve(items[0])
other => other
}
if !(params is PdfNull) {
if field(params, b"Predictor") is Some(predictor) {
if self.int(predictor) != 1 {
raise Unsupported("PDF stream predictors")
}
}
}
}
let budget = limit.min(64 * 1024 * 1024 - self.decoded_bytes)
let decoded = match filter {
None => {
if bytes.length() > budget {
raise Unsupported("decoded stream exceeds its size limit")
}
bytes
}
Some(name) if name == b"FlateDecode" => inflate_bounded(bytes, budget)
Some(name) =>
raise Unsupported("unsupported PDF stream filter /\{name_string(name)}")
}
self.decoded_bytes += decoded.length()
if raw is PdfIndirect(number) {
self.decoded_streams.set(number, decoded)
}
decoded
}
///|
fn Document::contents(
self : Document,
page : @syntax.PdfObject,
) -> Array[@syntax.PdfObject] raise GuardError {
match field(page, b"Contents") {
None => []
Some(item) =>
match self.resolve(item) {
PdfNull => []
PdfArray(items) => items
PdfStreamObject(_) => [item]
_ => raise Invalid("invalid /Contents in page dictionary")
}
}
}