pdf-reader 1.4.1 → 2.5.0

data/lib/pdf/reader/pages_strategy.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -27,42 +28,8 @@
 
 class PDF::Reader
   ################################################################################
-  # Walks the pages of the PDF file and calls the appropriate callback methods when
-  # something of interest is found.
-  #
-  # The callback methods should exist on the receiver object passed into the constructor.
-  # Whenever some content is found that will trigger a callback, the receiver is checked
-  # to see if the callback is defined.
-  #
-  # If it is defined it will be called. If not, processing will continue.
-  #
-  # = Available Callbacks
-  # The following callbacks are available and should be methods defined on your receiver class. Only
-  # implement the ones you need - the rest will be ignored.
-  #
-  # Some callbacks will include parameters which will be passed in as an array. For callbacks
-  # that supply no paramters, or where you don't need them, the *params argument can be left off.
-  # Some example callback method definitions are:
-  #
-  #   def begin_document
-  #   def end_page
-  #   def show_text(string, *params)
-  #   def fill_stroke(*params)
-  #
-  # You should be able to infer the basic command the callback is reporting based on the name. For
-  # further experimentation, define the callback with just a *params parameter, then print out the
-  # contents of the array using something like:
-  #
-  #   puts params.inspect
-  #
   # == Text Callbacks
   #
-  # All text passed into these callbacks will be encoded as UTF-8. Depending on where (and when) the
-  # PDF was generated, there's a good chance the text is NOT stored as UTF-8 internally so be
-  # careful when doing a comparison on strings returned from PDF::Reader (when doing unit tests for
-  # example). The string may not be byte-by-byte identical with the string that was originally
-  # written to the PDF.
-  #
   # - end_text_object
   # - move_to_start_of_next_line
   # - set_character_spacing
@@ -80,14 +47,6 @@ class PDF::Reader
   # - move_to_next_line_and_show_text
   # - set_spacing_next_line_show_text
   #
-  # If the :raw_text option was passed to the PDF::Reader class the following callbacks
-  # may also appear:
-  #
-  # - show_text_raw
-  # - show_text_with_positioning_raw
-  # - move_to_next_line_and_show_text_raw
-  # - set_spacing_next_line_show_text_raw
-  #
   # == Graphics Callbacks
   # - close_fill_stroke
   # - fill_stroke
@@ -145,42 +104,7 @@ class PDF::Reader
   # - set_clipping_path_with_even_odd
   # - append_curved_segment_final_point_replicated
   #
-  # == Misc Callbacks
-  # - begin_compatibility_section
-  # - end_compatibility_section,
-  # - begin_document
-  # - end_document
-  # - begin_page_container
-  # - end_page_container
-  # - begin_page
-  # - end_page
-  # - metadata
-  # - xml_metadata
-  # - page_count
-  # - begin_form_xobject
-  # - end_form_xobject
-  #
-  # == Resource Callbacks
-  #
-  # Each page can contain (or inherit) a range of resources required for the page,
-  # including things like fonts and images. The following callbacks may appear
-  # after begin_page if the relevant resources exist on a page:
-  #
-  # - resource_procset
-  # - resource_xobject
-  # - resource_extgstate
-  # - resource_colorspace
-  # - resource_pattern
-  # - resource_font
-  #
-  # In most cases, these callbacks associate a name with each resource, allowing it
-  # to be referred to by name in the page content. For example, an XObject can hold an image.
-  # If it gets mapped to the name "IM1", then it can be placed on the page using
-  # invoke_xobject "IM1".
-  #
-  # DEPRECATED: this class was deprecated in version 0.11.0 and will
-  #             eventually be removed
-  class PagesStrategy< AbstractStrategy # :nodoc:
+  class PagesStrategy # :nodoc:
     OPERATORS = {
       'b'   => :close_fill_stroke,
       'B'   => :fill_stroke,
@@ -256,232 +180,6 @@ class PDF::Reader
       '\''  => :move_to_next_line_and_show_text,
       '"'   => :set_spacing_next_line_show_text,
     }
