pdfrb 0.7.1 → 0.7.10

data/lib/pdfrb/color/default_profile.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Pdfrb
+  module Color
+    # Default sRGB ICC profile accessor. Builds a usable sRGB v4
+    # ICC profile (header + tag table + tagged elements) that real
+    # PDF readers can consume for ICCBased color spaces. The profile
+    # includes:
+    #
+    #   * desc  — profile description (sRGB by pdfrb)
+    #   * wtpt  — D50 media white point
+    #   * rXYZ, gXYZ, bXYZ — sRGB colorant matrix (D50-adapted)
+    #   * rTRC, gTRC, bTRC — gamma 2.2 tone reproduction curves
+    #
+    # Tagged-element types follow ICC.1:2022 §10 (multiLocalizedUnicodeType
+    # for desc, XYZType for colorants, curveType for TRCs).
+    module DefaultProfile
+      SRGB_SIGNATURE = "acsp".b
+      ICC_VERSION_V4 = [0x04, 0x40, 0x00, 0x00].freeze
+
+      module_function
+
+      # Returns the sRGB ICC profile bytes (~ 600 bytes). Includes
+      # the structural header + tag table + tagged elements needed
+      # for a real ICCBased color space.
+      def srgb_bytes
+        tags = build_srgb_tags
+        tag_table = build_tag_table(tags)
+        header = build_srgb_header(tag_table.bytesize + tags_total_size(tags))
+        profile = header + tag_table
+        tags.each_value { |tag_bytes| profile << tag_bytes }
+        # Compute MD5 ProfileID over the on-disk profile (sans the
+        # existing ID slot, which we'll patch in). ICC.1:2022 §7.1.
+        profile = patch_profile_id(profile)
+        profile.force_encoding(Encoding::BINARY)
+      end
+
+      # Build an ICCBased color space array referencing a new stream
+      # containing the sRGB profile bytes. Returns
+      # [:ICCBased, ref] suitable for /ColorSpace resources.
+      def srgb_color_space(document)
+        bytes = srgb_bytes
+        stream = document.add(
+          { N: 3, Length: bytes.bytesize },
+          type: Pdfrb::Model::Cos::Stream
+        )
+        stream.stream = bytes
+        [:ICCBased, Pdfrb::Model::Reference.new(stream.oid, stream.gen)]
+      end
+
+      # ---- Header construction ----
+
+      def build_srgb_header(tag_section_size)
+        header = +""
+        header << ([0] * 4).pack("C*")                # Profile size placeholder
+        header << ([0] * 4).pack("C*")                # Preferred CMM
+        header << ICC_VERSION_V4.pack("C*")           # Version 4.4
+        header << "mntr"                              # Device class
+        header << "RGB "                              # Color space
+        header << "XYZ "                              # PCS
+        header << date_bytes                          # Date
+        header << SRGB_SIGNATURE # 'acsp'
+        header << "APPL"                              # Primary platform
+        header << ([0] * 4).pack("C*")                # Profile flags
+        header << ([0] * 4).pack("C*")                # Device manufacturer
+        header << ([0] * 4).pack("C*")                # Device model
+        header << ([0] * 8).pack("C*")                # Device attributes
+        header << ([0] * 4).pack("C*")                # Rendering intent (perceptual)
+        header << d50_illuminant_bytes                # PCS illuminant (D50)
+        header << ([0] * 4).pack("C*")                # Profile creator
+        header << ([0] * 16).pack("C*")               # Profile ID (MD5, patched later)
+        header << ([0] * 28).pack("C*")               # Reserved
+
+        total_size = header.bytesize + tag_section_size
+        header[0, 4] = [total_size].pack("N")
+        header
+      end
+
+      def date_bytes
+        [0x07, 0xE8, 0x00, 0x01, 0x00, 0x01,
+         0x00, 0x00, 0x00, 0x00, 0x00, 0x00].pack("C*")
+      end
+
+      def d50_illuminant_bytes
+        # D50 X=0.9642, Y=1.0, Z=0.8249 in s15Fixed16.
+        [0x00, 0x00, 0xF6, 0xD6, 0x00, 0x01, 0x00, 0x00,
+         0x00, 0x00, 0xD3, 0x2D].pack("C*")
+      end
+
+      # ---- Tag table + tagged elements ----
+
+      # Returns a Hash of { tag_signature => tag_bytes } in the
+      # order they should appear after the tag table.
+      def build_srgb_tags
+        {
+          "desc" => desc_tag_bytes("sRGB by pdfrb"),
+          "wtpt" => xyz_tag_bytes(d50_xyz),
+          "rXYZ" => xyz_tag_bytes(srgb_r_xyz),
+          "gXYZ" => xyz_tag_bytes(srgb_g_xyz),
+          "bXYZ" => xyz_tag_bytes(srgb_b_xyz),
+          "rTRC" => curve_tag_bytes,
+          "gTRC" => curve_tag_bytes,
+          "bTRC" => curve_tag_bytes,
+        }
+      end
+
+      def build_tag_table(tags)
+        out = +""
+        count = tags.length
+        out << [count].pack("N")
+
+        # Compute offsets: tag table is 4 + count*12 bytes; each tag
+        # element is appended after the table in order.
+        offset = 4 + (count * 12)
+        tags.each do |sig, bytes|
+          out << sig
+          out << [offset].pack("N")
+          out << [bytes.bytesize].pack("N")
+          offset += bytes.bytesize
+        end
+        out
+      end
+
+      def tags_total_size(tags)
+        tags.values.sum(&:bytesize)
+      end
+
+      # ---- Tag element builders ----
+
+      # multiLocalizedUnicodeType (mluc) for desc, per ICC.10.13.
+      def desc_tag_bytes(text)
+        utf16 = text.encode("UTF-16BE").bytes
+        body = +""
+        body << "mluc"                              # type signature
+        body << ([0] * 4).pack("C*")                # reserved
+        body << [1].pack("N")                        # number of records
+        body << [12].pack("N")                       # record size in bytes
+        body << "enUS" # language + country
+        body << [utf16.length].pack("N")             # string length in bytes
+        body << [28].pack("N")                       # string offset (from tag start)
+        body << utf16.pack("C*")
+        body
+      end
+
+      # XYZType for colorants and white points, per ICC.10.22.
+      def xyz_tag_bytes(xyz_triplet)
+        body = +""
+        body << "XYZ "                              # type signature
+        body << ([0] * 4).pack("C*")                # reserved
+        xyz_triplet.each { |v| body << s15fixed16(v) }
+        body
+      end
+
+      # curveType with a single gamma value, per ICC.10.16.
+      # 2.2 is the canonical sRGB approximation (real sRGB uses a
+      # piecewise curve, but a single 2.2 gamma is acceptable for
+      # most rendering).
+      def curve_tag_bytes
+        body = +""
+        body << "curv"                              # type signature
+        body << ([0] * 4).pack("C*")                # reserved
+        body << [0].pack("N") # count = 0 → gamma follows in u8Fixed8
+        body << u8fixed8(2.2)
+        body
+      end
+
+      # Encode a Float as ICC s15Fixed16 (signed 16.16).
+      def s15fixed16(value)
+        v = (value * 65536.0).round.to_i
+        [v].pack("N")
+      end
+
+      # Encode a Float as ICC u8Fixed8 (unsigned 8.8).
+      def u8fixed8(value)
+        v = (value * 256.0).round.to_i
+        [v].pack("n")
+      end
+
+      # ---- sRGB colorants (D50-adapted, per ICC.1:2022 Annex A) ----
+
+      def d50_xyz
+        [0.9642, 1.0000, 0.8249]
+      end
+
+      def srgb_r_xyz
+        [0.4360, 0.2225, 0.0139]
+      end
+
+      def srgb_g_xyz
+        [0.3851, 0.7169, 0.0971]
+      end
+
+      def srgb_b_xyz
+        [0.1431, 0.0606, 0.7141]
+      end
+
+      # ---- Profile ID (MD5) ----
+
+      # Patch the Profile ID (offset 84..99) with the MD5 of the
+      # profile bytes computed with the ID slot zeroed (per ICC.1
+      # §7.1.1).
+      def patch_profile_id(profile)
+        copy = profile.b
+        copy[84, 16] = ([0] * 16).pack("C*")
+        md5 = Digest::MD5.digest(copy)
+        copy[84, 16] = md5
+        copy
+      end
+    end
+  end
+end

data/lib/pdfrb/color/icc_validator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Color
+    # Validates an ICC profile binary against the structural rules in
+    # ICC.1:2022 §7. The validator checks:
+    #   * Profile size >= 128 (header) + 4 (tag count)
+    #   * 'acsp' signature at offset 36
+    #   * Profile version is 2.x, 4.x, or 5.x
+    #   * Device class is one of the known classes
+    #   * Color space is one of the known spaces
+    #   * Tag table offsets don't exceed the file size
+    #
+    # Returns an Array of Violation strings (empty if valid).
+    module ICCValidator
+      VALID_VERSIONS = [(2.0..2.99), (4.0..4.99), (5.0..5.99)].freeze
+      VALID_DEVICE_CLASSES = %w[
+        scnr mntr prtr link spac abst nmcl nkpr
+      ].freeze
+      VALID_COLOR_SPACES = %w[
+        XYZ Lab Luv YCbCr Yxy RGB GRAY HSV HLS CMYK CMY 2CLR 3CLR
+        4CLR 5CLR 6CLR 7CLR 8CLR 9CLR ACLR BCLR CCLR DCLR ECLR FCLR
+      ].freeze
+
+      module_function
+
+      def validate(profile_bytes)
+        violations = []
+        unless profile_bytes.is_a?(::String) && profile_bytes.bytesize >= 132
+          violations << "ICC profile too small (need >= 132 bytes, got #{profile_bytes&.bytesize})"
+          return violations
+        end
+
+        unless profile_bytes.byteslice(36, 4) == "acsp"
+          violations << "ICC profile signature at offset 36 is not 'acsp'"
+        end
+
+        version_hi = profile_bytes.getbyte(8)
+        version_lo = profile_bytes.getbyte(9)
+        version = (version_hi * 1.0) + (version_lo / 16.0 / 10.0)
+        unless VALID_VERSIONS.any? { |range| range.cover?(version) }
+          violations << "ICC profile version #{version} not in 2.x/4.x/5.x"
+        end
+
+        device_class = profile_bytes.byteslice(12, 4).to_s.strip
+        unless VALID_DEVICE_CLASSES.include?(device_class)
+          violations << "ICC device class '#{device_class}' is not recognised"
+        end
+
+        color_space = profile_bytes.byteslice(16, 4).to_s.strip
+        unless VALID_COLOR_SPACES.include?(color_space)
+          violations << "ICC color space '#{color_space}' is not recognised"
+        end
+
+        # Tag table sanity check
+        tag_count = profile_bytes.unpack1("N", offset: 128)
+        if tag_count > 256
+          violations << "ICC tag count #{tag_count} looks bogus (max 256)"
+        end
+
+        violations
+      end
+
+      def valid?(profile_bytes)
+        validate(profile_bytes).empty?
+      end
+    end
+  end
+end

data/lib/pdfrb/color.rb

@@ -8,5 +8,7 @@ module Pdfrb
   module Color
     autoload :ICCProfile, "pdfrb/color/icc_profile"
     autoload :ColorSpace, "pdfrb/color/color_space"
+    autoload :DefaultProfile, "pdfrb/color/default_profile"
+    autoload :ICCValidator, "pdfrb/color/icc_validator"
   end
 end

data/lib/pdfrb/conformance/ltv.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+module Pdfrb
+  module Conformance
+    # Long-Term Validation (LTV) per ETSI EN 319 102-1 Annex B. LTV
+    # preserves the validity of a signature beyond the validity
+    # period of the signer's certificate by archiving revocation
+    # data and timestamping the archive over time.
+    #
+    # LTV requires:
+    #   * At least one signature with /ByteRange and /Contents.
+    #   * /DSS dictionary on Catalog with /Certs, /CRLs, /OCSPs as
+    #     applicable.
+    #   * For archival (LTA): a /DocumentTimeStamp on the catalog.
+    module Ltv
+      module_function
+
+      RULESET = RuleSet.new("LTV").tap do |rs|
+        rs.register(Rule.new(
+                      id: "ltv-1",
+                      description: "/DSS dictionary required for LTV",
+                      severity: :error,
+                      spec_clause: "ETSI EN 319 102-1 B.5",
+                      check: ->(doc) {
+                        next nil if doc.catalog[:DSS]
+
+                        Violation.new(
+                          rule_id: "ltv-1",
+                          message: "LTV requires /DSS dictionary on Catalog",
+                          object: "Catalog/DSS",
+                          severity: :error,
+                          spec_clause: "ETSI EN 319 102-1 B.5"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ltv-2",
+                      description: "/DSS must contain validation material",
+                      severity: :warning,
+                      spec_clause: "ETSI EN 319 102-1 B.5",
+                      check: ->(doc) {
+                        dss = doc.catalog[:DSS]
+                        dss = doc.object(dss) if dss.is_a?(Pdfrb::Model::Reference)
+                        next nil unless dss
+
+                        has_material = dss[:Certs] || dss[:CRLs] || dss[:OCSPs] ||
+                                       dss[:VRI]
+                        next nil if has_material
+
+                        Violation.new(
+                          rule_id: "ltv-2",
+                          message: "/DSS is empty (no /Certs, /CRLs, /OCSPs, or /VRI)",
+                          object: "Catalog/DSS",
+                          severity: :warning,
+                          spec_clause: "ETSI EN 319 102-1 B.5"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ltv-3",
+                      description: "At least one signature should be present",
+                      severity: :warning,
+                      spec_clause: "ETSI EN 319 102-1 B.4",
+                      check: ->(doc) {
+                        fields = Pdfrb::Conformance::Pades.signature_fields(doc)
+                        next nil if fields.any?
+
+                        Violation.new(
+                          rule_id: "ltv-3",
+                          message: "LTV document has no signatures to validate",
+                          object: "AcroForm/Fields",
+                          severity: :warning,
+                          spec_clause: "ETSI EN 319 102-1 B.4"
+                        )
+                      }
+                    ))
+
+        rs.register(Rule.new(
+                      id: "ltv-4",
+                      description: "Document Time Stamp for archival (LTA)",
+                      severity: :warning,
+                      spec_clause: "ETSI EN 319 102-1 B.6",
+                      check: ->(doc) {
+                        fields = Pdfrb::Conformance::Pades.signature_fields(doc)
+                        has_archival = fields.any? do |field|
+                          v = field[:V]
+                          v_obj = v.is_a?(Pdfrb::Model::Reference) ? doc.object(v) : v
+                          v_obj && v_obj[:Type]&.to_sym == :DocTimeStamp
+                        end
+                        next nil if has_archival
+
+                        Violation.new(
+                          rule_id: "ltv-4",
+                          message: "Long-Term Archival (LTA) recommends a Document Time Stamp",
+                          object: "AcroForm/Fields",
+                          severity: :warning,
+                          spec_clause: "ETSI EN 319 102-1 B.6"
+                        )
+                      }
+                    ))
+      end
+
+      def validate(document)
+        RULESET.validate(document)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/lib/pdfrb/conformance/pades.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+module Pdfrb
+  module Conformance
+    # PAdES (ETSI EN 319 142-1) signature profile validation. Four
+    # baseline levels build on each other:
+    #
+    #   B-B: Basic signatures — just the document hash + signer cert.
+    #   B-T: B-B + trusted timestamp (RFC 3161) on the signature.
+    #   B-LT: B-T + long-term validation material (DSS dictionary
+    #         with revocation data, signer certs, TSA cert chain).
+    #   B-LTA: B-LT + archival timestamp protecting the DSS itself.
+    #
+    # Each rule set checks signature dictionaries on the document's
+    # /AcroForm /Fields for the required components per level.
+    module Pades
+      ALLOWED_SIGNATURE_TYPES = %i[Sig DocTimeStamp].freeze
+
+      module_function
+
+      SHARED = RuleSet.new("PAdES-shared").tap do |rs|
+        rs.register(Rule.new(
+                      id: "pades-1",
+                      description: "At least one signature field must be present",
+                      severity: :error,
+                      spec_clause: "ETSI EN 319 142-1 5.2",
+                      check: ->(doc) {
+                        next nil if signature_fields(doc).any?
+
+                        Violation.new(
+                          rule_id: "pades-1",
+                          message: "PAdES requires at least one signature field",
+                          object: "AcroForm/Fields",
+                          severity: :error,
+                          spec_clause: "ETSI EN 319 142-1 5.2"
+                        )
+                      }
+                    ))
+      end
+
+      BB = RuleSet.new("PAdES-B-B").tap do |rs|
+        SHARED.rules.each { |r| rs.register(r) }
+        rs.register(Rule.new(
+                      id: "bb-1",
+                      description: "B-B: each signature must have /Type /Sig or /DocTimeStamp",
+                      severity: :error,
+                      spec_clause: "ETSI EN 319 142-1 5.3",
+                      check: ->(doc) {
+                        vs = []
+                        signature_fields(doc).each do |field|
+                          v = field[:V]
+                          next unless v
+
+                          v_obj = v.is_a?(Pdfrb::Model::Reference) ? doc.object(v) : v
+                          next if v_obj && ALLOWED_SIGNATURE_TYPES.include?(v_obj[:Type]&.to_sym)
+
+                          vs << Violation.new(
+                            rule_id: "bb-1",
+                            message: "Signature V must be /Type /Sig or /DocTimeStamp",
+                            object: "Field/V",
+                            severity: :error,
+                            spec_clause: "ETSI EN 319 142-1 5.3"
+                          )
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+      end
+
+      BT = RuleSet.new("PAdES-B-T").tap do |rs|
+        BB.rules.each { |r| rs.register(r) }
+        rs.register(Rule.new(
+                      id: "bt-1",
+                      description: "B-T: signature must include a trusted timestamp",
+                      severity: :error,
+                      spec_clause: "ETSI EN 319 142-1 5.4",
+                      check: ->(doc) {
+                        vs = []
+                        signature_fields(doc).each do |field|
+                          v = field[:V]
+                          next unless v
+
+                          v_obj = v.is_a?(Pdfrb::Model::Reference) ? doc.object(v) : v
+                          has_timestamp = v_obj && (
+                            v_obj[:Type]&.to_sym == :DocTimeStamp ||
+                              (v_obj[:ByteRange] && timestamp_in_signature?(v_obj))
+                          )
+                          next if has_timestamp
+
+                          vs << Violation.new(
+                            rule_id: "bt-1",
+                            message: "B-T requires a trusted timestamp (RFC 3161)",
+                            object: "Field/V",
+                            severity: :error,
+                            spec_clause: "ETSI EN 319 142-1 5.4"
+                          )
+                        end
+                        vs.empty? ? nil : vs
+                      }
+                    ))
+      end
+
+      BLT = RuleSet.new("PAdES-B-LT").tap do |rs|
+        BT.rules.each { |r| rs.register(r) }
+        rs.register(Rule.new(
+                      id: "blt-1",
+                      description: "B-LT: DSS dictionary required for LTV material",
+                      severity: :error,
+                      spec_clause: "ETSI EN 319 142-1 5.5",
+                      check: ->(doc) {
+                        next nil if doc.catalog[:DSS]
+
+                        Violation.new(
+                          rule_id: "blt-1",
+                          message: "B-LT requires /DSS dictionary with validation material",
+                          object: "Catalog/DSS",
+                          severity: :error,
+                          spec_clause: "ETSI EN 319 142-1 5.5"
+                        )
+                      }
+                    ))
+      end
+
+      BLTA = RuleSet.new("PAdES-B-LTA").tap do |rs|
+        BLT.rules.each { |r| rs.register(r) }
+        rs.register(Rule.new(
+                      id: "blta-1",
+                      description: "B-LTA: archival Document Time Stamp required",
+                      severity: :error,
+                      spec_clause: "ETSI EN 319 142-1 5.6",
+                      check: ->(doc) {
+                        # B-LTA needs a DocTimeStamp as the last signature,
+                        # protecting the DSS.
+                        has_archival = signature_fields(doc).any? do |field|
+                          v = field[:V]
+                          v_obj = v.is_a?(Pdfrb::Model::Reference) ? doc.object(v) : v
+                          v_obj && v_obj[:Type]&.to_sym == :DocTimeStamp
+                        end
+                        next nil if has_archival
+
+                        Violation.new(
+                          rule_id: "blta-1",
+                          message: "B-LTA requires an archival Document Time Stamp",
+                          object: "AcroForm/Fields",
+                          severity: :error,
+                          spec_clause: "ETSI EN 319 142-1 5.6"
+                        )
+                      }
+                    ))
+      end
+
+      LEVEL_RULESETS = {
+        "B-B": BB, "B-T": BT, "B-LT": BLT, "B-LTA": BLTA
+      }.freeze
+
+      def profiles
+        LEVEL_RULESETS.dup
+      end
+
+      def validate(document, level: :"B-B")
+        rs = LEVEL_RULESETS[level] || SHARED
+        rs.validate(document)
+      end
+
+      def signature_fields(document)
+        acroform = document.catalog[:AcroForm]
+        acroform = document.object(acroform) if acroform.is_a?(Pdfrb::Model::Reference)
+        return [] unless acroform
+
+        fields = acroform[:Fields]
+        fields = fields.value if fields.is_a?(Pdfrb::Model::PdfArray)
+        return [] unless fields.is_a?(::Array)
+
+        fields.filter_map do |ref|
+          obj = ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+          next nil unless obj
+
+          obj[:FT]&.to_sym == :Sig ? obj : nil
+        end
+      end
+
+      # Heuristic: look for the standard ASN.1 timestamp OID
+      # (1.2.840.113549.1.7.2 signedData, with a TSTInfo content
+      # type). Real validation requires parsing the PKCS#7 — out of
+      # scope for this rule set, which only checks the structural
+      # presence of a ByteRange + Contents long enough to hold a
+      # timestamp token.
+      def timestamp_in_signature?(signature)
+        contents = signature[:Contents]
+        return false unless contents.is_a?(::String)
+
+        contents.bytesize > 1024
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength