idnits 2.17.1 draft-ietf-oauth-jwt-bcp-06.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 (June 07, 2019) is 1777 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 ** Downref: Normative reference to an Informational RFC: RFC 8017 -- Obsolete informational reference (is this intentional?): RFC 2313 (Obsoleted by RFC 2437) -- Obsolete informational reference (is this intentional?): RFC 7159 (Obsoleted by RFC 8259) Summary: 2 errors (**), 0 flaws (~~), 1 warning (==), 3 comments (--). 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: December 9, 2019 6 M. Jones 7 Microsoft 8 June 07, 2019 10 JSON Web Token Best Current Practices 11 draft-ietf-oauth-jwt-bcp-06 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 December 9, 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. Incorrect Composition of Encryption and Signature . . . . 5 64 2.4. Plaintext Leakage through Analysis of Ciphertext Length . 5 65 2.5. Insecure Use of Elliptic Curve Encryption . . . . . . . . 5 66 2.6. Multiplicity of JSON encodings . . . . . . . . . . . . . 5 67 2.7. Substitution Attacks . . . . . . . . . . . . . . . . . . 6 68 2.8. Cross-JWT Confusion . . . . . . . . . . . . . . . . . . . 6 69 2.9. Indirect Attacks on the Server . . . . . . . . . . . . . 6 70 3. Best Practices . . . . . . . . . . . . . . . . . . . . . . . 6 71 3.1. Perform Algorithm Verification . . . . . . . . . . . . . 7 72 3.2. Use Appropriate Algorithms . . . . . . . . . . . . . . . 7 73 3.3. Validate All Cryptographic Operations . . . . . . . . . . 8 74 3.4. Validate Cryptographic Inputs . . . . . . . . . . . . . . 8 75 3.5. Ensure Cryptographic Keys have Sufficient Entropy . . . . 8 76 3.6. Avoid Length-Dependent Encryption Inputs . . . . . . . . 8 77 3.7. Use UTF-8 . . . . . . . . . . . . . . . . . . . . . . . . 9 78 3.8. Validate Issuer and Subject . . . . . . . . . . . . . . . 9 79 3.9. Use and Validate Audience . . . . . . . . . . . . . . . . 9 80 3.10. Do Not Trust Received Claims . . . . . . . . . . . . . . 9 81 3.11. Use Explicit Typing . . . . . . . . . . . . . . . . . . . 10 82 3.12. Use Mutually Exclusive Validation Rules for Different 83 Kinds of JWTs . . . . . . . . . . . . . . . . . . . . . . 10 84 4. Security Considerations . . . . . . . . . . . . . . . . . . . 11 85 5. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 11 86 6. Acknowledgements . . . . . . . . . . . . . . . . . . . . . . 11 87 7. References . . . . . . . . . . . . . . . . . . . . . . . . . 12 88 7.1. Normative References . . . . . . . . . . . . . . . . . . 12 89 7.2. Informative References . . . . . . . . . . . . . . . . . 13 90 Appendix A. Document History . . . . . . . . . . . . . . . . . . 15 91 A.1. draft-ietf-oauth-jwt-bcp-06 . . . . . . . . . . . . . . . 15 92 A.2. draft-ietf-oauth-jwt-bcp-05 . . . . . . . . . . . . . . . 15 93 A.3. draft-ietf-oauth-jwt-bcp-04 . . . . . . . . . . . . . . . 15 94 A.4. draft-ietf-oauth-jwt-bcp-03 . . . . . . . . . . . . . . . 15 95 A.5. draft-ietf-oauth-jwt-bcp-02 . . . . . . . . . . . . . . . 15 96 A.6. draft-ietf-oauth-jwt-bcp-01 . . . . . . . . . . . . . . . 15 97 A.7. draft-ietf-oauth-jwt-bcp-00 . . . . . . . . . . . . . . . 15 98 A.8. draft-sheffer-oauth-jwt-bcp-01 . . . . . . . . . . . . . 15 99 A.9. draft-sheffer-oauth-jwt-bcp-00 . . . . . . . . . . . . . 15 100 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 15 102 1. Introduction 104 JSON Web Tokens, also known as JWTs [RFC7519], are URL-safe JSON- 105 based security tokens that contain a set of claims that can be signed 106 and/or encrypted. The JWT specification has seen rapid adoption 107 because it encapsulates security-relevant information in one, easy to 108 protect location, and because it is easy to implement using widely- 109 available tools. One application area in which JWTs are commonly 110 used is representing digital identity information, such as OpenID 111 Connect ID Tokens [OpenID.Core] and OAuth 2.0 [RFC6749] access tokens 112 and refresh tokens, the details of which are deployment-specific. 114 Since the JWT specification was published, there have been several 115 widely published attacks on implementations and deployments. Such 116 attacks are the result of under-specified security mechanisms, as 117 well as incomplete implementations and incorrect usage by 118 applications. 120 The goal of this document is to facilitate secure implementation and 121 deployment of JWTs. Many of the recommendations in this document 122 will actually be about implementation and use of the cryptographic 123 mechanisms underlying JWTs that are defined by JSON Web Signature 124 (JWS) [RFC7515], JSON Web Encryption (JWE) [RFC7516], and JSON Web 125 Algorithms (JWA) [RFC7518]. Others will be about use of the JWT 126 claims themselves. 128 These are intended to be minimum recommendations for the use of JWTs 129 in the vast majority of implementation and deployment scenarios. 130 Other specifications that reference this document can have stricter 131 requirements related to one or more aspects of the format, based on 132 their particular circumstances; when that is the case, implementers 133 are advised to adhere to those stricter requirements. Furthermore, 134 this document provides a floor, not a ceiling, so stronger options 135 are always allowed (e.g., depending on differing evaluations of the 136 importance of cryptographic strength vs. computational load). 138 Community knowledge about the strength of various algorithms and 139 feasible attacks can change quickly, and experience shows that a Best 140 Current Practice (BCP) document about security is a point-in-time 141 statement. Readers are advised to seek out any errata or updates 142 that apply to this document. 144 1.1. Target Audience 146 The targets of this document are: 148 - Implementers of JWT libraries (and the JWS and JWE libraries used 149 by them), 151 - Implementers of code that uses such libraries (to the extent that 152 some mechanisms may not be provided by libraries, or until they 153 are), and 155 - Developers of specifications that rely on JWTs, both inside and 156 outside the IETF. 158 1.2. Conventions used in this document 160 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 161 "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and 162 "OPTIONAL" in this document are to be interpreted as described in 163 BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all 164 capitals, as shown here. 166 2. Threats and Vulnerabilities 168 This section lists some known and possible problems with JWT 169 implementations and deployments. Each problem description is 170 followed by references to one or more mitigations to those problems. 172 2.1. Weak Signatures and Insufficient Signature Validation 174 Signed JSON Web Tokens carry an explicit indication of the signing 175 algorithm, in the form of the "alg" header parameter, to facilitate 176 cryptographic agility. This, in conjunction with design flaws in 177 some libraries and applications, have led to several attacks: 179 - The algorithm can be changed to "none" by an attacker, and some 180 libraries would trust this value and "validate" the JWT without 181 checking any signature. 183 - An "RS256" (RSA, 2048 bit) parameter value can be changed into 184 "HS256" (HMAC, SHA-256), and some libraries would try to validate 185 the signature using HMAC-SHA256 and using the RSA public key as 186 the HMAC shared secret (see [McLean] and CVE-2015-9235). 188 For mitigations, see Section 3.1 and Section 3.2. 190 2.2. Weak symmetric keys 192 In addition, some applications sign tokens using a weak symmetric key 193 and a keyed MAC algorithm such as "HS256". In most cases, these keys 194 are human memorable passwords that are vulnerable to dictionary 195 attacks [Langkemper]. 197 For mitigations, see Section 3.5. 199 2.3. Incorrect Composition of Encryption and Signature 201 Some libraries that decrypt a JWE-encrypted JWT to obtain a JWS- 202 signed object do not always validate the internal signature. 204 For mitigations, see Section 3.3. 206 2.4. Plaintext Leakage through Analysis of Ciphertext Length 208 Many encryption algorithms leak information about the length of the 209 plaintext, with a varying amount of leakage depending on the 210 algorithm and mode of operation. This problem is exacerbated when 211 the plaintext is initially compressed, because the length of the 212 compressed plaintext and thus, the ciphertext, depends not only on 213 the length of the original plaintext but also on its content. See 214 [Kelsey] for general background on compression and encryption, and 215 [Alawatugoda] for a specific example of attacks on HTTP cookies. 217 For mitigations, see Section 3.6. 219 2.5. Insecure Use of Elliptic Curve Encryption 221 Per [Sanso], several JOSE libraries fail to validate their inputs 222 correctly when performing elliptic curve key agreement (the "ECDH-ES" 223 algorithm). An attacker that is able to send JWEs of its choosing 224 that use invalid curve points and observe the cleartext outputs 225 resulting from decryption with the invalid curve points can use this 226 vulnerability to recover the recipient's private key. 228 For mitigations, see Section 3.4. 230 2.6. Multiplicity of JSON encodings 232 Previous versions of the JSON format such as the obsoleted [RFC7159] 233 allowed several different character encodings: UTF-8, UTF-16 and UTF- 234 32. This is not the case anymore, with the latest standard [RFC8259] 235 only allowing UTF-8. However older implementations may result in the 236 JWT being misinterpreted by its recipient, and this could be used by 237 a malicious sender to bypass the recipient's validation checks. 239 For mitigations, see Section 3.7. 241 2.7. Substitution Attacks 243 There are attacks in which one recipient will have a JWT intended for 244 it and attempt to use it at a different recipient that it was not 245 intended for. If not caught, these attacks can result in the 246 attacker gaining access to resources that it is not entitled to 247 access. For instance, if an OAuth 2.0 [RFC6749] access token is 248 presented to an OAuth 2.0 protected resource that it is intended for, 249 that protected resource might then attempt to gain access to a 250 different protected resource by presenting that same access token to 251 the different protected resource, which the access token is not 252 intended for. 254 For mitigations, see Section 3.8 and Section 3.9. 256 2.8. Cross-JWT Confusion 258 As JWTs are being used by more different protocols in diverse 259 application areas, it becomes increasingly important to prevent cases 260 of JWT tokens that have been issued for one purpose being subverted 261 and used for another. Note that this is a specific type of 262 substitution attack. If the JWT could be used in an application 263 context in which it could be confused with other kinds of JWTs, then 264 mitigations MUST be employed to prevent these substitution attacks. 266 For mitigations, see Section 3.8, Section 3.9, Section 3.11, and 267 Section 3.12. 269 2.9. Indirect Attacks on the Server 271 Various JWT claims are used by the recipient to perform lookup 272 operations, e.g. database and LDAP searches. Others include URLs 273 that are similarly looked up by the server. Any of these claims can 274 be used by an attacker as vectors for injection attacks or server- 275 side request forgery (SSRF) attacks. 277 For mitigations, see Section 3.10. 279 3. Best Practices 281 The best practices listed below should be applied by practitioners to 282 mitigate the threats listed in the preceding section. 284 3.1. Perform Algorithm Verification 286 Libraries MUST enable the caller to specify a supported set of 287 algorithms and MUST NOT use any other algorithms when performing 288 cryptographic operations. The library MUST ensure that the "alg" or 289 "enc" header specifies the same algorithm that is used for the 290 cryptographic operation. Moreover, each key MUST be used with 291 exactly one algorithm, and this MUST be checked when the 292 cryptographic operation is performed. 294 3.2. Use Appropriate Algorithms 296 As Section 5.2 of [RFC7515] says, "it is an application decision 297 which algorithms may be used in a given context. Even if a JWS can 298 be successfully validated, unless the algorithm(s) used in the JWS 299 are acceptable to the application, it SHOULD consider the JWS to be 300 invalid." 302 Therefore, applications MUST only allow the use of cryptographically 303 current algorithms that meet the security requirements of the 304 application. This set will vary over time as new algorithms are 305 introduced and existing algorithms are deprecated due to discovered 306 cryptographic weaknesses. Applications MUST therefore be designed to 307 enable cryptographic agility. 309 That said, if a JWT is cryptographically protected by a transport 310 layer, such as TLS using cryptographically current algorithms, there 311 may be no need to apply another layer of cryptographic protections to 312 the JWT. In such cases, the use of the "none" algorithm can be 313 perfectly acceptable. The "none" algorithm should only be used when 314 the JWT is cryptographically protected by other means. JWTs using 315 "none" are often used in application contexts in which the content is 316 optionally signed; then the URL-safe claims representation and 317 processing can be the same in both the signed and unsigned cases. 318 JWT libraries SHOULD NOT generate JWTs using "none" unless explicitly 319 requested to do by the caller. 321 Applications SHOULD follow these algorithm-specific recommendations: 323 - Avoid all RSA-PKCS1 v1.5 [RFC2313] encryption algorithms, 324 preferring RSA-OAEP ([RFC8017], Sec. 7.1). 326 - ECDSA signatures [ANSI-X962-2005] require a unique random value 327 for every message that is signed. If even just a few bits of the 328 random value are predictable across multiple messages then the 329 security of the signature scheme may be compromised. In the worst 330 case, the private key may be recoverable by an attacker. To 331 counter these attacks, JWT libraries SHOULD implement ECDSA using 332 the deterministic approach defined in [RFC6979]. This approach is 333 completely compatible with existing ECDSA verifiers and so can be 334 implemented without new algorithm identifiers being required. 336 3.3. Validate All Cryptographic Operations 338 All cryptographic operations used in the JWT MUST be validated and 339 the entire JWT MUST be rejected if any of them fail to validate. 340 This is true not only of JWTs with a single set of Header Parameters 341 but also for Nested JWTs, in which both outer and inner operations 342 MUST be validated using the keys and algorithms supplied by the 343 application. 345 3.4. Validate Cryptographic Inputs 347 Some cryptographic operations, such as Elliptic Curve Diffie-Hellman 348 key agreement ("ECDH-ES") take inputs that may contain invalid 349 values, such as points not on the specified elliptic curve or other 350 invalid points (see e.g. [Valenta], Sec. 7.1). Either the JWS/JWE 351 library itself must validate these inputs before using them or it 352 must use underlying cryptographic libraries that do so (or both!). 354 ECDH-ES ephemeral public key (epk) inputs should be validated 355 according to the recipient's chosen elliptic curve. For the NIST 356 prime-order curves P-256, P-384 and P-521, validation MUST be 357 performed according to Section 5.6.2.3.4 "ECC Partial Public-Key 358 Validation Routine" of NIST Special Publication 800-56A revision 3 359 [nist-sp-800-56a-r3]. Likewise, if the "X25519" or "X448" [RFC8037] 360 algorithms are used, then the security considerations in [RFC8037] 361 apply. 363 3.5. Ensure Cryptographic Keys have Sufficient Entropy 365 The Key Entropy and Random Values advice in Section 10.1 of [RFC7515] 366 and the Password Considerations in Section 8.8 of [RFC7518] MUST be 367 followed. In particular, human-memorizable passwords MUST NOT be 368 directly used as the key to a keyed-MAC algorithm such as "HS256". 369 In particular, passwords should only be used to perform key 370 encryption, rather than content encryption, as described in 371 Section 4.8 of [RFC7518]. Note that even when used for key 372 encryption, password-based encryption is still subject to brute-force 373 attacks. 375 3.6. Avoid Length-Dependent Encryption Inputs 377 It is RECOMMENDED to avoid any compression of data before encryption 378 since such compression often reveals information about the plaintext. 380 3.7. Use UTF-8 382 [RFC7515], [RFC7516], and [RFC7519] all specify that UTF-8 be used 383 for encoding and decoding JSON used in Header Parameters and JWT 384 Claims Sets. This is also in line with the latest JSON specification 385 [RFC8259]. Implementations and applications MUST do this, and not 386 use or admit the use of other Unicode encodings for these purposes. 388 3.8. Validate Issuer and Subject 390 When a JWT contains an "iss" (issuer) claim, the application MUST 391 validate that the cryptographic keys used for the cryptographic 392 operations in the JWT belong to the issuer. If they do not, the 393 application MUST reject the JWT. 395 The means of determining the keys owned by an issuer is application- 396 specific. As one example, OpenID Connect [OpenID.Core] issuer values 397 are "https" URLs that reference a JSON metadata document that 398 contains a "jwks_uri" value that is an "https" URL from which the 399 issuer's keys are retrieved as a JWK Set [RFC7517]. This same 400 mechanism is used by [RFC8414]. Other applications may use different 401 means of binding keys to issuers. 403 Similarly, when the JWT contains a "sub" (subject) claim, the 404 application MUST validate that the subject value corresponds to a 405 valid subject and/or issuer/subject pair at the application. This 406 may include confirming that the issuer is trusted by the application. 407 If the issuer, subject, or the pair are invalid, the application MUST 408 reject the JWT. 410 3.9. Use and Validate Audience 412 If the same issuer can issue JWTs that are intended for use by more 413 than one relying party or application, the JWT MUST contain an "aud" 414 (audience) claim that can be used to determine whether the JWT is 415 being used by an intended party or was substituted by an attacker at 416 an unintended party. Furthermore, the relying party or application 417 MUST validate the audience value and if the audience value is not 418 present or not associated with the recipient, it MUST reject the JWT. 420 3.10. Do Not Trust Received Claims 422 The "kid" (key ID) header is used by the relying application to 423 perform key lookup. Applications should ensure that this does not 424 create SQL or LDAP injection vulnerabilities, by validating and/or 425 sanitizing the received value. 427 Similarly, blindly following a "jku" (JWK set URL) or "x5u" (X.509 428 URL) header, which may contain an arbitrary URL, could result in 429 server-side request forgery (SSRF) attacks. Applications should 430 protect against such attacks, e.g., by matching the URL to a 431 whitelist of allowed locations, and ensuring no cookies are sent in 432 the GET request. 434 3.11. Use Explicit Typing 436 Confusion of one kind of JWT for another can be prevented by having 437 all the kinds of JWTs that could otherwise potentially be confused 438 include an explicit JWT type value and include checking the type 439 value in their validation rules. Explicit JWT typing is accomplished 440 by using the "typ" header parameter. For instance, the [RFC8417] 441 specification uses the "application/secevent+jwt" media type to 442 perform explicit typing of Security Event Tokens (SETs). 444 Per the definition of "typ" in Section 4.1.9 of [RFC7515], it is 445 RECOMMENDED that the "application/" prefix be omitted from the "typ" 446 value. Therefore, for example, the "typ" value used to explicitly 447 include a type for a SET SHOULD be "secevent+jwt". When explicit 448 typing is employed for a JWT, it is RECOMMENDED that a media type 449 name of the format "application/example+jwt" be used, where "example" 450 is replaced by the identifier for the specific kind of JWT. 452 When applying explicit typing to a Nested JWT, the "typ" header 453 parameter containing the explicit type value MUST be present in the 454 inner JWT of the Nested JWT (the JWT whose payload is the JWT Claims 455 Set). The same "typ" header parameter value MAY be present in the 456 outer JWT as well, to explicitly type the entire Nested JWT. 458 Note that the use of explicit typing may not achieve disambiguation 459 from existing kinds of JWTs, as the validation rules for existing 460 kinds JWTs often do not use the "typ" header parameter value. 461 Explicit typing is RECOMMENDED for new uses of JWTs. 463 3.12. Use Mutually Exclusive Validation Rules for Different Kinds of 464 JWTs 466 Each application of JWTs defines a profile specifying the required 467 and optional JWT claims and the validation rules associated with 468 them. If more than one kind of JWT can be issued by the same issuer, 469 the validation rules for those JWTs MUST be written such that they 470 are mutually exclusive, rejecting JWTs of the wrong kind. To prevent 471 substitution of JWTs from one context into another, a number of 472 strategies may be employed: 474 - Use explicit typing for different kinds of JWTs. Then the 475 distinct "typ" values can be used to differentiate between the 476 different kinds of JWTs. 478 - Use different sets of required claims or different required claim 479 values. Then the validation rules for one kind of JWT will reject 480 those with different claims or values. 482 - Use different sets of required header parameters or different 483 required header parameter values. Then the validation rules for 484 one kind of JWT will reject those with different header parameters 485 or values. 487 - Use different keys for different kinds of JWTs. Then the keys 488 used to validate one kind of JWT will fail to validate other kinds 489 of JWTs. 491 - Use different "aud" values for different uses of JWTs from the 492 same issuer. Then audience validation will reject JWTs 493 substituted into inappropriate contexts. 495 - Use different issuers for different kinds of JWTs. Then the 496 distinct "iss" values can be used to segregate the different kinds 497 of JWTs. 499 Given the broad diversity of JWT usage and applications, the best 500 combination of types, required claims, values, header parameters, key 501 usages, and issuers to differentiate among different kinds of JWTs 502 will, in general, be application specific. For new JWT applications, 503 the use of explicit typing is RECOMMENDED. 505 4. Security Considerations 507 This entire document is about security considerations when 508 implementing and deploying JSON Web Tokens. 510 5. IANA Considerations 512 This document requires no IANA actions. 514 6. Acknowledgements 516 Thanks to Antonio Sanso for bringing the "ECDH-ES" invalid point 517 attack to the attention of JWE and JWT implementers. Tim McLean 518 [McLean] published the RSA/HMAC confusion attack. Thanks to Nat 519 Sakimura for advocating the use of explicit typing. Thanks to Neil 520 Madden for his numerous comments, and to Carsten Bormann, Brian 521 Campbell, Brian Carpenter, Roman Danyliw and Eric Rescorla for their 522 reviews. 524 7. References 526 7.1. Normative References 528 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 529 Requirement Levels", BCP 14, RFC 2119, 530 DOI 10.17487/RFC2119, March 1997, 531 . 533 [RFC6979] Pornin, T., "Deterministic Usage of the Digital Signature 534 Algorithm (DSA) and Elliptic Curve Digital Signature 535 Algorithm (ECDSA)", RFC 6979, DOI 10.17487/RFC6979, August 536 2013, . 538 [RFC7515] Jones, M., Bradley, J., and N. Sakimura, "JSON Web 539 Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May 540 2015, . 542 [RFC7516] Jones, M. and J. Hildebrand, "JSON Web Encryption (JWE)", 543 RFC 7516, DOI 10.17487/RFC7516, May 2015, 544 . 546 [RFC7518] Jones, M., "JSON Web Algorithms (JWA)", RFC 7518, 547 DOI 10.17487/RFC7518, May 2015, 548 . 550 [RFC7519] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token 551 (JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015, 552 . 554 [RFC8017] Moriarty, K., Ed., Kaliski, B., Jonsson, J., and A. Rusch, 555 "PKCS #1: RSA Cryptography Specifications Version 2.2", 556 RFC 8017, DOI 10.17487/RFC8017, November 2016, 557 . 559 [RFC8037] Liusvaara, I., "CFRG Elliptic Curve Diffie-Hellman (ECDH) 560 and Signatures in JSON Object Signing and Encryption 561 (JOSE)", RFC 8037, DOI 10.17487/RFC8037, January 2017, 562 . 564 [RFC8174] Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 565 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, 566 May 2017, . 568 [RFC8259] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data 569 Interchange Format", STD 90, RFC 8259, 570 DOI 10.17487/RFC8259, December 2017, 571 . 573 7.2. Informative References 575 [Alawatugoda] 576 Alawatugoda, J., Stebila, D., and C. Boyd, "Protecting 577 Encrypted Cookies from Compression Side-Channel Attacks", 578 Financial Cryptography and Data Security pp. 86-106, 579 DOI 10.1007/978-3-662-47854-7_6, 2015. 581 [ANSI-X962-2005] 582 "American National Standard X9.62: The Elliptic Curve 583 Digital Signature Algorithm (ECDSA)", November 2005. 585 [Kelsey] Kelsey, J., "Compression and Information Leakage of 586 Plaintext", Fast Software Encryption pp. 263-276, 587 DOI 10.1007/3-540-45661-9_21, 2002. 589 [Langkemper] 590 Langkemper, S., "Attacking JWT Authentication", September 591 2016, . 594 [McLean] McLean, T., "Critical vulnerabilities in JSON Web Token 595 libraries", March 2015, . 598 [nist-sp-800-56a-r3] 599 Barker, E., Chen, L., Keller, S., Roginsky, A., Vassilev, 600 A., and R. Davis, "Recommendation for Pair-Wise Key 601 Establishment Schemes Using Discrete Logarithm 602 Cryptography, Draft NIST Special Publication 800-56A 603 Revision 3", April 2018, 604 . 606 [OpenID.Core] 607 Sakimura, N., Bradley, J., Jones, M., Medeiros, B., and C. 608 Mortimore, "OpenID Connect Core 1.0", November 2014, 609 . 611 [RFC2313] Kaliski, B., "PKCS #1: RSA Encryption Version 1.5", 612 RFC 2313, DOI 10.17487/RFC2313, March 1998, 613 . 615 [RFC6749] Hardt, D., Ed., "The OAuth 2.0 Authorization Framework", 616 RFC 6749, DOI 10.17487/RFC6749, October 2012, 617 . 619 [RFC7159] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data 620 Interchange Format", RFC 7159, DOI 10.17487/RFC7159, March 621 2014, . 623 [RFC7517] Jones, M., "JSON Web Key (JWK)", RFC 7517, 624 DOI 10.17487/RFC7517, May 2015, 625 . 627 [RFC8414] Jones, M., Sakimura, N., and J. Bradley, "OAuth 2.0 628 Authorization Server Metadata", RFC 8414, 629 DOI 10.17487/RFC8414, June 2018, 630 . 632 [RFC8417] Hunt, P., Ed., Jones, M., Denniss, W., and M. Ansari, 633 "Security Event Token (SET)", RFC 8417, 634 DOI 10.17487/RFC8417, July 2018, 635 . 637 [Sanso] Sanso, A., "Critical Vulnerability Uncovered in JSON 638 Encryption", March 2017, 639 . 642 [Valenta] Valenta, L., Sullivan, N., Sanso, A., and N. Heninger, "In 643 search of CurveSwap: Measuring elliptic curve 644 implementations in the wild", March 2018, 645 . 647 Appendix A. Document History 649 [[ to be removed by the RFC editor before publication as an RFC ]] 651 A.1. draft-ietf-oauth-jwt-bcp-06 653 - Second AD review. 655 - Removed unworkable recommendation to pad encrypted passwords. 657 A.2. draft-ietf-oauth-jwt-bcp-05 659 - Genart review comments. 661 A.3. draft-ietf-oauth-jwt-bcp-04 663 - AD review comments. 665 A.4. draft-ietf-oauth-jwt-bcp-03 667 - Acknowledgements. 669 A.5. draft-ietf-oauth-jwt-bcp-02 671 - Implemented WGLC feedback. 673 A.6. draft-ietf-oauth-jwt-bcp-01 675 - Feedback from Brian Campbell. 677 A.7. draft-ietf-oauth-jwt-bcp-00 679 - Initial WG draft. No change from the latest individual version. 681 A.8. draft-sheffer-oauth-jwt-bcp-01 683 - Added explicit typing. 685 A.9. draft-sheffer-oauth-jwt-bcp-00 687 - Initial version. 689 Authors' Addresses 691 Yaron Sheffer 692 Intuit 694 EMail: yaronf.ietf@gmail.com 695 Dick Hardt 697 EMail: dick.hardt@gmail.com 699 Michael B. Jones 700 Microsoft 702 EMail: mbj@microsoft.com 703 URI: http://self-issued.info/