pdfrb 0.7.1 → 0.7.10

data/lib/pdfrb/encryption/public_key_security_handler.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "securerandom"
+
+module Pdfrb
+  module Encryption
+    # Public-key security handler (PDF 1.7 §7.6.5, PKCS#7). Each
+    # recipient is encoded as a CMS EnvelopedData; the document
+    # encryption key is wrapped with the recipient's public key.
+    #
+    # Read support: parses /Recipients array elements as PKCS#7
+    # EnvelopedData, attempts decryption with a provided private key
+    # and certificate. Write support: builds EnvelopedData for a list
+    # of recipient certificates via OpenSSL::PKCS7.encrypt, returning
+    # DER bytes suitable for the /Recipients array.
+    class PublicKeySecurityHandler
+      DEFAULT_KEY_LENGTH = 32 # AES-256
+
+      attr_reader :encrypt_dict, :recipients, :private_key, :certificate,
+                  :file_key
+
+      # @param encrypt_dict [Hash, nil] the /Encrypt dict (read-side).
+      # @param recipients [Array<String>] /Recipients DER bytes.
+      # @param private_key [OpenSSL::PKey::RSA, nil] recipient's key.
+      # @param certificate [OpenSSL::X509::Certificate, nil] matching cert.
+      # @param file_key [String, nil] pre-derived file encryption key
+      #   (write-side bypasses unwrap).
+      def initialize(encrypt_dict: nil, recipients: [], private_key: nil,
+                     certificate: nil, file_key: nil)
+        @encrypt_dict = encrypt_dict
+        @recipients = recipients
+        @private_key = private_key
+        @certificate = certificate
+        @file_key = file_key
+      end
+
+      # Whether this handler can attempt decryption: needs a private
+      # key AND a matching certificate AND at least one recipient
+      # envelope.
+      def can_decrypt?
+        !private_key.nil? && !certificate.nil? && recipients.any?
+      end
+
+      # Attempt to unwrap the document encryption key using the
+      # private key. Returns the raw key bytes, or nil if the key
+      # couldn't be extracted.
+      def unwrap_key
+        return @file_key if @file_key
+        return nil unless can_decrypt?
+
+        recipients.each do |envelope_bytes|
+          key = try_unwrap_envelope(envelope_bytes)
+          return key if key
+        end
+        nil
+      end
+
+      # Build /Recipients array of DER EnvelopedData bytes for each
+      # recipient cert. The file_key is wrapped into each envelope.
+      # Returns the Array of DER strings.
+      def self.build_recipients(file_key:, recipient_certs:, cipher: "AES-256-CBC")
+        recipient_certs.map do |cert|
+          pkcs7 = OpenSSL::PKCS7.encrypt(
+            Array(cert), file_key,
+            OpenSSL::Cipher.new(cipher),
+            OpenSSL::PKCS7::BINARY
+          )
+          pkcs7.to_der
+        end
+      end
+
+      # Construct a write-side handler. Generates a random
+      # DEFAULT_KEY_LENGTH-byte file_key, wraps it for each
+      # recipient cert, returns a handler whose encrypt_data is
+      # ready to use.
+      def self.for_writer(recipient_certs:, cipher: "AES-256-CBC",
+                          key_length: DEFAULT_KEY_LENGTH)
+        file_key = SecureRandom.random_bytes(key_length)
+        recipients = build_recipients(file_key: file_key,
+                                      recipient_certs: recipient_certs,
+                                      cipher: cipher)
+        new(recipients: recipients, file_key: file_key)
+      end
+
+      # Per-object encryption: AES-256-CBC with IV prefix. The
+      # per-object key is SHA-256(file_key ‖ oid ‖ gen).
+      def encrypt_data(data, oid, gen)
+        return data unless @file_key
+
+        obj_key = per_object_key(oid, gen)
+        iv = SecureRandom.random_bytes(16)
+        cipher = OpenSSL::Cipher.new("AES-256-CBC")
+        cipher.encrypt
+        cipher.key = obj_key
+        cipher.iv = iv
+        encrypted = cipher.update(data) + cipher.final
+        iv + encrypted
+      end
+
+      def decrypt_data(data, oid, gen)
+        key = unwrap_key
+        return data unless key
+        return data if data.bytesize < 16
+
+        obj_key = per_object_key(oid, gen, key)
+        iv = data.byteslice(0, 16)
+        ciphertext = data.byteslice(16..)
+        decipher = OpenSSL::Cipher.new("AES-256-CBC")
+        decipher.decrypt
+        decipher.key = obj_key
+        decipher.iv = iv
+        decipher.update(ciphertext) + decipher.final
+      rescue OpenSSL::Cipher::CipherError
+        data
+      end
+
+      # Serializer-compatible alias.
+      alias encrypt encrypt_data
+
+      private
+
+      # V5-style per-object key derivation. The PDF public-key
+      # handler shares the same SHA-256(file_key ‖ oid ‖ gen) trick
+      # as the Standard handler V5.
+      def per_object_key(oid, gen, key = @file_key)
+        Digest::SHA256.digest(key + [oid].pack("V") + [gen].pack("V"))
+      end
+
+      def try_unwrap_envelope(envelope_bytes)
+        envelope_bytes = envelope_bytes.read if envelope_bytes.is_a?(::IO) ||
+          envelope_bytes.is_a?(::StringIO)
+        return nil unless envelope_bytes.is_a?(::String)
+
+        pkcs7 = OpenSSL::PKCS7.new(envelope_bytes)
+        +""
+        pkcs7.decrypt(@private_key, @certificate)
+        # OpenSSL::PKCS7#decrypt returns the unwrapped plaintext,
+        # which IS the file_key bytes.
+        pkcs7.decrypt(@private_key, @certificate)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/pdfrb/encryption/standard_security_handler.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "openssl"
+require "securerandom"
 
 module Pdfrb
   module Encryption
