moxml 0.1.25 → 0.2.0

data/lib/moxml/signature/errors.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    class Error < ::Moxml::Error; end
+
+    class SignatureError < Error; end
+
+    class UnknownAlgorithm < Error
+      attr_reader :category, :uri
+
+      def initialize(category, uri)
+        @category = category
+        @uri = uri
+        super("Unknown #{category} algorithm: #{uri}")
+      end
+    end
+
+    class DuplicateAlgorithm < Error
+      attr_reader :category, :uri
+
+      def initialize(category, uri)
+        @category = category
+        @uri = uri
+        super("Algorithm already registered for #{category}: #{uri}")
+      end
+    end
+
+    class SigningError < Error
+      attr_reader :algorithm
+
+      def initialize(message, algorithm: nil)
+        @algorithm = algorithm
+        super(message)
+      end
+    end
+
+    class VerificationError < Error
+      attr_reader :signature_id
+
+      def initialize(message, signature_id: nil)
+        @signature_id = signature_id
+        super(message)
+      end
+    end
+
+    class ReferenceDigestMismatch < VerificationError
+      attr_reader :reference_uri, :expected, :computed
+
+      def initialize(reference_uri:, expected:, computed:, signature_id: nil)
+        @reference_uri = reference_uri
+        @expected = expected
+        @computed = computed
+        super(
+          "Digest mismatch for reference #{reference_uri.inspect}",
+          signature_id: signature_id,
+        )
+      end
+    end
+
+    class SignatureValueMismatch < VerificationError
+      attr_reader :algorithm
+
+      def initialize(algorithm: nil, signature_id: nil)
+        @algorithm = algorithm
+        super("SignatureValue did not verify", signature_id: signature_id)
+      end
+    end
+
+    class TransformError < Error
+      attr_reader :algorithm
+
+      def initialize(message, algorithm: nil)
+        @algorithm = algorithm
+        super(message)
+      end
+    end
+
+    class CanonicalizationError < Error
+      attr_reader :algorithm
+
+      def initialize(message, algorithm: nil)
+        @algorithm = algorithm
+        super(message)
+      end
+    end
+
+    class MalformedSignatureError < Error
+      attr_reader :detail
+
+      def initialize(message, detail: nil)
+        @detail = detail
+        super(message)
+      end
+    end
+
+    class SignatureKeyError < Error; end
+  end
+end

