pdfrb 0.7.13 → 0.7.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebb3cb6d645dd2e4f01dbfdcfc49e51ed0857281fc996a38ddb29afb18aef4e7
-  data.tar.gz: 9b359396f34164f661bebece73f26dd92fc9ea804c8edd802e53d80c6fccb334
+  metadata.gz: '0117148def4f7bc7280fa9727a6ce26fcafa9cb8f6e31cb32a480cb9548ac99e'
+  data.tar.gz: a7bf629aabbef013625f56e4c719f97a4fa6bc2823c158d4d7f37ea9c6ff8379
 SHA512:
-  metadata.gz: a3eb6c87f3e7b10fdb310669943b3f61cf206c10f3ad61a998673b83f94dc6aef3082a22ef8f56632dad2e75a858b39c7a969a0590779f8ae3b7320c6c78ff90
-  data.tar.gz: 9a1453e1556d9c968b3176aa207773e4083687441f7f8025941d82b4f34394a68fba1b3f7a386b4fb73743fb4770ca7c055276f28100b9686f40f6165eb69c76
+  metadata.gz: f7d17104eaf145c31e843f94e622dd181b965f18aa4e3aba4adb80bedbdb500855984c603ef2ce60fa4abec31d1e4a07841d96397a71452147a6bff19c122b94
+  data.tar.gz: e3513e197dff0e244f97adff17e332ff74b75509054449c32a779e8926bf1fbb91f9965b8a5757f78dbeb54f5e09741260b4139aef31f79cb0caaa25ca878b17

data/lib/pdfrb/digital_signature/verification.rb

@@ -89,7 +89,7 @@ module Pdfrb
             trusted?: !trusted_certs.empty? && valid,
             error: valid ? nil : "signature verification failed",
           )
-        rescue OpenSSL::PKCS7::PKCS7Error => e
+        rescue OpenSSL::PKCS7::PKCS7Error, ArgumentError => e
           VerificationResult.new(valid?: false,
                                  byte_range_ok?: true,
                                  cert_chain: [],

data/lib/pdfrb/document/encryption.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+require "securerandom"
+
+module Pdfrb
+  class Document
+    # Encryption facade. Exposes a clean API for encrypting a
+    # document (builds the /Encrypt dict, wires the security handler
+    # into the writer config) and for checking encryption status.
+    #
+    # Usage:
+    #   doc.encryption.encrypt!(
+    #     user_password: "reader",
+    #     owner_password: "owner",
+    #     bits: 128,
+    #     permissions: %i[print copy]
+    #   )
+    #   doc.write("encrypted.pdf")
+    class Encryption
+      PERMISSION_FLAGS = {
+        print: 1 << 2,
+        modify: 1 << 3,
+        copy: 1 << 4,
+        annotate: 1 << 5,
+        fill: 1 << 8,
+        extract: 1 << 9,
+        assemble: 1 << 10,
+        print_hq: 1 << 11,
+      }.freeze
+
+      attr_reader :document
+
+      def initialize(document)
+        @document = document
+      end
+
+      # Encrypt this document with a user + owner password.
+      #
+      # @param user_password [String] the password readers need to open.
+      # @param owner_password [String] the password that grants full
+      #   permissions (defaults to user_password).
+      # @param bits [Integer] key length: 40, 128 (AES-128), or
+      #   256 (AES-256 R6).
+      # @param permissions [Array<Symbol>] granted permissions from
+      #   PERMISSION_FLAGS keys; any not listed are denied.
+      # @return [Pdfrb::Model::Cos::Dictionary] the /Encrypt dict.
+      def encrypt!(user_password:, owner_password: nil, bits: 128,
+                   permissions: PERMISSION_FLAGS.keys)
+        case bits
+        when 256 then encrypt_v5(user_password, owner_password || user_password, permissions)
+        when 128 then encrypt_rc4(user_password, owner_password || user_password,
+                                  permissions, v: 4, r: 4, length: 128)
+        when 40 then encrypt_rc4(user_password, owner_password || user_password,
+                                 permissions, v: 2, r: 3, length: 40)
+        else
+          raise Pdfrb::EncryptionError,
+                "unsupported key length: #{bits} (use 40, 128, or 256)"
+        end
+      end
+
+      # Whether the document has an /Encrypt dict in the trailer.
+      def encrypted?
+        trailer = document.trailer
+        !trailer.nil? && !trailer[:Encrypt].nil?
+      end
+
+      # Remove /Encrypt from the trailer (decrypt use case). Returns
+      # self for chaining; use encrypted? to check the result.
+      def decrypt!
+        trailer = document.trailer
+        if trailer && trailer[:Encrypt]
+          if trailer.is_a?(Pdfrb::Model::Cos::Dictionary)
+            trailer.value.delete(:Encrypt)
+          else
+            trailer.delete(:Encrypt)
+          end
+          document.config["encryption.handler"] = nil
+          document.config["encryption.password"] = nil
+        end
+        self
+      end
+
+      # Compute the /P integer: all bits set minus the denied ones.
+      def self.permission_bits(granted)
+        base = -1
+        PERMISSION_FLAGS.each do |name, bit|
+          base &= ~bit unless granted.include?(name)
+        end
+        base
+      end
+
+      private
+
+      def ensure_id!
+        id0 = Digest::MD5.hexdigest(Time.now.to_s + rand.to_s)[0, 16]
+        trailer = document.trailer
+        if trailer.is_a?(Pdfrb::Model::Cos::Dictionary)
+          trailer.value[:ID] = [id0.b, id0.b]
+        else
+          trailer[:ID] = [id0.b, id0.b]
+        end
+        id0.b
+      end
+
+      # RC4-based encryption for V2/V4 (40-bit or 128-bit).
+      def encrypt_rc4(user_pw, owner_pw, permissions, v:, r:, length:)
+        p_bits = self.class.permission_bits(permissions)
+        id0 = ensure_id!
+
+        o_entry = compute_o_entry(user_pw, owner_pw, r, length)
+        key = Pdfrb::Encryption::PasswordVerification.derive_key_rc4(
+          password: user_pw, o_entry: o_entry.b, p_flags: p_bits,
+          id0: id0, revision: r, key_length_bits: length,
+          encrypt_metadata: true
+        )
+        u_entry =
+          if r == 2
+            Pdfrb::Encryption::PasswordVerification.build_u_r2(key)
+          else
+            Pdfrb::Encryption::PasswordVerification.build_u_r3plus(
+              file_key: key, id0: id0, revision: r
+            )
+          end
+
+        register({ Filter: :Standard, V: v, R: r, Length: length,
+                   P: p_bits, O: o_entry, U: u_entry },
+                 user_password: user_pw)
+      end
+
+      # AES-256 R6 encryption for V5.
+      def encrypt_v5(user_pw, owner_pw, permissions)
+        p_bits = self.class.permission_bits(permissions)
+        id0 = ensure_id!
+
+        handler = Pdfrb::Encryption::StandardSecurityHandler.for_v5(
+          user_password: user_pw, owner_password: owner_pw,
+          permissions: p_bits, id: id0
+        )
+        dict = handler.encrypt_dict
+        register({ Filter: :Standard, V: dict[:V], R: dict[:R],
+                   Length: dict[:Length], P: p_bits,
+                   O: dict[:O], U: dict[:U], UE: dict[:UE],
+                   OE: dict[:OE], Perms: dict[:Perms] },
+                 user_password: user_pw,
+                 prebuilt_handler: handler)
+      end
+
+      # Compute the /O entry per Algorithm 3 (owner password hash).
+      def compute_o_entry(user_pw, owner_pw, revision, length_bits)
+        require "digest/md5"
+        pv = Pdfrb::Encryption::PasswordVerification
+        padded = pv.pad_password(owner_pw)
+        digest = Digest::MD5.digest(padded)
+        if revision >= 3
+          50.times do
+            digest = if length_bits >= 128
+                       Digest::MD5.digest(digest[0, length_bits / 8])
+                     else
+                       Digest::MD5.digest(digest[0, 5])
+                     end
+          end
+        end
+        rc4 = Pdfrb::Encryption::RC4Impl.new(digest[0, length_bits / 8])
+        o = rc4.process(pv.pad_password(user_pw))
+        if revision >= 3
+          19.downto(1) do |i|
+            key = digest[0, length_bits / 8].bytes.map { |b| b ^ i }.pack("C*")
+            o = Pdfrb::Encryption::RC4Impl.new(key).process(o)
+          end
+        end
+        o
+      end
+
+      # Register the encrypt dict in the trailer + wire the handler.
+      def register(encrypt_hash, user_password:, prebuilt_handler: nil)
+        dict = document.add(encrypt_hash,
+                            type: Pdfrb::Model::Type::EncryptionStandard)
+        ref = Pdfrb::Model::Reference.new(dict.oid, dict.gen)
+        trailer = document.trailer
+        if trailer.is_a?(Pdfrb::Model::Cos::Dictionary)
+          trailer.value[:Encrypt] = ref
+        else
+          trailer[:Encrypt] = ref
+        end
+
+        handler = prebuilt_handler || begin
+          h = Pdfrb::Encryption::StandardSecurityHandler.new(
+            { Encrypt: encrypt_hash,
+              ID: if trailer.is_a?(Pdfrb::Model::Cos::Dictionary)
+                    trailer.value[:ID]
+                  else
+                    trailer[:ID]
+                  end }
+          )
+          h.verify_user_password?(user_password)
+          h
+        end
+        document.config["encryption.handler"] = handler
+        document.config["encryption.password"] = user_password
+        dict
+      end
+    end
+  end
+end

data/lib/pdfrb/document.rb

@@ -31,6 +31,7 @@ module Pdfrb
     autoload :Info, "pdfrb/document/info"
     autoload :PageLabels, "pdfrb/document/page_labels"
     autoload :Stamps, "pdfrb/document/stamps"
+    autoload :Encryption, "pdfrb/document/encryption"
 
     def initialize(io: nil, config: {})
       Pdfrb::Model::Type.eager_load!
@@ -163,6 +164,8 @@ module Pdfrb
 
     def stamps; @stamps ||= Document::Stamps.new(self); end
 
+    def encryption; @encryption ||= Document::Encryption.new(self); end
+
     def info; @info ||= Document::Info.new(self); end
 
     def display; @display ||= Document::Display.new(self); end

data/lib/pdfrb/encryption/standard_security_handler.rb

@@ -219,7 +219,11 @@ module Pdfrb
         hash = md5.digest
 
         rc4 = RC4Impl.new(key)
-        20.times { |i| hash = rc4.process(hash, key ^ i) }
+        19.downto(1) do |i|
+          xored_key = key.bytes.map { |b| b ^ i }.pack("C*")
+          rc4 = RC4Impl.new(xored_key)
+          hash = rc4.process(hash)
+        end
 
         hash[0, 16]
       end

data/lib/pdfrb/model/type/thumbnail.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Thumbnail image stream (ISO 32000-2 §12.3.4). A small image
+      # XObject rendered at reduced resolution for use in viewer
+      # navigation panels. Attached to a page via the /Thumb key.
+      class Thumbnail < Pdfrb::Model::Cos::Stream
+        arlington_object "Thumbnail"
+
+        # /Width — required.
+        def width
+          value[:Width]
+        end
+
+        # /Height — required.
+        def height
+          value[:Height]
+        end
+
+        # /ColorSpace — required unless /ImageMask true.
+        def color_space
+          value[:ColorSpace]
+        end
+
+        # /BitsPerComponent — required.
+        def bits_per_component
+          value[:BitsPerComponent]
+        end
+
+        # /Filter — optional; a named filter or array of filters.
+        def filter
+          value[:Filter]
+        end
+
+        def dimensions
+          [width, height]
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/timespan.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Timespan (ISO 32000-2 §12.7.11, PDF 1.5+). A duration with
+      # a unit, used in RichMedia timing, 3D animation, and
+      # JavaScript-embedded timelines.
+      class Timespan < Pdfrb::Model::Cos::Dictionary
+        arlington_object "Timespan"
+
+        # /Type — optional, fixed "Timespan".
+        def type
+          value[:Type]&.to_sym
+        end
+
+        # /S — required, fixed "S" (seconds).
+        def subtype
+          value[:S]&.to_sym
+        end
+
+        # /V — required, the numeric duration in seconds.
+        def duration
+          value[:V]
+        end
+
+        # Convenience: duration in milliseconds.
+        def milliseconds
+          v = duration
+          v ? v.to_f * 1000 : nil
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/user_property.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # UserProperty (ISO 32000-2 §14.7.5). A single property in the
+      # /P array of a user property list attached to structure
+      # elements for custom metadata.
+      class UserProperty < Pdfrb::Model::Cos::Dictionary
+        arlington_object "UserProperty"
+
+        # /N — required, the property name.
+        def name
+          value[:N]
+        end
+
+        # /V — required, the property value (any COS type).
+        def property_value
+          value[:V]
+        end
+
+        # /F — optional, a text string with the intended format of
+        # the value.
+        def format
+          value[:F]
+        end
+
+        # /H — optional, whether the property is hidden from the
+        # user (default false).
+        def hidden?
+          value[:H] == true
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/viewport.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Viewport (ISO 32000-2 §12.7.11, PDF 1.6+). Defines a
+      # rectangular region of a page intended for separate display,
+      # used for magnifier rectangles, measurement regions, and
+      # zoom targets.
+      class Viewport < Pdfrb::Model::Cos::Dictionary
+        arlington_object "Viewport"
+
+        # /Type — optional, fixed "Viewport".
+        def type
+          value[:Type]&.to_sym
+        end
+
+        # /BBox — required, the viewport rectangle.
+        def bbox
+          value[:BBox]
+        end
+
+        # /Name — optional, human-readable viewport name.
+        def name
+          value[:Name]
+        end
+
+        # /Measure — optional indirect Measure dict (RL for rulers,
+        # GEO for geospatial since PDF 2.0).
+        def measure(document = nil)
+          ref = value[:Measure]
+          return nil unless ref && document
+
+          ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/vri.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # VRI (Validation Related Information) dictionary per ETSI EN
+      # 319 142-1 (PAdES) §B.5. Lives in /DSS /VRI map, keyed by the
+      # hex-encoded SHA-1 of the signature it validates. Holds the
+      # certificates, CRLs, and OCSP responses relevant to one
+      # signature.
+      class Vri < Pdfrb::Model::Cos::Dictionary
+        arlington_object "VRI"
+
+        # /Type — optional, fixed "VRI".
+        def type
+          value[:Type]&.to_sym
+        end
+
+        # /Cert — array of indirect streams, each a DER-encoded
+        # X.509 certificate relevant to the signature.
+        def certificates(document = nil)
+          refs = value[:Cert]
+          return [] unless refs
+
+          resolve_refs(refs, document)
+        end
+
+        # /CRL — array of indirect streams, each a DER-encoded
+        # certificate revocation list.
+        def crls(document = nil)
+          refs = value[:CRL]
+          return [] unless refs
+
+          resolve_refs(refs, document)
+        end
+
+        # /OCSP — array of indirect streams, each a DER-encoded
+        # OCSP response.
+        def ocsp_responses(document = nil)
+          refs = value[:OCSP]
+          return [] unless refs
+
+          resolve_refs(refs, document)
+        end
+
+        # /TU — optional string-text with a human-readable timestamp.
+        def timestamp_text
+          value[:TU]
+        end
+
+        # /TS — optional indirect stream with a timestamp token.
+        def timestamp_token(document = nil)
+          ref = value[:TS]
+          return nil unless ref && document
+
+          ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+        end
+
+        private
+
+        def resolve_refs(refs, document)
+          return [] unless document
+
+          arr = refs.is_a?(Pdfrb::Model::PdfArray) ? refs.value : refs
+          arr = [arr] unless arr.is_a?(::Array)
+          arr.filter_map do |r|
+            next r unless r.is_a?(Pdfrb::Model::Reference)
+
+            document.object(r)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type.rb

@@ -356,6 +356,21 @@ module Pdfrb
 
       # Page-piece dictionary (s14.5).
       autoload :PagePieceInfo, "pdfrb/model/type/page_piece_info"
+
+      # PAdES validation-related information (ETSI EN 319 142-1).
+      autoload :Vri, "pdfrb/model/type/vri"
+
+      # Page thumbnails (s12.3.4).
+      autoload :Thumbnail, "pdfrb/model/type/thumbnail"
+
+      # Timespan (s12.7.11, PDF 1.5+).
+      autoload :Timespan, "pdfrb/model/type/timespan"
+
+      # Viewport (s12.7.11, PDF 1.6+).
+      autoload :Viewport, "pdfrb/model/type/viewport"
+
+      # User property (s14.7.5).
+      autoload :UserProperty, "pdfrb/model/type/user_property"
     end
   end
 end

data/lib/pdfrb/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdfrb
 version: !ruby/object:Gem::Version
-  version: 0.7.13
+  version: 0.7.15
 platform: ruby
 authors:
 - Ribose Inc.
@@ -817,6 +817,7 @@ files:
 - lib/pdfrb/document/colors.rb
 - lib/pdfrb/document/destinations.rb
 - lib/pdfrb/document/display.rb
+- lib/pdfrb/document/encryption.rb
 - lib/pdfrb/document/files.rb
 - lib/pdfrb/document/fonts.rb
 - lib/pdfrb/document/form.rb
@@ -1149,14 +1150,19 @@ files:
 - lib/pdfrb/model/type/three_d_stream.rb
 - lib/pdfrb/model/type/three_d_units.rb
 - lib/pdfrb/model/type/three_d_view.rb
+- lib/pdfrb/model/type/thumbnail.rb
+- lib/pdfrb/model/type/timespan.rb
 - lib/pdfrb/model/type/to_unicode_cmap_stream.rb
 - lib/pdfrb/model/type/transition.rb
 - lib/pdfrb/model/type/underline_annotation.rb
 - lib/pdfrb/model/type/ur_transform_parameters.rb
 - lib/pdfrb/model/type/uri_dict.rb
 - lib/pdfrb/model/type/url_alias.rb
+- lib/pdfrb/model/type/user_property.rb
 - lib/pdfrb/model/type/variable_text_field.rb
 - lib/pdfrb/model/type/viewer_preferences.rb
+- lib/pdfrb/model/type/viewport.rb
+- lib/pdfrb/model/type/vri.rb
 - lib/pdfrb/model/type/watermark_annotation.rb
 - lib/pdfrb/model/type/widget_annotation.rb
 - lib/pdfrb/model/type/widget_appearance.rb