pdf-reader 2.5.0 → 2.9.0

data/lib/pdf/reader/security_handler_factory.rb

@@ -0,0 +1,79 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+  # Examines the Encrypt entry of a PDF trailer (if any) and returns an object that's
+  # able to decrypt the file.
+  class SecurityHandlerFactory
+
+    def self.build(encrypt, doc_id, password)
+      doc_id   ||= []
+      password ||= ""
+
+      if encrypt.nil?
+        NullSecurityHandler.new
+      elsif standard?(encrypt)
+        build_standard_handler(encrypt, doc_id, password)
+      elsif standard_v5?(encrypt)
+        build_v5_handler(encrypt, doc_id, password)
+      else
+        UnimplementedSecurityHandler.new
+      end
+    end
+
+    def self.build_standard_handler(encrypt, doc_id, password)
+      encmeta = !encrypt.has_key?(:EncryptMetadata) || encrypt[:EncryptMetadata].to_s == "true"
+      key_builder = StandardKeyBuilder.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: doc_id.first,
+      )
+      cfm = encrypt.fetch(:CF, {}).fetch(encrypt[:StmF], {}).fetch(:CFM, nil)
+      if cfm == :AESV2
+        AesV2SecurityHandler.new(key_builder.key(password))
+      else
+        Rc4SecurityHandler.new(key_builder.key(password))
+      end
+    end
+
+    def self.build_v5_handler(encrypt, doc_id, password)
+      key_builder = KeyBuilderV5.new(
+        owner_key: encrypt[:O],
+        user_key: encrypt[:U],
+        owner_encryption_key: encrypt[:OE],
+        user_encryption_key: encrypt[:UE],
+      )
+      AesV3SecurityHandler.new(key_builder.key(password))
+    end
+
+    # This handler supports all encryption that follows upto PDF 1.5 spec (revision 4)
+    def self.standard?(encrypt)
+      return false if encrypt.nil?
+
+      filter = encrypt.fetch(:Filter, :Standard)
+      version = encrypt.fetch(:V, 0)
+      algorithm = encrypt.fetch(:CF, {}).fetch(encrypt[:StmF], {}).fetch(:CFM, nil)
+      (filter == :Standard) && (encrypt[:StmF] == encrypt[:StrF]) &&
+        (version <= 3 || (version == 4 && ((algorithm == :V2) || (algorithm == :AESV2))))
+    end
+
+    # This handler supports both
+    # - AES-256 encryption defined in PDF 1.7 Extension Level 3 ('revision 5')
+    # - AES-256 encryption defined in PDF 2.0 ('revision 6')
+    def self.standard_v5?(encrypt)
+      return false if encrypt.nil?
+
+      filter = encrypt.fetch(:Filter, :Standard)
+      version = encrypt.fetch(:V, 0)
+      revision = encrypt.fetch(:R, 0)
+      algorithm = encrypt.fetch(:CF, {}).fetch(encrypt[:StmF], {}).fetch(:CFM, nil)
+      (filter == :Standard) && (encrypt[:StmF] == encrypt[:StrF]) &&
+          ((version == 5) && (revision == 5 || revision == 6) && (algorithm == :AESV3))
+    end
+  end
+end

data/lib/pdf/reader/{standard_security_handler.rb → standard_key_builder.rb}

@@ -1,38 +1,19 @@
 # coding: utf-8
-# frozen_string_literal: true
 
-################################################################################
-#
-# Copyright (C) 2011 Evan J Brunner (ejbrun@appittome.com)
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-################################################################################
 require 'digest/md5'
-require 'openssl'
 require 'rc4'
 
 class PDF::Reader
 
-  # class creates interface to encrypt dictionary for use in Decrypt
-  class StandardSecurityHandler
+  # 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 key compatible with the following standard encryption algorithms:
+  #
+  # * Version 1-3, all variants
+  # * Version 4, V2 (RC4) and AESV2
+  #
+  class StandardKeyBuilder
 
     ## 7.6.3.3 Encryption Key Algorithm (pp61)
     #
