pdf-reader 2.15.1 → 2.16.0

data/lib/pdf/reader/form_xobject.rb

@@ -103,9 +103,12 @@ module PDF
       def tokens
         @cache[cached_tokens_key] ||= begin
                       buffer = Buffer.new(StringIO.new(raw_content), :content_stream => true)
-                      parser = Parser.new(buffer, @objects)
+                      parser = Parser.new(
+                        buffer,
+                        operators: PagesStrategy::OPERATORS, objects: @objects
+                      )
                       result = []
-                      while (token = parser.parse_token(PagesStrategy::OPERATORS))
+                      while (token = parser.parse_token)
                         result << token
                       end
                       result

data/lib/pdf/reader/key_builder_v5.rb

@@ -3,7 +3,6 @@
 # frozen_string_literal: true
 
 require 'digest/md5'
-require 'rc4'
 
 class PDF::Reader
 

data/lib/pdf/reader/object_cache.rb

@@ -17,18 +17,18 @@ class PDF::Reader
     # avoid lots of repetitive (and expensive) tokenising
     CACHEABLE_TYPES = [:Catalog, :Page, :Pages] #: Array[Symbol]
 
-    #: untyped
+    #: Integer
     attr_reader :hits
 
-    #: untyped
+    #: Integer
     attr_reader :misses
 
     #: (?untyped) -> void
     def initialize(lru_size = 1000)
-      @objects = {}
-      @lru_cache = Hashery::LRUHash.new(lru_size.to_i)
-      @hits = 0
-      @misses = 0
+      @objects = {} #: Hash[untyped, untyped]
+      @lru_cache = Hashery::LRUHash.new(lru_size.to_i) #: Hashery::LRUHash
+      @hits = 0 #: Integer
+      @misses = 0 #: Integer
     end
 
     def [](key)
@@ -46,7 +46,7 @@ class PDF::Reader
 
     def fetch(key, local_default = nil)
       update_stats(key)
-      @objects[key] || @lru_cache.fetch(key, local_default)
+      @objects[key] || @lru_cache.fetch(key) { local_default }
     end
 
     def each(&block)
@@ -85,14 +85,17 @@ class PDF::Reader
       @objects.has_value?(value) || @lru_cache.has_value?(value)
     end
 
+    #: () -> String
     def to_s
       "<PDF::Reader::ObjectCache size: #{self.size}>"
     end
 
+    #: () -> Array[untyped]
     def keys
       @objects.keys + @lru_cache.keys
     end
 
+    #: () -> Array[untyped]
     def values
       @objects.values + @lru_cache.values
     end
@@ -107,6 +110,7 @@ class PDF::Reader
       end
     end
 
+    #: (untyped) -> bool?
     def cacheable?(obj)
       obj.is_a?(Hash) && CACHEABLE_TYPES.include?(obj[:Type])
     end

data/lib/pdf/reader/object_hash.rb

@@ -59,9 +59,9 @@ class PDF::Reader
     #
     #   :password - the user password to decrypt the source PDF
     #
-    #: ((IO | Tempfile | StringIO | String), ?Hash[Symbol, untyped]) -> void
+    #: (untyped, ?Hash[Symbol, untyped]) -> void
     def initialize(input, opts = {})
-      @io          = extract_io_from(input) #: IO | Tempfile | StringIO
+      @io          = extract_io_from(input) #: untyped
       @xref        = PDF::Reader::XRef.new(@io) #: PDF::Reader::XRef[PDF::Reader::Reference]
       @pdf_version = read_version #: Float
       @trailer     = @xref.trailer #: Hash[Symbol, untyped]
@@ -127,6 +127,7 @@ class PDF::Reader
     # Guaranteed to only return an Array or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting an Array and no other type will do.
+    #
     #: (untyped) -> Array[untyped]?
     def deref_array(key)
       obj = deref(key)
@@ -146,6 +147,7 @@ class PDF::Reader
     # expecting an Array and no other type will do.
     #
     # Some effort to cast array elements to a number is made for any non-numeric elements.
+    #
     #: (untyped) -> Array[Numeric]?
     def deref_array_of_numbers(key)
       arr = deref(key)
