JSON Web Algorithms (JWA)
Microsoft
mbj@microsoft.com
http://self-issued.info/
Security
JOSE Working Group
RFC
Request for Comments
I-D
Internet-Draft
Assertion
Simple Web Token
Security Token
SWT
JavaScript Object Notation
JSON
JSON Web Token
JWT
JSON Web Signature
JWS
JSON Web Encryption
JWE
JSON Web Algorithms
JWA
The JSON Web Algorithms (JWA) specification enumerates
cryptographic algorithms and identifiers to be used with the
JSON Web Signature (JWS) and
JSON Web Encryption (JWE) specifications.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL
NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and
"OPTIONAL" in this document are to be interpreted as described
in RFC 2119.
The JSON Web Algorithms (JWA) specification enumerates
cryptographic algorithms and identifiers to be used with the
JSON Web Signature (JWS) and
JSON Web Encryption (JWE) specifications.
Enumerating the algorithms and identifiers for them in this
specification, rather than in the JWS and JWE
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 specification also describes the semantics and operations
that are specific to these algorithms and algorithm families.
This specification uses the terminology defined by the
JSON Web Signature (JWS) and
JSON Web Encryption (JWE) specifications.
JWS uses cryptographic algorithms to sign the contents
of the JWS Header and the JWS Payload. The
use of the following algorithms for producing JWSs is defined in
this section.
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 Parameter Value
Algorithm
HS256
HMAC using SHA-256 hash algorithm
HS384
HMAC using SHA-384 hash algorithm
HS512
HMAC using SHA-512 hash algorithm
RS256
RSA using SHA-256 hash algorithm
RS384
RSA using SHA-384 hash algorithm
RS512
RSA using SHA-512 hash algorithm
ES256
ECDSA using P-256 curve and SHA-256 hash algorithm
ES384
ECDSA using P-384 curve and SHA-384 hash algorithm
ES512
ECDSA using P-521 curve and SHA-512 hash algorithm
See for a table cross-referencing the
digital signature and HMAC alg (algorithm)
values used in this specification
with the equivalent identifiers used by other
standards and software packages.
Of these algorithms, only HMAC SHA-256 MUST be implemented by
conforming JWS implementations. It is RECOMMENDED that
implementations also support the RSA SHA-256 and ECDSA P-256
SHA-256 algorithms. Support for other algorithms and key
sizes is OPTIONAL.
Hash based Message Authentication Codes (HMACs) enable one to
use a secret plus a cryptographic hash function to generate a
Message Authentication Code (MAC). This can be used to
demonstrate that the MAC matches the hashed content, in this
case the JWS Secured Input, which therefore demonstrates that
whoever generated the MAC was in possession of the secret.
The means of exchanging the shared key is outside the scope
of this specification.
The algorithm for implementing and validating HMACs is
provided in RFC 2104. This
section defines the use of the HMAC SHA-256, HMAC SHA-384,
and HMAC SHA-512 cryptographic hash functions as defined in
FIPS 180-3. The
alg (algorithm) header parameter values
HS256, HS384, and HS512 are used in the JWS Header
to indicate that the Encoded JWS Signature contains a base64url
encoded HMAC value using the respective hash function.
The HMAC SHA-256 MAC is generated as follows:
Apply the HMAC SHA-256 algorithm to the UTF-8
representation of the JWS Secured Input using the shared
key to produce an HMAC value.
Base64url encode the resulting HMAC value.

The output is the Encoded JWS Signature for that JWS.
The HMAC SHA-256 MAC for a JWS is validated as follows:
Apply the HMAC SHA-256 algorithm to the UTF-8
representation of the JWS Secured Input of the JWS using
the shared key.
Base64url encode the resulting HMAC value.
If the JWS Signature and the base64url encoded HMAC
value exactly match, then one has confirmation that the
shared key was used to generate the HMAC on the JWS and that the
contents of the JWS have not be tampered with.
If the validation fails, the JWS MUST be rejected.

Securing content with the HMAC SHA-384 and HMAC SHA-512 algorithms is
performed identically to the procedure for HMAC SHA-256 - just
with correspondingly longer key and result values.
This section defines the use of the RSASSA-PKCS1-v1_5
digital signature algorithm as defined in RFC
3447, Section 8.2 (commonly known as PKCS#1), using
SHA-256, SHA-384, or SHA-512 as the hash function. The
RSASSA-PKCS1-v1_5 algorithm is described in FIPS 186-3, Section 5.5, and the
SHA-256, SHA-384, and SHA-512 cryptographic hash functions
are defined in FIPS 180-3.
The alg (algorithm) header
parameter values RS256, RS384, and RS512 are used in the JWS Header
to indicate that the Encoded JWS Signature contains a base64url
encoded RSA digital signature using the respective hash function.
A 2048-bit or longer key length MUST be used with this
algorithm.
The RSA SHA-256 digital signature is generated as follows:
Generate a digital signature of the UTF-8 representation
of the JWS Secured Input using RSASSA-PKCS1-V1_5-SIGN
and the SHA-256 hash function with the desired private
key. The output will be a byte array.
Base64url encode the resulting byte array.

The output is the Encoded JWS Signature for that JWS.
The RSA SHA-256 digital signature for a JWS is validated as follows:
Take the Encoded JWS Signature and base64url decode it into
a byte array. If decoding fails, the JWS MUST
be rejected.
Submit the UTF-8 representation of the JWS Secured Input
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.
If the validation fails, the JWS MUST be rejected.

Signing with the RSA SHA-384 and RSA SHA-512 algorithms is
performed identically to the procedure for RSA SHA-256 - just
with correspondingly longer key and result values.
The Elliptic Curve Digital Signature Algorithm (ECDSA) is
defined by FIPS 186-3. ECDSA
provides for the use of Elliptic Curve cryptography, which is
able to provide equivalent security to RSA cryptography but
using shorter key lengths and with greater processing
speed. 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 also
defined in FIPS 186-3. The alg (algorithm) header parameter values ES256, ES384, and ES512 are used in the JWS Header
to indicate that the Encoded JWS Signature contains a base64url
encoded ECDSA P-256 SHA-256, ECDSA P-384 SHA-384, or ECDSA
P-521 SHA-512 digital signature, respectively.
The ECDSA P-256 SHA-256 digital signature is generated as follows:
Generate a digital signature of the UTF-8 representation
of the JWS Secured Input using ECDSA P-256 SHA-256 with
the desired private key. The output will be the EC point
(R, S), where R and S are unsigned integers.
Turn R and S into byte arrays in big endian order. Each
array will be 32 bytes long.
Concatenate the two byte arrays in the order R and then S.
Base64url encode the resulting 64 byte array.

The output is the Encoded JWS Signature for the JWS.
The ECDSA P-256 SHA-256 digital signature for a JWS is validated as follows:
Take the Encoded JWS Signature and base64url decode it into
a byte array. If decoding fails, the JWS MUST
be rejected.
The output of the base64url decoding MUST be a 64 byte
array.
Split the 64 byte array into two 32 byte arrays. The first
array will be R and the second S. Remember that the byte
arrays are in big endian byte order; please check the
ECDSA validator in use to see what byte order it requires.
Submit the UTF-8 representation of the JWS Secured Input,
R, S and the public key (x, y) to the ECDSA P-256
SHA-256 validator.
If the validation fails, the JWS MUST be rejected.

The ECDSA validator will then determine if the digital
signature is valid, given the inputs. Note that ECDSA digital
signature contains a value referred to as K, which is a random
number generated for each digital signature instance. This
means that two ECDSA digital signatures using exactly the same
input parameters will output different signature values because
their K values will be different. The consequence of this is
that one must validate an ECDSA digital signature by submitting the
previously specified inputs to an ECDSA validator.
Signing 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 with correspondingly longer key and
result values.
Additional algorithms MAY be used to protect JWSs with
corresponding alg (algorithm) header parameter values being defined to
refer to them. New alg header parameter values SHOULD
either be defined in the IANA JSON Web Signature Algorithms
registry or be a URI that contains a collision resistant
namespace. In particular, it is permissible to use the algorithm identifiers
defined in XML DSIG and
related specifications as alg values.
JWE uses cryptographic algorithms to encrypt the Content
Encryption Key (CEK) and the Plaintext. This section
specifies a set of specific algorithms for these purposes.
The table below is the set of
alg (algorithm) header parameter values that
are defined by this specification for use with JWE. These algorithms are used
to encrypt the CEK, which produces the JWE Encrypted Key.
alg Parameter Value
Encryption Algorithm
RSA1_5
RSA using RSA-PKCS1-1.5 padding, as defined in RFC 3447
RSA-OAEP
RSA using Optimal Asymmetric Encryption Padding (OAEP), as
defined in RFC 3447
ECDH-ES
Elliptic Curve Diffie-Hellman Ephemeral Static, as defined
in RFC 6090, and using the
Concat KDF, as defined in ,
where the Digest Method is SHA-256
A128KW
Advanced Encryption Standard (AES) Key Wrap Algorithm using
128 bit keys, as defined in RFC
3394
A256KW
Advanced Encryption Standard (AES) Key Wrap Algorithm using
256 bit keys, as defined in RFC
3394
A128GCM
Advanced Encryption Standard (AES) using 128 bit keys in
Galois/Counter Mode, as defined in
and
A256GCM
Advanced Encryption Standard (AES) using 256 bit keys in
Galois/Counter Mode, as defined in
and
The table below is the set of
enc (encryption method) header parameter values that
are defined by this specification for use with JWE. These algorithms are used
to encrypt the Plaintext, which produces the Ciphertext.
enc Parameter Value
Symmetric Encryption Algorithm
A128CBC
Advanced Encryption Standard (AES) using 128 bit keys in
Cipher Block Chaining mode, as defined in
and
A256CBC
Advanced Encryption Standard (AES) using 256 bit keys in
Cipher Block Chaining mode, as defined in
and
A128GCM
Advanced Encryption Standard (AES) using 128 bit keys in
Galois/Counter Mode, as defined in
and
A256GCM
Advanced Encryption Standard (AES) using 256 bit keys in
Galois/Counter Mode, as defined in
and
See for a table cross-referencing the
encryption alg (algorithm) and
alg (encryption method)
values used in this specification
with the equivalent identifiers used by other
standards and software packages.
Of these algorithms, only RSA-PKCS1-1.5 with 2048 bit keys,
AES-128-CBC, and AES-256-CBC MUST be implemented by conforming JWE
implementations. It is RECOMMENDED that implementations also
support ECDH-ES with 256 bit keys, AES-128-GCM, and
AES-256-GCM. Support for other algorithms and key sizes is
OPTIONAL.
TBD: Descriptions of the particulars of using each specified
encryption algorithm go here.
Additional algorithms MAY be used to protect JWEs with
corresponding alg (algorithm) and enc (encryption method) header parameter values being
defined to refer to them. New alg and enc
header parameter values SHOULD either be defined in the IANA
JSON Web Encryption Algorithms registry or be a URI that
contains a collision resistant namespace. In particular,
it is permissible to use the algorithm identifiers defined in
XML Encryption,
XML Encryption 1.1,
and related specifications as alg
and enc values.
This specification calls for:
A new IANA registry entitled "JSON Web Signature Algorithms"
for values of the JWS alg (algorithm) header parameter
is defined in . Inclusion
in the registry is RFC Required in the RFC 5226 sense. The registry will
just record the alg value and a pointer to the RFC that
defines it. This specification defines inclusion of the
algorithm values defined in .
A new IANA registry entitled "JSON Web Encryption
Algorithms" for values used with the JWE alg (algorithm) and enc (encryption method) header parameters is
defined in . Inclusion in
the registry is RFC Required in the RFC 5226 sense. The registry will
record the alg or enc value and a pointer to the RFC
that defines it. This specification defines inclusion of
the algorithm values defined in and .

The following items remain to be done in this draft:
Since RFC 3447 Section 8 explicitly calls for people NOT to
adopt RSASSA-PKCS1 for new applications and instead requests
that people transition to RSASSA-PSS, we probably need some
Security Considerations text explaining why RSASSA-PKCS1 is
being used (it's what's commonly implemented) and what the
potential consequences are.
Consider having an algorithm that is a MAC using SHA-256
that provides content integrity but for which there is no
associated secret. This would be like the JWT
"alg":"none", in that no validation of the authenticity
content is performed but a checksum is provided.
Consider whether to define "alg":"none" here,
rather than in the JWT spec.
Should we define the use of RFC 5649 key wrapping
functions, which allow arbitrary key sizes, in addition to
the current use of RFC 3394 key wrapping functions, which
require that keys be multiples of 64 bits? Is this needed
in practice?
Decide whether to move the JWK algorithm family
definitions "EC" and "RSA" here. This would likely result
in all the family-specific parameter definitions also
moving here ("crv", "x", "y", "mod", "exp"), leaving very
little normative text in the JWK spec itself. This seems
like it would reduce spec readability and so was not done.
It would be good to say somewhere, in normative language,
that eventually the algorithms and/or key sizes currently
specified will no longer be considered sufficiently secure
and will be removed. Therefore, implementers MUST be
prepared for this eventuality.
Write the Security Considerations section.

Secure Hash Standard (SHS)
National Institute of Standards and
Technology
Digital Signature Standard (DSS)
National Institute of Standards and
Technology
Advanced Encryption Standard (AES)
National Institute of Standards and Technology (NIST)
Recommendation for Block Cipher Modes of Operation
National Institute of Standards and Technology (NIST)
Recommendation for Block Cipher Modes of Operation:
Galois/Counter Mode (GCM) and GMAC
National Institute of Standards and Technology (NIST)
Recommendation for Pair-Wise Key Establishment Schemes Using Discrete Logarithm Cryptography (Revised)
National Institute of Standards and Technology (NIST)
JSON Web Signature (JWS)
Microsoft
mbj@microsoft.com
http://self-issued.info/
independent
ve7jtb@ve7jtb.com
Nomura Research Institute
n-sakimura@nri.co.jp
JSON Web Encryption (JWE)
Microsoft
mbj@microsoft.com
http://self-issued.info/
RTFM, Inc.
ekr@rtfm.com
Cisco Systems, Inc.
jhildebr@cisco.com
Magic Signatures
JSON Simple Sign
independent
Nomura Research Institute
JSON Simple Encryption
independent
Nomura Research Institute
Canvas Applications
Java Cryptography Architecture
This appendix contains a table cross-referencing the
digital signature and HMAC alg (algorithm)
values used in this specification
with the equivalent identifiers used by other standards and
software packages. See XML DSIG
and Java Cryptography Architecture
for more information about the names defined by those
documents.
Algorithm
JWS
XML DSIG
JCA
OID
HMAC using SHA-256 hash algorithm
HS256
http://www.w3.org/2001/04/xmldsig-more#hmac-sha256
HmacSHA256
1.2.840.113549.2.9
HMAC using SHA-384 hash algorithm
HS384
http://www.w3.org/2001/04/xmldsig-more#hmac-sha384
HmacSHA384
1.2.840.113549.2.10
HMAC using SHA-512 hash algorithm
HS512
http://www.w3.org/2001/04/xmldsig-more#hmac-sha512
HmacSHA512
1.2.840.113549.2.11
RSA using SHA-256 hash algorithm
RS256
http://www.w3.org/2001/04/xmldsig-more#rsa-sha256
SHA256withRSA
1.2.840.113549.1.1.11
RSA using SHA-384 hash algorithm
RS384
http://www.w3.org/2001/04/xmldsig-more#rsa-sha384
SHA384withRSA
1.2.840.113549.1.1.12
RSA using SHA-512 hash algorithm
RS512
http://www.w3.org/2001/04/xmldsig-more#rsa-sha512
SHA512withRSA
1.2.840.113549.1.1.13
ECDSA using P-256 curve and SHA-256 hash algorithm
ES256
http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256
SHA256withECDSA
1.2.840.10045.4.3.2
ECDSA using P-384 curve and SHA-384 hash algorithm
ES384
http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha384
SHA384withECDSA
1.2.840.10045.4.3.3
ECDSA using P-521 curve and SHA-512 hash algorithm
ES512
http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha512
SHA512withECDSA
1.2.840.10045.4.3.4
This appendix contains a table cross-referencing the alg (algorithm) and enc (encryption method)
values used in this specification with the equivalent
identifiers used by other standards and software packages.
See
XML Encryption,
XML Encryption 1.1,
and Java Cryptography Architecture for more
information about the names defined by those documents.
Algorithm
JWE
XML ENC
JCA
RSA using RSA-PKCS1-1.5 padding
RSA1_5
http://www.w3.org/2001/04/xmlenc#rsa-1_5
RSA/ECB/PKCS1Padding
RSA using Optimal Asymmetric Encryption Padding (OAEP)
RSA-OAEP
http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p
RSA/ECB/OAEPWithSHA-1AndMGF1Padding
Elliptic Curve Diffie-Hellman Ephemeral Static
ECDH-ES
http://www.w3.org/2009/xmlenc11#ECDH-ES
TBD
Advanced Encryption Standard (AES) Key Wrap Algorithm RFC 3394 using 128 bit keys
A128KW
http://www.w3.org/2001/04/xmlenc#kw-aes128
TBD
Advanced Encryption Standard (AES) Key Wrap Algorithm RFC 3394 using 256 bit keys
A256KW
http://www.w3.org/2001/04/xmlenc#kw-aes256
TBD
Advanced Encryption Standard (AES) using 128 bit keys in
Cipher Block Chaining mode
A128CBC
http://www.w3.org/2001/04/xmlenc#aes128-cbc
AES/CBC/PKCS5Padding
Advanced Encryption Standard (AES) using 256 bit keys in
Cipher Block Chaining mode
A256CBC
http://www.w3.org/2001/04/xmlenc#aes256-cbc
AES/CBC/PKCS5Padding
Advanced Encryption Standard (AES) using 128 bit keys in
Galois/Counter Mode
A128GCM
http://www.w3.org/2009/xmlenc11#aes128-gcm
AES/GCM/NoPadding
Advanced Encryption Standard (AES) using 256 bit keys in
Galois/Counter Mode
A256GCM
http://www.w3.org/2009/xmlenc11#aes256-gcm
AES/GCM/NoPadding
Solutions for signing and encrypting JSON content were
previously explored by Magic
Signatures, JSON Simple Sign,
Canvas Applications, JSON Simple Encryption, and JavaScript Message Security
Format, all of which influenced this draft. Dirk
Balfanz, John Bradley, Yaron Y. Goland, John Panzer, Nat
Sakimura, and Paul Tarjan all made significant contributions
to the design of this specification and its related
specifications.
-00
Created the initial IETF draft based upon
draft-jones-json-web-signature-04 and
draft-jones-json-web-encryption-02 with no normative changes.
Changed terminology to no longer call both digital
signatures and HMACs "signatures".