Network Working Group D. Eastlake Request for Comments: 3075 Motorola Category: Standards Track J. Reagle W3C/MIT D. Solo Citigroup March 2001 XML-Signature Syntax and Processing Status of this Memo This document specifies an Internet standards track protocol for the Internet community, and requests discussion and suggestions for improvements. Please refer to the current edition of the "Internet Official Protocol Standards" (STD 1) for the standardization state and status of this protocol. Distribution of this memo is unlimited. Copyright Notice Copyright (c) 2001 The Internet Society & W3C (MIT, INRIA, Keio), All Rights Reserved. Abstract This document specifies XML (Extensible Markup Language) digital signature processing rules and syntax. 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. Table of Contents 1. Introduction ................................................ 3 1. Editorial Conventions .................................. 3 2. Design Philosophy ...................................... 4 3. Versions, Namespaces and Identifiers ................... 4 4. Acknowledgements ....................................... 5 2. Signature Overview and Examples ............................. 6 1. Simple Example (Signature, SignedInfo, Methods, and References) ............................................ 7 1. More on Reference ................................. 9 2. Extended Example (Object and SignatureProperty) ........ 10 3. Extended Example (Object and Manifest) ................. 11 3. Processing Rules ............................................ 13 1. Core Generation .... ................................... 13 1. Reference Generation .............................. 13 2. Signature Generation .............................. 13 Eastlake, et al. Standards Track [Page 1] RFC 3075 XML-Signature Syntax and Processing March 2001 2. Core Validation ........................................ 13 1. Reference Validation .............................. 14 2. Signature Validation .............................. 14 4. Core Signature Syntax ....................................... 14 1. The Signature element .................................. 15 2. The SignatureValue Element ............................. 16 3. The SignedInfo Element ................................. 16 1. The CanonicalizationMethod Element ................ 17 2. The SignatureMethod Element ....................... 18 3. The Reference Element ............................. 19 1. The URI Attribute ............................ 19 2. The Reference Processing Model ............... 21 3. Same-Document URI-References ................. 23 4. The Transforms Element ....................... 24 5. The DigestMethod Element ..................... 25 6. The DigestValue Element ...................... 26 4. The KeyInfo Element .................................... 26 1. The KeyName Element ............................... 27 2. The KeyValue Element .............................. 28 3. The RetrievalMethod Element ....................... 28 4. The X509Data Element .............................. 29 5. The PGPData Element ............................... 31 6. The SPKIData Element .............................. 32 7. The MgmtData Element .............................. 32 5. The Object Element ..................................... 33 5. Additional Signature Syntax ................................. 34 1. The Manifest Element ................................... 34 2. The SignatureProperties Element ........................ 35 3. Processing Instructions ................................ 36 4. Comments in dsig Elements .............................. 36 6. Algorithms .................................................. 36 1. Algorithm Identifiers and Implementation Requirements .. 36 2. Message Digests ........................................ 38 1. SHA-1 ............................................. 38 3. Message Authentication Codes ........................... 38 1. HMAC .............................................. 38 4. Signature Algorithms ................................... 39 1. DSA ............................................... 39 2. PKCS1 ............................................. 40 5. Canonicalization Algorithms ............................ 42 1. Minimal Canonicalization .......................... 43 2. Canonical XML ..................................... 43 6. Transform Algorithms ................................... 44 1. Canonicalization .................................. 44 2. Base64 ............................................ 44 3. XPath Filtering ................................... 45 4. Enveloped Signature Transform ..................... 48 5. XSLT Transform .................................... 48 Eastlake, et al. Standards Track [Page 2] RFC 3075 XML-Signature Syntax and Processing March 2001 7. XML Canonicalization and Syntax Constraint Considerations ... 49 1. XML 1.0, Syntax Constraints, and Canonicalization ..... 50 2. DOM/SAX Processing and Canonicalization ................ 51 8. Security Considerations ..................................... 52 1. Transforms ............................................. 52 1. Only What is Signed is Secure ..................... 52 2. Only What is "Seen" Should be Signed .............. 53 3. "See" What is Signed .............................. 53 2. Check the Security Model ............................... 54 3. Algorithms, Key Lengths, Etc. .......................... 54 9. Schema, DTD, Data Model,and Valid Examples .................. 55 10. Definitions ................................................. 56 11. References .................................................. 58 12. Authors' Addresses .......................................... 63 13. Full Copyright Statement .................................... 64 1.0 Introduction This document specifies XML syntax and processing rules for creating and representing digital signatures. XML Signatures can be applied to any digital content (data object), including XML. An XML Signature may be applied to the content of one or more resources. Enveloped or enveloping signatures are over data within the same XML document as the signature; detached signatures are over data external to the signature element. More specifically, this specification defines an XML signature element type and an XML signature application; conformance requirements for each are specified by way of schema definitions and prose respectively. This specification also includes other useful types that identify methods for referencing collections of resources, algorithms, and keying and management information. The XML Signature is a method of associating a key with referenced data (octets); it does not normatively specify how keys are associated with persons or institutions, nor the meaning of the data being referenced and signed. Consequently, while this specification is an important component of secure XML applications, it itself is not sufficient to address all application security/trust concerns, particularly with respect to using signed XML (or other data formats) as a basis of human-to-human communication and agreement. Such an application must specify additional key, algorithm, processing and rendering requirements. For further information, please see Security Considerations (section 8). 1.1 Editorial and Conformance Conventions For readability, brevity, and historic reasons this document uses the term "signature" to generally refer to digital authentication values of all types.Obviously, the term is also strictly used to refer to Eastlake, et al. Standards Track [Page 3] RFC 3075 XML-Signature Syntax and Processing March 2001 authentication values that are based on public keys and that provide signer authentication. When specifically discussing authentication values based on symmetric secret key codes we use the terms authenticators or authentication codes. (See Check the Security Model, section 8.3.) This specification uses both XML Schemas [XML-schema] and DTDs [XML]. (Readers unfamiliar with DTD syntax may wish to refer to Ron Bourret's "Declaring Elements and Attributes in an XML DTD" [Bourret].) The schema definition is presently normative. The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this specification are to be interpreted as described in RFC2119 [KEYWORDS]: "they MUST only be used where it is actually required for interoperation or to limit behavior which has potential for causing harm (e.g., limiting retransmissions)" Consequently, we use these capitalized keywords to unambiguously specify requirements over protocol and application features and behavior that affect the interoperability and security of implementations. These key words are not used (capitalized) to describe XML grammar; schema definitions unambiguously describe such requirements and we wish to reserve the prominence of these terms for the natural language descriptions of protocols and features. For instance, an XML attribute might be described as being "optional." Compliance with the XML-namespace specification [XML-ns] is described as "REQUIRED." 1.2 Design Philosophy The design philosophy and requirements of this specification are addressed in the XML-Signature Requirements document [XML-Signature- RD]. 1.3 Versions, Namespaces and Identifiers No provision is made for an explicit version number in this syntax. If a future version is needed, it will use a different namespace The XML namespace [XML-ns] URI that MUST be used by implementations of this (dated) specification is: xmlns="http://www.w3.org/2000/09/xmldsig#" Eastlake, et al. Standards Track [Page 4] RFC 3075 XML-Signature Syntax and Processing March 2001 This namespace is also used as the prefix for algorithm identifiers used by this specification. While applications MUST support XML and XML-namespaces, the use of internal entities [XML] or our "dsig" XML namespace prefix and defaulting/scoping conventions are OPTIONAL; we use these facilities to provide compact and readable examples. This specification uses Uniform Resource Identifiers [URI] to identify resources, algorithms, and semantics. The URI in the namespace declaration above is also used as a prefix for URIs under the control of this specification. For resources not under the control of this specification, we use the designated Uniform Resource Names [URN] or Uniform Resource Locators [URL] defined by its normative external specification. If an external specification has not allocated itself a Uniform Resource Identifier we allocate an identifier under our own namespace. For instance: SignatureProperties is identified and defined by this specification's namespace http://www.w3.org/2000/09/xmldsig#SignatureProperties XSLT is identified and defined by an external URI http://www.w3.org/TR/1999/PR-xslt-19991008 SHA1 is identified via this specification's namespace and defined via a normative reference http://www.w3.org/2000/09/xmldsig#sha1 FIPS PUB 180-1. Secure Hash Standard. U.S. Department of Commerce/National Institute of Standards and Technology. Finally, in order to provide for terse namespace declarations we sometimes use XML internal entities [XML] within URIs. For instance: ]> ... 1.4 Acknowledgements The contributions of the following working group members to this specification are gratefully acknowledged: * Mark Bartel, JetForm Corporation (Author) * John Boyer, PureEdge (Author) * Mariano P. Consens, University of Waterloo Eastlake, et al. Standards Track [Page 5] RFC 3075 XML-Signature Syntax and Processing March 2001 * John Cowan, Reuters Health * Donald Eastlake 3rd, Motorola (Chair, Author/Editor) * Barb Fox, Microsoft (Author) * Christian Geuer-Pollmann, University Siegen * Tom Gindin, IBM * Phillip Hallam-Baker, VeriSign Inc * Richard Himes, US Courts * Merlin Hughes, Baltimore * Gregor Karlinger, IAIK TU Graz * Brian LaMacchia, Microsoft * Peter Lipp, IAIK TU Graz * Joseph Reagle, W3C (Chair, Author/Editor) * Ed Simon, Entrust Technologies Inc. (Author) * David Solo, Citigroup (Author/Editor) * Petteri Stenius, DONE Information, Ltd * Raghavan Srinivas, Sun * Kent Tamura, IBM * Winchel Todd Vincent III, GSU * Carl Wallace, Corsec Security, Inc. * Greg Whitehead, Signio Inc. As are the last call comments from the following: * Dan Connolly, W3C * Paul Biron, Kaiser Permanente, on behalf of the XML Schema WG. * Martin J. Duerst, W3C; and Masahiro Sekiguchi, Fujitsu; on behalf of the Internationalization WG/IG. * Jonathan Marsh, Microsoft, on behalf of the Extensible Stylesheet Language WG. 2.0 Signature Overview and Examples This section provides an overview and examples of XML digital signature syntax. The specific processing is given in Processing Rules (section 3). The formal syntax is found in Core Signature Syntax (section 4) and Additional Signature Syntax (section 5). In this section, an informal representation and examples are used to describe the structure of the XML signature syntax. This representation and examples may omit attributes, details and potential features that are fully explained later. XML Signatures are applied to arbitrary digital content (data objects) via an indirection. Data objects are digested, the resulting value is placed in an element (with other information) and that element is then digested and cryptographically signed. XML digital signatures are represented by the Signature element which has Eastlake, et al. Standards Track [Page 6] RFC 3075 XML-Signature Syntax and Processing March 2001 the following structure (where "?" denotes zero or one occurrence; "+" denotes one or more occurrences; and "*" denotes zero or more occurrences): (CanonicalizationMethod) (SignatureMethod) ( (Transforms)? (DigestMethod) (DigestValue) )+ (SignatureValue) (KeyInfo)? (Object)* Signatures are related to data objects via URIs [URI]. Within an XML document, signatures are related to local data objects via fragment identifiers. Such local data can be included within an enveloping signature or can enclose an enveloped signature. Detached signatures are over external network resources or local data objects that resides within the same XML document as sibling elements; in this case, the signature is neither enveloping (signature is parent) nor enveloped (signature is child). Since a Signature element (and its Id attribute value/name) may co-exist or be combined with other elements (and their IDs) within a single XML document, care should be taken in choosing names such that there are no subsequent collisions that violate the ID uniqueness validity constraint [XML]. 2.1 Simple Example (Signature, SignedInfo, Methods, and References) The following example is a detached signature of the content of the HTML4 in XML specification. [s01] [s02] [s03] [s04] [s05] [s06] [s07] Eastlake, et al. Standards Track [Page 7] RFC 3075 XML-Signature Syntax and Processing March 2001 [s08] [s09] [s10] j6lwx3rvEPO0vKtMup4NbeVu8nk= [s11] [s12] [s13] MC0CFFrVLtRlk=... [s14] [s15a] [s15b] [s15c]

...

......... [s15d] [s15e] [s16] [s17] [s02-12] The required SignedInfo element is the information that is actually signed. Core validation of SignedInfo consists of two mandatory processes: validation of the signature over SignedInfo and validation of each Reference digest within SignedInfo. Note that the algorithms used in calculating the SignatureValue are also included in the signed information while the SignatureValue element is outside SignedInfo. [s03] The CanonicalizationMethod is the algorithm that is used to canonicalize the SignedInfo element before it is digested as part of the signature operation. [s04] The SignatureMethod is the algorithm that is used to convert the canonicalized SignedInfo into the SignatureValue. It is a combination of a digest algorithm and a key dependent algorithm and possibly other algorithms such as padding, for example RSA-SHA1. The algorithm names are signed to resist attacks based on substituting a weaker algorithm. To promote application interoperability we specify a set of signature algorithms that MUST be implemented, though their use is at the discretion of the signature creator. We specify additional algorithms as RECOMMENDED or OPTIONAL for implementation and the signature design permits arbitrary user algorithm specification. [s05-11] Each Reference element includes the digest method and resulting digest value calculated over the identified data object. It also may include transformations that produced the input to the digest operation. A data object is signed by computing its digest value and a signature over that value. The signature is later checked via reference and signature validation. Eastlake, et al. Standards Track [Page 8] RFC 3075 XML-Signature Syntax and Processing March 2001 [s14-16] KeyInfo indicates the key to be used to validate the signature. Possible forms for identification include certificates, key names, and key agreement algorithms and information -- we define only a few. KeyInfo is optional for two reasons. First, the signer may not wish to reveal key information to all document processing parties. Second, the information may be known within the application's context and need not be represented explicitly. Since KeyInfo is outside of SignedInfo, if the signer wishes to bind the keying information to the signature, a Reference can easily identify and include the KeyInfo as part of the signature. 2.1.1 More on Reference [s05] [s06] [s07] [s08] [s09] [s10] j6lwx3rvEPO0vKtMup4NbeVu8nk= [s11] [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 and XPath. 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 we specify mandatory (and Eastlake, et al. Standards Track [Page 9] RFC 3075 XML-Signature Syntax and Processing March 2001 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 a resources content to the signer's key. 2.2 Extended Example (Object and SignatureProperty) This specification does not address mechanisms for making statements or assertions. Instead, this document defines what it means for something to be signed by an XML Signature (message authentication, integrity, and/or signer authentication). Applications that wish to represent other semantics must rely upon other technologies, such as [XML, RDF]. For instance, an application might use a foo:assuredby attribute within its own markup to reference a Signature element. Consequently, it's the application that must understand and know how to make trust decisions given the validity of the signature and the meaning of assuredby syntax. We also define a SignatureProperties element type for the inclusion of assertions about the signature itself (e.g., signature semantics, the time of signing or the serial number of hardware used in cryptographic processes). Such assertions may be signed by including a Reference for the SignatureProperties in SignedInfo. While the signing application should be very careful about what it signs (it should understand what is in the SignatureProperty) a receiving application has no obligation to understand that semantic (though its parent trust engine may wish to). Any content about the signature generation may be located within the SignatureProperty element. The mandatory Target attribute references the Signature element to which the property applies. Consider the preceding example with an additional reference to a local Object that includes a SignatureProperty element. (Such a signature would not only be detached [p02] but enveloping [p03].) [ ] [p01] [ ] ... [p02] [ ] ... [p03] [p05] [p06] k3453rvEPO0vKtMup4NbeVu8nk= [p07] Eastlake, et al. Standards Track [Page 10] RFC 3075 XML-Signature Syntax and Processing March 2001 [p08] [p09] ... [p10] [p11] [p12] [p13] [p14] 19990908 [p15] [p16] [p17] [p18] [p19] [p20] [p04] The optional Type attribute of Reference provides information about the resource identified by the URI. In particular, it can indicate that it is an Object, SignatureProperty, or Manifest element. This can be used by applications to initiate special processing of some Reference elements. References to an XML data element within an Object element SHOULD identify the actual element pointed to. Where the element content is not XML (perhaps it is binary or encoded data) the reference should identify the Object and the Reference Type, if given, SHOULD indicate Object. Note that Type is advisory and no action based on it or checking of its correctness is required by core behavior. [p10] Object is an optional element for including data objects within the signature element or elsewhere. The Object can be optionally typed and/or encoded. [p11-18] Signature properties, such as time of signing, can be optionally signed by identifying them from within a Reference. (These properties are traditionally called signature "attributes" although that term has no relationship to the XML term "attribute".) 2.3 Extended Example (Object and Manifest) The Manifest element is provided to meet additional requirements not directly addressed by the mandatory parts of this specification. Two requirements and the way the Manifest satisfies them follows. First, applications frequently need to efficiently sign multiple data objects even where the signature operation itself is an expensive public key signature. This requirement can be met by including multiple Reference elements within SignedInfo since the inclusion of each digest secures the data digested. However, some applications may not want the core validation behavior associated with this Eastlake, et al. Standards Track [Page 11] RFC 3075 XML-Signature Syntax and Processing March 2001 approach because it requires every Reference within SignedInfo to undergo reference validation -- the DigestValue elements are checked. These applications may wish to reserve reference validation decision logic to themselves. For example, an application might receive a signature valid SignedInfo element that includes three Reference elements. If a single Reference fails (the identified data object when digested does not yield the specified DigestValue) the signature would fail core validation. However, the application may wish to treat the signature over the two valid Reference elements as valid or take different actions depending on which fails. To accomplish this, SignedInfo would reference a Manifest element that contains one or more Reference elements (with the same structure as those in SignedInfo). Then, reference validation of the Manifest is under application control. Second, consider an application where many signatures (using different keys) are applied to a large number of documents. An inefficient solution is to have a separate signature (per key) repeatedly applied to a large SignedInfo element (with many References); this is wasteful and redundant. A more efficient solution is to include many references in a single Manifest that is then referenced from multiple Signature elements. The example below includes a Reference that signs a Manifest found within the Object element. [ ] ... [m01] [m03] [m04] 345x3rvEPO0vKtMup4NbeVu8nk= [m05] [ ] ... [m06] [m07] [m08] [m09] ... [m10] [m11] [m12] ... [m13] [m14] [m15] Eastlake, et al. Standards Track [Page 12] RFC 3075 XML-Signature Syntax and Processing March 2001 3.0 Processing Rules The sections below describe the operations to be performed as part of signature generation and validation. 3.1 Core Generation The REQUIRED steps include the generation of Reference elements and the SignatureValue over SignedInfo. 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) (if desired, encoding may be different than that used for signing), KeyInfo (if required), and SignatureValue. 3.2 Core Validation The REQUIRED steps of core validation include (1) reference validation, the verification of the digest contained in each Reference in SignedInfo, and (2) the cryptographic signature validation of the signature calculated over SignedInfo. Note, there may be valid signatures that some signature applications are unable to validate. Reasons for this include failure to implement optional parts of this specification, inability or unwillingness to execute specified algorithms, or inability or unwillingness to dereference specified URIs (some URI schemes may cause undesirable side effects), etc. Eastlake, et al. Standards Track [Page 13] RFC 3075 XML-Signature Syntax and Processing March 2001 3.2.1 Reference Validation For each Reference in SignedInfo: 1. Canonicalize the SignedInfo element based on the CanonicalizationMethod in SignedInfo. 2. Obtain the data object to be digested. (The signature application may rely upon the identification (URI) and Transforms provided by the signer in the Reference element, or it may obtain the content through other means such as a local cache.) 3. Digest the resulting data object using the DigestMethod specified in its Reference specification. 4. 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 to ensure the application Sees What is Signed, which is the canonical form. For instance, if the CanonicalizationMethod rewrote the URIs (e.g., absolutizing relative URIs) the signature processing must be cognizant of this. 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 validate 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 be used. However, the required canonicalization [XML-C14N] of this specification does not change URIs. 4.0 Core Signature Syntax The general structure of an XML signature is described in Signature Overview (section 2). This section provides detailed syntax of the core signature features. Features described in this section are mandatory to implement unless otherwise indicated. The syntax is defined via DTDs and [XML-Schema] with the following XML preamble, declaration, internal entity, and simpleType: Eastlake, et al. Standards Track [Page 14] RFC 3075 XML-Signature Syntax and Processing March 2001 Schema Definition: ]> DTD: 4.1 The Signature element The Signature element is the root element of an XML Signature. Signature elements MUST be laxly schema valid [XML-schema] with respect to the following schema definition: Schema Definition: Eastlake, et al. Standards Track [Page 15] RFC 3075 XML-Signature Syntax and Processing March 2001 DTD: 4.2 The SignatureValue Element The SignatureValue element contains the actual value of the digital signature; it is always encoded using base64 [MIME]. While we specify a mandatory and optional to implement SignatureMethod algorithms, user specified algorithms are permitted. Schema Definition: DTD: 4.3 The SignedInfo Element The structure of SignedInfo includes the canonicalization algorithm, a signature algorithm, and one or more references. The SignedInfo element may contain an optional ID attribute that will allow it to be referenced by other signatures and objects. SignedInfo does not include explicit signature or digest properties (such as calculation time, cryptographic device serial number, etc.). If an application needs to associate properties with the signature or digest, it may include such information in a SignatureProperties element within an Object element. Schema Definition: Eastlake, et al. Standards Track [Page 16] RFC 3075 XML-Signature Syntax and Processing March 2001 DTD: 4.3.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 Algorithm Identifiers and Implementation Requirements (section 6.1). Implementations MUST support the REQUIRED Canonical XML [XML-C14N] method. Alternatives to the REQUIRED Canonical XML algorithm (section 6.5.2), such as Canonical XML with Comments (section 6.5.2) and Minimal Canonicalization (the CRLF and charset normalization specified in section 6.5.1), may be explicitly specified but are NOT REQUIRED. Consequently, their use may not interoperate with other applications that do no 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 minimal or other non-XML aware canonicalization algorithms are not properly constrained (see section 8.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 the two types of algorithms specified by this document: * Canonical XML [XML-C14N] (with or without comments) implementation 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 (such that the namespace context and similar ancestor information of the SignedInfo is preserved). * Minimal canonicalization implementations MUST be provided with the 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 Eastlake, et al. Standards Track [Page 17] RFC 3075 XML-Signature Syntax and Processing March 2001 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. We RECOMMEND that resource constrained applications that do not implement the Canonical XML [XML-C14N] algorithm and instead choose minimal canonicalization (or some other form) be implemented to generate Canonical XML as their output serialization so as to easily mitigate some of these interoperability and security concerns. (While a result might not be the canonical form of the original, it can still be in canonical form.) For instance, such an implementation SHOULD (at least) generate standalone XML instances [XML]. Schema Definition: DTD: 4.3.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: Eastlake, et al. Standards Track [Page 18] RFC 3075 XML-Signature Syntax and Processing March 2001 DTD: 4.3.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: DTD: 4.3.3.1 The URI Attribute The URI attribute identifies a data object using a URI-Reference, as specified by RFC2396 [URI]. The set of allowed characters for URI attributes is the same as for XML, namely [Unicode]. However, some Unicode characters are disallowed from URI references including all Eastlake, et al. Standards Track [Page 19] RFC 3075 XML-Signature Syntax and Processing March 2001 non-ASCII characters and the excluded characters listed in RFC2396 [URI, section 2.4]. However, the number sign (#), percent sign (%), and square bracket characters re-allowed in RFC 2732 [URI-Literal] are permitted. Disallowed characters must be escaped as follows: 1. Each disallowed character is converted to [UTF-8] as one or more bytes. 2. Any octets corresponding to a disallowed character are escaped with the URI escaping mechanism (that is, converted to %HH, where HH is the hexadecimal notation of the byte value). 3. The original character is replaced by the resulting character sequence. XML signature applications MUST be able to parse URI syntax. We RECOMMEND they be able to dereference URIs in the HTTP scheme. Dereferencing a URI in the HTTP scheme MUST comply with the Status Code Definitions of [HTTP] (e.g., 302, 305 and 307 redirects are followed to obtain the entity-body of a 200 status code response). Applications should also be cognizant of the fact that protocol parameter and state information, (such as a HTTP cookies, HTML device profiles or content negotiation), may affect the content yielded by dereferencing a URI. If a resource is identified by more than one URI, the most specific should be used (e.g. http://www.w3.org/2000/06/interop- pressrelease.html.en instead of http://www.w3.org/2000/06/interop- pressrelease). (See the Reference Validation (section 3.2.1) for a further information on reference processing.) If the URI attribute is omitted altogether, the receiving application is expected to know the identity of the object. For example, a lightweight data protocol might omit this attribute given the identity of the object is part of the application context. This attribute may be omitted from at most one Reference in any particular SignedInfo, or Manifest. The optional Type attribute contains information about the type of object being signed. This is represented as a URI. For example: Type="http://www.w3.org/2000/09/xmldsig#Object" Type="http://www.w3.org/2000/09/xmldsig#Manifest" The Type attribute applies to the item being pointed at, not its contents. For example, a reference that identifies an Object element containing a SignatureProperties element is still of type #Object. The type attribute is advisory. No validation of the type information is required by this specification. Eastlake, et al. Standards Track [Page 20] RFC 3075 XML-Signature Syntax and Processing March 2001 4.3.3.2 The Reference Processing Model Note: XPath is RECOMMENDED. Signature applications need not conform to [XPath] specification in order to conform to this specification. However, the XPath data model, definitions (e.g., node-sets) and syntax is used within this document in order to describe functionality for those that want to process XML-as-XML (instead of octets) as part of signature generation. For those that want to use these features, a conformant [XPath] implementation is one way to implement these features, but it is not required. Such applications could use a sufficiently functional replacement to a node-set and implement only those XPath expression behaviors REQUIRED by this specification. However, for simplicity we generally will use XPath terminology without including this qualification on every point. Requirements over "XPath nodesets" can include a node-set functional equivalent. Requirements over XPath processing can include application behaviors that are equivalent to the corresponding XPath behavior. The data-type of the result of URI dereferencing or subsequent Transforms is either an octet stream or an XPath node