pdf-reader 2.8.0 → 2.9.0

data/lib/pdf/reader/font_descriptor.rb

@@ -15,22 +15,23 @@ class PDF::Reader
                 :x_height, :font_flags
 
     def initialize(ohash, fd_hash)
-      @ascent                = ohash.object(fd_hash[:Ascent])    || 0
-      @descent               = ohash.object(fd_hash[:Descent])   || 0
-      @missing_width         = ohash.object(fd_hash[:MissingWidth]) || 0
-      @font_bounding_box     = ohash.object(fd_hash[:FontBBox])  || [0,0,0,0]
-      @avg_width             = ohash.object(fd_hash[:AvgWidth])  || 0
-      @cap_height            = ohash.object(fd_hash[:CapHeight]) || 0
-      @font_flags            = ohash.object(fd_hash[:Flags])     || 0
-      @italic_angle          = ohash.object(fd_hash[:ItalicAngle])
-      @font_name             = ohash.object(fd_hash[:FontName]).to_s
-      @leading               = ohash.object(fd_hash[:Leading])   || 0
-      @max_width             = ohash.object(fd_hash[:MaxWidth])  || 0
-      @stem_v                = ohash.object(fd_hash[:StemV])
-      @x_height              = ohash.object(fd_hash[:XHeight])
-      @font_stretch          = ohash.object(fd_hash[:FontStretch]) || :Normal
-      @font_weight           = ohash.object(fd_hash[:FontWeight])  || 400
-      @font_family           = ohash.object(fd_hash[:FontFamily])
+      # TODO change these to typed derefs
+      @ascent                = ohash.deref_number(fd_hash[:Ascent])    || 0
+      @descent               = ohash.deref_number(fd_hash[:Descent])   || 0
+      @missing_width         = ohash.deref_number(fd_hash[:MissingWidth]) || 0
+      @font_bounding_box     = ohash.deref_array_of_numbers(fd_hash[:FontBBox])  || [0,0,0,0]
+      @avg_width             = ohash.deref_number(fd_hash[:AvgWidth])  || 0
+      @cap_height            = ohash.deref_number(fd_hash[:CapHeight]) || 0
+      @font_flags            = ohash.deref_integer(fd_hash[:Flags])     || 0
+      @italic_angle          = ohash.deref_number(fd_hash[:ItalicAngle])
+      @font_name             = ohash.deref_name(fd_hash[:FontName]).to_s
+      @leading               = ohash.deref_number(fd_hash[:Leading])   || 0
+      @max_width             = ohash.deref_number(fd_hash[:MaxWidth])  || 0
+      @stem_v                = ohash.deref_number(fd_hash[:StemV])
+      @x_height              = ohash.deref_number(fd_hash[:XHeight])
+      @font_stretch          = ohash.deref_name(fd_hash[:FontStretch]) || :Normal
+      @font_weight           = ohash.deref_number(fd_hash[:FontWeight])  || 400
+      @font_family           = ohash.deref_string(fd_hash[:FontFamily])
 
       # A FontDescriptor may have an embedded font program in FontFile
       # (Type 1 Font Program), FontFile2 (TrueType font program), or
@@ -40,7 +41,7 @@ class PDF::Reader
       # 2) CIDFontType0C: Type 0 Font Program in Compact Font Format
       # 3) OpenType:      OpenType Font Program
       # see Section 9.9, PDF 32000-1:2008, pp 288-292
-      @font_program_stream = ohash.object(fd_hash[:FontFile2])
+      @font_program_stream = ohash.deref_stream(fd_hash[:FontFile2])
       #TODO handle FontFile and FontFile3
 
       @is_ttf = true if @font_program_stream

data/lib/pdf/reader/form_xobject.rb

@@ -15,15 +15,24 @@ module PDF
     # This behaves and looks much like a limited PDF::Reader::Page class.
     #
     class FormXObject
-      include ResourceMethods
+      extend Forwardable
 
       attr_reader :xobject
 
+      def_delegators :resources, :color_spaces
+      def_delegators :resources, :fonts
+      def_delegators :resources, :graphic_states
+      def_delegators :resources, :patterns
+      def_delegators :resources, :procedure_sets
+      def_delegators :resources, :properties
+      def_delegators :resources, :shadings
+      def_delegators :resources, :xobjects
+
       def initialize(page, xobject, options = {})
         @page    = page
         @objects = page.objects
         @cache   = options[:cache] || {}
-        @xobject = @objects.deref(xobject)
+        @xobject = @objects.deref_stream(xobject)
       end
 
       # return a hash of fonts used on this form.
@@ -34,9 +43,9 @@ module PDF
       # to most available metrics for each font.
       #
       def font_objects
