{"uuid": "7f34cd3f-adbe-4c54-878c-86a05dec5322", "vulnerability_lookup_origin": "1a89b78e-f703-45f3-bb86-59eb712668bd", "author": "9f56dd64-161d-43a6-b9c3-555944290a09", "vulnerability": "CVE-2015-9235", "type": "seen", "source": "https://gist.github.com/citadelculture/a18214d2c1b20fbdf843e0ff6fea8f9a", "content": "\ufeff\n\n\n\nInternet Engineering Task Force (IETF)                        Y. Sheffer\nRequest for Comments: 8725                                        Intuit\nBCP: 225                                                        D. Hardt\nUpdates: 7519                                                           \nCategory: Best Current Practice                                 M. Jones\nISSN: 2070-1721                                                Microsoft\n                                                           February 2020\n\n\n                 JSON Web Token Best Current Practices\n\nAbstract\n\n   JSON Web Tokens, also known as JWTs, are URL-safe JSON-based security\n   tokens that contain a set of claims that can be signed and/or\n   encrypted.  JWTs are being widely used and deployed as a simple\n   security token format in numerous protocols and applications, both in\n   the area of digital identity and in other application areas.  This\n   Best Current Practices document updates RFC 7519 to provide\n   actionable guidance leading to secure implementation and deployment\n   of JWTs.\n\nStatus of This Memo\n\n   This memo documents an Internet Best Current Practice.\n\n   This document is a product of the Internet Engineering Task Force\n   (IETF).  It represents the consensus of the IETF community.  It has\n   received public review and has been approved for publication by the\n   Internet Engineering Steering Group (IESG).  Further information on\n   BCPs is available in Section 2 of RFC 7841.\n\n   Information about the current status of this document, any errata,\n   and how to provide feedback on it may be obtained at\n   https://www.rfc-editor.org/info/rfc8725.\n\nCopyright Notice\n\n   Copyright (c) 2020 IETF Trust and the persons identified as the\n   document authors.  All rights reserved.\n\n   This document is subject to BCP 78 and the IETF Trust's Legal\n   Provisions Relating to IETF Documents\n   (https://trustee.ietf.org/license-info) in effect on the date of\n   publication of this document.  Please review these documents\n   carefully, as they describe your rights and restrictions with respect\n   to this document.  Code Components extracted from this document must\n   include Simplified BSD License text as described in Section 4.e of\n   the Trust Legal Provisions and are provided without warranty as\n   described in the Simplified BSD License.\n\nTable of Contents\n\n   1.  Introduction\n     1.1.  Target Audience\n     1.2.  Conventions Used in this Document\n   2.  Threats and Vulnerabilities\n     2.1.  Weak Signatures and Insufficient Signature Validation\n     2.2.  Weak Symmetric Keys\n     2.3.  Incorrect Composition of Encryption and Signature\n     2.4.  Plaintext Leakage through Analysis of Ciphertext Length\n     2.5.  Insecure Use of Elliptic Curve Encryption\n     2.6.  Multiplicity of JSON Encodings\n     2.7.  Substitution Attacks\n     2.8.  Cross-JWT Confusion\n     2.9.  Indirect Attacks on the Server\n   3.  Best Practices\n     3.1.  Perform Algorithm Verification\n     3.2.  Use Appropriate Algorithms\n     3.3.  Validate All Cryptographic Operations\n     3.4.  Validate Cryptographic Inputs\n     3.5.  Ensure Cryptographic Keys Have Sufficient Entropy\n     3.6.  Avoid Compression of Encryption Inputs\n     3.7.  Use UTF-8\n     3.8.  Validate Issuer and Subject\n     3.9.  Use and Validate Audience\n     3.10. Do Not Trust Received Claims\n     3.11. Use Explicit Typing\n     3.12. Use Mutually Exclusive Validation Rules for Different Kinds\n            of JWTs\n   4.  Security Considerations\n   5.  IANA Considerations\n   6.  References\n     6.1.  Normative References\n     6.2.  Informative References\n   Acknowledgements\n   Authors' Addresses\n\n1.  Introduction\n\n   JSON Web Tokens, also known as JWTs [RFC7519], are URL-safe JSON-\n   based security tokens that contain a set of claims that can be signed\n   and/or encrypted.  The JWT specification has seen rapid adoption\n   because it encapsulates security-relevant information in one easy-to-\n   protect location, and because it is easy to implement using widely\n   available tools.  One application area in which JWTs are commonly\n   used is representing digital identity information, such as OpenID\n   Connect ID Tokens [OpenID.Core] and OAuth 2.0 [RFC6749] access tokens\n   and refresh tokens, the details of which are deployment-specific.\n\n   Since the JWT specification was published, there have been several\n   widely published attacks on implementations and deployments.  Such\n   attacks are the result of under-specified security mechanisms, as\n   well as incomplete implementations and incorrect usage by\n   applications.\n\n   The goal of this document is to facilitate secure implementation and\n   deployment of JWTs.  Many of the recommendations in this document are\n   about implementation and use of the cryptographic mechanisms\n   underlying JWTs that are defined by JSON Web Signature (JWS)\n   [RFC7515], JSON Web Encryption (JWE) [RFC7516], and JSON Web\n   Algorithms (JWA) [RFC7518].  Others are about use of the JWT claims\n   themselves.\n\n   These are intended to be minimum recommendations for the use of JWTs\n   in the vast majority of implementation and deployment scenarios.\n   Other specifications that reference this document can have stricter\n   requirements related to one or more aspects of the format, based on\n   their particular circumstances; when that is the case, implementers\n   are advised to adhere to those stricter requirements.  Furthermore,\n   this document provides a floor, not a ceiling, so stronger options\n   are always allowed (e.g., depending on differing evaluations of the\n   importance of cryptographic strength vs. computational load).\n\n   Community knowledge about the strength of various algorithms and\n   feasible attacks can change quickly, and experience shows that a Best\n   Current Practice (BCP) document about security is a point-in-time\n   statement.  Readers are advised to seek out any errata or updates\n   that apply to this document.\n\n1.1.  Target Audience\n\n   The intended audiences of this document are:\n\n   *  Implementers of JWT libraries (and the JWS and JWE libraries used\n      by those libraries),\n\n   *  Implementers of code that uses such libraries (to the extent that\n      some mechanisms may not be provided by libraries, or until they\n      are), and\n\n   *  Developers of specifications that rely on JWTs, both inside and\n      outside the IETF.\n\n1.2.  Conventions Used in this Document\n\n   The key words \"MUST\", \"MUST NOT\", \"REQUIRED\", \"SHALL\", \"SHALL NOT\",\n   \"SHOULD\", \"SHOULD NOT\", \"RECOMMENDED\", \"NOT RECOMMENDED\", \"MAY\", and\n   \"OPTIONAL\" in this document are to be interpreted as described in\n   BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all\n   capitals, as shown here.\n\n2.  Threats and Vulnerabilities\n\n   This section lists some known and possible problems with JWT\n   implementations and deployments.  Each problem description is\n   followed by references to one or more mitigations to those problems.\n\n2.1.  Weak Signatures and Insufficient Signature Validation\n\n   Signed JSON Web Tokens carry an explicit indication of the signing\n   algorithm, in the form of the \"alg\" Header Parameter, to facilitate\n   cryptographic agility.  This, in conjunction with design flaws in\n   some libraries and applications, has led to several attacks:\n\n   *  The algorithm can be changed to \"none\" by an attacker, and some\n      libraries would trust this value and \"validate\" the JWT without\n      checking any signature.\n\n   *  An \"RS256\" (RSA, 2048 bit) parameter value can be changed into\n      \"HS256\" (HMAC, SHA-256), and some libraries would try to validate\n      the signature using HMAC-SHA256 and using the RSA public key as\n      the HMAC shared secret (see [McLean] and [CVE-2015-9235]).\n\n   For mitigations, see Sections 3.1 and 3.2.\n\n2.2.  Weak Symmetric Keys\n\n   In addition, some applications use a keyed Message Authentication\n   Code (MAC) algorithm, such as \"HS256\", to sign tokens but supply a\n   weak symmetric key with insufficient entropy (such as a human-\n   memorable password).  Such keys are vulnerable to offline brute-force\n   or dictionary attacks once an attacker gets hold of such a token\n   [Langkemper].\n\n   For mitigations, see Section 3.5.\n\n2.3.  Incorrect Composition of Encryption and Signature\n\n   Some libraries that decrypt a JWE-encrypted JWT to obtain a JWS-\n   signed object do not always validate the internal signature.\n\n   For mitigations, see Section 3.3.\n\n2.4.  Plaintext Leakage through Analysis of Ciphertext Length\n\n   Many encryption algorithms leak information about the length of the\n   plaintext, with a varying amount of leakage depending on the\n   algorithm and mode of operation.  This problem is exacerbated when\n   the plaintext is initially compressed, because the length of the\n   compressed plaintext and, thus, the ciphertext depends not only on\n   the length of the original plaintext but also on its content.\n   Compression attacks are particularly powerful when there is attacker-\n   controlled data in the same compression space as secret data, which\n   is the case for some attacks on HTTPS.\n\n   See [Kelsey] for general background on compression and encryption and\n   [Alawatugoda] for a specific example of attacks on HTTP cookies.\n\n   For mitigations, see Section 3.6.\n\n2.5.  Insecure Use of Elliptic Curve Encryption\n\n   Per [Sanso], several Javascript Object Signing and Encryption (JOSE)\n   libraries fail to validate their inputs correctly when performing\n   elliptic curve key agreement (the \"ECDH-ES\" algorithm).  An attacker\n   that is able to send JWEs of its choosing that use invalid curve\n   points and observe the cleartext outputs resulting from decryption\n   with the invalid curve points can use this vulnerability to recover\n   the recipient's private key.\n\n   For mitigations, see Section 3.4.\n\n2.6.  Multiplicity of JSON Encodings\n\n   Previous versions of the JSON format, such as the obsoleted\n   [RFC7159], allowed several different character encodings: UTF-8, UTF-\n   16, and UTF-32.  This is not the case anymore, with the latest\n   standard [RFC8259] only allowing UTF-8 except for internal use within\n   a \"closed ecosystem\".  This ambiguity, where older implementations\n   and those used within closed environments may generate non-standard\n   encodings, may result in the JWT being misinterpreted by its\n   recipient.  This, in turn, could be used by a malicious sender to\n   bypass the recipient's validation checks.\n\n   For mitigations, see Section 3.7.\n\n2.7.  Substitution Attacks\n\n   There are attacks in which one recipient will be given a JWT that was\n   intended for it and will attempt to use it at a different recipient\n   for which that JWT was not intended.  For instance, if an OAuth 2.0\n   [RFC6749] access token is legitimately presented to an OAuth 2.0\n   protected resource for which it is intended, that protected resource\n   might then present that same access token to a different protected\n   resource for which the access token is not intended, in an attempt to\n   gain access.  If such situations are not caught, this can result in\n   the attacker gaining access to resources that it is not entitled to\n   access.\n\n   For mitigations, see Sections 3.8 and 3.9.\n\n2.8.  Cross-JWT Confusion\n\n   As JWTs are being used by more different protocols in diverse\n   application areas, it becomes increasingly important to prevent cases\n   of JWT tokens that have been issued for one purpose being subverted\n   and used for another.  Note that this is a specific type of\n   substitution attack.  If the JWT could be used in an application\n   context in which it could be confused with other kinds of JWTs, then\n   mitigations MUST be employed to prevent these substitution attacks.\n\n   For mitigations, see Sections 3.8, 3.9, 3.11, and 3.12.\n\n2.9.  Indirect Attacks on the Server\n\n   Various JWT claims are used by the recipient to perform lookup\n   operations, such as database and Lightweight Directory Access\n   Protocol (LDAP) searches.  Others include URLs that are similarly\n   looked up by the server.  Any of these claims can be used by an\n   attacker as vectors for injection attacks or server-side request\n   forgery (SSRF) attacks.\n\n   For mitigations, see Section 3.10.\n\n3.  Best Practices\n\n   The best practices listed below should be applied by practitioners to\n   mitigate the threats listed in the preceding section.\n\n3.1.  Perform Algorithm Verification\n\n   Libraries MUST enable the caller to specify a supported set of\n   algorithms and MUST NOT use any other algorithms when performing\n   cryptographic operations.  The library MUST ensure that the \"alg\" or\n   \"enc\" header specifies the same algorithm that is used for the\n   cryptographic operation.  Moreover, each key MUST be used with\n   exactly one algorithm, and this MUST be checked when the\n   cryptographic operation is performed.\n\n3.2.  Use Appropriate Algorithms\n\n   As Section 5.2 of [RFC7515] says, \"it is an application decision\n   which algorithms may be used in a given context.  Even if a JWS can\n   be successfully validated, unless the algorithm(s) used in the JWS\n   are acceptable to the application, it SHOULD consider the JWS to be\n   invalid.\"\n\n   Therefore, applications MUST only allow the use of cryptographically\n   current algorithms that meet the security requirements of the\n   application.  This set will vary over time as new algorithms are\n   introduced and existing algorithms are deprecated due to discovered\n   cryptographic weaknesses.  Applications MUST therefore be designed to\n   enable cryptographic agility.\n\n   That said, if a JWT is cryptographically protected end-to-end by a\n   transport layer, such as TLS using cryptographically current\n   algorithms, there may be no need to apply another layer of\n   cryptographic protections to the JWT.  In such cases, the use of the\n   \"none\" algorithm can be perfectly acceptable.  The \"none\" algorithm\n   should only be used when the JWT is cryptographically protected by\n   other means.  JWTs using \"none\" are often used in application\n   contexts in which the content is optionally signed; then, the URL-\n   safe claims representation and processing can be the same in both the\n   signed and unsigned cases.  JWT libraries SHOULD NOT generate JWTs\n   using \"none\" unless explicitly requested to do so by the caller.\n   Similarly, JWT libraries SHOULD NOT consume JWTs using \"none\" unless\n   explicitly requested by the caller.\n\n   Applications SHOULD follow these algorithm-specific recommendations:\n\n   *  Avoid all RSA-PKCS1 v1.5 encryption algorithms ([RFC8017],\n      Section 7.2), preferring RSAES-OAEP ([RFC8017], Section 7.1).\n\n   *  Elliptic Curve Digital Signature Algorithm (ECDSA) signatures\n      [ANSI-X962-2005] require a unique random value for every message\n      that is signed.  If even just a few bits of the random value are\n      predictable across multiple messages, then the security of the\n      signature scheme may be compromised.  In the worst case, the\n      private key may be recoverable by an attacker.  To counter these\n      attacks, JWT libraries SHOULD implement ECDSA using the\n      deterministic approach defined in [RFC6979].  This approach is\n      completely compatible with existing ECDSA verifiers and so can be\n      implemented without new algorithm identifiers being required.\n\n3.3.  Validate All Cryptographic Operations\n\n   All cryptographic operations used in the JWT MUST be validated and\n   the entire JWT MUST be rejected if any of them fail to validate.\n   This is true not only of JWTs with a single set of Header Parameters\n   but also for Nested JWTs in which both outer and inner operations\n   MUST be validated using the keys and algorithms supplied by the\n   application.\n\n3.4.  Validate Cryptographic Inputs\n\n   Some cryptographic operations, such as Elliptic Curve Diffie-Hellman\n   key agreement (\"ECDH-ES\"), take inputs that may contain invalid\n   values.  This includes points not on the specified elliptic curve or\n   other invalid points (e.g., [Valenta], Section 7.1).  The JWS/JWE\n   library itself must validate these inputs before using them, or it\n   must use underlying cryptographic libraries that do so (or both!).\n\n   Elliptic Curve Diffie-Hellman Ephemeral Static (ECDH-ES) ephemeral\n   public key (epk) inputs should be validated according to the\n   recipient's chosen elliptic curve.  For the NIST prime-order curves\n   P-256, P-384, and P-521, validation MUST be performed according to\n   Section 5.6.2.3.4 (ECC Partial Public-Key Validation Routine) of\n   \"Recommendation for Pair-Wise Key-Establishment Schemes Using\n   Discrete Logarithm Cryptography\" [nist-sp-800-56a-r3].  If the\n   \"X25519\" or \"X448\" [RFC8037] algorithms are used, then the security\n   considerations in [RFC8037] apply.\n\n3.5.  Ensure Cryptographic Keys Have Sufficient Entropy\n\n   The Key Entropy and Random Values advice in Section 10.1 of [RFC7515]\n   and the Password Considerations in Section 8.8 of [RFC7518] MUST be\n   followed.  In particular, human-memorizable passwords MUST NOT be\n   directly used as the key to a keyed-MAC algorithm such as \"HS256\".\n   Moreover, passwords should only be used to perform key encryption,\n   rather than content encryption, as described in Section 4.8 of\n   [RFC7518].  Note that even when used for key encryption, password-\n   based encryption is still subject to brute-force attacks.\n\n3.6.  Avoid Compression of Encryption Inputs\n\n   Compression of data SHOULD NOT be done before encryption, because\n   such compressed data often reveals information about the plaintext.\n\n3.7.  Use UTF-8\n\n   [RFC7515], [RFC7516], and [RFC7519] all specify that UTF-8 be used\n   for encoding and decoding JSON used in Header Parameters and JWT\n   Claims Sets.  This is also in line with the latest JSON specification\n   [RFC8259].  Implementations and applications MUST do this and not use\n   or admit the use of other Unicode encodings for these purposes.\n\n3.8.  Validate Issuer and Subject\n\n   When a JWT contains an \"iss\" (issuer) claim, the application MUST\n   validate that the cryptographic keys used for the cryptographic\n   operations in the JWT belong to the issuer.  If they do not, the\n   application MUST reject the JWT.\n\n   The means of determining the keys owned by an issuer is application-\n   specific.  As one example, OpenID Connect [OpenID.Core] issuer values\n   are \"https\" URLs that reference a JSON metadata document that\n   contains a \"jwks_uri\" value that is an \"https\" URL from which the\n   issuer's keys are retrieved as a JWK Set [RFC7517].  This same\n   mechanism is used by [RFC8414].  Other applications may use different\n   means of binding keys to issuers.\n\n   Similarly, when the JWT contains a \"sub\" (subject) claim, the\n   application MUST validate that the subject value corresponds to a\n   valid subject and/or issuer-subject pair at the application.  This\n   may include confirming that the issuer is trusted by the application.\n   If the issuer, subject, or the pair are invalid, the application MUST\n   reject the JWT.\n\n3.9.  Use and Validate Audience\n\n   If the same issuer can issue JWTs that are intended for use by more\n   than one relying party or application, the JWT MUST contain an \"aud\"\n   (audience) claim that can be used to determine whether the JWT is\n   being used by an intended party or was substituted by an attacker at\n   an unintended party.\n\n   In such cases, the relying party or application MUST validate the\n   audience value, and if the audience value is not present or not\n   associated with the recipient, it MUST reject the JWT.\n\n3.10.  Do Not Trust Received Claims\n\n   The \"kid\" (key ID) header is used by the relying application to\n   perform key lookup.  Applications should ensure that this does not\n   create SQL or LDAP injection vulnerabilities by validating and/or\n   sanitizing the received value.\n\n   Similarly, blindly following a \"jku\" (JWK set URL) or \"x5u\" (X.509\n   URL) header, which may contain an arbitrary URL, could result in\n   server-side request forgery (SSRF) attacks.  Applications SHOULD\n   protect against such attacks, e.g., by matching the URL to a\n   whitelist of allowed locations and ensuring no cookies are sent in\n   the GET request.\n\n3.11.  Use Explicit Typing\n\n   Sometimes, one kind of JWT can be confused for another.  If a\n   particular kind of JWT is subject to such confusion, that JWT can\n   include an explicit JWT type value, and the validation rules can\n   specify checking the type.  This mechanism can prevent such\n   confusion.  Explicit JWT typing is accomplished by using the \"typ\"\n   Header Parameter.  For instance, the [RFC8417] specification uses the\n   \"application/secevent+jwt\" media type to perform explicit typing of\n   Security Event Tokens (SETs).\n\n   Per the definition of \"typ\" in Section 4.1.9 of [RFC7515], it is\n   RECOMMENDED that the \"application/\" prefix be omitted from the \"typ\"\n   value.  Therefore, for example, the \"typ\" value used to explicitly\n   include a type for a SET SHOULD be \"secevent+jwt\".  When explicit\n   typing is employed for a JWT, it is RECOMMENDED that a media type\n   name of the format \"application/example+jwt\" be used, where \"example\"\n   is replaced by the identifier for the specific kind of JWT.\n\n   When applying explicit typing to a Nested JWT, the \"typ\" Header\n   Parameter containing the explicit type value MUST be present in the\n   inner JWT of the Nested JWT (the JWT whose payload is the JWT Claims\n   Set).  In some cases, the same \"typ\" Header Parameter value will be\n   present in the outer JWT as well, to explicitly type the entire\n   Nested JWT.\n\n   Note that the use of explicit typing may not achieve disambiguation\n   from existing kinds of JWTs, as the validation rules for existing\n   kinds of JWTs often do not use the \"typ\" Header Parameter value.\n   Explicit typing is RECOMMENDED for new uses of JWTs.\n\n3.12.  Use Mutually Exclusive Validation Rules for Different Kinds of\n       JWTs\n\n   Each application of JWTs defines a profile specifying the required\n   and optional JWT claims and the validation rules associated with\n   them.  If more than one kind of JWT can be issued by the same issuer,\n   the validation rules for those JWTs MUST be written such that they\n   are mutually exclusive, rejecting JWTs of the wrong kind.  To prevent\n   substitution of JWTs from one context into another, application\n   developers may employ a number of strategies:\n\n   *  Use explicit typing for different kinds of JWTs.  Then the\n      distinct \"typ\" values can be used to differentiate between the\n      different kinds of JWTs.\n\n   *  Use different sets of required claims or different required claim\n      values.  Then the validation rules for one kind of JWT will reject\n      those with different claims or values.\n\n   *  Use different sets of required Header Parameters or different\n      required Header Parameter values.  Then the validation rules for\n      one kind of JWT will reject those with different Header Parameters\n      or values.\n\n   *  Use different keys for different kinds of JWTs.  Then the keys\n      used to validate one kind of JWT will fail to validate other kinds\n      of JWTs.\n\n   *  Use different \"aud\" values for different uses of JWTs from the\n      same issuer.  Then audience validation will reject JWTs\n      substituted into inappropriate contexts.\n\n   *  Use different issuers for different kinds of JWTs.  Then the\n      distinct \"iss\" values can be used to segregate the different kinds\n      of JWTs.\n\n   Given the broad diversity of JWT usage and applications, the best\n   combination of types, required claims, values, Header Parameters, key\n   usages, and issuers to differentiate among different kinds of JWTs\n   will, in general, be application-specific.  As discussed in\n   Section 3.11, for new JWT applications, the use of explicit typing is\n   RECOMMENDED.\n\n4.  Security Considerations\n\n   This entire document is about security considerations when\n   implementing and deploying JSON Web Tokens.\n\n5.  IANA Considerations\n\n   This document has no IANA actions.\n\n6.  References\n\n6.1.  Normative References\n\n   [nist-sp-800-56a-r3]\n              Barker, E., Chen, L., Roginsky, A., Vassilev, A., and R.\n              Davis, \"Recommendation for Pair-Wise Key-Establishment\n              Schemes Using Discrete Logarithm Cryptography\", NIST\n              Special Publication 800-56A Revision 3,\n              DOI 10.6028/NIST.SP.800-56Ar3, April 2018,\n              .\n\n   [RFC2119]  Bradner, S., \"Key words for use in RFCs to Indicate\n              Requirement Levels\", BCP 14, RFC 2119,\n              DOI 10.17487/RFC2119, March 1997,\n              .\n\n   [RFC6979]  Pornin, T., \"Deterministic Usage of the Digital Signature\n              Algorithm (DSA) and Elliptic Curve Digital Signature\n              Algorithm (ECDSA)\", RFC 6979, DOI 10.17487/RFC6979, August\n              2013, .\n\n   [RFC7515]  Jones, M., Bradley, J., and N. Sakimura, \"JSON Web\n              Signature (JWS)\", RFC 7515, DOI 10.17487/RFC7515, May\n              2015, .\n\n   [RFC7516]  Jones, M. and J. Hildebrand, \"JSON Web Encryption (JWE)\",\n              RFC 7516, DOI 10.17487/RFC7516, May 2015,\n              .\n\n   [RFC7518]  Jones, M., \"JSON Web Algorithms (JWA)\", RFC 7518,\n              DOI 10.17487/RFC7518, May 2015,\n              .\n\n   [RFC7519]  Jones, M., Bradley, J., and N. Sakimura, \"JSON Web Token\n              (JWT)\", RFC 7519, DOI 10.17487/RFC7519, May 2015,\n              .\n\n   [RFC8017]  Moriarty, K., Ed., Kaliski, B., Jonsson, J., and A. Rusch,\n              \"PKCS #1: RSA Cryptography Specifications Version 2.2\",\n              RFC 8017, DOI 10.17487/RFC8017, November 2016,\n              .\n\n   [RFC8037]  Liusvaara, I., \"CFRG Elliptic Curve Diffie-Hellman (ECDH)\n              and Signatures in JSON Object Signing and Encryption\n              (JOSE)\", RFC 8037, DOI 10.17487/RFC8037, January 2017,\n              .\n\n   [RFC8174]  Leiba, B., \"Ambiguity of Uppercase vs Lowercase in RFC\n              2119 Key Words\", BCP 14, RFC 8174, DOI 10.17487/RFC8174,\n              May 2017, .\n\n   [RFC8259]  Bray, T., Ed., \"The JavaScript Object Notation (JSON) Data\n              Interchange Format\", STD 90, RFC 8259,\n              DOI 10.17487/RFC8259, December 2017,\n              .\n\n6.2.  Informative References\n\n   [Alawatugoda]\n              Alawatugoda, J., Stebila, D., and C. Boyd, \"Protecting\n              Encrypted Cookies from Compression Side-Channel Attacks\",\n              Financial Cryptography and Data Security, pp. 86-106,\n              DOI 10.1007/978-3-662-47854-7_6, July 2015,\n              .\n\n   [ANSI-X962-2005]\n              American National Standards Institute, \"Public Key\n              Cryptography for the Financial Services Industry: the\n              Elliptic Curve Digital Signature Algorithm (ECDSA)\",\n              ANSI X9.62-2005, November 2005.\n\n   [CVE-2015-9235]\n              NIST, \"CVE-2015-9235 Detail\", National Vulnerability\n              Database, May 2018,\n              .\n\n   [Kelsey]   Kelsey, J., \"Compression and Information Leakage of\n              Plaintext\", Fast Software Encryption, pp. 263-276,\n              DOI 10.1007/3-540-45661-9_21, July 2002,\n              .\n\n   [Langkemper]\n              Langkemper, S., \"Attacking JWT authentication\", September\n              2016, .\n\n   [McLean]   McLean, T., \"Critical vulnerabilities in JSON Web Token\n              libraries\", March 2015, .\n\n   [OpenID.Core]\n              Sakimura, N., Bradley, J., Jones, M., de Medeiros, B., and\n              C. Mortimore, \"OpenID Connect Core 1.0 incorporating\n              errata set 1\", November 2014,\n              .\n\n   [RFC6749]  Hardt, D., Ed., \"The OAuth 2.0 Authorization Framework\",\n              RFC 6749, DOI 10.17487/RFC6749, October 2012,\n              .\n\n   [RFC7159]  Bray, T., Ed., \"The JavaScript Object Notation (JSON) Data\n              Interchange Format\", RFC 7159, DOI 10.17487/RFC7159, March\n              2014, .\n\n   [RFC7517]  Jones, M., \"JSON Web Key (JWK)\", RFC 7517,\n              DOI 10.17487/RFC7517, May 2015,\n              .\n\n   [RFC8414]  Jones, M., Sakimura, N., and J. Bradley, \"OAuth 2.0\n              Authorization Server Metadata\", RFC 8414,\n              DOI 10.17487/RFC8414, June 2018,\n              .\n\n   [RFC8417]  Hunt, P., Ed., Jones, M., Denniss, W., and M. Ansari,\n              \"Security Event Token (SET)\", RFC 8417,\n              DOI 10.17487/RFC8417, July 2018,\n              .\n\n   [Sanso]    Sanso, A., \"Critical Vulnerability Uncovered in JSON\n              Encryption\", March 2017,\n              .\n\n   [Valenta]  Valenta, L., Sullivan, N., Sanso, A., and N. Heninger, \"In\n              search of CurveSwap: Measuring elliptic curve\n              implementations in the wild\", March 2018,\n              .\n\nAcknowledgements\n\n   Thanks to Antonio Sanso for bringing the \"ECDH-ES\" invalid point\n   attack to the attention of JWE and JWT implementers.  Tim McLean\n   published the RSA/HMAC confusion attack [McLean].  Thanks to Nat\n   Sakimura for advocating the use of explicit typing.  Thanks to Neil\n   Madden for his numerous comments, and to Carsten Bormann, Brian\n   Campbell, Brian Carpenter, Alissa Cooper, Roman Danyliw, Ben Kaduk,\n   Mirja K\u00fchlewind, Barry Leiba, Eric Rescorla, Adam Roach, Martin\n   Vigoureux, and \u00c9ric Vyncke for their reviews.\n\nAuthors' Addresses\n\n   Yaron Sheffer\n   Intuit\n\n   Email: yaronf.ietf@gmail.com\n\n\n   Dick Hardt\n\n   Email: dick.hardt@gmail.com\n\n\n   Michael B. Jones\n   Microsoft\n\n   Email: mbj@microsoft.com\n   URI:   https://self-issued.info/\n", "creation_timestamp": "2026-10-07T09:02:36.000000Z"}