data/lib/moxml/signature/key_extractor.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+
+module Moxml
+  module Signature
+    # Extracts an OpenSSL verification key from a Model::KeyInfo.
+    #
+    # Strategy (per spec §4.5): X509Certificate is preferred for key
+    # reconstruction because it carries the certified binding. Falls back
+    # to RSAKeyValue / DSAKeyValue / ECKeyValue if no certificate is
+    # present. KeyName is resolved via an application-supplied key map.
+    class KeyExtractor
+      attr_reader :key_map, :cert_store
+
+      def initialize(key_map: {}, cert_store: nil)
+        @key_map = key_map || {}
+        @cert_store = cert_store
+      end
+
+      def extract(key_info)
+        return nil if key_info.nil?
+
+        from_x509_data(key_info.x509_data) ||
+          from_key_value(key_info.key_value) ||
+          from_key_name(key_info.key_name)
+      end
+
+      private
+
+      def from_x509_data(x509_data)
+        return nil unless x509_data
+
+        cert_b64 = x509_data.certificates.first
+        return nil unless cert_b64
+
+        # Certificates are stored as base64-encoded DER (spec §4.5.4).
+        # Decode here so we hand OpenSSL raw DER bytes.
+        cert_der = Base64.strict_decode64(cert_b64.to_s.gsub(/\s+/, ""))
+        cert = OpenSSL::X509::Certificate.new(cert_der)
+        cert.public_key
+      rescue OpenSSL::X509::CertificateError, ArgumentError
+        nil
+      end
+
+      def from_key_value(key_value)
+        return nil unless key_value
+
+        if key_value.rsa_key_value
+          rsa_public_key(key_value.rsa_key_value)
+        elsif key_value.dsa_key_value
+          dsa_public_key(key_value.dsa_key_value)
+        elsif key_value.ec_key_value
+          ec_public_key(key_value.ec_key_value)
+        end
+      end
+
+      def from_key_name(key_name)
+        return nil unless key_name
+
+        key_map[key_name]
+      end
+
+      def rsa_public_key(rsa_kv)
+        n = crypto_binary_to_integer(rsa_kv.modulus)
+        e = crypto_binary_to_integer(rsa_kv.exponent)
+        return nil unless n && e
+
+        # OpenSSL 3.x removed RSA.new(n, e). Reconstruct via the
+        # SubjectPublicKeyInfo form (PKCS#1 RSA public key DER).
+        asn1 = OpenSSL::ASN1::Sequence.new(
+          [
+            OpenSSL::ASN1::Integer.new(n),
+            OpenSSL::ASN1::Integer.new(e),
+          ],
+        )
+        OpenSSL::PKey::RSA.new(asn1.to_der)
+      rescue OpenSSL::PKey::RSAError
+        nil
+      end
+
+      def dsa_public_key(dsa_kv)
+        p = crypto_binary_to_integer(dsa_kv.p)
+        q = crypto_binary_to_integer(dsa_kv.q)
+        g = crypto_binary_to_integer(dsa_kv.g) if dsa_kv.g
+        y = crypto_binary_to_integer(dsa_kv.y)
+        return nil unless p && q && y
+
+        params = OpenSSL::ASN1::Sequence.new(
+          [
+            OpenSSL::ASN1::Integer.new(p),
+            OpenSSL::ASN1::Integer.new(q),
+            OpenSSL::ASN1::Integer.new(g || 0),
+            OpenSSL::ASN1::Integer.new(y),
+          ],
+        )
+        OpenSSL::PKey::DSA.new(params.to_der)
+      rescue OpenSSL::PKey::DSAError
+        nil
+      end
+
+      def ec_public_key(ec_kv)
+        return nil unless ec_kv.named_curve_uri && ec_kv.public_key
+
+        curve_name = curve_name_for(ec_kv.named_curve_uri)
+        return nil unless curve_name
+
+        # The XML signature PublicKey element already contains the
+        # uncompressed-point form (0x04 || x || y) per spec §4.5.2.3.
+        public_key_decoded = Base64.strict_decode64(ec_kv.public_key)
+        spki_der = build_ec_subject_public_key_info(curve_name, public_key_decoded)
+        OpenSSL::PKey::EC.new(spki_der)
+      rescue OpenSSL::PKey::ECError, ArgumentError
+        nil
+      end
+
+      # Build a SubjectPublicKeyInfo DER for an EC public key.
+      # OpenSSL 3.0 makes PKey instances immutable; we can no longer
+      # create an empty EC key and assign public_key=. Constructing the
+      # full SPKI and reading it back via OpenSSL::PKey::EC.new(der)
+      # is the supported path.
+      def build_ec_subject_public_key_info(curve_name, point_octets)
+        algorithm = OpenSSL::ASN1::Sequence.new(
+          [
+            OpenSSL::ASN1::ObjectId.new("id-ecPublicKey"),
+            OpenSSL::ASN1::ObjectId.new(curve_name_to_oid(curve_name)),
+          ],
+        )
+        OpenSSL::ASN1::Sequence.new(
+          [
+            algorithm,
+            OpenSSL::ASN1::BitString.new(point_octets),
+          ],
+        ).to_der
+      end
+
+      CURVE_NAME_TO_OID = {
+        "prime256v1" => "1.2.840.10045.3.1.7",
+        "secp384r1" => "1.3.132.0.34",
+        "secp521r1" => "1.3.132.0.35",
+      }.freeze
+      private_constant :CURVE_NAME_TO_OID
+
+      def curve_name_to_oid(curve_name)
+        CURVE_NAME_TO_OID.fetch(curve_name)
+      end
+
+      # ds:CryptoBinary is base64-encoded I2OSP output.
+      def crypto_binary_to_integer(base64_text)
+        return nil unless base64_text
+
+        raw = Base64.strict_decode64(base64_text.to_s.gsub(/\s+/, ""))
+        raw.bytes.reduce(0) { |acc, byte| (acc << 8) | byte }
+      rescue ArgumentError
+        nil
+      end
+
+      # Map NamedCurve URN OIDs to OpenSSL curve names (RFC 5480 §2.1).
+      CURVE_OID_TO_NAME = {
+        "urn:oid:1.2.840.10045.3.1.7" => "prime256v1", # P-256
+        "urn:oid:1.3.132.0.34" => "secp384r1",         # P-384
+        "urn:oid:1.3.132.0.35" => "secp521r1",         # P-521
+      }.freeze
+      private_constant :CURVE_OID_TO_NAME
+
+      def curve_name_for(uri)
+        CURVE_OID_TO_NAME[uri]
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/algorithm_method.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      # Generic algorithm method element. Used for CanonicalizationMethod and
+      # SignatureMethod, both of which are `<Foo Algorithm="uri" />` shape.
+      class AlgorithmMethod
+        attr_accessor :algorithm, :parameters
+
+        def initialize(algorithm:, parameters: {})
+          @algorithm = algorithm
+          @parameters = parameters
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/digest_method.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class DigestMethod
+        attr_accessor :algorithm
+
+        def initialize(algorithm:)
+          @algorithm = algorithm
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/key/dsa_key_value.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      module Key
+        # ds:DSAKeyValue — P, Q, G, Y required; J, Seed, PgenCounter optional.
+        # Attribute names mirror the W3C spec §4.5.2.1 element names
+        # (P, Q, G, Y, J, Seed, PgenCounter).
+        class DSAKeyValue
+          attr_accessor :p, :q, :g, :y, :j, :seed, :pgen_counter
+
+          # rubocop:disable-next Naming/MethodParameterName -- P/Q/G/Y/J are W3C spec names
+          def initialize(p:, q:, y:, g: nil, j: nil, seed: nil,
+                         pgen_counter: nil)
+            @p = p
+            @q = q
+            @y = y
+            @g = g
+            @j = j
+            @seed = seed
+            @pgen_counter = pgen_counter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/key/ec_key_value.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      module Key
+        # dsig11:ECKeyValue — NamedCurve URI + PublicKey octets, or
+        # explicit ECParameters.
+        class ECKeyValue
+          attr_accessor :named_curve_uri, :public_key, :ec_parameters
+
+          def initialize(named_curve_uri: nil, public_key: nil,
+                         ec_parameters: nil)
+            @named_curve_uri = named_curve_uri
+            @public_key = public_key
+            @ec_parameters = ec_parameters
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/key/rsa_key_value.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      module Key
+        # ds:RSAKeyValue — base64-encoded CryptoBinary Modulus + Exponent.
+        class RSAKeyValue
+          attr_accessor :modulus, :exponent
+
+          def initialize(modulus:, exponent:)
+            @modulus = modulus
+            @exponent = exponent
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/key/x509_data.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      module Key
+        # ds:X509Data (spec §4.5.4) — container for certificate identifiers.
+        # May carry X509IssuerSerial, X509SubjectName, X509SKI, X509Certificate,
+        # X509CRL, and dsig11:X509Digest children, all describing the same key.
+        class X509Data
+          attr_accessor :issuer_serial, :subject_name, :subject_key_id,
+                        :certificates, :crls, :digests
+
+          def initialize(issuer_serial: nil, subject_name: nil,
+                         subject_key_id: nil, certificates: [],
+                         crls: [], digests: [])
+            @issuer_serial = issuer_serial
+            @subject_name = subject_name
+            @subject_key_id = subject_key_id
+            @certificates = Array(certificates)
+            @crls = Array(crls)
+            @digests = Array(digests)
+          end
+
+          def first_certificate
+            certificates.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/key/x509_digest.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      module Key
+        # dsig11:X509Digest — algorithm URI + base64 digest of a cert.
+        class X509Digest
+          attr_accessor :algorithm, :digest
+
+          def initialize(algorithm:, digest:)
+            @algorithm = algorithm
+            @digest = digest
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/key/x509_issuer_serial.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      module Key
+        # ds:X509IssuerSerial — deprecated in favor of X509Digest.
+        class X509IssuerSerial
+          attr_accessor :issuer_name, :serial_number
+
+          def initialize(issuer_name:, serial_number:)
+            @issuer_name = issuer_name
+            @serial_number = serial_number
+          end
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/key_info.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class KeyInfo
+        attr_accessor :id, :key_name, :key_value, :x509_data,
+                      :raw_elements
+
+        def initialize(id: nil, key_name: nil, key_value: nil,
+                       x509_data: nil, raw_elements: [])
+          @id = id
+          @key_name = key_name
+          @key_value = key_value
+          @x509_data = x509_data
+          @raw_elements = raw_elements
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/key_value.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class KeyValue
+        attr_accessor :rsa_key_value, :dsa_key_value, :ec_key_value,
+                      :raw_element
+
+        def initialize(rsa_key_value: nil, dsa_key_value: nil,
+                       ec_key_value: nil, raw_element: nil)
+          @rsa_key_value = rsa_key_value
+          @dsa_key_value = dsa_key_value
+          @ec_key_value = ec_key_value
+          @raw_element = raw_element
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/object_element.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class ObjectElement
+        attr_accessor :id, :mime_type, :encoding, :content
+
+        def initialize(id: nil, mime_type: nil, encoding: nil, content: nil)
+          @id = id
+          @mime_type = mime_type
+          @encoding = encoding
+          @content = content
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/reference.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class Reference
+        attr_accessor :id, :uri, :type, :transforms, :digest_method,
+                      :digest_value
+
+        def initialize(id: nil, uri: nil, type: nil, transforms: nil,
+                       digest_method: nil, digest_value: nil)
+          @id = id
+          @uri = uri
+          @type = type
+          @transforms = transforms
+          @digest_method = digest_method
+          @digest_value = digest_value
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/signature.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class Signature
+        attr_accessor :id, :signed_info, :signature_value,
+                      :key_info, :objects
+
+        def initialize(id: nil, signed_info: nil, signature_value: nil,
+                       key_info: nil, objects: [])
+          @id = id
+          @signed_info = signed_info
+          @signature_value = signature_value
+          @key_info = key_info
+          @objects = objects
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/signature_value.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class SignatureValue
+        attr_accessor :id, :value
+
+        def initialize(id: nil, value: nil)
+          @id = id
+          @value = value
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/signed_info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class SignedInfo
+        attr_accessor :id, :canonicalization_method, :signature_method,
+                      :references
+
+        def initialize(id: nil, canonicalization_method: nil,
+                       signature_method: nil, references: [])
+          @id = id
+          @canonicalization_method = canonicalization_method
+          @signature_method = signature_method
+          @references = references
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/transform.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class Transform
+        attr_accessor :algorithm, :parameters
+
+        def initialize(algorithm:, parameters: {})
+          @algorithm = algorithm
+          @parameters = parameters
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model/transforms.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    module Model
+      class Transforms
+        attr_accessor :transforms
+
+        def initialize(transforms: [])
+          @transforms = Array(transforms)
+        end
+
+        def <<(transform)
+          @transforms << transform
+          self
+        end
+
+        def each(&block)
+          @transforms.each(&block)
+        end
+
+        def empty?
+          @transforms.empty?
+        end
+
+        def size
+          @transforms.size
+        end
+
+        def length
+          @transforms.size
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/model.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    # Plain-Ruby-Object model of the W3C ds:Signature schema.
+    #
+    # Models carry data; they do not (de)serialize themselves. The Serializer
+    # walks a model and emits a Moxml document; the Parser walks a Moxml
+    # document and constructs a model. This separation keeps the data shape
+    # and the wire shape independent.
+    module Model
+      autoload :Signature, "moxml/signature/model/signature"
+      autoload :SignedInfo, "moxml/signature/model/signed_info"
+      autoload :Reference, "moxml/signature/model/reference"
+      autoload :Transforms, "moxml/signature/model/transforms"
+      autoload :Transform, "moxml/signature/model/transform"
+      autoload :DigestMethod, "moxml/signature/model/digest_method"
+      autoload :AlgorithmMethod, "moxml/signature/model/algorithm_method"
+      autoload :SignatureValue, "moxml/signature/model/signature_value"
+      autoload :KeyInfo, "moxml/signature/model/key_info"
+      autoload :KeyValue, "moxml/signature/model/key_value"
+      autoload :ObjectElement, "moxml/signature/model/object_element"
+
+      module Key
+        autoload :X509Data, "moxml/signature/model/key/x509_data"
+        autoload :X509IssuerSerial,
+                 "moxml/signature/model/key/x509_issuer_serial"
+        autoload :X509Digest, "moxml/signature/model/key/x509_digest"
+        autoload :RSAKeyValue, "moxml/signature/model/key/rsa_key_value"
+        autoload :DSAKeyValue, "moxml/signature/model/key/dsa_key_value"
+        autoload :ECKeyValue, "moxml/signature/model/key/ec_key_value"
+      end
+    end
+  end
+end