moxml 0.1.25 → 0.2.0

data/lib/moxml/signature/parser.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Moxml
+  module Signature
+    # Translates a Moxml::Document containing ds:Signature into a Model::Signature.
+    #
+    # Robust against namespace prefix variations (ds:, dsig:, default ns).
+    class Parser
+      DS = { "ds" => DSIG_NS }.freeze
+
+      attr_reader :context
+
+      def initialize(context:)
+        @context = context
+      end
+
+      # `signature_element`: a Moxml::Element whose name is Signature in the
+      # xmldsig# namespace.
+      def parse(signature_element)
+        Model::Signature.new(
+          id: signature_element["Id"],
+          signed_info: parse_signed_info(at_child(signature_element, "SignedInfo")),
+          signature_value: parse_signature_value(at_child(signature_element, "SignatureValue")),
+          key_info: parse_key_info(at_child(signature_element, "KeyInfo")),
+          objects: [],
+        )
+      end
+
+      private
+
+      def parse_signed_info(elem)
+        return nil unless elem
+
+        Model::SignedInfo.new(
+          id: elem["Id"],
+          canonicalization_method: parse_algorithm_method(at_child(elem, "CanonicalizationMethod")),
+          signature_method: parse_algorithm_method(at_child(elem, "SignatureMethod")),
+          references: at_children(elem, "Reference").map { |r| parse_reference(r) },
+        )
+      end
+
+      def parse_algorithm_method(elem)
+        return nil unless elem
+
+        parameters = {}
+        hmac_len = at_child(elem, "HMACOutputLength")
+        if hmac_len
+          length = begin
+            Integer(hmac_len.text.strip)
+          rescue StandardError
+            nil
+          end
+          parameters[:hmac_output_length] = length if length
+        end
+
+        Model::AlgorithmMethod.new(
+          algorithm: elem["Algorithm"],
+          parameters: parameters,
+        )
+      end
+
+      def parse_reference(elem)
+        return nil unless elem
+
+        transforms_elem = at_child(elem, "Transforms")
+        Model::Reference.new(
+          id: elem["Id"],
+          uri: elem["URI"],
+          type: elem["Type"],
+          transforms: parse_transforms(transforms_elem),
+          digest_method: parse_digest_method(at_child(elem, "DigestMethod")),
+          digest_value: at_child(elem, "DigestValue")&.text || "",
+        )
+      end
+
+      def parse_transforms(elem)
+        return nil unless elem
+
+        transforms = at_children(elem, "Transform").map do |t|
+          xpath_children = at_children(t, "XPath").map(&:text)
+          Model::Transform.new(
+            algorithm: t["Algorithm"],
+            parameters: xpath_children.empty? ? {} : { xpaths: xpath_children },
+          )
+        end
+        Model::Transforms.new(transforms: transforms)
+      end
+
+      def parse_digest_method(elem)
+        return nil unless elem
+
+        Model::DigestMethod.new(algorithm: elem["Algorithm"])
+      end
+
+      def parse_signature_value(elem)
+        return nil unless elem
+
+        text = (elem.text || "").gsub(/\s+/, "")
+        value = text.empty? ? nil : Base64.strict_decode64(text)
+        Model::SignatureValue.new(id: elem["Id"], value: value)
+      rescue ArgumentError => e
+        raise MalformedSignatureError.new(
+          "SignatureValue is not valid base64: #{e.message}",
+        )
+      end
+
+      def parse_key_info(elem)
+        return nil unless elem
+
+        key_name_el = at_child(elem, "KeyName")
+        x509_data_el = at_child(elem, "X509Data")
+        key_value_el = at_child(elem, "KeyValue")
+
+        Model::KeyInfo.new(
+          id: elem["Id"],
+          key_name: key_name_el&.text,
+          x509_data: parse_x509_data(x509_data_el),
+          key_value: parse_key_value(key_value_el),
+          raw_elements: raw_key_info_children(elem),
+        )
+      end
+
+      def parse_x509_data(elem)
+        return nil unless elem
+
+        certificates = at_children(elem, "X509Certificate").map do |cert_el|
+          strip_base64(cert_el.text)
+        end
+        issuer_serial_el = at_child(elem, "X509IssuerSerial")
+        subject_name_el = at_child(elem, "X509SubjectName")
+        ski_el = at_child(elem, "X509SKI")
+        crl_els = at_children(elem, "X509CRL")
+        # dsig11:X509Digest is in a different namespace; look it up loosely.
+        digest_els = elem.children.select do |c|
+          c.is_a?(::Moxml::Element) &&
+            c.name == "X509Digest" &&
+            c.namespace_uri == DSIG11_NS
+        end
+
+        Model::Key::X509Data.new(
+          issuer_serial: parse_x509_issuer_serial(issuer_serial_el),
+          subject_name: subject_name_el&.text,
+          subject_key_id: strip_base64(ski_el&.text),
+          certificates: certificates,
+          crls: crl_els.map { |e| strip_base64(e.text) },
+          digests: digest_els.map { |e| parse_x509_digest(e) },
+        )
+      end
+
+      def parse_x509_issuer_serial(elem)
+        return nil unless elem
+
+        issuer = at_child(elem, "X509IssuerName")
+        serial = at_child(elem, "X509SerialNumber")
+        return nil unless issuer && serial
+
+        Model::Key::X509IssuerSerial.new(
+          issuer_name: issuer.text,
+          serial_number: serial.text,
+        )
+      end
+
+      def parse_x509_digest(elem)
+        return nil unless elem
+
+        Model::Key::X509Digest.new(
+          algorithm: elem["Algorithm"],
+          digest: strip_base64(elem.text),
+        )
+      end
+
+      def parse_key_value(elem)
+        return nil unless elem
+
+        rsa_el = at_child(elem, "RSAKeyValue")
+        dsa_el = at_child(elem, "DSAKeyValue")
+        ec_el = elem.children.find do |c|
+          c.is_a?(::Moxml::Element) &&
+            c.name == "ECKeyValue" &&
+            c.namespace_uri == DSIG11_NS
+        end
+
+        Model::KeyValue.new(
+          rsa_key_value: parse_rsa_key_value(rsa_el),
+          dsa_key_value: parse_dsa_key_value(dsa_el),
+          ec_key_value: parse_ec_key_value(ec_el),
+        )
+      end
+
+      def parse_rsa_key_value(elem)
+        return nil unless elem
+
+        Model::Key::RSAKeyValue.new(
+          modulus: text_of(elem, "Modulus"),
+          exponent: text_of(elem, "Exponent"),
+        )
+      end
+
+      def parse_dsa_key_value(elem)
+        return nil unless elem
+
+        Model::Key::DSAKeyValue.new(
+          p: text_of(elem, "P"),
+          q: text_of(elem, "Q"),
+          g: text_of(elem, "G"),
+          y: text_of(elem, "Y"),
+          j: text_of(elem, "J"),
+          seed: text_of(elem, "Seed"),
+          pgen_counter: text_of(elem, "PgenCounter"),
+        )
+      end
+
+      def parse_ec_key_value(elem)
+        return nil unless elem
+
+        named_curve_el = elem.children.find do |c|
+          c.is_a?(::Moxml::Element) &&
+            c.name == "NamedCurve" &&
+            c.namespace_uri == DSIG11_NS
+        end
+        public_key_el = elem.children.find do |c|
+          c.is_a?(::Moxml::Element) &&
+            c.name == "PublicKey" &&
+            c.namespace_uri == DSIG11_NS
+        end
+
+        Model::Key::ECKeyValue.new(
+          named_curve_uri: named_curve_el&.[]("URI"),
+          public_key: strip_base64(public_key_el&.text),
+        )
+      end
+
+      def text_of(parent, local_name)
+        elem = at_child(parent, local_name)
+        elem&.text
+      end
+
+      def strip_base64(text)
+        return nil if text.nil?
+
+        text.to_s.gsub(/\s+/, "")
+      end
+
+      def raw_key_info_children(elem)
+        # Children we don't model explicitly are preserved for round-trip
+        # fidelity (PGPData, SPKIData, MgmtData, dsig11:KeyInfoReference,
+        # dsig11:DEREncodedKeyValue, xenc:*).
+        elem.children.grep(::Moxml::Element).to_a
+      end
+
+      def at_child(parent, local_name)
+        parent.children.find do |c|
+          c.is_a?(::Moxml::Element) &&
+            c.name == local_name &&
+            c.namespace_uri == DSIG_NS
+        end
+      end
+
+      def at_children(parent, local_name)
+        parent.children.select do |c|
+          c.is_a?(::Moxml::Element) &&
+            c.name == local_name &&
+            c.namespace_uri == DSIG_NS
+        end
+      end
+    end
+  end
+end

