moxml 0.1.25 → 0.2.0

data/spec/moxml/sax_entity_parity_spec.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Pins cross-adapter parity for entity-decoding in attribute values and
+# text content, across SAX, DOM, and build-then-serialize-then-reparse.
+# Previously the four adapters diverged: nokogiri/libxml SAX failed to
+# resolve "&#NN;"; rexml SAX delivered raw escaped strings; oga DOM
+# and SAX double-decoded.
+
+# Namespace-isolated container for the test data and the SAX capture
+# handler. Wrapping these in a module rather than declaring them as
+# top-level constants inside `RSpec.describe` keeps them out of the
+# global namespace and lets the spec reference them without tripping
+# the RSpec/* cops that forbid local-variable use inside examples.
+module SaxEntityParityFixtures
+  class CaptureHandler < Moxml::SAX::ElementHandler
+    attr_reader :first_attrs, :text
+
+    def initialize
+      super
+      @first_attrs = nil
+      @text = +""
+    end
+
+    def on_start_element(_name, attrs = {}, _namespaces = {})
+      @first_attrs = attrs.dup if @first_attrs.nil?
+    end
+
+    def on_characters(chunk)
+      @text << chunk
+    end
+  end
+
+  ADAPTERS = %i[nokogiri ox oga rexml libxml headed_ox].freeze
+
+  # Each row: [input XML, decoded attribute value, expected attribute
+  # value as it appears in the serialized XML]. The serialized form
+  # asserts what every adapter must emit byte-for-byte for the attribute.
+  ATTRIBUTE_CASES = {
+    "wrapped amp + decimal ref" => ['<doc x="&amp;#38;"/>', "&#38;", "&amp;#38;"],
+    "wrapped amp + hex ref" => ['<doc x="&amp;#x26;"/>', "&#x26;", "&amp;#x26;"],
+    "wrapped amp + non-std ref" => ['<doc x="&amp;copy;"/>', "&copy;", "&amp;copy;"],
+    "wrapped amp + lt" => ['<doc x="&amp;lt;"/>', "&lt;", "&amp;lt;"],
+    "wrapped amp + amp" => ['<doc x="&amp;amp;"/>', "&amp;", "&amp;amp;"],
+    "two amps" => ['<doc x="&amp;&amp;"/>', "&&", "&amp;&amp;"],
+    "plain amp" => ['<doc x="&amp;"/>', "&", "&amp;"],
+    "plain decimal ref" => ['<doc x="&#38;"/>', "&", "&amp;"],
+    "plain hex ref" => ['<doc x="&#x26;"/>', "&", "&amp;"],
+    "high codepoint" => ['<doc x="&#169;"/>', "©", "©"],
+    "no entities" => ['<doc x="plain"/>', "plain", "plain"],
+  }.freeze
+
+  # Each row: [input XML, decoded text, expected text as it appears in
+  # serialized XML].
+  TEXT_CASES = {
+    "text wrapped amp + decimal" => ["<doc>&amp;#38;</doc>", "&#38;", "&amp;#38;"],
+    "text wrapped amp + non-std" => ["<doc>&amp;copy;</doc>", "&copy;", "&amp;copy;"],
+    "text plain amp" => ["<doc>&amp;</doc>", "&", "&amp;"],
+  }.freeze
+
+  # XML 1.0 §2.6 — entity references inside PI content are NOT resolved.
+  # Every adapter must surface the literal source text. The libxml
+  # adapter previously decoded these five entities via a gsub chain in
+  # processing_instruction_content; pin each one explicitly.
+  PI_ENTITY_CASES = {
+    "&amp;" => "data &amp; more",
+    "&lt;" => "data &lt; more",
+    "&gt;" => "data &gt; more",
+    "&quot;" => "data &quot; more",
+    "&apos;" => "data &apos; more",
+  }.freeze
+
+  # Per-adapter overrides for the rebuild-path serialized form. Oga's
+  # set_attribute calls preprocess_entities which marks non-standard
+  # named entities so they survive serialization as "&name;" rather than
+  # being escaped to "&amp;name;". This is the entity-preservation
+  # feature documented in spec/moxml/adapter/entity_restoration_spec.rb
+  # and spec/moxml/adapter/oga_spec.rb — not a bug.
+  REBUILD_SERIALIZED_OVERRIDES = {
+    oga: {
+      "wrapped amp + non-std ref" => "&copy;",
+    },
+  }.freeze
+end
+
+RSpec.describe "SAX/DOM entity parity" do
+  SaxEntityParityFixtures::ADAPTERS.each do |adapter|
+    context "with #{adapter} adapter" do
+      let(:ctx) { Moxml.new(adapter) }
+
+      SaxEntityParityFixtures::ATTRIBUTE_CASES.each do |label, (xml, expected, expected_serialized)|
+        it "decodes attribute via SAX: #{label}" do
+          handler = SaxEntityParityFixtures::CaptureHandler.new
+          ctx.sax_parse(xml, handler)
+          expect(handler.first_attrs["x"]).to eq(expected)
+        end
+
+        it "decodes attribute via DOM: #{label}" do
+          expect(ctx.parse(xml).root["x"]).to eq(expected)
+        end
+
+        it "serializes attribute to expected XML form: #{label}" do
+          # End-to-end: parse → DOM access → set on fresh doc → serialize
+          # → assert exact serialized form. This pins what the consumer
+          # sees on the wire, not just what the parser delivers in memory.
+          parsed_value = ctx.parse(xml).root["x"]
+
+          doc2 = ctx.create_document
+          el = doc2.create_element("doc")
+          el["x"] = parsed_value
+          doc2.add_child(el)
+
+          serialized = doc2.to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          expected_form = SaxEntityParityFixtures::REBUILD_SERIALIZED_OVERRIDES.dig(adapter, label) || expected_serialized
+          expect(serialized).to include(%(x="#{expected_form}"))
+        end
+
+        it "round-trips attribute through build+serialize+reparse: #{label}" do
+          parsed_value = ctx.parse(xml).root["x"]
+
+          doc2 = ctx.create_document
+          el = doc2.create_element("doc")
+          el["x"] = parsed_value
+          doc2.add_child(el)
+
+          serialized = doc2.to_xml.sub(/\A<\?[^>]*\?>/, "")
+          expect(ctx.parse(serialized).root["x"]).to eq(parsed_value)
+        end
+
+        it "re-serializes parsed document idempotently: #{label}" do
+          # Parse → serialize → re-parse → re-serialize → assert the two
+          # serializations match. This catches any non-idempotent
+          # mutations the adapter applies during the round-trip.
+          first = ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          second = ctx.parse(first).to_xml.sub(/\A<\?[^>]*\?>\s*/, "")
+          expect(second).to eq(first)
+        end
+      end
+
+      SaxEntityParityFixtures::TEXT_CASES.each do |label, (xml, expected, expected_serialized)|
+        it "decodes text via SAX: #{label}" do
+          handler = SaxEntityParityFixtures::CaptureHandler.new
+          ctx.sax_parse(xml, handler)
+          expect(handler.text).to eq(expected)
+        end
+
+        it "decodes text via DOM: #{label}" do
+          expect(ctx.parse(xml).root.text).to eq(expected)
+        end
+
+        it "serializes text to expected XML form: #{label}" do
+          serialized = ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+          expect(serialized).to include(">#{expected_serialized}<")
+        end
+      end
+
+      it "does not double-escape '&' in a programmatically-built text node" do
+        # Pins the libxml customized Text#to_xml fix: an authored "&"
+        # must serialize to "&amp;" exactly once, never "&amp;amp;".
+        # Regression target for adapter/customized_libxml/text.rb where
+        # the previous implementation used #content (decoded text) and
+        # lost the "&" → "&amp;" escape, and earlier variants risked
+        # double-escaping on round-trip.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        el.add_child("a & b")
+        doc.add_child(el)
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).not_to include("&amp;amp;")
+
+        # And the round-trip must preserve the original text exactly.
+        reparsed_text = ctx.parse(serialized).root.text
+        expect(reparsed_text).to eq("a & b")
+      end
+
+      it "mutates in-tree text node content without double-escaping '&'" do
+        # Pins the libxml fix for set_text_content on attached text
+        # nodes: libxml-ruby's #content= setter pre-escapes the input,
+        # and #to_s escapes again on serialization. The adapter must
+        # replace the in-tree node with a fresh raw-storage node to
+        # avoid silent double-escape data corruption.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        text = doc.create_text("placeholder")
+        el.add_child(text)
+        doc.add_child(el)
+
+        text.content = "a & b"
+        expect(text.content).to eq("a & b")
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).not_to include("&amp;amp;")
+        expect(ctx.parse(serialized).root.text).to eq("a & b")
+      end
+
+      it "mutates in-tree PI content verbatim without escaping" do
+        # Pins the libxml fix for set_processing_instruction_content
+        # on attached PI nodes: libxml-ruby's #content= setter pre-
+        # escapes quotes and ampersands, but XML 1.0 §2.6 specifies
+        # PI content is verbatim — entity references are not resolved
+        # and no escaping is required on serialization.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+        pi = doc.create_processing_instruction("target", "placeholder")
+        el.add_child(pi)
+        doc.add_child(el)
+
+        pi.content = 'a " & b'
+        expect(pi.content.strip).to eq('a " & b')
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include('a " & b?>')
+        expect(serialized).not_to include("&quot;")
+        expect(serialized).not_to include("&amp;")
+        reparsed = ctx.parse(serialized).root.children.find do |c|
+          c.is_a?(Moxml::ProcessingInstruction)
+        end
+        expect(reparsed.content.strip).to eq('a " & b')
+      end
+
+      it "mutates unparented text/PI content before adoption into the tree" do
+        # Pins the swap_native_in_place early-return when parent is nil:
+        # set_text_content / set_processing_instruction_content called
+        # before the node is added to any element must still replace the
+        # wrapper's @native with a fresh raw-storage node, so the value
+        # survives correctly once the node is later attached and serialized.
+        doc = ctx.create_document
+        el = doc.create_element("doc")
+
+        text = doc.create_text("placeholder")
+        text.content = "a & b"
+        pi = doc.create_processing_instruction("target", "placeholder")
+        pi.content = 'a " & b'
+
+        el.add_child(text)
+        el.add_child(pi)
+        doc.add_child(el)
+
+        serialized = doc.to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+        expect(serialized).to include(">a &amp; b<")
+        expect(serialized).to include('<?target a " & b?>')
+        expect(serialized).not_to include("&amp;amp;")
+      end
+
+      # Regressions around &amp; appearing inside contexts that Oga's
+      # source-level preprocessor must not touch (CDATA, comments,
+      # DOCTYPE) — verified across adapters to ensure parity holds.
+      it "preserves literal &amp; inside CDATA" do
+        doc = ctx.parse("<doc><![CDATA[a &amp; b]]></doc>")
+        expect(doc.root.text).to eq("a &amp; b")
+      end
+
+      it "preserves literal &amp; inside comment" do
+        doc = ctx.parse("<doc><!-- a &amp; b --></doc>")
+        comment = doc.root.children.find { |c| c.is_a?(Moxml::Comment) }
+        expect(comment.content.strip).to eq("a &amp; b")
+      end
+
+      it "preserves literal U+FFFC U+FFFC user data in attribute" do
+        xml = "<doc x=\"\u{FFFC}\u{FFFC} test\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FFFC}\u{FFFC} test")
+      end
+
+      it "preserves literal U+FDD0 U+FDD0 user data in attribute" do
+        # Single noncharacters near the Oga marker codepoints — must not
+        # collide with the internal DEFAULT_AMP_MARKER sentinel.
+        xml = "<doc x=\"\u{FDD0}\u{FDD0} test\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD0} test")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in attribute (no amp)" do
+        # User data matching the default Oga marker codepoints with NO
+        # &amp; in the input — restore must not run, so the sequence
+        # survives intact.
+        xml = "<doc x=\"\u{FDD0}\u{FDD1}\u{FDD2} plain\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD1}\u{FDD2} plain")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in attribute (with amp)" do
+        # User data matching the default Oga marker codepoints alongside
+        # an &amp; that the preprocessor would otherwise substitute.
+        # The adapter must pick a marker not present in user data so
+        # restore doesn't corrupt the original sequence.
+        xml = "<doc x=\"\u{FDD0}\u{FDD1}\u{FDD2} &amp; foo\"/>"
+        expect(ctx.parse(xml).root["x"]).to eq("\u{FDD0}\u{FDD1}\u{FDD2} & foo")
+      end
+
+      it "preserves the exact Oga DEFAULT_AMP_MARKER sequence in text" do
+        xml = "<doc>\u{FDD0}\u{FDD1}\u{FDD2} &amp; foo</doc>"
+        expect(ctx.parse(xml).root.text).to eq("\u{FDD0}\u{FDD1}\u{FDD2} & foo")
+      end
+
+      it "handles DOCTYPE with '[' in quoted system ID" do
+        # System ID containing a literal "[" before the internal subset
+        # opener — quote-aware DOCTYPE terminator must not pick "]>"
+        # based on the bracket inside the quoted string.
+        xml = %(<!DOCTYPE root SYSTEM "has[bracket"><root x="&amp;#38;"/>)
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      it "handles bare DOCTYPE with '>' in quoted system ID" do
+        # Bare DOCTYPE (no internal subset) — the terminator is ">".
+        # A literal ">" inside the quoted SYSTEM id must not be treated
+        # as the end of the declaration. For the Oga adapter this also
+        # exercises find_block_terminator's quote-aware ">" scan; if
+        # the bare-DOCTYPE end was misidentified, the preprocessor
+        # would rewrite "&amp;" inside the remaining quoted ID region
+        # to DEFAULT_AMP_MARKER and leak it into the serialized doctype.
+        xml = %(<!DOCTYPE root SYSTEM "a>b&amp;c"><root x="&amp;#38;"/>)
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      it "handles DOCTYPE with ']>' inside a quoted entity value" do
+        # Quote-aware DOCTYPE terminator must skip past a literal "]>"
+        # appearing inside a quoted ExternalID / ENTITY value so the
+        # internal subset terminator is matched correctly. For the Oga
+        # adapter this also exercises the source-level DOCTYPE skipper;
+        # native-DOCTYPE parsers must reach the same result.
+        xml = '<!DOCTYPE root [ <!ENTITY foo "]>"> ]><root x="&amp;#38;"/>'
+        expect(ctx.parse(xml).root["x"]).to eq("&#38;")
+      end
+
+      SaxEntityParityFixtures::PI_ENTITY_CASES.each do |entity_label, payload|
+        it "preserves literal #{entity_label} inside processing instruction" do
+          doc = ctx.parse("<doc><?target #{payload}?></doc>")
+          pi = doc.root.children.find { |c| c.is_a?(Moxml::ProcessingInstruction) }
+          expect(pi.content.strip).to eq(payload)
+        end
+      end
+    end
+  end
+
+  # Cross-adapter equivalence: feed the same XML into every adapter and
+  # assert all of them emit the same serialized attribute form. Catches
+  # any regression where one adapter starts to deviate from the rest.
+  describe "cross-adapter serialization equivalence" do
+    def serialize_via(adapter, xml)
+      ctx = Moxml.new(adapter)
+      ctx.parse(xml).to_xml.sub(/\A<\?[^>]*\?>\s*/, "").strip
+    end
+
+    SaxEntityParityFixtures::ATTRIBUTE_CASES.each do |label, (xml, _expected, expected_serialized)|
+      it "every adapter emits the same attribute form: #{label}" do
+        results = SaxEntityParityFixtures::ADAPTERS.to_h { |a| [a, serialize_via(a, xml)] }
+        results.each do |a, out|
+          expect(out).to(
+            include(%(x="#{expected_serialized}")),
+            "#{a} produced #{out.inspect}",
+          )
+        end
+      end
+    end
+  end
+end

