pdf-reader 2.7.0 → 2.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ee0d8c3c55f6a0aebb60a0a6dce92428e8371b96a6beb6d75bfe90602bffae7
-  data.tar.gz: '0911d108353bf577aa9fd7b49b97dda1cf9d54816bf8ff6c4225281eeda63229'
+  metadata.gz: cc98ab07b3c66f13f663ea5faf8132b45d769912e0da737917dd054e38318ede
+  data.tar.gz: 0f2928d9778b5b3ea8fca5e723a2b3fa6f275df70b02f1eb4385e077c535ac78
 SHA512:
-  metadata.gz: 917db2b1fb977b41e7b057ff3d215b8f249577254d9fe3df72f330b32ff49630874c58f480495ddcd137d9f31d014083438623cdf7260b0d7a87bbe3a5f3685a
-  data.tar.gz: cd9832f025264e54d586e81eff69727379e8646d741f53ae61e90a5b38945d852147853891d468bab683581bdd0beb68a9b7c7f5e54e064e9a3935262ea9d651
+  metadata.gz: 210cd8c8cef93b0e0fac1446c091c2a62772ffe8b1786627089e5a330ca7defd501df7cccc0b48d326d38ff74318b162e512220e8a4460260bebe7da0ef8b757
+  data.tar.gz: 047e7f6641411557b1d3b50035dbdf55647c63deede273b6ce4442230b85372045494b81e88c1ffcaa09a7c5ea26823ee33b33c3bf82013328d0e32a95021284

data/CHANGELOG

