pdf-reader 0.11.0.alpha → 0.12.0.alpha

data/lib/pdf/reader/glyphlist.txt

@@ -22,7 +22,7 @@
 # damages, whether based on tort (including without limitation negligence
 # or strict liability), contract or other legal or equitable grounds even
 # if Adobe has been advised or had reason to know of the possibility of
-# such damages.� The Adobe materials are provided on an "AS IS" basis.�
+# such damages. The Adobe materials are provided on an "AS IS" basis.
 # Adobe specifically disclaims all express, statutory, or implied
 # warranties relating to the Adobe materials, including but not limited to
 # those concerning merchantability or fitness for a particular purpose or

data/lib/pdf/reader/object_hash.rb

@@ -28,15 +28,17 @@ class PDF::Reader
   class ObjectHash
     include Enumerable
 
-    CACHEABLE_TYPES = [:Catalog, :Page, :Pages]
-
     attr_accessor :default
     attr_reader :trailer, :pdf_version
 
     # Creates a new ObjectHash object. input can be a string with a valid filename,
     # a string containing a PDF file, or an IO object.
     #
-    def initialize(input)
+    # valid options
+    #
+    #   :password - the user password to decrypt the source PDF
+    #
+    def initialize(input, opts = {})
       if input.respond_to?(:seek) && input.respond_to?(:read)
         @io = input
       elsif File.file?(input.to_s)
@@ -53,10 +55,7 @@ class PDF::Reader
       @xref        = PDF::Reader::XRef.new(@io)
       @trailer     = @xref.trailer
       @cache       = PDF::Reader::ObjectCache.new
-
-      if trailer[:Encrypt]
-        raise ::PDF::Reader::UnsupportedFeatureError, 'PDF::Reader cannot read encrypted PDF files'
-      end
+      @sec_handler = build_security_handler(opts)
     end
 
     # returns the type of object a ref points to
@@ -92,7 +91,7 @@ class PDF::Reader
           @cache[key]
         elsif xref[key].is_a?(Fixnum)
           buf = new_buffer(xref[key])
-          @cache[key] = Parser.new(buf, self).object(key.id, key.gen)
+          @cache[key] = decrypt(key, Parser.new(buf, self).object(key.id, key.gen))
         elsif xref[key].is_a?(PDF::Reader::Reference)
           container_key = xref[key]
           object_streams[container_key] ||= PDF::Reader::ObjectStream.new(object(container_key))
@@ -103,10 +102,6 @@ class PDF::Reader
       end
     end
 
-    def cacheable?(obj)
-      obj.is_a?(Hash) && CACHEABLE_TYPES.include?(obj[:Type])
-    end
-
     # If key is a PDF::Reader::Reference object, lookup the corresponding
     # object in the PDF and return it. Otherwise return key untouched.
     #
@@ -252,8 +247,43 @@ class PDF::Reader
       @page_references ||= get_page_objects(root[:Pages]).flatten
     end
 
+    def encrypted?
+      trailer.has_key?(:Encrypt)
+    end
+
     private
 
+    def build_security_handler(opts = {})
+      return nil if trailer[:Encrypt].nil?
+
+      enc = deref(trailer[:Encrypt])
+      case enc[:Filter]
+      when :Standard
+        StandardSecurityHandler.new(enc, deref(trailer[:ID]), opts[:password])
+      else
+        raise PDF::Reader::EncryptedPDFError, "Unsupported encryption method (#{enc[:Filter]})"
+      end
+    end
+
+    def decrypt(ref, obj)
+      return obj if @sec_handler.nil?
+
+      case obj
+      when PDF::Reader::Stream then
+        obj.data = @sec_handler.decrypt(obj.data, ref)
+        obj
+      when Hash                then
+        arr = obj.map { |key,val| [key, decrypt(ref, val)] }.flatten(1)
+        Hash[*arr]
+      when Array               then
+        obj.collect { |item| decrypt(ref, item) }
+      when String
+        @sec_handler.decrypt(obj, ref)
+      else
+        obj
+      end
+    end
+
     def new_buffer(offset = 0)
       PDF::Reader::Buffer.new(@io, :seek => offset)
     end

data/lib/pdf/reader/page.rb

@@ -63,27 +63,62 @@ module PDF
         @resources ||= @objects.deref(attributes[:Resources]) || {}
       end
 
-      # return a hash of fonts used on this page.
+      # Returns a Hash of color spaces that are available to this page
       #
-      # The keys are the font labels used within the page content stream.
-      #
-      # The values are a PDF::Reader::Font instances that provide access
-      # to most available metrics for each font.
+      def color_spaces
+        @objects.deref(resources[:ColorSpace]) || {}
+      end
+
+      # Returns a Hash of fonts that are available to this page
       #
       def fonts
-        raw_fonts = objects.deref(resources[:Font] || {})
-        ::Hash[raw_fonts.map { |label, font|
-          [label, PDF::Reader::Font.new(objects, objects.deref(font))]
-        }]
+        @objects.deref(resources[:Font]) || {}
+      end
+
+      # Returns a Hash of external graphic states that are available to this
+      # page
+      #
+      def graphic_states
+        @objects.deref(resources[:ExtGState]) || {}
+      end
+
+      # Returns a Hash of patterns that are available to this page
+      #
+      def patterns
+        @objects.deref(resources[:Pattern]) || {}
+      end
+
+      # Returns an Array of procedure sets that are available to this page
+      #
+      def procedure_sets
+        @objects.deref(resources[:ProcSet]) || []
+      end
+
+      # Returns a Hash of properties sets that are available to this page
+      #
+      def properties
+        @objects.deref(resources[:Properties]) || {}
+      end
+
+      # Returns a Hash of shadings that are available to this page
+      #
+      def shadings
+        @objects.deref(resources[:Shading]) || {}
+      end
+
+      # Returns a Hash of XObjects that are available to this page
+      #
+      def xobjects
+        @objects.deref(resources[:XObject]) || {}
       end
 
       # returns the plain text content of this page encoded as UTF-8. Any
       # characters that can't be translated will be returned as a ▯
       #
       def text
-        text_receiver = PageTextReceiver.new(fonts)
-        walk(text_receiver)
-        text_receiver.content
+        receiver = PageTextReceiver.new
+        walk(receiver)
+        receiver.content
       end
       alias :to_s :text
 
@@ -91,10 +126,25 @@ module PDF
       # passes callbacks to the receiver objects.
       #
       # This is mostly low level and you can probably ignore it unless you need
-      # access to soemthing like the raw encoded text. For an example of how
+      # access to something like the raw encoded text. For an example of how
       # this can be used as a basis for higher level functionality, see the
       # text() method
       #
+      # If someone was motivated enough, this method is intended to provide all
+      # the data required to faithfully render the entire page. If you find
+      # some required data isn't available it's a bug - let me know.
+      #
+      # Many operators that generate callbacks will reference resources stored
+      # in the page header - think images, fonts, etc. To facilitate these
+      # operators, the first available callback is page=. If your receiver
+      # accepts that callback it will be passed the current
+      # PDF::Reader::Page object. Use the Page#resources method to grab any
+      # required resources.
+      #
+      # It may help to think of each page as a self contained program made up of
+      # a set of instructions and associated resources. Calling walk() executes
+      # the program in the correct order and calls out to your implementation.
+      #
       def walk(*receivers)
         callback(receivers, :page=, [self])
         content_stream(receivers, raw_content)
@@ -118,10 +168,6 @@ module PDF
         root ||= objects.deref(@objects.trailer[:Root])
       end
 
-      def xobjects
-        resources[:XObject] || {}
-      end
-
       def content_stream(receivers, instructions)
         buffer       = Buffer.new(StringIO.new(instructions), :content_stream => true)
         parser       = Parser.new(buffer, @objects)

data/lib/pdf/reader/page_text_receiver.rb

@@ -1,6 +1,7 @@
 # coding: utf-8
 
 require 'matrix'
+require 'yaml'
 
 module PDF
   class Reader
@@ -19,10 +20,14 @@ module PDF
         :text_knockout => 0
       }
 
-      def initialize(fonts)
-        @fonts   = fonts
+      # starting a new page
+      def page=(page)
+        @page    = page
+        @objects = page.objects
+        @fonts   = build_fonts(page.fonts)
+        @form_fonts = {}
         @content = ::Hash.new
-        @stack = [DEFAULT_GRAPHICS_STATE]
+        @stack   = [DEFAULT_GRAPHICS_STATE]
       end
 
       def content
@@ -151,6 +156,7 @@ module PDF
 
       # record text that is drawn on the page
       def show_text(string) # Tj
+        raise PDF::Reader::MalformedPDFError, "current font is invalid" if current_font.nil?
         at = transform(Point.new(0,0))
         @content[at.y] ||= ""
         @content[at.y] << current_font.to_utf8(string)
@@ -178,8 +184,36 @@ module PDF
         move_to_next_line_and_show_text(string)
       end
 
+      #####################################################
+      # XObjects
+      #####################################################
+      def invoke_xobject(label)
+        save_graphics_state
+        xobject = @objects.deref(@page.xobjects[label])
+
+        matrix = xobject.hash[:Matrix]
+        concatenate_matrix(*matrix) if matrix
+
+        if xobject.hash[:Subtype] == :Form
+          form = PDF::Reader::FormXObject.new(@page, xobject)
+          @form_fonts = form.fonts
+          form.walk(self)
+        end
+        @form_fonts = {}
+
+        restore_graphics_state
+      end
+
       private
 
