As per Relevance of the word canonical, we have this rfc below:










Network Working Group D. Eastlake 3
Request for Comments: 3275
Obsoletes: 3075 J.
Category: Standards Track W3
D.

March 2002


(Extensible Markup Language) XML-Signature Syntax and

Status of this

This document specifies an Internet standards track protocol for
Internet community, and requests discussion and suggestions
improvements. Please refer to the current edition of the "
Official Protocol Standards" (STD 1) for the standardization
and status of this protocol. Distribution of this memo is unlimited

Copyright

Copyright (c) 2002 The Internet Society & W3C (MIT, INRIA, Keio),
Rights Reserved



This document specifies XML (Extensible Markup Language)
signature processing rules and syntax. XML Signatures
integrity, message authentication, and/or signer
services for data of any type, whether located within the XML
includes the signature or elsewhere

Table of

1. Introduction................................................... 3
1.1 Editorial and Conformance Conventions......................... 4
1.2 Design Philosophy............................................. 4
1.3 Versions, Namespaces and Identifiers.......................... 4
1.4 Acknowledgements.............................................. 6
1.5 W3C Status.................................................... 6
2. Signature Overview and Examples................................ 7
2.1 Simple Example (Signature, SignedInfo, Methods, and References) 8
2.1.1 More on Reference........................................... 9
2.2 Extended Example (Object and SignatureProperty)............... 10
2.3 Extended Example (Object and Manifest)........................ 12
3.0 Processing Rules.............................................. 13
3.1 Core Generation............................................... 13
3.1.1 Reference Generation........................................ 13



Eastlake, et al. Standards Track [Page 1]

RFC 3275 XML-Signature Syntax and Processing March 2002


3.1.2 Signature Generation........................................ 13
3.2 Core Validation............................................... 14
3.2.1 Reference Validation........................................ 14
3.2.2 Signature Validation........................................ 15
4.0 Core Signature Syntax......................................... 15
4.0.1 The ds:CryptoBinary Simple Type............................. 17
4.1 The Signature element......................................... 17
4.2 The SignatureValue Element.................................... 18
4.3 The SignedInfo Element........................................ 18
4.3.1 The CanonicalizationMethod Element.......................... 19
4.3.2 The SignatureMethod Element................................. 21
4.3.3 The Reference Element....................................... 21
4.3.3.1 The URI Attribute......................................... 22
4.3.3.2 The Reference Processing Model............................ 23
4.3.3.3 Same-Document URI-References.............................. 25
4.3.3.4 The Transforms Element.................................... 26
4.3.3.5 The DigestMethod Element.................................. 28
4.3.3.6 The DigestValue Element................................... 28
4.4 The KeyInfo Element........................................... 29
4.4.1 The KeyName Element......................................... 31
4.4.2 The KeyValue Element........................................ 31
4.4.2.1 The DSAKeyValue Element................................... 32
4.4.2.2 The RSAKeyValue Element................................... 33
4.4.3 The RetrievalMethod Element................................. 34
4.4.4 The X509Data Element........................................ 35
4.4.5 The PGPData Element......................................... 38
4.4.6 The SPKIData Element........................................ 39
4.4.7 The MgmtData Element........................................ 40
4.5 The Object Element............................................ 40
5.0 Additional Signature Syntax................................... 42
5.1 The Manifest Element.......................................... 42
5.2 The SignatureProperties Element............................... 43
5.3 Processing Instructions in Signature Elements................. 44
5.4 Comments in Signature Elements................................ 44
6.0 Algorithms.................................................... 44
6.1 Algorithm Identifiers and Implementation Requirements......... 44
6.2 Message Digests............................................... 46
6.2.1 SHA-1....................................................... 46
6.3 Message Authentication Codes.................................. 46
6.3.1 HMAC........................................................ 46
6.4 Signature Algorithms.......................................... 47
6.4.1 DSA......................................................... 47
6.4.2 PKCS1 (RSA-SHA1)............................................ 48
6.5 Canonicalization Algorithms................................... 49
6.5.1 Canonical XML............................................... 49
6.6 Transform Algorithms.......................................... 50
6.6.1 Canonicalization............................................ 50
6.6.2 Base64...................................................... 50



Eastlake, et al. Standards Track [Page 2]

RFC 3275 XML-Signature Syntax and Processing March 2002


