moxml 0.1.24 → 0.1.26

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

data/lib/moxml/signature/transform_pipeline.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    # Shared transform-pipeline logic used by both Signer (signing flow,
+    # signature_element: nil) and Verifier (verification flow, with the
+    # containing Signature element so the Enveloped Signature transform
+    # can remove it from the digest input).
+    #
+    # Each Transform in the chain is looked up via Algorithms.lookup(:transform, uri),
+    # with a fallback to Algorithms.lookup(:canonicalization, uri) per
+    # spec §6.6.1 (any canonicalization algorithm can be used as a transform).
+    #
+    # Type coercion matches spec §4.4.3.2 reference processing model:
+    #   - octets → nodeset: parse as XML
+    #   - nodeset → octets: apply inclusive C14N 1.0
+    class TransformPipeline
+      attr_reader :context, :signature_element
+
+      def initialize(context:, signature_element: nil)
+        @context = context
+        @signature_element = signature_element
+      end
+
+      def apply(input, transforms_model)
+        current = input
+        current_type = type_of(current)
+        transforms = transforms_from(transforms_model)
+
+        transforms.each do |transform_model|
+          algo_class = lookup(transform_model.algorithm)
+          transform = algo_class.new(
+            parameters: transform_model.parameters,
+            context: context,
+            signature_element: signature_element,
+          )
+          current_type, current = coerce(current, current_type,
+                                         algo_class.input_type)
+          current = transform.transform(current)
+          current_type = algo_class.output_type
+        end
+
+        current
+      end
+
+      # Final step: convert the pipeline output (which may still be a node)
+      # to octets suitable for digesting. Uses inclusive C14N 1.0 as the
+      # default mapping per spec §4.4.3.2.
+      def to_octets(value, reference = nil)
+        return value if value.is_a?(String)
+
+        c14n_uri = canonicalization_from(reference) || DEFAULT_OCTET_C14N
+        klass = Algorithms.lookup(:canonicalization, c14n_uri)
+        klass.new(identifier_uri: c14n_uri).canonicalize(value)
+      end
+
+      DEFAULT_OCTET_C14N = "http://www.w3.org/TR/2001/REC-xml-c14n-20010315"
+
+      private_constant :DEFAULT_OCTET_C14N
+
+      private
+
+      def transforms_from(transforms_model)
+        return [] unless transforms_model
+
+        transforms_model.transforms
+      end
+
+      def lookup(uri)
+        Algorithms.lookup(:transform, uri)
+      rescue UnknownAlgorithm
+        Algorithms.lookup(:canonicalization, uri)
+      end
+
+      def type_of(value)
+        case value
+        when ::Moxml::Node, Array then :nodeset
+        else :octets
+        end
+      end
+
+      def coerce(input, from, to)
+        return [to, input] if from == to
+
+        case [from, to]
+        when %i[octets nodeset]
+          parsed = context.parse(input.to_s)
+          [:nodeset, parsed.root]
+        when %i[nodeset octets]
+          octets = C14n::Inclusive10.new.canonicalize(input)
+          [:octets, octets]
+        else
+          raise TransformError, "cannot coerce #{from} to #{to}"
+        end
+      end
+
+      def canonicalization_from(reference)
+        return nil unless reference&.transforms
+
+        reference.transforms.transforms.reverse_each.find do |t|
+          Algorithms.registered?(:canonicalization, t.algorithm)
+        end&.algorithm
+      end
+    end
+  end
+end

data/lib/moxml/signature/verification_result.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    # Aggregated verification result for a document. A document may
+    # contain multiple Signature elements; this result wraps them all.
+    class VerificationResult
+      attr_reader :results
+
+      def initialize(results:)
+        @results = results
+      end
+
+      def valid?
+        results.all?(&:valid?)
+      end
+
+      def signature_count
+        results.size
+      end
+
+      def failing
+        results.reject(&:valid?)
+      end
+    end
+  end
+end

data/lib/moxml/signature/verifier.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Signature
+    # Core Validation per spec §3.2, with the safe ordering prescribed by
+    # Best Practice 1: verify SignatureValue BEFORE running any reference
+    # transforms (which could be hostile).
+    class Verifier
+      attr_reader :context, :document, :key, :key_map
+
+      def initialize(context:, document:, key: nil, key_map: {}, **_options)
+        @context = context
+        @document = document
+        @key = key
+        @key_map = key_map || {}
+      end
+
+      def verify
+        Algorithms.load_builtins!
+        signatures = find_signatures
+
+        results = signatures.map { |sig_elem| verify_one(sig_elem) }
+        VerificationResult.new(results: results)
+      end
+
+      private
+
+      def find_signatures
+        document.xpath("//ds:Signature", "ds" => DSIG_NS)
+          .grep(::Moxml::Element)
+      end
+
+      def verify_one(signature_element)
+        signature = Parser.new(context: context).parse(signature_element)
+        signature_value_ok, error = verify_signature_value(signature, signature_element)
+        reference_results = if signature_value_ok
+                              verify_references(signature, signature_element)
+                            else
+                              []
+                            end
+
+        SingleVerificationResult.new(
+          signature_id: signature.id,
+          signature_valid: signature_value_ok,
+          references: reference_results,
+          error: error,
+        )
+      end
+
+      # Returns [Boolean, ErrorOrNil] so the caller can attach the error
+      # to the result for debugging. The error is never raised — Best
+      # Practice 1 says authenticate first; surfacing why auth failed is
+      # an application concern, not a panic.
+      def verify_signature_value(signature, signature_element)
+        return [false, nil] if signature.signature_value.nil?
+        return [false, nil] if signature.signature_value.value.nil?
+
+        signed_info_elem = signature_element.at_xpath(
+          "./ds:SignedInfo", "ds" => DSIG_NS
+        )
+        return [false, nil] if signed_info_elem.nil?
+
+        c14n_uri = signature.signed_info.canonicalization_method&.algorithm
+        return [false, nil] if c14n_uri.nil?
+
+        canonical = canonicalize_signed_info(c14n_uri, signed_info_elem)
+        sm_uri = signature.signed_info.signature_method.algorithm
+        sm = Algorithms.lookup(:signature_method, sm_uri).new(
+          identifier_uri: sm_uri,
+          parameters: signature.signed_info.signature_method.parameters,
+        )
+        verification_key = resolve_key(signature)
+        return [false, nil] if verification_key.nil?
+
+        ok = sm.verify(canonical, verification_key, signature.signature_value.value)
+        [ok, nil]
+      rescue VerificationError, UnknownAlgorithm => e
+        [false, e]
+      end
+
+      # Canonicalize the original SignedInfo element as it appears in the
+      # document. Re-serializing the parsed model would change namespace
+      # prefixes (e.g. SignedInfo → ds:SignedInfo) and break byte-exact
+      # verification.
+      def canonicalize_signed_info(c14n_uri, signed_info_elem)
+        Algorithms.lookup(:canonicalization, c14n_uri)
+          .new(identifier_uri: c14n_uri)
+          .canonicalize(signed_info_elem)
+      end
+
+      def resolve_key(signature)
+        return key if key
+        return nil unless signature.key_info
+
+        KeyExtractor.new(key_map: key_map).extract(signature.key_info)
+      end
+
+      def verify_references(signature, signature_element)
+        signature.signed_info.references.map do |ref|
+          verify_reference(ref, signature_element)
+        end
+      end
+
+      def verify_reference(reference, signature_element)
+        resolver = ReferenceResolver.new(context: context, document: document)
+        input = resolver.resolve(reference.uri)
+        pipeline = TransformPipeline.new(
+          context: context,
+          signature_element: signature_element,
+        )
+        transformed = pipeline.apply(input, reference.transforms)
+        canonical = pipeline.to_octets(transformed, reference)
+
+        digest_algo = Algorithms.lookup(
+          :digest, reference.digest_method.algorithm
+        ).new
+        computed = digest_algo.digest_base64(canonical)
+        expected = (reference.digest_value || "").strip
+
+        ReferenceResult.new(
+          uri: reference.uri,
+          digest_method: reference.digest_method.algorithm,
+          expected: expected,
+          computed: computed,
+        )
+      end
+    end
+  end
+end

data/lib/moxml/signature.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+
+module Moxml
+  # W3C XML Signature (xmldsig-core-1.1) processing for any moxml adapter.
+  #
+  # All XML operations flow through Moxml::Document / Moxml::Element; the
+  # signature module never touches the underlying adapter (Nokogiri, Oga,
+  # REXML, Ox, LibXML) directly.
+  module Signature
+    DSIG_NS = "http://www.w3.org/2000/09/xmldsig#"
+    DSIG11_NS = "http://www.w3.org/2009/xmldsig11#"
+    DSIG_MORE_NS = "http://www.w3.org/2001/04/xmldsig-more#"
+
+    autoload :Error, "moxml/signature/errors"
+    autoload :SignatureError, "moxml/signature/errors"
+    autoload :UnknownAlgorithm, "moxml/signature/errors"
+    autoload :DuplicateAlgorithm, "moxml/signature/errors"
+    autoload :SigningError, "moxml/signature/errors"
+    autoload :VerificationError, "moxml/signature/errors"
+    autoload :ReferenceDigestMismatch, "moxml/signature/errors"
+    autoload :SignatureValueMismatch, "moxml/signature/errors"
+    autoload :TransformError, "moxml/signature/errors"
+    autoload :CanonicalizationError, "moxml/signature/errors"
+    autoload :MalformedSignatureError, "moxml/signature/errors"
+    autoload :SignatureKeyError, "moxml/signature/errors"
+
+    autoload :Algorithms, "moxml/signature/algorithms"
+    autoload :C14n, "moxml/c14n"
+    autoload :Model, "moxml/signature/model"
+    autoload :Serializer, "moxml/signature/serializer"
+    autoload :Parser, "moxml/signature/parser"
+    autoload :ReferenceResolver, "moxml/signature/reference_resolver"
+    autoload :Signer, "moxml/signature/signer"
+    autoload :Verifier, "moxml/signature/verifier"
+    autoload :KeyExtractor, "moxml/signature/key_extractor"
+    autoload :TransformPipeline, "moxml/signature/transform_pipeline"
+    autoload :VerificationResult, "moxml/signature/verification_result"
+    autoload :SingleVerificationResult,
+             "moxml/signature/single_verification_result"
+    autoload :ReferenceResult, "moxml/signature/reference_result"
+
+    class << self
+      def sign(context:, document:, key:, **options)
+        signature = build_signature(context: context, document: document, **options)
+        Signer.new(
+          context: context,
+          signature: signature,
+          document: document,
+          key: key,
+        ).sign
+        signature
+      end
+
+      def verify(context:, document:, key: nil, **options)
+        Verifier.new(context: context, document: document, key: key, **options).verify
+      end
+
+      private
+
+      def build_signature(**opts)
+        _context = opts[:context]
+        _document = opts[:document]
+        signed_info = Model::SignedInfo.new(
+          canonicalization_method: Model::AlgorithmMethod.new(
+            algorithm: opts[:canonicalization_method],
+          ),
+          signature_method: Model::AlgorithmMethod.new(
+            algorithm: opts[:signature_method],
+          ),
+          references: [
+            Model::Reference.new(
+              uri: opts[:reference_uri],
+              transforms: Model::Transforms.new(
+                transforms: opts[:transforms].map do |transform|
+                  Model::Transform.new(algorithm: transform)
+                end,
+              ),
+              digest_method: Model::DigestMethod.new(algorithm: opts[:digest_method]),
+            ),
+          ],
+        )
+
+        Model::Signature.new(
+          id: opts[:signature_id],
+          signed_info: signed_info,
+          key_info: opts[:key_info],
+        )
+      end
+    end
+  end
+end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.1.24"
+  VERSION = "0.1.26"
 end

data/lib/moxml.rb

@@ -89,6 +89,8 @@ module Moxml
   autoload :Adapter, "moxml/adapter"
   autoload :XPath, "moxml/xpath"
   autoload :SAX, "moxml/sax"
+  autoload :Signature, "moxml/signature"
+  autoload :C14n, "moxml/c14n"
 
   # Error hierarchy — each subclass autoloads from the same file
   autoload :Error, "moxml/error"

data/moxml.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   # RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|features)/})
+      f.match(%r{^(test|features|vendor/)})
     end
   end
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }