pdf-reader 1.4.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,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #

data/lib/pdf/reader/synchronized_cache.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# 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
+# frozen_string_literal: true
 
 class PDF::Reader
   # A value object that represents one or more consecutive characters on a page.
@@ -37,6 +38,10 @@ class PDF::Reader
       @endx ||= x + width
     end
 
+    def endy
+      @endy ||= y + font_size
+    end
+
     def mean_character_width
       @width / character_count
     end
@@ -59,22 +64,36 @@ class PDF::Reader
       "#{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
-      if @text.size == 1
-        1.0
-      elsif @text.respond_to?(:bytesize)
-        # M17N aware VM
-        # so we can trust String#size to return a character count
-        @text.size.to_f
-      else
-        text.unpack("U*").size.to_f
-      end
+      @text.size.to_f
     end
   end
 end

data/lib/pdf/reader/token.rb

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

data/lib/pdf/reader/transformation_matrix.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 class PDF::Reader
   # co-ordinate systems in PDF files are specified using a 3x3 matrix that looks

data/lib/pdf/reader/unimplemented_security_handler.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+class PDF::Reader
+
+  # Security handler for when we don't support the flavour of encryption
+  # used in a PDF.
+  class UnimplementedSecurityHandler
+    def self.supports?(encrypt)
+      true
+    end
+
+    def decrypt(buf, ref)
+      raise PDF::Reader::EncryptedPDFError, "Unsupported encryption style"
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require 'afm'
 require 'pdf/reader/synchronized_cache'
@@ -11,11 +12,20 @@ class PDF::Reader
     # see Section 9.6.2.2, PDF 32000-1:2008, pp 256
     class BuiltIn
 
+      BUILTINS = [
+        :Courier, :"Courier-Bold", :"Courier-BoldOblique", :"Courier-Oblique",
+        :Helvetica, :"Helvetica-Bold", :"Helvetica-BoldOblique", :"Helvetica-Oblique",
+        :Symbol,
+        :"Times-Roman", :"Times-Bold", :"Times-BoldItalic", :"Times-Italic",
+        :ZapfDingbats
+      ]
+
       def initialize(font)
         @font = font
         @@all_metrics ||= PDF::Reader::SynchronizedCache.new
 
-        metrics_path = File.join(File.dirname(__FILE__), "..","afm","#{font.basefont}.afm")
+        basefont = extract_basefont(font.basefont)
+        metrics_path = File.join(File.dirname(__FILE__), "..","afm","#{basefont}.afm")
 
         if File.file?(metrics_path)
           @metrics = @@all_metrics[metrics_path] ||= AFM::Font.new(metrics_path)
@@ -27,23 +37,15 @@ class PDF::Reader
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
 
-        m = @metrics.char_metrics_by_code[code_point]
-        if m.nil?
-          names = @font.encoding.int_to_name(code_point)
-
-          m = names.map { |name|
-            @metrics.char_metrics[name.to_s]
-          }.compact.first
-        end
+        names = @font.encoding.int_to_name(code_point)
+        metrics = names.map { |name|
+          @metrics.char_metrics[name.to_s]
+        }.compact.first
 
-        if m
-          m[:wx]
-        elsif @font.widths[code_point - 1]
-          @font.widths[code_point - 1]
-        elsif control_character?(code_point)
-          0
+        if metrics
+          metrics[:wx]
         else
-          0
+          @font.widths[code_point - 1] || 0
         end
       end
 
@@ -53,6 +55,13 @@ class PDF::Reader
         @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
       end
 
+      def extract_basefont(font_name)
+        if BUILTINS.include?(font_name)
+          font_name
+        else
+          "Times-Roman"
+        end
+      end
     end
   end
 end

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

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

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

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 class PDF::Reader
   module WidthCalculator
@@ -17,8 +18,7 @@ class PDF::Reader
 
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
-
-        glyph_width_from_font(code_point) || glyph_width_from_descriptor(code_point)
+        glyph_width_from_font(code_point) || glyph_width_from_descriptor(code_point) || 0
       end
 
       private

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

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

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

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

data/lib/pdf/reader/width_calculator.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 # PDF files may define fonts in a number of ways. Each approach means we must
 # calculate glyph widths differently, so this set of classes conform to an

data/lib/pdf/reader/xref.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -203,8 +204,10 @@ class PDF::Reader
         ("\x00" + bytes).unpack("N")[0]
       elsif bytes.size == 4
         bytes.unpack("N")[0]
+      elsif bytes.size == 8
+        bytes.unpack("Q>")[0]
       else
