tech-invite   World Map     

IETF     RFCs     Groups     SIP     ABNFs    |    3GPP     Specs     Gloss.     Arch.     IMS     UICC    |    Misc.    |    search     info

RFC 7518

Proposed STD
Pages: 69
Top     in Index     Prev     Next
in Group Index     Prev in Group     Next in Group     Group: JOSE

JSON Web Algorithms (JWA)

Part 1 of 4, p. 1 to 11
None       Next RFC Part

 


Top       ToC       Page 1 
Internet Engineering Task Force (IETF)                          M. Jones
Request for Comments: 7518                                     Microsoft
Category: Standards Track                                       May 2015
ISSN: 2070-1721


                       JSON Web Algorithms (JWA)

Abstract

   This specification registers cryptographic algorithms and identifiers
   to be used with the JSON Web Signature (JWS), JSON Web Encryption
   (JWE), and JSON Web Key (JWK) specifications.  It defines several
   IANA registries for these identifiers.

Status of This Memo

   This is an Internet Standards Track document.

   This document is a product of the Internet Engineering Task Force
   (IETF).  It represents the consensus of the IETF community.  It has
   received public review and has been approved for publication by the
   Internet Engineering Steering Group (IESG).  Further information on
   Internet Standards is available in Section 2 of RFC 5741.

   Information about the current status of this document, any errata,
   and how to provide feedback on it may be obtained at
   http://www.rfc-editor.org/info/rfc7518.

Copyright Notice

   Copyright (c) 2015 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (http://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

Top       Page 2 
Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   4
     1.1.  Notational Conventions  . . . . . . . . . . . . . . . . .   4
   2.  Terminology . . . . . . . . . . . . . . . . . . . . . . . . .   5
   3.  Cryptographic Algorithms for Digital Signatures and MACs  . .   6
     3.1.  "alg" (Algorithm) Header Parameter Values for JWS . . . .   6
     3.2.  HMAC with SHA-2 Functions . . . . . . . . . . . . . . . .   7
     3.3.  Digital Signature with RSASSA-PKCS1-v1_5  . . . . . . . .   8
     3.4.  Digital Signature with ECDSA  . . . . . . . . . . . . . .   9
     3.5.  Digital Signature with RSASSA-PSS . . . . . . . . . . . .  10
     3.6.  Using the Algorithm "none"  . . . . . . . . . . . . . . .  11
   4.  Cryptographic Algorithms for Key Management . . . . . . . . .  11
     4.1.  "alg" (Algorithm) Header Parameter Values for JWE . . . .  12
     4.2.  Key Encryption with RSAES-PKCS1-v1_5  . . . . . . . . . .  13
     4.3.  Key Encryption with RSAES OAEP  . . . . . . . . . . . . .  14
     4.4.  Key Wrapping with AES Key Wrap  . . . . . . . . . . . . .  14
     4.5.  Direct Encryption with a Shared Symmetric Key . . . . . .  15
     4.6.  Key Agreement with Elliptic Curve Diffie-Hellman
           Ephemeral Static (ECDH-ES)  . . . . . . . . . . . . . . .  15
       4.6.1.  Header Parameters Used for ECDH Key Agreement . . . .  16
         4.6.1.1.  "epk" (Ephemeral Public Key) Header Parameter . .  16
         4.6.1.2.  "apu" (Agreement PartyUInfo) Header Parameter . .  17
         4.6.1.3.  "apv" (Agreement PartyVInfo) Header Parameter . .  17
       4.6.2.  Key Derivation for ECDH Key Agreement . . . . . . . .  17
     4.7.  Key Encryption with AES GCM . . . . . . . . . . . . . . .  18
       4.7.1.  Header Parameters Used for AES GCM Key Encryption . .  19
         4.7.1.1.  "iv" (Initialization Vector) Header Parameter . .  19
         4.7.1.2.  "tag" (Authentication Tag) Header Parameter . . .  19
     4.8.  Key Encryption with PBES2 . . . . . . . . . . . . . . . .  20
       4.8.1.  Header Parameters Used for PBES2 Key Encryption . . .  20
         4.8.1.1.  "p2s" (PBES2 Salt Input) Header Parameter . . . .  21
         4.8.1.2.  "p2c" (PBES2 Count) Header Parameter  . . . . . .  21
   5.  Cryptographic Algorithms for Content Encryption . . . . . . .  21
     5.1.  "enc" (Encryption Algorithm) Header Parameter Values for
           JWE . . . . . . . . . . . . . . . . . . . . . . . . . . .  22
     5.2.  AES_CBC_HMAC_SHA2 Algorithms  . . . . . . . . . . . . . .  22
       5.2.1.  Conventions Used in Defining AES_CBC_HMAC_SHA2  . . .  23
       5.2.2.  Generic AES_CBC_HMAC_SHA2 Algorithm . . . . . . . . .  23
         5.2.2.1.  AES_CBC_HMAC_SHA2 Encryption  . . . . . . . . . .  23
         5.2.2.2.  AES_CBC_HMAC_SHA2 Decryption  . . . . . . . . . .  25
       5.2.3.  AES_128_CBC_HMAC_SHA_256  . . . . . . . . . . . . . .  25
       5.2.4.  AES_192_CBC_HMAC_SHA_384  . . . . . . . . . . . . . .  26
       5.2.5.  AES_256_CBC_HMAC_SHA_512  . . . . . . . . . . . . . .  26
       5.2.6.  Content Encryption with AES_CBC_HMAC_SHA2 . . . . . .  26
     5.3.  Content Encryption with AES GCM . . . . . . . . . . . . .  27
   6.  Cryptographic Algorithms for Keys . . . . . . . . . . . . . .  27
     6.1.  "kty" (Key Type) Parameter Values . . . . . . . . . . . .  28

Top      ToC       Page 3 
     6.2.  Parameters for Elliptic Curve Keys  . . . . . . . . . . .  28
       6.2.1.  Parameters for Elliptic Curve Public Keys . . . . . .  28
         6.2.1.1.  "crv" (Curve) Parameter . . . . . . . . . . . . .  28
         6.2.1.2.  "x" (X Coordinate) Parameter  . . . . . . . . . .  29
         6.2.1.3.  "y" (Y Coordinate) Parameter  . . . . . . . . . .  29
       6.2.2.  Parameters for Elliptic Curve Private Keys  . . . . .  29
         6.2.2.1.  "d" (ECC Private Key) Parameter . . . . . . . . .  29
     6.3.  Parameters for RSA Keys . . . . . . . . . . . . . . . . .  30
       6.3.1.  Parameters for RSA Public Keys  . . . . . . . . . . .  30
         6.3.1.1.  "n" (Modulus) Parameter . . . . . . . . . . . . .  30
         6.3.1.2.  "e" (Exponent) Parameter  . . . . . . . . . . . .  30
       6.3.2.  Parameters for RSA Private Keys . . . . . . . . . . .  30
         6.3.2.1.  "d" (Private Exponent) Parameter  . . . . . . . .  30
         6.3.2.2.  "p" (First Prime Factor) Parameter  . . . . . . .  31
         6.3.2.3.  "q" (Second Prime Factor) Parameter . . . . . . .  31
         6.3.2.4.  "dp" (First Factor CRT Exponent) Parameter  . . .  31
         6.3.2.5.  "dq" (Second Factor CRT Exponent) Parameter . . .  31
         6.3.2.6.  "qi" (First CRT Coefficient) Parameter  . . . . .  31
         6.3.2.7.  "oth" (Other Primes Info) Parameter . . . . . . .  31
     6.4.  Parameters for Symmetric Keys . . . . . . . . . . . . . .  32
       6.4.1.  "k" (Key Value) Parameter . . . . . . . . . . . . . .  32
   7.  IANA Considerations . . . . . . . . . . . . . . . . . . . . .  32
     7.1.  JSON Web Signature and Encryption Algorithms Registry . .  33
       7.1.1.  Registration Template . . . . . . . . . . . . . . . .  34
       7.1.2.  Initial Registry Contents . . . . . . . . . . . . . .  35
     7.2.  Header Parameter Names Registration . . . . . . . . . . .  42
       7.2.1.  Registry Contents . . . . . . . . . . . . . . . . . .  42
     7.3.  JSON Web Encryption Compression Algorithms Registry . . .  43
       7.3.1.  Registration Template . . . . . . . . . . . . . . . .  43
       7.3.2.  Initial Registry Contents . . . . . . . . . . . . . .  44
     7.4.  JSON Web Key Types Registry . . . . . . . . . . . . . . .  44
       7.4.1.  Registration Template . . . . . . . . . . . . . . . .  44
       7.4.2.  Initial Registry Contents . . . . . . . . . . . . . .  45
     7.5.  JSON Web Key Parameters Registration  . . . . . . . . . .  45
       7.5.1.  Registry Contents . . . . . . . . . . . . . . . . . .  46
     7.6.  JSON Web Key Elliptic Curve Registry  . . . . . . . . . .  48
       7.6.1.  Registration Template . . . . . . . . . . . . . . . .  48
       7.6.2.  Initial Registry Contents . . . . . . . . . . . . . .  49
   8.  Security Considerations . . . . . . . . . . . . . . . . . . .  49
     8.1.  Cryptographic Agility . . . . . . . . . . . . . . . . . .  50
     8.2.  Key Lifetimes . . . . . . . . . . . . . . . . . . . . . .  50
     8.3.  RSAES-PKCS1-v1_5 Security Considerations  . . . . . . . .  50
     8.4.  AES GCM Security Considerations . . . . . . . . . . . . .  50
     8.5.  Unsecured JWS Security Considerations . . . . . . . . . .  51
     8.6.  Denial-of-Service Attacks . . . . . . . . . . . . . . . .  51
     8.7.  Reusing Key Material when Encrypting Keys . . . . . . . .  51
     8.8.  Password Considerations . . . . . . . . . . . . . . . . .  52
     8.9.  Key Entropy and Random Values . . . . . . . . . . . . . .  52

Top      ToC       Page 4 
     8.10. Differences between Digital Signatures and MACs . . . . .  52
     8.11. Using Matching Algorithm Strengths  . . . . . . . . . . .  53
     8.12. Adaptive Chosen-Ciphertext Attacks  . . . . . . . . . . .  53
     8.13. Timing Attacks  . . . . . . . . . . . . . . . . . . . . .  53
     8.14. RSA Private Key Representations and Blinding  . . . . . .  53
   9.  Internationalization Considerations . . . . . . . . . . . . .  53
   10. References  . . . . . . . . . . . . . . . . . . . . . . . . .  53
     10.1.  Normative References . . . . . . . . . . . . . . . . . .  53
     10.2.  Informative References . . . . . . . . . . . . . . . . .  56
   Appendix A.  Algorithm Identifier Cross-Reference . . . . . . . .  59
     A.1.  Digital Signature/MAC Algorithm Identifier Cross-
           Reference . . . . . . . . . . . . . . . . . . . . . . . .  60
     A.2.  Key Management Algorithm Identifier Cross-Reference . . .  61
     A.3.  Content Encryption Algorithm Identifier Cross-Reference .  62
   Appendix B.  Test Cases for AES_CBC_HMAC_SHA2 Algorithms  . . . .  62
     B.1.  Test Cases for AES_128_CBC_HMAC_SHA_256 . . . . . . . . .  63
     B.2.  Test Cases for AES_192_CBC_HMAC_SHA_384 . . . . . . . . .  64
     B.3.  Test Cases for AES_256_CBC_HMAC_SHA_512 . . . . . . . . .  65
   Appendix C.  Example ECDH-ES Key Agreement Computation  . . . . .  66
   Acknowledgements  . . . . . . . . . . . . . . . . . . . . . . . .  69
   Author's Address  . . . . . . . . . . . . . . . . . . . . . . . .  69

1.  Introduction

   This specification registers cryptographic algorithms and identifiers
   to be used with the JSON Web Signature (JWS) [JWS], JSON Web
   Encryption (JWE) [JWE], and JSON Web Key (JWK) [JWK] specifications.
   It defines several IANA registries for these identifiers.  All these
   specifications utilize JSON-based [RFC7159] data structures.  This
   specification also describes the semantics and operations that are
   specific to these algorithms and key types.

   Registering the algorithms and identifiers here, rather than in the
   JWS, JWE, and JWK specifications, is intended to allow them to remain
   unchanged in the face of changes in the set of Required, Recommended,
   Optional, and Deprecated algorithms over time.  This also allows
   changes to the JWS, JWE, and JWK specifications without changing this
   document.

   Names defined by this specification are short because a core goal is
   for the resulting representations to be compact.

1.1.  Notational Conventions

   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
   "OPTIONAL" in this document are to be interpreted as described in
   "Key words for use in RFCs to Indicate Requirement Levels" [RFC2119].

Top      ToC       Page 5 
   The interpretation should only be applied when the terms appear in
   all capital letters.

   BASE64URL(OCTETS) denotes the base64url encoding of OCTETS, per
   Section 2 of [JWS].

   UTF8(STRING) denotes the octets of the UTF-8 [RFC3629] representation
   of STRING, where STRING is a sequence of zero or more Unicode
   [UNICODE] characters.

   ASCII(STRING) denotes the octets of the ASCII [RFC20] representation
   of STRING, where STRING is a sequence of zero or more ASCII
   characters.

   The concatenation of two values A and B is denoted as A || B.

2.  Terminology

   The terms "JSON Web Signature (JWS)", "Base64url Encoding", "Header
   Parameter", "JOSE Header", "JWS Payload", "JWS Protected Header",
   "JWS Signature", "JWS Signing Input", and "Unsecured JWS" are defined
   by the JWS specification [JWS].

   The terms "JSON Web Encryption (JWE)", "Additional Authenticated Data
   (AAD)", "Authentication Tag", "Content Encryption Key (CEK)", "Direct
   Encryption", "Direct Key Agreement", "JWE Authentication Tag", "JWE
   Ciphertext", "JWE Encrypted Key", "JWE Initialization Vector", "JWE
   Protected Header", "Key Agreement with Key Wrapping", "Key
   Encryption", "Key Management Mode", and "Key Wrapping" are defined by
   the JWE specification [JWE].

   The terms "JSON Web Key (JWK)" and "JWK Set" are defined by the JWK
   specification [JWK].

   The terms "Ciphertext", "Digital Signature", "Initialization Vector",
   "Message Authentication Code (MAC)", and "Plaintext" are defined by
   the "Internet Security Glossary, Version 2" [RFC4949].

   This term is defined by this specification:

   Base64urlUInt
      The representation of a positive or zero integer value as the
      base64url encoding of the value's unsigned big-endian
      representation as an octet sequence.  The octet sequence MUST
      utilize the minimum number of octets needed to represent the
      value.  Zero is represented as BASE64URL(single zero-valued
      octet), which is "AA".

Top      ToC       Page 6 
3.  Cryptographic Algorithms for Digital Signatures and MACs

   JWS uses cryptographic algorithms to digitally sign or create a MAC
   of the contents of the JWS Protected Header and the JWS Payload.

3.1.  "alg" (Algorithm) Header Parameter Values for JWS

   The table below is the set of "alg" (algorithm) Header Parameter
   values defined by this specification for use with JWS, each of which
   is explained in more detail in the following sections:

   +--------------+-------------------------------+--------------------+
   | "alg" Param  | Digital Signature or MAC      | Implementation     |
   | Value        | Algorithm                     | Requirements       |
   +--------------+-------------------------------+--------------------+
   | HS256        | HMAC using SHA-256            | Required           |
   | HS384        | HMAC using SHA-384            | Optional           |
   | HS512        | HMAC using SHA-512            | Optional           |
   | RS256        | RSASSA-PKCS1-v1_5 using       | Recommended        |
   |              | SHA-256                       |                    |
   | RS384        | RSASSA-PKCS1-v1_5 using       | Optional           |
   |              | SHA-384                       |                    |
   | RS512        | RSASSA-PKCS1-v1_5 using       | Optional           |
   |              | SHA-512                       |                    |
   | ES256        | ECDSA using P-256 and SHA-256 | Recommended+       |
   | ES384        | ECDSA using P-384 and SHA-384 | Optional           |
   | ES512        | ECDSA using P-521 and SHA-512 | Optional           |
   | PS256        | RSASSA-PSS using SHA-256 and  | Optional           |
   |              | MGF1 with SHA-256             |                    |
   | PS384        | RSASSA-PSS using SHA-384 and  | Optional           |
   |              | MGF1 with SHA-384             |                    |
   | PS512        | RSASSA-PSS using SHA-512 and  | Optional           |
   |              | MGF1 with SHA-512             |                    |
   | none         | No digital signature or MAC   | Optional           |
   |              | performed                     |                    |
   +--------------+-------------------------------+--------------------+

   The use of "+" in the Implementation Requirements column indicates
   that the requirement strength is likely to be increased in a future
   version of the specification.

   See Appendix A.1 for a table cross-referencing the JWS digital
   signature and MAC "alg" (algorithm) values defined in this
   specification with the equivalent identifiers used by other standards
   and software packages.

Top      ToC       Page 7 
3.2.  HMAC with SHA-2 Functions

   Hash-based Message Authentication Codes (HMACs) enable one to use a
   secret plus a cryptographic hash function to generate a MAC.  This
   can be used to demonstrate that whoever generated the MAC was in
   possession of the MAC key.  The algorithm for implementing and
   validating HMACs is provided in RFC 2104 [RFC2104].

   A key of the same size as the hash output (for instance, 256 bits for
   "HS256") or larger MUST be used with this algorithm.  (This
   requirement is based on Section 5.3.4 (Security Effect of the HMAC
   Key) of NIST SP 800-117 [NIST.800-107], which states that the
   effective security strength is the minimum of the security strength
   of the key and two times the size of the internal hash value.)

   The HMAC SHA-256 MAC is generated per RFC 2104, using SHA-256 as the
   hash algorithm "H", using the JWS Signing Input as the "text" value,
   and using the shared key.  The HMAC output value is the JWS
   Signature.

   The following "alg" (algorithm) Header Parameter values are used to
   indicate that the JWS Signature is an HMAC value computed using the
   corresponding algorithm:

                +-------------------+--------------------+
                | "alg" Param Value | MAC Algorithm      |
                +-------------------+--------------------+
                | HS256             | HMAC using SHA-256 |
                | HS384             | HMAC using SHA-384 |
                | HS512             | HMAC using SHA-512 |
                +-------------------+--------------------+

   The HMAC SHA-256 MAC for a JWS is validated by computing an HMAC
   value per RFC 2104, using SHA-256 as the hash algorithm "H", using
   the received JWS Signing Input as the "text" value, and using the
   shared key.  This computed HMAC value is then compared to the result
   of base64url decoding the received encoded JWS Signature value.  The
   comparison of the computed HMAC value to the JWS Signature value MUST
   be done in a constant-time manner to thwart timing attacks.
   Alternatively, the computed HMAC value can be base64url encoded and
   compared to the received encoded JWS Signature value (also in a
   constant-time manner), as this comparison produces the same result as
   comparing the unencoded values.  In either case, if the values match,
   the HMAC has been validated.

Top      ToC       Page 8 
   Securing content and validation with the HMAC SHA-384 and HMAC
   SHA-512 algorithms is performed identically to the procedure for HMAC
   SHA-256 -- just using the corresponding hash algorithms with
   correspondingly larger minimum key sizes and result values: 384 bits
   each for HMAC SHA-384 and 512 bits each for HMAC SHA-512.

   An example using this algorithm is shown in Appendix A.1 of [JWS].

3.3.  Digital Signature with RSASSA-PKCS1-v1_5

   This section defines the use of the RSASSA-PKCS1-v1_5 digital
   signature algorithm as defined in Section 8.2 of RFC 3447 [RFC3447]
   (commonly known as PKCS #1), using SHA-2 [SHS] hash functions.

   A key of size 2048 bits or larger MUST be used with these algorithms.

   The RSASSA-PKCS1-v1_5 SHA-256 digital signature is generated as
   follows: generate a digital signature of the JWS Signing Input using
   RSASSA-PKCS1-v1_5-SIGN and the SHA-256 hash function with the desired
   private key.  This is the JWS Signature value.

   The following "alg" (algorithm) Header Parameter values are used to
   indicate that the JWS Signature is a digital signature value computed
   using the corresponding algorithm:

          +-------------------+---------------------------------+
          | "alg" Param Value | Digital Signature Algorithm     |
          +-------------------+---------------------------------+
          | RS256             | RSASSA-PKCS1-v1_5 using SHA-256 |
          | RS384             | RSASSA-PKCS1-v1_5 using SHA-384 |
          | RS512             | RSASSA-PKCS1-v1_5 using SHA-512 |
          +-------------------+---------------------------------+

   The RSASSA-PKCS1-v1_5 SHA-256 digital signature for a JWS is
   validated as follows: submit the JWS Signing Input, the JWS
   Signature, and the public key corresponding to the private key used
   by the signer to the RSASSA-PKCS1-v1_5-VERIFY algorithm using SHA-256
   as the hash function.

   Signing and validation with the RSASSA-PKCS1-v1_5 SHA-384 and RSASSA-
   PKCS1-v1_5 SHA-512 algorithms is performed identically to the
   procedure for RSASSA-PKCS1-v1_5 SHA-256 -- just using the
   corresponding hash algorithms instead of SHA-256.

   An example using this algorithm is shown in Appendix A.2 of [JWS].

Top      ToC       Page 9 
3.4.  Digital Signature with ECDSA

   The Elliptic Curve Digital Signature Algorithm (ECDSA) [DSS] provides
   for the use of Elliptic Curve Cryptography, which is able to provide
   equivalent security to RSA cryptography but using shorter key sizes
   and with greater processing speed for many operations.  This means
   that ECDSA digital signatures will be substantially smaller in terms
   of length than equivalently strong RSA digital signatures.

   This specification defines the use of ECDSA with the P-256 curve and
   the SHA-256 cryptographic hash function, ECDSA with the P-384 curve
   and the SHA-384 hash function, and ECDSA with the P-521 curve and the
   SHA-512 hash function.  The P-256, P-384, and P-521 curves are
   defined in [DSS].

   The ECDSA P-256 SHA-256 digital signature is generated as follows:

   1.  Generate a digital signature of the JWS Signing Input using ECDSA
       P-256 SHA-256 with the desired private key.  The output will be
       the pair (R, S), where R and S are 256-bit unsigned integers.

   2.  Turn R and S into octet sequences in big-endian order, with each
       array being be 32 octets long.  The octet sequence
       representations MUST NOT be shortened to omit any leading zero
       octets contained in the values.

   3.  Concatenate the two octet sequences in the order R and then S.
       (Note that many ECDSA implementations will directly produce this
       concatenation as their output.)

   4.  The resulting 64-octet sequence is the JWS Signature value.

   The following "alg" (algorithm) Header Parameter values are used to
   indicate that the JWS Signature is a digital signature value computed
   using the corresponding algorithm:

           +-------------------+-------------------------------+
           | "alg" Param Value | Digital Signature Algorithm   |
           +-------------------+-------------------------------+
           | ES256             | ECDSA using P-256 and SHA-256 |
           | ES384             | ECDSA using P-384 and SHA-384 |
           | ES512             | ECDSA using P-521 and SHA-512 |
           +-------------------+-------------------------------+

Top      ToC       Page 10 
   The ECDSA P-256 SHA-256 digital signature for a JWS is validated as
   follows:

   1.  The JWS Signature value MUST be a 64-octet sequence.  If it is
       not a 64-octet sequence, the validation has failed.

   2.  Split the 64-octet sequence into two 32-octet sequences.  The
       first octet sequence represents R and the second S.  The values R
       and S are represented as octet sequences using the Integer-to-
       OctetString Conversion defined in Section 2.3.7 of SEC1 [SEC1]
       (in big-endian octet order).

   3.  Submit the JWS Signing Input, R, S, and the public key (x, y) to
       the ECDSA P-256 SHA-256 validator.

   Signing and validation with the ECDSA P-384 SHA-384 and ECDSA P-521
   SHA-512 algorithms is performed identically to the procedure for
   ECDSA P-256 SHA-256 -- just using the corresponding hash algorithms
   with correspondingly larger result values.  For ECDSA P-384 SHA-384,
   R and S will be 384 bits each, resulting in a 96-octet sequence.  For
   ECDSA P-521 SHA-512, R and S will be 521 bits each, resulting in a
   132-octet sequence.  (Note that the Integer-to-OctetString Conversion
   defined in Section 2.3.7 of SEC1 [SEC1] used to represent R and S as
   octet sequences adds zero-valued high-order padding bits when needed
   to round the size up to a multiple of 8 bits; thus, each 521-bit
   integer is represented using 528 bits in 66 octets.)

   Examples using these algorithms are shown in Appendices A.3 and A.4
   of [JWS].

3.5.  Digital Signature with RSASSA-PSS

   This section defines the use of the RSASSA-PSS digital signature
   algorithm as defined in Section 8.1 of RFC 3447 [RFC3447] with the
   MGF1 mask generation function and SHA-2 hash functions, always using
   the same hash function for both the RSASSA-PSS hash function and the
   MGF1 hash function.  The size of the salt value is the same size as
   the hash function output.  All other algorithm parameters use the
   defaults specified in Appendix A.2.3 of RFC 3447.

   A key of size 2048 bits or larger MUST be used with this algorithm.

   The RSASSA-PSS SHA-256 digital signature is generated as follows:
   generate a digital signature of the JWS Signing Input using RSASSA-
   PSS-SIGN, the SHA-256 hash function, and the MGF1 mask generation
   function with SHA-256 with the desired private key.  This is the JWS
   Signature value.

Top      ToC       Page 11 
   The following "alg" (algorithm) Header Parameter values are used to
   indicate that the JWS Signature is a digital signature value computed
   using the corresponding algorithm:

   +-------------------+-----------------------------------------------+
   | "alg" Param Value | Digital Signature Algorithm                   |
   +-------------------+-----------------------------------------------+
   | PS256             | RSASSA-PSS using SHA-256 and MGF1 with        |
   |                   | SHA-256                                       |
   | PS384             | RSASSA-PSS using SHA-384 and MGF1 with        |
   |                   | SHA-384                                       |
   | PS512             | RSASSA-PSS using SHA-512 and MGF1 with        |
   |                   | SHA-512                                       |
   +-------------------+-----------------------------------------------+

   The RSASSA-PSS SHA-256 digital signature for a JWS is validated as
   follows: submit the JWS Signing Input, the JWS Signature, and the
   public key corresponding to the private key used by the signer to the
   RSASSA-PSS-VERIFY algorithm using SHA-256 as the hash function and
   using MGF1 as the mask generation function with SHA-256.

   Signing and validation with the RSASSA-PSS SHA-384 and RSASSA-PSS
   SHA-512 algorithms is performed identically to the procedure for
   RSASSA-PSS SHA-256 -- just using the alternative hash algorithm in
   both roles.

3.6.  Using the Algorithm "none"

   JWSs MAY also be created that do not provide integrity protection.
   Such a JWS is called an Unsecured JWS.  An Unsecured JWS uses the
   "alg" value "none" and is formatted identically to other JWSs, but
   MUST use the empty octet sequence as its JWS Signature value.
   Recipients MUST verify that the JWS Signature value is the empty
   octet sequence.

   Implementations that support Unsecured JWSs MUST NOT accept such
   objects as valid unless the application specifies that it is
   acceptable for a specific object to not be integrity protected.
   Implementations MUST NOT accept Unsecured JWSs by default.  In order
   to mitigate downgrade attacks, applications MUST NOT signal
   acceptance of Unsecured JWSs at a global level, and SHOULD signal
   acceptance on a per-object basis.  See Section 8.5 for security
   considerations associated with using this algorithm.



(page 11 continued on part 2)

Next RFC Part