idnits 2.17.1 draft-ietf-oauth-jwsreq-17.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 (October 21, 2018) is 2007 days in the past. Is this intentional? Checking references for intended status: Proposed Standard ---------------------------------------------------------------------------- (See RFCs 3967 and 4897 for information about using normative references to lower-maturity documents in RFCs) ** Obsolete normative reference: RFC 7525 (ref. 'BCP195') (Obsoleted by RFC 9325) ** Obsolete normative reference: RFC 6125 (Obsoleted by RFC 9525) ** Downref: Normative reference to an Informational RFC: RFC 6819 ** Downref: Normative reference to an Informational RFC: RFC 6973 ** Obsolete normative reference: RFC 7159 (Obsoleted by RFC 8259) ** Obsolete normative reference: RFC 7230 (Obsoleted by RFC 9110, RFC 9112) Summary: 6 errors (**), 0 flaws (~~), 1 warning (==), 1 comment (--). Run idnits with the --verbose option for more detailed information about the items above. -------------------------------------------------------------------------------- 2 OAuth Working Group N. Sakimura 3 Internet-Draft Nomura Research Institute 4 Intended status: Standards Track J. Bradley 5 Expires: April 24, 2019 Yubico 6 October 21, 2018 8 The OAuth 2.0 Authorization Framework: JWT Secured Authorization Request 9 (JAR) 10 draft-ietf-oauth-jwsreq-17 12 Abstract 14 The authorization request in OAuth 2.0 described in RFC 6749 utilizes 15 query parameter serialization, which means that Authorization Request 16 parameters are encoded in the URI of the request and sent through 17 user agents such as web browsers. While it is easy to implement, it 18 means that (a) the communication through the user agents are not 19 integrity protected and thus the parameters can be tainted, and (b) 20 the source of the communication is not authenticated. Because of 21 these weaknesses, several attacks to the protocol have now been put 22 forward. 24 This document introduces the ability to send request parameters in a 25 JSON Web Token (JWT) instead, which allows the request to be signed 26 with JSON Web Signature (JWS) and encrypted with JSON Web Encryption 27 (JWE) so that the integrity, source authentication and 28 confidentiality property of the Authorization Request is attained. 29 The request can be sent by value or by reference. 31 Status of This Memo 33 This Internet-Draft is submitted in full conformance with the 34 provisions of BCP 78 and BCP 79. 36 Internet-Drafts are working documents of the Internet Engineering 37 Task Force (IETF). Note that other groups may also distribute 38 working documents as Internet-Drafts. The list of current Internet- 39 Drafts is at https://datatracker.ietf.org/drafts/current/. 41 Internet-Drafts are draft documents valid for a maximum of six months 42 and may be updated, replaced, or obsoleted by other documents at any 43 time. It is inappropriate to use Internet-Drafts as reference 44 material or to cite them other than as "work in progress." 46 This Internet-Draft will expire on April 24, 2019. 48 Copyright Notice 50 Copyright (c) 2018 IETF Trust and the persons identified as the 51 document authors. All rights reserved. 53 This document is subject to BCP 78 and the IETF Trust's Legal 54 Provisions Relating to IETF Documents 55 (https://trustee.ietf.org/license-info) in effect on the date of 56 publication of this document. Please review these documents 57 carefully, as they describe your rights and restrictions with respect 58 to this document. Code Components extracted from this document must 59 include Simplified BSD License text as described in Section 4.e of 60 the Trust Legal Provisions and are provided without warranty as 61 described in the Simplified BSD License. 63 Table of Contents 65 1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3 66 1.1. Requirements Language . . . . . . . . . . . . . . . . . . 5 67 2. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 5 68 2.1. Request Object . . . . . . . . . . . . . . . . . . . . . 5 69 2.2. Request Object URI . . . . . . . . . . . . . . . . . . . 6 70 3. Symbols and abbreviated terms . . . . . . . . . . . . . . . . 6 71 4. Request Object . . . . . . . . . . . . . . . . . . . . . . . 6 72 5. Authorization Request . . . . . . . . . . . . . . . . . . . . 8 73 5.1. Passing a Request Object by Value . . . . . . . . . . . . 9 74 5.2. Passing a Request Object by Reference . . . . . . . . . . 9 75 5.2.1. URI Referencing the Request Object . . . . . . . . . 11 76 5.2.2. Request using the "request_uri" Request Parameter . . 11 77 5.2.3. Authorization Server Fetches Request Object . . . . . 11 78 6. Validating JWT-Based Requests . . . . . . . . . . . . . . . . 12 79 6.1. Encrypted Request Object . . . . . . . . . . . . . . . . 12 80 6.2. JWS Signed Request Object . . . . . . . . . . . . . . . . 13 81 6.3. Request Parameter Assembly and Validation . . . . . . . . 13 82 7. Authorization Server Response . . . . . . . . . . . . . . . . 13 83 8. TLS Requirements . . . . . . . . . . . . . . . . . . . . . . 13 84 9. IANA Considerations . . . . . . . . . . . . . . . . . . . . 14 85 10. Security Considerations . . . . . . . . . . . . . . . . . . . 14 86 10.1. Choice of Algorithms . . . . . . . . . . . . . . . . . . 14 87 10.2. Request Source Authentication . . . . . . . . . . . . . 15 88 10.3. Explicit Endpoints . . . . . . . . . . . . . . . . . . . 15 89 10.4. Risks Associated with request_uri . . . . . . . . . . . 16 90 10.4.1. DDoS Attack on the Authorization Server . . . . . . 16 91 10.4.2. Request URI Rewrite . . . . . . . . . . . . . . . . 16 92 11. TLS security considerations . . . . . . . . . . . . . . . . . 17 93 12. Privacy Considerations . . . . . . . . . . . . . . . . . . . 17 94 12.1. Collection limitation . . . . . . . . . . . . . . . . . 17 95 12.2. Disclosure Limitation . . . . . . . . . . . . . . . . . 18 96 12.2.1. Request Disclosure . . . . . . . . . . . . . . . . . 18 97 12.2.2. Tracking using Request Object URI . . . . . . . . . 18 98 13. Acknowledgements . . . . . . . . . . . . . . . . . . . . . . 18 99 14. Revision History . . . . . . . . . . . . . . . . . . . . . . 19 100 15. References . . . . . . . . . . . . . . . . . . . . . . . . . 24 101 15.1. Normative References . . . . . . . . . . . . . . . . . . 24 102 15.2. Informative References . . . . . . . . . . . . . . . . . 26 103 Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 27 105 1. Introduction 107 The Authorization Request in OAuth 2.0 [RFC6749] utilizes query 108 parameter serialization and is typically sent through user agents 109 such as web browsers. 111 For example, the parameters "response_type", "client_id", "state", 112 and "redirect_uri" are encoded in the URI of the request: 114 GET /authorize?response_type=code&client_id=s6BhdRkqt3&state=xyz 115 &redirect_uri=https%3A%2F%2Fclient%2Eexample%2Ecom%2Fcb HTTP/1.1 116 Host: server.example.com 118 While it is easy to implement, the encoding in the URI does not allow 119 application layer security with confidentiality and integrity 120 protection to be used. While TLS is used to offer communication 121 security between the Client and the user-agent as well as the user- 122 agent and the Authorization Server, TLS sessions are terminated in 123 the user-agent. In addition, TLS sessions may be terminated 124 prematurely at some middlebox (such as a load balancer). 126 As the result, the Authorization Request of [RFC6749] has 127 shortcomings in that: 129 (a) the communication through the user agents are not integrity 130 protected and thus the parameters can be tainted (integrity 131 protection failure) 133 (b) the source of the communication is not authenticated (source 134 authentication failure) 136 (c) the communication through the user agents can be monitored 137 (containment / confidentiality failure). 139 Due to these inherent weaknesses, several attacks against the 140 protocol, such as Redirection URI rewriting and Mix-up attack [FETT], 141 have been identified. 143 The use of application layer security mitigates these issues. 145 The use of application layer security allows requests to be prepared 146 by a third party so that a client application cannot request more 147 permissions than previously agreed. This offers an additional degree 148 of privacy protection. 150 Furthermore, the request by reference allows the reduction of over- 151 the-wire overhead. 153 The JWT [RFC7519] encoding has been chosen because of 155 (1) its close relationship with JSON, which is used as OAuth's 156 response format 158 (2) its developer friendliness due to its textual nature 160 (3) its relative compactness compared to XML 162 (4) its development status that it is an RFC and so is its 163 associated signing and encryption methods as [RFC7515] and 164 [RFC7516] 166 (5) the relative ease of JWS and JWE compared to XML Signature and 167 Encryption. 169 The parameters "request" and "request_uri" are introduced as 170 additional authorization request parameters for the OAuth 2.0 171 [RFC6749] flows. The "request" parameter is a JSON Web Token (JWT) 172 [RFC7519] whose JWT Claims Set holds the JSON encoded OAuth 2.0 173 authorization request parameters. This JWT is integrity protected 174 and source authenticated using JWS. 176 The JWT [RFC7519] can be passed to the authorization endpoint by 177 reference, in which case the parameter "request_uri" is used instead 178 of the "request". 180 Using JWT [RFC7519] as the request encoding instead of query 181 parameters has several advantages: 183 (a) (integrity protection) The request can be signed so that the 184 integrity of the request can be checked. 186 (b) (source authentication) The request can be signed so that the 187 signer can be authenticated. 189 (c) (confidentiality protection) The request can be encrypted so 190 that end-to-end confidentiality can be provided even if the TLS 191 connection is terminated at one point or another. 193 (d) (collection minimization) The request can be signed by a third 194 party attesting that the authorization request is compliant with 195 a certain policy. For example, a request can be pre-examined by 196 a third party that all the personal data requested is strictly 197 necessary to perform the process that the end-user asked for, 198 and statically signed by that third party. The authorization 199 server then examines the signature and shows the conformance 200 status to the end-user, who would have some assurance as to the 201 legitimacy of the request when authorizing it. In some cases, 202 it may even be desirable to skip the authorization dialogue 203 under such circumstances. 205 There are a few cases that request by reference is useful such as: 207 1. When it is desirable to reduce the size of transmitted request. 208 The use of application layer security increases the size of the 209 request, particularly when public key cryptography is used. 211 2. When the client does not want to do the crypto. The 212 Authorization Server may provide an endpoint to accept the 213 Authorization Request through direct communication with the 214 Client so that the Client is authenticated and the channel is TLS 215 protected. 217 This capability is in use by OpenID Connect [OpenID.Core]. 219 1.1. Requirements Language 221 The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", 222 "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this 223 document are to be interpreted as described in RFC 2119 [RFC2119]. 225 2. Terminology 227 For the purposes of this specification, the following terms and 228 definitions in addition to what is defined in OAuth 2.0 Framework 229 [RFC6749], JSON Web Signature [RFC7515], and JSON Web Encryption 230 [RFC7519] apply. 232 2.1. Request Object 234 JWT [RFC7519] that holds an OAuth 2.0 authorization request as JWT 235 Claims Set 237 2.2. Request Object URI 239 Absolute URI from which the Request Object (Section 2.1) can be 240 obtained 242 3. Symbols and abbreviated terms 244 The following abbreviations are common to this specification. 246 JSON Javascript Object Notation 248 JWT JSON Web Token 250 JWS JSON Web Signature 252 JWE JSON Web Encryption 254 URI Uniform Resource Identifier 256 URL Uniform Resource Locator 258 4. Request Object 260 A Request Object (Section 2.1) is used to provide authorization 261 request parameters for an OAuth 2.0 authorization request. It MUST 262 contains all the OAuth 2.0 [RFC6749] authorization request parameters 263 including extension parameters. The parameters are represented as 264 the JWT claims. Parameter names and string values MUST be included 265 as JSON strings. Since Request Objects are handled across domains 266 and potentially outside of a closed ecosystem, per section 8.1 of 267 [RFC8259], these JSON strings MUST be encoded using UTF-8 [RFC3629]. 268 Numerical values MUST be included as JSON numbers. It MAY include 269 any extension parameters. This JSON [RFC7159] constitutes the JWT 270 Claims Set defined in JWT [RFC7519]. The JWT Claims Set is then 271 signed or signed and encrypted. 273 To sign, JSON Web Signature (JWS) [RFC7515] is used. The result is a 274 JWS signed JWT [RFC7519]. If signed, the Authorization Request 275 Object SHOULD contain the Claims "iss" (issuer) and "aud" (audience) 276 as members, with their semantics being the same as defined in the JWT 277 [RFC7519] specification. 279 To encrypt, JWE [RFC7516] is used. When both signature and 280 encryption are being applied, the JWT MUST be signed then encrypted 281 as advised in the section 11.2 of [RFC7519]. The result is a Nested 282 JWT, as defined in [RFC7519]. 284 The Authorization Request Object MAY be sent by value as described in 285 Section 5.1 or by reference as described in Section 5.2. 287 "request" and "request_uri" parameters MUST NOT be included in 288 Request Objects. 290 The following is an example of the Claims in a Request Object before 291 base64url encoding and signing. Note that it includes extension 292 variables such as "nonce" and "max_age". 294 { 295 "iss": "s6BhdRkqt3", 296 "aud": "https://server.example.com", 297 "response_type": "code id_token", 298 "client_id": "s6BhdRkqt3", 299 "redirect_uri": "https://client.example.org/cb", 300 "scope": "openid", 301 "state": "af0ifjsldkj", 302 "nonce": "n-0S6_WzA2Mj", 303 "max_age": 86400 304 } 306 Signing it with the "RS256" algorithm results in this Request Object 307 value (with line wraps within values for display purposes only): 309 eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiAiczZCaGRSa3 310 F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmNvbSIsDQogInJl 311 c3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWVudF9pZCI6ICJzNk 312 JoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8vY2xpZW50LmV4YW1w 313 bGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiAic3RhdGUiOiAiYWYwaW 314 Zqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWoiLA0KICJtYXhfYWdlIjog 315 ODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXNlcmluZm8iOiANCiAgICB7DQ 316 ogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgIm5p 317 Y2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjogeyJlc3NlbnRpYWwiOiB0cnVlfS 318 wNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAg 319 ICAgInBpY3R1cmUiOiBudWxsDQogICAgfSwNCiAgICJpZF90b2tlbiI6IA0KICAgIH 320 sNCiAgICAgImdlbmRlciI6IG51bGwsDQogICAgICJiaXJ0aGRhdGUiOiB7ImVzc2Vu 321 dGlhbCI6IHRydWV9LA0KICAgICAiYWNyIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOm 322 luY29tbW9uOmlhcDpzaWx2ZXIiXX0NCiAgICB9DQogIH0NCn0.nwwnNsk1-Zkbmnvs 323 F6zTHm8CHERFMGQPhos-EJcaH4Hh-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyF 324 KzuMXZFSZ3p6Mb8dkxtVyjoy2GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx 325 0GxFbuPbj96tVuj11pTnmFCUR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8K 326 ol-cSLWoYE9l5QqholImzjT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPG 327 iyon_-Te111V8uE83IlzCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 329 The following RSA public key, represented in JWK format, can be used 330 to validate the Request Object signature in this and subsequent 331 Request Object examples (with line wraps within values for display 332 purposes only): 334 { 335 "kty":"RSA", 336 "kid":"k2bdc", 337 "n":"y9Lqv4fCp6Ei-u2-ZCKq83YvbFEk6JMs_pSj76eMkddWRuWX2aBKGHAtKlE5P 338 7_vn__PCKZWePt3vGkB6ePgzAFu08NmKemwE5bQI0e6kIChtt_6KzT5OaaXDF 339 I6qCLJmk51Cc4VYFaxgqevMncYrzaW_50mZ1yGSFIQzLYP8bijAHGVjdEFgZa 340 ZEN9lsn_GdWLaJpHrB3ROlS50E45wxrlg9xMncVb8qDPuXZarvghLL0HzOuYR 341 adBJVoWZowDNTpKpk2RklZ7QaBO7XDv3uR7s_sf2g-bAjSYxYUGsqkNA9b3xV 342 W53am_UZZ3tZbFTIh557JICWKHlWj5uzeJXaw", 343 "e":"AQAB" 344 } 346 5. Authorization Request 348 The client constructs the authorization request URI by adding one of 349 the following parameters but not both to the query component of the 350 authorization endpoint URI using the "application/x-www-form- 351 urlencoded" format: 353 request The Request Object (Section 2.1) that holds authorization 354 request parameters stated in section 4 of OAuth 2.0 [RFC6749]. 356 request_uri The absolute URI as defined by RFC3986 [RFC3986] that 357 points to the Request Object (Section 2.1) that holds 358 authorization request parameters stated in section 4 of OAuth 2.0 359 [RFC6749]. 361 The client directs the resource owner to the constructed URI using an 362 HTTP redirection response, or by other means available to it via the 363 user-agent. 365 For example, the client directs the end user's user-agent to make the 366 following HTTPS request: 368 GET /authz?request=eyJhbG..AlMGzw HTTP/1.1 369 Host: server.example.com 371 The value for the request parameter is abbreviated for brevity. 373 The authorization request object MUST be one of the following: 375 (a) JWS signed 376 (b) JWS signed and JWE encrypted 378 The client MAY send the parameters included in the request object 379 duplicated in the query parameters as well for the backward 380 compatibility etc. However, the authorization server supporting this 381 specification MUST only use the parameters included in the request 382 object. 384 5.1. Passing a Request Object by Value 386 The Client sends the Authorization Request as a Request Object to the 387 Authorization Endpoint as the "request" parameter value. 389 The following is an example of an Authorization Request using the 390 "request" parameter (with line wraps within values for display 391 purposes only): 393 https://server.example.com/authorize? 394 request=eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiA 395 iczZCaGRSa3F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmN 396 vbSIsDQogInJlc3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWV 397 udF9pZCI6ICJzNkJoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8 398 vY2xpZW50LmV4YW1wbGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiA 399 ic3RhdGUiOiAiYWYwaWZqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWo 400 iLA0KICJtYXhfYWdlIjogODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXN 401 lcmluZm8iOiANCiAgICB7DQogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWw 402 iOiB0cnVlfSwNCiAgICAgIm5pY2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjo 403 geyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJ 404 lc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgInBpY3R1cmUiOiBudWxsDQogICAgfSw 405 NCiAgICJpZF90b2tlbiI6IA0KICAgIHsNCiAgICAgImdlbmRlciI6IG51bGwsDQo 406 gICAgICJiaXJ0aGRhdGUiOiB7ImVzc2VudGlhbCI6IHRydWV9LA0KICAgICAiYWN 407 yIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOmluY29tbW9uOmlhcDpzaWx2ZXIiXX0 408 NCiAgICB9DQogIH0NCn0.nwwnNsk1-ZkbmnvsF6zTHm8CHERFMGQPhos-EJcaH4H 409 h-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyFKzuMXZFSZ3p6Mb8dkxtVyjoy2 410 GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx0GxFbuPbj96tVuj11pTnmFC 411 UR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8Kol-cSLWoYE9l5QqholImz 412 jT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPGiyon_-Te111V8uE83Il 413 zCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 415 5.2. Passing a Request Object by Reference 417 The "request_uri" Authorization Request parameter enables OAuth 418 authorization requests to be passed by reference, rather than by 419 value. This parameter is used identically to the "request" 420 parameter, other than that the Request Object value is retrieved from 421 the resource identified by the specified URI rather than passed by 422 value. 424 The entire Request URI MUST NOT exceed 512 ASCII characters. There 425 are three reasons for this restriction. 427 1. Many phones in the market as of this writing still do not accept 428 large payloads. The restriction is typically either 512 or 1024 429 ASCII characters. 431 2. The maximum URL length supported by older versions of Internet 432 Explorer is 2083 ASCII characters. 434 3. On a slow connection such as 2G mobile connection, a large URL 435 would cause the slow response and therefore the use of such is 436 not advisable from the user experience point of view. 438 The contents of the resource referenced by the URI MUST be a Request 439 Object. The "request_uri" value MUST be either URN as defined in 440 RFC8141 [RFC8141] or "https" URI, as defined in 2.7.2 of RFC7230 441 [RFC7230] . The "request_uri" value MUST be reachable by the 442 Authorization Server. 444 The following is an example of the contents of a Request Object 445 resource that can be referenced by a "request_uri" (with line wraps 446 within values for display purposes only): 448 eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiAiczZCaGRSa3 449 F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmNvbSIsDQogInJl 450 c3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWVudF9pZCI6ICJzNk 451 JoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8vY2xpZW50LmV4YW1w 452 bGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiAic3RhdGUiOiAiYWYwaW 453 Zqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWoiLA0KICJtYXhfYWdlIjog 454 ODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXNlcmluZm8iOiANCiAgICB7DQ 455 ogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgIm5p 456 Y2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjogeyJlc3NlbnRpYWwiOiB0cnVlfS 457 wNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAg 458 ICAgInBpY3R1cmUiOiBudWxsDQogICAgfSwNCiAgICJpZF90b2tlbiI6IA0KICAgIH 459 sNCiAgICAgImdlbmRlciI6IG51bGwsDQogICAgICJiaXJ0aGRhdGUiOiB7ImVzc2Vu 460 dGlhbCI6IHRydWV9LA0KICAgICAiYWNyIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOm 461 luY29tbW9uOmlhcDpzaWx2ZXIiXX0NCiAgICB9DQogIH0NCn0.nwwnNsk1-Zkbmnvs 462 F6zTHm8CHERFMGQPhos-EJcaH4Hh-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyF 463 KzuMXZFSZ3p6Mb8dkxtVyjoy2GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx 464 0GxFbuPbj96tVuj11pTnmFCUR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8K 465 ol-cSLWoYE9l5QqholImzjT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPG 466 iyon_-Te111V8uE83IlzCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 468 5.2.1. URI Referencing the Request Object 470 The Client stores the Request Object resource either locally or 471 remotely at a URI the Authorization Server can access. Such facility 472 may be provided by the authorization server or a third party. For 473 example, the authorization server may provide a URL to which the 474 client POSTs the request object and obtains the Requiest URI. This 475 URI is the Request Object URI, "request_uri". 477 It is possible for the Request Object to include values that are to 478 be revealed only to the Authorization Server. As such, the 479 "request_uri" MUST have appropriate entropy for its lifetime. For 480 the guidance, refer to 5.1.4.2.2 of [RFC6819]. It is RECOMMENDED 481 that it be removed after a reasonable timeout unless access control 482 measures are taken. 484 The following is an example of a Request Object URI value (with line 485 wraps within values for display purposes only): 487 https://tfp.example.org/request.jwt# 488 GkurKxf5T0Y-mnPFCHqWOMiZi4VS138cQO_V7PZHAdM 490 5.2.2. Request using the "request_uri" Request Parameter 492 The Client sends the Authorization Request to the Authorization 493 Endpoint. 495 The following is an example of an Authorization Request using the 496 "request_uri" parameter (with line wraps within values for display 497 purposes only): 499 https://server.example.com/authorize? 500 response_type=code%20id_token 501 &client_id=s6BhdRkqt3 502 &request_uri=https%3A%2F%2Ftfp.example.org%2Frequest.jwt 503 %23GkurKxf5T0Y-mnPFCHqWOMiZi4VS138cQO_V7PZHAdM 504 &state=af0ifjsldkj 506 5.2.3. Authorization Server Fetches Request Object 508 Upon receipt of the Request, the Authorization Server MUST send an 509 HTTP "GET" request to the "request_uri" to retrieve the referenced 510 Request Object, unless it is stored in a way so that it can retrieve 511 it through other mechanism securely, and parse it to recreate the 512 Authorization Request parameters. 514 The following is an example of this fetch process: 516 GET /request.jwt HTTP/1.1 517 Host: tfp.example.org 519 The following is an example of the fetch response: 521 HTTP/1.1 200 OK 522 Date: Thu, 16 Feb 2017 23:52:39 GMT 523 Server: Apache/2.2.22 (tfp.example.org) 524 Content-type: application/jwt 525 Content-Length: 1250 526 Last-Modified: Wed, 15 Feb 2017 23:52:32 GMT 528 eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiAiczZCaGRSa3 529 F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmNvbSIsDQogInJl 530 c3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWVudF9pZCI6ICJzNk 531 JoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8vY2xpZW50LmV4YW1w 532 bGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiAic3RhdGUiOiAiYWYwaW 533 Zqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWoiLA0KICJtYXhfYWdlIjog 534 ODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXNlcmluZm8iOiANCiAgICB7DQ 535 ogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgIm5p 536 Y2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjogeyJlc3NlbnRpYWwiOiB0cnVlfS 537 wNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAg 538 ICAgInBpY3R1cmUiOiBudWxsDQogICAgfSwNCiAgICJpZF90b2tlbiI6IA0KICAgIH 539 sNCiAgICAgImdlbmRlciI6IG51bGwsDQogICAgICJiaXJ0aGRhdGUiOiB7ImVzc2Vu 540 dGlhbCI6IHRydWV9LA0KICAgICAiYWNyIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOm 541 luY29tbW9uOmlhcDpzaWx2ZXIiXX0NCiAgICB9DQogIH0NCn0.nwwnNsk1-Zkbmnvs 542 F6zTHm8CHERFMGQPhos-EJcaH4Hh-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyF 543 KzuMXZFSZ3p6Mb8dkxtVyjoy2GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx 544 0GxFbuPbj96tVuj11pTnmFCUR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8K 545 ol-cSLWoYE9l5QqholImzjT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPG 546 iyon_-Te111V8uE83IlzCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 548 6. Validating JWT-Based Requests 550 6.1. Encrypted Request Object 552 If the request object is encrypted, the Authorization Server MUST 553 decrypt the JWT in accordance with the JSON Web Encryption [RFC7516] 554 specification. 556 The result is a signed request object. 558 If decryption fails, the Authorization Server MUST return an 559 "invalid_request_object" error. 561 6.2. JWS Signed Request Object 563 The Authorization Server MUST perform the signature validation of the 564 JSON Web Signature [RFC7515] signed request object. For this, the 565 "alg" Header Parameter in its JOSE Header MUST match the value of the 566 pre-registered algorithm. The signature MUST be validated against 567 the appropriate key for that "client_id" and algorithm. 569 If signature validation fails, the Authorization Server MUST return 570 an "invalid_request_object" error. 572 6.3. Request Parameter Assembly and Validation 574 The Authorization Server MUST extract the set of Authorization 575 Request parameters from the Request Object value. The Authorization 576 Server MUST only use the parameters in the Request Object even if the 577 same parameter is provided in the query parameter. The Authorization 578 Server then validates the request as specified in OAuth 2.0 579 [RFC6749]. 581 If the validation fails, then the Authorization Server MUST return an 582 error as specified in OAuth 2.0 [RFC6749]. 584 7. Authorization Server Response 586 Authorization Server Response is created and sent to the client as in 587 Section 4 of OAuth 2.0 [RFC6749] . 589 In addition, this document uses these additional error values: 591 invalid_request_uri The "request_uri" in the Authorization Request 592 returns an error or contains invalid data. 594 invalid_request_object The request parameter contains an invalid 595 Request Object. 597 request_not_supported The Authorization Server does not support the 598 use of the "request" parameter. 600 request_uri_not_supported The Authorization Server does not support 601 the use of the "request_uri" parameter. 603 8. TLS Requirements 605 Client implementations supporting the Request Object URI method MUST 606 support TLS following Recommendations for Secure Use of Transport 607 Layer Security (TLS) and Datagram Transport Layer Security (DTLS) 608 [BCP195]. 610 To protect against information disclosure and tampering, 611 confidentiality protection MUST be applied using TLS with a cipher 612 suite that provides confidentiality and integrity protection. 614 HTTP clients MUST also verify the TLS server certificate, using 615 subjectAltName dNSName identities as described in [RFC6125], to avoid 616 man-in-the-middle attacks. The rules and guidelines defined in 617 [RFC6125] apply here, with the following considerations: 619 o Support for DNS-ID identifier type (that is, the dNSName identity 620 in the subjectAltName extension) is REQUIRED. Certification 621 authorities which issue server certificates MUST support the DNS- 622 ID identifier type, and the DNS-ID identifier type MUST be present 623 in server certificates. 625 o DNS names in server certificates MAY contain the wildcard 626 character "*". 628 o Clients MUST NOT use CN-ID identifiers; a CN field may be present 629 in the server certificate's subject name, but MUST NOT be used for 630 authentication within the rules described in [BCP195] . 632 o SRV-ID and URI-ID as described in Section 6.5 of [RFC6125] MUST 633 NOT be used for comparison. 635 9. IANA Considerations 637 This specification requests no actions by IANA. 639 10. Security Considerations 641 In addition to the all the security considerations discussed in OAuth 642 2.0 [RFC6819], the security considerations in [RFC7515], [RFC7516], 643 and [RFC7518] needs to be considered. Also, there are several 644 academic papers such as [BASIN] that provide useful insight into the 645 security properties of protocols like OAuth. 647 In consideration of the above, this document advises taking the 648 following security considerations into account. 650 10.1. Choice of Algorithms 652 When sending the authorization request object through "request" 653 parameter, it MUST either be signed using JWS [RFC7515] or encrypted 654 using JWE [RFC7516] with then considered appropriate algorithm. 656 10.2. Request Source Authentication 658 The source of the Authorization Request MUST always be verified. 659 There are several ways to do it in this specification. 661 (a) Verifying the JWS Signature of the Request Object. 663 (b) Verifying that the symmetric key for the JWE encryption is the 664 correct one if the JWE is using symmetric encryption. 666 (c) Verifying the TLS Server Identity of the Request Object URI. In 667 this case, the Authorization Server MUST know out-of-band that 668 the Client uses Request Object URI and only the Client is 669 covered by the TLS certificate. In general, it is not a 670 reliable method. 672 (d) Authorization Server is providing an endpoint that provides a 673 Request Object URI in exchange for a Request Object. In this 674 case, the Authorization Server MUST perform Client 675 Authentication to accept the Request Object and bind the Client 676 Identifier to the Request Object URI it is providing. Since 677 Request Object URI can be replayed, the lifetime of the Request 678 Object URI MUST be short and preferably one-time use. The 679 entropy of the Request Object URI MUST be sufficiently large. 680 The adequate shortness of the validity and the entropy of the 681 Request Object URI depends on the risk calculation based on the 682 value of the resource being protected. A general guidance for 683 the validity time would be less than a minute and the Request 684 Object URI is to include a cryptographic random value of 128bit 685 or more at the time of the writing of this specification. 687 (e) A third party, such as a Trust Framework Provider, provides an 688 endpoint that provides a Request Object URI in exchange for a 689 Request Object. The same requirements as (b) above apply. In 690 addition, the Authorization Server MUST know out-of-band that 691 the Client utilizes the Trust Framework Operator. 693 10.3. Explicit Endpoints 695 Although this specification does not require them, research such as 696 [BASIN] points out that it is a good practice to explicitly state the 697 intended interaction endpoints and the message position in the 698 sequence in a tamper evident manner so that the intent of the 699 initiator is unambiguous. The endpoints that come into question in 700 this specification are : 702 (a) Protected Resources ("protected_resources") 703 (b) Authorization Endpoint ("authorization_endpoint") 705 (c) Redirection URI ("redirect_uri") 707 (d) Token Endpoint ("token_endpoint") 709 Further, if dynamic discovery is used, then the discovery related 710 endpoints also come into question. 712 In [RFC6749], while Redirection URI is included, others are not 713 included in the Authorization Request. As the result, the same 714 applies to Authorization Request Object. 716 The lack of the link among those endpoints are sited as the cause of 717 Cross-Phase Attacks introduced in [FETT]. An extension specification 718 should be created as a measure to address the risk. 720 10.4. Risks Associated with request_uri 722 The introduction of "request_uri" introduces several attack 723 possibilities. 725 10.4.1. DDoS Attack on the Authorization Server 727 A set of malicious client can launch a DoS attack to the 728 authorization server by pointing the "request_uri" to a uri that 729 returns extremely large content or extremely slow to respond. Under 730 such an attack, the server may use up its resource and start failing. 732 Similarly, a malicious client can specify the "request_uri" value 733 that itself points to an authorization request URI that uses 734 "request_uri" to cause the recursive lookup. 736 To prevent such attack to succeed, the server should (a) check that 737 the value of "request_uri" parameter does not point to an unexpected 738 location, (b) check the content type of the response is "application/ 739 jwt" (c) implement a time-out for obtaining the content of 740 "request_uri", and (d) do not perform recursive GET on the 741 "request_uri". 743 10.4.2. Request URI Rewrite 745 The value of "request_uri" is not signed thus it can be tampered by 746 Man-in-the-browser attacker. Several attack possibilities rise 747 because of this, e.g., (a) attacker may create another file that the 748 rewritten URI points to making it possible to request extra scope (b) 749 attacker launches a DoS attack to a victim site by setting the value 750 of "request_uri" to be that of the victim. 752 To prevent such attack to succeed, the server should (a) check that 753 the value of "request_uri" parameter does not point to an unexpected 754 location, (b) check the content type of the response is "application/ 755 jwt" (c) implement a time-out for obtaining the content of 756 "request_uri". 758 11. TLS security considerations 760 Curent security considerations can be found in Recommendations for 761 Secure Use of TLS and DTLS [BCP195]. This supersedes the TLS version 762 recommendations in OAuth 2.0 [RFC6749]. 764 12. Privacy Considerations 766 When the Client is being granted access to a protected resource 767 containing personal data, both the Client and the Authorization 768 Server need to adhere to Privacy Principles. RFC 6973 Privacy 769 Considerations for Internet Protocols [RFC6973] gives excellent 770 guidance on the enhancement of protocol design and implementation. 771 The provision listed in it should be followed. 773 Most of the provision would apply to The OAuth 2.0 Authorization 774 Framework [RFC6749] and The OAuth 2.0 Authorization Framework: Bearer 775 Token Usage [RFC6750] and are not specific to this specification. In 776 what follows, only the specific provisions to this specification are 777 noted. 779 12.1. Collection limitation 781 When the Client is being granted access to a protected resource 782 containing personal data, the Client SHOULD limit the collection of 783 personal data to that which is within the bounds of applicable law 784 and strictly necessary for the specified purpose(s). 786 It is often hard for the user to find out if the personal data asked 787 for is strictly necessary. A Trust Framework Provider can help the 788 user by examining the Client request and comparing to the proposed 789 processing by the Client and certifying the request. After the 790 certification, the Client, when making an Authorization Request, can 791 submit Authorization Request to the Trust Framework Provider to 792 obtain the Request Object URI. 794 Upon receiving such Request Object URI in the Authorization Request, 795 the Authorization Server first verifies that the authority portion of 796 the Request Object URI is a legitimate one for the Trust Framework 797 Provider. Then, the Authorization Server issues HTTP GET request to 798 the Request Object URI. Upon connecting, the Authorization Server 799 MUST verify the server identity represented in the TLS certificate is 800 legitimate for the Request Object URI. Then, the Authorization 801 Server can obtain the Request Object, which includes the "client_id" 802 representing the Client. 804 The Consent screen MUST indicate the Client and SHOULD indicate that 805 the request has been vetted by the Trust Framework Operator for the 806 adherence to the Collection Limitation principle. 808 12.2. Disclosure Limitation 810 12.2.1. Request Disclosure 812 This specification allows extension parameters. These may include 813 potentially sensitive information. Since URI query parameter may 814 leak through various means but most notably through referrer and 815 browser history, if the authorization request contains a potentially 816 sensitive parameter, the Client SHOULD JWE [RFC7516] encrypt the 817 request object. 819 Where Request Object URI method is being used, if the request object 820 contains personally identifiable or sensitive information, the 821 "request_uri" SHOULD be used only once, have a short validity period, 822 and MUST have large enough entropy deemed necessary with applicable 823 security policy unless the Request Object itself is JWE [RFC7516] 824 Encrypted. The adequate shortness of the validity and the entropy of 825 the Request Object URI depends on the risk calculation based on the 826 value of the resource being protected. A general guidance for the 827 validity time would be less than a minute and the Request Object URI 828 is to include a cryptographic random value of 128bit or more at the 829 time of the writing of this specification. 831 12.2.2. Tracking using Request Object URI 833 Even if the protected resource does not include a personally 834 identifiable information, it is sometimes possible to identify the 835 user through the Request Object URI if persistent per-user Request 836 Object URI is used. A third party may observe it through browser 837 history etc. and start correlating the user's activity using it. In 838 a way, it is a data disclosure as well and should be avoided. 840 Therefore, per-user Request Object URI should be avoided. 842 13. Acknowledgements 844 The following people contributed to the creation of this document in 845 the OAuth WG. (Affiliations at the time of the contribution are 846 used.) 847 Sergey Beryozkin, Brian Campbell (Ping Identity), Vladimir Dzhuvinov 848 (Connect2id), Michael B. Jones (Microsoft), Torsten Lodderstedt 849 (YES) Jim Manico, Axel Nenker(Deutsche Telecom), Hannes Tschofenig 850 (ARM), Ben Campbell, Kathleen Moriarty (as AD), and Steve Kent (as 851 SECDIR). 853 The following people contributed to creating this document through 854 the OpenID Connect Core 1.0 [OpenID.Core]. 856 Brian Campbell (Ping Identity), George Fletcher (AOL), Ryo Itou 857 (Mixi), Edmund Jay (Illumila), Michael B. Jones (Microsoft), Breno 858 de Medeiros (Google), Hideki Nara (TACT), Justin Richer (MITRE). 860 In addition, the following people contributed to this and previous 861 versions through the OAuth Working Group. 863 Dirk Balfanz (Google), James H. Manger (Telstra), John Panzer 864 (Google), David Recordon (Facebook), Marius Scurtescu (Google), Luke 865 Shepard (Facebook). 867 14. Revision History 869 Note to the RFC Editor: Please remove this section from the final 870 RFC. 872 -17 874 o #78 Typos in content-type 876 -16 878 o Treated remaining Ben Campbell comments. 880 -15 882 o Removed further duplication 884 -14 886 o #71 Reiterate dynamic params are included. 888 o #70 Made clear that AS must return error. 890 o #69 Inconsistency of the need to sign. 892 o Fixed Mimetype. 894 o #67 Incosistence in requiring HTTPS in request uri. 896 o #66 Dropped ISO 29100 reference. 898 o #25 Removed Encrypt only option. 900 o #59 Same with #25. 902 -13 904 o add TLS Security Consideration section 906 o replace RFC7525 reference with BCP195 908 o moved front tag in FETT reference to fix XML structure 910 o changes reference from SoK to FETT 912 -12 914 o fixes #62 - Alexey Melnikov Discuss 916 o fixes #48 - OPSDIR Review : General - delete semicolors after list 917 items 919 o fixes #58 - DP Comments for the Last Call 921 o fixes #57 - GENART - Remove "non-normative ... " from examples. 923 o fixes #45 - OPSDIR Review : Introduction - are attacks discovered 924 or already opened 926 o fixes #49 - OPSDIR Review : Introduction - Inconsistent colons 927 after initial sentence of list items. 929 o fixes #53 - OPSDIR Review : 6.2 JWS Signed Request Object - 930 Clarify JOSE Header 932 o fixes #42 - OPSDIR Review : Introduction - readability of 'and' is 933 confusing 935 o fixes #50 - OPSDIR Review : Section 4 Request Object - Clarify 936 'signed, encrypted, or signed and encrypted' 938 o fixes #39 - OPSDIR Review : Abstract - Explain/Clarify JWS and JWE 940 o fixed #50 - OPSDIR Review : Section 4 Request Object - Clarify 941 'signed, encrypted, or signed and encrypted' 943 o fixes #43 - OPSDIR Review : Introduction - 'properties' sounds 944 awkward and are not exactly 'properties' 946 o fixes #56 - OPSDIR Review : 12 Acknowledgements - 'contribution 947 is' => 'contribution are' 949 o fixes #55 - OPSDIR Review : 11.2.2 Privacy Considerations - ' It 950 is in a way' => 'In a way, it is' 952 o fixes #54 - OPSDIR Review : 11 Privacy Considerations - 'and not 953 specific' => 'and are not specific' 955 o fixes #51 - OPSDIR Review : Section 4 Request Object - 'It is 956 fine' => 'It is recommended' 958 o fixes #47 - OPSDIR Review : Introduction - 'over- the- wire' => 959 'over-the-wire' 961 o fixes #46 - OPSDIR Review : Introduction - 'It allows' => 'The use 962 of application security' for 964 o fixes #44 - OPSDIR Review : Introduction - 'has' => 'have' 966 o fixes #41 - OPSDIR Review : Introduction - missing 'is' before 967 'typically sent' 969 o fixes #38 - OPSDIR Review : Section 11 - Delete 'freely 970 accessible' regarding ISO 29100 972 -11 974 o s/bing/being/ 976 o Added history for -10 978 -10 980 o #20: KM1 -- some wording that is awkward in the TLS section. 982 o #21: KM2 - the additional attacks against OAuth 2.0 should also 983 have a pointer 985 o #22: KM3 -- Nit: in the first line of 10.4: 987 o #23: KM4 -- Mention RFC6973 in Section 11 in addition to ISO 29100 989 o #24: SECDIR review: Section 4 -- Confusing requirements for 990 sign+encrypt 992 o #25: SECDIR review: Section 6 -- authentication and integrity need 993 not be provided if the requestor encrypts the token? 995 o #26: SECDIR Review: Section 10 -- why no reference for JWS 996 algorithms? 998 o #27: SECDIR Review: Section 10.2 - how to do the agreement between 999 client and server "a priori"? 1001 o #28: SECDIR Review: Section 10.3 - Indication on "large entropy" 1002 and "short lifetime" should be indicated 1004 o #29: SECDIR Review: Section 10.3 - Typo 1006 o #30: SECDIR Review: Section 10.4 - typos and missing articles 1008 o #31: SECDIR Review: Section 10.4 - Clearer statement on the lack 1009 of endpoint identifiers needed 1011 o #32: SECDIR Review: Section 11 - ISO29100 needs to be moved to 1012 normative reference 1014 o #33: SECDIR Review: Section 11 - Better English and Entropy 1015 language needed 1017 o #34: Section 4: Typo 1019 o #35: More Acknowledgment 1021 o #36: DP - More precise qualification on Encryption needed. 1023 -09 1025 o Minor Editorial Nits. 1027 o Section 10.4 added. 1029 o Explicit reference to Security consideration (10.2) added in 1030 section 5 and section 5.2. 1032 o , (add yourself) removed from the acknowledgment. 1034 -08 1036 o Applied changes proposed by Hannes on 2016-06-29 on IETF OAuth 1037 list recorded as https://bitbucket.org/Nat/oauth-jwsreq/ 1038 issues/12/. 1040 o TLS requirements added. 1042 o Security Consideration reinforced. 1044 o Privacy Consideration added. 1046 o Introduction improved. 1048 -07 1050 o Changed the abbrev to OAuth JAR from oauth-jar. 1052 o Clarified sig and enc methods. 1054 o Better English. 1056 o Removed claims from one of the example. 1058 o Re-worded the URI construction. 1060 o Changed the example to use request instead of request_uri. 1062 o Clarified that Request Object parameters take precedence 1063 regardless of request or request_uri parameters were used. 1065 o Generalized the language in 4.2.1 to convey the intent more 1066 clearly. 1068 o Changed "Server" to "Authorization Server" as a clarification. 1070 o Stopped talking about request_object_signing_alg. 1072 o IANA considerations now reflect the current status. 1074 o Added Brian Campbell to the contributors list. Made the lists 1075 alphabetic order based on the last names. Clarified that the 1076 affiliation is at the time of the contribution. 1078 o Added "older versions of " to the reference to IE uri length 1079 limitations. 1081 o Stopped talking about signed or unsigned JWS etc. 1083 o 1.Introduction improved. 1085 -06 1087 o Added explanation on the 512 chars URL restriction. 1089 o Updated Acknowledgements. 1091 -05 1093 o More alignment with OpenID Connect. 1095 -04 1097 o Fixed typos in examples. (request_url -> request_uri, cliend_id -> 1098 client_id) 1100 o Aligned the error messages with the OAuth IANA registry. 1102 o Added another rationale for having request object. 1104 -03 1106 o Fixed the non-normative description about the advantage of static 1107 signature. 1109 o Changed the requirement for the parameter values in the request 1110 itself and the request object from 'MUST MATCH" to 'Req Obj takes 1111 precedence. 1113 -02 1115 o Now that they are RFCs, replaced JWS, JWE, etc. with RFC numbers. 1117 -01 1119 o Copy Edits. 1121 15. References 1123 15.1. Normative References 1125 [BCP195] Sheffer, Y., Holz, R., and P. Saint-Andre, 1126 "Recommendations for Secure Use of Transport Layer 1127 Security (TLS) and Datagram Transport Layer Security 1128 (DTLS)", BCP 195, RFC 7525, May 2015. 1130 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 1131 Requirement Levels", BCP 14, RFC 2119, 1132 DOI 10.17487/RFC2119, March 1997, 1133 . 1135 [RFC3629] Yergeau, F., "UTF-8, a transformation format of ISO 1136 10646", STD 63, RFC 3629, DOI 10.17487/RFC3629, November 1137 2003, . 1139 [RFC3986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform 1140 Resource Identifier (URI): Generic Syntax", STD 66, 1141 RFC 3986, DOI 10.17487/RFC3986, January 2005, 1142 . 1144 [RFC6125] Saint-Andre, P. and J. Hodges, "Representation and 1145 Verification of Domain-Based Application Service Identity 1146 within Internet Public Key Infrastructure Using X.509 1147 (PKIX) Certificates in the Context of Transport Layer 1148 Security (TLS)", RFC 6125, DOI 10.17487/RFC6125, March 1149 2011, . 1151 [RFC6749] Hardt, D., Ed., "The OAuth 2.0 Authorization Framework", 1152 RFC 6749, DOI 10.17487/RFC6749, October 2012, 1153 . 1155 [RFC6750] Jones, M. and D. Hardt, "The OAuth 2.0 Authorization 1156 Framework: Bearer Token Usage", RFC 6750, 1157 DOI 10.17487/RFC6750, October 2012, 1158 . 1160 [RFC6819] Lodderstedt, T., Ed., McGloin, M., and P. Hunt, "OAuth 2.0 1161 Threat Model and Security Considerations", RFC 6819, 1162 DOI 10.17487/RFC6819, January 2013, 1163 . 1165 [RFC6973] Cooper, A., Tschofenig, H., Aboba, B., Peterson, J., 1166 Morris, J., Hansen, M., and R. Smith, "Privacy 1167 Considerations for Internet Protocols", RFC 6973, 1168 DOI 10.17487/RFC6973, July 2013, 1169 . 1171 [RFC7159] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data 1172 Interchange Format", RFC 7159, DOI 10.17487/RFC7159, March 1173 2014, . 1175 [RFC7230] Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer 1176 Protocol (HTTP/1.1): Message Syntax and Routing", 1177 RFC 7230, DOI 10.17487/RFC7230, June 2014, 1178 . 1180 [RFC7515] Jones, M., Bradley, J., and N. Sakimura, "JSON Web 1181 Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May 1182 2015, . 1184 [RFC7516] Jones, M. and J. Hildebrand, "JSON Web Encryption (JWE)", 1185 RFC 7516, DOI 10.17487/RFC7516, May 2015, 1186 . 1188 [RFC7518] Jones, M., "JSON Web Algorithms (JWA)", RFC 7518, 1189 DOI 10.17487/RFC7518, May 2015, 1190 . 1192 [RFC7519] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token 1193 (JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015, 1194 . 1196 [RFC8141] Saint-Andre, P. and J. Klensin, "Uniform Resource Names 1197 (URNs)", RFC 8141, DOI 10.17487/RFC8141, April 2017, 1198 . 1200 [RFC8259] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data 1201 Interchange Format", STD 90, RFC 8259, 1202 DOI 10.17487/RFC8259, December 2017, 1203 . 1205 15.2. Informative References 1207 [BASIN] Basin, D., Cremers, C., and S. Meier, "Provably Repairing 1208 the ISO/IEC 9798 Standard for Entity Authentication", 1209 Journal of Computer Security - Security and Trust 1210 Principles Volume 21 Issue 6, Pages 817-846, November 1211 2013, 1212 . 1215 [FETT] Fett, D., Kusters, R., and G. Schmitz, "A Comprehensive 1216 Formal Security Analysis of OAuth 2.0", CCS '16 1217 Proceedings of the 2016 ACM SIGSAC Conference on Computer 1218 and Communications Security Pages 1204-1215 , October 1219 2016, . 1223 [OpenID.Core] 1224 Sakimura, N., Bradley, J., Jones, M., de Medeiros, B., and 1225 C. Mortimore, "OpenID Connect Core 1.0", OpenID 1226 Foundation Standards, February 2014, 1227 . 1229 Authors' Addresses 1231 Nat Sakimura 1232 Nomura Research Institute 1233 Otemachi Financial City Grand Cube, 1-9-2 Otemachi 1234 Chiyoda-ku, Tokyo 100-0004 1235 Japan 1237 Phone: +81-3-5533-2111 1238 Email: n-sakimura@nri.co.jp 1239 URI: http://nat.sakimura.org/ 1241 John Bradley 1242 Yubico 1243 Casilla 177, Sucursal Talagante 1244 Talagante, RM 1245 Chile 1247 Phone: +1.202.630.5272 1248 Email: ve7jtb@ve7jtb.com 1249 URI: http://www.thread-safe.com/