pdfrb 0.3.0 → 0.7.1

data/lib/pdfrb/encryption/standard_security_handler.rb

@@ -1,116 +1,189 @@
 # frozen_string_literal: true
 
-require "digest/md5"
+require "openssl"
 
 module Pdfrb
   module Encryption
-    # Standard security handler (s7.6.3). V1..V6 / R2..R6.
-    # Owns per-document key derivation + per-object (de)cryption.
-    #
-    # Supports:
-    #   V1, V2 + R2     : RC4 40-bit and 128-bit (PDF 1.4-1.5).
-    #   V4   + R4       : RC4 or AES-128 with crypt filters (PDF 1.5+).
-    #   V5   + R5       : AES-256 (PDF 1.7 Ext. 3).
-    #   V6   + R6       : AES-256 (PDF 2.0).
-    #
-    # AES uses the openssl stdlib. RC4 is pure Ruby (TODO 119).
-    class StandardSecurityHandler < SecurityHandler
-      register "Standard", self
-
-      attr_reader :file_key, :version, :revision
-
-      def set_up_decryption(password: "")
-        @encrypt_dict = read_encrypt_dict
-        return unless @encrypt_dict
-
-        @version = @encrypt_dict[:V].to_i
-        @revision = @encrypt_dict[:R].to_i
-        id0 = document.trailer[:ID].to_a.first.b
-        unless verify_password(password)
-          raise Pdfrb::EncryptionError, "incorrect password"
+    class StandardSecurityHandler
+      PAD = String.new("\x28\xBF\x4E\x5E\x4E\x75\x8A\x41\x64\x00\x4E\x56\xFF\xFA\x01\x08" \
+                       "\x2E\x2E\x00\xB6\xD0\x68\x3E\x80\x2F\x0C\xA9\xFE\x64\x53\x69\x7A",
+                       encoding: Encoding::BINARY).freeze
+
+      attr_reader :key, :key_length, :version, :revision, :permissions
+
+      def initialize(trailer_dict)
+        @encrypt = trailer_dict[:Encrypt]
+        @id = trailer_dict[:ID]
+        @version = (@encrypt[:V] || 0).to_i
+        @revision = (@encrypt[:R] || 3).to_i
+        @key_length = (@encrypt[:Length] || 40).to_i / 8
+        @permissions = (@encrypt[:P] || -1).to_i
+        @key = nil
+      end
+
+      def verify_user_password?(password)
+        computed = compute_encryption_key(password)
+        @key = computed
+        verify_user_password_hash?(computed)
+      end
+
+      def compute_encryption_key(password)
+        padded = pad_password(password)
+        owner_hash = @encrypt[:O] || String.new("", encoding: Encoding::BINARY)
+        perms = [@permissions].pack("V")
+        id_first = id_bytes
+
+        md5 = Digest::MD5.new
+        md5.update(padded)
+        md5.update(owner_hash)
+        md5.update(perms)
+        md5.update(id_first)
+
+        if @revision >= 4
+          md5.update(@encrypt[:UE] || "")
+          md5.update(@encrypt[:Perms] ? [@encrypt[:Perms]].pack("N") : "")
+        end
+
+        hash = md5.digest
+
+        if @revision >= 3
+          50.times { hash = Digest::MD5.digest(hash[0, @key_length]) }
         end
-        derive_file_key(password, id0)
+
+        hash[0, @key_length]
       end
 
-      # Verify the user (or owner) password. Returns true on match.
-      def verify_password(password)
-        PasswordVerification.verify_user_password(
-          password: password,
-          encrypt_dict: @encrypt_dict,
-          id0: document.trailer[:ID].to_a.first.b
-        )
+      def compute_object_key(oid, gen)
+        md5 = Digest::MD5.new
+        md5.update(@key)
+        md5.update([oid].pack("V"))
+        md5.update([gen].pack("v"))
+
+        if @version >= 4
+          md5.update("\xAA")
+        end
+
+        md5.digest[0, [@key_length + 5, 16].min]
       end
 
-      def decrypt(bytes, oid, gen)
-        return bytes if @file_key.nil?
+      def encrypt_data(data, oid, gen)
+        return data unless @key
 
-        case cipher_type
-        when :rc4 then RC4.new(object_key(oid, gen, 16)).process(bytes)
-        when :aes then AES.new(key_size: aes_key_bits, mode: :CBC).decrypt(bytes, object_key(oid, gen, aes_key_bits / 8 + 5).byteslice(0, aes_key_bits / 8))
-        else bytes
+        obj_key = compute_object_key(oid, gen)
+
+        if @version >= 4
+          encrypt_aes_cbc(data, obj_key)
+        else
+          encrypt_rc4(data, obj_key)
         end
       end
 
-      def encrypt(bytes, oid, gen)
-        return bytes if @file_key.nil?
+      # Serializer-compatible alias for encrypt_data. The Serializer
+      # calls encrypter.encrypt(payload, oid, gen) on string/stream
+      # payloads during serialization.
+      alias encrypt encrypt_data
+
+      def decrypt_data(data, oid, gen)
+        return data unless @key
 
-        case cipher_type
-        when :rc4 then RC4.new(object_key(oid, gen, 16)).process(bytes)
-        when :aes then AES.new(key_size: aes_key_bits, mode: :CBC).encrypt(bytes, object_key(oid, gen, aes_key_bits / 8 + 5).byteslice(0, aes_key_bits / 8), random_iv)
-        else bytes
+        obj_key = compute_object_key(oid, gen)
+
+        if @version >= 4
+          decrypt_aes_cbc(data, obj_key)
+        else
+          decrypt_rc4(data, obj_key)
         end
       end
 
       private
 
-      def read_encrypt_dict
-        ref = document.trailer[:Encrypt]
-        return nil unless ref
+      def pad_password(password)
+        pw = password.to_s.encode(Encoding::BINARY)[0, 32]
+        pw + PAD[pw.bytesize, 32 - pw.bytesize]
+      end
+
+      def id_bytes
+        return String.new("", encoding: Encoding::BINARY) unless @id
 
-        encrypt = ref.is_a?(Pdfrb::Model::Reference) ?
-                    document.object(ref) : ref
-        encrypt.is_a?(Pdfrb::Model::Cos::Dictionary) ? encrypt : nil
+        first = @id.is_a?(Array) ? @id[0] : @id
+        first.to_s.encode(Encoding::BINARY)
       end
 
-      def derive_file_key(password, id0)
-        @file_key = PasswordVerification.derive_key_rc4(
-          password: password,
-          o_entry: @encrypt_dict[:O].to_s.b,
-          p_flags: @encrypt_dict[:P].to_i,
-          id0: id0,
-          revision: @revision,
-          key_length_bits: (@encrypt_dict[:Length] || 40).to_i,
-          encrypt_metadata: @encrypt_dict.fetch(:EncryptMetadata, true)
-        )
+      def verify_user_password_hash?(key)
+        return true if @revision < 3
+
+        hash = compute_user_password_hash(key)
+        stored = @encrypt[:U] || ""
+        hash[0, 16] == stored[0, 16]
       end
 
-      def cipher_type
-        return :rc4 if @version <= 2
-        return :aes if @version >= 4 && @version <= 5
+      def compute_user_password_hash(key)
+        md5 = Digest::MD5.new
+        md5.update(PAD)
+        md5.update(id_bytes)
+        hash = md5.digest
 
-        # V6 (PDF 2.0) — AES-256 always.
-        :aes
+        rc4 = RC4Impl.new(key)
+        20.times { |i| hash = rc4.process(hash, key ^ i) }
+
+        hash[0, 16]
       end
 
-      def aes_key_bits
-        @version >= 5 ? 256 : 128
+      def encrypt_rc4(data, key)
+        RC4Impl.new(key).process(data)
       end
 
-      # Per-object key per Algorithm 1: MD5(file_key + oid(LE) + gen(LE) + (sAlT for AES)).
-      def object_key(oid, gen, output_len)
-        md5 = Digest::MD5.new
-        md5.update(@file_key)
-        md5.update([oid].pack("V"))
-        md5.update([gen].pack("V"))
-        md5.update("sAlT".b) if cipher_type == :aes
-        md5.digest.byteslice(0, output_len)
+      def decrypt_rc4(data, key)
+        RC4Impl.new(key).process(data)
       end
 
-      def random_iv
-        OpenSSL::Random.random_bytes(16)
-      rescue StandardError
-        require "securerandom"
-        SecureRandom.random_bytes(16)
+      def encrypt_aes_cbc(data, key)
+        iv = OpenSSL::Random.random_bytes(16)
+        cipher = OpenSSL::Cipher.new("aes-128-cbc")
+        cipher.encrypt
+        cipher.key = key[0, 16]
+        cipher.iv = iv
+        encrypted = cipher.update(data) + cipher.final
+        iv + encrypted
+      end
+
+      def decrypt_aes_cbc(data, key)
+        return data if data.bytesize < 16
+
+        iv = data[0, 16]
+        ciphertext = data[16..]
+        decipher = OpenSSL::Cipher.new("aes-128-cbc")
+        decipher.decrypt
+        decipher.key = key[0, 16]
+        decipher.iv = iv
+        decipher.update(ciphertext) + decipher.final
+      rescue OpenSSL::Cipher::CipherError
+        data
+      end
+    end
+
+    # Minimal RC4 implementation
+    class RC4Impl
+      def initialize(key)
+        @s = (0..255).to_a
+        j = 0
+        key.bytes.each_with_index do |_b, i|
+          j = (j + @s[i] + key.getbyte(i % key.bytesize)) & 0xFF
+          @s[i], @s[j] = @s[j], @s[i]
+        end
+        @i = @j = 0
+      end
+
+      def process(data, _xor = nil)
+        result = data.dup.force_encoding(Encoding::BINARY)
+        result.bytes.each_with_index do |_b, idx|
+          @i = (@i + 1) & 0xFF
+          @j = (@j + @s[@i]) & 0xFF
+          @s[@i], @s[@j] = @s[@j], @s[@i]
+          k = @s[(@s[@i] + @s[@j]) & 0xFF]
+          result.setbyte(idx, result.getbyte(idx) ^ k)
+        end
+        result
       end
     end
   end

data/lib/pdfrb/encryption.rb

@@ -16,5 +16,22 @@ module Pdfrb
     autoload :RC4, "pdfrb/encryption/rc4"
     autoload :AES, "pdfrb/encryption/aes"
     autoload :PasswordVerification, "pdfrb/encryption/password_verification"
+    autoload :Identity, "pdfrb/encryption/identity"
+
+    module_function
+
+    # Look up a registered security-handler subclass by /Filter name.
+    def handler_for(filter_name)
+      SecurityHandler.lookup(filter_name)
+    end
+
+    # Build a security handler for +document+ by inspecting its /Encrypt.
+    # Returns nil if the document is not encrypted.
+    def handler_for_document(document, **opts)
+      SecurityHandler.for(document, decryption_opts: opts)
+    end
   end
 end
+
+# Register built-in handlers after the module is fully defined.
+Pdfrb::Encryption::SecurityHandler.register("Standard", Pdfrb::Encryption::StandardSecurityHandler)

data/lib/pdfrb/error.rb

@@ -29,9 +29,9 @@ module Pdfrb
   class MalformedPdfError < ParseError
     attr_reader :recovered
 
-    def initialize(message, recovered: false, **opts)
+    def initialize(message, recovered: false, **)
       @recovered = recovered
-      super(message, **opts)
+      super(message, **)
     end
 
     def recovered? = @recovered

data/lib/pdfrb/filter/brotli_decode.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    module BrotliDecode
+      module_function
+
+      def decoder(data, **_opts)
+        return data unless data
+
+        begin
+          require "brotli"
+          Brotli.inflate(data)
+        rescue LoadError
+          raise FilterError, "BrotliDecode requires the 'brotli' gem"
+        end
+      end
+
+      def encoder(data, **_opts)
+        return data unless data
+
+        begin
+          require "brotli"
+          Brotli.deflate(data)
+        rescue LoadError
+          data
+        end
+      end
+    end
+    REGISTRY[:BrotliDecode] = BrotliDecode if defined?(REGISTRY)
+  end
+end

data/lib/pdfrb/filter/ccitt_fax_decode.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    module CCITTFaxDecode
+      module_function
+
+      def decoder(data, **_opts); data; end
+      def encoder(data, **_opts); data; end
+    end
+  end
+end

data/lib/pdfrb/filter/crypt.rb

@@ -15,7 +15,7 @@ module Pdfrb
           return bytes unless document
           return bytes if parms == :Identity || parms.nil?
 
-          handler = document.security_handler if document.respond_to?(:security_handler)
+          handler = document.security_handler if !document.config["security.handler"].nil?
           return bytes unless handler
 
           handler.decrypt(bytes, document.current_object_oid)
@@ -25,7 +25,7 @@ module Pdfrb
           return bytes unless document
           return bytes if parms == :Identity || parms.nil?
 
-          handler = document.security_handler if document.respond_to?(:security_handler)
+          handler = document.security_handler if !document.config["security.handler"].nil?
           return bytes unless handler
 
           handler.encrypt(bytes, document.current_object_oid)

data/lib/pdfrb/filter/dct_decode.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    module DCTDecode
+      module_function
+
+      def decoder(data, **_opts)
+        data
+      end
+
+      def encoder(data, **_opts)
+        data
+      end
+    end
+    REGISTRY[:DCTDecode] = DCTDecode if defined?(REGISTRY)
+  end
+end

data/lib/pdfrb/filter/flate_decode.rb

@@ -51,24 +51,10 @@ module Pdfrb
         # predictor: 10..15 = PNG predictors; we implement the None/Sub/Up/
         # Average/Paeth (filter type byte at start of each row).
         def apply_png_predictor_decode(bytes, predictor:, columns:, colors:, bits_per_component:)
-          return bytes unless (10..15).cover?(predictor)
-
-          row_len = columns * colors * (bits_per_component / 8)
-          row_len += 1 # leading filter-type byte per row
-          rows = bytes.each_byte.each_slice(row_len).to_a
-          prev_row = nil
-          bpp = (colors * (bits_per_component / 8)) || 1
-          bpp = 1 if bpp.zero?
-
-          out = +""
-          rows.each do |row|
-            filter_type = row[0]
-            data = row[1..]
-            unfiltered = unfilter_row(filter_type, data, prev_row, bpp)
-            out << unfiltered.pack("C*")
-            prev_row = unfiltered
-          end
-          out.force_encoding(Encoding::BINARY)
+          Pdfrb::Filter::PNGPredictor.decode(
+            bytes, predictor: predictor, columns: columns,
+                   colors: colors, bits_per_component: bits_per_component
+          )
         end
 
         def unfilter_row(filter_type, data, prev_row, bpp)

data/lib/pdfrb/filter/jbig2_decode.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    module JBIG2Decode
+      module_function
+
+      def decoder(data, **_opts); data; end
+      def encoder(data, **_opts); data; end
+    end
+  end
+end

data/lib/pdfrb/filter/jpx_decode.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    module JPXDecode
+      module_function
+
+      def decoder(data, **_opts)
+        data
+      end
+
+      def encoder(data, **_opts)
+        data
+      end
+    end
+    REGISTRY[:JPXDecode] = JPXDecode if defined?(REGISTRY)
+  end
+end

data/lib/pdfrb/filter/lzw_decode.rb

@@ -86,12 +86,13 @@ module Pdfrb
           predictor = parms[:Predictor] || 1
           return bytes if predictor == 1
 
-          Pdfrb::Filter::FlateDecode.send(:apply_png_predictor_decode,
+          Pdfrb::Filter::PNGPredictor.decode(
             bytes,
             predictor: predictor,
             columns: parms[:Columns] || 1,
             colors: parms[:Colors] || 1,
-            bits_per_component: parms[:BitsPerComponent] || 8)
+            bits_per_component: parms[:BitsPerComponent] || 8
+          )
         end
       end
 

data/lib/pdfrb/filter/png_predictor.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Filter
+    # PNG predictor (de)coding shared between FlateDecode and LZWDecode
+    # (s7.4.8.4 / RFC 2083 6.6). Extracted as a standalone module so
+    # both filters can use it without one calling the other's private
+    # methods.
+    module PNGPredictor
+      module_function
+
+      def decode(bytes, predictor:, columns:, colors:, bits_per_component:)
+        return bytes unless (10..15).cover?(predictor)
+
+        row_len = columns * colors * (bits_per_component / 8)
+        row_len += 1 # leading filter-type byte per row
+        rows = bytes.each_byte.each_slice(row_len).to_a
+        prev_row = nil
+        bpp = (colors * (bits_per_component / 8)) || 1
+        bpp = 1 if bpp.zero?
+
+        out = +""
+        rows.each do |row|
+          filter_type = row[0]
+          data = row[1..]
+          unfiltered = unfilter_row(filter_type, data, prev_row, bpp)
+          out << unfiltered.pack("C*")
+          prev_row = unfiltered
+        end
+        out.force_encoding(Encoding::BINARY)
+      end
+
+      def unfilter_row(filter_type, data, prev_row, bpp)
+        case filter_type
+        when 1 then png_sub(data, bpp)
+        when 2 then png_up(data, prev_row)
+        when 3 then png_average(data, prev_row, bpp)
+        when 4 then png_paeth(data, prev_row, bpp)
+        else data
+        end
+      end
+
+      def png_sub(data, bpp)
+        bytes = data.dup
+        bpp.upto(bytes.length - 1).each do |i|
+          bytes[i] = (bytes[i] + bytes[i - bpp]) & 0xFF
+        end
+        bytes
+      end
+
+      def png_up(data, prev_row)
+        return data unless prev_row
+
+        bytes = data.dup
+        (0...bytes.length).each do |i|
+          bytes[i] = (bytes[i] + (prev_row[i] || 0)) & 0xFF
+        end
+        bytes
+      end
+
+      def png_average(data, prev_row, bpp)
+        bytes = data.dup
+        (0...bytes.length).each do |i|
+          left = bytes[i - bpp] || 0
+          up = prev_row ? (prev_row[i] || 0) : 0
+          bytes[i] = (bytes[i] + ((left + up) / 2)) & 0xFF
+        end
+        bytes
+      end
+
+      def png_paeth(data, prev_row, bpp)
+        bytes = data.dup
+        (0...bytes.length).each do |i|
+          left = bytes[i - bpp] || 0
+          up = prev_row ? (prev_row[i] || 0) : 0
+          up_left = prev_row ? (prev_row[i - bpp] || 0) : 0
+          bytes[i] = (bytes[i] + paeth(left, up, up_left)) & 0xFF
+        end
+        bytes
+      end
+
+      def paeth(a, b, c)
+        p = a + b - c
+        pa = (p - a).abs
+        pb = (p - b).abs
+        pc = (p - c).abs
+        return a if pa <= pb && pa <= pc
+        return b if pb <= pc
+
+        c
+      end
+    end
+  end
+end

data/lib/pdfrb/filter.rb

@@ -6,7 +6,18 @@ module Pdfrb
   # document)` class methods, registered via `register_as`.
   module Filter
     autoload :Base, "pdfrb/filter/base"
-
+    autoload :FlateDecode, "pdfrb/filter/flate_decode"
+    autoload :ASCIIHexDecode, "pdfrb/filter/ascii_hex_decode"
+    autoload :ASCII85Decode, "pdfrb/filter/ascii_85_decode"
+    autoload :LZWDecode, "pdfrb/filter/lzw_decode"
+    autoload :RunLengthDecode, "pdfrb/filter/run_length_decode"
+    autoload :Crypt, "pdfrb/filter/crypt"
+    autoload :DCTDecode, "pdfrb/filter/dct_decode"
+    autoload :JPXDecode, "pdfrb/filter/jpx_decode"
+    autoload :CCITTFaxDecode, "pdfrb/filter/ccitt_fax_decode"
+    autoload :JBIG2Decode, "pdfrb/filter/jbig2_decode"
+    autoload :BrotliDecode, "pdfrb/filter/brotli_decode"
+    autoload :PNGPredictor, "pdfrb/filter/png_predictor"
     class << self
       def registry; @registry ||= {}; end
 
@@ -18,7 +29,21 @@ module Pdfrb
         registry[name.to_s]
       end
 
+      # Force-load all filter implementations so register_as calls
+      # fire and populate the registry. Idempotent.
+      def eager_load!
+        return if @eager_loaded
+
+        constants.each do |c|
+          const_get(c)
+        rescue NameError
+          # Skip autoload targets that don't define a class.
+        end
+        @eager_loaded = true
+      end
+
       def apply(bytes, filters:, parms:, direction:, document: nil)
+        eager_load!
         return bytes if filters.empty?
 
         case direction
@@ -50,15 +75,3 @@ module Pdfrb
     end
   end
 end
-
-# Eager-load filters so register_as calls populate the registry
-# before any stream decode happens. Must be after the Filter module
-# and its singleton methods are fully defined.
-require "pdfrb/filter/base"
-require "pdfrb/filter/flate_decode"
-require "pdfrb/filter/ascii_hex_decode"
-require "pdfrb/filter/ascii_85_decode"
-require "pdfrb/filter/lzw_decode"
-require "pdfrb/filter/run_length_decode"
-require "pdfrb/filter/crypt"
-require "pdfrb/filter/passthrough_filters"