pdf-reader 1.1.1 → 2.5.0

data/lib/pdf/reader/parser.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -58,7 +61,7 @@ class PDF::Reader
     #
     # buffer - a PDF::Reader::Buffer object that contains PDF data
     # objects  - a PDF::Reader::ObjectHash object that can return objects from the PDF file
-    def initialize (buffer, objects=nil)
+    def initialize(buffer, objects=nil)
       @buffer = buffer
       @objects  = objects
     end
@@ -67,15 +70,13 @@ class PDF::Reader
     # object
     #
     # operators - a hash of supported operators to read from the underlying buffer.
-    def parse_token (operators={})
+    def parse_token(operators={})
       token = @buffer.token
 
       if STRATEGIES.has_key? token
         STRATEGIES[token].call(self, token)
       elsif token.is_a? PDF::Reader::Reference
         token
-      elsif token.is_a? Token
-        token
       elsif operators.has_key? token
         Token.new(token)
       elsif token.respond_to?(:to_token)
@@ -93,13 +94,14 @@ class PDF::Reader
     #
     # id  - the object ID to return
     # gen - the object revision number to return
-    def object (id, gen)
+    def object(id, gen)
       Error.assert_equal(parse_token, id)
       Error.assert_equal(parse_token, gen)
       Error.str_assert(parse_token, "obj")
 
       obj = parse_token
       post_obj = parse_token
+
       if post_obj == "stream"
         stream(obj)
       else
@@ -117,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
@@ -130,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
@@ -144,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
 
@@ -152,80 +155,53 @@ 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, ")")
 
-      ret = ""
-      idx = 0
-
-      while idx < str.size
-        chr = str[idx,1]
-        jump = 1
-
-        if chr == "\\"
-          jump = 2
-          case str[idx+1, 1]
-          when "" then jump = 1
-          when "n"  then chr = "\n"
-          when "r"  then chr = "\r"
-          when "t"  then chr = "\t"
-          when "b"  then chr = "\b"
-          when "f"  then chr = "\f"
-          when "("  then chr = "("
-          when ")"  then chr = ")"
-          when "\\" then chr = "\\"
-          when "\n" then
-            chr = ""
-            jump = 2
-          else
-            if str[idx+1,3].match(/\d{3}/)
-              jump = 4
-              chr = str[idx+1,3].oct.chr
-            elsif str[idx+1,2].match(/\d{2}/)
-              jump = 3
-              chr = ("0"+str[idx+1,2]).oct.chr
-            elsif str[idx+1,1].match(/\d/)
-              jump = 2
-              chr = ("00"+str[idx+1,1]).oct.chr
-            else
-              jump = 1
-              chr = ""
-            end
-
-          end
-        elsif chr == "\r" && str[idx+1,1] == "\n"
-          chr = "\n"
-          jump = 2
-        elsif chr == "\n" && str[idx+1,1] == "\r"
-          chr = "\n"
-          jump = 2
-        elsif chr == "\r"
-          chr = "\n"
-        end
-        ret << chr
-        idx += jump
+      str.gsub!(/\\([nrtbf()\\\n]|\d{1,3})?|\r\n?|\n\r/m) do |match|
+        MAPPING[match] || "".dup
       end
-      ret
+      str.force_encoding("binary")
     end
+
+    MAPPING = {
+      "\r"   => "\n",
+      "\n\r" => "\n",
+      "\r\n" => "\n",
+      "\\n"  => "\n",
+      "\\r"  => "\r",
+      "\\t"  => "\t",
+      "\\b"  => "\b",
+      "\\f"  => "\f",
+      "\\("  => "(",
+      "\\)"  => ")",
+      "\\\\" => "\\",
+      "\\\n" => "",
+    }
+    0.upto(9)   { |n| MAPPING["\\00"+n.to_s] = ("00"+n.to_s).oct.chr }
+    0.upto(99)  { |n| MAPPING["\\0"+n.to_s]  = ("0"+n.to_s).oct.chr }
+    0.upto(377) { |n| MAPPING["\\"+n.to_s]   = n.to_s.oct.chr }
+
     ################################################################################
     # Decodes the contents of a PDF Stream and returns it as a Ruby String.
-    def stream (dict)
+    def stream(dict)
       raise MalformedPDFError, "PDF malformed, missing stream length" unless dict.has_key?(:Length)
       if @objects
         length = @objects.deref(dict[:Length])

data/lib/pdf/reader/print_receiver.rb

@@ -1,4 +1,10 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 class PDF::Reader
+  # A simple receiver that prints all operaters and parameters in the content
+  # stream of a single page.
+  #
   class PrintReceiver
 
     attr_accessor :callbacks

data/lib/pdf/reader/reference.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2006 Peter J Jones (pjones@pmade.com)
@@ -30,7 +33,7 @@ class PDF::Reader
     attr_reader :id, :gen
     ################################################################################
     # Create a new Reference to an object with the specified id and revision number
-    def initialize (id, gen)
+    def initialize(id, gen)
       @id, @gen = id, gen
     end
     ################################################################################

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)
 
@@ -11,10 +12,12 @@ class PDF::Reader
   #
   # Usage:
   #
-  #  receiver = PDF::Reader::RegisterReceiver.new
-  #  PDF::Reader.file("somefile.pdf", receiver)
-  #  callback = receiver.first_occurance_of(:show_text)
-  #  callback[:args].first.should == "Hellow World"
+  #     PDF::Reader.open("somefile.pdf") do |reader|
+  #       receiver = PDF::Reader::RegisterReceiver.new
+  #       reader.page(1).walk(receiver)
+  #       callback = receiver.first_occurance_of(:show_text)
+  #       callback[:args].first.should == "Hellow World"
+  #     end
   #
   class RegisterReceiver
 
@@ -34,18 +37,12 @@ class PDF::Reader
 
     # count the number of times a callback fired
     def count(methodname)
-      counter = 0
-      callbacks.each { |cb| counter += 1 if cb[:name] == methodname}
-      return counter
+      callbacks.count { |cb| cb[:name] == methodname}
     end
 
     # return the details for every time the specified callback was fired
     def all(methodname)
-      ret = []
-      callbacks.each do |cb|
-        ret << cb if cb[:name] == methodname
-      end
-      return ret
+      callbacks.select { |cb| cb[:name] == methodname }
     end
 
     def all_args(methodname)
@@ -54,42 +51,31 @@ class PDF::Reader
 
     # return the details for the first time the specified callback was fired
     def first_occurance_of(methodname)
-      callbacks.each do |cb|
-        return cb if cb[:name] == methodname
-      end
-      return nil
+      callbacks.find { |cb| cb[:name] == methodname }
     end
 
     # return the details for the final time the specified callback was fired
     def final_occurance_of(methodname)
-      returnme = nil
-      callbacks.each do |cb|
-        returnme = cb if cb[:name] == methodname
-      end
-      return returnme
+      all(methodname).last
     end
 
     # return the first occurance of a particular series of callbacks
     def series(*methods)
       return nil if methods.empty?
 
-      indexes = (0..(callbacks.size-1-methods.size))
+      indexes = (0..(callbacks.size-1))
       method_indexes = (0..(methods.size-1))
-      match = nil
 
       indexes.each do |idx|
         count = methods.size
         method_indexes.each do |midx|
-          count -= 1 if callbacks[idx+midx][:name] == methods[midx]
+          count -= 1 if callbacks[idx+midx] && callbacks[idx+midx][:name] == methods[midx]
+        end
+        if count == 0
+          return callbacks[idx, methods.size]
         end
-        match = idx and break if count == 0
-      end
-
-      if match 
-        return callbacks[match, methods.size]
-      else
-        return nil
       end
+      nil
     end
   end
 end

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,3 +1,6 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 ################################################################################
 #
 # Copyright (C) 2011 Evan J Brunner (ejbrun@appittome.com)
@@ -23,6 +26,7 @@
 #
 ################################################################################
 require 'digest/md5'
+require 'openssl'
 require 'rc4'
 
 class PDF::Reader
@@ -40,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
@@ -92,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
 
@@ -116,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 )
@@ -140,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
@@ -161,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)