pdfrb 0.8.6 → 0.8.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84368b352e856470e7d3f3374071df7724c21d5dba77596842ac5bacc419db59
-  data.tar.gz: c0bfb8c0a8803aa74ecf43d1e3e35ff18b17bc457582705c409d8fae89b8f50f
+  metadata.gz: b0edf5439bfe359af4b900aeb846047b168d741271eb78a7f78315ca5b0bba55
+  data.tar.gz: 0b30e0edb04dcc2a4d26a493ba782379a8a864904eafc72f07c0c49ca4a25e57
 SHA512:
-  metadata.gz: 4d6aec972d3b32bc66f70098ab1122472fef43c675d4eaba1b77cb4c3b74231a515f9ad877d648c8b28d3dc874b55475327b20ade2b2dcc85d70e3e15712fdbc
-  data.tar.gz: 65fd26f6e44e1bcaa18471e86662f53e46ae4c2ac9a91a82fb182adbb10c7ef6616e6ab5505379dbc42c414a6684f848864648c486567a59e2f9aa695de67f57
+  metadata.gz: bd9802dee13e72edb052c80bd4fea095eade14c95b0fe8cb31277c0a9c36de9f9c202d99bbc3a485911dc5035d6253589b3f50358f0d2b789f4756c19d211e72
+  data.tar.gz: c44636603bba32db00de362646b378238fcb884008b085627c1e19d66e899472d9c1a2539ffffd3eb076a58788afb3abec2eaecfb9b44274960e025d31c7ed34

data/lib/pdfrb/cli.rb

@@ -334,10 +334,16 @@ module Pdfrb
 
       # Set up the handler so Writer can encrypt per-object.
       handler = Pdfrb::Encryption::StandardSecurityHandler.new(
-        Encrypt: { V: v, R: r, Length: length, P: perms, O: o_entry, U: u_entry },
-        ID: [id0.b, id0.b]
+        {
+          Encrypt: { V: v, R: r, Length: length, P: perms,
+                     O: o_entry, U: u_entry },
+          ID: [id0.b, id0.b],
+        }
       )
-      handler.verify_user_password(user_pw)
+      unless handler.verify_user_password?(user_pw)
+        raise Pdfrb::EncryptionError, "failed to derive encryption key"
+      end
+
       doc.config["encryption.handler"] = handler
       doc.config["encryption.password"] = user_pw
     end

data/lib/pdfrb/digital_signature.rb

@@ -13,16 +13,17 @@ module Pdfrb
     autoload :TimestampHandler, "pdfrb/digital_signature/timestamp_handler"
     autoload :TimestampClient, "pdfrb/digital_signature/timestamp_client"
 
-    HANDLERS = {
-      "adbe.pkcs7.detached": CmsHandler,
-      "adbe.pkcs7.sha1": CmsHandler,
-      "adbe.revision": TimestampHandler,
-    }.freeze
-
     module_function
 
+    # Resolve the handler class for +sub_filter+. Constant references
+    # live inside the case so the autoloads above defer loading the
+    # handlers (and their OpenSSL surface) until an actual
+    # sign/verify call needs them.
     def handler_for(sub_filter)
-      HANDLERS[sub_filter.to_sym]
+      case sub_filter.to_sym
+      when :"adbe.pkcs7.detached", :"adbe.pkcs7.sha1" then CmsHandler
+      when :"adbe.revision" then TimestampHandler
+      end
     end
 
     def sign(document, cert:, key:, **)

data/lib/pdfrb/linearization/writer.rb

@@ -30,7 +30,7 @@ module Pdfrb
 
       def initialize(document)
         @document = document
-        @serializer = Pdfrb::Serializer.new
+        @serializer = Pdfrb::Writer.serializer_for(document)
       end
 
       # @param io [IO] target output.
@@ -70,7 +70,8 @@ module Pdfrb
 
         ordered.each do |obj|
           offsets[obj.oid] = temp.pos
-          temp << @serializer.serialize_indirect(obj)
+          temp << @serializer.serialize_indirect(obj,
+                                                 skip_string_encryption: encryption_dict?(obj))
         end
         first_page_end = temp.pos if first_page_objects.any?
 
@@ -79,7 +80,6 @@ module Pdfrb
         hint_compressed = ::Zlib::Deflate.deflate(hint_data)
         hint_offset = temp.pos
         hint_dict = @serializer.serialize(
-          Type: :XRef,
           S: HintStream::DEFAULT_ITEM_BITS,
           Filter: :FlateDecode,
           Length: hint_compressed.bytesize
@@ -132,7 +132,8 @@ module Pdfrb
         buf << lin_padded
 
         layout.ordered_objects.each do |obj|
-          buf << @serializer.serialize_indirect(obj)
+          buf << @serializer.serialize_indirect(obj,
+                                                skip_string_encryption: encryption_dict?(obj))
         end
 
         buf << "#{layout.hint_oid} 0 obj\n"
@@ -243,7 +244,16 @@ module Pdfrb
                    end
         size = [@document.next_oid || 1, 2].max
 
-        trailer_str = @serializer.serialize(Size: size, Root: root_ref)
+        trailer_hash = {}
+        (@document.trailer || {}).each do |k, v|
+          next if Pdfrb::Writer::TRAILER_OVERRIDDEN_KEYS.include?(k)
+
+          trailer_hash[k] = v
+        end
+        trailer_hash[:Size] = size
+        trailer_hash[:Root] = root_ref if root_ref
+
+        trailer_str = @serializer.serialize(trailer_hash)
         "trailer\n#{trailer_str}\nstartxref\n#{xref_offset}\n%%EOF\n"
       end
 
@@ -251,6 +261,11 @@ module Pdfrb
         "%PDF-1.7\n%\xE2\xE3\xCF\xD3\n"
       end
 
+      # The /Encrypt dictionary's own strings must stay in cleartext.
+      def encryption_dict?(obj)
+        (@document.trailer || {})[:Encrypt]&.oid == obj.oid
+      end
+
       def write_non_linearized(io)
         Pdfrb::Writer.write(@document, io)
       end

data/lib/pdfrb/serializer.rb

@@ -50,21 +50,28 @@ module Pdfrb
     end
 
     # Serialise an indirect object's body, including `oid gen obj`
-    # header and (for streams) the stream payload.
-    def serialize_indirect(obj)
+    # header and (for streams) the stream payload. When an encrypter
+    # is set, all strings in the object's dictionaries and the stream
+    # payload are encrypted with the per-object key (s7.6.1) — pass
+    # +skip_string_encryption:+ for the /Encrypt dictionary itself,
+    # whose entries must stay readable.
+    def serialize_indirect(obj, skip_string_encryption: false)
       raise ArgumentError, "not indirect: #{obj.inspect}" unless obj.indirect?
 
+      encrypt_strings = !skip_string_encryption && encrypter
       buffer = +""
       buffer << "#{obj.oid} #{obj.gen} obj\n"
       case obj
       when Pdfrb::Model::Cos::Stream
-        dict, payload = emit_stream(obj)
+        dict_value = encrypt_strings ? encrypt_value_strings(obj.value, obj.oid, obj.gen) : obj.value
+        dict, payload = emit_stream(obj, dict_value)
         buffer << dict
         buffer << "\nstream\n"
         buffer << (encrypter ? encrypter.encrypt(payload, obj.oid, obj.gen) : payload)
         buffer << "\nendstream\n"
       else
-        buffer << serialize(obj)
+        value = encrypt_strings ? encrypt_value_strings(obj.value, obj.oid, obj.gen) : obj.value
+        buffer << serialize(value)
         buffer << "\n"
       end
       buffer << "endobj\n"
@@ -73,12 +80,39 @@ module Pdfrb
 
     private
 
+    # Deep-transform +value+ so every literal string carries the
+    # per-object ciphertext (s7.6.1: strings AND streams encrypt).
+    def encrypt_value_strings(value, oid, gen)
+      case value
+      when ::Hash
+        value.each_with_object({}) do |(k, v), h|
+          h[k] = encrypt_value_strings(v, oid, gen)
+        end
+      when ::Array
+        value.map { |v| encrypt_value_strings(v, oid, gen) }
+      when Pdfrb::Model::PdfArray
+        Pdfrb::Model::PdfArray.new(value.map { |v| encrypt_value_strings(v, oid, gen) })
+      when Pdfrb::Model::Object
+        Pdfrb::Model::Object.new(encrypt_value_strings(value.value, oid, gen),
+                                 oid: value.oid, gen: value.gen)
+      when ::String
+        bytes = if value.encoding == Encoding::UTF_8
+                  Pdfrb::Model::Cos::StringEncoding.encode_text(value)
+                else
+                  value.dup.force_encoding(Encoding::BINARY)
+                end
+        encrypter.encrypt(bytes, oid, gen)
+      else
+        value
+      end
+    end
+
     # Build the dict body + payload for a stream object, applying
     # FlateDecode compression when enabled and the stream is large
     # enough to benefit. Returns [dict_bytes, payload_bytes].
-    def emit_stream(stream_obj)
+    def emit_stream(stream_obj, dict_value = stream_obj.value)
       payload = stream_obj.stream
-      hash = stream_obj.value.dup
+      hash = dict_value.dup
       existing_filter = hash[:Filter]
 
       if should_compress?(stream_obj, payload, existing_filter)

data/lib/pdfrb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pdfrb
-  VERSION = "0.8.6"
+  VERSION = "0.8.7"
 end

data/lib/pdfrb/writer.rb

@@ -17,24 +17,37 @@ module Pdfrb
   class Writer
     DEFAULT_VERSION = "1.4"
 
+    # Trailer keys each writer recomputes itself; existing values
+    # for these are never carried through from the parsed trailer.
+    TRAILER_OVERRIDDEN_KEYS = %i[Size Root Prev XRefStm].freeze
+
     attr_reader :document, :io, :serializer
 
     def initialize(document, io)
       @document = document
       @io = io
-      @serializer = Serializer.new(
+      @serializer = Writer.serializer_for(document)
+      @xref_offsets = {}
+    end
+
+    # Build a Serializer configured for +document+: stream compression
+    # from config, and an encrypter derived from the trailer /Encrypt.
+    # Raises EncryptionError when the document is encrypted but the
+    # configured password does not open it — writing must never
+    # silently fall back to plaintext.
+    def self.serializer_for(document)
+      Serializer.new(
         compress_streams: document.config["writer.compress_streams"],
         compress_min_size: document.config["writer.compress_min_size"],
-        **serializer_encrypter_opts
+        **serializer_encrypter_opts_for(document)
       )
-      @xref_offsets = {}
     end
 
     # Build the encrypter option for the Serializer from the document's
     # /Encrypt dict. If the document isn't encrypted, returns empty hash.
     # The SecurityHandler's encrypt_data method becomes the Serializer's
     # encrypter, which encrypts string/stream payloads per-object.
-    def serializer_encrypter_opts
+    def self.serializer_encrypter_opts_for(document)
       # Use a pre-configured handler if the document provides one
       # (e.g., set by the encryption CLI).
       handler = document.config["encryption.handler"]
@@ -50,15 +63,21 @@ module Pdfrb
       return {} unless encrypt_dict
 
       handler = Pdfrb::Encryption::StandardSecurityHandler.new(
-        Encrypt: encrypt_dict.value,
-        ID: trailer[:ID]
+        { Encrypt: encrypt_dict.value, ID: trailer[:ID] }
       )
       password = document.config["encryption.password"] || ""
-      handler.verify_user_password(password)
+      unless handler.verify_user_password?(password)
+        raise Pdfrb::EncryptionError,
+              "cannot write encrypted document: password does not verify"
+      end
 
       { encrypter: handler }
-    rescue StandardError
-      {}
+    end
+
+    # The /Encrypt dictionary's own strings (U, O, UE, OE, Perms) must
+    # stay in cleartext — they carry the password hashes.
+    def encryption_dict?(obj)
+      (document.trailer || {})[:Encrypt]&.oid == obj.oid
     end
 
     def self.write(document, io)
@@ -84,7 +103,8 @@ module Pdfrb
         next if packed.key?(obj.oid)
 
         @xref_offsets[obj.oid] = @io.pos
-        @io << @serializer.serialize_indirect(obj)
+        @io << @serializer.serialize_indirect(obj,
+                                              skip_string_encryption: encryption_dict?(obj))
       end
 
       xref_pos = if use_stream
@@ -118,7 +138,8 @@ module Pdfrb
         next unless obj.indirect?
 
         @xref_offsets[obj.oid] = @io.pos
-        @io << @serializer.serialize_indirect(obj)
+        @io << @serializer.serialize_indirect(obj,
+                                              skip_string_encryption: encryption_dict?(obj))
       end
       xref_pos = write_xref(prev: previous_xref_offset)
       write_trailer(xref_pos, prev: previous_xref_offset)
@@ -293,7 +314,7 @@ module Pdfrb
       existing = document.trailer || {}
       trailer_hash = {}
       existing.each do |k, v|
-        next if %i[Size Root Prev XRefStm].include?(k)
+        next if TRAILER_OVERRIDDEN_KEYS.include?(k)
 
         trailer_hash[k] = v
       end

data/lib/pdfrb.rb

@@ -47,8 +47,6 @@ module Pdfrb
   autoload :Serializer, "pdfrb/serializer"
   autoload :Writer, "pdfrb/writer"
   autoload :Importer, "pdfrb/importer"
-  autoload :Revision, "pdfrb/revision"
-  autoload :Revisions, "pdfrb/revisions"
   autoload :XrefSection, "pdfrb/xref_section"
   autoload :Document, "pdfrb/document"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdfrb
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.8.7
 platform: ruby
 authors:
 - Ribose Inc.