-        raise UnsupportedFeatureError, "Unable to unpack xref stream entries with more than 4 bytes"
+        raise UnsupportedFeatureError, "Unable to unpack xref stream entries of #{bytes.size} bytes"
       end
     end
     ################################################################################
@@ -227,18 +230,21 @@ class PDF::Reader
     # should always be 0, but all sort of crazy junk is prefixed to PDF files
     # in the real world.
     #
-    # Checks up to 50 chars into the file, returns nil if no PDF data detected.
+    # Checks up to 1024 chars into the file,
+    # returns nil if no PDF data detected.
+    # Adobe PDF 1.4 spec (3.4.1) 12. Acrobat viewers require only that the
+    # header appear somewhere within the first 1024 bytes of the file
     #
     def calc_junk_offset(io)
       io.rewind
       offset = io.pos
-      until (c = io.readchar) == '%' || c == 37 || offset > 50
+      until (c = io.readchar) == '%' || c == 37 || offset > 1024
         offset += 1
       end
       io.rewind
-      offset < 50 ? offset : nil
+      offset < 1024 ? offset : nil
     rescue EOFError
-      return nil
+      nil
     end
   end
   ################################################################################

data/lib/pdf/reader.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -110,16 +111,10 @@ module PDF
     #
     #   reader = PDF::Reader.new("somefile.pdf", :password => "apples")
     #
-    def initialize(input = nil, opts = {})
-      if input # support the deprecated Reader API
-        @cache   = PDF::Reader::ObjectCache.new
-        opts.merge!(:cache => @cache)
-        @objects = PDF::Reader::ObjectHash.new(input, opts)
-      else
-        msg  = "Calling PDF::Reader#new with no arguments is deprecated and will be removed "
-        msg += "in the 2.0 release"
-        $stderr.puts(msg)
-      end
+    def initialize(input, opts = {})
+      @cache   = PDF::Reader::ObjectCache.new
+      opts.merge!(:cache => @cache)
+      @objects = PDF::Reader::ObjectHash.new(input, opts)
     end
 
     def info
@@ -133,13 +128,16 @@ module PDF
         nil
       else
         xml = stream.unfiltered_data
-        xml.force_encoding("utf-8") if xml.respond_to?(:force_encoding)
+        xml.force_encoding("utf-8")
         xml
       end
     end
 
     def page_count
       pages = @objects.deref(root[:Pages])
+      unless pages.kind_of?(::Hash)
+        raise MalformedPDFError, 'Pages structure is missing'
+      end
       @page_count ||= @objects.deref(pages[:Count])
     end
 
@@ -164,61 +162,6 @@ module PDF
       yield PDF::Reader.new(input, opts)
     end
 
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    #
-    # Parse the file with the given name, sending events to the given receiver.
-    #
-    def self.file(name, receivers, opts = {})
-      msg  = "PDF::Reader#file is deprecated and will be removed in the 2.0 release"
-      $stderr.puts(msg)
-      File.open(name,"rb") do |f|
-        new.parse(f, receivers, opts)
-      end
-    end
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Parse the given string, sending events to the given receiver.
-    #
-    def self.string(str, receivers, opts = {})
-      msg  = "PDF::Reader#string is deprecated and will be removed in the 2.0 release"
-      $stderr.puts(msg)
-      StringIO.open(str) do |s|
-        new.parse(s, receivers, opts)
-      end
-    end
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Parse the file with the given name, returning an unmarshalled ruby version of
-    # represents the requested pdf object
-    #
-    def self.object_file(name, id, gen = 0)
-      msg  = "PDF::Reader#object_file is deprecated and will be removed in the 2.0 release"
-      $stderr.puts(msg)
-      File.open(name,"rb") { |f|
-        new.object(f, id.to_i, gen.to_i)
-      }
-    end
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Parse the given string, returning an unmarshalled ruby version of represents
-    # the requested pdf object
-    #
-    def self.object_string(str, id, gen = 0)
-      msg  = "PDF::Reader#object_string is deprecated and will be removed in the 2.0 release"
-      $stderr.puts(msg)
-      StringIO.open(str) { |s|
-        new.object(s, id.to_i, gen.to_i)
-      }
-    end
-
     # returns an array of PDF::Reader::Page objects, one for each
     # page in the source PDF.
     #
@@ -234,9 +177,13 @@ module PDF
     # methods available on each page
     #
     def pages
-      (1..self.page_count).map { |num|
-        PDF::Reader::Page.new(@objects, num, :cache => @cache)
-      }
+      (1..self.page_count).map do |num|
+        begin
+          PDF::Reader::Page.new(@objects, num, :cache => @cache)
+        rescue InvalidPageError
+          raise MalformedPDFError, "Missing data for page: #{num}"
+        end
+      end
     end
 
     # returns a single PDF::Reader::Page for the specified page.
