tech-invite   World Map
3GPP     Specs     Glossaries     UICC       IETF     RFCs     Groups     SIP     ABNFs       T+       Search     Home

RFC 3275

 Errata 
Draft STD
Pages: 73
Top     in Index     Prev     Next
in Group Index     Prev in Group     Next in Group     Group: XMLDSIG

(Extensible Markup Language) XML-Signature Syntax and Processing

Part 1 of 3, p. 1 to 15
None       Next RFC Part

Obsoletes:    3075


Top       ToC       Page 1 
Network Working Group                                    D. Eastlake 3rd
Request for Comments: 3275                                      Motorola
Obsoletes: 3075                                                J. Reagle
Category: Standards Track                                            W3C
                                                                 D. Solo
                                                               Citigroup
                                                              March 2002


    (Extensible Markup Language) 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) 2002 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.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

Top      ToC       Page 2 
   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

Top      ToC       Page 3 
   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. 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).

Top      ToC       Page 4 
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
   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 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 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 key words 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 Namespaces in XML 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#"

Top      ToC       Page 5 
   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/REC-xslt-19991116

   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:

      <?xml version='1.0'?>
      <!DOCTYPE Signature SYSTEM
        "xmldsig-core-schema.dtd" [ <!ENTITY dsig
        "http://www.w3.org/2000/09/xmldsig#"> ]>
      <Signature xmlns="&dsig;" Id="MyFirstSignature">
        <SignedInfo>
        ...

Top      ToC       Page 6 
1.4 Acknowledgements

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

      * Mark Bartel, Accelio (Author)
      * John Boyer, PureEdge (Author)
      * Mariano P. Consens, University of Waterloo
      * 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 (Author)
      * Peter Lipp, IAIK TU Graz
      * Joseph Reagle, W3C (Chair, Author/Editor)
      * Ed Simon, XMLsec (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.

1.5 W3C Status

   The World Wide Web Consortium Recommendation corresponding to
   this RFC is at:

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

Top      ToC       Page 7 
2. 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
   the following structure (where "?" denotes zero or one occurrence;
   "+" denotes one or more occurrences; and "*" denotes zero or more
   occurrences):

      <Signature ID?>
         <SignedInfo>
           <CanonicalizationMethod/>
           <SignatureMethod/>
           (<Reference URI? >
             (<Transforms>)?
             <DigestMethod>
             <DigestValue>
           </Reference>)+
         </SignedInfo>
         <SignatureValue>
        (<KeyInfo>)?
        (<Object ID?>)*
       </Signature>

   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 reside
   within the same XML document as sibling elements; in this case, the
   signature is neither enveloping (signature is parent) nor enveloped
   attribute (signature is child).  Since a Signature element (and its
   Id 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].

Top      ToC       Page 8 
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] <Signature Id="MyFirstSignature"
   xmlns="http://www.w3.org/2000/09/xmldsig#">
    [s02]   <SignedInfo>
    [s03]   <CanonicalizationMethod
   Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
    [s04]   <SignatureMethod
   Algorithm="http://www.w3.org/2000/09/xmldsig#dsa-sha1"/>
    [s05]   <Reference
   URI="http://www.w3.org/TR/2000/REC-xhtml1-20000126/">
    [s06]     <Transforms>
    [s07]       <Transform
   Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
    [s08]     </Transforms>
    [s09]     <DigestMethod
   Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
    [s10]     <DigestValue>j6lwx3rvEPO0vKtMup4NbeVu8nk=</DigestValue>
    [s11]   </Reference>
    [s12] </SignedInfo>
    [s13]   <SignatureValue>MC0CFFrVLtRlk=...</SignatureValue>
    [s14]   <KeyInfo>
    [s15a]    <KeyValue>
    [s15b]      <DSAKeyValue>
    [s15c]        <P>...</P><Q>...</Q><G>...</G><Y>...</Y>
    [s15d]      </DSAKeyValue>
    [s15e]    </KeyValue>
    [s16]   </KeyInfo>
    [s17] </Signature>

   [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.  Note that this example, and all examples in
   this specification, are not in canonical form.

Top      ToC       Page 9 
   [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;
   the design also permits arbitrary user specified algorithms.

   [s05-11] Each Reference element includes the digest method and
   resulting digest value calculated over the identified data object.
   It may also 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.

   [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]   <Reference
   URI="http://www.w3.org/TR/2000/REC-xhtml1-20000126/">
    [s06]     <Transforms>
    [s07]       <Transform
   Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
    [s08]     </Transforms>
    [s09]     <DigestMethod
   Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
    [s10]     <DigestValue>j6lwx3rvEPO0vKtMup4NbeVu8nk=</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.)

Top      ToC       Page 10 
   [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, as
   opposed to 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 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 (integrity, message
   authentication, 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

Top      ToC       Page 11 
   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].)

    [   ]  <Signature Id="MySecondSignature" ...>
    [p01]  <SignedInfo>
    [   ]   ...
    [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]    <DigestMethod
   Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
    [p06]    <DigestValue>k3453rvEPO0vKtMup4NbeVu8nk=</DigestValue>
    [p07]   </Reference>
    [p08]  </SignedInfo>
    [p09]  ...
    [p10]  <Object>
    [p11]   <SignatureProperties>
    [p12]     <SignatureProperty Id="AMadeUpTimeStamp"
   Target="#MySecondSignature">
    [p13]        <timestamp xmlns="http://www.ietf.org/rfcXXXX.txt">
    [p14]          <date>19990908</date>
    [p15]          <time>14:34:34:34</time>
    [p16]        </timestamp>
    [p17]     </SignatureProperty>
    [p18]   </SignatureProperties>
    [p19]  </Object>
    [p20]</Signature>

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

Top      ToC       Page 12 
   [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 follow.

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

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

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

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.

Top      ToC       Page 14 
   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, [XML] or
   [XML-schema] 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 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.

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

3.2.1 Reference Validation

   1. Canonicalize the SignedInfo element based on the
      CanonicalizationMethod in SignedInfo.
   2. For each Reference in SignedInfo:
      2.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.2 Digest the resulting data object using the DigestMethod
          specified in its Reference specification.
      2.3 Compare the generated digest value against DigestValue in the
          SignedInfo Reference; if there is any mismatch, validation
          fails.

Top      ToC       Page 15 
   Note, SignedInfo is canonicalized in step 1.  The application must
   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 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 be used.  However, the
   required canonicalization [XML-C14N] of this specification does not
   change URIs.



(page 15 continued on part 2)

Next RFC Part