pdf-reader 1.1.1 → 2.5.0

data/lib/pdf/reader/standard_security_handler_v5.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'digest'
+require 'openssl'
+
+class PDF::Reader
+
+  # class creates interface to encrypt dictionary for use in Decrypt
+  class StandardSecurityHandlerV5
+
+    attr_reader :key_length, :encrypt_key
+
+    def initialize(opts = {})
+      @key_length   = 256
+      @O            = opts[:O]   # hash(32B) + validation salt(8B) + key salt(8B)
+      @U            = opts[:U]   # hash(32B) + validation salt(8B) + key salt(8B)
+      @OE           = opts[:OE]  # decryption key, encrypted w/ owner password
+      @UE           = opts[:UE]  # decryption key, encrypted w/ user password
+      @encrypt_key  = build_standard_key(opts[:password] || '')
+    end
+
+    # This handler supports AES-256 encryption defined in PDF 1.7 Extension Level 3
+    def self.supports?(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) && (algorithm == :AESV3))
+    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)
+    #
+    # buf - a string to decrypt
+    # ref - a PDF::Reader::Reference for the object to decrypt
+    #
+    def decrypt( buf, ref )
+      cipher = OpenSSL::Cipher.new("AES-#{@key_length}-CBC")
+      cipher.decrypt
+      cipher.key = @encrypt_key.dup
+      cipher.iv = buf[0..15]
+      cipher.update(buf[16..-1]) + cipher.final
+    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 + @O[32..39] + @U) == @O[0..31]
+        cipher = OpenSSL::Cipher.new('AES-256-CBC')
+        cipher.decrypt
+        cipher.key = Digest::SHA256.digest(password + @O[40..-1] + @U)
+        cipher.iv = "\x00" * 16
+        cipher.padding = 0
+        cipher.update(@OE) + cipher.final
+      end
+    end
+
+    def auth_user_pass(password)
+      if Digest::SHA256.digest(password + @U[32..39]) == @U[0..31]
+        cipher = OpenSSL::Cipher.new('AES-256-CBC')
+        cipher.decrypt
+        cipher.key = Digest::SHA256.digest(password + @U[40..-1])
+        cipher.iv = "\x00" * 16
+        cipher.padding = 0
+        cipher.update(@UE) + cipher.final
+      end
+    end
+
+    def build_standard_key(pass)
+      pass = pass.byteslice(0...127)   # UTF-8 encoded password. first 127 bytes
+
+      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,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -35,7 +38,7 @@ class PDF::Reader
     ################################################################################
     # Creates a new stream with the specified dictionary and data. The dictionary
     # should be a standard ruby hash, the data should be a standard ruby string.
-    def initialize (hash, data)
+    def initialize(hash, data)
       @hash = hash
       @data = data
       @udata = nil
@@ -58,7 +61,7 @@ class PDF::Reader
         end
 
         Array(hash[:Filter]).each_with_index do |filter, index|
-          @udata = Filter.new(filter, options[index]).filter(@udata)
+          @udata = Filter.with(filter, options[index]).filter(@udata)
         end
       end
       @udata

data/lib/pdf/reader/synchronized_cache.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+# utilities.rb : General-purpose utility classes which don't fit anywhere else
+#
+# Copyright August 2012, Alex Dowad. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+# This was originally written for the prawn gem.
+
+require 'thread'
+
+class PDF::Reader
+
+  # Throughout the pdf-reader codebase, repeated calculations which can benefit
+  # from caching are made In some cases, caching and reusing results can not
+  # only save CPU cycles but also greatly reduce memory requirements But at the
+  # same time, we don't want to throw away thread safety We have two
+  # interchangeable thread-safe cache implementations:
+  class SynchronizedCache
+    def initialize
+      @cache = {}
+      @mutex = Mutex.new
+    end
+    def [](key)
+      @mutex.synchronize { @cache[key] }
+    end
+    def []=(key,value)
+      @mutex.synchronize { @cache[key] = value }
+    end
+  end
+end

data/lib/pdf/reader/text_run.rb