data/spec/moxml/signature/algorithms/base64_transform_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "base64"
+
+RSpec.describe Moxml::Signature::Algorithms::Base64Transform do
+  let(:ctx) { Moxml.new(:nokogiri) }
+  let(:transform) { described_class.new(context: ctx) }
+
+  it "decodes base64 octet input" do
+    encoded = Base64.strict_encode64("hello world")
+    expect(transform.transform(encoded)).to eq("hello world")
+  end
+
+  it "strips whitespace before decoding" do
+    encoded = Base64.strict_encode64("hello world").chars.each_slice(4).map(&:join).join("\n")
+    expect(transform.transform(encoded)).to eq("hello world")
+  end
+
+  it "raises TransformError on invalid base64" do
+    expect do
+      transform.transform("!!!not base64!!!")
+    end.to raise_error(Moxml::Signature::TransformError)
+  end
+end

data/spec/moxml/signature/algorithms/digest_base_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "openssl"
+require "base64"
+
+RSpec.describe Moxml::Signature::Algorithms::DigestBase do
+  describe "SHA-256" do
+    let(:digest) { Moxml::Signature::Algorithms::SHA256.new }
+
+    it "computes raw bytes matching OpenSSL" do
+      data = "hello"
+      expect(digest.digest(data)).to eq(OpenSSL::Digest::SHA256.digest(data))
+    end
+
+    it "computes base64-encoded digest matching OpenSSL" do
+      data = "hello"
+      expected = Base64.strict_encode64(OpenSSL::Digest::SHA256.digest(data))
+      expect(digest.digest_base64(data)).to eq(expected)
+    end
+
+    it "matches the FIPS 180-3 test vector for empty string" do
+      # SHA-256("") = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+      expected_hex = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+      expect(digest.digest("").unpack1("H*")).to eq(expected_hex)
+    end
+
+    it "matches the FIPS 180-3 test vector for 'abc'" do
+      expected_hex = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+      expect(digest.digest("abc").unpack1("H*")).to eq(expected_hex)
+    end
+  end
+
+  describe "SHA-1" do
+    it "matches the FIPS test vector for 'abc'" do
+      digest = Moxml::Signature::Algorithms::SHA1.new
+      expected_hex = "a9993e364706816aba3e25717850c26c9cd0d89d"
+      expect(digest.digest("abc").unpack1("H*")).to eq(expected_hex)
+    end
+
+    it "is registered under its W3C URI" do
+      klass = Moxml::Signature::Algorithms.lookup(
+        :digest, "http://www.w3.org/2000/09/xmldsig#sha1"
+      )
+      expect(klass).to eq(Moxml::Signature::Algorithms::SHA1)
+    end
+  end
+
+  describe "all five SHA digests" do
+    expected_uris = {
+      "http://www.w3.org/2000/09/xmldsig#sha1" =>
+        [Moxml::Signature::Algorithms::SHA1, 20],
+      "http://www.w3.org/2001/04/xmldsig-more#sha224" =>
+        [Moxml::Signature::Algorithms::SHA224, 28],
+      "http://www.w3.org/2001/04/xmlenc#sha256" =>
+        [Moxml::Signature::Algorithms::SHA256, 32],
+      "http://www.w3.org/2001/04/xmldsig-more#sha384" =>
+        [Moxml::Signature::Algorithms::SHA384, 48],
+      "http://www.w3.org/2001/04/xmlenc#sha512" =>
+        [Moxml::Signature::Algorithms::SHA512, 64],
+    }
+
+    expected_uris.each do |uri, (klass, byte_length)|
+      it "#{uri} resolves to #{klass.name.split('::').last} with #{byte_length}-byte output" do
+        instance = klass.new
+        result = instance.digest("test")
+        expect(result.bytesize).to eq(byte_length)
+      end
+    end
+  end
+end

