hexapdf 0.14.3 → 0.14.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c43d8e9e117db1717ddfee73a54e4384743b8aa35863ab5bd19ffe57b8ce5674
-  data.tar.gz: 1020c8a3de8fcdf201500c1c0d22dfb99ed27daebac7baac92748f8127efc992
+  metadata.gz: 958692ab2c53f74fe599c0ba8c9c046aa41b38d2bf840a47dec8f0e258fd86e0
+  data.tar.gz: b41d46ccb39d36d351cc143ba0afc145e785307b2a7ae90bc0f32d1ab76949af
 SHA512:
-  metadata.gz: e19eea4e88077afb7e8532fa6fe9ab2a03ffc5588749b72277462a971ebcec877ee72868d0ab698744117d46566be98e65c10225649d3bd1b4cd6e64e9625767
-  data.tar.gz: 6626a9feba0af0b46f293c1069a0d53b458a0dc29d08b82253f14f9bb98a878b914042faccc433b73f2f0e35d4da47c58a1bdebd2f3dee2fefb24c076a4e6bb3
+  metadata.gz: c16e231aeeb12b55daf75a28a8e3918f6807127257655f42d1f3433c76cb25f0ea42daafc8dd20bd37099f9ef5f6f2a6a3e3b2468acf000c041452a32908e1ee
+  data.tar.gz: a9a1fff7c7ff699c2b48333d89fae1aa67cd7ce61003845f76e4855cfc2f2ad5969ae668359091cd3fa225ea9a8b99fb9883e28b07fe6fcd985c7f83b842969d

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 0.14.4 - 2021-02-27
+
+### Added
+
+* Support for the Crypt filters
+
+### Changed
+
+* [HexaPDF::MalformedPDFError] to make the `pos` argument optional
+
+### Fixed
+
+* Handling of invalid floating point numbers NaN, Inf and -Inf when serializing
+* Processing of invalid PDF files containing NaN and Inf instead of numbers
+* Bug in Type1 font AFM parser that occured if the file doesn't end with a new
+  line character
+* Cross-reference table reconstruction to handle the case of an entry specifying
+  a non-existent indirect object
+* Cross-reference table reconstruction to handle trailers specified by cross-
+  reference streams
+* Cross-reference table reconstruction to use the set security handle for
+  decrypting indirect objects
+* Parsing of cross-reference streams where data is missing
+
+
 ## 0.14.3 - 2021-02-16
 
 ### Fixed

data/lib/hexapdf/configuration.rb

@@ -393,7 +393,7 @@ module HexaPDF
                         DCTDecode: 'HexaPDF::Filter::PassThrough',
                         DCT: 'HexaPDF::Filter::PassThrough',
                         JPXDecode: 'HexaPDF::Filter::PassThrough',
-                        Crypt: nil,
+                        Crypt: 'HexaPDF::Filter::Crypt',
                         Encryption: 'HexaPDF::Filter::Encryption',
                       },
                       'font.map' => {},

data/lib/hexapdf/encryption/security_handler.rb

@@ -268,7 +268,7 @@ module HexaPDF
           str.replace(string_algorithm.decrypt(key, str))
         end
 
-        if obj.kind_of?(HexaPDF::Stream)
+        if obj.kind_of?(HexaPDF::Stream) && obj.raw_stream.filter[0] != :Crypt
           unless string_algorithm == stream_algorithm
             key = object_key(obj.oid, obj.gen, stream_algorithm)
           end
@@ -300,7 +300,12 @@ module HexaPDF
             obj.raw_stream.key == key && obj.raw_stream.algorithm == stream_algorithm
           obj.raw_stream.undecrypted_fiber
         else
-          stream_algorithm.encryption_fiber(key, result)
+          filter = obj[:Filter]
+          if filter == :Crypt || (filter.kind_of?(PDFArray) && filter[0] == :Crypt)
+            result
+          else
+            stream_algorithm.encryption_fiber(key, result)
+          end
         end
       end
 

data/lib/hexapdf/error.rb

@@ -47,14 +47,14 @@ module HexaPDF
 
     # Creates a new malformed PDF error object for the given exception message.
     #
-    # The byte position where the error occured has to be given via the +pos+ argument.
-    def initialize(message, pos:)
+    # The byte position where the error occured can be given via the +pos+ argument.
+    def initialize(message, pos: nil)
       super(message)
       @pos = pos
     end
 
     def message # :nodoc:
-      "PDF malformed around position #{pos}: #{super}"
+      "PDF malformed#{pos ? "around position #{pos}" : ''}: #{super}"
     end
 
   end

data/lib/hexapdf/filter.rb

@@ -95,6 +95,7 @@ module HexaPDF
     autoload(:Predictor, 'hexapdf/filter/predictor')
 
     autoload(:Encryption, 'hexapdf/filter/encryption')
+    autoload(:Crypt, 'hexapdf/filter/crypt')
 
     autoload(:PassThrough, 'hexapdf/filter/pass_through')
 

data/lib/hexapdf/filter/crypt.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2020 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/error'
+
+module HexaPDF
+  module Filter
+
+    # This filter module implements the Crypt filter. The only supported part is using the Identity
+    # filter.
+    module Crypt
+
+      # See HexaPDF::Filter
+      def self.decoder(source, options)
+        if !options || !options.key?(:Name) || options[:Name] == :Identity
+          source
+        else
+          raise FilterError, "Handling of Crypt filters besides Identity is not implemented"
+        end
+      end
+
+      singleton_class.send(:alias_method, :encoder, :decoder)
+
+    end
+
+  end
+end

data/lib/hexapdf/font/type1/afm_parser.rb

@@ -207,7 +207,8 @@ module HexaPDF
 
         # Returns the rest of the line, with whitespace stripped.
         def parse_string
-          line = @line.strip!
+          @line.strip!
+          line = @line
           @line = ''
           line
         end

data/lib/hexapdf/parser.rb

@@ -56,10 +56,12 @@ module HexaPDF
     # PDF references are resolved using the associated Document object.
     def initialize(io, document)
       @io = io
-      @tokenizer = Tokenizer.new(io)
+      on_correctable_error = document.config['parser.on_correctable_error'].curry[document]
+      @tokenizer = Tokenizer.new(io, on_correctable_error: on_correctable_error)
       @document = document
       @object_stream_data = {}
       @reconstructed_revision = nil
+      @in_reconstruct_revision = false
       retrieve_pdf_header_offset_and_version
     end
 
@@ -94,7 +96,8 @@ module HexaPDF
 
       @document.wrap(obj, oid: oid, gen: gen, stream: stream)
     rescue HexaPDF::MalformedPDFError
-      reconstructed_revision.object(xref_entry)
+      reconstructed_revision.object(xref_entry) ||
+        @document.wrap(nil, oid: xref_entry.oid, gen: xref_entry.gen)
     end
 
     # Parses the indirect object at the specified offset.
@@ -389,6 +392,9 @@ module HexaPDF
     # If the file contains multiple cross-reference sections, all objects will be put into a single
     # cross-reference table, later objects overwriting prior ones.
     def reconstruct_revision
+      return if @in_reconstruct_revision
+      @in_reconstruct_revision = true
+
       raise unless @document.config['parser.try_xref_reconstruction']
       msg = "#{$!} - trying cross-reference table reconstruction"
       @document.config['parser.on_correctable_error'].call(@document, msg, @tokenizer.pos)
@@ -424,16 +430,22 @@ module HexaPDF
         end
       end
 
-      trailer&.delete(:Prev) # no need for this and may wreak havoc
       if !trailer || trailer.empty?
-        raise_malformed("Could not reconstruct malformed PDF because trailer was not found", pos: 0)
+        _, trailer = load_revision(startxref_offset) rescue nil
+        unless trailer
+          @in_reconstruct_revision = false
+          raise_malformed("Could not reconstruct malformed PDF because trailer was not found", pos: 0)
+        end
       end
+      trailer&.delete(:Prev) # no need for this and may wreak havoc
 
       loader = lambda do |xref_entry|
         obj, oid, gen, stream = parse_indirect_object(xref_entry.pos)