-        raw_fonts = @objects.deref(resources[:Font] || {})
+        raw_fonts = @objects.deref_hash(fonts)
         ::Hash[raw_fonts.map { |label, font|
-          [label, PDF::Reader::Font.new(@objects, @objects.deref(font))]
+          [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font))]
         }]
       end
 
@@ -61,7 +70,7 @@ module PDF
       # Returns the resources that accompany this form.
       #
       def resources
-        @resources ||= @objects.deref(@xobject.hash[:Resources]) || {}
+        @resources ||= Resources.new(@objects, @objects.deref_hash(@xobject.hash[:Resources]) || {})
       end
 
       def callback(receivers, name, params=[])

data/lib/pdf/reader/key_builder_v5.rb

@@ -0,0 +1,138 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+require 'digest/md5'
+require 'rc4'
+
+class PDF::Reader
+
+  # Processes the Encrypt dict from an encrypted PDF and a user provided
+  # password and returns a key that can decrypt the file.
+  #
+  # This can generate a decryption key compatible with the following standard encryption algorithms:
+  #
+  # * Version 5 (AESV3)
+  #
+  class KeyBuilderV5
+
+    def initialize(opts = {})
+      @key_length   = 256
+
+      # hash(32B) + validation salt(8B) + key salt(8B)
+      @owner_key    = opts[:owner_key] || ""
+
+      # hash(32B) + validation salt(8B) + key salt(8B)
+      @user_key     = opts[:user_key] || ""
+
+      # decryption key, encrypted w/ owner password
+      @owner_encryption_key = opts[:owner_encryption_key] || ""
+
+      # decryption key, encrypted w/ user password
+      @user_encryption_key  = opts[:user_encryption_key] || ""
+    end
+
+    # Takes a string containing a user provided password.
+    #
+    # If the password matches the file, then a string containing a key suitable for
+    # decrypting the file will be returned. If the password doesn't match the file,
+    # and exception will be raised.
+    #
+    def key(pass)
+      pass = pass.byteslice(0...127).to_s   # UTF-8 encoded password. first 127 bytes
+
+      encrypt_key   = auth_owner_pass(pass)
+      encrypt_key ||= auth_user_pass(pass)
+      encrypt_key ||= auth_owner_pass_r6(pass)
+      encrypt_key ||= auth_user_pass_r6(pass)
+
+      raise PDF::Reader::EncryptedPDFError, "Invalid password (#{pass})" if encrypt_key.nil?
+      encrypt_key
+    end
+
+    private
+
+    # Algorithm 3.2a - Computing an encryption key
+    #
+    # Defined in PDF 1.7 Extension Level 3
+    #
+    # if the string is a valid user/owner password, this will return the decryption key
+    #
+    def auth_owner_pass(password)
+      if Digest::SHA256.digest(password + @owner_key[32..39] + @user_key) == @owner_key[0..31]
+        cipher = OpenSSL::Cipher.new('AES-256-CBC')
+        cipher.decrypt
+        cipher.key = Digest::SHA256.digest(password + @owner_key[40..-1] + @user_key)
+        cipher.iv = "\x00" * 16
+        cipher.padding = 0
+        cipher.update(@owner_encryption_key) + cipher.final
+      end
+    end
+
+    def auth_user_pass(password)
+      if Digest::SHA256.digest(password + @user_key[32..39]) == @user_key[0..31]
+        cipher = OpenSSL::Cipher.new('AES-256-CBC')
+        cipher.decrypt
+        cipher.key = Digest::SHA256.digest(password + @user_key[40..-1])
+        cipher.iv = "\x00" * 16
+        cipher.padding = 0
+        cipher.update(@user_encryption_key) + cipher.final
+      end
+    end
+
+    def auth_owner_pass_r6(password)
+      if r6_digest(password, @owner_key[32..39].to_s, @user_key[0,48].to_s) == @owner_key[0..31]
+        cipher = OpenSSL::Cipher.new('AES-256-CBC')
+        cipher.decrypt
+        cipher.key = r6_digest(password, @owner_key[40,8].to_s, @user_key[0, 48].to_s)
+        cipher.iv = "\x00" * 16
+        cipher.padding = 0
+        cipher.update(@owner_encryption_key) + cipher.final
+      end
+    end
+
+    def auth_user_pass_r6(password)
+      if r6_digest(password, @user_key[32..39].to_s) == @user_key[0..31]
+        cipher = OpenSSL::Cipher.new('AES-256-CBC')
+        cipher.decrypt
+        cipher.key = r6_digest(password, @user_key[40,8].to_s)
+        cipher.iv = "\x00" * 16
+        cipher.padding = 0
+        cipher.update(@user_encryption_key) + cipher.final
+      end
+    end
+
+    # PDF 2.0 spec, 7.6.4.3.4
+    # Algorithm 2.B: Computing a hash (revision 6 and later)
+    def r6_digest(password, salt, user_key = '')
+      k = Digest::SHA256.digest(password + salt + user_key)
+      e = ''
+
+      i = 0
+      while i < 64 or e.getbyte(-1).to_i > i - 32
+        k1 = (password + k + user_key) * 64
+
+        aes = OpenSSL::Cipher.new("aes-128-cbc").encrypt
+        aes.key = k[0, 16].to_s
+        aes.iv = k[16, 16].to_s
+        aes.padding = 0
+        e = String.new(aes.update(k1))
+        k = case unpack_128bit_bigendian_int(e) % 3
+            when 0 then Digest::SHA256.digest(e)
+            when 1 then Digest::SHA384.digest(e)
+            when 2 then Digest::SHA512.digest(e)
+            end
+        i = i + 1
+      end
+
+      k[0, 32].to_s
+    end
+
+    def unpack_128bit_bigendian_int(str)
+      ints = str[0,16].to_s.unpack("N*")
+      (ints[0].to_i << 96) + (ints[1].to_i << 64) + (ints[2].to_i << 32) + ints[3].to_i
+    end
+
+  end
+end
+

