hexapdf 0.15.3 → 0.15.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 592ea8ae7648df43e92ba50effdf3f8f34163e4acf7fb9567c3b38db46eb598e
-  data.tar.gz: 6c3b7d32a1499f2e2133fbafdf46b9d3cd4d1df41b9ae308c0c32ea39aefff2d
+  metadata.gz: 1385aca5e91916034a5494142b4c88e51de46d2d13b79ddaed9494c74808793a
+  data.tar.gz: 4fee33d3c96e74c00565ac6211901f39c0242cd2e0926f0760be7bfb18fe7f12
 SHA512:
-  metadata.gz: fdf9edf53c0443d459008634ddbff7cd80fc1422fa558df41db04af0d9eeb512ea050d5b4a10987b824c675203e39bc851d1b2a68d0178f2cd12fada66b31245
-  data.tar.gz: 8e6a7b91da0ed2b63f7bc6d52c3993553f439edf986253b3508d0510310195c2a6f3721c2cfed735afc3d60dacacedc8207a6fac361bedc354bc6bd779207eac
+  metadata.gz: 3fa1454ec6821500c1f94981ad17efcbf36f125a29870a62ad0d626fe65cd35bb7ef6426021daba3b2554dcbd20f1ce6efc4d93c1d4d8b5303d6063eb27804fb
+  data.tar.gz: 8f2c3de849fed113c6f4fe7494312a202a872f7364052b584a38352315a4a358f135beea8dd951c29d2dbd3b842c4eefe3892ed3d9bb3c24e6875cdbb0c59123

data/CHANGELOG.md

