pdfrb 0.2.1 → 0.6.0

data/lib/pdfrb/content.rb

@@ -1,38 +1,19 @@
 # frozen_string_literal: true
 
 module Pdfrb
-  # Content-stream layer. Pages and Form XObjects carry a content
-  # stream: a sequence of `operands operator` instructions that draw
-  # graphics and text. This layer parses, walks, and emits those
-  # streams.
-  #
-  # Architecture mirrors HexaPDF::Content:
-  #   * +Tokenizer+ from Source layer produces tokens (content
-  #     streams use the same PDF object syntax as COS values).
-  #   * +Content::Parser+ groups operands + operator into invocations.
-  #   * +Content::Operator::Base+ subclasses implement each PDF
-  #     operator (one file per category — open/closed via `register`).
-  #   * +Content::Processor+ walks a stream, invoking operators
-  #     against a +GraphicsState+ (with a stack for `q`/`Q`).
-  #   * +Content::Canvas+ is the high-level drawing API on a Stream.
   module Content
     autoload :GraphicsState, "pdfrb/content/graphics_state"
     autoload :Operator, "pdfrb/content/operator"
     autoload :Parser, "pdfrb/content/parser"
     autoload :Processor, "pdfrb/content/processor"
+    autoload :ColorSpace, "pdfrb/content/color_space"
+    autoload :TransformationMatrix, "pdfrb/content/transformation_matrix"
     autoload :Canvas, "pdfrb/content/canvas"
     autoload :GraphicObject, "pdfrb/content/graphic_object"
+    autoload :Operators, "pdfrb/content/operators"
+    autoload :TilingPattern, "pdfrb/content/tiling_pattern"
+    autoload :HiddenTextDetector, "pdfrb/content/hidden_text_detector"
+    autoload :SmartTextExtractor, "pdfrb/content/smart_text_extractor"
+    autoload :Shading, "pdfrb/content/shading"
   end
 end
-
-# Eager-load operator subclasses so they self-register in the
-# Operator::REGISTRY. (Each file calls Operator.register at the bottom.)
-require "pdfrb/content/operators/general"
-require "pdfrb/content/operators/path"
-require "pdfrb/content/operators/painting"
-require "pdfrb/content/operators/text_state"
-require "pdfrb/content/operators/text_positioning"
-require "pdfrb/content/operators/text_showing"
-require "pdfrb/content/operators/color"
-require "pdfrb/content/operators/graphics_state_params"
-require "pdfrb/content/operators/marked_content"

data/lib/pdfrb/destination/fit.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Destination
+    # Destination fit types (ISO 32000-2 §12.3.2.2). Each type specifies
+    # how the page should be displayed when navigated to.
+    #
+    # OCP: new fit type = subclass + register_as.
+    class Fit
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(name, klass)
+          registry[name.to_sym] = klass
+        end
+
+        def [](name)
+          registry[name.to_sym]
+        end
+
+        def types
+          registry.keys
+        end
+
+        def fit_keyword
+          raise NotImplementedError
+        end
+
+        def register_as(name = fit_keyword)
+          Fit.register(name, self)
+          self
+        end
+      end
+
+      attr_reader :page_ref
+
+      def initialize(page_ref)
+        @page_ref = page_ref
+      end
+
+      # Serialize to the PDF destination array form.
+      # @return [Pdfrb::Model::PdfArray]
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, self.class.fit_keyword])
+      end
+    end
+
+    # /Fit — fit the entire page in the window.
+    class FullPage < Fit
+      class << self
+        def fit_keyword; :Fit; end
+      end
+      register_as
+    end
+
+    # /FitH top — fit width, top at +top+.
+    class FitHorizontal < Fit
+      attr_reader :top
+
+      def initialize(page_ref, top: nil)
+        super(page_ref)
+        @top = top
+      end
+
+      class << self
+        def fit_keyword; :FitH; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitH, @top].compact)
+      end
+      register_as
+    end
+
+    # /FitV left — fit height, left at +left+.
+    class FitVertical < Fit
+      attr_reader :left
+
+      def initialize(page_ref, left: nil)
+        super(page_ref)
+        @left = left
+      end
+
+      class << self
+        def fit_keyword; :FitV; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitV, @left].compact)
+      end
+      register_as
+    end
+
+    # /FitR left bottom right top — fit the specified rectangle.
+    class FitRectangle < Fit
+      attr_reader :left, :bottom, :right, :top
+
+      def initialize(page_ref, left:, bottom:, right:, top:)
+        super(page_ref)
+        @left = left
+        @bottom = bottom
+        @right = right
+        @top = top
+      end
+
+      class << self
+        def fit_keyword; :FitR; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitR, @left, @bottom, @right, @top])
+      end
+      register_as
+    end
+
+    # /XYZ left top zoom — explicit position and zoom.
+    class XYZ < Fit
+      attr_reader :left, :top, :zoom
+
+      def initialize(page_ref, left: nil, top: nil, zoom: nil)
+        super(page_ref)
+        @left = left
+        @top = top
+        @zoom = zoom
+      end
+
+      class << self
+        def fit_keyword; :XYZ; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :XYZ, @left, @top, @zoom].compact)
+      end
+      register_as
+    end
+
+    # /FitB — fit the bounding box of the page contents.
+    class FitBoundingBox < Fit
+      class << self
+        def fit_keyword; :FitB; end
+      end
+      register_as
+    end
+
+    # /FitBH top — fit bounding box width, top at +top+.
+    class FitBoundingBoxHorizontal < Fit
+      attr_reader :top
+
+      def initialize(page_ref, top: nil)
+        super(page_ref)
+        @top = top
+      end
+
+      class << self
+        def fit_keyword; :FitBH; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitBH, @top].compact)
+      end
+      register_as
+    end
+
+    # /FitBV left — fit bounding box height, left at +left+.
+    class FitBoundingBoxVertical < Fit
+      attr_reader :left
+
+      def initialize(page_ref, left: nil)
+        super(page_ref)
+        @left = left
+      end
+
+      class << self
+        def fit_keyword; :FitBV; end
+      end
+
+      def to_pdf
+        Pdfrb::Model::PdfArray.new([@page_ref, :FitBV, @left].compact)
+      end
+      register_as
+    end
+  end
+end

data/lib/pdfrb/destination.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  # Destinations (ISO 32000-2 §12.3.2). A destination specifies a view
+  # of a page: which page, how to fit it in the viewport, and optional
+  # position/zoom parameters.
+  #
+  # Each fit type is a value object that serializes to a PDF destination
+  # array: [page_ref /Fit], [page_ref /XYZ x y zoom], etc.
+  module Destination
+    autoload :Fit, "pdfrb/destination/fit"
+  end
+end

data/lib/pdfrb/digital_signature/cms_handler.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module DigitalSignature
+    module CmsHandler
+      module_function
+
+      def type; :"adbe.pkcs7.detached"; end
+
+      def sign(document, cert:, key:, **)
+        Pdfrb::DigitalSignature::Signing.sign(document, cert: cert, key: key, **)
+      end
+
+      def verify(signature_data, signed_data, trusted_certs: [])
+        pkcs7 = OpenSSL::PKCS7.new(signature_data)
+        store = OpenSSL::X509::Store.new
+        trusted_certs.each { |c| store.add_cert(c) }
+        pkcs7.verify(nil, store, signed_data, OpenSSL::PKCS7::DETACHED)
+      end
+    end
+  end
+end

data/lib/pdfrb/digital_signature/signing.rb

@@ -1,28 +1,124 @@
 # frozen_string_literal: true
 
 require "openssl"
+require "stringio"
 
 module Pdfrb
   module DigitalSignature
-    # PKCS#7 signing (s12.8.3). Creates a signature field, computes
-    # the byte-range hash, and embeds the detached PKCS#7 signature.
     module Signing
+      PLACEHOLDER_HEX_LEN = 8192
+
       module_function
 
-      def sign(document, cert:, key:, **_opts)
+      def sign(document, cert:, key:, reason: nil, name: nil)
         raise Pdfrb::Error, "OpenSSL cert required" unless cert.is_a?(OpenSSL::X509::Certificate)
         raise Pdfrb::Error, "OpenSSL PKey required" unless key.is_a?(OpenSSL::PKey::PKey)
 
-        # Create a signature field (widget annotation).
-        sig_dict = document.add(
-          {
-            Type: :Sig,
-            Filter: :Adobe.PPKLite,
-            SubFilter: :adbe.pkcs7.detached
-          },
+        sig_dict = build_sig_dict(document, reason: reason, name: name)
+        attach_to_acroform(document, sig_dict)
+
+        pdf = serialize(document)
+        pdf = insert_contents_placeholder(pdf, sig_dict.oid)
+        finalize_signature(pdf, cert, key)
+      end
+
+      def build_sig_dict(document, reason:, name:)
+        hash = {
+          Type: :Sig,
+          Filter: :"Adobe.PPKLite",
+          SubFilter: :"adbe.pkcs7.detached",
+          ByteRange: [0, 0, 0, 0],
+        }
+        hash[:Reason] = reason if reason
+        hash[:Name] = name if name
+        hash[:M] = "D:#{Time.now.utc.strftime("%Y%m%d%H%M%S+00'00'")}"
+        document.add(hash, type: Pdfrb::Model::Cos::Dictionary)
+      end
+
+      def attach_to_acroform(document, sig_dict)
+        catalog = document.catalog
+        catalog.value[:AcroForm] ||= {}
+        catalog.value[:AcroForm][:SigFlags] = 3
+        catalog.value[:AcroForm][:Fields] ||= []
+
+        field = document.add(
+          { Type: :Annot, Subtype: :Widget, FT: :Sig, T: "Signature1",
+            V: Pdfrb::Model::Reference.new(sig_dict.oid, sig_dict.gen),
+            Rect: [0, 0, 0, 0] },
           type: Pdfrb::Model::Cos::Dictionary
         )
-        sig_dict
+        catalog.value[:AcroForm][:Fields] <<
+          Pdfrb::Model::Reference.new(field.oid, field.gen)
+      end
+
+      def serialize(document)
+        io = StringIO.new
+        Pdfrb::Writer.write(document, io)
+        io.string
+      end
+
+      def insert_contents_placeholder(pdf, sig_oid)
+        sig_pattern = "#{sig_oid} 0 obj"
+        sig_start = pdf.index(sig_pattern)
+        return pdf unless sig_start
+
+        dict_end = pdf.index(">>", sig_start)
+        return pdf unless dict_end
+
+        placeholder = "0" * PLACEHOLDER_HEX_LEN
+        contents_str = "/Contents <#{placeholder}>"
+
+        "#{pdf[0, dict_end + 2]}\n#{contents_str}#{pdf[(dict_end + 2)..]}"
+      end
+
+      def finalize_signature(pdf, cert, key)
+        marker = "/Contents <"
+        contents_marker = pdf.index(marker)
+        return pdf unless contents_marker
+
+        hex_start = contents_marker + marker.bytesize
+        hex_end = pdf.index(">", hex_start)
+        return pdf unless hex_end
+
+        part1_end = hex_start
+        part2_start = hex_end + 1
+        part2_len = pdf.bytesize - part2_start
+
+        br_old = "/ByteRange [0 0 0 0]"
+        br_new = "/ByteRange [0 #{part1_end} #{part2_start} #{part2_len}]"
+        size_diff = br_new.bytesize - br_old.bytesize
+
+        if size_diff.positive?
+          part1_end += size_diff
+          part2_start += size_diff
+          br_new = "/ByteRange [0 #{part1_end} #{part2_start} #{part2_len}]"
+          new_size_diff = br_new.bytesize - br_old.bytesize
+          if new_size_diff != size_diff
+            adjust = new_size_diff - size_diff
+            part1_end += adjust
+            part2_start += adjust
+            br_new = "/ByteRange [0 #{part1_end} #{part2_start} #{part2_len}]"
+          end
+        elsif size_diff.negative?
+          br_new = br_new.ljust(br_old.bytesize)
+        end
+
+        pdf = pdf.sub(br_old, br_new)
+
+        hex_start = part1_end
+        hex_end = pdf.index(">", hex_start)
+        hex_len = hex_end - hex_start
+
+        signed_data = pdf.bytes[0, part1_end].pack("C*") +
+          pdf.bytes[part2_start, part2_len].pack("C*")
+
+        der = OpenSSL::PKCS7.sign(cert, key, signed_data, [],
+                                  OpenSSL::PKCS7::DETACHED |
+                                  OpenSSL::PKCS7::BINARY).to_der
+
+        hex_sig = der.unpack1("H*").ljust(hex_len, "0")
+
+        pdf[0, hex_start] + hex_sig + pdf[hex_end..]
       end
     end
   end

data/lib/pdfrb/digital_signature/timestamp_handler.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module DigitalSignature
+    module TimestampHandler
+      module_function
+
+      def type; :"adbe.revision"; end
+
+      def create_timestamp(data, tsa_url: nil)
+        return nil unless tsa_url
+
+        require "net/http"
+        require "uri"
+
+        uri = URI(tsa_url)
+        response = Net::HTTP.start(uri.host, uri.port) do |http|
+          req = Net::HTTP::Post.new(uri.request_uri)
+          req["Content-Type"] = "application/timestamp-query"
+          req.body = build_tsr_request(data)
+          http.request(req)
+        end
+
+        response.body if response.is_a?(Net::HTTPSuccess)
+      end
+
+      def build_tsr_request(data)
+        require "openssl"
+        hash = OpenSSL::Digest.new("SHA256")
+        req = OpenSSL::ASN1::Sequence.new([
+                                            OpenSSL::ASN1::Integer.new(1),
+                                            OpenSSL::ASN1::Sequence.new([
+                                                                          OpenSSL::ASN1::Sequence.new([
+                                                                                                        OpenSSL::ASN1::ObjectId.new("2.16.840.1.101.3.4.2.1"),
+                                                                                                        OpenSSL::ASN1::OctetString.new(hash.digest(data).force_encoding("BINARY")),
+                                                                                                      ]),
+                                                                        ]),
+                                            OpenSSL::ASN1::Integer.new(0),
+                                            OpenSSL::ASN1::Boolean.new(false),
+                                          ])
+        req.to_der
+      end
+    end
+  end
+end

data/lib/pdfrb/digital_signature/verification.rb

@@ -1,21 +1,100 @@
 # frozen_string_literal: true
 
 require "openssl"
+require "stringio"
 
 module Pdfrb
   module DigitalSignature
-    # PKCS#7 signature verification (s12.8.3). Extracts signature
-    # from the document, checks byte-range integrity, and verifies
-    # the cert chain against the system trust store.
     module Verification
-      Result = Struct.new(:signer, :valid?, :byte_range_ok?,
-                          :cert_chain, :error, keyword_init: true)
-
       module_function
 
-      def verify(document)
-        Result.new(signer: nil, valid?: false, byte_range_ok?: nil,
-                   cert_chain: [], error: "verification stub — not yet implemented")
+      def verify(pdf_bytes, trusted_certs: [])
+        results = []
+        offset = 0
+
+        loop do
+          sig_info = find_signature(pdf_bytes, offset)
+          break unless sig_info
+
+          results << verify_signature(pdf_bytes, sig_info, trusted_certs)
+          offset = sig_info[:contents_end] + 1
+        end
+
+        results
+      end
+
+      def find_signature(pdf_bytes, start_offset)
+        contents_marker = "/Contents <"
+        ck_start = pdf_bytes.index(contents_marker, start_offset)
+        return nil unless ck_start
+
+        hex_start = ck_start + contents_marker.bytesize
+        hex_end = pdf_bytes.index(">", hex_start)
+        return nil unless hex_end
+
+        br_start = pdf_bytes.rindex("/ByteRange [", ck_start)
+        return nil unless br_start
+
+        br_str_start = br_start + "/ByteRange [".bytesize
+        br_end = pdf_bytes.index("]", br_str_start)
+        return nil unless br_end
+
+        br_str = pdf_bytes[br_str_start...br_end]
+        byte_range = br_str.split.map(&:to_i)
+
+        {
+          byte_range: byte_range,
+          contents_hex_start: hex_start,
+          contents_hex_end: hex_end,
+          contents_end: hex_end,
+        }
+      end
+
+      def verify_signature(pdf_bytes, sig_info, trusted_certs)
+        byte_range = sig_info[:byte_range]
+
+        if byte_range.nil? || byte_range.length != 4
+          return VerificationResult.new(valid?: false,
+                                        byte_range_ok?: false,
+                                        cert_chain: [],
+                                        error: "invalid ByteRange")
+        end
+
+        _start1, len1, start2, len2 = byte_range
+        part1 = pdf_bytes.bytes[0, len1] || []
+        part2 = pdf_bytes.bytes[start2, len2] || []
+        signed_data = part1.pack("C*") + part2.pack("C*")
+
+        hex_start = sig_info[:contents_hex_start]
+        hex_end = sig_info[:contents_hex_end]
+        contents_hex = pdf_bytes[hex_start...hex_end]
+        contents_hex = contents_hex.sub(/0+$/, "")
+
+        begin
+          der = [contents_hex].pack("H*")
+          pkcs7 = OpenSSL::PKCS7.new(der)
+
+          store = OpenSSL::X509::Store.new
+          trusted_certs.each { |c| store.add_cert(c) }
+
+          valid = pkcs7.verify(nil, store, signed_data,
+                               OpenSSL::PKCS7::DETACHED |
+                               OpenSSL::PKCS7::BINARY)
+
+          VerificationResult.new(
+            signer: pkcs7.signers.first&.issuer&.to_s,
+            valid?: valid,
+            byte_range_ok?: true,
+            cert_chain: pkcs7.certificates || [],
+            trusted?: !trusted_certs.empty? && valid,
+            error: valid ? nil : "signature verification failed",
+          )
+        rescue OpenSSL::PKCS7::PKCS7Error => e
+          VerificationResult.new(valid?: false,
+                                 byte_range_ok?: true,
+                                 cert_chain: [],
+                                 error: e.message)
+        end
       end
     end
   end

data/lib/pdfrb/digital_signature/verification_result.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module DigitalSignature
+    VerificationResult = Struct.new(
+      :signer, :valid?, :byte_range_ok?, :cert_chain, :error,
+      :signed_at, :trusted?, keyword_init: true
+    ) do
+      def trusted?; self[:trusted?]; end
+      def has_error?; !error.nil?; end
+      def cert_count; cert_chain&.length || 0; end
+    end
+  end
+end

data/lib/pdfrb/digital_signature.rb

@@ -1,11 +1,35 @@
 # frozen_string_literal: true
 
 module Pdfrb
-  # Digital signatures (s12.8). Stub implementation — full PKCS#7
-  # signing + verification needs the OpenSSL PKCS7 module.
+  # Digital signatures (s12.8). PKCS#7 detached signing + verification
+  # against a cert + private key pair. CMS handler is the default
+  # +adbe.pkcs7.detached+ subfilter.
   module DigitalSignature
     autoload :Handler, "pdfrb/digital_signature/handler"
     autoload :Signing, "pdfrb/digital_signature/signing"
     autoload :Verification, "pdfrb/digital_signature/verification"
+    autoload :VerificationResult, "pdfrb/digital_signature/verification_result"
+    autoload :CmsHandler, "pdfrb/digital_signature/cms_handler"
+    autoload :TimestampHandler, "pdfrb/digital_signature/timestamp_handler"
+
+    HANDLERS = {
+      "adbe.pkcs7.detached": CmsHandler,
+      "adbe.pkcs7.sha1": CmsHandler,
+      "adbe.revision": TimestampHandler,
+    }.freeze
+
+    module_function
+
+    def handler_for(sub_filter)
+      HANDLERS[sub_filter.to_sym]
+    end
+
+    def sign(document, cert:, key:, **)
+      Handler.sign(document, cert: cert, key: key, **)
+    end
+
+    def verify(document, trusted_certs: [])
+      Handler.verify(document, trusted_certs: trusted_certs)
+    end
   end
 end