data/lib/pdf/reader/null_security_handler.rb

@@ -7,10 +7,6 @@ class PDF::Reader
   # A null object security handler. Used when a PDF is unencrypted.
   class NullSecurityHandler
 
-    def self.supports?(encrypt)
-      encrypt.nil?
-    end
-
     def decrypt(buf, _ref)
       buf
     end

data/lib/pdf/reader/object_hash.rb

@@ -48,7 +48,11 @@ class PDF::Reader
       @trailer     = @xref.trailer
       @cache       = opts[:cache] || PDF::Reader::ObjectCache.new
       @sec_handler = NullSecurityHandler.new
-      @sec_handler = build_security_handler(opts)
+      @sec_handler = SecurityHandlerFactory.build(
+        deref(trailer[:Encrypt]),
+        deref(trailer[:ID]),
+        opts[:password]
+      )
     end
 
     # returns the type of object a ref points to
@@ -92,6 +96,218 @@ class PDF::Reader
     end
     alias :deref :object
 
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return an Array or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting an Array and no other type will do.
+    def deref_array(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        raise MalformedPDFError, "expected object to be an Array or nil" if !obj.is_a?(Array)
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return an Array of Numerics or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting an Array and no other type will do.
+    #
+    # Some effort to cast array elements to a number is made for any non-numeric elements.
+    def deref_array_of_numbers(key)
+      arr = deref(key)
+
+      return arr if arr.nil?
+
+      raise MalformedPDFError, "expected object to be an Array" unless arr.is_a?(Array)
+
+      arr.map { |item|
+        if item.is_a?(Numeric)
+          item
+        elsif item.respond_to?(:to_f)
+          item.to_f
+        elsif item.respond_to?(:to_i)
+          item.to_i
+        else
+          raise MalformedPDFError, "expected object to be a number"
+        end
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a Hash or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting an Array and no other type will do.
+    def deref_hash(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        raise MalformedPDFError, "expected object to be a Hash or nil" if !obj.is_a?(Hash)
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a PDF name (Symbol) or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting an Array and no other type will do.
+    #
+    # Some effort to cast to a symbol is made when the reference points to a non-symbol.
+    def deref_name(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      if !obj.is_a?(Symbol)
+        if obj.respond_to?(:to_sym)
+          obj = obj.to_sym
+        else
+          raise MalformedPDFError, "expected object to be a Name"
+        end
+      end
+
+      obj
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return an Integer or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting an Array and no other type will do.
+    #
+    # Some effort to cast to an int is made when the reference points to a non-integer.
+    def deref_integer(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      if !obj.is_a?(Integer)
+        if obj.respond_to?(:to_i)
+          obj = obj.to_i
+        else
+          raise MalformedPDFError, "expected object to be an Integer"
+        end
+      end
+
+      obj
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a Numeric or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting an Array and no other type will do.
+    #
+    # Some effort to cast to a number is made when the reference points to a non-number.
+    def deref_number(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      if !obj.is_a?(Numeric)
+        if obj.respond_to?(:to_f)
+          obj = obj.to_f
+        elsif obj.respond_to?(:to_i)
+          obj.to_i
+        else
+          raise MalformedPDFError, "expected object to be a number"
+        end
+      end
+
+      obj
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a PDF::Reader::Stream or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting a stream and no other type will do.
+    def deref_stream(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        if !obj.is_a?(PDF::Reader::Stream)
+          raise MalformedPDFError, "expected object to be an Array or nil"
+        end
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a String or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting a string and no other type will do.
+    #
+    # Some effort to cast to a string is made when the reference points to a non-string.
+    def deref_string(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      if !obj.is_a?(String)
+        if obj.respond_to?(:to_s)
+          obj = obj.to_s
+        else
+          raise MalformedPDFError, "expected object to be a string"
+        end
+      end
+
+      obj
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a PDF Name (symbol), Array or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting a Name or Array and no other type will do.
+    def deref_name_or_array(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        if !obj.is_a?(Symbol) && !obj.is_a?(Array)
+          raise MalformedPDFError, "expected object to be an Array or Name"
+        end
+      }
+    end
+
+    # If key is a PDF::Reader::Reference object, lookup the corresponding
+    # object in the PDF and return it. Otherwise return key untouched.
+    #
+    # Guaranteed to only return a PDF::Reader::Stream, Array or nil. If the dereference results in
+    # any other type then a MalformedPDFError exception will raise. Useful when
+    # expecting a stream or Array and no other type will do.
+    def deref_stream_or_array(key)
+      obj = deref(key)
+
+      return obj if obj.nil?
+
+      obj.tap { |obj|
+        if !obj.is_a?(PDF::Reader::Stream) && !obj.is_a?(Array)
+          raise MalformedPDFError, "expected object to be an Array or Stream"
+        end
+      }
+    end
+
     # Recursively dereferences the object refered to be +key+. If +key+ is not
     # a PDF::Reader::Reference, the key is returned unchanged.
     #
@@ -99,6 +315,22 @@ class PDF::Reader
       deref_internal!(key, {})
     end
 
+    def deref_array!(key)
+      deref!(key).tap { |obj|
+        if !obj.nil? && !obj.is_a?(Array)
+          raise MalformedPDFError, "expected object (#{obj.inspect}) to be an Array or nil"
+        end
+      }
+    end
+
+    def deref_hash!(key)
+      deref!(key).tap { |obj|
+        if !obj.nil? && !obj.is_a?(Hash)
+          raise MalformedPDFError, "expected object (#{obj.inspect}) to be a Hash or nil"
+        end
+      }
+    end
+
     # Access an object from the PDF. key can be an int or a PDF::Reader::Reference
     # object.
     #
@@ -233,7 +465,10 @@ class PDF::Reader
     #
     def page_references
       root  = fetch(trailer[:Root])
-      @page_references ||= get_page_objects(root[:Pages]).flatten
+      @page_references ||= begin
+                             pages_root = deref_hash(root[:Pages]) || {}
+                             get_page_objects(pages_root)
+                           end
     end
 
     def encrypted?
@@ -299,36 +534,6 @@ class PDF::Reader
       end
     end
 
-    def build_security_handler(opts = {})
-      encrypt = deref(trailer[:Encrypt])
-      if NullSecurityHandler.supports?(encrypt)
-        NullSecurityHandler.new
-      elsif StandardSecurityHandler.supports?(encrypt)
-        encmeta = !encrypt.has_key?(:EncryptMetadata) || encrypt[:EncryptMetadata].to_s == "true"
-        StandardSecurityHandler.new(
-          key_length: (encrypt[:Length] || 40).to_i,
-          revision: encrypt[:R],
-          owner_key: encrypt[:O],
-          user_key: encrypt[:U],
-          permissions: encrypt[:P].to_i,
-          encrypted_metadata: encmeta,
-          file_id: (deref(trailer[:ID]) || []).first,
-          password: opts[:password],
-          cfm: encrypt.fetch(:CF, {}).fetch(encrypt[:StmF], {}).fetch(:CFM, nil)
-        )
-      elsif StandardSecurityHandlerV5.supports?(encrypt)
-        StandardSecurityHandlerV5.new(
-            O: encrypt[:O],
-            U: encrypt[:U],
-            OE: encrypt[:OE],
-            UE: encrypt[:UE],
-            password: opts[:password]
-        )
-      else
-        UnimplementedSecurityHandler.new
-      end
-    end
-
     def decrypt(ref, obj)
       case obj
       when PDF::Reader::Stream then
@@ -362,19 +567,19 @@ class PDF::Reader
       @object_stream ||= {}
     end
 
-    # returns a nested array of object references for all pages in this object store.
+    # returns an array of object references for all pages in this object store. The ordering of
+    # the Array is significant and matches the page ordering of the document
     #
-    def get_page_objects(ref)
-      obj = deref(ref)
-
-      unless obj.kind_of?(::Hash)
-        raise MalformedPDFError, "Dereferenced page object must be a dict"
-      end
-
+    def get_page_objects(obj)
       if obj[:Type] == :Page
-        ref
+        [obj]
       elsif obj[:Kids]
-        deref(obj[:Kids]).map { |kid| get_page_objects(kid) }
+        kids = deref_array(obj[:Kids]) || []
+        kids.map { |kid|
+          get_page_objects(deref_hash(kid) || {})
+        }.flatten
+      else
+        raise MalformedPDFError, "Expected Page or Pages object"
       end
     end