data/spec/moxml/signature/algorithms/dsa_sha_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "openssl"
+
+RSpec.describe Moxml::Signature::Algorithms::DsaSha do
+  let(:key) { OpenSSL::PKey::DSA.generate(2048) }
+  let(:data) { "the quick brown fox jumps over the lazy dog" }
+
+  it "round-trips DSA-SHA1" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2000/09/xmldsig#dsa-sha1",
+    )
+    sig = algo.sign(data, key)
+    # DSA q for 2048-bit DSA is 256 bits → 32-byte halves → 64-byte raw sig.
+    expect(sig.bytesize).to eq(64)
+    expect(algo.verify(data, key, sig)).to be true
+  end
+
+  it "round-trips DSA-SHA256" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2009/xmldsig11#dsa-sha256",
+    )
+    sig = algo.sign(data, key)
+    expect(sig.bytesize).to eq(64)
+    expect(algo.verify(data, key, sig)).to be true
+  end
+
+  it "rejects tampered payload" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2009/xmldsig11#dsa-sha256",
+    )
+    sig = algo.sign(data, key)
+    expect(algo.verify("#{data}!", key, sig)).to be false
+  end
+
+  it "rejects non-DSA keys" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2009/xmldsig11#dsa-sha256",
+    )
+    expect do
+      algo.sign(data, OpenSSL::PKey::RSA.generate(2048))
+    end.to raise_error(Moxml::Signature::SignatureKeyError)
+  end
+end

data/spec/moxml/signature/algorithms/ecdsa_sha_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "openssl"
+
+RSpec.describe Moxml::Signature::Algorithms::EcdsaSha do
+  let(:key) { OpenSSL::PKey::EC.generate("prime256v1") }
+  let(:data) { "the quick brown fox jumps over the lazy dog" }
+
+  %w[
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha224
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha384
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha512
+  ].each do |uri|
+    it "#{uri} round-trips sign/verify on P-256" do
+      algo = described_class.new(identifier_uri: uri)
+      sig = algo.sign(data, key)
+      # P-256: 32-byte r ‖ 32-byte s = 64 bytes
+      expect(sig.bytesize).to eq(64)
+      expect(algo.verify(data, key, sig)).to be true
+    end
+  end
+
+  it "rejects tampered payload" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256",
+    )
+    sig = algo.sign(data, key)
+    expect(algo.verify("#{data}!", key, sig)).to be false
+  end
+
+  it "rejects verification with a different key" do
+    other = OpenSSL::PKey::EC.generate("prime256v1")
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256",
+    )
+    sig = algo.sign(data, key)
+    expect(algo.verify(data, other, sig)).to be false
+  end
+
+  it "supports P-384 with 48-byte coordinates" do
+    p384 = OpenSSL::PKey::EC.generate("secp384r1")
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha384",
+    )
+    sig = algo.sign(data, p384)
+    expect(sig.bytesize).to eq(96)
+    expect(algo.verify(data, p384, sig)).to be true
+  end
+
+  it "supports P-521 with 66-byte coordinates" do
+    p521 = OpenSSL::PKey::EC.generate("secp521r1")
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha512",
+    )
+    sig = algo.sign(data, p521)
+    expect(sig.bytesize).to eq(132)
+    expect(algo.verify(data, p521, sig)).to be true
+  end
+
+  it "rejects non-EC keys" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256",
+    )
+    expect do
+      algo.sign(data, OpenSSL::PKey::RSA.generate(2048))
+    end.to raise_error(Moxml::Signature::SignatureKeyError)
+  end
+end

data/spec/moxml/signature/algorithms/enveloped_signature_transform_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+
+RSpec.describe Moxml::Signature::Algorithms::EnvelopedSignatureTransform do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  it "is a no-op when signature_element is nil (signing case)" do
+    doc = ctx.parse("<root><child/></root>")
+    root = doc.root
+    transform = described_class.new(context: ctx, signature_element: nil)
+    expect(transform.transform(root)).to equal(root)
+  end
+
+  it "removes the containing signature from a copy (verification case)" do
+    xml = <<~XML.strip
+      <root>
+        <payload>important</payload>
+        <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
+          <ds:SignedInfo/>
+        </ds:Signature>
+      </root>
+    XML
+    doc = ctx.parse(xml)
+    sig_elem = doc.at_xpath("//ds:Signature",
+                            "ds" => "http://www.w3.org/2000/09/xmldsig#")
+
+    transform = described_class.new(context: ctx, signature_element: sig_elem)
+    result = transform.transform(doc.root)
+
+    expect(doc.at_xpath("//ds:Signature",
+                        "ds" => "http://www.w3.org/2000/09/xmldsig#")).not_to be_nil
+
+    c14n = Moxml::C14n::Exclusive.new
+    canonical = c14n.canonicalize(result)
+    expect(canonical).not_to include("Signature")
+    expect(canonical).to include("important")
+  end
+end