@@ -172,7 +174,8 @@ class PDF::Reader
     #
     # Guaranteed to only return a Hash or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
-    # expecting an Array and no other type will do.
+    # expecting a Hash and no other type will do.
+    #
     #: (untyped) -> Hash[Symbol, untyped]?
     def deref_hash(key)
       obj = deref(key)
@@ -189,9 +192,10 @@ class PDF::Reader
     #
     # Guaranteed to only return a PDF name (Symbol) or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
-    # expecting an Array and no other type will do.
+    # expecting a PDF Name and no other type will do.
     #
     # Some effort to cast to a symbol is made when the reference points to a non-symbol.
+    #
     #: (untyped) -> Symbol?
     def deref_name(key)
       obj = deref(key)
@@ -214,7 +218,7 @@ class PDF::Reader
     #
     # Guaranteed to only return an Integer or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
-    # expecting an Array and no other type will do.
+    # expecting an Integer and no other type will do.
     #
     # Some effort to cast to an int is made when the reference points to a non-integer.
     #: (untyped) -> Integer?
@@ -239,7 +243,7 @@ class PDF::Reader
     #
     # Guaranteed to only return a Numeric or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
-    # expecting an Array and no other type will do.
+    # expecting a Number and no other type will do.
     #
     # Some effort to cast to a number is made when the reference points to a non-number.
     #: (untyped) -> Numeric?
@@ -267,6 +271,7 @@ class PDF::Reader
     # Guaranteed to only return a PDF::Reader::Stream or nil. If the dereference results in
     # any other type then a MalformedPDFError exception will raise. Useful when
     # expecting a stream and no other type will do.
+    #
     #: (untyped) -> PDF::Reader::Stream?
     def deref_stream(key)
       obj = deref(key)
@@ -553,7 +558,7 @@ class PDF::Reader
     def fetch_object(key)
       if xref[key].is_a?(Integer)
         buf = new_buffer(xref[key])
-        decrypt(key, Parser.new(buf, self).object(key.id, key.gen))
+        decrypt(key, Parser.new(buf, objects: self).object(key.id, key.gen))
       end
     end
 
@@ -703,9 +708,9 @@ class PDF::Reader
       version.to_f
     end
 
-    #: (IO | Tempfile | StringIO | String) -> (IO | Tempfile | StringIO)
+    #: (untyped) -> untyped
     def extract_io_from(input)
-      if input.is_a?(IO) || input.is_a?(StringIO) || input.is_a?(Tempfile)
+      if input.respond_to?(:read) && input.respond_to?(:seek)
         input
       elsif File.file?(input.to_s)
         StringIO.new read_as_binary(input.to_s)

data/lib/pdf/reader/page.rb

@@ -274,10 +274,10 @@ module PDF
       #: (Array[untyped], String) -> void
       def content_stream(receivers, instructions)
         buffer       = Buffer.new(StringIO.new(instructions), :content_stream => true)
-        parser       = Parser.new(buffer, @objects)
+        parser       = Parser.new(buffer, operators: PagesStrategy::OPERATORS, objects: @objects)
         params       = []
 
-        while (token = parser.parse_token(PagesStrategy::OPERATORS))
+        while (token = parser.parse_token)
           if token.kind_of?(Token) && method_name = PagesStrategy::OPERATORS[token]
             callback(receivers, method_name, params)
             params.clear

data/lib/pdf/reader/page_layout.rb

@@ -122,7 +122,7 @@ class PDF::Reader
 
     #: (untyped, untyped, untyped) -> untyped
     def local_string_insert(haystack, needle, index)
-      haystack[Range.new(index, index + needle.length - 1)] = String.new(needle)
+      haystack[index, needle.length] = needle
     end
 
     #: (untyped) -> untyped

data/lib/pdf/reader/page_state.rb

@@ -119,9 +119,9 @@ class PDF::Reader
 
       def font_size
         @font_size ||= begin
-                         _, zero = trm_transform(0,0)
-                         _, one  = trm_transform(1,1)
-                         (zero - one).abs.round(10)
+                         bl = trm_transform_point(Point::ZERO_ZERO)
+                         tr = trm_transform_point(Point::ONE_ONE)
+                         (bl.y - tr.y).abs.round(10)
                        end
       end
 
