XML Signature Syntax and Processing Version 1.1

2.1.1 More on Reference

[s05]   <Reference URI="http://www.w3.org/TR/2000/REC-xhtml1-20000126/"> 
[s06]     <Transforms> 
[s07]       <Transform Algorithm="http://www.w3.org/2006/12/xml-c14n11"/> 
[s08]     </Transforms> 
[s09]     <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/> 
[s10]     <DigestValue>dGhpcyBpcyBub3QgYSBzaWduYXR1cmUK...</DigestValue> 


[


s11


]




</


Reference


>

[s05] The optional URI attribute of Reference identifies the data object to be signed. This attribute may be omitted on at most one Reference in a Signature . (This limitation is imposed in order to ensure that references and objects may be matched unambiguously.)

[s05-08] This identification, along with the transforms, is a description provided by the signer on how they obtained the signed data object in the form it was digested (i.e. the digested content). The verifier may obtain the digested content in another method so long as the digest verifies. In particular, the verifier may obtain the content from a different location such as a local store than that specified in the URI .

[s06-08] Transforms is an optional ordered list of processing steps that were applied to the resource's content before it was digested. Transforms can include operations such as canonicalization, encoding/decoding (including compression/inflation), XSLT, XPath, XML schema validation, or XInclude. XPath transforms permit the signer to derive an XML document that omits portions of the source document. Consequently those excluded portions can change without affecting signature validity. For example, if the resource being signed encloses the signature itself, such a transform must be used to exclude the signature value from its own computation. If no Transforms element is present, the resource's content is digested directly. While the Working Group has specified mandatory (and optional) canonicalization and decoding algorithms, user specified transforms are permitted.

[s09-10] DigestMethod is the algorithm applied to the data after Transforms is applied (if specified) to yield the DigestValue . The signing of the DigestValue is what binds the content of a resource to the signer's key.

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 . (Note, it is the canonical form of these references that are signed in section 3.1.2 Signature Generation and validated in section 3.2.1 Reference Validation .)

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) (if desired, encoding may be different than that used for signing), KeyInfo (if required), and SignatureValue .

   Note, if the Signature includes same-document references, [ XML10 ] or [ XMLSCHEMA-1 ], [ XMLSCHEMA-2 ] validation of the document might introduce changes that break the signature. Consequently, applications should be careful to consistently process the document or refrain from using external contributions (e.g., defaults and entities).

3.2.1 Reference Validation

1. Canonicalize the SignedInfo element based on the CanonicalizationMethod in SignedInfo .
2. For each Reference in SignedInfo :
   1. Obtain the data object to be digested. (For example, the signature application may dereference the URI and execute Transforms provided by the signer in the Reference element, or it may obtain the content through other means such as a local cache.)
   2. Digest the resulting data object using the DigestMethod specified in its Reference specification.
   3. Compare the generated digest value against DigestValue in the SignedInfo Reference ; if there is any mismatch, validation fails.

Note, SignedInfo is canonicalized in step 1. The application must ensure that the CanonicalizationMethod has no dangerous side effects, such as rewriting URIs, (see note on Canonicalization Method ) and that it Sees What is Signed , which is the canonical form.

Note, After a Signature element has been created in Signature Generation for a signature with a same document reference, an implementation can serialize the XML content with variations in that serialization. This means that Reference Validation needs to canonicalize the XML document before digesting in step 1 to avoid issues related to variations in serialization.

3.2.2 Signature Validation

1. Obtain the keying information from KeyInfo or from an external source.
2. Obtain the canonical form of the SignatureMethod using the CanonicalizationMethod and use the result (and previously obtained KeyInfo ) to confirm the SignatureValue over the SignedInfo element.

Note, KeyInfo (or some transformed version thereof) may be signed via a Reference element. Transformation and validation of this reference (3.2.1) is orthogonal to Signature Validation which uses the KeyInfo as parsed.

Additionally, the SignatureMethod URI may have been altered by the canonicalization of SignedInfo (e.g., absolutization of relative URIs) and it is the canonical form that must MUST be used. However, the required canonicalization [ XML-C14N ] of this specification does not change URIs.

4.4.1 The CanonicalizationMethod Element

CanonicalizationMethod is a required element that specifies the canonicalization algorithm applied to the SignedInfo element prior to performing signature calculations. This element uses the general structure for algorithms described in section 6.1 Algorithm Identifiers and Implementation Requirements . Implementations must MUST support the required REQUIRED canonicalization algorithms .

Alternatives to the required REQUIRED canonicalization algorithms (section 6.5), such as Canonical XML with Comments (section 6.5.1) or a minimal canonicalization (such as CRLF and charset normalization) , may be explicitly specified but are not required NOT REQUIRED . Consequently, their use may not interoperate with other applications that do not support the specified algorithm (see XML Canonicalization and Syntax Constraint Considerations , section 7). Security issues may also arise in the treatment of entity processing and comments if non-XML aware canonicalization algorithms are not properly constrained (see section 8.1.2: Only What is "Seen" Should be Signed ).

The way in which the SignedInfo element is presented to the canonicalization method is dependent on that method. The following applies to algorithms which process XML as nodes or characters:

• XML based canonicalization implementations must MUST be provided with an [ XPATH ] node-set originally formed from the document containing the SignedInfo and currently indicating the SignedInfo , its descendants, and the attribute and namespace nodes of SignedInfo and its descendant elements.
• Text based canonicalization algorithms (such as CRLF and charset normalization) should be provided with the UTF-8 octets that represent the well-formed SignedInfo element, from the first character to the last character of the XML representation, inclusive. This includes the entire text of the start and end tags of the SignedInfo element as well as all descendant markup and character data (i.e., the text ) between those tags. Use of text based canonicalization of SignedInfo is not recommended NOT RECOMMENDED .

We recommend applications that implement a text-based instead of XML-based canonicalization -- such as resource constrained apps -- generate canonicalized XML as their output serialization so as to mitigate interoperability and security concerns. For instance, such an implementation should SHOULD (at least) generate standalone XML instances [ XML10 ].

Note : The signature application must exercise great care in accepting and executing an arbitrary CanonicalizationMethod . For example, the canonicalization method could rewrite the URIs of the Reference s being validated. Or, the method could massively transform SignedInfo so that validation would always succeed (i.e., converting it to a trivial signature with a known key over trivial data). Since CanonicalizationMethod is inside SignedInfo , in the resulting canonical form it could erase itself from SignedInfo or modify the SignedInfo element so that it appears that a different canonicalization function was used! Thus a Signature which appears to authenticate the desired data with the desired key, DigestMethod , and SignatureMethod , can be meaningless if a capricious CanonicalizationMethod is used.

Schema




Definition

:

<element




name


=


"CanonicalizationMethod"




type


=


"ds:CanonicalizationMethodType"


/>




<complexType




name


=


"CanonicalizationMethodType"




mixed


=


"true"


>




<sequence>




<any




namespace


=


"##any"




minOccurs


=


"0"




maxOccurs


=


"unbounded"


/>




<!--
(0,unbounded)
elements
from
(1,1)
namespace
-->




</sequence>




<attribute




name


=


"Algorithm"




type


=


"anyURI"




use


=


"required"


/>




</complexType>

4.4.2 The SignatureMethod Element

SignatureMethod is a required element that specifies the algorithm used for signature generation and validation. This algorithm identifies all cryptographic functions involved in the signature operation (e.g. hashing, public key algorithms, MACs, padding, etc.). This element uses the general structure here for algorithms described in section 6.1 Algorithm Identifiers and Implementation Requirements . While there is a single identifier, that identifier may specify a format containing multiple distinct signature values.

Schema




Definition

:

<element




name


=


"SignatureMethod"




type


=


"ds:SignatureMethodType"


/>




<complexType




name


=


"SignatureMethodType"




mixed


=


"true"


>




<sequence>




<element




name


=


"HMACOutputLength"




minOccurs


=


"0"




type


=


"ds:HMACOutputLengthType"


/>




<any




namespace


=


"##other"




minOccurs


=


"0"




maxOccurs


=


"unbounded"


/>




<!--
(0,unbounded)
elements
from
(1,1)
external
namespace
-->




</sequence>




<attribute




name


=


"Algorithm"




type


=


"anyURI"




use


=


"required"


/>




</complexType>

The ds:HMACOutputLength parameter is used for HMAC [ HMAC ] algorithms. The parameter specifies a truncation length in bits. If this parameter is trusted without further verification, then this can lead to a security bypass [ CVE-2009-0217 ]. Signatures must MUST be deemed invalid if the truncation length is below the larger of (a) half the underlying hash algorithm's output length, and (b) 80 bits. Note that some implementations are known to not accept truncation lengths that are lower than the underlying hash algorithm's output length.

4.4.3 The Reference Element

Reference is an element that may occur one or more times. It specifies a digest algorithm and digest value, and optionally an identifier of the object being signed, the type of the object, and/or a list of transforms to be applied prior to digesting. The identification (URI) and transforms describe how the digested content (i.e., the input to the digest method) was created. The Type attribute facilitates the processing of referenced data. For example, while this specification makes no requirements over external data, an application may wish to signal that the referent is a Manifest . An optional ID attribute permits a Reference to be referenced from elsewhere.

Schema




Definition

:

<element




name


=


"Reference"




type


=


"ds:ReferenceType"


/>




<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>

Schema




Definition

:

<element




name


=


"Transforms"




type


=


"ds:TransformsType"


/>




<complexType




name


=


"TransformsType"


>




<sequence>




<element




ref


=


"ds:Transform"




maxOccurs


=


"unbounded"


/>




</sequence>




</complexType>




<element




name


=


"Transform"




type


=


"ds:TransformType"


/>




<complexType




name


=


"TransformType"




mixed


=


"true"


>




<choice




minOccurs


=


"0"




maxOccurs


=


"unbounded"


>




<any




namespace


=


"##other"




processContents


=


"lax"


/>




<!--
(1,1)
elements
from
(0,unbounded)
namespaces
-->




<element




name


=


"XPath"




type


=


"string"


/>




</choice>




<attribute




name


=


"Algorithm"




type


=


"anyURI"




use


=


"required"


/>




</complexType>

Schema




Definition

:

<element




name


=


"DigestMethod"




type


=


"ds:DigestMethodType"


/>




<complexType




name


=


"DigestMethodType"




mixed


=


"true"


>




<sequence>




<any




namespace


=


"##other"




processContents


=


"lax"




minOccurs


=


"0"




maxOccurs


=


"unbounded"


/>




</sequence>




<attribute




name


=


"Algorithm"




type


=


"anyURI"




use


=


"required"


/>




</complexType>

Schema




Definition

:

<element




name


=


"DigestValue"




type


=


"ds:DigestValueType"


/>




<simpleType




name


=


"DigestValueType"


>




<restriction




base


=


"base64Binary"


/>




</simpleType>

4.5.1 The KeyName Element

The KeyName element contains a string value (in which white space is significant) which may be used by the signer to communicate a key identifier to the recipient. Typically, KeyName contains an identifier related to the key pair used to sign the message, but it may contain other protocol-related information that indirectly identifies a key pair. (Common uses of KeyName include simple string names for keys, a key index, a distinguished name (DN), an email address, etc.)

Schema




Definition

:

<element




name


=


"KeyName"




type


=


"string"




/>

4.5.2 The KeyValue Element

The KeyValue element contains a single public key that may be useful in validating the signature. Structured formats for defining DSA ( required REQUIRED ), RSA ( required REQUIRED ) and ECDSA ( required REQUIRED ) public keys are defined in section 6.4 Signature Algorithms . The KeyValue element may include externally defined public keys values represented as PCDATA or element types from an external namespace.

Schema




Definition

:

<element




name


=


"KeyValue"




type


=


"ds:KeyValueType"




/>




<complexType




name


=


"KeyValueType"




mixed


=


"true"


>




<choice>




<element




ref


=


"ds:DSAKeyValue"


/>




<element




ref


=


"ds:RSAKeyValue"


/>




<!--
<element
ref="dsig11:ECKeyValue"/>
-->




<!--
ECC
keys
(XMLDsig
1.1)
will
use
the
any
element
-->




<any




namespace


=


"##other"




processContents


=


"lax"


/>




</choice>




</complexType>

Schema




Definition

:

<element




name


=


"DSAKeyValue"




type


=


"ds:DSAKeyValueType"




/>




<complexType




name


=


"DSAKeyValueType"


>




<sequence>




<sequence




minOccurs


=


"0"


>




<element




name


=


"P"




type


=


"ds:CryptoBinary"


/>




<element




name


=


"Q"




type


=


"ds:CryptoBinary"


/>




</sequence>




<element




name


=


"G"




type


=


"ds:CryptoBinary"




minOccurs


=


"0"


/>




<element




name


=


"Y"




type


=


"ds:CryptoBinary"


/>




<element




name


=


"J"




type


=


"ds:CryptoBinary"




minOccurs


=


"0"


/>




<sequence




minOccurs


=


"0"


>




<element




name


=


"Seed"




type


=


"ds:CryptoBinary"


/>




<element




name


=


"PgenCounter"




type


=


"ds:CryptoBinary"


/>




</sequence>




</sequence>




</complexType>

<RSAKeyValue>
  <Modulus>xA7SEU+e0yQH5rm9kbCDN9o3aPIo7HbP7tX6WOocLZAtNfyxSZDU16ksL6W
  jubafOqNEpcwR3RdFsT7bCqnXPBe5ELh5u4VEy19MzxkXRgrMvavzyBpVRgBUwUlV
  5foK5hhmbktQhyNdy/6LpQRhDUDsTvK+g9Ucj47es9AQJ3U=
  </Modulus>
  <Exponent>AQAB</Exponent>


</RSAKeyValue>

Schema




Definition

:

<element




name


=


"RSAKeyValue"




type


=


"ds:RSAKeyValueType"




/>




<complexType




name


=


"RSAKeyValueType"


>




<sequence>




<element




name


=


"Modulus"




type


=


"ds:CryptoBinary"




/>




<element




name


=


"Exponent"




type


=


"ds:CryptoBinary"




/>




</sequence>




</complexType>

<ECKeyValue xmlns="http://www.w3.org/2009/xmldsig11#">
  <NamedCurve URI="urn:oid:1.2.840.10045.3.1.7" />
  <PublicKey>
    vWccUP6Jp3pcaMCGIcAh3YOev4gaa2ukOANC7Ufg
    Cf8KDO7AtTOsGJK7/TA8IC3vZoCy9I5oPjRhyTBulBnj7Y
  </PublicKey>


</ECKeyValue>

Schema




Definition

:

<!--
targetNamespace="http://www.w3.org/2009/xmldsig11#"
-->




<element




name


=


"ECKeyValue"




type


=


"dsig11:ECKeyValueType"




/>




<complexType




name


=


"ECKeyValueType"


>




<sequence>




<choice>




<element




name


=


"ECParameters"




type


=


"dsig11:ECParametersType"




/>




<element




name


=


"NamedCurve"




type


=


"dsig11:NamedCurveType"




/>




</choice>




<element




name


=


"PublicKey"




type


=


"dsig11:ECPointType"




/>




</sequence>




<attribute




name


=


"Id"




type


=


"ID"




use


=


"optional"




/>




</complexType>




<complexType




name


=


"NamedCurveType"


>




<attribute




name


=


"URI"




type


=


"anyURI"




use


=


"required"




/>




</complexType>




<simpleType




name


=


"ECPointType"


>




<restriction




base


=


"ds:CryptoBinary"




/>




</simpleType>

Schema




Definition

:

<!--
targetNamespace="http://www.w3.org/2009/xmldsig11#"
-->




<complexType




name


=


"ECParametersType"


>




<sequence>




<element




name


=


"FieldID"




type


=


"dsig11:FieldIDType"




/>




<element




name


=


"Curve"




type


=


"dsig11:CurveType"




/>




<element




name


=


"Base"




type


=


"dsig11:ECPointType"




/>




<element




name


=


"Order"




type


=


"ds:CryptoBinary"




/>




<element




name


=


"CoFactor"




type


=


"integer"




minOccurs


=


"0"




/>




<element




name


=


"ValidationData"




type


=


"dsig11:ECValidationDataType"




minOccurs


=


"0"




/>




</sequence>




</complexType>




<complexType




name


=


"FieldIDType"


>




<choice>




<element




ref


=


"dsig11:Prime"




/>




<element




ref


=


"dsig11:TnB"




/>




<element




ref


=


"dsig11:PnB"




/>




<element




ref


=


"dsig11:GnB"




/>




<any




namespace


=


"##other"




processContents


=


"lax"




/>




</choice>




</complexType>




<complexType




name


=


"CurveType"


>




<sequence>




<element




name


=


"A"




type


=


"ds:CryptoBinary"




/>




<element




name


=


"B"




type


=


"ds:CryptoBinary"




/>




</sequence>




</complexType>




<complexType




name


=


"ECValidationDataType"


>




<sequence>




<element




name


=


"seed"




type


=


"ds:CryptoBinary"




/>




</sequence>




<attribute




name


=


"hashAlgorithm"




type


=


"anyURI"




use


=


"required"




/>




</complexType>

Schema




Definition

:

<!--
targetNamespace="http://www.w3.org/2009/xmldsig11#"
-->




<element




name


=


"Prime"




type


=


"dsig11:PrimeFieldParamsType"




/>




<complexType




name


=


"PrimeFieldParamsType"


>




<sequence>




<element




name


=


"P"




type


=


"ds:CryptoBinary"




/>




</sequence>




</complexType>

Schema




Definition

:

<!--
targetNamespace="http://www.w3.org/2009/xmldsig11#"
-->




<element




name


=


"GnB"




type


=


"dsig11:CharTwoFieldParamsType"




/>




<complexType




name


=


"CharTwoFieldParamsType"


>




<sequence>




<element




name


=


"M"




type


=


"positiveInteger"




/>




</sequence>




</complexType>




<element




name


=


"TnB"




type


=


"dsig11:TnBFieldParamsType"




/>




<complexType




name


=


"TnBFieldParamsType"


>




<complexContent>




<extension




base


=


"dsig11:CharTwoFieldParamsType"


>




<sequence>




<element




name


=


"K"




type


=


"positiveInteger"




/>




</sequence>




</extension>




</complexContent>




</complexType>




<element




name


=


"PnB"




type


=


"dsig11:PnBFieldParamsType"




/>




<complexType




name


=


"PnBFieldParamsType"


>




<complexContent>




<extension




base


=


"dsig11:CharTwoFieldParamsType"


>




<sequence>




<element




name


=


"K1"




type


=


"positiveInteger"




/>




<element




name


=


"K2"




type


=


"positiveInteger"




/>




<element




name


=


"K3"




type


=


"positiveInteger"




/>




</sequence>




</extension>




</complexContent>




</complexType>

<ECDSAKeyValue xmlns="http://www.w3.org/2001/04/xmldsig-more#">
  <DomainParameters>
    <NamedCurve URN="urn:oid:1.2.840.10045.3.1.7" />
  </DomainParameters>
  <PublicKey>
    <X Value="5851106065380174439324917904648283332
              0204931884267326155134056258624064349885" />
    <Y Value="1024033521368277752409102672177795083
              59028642524881540878079119895764161434936" />
  </PublicKey>


</ECDSAKeyValue>

4.5.3 The RetrievalMethod Element

A RetrievalMethod element within KeyInfo is used to convey a reference to KeyInfo information that is stored at another location. For example, several signatures in a document might use a key verified by an X.509v3 certificate chain appearing once in the document or remotely outside the document; each signature's KeyInfo can reference this chain using a single RetrievalMethod element instead of including the entire chain with a sequence of X509Certificate elements.

RetrievalMethod uses the same syntax and dereferencing behavior as the Reference URI attribute ( section 4.4.3.1 The URI Attribute ) and the Reference Processing Model except that there are no DigestMethod or DigestValue child elements and presence of the URI attribute is mandatory.

Type is an optional identifier for the type of data retrieved after all transforms have been applied. The result of dereferencing a RetrievalMethod Reference for all KeyInfo types defined by this specification ( section 4.5 The KeyInfo Element ) with a corresponding XML structure is an XML element or document with that element as the root. The rawX509Certificate KeyInfo (for which there is no XML structure) returns a binary X509 certificate.

Note that when referencing one of the defined KeyInfo types within the same document, or some remote documents, at least one Transform is required to turn an ID-based reference to a KeyInfo element into a child element located inside it. This is due to the lack of an XML ID attribute on the defined KeyInfo types. In such cases, use of KeyInfoReference is encouraged instead, see section 4.5.10 The KeyInfoReference Element .

Note: The KeyInfoReference element is preferred over use of RetrievalMethod as it avoids use of Transform child elements that introduce security risk and implementation challenges.

Schema




Definition

:

<element




name


=


"RetrievalMethod"




type


=


"ds:RetrievalMethodType"




/>




<complexType




name


=


"RetrievalMethodType"


>




<sequence>




<element




ref


=


"ds:Transforms"




minOccurs


=


"0"




/>




</sequence>




<attribute




name


=


"URI"




type


=


"anyURI"




/>




<attribute




name


=


"Type"




type


=


"anyURI"




use


=


"optional"




/>




</complexType>

Note: The schema for the URI attribute of RetrievalMethod erroneously omitted the attribute: use="required" . However, this error only results in a more lax schema which permits all valid RetrievalMethod elements. Because the existing schema is embedded in many applications, which may include the schema in their signatures, the schema has not been corrected to be more restrictive.

4.5.4 The X509Data Element

Identifier

Type=" http://www.w3.org/2000/09/xmldsig#X509Data "
(this can be used within a RetrievalMethod or Reference element to identify the referent's type)

An X509Data element within KeyInfo contains one or more identifiers of keys or X509 certificates (or certificates' identifiers or a revocation list). The content of X509Data is at least one element, from the following set of element types; any of these may appear together or more than once iff (if and only if) each instance describes or is related to the same certificate:

• The deprecated X509IssuerSerial element, which contains an X.509 issuer distinguished name/serial number pair. The distinguished name should SHOULD be represented as a string that complies with section 3 of RFC4514 [ LDAP-DN ], to be generated according to the Distinguished Name Encoding Rules section below,
• The X509SubjectName element, which contains an X.509 subject distinguished name that should SHOULD be represented as a string that complies with section 3 of RFC4514 [ LDAP-DN ], to be generated according to the Distinguished Name Encoding Rules section below,
• The X509SKI element, which contains the base64 encoded plain (i.e. non-DER-encoded) value of a X509 V.3 SubjectKeyIdentifier extension,
• The X509Certificate element, which contains a base64-encoded [ X509V3 ] certificate, and
• The X509CRL element, which contains a base64-encoded certificate revocation list (CRL) [ X509V3 ].
• The dsig11:X509Digest element contains a base64-encoded digest of a certificate. The digest algorithm URI is identified with a required Algorithm attribute. The input to the digest must MUST be the raw octets that would be base64-encoded were the same certificate to appear in the X509Certificate element.
• Elements from an external namespace which accompanies/complements any of the elements above.

Any X509IssuerSerial , X509SKI , X509SubjectName , and dsig11:X509Digest elements that appear must MUST refer to the certificate or certificates containing the validation key. All such elements that refer to a particular individual certificate must MUST be grouped inside a single X509Data element and if the certificate to which they refer appears, it must MUST also be in that X509Data element.

Any X509IssuerSerial , X509SKI , X509SubjectName , and dsig11:X509Digest elements that relate to the same key but different certificates must MUST be grouped within a single KeyInfo but may MAY occur in multiple X509Data elements.

Note that if X509Data child elements are used to identify a trusted certificate (rather than solely as an untrusted hint supplemented by validation by policy), the complete set of such elements that are intended to identify a certificate should SHOULD be integrity protected, typically by signing an entire X509Data or KeyInfo element.

All certificates appearing in an X509Data element must MUST relate to the validation key by either containing it or being part of a certification chain that terminates in a certificate containing the validation key.

No ordering is implied by the above constraints. The comments in the following instance demonstrate these constraints:

<KeyInfo>
  <X509Data> <!-- two pointers to certificate-A -->
    <X509IssuerSerial> 
      <X509IssuerName>
        CN=TAMURA Kent, OU=TRL, O=IBM, L=Yamato-shi, ST=Kanagawa, C=JP
      </X509IssuerName>
      <X509SerialNumber>12345678</X509SerialNumber>
    </X509IssuerSerial>
    <X509SKI>31d97bd7</X509SKI> 
  </X509Data>
  <X509Data><!-- single pointer to certificate-B -->
    <X509SubjectName>Subject of Certificate B</X509SubjectName>
  </X509Data>
  <X509Data> <!-- certificate chain -->
    <!--Signer cert, issuer CN=arbolCA,OU=FVT,O=IBM,C=US, serial 4-->
    <X509Certificate>MIICXTCCA..</X509Certificate>
    <!-- Intermediate cert subject CN=arbolCA,OU=FVT,O=IBM,C=US 
         issuer CN=tootiseCA,OU=FVT,O=Bridgepoint,C=US -->
    <X509Certificate>MIICPzCCA...</X509Certificate>
    <!-- Root cert subject CN=tootiseCA,OU=FVT,O=Bridgepoint,C=US -->
    <X509Certificate>MIICSTCCA...</X509Certificate>
  </X509Data>


</KeyInfo>

Note, there is no direct provision for a PKCS#7 encoded "bag" of certificates or CRLs. However, a set of certificates and CRLs can occur within an X509Data element and multiple X509Data elements can occur in a KeyInfo . Whenever multiple certificates occur in an X509Data element, at least one such certificate must contain the public key which verifies the signature.

While in principle many certificate encodings are possible, it is recommended RECOMMENDED that certificates appearing in an X509Certificate element be limited to an encoding of BER or its DER subset, allowing that within the certificate other content may be present. The use of other encodings may lead to interoperability issues. In any case, XML Signature implementations should not SHOULD NOT alter or re-encode certificates, as doing so could invalidate their signatures.

The X509IssuerSerial element has been deprecated in favor of the newly-introduced dsig11:X509Digest element. The XML Schema type of the serial number was defined to be an integer, and XML Schema validators may not support integer types with decimal data exceeding 18 decimal digits [ XMLSCHEMA-2 ]. This has proven insufficient, because many Certificate Authorities issue certificates with large, random serial numbers that exceed this limit. As a result, deployments that do make use of this element should take care if schema validation is involved. New deployments should SHOULD avoid use of the element.

Schema




Definition

:

<element




name


=


"X509Data"




type


=


"ds:X509DataType"


/>




<complexType




name


=


"X509DataType"


>




<sequence




maxOccurs


=


"unbounded"


>




<choice>




<element




name


=


"X509IssuerSerial"




type


=


"ds:X509IssuerSerialType"


/>




<element




name


=


"X509SKI"




type


=


"base64Binary"


/>




<element




name


=


"X509SubjectName"




type


=


"string"


/>




<element




name


=


"X509Certificate"




type


=


"base64Binary"


/>




<element




name


=


"X509CRL"




type


=


"base64Binary"


/>




<!--
<element
ref="dsig11:X509Digest"/>
-->




<!--
The
X509Digest
element
(XMLDSig
1.1)
will
use
the
any
element
-->




<any




namespace


=


"##other"




processContents


=


"lax"


/>




</choice>




</sequence>




</complexType>




<complexType




name


=


"X509IssuerSerialType"


>




<sequence>




<element




name


=


"X509IssuerName"




type


=


"string"


/>




<element




name


=


"X509SerialNumber"




type


=


"integer"


/>




</sequence>




</complexType>




<!--
Note,
this
schema
permits
X509Data
to
be
empty;
this
is
precluded
by
the
text
in
<a
href="#sec-KeyInfo"
class="sectionRef"></a>
which
states
that
at
least
one
element
from
the
dsig
namespace
should
be
present
in
the
PGP,
SPKI,
and
X509
structures.
This
is
easily
expressed
for
the
other
key
types,
but
not
for
X509Data
because
of
its
rich
structure.
-->




<!--
targetNameSpace="http://www.w3.org/2009/xmldsig11#"
-->




<element




name


=


"X509Digest"




type


=


"dsig11:X509DigestType"


/>




<complexType




name


=


"X509DigestType"


>




<simpleContent>




<extension




base


=


"base64Binary"


>




<attribute




name


=


"Algorithm"




type


=


"anyURI"




use


=


"required"


/>




</extension>




</simpleContent>




</complexType>

4.5.5 The PGPData Element

Identifier

Type=" http://www.w3.org/2000/09/xmldsig#PGPData "
(this can be used within a RetrievalMethod or Reference element to identify the referent's type)

The PGPData element within KeyInfo is used to convey information related to PGP public key pairs and signatures on such keys. The PGPKeyID 's value is a base64Binary sequence containing a standard PGP public key identifier as defined in [ PGP ] section 11.2]. The PGPKeyPacket contains a base64-encoded Key Material Packet as defined in [ PGP ] section 5.5]. These children element types can be complemented/extended by siblings from an external namespace within PGPData , or PGPData can be replaced all together with an alternative PGP XML structure as a child of KeyInfo . PGPData must contain one PGPKeyID and/or one PGPKeyPacket and 0 or more elements from an external namespace.

Schema




Definition

:

<element




name


=


"PGPData"




type


=


"ds:PGPDataType"


/>




<complexType




name


=


"PGPDataType"


>




<choice>




<sequence>




<element




name


=


"PGPKeyID"




type


=


"base64Binary"


/>




<element




name


=


"PGPKeyPacket"




type


=


"base64Binary"




minOccurs


=


"0"


/>




<any




namespace


=


"##other"




processContents


=


"lax"




minOccurs


=


"0"




maxOccurs


=


"unbounded"


/>




</sequence>




<sequence>




<element




name


=


"PGPKeyPacket"




type


=


"base64Binary"


/>




<any




namespace


=


"##other"




processContents


=


"lax"




minOccurs


=


"0"




maxOccurs


=


"unbounded"


/>




</sequence>




</choice>




</complexType>

4.5.6 The SPKIData Element

Identifier

Type=" http://www.w3.org/2000/09/xmldsig#SPKIData "
(this can be used within a RetrievalMethod or Reference element to identify the referent's type)

The SPKIData element within KeyInfo is used to convey information related to SPKI public key pairs, certificates and other SPKI data. SPKISexp is the base64 encoding of a SPKI canonical S-expression. SPKIData must have at least one SPKISexp ; SPKISexp can be complemented/extended by siblings from an external namespace within SPKIData , or SPKIData can be entirely replaced with an alternative SPKI XML structure as a child of KeyInfo .

Schema




Definition

:

<element




name


=


"SPKIData"




type


=


"ds:SPKIDataType"


/>




<complexType




name


=


"SPKIDataType"


>




<sequence




maxOccurs


=


"unbounded"


>




<element




name


=


"SPKISexp"




type


=


"base64Binary"


/>




<any




namespace


=


"##other"




processContents


=


"lax"




minOccurs


=


"0"


/>




</sequence>




</complexType>

4.5.7 The MgmtData Element

Identifier

Type=" http://www.w3.org/2000/09/xmldsig#MgmtData "
(this can be used within a RetrievalMethod or Reference element to identify the referent's type)

Schema




Definition

:

<element




name


=


"MgmtData"




type


=


"string"




/>

4.5.8 XML Encryption EncryptedKey and DerivedKey Elements

4.5.9 The DEREncodedKeyValue Element

Identifier

Type=" http://www.w3.org/2009/xmldsig11#DEREncodedKeyValue "
(this can be used within a RetrievalMethod or Reference element to identify the referent's type)

The public key algorithm and value are DER-encoded in accordance with the value that would be used in the Subject Public Key Info field of an X.509 certificate, per section 4.1.2.7 of [ RFC5280 ]. The DER-encoded value is then base64-encoded.

For the key value types supported in this specification, refer to the following for normative references on the format of Subject Public Key Info and the relevant OID values that identify the key/algorithm type:

RSA

See section 2.3.1 of [ RFC3279 ]

DSA

See section 2.3.2 of [ RFC3279 ]

EC

See section 2 of [ RFC5480 ]

Specifications that define additional key types should provide such a normative reference for their own key types where possible.

Schema




Definition

:

<!--
targetNamespace="http://www.w3.org/2009/xmldsig11#"
-->




<element




name


=


"DEREncodedKeyValue"




type


=


"dsig11:DEREncodedKeyValueType"




/>




<complexType




name


=


"DEREncodedKeyValueType"


>




<simpleContent>




<extension




base


=


"base64Binary"


>




<attribute




name


=


"Id"




type


=


"ID"




use


=


"optional"


/>




</extension>




</simpleContent>




</complexType>

Historical note: The DEREncodedKeyValue element was added to XML Signature 1.1 in order to support certain interoperability scenarios where at least one of signer and/or verifier are not able to serialize keys in the XML formats described in section 4.5.2 The KeyValue Element above. The KeyValue element is to be used for "bare" XML key representations (not XML wrappings around other binary encodings like ASN.1 DER); for this reason the DEREncodedKeyValue element is not a child of KeyValue . The DEREncodedKeyValue element is also not a child of the X509Data element, as the keys represented by DEREncodedKeyValue may not have X.509 certificates associated with them (a requirement for X509Data ).

4.5.10 The KeyInfoReference Element

A KeyInfoReference element within KeyInfo is used to convey a reference to a KeyInfo element at another location in the same or different document. For example, several signatures in a document might use a key verified by an X.509v3 certificate chain appearing once in the document or remotely outside the document; each signature's KeyInfo can reference this chain using a single KeyInfoReference element instead of including the entire chain with a sequence of X509Certificate elements repeated in multiple places.

KeyInfoReference uses the same syntax and dereferencing behavior as Reference 's URI ( section 4.4.3.1 The URI Attribute ) and the Reference Processing Model ( section 4.4.3.2 The Reference Processing Model ) except that there are no child elements and the presence of the URI attribute is mandatory.

The result of dereferencing a KeyInfoReference must MUST be a KeyInfo element, or an XML document with a KeyInfo element as the root.

Note: The KeyInfoReference element is a desirable alternative to the use of RetrievalMethod when the data being referred to is a KeyInfo element and the use of RetrievalMethod would require one or more Transform child elements, which introduce security risk and implementation challenges.

Schema




Definition

:

<!--
targetNamespace="http://www.w3.org/2009/xmldsig11#"
-->




<element




name


=


"KeyInfoReference"




type


=


"dsig11:KeyInfoReferenceType"


/>




<complexType




name


=


"KeyInfoReferenceType"


>




<attribute




name


=


"URI"




type


=


"anyURI"




use


=


"required"


/>




<attribute




name


=


"Id"




type


=


"ID"




use


=


"optional"


/>




</complexType>

6.2.1 SHA-1

Identifier:

http://www.w3.org/2000/09/xmldsig#sha1

Note: Use of SHA-256 is strongly recommended over SHA-1 because recent advances in cryptanalysis (see e.g. [ SHA-1-Analysis ], [ SHA-1-Collisions ] ) have cast doubt on the long-term collision resistance of SHA-1.

The SHA-1 algorithm [ FIPS-186-3 ] takes no explicit parameters. An example of an SHA-1 DigestAlg element is:

<DigestMethod




Algorithm


=


"http://www.w3.org/2000/09/xmldsig#sha1"


/>

A SHA-1 digest is a 160-bit string. The content of the DigestValue element shall be the base64 encoding of this bit string viewed as a 20-octet octet stream. For example, the DigestValue element for the message digest:

A9993E36


4706816A


BA3E2571


7850C26C




9CD0D89D

from Appendix A of the SHA-1 standard would be:

<DigestValue>


qZk+NkcGgWq6PiVxeFDCbJzQ2J0=


</DigestValue>

6.2.2 SHA-224

Identifier:

http://www.w3.org/2001/04/xmldsig-more#sha224

The SHA-224 algorithm [ FIPS-180-3 ] takes no explicit parameters. A SHA-224 digest is a 224-bit string. The content of the DigestValue element shall be the base64 encoding of this bit string viewed as a 28-octet octet stream.

6.2.3 SHA-256

Identifier:

http://www.w3.org/2001/04/xmlenc#sha256

The SHA-256 algorithm [ FIPS-180-3 ] takes no explicit parameters. A SHA-256 digest is a 256-bit string. The content of the DigestValue element shall be the base64 encoding of this bit string viewed as a 32-octet octet stream.

6.2.4 SHA-384

Identifier:

http://www.w3.org/2001/04/xmldsig-more#sha384

The SHA-384 algorithm [ FIPS-180-3 ] takes no explicit parameters. A SHA-384 digest is a 384-bit string. The content of the DigestValue element shall be the base64 encoding of this bit string viewed as a 48-octet octet stream.

6.2.5 SHA-512

Identifier:

http://www.w3.org/2001/04/xmlenc#sha512

The SHA-512 algorithm [ FIPS-180-3 ] takes no explicit parameters. A SHA-512 digest is a 512-bit string. The content of the DigestValue element shall be the base64 encoding of this bit string viewed as a 64-octet octet stream.

6.3.1 HMAC

Identifier:

http://www.w3.org/2000/09/xmldsig#hmac-sha1

http://www.w3.org/2001/04/xmldsig-more#hmac-sha224

http://www.w3.org/2001/04/xmldsig-more#hmac-sha256

http://www.w3.org/2001/04/xmldsig-more#hmac-sha384

http://www.w3.org/2001/04/xmldsig-more#hmac-sha512

The HMAC algorithm (RFC2104 [ HMAC ]) takes the output (truncation) length in bits as a parameter; this specification REQUIRES that the truncation length be a multiple of 8 (i.e. fall on a byte boundary) because Base64 encoding operates on full bytes.  If the truncation parameter is not specified then all the bits of the hash are output. Any signature with a truncation length that is less than half the output length of the underlying hash algorithm must MUST be deemed invalid. An example of an HMAC SignatureMethod element:

<SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#hmac-sha1">
  <HMACOutputLength>128</HMACOutputLength>


</SignatureMethod>

The output of the HMAC algorithm is ultimately the output (possibly truncated) of the chosen digest algorithm. This value shall be base64 encoded in the same straightforward fashion as the output of the digest algorithms. Example: the SignatureValue element for the HMAC-SHA1 digest

9294727A




3638BB1C




13F48EF8




158BFC9D

from the test vectors in [ HMAC ] would be

<SignatureValue>


kpRyejY4uxwT9I74FYv8nQ==


</SignatureValue>

Schema




Definition

:

<simpleType




name


=


"HMACOutputLengthType"


>




<restriction




base


=


"integer"




/>




</simpleType>

6.4.1 DSA

Identifier:

http://www.w3.org/2000/09/xmldsig#dsa-sha1

http://www.w3.org/2009/xmldsig11#dsa-sha256

The DSA family of algorithms is defined in FIPS 186-3 [ FIPS-186-3 ].  FIPS 186-3 defines DSA in terms of two security parameters L and N where L = |p|, N = |q|, p is the prime modulus, q is a prime divisor of (p-1).  FIPS 186-3 defines four valid pairs of (L, N); they are: (1024, 160), (2048, 224), (2048, 256) and (3072, 256).  The pair (1024, 160) corresponds to the algorithm DSAwithSHA1, which is identified in this specification by the URI http://www.w3.org/2000/09/xmldsig#dsa-sha1 .  The pairs (2048, 256) and (3072, 256) correspond to the algorithm DSAwithSHA256, which is identified in this specification by the URI http://www.w3.org/2009/xmldsig11#dsa-sha256 .  This specification does not use the (2048, 224) instance of DSA (which corresponds to DSAwithSHA224).

 DSA takes no explicit parameters; an example of a DSA SignatureMethod element is:

<SignatureMethod




Algorithm


=


"http://www.w3.org/2009/xmldsig11#dsa-sha256"


/>

The output of the DSA algorithm consists of a pair of integers usually referred by the pair (r, s). The signature value consists of the base64 encoding of the concatenation of two octet-streams that respectively result from the octet-encoding of the values r and s in that order. Integer to octet-stream conversion must be done according to the I2OSP operation defined in the RFC 3447 [ PKCS1 ] specification with a l parameter equal to 20. For example, the SignatureValue element for a DSA signature ( r , s ) with values specified in hexadecimal:

r = 8BAC1AB6 6410435C B7181F95 B16AB97C 92B341C0



s


=




41E2345F




1F56DF24




58F426D1




55B4BA2D


B6DCD8C8

from the example in Appendix 5 of the DSS standard would be

<SignatureValue>



i6watmQQQ1y3GB+VsWq5fJKzQcBB4jRfH1bfJFj0JtFVtLotttzYyA==


</SignatureValue>

Security considerations regarding DSA key sizes

Per FIPS 186-3 [ FIPS-186-3 ], the DSA security parameter L is defined to be 1024, 2048 or 3072 bits and the corresponding DSA q value is defined to be 160, 224/256 and 256 bits respectively.

NIST provides guidance on the use of keys of various strength for various time frames in special Publication SP 800-57 Part 1 [ SP800-57 ]. Implementers should consult this publication for guidance on acceptable key lengths for applications, however 2048-bit public keys are the minimum recommended key length and 3072-bit keys are recommended for securing information beyond 2030. SP800-57 Part 1 states that DSA 1024-bit key sizes should not be used except to verify and honor signatures created using older legacy systems.

Since XML Signature 1.0 requires implementations to support DSA-based digital signatures, this XML Signature 1.1 revision allows verifiers to verify DSA signatures for DSA keys of 1024 bits in order to validate existing signatures. XML Signature 1.1 implementations may MAY but are not required NOT REQUIRED to support DSA-based signature generation. Given the short key size and SP800-57 guidelines, DSA with 1024-bit prime moduli should not SHOULD NOT be used to create signatures. DSA with 1024-bit prime moduli may MAY be used to verify older legacy signatures, with an understanding of the associated risks. Important older signatures should SHOULD be re-signed with stronger signatures.

6.4.2 RSA (PKCS#1 v1.5)

Identifier:

http://www.w3.org/2000/09/xmldsig#rsa-sha1

http://www.w3.org/2001/04/xmldsig-more#rsa-sha224

http://www.w3.org/2001/04/xmldsig-more#rsa-sha256

http://www.w3.org/2001/04/xmldsig-more#rsa-sha384

http://www.w3.org/2001/04/xmldsig-more#rsa-sha512

The expression "RSA algorithm" as used in this specification refers to the RSASSA-PKCS1-v1_5 algorithm described in RFC 3447 [ PKCS1 ]. The RSA algorithm takes no explicit parameters. An example of an RSA SignatureMethod element is:

<SignatureMethod




Algorithm


=


"http://www.w3.org/2000/09/xmldsig#rsa-sha1"


/>

The SignatureValue content for an RSA signature is the base64 [ RFC2045 ] encoding of the octet string computed as per RFC 3447 [ PKCS1 ], section 8.2.1: Signature generation for the RSASSA-PKCS1-v1_5 signature scheme]. Computation of the signature will require concatenation of the hash value and a constant string determined by RFC 3447. Signature computation and verification does not require implementation of an ASN.1 parser.

The resulting base64 [ RFC2045 ] string is the value of the child text node of the SignatureValue element, e.g.

<SignatureValue>
  IWijxQjUrcXBYoCei4QxjWo9Kg8D3p9tlWoT4t0/gyTE96639In0FZFY2/rvP+/bMJ01EArmKZs
R5VW3rwoPxw=


</SignatureValue>

Note - A line break has been added to preserve printed page width.

Security considerations regarding RSA key sizes

NIST provides guidance on the use of keys of various strength for various time frames in special Publication SP 800-57 Part 1 [ SP800-57 ]. Implementers should consult this publication for guidance on acceptable key lengths for applications, however 2048-bit public keys are the minimum recommended key length and 3072-bit keys are recommended for securing information beyond 2030.

All conforming implementations of XML Signature 1.1 must MUST support RSA signature generation and verification with public keys at least 2048 bits in length. RSA public keys of 1024 bits or less should not SHOULD NOT be used to create new signatures but may MAY be used to verify signatures created by older legacy systems. XML Signature 1.1 implementations must MUST use at least 2048-bit keys for creating signatures, and should SHOULD use at least 3072-bit keys for signatures that will be verified beyond 2030.

6.4.3 ECDSA

Identifiers:

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

The ECDSA algorithm [ FIPS-186-3 ] takes no explicit parameters. An example of a ECDSA SignatureMethod element is:

<SignatureMethod




Algorithm


=


"http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256"




/>

The output of the ECDSA algorithm consists of a pair of integers usually referred by the pair (r, s). The signature value consists of the base64 encoding of the concatenation of two octet-streams that respectively result from the octet-encoding of the values r and s in that order. Integer to octet-stream conversion must be done according to the I2OSP operation defined in the RFC 3447 [ PKCS1 ] specification with the l parameter equal to the size of the base point order of the curve in bytes (e.g. 32 for the P-256 curve and 66 for the P-521 curve).

This specification REQUIRES implementations to implement an algorithm that leads to the same results as ECDSA over the P-256 prime curve specified in Section D.2.3 of FIPS 186-3 [ FIPS-186-3 ] (and using the SHA-256 hash algorithm), referred to as the ECDSAwithSHA256 signature algorithm [ ECC-ALGS ]. It is further recommended RECOMMENDED that implementations also implement algorithms that lead to the same results as ECDSA over the P-384 and P-521 prime curves; these curves are defined in Sections D.2.4 and D.2.5 of FIPS 186-3, respectively [ ECC-ALGS ].

6.5.1 Canonical XML 1.0

Identifier for required REQUIRED Canonical XML 1.0 (omits comments):

http://www.w3.org/TR/2001/REC-xml-c14n-20010315

Identifier for Canonical XML 1.0 with Comments:

http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments

Input:

octet-stream, node-set

Output:

octet-stream

An example of an XML canonicalization element is:

<CanonicalizationMethod




Algorithm


=


"



http://www.w3.org/TR/2001/REC-xml-c14n-20010315



"


/>

The normative specification of Canonical XML1.0 is [ XML-C14N ]. The algorithm is capable of taking as input either an octet stream or an XPath node-set (or sufficiently functional alternative). The algorithm produces an octet stream as output. Canonical XML is easily parameterized (via an additional URI) to omit or retain comments.

6.5.2 Canonical XML 1.1

Identifier for required REQUIRED Canonical XML 1.1 (omits comments):

http://www.w3.org/2006/12/xml-c14n11

Identifier for Canonical XML 1.1 with Comments:

http://www.w3.org/2006/12/xml-c14n11#WithComments

Input:

octet-stream, node-set

Output:

octet-stream

The normative specification of Canonical XML 1.1 is [ XML-C14N11 ]. The algorithm is capable of taking as input either an octet stream or an XPath node-set (or sufficiently functional alternative). The algorithm produces an octet stream as output. Canonical XML 1.1 is easily parameterized (via an additional URI) to omit or retain comments.

6.5.3 Exclusive XML Canonicalization 1.0

Identifier for required REQUIRED Exclusive XML Canonicalization 1.0 (omits comments):

http://www.w3.org/2001/10/xml-exc-c14n#

Identifier for Exclusive XML Canonicalization 1.0 with Comments:

http://www.w3.org/2001/10/xml-exc-c14n#WithComments

Input:

octet-stream, node-set

Output:

octet-stream

The normative specification of Exclusive XML Canonicalization 1.0 is [XML-EXC-C14N]].

6.6.1 Canonicalization

Any canonicalization algorithm that can be used for CanonicalizationMethod (such as those in  Canonicalization Algorithms (section 6.5)) can be used as a Transform .

6.6.2 Base64

Identifiers:

http://www.w3.org/2000/09/xmldsig#base64

Input:

octet-stream, node-set

Output:

octet-stream

The normative specification for base64 decoding transforms is [ RFC2045 ]. The base64 Transform element has no content. The input is decoded by the algorithms. This transform is useful if an application needs to sign the raw data associated with the encoded content of an element.

This transform accepts either an octet-stream or a node-set as input. If an octet-string is given as input, then this octet-stream is processed directly. If an XPath node-set (or sufficiently functional alternative) is given as input, then it is converted to an octet stream by performing operations logically equivalent to 1) applying an XPath transform with expression self::text() , then 2) sorting the nodeset by document order, then concatenating the string-value of each of the nodes into one long string. Thus, if an XML element is identified by a shortname XPointer in the Reference URI, and its content consists solely of base64 encoded character data, then this transform automatically strips away the start and end tags of the identified element and any of its descendant elements as well as any descendant comments and processing instructions. The output of this transform is an octet stream.

6.6.3 XPath Filtering

Identifier:

http://www.w3.org/TR/1999/REC-xpath-19991116

Input:

octet-stream, node-set

Output:

node-set

The normative specification for XPath expression evaluation is [ XPATH ]. The XPath expression to be evaluated appears as the character content of a transform parameter child element named XPath .

The input required by this transform is an XPath node-set or an octet-stream. Note that if the actual input is an XPath node-set resulting from a null URI or shortname XPointer dereference, then comment nodes will have been omitted. If the actual input is an octet stream, then the application must MUST convert the octet stream to an XPath node-set suitable for use by Canonical XML with Comments. (A subsequent application of the required REQUIRED Canonical XML algorithm would strip away these comments.) In other words, the input node-set should be equivalent to the one that would be created by the following process:

1. Initialize an XPath evaluation context by setting the initial node equal to the input XML document's root node, and set the context position and size to 1.
2. Evaluate the XPath expression (//. | //@* | //namespace::*)

The evaluation of this expression includes all of the document's nodes (including comments) in the node-set representing the octet stream.

The transform output is always an XPath node-set. The XPath expression appearing in the XPath parameter is evaluated once for each node in the input node-set. The result is converted to a boolean. If the boolean is true, then the node is included in the output node-set. If the boolean is false, then the node is omitted from the output node-set.

Note: Even if the input node-set has had comments removed, the comment nodes still exist in the underlying parse tree and can separate text nodes. For example, the markup <e>Hello, <!-- comment -->world!</e> contains two text nodes. Therefore, the expression self::text()[string()="Hello, world!"] would fail. Should this problem arise in the application, it can be solved by either canonicalizing the document before the XPath transform to physically remove the comments or by matching the node based on the parent element's string value (e.g. by using the expression self::text()[string(parent::e)="Hello, world!"] ).

The primary purpose of this transform is to ensure that only specifically defined changes to the input XML document are permitted after the signature is affixed. This is done by omitting precisely those nodes that are allowed to change once the signature is affixed, and including all other input nodes in the output. It is the responsibility of the XPath expression author to include all nodes whose change could affect the interpretation of the transform output in the application context.

Note that the XML-Signature XPath Filter 2.0 Recommendation [ XMLDSIG-XPATH-FILTER2 ] may be used for this purpose. That recommendation defines an XPath transform that permits the easy specification of subtree selection and omission that can be efficiently implemented.

An important scenario would be a document requiring two enveloped signatures. Each signature must omit itself from its own digest calculations, but it is also necessary to exclude the second signature element from the digest calculations of the first signature so that adding the second signature does not break the first signature.

The XPath transform establishes the following evaluation context for each node of the input node-set:

• A context node equal to a node of the input node-set.
• A context position , initialized to 1.
• A context size , initialized to 1.
• A library of functions equal to the function set defined in [ XPATH ] augmented with a function named here to be treated as if part of the library (and not namespace prefixed).
• A set of variable bindings. No means for initializing these is defined. Thus, the set of variable bindings used when evaluating the XPath expression is empty, and use of a variable reference in the XPath expression results in an error.
• The set of namespace declarations in scope for the XPath expression.

As a result of the context node setting, the XPath expressions appearing in this transform will be quite similar to those used in used in [ XSLT ], except that the size and position are always 1 to reflect the fact that the transform is automatically visiting every node (in XSLT, one recursively calls the command apply-templates to visit the nodes of the input tree).

The function here() is defined as follows:

Function: node-set here ()

The here function returns a node-set containing the attribute or processing instruction node or the parent element of the text node that directly bears the XPath expression.  This expression results in an error if the containing XPath expression does not appear in the same XML document against which the XPath expression is being evaluated.

As an example, consider creating an enveloped signature (a Signature element that is a descendant of an element being signed). Although the signed content should not be changed after signing, the elements within the Signature element are changing (e.g. the digest value must be put inside the DigestValue and the SignatureValue must be subsequently calculated). One way to prevent these changes from invalidating the digest value in DigestValue is to add an XPath Transform that omits all Signature elements and their descendants. For example,

<Document>
  ...   
  <Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
    <SignedInfo>
      ...
      <Reference URI="">
        <Transforms>
          <Transform Algorithm="http://www.w3.org/TR/1999/REC-xpath-19991116">
            <XPath xmlns:dsig="&dsig;">
              not(ancestor-or-self::dsig:Signature)
            </XPath>
          </Transform>
        </Transforms>
        <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
        <DigestValue></DigestValue>
      </Reference>
    </SignedInfo>
    <SignatureValue></SignatureValue>
  </Signature>
  ...


</Document>

Due to the null Reference URI in this example, the XPath transform input node-set contains all nodes in the entire parse tree starting at the root node (except the comment nodes). For each node in this node-set, the node is included in the output node-set except if the node or one of its ancestors has a tag of Signature that is in the namespace given by the replacement text for the entity &dsig; .

A more elegant solution uses the here function to omit only the Signature containing the XPath Transform, thus allowing enveloped signatures to sign other signatures. In the example above, use the XPath element:

<XPath xmlns:dsig="&dsig;">
count(ancestor-or-self::dsig:Signature |
here()/ancestor::dsig:Signature[1]) >
count(ancestor-or-self::dsig:Signature)


</XPath>

Since the XPath equality operator converts node sets to string values before comparison, we must instead use the XPath union operator (|). For each node of the document, the predicate expression is true if and only if the node-set containing the node and its Signature element ancestors does not include the enveloped Signature element containing the XPath expression (the union does not produce a larger set if the enveloped Signature element is in the node-set given by ancestor-or-self::Signature ).

6.6.4 Enveloped Signature Transform

Identifier:

http://www.w3.org/2000/09/xmldsig#enveloped-signature

Input:

node-set

Output:

node-set

An enveloped signature transform T removes the whole Signature element containing T from the digest calculation of the Reference element containing T . The entire string of characters used by an XML processor to match the Signature with the XML production element is removed. The output of the transform is equivalent to the output that would result from replacing T with an XPath transform containing the following XPath parameter element:

<XPath xmlns:dsig="&dsig;">
count(ancestor-or-self::dsig:Signature |
here()/ancestor::dsig:Signature[1]) >
count(ancestor-or-self::dsig:Signature)


</XPath>

The input and output requirements of this transform are identical to those of the XPath transform, but may only be applied to a node-set from its parent XML document. Note that it is not necessary to use an XPath expression evaluator to create this transform. However, this transform must MUST produce output in exactly the same manner as the XPath transform parameterized by the XPath expression above.

6.6.5 XSLT Transform

Identifier:

http://www.w3.org/TR/1999/REC-xslt-19991116

Input:

octet-stream

Output:

octet-stream

The normative specification for XSL Transformations is [ XSLT ]. Specification of a namespace-qualified stylesheet element, which must MUST be the sole child of the Transform element, indicates that the specified style sheet should be used. Whether this instantiates in-line processing of local XSLT declarations within the resource is determined by the XSLT processing model; the ordered application of multiple stylesheet may require multiple Transforms . No special provision is made for the identification of a remote stylesheet at a given URI because it can be communicated via an xsl:include or xsl:import within the stylesheet child of the Transform .

This transform requires an octet stream as input.

The output of this transform is an octet stream. The processing rules for the XSL style sheet [ XSL10 ] or transform element are stated in the XSLT specification [ XSLT ].

We RECOMMEND that XSLT transform authors use an output method of xml for XML and HTML. As XSLT implementations do not produce consistent serializations of their output, we further RECOMMEND inserting a transform after the XSLT transform to canonicalize the output. These steps will help to ensure interoperability of the resulting signatures among applications that support the XSLT transform. Note that if the output is actually HTML, then the result of these steps is logically equivalent [ XHTML10 ].

8.1.1 Only What is Signed is Secure

First, obviously, signatures over a transformed document do not secure any information discarded by transforms: only what is signed is secure.

Note that the use of Canonical  XML [ XML-C14N ] ensures that all internal entities and XML namespaces are expanded within the content being signed. All entities are replaced with their definitions and the canonical form explicitly represents the namespace that an element would otherwise inherit. Applications that do not canonicalize XML content (especially the SignedInfo element) should not SHOULD NOT use internal entities and should SHOULD represent the namespace explicitly within the content being signed since they can not rely upon canonicalization to do this for them. Also, users concerned with the integrity of the element type definitions associated with the XML instance being signed may wish to sign those definitions as well (i.e., the schema, DTD, or natural language description associated with the namespace/identifier).

Second, an envelope containing signed information is not secured by the signature. For instance, when an encrypted envelope contains a signature, the signature does not protect the authenticity or integrity of unsigned envelope headers nor its ciphertext form, it only secures the plaintext actually signed.

8.1.2 Only What is "Seen" Should be Signed

Additionally, the signature secures any information introduced by the transform: only what is "seen" (that which is represented to the user via visual, auditory or other media) should be signed. If signing is intended to convey the judgment or consent of a user (an automated mechanism or person), then it is normally necessary to secure as exactly as practical the information that was presented to that user. Note that this can be accomplished by literally signing what was presented, such as the screen images shown a user. However, this may result in data which is difficult for subsequent software to manipulate. Instead, one can sign the data along with whatever filters, style sheets, client profile or other information that affects its presentation.

8.1.3 "See" What is Signed

Just as a user should only sign what he or she "sees," persons and automated mechanism that trust the validity of a transformed document on the basis of a valid signature should operate over the data that was transformed (including canonicalization) and signed, not the original pre-transformed data. This recommendation applies to transforms specified within the signature as well as those included as part of the document itself. For instance, if an XML document includes an embedded style sheet [ XSLT ] it is the transformed document that should be represented to the user and signed. To meet this recommendation where a document references an external style sheet, the content of that external resource should also be signed as via a signature Reference otherwise the content of that external content might change which alters the resulting document without invalidating the signature.

Some applications might operate over the original or intermediary data but should be extremely careful about potential weaknesses introduced between the original and transformed data. This is a trust decision about the character and meaning of the transforms that an application needs to make with caution. Consider a canonicalization algorithm that normalizes character case (lower to upper) or character composition ('e and accent' to 'accented-e'). An adversary could introduce changes that are normalized and consequently inconsequential to signature validity but material to a DOM processor. For instance, by changing the case of a character one might influence the result of an XPath selection. A serious risk is introduced if that change is normalized for signature validation but the processor operates over the original data and returns a different result than intended.

As a result:

• All documents operated upon and generated by signature applications must MUST be in [ NFC ] (otherwise intermediate processors might unintentionally break the signature)
• Encoding normalizations should not SHOULD NOT be done as part of a signature transform, or (to state it another way) if normalization does occur, the application should SHOULD always "see" (operate over) the normalized form.