moxml 0.1.25 → 0.2.0

data/reference-docs/w3c-xmldsig-bestpractices.md

@@ -0,0 +1,216 @@
+# XML Signature Best Practices
+
+W3C Working Group Note 11 April 2013
+
+- This version: http://www.w3.org/TR/2013/NOTE-xmldsig-bestpractices-20130411/
+- Latest published version: http://www.w3.org/TR/xmldsig-bestpractices/
+- Latest editor's draft: http://www.w3.org/2008/xmlsec/Drafts/best-practices/Overview.html
+- Previous version: http://www.w3.org/TR/2013/NOTE-xmldsig-bestpractices-20130124/
+- Editors: Frederick Hirsch (Nokia), Pratik Datta (Oracle)
+
+Copyright © 2013 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved.
+
+## Abstract
+
+This document collects best practices for implementers and users of the XML
+Signature specification [XMLDSIG-CORE1]. Most of these best practices are
+related to improving security and mitigating attacks, yet others are for best
+practices in the practical use of XML Signature, such as signing XML that
+doesn't use namespaces, for example.
+
+## 1. Overview
+
+The XML Signature specification [XMLDSIG-CORE1] offers powerful and flexible
+mechanisms to support a variety of use cases. This flexibility has the downside
+of increasing the number of possible attacks. One countermeasure to the
+increased number of threats is to follow best practices, including a
+simplification of use of XML Signature where possible.
+
+## 2. Best Practices for Implementers
+
+### 2.1 Reduce the opportunities for denial of service attacks
+
+XML Signature may be used in application server systems, where multiple incoming
+messages are being processed simultaneously. In this situation incoming messages
+should be assumed to be possibly hostile with the concern that a single poison
+message could bring down an entire set of web applications and services.
+
+**Best Practice 1**: Mitigate denial of service attacks by executing potentially
+dangerous operations only after successfully authenticating the signature.
+
+Validate the `ds:Reference` elements for a signature only after establishing
+trust, for example by verifying the key and validating `ds:SignedInfo` first.
+
+Recommended order of operations:
+
+1. **Step 1** — fetch the verification key and establish trust in that key.
+2. **Step 2** — validate `ds:SignedInfo` with that key.
+3. **Step 3** — validate the references.
+
+**Best Practice 2**: Establish trust in the verification/validation key (validate
+X.509 certificates, certificate chains and revocation status).
+
+#### 2.1.1 XSLT transform that causes denial of service
+
+A nested-loop XSLT can require O(N^4) operations on a document with N elements.
+
+**Best Practice 3**: Consider avoiding XSLT Transforms.
+
+#### 2.1.2 XSLT transform that executes arbitrary code
+
+XSLT user-defined extensions can execute arbitrary code (e.g., shell commands).
+
+**Best Practice 4**: When XSLT is required disallow the use of user-defined
+extensions.
+
+#### 2.1.3 XPath Filtering transform that causes denial of service
+
+A document with N namespaces and N elements produces N×N namespace nodes; an
+XPath Filter evaluates the expression once per node, giving O(N^4) cost.
+
+**Best Practice 5**: Try to avoid or limit XPath transforms.
+
+#### 2.1.4 XPath selection DoS in streaming mode
+
+Wildcard axes (descendant, following, etc.) cause search-context explosion in
+streaming verifiers.
+
+**Best Practice 6**: Avoid using "descendant", "descendant-or-self",
+"following-sibling", and "following" axes when using streaming XPaths.
+
+#### 2.1.5 Retrieval method that causes an infinite loop
+
+`ds:RetrievalMethod` may form cyclic references.
+
+**Best Practice 7**: Try to avoid or limit `ds:RetrievalMethod` support with
+`ds:KeyInfo`.
+
+#### 2.1.6 Problematic external references
+
+External URI references can read sensitive files or trigger side effects on
+other sites.
+
+**Best Practice 8**: Control external references (mitigate query parameters,
+unknown URI schemes, inappropriate content).
+
+#### 2.1.7 Denial of service caused by too many transforms
+
+A reference may carry thousands of C14N transforms.
+
+**Best Practice 9**: Limit the number of `ds:Reference` transforms allowed.
+
+### 2.2 Provide a mechanism to determine what was signed
+
+**Best Practice 10**: Offer interfaces for the application to learn what was
+signed (return pre-digested data and pre-C14N data).
+
+### 2.3 Be aware of certificate encoding issues
+
+**Best Practice 11**: Do not re-encode certificates; use DER when possible with
+the `X509Certificate` element. Re-encoding can break the signature on the
+certificate.
+
+## 3. Best Practices for Applications
+
+### 3.1 Check what is signed
+
+**Best Practice 12**: Enable verifier to automate "see what is signed"
+functionality.
+
+**Best Practice 13**: When applying XML Signatures using XPath it is recommended
+to always actively verify that the signature protects the intended elements and
+not more or less.
+
+**Best Practice 14**: When checking a reference URI, don't just check the name of
+the element (wrapping attack mitigation — also check position).
+
+### 3.2 Prevent replay attacks
+
+**Best Practice 15**: Unless impractical, sign all parts of the document.
+
+**Best Practice 16**: Use a nonce in combination with signing time.
+
+**Best Practice 17**: Do not rely on application logic to prevent replay attacks
+since applications may change.
+
+**Best Practice 18**: Nonce and signing time must be signature protected.
+
+### 3.3 Enable Long-Lived Signatures
+
+**Best Practice 19**: Use Timestamp tokens issued by Timestamp authorities for
+long lived signatures.
+
+**Best Practice 20**: Long lived signatures should include a `xsd:dateTime` field
+to indicate the time of signing.
+
+### 3.4 Signing XML without namespace information ("legacy XML")
+
+**Best Practice 21**: When creating an enveloping signature over XML without
+namespace information, take steps to avoid having that content inherit the XML
+Signature namespace (insert an empty default namespace declaration, or define a
+namespace prefix for the Signature namespace).
+
+### 3.5 Prefer the XPath Filter 2 Transform
+
+**Best Practice 22**: Prefer the XPath Filter 2 Transform to the XPath Filter
+Transform if possible.
+
+## 4. Best Practices for Signers and Verifiers
+
+### 4.1 Do not transmit external unparsed entity references
+
+**Best Practice 23**: Do not transmit unparsed external entity references in
+signed material. Expand all entity references before creating the cleartext.
+
+### 4.2 Be aware of schema processing
+
+**Best Practice 24**: Do not rely on a validating processor on the consumer's end
+to normalize XML documents.
+
+**Best Practice 25**: Avoid destructive validation before signature validation.
+
+### 4.3 HMAC truncation
+
+**Best Practice 26**: When using an HMAC, set the HMAC Output Length to one half
+the number of bits in the hash size.
+
+### 4.4 Distinct keys for sign and encrypt
+
+**Best Practice 27**: When encrypting and signing use distinct keys.
+
+## 5. Best Practices Summary
+
+1. Mitigate DoS by authenticating before dangerous operations.
+2. Establish trust in the verification key.
+3. Avoid XSLT transforms.
+4. Disallow XSLT user-defined extensions.
+5. Avoid/limit XPath transforms.
+6. Avoid wildcard axes in streaming XPaths.
+7. Avoid/limit `ds:RetrievalMethod`.
+8. Control external references.
+9. Limit number of transforms per Reference.
+10. Offer interfaces to learn what was signed.
+11. Don't re-encode certificates; prefer DER.
+12. Enable verifier to "see what is signed".
+13. With XPath, verify the signature actually protects intended elements.
+14. When checking reference URI, check both name and position.
+15. Sign all parts of the document unless impractical.
+16. Use nonce + signing time.
+17. Don't rely solely on application logic for replay prevention.
+18. Nonce and signing time must be signature protected.
+19. Use TSA-issued timestamp tokens for long-lived signatures.
+20. Include `xsd:dateTime` for signing time in long-lived signatures.
+21. Avoid namespace inheritance in enveloping signatures over legacy XML.
+22. Prefer XPath Filter 2 over XPath Filter.
+23. Don't transmit unparsed external entity references.
+24. Don't rely on validating parser on consumer's end.
+25. Avoid destructive validation before signature validation.
+26. Truncate HMAC to half hash size.
+27. Use distinct keys for signing and encryption.
+
+## References
+
+- [XMLDSIG-CORE1] — XML Signature Syntax and Processing Version 1.1
+- [XADES] — XML Advanced Electronic Signatures (ETSI TS 101 903)
+- [RFC3161] — Internet X.509 PKI Time-Stamp Protocol (TSP)
+- [MCINTOSH-WRAP] — XML signature element wrapping attacks and countermeasures

data/reference-docs/w3c-xmldsig-core.md

@@ -0,0 +1,400 @@
+# XML Signature Syntax and Processing Version 1.1 (W3C Recommendation, 11 April 2013)
+
+Curated implementation-focused extract. Source: https://www.w3.org/TR/xmldsig-core/
+
+Editors: Donald Eastlake, Joseph Reagle, David Solo, Frederick Hirsch, Magnus Nyström, Thomas Roessler, Kelvin Yiu.
+
+## Abstract
+
+XML Signatures provide integrity, message authentication, and/or signer
+authentication services for data of any type, whether located within the XML
+that includes the signature or elsewhere.
+
+## Namespaces
+
+| URI | prefix |
+| --- | --- |
+| `http://www.w3.org/2000/09/xmldsig#` | `ds:` / `dsig:` |
+| `http://www.w3.org/2009/xmldsig11#` | `dsig11:` |
+
+Algorithm identifiers in the `http://www.w3.org/2001/04/xmldsig-more#` namespace
+are defined by RFC 6931.
+
+## Signature Structure
+
+```
+<Signature ID?>
+  <SignedInfo>
+    <CanonicalizationMethod />
+    <SignatureMethod />
+   (<Reference URI? >
+     (<Transforms>)?
+      <DigestMethod>
+      <DigestValue>
+    </Reference>)+
+  </SignedInfo>
+  <SignatureValue>
+ (<KeyInfo>)?
+ (<Object ID?>)*
+</Signature>
+```
+
+## Processing Rules
+
+### 3.1 Signature Generation
+
+#### 3.1.1 Reference Generation
+
+For each data object being signed:
+
+1. Apply the `Transforms`, as determined by the application, to the data object.
+2. Calculate the digest value over the resulting data object.
+3. Create a `Reference` element, including the (optional) identification of the
+   data object, any (optional) transform elements, the digest algorithm and the
+   `DigestValue`.
+
+#### 3.1.2 Signature Generation
+
+1. Create `SignedInfo` element with `SignatureMethod`, `CanonicalizationMethod`
+   and `Reference`(s).
+2. Canonicalize and then calculate the `SignatureValue` over `SignedInfo` based
+   on algorithms specified in `SignedInfo`.
+3. Construct the `Signature` element that includes `SignedInfo`, `Object`(s),
+   `KeyInfo` (if required), and `SignatureValue`.
+
+### 3.2 Core Validation
+
+The required steps of core validation include:
+
+1. **Reference validation** — verification of the digest contained in each
+   `Reference` in `SignedInfo`.
+2. **Signature validation** — cryptographic signature validation of the signature
+   calculated over `SignedInfo`.
+
+Comparison of each value is over the numeric (integer) or decoded octet sequence
+of the value.
+
+#### 3.2.1 Reference Validation
+
+1. Canonicalize the `SignedInfo` element based on the `CanonicalizationMethod`.
+2. For each `Reference` in `SignedInfo`:
+   1. Obtain the data object (dereference `URI`, execute `Transforms`, or fetch
+      from local cache).
+   2. Digest using the `DigestMethod`.
+   3. Compare against `DigestValue`; mismatch ⇒ validation fails.
+
+#### 3.2.2 Signature Validation
+
+1. Obtain the keying information from `KeyInfo` or external source.
+2. Obtain the canonical form of `SignedInfo` using `CanonicalizationMethod` and
+   confirm the `SignatureValue` over `SignedInfo`.
+
+## Schema
+
+### `ds:CryptoBinary`
+
+Integer-to-octet conversion equivalent to IEEE 1363 I2OSP with minimal length,
+then base64-encoded.
+
+### 4.2 `Signature`
+
+```xml
+<element name="Signature" type="ds:SignatureType"/>
+<complexType name="SignatureType">
+  <sequence>
+    <element ref="ds:SignedInfo"/>
+    <element ref="ds:SignatureValue"/>
+    <element ref="ds:KeyInfo" minOccurs="0"/>
+    <element ref="ds:Object" minOccurs="0" maxOccurs="unbounded"/>
+  </sequence>
+  <attribute name="Id" type="ID" use="optional"/>
+</complexType>
+```
+
+### 4.3 `SignatureValue`
+
+```xml
+<complexType name="SignatureValueType">
+  <simpleContent>
+    <extension base="base64Binary">
+      <attribute name="Id" type="ID" use="optional"/>
+    </extension>
+  </simpleContent>
+</complexType>
+```
+
+### 4.4 `SignedInfo`
+
+```xml
+<complexType name="SignedInfoType">
+  <sequence>
+    <element ref="ds:CanonicalizationMethod"/>
+    <element ref="ds:SignatureMethod"/>
+    <element ref="ds:Reference" maxOccurs="unbounded"/>
+  </sequence>
+  <attribute name="Id" type="ID" use="optional"/>
+</complexType>
+```
+
+### 4.4.1 `CanonicalizationMethod`
+
+```xml
+<complexType name="CanonicalizationMethodType" mixed="true">
+  <sequence>
+    <any namespace="##any" minOccurs="0" maxOccurs="unbounded"/>
+  </sequence>
+  <attribute name="Algorithm" type="anyURI" use="required"/>
+</complexType>
+```
+
+### 4.4.2 `SignatureMethod`
+
+```xml
+<complexType name="SignatureMethodType" mixed="true">
+  <sequence>
+    <element name="HMACOutputLength" minOccurs="0" type="ds:HMACOutputLengthType"/>
+    <any namespace="##other" minOccurs="0" maxOccurs="unbounded"/>
+  </sequence>
+  <attribute name="Algorithm" type="anyURI" use="required"/>
+</complexType>
+```
+
+Signatures MUST be deemed invalid if the HMAC truncation length is below the
+larger of (a) half the underlying hash output length, and (b) 80 bits.
+
+### 4.4.3 `Reference`
+
+```xml
+<complexType name="ReferenceType">
+  <sequence>
+    <element ref="ds:Transforms" minOccurs="0"/>
+    <element ref="ds:DigestMethod"/>
+    <element ref="ds:DigestValue"/>
+  </sequence>
+  <attribute name="Id" type="ID" use="optional"/>
+  <attribute name="URI" type="anyURI" use="optional"/>
+  <attribute name="Type" type="anyURI" use="optional"/>
+</complexType>
+```
+
+#### 4.4.3.2 Reference Processing Model
+
+Result of URI dereferencing or transforms is either octet stream or XPath node-set.
+
+Defaults:
+- octet stream + node-set transform expected ⇒ parse octets as XML.
+- node-set + octet transform expected ⇒ canonicalize via C14N.
+
+A **same-document reference** is a URI-Reference that consists of `#` followed by
+a fragment, or an empty URI.
+
+- `URI=""` ⇒ node-set (minus comments) of the entire document.
+- `URI="#id"` ⇒ node-set of the element with that ID + descendants + in-scope
+  namespaces/attributes, no comments.
+- `#xpointer(/)` retains comments at root.
+- `#xpointer(id('ID'))` retains comments for the element.
+
+### 4.4.3.4 `Transforms`
+
+```xml
+<complexType name="TransformsType">
+  <sequence>
+    <element ref="ds:Transform" maxOccurs="unbounded"/>
+  </sequence>
+</complexType>
+
+<complexType name="TransformType" mixed="true">
+  <choice minOccurs="0" maxOccurs="unbounded">
+    <any namespace="##other" processContents="lax"/>
+    <element name="XPath" type="string"/>
+  </choice>
+  <attribute name="Algorithm" type="anyURI" use="required"/>
+</complexType>
+```
+
+### 4.5 `KeyInfo`
+
+```xml
+<complexType name="KeyInfoType" mixed="true">
+  <choice maxOccurs="unbounded">
+    <element ref="ds:KeyName"/>
+    <element ref="ds:KeyValue"/>
+    <element ref="ds:RetrievalMethod"/>
+    <element ref="ds:X509Data"/>
+    <element ref="ds:PGPData"/>
+    <element ref="ds:SPKIData"/>
+    <element ref="ds:MgmtData"/>
+    <any processContents="lax" namespace="##other"/>
+  </choice>
+  <attribute name="Id" type="ID" use="optional"/>
+</complexType>
+```
+
+`KeyValue` contains one of `DSAKeyValue`, `RSAKeyValue`, or (1.1) `ECKeyValue`.
+
+X509Data child elements: `X509IssuerSerial` (deprecated), `X509SKI`,
+`X509SubjectName`, `X509Certificate`, `X509CRL`, `dsig11:X509Digest`.
+
+### 4.6 `Object`
+
+Optional element for including data objects. Has `Id`, `MimeType`, `Encoding`
+attributes.
+
+## Additional Syntax
+
+### 5.1 `Manifest`
+
+A list of `Reference`s where digest checking is application-defined (not core).
+
+### 5.2 `SignatureProperties`
+
+For signature-time, hardware serial, etc. `SignatureProperty` has required
+`Target` attribute referencing the `Signature` element.
+
+### 5.3 PIs and 5.4 Comments
+
+Unless `CanonicalizationMethod` strips comments or PIs, they are signed.
+
+## Algorithms
+
+### Mandatory & Recommended URIs
+
+**Digest**:
+- Required: SHA1 `http://www.w3.org/2000/09/xmldsig#sha1` (discouraged); SHA256
+  `http://www.w3.org/2001/04/xmlenc#sha256`
+- Optional: SHA224 `…xmldsig-more#sha224`; SHA384 `…xmldsig-more#sha384`; SHA512
+  `…xmlenc#sha512`
+
+**MAC**:
+- Required: HMAC-SHA1 `…xmldsig#hmac-sha1` (discouraged); HMAC-SHA256
+  `…xmldsig-more#hmac-sha256`
+- Recommended: HMAC-SHA384, HMAC-SHA512
+
+**Signature**:
+- Required: RSA-SHA256 `…xmldsig-more#rsa-sha256`; ECDSA-SHA256
+  `…xmldsig-more#ecdsa-sha256`; DSA-SHA1 (verification only) `…xmldsig#dsa-sha1`
+- Recommended: RSA-SHA1 (verification; discouraged for generation)
+- Optional: RSA-{SHA224,SHA384,SHA512}; ECDSA-{SHA1,SHA224,SHA384,SHA512};
+  DSA-SHA256 `…xmldsig11#dsa-sha256`
+
+**Canonicalization**:
+- Required:
+  - Canonical XML 1.0 (omit comments): `http://www.w3.org/TR/2001/REC-xml-c14n-20010315`
+  - Canonical XML 1.1 (omit comments): `http://www.w3.org/2006/12/xml-c14n11`
+  - Exclusive XML Canonicalization 1.0 (omit comments): `http://www.w3.org/2001/10/xml-exc-c14n#`
+- Recommended variants append `#WithComments`
+
+**Transform**:
+- Required: base64 `…xmldsig#base64`; Enveloped Signature
+  `…xmldsig#enveloped-signature`
+- Recommended: XPath `…REC-xpath-19991116`; XPath Filter 2.0
+  `…2002/06/xmldsig-filter2`
+- Optional: XSLT `…REC-xslt-19991116`
+
+### Digest Algorithms
+
+- SHA-1: 160-bit / 20 octets, base64-encoded.
+- SHA-256: 256-bit / 32 octets.
+- SHA-384: 384-bit / 48 octets.
+- SHA-512: 512-bit / 64 octets.
+
+### HMAC
+
+Identifier family: `…xmldsig#hmac-sha1`, `…xmldsig-more#hmac-{sha224,sha256,sha384,sha512}`.
+Truncation length (`HMACOutputLength`) MUST be a multiple of 8 bits. If below
+half the hash output length, signature MUST be deemed invalid.
+
+### DSA
+
+Identifier: `…xmldsig#dsa-sha1` (1024/160), `…xmldsig11#dsa-sha256` (2048/256 or
+3072/256).
+
+Output (r, s): base64-encoded concatenation of two octet streams using I2OSP with
+length parameter 20 (for SHA-1) or `N` (for SHA-256 with N=|q|).
+
+### RSA (PKCS#1 v1.5)
+
+Identifiers: `…xmldsig#rsa-sha1`, `…xmldsig-more#rsa-{sha224,sha256,sha384,sha512}`.
+RSASSA-PKCS1-v1_5 per RFC 3447 §8.2.1.
+
+### ECDSA
+
+Identifiers: `…xmldsig-more#ecdsa-{sha1,sha224,sha256,sha384,sha512}`.
+Output (r, s): base64-encoded concatenation of I2OSP of r and s, each of length
+equal to the base point order in bytes (32 for P-256, 66 for P-521).
+
+Required curve: P-256 (FIPS 186-3 §D.2.3). Recommended: P-384, P-521.
+
+### Canonicalization
+
+All algorithms take octet-stream or node-set, produce octet-stream output.
+Output is UTF-8 (no BOM), NFC. See [XML-C14N], [XML-C14N11], [XML-EXC-C14N].
+
+### Transforms
+
+- **base64** (octet→octet, node-set→octet): decodes base64. For node-set input,
+  logically applies `self::text()`, sorts by document order, concatenates.
+- **XPath Filtering** (octet|node-set → node-set): evaluates XPath per node,
+  includes nodes where boolean result is true. Includes `here()` function.
+- **Enveloped Signature**: removes the containing `Signature` element from
+  digest calculation. Equivalent to specific XPath.
+- **XSLT**: octet-stream → octet-stream via XSL stylesheet (sole child).
+
+## XML Canonicalization Considerations
+
+Signatures only work if verification uses the same bits as signing. XML surface
+forms vary, so canonicalization standardizes before signing/verification.
+
+Categories of change to canonicalize:
+1. XML 1.0 syntax (line endings, attribute defaults, entity refs, attribute
+   normalization).
+2. DOM/SAX information loss (attribute order, insignificant whitespace, namespace
+   declaration locations).
+3. Charset conversion.
+4. Namespace inheritance/context.
+
+All canonicalization algorithms identified use UTF-8 (no BOM) and do not perform
+character normalization. Applications SHOULD produce content in NFC.
+
+### Namespace Context and Portable Signatures
+
+Inclusive canonicalization "attracts" ancestor namespace context, breaking
+signatures when subdocuments are moved. Exclusive canonicalization "repels"
+ancestor context, preserving portability.
+
+## Security Considerations
+
+### 8.1 Transforms
+
+- Only what is signed is secure.
+- Only what is "seen" should be signed.
+- "See" what is signed (operate over canonicalized form).
+
+### 8.2 Security Models
+
+Public-key signatures vs keyed-hash MACs have different trust models. Public
+keys verify; only private-key holders can sign. MAC keys are shared; any
+verifier can forge.
+
+### 8.3 Algorithms, Key Lengths, Certificates
+
+Conforming implementations MUST support RSA signature generation and
+verification with public keys at least 2048 bits. 3072-bit recommended for
+signatures verified beyond 2030.
+
+### 8.4 Error Messages
+
+Generic error responses; avoid leaking specifics about algorithm processing.
+
+## References
+
+- [XML-C14N] Canonical XML 1.0
+- [XML-C14N11] Canonical XML 1.1
+- [XML-EXC-C14N] Exclusive XML Canonicalization 1.0
+- [PKCS1] RFC 3447 (RSA Cryptography Specifications v2.1)
+- [FIPS-186-3] Digital Signature Standard
+- [FIPS-180-3] Secure Hash Standard
+- [HMAC] RFC 2104
+- [RFC6931] Additional XML Security URIs
+- [XPATH] XML Path Language 1.0
+- [XMLDSIG-BESTPRACTICES] XML Signature Best Practices

data/spec/examples/readme_examples_spec.rb

@@ -110,10 +110,6 @@ RSpec.shared_examples "README Examples" do
   describe "Error handling example" do
     it "handles errors as shown in README" do
       context = Moxml.new
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
-
       expect do
         context.parse("<invalid>")
       end.to raise_error(Moxml::ParseError)

data/spec/examples/xpath_examples_spec.rb

@@ -24,20 +24,12 @@ RSpec.shared_examples "XPath Examples" do
     end
 
     it "finds nodes with namespaces" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't have a native XPath"
-      end
-
       titles = doc.xpath("//dc:title",
                          "dc" => "http://purl.org/dc/elements/1.1/")
       expect(titles.map(&:text)).to eq(%w[First Second])
     end
 
     it "finds nodes by attributes" do
-      if %i[ox headed_ox].include?(context.config.adapter_name)
-        pending "Ox doesn't have native XPath, HeadedOx parser doesn't support .// syntax yet"
-      end
-
       book = doc.at_xpath('//book[@id="2"]')
       expect(book).not_to be_nil
       title = book.at_xpath(".//dc:title",
@@ -46,9 +38,6 @@ RSpec.shared_examples "XPath Examples" do
     end
 
     it "finds nested attributes efficiently" do
-      if %i[ox headed_ox].include?(context.config.adapter_name)
-        pending "Ox doesn't have native XPath, HeadedOx parser doesn't support .// syntax yet"
-      end
       # More efficient - specific path
       titles1 = doc.xpath("//book/dc:title")
 

data/spec/fixtures/xmldsig/keys/rsa_private.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC8F3ut738mezjz
+Wg6J11OJCe28lyJXHcb6PbMJVm9NUC3MeMr27PI9s7ildxEodm9bOkXTIGD1ev4Y
+4p69cjMeyn1vFoxUyE+IN9+0pSVs/ABf19/349MFMTC1mpWlBvRtOKyCkLObQ0hn
+i+lMd4mQ+Ht+6+ZQNpNGIE0HcUUTH/r13AkmYLGYjlf2BwiqLP5MaxsdARormXwJ
+wsJD92us5MHN2P4Pew+J+TyCMdM94h7TCR4vmhZrX7EQcbIfsIEYpfRs3IeORW90
+CoXt7AgLmC+myMt8N/VF6OTKzXrShjGGeF88sikG0GSsIVWy7+tReqe4rfx/iavd
+da0LhPJVAgMBAAECggEAMSugaPmFj11CJ5fg2hcA3v/J9vW5g/WkWTG89pFyek8e
+Eeh4ArIxp4Cuog7s3NuNQ9eJfmZmAnZ7K60+mz7Z71A3F03ZNKbC59TXdeWAUavV
+Ozj3c1nLBf30gl0dhq05Q74/lshWM54UtQEF5bgQLeZPfoATzt9dg8UY7ful95f/
+StU1jJB16r7l8Oy1KyJE094ZL+dYSAaJaG/kb/hq857UJxU/9mmnqq0AsAseXrHm
+9T4AR5vJjhh71+3BHsQNxP6oO2ErV+Bd4MddMRYZbyo7jVIN6t6nti+uB+reKAi0
+FdcKNL+zldxPyKzt/dXh43M1Y60aFJ9jre/x+aqW9wKBgQDmGrguBixFJiBYdJXw
+NXyIDKDYPRlP3+B28piybne3JVvnyZQ+v5KmDCAtE4i/hIkX9/pdyXAoAfsEI8dc
+sarcFPynMjl+BpBxRKiMgIJvAsRh83HfrkewUTk9uhD3hqW4RlKZZIRlsPuEhIcG
+2oWJzwuDlRsZyrlqLef94O59FwKBgQDRQmJgZm0faJfIFkmy17iCSmpLCHsef3iJ
+gKr2yQBxOJMwConPauZEQ+YdTjk2XPo81TNpjWyBKZD+1RPPpJ5sFzUAfAqCfsxY
+EZWCzuZKntiegwOsdRrp5FdAFrFCmttW0p5AnTH23PMKxT+7fMDmuwq1X3pS712X
+hGujrnXncwKBgDKKrefWDUVHAZXMTd7MMMVFWNMGYJftycT2tlmC8CK3Pv+jhD9g
+HtsAENU11DSU7PPp0QFmrI7tGHCpVzHiCHB8353t5zjqQjHO7eKmm3+8sNv++AU0
+p6Rvws3vH6ju11mpgJ0WugoIHMbXwTzdJLXHV3UYfDJnF+DdonZeQKQTAoGAIo7K
+/k6MAN7eCg4cN6vGbcXqTd/lrUCx4EtecIj7SLdmH03uOlHWGzn3W6maay7pqHgx
+GGJho+cAagU4U1dFTmZ6u0zA05IrHvQwc7zFbVdUQME0LxvbyPqLqirVNUGrrWf0
++Ii9Qp50iLfQcZ8FoFUNTKyq391l4Gre99YM5J8CgYEA2EsA5AVf3Q4hkY5ImWN9
+hWgcvKaa1Fw8n59iGExgoh1Zr4p9SWxaNxa/iY3q0wdiQBMihEgFdc3JMBiS3RSe
+KZCpPAFeNW9RnXIQwnW06oyaiZkymLq96cYT5ToSLEoFl9/Z+ulMAYrfRJGszyR+
+hJAW5QUsrp1RKksKftYOAlA=
+-----END PRIVATE KEY-----

data/spec/fixtures/xmldsig/keys/rsa_public.pem

@@ -0,0 +1,9 @@
+-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvBd7re9/Jns481oOiddT
+iQntvJciVx3G+j2zCVZvTVAtzHjK9uzyPbO4pXcRKHZvWzpF0yBg9Xr+GOKevXIz
+Hsp9bxaMVMhPiDfftKUlbPwAX9ff9+PTBTEwtZqVpQb0bTisgpCzm0NIZ4vpTHeJ
+kPh7fuvmUDaTRiBNB3FFEx/69dwJJmCxmI5X9gcIqiz+TGsbHQEaK5l8CcLCQ/dr
+rOTBzdj+D3sPifk8gjHTPeIe0wkeL5oWa1+xEHGyH7CBGKX0bNyHjkVvdAqF7ewI
+C5gvpsjLfDf1Rejkys160oYxhnhfPLIpBtBkrCFVsu/rUXqnuK38f4mr3XWtC4Ty
+VQIDAQAB
+-----END PUBLIC KEY-----