6.6.3 XPath Filtering............................................. 51
6.6.4 Enveloped Signature Transform............................... 54
6.6.5 XSLT Transform.............................................. 54
7. XML Canonicalization and Syntax Constraint Considerations...... 55
7.1 XML 1.0, Syntax Constraints, and Canonicalization............. 56
7.2 DOM/SAX Processing and Canonicalization....................... 57
7.3 Namespace Context and Portable Signatures..................... 58
8.0 Security Considerations....................................... 59
8.1 Transforms.................................................... 59
8.1.1 Only What is Signed is Secure............................... 60
8.1.2 Only What is 'Seen' Should be Signed........................ 60
8.1.3 'See' What is Signed........................................ 61
8.2 Check the Security Model...................................... 62
8.3 Algorithms, Key Lengths, Certificates, Etc.................... 62
9. Schema, DTD, Data Model, and Valid Examples.................... 63
10. Definitions................................................... 63
Appendix: Changes from RFC 3075................................... 67
References........................................................ 67
Authors' Addresses................................................ 72
Full Copyright Statement.......................................... 73

1.

This document specifies XML syntax and processing rules for
and representing digital signatures. XML Signatures can be
to any digital content (data object), including XML. An
Signature may be applied to the content of one or more resources
Enveloped or enveloping signatures are over data within the same
document as the signature; detached signatures are over data
to the signature element. More specifically, this
defines an XML signature element type and an XML
application; conformance requirements for each are specified by
of schema definitions and prose respectively. This
also includes other useful types that identify methods
referencing collections of resources, algorithms, and keying
management information

The XML Signature is a method of associating a key with
data (octets); it does not normatively specify how keys
associated with persons or institutions, nor the meaning of the
being referenced and signed. Consequently, while this
is an important component of secure XML applications, it itself
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
application must specify additional key, algorithm, processing
rendering requirements. For further information, please see
Considerations (section 8).



Eastlake, et al. Standards Track [Page 3]

RFC 3275 XML-Signature Syntax and Processing March 2002


1.1 Editorial and Conformance

For readability, brevity, and historic reasons this document uses
term "signature" to generally refer to digital authentication
of all types. Obviously, the term is also strictly used to refer
authentication values that are based on public keys and that
signer authentication. When specifically discussing
values based on symmetric secret key codes we use the
authenticators or authentication codes. (See Check the
Model, section 8.3.)

This specification provides an XML Schema [XML-schema] and DTD [XML].
The schema definition is normative

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
"SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in
specification are to be interpreted as described in RFC2119
[KEYWORDS]:

"they MUST only be used where it is actually required
interoperation or to limit behavior which has potential
causing harm (e.g., limiting retransmissions)"

Consequently, we use these capitalized key words to
specify requirements over protocol and application features
behavior that affect the interoperability and security
implementations. These key words are not used (capitalized)
describe XML grammar; schema definitions unambiguously describe
requirements and we wish to reserve the prominence of these terms
the natural language descriptions of protocols and features.
instance, an XML attribute might be described as being "optional."
Compliance with the Namespaces in XML specification [XML-ns]
described as "REQUIRED."

1.2 Design

The design philosophy and requirements of this specification
addressed in the XML-Signature Requirements document [XML-Signature
RD].

1.3 Versions, Namespaces and

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
of this (dated) specification is

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



Eastlake, et al. Standards Track [Page 4]

RFC 3275 XML-Signature Syntax and Processing March 2002


This namespace is also used as the prefix for algorithm
used by this specification. While applications MUST support XML
XML namespaces, the use of internal entities [XML] or our "dsig"
namespace prefix and defaulting/scoping conventions are OPTIONAL;
use these facilities to provide compact and readable examples

This specification uses Uniform Resource Identifiers [URI]
identify resources, algorithms, and semantics. The URI in
namespace declaration above is also used as a prefix for URIs
the control of this specification. For resources not under
control of this specification, we use the designated Uniform
Names [URN] or Uniform Resource Locators [URL] defined by
normative external specification. If an external specification
not allocated itself a Uniform Resource Identifier we allocate
identifier under our own namespace. For instance

SignatureProperties is identified and defined by this specification'
namespace
http://www.w3.org/2000/09/xmldsig#

XSLT is identified and defined by an external
http://www.w3.org/TR/1999/REC-xslt-19991116

SHA1 is identified via this specification's namespace and defined
a normative
http://www.w3.org/2000/09/xmldsig#sha
FIPS PUB 180-1. Secure Hash Standard. U.S. Department
Commerce/National Institute of Standards and Technology

Finally, in order to provide for terse namespace declarations
sometimes use XML internal entities [XML] within URIs. For instance


Signature
"xmldsig-core-schema.dtd" [ "http://www.w3.org/2000/09/xmldsig#"> ]>
<Signature xmlns="&dsig;" Id="MyFirstSignature">
...












Eastlake, et al. Standards Track [Page 5]

RFC 3275 XML-Signature Syntax and Processing March 2002


1.4

The contributions of the following Working Group members to
specification are gratefully acknowledged

* Mark Bartel, Accelio (Author
* John Boyer, PureEdge (Author
* Mariano P. Consens, University of
* John Cowan, Reuters
* Donald Eastlake 3rd, Motorola (Chair, Author/Editor
* Barb Fox, Microsoft (Author
* Christian Geuer-Pollmann, University
* Tom Gindin,
* Phillip Hallam-Baker, VeriSign
* Richard Himes, US
* Merlin Hughes,
* Gregor Karlinger, IAIK TU
* Brian LaMacchia, Microsoft (Author
* Peter Lipp, IAIK TU
* Joseph Reagle, W3C (Chair, Author/Editor
* Ed Simon, XMLsec (Author
* David Solo, Citigroup (Author/Editor
* Petteri Stenius, DONE Information,
* Raghavan Srinivas,
* Kent Tamura,
* Winchel Todd Vincent III,
* Carl Wallace, Corsec Security, Inc
* Greg Whitehead, Signio Inc

As are the Last Call comments from the following

* Dan Connolly, W3
* Paul Biron, Kaiser Permanente, on behalf of the XML Schema WG
* Martin J. Duerst, W3C; and Masahiro Sekiguchi, Fujitsu;
behalf of the Internationalization WG/IG
* Jonathan Marsh, Microsoft, on behalf of the
Stylesheet Language WG

1.5 W3C

The World Wide Web Consortium Recommendation corresponding
this RFC is at

http://www.w3.org/TR/2002/REC-xmldsig-core-20020212/







Eastlake, et al. Standards Track [Page 6]

RFC 3275 XML-Signature Syntax and Processing March 2002


2. Signature Overview and

This section provides an overview and examples of XML
signature syntax. The specific processing is given in
Rules (section 3). The formal syntax is found in Core
Syntax (section 4) and Additional Signature Syntax (section 5).

In this section, an informal representation and examples are used
describe the structure of the XML signature syntax.
representation and examples may omit attributes, details
potential features that are fully explained later

XML Signatures are applied to arbitrary digital content (
objects) via an indirection. Data objects are digested,
resulting value is placed in an element (with other information)
that element is then digested and cryptographically signed.
digital signatures are represented by the Signature element which
the following structure (where "?" denotes zero or one occurrence
"+" denotes one or more occurrences; and "*" denotes zero or
occurrences):

<Signature ID?>


(<Reference URI? >
()?
Reference>)+
 ()?
()*
Signature

Signatures are related to data objects via URIs [URI]. Within an
document, signatures are related to local data objects via
identifiers. Such local data can be included within an
signature or can enclose an enveloped signature. Detached
are over external network resources or local data objects that
within the same XML document as sibling elements; in this case,
signature is neither enveloping (signature is parent) nor
attribute (signature is child). Since a Signature element (and
Id value/name) may co-exist or be combined with other elements (
their IDs) within a single XML document, care should be taken
choosing names such that there are no subsequent collisions
violate the ID uniqueness validity constraint [XML].



Eastlake, et al. Standards Track [Page 7]

RFC 3275 XML-Signature Syntax and Processing March 2002


2.1 Simple Example (Signature, SignedInfo, Methods, and References

The following example is a detached signature of the content of
HTML4 in XML specification

[s01] <Signature Id="MyFirstSignature
xmlns="http://www.w3.org/2000/09/xmldsig#">
[s02] [s03] <
Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
[s04] <
Algorithm="http://www.w3.org/2000/09/xmldsig#dsa-sha1"/>
[s05] <
URI="http://www.w3.org/TR/2000/REC-xhtml1-20000126/">
[s06] [s07] <
Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
[s08] [s09] <
Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
[s10] j6lwx3rvEPO0vKtMup4NbeVu8nk= [s11] Reference
[s12] [s13] MC0CFFrVLtRlk=... [s14] [s15a] [s15b] [s15c]

...

......... [s15d] [s15e] [s16] [s17] Signature

[s02-12] The required SignedInfo element is the information that
actually signed. Core validation of SignedInfo consists of
mandatory processes: validation of the signature over SignedInfo
validation of each Reference digest within SignedInfo. Note that
algorithms used in calculating the SignatureValue are also
in the signed information while the SignatureValue element is
SignedInfo

[s03] The CanonicalizationMethod is the algorithm that is used
canonicalize the SignedInfo element before it is digested as part
the signature operation. Note that this example, and all examples
this specification, are not in canonical form






Eastlake, et al. Standards Track [Page 8]

RFC 3275 XML-Signature Syntax and Processing March 2002


[s04] The SignatureMethod is the algorithm that is used to
the canonicalized SignedInfo into the SignatureValue. It is
combination of a digest algorithm and a key dependent algorithm
possibly other algorithms such as padding, for example RSA-SHA1.
algorithm names are signed to resist attacks based on substituting
weaker algorithm. To promote application interoperability we
a set of signature algorithms that MUST be implemented, though
use is at the discretion of the signature creator. We
additional algorithms as RECOMMENDED or OPTIONAL for implementation
the design also permits arbitrary user specified algorithms

[s05-11] Each Reference element includes the digest method
resulting digest value calculated over the identified data object
It may also include transformations that produced the input to
digest operation. A data object is signed by computing its
value and a signature over that value. The signature is
checked via reference and signature validation

[s14-16] KeyInfo indicates the key to be used to validate
signature. Possible forms for identification include certificates
key names, and key agreement algorithms and information -- we
only a few. KeyInfo is optional for two reasons. First, the
may not wish to reveal key information to all document
parties. Second, the information may be known within
application's context and need not be represented explicitly.
KeyInfo is outside of SignedInfo, if the signer wishes to bind
keying information to the signature, a Reference can easily
and include the KeyInfo as part of the signature

2.1.1 More on

[s05] <
URI="http://www.w3.org/TR/2000/REC-xhtml1-20000126/">
[s06] [s07] <
Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
[s08] [s09] <
Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
[s10] j6lwx3rvEPO0vKtMup4NbeVu8nk= [s11] Reference

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





Eastlake, et al. Standards Track [Page 9]

RFC 3275 XML-Signature Syntax and Processing March 2002


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

[s06-08] Transforms is an optional ordered list of processing
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,
schema validation, or XInclude. XPath transforms permit the
to derive an XML document that omits portions of the source document
Consequently those excluded portions can change without
signature validity. For example, if the resource being
encloses the signature itself, such a transform must be used
exclude the signature value from its own computation. If
Transforms element is present, the resource's content is
directly. While the Working Group has specified mandatory (
optional) canonicalization and decoding algorithms, user
transforms are permitted

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

2.2 Extended Example (Object and SignatureProperty

This specification does not address mechanisms for making
or assertions. Instead, this document defines what it means
something to be signed by an XML Signature (integrity,
authentication, and/or signer authentication). Applications
wish to represent other semantics must rely upon other technologies
such as [XML, RDF]. For instance, an application might use
foo:assuredby attribute within its own markup to reference
Signature element. Consequently, it's the application that
understand and know how to make trust decisions given the validity
the signature and the meaning of assuredby syntax. We also define
SignatureProperties element type for the inclusion of
about the signature itself (e.g., signature semantics, the time
signing or the serial number of hardware used in
processes). Such assertions may be signed by including a
for the SignatureProperties in SignedInfo. While the
application should be very careful about what it signs (it
understand what is in the SignatureProperty) a receiving
has no obligation to understand that semantic (though its



Eastlake, et al. Standards Track [Page 10]

RFC 3275 XML-Signature Syntax and Processing March 2002


trust engine may wish to). Any content about the
generation may be located within the SignatureProperty element.
mandatory Target attribute references the Signature element to
the property applies

Consider the preceding example with an additional reference to
local Object that includes a SignatureProperty element. (Such
signature would not only be detached [p02] but enveloping [p03].)

[ ] <Signature Id="MySecondSignature" ...>
[p01] [ ] ...
[p02] <Reference URI="http://www.w3.org/TR/xml-stylesheet/">
[ ] ...
[p03] <Reference URI="#AMadeUpTimeStamp
[p04]
Type="http://www.w3.org/2000/09/xmldsig#SignatureProperties">
[p05] <
Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
[p06] k3453rvEPO0vKtMup4NbeVu8nk= [p07] Reference
[p08] [p09] ...
[p10] [p11] [p12]
[p13] <timestamp xmlns="http://www.ietf.org/rfcXXXX.txt">
[p14] 19990908 [p15] [p19] [p20]Signature

[p04] The optional Type attribute of Reference provides
about the resource identified by the URI. In particular, it
indicate that it is an Object, SignatureProperty, or
element. This can be used by applications to initiate
processing of some Reference elements. References to an XML
element within an Object element SHOULD identify the actual
pointed to. Where the element content is not XML (perhaps it
binary or encoded data) the reference should identify the Object
the Reference Type, if given, SHOULD indicate Object. Note that
is advisory and no action based on it or checking of its
is required by core behavior




Eastlake, et al. Standards Track [Page 11]

RFC 3275 XML-Signature Syntax and Processing March 2002


[p10] Object is an optional element for including data objects
the signature element or elsewhere. The Object can be
typed and/or encoded

[p11-18] Signature properties, such as time of signing, can
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
directly addressed by the mandatory parts of this specification.
requirements and the way the Manifest satisfies them follow

First, applications frequently need to efficiently sign multiple
objects even where the signature operation itself is an
public key signature. This requirement can be met by
multiple Reference elements within SignedInfo since the inclusion
each digest secures the data digested. However, some
may not want the core validation behavior associated with
approach because it requires every Reference within SignedInfo
undergo reference validation -- the DigestValue elements are checked
These applications may wish to reserve reference validation
logic to themselves. For example, an application might receive
signature valid SignedInfo element that includes three
elements. If a single Reference fails (the identified data
when digested does not yield the specified DigestValue) the
would fail core validation. However, the application may wish
treat the signature over the two valid Reference elements as valid
take different actions depending on which fails. To accomplish this
SignedInfo would reference a Manifest element that contains one
more Reference elements (with the same structure as those
SignedInfo). Then, reference validation of the Manifest is
application control

Second, consider an application where many signatures (
different keys) are applied to a large number of documents.
inefficient solution is to have a separate signature (per key
repeatedly applied to a large SignedInfo element (with
References); this is wasteful and redundant. A more
solution is to include many references in a single Manifest that
then referenced from multiple Signature elements

The example below includes a Reference that signs a Manifest
within the Object element





Eastlake, et al. Standards Track [Page 12]

RFC 3275 XML-Signature Syntax and Processing March 2002


[ ] ...
[m01] <Reference URI="#MyFirstManifest
[m02] Type="http://www.w3.org/2000/09/xmldsig#Manifest">
[m03] <
Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
[m04] 345x3rvEPO0vKtMup4NbeVu8nk= [m05] Reference
[ ] ...
[m06] [m07]
[m08] <Reference
[m09] ...
[m10] Reference
[m11] <Reference
[m12] ...
[m13] Reference
[m14] [m15]
3.0 Processing

The sections below describe the operations to be performed as part
signature generation and validation

3.1 Core

The REQUIRED steps include the generation of Reference elements
the SignatureValue over SignedInfo

3.1.1 Reference

For each data object being signed

1. Apply the Transforms, as determined by the application, to
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)
elements, the digest algorithm and the DigestValue. (Note, it
the canonical form of these references that are signed in 3.1.2
and validated in 3.2.1.)

3.1.2 Signature

1. Create SignedInfo element with SignatureMethod
CanonicalizationMethod and Reference(s).
2. Canonicalize and then calculate the SignatureValue over
based on algorithms specified in SignedInfo



Eastlake, et al. Standards Track [Page 13]

RFC 3275 XML-Signature Syntax and Processing March 2002


3. Construct the Signature element that includes SignedInfo
Object(s) (if desired, encoding may be different than that
for signing), KeyInfo (if required), and SignatureValue

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

3.2 Core

The REQUIRED steps of core validation include (1)
validation, the verification of the digest contained in
Reference in SignedInfo, and (2) the cryptographic
validation of the signature calculated over SignedInfo

Note, there may be valid signatures that some signature
are unable to validate. Reasons for this include failure
implement optional parts of this specification, inability
unwillingness to execute specified algorithms, or inability
unwillingness to dereference specified URIs (some URI schemes
cause undesirable side effects), etc

Comparison of values in reference and signature validation are
the numeric (e.g., integer) or decoded octet sequence of the value
Different implementations may produce different encoded digest
signature values when processing the same resources because
variances in their encoding, such as accidental white space. But
one uses numeric or octet comparison (choose one) on both the
and computed values these problems are eliminated

3.2.1 Reference

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




Eastlake, et al. Standards Track [Page 14]

RFC 3275 XML-Signature Syntax and Processing March 2002


Note, SignedInfo is canonicalized in step 1. The application
ensure that the CanonicalizationMethod has no dangerous side affects
such as rewriting URIs, (see CanonicalizationMethod (section 4.3))
and that it Sees What is Signed, which is the canonical form

3.2.2 Signature

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

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

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

4.0 Core Signature

The general structure of an XML signature is described in
Overview (section 2). This section provides detailed syntax of
core signature features. Features described in this section
mandatory to implement unless otherwise indicated. The syntax
defined via DTDs and [XML-Schema] with the following XML preamble
declaration, and internal entity


















Eastlake, et al. Standards Track [Page 15]

RFC 3275 XML-Signature Syntax and Processing March 2002


Schema Definition

encoding="utf-8"?>
PUBLIC "-//W3C//DTD XMLSchema 200102//EN
"http://www.w3.org/2001/XMLSchema.dtd
[
xmlns:ds CDATA #FIXED "http://www.w3.org/2000/09/xmldsig#">



]>

targetNamespace="http://www.w3.org/2000/09/xmldsig#"
version="0.1" elementFormDefault="qualified">

DTD





Transform.ANY ''>











Eastlake, et al. Standards Track [Page 16]

RFC 3275 XML-Signature Syntax and Processing March 2002


4.0.1 The ds:CryptoBinary Simple

This specification defines the ds:CryptoBinary simple type
representing arbitrary-length integers (e.g., "bignums") in XML
octet strings. The integer value is first converted to a "
endian" bitstring. The bitstring is then padded with leading
bits so that the total number of bits == 0 mod 8 (so that there
an integral number of octets). If the bitstring contains
leading octets that are zero, these are removed (so the high-
octet is always non-zero). This octet string is then base64 [MIME
encoded. (The conversion from integer to octet string is
to IEEE 1363's I2OSP [1363] with minimal length).

This type is used by "bignum" values such as RSAKeyValue
DSAKeyValue. If a value can be of type base64Binary
ds:CryptoBinary they are defined as base64Binary. For example,
the signature algorithm is RSA or DSA then SignatureValue
a bignum and could be ds:CryptoBinary. However, if HMAC-SHA1 is
signature algorithm then SignatureValue could have leading
octets that must be preserved. Thus SignatureValue is
defined as of type base64Binary

Schema Definition


<restriction base="base64Binary">
restriction

4.1 The Signature

The Signature element is the root element of an XML Signature
Implementation MUST generate laxly schema valid [XML-schema
Signature elements as specified by the following schema

Schema Definition

Signature" type="ds:SignatureType"/>

<sequence




sequence
<attribute name="Id" type="ID" use="optional"/>




Eastlake, et al. Standards Track [Page 17]

RFC 3275 XML-Signature Syntax and Processing March 2002


DTD

Signature (SignedInfo, SignatureValue, KeyInfo?,
Object*) >
xmlns CDATA #FIXED 'http://www.w3.org/2000/09/xmldsig#'
Id ID #IMPLIED >

4.2 The SignatureValue

The SignatureValue element contains the actual value of the
signature; it is always encoded using base64 [MIME]. While
identify two SignatureMethod algorithms, one mandatory and
optional to implement, user specified algorithms may be used as well

Schema Definition



<extension base="base64Binary">
<attribute name="Id" type="ID" use="optional"/>
extension
DTD


Id ID #IMPLIED

4.3 The SignedInfo

The structure of SignedInfo includes the canonicalization algorithm
a signature algorithm, and one or more references. The
element may contain an optional ID attribute that will allow it to
referenced by other signatures and objects

SignedInfo does not include explicit signature or digest
(such as calculation time, cryptographic device serial number, etc.).
If an application needs to associate properties with the signature
digest, it may include such information in a
element within an Object element







Eastlake, et al. Standards Track [Page 18]

RFC 3275 XML-Signature Syntax and Processing March 2002


Schema Definition



<sequence


Reference" maxOccurs="unbounded"/>
sequence
<attribute name="Id" type="ID" use="optional"/>

DTD

SignatureMethod, Reference+) >
Id ID #

4.3.1 The CanonicalizationMethod

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

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

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

* XML based canonicalization implementations MUST be
with a [XPath] node-set originally formed from the
containing the SignedInfo and currently indicating
SignedInfo, its descendants, and the attribute and
nodes of SignedInfo and its descendant elements



Eastlake, et al. Standards Track [Page 19]

RFC 3275 XML-Signature Syntax and Processing March 2002


* Text based canonicalization algorithms (such as CRLF
charset normalization) should be provided with the UTF-8
that represent the well-formed SignedInfo element, from
first character to the last character of the
representation, inclusive. This includes the entire text
the start and end tags of the SignedInfo element as well as
descendant markup and character data (i.e., the text)
those tags. Use of text based canonicalization of
is NOT RECOMMENDED

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

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

Schema Definition



<sequence
namespace="##any" minOccurs="0" maxOccurs="unbounded"/>

sequence
<attribute name="Algorithm" type="anyURI" use="required"/>

DTD


Algorithm CDATA #REQUIRED >



Eastlake, et al. Standards Track [Page 20]

RFC 3275 XML-Signature Syntax and Processing March 2002


4.3.2 The SignatureMethod

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

Schema Definition



<sequence
type="ds:HMACOutputLengthType"/>
namespace="##other" minOccurs="0" maxOccurs="unbounded"/>

sequence
<attribute name="Algorithm" type="anyURI" use="required"/>

DTD

(#PCDATA|HMACOutputLength %Method.ANY;)* >
Algorithm CDATA #REQUIRED >

4.3.3 The Reference

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







Eastlake, et al. Standards Track [Page 21]

RFC 3275 XML-Signature Syntax and Processing March 2002


Schema Definition

Reference" type="ds:ReferenceType"/>

<sequence



sequence
<attribute name="Id" type="ID" use="optional"/>
<attribute name="URI" type="anyURI" use="optional"/>
<attribute name="Type" type="anyURI" use="optional"/>

DTD

Reference (Transforms?, DigestMethod, DigestValue) >
Id ID #
URI CDATA #
Type CDATA #IMPLIED

4.3.3.1 The URI

The URI attribute identifies a data object using a URI-Reference,
specified by RFC2396 [URI]. The set of allowed characters for
attributes is the same as for XML, namely [Unicode]. However,
Unicode characters are disallowed from URI references including
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
octets
2. Any octets corresponding to a disallowed character are
with the URI escaping mechanism (that is, converted to %HH,
HH is the hexadecimal notation of the octet value).
3. The original character is replaced by the resulting
sequence

XML signature applications MUST be able to parse URI syntax.
RECOMMEND they be able to dereference URIs in the HTTP scheme
Dereferencing a URI in the HTTP scheme MUST comply with the
Code Definitions of [HTTP] (e.g., 302, 305 and 307 redirects
followed to obtain the entity-body of a 200 status code response).
Applications should also be cognizant of the fact that




Eastlake, et al. Standards Track [Page 22]

RFC 3275 XML-Signature Syntax and Processing March 2002


parameter and state information, (such as HTTP cookies, HTML
profiles or content negotiation), may affect the content yielded
dereferencing a URI

If a resource is identified by more than one URI, the most
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
further information on reference processing.)

If the URI attribute is omitted altogether, the receiving
is expected to know the identity of the object. For example,
lightweight data protocol might omit this attribute given
identity of the object is part of the application context.
attribute may be omitted from at most one Reference in any
SignedInfo, or Manifest

The optional Type attribute contains information about the type
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
contents. For example, a reference that identifies an Object
containing a SignatureProperties element is still of type #Object
The type attribute is advisory. No validation of the
information is required by this specification

4.3.3.2 The Reference Processing

Note: XPath is RECOMMENDED. Signature applications need not
to [XPath] specification in order to conform to this specification
However, the XPath data model, definitions (e.g., node-sets)
syntax is used within this document in order to
functionality for those that want to process XML-as-XML (instead
octets) as part of signature generation. For those that want to
these features, a conformant [XPath] implementation is one way
implement these features, but it is not required. Such
could use a sufficiently functional replacement to a node-set
implement only those XPath expression behaviors REQUIRED by
specification. However, for simplicity we generally will use
terminology without including this qualification on every point
Requirements over "XPath node-sets" can include a node-set
equivalent. Requirements over XPath processing can
application behaviors that are equivalent to the corresponding
behavior




Eastlake, et al. Standards Track [Page 23]

RFC 3275 XML-Signature Syntax and Processing March 2002


The data-type of the result of URI dereferencing or
Transforms is either an octet stream or an XPath node-set

The Transforms specified in this document are defined with respect
the input they require. The following is the default
application behavior

* If the data object is an octet stream and the next
requires a node-set, the signature application MUST attempt
parse the octets yielding the required node-set via [XML
well-formed processing
* If the data object is a node-set and the next
requires octets, the signature application MUST attempt
convert the node-set to an octet stream using Canonical
[XML-C14N].

Users may specify alternative transforms that override these
in transitions between transforms that expect different inputs.
final octet stream contains the data octets being secured.
digest algorithm specified by DigestMethod is then applied to
data octets, resulting in the DigestValue

Unless the URI-Reference is a 'same-document' reference as defined
[URI, Section 4.2], the result of dereferencing the URI-
MUST be an octet stream. In particular, an XML document
by URI is not parsed by the signature application unless the URI is
same-document reference or unless a transform that requires
parsing is applied. (See Transforms (section 4.3.3.1).)

When a fragment is preceded by an absolute or relative URI in
URI-Reference, the meaning of the fragment is defined by
resource's MIME type. Even for XML documents, URI
(including the fragment processing) might be done for the
application by a proxy. Therefore, reference validation might
if fragment processing is not performed in a standard way (as
in the following section for same-document references).
Consequently, we RECOMMEND that the URI attribute not
fragment identifiers and that such processing be specified as
additional XPath Transform

When a fragment is not preceded by a URI in the URI-Reference,
signature applications MUST support the null URI and
XPointer. We RECOMMEND support for the same-document
'#xpointer(/)' and '#xpointer(id('ID'))' if the application
intends to support any canonicalization that preserves comments
(Otherwise URI="#foo" will automatically remove comments before
canonicalization can even be invoked.) All other support
XPointers is OPTIONAL, especially all support for barename and



Eastlake, et al. Standards Track [Page 24]

RFC 3275 XML-Signature Syntax and Processing March 2002


XPointers in external resources since the application may not
control over how the fragment is generated (leading
interoperability problems and validation failures).

The following examples demonstrate what the URI attribute
and how it is dereferenced

URI="http://example.com/bar.xml
Identifies the octets that represent the external
'http://example.com/bar.xml', that is probably an XML
given its file extension
URI="http://example.com/bar.xml#chapter1"
Identifies the element with ID attribute value 'chapter1' of
external XML resource 'http://example.com/bar.xml', provided
an octet stream. Again, for the sake of interoperability,
element identified as 'chapter1' should be obtained using
XPath transform rather than a URI fragment (barename
resolution in external resources is not REQUIRED in
specification).
URI=""
Identifies the node-set (minus any comment nodes) of the
resource containing the
URI="#chapter1"
Identifies a node-set containing the element with ID
value 'chapter1' of the XML resource containing the signature
XML Signature (and its applications) modify this node-set
include the element plus all descendents including namespaces
attributes -- but not comments

4.3.3.3 Same-Document URI-

Dereferencing a same-document reference MUST result in an
node-set suitable for use by Canonical XML [XML-C14N]. Specifically
dereferencing a null URI (URI="") MUST result in an XPath node-
that includes every non-comment node of the XML document
the URI attribute. In a fragment URI, the characters after
number sign ('#') character conform to the XPointer syntax [Xptr].
When processing an XPointer, the application MUST behave as if
root node of the XML document containing the URI attribute were
to initialize the XPointer evaluation context. The application
behave as if the result of XPointer processing were a node-
derived from the resultant location-set as follows

1. discard point
2. replace each range node with all XPath nodes having full
partial content within the
3. replace the root node with its children (if it is in the node-set




Eastlake, et al. Standards Track [Page 25]

RFC 3275 XML-Signature Syntax and Processing March 2002


4. replace any element node E with E plus all descendants of E (text
comment, PI, element) and all namespace and attribute nodes of
and its descendant elements
5. if the URI is not a full XPointer, then delete all comment

The second to last replacement is necessary because
typically indicates a subtree of an XML document's parse tree
just the element node at the root of the subtree, whereas
XML treats a node-set as a set of nodes in which absence
descendant nodes results in absence of their representative text
the canonical form

The last step is performed for null URIs, barename XPointers
child sequence XPointers. It's necessary because when [XML-C14N]
passed a node-set, it processes the node-set as is: with or
comments. Only when it's called with an octet stream does it
its own XPath expressions (default or without comments).
to retain the default behavior of stripping comments when passed
node-set, they are removed in the last step if the URI is not a
XPointer. To retain comments while selecting an element by
identifier ID, use the following full XPointer
URI='#xpointer(id('ID'))'. To retain comments while selecting
entire document, use the following full XPointer: URI='#xpointer(/)'.
This XPointer contains a simple XPath expression that includes
root node, which the second to last step above replaces with
nodes of the parse tree (all descendants, plus all attributes,
all namespaces nodes).

4.3.3.4 The Transforms

The optional Transforms element contains an ordered list of
elements; these describe how the signer obtained the data object
was digested. The output of each Transform serves as input to
next Transform. The input to the first Transform is the result
dereferencing the URI attribute of the Reference element. The
from the last Transform is the input for the DigestMethod algorithm
When transforms are applied the signer is not signing the
(original) document but the resulting (transformed) document. (
Only What is Signed is Secure (section 8.1).)

Each Transform consists of an Algorithm attribute and
parameters, if any, appropriate for the given algorithm.
Algorithm attribute value specifies the name of the algorithm to
performed, and the Transform content provides additional d