hexapdf 0.15.2 → 0.15.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a6ef1bdd17664ef0b9474b931d31ad69c57c77928ce2b69a3bbd5dadda0dce6
-  data.tar.gz: 11b87436d19cc5498fd6a77f0b6c410e717809264153964668be0f5199b9354d
+  metadata.gz: bcffb10babdbf723a478ea40721d9515222adf8d12ba9bd799f7b95fa66bc408
+  data.tar.gz: d5929900ab1b010a39964edc366ea223ef8a2ee9bcd1e9a5873874b4d5a8ecc5
 SHA512:
-  metadata.gz: 525a55832758b5eecd1a7f2daf5f220e1afa7ff8e88ca2d65998e658585f290ff2018450e50423f2331b7f195865eab8b1c62562ecdbf3671b46d4da770aed12
-  data.tar.gz: 0b0e18c7f79f0e2a54080fefad1dd4d94e15157f72e5360a3ebd827fc0cc2037ae6e06302155426e7f0900e97ee0cee678e069bd8ef05a9333d684c50e1343a5
+  metadata.gz: d12bbd49204c28675d399477ce0249140bf6ead3fe9332541128802f0edc3ebb2b187752b464b9acd3b71ca4ce6cb5cba33caf19282bd5a15020cec3c6e20297
+  data.tar.gz: 8df3586c8069db615bf317f22b28069f4bfd1395d31c285bb5c4a63b1b46ec60b088082a5d461adafd590718df6307734361e1e61fe3210009d158fc95c558be

data/CHANGELOG.md

@@ -1,3 +1,39 @@
+## 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
+
+* Handling of general (not document-level), unencrypted metadata streams
+
+
 ## 0.15.2 - 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/encryption/standard_security_handler.rb

@@ -241,7 +241,7 @@ module HexaPDF
       end
 
       def decrypt(obj) #:nodoc:
-        if obj.type == :Metadata && obj == document.catalog.value[:Metadata] && !dict[:EncryptMetadata]
+        if dict[:V] >= 4 && obj.type == :Metadata && obj[:Subtype] == :XML && !dict[:EncryptMetadata]
           obj
         else
           super
@@ -249,7 +249,11 @@ module HexaPDF
       end
 
       def encrypt_stream(obj) #:nodoc
-        obj == document.catalog.value[:Metadata] && !dict[:EncryptMetadata] ? obj.stream_encoder : super
+        if dict[:V] >= 4 && obj.type == :Metadata && obj[:Subtype] == :XML && !dict[:EncryptMetadata]
+          obj.stream_encoder
+        else
+          super
+        end
       end
 
       private

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

data/lib/hexapdf/tokenizer.rb

@@ -225,13 +225,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

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.2'
+  VERSION = '0.15.6'
 
 end

data/test/hexapdf/common_tokenizer_tests.rb

@@ -210,8 +210,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/encryption/test_standard_security_handler.rb

@@ -296,11 +296,11 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
   describe "handling of metadata streams" do
     before do
       @doc = HexaPDF::Document.new
-      @doc.encrypt(encrypt_metadata: false)
       @output = StringIO.new(''.b)
     end
 
-    it "doesn't decrypt or encrypt the document level metadata stream if /EncryptMetadata is false" do
+    it "doesn't decrypt or encrypt a metadata stream if /EncryptMetadata is false" do
+      @doc.encrypt(encrypt_metadata: false)
       @doc.catalog[:Metadata] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
       @doc.write(@output)
       assert_match(/stream\nHELLODATA\nendstream/, @output.string)
@@ -309,13 +309,14 @@ describe HexaPDF::Encryption::StandardSecurityHandler do
       assert_equal('HELLODATA', doc.catalog[:Metadata].stream)
     end
 
-    it "doesn't modify decryption/encryption for arbitrary metadata streams" do
-      @doc.catalog[:Anything] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
+    it "doesn't modify decryption/encryption for metadata streams if /V is not 4 or 5" do
+      @doc.encrypt(encrypt_metadata: false, algorithm: :arc4)
+      @doc.catalog[:Metadata] = @doc.wrap({Type: :Metadata, Subtype: :XML}, stream: "HELLODATA")
       @doc.write(@output)
       refute_match(/stream\nHELLODATA\nendstream/, @output.string)
 
       doc = HexaPDF::Document.new(io: @output)
-      assert_equal('HELLODATA', doc.catalog[:Anything].stream)
+      assert_equal('HELLODATA', doc.catalog[:Metadata].stream)
     end
   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

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.15.2)>>
+      <</Producer(HexaPDF version 0.15.6)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.15.2)>>
+      <</Producer(HexaPDF version 0.15.6)>>
       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.2
+  version: 0.15.6
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-01 00:00:00.000000000 Z
+date: 2021-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse