pdf-reader 2.15.0 → 2.16.0

data/lib/pdf/reader/parser.rb

@@ -34,6 +34,7 @@ class PDF::Reader
   class Parser
 
     TOKEN_STRATEGY = proc { |parser, token| Token.new(token) } #: Proc
+    INTERNED_TOKENS = {} #: Hash[String, PDF::Reader::Token]
 
     STRATEGIES = {
       "/"  => proc { |parser, token| parser.send(:pdf_name) },
@@ -62,17 +63,28 @@ 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
-    #: (PDF::Reader::Buffer, ?PDF::Reader::ObjectHash?) -> void
-    def initialize(buffer, objects=nil)
+    # operators - a hash of supported operators to read from the underlying buffer.
+    # relaxed_dictionaries - quietly skip unexpected operator tokens inside a dictionary. Useful for
+    #                        handling Postscript dictionaries in CMaps
+    #
+    #: (
+    #|   PDF::Reader::Buffer,
+    #|   ?operators: Hash[String | PDF::Reader::Token, Symbol],
+    #|   ?objects: PDF::Reader::ObjectHash?,
+    #|   ?relaxed_dictionaries: T::Boolean
+    #| ) -> void
+    def initialize(buffer, operators: {}, objects: nil, relaxed_dictionaries: false)
       @buffer = buffer
+      @operators = operators
       @objects  = objects
+      @relaxed_dictionaries = relaxed_dictionaries
+      @hex_pack_buffer = [""] #: Array[String]
     end
     ################################################################################
     # Reads the next token from the underlying buffer and convets it to an appropriate
     # object
     #
-    # operators - a hash of supported operators to read from the underlying buffer.
-    #: (?Hash[String | PDF::Reader::Token, Symbol]) -> (
+    #: () -> (
     #|   PDF::Reader::Reference |
     #|   PDF::Reader::Token |
     #|   Numeric |
@@ -82,7 +94,7 @@ class PDF::Reader
     #|   Hash[untyped, untyped] |
     #|   nil
     #| )
-    def parse_token(operators={})
+    def parse_token
       token = @buffer.token
 
       if token.nil?
@@ -92,11 +104,11 @@ class PDF::Reader
         proc.call(self, token) if proc
       elsif token.is_a? PDF::Reader::Reference
         token
-      elsif operators.has_key? token
-        Token.new(token)
+      elsif @operators.has_key? token
+        INTERNED_TOKENS[token] ||= Token.new(token)
       elsif token.frozen?
         token
-      elsif token =~ /\d*\.\d/
+      elsif match?(token, /\d*\.\d/)
         token.to_f
       else
         token.to_i
@@ -143,6 +155,18 @@ class PDF::Reader
 
     private
 
+    # Once min ruby version is >= 2.4, we can drop this method and just use String#match?
+    #
+    #: (String, Regexp) -> bool
+    def match?(str, regexp)
+      # We prefer match? because fewer objects are allocated, and this code path is hot
+      if str.respond_to?(:match?)
+        str.match?(regexp)
+      else
+        str.match(regexp) != nil
+      end
+    end
+
     ################################################################################
     # reads a PDF dict from the buffer and converts it to a Ruby Hash.
     #: () -> Hash[Symbol, untyped]
@@ -152,6 +176,11 @@ class PDF::Reader
       loop do
         key = parse_token
         break if key.kind_of?(Token) and key == ">>"
+
+        # Skip operator tokens (e.g. PostScript "def") that appear inside
+        # dictionary blocks in CMap streams parsed with operator keywords.
+        next if @relaxed_dictionaries && key.kind_of?(Token)
+
         raise MalformedPDFError, "unterminated dict" if @buffer.empty?
         PDF::Reader::Error.validate_type_as_malformed(key, "Dictionary key", Symbol)
 
@@ -169,9 +198,11 @@ class PDF::Reader
       tok = @buffer.token
 
       if tok.is_a?(String)
-        tok = tok.dup.gsub(/#([A-Fa-f0-9]{2})/) do |match|
-          res = match[1, 2]
-          res ? res.hex.chr : ""
+        if tok.include?('#')
+          tok = tok.gsub(/#([A-Fa-f0-9]{2})/) do |match|
+            res = match[1, 2]
+            res ? res.hex.chr : ""
+          end
         end
         tok.to_sym
       elsif tok.is_a?(PDF::Reader::Reference)
@@ -199,18 +230,21 @@ class PDF::Reader
     # Reads a PDF hex string from the buffer and converts it to a Ruby String
     #: () -> String
     def hex_string
-      str = "".dup
+      str = @buffer.token
 
-      loop do
-        token = @buffer.token
-        break if token == ">"
-        raise MalformedPDFError, "unterminated hex string" if @buffer.empty?
-        str << token
+      if str == ">"
+        # empty hex string
+        return "".dup.force_encoding("binary")
       end
 
+      raise MalformedPDFError, "unterminated hex string" if str.nil? || @buffer.empty?
+      raise MalformedPDFError, "invalid hex string" unless str.is_a?(String)
+      @buffer.token # consume the closing ">"
+
       # add a missing digit if required, as required by the spec
       str << "0" unless str.size % 2 == 0
-      [str].pack('H*')
+      @hex_pack_buffer[0] = str
+      @hex_pack_buffer.pack('H*')
     end
     ################################################################################
     # Reads a PDF String from the buffer and converts it to a Ruby String

data/lib/pdf/reader/point.rb

@@ -27,6 +27,12 @@ module PDF
         other.respond_to?(:x) && other.respond_to?(:y) && x == other.x && y == other.y
       end
 
+      # These two points are super common, so make them available as constants to reduce
+      # object allocations. Points are immutable, so it's fine to have multiple code paths
+      # using the same object
+      ZERO_ZERO = self.new(0, 0) #: PDF::Reader::Point
+      ONE_ONE = self.new(1, 1) #: PDF::Reader::Point
+
     end
   end
 end

data/lib/pdf/reader/rc4.rb

@@ -0,0 +1,43 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+  # A minimal, self-contained implementation of the RC4 stream cipher, used to decrypt
+  # PDFs encrypted with the (legacy, but still spec-compliant) RC4 security handler.
+  # Vendored directly to avoid depending on the abandoned ruby-rc4 gem (last released
+  # 2012, archived since 2020, and missing license metadata in its gemspec).
+  class Rc4 # :nodoc:
+    #: (String) -> void
+    def initialize(key)
+      raise ArgumentError, "key must not be empty" if key.empty?
+
+      @key = key.bytes #: Array[Integer]
+      @s = (0..255).to_a #: Array[Integer]
+      j = 0
+      256.times do |i|
+        j = (j + @s.fetch(i) + @key.fetch(i % @key.length)) & 0xFF
+        @s[i], @s[j] = @s.fetch(j), @s.fetch(i)
+      end
+      @i = 0 #: Integer
+      @j = 0 #: Integer
+    end
+
+    # RC4 encryption and decryption are the same operation (XOR with the keystream).
+    #: (String) -> String
+    def decrypt(data)
+      out = "".b
+      data = data.dup.force_encoding(::Encoding::ASCII_8BIT)
+      data.each_byte do |byte|
+        @i = (@i + 1) & 0xFF
+        @j = (@j + @s.fetch(@i)) & 0xFF
+        @s[@i], @s[@j] = @s.fetch(@j), @s.fetch(@i)
+        k = @s.fetch((@s.fetch(@i) + @s.fetch(@j)) & 0xFF)
+        out << (byte ^ k)
+      end
+      out
+    end
+
+    alias_method :encrypt, :decrypt
+  end
+end

data/lib/pdf/reader/rc4_security_handler.rb

@@ -3,7 +3,7 @@
 # frozen_string_literal: true
 
 require 'digest/md5'
-require 'rc4'
+require 'pdf/reader/rc4'
 
 class PDF::Reader
 
@@ -32,7 +32,7 @@ class PDF::Reader
       (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
 

data/lib/pdf/reader/rectangle.rb

@@ -70,10 +70,21 @@ module PDF
         bottom_right.x - bottom_left.x
       end
 
+      # Is the point inside this rectangle? Nicer to read and use than contains_xy?(), but
+      # allocates more objects so be careful using on hot code paths.
+      #
       #: (PDF::Reader::Point) -> bool
       def contains?(point)
-        point.x >= bottom_left.x && point.x <= top_right.x &&
-          point.y >= bottom_left.y && point.y <= top_right.y
+        contains_xy?(point.x, point.y)
+      end
+
+      # Is the point inside this rectangle? Worse to read and use than contains?(), but
+      # allocates fewer objects so may be preferrable on hot code paths.
+      #
+      #: (Numeric, Numeric) -> bool
+      def contains_xy?(x, y)
+        x >= bottom_left.x && x <= top_right.x &&
+          y >= bottom_left.y && y <= top_right.y
       end
 
       # A pdf-style 4-number array

data/lib/pdf/reader/reference.rb

@@ -71,7 +71,7 @@ class PDF::Reader
     # return an identical hash
     #: () -> Integer
     def hash
-      "#{self.id}:#{self.gen}".hash
+      (id << 16) ^ gen
     end
     ################################################################################
   end

data/lib/pdf/reader/standard_key_builder.rb

@@ -2,7 +2,7 @@
 # typed: strict
 
 require 'digest/md5'
-require 'rc4'
+require 'pdf/reader/rc4'
 
 class PDF::Reader
 
@@ -91,22 +91,21 @@ class PDF::Reader
     #
     #: (String) -> String?
     def auth_owner_pass(pass)
+      owner_key = @owner_key
+      raise MalformedPDFError, "encrypted PDF is missing an owner key" if owner_key.nil?
+
       md5 = Digest::MD5.digest(pad_pass(pass))
       if @revision > 2 then
         50.times { md5 = Digest::MD5.digest(md5) }
         keyBegins = md5[0, @key_length]
         #first iteration decrypt owner_key
-        out = @owner_key
+        out = owner_key
         #RC4 keyed with (keyBegins XOR with iteration #) to decrypt previous out
         19.downto(0).each { |i|
-          # The RC4 gem doen't have type annotations, so the type checker doesn't
-          # know decrypt() returns a string
-          out = TypeCheck.cast_to_string!(
-            RC4.new(xor_each_byte(keyBegins,i)).decrypt(out)
-          )
+          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 )
@@ -129,10 +128,10 @@ class PDF::Reader
         #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)).encrypt(out) }
+        20.times{ |i| out=Rc4.new(xor_each_byte(keyBegins, i)).encrypt(out) }
         pass = @user_key.to_s[0, 16] == out
       else
-        pass = RC4.new(keyBegins).encrypt(PassPadBytes.pack("C*")) == @user_key
+        pass = Rc4.new(keyBegins).encrypt(PassPadBytes.pack("C*")) == @user_key
       end
       pass ? keyBegins : nil
     end

data/lib/pdf/reader/text_run.rb

@@ -7,9 +7,6 @@ class PDF::Reader
   class TextRun
     include Comparable
 
-    #: PDF::Reader::Point
-    attr_reader :origin
-
     #: Numeric
     attr_reader :width
 
@@ -23,15 +20,23 @@ class PDF::Reader
 
     #: (Numeric, Numeric, Numeric, Numeric, String) -> void
     def initialize(x, y, width, font_size, text)
-      @origin = PDF::Reader::Point.new(x, y) #: PDF::Reader::Point
+      @x = x #: Numeric
+      @y = y #: Numeric
       @width = width
       @font_size = font_size
       @text = text
+      @origin = nil #: PDF::Reader::Point | nil
       @endx = nil #: Numeric | nil
       @endy = nil #: Numeric | nil
       @mergable_range = nil #: Range[Numeric] | nil
     end
 
+    # Lazily constructed to avoid allocating a Point on every TextRun
+    #: () -> PDF::Reader::Point
+    def origin
+      @origin ||= PDF::Reader::Point.new(@x, @y)
+    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
     #: (PDF::Reader::Point) -> Numeric
@@ -53,22 +58,22 @@ class PDF::Reader
 
     #: () -> Numeric
     def x
-      @origin.x
+      @x
     end
 
     #: () -> Numeric
     def y
-      @origin.y
+      @y
     end
 
     #: () -> Numeric
     def endx
-      @endx ||= @origin.x + width
+      @endx ||= @x + width
     end
 
     #: () -> Numeric
     def endy
-      @endy ||= @origin.y + font_size
+      @endy ||= @y + font_size
     end
 
     #: () -> Numeric

data/lib/pdf/reader/transformation_matrix.rb

@@ -54,6 +54,17 @@ class PDF::Reader
        @e,@f,1]
     end
 
+    # Apply a left-multiplication by a translation matrix [1, 0, 0, 1, tx, ty]
+    # without allocating a new TransformationMatrix.
+    #
+    #: (Numeric, Numeric) -> void
+    def prepend_translation!(tx, ty)
+      new_e = (tx * @a) + (ty * @c) + @e
+      new_f = (tx * @b) + (ty * @d) + @f
+      @e = new_e
+      @f = new_f
+    end
+
     # multiply this matrix with another.
     #
     # the second matrix is represented by the 6 scalar values that are changeable

data/lib/pdf/reader/type_check.rb

@@ -50,7 +50,7 @@ module PDF
         end
       end
 
-      #: (untyped) -> Symbol | nil
+      #: (untyped) -> (Symbol | nil)
       def self.cast_to_symbol(obj)
         if obj.is_a?(Symbol)
           obj

data/lib/pdf/reader/xref.rb

@@ -151,14 +151,17 @@ class PDF::Reader
           end
 
           objid, count = params[0].to_i, params[1].to_i
-          count.times do
+          count.times do |entry_index|
             offset = buf.token.to_i
             generation = buf.token.to_i
             state = buf.token
 
             # Some PDF writers start numbering at 1 instead of 0. Fix up the number.
-            # TODO should this fix be logged?
-            objid = 0 if objid == 1 and offset == 0 and generation == 65535 and state == 'f'
+            # Only apply this on the first entry of the section - if entry_index > 0,
+            # objid has been incremented from 0 and object 1 is a legitimate free entry.
+            if entry_index == 0 and objid == 1 and offset == 0 and generation == 65535 and state == 'f'
+              objid = 0
+            end
             store(objid, generation, offset + @junk_offset) if state == "n" && offset > 0
             objid += 1
             params.clear

data/lib/pdf/reader.rb

@@ -130,7 +130,7 @@ module PDF
     #: () -> Hash[untyped, untyped]?
     def info
       dict = @objects.deref_hash(@objects.trailer[:Info]) || {}
-      doc_strings_to_utf8(dict)
+      EncodingUtils.obj_to_utf8(dict)
     end
 
     # Return a String with extra XML metadata provided by the author of the PDF file. Not
@@ -234,58 +234,6 @@ module PDF
 
     private
 
-    # recursively convert strings from outside a content stream into UTF-8
-    #
-    #: (untyped) -> untyped
-    def doc_strings_to_utf8(obj)
-      case obj
-      when ::Hash then
-        {}.tap { |new_hash|
-          obj.each do |key, value|
-            new_hash[key] = doc_strings_to_utf8(value)
-          end
-        }
-      when Array then
-        obj.map { |item| doc_strings_to_utf8(item) }
-      when String then
-        if has_utf16_bom?(obj)
-          utf16_to_utf8(obj)
-        else
-          pdfdoc_to_utf8(obj)
-        end
-      else
-        obj
-      end
-    end
-
-    #: (String) -> bool
-    def has_utf16_bom?(str)
-      first_bytes = str[0,2]
-
-      return false if first_bytes.nil?
-
-      first_bytes.unpack("C*") == [254, 255]
-    end
-
-    # TODO find a PDF I can use to spec this behaviour
-    #
-    #: (String) -> String
-    def pdfdoc_to_utf8(obj)
-      obj.force_encoding("utf-8")
-      obj
-    end
-
-    # one day we'll all run on a 1.9 compatible VM and I can just do this with
-    # String#encode
-    #
-    #: (String) -> String
-    def utf16_to_utf8(obj)
-      str = obj[2, obj.size].to_s
-      str = str.unpack("n*").pack("U*")
-      str.force_encoding("utf-8")
-      str
-    end
-
     #: () -> Hash[Symbol, untyped]
     def root
       @root ||= @objects.deref_hash(@objects.trailer[:Root]) || {}
@@ -302,6 +250,7 @@ require 'pdf/reader/bounding_rectangle_runs_filter'
 require 'pdf/reader/cid_widths'
 require 'pdf/reader/cmap'
 require 'pdf/reader/encoding'
+require 'pdf/reader/encoding_utils'
 require 'pdf/reader/error'
 require 'pdf/reader/filter'
 require 'pdf/reader/filter/ascii85'
@@ -333,6 +282,7 @@ require 'pdf/reader/standard_key_builder'
 require 'pdf/reader/key_builder_v5'
 require 'pdf/reader/aes_v2_security_handler'
 require 'pdf/reader/aes_v3_security_handler'
+require 'pdf/reader/rc4'
 require 'pdf/reader/rc4_security_handler'
 require 'pdf/reader/unimplemented_security_handler'
 require 'pdf/reader/stream'