-        @document.wrap(obj, oid: oid, gen: gen, stream: stream)
+        obj = @document.wrap(obj, oid: oid, gen: gen, stream: stream)
+        @document.security_handler ? @document.security_handler.decrypt(obj) : obj
       end
 
+      @in_reconstruct_revision = false
       Revision.new(@document.wrap(trailer, type: :XXTrailer), xref_section: xref,
                    loader: loader)
     end

data/lib/hexapdf/serializer.rb

@@ -191,7 +191,13 @@ module HexaPDF
     #
     # See: PDF1.7 s7.3.3
     def serialize_float(obj)
-      -0.0001 < obj && obj < 0.0001 && obj != 0 ? sprintf("%.6f", obj) : obj.round(6).to_s
+      if -0.0001 < obj && obj < 0.0001 && obj != 0
+        sprintf("%.6f", obj)
+      elsif obj.finite?
+        obj.round(6).to_s
+      else
+        raise HexaPDF::Error, "Can't serialize special floating point number #{obj}"
+      end
     end
 
     # The regexp matches all characters that need to be escaped and the substs hash contains the

data/lib/hexapdf/tokenizer.rb

@@ -73,11 +73,15 @@ module HexaPDF
     # The IO object from the tokens are read.
     attr_reader :io
 
-    # Creates a new tokenizer.
-    def initialize(io)
+    # Creates a new tokenizer for the given IO stream.
+    #
+    # If +on_correctable_error+ is set to an object responding to +call(msg, pos)+, errors for
+    # correctable situations are only raised if the return value of calling the object is +true+.
+    def initialize(io, on_correctable_error: nil)
       @io = io
       @ss = StringScanner.new(''.b)
       @original_pos = -1
+      @on_correctable_error = on_correctable_error || proc { false }
       self.pos = 0
     end
 
@@ -180,7 +184,8 @@ module HexaPDF
           end
         else
           unless allow_keyword
-            raise HexaPDF::MalformedPDFError.new("Invalid object, got token #{token}", pos: pos)
+            maybe_raise("Invalid object, got token #{token}", force: token !~ /^-?(nan|inf)$/i)
+            token = 0
           end
         end
       end
@@ -428,6 +433,20 @@ module HexaPDF
       true
     end
 
+    # Calls the @on_correctable_error callable object with the given message and the current
+    # position. If the returned value is +true+, raises a HexaPDF::MalformedPDFError. Otherwise the
+    # error is corrected (by the caller) and tokenization continues.
+    #
+    # If the option +force+ is used, the callable object is not called and the error is raised
+    # immediately.
+    def maybe_raise(msg, force: false)
+      if force || @on_correctable_error.call(msg, pos)
+        error = HexaPDF::MalformedPDFError.new(msg, pos: pos)
+        error.set_backtrace(caller(1))
+        raise error
+      end
+    end
+
   end
 
 end

data/lib/hexapdf/type/xref_stream.rb

@@ -135,6 +135,13 @@ module HexaPDF
         w1 = w[1]
         w2 = w[2]
 
+        needed_bytes = (w0 + w1 + w2) * index.each_slice(2).sum(&:last)
+
+        if needed_bytes > data.size
+          raise HexaPDF::MalformedPDFError, "Cross-reference stream is missing data " \
+            "(#{needed_bytes} bytes needed, got #{data.size})"
+        end
+
         index.each_slice(2) do |first_oid, number_of_entries|
           first_oid.upto(first_oid + number_of_entries - 1) do |oid|
             # Default for first field: type 1

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '0.14.3'
+  VERSION = '0.14.4'
 
 end

data/test/hexapdf/encryption/test_security_handler.rb

@@ -297,6 +297,13 @@ describe HexaPDF::Encryption::SecurityHandler do
       assert_equal(@encrypted, @handler.decrypt(@obj)[:Key])
     end
 
+    it "defers handling encryption to a Crypt filter is specified" do
+      data = HexaPDF::StreamData.new(proc { 'mydata' }, filter: :Crypt)
+      obj = @document.wrap({}, oid: 1, stream: data)
+      @handler.decrypt(obj)
+      assert_equal('mydata', obj.stream)
+    end
+
     it "doesn't decrypt XRef streams" do
       @obj[:Type] = :XRef
       assert_equal(@encrypted, @handler.decrypt(@obj)[:Key])
@@ -343,6 +350,14 @@ describe HexaPDF::Encryption::SecurityHandler do
       assert_equal('string', @handler.encrypt_stream(@stream).resume)
     end
 
+    it "defers encrypting to a Crypt filter if specified" do
+      @stream.set_filter(:Crypt)
+      assert_equal('string', @handler.encrypt_stream(@stream).resume)
+
+      @stream.set_filter([:Crypt])
+      assert_equal('string', @handler.encrypt_stream(@stream).resume)
+    end
+
     it "doesn't encrypt the /Contents key of signature dictionaries" do
       @obj[:Type] = :Sig
       @obj[:Contents] = "test"

data/test/hexapdf/filter/test_crypt.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/filter/crypt'
+
+describe HexaPDF::Filter::Crypt do
+  before do
+    @obj = HexaPDF::Filter::Crypt
+    @source = Fiber.new { "hallo" }
+  end
+
+  it "works with the Identity filter" do
+    assert_equal(@source, @obj.decoder(@source, nil))
+    assert_equal(@source, @obj.encoder(@source, {})) # sic: 'encoder'
+    assert_equal(@source, @obj.decoder(@source, {Name: :Identity}))
+  end
+
+  it "fails if crypt filter name is not Identity" do
+    assert_raises(HexaPDF::FilterError) { @obj.decoder(@source, {Name: :Other}) }
+  end
+end

data/test/hexapdf/font/type1/test_afm_parser.rb

@@ -39,6 +39,11 @@ describe HexaPDF::Font::Type1::AFMParser do
     end
   end
 
+  it "parses until EOF if no end token is found" do
+    io = StringIO.new("StartFontMetrics 4.1\nFontName Test")
+    assert_equal('Test', HexaPDF::Font::Type1::AFMParser.parse(io).font_name)
+  end
+
   it "extracts kerning and ligature information" do
     metrics = FONT_TIMES.metrics
     glyph = metrics.character_metrics[:f]

data/test/hexapdf/test_parser.rb

@@ -531,11 +531,25 @@ describe HexaPDF::Parser do
       assert_equal(6, @parser.load_object(@xref).value)
     end
 
+    it "uses a security handler for decrypting indirect objects if necessary" do
+      handler = Minitest::Mock.new
+      handler.expect(:decrypt, HexaPDF::Object.new(:result, oid: 1), [HexaPDF::Object])
+      @document.instance_variable_set(:@security_handler, handler)
+      create_parser("1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
+      assert_equal(:result, @parser.load_object(@xref).value)
+      assert(handler.verify)
+    end
+
     it "ignores parts where the starting line is split across lines" do
       create_parser("1 0 obj\n5\nendobj\n1 0\nobj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(5, @parser.load_object(@xref).value)
     end
 
+    it "handles the case when the specified object had an xref entry but is not found" do
+      create_parser("3 0 obj\n5\nendobj\ntrailer\n<</Size 1>>")
+      assert(@parser.load_object(@xref).null?)
+    end
+
     it "handles cases where the line contains an invalid string that exceeds the read buffer" do
       create_parser("(1" << "(abc" * 32188 << "\n1 0 obj\n6\nendobj\ntrailer\n<</Size 1>>")
       assert_equal(6, @parser.load_object(@xref).value)
@@ -568,6 +582,16 @@ describe HexaPDF::Parser do
       assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
     end
 
+    it "tries the trailer specified at the startxref position if no other is found" do
+      create_parser("1 0 obj\n5\nendobj\nquack xref trailer <</Size 1/Prev 5>>\nstartxref\n22\n%%EOF")
+      assert_equal({Size: 1}, @parser.reconstructed_revision.trailer.value)
+    end
+
+    it "fails if no trailer is found and the trailer specified at the startxref position is not valid" do
+      create_parser("1 0 obj\n5\nendobj\nquack trailer <</Size 1>>\nstartxref\n22\n%%EOF")
+      assert_raises(HexaPDF::MalformedPDFError) { @parser.reconstructed_revision.trailer }
+    end
+
     it "fails if no valid trailer is found" do
       create_parser("1 0 obj\n5\nendobj")
       assert_raises(HexaPDF::MalformedPDFError) { @parser.load_object(@xref) }

data/test/hexapdf/test_serializer.rb

@@ -58,6 +58,9 @@ describe HexaPDF::Serializer do
     assert_serialized("0.000005", 0.000005)
     assert_serialized("-0.000005", -0.000005)
     assert_serialized("0.0", 0.0)
+    assert_raises(HexaPDF::Error) { @serializer.serialize(0.0 / 0) }
+    assert_raises(HexaPDF::Error) { @serializer.serialize(1.0 / 0) }
+    assert_raises(HexaPDF::Error) { @serializer.serialize(-1.0 / 0) }
   end
 
   it "serializes numerics" do

data/test/hexapdf/test_tokenizer.rb

@@ -55,4 +55,26 @@ describe HexaPDF::Tokenizer do
     assert_equal(HexaPDF::Tokenizer::NO_MORE_TOKENS, @tokenizer.next_integer_or_keyword)
   end
 
+  describe "can correct some problems" do
+    describe "invalid inf/-inf/nan/-nan tokens" do
+      it "turns them into zeros" do
+        count = 0
+        on_correctable_error = lambda do |msg, pos|
+          count += 1
+          assert_match(/Invalid object, got token/, msg)
+          assert_equal(8, pos) if count == 2
+          false
+        end
+        tokenizer = HexaPDF::Tokenizer.new(StringIO.new("inf -Inf NaN -nan"),
+                                           on_correctable_error: on_correctable_error)
+        assert_equal([0, 0, 0, 0], 4.times.map { tokenizer.next_object })
+        assert_equal(4, count)
+      end
+
+      it "raises an error if configured so" do
+        tokenizer = HexaPDF::Tokenizer.new(StringIO.new("inf"), on_correctable_error: proc { true })
+        assert_raises(HexaPDF::MalformedPDFError) { tokenizer.next_object }
+      end
+    end
+  end
 end

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.14.3)>>
+      <</Producer(HexaPDF version 0.14.4)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.14.3)>>
+      <</Producer(HexaPDF version 0.14.4)>>
       endobj
       2 0 obj
       <</Length 10>>stream

data/test/hexapdf/type/test_xref_stream.rb

@@ -71,6 +71,13 @@ describe HexaPDF::Type::XRefStream do
       assert(section[10, 0].in_use?)
       assert_equal(250, section[10, 0].pos)
     end
+
+    it "fails if there is not enough data available" do
+      @obj[:Index] = [1, 2, 10, 4]
+      @obj[:W] = [1, 2, 1]
+      @obj.stream = "abcd"
+      assert_raises(HexaPDF::MalformedPDFError) { @obj.xref_section }
+    end
   end
 
   describe "trailer" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.14.3
+  version: 0.14.4
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-16 00:00:00.000000000 Z
+date: 2021-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -267,6 +267,7 @@ files:
 - lib/hexapdf/filter.rb
 - lib/hexapdf/filter/ascii85_decode.rb
 - lib/hexapdf/filter/ascii_hex_decode.rb
+- lib/hexapdf/filter/crypt.rb
 - lib/hexapdf/filter/encryption.rb
 - lib/hexapdf/filter/flate_decode.rb
 - lib/hexapdf/filter/lzw_decode.rb
@@ -507,6 +508,7 @@ files:
 - test/hexapdf/filter/common.rb
 - test/hexapdf/filter/test_ascii85_decode.rb
 - test/hexapdf/filter/test_ascii_hex_decode.rb
+- test/hexapdf/filter/test_crypt.rb
 - test/hexapdf/filter/test_encryption.rb
 - test/hexapdf/filter/test_flate_decode.rb
 - test/hexapdf/filter/test_lzw_decode.rb