@@ -1,3 +1,23 @@
+v2.9.2 (20th February 2022)
+- Fix PDF::Reader::ObjectHash#page_references to return an Array of PDF::Reader::Reference (http://github.com/yob/pdf-reader/pull/444)
+
+v2.9.1 (4th February 2022)
+- Fix exception in Page#walk introduced in 2.9.0 (http://github.com/yob/pdf-reader/pull/442)
+- Other small bug fixes
+
+v2.9.0 (24th January 2022)
+- Support additional encryption standards (http://github.com/yob/pdf-reader/pull/419)
+- Return CropBox correctly from Page#rectangles (https://github.com/yob/pdf-reader/pull/420)
+- For sorbet users, additional type annotations are included in the gem
+
+v2.8.0 (28th Decemeber 2021)
+- Add PDF::Reader::Page#runs for extracting text from a page with positioning metadata (http://github.com/yob/pdf-reader/pull/411)
+- Add options to PDF::Reader::Page#text to make some behaviour configurable (http://github.com/yob/pdf-reader/pull/411)
+    - including extracting the text for only part of the page
+- Improve text positioning and extraction for Type3 fonts (http://github.com/yob/pdf-reader/pull/412)
+- Skip extracting text that is positioned outside the page (http://github.com/yob/pdf-reader/pull/413)
+- Fix occasional crash when reading some streams (http://github.com/yob/pdf-reader/pull/405)
+
 v2.7.0 (13th December 2021)
 - Include RBI type files in the gem
   - Downstream users of pdf-reader who also use sorbet *should* find many parts of the API will

data/Rakefile

@@ -14,7 +14,7 @@ desc "Run cane to check quality metrics"
 Cane::RakeTask.new(:quality) do |cane|
   cane.abc_max = 20
   cane.style_measure = 100
-  cane.max_violations = 32
+  cane.max_violations = 28
 
   cane.use Morecane::EncodingCheck, :encoding_glob => "{app,lib,spec}/**/*.rb"
 end

data/lib/pdf/reader/aes_v2_security_handler.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+class PDF::Reader
+
+  # Decrypts data using the AESV2 algorithim defined in the PDF spec. Requires
+  # a decryption key, which is usually generated by PDF::Reader::StandardKeyBuilder
+  #
+  class AesV2SecurityHandler
+
+    def initialize(key)
+      @encrypt_key = key
+    end
+
+    ##7.6.2 General Encryption Algorithm
+    #
+    # Algorithm 1: Encryption of data using the AES-128-CBC algorithm
+    #
+    # version == 4 and CFM == AESV2
+    #
+    # 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 ) }
+      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
+
+  end
+end

data/lib/pdf/reader/aes_v3_security_handler.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+require 'digest'
+require 'openssl'
+
+class PDF::Reader
+
+  # Decrypts data using the AESV3 algorithim defined in the PDF 1.7, Extension Level 3 spec.
+  # Requires a decryption key, which is usually generated by PDF::Reader::KeyBuilderV5
+  #
+  class AesV3SecurityHandler
+
+    def initialize(key)
+      @encrypt_key = key
+      @cipher = "AES-256-CBC"
+    end
+
+    ##7.6.2 General Encryption Algorithm
+    #
+    # Algorithm 1: Encryption of data using the RC4 or AES algorithms
+    #
+    # 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 )
+      cipher = OpenSSL::Cipher.new(@cipher)
+      cipher.decrypt
+      cipher.key = @encrypt_key.dup
+      cipher.iv = buf[0..15]
+      cipher.update(buf[16..-1]) + cipher.final
+    end
+
+  end
+end

data/lib/pdf/reader/bounding_rectangle_runs_filter.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+
+  # Filter our text/characters that are positioned outside a rectangle. Usually the page
+  # MediaBox or CropBox, but could be a user specified rectangle too
+  class BoundingRectangleRunsFilter
+
+    def self.runs_within_rect(runs, rect)
+      runs.select { |run| rect.contains?(run.origin) }
+    end
+  end
+end
+

data/lib/pdf/reader/buffer.rb

@@ -1,5 +1,5 @@
 # coding: ASCII-8BIT
-# typed: false
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -59,6 +59,9 @@ class PDF::Reader
     # Allow for this here
     TRAILING_BYTECOUNT = 5000
 
+    # must match whole tokens
+    DIGITS_ONLY = %r{\A\d+\z}
+
     attr_reader :pos
 
     # Creates a new buffer.
@@ -143,13 +146,20 @@ class PDF::Reader
       @io.seek(-TRAILING_BYTECOUNT, IO::SEEK_END) rescue @io.seek(0)
       data = @io.read(TRAILING_BYTECOUNT)
 
+      raise MalformedPDFError, "PDF does not contain EOF marker" if data.nil?
+
       # the PDF 1.7 spec (section #3.4) says that EOL markers can be either \r, \n, or both.
       lines = data.split(/[\n\r]+/).reverse
       eof_index = lines.index { |l| l.strip[/^%%EOF/] }
 
       raise MalformedPDFError, "PDF does not contain EOF marker" if eof_index.nil?
       raise MalformedPDFError, "PDF EOF marker does not follow offset" if eof_index >= lines.size-1
-      lines[eof_index+1].to_i
+      offset = lines[eof_index+1].to_i
+
+      # a byte offset < 0 doesn't make much sense. This is unlikely to happen, but in theory some
+      # corrupted PDFs might have a line that looks like a negative int preceding the `%%EOF`
+      raise MalformedPDFError, "invalid xref offset" if offset < 0
+      offset
     end
 
     private
@@ -230,13 +240,12 @@ class PDF::Reader
       return if @tokens.size < 3
       return if @tokens[2] != "R"
 
-      # must match whole tokens
-      digits_only = %r{\A\d+\z}
-      if @tokens[0].match(digits_only) && @tokens[1].match(digits_only)
-        @tokens[0] = PDF::Reader::Reference.new(@tokens[0].to_i, @tokens[1].to_i)
-        @tokens[1] = nil
-        @tokens[2] = nil
-        @tokens.compact!
+      token_one = @tokens[0]
+      token_two = @tokens[1]
+      if token_one.is_a?(String) && token_two.is_a?(String) && token_one.match(DIGITS_ONLY) && token_two.match(DIGITS_ONLY)
+        @tokens[0] = PDF::Reader::Reference.new(token_one.to_i, token_two.to_i)
+        @tokens.delete_at(2)
+        @tokens.delete_at(1)
       end
     end
 
@@ -246,7 +255,7 @@ class PDF::Reader
     # This is to reduce the chance of accidentally matching an embedded EI
     def prepare_inline_token
       idstart = @io.pos
-      chr = prevchr = nil
+      prevchr = ''
       eisize = 0 # how many chars in the end marker
       seeking = 'E' # what are we looking for now?
       loop do
@@ -264,11 +273,11 @@ class PDF::Reader
           end
         when 'I'
           if chr == 'I'
-            seeking = :END
+            seeking = ''
           else
             seeking = 'E'
           end
-        when :END
+        when ''
           if WHITE_SPACE.include? chr
             eisize += 1 # Drop trailer
             break
@@ -276,28 +285,28 @@ class PDF::Reader
             seeking = 'E'
           end
         end
-        prevchr = chr
+        prevchr = chr.is_a?(String) ? chr : ''
       end
-      unless seeking == :END
+      unless seeking == ''
         raise MalformedPDFError, "EI terminator not found"
       end
       eiend = @io.pos
       @io.seek(idstart, IO::SEEK_SET)
       str = @io.read(eiend - eisize - idstart) # get the ID content
-      @tokens << string_token(str)
+      @tokens << str.freeze if str
     end
 
     # if we're currently inside a hex string, read hex nibbles until
     # we find a closing >
     #
     def prepare_hex_token
+      finished = :false
       str = "".dup
-      finished = false
 
-      while !finished
+      until finished == :true
         byte = @io.getbyte
         if byte.nil?
-          finished = true # unbalanced params
+          finished = :true # unbalanced params
         elsif (48..57).include?(byte) || (65..90).include?(byte) || (97..122).include?(byte)
           str << byte
         elsif byte <= 32
@@ -306,7 +315,7 @@ class PDF::Reader
           @tokens << str if str.size > 0
           @tokens << ">" if byte != 0x3E # '>'
           @tokens << byte.chr
-          finished = true
+          finished = :true
         end
       end
     end
@@ -353,14 +362,17 @@ class PDF::Reader
     def prepare_regular_token
       tok = "".dup
 
-      while byte = @io.getbyte
+      loop do
+        byte = @io.getbyte
+
         case byte
+        when nil
+          break
         when 0x25
           # comment, ignore everything until the next EOL char
-          done = false
-          while !done
-            byte = @io.getbyte
-            done = true if byte.nil? || byte == 0x0A || byte == 0x0D
+          loop do
+            commentbyte = @io.getbyte
+            break if commentbyte.nil? || commentbyte == 0x0A || commentbyte == 0x0D
           end
         when *TOKEN_WHITESPACE
           # white space, token finished
@@ -430,15 +442,5 @@ class PDF::Reader
       byte
     end
 
-    # for a handful of tokens we want to tell the parser how to convert them
-    # into higher level tokens. This methods adds a to_token() method
-    # to tokens that should remain as strings.
-    #
-    def string_token(token)
-      def token.to_token
-        to_s
-      end
-      token
-    end
   end
 end

data/lib/pdf/reader/cmap.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: false
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -35,15 +35,15 @@ class PDF::Reader
   class CMap # :nodoc:
 
     CMAP_KEYWORDS = {
-      "begincodespacerange" => 1,
-      "endcodespacerange" => 1,
-      "beginbfchar" => 1,
-      "endbfchar" => 1,
-      "beginbfrange" => 1,
-      "endbfrange" => 1,
-      "begin" => 1,
-      "begincmap" => 1,
-      "def" => 1
+      "begincodespacerange" => :noop,
+      "endcodespacerange" => :noop,
+      "beginbfchar" => :noop,
+      "endbfchar" => :noop,
+      "beginbfrange" => :noop,
+      "endbfrange" => :noop,
+      "begin" => :noop,
+      "begincmap" => :noop,
+      "def" => :noop
     }
 
     attr_reader :map
@@ -53,30 +53,6 @@ class PDF::Reader
       process_data(data)
     end
 
-    def process_data(data)
-      parser = build_parser(data)
-      mode = :none
-      instructions = []
-
-      while token = parser.parse_token(CMAP_KEYWORDS)
-        if token == "beginbfchar"
-          mode = :char
-        elsif token == "endbfchar"
-          process_bfchar_instructions(instructions)
-          instructions = []
-          mode = :none
-        elsif token == "beginbfrange"
-          mode = :range
-        elsif token == "endbfrange"
-          process_bfrange_instructions(instructions)
-          instructions = []
-          mode = :none
-        elsif mode == :char || mode == :range
-          instructions << token
-        end
-      end
-    end
-
     def size
       @map.size
     end
@@ -86,13 +62,40 @@ class PDF::Reader
     # Returns an array of Integers.
     #
     def decode(c)
-      # TODO: implement the conversion
-      return c unless Integer === c
-      @map[c]
+      @map.fetch(c, [])
     end
 
     private
 
+    def process_data(data, initial_mode = :none)
+      parser = build_parser(data)
+      mode = initial_mode
+      instructions = []
+
+      while token = parser.parse_token(CMAP_KEYWORDS)
+        if token.is_a?(String) || token.is_a?(Array)
+          if token == "beginbfchar"
+            mode = :char
+          elsif token == "endbfchar"
+            process_bfchar_instructions(instructions)
+            instructions = []
+            mode = :none
+          elsif token == "beginbfrange"
+            mode = :range
+          elsif token == "endbfrange"
+            process_bfrange_instructions(instructions)
+            instructions = []
+            mode = :none
+          elsif mode == :char
+            instructions << token.to_s
+          elsif mode == :range
+            instructions << token
+          end
+        end
+      end
+    end
+
+
     def build_parser(instructions)
       buffer = Buffer.new(StringIO.new(instructions))
       Parser.new(buffer)
@@ -107,7 +110,6 @@ class PDF::Reader
     # exception when we try converting broken UTF-16 to UTF-8
     #
     def str_to_int(str)
-      return nil if str.nil? || str.size == 0
       unpacked_string = if str.bytesize == 1 # UTF-8
         str.unpack("C*")
       else # UTF-16
@@ -115,12 +117,15 @@ class PDF::Reader
       end
       result = []
       while unpacked_string.any? do
-        if unpacked_string.size >= 2 && unpacked_string[0] > 0xD800 && unpacked_string[0] < 0xDBFF
+        if unpacked_string.size >= 2 &&
+            unpacked_string.first.to_i > 0xD800 &&
+            unpacked_string.first.to_i < 0xDBFF
           # this is a Unicode UTF-16 "Surrogate Pair" see Unicode Spec. Chapter 3.7
           # lets convert to a UTF-32. (the high bit is between 0xD800-0xDBFF, the
           # low bit is between 0xDC00-0xDFFF) for example: U+1D44E (U+D835 U+DC4E)
-          points = [unpacked_string.shift, unpacked_string.shift]
-          result << (points[0] - 0xD800) * 0x400 + (points[1] - 0xDC00) + 0x10000
+          point_one = unpacked_string.shift.to_i
+          point_two = unpacked_string.shift.to_i
+          result << (point_one - 0xD800) * 0x400 + (point_two - 0xDC00) + 0x10000
         else
           result << unpacked_string.shift
         end
@@ -130,9 +135,11 @@ class PDF::Reader
 
     def process_bfchar_instructions(instructions)
       instructions.each_slice(2) do |one, two|
-        find    = str_to_int(one)
-        replace = str_to_int(two)
-        @map[find.first] = replace
+        find    = str_to_int(one.to_s)
+        replace = str_to_int(two.to_s)
+        if find.any? && replace.any?
+          @map[find.first.to_i] = replace
+        end
       end
     end
 
@@ -143,30 +150,36 @@ class PDF::Reader
         elsif start.kind_of?(String) && finish.kind_of?(String) && to.kind_of?(Array)
           bfrange_type_two(start, finish, to)
         else
-          raise "invalid bfrange section"
+          raise MalformedPDFError, "invalid bfrange section"
         end
       end
     end
 
     def bfrange_type_one(start_code, end_code, dst)
-      start_code = str_to_int(start_code)[0]
-      end_code   = str_to_int(end_code)[0]
+      start_code = str_to_int(start_code).first
+      end_code   = str_to_int(end_code).first
       dst        = str_to_int(dst)
 
+      return if start_code.nil? || end_code.nil?
+
       # add all values in the range to our mapping
       (start_code..end_code).each_with_index do |val, idx|
-        @map[val] = dst.length == 1 ? [dst[0] + idx] : [dst[0], dst[1] + 1]
+        @map[val] = dst.length == 1 ? [dst[0].to_i + idx] : [dst[0].to_i, dst[1].to_i + 1]
       end
     end
 
     def bfrange_type_two(start_code, end_code, dst)
-      start_code = str_to_int(start_code)[0]
-      end_code   = str_to_int(end_code)[0]
+      start_code = str_to_int(start_code).first
+      end_code   = str_to_int(end_code).first
+
+      return if start_code.nil? || end_code.nil?
+
       from_range = (start_code..end_code)
 
       # add all values in the range to our mapping
       from_range.each_with_index do |val, idx|
-        @map[val] = str_to_int(dst[idx])
+        dst_char = dst[idx]
+        @map[val.to_i] = str_to_int(dst_char) if dst_char
       end
     end
   end

data/lib/pdf/reader/error.rb

@@ -51,9 +51,17 @@ class PDF::Reader
       raise ArgumentError, "#{name} (#{object}) must be a #{klass}" unless object.is_a?(klass)
     end
     ################################################################################
+    def self.validate_type_as_malformed(object, name, klass)
+      raise MalformedPDFError, "#{name} (#{object}) must be a #{klass}" unless object.is_a?(klass)
+    end
+    ################################################################################
     def self.validate_not_nil(object, name)
       raise ArgumentError, "#{object} must not be nil" if object.nil?
     end
+    ################################################################################
+    def self.validate_not_nil_as_malformed(object, name)
+      raise MalformedPDFError, "#{object} must not be nil" if object.nil?
+    end
   end
 
   ################################################################################

data/lib/pdf/reader/filter/ascii85.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require 'ascii85'

data/lib/pdf/reader/filter/ascii_hex.rb

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

data/lib/pdf/reader/filter/depredict.rb

@@ -9,7 +9,7 @@ class PDF::Reader
     class Depredict
 
       def initialize(options = {})
-        @options = options || {}
+        @options = options
       end
 
       ################################################################################

data/lib/pdf/reader/filter/flate.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 
@@ -34,7 +34,7 @@ class PDF::Reader
       def zlib_inflate(data)
         begin
           return Zlib::Inflate.new(ZLIB_AUTO_DETECT_ZLIB_OR_GZIP).inflate(data)
-        rescue Zlib::DataError
+        rescue Zlib::Error
           # by default, Ruby's Zlib assumes the data it's inflating
           # is RFC1951 deflated data, wrapped in a RFC1950 zlib container. If that
           # fails, swallow the exception and attempt to inflate the data as a raw
@@ -43,7 +43,7 @@ class PDF::Reader
 
         begin
           return Zlib::Inflate.new(ZLIB_RAW_DEFLATE).inflate(data)
-        rescue StandardError
+        rescue Zlib::Error
           # swallow this one too, so we can try some other fallback options
         end
 

data/lib/pdf/reader/filter/lzw.rb

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

data/lib/pdf/reader/filter/null.rb

@@ -1,8 +1,7 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-#
 class PDF::Reader
   module Filter # :nodoc:
     # implementation of the null stream filter

data/lib/pdf/reader/filter/run_length.rb

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

data/lib/pdf/reader/filter.rb

@@ -42,17 +42,16 @@ class PDF::Reader
     # returned untouched. At this stage PDF::Reader has no need to decode images.
     #
     def self.with(name, options = {})
-      case name.to_sym
-      when :ASCII85Decode   then PDF::Reader::Filter::Ascii85.new(options)
-      when :ASCIIHexDecode  then PDF::Reader::Filter::AsciiHex.new(options)
-      when :CCITTFaxDecode  then PDF::Reader::Filter::Null.new(options)
-      when :DCTDecode       then PDF::Reader::Filter::Null.new(options)
-      when :FlateDecode     then PDF::Reader::Filter::Flate.new(options)
-      when :Fl              then PDF::Reader::Filter::Flate.new(options)
-      when :JBIG2Decode     then PDF::Reader::Filter::Null.new(options)
-      when :JPXDecode       then PDF::Reader::Filter::Null.new(options)
-      when :LZWDecode       then PDF::Reader::Filter::Lzw.new(options)
-      when :RunLengthDecode then PDF::Reader::Filter::RunLength.new(options)
+      case name
+      when :ASCII85Decode, :A85   then PDF::Reader::Filter::Ascii85.new(options)
+      when :ASCIIHexDecode, :AHx  then PDF::Reader::Filter::AsciiHex.new(options)
+      when :CCITTFaxDecode, :CCF  then PDF::Reader::Filter::Null.new(options)
+      when :DCTDecode, :DCT       then PDF::Reader::Filter::Null.new(options)
+      when :FlateDecode, :Fl      then PDF::Reader::Filter::Flate.new(options)
+      when :JBIG2Decode           then PDF::Reader::Filter::Null.new(options)
+      when :JPXDecode             then PDF::Reader::Filter::Null.new(options)
+      when :LZWDecode, :LZW       then PDF::Reader::Filter::Lzw.new(options)
+      when :RunLengthDecode, :RL  then PDF::Reader::Filter::RunLength.new(options)
       else
         raise UnsupportedFeatureError, "Unknown filter: #{name}"
       end