-    def self.to_sym
-      :pages
-    end
-    ################################################################################
-    # Begin processing the document
-    def process
-      return false unless options[:pages]
-
-      callback(:begin_document, [root])
-      walk_pages(@ohash.object(root[:Pages]))
-      callback(:end_document)
-    end
-    private
-    ################################################################################
-    def params_to_utf8(params, font)
-      if params.is_a?(String)
-        font.to_utf8(params)
-      elsif params.is_a?(Array)
-        params.map { |i| params_to_utf8(i, font)}
-      else
-        params
-      end
-    end
-    ################################################################################
-    # Walk over all pages in the PDF file, calling the appropriate callbacks for each page and all
-    # its content
-    def walk_pages(page)
-
-      # extract page content
-      if page[:Type] == :Pages
-        callback(:begin_page_container, [page])
-        res = @ohash.object(page[:Resources])
-        resources.push res if res
-        @ohash.object(page[:Kids]).each {|child| walk_pages(@ohash.object(child))}
-        resources.pop if res
-        callback(:end_page_container)
-      elsif page[:Type] == :Page
-        callback(:begin_page, [page])
-        res = @ohash.object(page[:Resources])
-        resources.push res if res
-        walk_resources(current_resources)
-
-        if @ohash.object(page[:Contents]).kind_of?(Array)
-          contents = @ohash.object(page[:Contents])
-        else
-          contents = [page[:Contents]]
-        end
-
-        fonts = font_hash_from_resources(current_resources)
-
-        if page.has_key?(:Contents) and page[:Contents]
-          direct_contents = contents.map { |content| @ohash.object(content) }
-          content_stream(direct_contents, fonts)
-        end
-
-        resources.pop if res
-        callback(:end_page)
-      end
-    end
-    ################################################################################
-    # Retreive the XObject for the supplied label and if it's a Form, walk it
-    # like a regular page content stream.
-    #
-    def walk_xobject_form(label)
-      xobjects = @ohash.object(current_resources[:XObject]) || {}
-      xobject  = @ohash.object(xobjects[label])
-
-      if xobject && xobject.hash[:Subtype] == :Form
-        callback(:begin_form_xobject)
-        xobj_resources = @ohash.object(xobject.hash[:Resources])
-        if xobj_resources
-          resources.push xobj_resources
-          walk_resources(xobj_resources)
-        end
-        fonts = font_hash_from_resources(xobj_resources)
-        content_stream(xobject, fonts)
-        callback(:end_form_xobject)
-        resources.pop if xobj_resources
-      end
-    end
-
-    ################################################################################
-    # Return a merged hash of all resources that are current. Pages, page and xobject
-    #
-    def current_resources
-      hash = {}
-      resources.each do |res|
-        hash.merge!(res)
-      end
-      hash
-    end
-    ################################################################################
-    # Reads a PDF content stream and calls all the appropriate callback methods for the operators
-    # it contains
-    #
-    def content_stream(instructions, fonts = {})
-      instructions = [instructions] unless instructions.kind_of?(Array)
-      instructions = instructions.map { |ins|
-        ins.is_a?(PDF::Reader::Stream) ? ins.unfiltered_data : ins.to_s
-      }.join
-      buffer       = Buffer.new(StringIO.new(instructions), :content_stream => true)
-      parser       = Parser.new(buffer, @ohash)
-      current_font = nil
-      params       = []
-
-      while (token = parser.parse_token(OPERATORS))
-        if token.kind_of?(Token) and OPERATORS.has_key?(token)
-          if OPERATORS[token] == :set_text_font_and_size
-            current_font = params.first
-            if fonts[current_font].nil?
-              raise MalformedPDFError, "Unknown font #{current_font}"
-            end
-          end
-
-          # handle special cases in response to certain operators
-          if OPERATORS[token].to_s.include?("show_text")
-            # convert any text to utf-8, but output the raw string if the user wants it
-            if options[:raw_text]
-              callback("#{OPERATORS[token]}_raw".to_sym, params)
-            end
-            params = params_to_utf8(params, fonts[current_font])
-          elsif token == "ID"
-            # inline image data, first convert the current params into a more familiar hash
-            map = {}
-            params.each_slice(2) do |key, value|
-              map[key] = value
-            end
-            params = [map, buffer.token]
-          end
-
-          callback(OPERATORS[token], params)
-
-          if OPERATORS[token] == :invoke_xobject
-            xobject_label = params.first
-            params.clear
-            walk_xobject_form(xobject_label)
-          else
-            params.clear
-          end
-        else
-          params << token
-        end
-      end
-    rescue EOFError
-      raise MalformedPDFError, "End Of File while processing a content stream"
-    end
-    ################################################################################
-    def walk_resources(resources)
-      return unless resources.respond_to?(:[])
-
-      resources = resolve_references(resources)
-
-      # extract any procset information
-      if resources[:ProcSet]
-        callback(:resource_procset, resources[:ProcSet])
-      end
-
-      # extract any xobject information
-      if resources[:XObject]
-        @ohash.object(resources[:XObject]).each do |name, val|
-          callback(:resource_xobject, [name, @ohash.object(val)])
-        end
-      end
-
-      # extract any extgstate information
-      if resources[:ExtGState]
-        @ohash.object(resources[:ExtGState]).each do |name, val|
-          callback(:resource_extgstate, [name, @ohash.object(val)])
-        end
-      end
-
-      # extract any colorspace information
-      if resources[:ColorSpace]
-        @ohash.object(resources[:ColorSpace]).each do |name, val|
-          callback(:resource_colorspace, [name, @ohash.object(val)])
-        end
-      end
-
-      # extract any pattern information
-      if resources[:Pattern]
-        @ohash.object(resources[:Pattern]).each do |name, val|
-          callback(:resource_pattern, [name, @ohash.object(val)])
-        end
-      end
-
-      # extract any font information
-      if resources[:Font]
-        fonts = font_hash_from_resources(resources)
-        fonts.each do  |label, font|
-          callback(:resource_font, [label, font])
-        end
-      end
-    end
-    ################################################################################
-    # Convert any PDF::Reader::Resource objects into a real object
-    def resolve_references(obj)
-      case obj
-      when PDF::Reader::Stream then
-        obj.hash = resolve_references(obj.hash)
-        obj
-      when PDF::Reader::Reference then
-        resolve_references(@ohash.object(obj))
-      when Hash                   then
-        arr = obj.map { |key,val| [key, resolve_references(val)] }.flatten(1)
-        Hash[*arr]
-      when Array                  then
-        obj.collect { |item| resolve_references(item) }
-      else
-        obj
-      end
-    end
-    ################################################################################
-    ################################################################################
-    def font_hash_from_resources(resources)
-      return {} unless resources.respond_to?(:[])
-
-      fonts = {}
-      resources = @ohash.object(resources[:Font]) || {}
-      resources.each do |label, desc|
-        fonts[label] = PDF::Reader::Font.new(@ohash, @ohash.object(desc))
-      end
-      fonts
-    end
-    def resources
-      @resources ||= []
-    end
   end
   ################################################################################
 end