@@ -254,45 +201,11 @@ module PDF
     def page(num)
       num = num.to_i
       if num < 1 || num > self.page_count
-        raise ArgumentError, "valid pages are 1 .. #{self.page_count}"
+        raise InvalidPageError, "Valid pages are 1 .. #{self.page_count}"
       end
       PDF::Reader::Page.new(@objects, num, :cache => @cache)
     end
 
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Given an IO object that contains PDF data, parse it.
-    #
-    def parse(io, receivers, opts = {})
-      msg  = "PDF::Reader#parse is deprecated and will be removed in the 2.0 release"
-      $stderr.puts(msg)
-      ohash    = ObjectHash.new(io)
-
-      options = {:pages => true, :raw_text => false, :metadata => true}
-      options.merge!(opts)
-
-      strategies.each do |s|
-        s.new(ohash, receivers, options).process
-      end
-
-      self
-    end
-
-    # DEPRECATED: this method was deprecated in version 1.0.0 and will
-    #             eventually be removed
-    #
-    # Given an IO object that contains PDF data, return the contents of a single object
-    #
-    def object(io, id, gen)
-      msg  = "PDF::Reader#object is deprecated and will be removed in the 2.0 release"
-      $stderr.puts(msg)
-      @objects = ObjectHash.new(io)
-
-      @objects.deref(Reference.new(id, gen))
-    end
-
     private
 
     # recursively convert strings from outside a content stream into UTF-8
@@ -314,14 +227,14 @@ module PDF
           pdfdoc_to_utf8(obj)
         end
       else
-        obj
+        @objects.deref(obj)
       end
     end
 
     # TODO find a PDF I can use to spec this behaviour
     #
     def pdfdoc_to_utf8(obj)
-      obj.force_encoding("utf-8") if obj.respond_to?(:force_encoding)
+      obj.force_encoding("utf-8")
       obj
     end
 
@@ -331,19 +244,18 @@ module PDF
     def utf16_to_utf8(obj)
       str = obj[2, obj.size]
       str = str.unpack("n*").pack("U*")
-      str.force_encoding("utf-8") if str.respond_to?(:force_encoding)
+      str.force_encoding("utf-8")
       str
     end
 
-    def strategies
-      @strategies ||= [
-        ::PDF::Reader::MetadataStrategy,
-        ::PDF::Reader::PagesStrategy
-      ]
-    end
-
     def root
-      @root ||= @objects.deref(@objects.trailer[:Root])
+      @root ||= begin
+        obj = @objects.deref(@objects.trailer[:Root])
+        unless obj.kind_of?(::Hash)
+          raise MalformedPDFError, "PDF malformed, trailer Root should be a dictionary"
+        end
+        obj
+      end
     end
 
   end
@@ -351,7 +263,6 @@ end
 ################################################################################
 
 require 'pdf/reader/resource_methods'
-require 'pdf/reader/abstract_strategy'
 require 'pdf/reader/buffer'
 require 'pdf/reader/cid_widths'
 require 'pdf/reader/cmap'
@@ -370,7 +281,6 @@ require 'pdf/reader/font_descriptor'
 require 'pdf/reader/form_xobject'
 require 'pdf/reader/glyph_hash'
 require 'pdf/reader/lzw'
-require 'pdf/reader/metadata_strategy'
 require 'pdf/reader/object_cache'
 require 'pdf/reader/object_hash'
 require 'pdf/reader/object_stream'
@@ -379,9 +289,11 @@ require 'pdf/reader/parser'
 require 'pdf/reader/print_receiver'
 require 'pdf/reader/reference'
 require 'pdf/reader/register_receiver'
+require 'pdf/reader/null_security_handler'
 require 'pdf/reader/standard_security_handler'
+require 'pdf/reader/standard_security_handler_v5'
+require 'pdf/reader/unimplemented_security_handler'
 require 'pdf/reader/stream'
-require 'pdf/reader/text_receiver'
 require 'pdf/reader/text_run'
 require 'pdf/reader/page_state'
 require 'pdf/reader/page_text_receiver'
@@ -389,4 +301,3 @@ require 'pdf/reader/token'
 require 'pdf/reader/xref'
 require 'pdf/reader/orientation_detector'
 require 'pdf/reader/page'
-require 'pdf/hash'

data/lib/pdf-reader.rb

@@ -1,3 +1,4 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require "pdf/reader"