@@ -0,0 +1,99 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+  # A value object that represents one or more consecutive characters on a page.
+  class TextRun
+    include Comparable
+
+    attr_reader :x, :y, :width, :font_size, :text
+
+    alias :to_s :text
+
+    def initialize(x, y, width, font_size, text)
+      @x = x
+      @y = y
+      @width = width
+      @font_size = font_size.floor
+      @text = text
+    end
+
+    # Allows collections of TextRun objects to be sorted. They will be sorted
+    # in order of their position on a cartesian plain - Top Left to Bottom Right
+    def <=>(other)
+      if x == other.x && y == other.y
+        0
+      elsif y < other.y
+        1
+      elsif y > other.y
+        -1
+      elsif x < other.x
+        -1
+      elsif x > other.x
+        1
+      end
+    end
+
+    def endx
+      @endx ||= x + width
+    end
+
+    def endy
+      @endy ||= y + font_size
+    end
+
+    def mean_character_width
+      @width / character_count
+    end
+
+    def mergable?(other)
+      y.to_i == other.y.to_i && font_size == other.font_size && mergable_range.include?(other.x)
+    end
+
+    def +(other)
+      raise ArgumentError, "#{other} cannot be merged with this run" unless mergable?(other)
+
+      if (other.x - endx) <( font_size * 0.2)
+        TextRun.new(x, y, other.endx - x, font_size, text + other.text)
+      else
+        TextRun.new(x, y, other.endx - x, font_size, "#{text} #{other.text}")
+      end
+    end
+
+    def inspect
+      "#{text} w:#{width} f:#{font_size} @#{x},#{y}"
+    end
+
+    def intersect?(other_run)
+      x <= other_run.endx && endx >= other_run.x &&
+        endy >= other_run.y && y <= other_run.endy
+    end
+
+    # return what percentage of this text run is overlapped by another run
+    def intersection_area_percent(other_run)
+      return 0 unless intersect?(other_run)
+
+      dx = [endx, other_run.endx].min - [x, other_run.x].max
+      dy = [endy, other_run.endy].min - [y, other_run.y].max
+      intersection_area = dx*dy
+
+      intersection_area.to_f / area
+    end
+
+    private
+
+    def area
+      (endx - x) * (endy - y)
+    end
+
+    def mergable_range
+      @mergable_range ||= Range.new(endx - 3, endx + font_size)
+    end
+
+    # Assume string encoding is marked correctly and we can trust String#size to return a
+    # character count
+    def character_count
+      @text.size.to_f
+    end
+  end
+end

data/lib/pdf/reader/token.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -31,7 +34,7 @@ class PDF::Reader
   class Token < String # :nodoc:
     ################################################################################
     # Creates a new token with the specified value
-    def initialize (val)
+    def initialize(val)
       super
     end
     ################################################################################

data/lib/pdf/reader/transformation_matrix.rb