+      # wrap the raw PDF Font objects in handy ruby Font objects.
+      #
+      def build_fonts(raw_fonts)
+        ::Hash[raw_fonts.map { |label, font|
+          [label, PDF::Reader::Font.new(@objects, @objects.deref(font))]
+        }]
+      end
+
       # transform x and y co-ordinates from the current text space to the
       # underlying device space.
       #
@@ -231,7 +265,7 @@ module PDF
       end
 
       def current_font
-        @fonts[state[:text_font]]
+        @form_fonts[state[:text_font]] || @fonts[state[:text_font]]
       end
 
       # private class for representing points on a cartesian plain. Used

data/lib/pdf/reader/standard_security_handler.rb

@@ -0,0 +1,186 @@
+################################################################################
+#
+# 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 'rc4'
+
+class PDF::Reader
+
+  # class creates interface to encrypt dictionary for use in Decrypt
+  class StandardSecurityHandler
+
+    ## 7.6.3.3 Encryption Key Algorithm (pp61)
+    #
+    # needs a document's user password to build a key for decrypting an
+    # encrypted PDF document
+    #
+    PassPadBytes = [ 0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41,
+                     0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08,
+                     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)
+    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)
+    #
+    # buf - a string to decrypt
+    # ref - a PDF::Reader::Reference for the object to decrypt
+    #
+    def decrypt( 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 ) }
+      rc4 = RC4.new( Digest::MD5.digest(objKey) )
+      rc4.decrypt(buf)
+    end
+
+    private
+
+    # Pads supplied password to 32bytes using PassPadBytes as specified on
+    # pp61 of spec
+    def padPass(p="")
+      if p.nil? || p.empty?
+        PassPadBytes.pack('C*')
+      else
+        p[(0...32)] + PassPadBytes[0...(32-p.length)].pack('C*')
+      end
+    end
+
+    def xorEachByte(buf, int)
+      buf.each_byte.map{ |b| b^int}.pack("C*")
+    end
+
+    ## 7.6.3.4 Password Algorithms
+    #
+    # Algorithm 7 - Authenticating the Owner Password
+    #
+    # Used to test Owner passwords
+    #
+    # if the string is a valid owner password this will return the user
+    # password that should be used to decrypt the document.
+    #
+    # if the supplied password is not a valid owner password for this document
+    # then it returns nil
+    #
+    def authOwnerPass(pass)
+      md5 = Digest::MD5.digest(padPass(pass))
+      if @revision > 2 then
+        50.times { md5 = Digest::MD5.digest(md5) }
+        keyBegins = md5[(0...@key_length)]
+        #first itteration decrypt owner_key
+        out = @owner_key
+        #RC4 keyed with (keyBegins XOR with itteration #) to decrypt previous out
+        19.downto(0).each { |i| out=RC4.new(xorEachByte(keyBegins,i)).decrypt(out) }
+      else
+        out = RC4.new( md5[(0...5)] ).decrypt( @owner_key )
+      end
+      # c) check output as user password
+      authUserPass( out )
+    end
+
+    # Algorithm 6 - Authenticating the User Password
+    #
+    # Used to test User passwords
+    #
+    # if the string is a valid user password this will return the user
+    # password that should be used to decrypt the document.
+    #
+    # if the supplied password is not a valid user password for this document
+    # then it returns nil
+    #
+    def authUserPass(pass)
+      keyBegins = makeFileKey(pass)
+      if @revision > 2
+        #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(xorEachByte(keyBegins, i)).decrypt(out) }
+      else
+        out = RC4.new(keyBegins).encrypt(PassPadBytes.pack("C*"))
+      end
+      @user_key[(0...16)] == out ? keyBegins : nil
+    end
+
+    def makeFileKey( user_pass )
+      # a) if there's a password, pad it to 32 bytes, else, just use the padding.
+      @buf  = padPass(user_pass)
+      # c) add owner key
+      @buf << @owner_key
+      # d) add permissions 1 byte at a time, in little-endian order
+      (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
+      end
+      # b) init MD5 digest + g) finish the hash
+      md5 = Digest::MD5.digest(@buf)
+      # h) spin hash 50 times
+      if @revision > 2
+        50.times {
+          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))]
+    end
+
+    def build_standard_key(pass)
+      encrypt_key   = authOwnerPass(pass)
+      encrypt_key ||= authUserPass(pass)
+
+      raise PDF::Reader::EncryptedPDFError, "Invalid password (#{pass})" if encrypt_key.nil?
+      encrypt_key
+    end
+  end
+end