@@ -44,9 +25,6 @@ class PDF::Reader
                      0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
                      0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a ]
 
-    attr_reader :key_length, :revision, :encrypt_key
-    attr_reader :owner_key, :user_key, :permissions, :file_id, :password
-
     def initialize(opts = {})
       @key_length    = opts[:key_length].to_i/8
       @revision      = opts[:revision].to_i
@@ -55,72 +33,30 @@ class PDF::Reader
       @permissions   = opts[:permissions].to_i
       @encryptMeta   = opts.fetch(:encrypted_metadata, true)
       @file_id       = opts[:file_id] || ""
-      @encrypt_key   = build_standard_key(opts[:password] || "")
-      @cfm           = opts[:cfm]
 
       if @key_length != 5 && @key_length != 16
-        msg = "StandardSecurityHandler only supports 40 and 128 bit\
+        msg = "StandardKeyBuilder only supports 40 and 128 bit\
                encryption (#{@key_length * 8}bit)"
-        raise ArgumentError, msg
+        raise UnsupportedFeatureError, msg
       end
     end
 
-    # This handler supports all encryption that follows upto PDF 1.5 spec (revision 4)
-    def self.supports?(encrypt)
-      return false if encrypt.nil?
-
-      filter = encrypt.fetch(:Filter, :Standard)
-      version = encrypt.fetch(:V, 0)
-      algorithm = encrypt.fetch(:CF, {}).fetch(encrypt[:StmF], {}).fetch(:CFM, nil)
-      (filter == :Standard) && (encrypt[:StmF] == encrypt[:StrF]) &&
-        (version <= 3 || (version == 4 && ((algorithm == :V2) || (algorithm == :AESV2))))
-    end
-
-    ##7.6.2 General Encryption Algorithm
-    #
-    # Algorithm 1: Encryption of data using the RC4 or AES algorithms
-    #
-    # used to decrypt RC4/AES encrypted PDF streams (buf)
+    # Takes a string containing a user provided password.
     #
-    # buf - a string to decrypt
-    # ref - a PDF::Reader::Reference for the object to decrypt
+    # 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 decrypt( buf, ref )
-      case @cfm
-        when :AESV2
-          decrypt_aes128(buf, ref)
-        else
-          decrypt_rc4(buf, ref)
-      end
-    end
-
-    private
+    def key(pass)
+      pass ||= ""
+      encrypt_key   = auth_owner_pass(pass)
+      encrypt_key ||= auth_user_pass(pass)
 
-    # decrypt with RC4 algorithm
-    # version <=3 or (version == 4 and CFM == V2)
-    def decrypt_rc4( buf, ref )
-      objKey = @encrypt_key.dup
-      (0..2).each { |e| objKey << (ref.id >> e*8 & 0xFF ) }
-      (0..1).each { |e| objKey << (ref.gen >> e*8 & 0xFF ) }
-      length = objKey.length < 16 ? objKey.length : 16
-      rc4 = RC4.new( Digest::MD5.digest(objKey)[0,length] )
-      rc4.decrypt(buf)
+      raise PDF::Reader::EncryptedPDFError, "Invalid password (#{pass})" if encrypt_key.nil?
+      encrypt_key
     end
 
-    # decrypt with AES-128-CBC algorithm
-    # when (version == 4 and CFM == AESV2)
-    def decrypt_aes128( buf, ref )
-      objKey = @encrypt_key.dup
-      (0..2).each { |e| objKey << (ref.id >> e*8 & 0xFF ) }
-      (0..1).each { |e| objKey << (ref.gen >> e*8 & 0xFF ) }
-      objKey << 'sAlT'  # Algorithm 1, b)
-      length = objKey.length < 16 ? objKey.length : 16
-      cipher = OpenSSL::Cipher.new("AES-#{length << 3}-CBC")
-      cipher.decrypt
-      cipher.key = Digest::MD5.digest(objKey)[0,length]
-      cipher.iv = buf[0..15]
-      cipher.update(buf[16..-1]) + cipher.final
-    end
+    private
 
     # Pads supplied password to 32bytes using PassPadBytes as specified on
     # pp61 of spec
@@ -152,7 +88,7 @@ class PDF::Reader
       md5 = Digest::MD5.digest(pad_pass(pass))
       if @revision > 2 then
         50.times { md5 = Digest::MD5.digest(md5) }
-        keyBegins = md5[0, key_length]
+        keyBegins = md5[0, @key_length]
         #first iteration decrypt owner_key
         out = @owner_key
         #RC4 keyed with (keyBegins XOR with iteration #) to decrypt previous out
@@ -217,12 +153,5 @@ class PDF::Reader
       end
     end
 
-    def build_standard_key(pass)
-      encrypt_key   = auth_owner_pass(pass)
-      encrypt_key ||= auth_user_pass(pass)
-
-      raise PDF::Reader::EncryptedPDFError, "Invalid password (#{pass})" if encrypt_key.nil?
-      encrypt_key
-    end
   end
 end

data/lib/pdf/reader/stream.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################
@@ -61,7 +62,7 @@ class PDF::Reader
         end
 
         Array(hash[:Filter]).each_with_index do |filter, index|
-          @udata = Filter.with(filter, options[index]).filter(@udata)
+          @udata = Filter.with(filter, options[index] || {}).filter(@udata)
         end
       end
       @udata

data/lib/pdf/reader/synchronized_cache.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 # utilities.rb : General-purpose utility classes which don't fit anywhere else

data/lib/pdf/reader/text_run.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -6,15 +7,14 @@ class PDF::Reader
   class TextRun
     include Comparable
 
-    attr_reader :x, :y, :width, :font_size, :text
+    attr_reader :origin, :width, :font_size, :text
 
     alias :to_s :text
 
     def initialize(x, y, width, font_size, text)
-      @x = x
-      @y = y
+      @origin = PDF::Reader::Point.new(x, y)
       @width = width
-      @font_size = font_size.floor
+      @font_size = font_size
       @text = text
     end
 
@@ -34,12 +34,20 @@ class PDF::Reader
       end
     end
 
+    def x
+      @origin.x
+    end
+
+    def y
+      @origin.y
+    end
+
     def endx
-      @endx ||= x + width
+      @endx ||= @origin.x + width
     end
 
     def endy
-      @endy ||= y + font_size
+      @endy ||= @origin.y + font_size
     end
 
     def mean_character_width

data/lib/pdf/reader/token.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 ################################################################################

data/lib/pdf/reader/transformation_matrix.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/type_check.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+
+    # Cast untrusted input (usually parsed out of a PDF file) to a known type
+    #
+    class TypeCheck
+
+      def self.cast_to_numeric!(obj)
+        if obj.is_a?(Numeric)
+          obj
+        elsif obj.nil?
+          0
+        elsif obj.respond_to?(:to_f)
+          obj.to_f
+        elsif obj.respond_to?(:to_i)
+          obj.to_i
+        else
+          raise MalformedPDFError, "Unable to cast to numeric"
+        end
+      end
+
+      def self.cast_to_string!(string)
+        if string.is_a?(String)
+          string
+        elsif string.nil?
+          ""
+        elsif string.respond_to?(:to_s)
+          string.to_s
+        else
+          raise MalformedPDFError, "Unable to cast to string"
+        end
+      end
+
+      def self.cast_to_symbol(obj)
+        if obj.is_a?(Symbol)
+          obj
+        elsif obj.nil?
+          nil
+        elsif obj.respond_to?(:to_sym)
+          obj.to_sym
+        else
+          raise MalformedPDFError, "Unable to cast to symbol"
+        end
+      end
+    end
+  end
+end
+

data/lib/pdf/reader/unimplemented_security_handler.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/validating_receiver.rb

@@ -0,0 +1,262 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+module PDF
+  class Reader
+
+    # Page#walk will execute the content stream of a page, calling methods on a receiver class
+    # provided by the user. Each operator has a specific set of parameters it expects, and we
+    # wrap the users receiver class in this one to verify the PDF uses valid parameters.
+    #
+    # Without these checks, users can't be confident about the number of parameters they'll receive
+    # for an operator, or what the type of those parameters will be. Everyone ends up building their
+    # own type safety guard clauses and it's tedious.
+    #
+    # Not all operators have type safety implemented yet, but we can expand the number over time.
+    class ValidatingReceiver
+
+      def initialize(wrapped)
+        @wrapped = wrapped
+      end
+
+      def page=(page)
+        call_wrapped(:page=, page)
+      end
+
+      #####################################################
+      # Graphics State Operators
+      #####################################################
+      def save_graphics_state(*args)
+        call_wrapped(:save_graphics_state)
+      end
+
+      def restore_graphics_state(*args)
+        call_wrapped(:restore_graphics_state)
+      end
+
+      #####################################################
+      # Matrix Operators
+      #####################################################
+
+      def concatenate_matrix(*args)
+        a, b, c, d, e, f = *args
+        call_wrapped(
+          :concatenate_matrix,
+          TypeCheck.cast_to_numeric!(a),
+          TypeCheck.cast_to_numeric!(b),
+          TypeCheck.cast_to_numeric!(c),
+          TypeCheck.cast_to_numeric!(d),
+          TypeCheck.cast_to_numeric!(e),
+          TypeCheck.cast_to_numeric!(f),
+        )
+      end
+
+      #####################################################
+      # Text Object Operators
+      #####################################################
+
+      def begin_text_object(*args)
+        call_wrapped(:begin_text_object)
+      end
+
+      def end_text_object(*args)
+        call_wrapped(:end_text_object)
+      end
+
+      #####################################################
+      # Text State Operators
+      #####################################################
+      def set_character_spacing(*args)
+        char_spacing, _ = *args
+        call_wrapped(
+          :set_character_spacing,
+          TypeCheck.cast_to_numeric!(char_spacing)
+        )
+      end
+
+      def set_horizontal_text_scaling(*args)
+        h_scaling, _ = *args
+        call_wrapped(
+          :set_horizontal_text_scaling,
+          TypeCheck.cast_to_numeric!(h_scaling)
+        )
+      end
+
+      def set_text_font_and_size(*args)
+        label, size, _ = *args
+        call_wrapped(
+          :set_text_font_and_size,
+          TypeCheck.cast_to_symbol(label),
+          TypeCheck.cast_to_numeric!(size)
+        )
+      end
+
+      def set_text_leading(*args)
+        leading, _ = *args
+        call_wrapped(
+          :set_text_leading,
+          TypeCheck.cast_to_numeric!(leading)
+        )
+      end
+
+      def set_text_rendering_mode(*args)
+        mode, _ = *args
+        call_wrapped(
+          :set_text_rendering_mode,
+          TypeCheck.cast_to_numeric!(mode)
+        )
+      end
+
+      def set_text_rise(*args)
+        rise, _ = *args
+        call_wrapped(
+          :set_text_rise,
+          TypeCheck.cast_to_numeric!(rise)
+        )
+      end
+
+      def set_word_spacing(*args)
+        word_spacing, _ = *args
+        call_wrapped(
+          :set_word_spacing,
+          TypeCheck.cast_to_numeric!(word_spacing)
+        )
+      end
+
+      #####################################################
+      # Text Positioning Operators
+      #####################################################
+
+      def move_text_position(*args) # Td
+        x, y, _ = *args
+        call_wrapped(
+          :move_text_position,
+          TypeCheck.cast_to_numeric!(x),
+          TypeCheck.cast_to_numeric!(y)
+        )
+      end
+
+      def move_text_position_and_set_leading(*args) # TD
+        x, y, _ = *args
+        call_wrapped(
+          :move_text_position_and_set_leading,
+          TypeCheck.cast_to_numeric!(x),
+          TypeCheck.cast_to_numeric!(y)
+        )
+      end
+
+      def set_text_matrix_and_text_line_matrix(*args) # Tm
+        a, b, c, d, e, f = *args
+        call_wrapped(
+          :set_text_matrix_and_text_line_matrix,
+          TypeCheck.cast_to_numeric!(a),
+          TypeCheck.cast_to_numeric!(b),
+          TypeCheck.cast_to_numeric!(c),
+          TypeCheck.cast_to_numeric!(d),
+          TypeCheck.cast_to_numeric!(e),
+          TypeCheck.cast_to_numeric!(f),
+        )
+      end
+
+      def move_to_start_of_next_line(*args) # T*
+        call_wrapped(:move_to_start_of_next_line)
+      end
+
+      #####################################################
+      # Text Showing Operators
+      #####################################################
+      def show_text(*args) # Tj (AWAY)
+        string, _ = *args
+        call_wrapped(
+          :show_text,
+          TypeCheck.cast_to_string!(string)
+        )
+      end
+
+      def show_text_with_positioning(*args) # TJ [(A) 120 (WA) 20 (Y)]
+        params, _ = *args
+        unless params.is_a?(Array)
+          raise MalformedPDFError, "TJ operator expects a single Array argument"
+        end
+
+        call_wrapped(
+          :show_text_with_positioning,
+          params
+        )
+      end
+
+      def move_to_next_line_and_show_text(*args) # '
+        string, _ = *args
+        call_wrapped(
+          :move_to_next_line_and_show_text,
+          TypeCheck.cast_to_string!(string)
+        )
+      end
+
+      def set_spacing_next_line_show_text(*args) # "
+        aw, ac, string = *args
+        call_wrapped(
+          :set_spacing_next_line_show_text,
+          TypeCheck.cast_to_numeric!(aw),
+          TypeCheck.cast_to_numeric!(ac),
+          TypeCheck.cast_to_string!(string)
+        )
+      end
+
+      #####################################################
+      # Form XObject Operators
+      #####################################################
+
+      def invoke_xobject(*args)
+        label, _ = *args
+
+        call_wrapped(
+          :invoke_xobject,
+          TypeCheck.cast_to_symbol(label)
+        )
+      end
+
+      #####################################################
+      # Inline Image Operators
+      #####################################################
+
+      def begin_inline_image(*args)
+        call_wrapped(:begin_inline_image)
+      end
+
+      def begin_inline_image_data(*args)
+        # We can't use call_wrapped() here because sorbet won't allow splat args with a dynamic
+        # number of elements
+        @wrapped.begin_inline_image_data(*args) if @wrapped.respond_to?(:begin_inline_image_data)
+      end
+
+      def end_inline_image(*args)
+        data, _ = *args
+
+        call_wrapped(
+          :end_inline_image,
+          TypeCheck.cast_to_string!(data)
+        )
+      end
+
+      #####################################################
+      # Final safety net for any operators that don't have type checking enabled yet
+      #####################################################
+
+      def respond_to?(meth)
+        @wrapped.respond_to?(meth)
+      end
+
+      def method_missing(methodname, *args)
+        @wrapped.call(methodname, *args)
+      end
+
+      private
+
+      def call_wrapped(methodname, *args)
+        @wrapped.send(methodname, *args) if @wrapped.respond_to?(methodname)
+      end
+    end
+  end
+end

data/lib/pdf/reader/width_calculator/built_in.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 require 'afm'

data/lib/pdf/reader/width_calculator/composite.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/width_calculator/true_type.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -29,7 +30,7 @@ class PDF::Reader
 
         # in ruby a negative index is valid, and will go from the end of the array
         # which is undesireable in this case.
-        if @font.first_char <= code_point
+        if @font.first_char && @font.first_char <= code_point
           @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
         else
           @missing_width.to_f

data/lib/pdf/reader/width_calculator/type_one_or_three.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader

data/lib/pdf/reader/width_calculator/type_zero.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 class PDF::Reader