@@ -0,0 +1,195 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+  # co-ordinate systems in PDF files are specified using a 3x3 matrix that looks
+  # something like this:
+  #
+  #   [ a b 0 ]
+  #   [ c d 0 ]
+  #   [ e f 1 ]
+  #
+  # Because the final column never changes, we can represent each matrix using
+  # only 6 numbers. This is important to save CPU time, memory and GC pressure
+  # caused by allocating too many unnecessary objects.
+  class TransformationMatrix
+    attr_reader :a, :b, :c, :d, :e, :f
+
+    def initialize(a, b, c, d, e, f)
+      @a, @b, @c, @d, @e, @f = a, b, c, d, e, f
+    end
+
+    def inspect
+      "#{a}, #{b}, 0,\n#{c}, #{d}, #{0},\n#{e}, #{f}, 1"
+    end
+
+    def to_a
+      [@a,@b,0,
+       @c,@d,0,
+       @e,@f,1]
+    end
+
+    # multiply this matrix with another.
+    #
+    # the second matrix is represented by the 6 scalar values that are changeable
+    # in a PDF transformation matrix.
+    #
+    # WARNING: This mutates the current matrix to avoid allocating memory when
+    #          we don't need too. Matrices are multiplied ALL THE FREAKING TIME
+    #          so this is a worthwhile optimisation
+    #
+    # NOTE: When multiplying matrices, ordering matters. Double check
+    #       the PDF spec to ensure you're multiplying things correctly.
+    #
+    # NOTE: see Section 8.3.3, PDF 32000-1:2008, pp 119
+    #
+    # NOTE: The if statements in this method are ordered to prefer optimisations
+    #       that allocate fewer objects
+    #
+    # TODO: it might be worth adding an optimised path for vertical
+    #       displacement to speed up processing documents that use vertical
+    #       writing systems
+    #
+    def multiply!(a,b=nil,c=nil, d=nil,e=nil,f=nil)
+      if a == 1 && b == 0 && c == 0 && d == 1 && e == 0 && f == 0
+        # the identity matrix, no effect
+        self
+      elsif @a == 1 && @b == 0 && @c == 0 && @d == 1 && @e == 0 && @f == 0
+        # I'm the identity matrix, so just copy values across
+        @a = a
+        @b = b
+        @c = c
+        @d = d
+        @e = e
+        @f = f
+      elsif a == 1 && b == 0 && c == 0 && d == 1 && f == 0
+        # the other matrix is a horizontal displacement
+        horizontal_displacement_multiply!(e)
+      elsif @a == 1 && @b == 0 && @c == 0 && @d == 1 && @f == 0
+        # I'm a horizontal displacement
+        horizontal_displacement_multiply_reversed!(a,b,c,d,e,f)
+      elsif @a != 1 && @b == 0 && @c == 0 && @d != 1 && @e == 0 && @f == 0
+        # I'm a xy scale
+        xy_scaling_multiply_reversed!(a,b,c,d,e,f)
+      elsif a != 1 && b == 0 && c == 0 && d != 1 && e == 0 && f == 0
+        # the other matrix is an xy scale
+        xy_scaling_multiply!(a,b,c,d,e,f)
+      else
+        faster_multiply!(a,b,c, d,e,f)
+      end
+      self
+    end
+
+    # Optimised method for when the second matrix in the calculation is
+    # a simple horizontal displacement.
+    #
+    # Like this:
+    #
+    #   [ 1 2 0 ]   [ 1  0 0 ]
+    #   [ 3 4 0 ] x [ 0  1 0 ]
+    #   [ 5 6 1 ]   [ e2 0 1 ]
+    #
+    def horizontal_displacement_multiply!(e2)
+      @e = @e + e2
+    end
+
+    private
+
+    # Optimised method for when the first matrix in the calculation is
+    # a simple horizontal displacement.
+    #
+    # Like this:
+    #
+    #   [ 1 0 0 ]   [ 1 2 0 ]
+    #   [ 0 1 0 ] x [ 3 4 0 ]
+    #   [ 5 0 1 ]   [ 5 6 1 ]
+    #
+    def horizontal_displacement_multiply_reversed!(a2,b2,c2,d2,e2,f2)
+      newa = a2
+      newb = b2
+      newc = c2
+      newd = d2
+      newe = (@e * a2) + e2
+      newf = (@e * b2) + f2
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+
+    # Optimised method for when the second matrix in the calculation is
+    # an X and Y scale
+    #
+    # Like this:
+    #
+    #   [ 1 2 0 ]   [ 5 0 0 ]
+    #   [ 3 4 0 ] x [ 0 5 0 ]
+    #   [ 5 6 1 ]   [ 0 0 1 ]
+    #
+    def xy_scaling_multiply!(a2,b2,c2,d2,e2,f2)
+      newa = @a * a2
+      newb = @b * d2
+      newc = @c * a2
+      newd = @d * d2
+      newe = @e * a2
+      newf = @f * d2
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+
+    # Optimised method for when the first matrix in the calculation is
+    # an X and Y scale
+    #
+    # Like this:
+    #
+    #   [ 5 0 0 ]   [ 1 2 0 ]
+    #   [ 0 5 0 ] x [ 3 4 0 ]
+    #   [ 0 0 1 ]   [ 5 6 1 ]
+    #
+    def xy_scaling_multiply_reversed!(a2,b2,c2,d2,e2,f2)
+      newa = @a * a2
+      newb = @a * b2
+      newc = @d * c2
+      newd = @d * d2
+      newe = e2
+      newf = f2
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+
+    # A general solution to multiplying two 3x3 matrixes. This is correct in all cases,
+    # but slower due to excessive object allocations. It's not actually used in any
+    # active code paths, but is here for reference. Use faster_multiply instead.
+    #
+    # Like this:
+    #
+    #   [ a b 0 ]   [ a b 0 ]
+    #   [ c d 0 ] x [ c d 0 ]
+    #   [ e f 1 ]   [ e f 1 ]
+    #
+    def regular_multiply!(a2,b2,c2,d2,e2,f2)
+      newa = (@a * a2) + (@b * c2) + (0 * e2)
+      newb = (@a * b2) + (@b * d2) + (0 * f2)
+      newc = (@c * a2) + (@d * c2) + (0 * e2)
+      newd = (@c * b2) + (@d * d2) + (0 * f2)
+      newe = (@e * a2) + (@f * c2) + (1 * e2)
+      newf = (@e * b2) + (@f * d2) + (1 * f2)
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+
+    # A general solution for multiplying two matrices when we know all values
+    # in the final column are fixed. This is the fallback method for when none
+    # of the optimised methods are applicable.
+    #
+    # Like this:
+    #
+    #   [ a b 0 ]   [ a b 0 ]
+    #   [ c d 0 ] x [ c d 0 ]
+    #   [ e f 1 ]   [ e f 1 ]
+    #
+    def faster_multiply!(a2,b2,c2, d2,e2,f2)
+      newa = (@a * a2) + (@b * c2)
+      newb = (@a * b2) + (@b * d2)
+      newc = (@c * a2) + (@d * c2)
+      newd = (@c * b2) + (@d * d2)
+      newe = (@e * a2) + (@f * c2) + e2
+      newf = (@e * b2) + (@f * d2) + f2
+      @a, @b, @c, @d, @e, @f = newa, newb, newc, newd, newe, newf
+    end
+  end
+end