@@ -146,14 +146,7 @@ class PDF::Reader
       #####################################################
 
       def move_text_position(x, y) # Td
-        temp = TransformationMatrix.new(1, 0,
-                                        0, 1,
-                                        x, y)
-        @text_line_matrix = temp.multiply!(
-          @text_line_matrix.a, @text_line_matrix.b,
-          @text_line_matrix.c, @text_line_matrix.d,
-          @text_line_matrix.e, @text_line_matrix.f
-        )
+        @text_line_matrix.prepend_translation!(x, y)
         @text_matrix = @text_line_matrix.dup
         @font_size = @text_rendering_matrix = nil # invalidate cached value
       end
@@ -227,28 +220,83 @@ class PDF::Reader
       # transform x and y co-ordinates from the current user space to the
       # underlying device space.
       #
+      # Deprecated. Prefer ctm_transform_point()
+      #
+      #: (Numeric, Numeric) -> [Numeric]
       def ctm_transform(x, y)
+        # TODO print a deprecation warning
+        res = ctm_transform_point(x, y)
         [
-          (ctm.a * x) + (ctm.c * y) + (ctm.e),
-          (ctm.b * x) + (ctm.d * y) + (ctm.f)
+          res.x,
+          res.y
         ]
       end
 
+      # transform x and y co-ordinates from the current user space to the
+      # underlying device space.
+      #
+      # Recommended usage:
+      #
+      #     ctm_transform_point(Point.new(0,1))
+      #
+      # Also supported:
+      #
+      #     ctm_transform_point(0,1)
+      #
+      #: (PDF::Reader::Point | Numeric, ?Numeric) -> PDF::Reader::Point
+      def ctm_transform_point(pt, opt_y = -1)
+        unless pt.is_a?(Point)
+          pt = Point.new(pt.to_i, opt_y.to_i)
+        end
+        Point.new(
+          (ctm.a * pt.x) + (ctm.c * pt.y) + (ctm.e),
+          (ctm.b * pt.x) + (ctm.d * pt.y) + (ctm.f)
+        )
+      end
+
       # transform x and y co-ordinates from the current text space to the
       # underlying device space.
       #
+      # Deprecated. Prefer trm_transform_point()
+      #
+      #: (Numeric, Numeric) -> Array[Numeric]
+      def trm_transform(x, y)
+        # TODO print a deprecation warning
+        res = trm_transform_point(x, y)
+        [
+          res.x,
+          res.y
+        ]
+      end
+
+      # transform x and y co-ordinates from the current text space to the
+      # underlying device space.
+      #
+      # Recommended usage:
+      #
+      #     trm_transform_point(Point.new(0,1))
+      #
+      # Also supported:
+      #
+      #     trm_transform_point(0,1)
+      #
       # transforming (0,0) is a really common case, so optimise for it to
       # avoid unnecessary object allocations
       #
-      def trm_transform(x, y)
+      #: (PDF::Reader::Point | Numeric, ?Numeric) -> PDF::Reader::Point
+      def trm_transform_point(pt, opt_y = -1)
+        unless pt.is_a?(Point)
+          pt = Point.new(pt.to_i, opt_y.to_i)
+        end
+
         trm = text_rendering_matrix
-        if x == 0 && y == 0
-          [trm.e, trm.f]
+        if pt.x == 0 && pt.y == 0
+          Point.new(trm.e, trm.f)
         else
-          [
-            (trm.a * x) + (trm.c * y) + (trm.e),
-            (trm.b * x) + (trm.d * y) + (trm.f)
-          ]
+          Point.new(
+            (trm.a * pt.x) + (trm.c * pt.y) + (trm.e),
+            (trm.b * pt.x) + (trm.d * pt.y) + (trm.f)
+          )
         end
       end
 
@@ -342,15 +390,11 @@ class PDF::Reader
         end
         # TODO: support ty > 0
         ty = 0