data/lib/moxml/signature/reference_resolver.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    # Translates a Reference URI to a node (subtree) or octet string ready
+    # for the transform pipeline.
+    #
+    # Only same-document references and bare-octet inputs are handled in
+    # this tier. External URI dereferencing is documented in
+    # TODO.complete/11.
+    class ReferenceResolver
+      attr_reader :context, :document
+
+      def initialize(context:, document:)
+        @context = context
+        @document = document
+      end
+
+      # Returns:
+      #   - Moxml::Node for same-document references (subtree apex)
+      #   - String (octets) for octet inputs
+      def resolve(uri)
+        case uri.to_s
+        when ""
+          document.root
+        when /\A#/
+          resolve_fragment(uri[1..])
+        else
+          uri.to_s
+        end
+      end
+
+      private
+
+      def resolve_fragment(fragment)
+        case fragment
+        when /\Axpointer\(\/\)\z/
+          document.root
+        when /\Axpointer\(id\(['"]([^'"]+)['"]\)\)\z/
+          find_by_id(::Regexp.last_match(1))
+        else
+          find_by_id(fragment)
+        end
+      end
+
+      def find_by_id(id)
+        candidate = search_by_xml_id(id) || search_by_attribute_id(id)
+        unless candidate
+          raise MalformedSignatureError.new(
+            "Reference URI ##{id.inspect} does not resolve to any element",
+          )
+        end
+        candidate
+      end
+
+      def search_by_xml_id(id)
+        result = document.at_xpath("//*[@xml:id='#{xpath_escape(id)}']")
+        return nil unless result
+        return nil unless result.is_a?(::Moxml::Element)
+
+        result
+      end
+
+      def search_by_attribute_id(id)
+        matches = document
+          .xpath("//*[@Id='#{xpath_escape(id)}'] | " \
+                 "//*[@ID='#{xpath_escape(id)}']")
+          .grep(::Moxml::Element)
+        return nil if matches.empty?
+
+        matches.first
+      end
+
+      def xpath_escape(value)
+        value.to_s.gsub("'", "''")
+      end
+    end
+  end
+end

data/lib/moxml/signature/reference_result.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    # Per-reference digest comparison result. `valid?` is true iff the
+    # freshly-computed digest matches the expected DigestValue.
+    class ReferenceResult
+      attr_reader :uri, :digest_method, :expected, :computed
+
+      def initialize(uri:, digest_method:, expected:, computed:)
+        @uri = uri
+        @digest_method = digest_method
+        @expected = expected
+        @computed = computed
+      end
+
+      def valid?
+        expected == computed
+      end
+    end
+  end
+end

data/lib/moxml/signature/serializer.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module Moxml
+  module Signature
+    # Translates a Model::Signature into a Moxml::Document.
+    #
+    # All XML construction goes through moxml primitives
+    # (create_element, []=, add_child, create_text). No string templates,
+    # no manual attribute escaping — moxml handles entity encoding
+    # correctly per the XML spec.
+    class Serializer
+      DS_PREFIX = "ds"
+
+      attr_reader :context
+
+      def initialize(context:)
+        @context = context
+      end
+
+      def serialize(signature)
+        doc = context.create_document
+        root = create_namespaced_element("Signature", doc)
+        root["Id"] = signature.id if signature.id
+        doc.root = root
+
+        if signature.signed_info
+          root.add_child(build_signed_info(signature.signed_info, doc))
+        end
+        if signature.signature_value
+          root.add_child(build_signature_value(signature.signature_value, doc))
+        end
+        if signature.key_info
+          root.add_child(build_key_info(signature.key_info, doc))
+        end
+        signature.objects.each do |obj|
+          root.add_child(build_object(obj, doc))
+        end
+
+        doc
+      end
+
+      # Produces a standalone ds:SignedInfo document. Used by the Signer
+      # when canonicalizing SignedInfo in isolation.
+      def serialize_signed_info(signed_info)
+        doc = context.create_document
+        root = create_namespaced_element("SignedInfo", doc)
+        root["Id"] = signed_info.id if signed_info.id
+        doc.root = root
+        populate_signed_info(root, signed_info, doc)
+        doc
+      end
+
+      private
+
+      def build_signed_info(signed_info, doc)
+        el = create_namespaced_element("SignedInfo", doc)
+        el["Id"] = signed_info.id if signed_info.id
+        populate_signed_info(el, signed_info, doc)
+        el
+      end
+
+      def populate_signed_info(root, signed_info, doc)
+        if signed_info.canonicalization_method
+          root.add_child(
+            build_algorithm_method("CanonicalizationMethod",
+                                   signed_info.canonicalization_method, doc),
+          )
+        end
+        if signed_info.signature_method
+          root.add_child(
+            build_algorithm_method("SignatureMethod",
+                                   signed_info.signature_method, doc),
+          )
+        end
+        signed_info.references.each do |ref|
+          root.add_child(build_reference(ref, doc))
+        end
+      end
+
+      def build_algorithm_method(name, method, doc)
+        el = create_namespaced_element(name, doc)
+        el["Algorithm"] = method.algorithm
+        if method.parameters.is_a?(Hash) && method.parameters[:hmac_output_length]
+          len = create_namespaced_element("HMACOutputLength", doc)
+          len.add_child(doc.create_text(method.parameters[:hmac_output_length].to_s))
+          el.add_child(len)
+        end
+        el
+      end
+
+      def build_reference(reference, doc)
+        el = create_namespaced_element("Reference", doc)
+        el["Id"] = reference.id if reference.id
+        el["URI"] = reference.uri if reference.uri
+        el["Type"] = reference.type if reference.type
+
+        if reference.transforms && !reference.transforms.empty?
+          tf = create_namespaced_element("Transforms", doc)
+          reference.transforms.each do |transform|
+            tr = create_namespaced_element("Transform", doc)
+            tr["Algorithm"] = transform.algorithm
+            tf.add_child(tr)
+          end
+          el.add_child(tf)
+        end
+
+        if reference.digest_method
+          dm = create_namespaced_element("DigestMethod", doc)
+          dm["Algorithm"] = reference.digest_method.algorithm
+          el.add_child(dm)
+        end
+
+        dv = create_namespaced_element("DigestValue", doc)
+        dv.add_child(doc.create_text(reference.digest_value || ""))
+        el.add_child(dv)
+        el
+      end
+
+      def build_signature_value(signature_value, doc)
+        el = create_namespaced_element("SignatureValue", doc)
+        el["Id"] = signature_value.id if signature_value.id
+        if signature_value.value
+          el.add_child(doc.create_text(Base64.strict_encode64(signature_value.value)))
+        end
+        el
+      end
+
+      def build_key_info(key_info, doc)
+        el = create_namespaced_element("KeyInfo", doc)
+        el["Id"] = key_info.id if key_info.id
+        if key_info.key_name
+          kn = create_namespaced_element("KeyName", doc)
+          kn.add_child(doc.create_text(key_info.key_name))
+          el.add_child(kn)
+        end
+        key_info.raw_elements.each { |raw| el.add_child(raw.dup) }
+        el
+      end
+
+      def build_object(obj, doc)
+        el = create_namespaced_element("Object", doc)
+        el["Id"] = obj.id if obj.id
+        el["MimeType"] = obj.mime_type if obj.mime_type
+        el["Encoding"] = obj.encoding if obj.encoding
+        # Payload content (Manifest, SignatureProperties, XAdES
+        # QualifyingProperties) comes in later tiers.
+        el
+      end
+
+      # Create an element in the xmldsig# namespace with the conventional
+      # `ds` prefix. The namespace declaration is added once on the
+      # element itself; descendants inherit it.
+      def create_namespaced_element(local_name, doc)
+        el = doc.create_element(local_name)
+        el.add_namespace(DS_PREFIX, DSIG_NS)
+        el.namespace = { DS_PREFIX => DSIG_NS }
+        el
+      end
+    end
+  end
+end

data/lib/moxml/signature/signer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    # Reference generation + SignatureValue computation per spec §3.1.
+    #
+    # Flow:
+    #   1. For each Reference in signed_info.references:
+    #      a. Resolve URI (same-document or octet).
+    #      b. Apply each Transform in order.
+    #      c. Compute digest via DigestMethod.
+    #      d. Store base64 digest on Reference#digest_value.
+    #   2. Serialize SignedInfo.
+    #   3. Canonicalize per CanonicalizationMethod.
+    #   4. Sign via SignatureMethod#sign(canonical_octets, key).
+    #   5. Set signature.signature_value.
+    class Signer
+      attr_reader :context, :signature, :document, :key
+
+      def initialize(context:, signature:, document:, key:)
+        @context = context
+        @signature = signature
+        @document = document
+        @key = key
+      end
+
+      def sign
+        Algorithms.load_builtins!
+
+        signature.signed_info.references.each do |ref|
+          digest = compute_reference_digest(ref)
+          ref.digest_value = digest
+        end
+
+        signature.signature_value = Model::SignatureValue.new(
+          value: compute_signature_value,
+        )
+        signature
+      end
+
+      private
+
+      def compute_reference_digest(reference)
+        resolver = ReferenceResolver.new(context: context, document: document)
+        input = resolver.resolve(reference.uri)
+        pipeline = TransformPipeline.new(context: context, signature_element: nil)
+        transformed = pipeline.apply(input, reference.transforms)
+        canonical = pipeline.to_octets(transformed, reference)
+        digest_algo = Algorithms.lookup(:digest, reference.digest_method.algorithm).new
+        digest_algo.digest_base64(canonical)
+      end
+
+      def compute_signature_value
+        signed_info = signature.signed_info
+        serializer = Serializer.new(context: context)
+        signed_info_doc = serializer.serialize_signed_info(signed_info)
+
+        c14n_uri = signed_info.canonicalization_method.algorithm
+        c14n_klass = Algorithms.lookup(:canonicalization, c14n_uri)
+        c14n = c14n_klass.new(identifier_uri: c14n_uri)
+        canonical_octets = c14n.canonicalize(signed_info_doc.root)
+
+        sm_uri = signed_info.signature_method.algorithm
+        sm_klass = Algorithms.lookup(:signature_method, sm_uri)
+        sm = sm_klass.new(
+          identifier_uri: sm_uri,
+          parameters: signed_info.signature_method.parameters,
+        )
+        sm.sign(canonical_octets, key)
+      end
+    end
+  end
+end

data/lib/moxml/signature/single_verification_result.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    # Verification outcome for a single Signature element. Carries the
+    # cryptographic-result boolean, per-reference results, and (when
+    # applicable) the error that caused failure.
+    class SingleVerificationResult
+      attr_reader :signature_id, :references, :error
+
+      def initialize(signature_id:, signature_valid:, references:, error: nil)
+        @signature_id = signature_id
+        @signature_valid = signature_valid
+        @references = references
+        @error = error
+      end
+
+      def signature_valid?
+        @signature_valid
+      end
+
+      def valid?
+        @signature_valid && references.all?(&:valid?)
+      end
+
+      def failing_references
+        references.reject(&:valid?)
+      end
+    end
+  end
+end