idnits 2.17.1 draft-ietf-oauth-jwt-bcp-05.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- No issues found here. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the IETF Trust and authors Copyright Line does not match the current year -- The document date (April 16, 2019) is 1830 days in the past. Is this intentional? Checking references for intended status: Best Current Practice ---------------------------------------------------------------------------- (See RFCs 3967 and 4897 for information about using normative references to lower-maturity documents in RFCs) ** Downref: Normative reference to an Informational RFC: RFC 6979 Summary: 1 error (**), 0 flaws (~~), 1 warning (==), 1 comment (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 2 OAuth Working Group Y. Sheffer 3 Internet-Draft Intuit 4 Intended status: Best Current Practice D. Hardt 5 Expires: October 18, 2019 6 M. Jones 7 Microsoft 8 April 16, 2019 10 JSON Web Token Best Current Practices 11 draft-ietf-oauth-jwt-bcp-05 13 Abstract 15 JSON Web Tokens, also known as JWTs, are URL-safe JSON-based security 16 tokens that contain a set of claims that can be signed and/or 17 encrypted. JWTs are being widely used and deployed as a simple 18 security token format in numerous protocols and applications, both in 19 the area of digital identity, and in other application areas. The 20 goal of this Best Current Practices document is to provide actionable 21 guidance leading to secure implementation and deployment of JWTs. 23 Status of This Memo 25 This Internet-Draft is submitted in full conformance with the 26 provisions of BCP 78 and BCP 79. 28 Internet-Drafts are working documents of the Internet Engineering 29 Task Force (IETF). Note that other groups may also distribute 30 working documents as Internet-Drafts. The list of current Internet- 31 Drafts is at https://datatracker.ietf.org/drafts/current/. 33 Internet-Drafts are draft documents valid for a maximum of six months 34 and may be updated, replaced, or obsoleted by other documents at any 35 time. It is inappropriate to use Internet-Drafts as reference 36 material or to cite them other than as "work in progress." 38 This Internet-Draft will expire on October 18, 2019. 40 Copyright Notice 42 Copyright (c) 2019 IETF Trust and the persons identified as the 43 document authors. All rights reserved. 45 This document is subject to BCP 78 and the IETF Trust's Legal 46 Provisions Relating to IETF Documents 47 (https://trustee.ietf.org/license-info) in effect on the date of 48 publication of this document. Please review these documents 49 carefully, as they describe your rights and restrictions with respect 50 to this document. Code Components extracted from this document must 51 include Simplified BSD License text as described in Section 4.e of 52 the Trust Legal Provisions and are provided without warranty as 53 described in the Simplified BSD License. 55 Table of Contents 57 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3 58 1.1. Target Audience . . . . . . . . . . . . . . . . . . . . . 4 59 1.2. Conventions used in this document . . . . . . . . . . . . 4 60 2. Threats and Vulnerabilities . . . . . . . . . . . . . . . . . 4 61 2.1. Weak Signatures and Insufficient Signature Validation . . 4 62 2.2. Weak symmetric keys . . . . . . . . . . . . . . . . . . . 5 63 2.3. Multiplicity of JSON encodings . . . . . . . . . . . . . 5 64 2.4. Incorrect Composition of Encryption and Signature . . . . 5 65 2.5. Insecure Use of Elliptic Curve Encryption . . . . . . . . 5 66 2.6. Substitution Attacks . . . . . . . . . . . . . . . . . . 5 67 2.7. Cross-JWT Confusion . . . . . . . . . . . . . . . . . . . 6 68 3. Best Practices . . . . . . . . . . . . . . . . . . . . . . . 6 69 3.1. Perform Algorithm Verification . . . . . . . . . . . . . 6 70 3.2. Use Appropriate Algorithms . . . . . . . . . . . . . . . 6 71 3.3. Validate All Cryptographic Operations . . . . . . . . . . 7 72 3.4. Validate Cryptographic Inputs . . . . . . . . . . . . . . 7 73 3.5. Ensure Cryptographic Keys have Sufficient Entropy . . . . 8 74 3.6. Avoid Length-Dependent Encryption Inputs . . . . . . . . 8 75 3.7. Use UTF-8 . . . . . . . . . . . . . . . . . . . . . . . . 8 76 3.8. Validate Issuer and Subject . . . . . . . . . . . . . . . 8 77 3.9. Use and Validate Audience . . . . . . . . . . . . . . . . 9 78 3.10. Do Not Trust Received Claims . . . . . . . . . . . . . . 9 79 3.11. Use Explicit Typing . . . . . . . . . . . . . . . . . . . 9 80 3.12. Use Mutually Exclusive Validation Rules for Different 81 Kinds of JWTs . . . . . . . . . . . . . . . . . . . . . . 10 82 4. Security Considerations . . . . . . . . . . . . . . . . . . . 11 83 5. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 11 84 6. Acknowledgements . . . . . . . . . . . . . . . . . . . . . . 11 85 7. References . . . . . . . . . . . . . . . . . . . . . . . . . 11 86 7.1. Normative References . . . . . . . . . . . . . . . . . . 11 87 7.2. Informative References . . . . . . . . . . . . . . . . . 12 88 Appendix A. Document History . . . . . . . . . . . . . . . . . . 14 89 A.1. draft-ietf-oauth-jwt-bcp-05 . . . . . . . . . . . . . . . 14 90 A.2. draft-ietf-oauth-jwt-bcp-04 . . . . . . . . . . . . . . . 14 91 A.3. draft-ietf-oauth-jwt-bcp-03 . . . . . . . . . . . . . . . 14 92 A.4. draft-ietf-oauth-jwt-bcp-02 . . . . . . . . . . . . . . . 14 93 A.5. draft-ietf-oauth-jwt-bcp-01 . . . . . . . . . . . . . . . 14 94 A.6. draft-ietf-oauth-jwt-bcp-00 . . . . . . . . . . . . . . . 14 95 A.7. draft-sheffer-oauth-jwt-bcp-01 . . . . . . . . . . . . . 14 96 A.8. draft-sheffer-oauth-jwt-bcp-00 . . . . . . . . . . . . . 14 98 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 14 100 1. Introduction 102 JSON Web Tokens, also known as JWTs [RFC7519], are URL-safe JSON- 103 based security tokens that contain a set of claims that can be signed 104 and/or encrypted. The JWT specification has seen rapid adoption 105 because it encapsulates security-relevant information in one, easy to 106 protect location, and because it is easy to implement using widely- 107 available tools. One application area in which JWTs are commonly 108 used is representing digital identity information, such as OpenID 109 Connect ID Tokens [OpenID.Core] and OAuth 2.0 [RFC6749] access tokens 110 and refresh tokens, the details of which are deployment-specific. 112 Since the JWT specification was published, there have been several 113 widely published attacks on implementations and deployments. Such 114 attacks are the result of under-specified security mechanisms, as 115 well as incomplete implementations and incorrect usage by 116 applications. 118 The goal of this document is to facilitate secure implementation and 119 deployment of JWTs. Many of the recommendations in this document 120 will actually be about implementation and use of the cryptographic 121 mechanisms underlying JWTs that are defined by JSON Web Signature 122 (JWS) [RFC7515], JSON Web Encryption (JWE) [RFC7516], and JSON Web 123 Algorithms (JWA) [RFC7518]. Others will be about use of the JWT 124 claims themselves. 126 These are intended to be minimum recommendations for the use of JWTs 127 in the vast majority of implementation and deployment scenarios. 128 Other specifications that reference this document can have stricter 129 requirements related to one or more aspects of the format, based on 130 their particular circumstances; when that is the case, implementers 131 are advised to adhere to those stricter requirements. Furthermore, 132 this document provides a floor, not a ceiling, so stronger options 133 are always allowed (e.g., depending on differing evaluations of the 134 importance of cryptographic strength vs. computational load). 136 Community knowledge about the strength of various algorithms and 137 feasible attacks can change quickly, and experience shows that a Best 138 Current Practice (BCP) document about security is a point-in-time 139 statement. Readers are advised to seek out any errata or updates 140 that apply to this document. 142 1.1. Target Audience 144 The targets of this document are: 146 - Implementers of JWT libraries (and the JWS and JWE libraries used 147 by them), 149 - Implementers of code that uses such libraries (to the extent that 150 some mechanisms may not be provided by libraries, or until they 151 are), and 153 - Developers of specifications that rely on JWTs, both inside and 154 outside the IETF. 156 1.2. Conventions used in this document 158 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 159 "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and 160 "OPTIONAL" in this document are to be interpreted as described in 161 BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all 162 capitals, as shown here. 164 2. Threats and Vulnerabilities 166 This section lists some known and possible problems with JWT 167 implementations and deployments. Each problem description is 168 followed by references to one or more mitigations to those problems. 170 2.1. Weak Signatures and Insufficient Signature Validation 172 Signed JSON Web Tokens carry an explicit indication of the signing 173 algorithm, in the form of the "alg" header parameter, to facilitate 174 cryptographic agility. This, in conjunction with design flaws in 175 some libraries and applications, have led to several attacks: 177 - The algorithm can be changed to "none" by an attacker, and some 178 libraries would trust this value and "validate" the JWT without 179 checking any signature. 181 - An "RS256" (RSA, 2048 bit) parameter value can be changed into 182 "HS256" (HMAC, SHA-256), and some libraries would try to validate 183 the signature using HMAC-SHA256 and using the RSA public key as 184 the HMAC shared secret. 186 For mitigations, see Section 3.1 and Section 3.2. 188 2.2. Weak symmetric keys 190 In addition, some applications sign tokens using a weak symmetric key 191 and a keyed MAC algorithm such as "HS256". In most cases, these keys 192 are human memorable passwords that are vulnerable to dictionary 193 attacks [Langkemper]. 195 For mitigations, see Section 3.5. 197 2.3. Multiplicity of JSON encodings 199 Previous versions of the JSON format [RFC8259] allowed several 200 different character encodings: UTF-8, UTF-16 and UTF-32. This is not 201 the case anymore, with the latest standard only allowing UTF-8. 202 However older implementations may result in the JWT being 203 misinterpreted by its recipient, and this could be used by a 204 malicious sender to bypass the recipient's validation checks. 206 For mitigations, see Section 3.7. 208 2.4. Incorrect Composition of Encryption and Signature 210 Some libraries that decrypt a JWE-encrypted JWT to obtain a JWS- 211 signed object do not always validate the internal signature. 213 For mitigations, see Section 3.3. 215 2.5. Insecure Use of Elliptic Curve Encryption 217 Per [Sanso], several JOSE libraries fail to validate their inputs 218 correctly when performing elliptic curve key agreement (the "ECDH-ES" 219 algorithm). An attacker that is able to send JWEs of its choosing 220 that use invalid curve points and observe the cleartext outputs 221 resulting from decryption with the invalid curve points can use this 222 vulnerability to recover the recipient's private key. 224 For mitigations, see Section 3.4. 226 2.6. Substitution Attacks 228 There are attacks in which one recipient will have a JWT intended for 229 it and attempt to use it at a different recipient that it was not 230 intended for. If not caught, these attacks can result in the 231 attacker gaining access to resources that it is not entitled to 232 access. For instance, if an OAuth 2.0 [RFC6749] access token is 233 presented to an OAuth 2.0 protected resource that it is intended for, 234 that protected resource might then attempt to gain access to a 235 different protected resource by presenting that same access token to 236 the different protected resource, which the access token is not 237 intended for. 239 For mitigations, see Section 3.8 and Section 3.9. 241 2.7. Cross-JWT Confusion 243 As JWTs are being used by more different protocols in diverse 244 application areas, it becomes increasingly important to prevent cases 245 of JWT tokens that have been issued for one purpose being subverted 246 and used for another. Note that this is a specific type of 247 substitution attack. If the JWT could be used in an application 248 context in which it could be confused with other kinds of JWTs, then 249 mitigations MUST be employed to prevent these substitution attacks. 251 For mitigations, see Section 3.8, Section 3.9, Section 3.11, and 252 Section 3.12. 254 3. Best Practices 256 The best practices listed below should be applied by practitioners to 257 mitigate the threats listed in the preceding section. 259 3.1. Perform Algorithm Verification 261 Libraries MUST enable the caller to specify a supported set of 262 algorithms and MUST NOT use any other algorithms when performing 263 cryptographic operations. The library MUST ensure that the "alg" or 264 "enc" header specifies the same algorithm that is used for the 265 cryptographic operation. Moreover, each key MUST be used with 266 exactly one algorithm, and this MUST be checked when the 267 cryptographic operation is performed. 269 3.2. Use Appropriate Algorithms 271 As Section 5.2 of [RFC7515] says, "it is an application decision 272 which algorithms may be used in a given context. Even if a JWS can 273 be successfully validated, unless the algorithm(s) used in the JWS 274 are acceptable to the application, it SHOULD consider the JWS to be 275 invalid." 277 Therefore, applications MUST only allow the use of cryptographically 278 current algorithms that meet the security requirements of the 279 application. This set will vary over time as new algorithms are 280 introduced and existing algorithms are deprecated due to discovered 281 cryptographic weaknesses. Applications MUST therefore be designed to 282 enable cryptographic agility. 284 That said, if a JWT is cryptographically protected by a transport 285 layer, such as TLS using cryptographically current algorithms, there 286 may be no need to apply another layer of cryptographic protections to 287 the JWT. In such cases, the use of the "none" algorithm can be 288 perfectly acceptable. The "none" algorithm should only be used when 289 the JWT is cryptographically protected by other means. JWTs using 290 "none" are often used in application contexts in which the content is 291 optionally signed; then the URL-safe claims representation and 292 processing can be the same in both the signed and unsigned cases. 293 JWT libraries SHOULD NOT generate JWTs using "none" unless explicitly 294 requested to do by the caller. 296 Applications SHOULD follow these algorithm-specific recommendations: 298 - Avoid all RSA-PKCS1 v1.5 encryption algorithms, preferring RSA- 299 OAEP. 301 - ECDSA signatures require a unique random value for every message 302 that is signed. If even just a few bits of the random value are 303 predictable across multiple messages then the security of the 304 signature scheme may be compromised. In the worst case, the 305 private key may be recoverable by an attacker. To counter these 306 attacks, JWT libraries SHOULD implement ECDSA using the 307 deterministic approach defined in [RFC6979]. This approach is 308 completely compatible with existing ECDSA verifiers and so can be 309 implemented without new algorithm identifiers being required. 311 3.3. Validate All Cryptographic Operations 313 All cryptographic operations used in the JWT MUST be validated and 314 the entire JWT MUST be rejected if any of them fail to validate. 315 This is true not only of JWTs with a single set of Header Parameters 316 but also for Nested JWTs, in which both outer and inner operations 317 MUST be validated using the keys and algorithms supplied by the 318 application. 320 3.4. Validate Cryptographic Inputs 322 Some cryptographic operations, such as Elliptic Curve Diffie-Hellman 323 key agreement ("ECDH-ES") take inputs that may contain invalid 324 values, such as points not on the specified elliptic curve or other 325 invalid points (see e.g. [Valenta], Sec. 7.1). Either the JWS/JWE 326 library itself must validate these inputs before using them or it 327 must use underlying cryptographic libraries that do so (or both!). 329 ECDH-ES ephemeral public key (epk) inputs should be validated 330 according to the recipient's chosen elliptic curve. For the NIST 331 prime-order curves P-256, P-384 and P-521, validation MUST be 332 performed according to Section 5.6.2.3.4 "ECC Partial Public-Key 333 Validation Routine" of NIST Special Publication 800-56A revision 3 334 [nist-sp-800-56a-r3]. Likewise, if the "X25519" or "X448" [RFC8037] 335 algorithms are used, then the security considerations in [RFC8037] 336 apply. 338 3.5. Ensure Cryptographic Keys have Sufficient Entropy 340 The Key Entropy and Random Values advice in Section 10.1 of [RFC7515] 341 and the Password Considerations in Section 8.8 of [RFC7518] MUST be 342 followed. In particular, human-memorizable passwords MUST NOT be 343 directly used as the key to a keyed-MAC algorithm such as "HS256". 344 In particular, passwords should only be used to perform key 345 encryption, rather than content encryption, as described in 346 Section 4.8 of [RFC7518]. Note that even when used for key 347 encryption, password-based encryption is still subject to brute-force 348 attacks. 350 3.6. Avoid Length-Dependent Encryption Inputs 352 Many encryption algorithms leak information about the length of the 353 plaintext, with a varying amount of leakage depending on the 354 algorithm and mode of operation. Sensitive information, such as 355 passwords, SHOULD be padded before being encrypted. It is 356 RECOMMENDED to avoid any compression of data before encryption since 357 such compression often reveals information about the plaintext. See 358 [Kelsey] for general background on compression and encryption, and 359 [Alawatugoda] for a specific example of attacks on HTTP cookies. 361 3.7. Use UTF-8 363 [RFC7515], [RFC7516], and [RFC7519] all specify that UTF-8 be used 364 for encoding and decoding JSON used in Header Parameters and JWT 365 Claims Sets. This is also in line with the latest JSON specification 366 [RFC8259]. Implementations and applications MUST do this, and not 367 use or admit the use of other Unicode encodings for these purposes. 369 3.8. Validate Issuer and Subject 371 When a JWT contains an "iss" (issuer) claim, the application MUST 372 validate that the cryptographic keys used for the cryptographic 373 operations in the JWT belong to the issuer. If they do not, the 374 application MUST reject the JWT. 376 The means of determining the keys owned by an issuer is application- 377 specific. As one example, OpenID Connect [OpenID.Core] issuer values 378 are "https" URLs that reference a JSON metadata document that 379 contains a "jwks_uri" value that is an "https" URL from which the 380 issuer's keys are retrieved as a JWK Set [RFC7517]. This same 381 mechanism is used by [I-D.ietf-oauth-discovery]. Other applications 382 may use different means of binding keys to issuers. 384 Similarly, when the JWT contains a "sub" (subject) claim, the 385 application MUST validate that the subject value corresponds to a 386 valid subject and/or issuer/subject pair at the application. This 387 may include confirming that the issuer is trusted by the application. 388 If the issuer, subject, or the pair are invalid, the application MUST 389 reject the JWT. 391 3.9. Use and Validate Audience 393 If the same issuer can issue JWTs that are intended for use by more 394 than one relying party or application, the JWT MUST contain an "aud" 395 (audience) claim that can be used to determine whether the JWT is 396 being used by an intended party or was substituted by an attacker at 397 an unintended party. Furthermore, the relying party or application 398 MUST validate the audience value and if the audience value is not 399 present or not associated with the recipient, it MUST reject the JWT. 401 3.10. Do Not Trust Received Claims 403 The "kid" (key ID) header is used by the relying application to 404 perform key lookup. Applications should ensure that this does not 405 create SQL or LDAP injection vulnerabilities, by validating and/or 406 sanitizing the received value. 408 Similarly, blindly following a "jku" (JWK set URL) header, which may 409 contain an arbitrary URL, could result in server-side request forgery 410 (SSRF) attacks. Applications should protect against such attacks, 411 e.g., by matching the URL to a whitelist of allowed locations, and 412 ensuring no cookies are sent in the GET request. 414 3.11. Use Explicit Typing 416 Confusion of one kind of JWT for another can be prevented by having 417 all the kinds of JWTs that could otherwise potentially be confused 418 include an explicit JWT type value and include checking the type 419 value in their validation rules. Explicit JWT typing is accomplished 420 by using the "typ" header parameter. For instance, the 421 [I-D.ietf-secevent-token] specification uses the "application/ 422 secevent+jwt" media type to perform explicit typing of Security Event 423 Tokens (SETs). 425 Per the definition of "typ" in Section 4.1.9 of [RFC7515], it is 426 RECOMMENDED that the "application/" prefix be omitted from the "typ" 427 value. Therefore, for example, the "typ" value used to explicitly 428 include a type for a SET SHOULD be "secevent+jwt". When explicit 429 typing is employed for a JWT, it is RECOMMENDED that a media type 430 name of the format "application/example+jwt" be used, where "example" 431 is replaced by the identifier for the specific kind of JWT. 433 When applying explicit typing to a Nested JWT, the "typ" header 434 parameter containing the explicit type value MUST be present in the 435 inner JWT of the Nested JWT (the JWT whose payload is the JWT Claims 436 Set). The same "typ" header parameter value MAY be present in the 437 outer JWT as well, to explicitly type the entire Nested JWT. 439 Note that the use of explicit typing may not achieve disambiguation 440 from existing kinds of JWTs, as the validation rules for existing 441 kinds JWTs often do not use the "typ" header parameter value. 442 Explicit typing is RECOMMENDED for new uses of JWTs. 444 3.12. Use Mutually Exclusive Validation Rules for Different Kinds of 445 JWTs 447 Each application of JWTs defines a profile specifying the required 448 and optional JWT claims and the validation rules associated with 449 them. If more than one kind of JWT can be issued by the same issuer, 450 the validation rules for those JWTs MUST be written such that they 451 are mutually exclusive, rejecting JWTs of the wrong kind. To prevent 452 substitution of JWTs from one context into another, a number of 453 strategies may be employed: 455 - Use explicit typing for different kinds of JWTs. Then the 456 distinct "typ" values can be used to differentiate between the 457 different kinds of JWTs. 459 - Use different sets of required claims or different required claim 460 values. Then the validation rules for one kind of JWT will reject 461 those with different claims or values. 463 - Use different sets of required header parameters or different 464 required header parameter values. Then the validation rules for 465 one kind of JWT will reject those with different header parameters 466 or values. 468 - Use different keys for different kinds of JWTs. Then the keys 469 used to validate one kind of JWT will fail to validate other kinds 470 of JWTs. 472 - Use different "aud" values for different uses of JWTs from the 473 same issuer. Then audience validation will reject JWTs 474 substituted into inappropriate contexts. 476 - Use different issuers for different kinds of JWTs. Then the 477 distinct "iss" values can be used to segregate the different kinds 478 of JWTs. 480 Given the broad diversity of JWT usage and applications, the best 481 combination of types, required claims, values, header parameters, key 482 usages, and issuers to differentiate among different kinds of JWTs 483 will, in general, be application specific. For new JWT applications, 484 the use of explicit typing is RECOMMENDED. 486 4. Security Considerations 488 This entire document is about security considerations when 489 implementing and deploying JSON Web Tokens. 491 5. IANA Considerations 493 This document requires no IANA actions. 495 6. Acknowledgements 497 Thanks to Antonio Sanso for bringing the "ECDH-ES" invalid point 498 attack to the attention of JWE and JWT implementers. Tim McLean 499 published the RSA/HMAC confusion attack. Thanks to Nat Sakimura for 500 advocating the use of explicit typing. Thanks to Neil Madden for his 501 numerous comments, and to Carsten Bormann, Brian Campbell, Brian 502 Carpenter and Eric Rescorla for their reviews. 504 7. References 506 7.1. Normative References 508 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 509 Requirement Levels", BCP 14, RFC 2119, 510 DOI 10.17487/RFC2119, March 1997, 511 . 513 [RFC6979] Pornin, T., "Deterministic Usage of the Digital Signature 514 Algorithm (DSA) and Elliptic Curve Digital Signature 515 Algorithm (ECDSA)", RFC 6979, DOI 10.17487/RFC6979, August 516 2013, . 518 [RFC7515] Jones, M., Bradley, J., and N. Sakimura, "JSON Web 519 Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May 520 2015, . 522 [RFC7516] Jones, M. and J. Hildebrand, "JSON Web Encryption (JWE)", 523 RFC 7516, DOI 10.17487/RFC7516, May 2015, 524 . 526 [RFC7518] Jones, M., "JSON Web Algorithms (JWA)", RFC 7518, 527 DOI 10.17487/RFC7518, May 2015, 528 . 530 [RFC7519] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token 531 (JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015, 532 . 534 [RFC8037] Liusvaara, I., "CFRG Elliptic Curve Diffie-Hellman (ECDH) 535 and Signatures in JSON Object Signing and Encryption 536 (JOSE)", RFC 8037, DOI 10.17487/RFC8037, January 2017, 537 . 539 [RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 540 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, 541 May 2017, . 543 [RFC8259] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data 544 Interchange Format", STD 90, RFC 8259, 545 DOI 10.17487/RFC8259, December 2017, 546 . 548 7.2. Informative References 550 [Alawatugoda] 551 Alawatugoda, J., Stebila, D., and C. Boyd, "Protecting 552 Encrypted Cookies from Compression Side-Channel Attacks", 553 Financial Cryptography and Data Security pp. 86-106, 554 DOI 10.1007/978-3-662-47854-7_6, 2015. 556 [I-D.ietf-oauth-discovery] 557 Jones, M., Sakimura, N., and J. Bradley, "OAuth 2.0 558 Authorization Server Metadata", draft-ietf-oauth- 559 discovery-10 (work in progress), March 2018. 561 [I-D.ietf-secevent-token] 562 Hunt, P., Jones, M., Denniss, W., and M. Ansari, "Security 563 Event Token (SET)", draft-ietf-secevent-token-13 (work in 564 progress), May 2018. 566 [Kelsey] Kelsey, J., "Compression and Information Leakage of 567 Plaintext", Fast Software Encryption pp. 263-276, 568 DOI 10.1007/3-540-45661-9_21, 2002. 570 [Langkemper] 571 Langkemper, S., "Attacking JWT Authentication", September 572 2016, . 575 [nist-sp-800-56a-r3] 576 Barker, E., Chen, L., Keller, S., Roginsky, A., Vassilev, 577 A., and R. Davis, "Recommendation for Pair-Wise Key 578 Establishment Schemes Using Discrete Logarithm 579 Cryptography, Draft NIST Special Publication 800-56A 580 Revision 3", April 2018, 581 . 583 [OpenID.Core] 584 Sakimura, N., Bradley, J., Jones, M., Medeiros, B., and C. 585 Mortimore, "OpenID Connect Core 1.0", November 2014, 586 . 588 [RFC6749] Hardt, D., Ed., "The OAuth 2.0 Authorization Framework", 589 RFC 6749, DOI 10.17487/RFC6749, October 2012, 590 . 592 [RFC7517] Jones, M., "JSON Web Key (JWK)", RFC 7517, 593 DOI 10.17487/RFC7517, May 2015, 594 . 596 [Sanso] Sanso, A., "Critical Vulnerability Uncovered in JSON 597 Encryption", March 2017, 598 . 601 [Valenta] Valenta, L., Sullivan, N., Sanso, A., and N. Heninger, "In 602 search of CurveSwap: Measuring elliptic curve 603 implementations in the wild", March 2018, 604 . 606 Appendix A. Document History 608 [[ to be removed by the RFC editor before publication as an RFC ]] 610 A.1. draft-ietf-oauth-jwt-bcp-05 612 - Genart review comments. 614 A.2. draft-ietf-oauth-jwt-bcp-04 616 - AD review comments. 618 A.3. draft-ietf-oauth-jwt-bcp-03 620 - Acknowledgements. 622 A.4. draft-ietf-oauth-jwt-bcp-02 624 - Implemented WGLC feedback. 626 A.5. draft-ietf-oauth-jwt-bcp-01 628 - Feedback from Brian Campbell. 630 A.6. draft-ietf-oauth-jwt-bcp-00 632 - Initial WG draft. No change from the latest individual version. 634 A.7. draft-sheffer-oauth-jwt-bcp-01 636 - Added explicit typing. 638 A.8. draft-sheffer-oauth-jwt-bcp-00 640 - Initial version. 642 Authors' Addresses 644 Yaron Sheffer 645 Intuit 647 EMail: yaronf.ietf@gmail.com 649 Dick Hardt 651 EMail: dick.hardt@gmail.com 652 Michael B. Jones 653 Microsoft 655 EMail: mbj@microsoft.com 656 URI: http://self-issued.info/