@@ -1,3 +1,40 @@
+## 0.15.7 - 2021-07-17
+
+### Fixed
+
+* Infinite loop while parsing PDF array due to missing closing bracket
+* Handling of invalid files with missing or corrupted trailer dictionary
+
+
+## 0.15.6 - 2021-07-16
+
+### Fixed
+
+* Handling of indirect objects with invalid values which are now treated as null
+  objects
+
+
+## 0.15.5 - 2021-07-06
+
+### Changed
+
+* Refactored [HexaPDF::Tokenizer#next_xref_entry] and changed yielded value
+
+
+### Fixed
+
+* Handling of invalid cross-reference stream entries that ends with the sequence
+  `\r\r`
+
+
+## 0.15.4 - 2021-05-27
+
+### Fixed
+
+* [HexaPDF::Type::Annotation#appearance] to handle cases where there is
+  no valid appearance stream
+
+
 ## 0.15.3 - 2021-05-01
 
 ### Fixed

data/lib/hexapdf/cli/command.rb

@@ -50,7 +50,7 @@ module HexaPDF
       module Extensions #:nodoc:
         def help_banner #:nodoc:
           "hexapdf #{HexaPDF::VERSION} - Versatile PDF Manipulation Tool\n" \
-            "Copyright (c) 2014-2017 Thomas Leitner; licensed under the AGPLv3\n\n" \
+            "Copyright (c) 2014-2021 Thomas Leitner; licensed under the AGPLv3\n\n" \
             "#{format(usage, indent: 7)}\n\n"
         end
       end

data/lib/hexapdf/parser.rb

@@ -125,11 +125,14 @@ module HexaPDF
         begin
           object = @tokenizer.next_object
         rescue MalformedPDFError
-          # Handle often found invalid indirect object with missing whitespace after number
-          maybe_raise("Invalid object value after 'obj'", pos: @tokenizer.pos,
-                      force: !(tok.kind_of?(Tokenizer::Token) && tok =~ /\A\d+endobj\z/))
-          object = tok.to_i
-          @tokenizer.pos -= 6
+          if tok.kind_of?(Tokenizer::Token) && tok =~ /\A\d+endobj\z/
+            # Handle often found invalid indirect object with missing whitespace after number
+            maybe_raise("Missing whitespace after number'", pos: @tokenizer.pos)
+            object = tok.to_i
+            @tokenizer.pos -= 6
+          else
+            maybe_raise("Invalid value after '#{oid} #{gen} obj', treating as null", pos: @tokenizer.pos)
+          end
         end
       end
 
@@ -263,9 +266,9 @@ module HexaPDF
 
         @tokenizer.skip_whitespace
         start.upto(start + number_of_entries - 1) do |oid|
-          pos, gen, type = @tokenizer.next_xref_entry do |matched_size|
+          pos, gen, type = @tokenizer.next_xref_entry do |recoverable|
             maybe_raise("Invalid cross-reference entry", pos: @tokenizer.pos,
-                        force: !matched_size)
+                        force: !recoverable)
           end
           if xref.entry?(oid)
             next
@@ -444,6 +447,15 @@ module HexaPDF
 
       if !trailer || trailer.empty?
         _, trailer = load_revision(startxref_offset) rescue nil
+        unless trailer
+          xref.each do |_oid, _gen, xref_entry|
+            obj, * = parse_indirect_object(xref_entry.pos) rescue nil
+            if obj.kind_of?(Hash) && obj[:Type] == :Catalog
+              trailer = {Root: HexaPDF::Reference.new(xref_entry.oid, xref_entry.gen)}
+              break
+            end
+          end
+        end
         unless trailer
           @in_reconstruct_revision = false
           raise_malformed("Could not reconstruct malformed PDF because trailer was not found", pos: 0)

data/lib/hexapdf/tokenizer.rb

@@ -55,6 +55,9 @@ module HexaPDF
 
     # This object is returned when there are no more tokens to read.
     NO_MORE_TOKENS = ::Object.new
+    def NO_MORE_TOKENS.to_s
+      "EOS - no more tokens"
+    end
 
     # Characters defined as whitespace.
     #
@@ -225,13 +228,14 @@ module HexaPDF
     # Reads the cross-reference subsection entry at the current position and advances the scan
     # pointer.
     #
-    # If a possible problem is detected, yields to caller.
+    # If a problem is detected, yields to caller where the argument +recoverable+ is truthy if the
+    # problem is recoverable.
     #
     # See: PDF1.7 7.5.4
-    def next_xref_entry #:yield: matched_size
+    def next_xref_entry #:yield: recoverable
       prepare_string_scanner(20)
-      unless @ss.skip(/(\d{10}) (\d{5}) ([nf])(?: \r| \n|\r\n|\r|\n)/) && @ss.matched_size == 20
-        yield(@ss.matched_size)
+      if !@ss.skip(/(\d{10}) (\d{5}) ([nf])(?: \r| \n|\r\n|(\r\r|\r|\n))/) || @ss[4]
+        yield(@ss[4])
       end
       [@ss[1].to_i, @ss[2].to_i, @ss[3]]
     end
@@ -383,7 +387,11 @@ module HexaPDF
       result = []
       while true
         obj = next_object(allow_end_array_token: true)
-        break if obj.equal?(TOKEN_ARRAY_END)
+        if obj.equal?(TOKEN_ARRAY_END)
+          break
+        elsif obj.equal?(NO_MORE_TOKENS)
+          raise HexaPDF::MalformedPDFError.new("Unclosed array found", pos: pos)
+        end
         result << obj
       end
       result
@@ -402,7 +410,8 @@ module HexaPDF
         key = next_token
         break if key.equal?(TOKEN_DICT_END)
         unless key.kind_of?(Symbol)
-          raise HexaPDF::MalformedPDFError.new("Dictionary keys must be PDF name objects", pos: pos)
+          raise HexaPDF::MalformedPDFError.new("Dictionary keys must be PDF name objects, " \
+                                               "found '#{key}'", pos: pos)
         end
 
         val = next_object

data/lib/hexapdf/type/annotation.rb

@@ -138,8 +138,13 @@ module HexaPDF
         if entry.kind_of?(HexaPDF::Dictionary) && !entry.kind_of?(HexaPDF::Stream)
           entry = entry[self[:AS]]
         end
-        if entry.kind_of?(HexaPDF::Stream)
-          entry[:Subtype] == :Form ? entry : document.wrap(entry, type: :XObject, subtype: :Form)
+        return unless entry.kind_of?(HexaPDF::Stream)
+
+        if entry.type == :XObject && entry[:Subtype] == :Form
+          entry
+        elsif (entry[:Type].nil? || entry[:Type] == :XObject) &&
+            (entry[:Subtype].nil? || entry[:Subtype] == :Form) && entry[:BBox]
+          document.wrap(entry, type: :XObject, subtype: :Form)
         end
       end
       alias appearance? appearance

data/lib/hexapdf/version.rb

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

data/test/hexapdf/common_tokenizer_tests.rb

@@ -161,6 +161,21 @@ module CommonTokenizerTests
     assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
   end
 
+  it "next_object: fails for an array without closing bracket, encountering EOS" do
+    create_tokenizer("[1 2")
+    exception = assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    assert_match(/Unclosed array found/, exception.message)
+  end
+
+  it "next_object: fails for a dictionary without closing bracket, encountering EOS" do
+    create_tokenizer("<</Name 5")
+    exception = assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    assert_match(/must be PDF name objects.*EOS/, exception.message)
+    create_tokenizer("<</Name 5 /Other")
+    exception = assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    assert_match(/must be PDF name objects.*EOS/, exception.message)
+  end
+
   it "returns the correct position on operations" do
     create_tokenizer("hallo du" << " " * 50000 << "hallo du")
     @tokenizer.next_token
@@ -210,8 +225,12 @@ module CommonTokenizerTests
 
   it "next_xref_entry: fails on invalidly formatted entries" do
     create_tokenizer("0000000001 00001 g \n")
-    assert_raises(RuntimeError) { @tokenizer.next_xref_entry { raise } }
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry {|recoverable| refute(recoverable); raise } }
     create_tokenizer("0000000001 00001 n\n")
-    assert_raises(RuntimeError) { @tokenizer.next_xref_entry { raise } }
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry {|recoverable| assert(recoverable); raise } }
+    create_tokenizer("0000000001 00001 n\r")
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry {|recoverable| assert(recoverable); raise } }
+    create_tokenizer("0000000001 00001 n\r\r")
+    assert_raises(RuntimeError) { @tokenizer.next_xref_entry {|recoverable| assert(recoverable); raise } }
   end
 end

data/test/hexapdf/test_parser.rb

@@ -107,6 +107,12 @@ describe HexaPDF::Parser do
       assert_equal(749, object)
     end
 
+    it "treats indirect objects with invalid values as null objects" do
+      create_parser("1 0 obj <</test ( /other (end)>> endobj")
+      object, * =  @parser.parse_indirect_object
+      assert_nil(object)
+    end
+
     it "recovers from an invalid stream length value" do
       create_parser("1 0 obj<</Length 4>> stream\n12endstream endobj")
       obj, _, _, stream = @parser.parse_indirect_object
@@ -185,7 +191,13 @@ describe HexaPDF::Parser do
       it "fails for numbers followed by endobj without space" do
         create_parser("1 0 obj 749endobj")
         exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
-        assert_match(/Invalid object value after 'obj'/, exp.message)
+        assert_match(/Missing whitespace after number/, exp.message)
+      end
+
+      it "fails for invalid values" do
+        create_parser("1 0 obj <</test ( /other (end)>> endobj")
+        exp = assert_raises(HexaPDF::MalformedPDFError) { @parser.parse_indirect_object }
+        assert_match(/Invalid value after '1 0 obj'/, exp.message)
       end
 
       it "fails if the stream length value is invalid" do
@@ -607,7 +619,12 @@ describe HexaPDF::Parser do
       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
+    it "constructs a trailer with a /Root entry if no valid trailer was found" do
+      create_parser("1 0 obj\n<</Type /Catalog/Pages 2 0 R>>\nendobj\nxref trailer <</Size 1/Prev 5\n%%EOF")
+      assert_equal({Root: HexaPDF::Reference.new(1, 0)}, @parser.reconstructed_revision.trailer.value)
+    end
+
+    it "fails if no valid trailer is found and couldn't be constructed" 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

data/test/hexapdf/test_writer.rb

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

data/test/hexapdf/type/test_annotation.rb

@@ -51,14 +51,18 @@ describe HexaPDF::Type::Annotation do
 
     stream = @doc.wrap({}, stream: '')
     @annot[:AP][:N] = stream
+    assert_nil(@annot.appearance)
+
+    stream[:BBox] = [1, 2, 3, 4]
     appearance = @annot.appearance
     assert_same(stream.data, appearance.data)
     assert_equal(:Form, appearance[:Subtype])
 
-    @annot[:AP][:N] = {X: stream}
+    @annot[:AP][:N] = {X: {}}
     assert_nil(@annot.appearance)
 
     @annot[:AS] = :X
+    @annot[:AP][:N][:X] = stream
     assert_same(stream.data, @annot.appearance.data)
 
     @annot[:AP][:D] = {X: stream}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 0.15.3
+  version: 0.15.7
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-01 00:00:00.000000000 Z
+date: 2021-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse