moxml 0.1.25 → 0.2.0

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.25"
+  VERSION = "0.2.0"
 end

data/lib/moxml/xml_emitter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Moxml
+  # Single source of XML emission knowledge: character escaping,
+  # CDATA end-sequence segmentation, and declaration/DOCTYPE
+  # rendering. Adapters keep their tree walks (those are
+  # adapter-shaped) but stop re-deriving the wire format:
+  #
+  # - text escapes & < >; attribute values also escape " —
+  #   apostrophes stay literal (moxml-canonical form)
+  # - a CDATA section's end sequence is split into adjacent sections
+  # - the moxml declaration shape is <?xml version="..."
+  #   encoding="..." standalone="..."?> with only the set attributes
+  # - DOCTYPE renders PUBLIC and SYSTEM external identifiers
+  module XmlEmitter
+    TEXT_ESCAPE_RE = /[<>&]/
+    TEXT_ESCAPE_MAP = {
+      "<" => "&lt;", ">" => "&gt;", "&" => "&amp;"
+    }.freeze
+    ATTRIBUTE_ESCAPE_RE = /[<>&"]/
+    ATTRIBUTE_ESCAPE_MAP = {
+      "<" => "&lt;", ">" => "&gt;", "&" => "&amp;", '"' => "&quot;"
+    }.freeze
+    CDATA_END = "]]>"
+    CDATA_END_SPLIT = "]]]]><![CDATA[>"
+
+    module_function
+
+    # @return [String] text with & < > escaped
+    def escape_text(text)
+      str = text.is_a?(String) ? text : text.to_s
+      return str unless str.match?(TEXT_ESCAPE_RE)
+
+      str.gsub(TEXT_ESCAPE_RE, TEXT_ESCAPE_MAP)
+    end
+
+    # @return [String] attribute value with & < > " escaped
+    def escape_attribute(value)
+      str = value.is_a?(String) ? value : value.to_s
+      return str unless str.match?(ATTRIBUTE_ESCAPE_RE)
+
+      str.gsub(ATTRIBUTE_ESCAPE_RE, ATTRIBUTE_ESCAPE_MAP)
+    end
+
+    # @return [String] a CDATA section, splitting any embedded end
+    #   sequence into adjacent sections
+    def cdata(content)
+      "<![CDATA[#{content.to_s.gsub(CDATA_END, CDATA_END_SPLIT)}]]>"
+    end
+
+    # @return [String] an XML declaration with only the set attributes
+    def declaration_xml(version, encoding, standalone)
+      output = %(<?xml version="#{version}")
+      output << %( encoding="#{encoding}") if encoding && !encoding.to_s.empty?
+      output << %( standalone="#{standalone}") unless standalone.nil?
+      output << "?>"
+    end
+
+    # @return [String] a DOCTYPE with its external identifier
+    def doctype_xml(name, public_id, system_id)
+      output = "<!DOCTYPE #{name}"
+      if public_id && !public_id.to_s.empty?
+        output << %( PUBLIC "#{public_id}")
+        output << %( "#{system_id}") if system_id
+      elsif system_id && !system_id.to_s.empty?
+        output << %( SYSTEM "#{system_id}")
+      end
+      output << ">"
+    end
+  end
+end

data/lib/moxml/xpath/compiler.rb

@@ -425,15 +425,22 @@ module Moxml
         end
       end
 
-      # AXIS: attribute - Enables @attribute syntax
+      # AXIS: attribute - Enables @attribute syntax. Name tests share
+      # the resolver's expanded-name semantics (Namespaces 1.0): bare
+      # names match no-namespace attributes only; prefixed names match
+      # by namespace URI, never by prefix spelling.
       def on_axis_attribute(ast, input)
         elem_class = const_ref("Moxml", "Element")
         attribute = unique_literal(:attribute)
 
         input.is_a?(elem_class).if_true do
           input.attributes.each.add_block(attribute) do
-            # Use process to handle both :test and :wildcard nodes
-            condition = process(ast, attribute)
+            condition = if ast.type == :test
+                          attribute_test_condition(ast, input, attribute)
+                        else
+                          # Wildcards and node types keep the generic path
+                          process(ast, attribute)
+                        end
 
             if block_given?
               condition.if_true { yield attribute }
@@ -444,6 +451,34 @@ module Moxml
         end
       end
 
+      # Attribute node-test condition built on AttributeResolver. The
+      # XPath context's prefix mapping (when provided) wins over the
+      # document's own declarations and is resolved at compile time.
+      # Returns nil for the both-wildcard test (@*): no name constraint.
+      def attribute_test_condition(ast, element, attribute)
+        resolver = const_ref("Moxml", "AttributeResolver")
+        ns = ast.value[:namespace]
+        name = ast.value[:name]
+
+        return nil if name == STAR && (!ns || ns == STAR)
+
+        local = name == STAR ? self_nil : string(name)
+
+        if ns && ns != STAR && @namespaces && (uri = @namespaces[ns])
+          return resolver.attribute_test_uri?(element, attribute,
+                                              string(uri.to_s), local)
+        end
+
+        prefix = if ns.nil?
+                   self_nil
+                 elsif ns == STAR
+                   symbol(:any)
+                 else
+                   string(ns)
+                 end
+        resolver.attribute_test?(element, attribute, prefix, local)
+      end
+
       # AXIS: descendant - All descendant nodes (without self)
       def on_axis_descendant(ast, input)
         node = unique_literal(:descendant)
@@ -494,6 +529,13 @@ module Moxml
         when "node"
           # node() matches everything — use a truthy literal
           Ruby::Node.new(:lit, ["true"])
+        when "text"
+          # CDATA sections are text nodes in the XPath data model
+          text_class = const_ref("Moxml", "Text")
+          cdata_class = const_ref("Moxml", "Cdata")
+          input.is_a?(text_class).or(input.is_a?(cdata_class))
+        when "comment"
+          input.is_a?(const_ref("Moxml", "Comment"))
         else element_or_attribute(input)
         end
       end
@@ -531,9 +573,21 @@ module Moxml
         # Match namespace if specified
         if ns && ns != STAR
           if @namespaces && @namespaces[ns]
-            # Resolve prefix to URI using namespace mappings
+            # Resolve prefix to URI using namespace mappings. An empty
+            # URI binding ("xmlns" => "") selects elements in no
+            # namespace, e.g. after an xmlns="" undeclaration.
             ns_uri = @namespaces[ns]
-            ns_match = input.namespace.and(input.namespace.uri.eq(string(ns_uri)))
+            ns_match = if ns_uri.to_s.empty?
+                         input.namespace.nil?.or(input.namespace.uri.eq(string("")))
+                       else
+                         input.namespace.and(input.namespace.uri.eq(string(ns_uri)))
+                       end
+          elsif ns == "xmlns"
+            # Nokogiri-compatible reserved prefix: xmlns:name addresses
+            # elements in the default namespace (no prefix).
+            ns_match = input.namespace.and(
+              input.namespace.prefix.to_s.eq(string("")),
+            )
           else
             # No mapping provided - check against element's namespace prefix
             # Need to ensure input.namespace exists first
@@ -977,10 +1031,9 @@ module Moxml
           conversions << conversion.to_string(arg_var)
         end
 
-        # rubocop:disable Style/RedundantSum, Performance/Sum
+        # rubocop:disable-next Performance/Sum
         concatted = assigns.inject(:followed_by)
           .followed_by(conversions.inject(:+))
-        # rubocop:enable Style/RedundantSum, Performance/Sum
 
         block_given? ? concatted.empty?.if_false { yield concatted } : concatted
       end

data/lib/moxml/xpath/parser.rb

@@ -327,11 +327,18 @@ module Moxml
       def parse_relative_path
         steps = [parse_step]
 
-        while match?(:slash) && !at_end?
+        # Continue on both step separators: "/step" and the
+        # descendant-or-self shorthand "//step". A "//" arrives as a
+        # single :dslash (".//step", "a//step") or occasionally as a
+        # :slash/:slash or :slash/:dslash pair.
+        while !at_end? && match?(:slash, :dslash)
+          is_dslash = match?(:dslash)
           advance
-          if match?(:slash)
-            # Double slash within path: expands to descendant-or-self::node()
+          if !is_dslash && match?(:slash, :dslash)
             advance
+            is_dslash = true
+          end
+          if is_dslash
             steps << AST::Node.axis("descendant-or-self", AST::Node.node_type("node"))
           end
           steps << parse_step unless at_end? || match?(:pipe, :rbracket,
@@ -352,14 +359,10 @@ module Moxml
           return AST::Node.parent
         elsif match?(:at)
           advance
-          # Attribute: @name or @*
-          if match?(:star)
-            advance
-            node_test = AST::Node.wildcard
-          else
-            name = consume(:name, "Expected attribute name after @")
-            node_test = AST::Node.test(nil, name[1])
-          end
+          # Attribute: @name, @prefix:name, @prefix:* or @* (XPath 1.0
+          # §3.2, NameTest). parse_node_test handles prefixed and
+          # wildcard names; bare names land in its plain-name branch.
+          node_test = parse_node_test
           step = AST::Node.axis("attribute", node_test)
           return parse_predicates(step)
         end
@@ -385,14 +388,18 @@ module Moxml
         if match?(:star)
           advance
           return AST::Node.wildcard
-        elsif match?(:node_type)
+        elsif match?(:node_type) && peek_is?(:lparen)
           type_name = current_value
           advance
           consume(:lparen, "Expected '(' after node type")
           consume(:rparen, "Expected ')' after node type")
           return AST::Node.node_type(type_name)
-        elsif match?(:name, :and, :or, :mod, :div)
-          # Accept keywords as valid element names (they're valid XML names)
+        elsif match?(:name, :node_type, :and, :or, :mod, :div)
+          # Accept keywords as valid element names (they're valid XML
+          # names). Node-type words (text, comment, node) also land here
+          # when not followed by '(' — they name elements, either alone
+          # ("//text") or as the local part of a prefixed name
+          # ("//svg:text").
           name = current_value
           advance
 
@@ -402,7 +409,7 @@ module Moxml
             if match?(:star)
               advance
               return AST::Node.test(name, "*")
-            elsif match?(:name, :and, :or, :mod, :div)
+            elsif match?(:name, :node_type, :and, :or, :mod, :div)
               # Accept keywords as local names too
               local_name = current_value
               advance

data/lib/moxml.rb

@@ -76,6 +76,7 @@ module Moxml
   autoload :Cdata, "moxml/cdata"
   autoload :Comment, "moxml/comment"
   autoload :Attribute, "moxml/attribute"
+  autoload :AttributeResolver, "moxml/attribute_resolver"
   autoload :ProcessingInstruction, "moxml/processing_instruction"
   autoload :Declaration, "moxml/declaration"
   autoload :Namespace, "moxml/namespace"
@@ -83,12 +84,16 @@ module Moxml
   autoload :EntityReference, "moxml/entity_reference"
   autoload :DocumentBuilder, "moxml/document_builder"
   autoload :Builder, "moxml/builder"
+  autoload :Entity, "moxml/entity"
   autoload :EntityRegistry, "moxml/entity_registry"
   autoload :NativeAttachment, "moxml/native_attachment"
   autoload :XmlUtils, "moxml/xml_utils"
+  autoload :XmlEmitter, "moxml/xml_emitter"
   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"