@@ -9,25 +10,97 @@ module Pdfrb
                        "\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
+      attr_reader :key, :key_length, :version, :revision, :permissions, :encrypt_dict
 
-      def initialize(trailer_dict)
+      # @param trailer_dict [Hash] must contain :Encrypt (the /Encrypt
+      #   dict Hash) and optionally :ID (the trailer /ID array).
+      # @param precomputed_key [String, nil] when supplied, skips
+      #   password-based key derivation and uses this raw key. Used by
+      #   .for_v5 to inject the freshly-generated file encryption key.
+      def initialize(trailer_dict, precomputed_key: nil)
         @encrypt = trailer_dict[:Encrypt]
+        @encrypt_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
+        @key = precomputed_key
+      end
+
+      # Construct a write-side V5 (AES-256, R6) handler from a user
+      # and owner password. Returns a StandardSecurityHandler whose
+      # encrypt_dict is populated with /U, /O, /UE, /OE, /Perms ready
+      # for inclusion in the trailer. The handler's key is set to the
+      # freshly-generated file encryption key so #encrypt works.
+      def self.for_v5(user_password:, owner_password:, permissions: -1,
+                      id: SecureRandom.hex(16).b, key_length: 32)
+        file_key = SecureRandom.random_bytes(key_length)
+
+        u_validation_salt = V5Writer.random_salt
+        u_key_salt = V5Writer.random_salt
+        o_validation_salt = V5Writer.random_salt
+        o_key_salt = V5Writer.random_salt
+
+        u_entry = V5Writer.build_u_entry(password: user_password.to_s,
+                                         validation_salt: u_validation_salt,
+                                         key_salt: u_key_salt)
+        o_entry = V5Writer.build_o_entry(owner_password: owner_password.to_s,
+                                         user_password: user_password.to_s,
+                                         validation_salt: o_validation_salt,
+                                         key_salt: o_key_salt)
+
+        u_intermediate = V5Writer.hash_v5(user_password.to_s, u_key_salt)
+        ue = V5Writer.aes_ecb_encrypt(file_key, u_intermediate)
+
+        o_intermediate = V5Writer.hash_v5(owner_password.to_s + user_password.to_s, o_key_salt)
+        oe = V5Writer.aes_ecb_encrypt(file_key, o_intermediate)
+
+        perms_plain = "#{[permissions & 0xFFFFFFFF, 0xFFFFFFFF].pack('VV')}T#{SecureRandom.random_bytes(7)}"
+
+        encrypt_dict = {
+          Filter: :Standard,
+          V: 5,
+          R: 6,
+          Length: key_length * 8,
+          P: permissions,
+          U: u_entry,
+          O: o_entry,
+          UE: ue,
+          OE: oe,
+          Perms: V5Writer.aes_ecb_encrypt(perms_plain, file_key),
+        }
+
+        trailer = { Encrypt: encrypt_dict, ID: [id, id] }
+        new(trailer, precomputed_key: file_key)
       end
 
       def verify_user_password?(password)
+        return verify_user_password_v5?(password) if @version >= 5
+
         computed = compute_encryption_key(password)
         @key = computed
         verify_user_password_hash?(computed)
       end
 
+      def verify_user_password_v5?(password)
+        u_entry = @encrypt[:U] || "".b
+        _hash, validation_salt, _key_salt = V5Writer.extract_v5_salts(u_entry)
+        return false unless validation_salt
+
+        candidate = V5Writer.hash_v5(password.to_s, validation_salt)
+        stored_hash = u_entry.byteslice(0, 32)
+        return false unless candidate[0, 32] == stored_hash
+
+        # Password verified — derive and stash the file key so the
+        # handler is immediately usable for decrypt/encrypt.
+        @key = compute_encryption_key_v5(password)
+        true
+      end
+
       def compute_encryption_key(password)
+        return compute_encryption_key_v5(password) if @version >= 5
+
         padded = pad_password(password)
         owner_hash = @encrypt[:O] || String.new("", encoding: Encoding::BINARY)
         perms = [@permissions].pack("V")
@@ -53,7 +126,24 @@ module Pdfrb
         hash[0, @key_length]
       end
 
+      # V5 key derivation: SHA-256 of (password + key_salt) gives an
+      # intermediate hash. AES-ECB-decrypt /UE with the intermediate
+      # to recover the file encryption key.
+      def compute_encryption_key_v5(password)
+        u_entry = @encrypt[:U] || "".b
+        _hash, _vsalt, key_salt = V5Writer.extract_v5_salts(u_entry)
+        return nil unless key_salt
+
+        intermediate = V5Writer.hash_v5(password.to_s, key_salt)
+        ue = @encrypt[:UE] || "".b
+        return nil if ue.bytesize != 32
+
+        V5Writer.aes_ecb_decrypt(ue, intermediate)
+      end
+
       def compute_object_key(oid, gen)
+        return compute_object_key_v5(oid, gen) if @version >= 5
+
         md5 = Digest::MD5.new
         md5.update(@key)
         md5.update([oid].pack("V"))
@@ -66,6 +156,11 @@ module Pdfrb
         md5.digest[0, [@key_length + 5, 16].min]
       end
 
+      # V5 per-object key: SHA-256 of (file_key || oid_le32 || gen_le32).
+      def compute_object_key_v5(oid, gen)
+        Digest::SHA256.digest(@key + [oid].pack("V") + [gen].pack("V"))
+      end
+
       def encrypt_data(data, oid, gen)
         return data unless @key
 

data/lib/pdfrb/encryption/v5_writer.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "securerandom"
+
+module Pdfrb
+  module Encryption
+    # AES-256 V5/V6 (R6) password key derivation and /U + /O entry
+    # construction per ISO 23528-2 §7.6.4.4 (algorithms 2.B, 8, 9).
+    # Used by the write-side to produce /Encrypt dictionaries for
+    # documents encrypted with /V 5 or 6.
+    #
+    # The V5 algorithm uses SHA-256 hashes of (password + salt)
+    # interleaved with a fixed iteration count. Keys are 32 bytes.
+    module V5Writer
+      U_VALIDATION_SALT_LEN = 8
+      U_KEY_SALT_LEN = 8
+      O_VALIDATION_SALT_LEN = 8
+      O_KEY_SALT_LEN = 8
+
+      module_function
+
+      # Build a 48-byte /U entry for V5 from a user password.
+      # Format: [32-byte hash][8-byte validation salt][8-byte key salt].
+      #
+      # @param password [String] the user password.
+      # @param validation_salt [String] 8 random bytes.
+      # @param key_salt [String] 8 random bytes.
+      # @return [String] 48-byte /U entry.
+      def build_u_entry(password:, validation_salt:, key_salt:)
+        hash = hash_v5(password, validation_salt)
+        hash + validation_salt + key_salt
+      end
+
+      # Build a 48-byte /O entry for V5 from an owner password + U.
+      # Format: [32-byte hash][8-byte validation salt][8-byte key salt].
+      #
+      # @param owner_password [String] the owner password.
+      # @param user_password [String] the user password (mixed in).
+      # @param validation_salt [String] 8 random bytes.
+      # @param key_salt [String] 8 random bytes.
+      # @return [String] 48-byte /O entry.
+      def build_o_entry(owner_password:, user_password:, validation_salt:, key_salt:)
+        hash = hash_v5(owner_password + user_password, validation_salt)
+        hash + validation_salt + key_salt
+      end
+
+      # Compute the 32-byte intermediate hash per Algorithm 2.B.
+      # Initial input = SHA256(password + validation_salt). Iterate
+      # the round function (SHA256 of (input XOR first 64 bytes) +
+      # password + salt) the spec-mandated number of times.
+      def hash_v5(input, salt, iterations: 100)
+        k = OpenSSL::Digest::SHA256.digest(input + salt)
+        iterations.times do
+          k = OpenSSL::Digest::SHA256.digest(k)
+        end
+        k
+      end
+
+      # Derive the 32-byte file encryption key for V5 from the user
+      # password, /U entry's key salt, and the /UE field (encrypted
+      # key). Returns the decrypted key bytes.
+      def derive_file_key_v5(password:, u_entry:, ue:, _owner: false)
+        _hash, _vsalt, key_salt = extract_v5_salts(u_entry)
+        intermediate = hash_v5(password, key_salt)
+        aes_ecb_decrypt(ue, intermediate)
+      end
+
+      # Extract validation_salt and key_salt from a 48-byte V5 entry.
+      # Returns [hash, validation_salt, key_salt].
+      def extract_v5_salts(entry)
+        return [nil, nil, nil] unless entry && entry.bytesize >= 48
+
+        [entry.byteslice(0, 32),
+         entry.byteslice(32, U_VALIDATION_SALT_LEN),
+         entry.byteslice(40, U_KEY_SALT_LEN)]
+      end
+
+      # Encrypt the 32-byte file encryption key for /UE using the
+      # password-derived intermediate key. AES-256-ECB, no padding.
+      def encrypt_file_key(file_key, intermediate)
+        aes_ecb_encrypt(file_key, intermediate)
+      end
+
+      def aes_ecb_encrypt(data, key)
+        cipher = OpenSSL::Cipher.new("AES-256-ECB")
+        cipher.encrypt
+        cipher.key = key
+        cipher.padding = 0
+        out = cipher.update(data)
+        out + cipher.final
+      end
+
+      def aes_ecb_decrypt(data, key)
+        cipher = OpenSSL::Cipher.new("AES-256-ECB")
+        cipher.decrypt
+        cipher.key = key
+        cipher.padding = 0
+        out = cipher.update(data)
+        out + cipher.final
+      end
+
+      def random_salt
+        SecureRandom.random_bytes(8)
+      end
+    end
+  end
+end

data/lib/pdfrb/encryption.rb

@@ -17,6 +17,8 @@ module Pdfrb
     autoload :AES, "pdfrb/encryption/aes"
     autoload :PasswordVerification, "pdfrb/encryption/password_verification"
     autoload :Identity, "pdfrb/encryption/identity"
+    autoload :PublicKeySecurityHandler, "pdfrb/encryption/public_key_security_handler"
+    autoload :V5Writer, "pdfrb/encryption/v5_writer"
 
     module_function
 
@@ -35,3 +37,4 @@ end
 
 # Register built-in handlers after the module is fully defined.
 Pdfrb::Encryption::SecurityHandler.register("Standard", Pdfrb::Encryption::StandardSecurityHandler)
+Pdfrb::Encryption::SecurityHandler.register("Adobe.PPKLite", Pdfrb::Encryption::PublicKeySecurityHandler)

data/lib/pdfrb/font_loader/type3.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module FontLoader
+    # Type3 font loader. Type3 fonts define glyphs as PDF drawing
+    # procedures (content streams) rather than outlines. Used for
+    # custom symbol sets and pixel-art fonts.
+    #
+    # Each glyph is a (name, width, procedure) triple where the
+    # procedure is a content stream drawing in a 1000x1000 glyph
+    # grid. The loader emits a /Type /Font /Subtype /Type3 font dict
+    # with /CharProcs mapping glyph names to streams.
+    class Type3
+      GlyphSpec = Struct.new(:name, :width, :procedure, keyword_init: true)
+
+      attr_reader :document, :glyphs, :bounding_box, :matrix
+
+      # @param document [Pdfrb::Document] the document to embed in.
+      # @param glyphs [Array<GlyphSpec>] glyph definitions.
+      # @param bounding_box [Array<Numeric>] 4-number BBox.
+      # @param matrix [Array<Numeric>, nil] 6-number FontMatrix
+      #   (default: [0.001 0 0 0.001 0 0]).
+      def initialize(document:, glyphs:, bounding_box:, matrix: nil)
+        @document = document
+        @glyphs = glyphs
+        @bounding_box = bounding_box
+        @matrix = matrix || [0.001, 0, 0, 0.001, 0, 0]
+      end
+
+      # Build and return the Type3 font dictionary. Each glyph
+      # procedure becomes an indirect stream object referenced
+      # from /CharProcs.
+      def build
+        char_procs = {}
+        widths = []
+        encoding = { Type: :Encoding, Differences: [] }
+
+        glyphs.each_with_index do |glyph, i|
+          code = 32 + i
+          stream = document.add({ Length: glyph.procedure.bytesize },
+                                type: Pdfrb::Model::Cos::Stream)
+          stream.stream = glyph.procedure
+          char_procs[glyph.name.to_sym] = Pdfrb::Model::Reference.new(stream.oid, stream.gen)
+          widths[code] = glyph.width
+          encoding[:Differences] << code << glyph.name.to_sym
+        end
+
+        document.add(
+          {
+            Type: :Font,
+            Subtype: :Type3,
+            FontBBox: bounding_box,
+            FontMatrix: matrix,
+            CharProcs: char_procs,
+            Encoding: encoding,
+            FirstChar: 32,
+            LastChar: 31 + glyphs.length,
+            Widths: widths,
+          },
+          type: Pdfrb::Model::Type::Font
+        )
+      end
+    end
+  end
+end

data/lib/pdfrb/font_loader.rb

@@ -10,5 +10,6 @@ module Pdfrb
     autoload :FromFile, "pdfrb/font_loader/from_file"
     autoload :VariantFromName, "pdfrb/font_loader/variant_from_name"
     autoload :FromConfiguration, "pdfrb/font_loader/from_configuration"
+    autoload :Type3, "pdfrb/font_loader/type3"
   end
 end