data/lib/pdf/reader/parser.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -118,6 +119,7 @@ class PDF::Reader
       loop do
         key = parse_token
         break if key.kind_of?(Token) and key == ">>"
+        raise MalformedPDFError, "unterminated dict" if @buffer.empty?
         raise MalformedPDFError, "Dictionary key (#{key.inspect}) is not a name" unless key.kind_of?(Symbol)
 
         value = parse_token
@@ -131,8 +133,7 @@ class PDF::Reader
     # reads a PDF name from the buffer and converts it to a Ruby Symbol
     def pdf_name
       tok = @buffer.token
-      tok = " " if tok == "" && RUBY_VERSION < "1.9"
-      tok.gsub!(/#([A-Fa-f0-9]{2})/) do |match|
+      tok = tok.dup.gsub(/#([A-Fa-f0-9]{2})/) do |match|
         match[1, 2].hex.chr
       end
       tok.to_sym
@@ -145,6 +146,7 @@ class PDF::Reader
       loop do
         item = parse_token
         break if item.kind_of?(Token) and item == "]"
+        raise MalformedPDFError, "unterminated array" if @buffer.empty?
         a << item
       end
 
@@ -153,29 +155,30 @@ class PDF::Reader
     ################################################################################
     # Reads a PDF hex string from the buffer and converts it to a Ruby String
     def hex_string
-      str = ""
+      str = "".dup
 
       loop do
         token = @buffer.token
         break if token == ">"
+        raise MalformedPDFError, "unterminated hex string" if @buffer.empty?
         str << token
       end
 
       # add a missing digit if required, as required by the spec
       str << "0" unless str.size % 2 == 0
-      str.scan(/../).map {|i| i.hex.chr}.join
+      str.scan(/../).map {|i| i.hex.chr}.join.force_encoding("binary")
     end
     ################################################################################
     # Reads a PDF String from the buffer and converts it to a Ruby String
     def string
       str = @buffer.token
-      return "" if str == ")"
+      return "".dup.force_encoding("binary") if str == ")"
       Error.assert_equal(parse_token, ")")
 
       str.gsub!(/\\([nrtbf()\\\n]|\d{1,3})?|\r\n?|\n\r/m) do |match|
-        MAPPING[match] || ""
+        MAPPING[match] || "".dup
       end
-      str
+      str.force_encoding("binary")
     end
 
     MAPPING = {

data/lib/pdf/reader/print_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 class PDF::Reader
   # A simple receiver that prints all operaters and parameters in the content

data/lib/pdf/reader/reference.rb

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

data/lib/pdf/reader/register_receiver.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 # Copyright (C) 2010 James Healy (jimmy@deefa.com)
 

data/lib/pdf/reader/resource_methods.rb

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

data/lib/pdf/reader/standard_security_handler.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 ################################################################################
 #
@@ -25,6 +26,7 @@
 #
 ################################################################################
 require 'digest/md5'
+require 'openssl'
 require 'rc4'
 
 class PDF::Reader
@@ -42,51 +44,83 @@ class PDF::Reader
                      0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80,
                      0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a ]
 
-    attr_reader :filter, :subFilter, :version, :key_length,
-                :crypt_filter, :stream_filter, :string_filter, :embedded_file_filter,
-                :encrypt_key
-    attr_reader :revision, :owner_key, :user_key, :permissions, :file_id, :password
-
-    def initialize( enc, file_id, password )
-      @filter        = enc[:Filter]
-      @subFilter     = enc[:SubFilter]
-      @version       = enc[:V].to_i
-      @key_length    = enc[:Length].to_i/8
-      @crypt_filter  = enc[:CF]
-      @stream_filter = enc[:StmF]
-      @string_filter = enc[:StrF]
-      @revision      = enc[:R].to_i
-      @owner_key     = enc[:O]
-      @user_key      = enc[:U]
-      @permissions   = enc[:P].to_i
-      @embedded_file_filter = enc[:EFF]
-
-      @encryptMeta   = enc.has_key?(:EncryptMetadata)? enc[:EncryptMetadata].to_s == "true" : true;
-
-      @file_id       = (file_id || []).first || ""
-
-      @encrypt_key   = build_standard_key(password)
+    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
+      @owner_key     = opts[:owner_key]
+      @user_key      = opts[:user_key]
+      @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\
+               encryption (#{@key_length * 8}bit)"
+        raise ArgumentError, 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 encrypted PDF streams (buf)
+    # 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 )
+      case @cfm
+        when :AESV2
+          decrypt_aes128(buf, ref)
+        else
+          decrypt_rc4(buf, ref)
+      end
+    end
+
+    private
+
+    # 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 = RC4.new( Digest::MD5.digest(objKey)[0,length] )
       rc4.decrypt(buf)
     end
 
-    private
+    # 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
 
     # Pads supplied password to 32bytes using PassPadBytes as specified on
     # pp61 of spec
@@ -94,7 +128,7 @@ class PDF::Reader
       if p.nil? || p.empty?
         PassPadBytes.pack('C*')
       else
-        p[(0...32)] + PassPadBytes[0...(32-p.length)].pack('C*')
+        p[0, 32] + PassPadBytes[0, 32-p.length].pack('C*')
       end
     end
 
@@ -118,13 +152,13 @@ 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)]
-        #first itteration decrypt owner_key
+        keyBegins = md5[0, key_length]
+        #first iteration decrypt owner_key
         out = @owner_key
-        #RC4 keyed with (keyBegins XOR with itteration #) to decrypt previous out
+        #RC4 keyed with (keyBegins XOR with iteration #) to decrypt previous out
         19.downto(0).each { |i| out=RC4.new(xor_each_byte(keyBegins,i)).decrypt(out) }
       else
-        out = RC4.new( md5[(0...5)] ).decrypt( @owner_key )
+        out = RC4.new( md5[0, 5] ).decrypt( @owner_key )
       end
       # c) check output as user password
       auth_user_pass( out )
@@ -142,12 +176,12 @@ class PDF::Reader
     #
     def auth_user_pass(pass)
       keyBegins = make_file_key(pass)
-      if @revision > 2
+      if @revision >= 3
         #initialize out for first iteration
         out = Digest::MD5.digest(PassPadBytes.pack("C*") + @file_id)
         #zero doesn't matter -> so from 0-19
-        20.times{ |i| out=RC4.new(xor_each_byte(keyBegins, i)).decrypt(out) }
-        pass = @user_key[(0...16)] == out
+        20.times{ |i| out=RC4.new(xor_each_byte(keyBegins, i)).encrypt(out) }
+        pass = @user_key[0, 16] == out
       else
         pass = RC4.new(keyBegins).encrypt(PassPadBytes.pack("C*")) == @user_key
       end
@@ -163,20 +197,24 @@ class PDF::Reader
       (0..24).step(8){|e| @buf << (@permissions >> e & 0xFF)}
       # e) add the file ID
       @buf << @file_id
-      # f) if revision > 4 then if encryptMetadata add 4 bytes of 0x00 else add 4 bytes of 0xFF
-      if @revision > 4
-        @buf << [ @encryptMetadata ? 0x00 : 0xFF ].pack('C')*4
+      # f) if revision >= 4 and metadata not encrypted then add 4 bytes of 0xFF
+      if @revision >= 4 && !@encryptMeta
+        @buf << [0xFF,0xFF,0xFF,0xFF].pack('C*')
       end
       # b) init MD5 digest + g) finish the hash
       md5 = Digest::MD5.digest(@buf)
       # h) spin hash 50 times
-      if @revision > 2
+      if @revision >= 3
         50.times {
-          md5 = Digest::MD5.digest(md5[(0...@key_length)])
+          md5 = Digest::MD5.digest(md5[0, @key_length])
         }
       end
-      # i) n = key_length revision > 3, n = 5 revision == 2
-      md5[(0...((@revision < 3) ? 5 : @key_length))]
+      # i) n = key_length revision >= 3, n = 5 revision == 2
+      if @revision < 3
+        md5[0, 5]
+      else
+        md5[0, @key_length]
+      end
     end
 
     def build_standard_key(pass)