-        temp = TransformationMatrix.new(1, 0,
-                                        0, 1,
-                                        tx, ty)
-        @text_matrix = temp.multiply!(
-          @text_matrix.a, @text_matrix.b,
-          @text_matrix.c, @text_matrix.d,
-          @text_matrix.e, @text_matrix.f
-        )
-        @font_size = @text_rendering_matrix = nil # invalidate cached value
+        @text_matrix.prepend_translation!(tx, ty)
+        @text_rendering_matrix = nil # invalidate cached value
+        # we used to invalidate @font_size here too, but it's not required
+        # font_size depends only on trm.b/trm.d (scale/rotation), not trm.e/f (translation),
+        # so it remains valid after a glyph displacement and does not need invalidation
       end
 
       private

data/lib/pdf/reader/page_text_receiver.rb

@@ -49,6 +49,8 @@ module PDF
         @page = page
         @content = []
         @characters = []
+        @actual_text = nil
+        @actual_text_consumed = false
       end
 
       def runs(opts = {})
@@ -84,6 +86,7 @@ module PDF
       end
 
       # deprecated
+      #: () -> String
       def content
         mediabox = @page.rectangles[:MediaBox]
         PageLayout.new(runs, mediabox).to_s
@@ -120,6 +123,21 @@ module PDF
         move_to_next_line_and_show_text(string)
       end
 
+      #####################################################
+      # Marked Content
+      #####################################################
+      def begin_marked_content_with_pl(tag, properties)
+        if properties.is_a?(Hash) && properties[:ActualText]
+          @actual_text = properties[:ActualText]
+          @actual_text_consumed = false
+        end
+      end
+
+      def end_marked_content
+        @actual_text = nil
+        @actual_text_consumed = false
+      end
+
       #####################################################
       # XObjects
       #####################################################
@@ -134,6 +152,7 @@ module PDF
 
       private
 
+      #: (String) -> void
       def internal_show_text(string)
         PDF::Reader::Error.validate_type_as_malformed(string, "string", String)
         if @state.current_font.nil?
@@ -142,41 +161,52 @@ module PDF
         glyphs = @state.current_font.unpack(string)
         glyphs.each_with_index do |glyph_code, index|
           # paint the current glyph
-          newx, newy = @state.trm_transform(0,0)
-          newx, newy = apply_rotation(newx, newy)
+          bl = @state.trm_transform_point(Point::ZERO_ZERO)
+          text_origin = apply_rotation(bl)
 
           utf8_chars = @state.current_font.to_utf8(glyph_code)
 
+          # Use ActualText from marked content if available (PDF 32000-1 §14.9.4).
+          # ActualText replaces all text within a BDC/EMC span.
+          if @actual_text
+            if !@actual_text_consumed
+              text = @actual_text
+              utf8_chars = PDF::Reader::EncodingUtils.string_to_utf8(text)
+              @actual_text_consumed = true
+            else
+              utf8_chars = ""
+            end
+          end
+
           # apply to glyph displacment for the current glyph so the next
           # glyph will appear in the correct position
           glyph_width = @state.current_font.glyph_width_in_text_space(glyph_code)
           th = 1
           scaled_glyph_width = glyph_width * @state.font_size * th
           unless utf8_chars == SPACE
-            @characters << TextRun.new(newx, newy, scaled_glyph_width, @state.font_size, utf8_chars)
+            @characters << TextRun.new(text_origin.x, text_origin.y, scaled_glyph_width, @state.font_size, utf8_chars)
           end
           @state.process_glyph_displacement(glyph_width, 0, utf8_chars == SPACE)
         end
       end
 
-      def apply_rotation(x, y)
+      #: (Point) -> Point
+      def apply_rotation(pt)
         if @page.rotate == 90
-          tmp = x
-          x = y
-          y = tmp * -1
+          Point.new(pt.y, pt.x * -1)
         elsif @page.rotate == 180
-          y *= -1
-          x *= -1
+          Point.new(pt.x * -1, pt.y * -1)
         elsif @page.rotate == 270
-          tmp = y
-          y = x
-          x = tmp * -1
+          Point.new(pt.y * -1, pt.x)
+        else
+          pt
         end
-        return x, y
       end
 
       # take a collection of TextRun objects and merge any that are in close
       # proximity
+      #
+      #: (Array[PDF::Reader::TextRun]) -> Array[PDF::Reader::TextRun]
       def merge_runs(runs)
         runs.group_by { |char|
           char.y.to_i

data/lib/pdf/reader/pages_strategy.rb

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

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