idnits 2.17.1 draft-ietf-oauth-jwsreq-16.txt: Checking boilerplate required by RFC 5378 and the IETF Trust (see https://trustee.ietf.org/license-info): ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/1id-guidelines.txt: ---------------------------------------------------------------------------- No issues found here. Checking nits according to https://www.ietf.org/id-info/checklist : ---------------------------------------------------------------------------- No issues found here. Miscellaneous warnings: ---------------------------------------------------------------------------- == The copyright year in the IETF Trust and authors Copyright Line does not match the current year -- The document date (April 6, 2018) is 2204 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: October 8, 2018 Yubico 6 April 6, 2018 8 The OAuth 2.0 Authorization Framework: JWT Secured Authorization Request 9 (JAR) 10 draft-ietf-oauth-jwsreq-16 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 October 8, 2018. 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 . . . . . . . . . . . . . . . . . . . . . . . 26 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 WAP Wireless Application Protocol 260 4. Request Object 262 A Request Object (Section 2.1) is used to provide authorization 263 request parameters for an OAuth 2.0 authorization request. It MUST 264 contains all the OAuth 2.0 [RFC6749] authorization request parameters 265 including extension parameters. The parameters are represented as 266 the JWT claims. Parameter names and string values MUST be included 267 as JSON strings. Since Request Objects are handled across domains 268 and potentially outside of a closed ecosystem, per section 8.1 of 269 [RFC8259], these JSON strings MUST be encoded using UTF-8 [RFC3629]. 270 Numerical values MUST be included as JSON numbers. It MAY include 271 any extension parameters. This JSON [RFC7159] constitutes the JWT 272 Claims Set defined in JWT [RFC7519]. The JWT Claims Set is then 273 signed or signed and encrypted. 275 To sign, JSON Web Signature (JWS) [RFC7515] is used. The result is a 276 JWS signed JWT [RFC7519]. If signed, the Authorization Request 277 Object SHOULD contain the Claims "iss" (issuer) and "aud" (audience) 278 as members, with their semantics being the same as defined in the JWT 279 [RFC7519] specification. 281 To encrypt, JWE [RFC7516] is used. When both signature and 282 encryption are being applied, the JWT MUST be signed then encrypted 283 as advised in the section 11.2 of [RFC7519]. The result is a Nested 284 JWT, as defined in [RFC7519]. 286 The Authorization Request Object MAY be sent by value as described in 287 Section 5.1 or by reference as described in Section 5.2. 289 "request" and "request_uri" parameters MUST NOT be included in 290 Request Objects. 292 The following is an example of the Claims in a Request Object before 293 base64url encoding and signing. Note that it includes extension 294 variables such as "nonce" and "max_age". 296 { 297 "iss": "s6BhdRkqt3", 298 "aud": "https://server.example.com", 299 "response_type": "code id_token", 300 "client_id": "s6BhdRkqt3", 301 "redirect_uri": "https://client.example.org/cb", 302 "scope": "openid", 303 "state": "af0ifjsldkj", 304 "nonce": "n-0S6_WzA2Mj", 305 "max_age": 86400 306 } 308 Signing it with the "RS256" algorithm results in this Request Object 309 value (with line wraps within values for display purposes only): 311 eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiAiczZCaGRSa3 312 F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmNvbSIsDQogInJl 313 c3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWVudF9pZCI6ICJzNk 314 JoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8vY2xpZW50LmV4YW1w 315 bGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiAic3RhdGUiOiAiYWYwaW 316 Zqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWoiLA0KICJtYXhfYWdlIjog 317 ODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXNlcmluZm8iOiANCiAgICB7DQ 318 ogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgIm5p 319 Y2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjogeyJlc3NlbnRpYWwiOiB0cnVlfS 320 wNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAg 321 ICAgInBpY3R1cmUiOiBudWxsDQogICAgfSwNCiAgICJpZF90b2tlbiI6IA0KICAgIH 322 sNCiAgICAgImdlbmRlciI6IG51bGwsDQogICAgICJiaXJ0aGRhdGUiOiB7ImVzc2Vu 323 dGlhbCI6IHRydWV9LA0KICAgICAiYWNyIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOm 324 luY29tbW9uOmlhcDpzaWx2ZXIiXX0NCiAgICB9DQogIH0NCn0.nwwnNsk1-Zkbmnvs 325 F6zTHm8CHERFMGQPhos-EJcaH4Hh-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyF 326 KzuMXZFSZ3p6Mb8dkxtVyjoy2GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx 327 0GxFbuPbj96tVuj11pTnmFCUR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8K 328 ol-cSLWoYE9l5QqholImzjT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPG 329 iyon_-Te111V8uE83IlzCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 331 The following RSA public key, represented in JWK format, can be used 332 to validate the Request Object signature in this and subsequent 333 Request Object examples (with line wraps within values for display 334 purposes only): 336 { 337 "kty":"RSA", 338 "kid":"k2bdc", 339 "n":"y9Lqv4fCp6Ei-u2-ZCKq83YvbFEk6JMs_pSj76eMkddWRuWX2aBKGHAtKlE5P 340 7_vn__PCKZWePt3vGkB6ePgzAFu08NmKemwE5bQI0e6kIChtt_6KzT5OaaXDF 341 I6qCLJmk51Cc4VYFaxgqevMncYrzaW_50mZ1yGSFIQzLYP8bijAHGVjdEFgZa 342 ZEN9lsn_GdWLaJpHrB3ROlS50E45wxrlg9xMncVb8qDPuXZarvghLL0HzOuYR 343 adBJVoWZowDNTpKpk2RklZ7QaBO7XDv3uR7s_sf2g-bAjSYxYUGsqkNA9b3xV 344 W53am_UZZ3tZbFTIh557JICWKHlWj5uzeJXaw", 345 "e":"AQAB" 346 } 348 5. Authorization Request 350 The client constructs the authorization request URI by adding one of 351 the following parameters but not both to the query component of the 352 authorization endpoint URI using the "application/x-www-form- 353 urlencoded" format: 355 request The Request Object (Section 2.1) that holds authorization 356 request parameters stated in section 4 of OAuth 2.0 [RFC6749]. 358 request_uri The absolute URI as defined by RFC3986 [RFC3986] that 359 points to the Request Object (Section 2.1) that holds 360 authorization request parameters stated in section 4 of OAuth 2.0 361 [RFC6749]. 363 The client directs the resource owner to the constructed URI using an 364 HTTP redirection response, or by other means available to it via the 365 user-agent. 367 For example, the client directs the end user's user-agent to make the 368 following HTTPS request: 370 GET /authz?request=eyJhbG..AlMGzw HTTP/1.1 371 Host: server.example.com 373 The value for the request parameter is abbreviated for brevity. 375 The authorization request object MUST be one of the following: 377 (a) JWS signed 378 (b) JWS signed and JWE encrypted 380 The client MAY send the parameters included in the request object 381 duplicated in the query parameters as well for the backward 382 compatibility etc. However, the authorization server supporting this 383 specification MUST only use the parameters included in the request 384 object. 386 5.1. Passing a Request Object by Value 388 The Client sends the Authorization Request as a Request Object to the 389 Authorization Endpoint as the "request" parameter value. 391 The following is an example of an Authorization Request using the 392 "request" parameter (with line wraps within values for display 393 purposes only): 395 https://server.example.com/authorize? 396 request=eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiA 397 iczZCaGRSa3F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmN 398 vbSIsDQogInJlc3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWV 399 udF9pZCI6ICJzNkJoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8 400 vY2xpZW50LmV4YW1wbGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiA 401 ic3RhdGUiOiAiYWYwaWZqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWo 402 iLA0KICJtYXhfYWdlIjogODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXN 403 lcmluZm8iOiANCiAgICB7DQogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWw 404 iOiB0cnVlfSwNCiAgICAgIm5pY2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjo 405 geyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJ 406 lc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgInBpY3R1cmUiOiBudWxsDQogICAgfSw 407 NCiAgICJpZF90b2tlbiI6IA0KICAgIHsNCiAgICAgImdlbmRlciI6IG51bGwsDQo 408 gICAgICJiaXJ0aGRhdGUiOiB7ImVzc2VudGlhbCI6IHRydWV9LA0KICAgICAiYWN 409 yIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOmluY29tbW9uOmlhcDpzaWx2ZXIiXX0 410 NCiAgICB9DQogIH0NCn0.nwwnNsk1-ZkbmnvsF6zTHm8CHERFMGQPhos-EJcaH4H 411 h-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyFKzuMXZFSZ3p6Mb8dkxtVyjoy2 412 GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx0GxFbuPbj96tVuj11pTnmFC 413 UR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8Kol-cSLWoYE9l5QqholImz 414 jT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPGiyon_-Te111V8uE83Il 415 zCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 417 5.2. Passing a Request Object by Reference 419 The "request_uri" Authorization Request parameter enables OAuth 420 authorization requests to be passed by reference, rather than by 421 value. This parameter is used identically to the "request" 422 parameter, other than that the Request Object value is retrieved from 423 the resource identified by the specified URI rather than passed by 424 value. 426 The entire Request URI MUST NOT exceed 512 ASCII characters. There 427 are three reasons for this restriction. 429 1. Many phones in the market as of this writing still do not accept 430 large payloads. The restriction is typically either 512 or 1024 431 ASCII characters. 433 2. The maximum URL length supported by older versions of Internet 434 Explorer is 2083 ASCII characters. 436 3. On a slow connection such as 2G mobile connection, a large URL 437 would cause the slow response and therefore the use of such is 438 not advisable from the user experience point of view. 440 The contents of the resource referenced by the URI MUST be a Request 441 Object. The "request_uri" value MUST be either URN as defined in 442 RFC8141 [RFC8141] or "https" URI, as defined in 2.7.2 of RFC7230 443 [RFC7230] . The "request_uri" value MUST be reachable by the 444 Authorization Server. 446 The following is an example of the contents of a Request Object 447 resource that can be referenced by a "request_uri" (with line wraps 448 within values for display purposes only): 450 eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiAiczZCaGRSa3 451 F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmNvbSIsDQogInJl 452 c3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWVudF9pZCI6ICJzNk 453 JoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8vY2xpZW50LmV4YW1w 454 bGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiAic3RhdGUiOiAiYWYwaW 455 Zqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWoiLA0KICJtYXhfYWdlIjog 456 ODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXNlcmluZm8iOiANCiAgICB7DQ 457 ogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgIm5p 458 Y2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjogeyJlc3NlbnRpYWwiOiB0cnVlfS 459 wNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAg 460 ICAgInBpY3R1cmUiOiBudWxsDQogICAgfSwNCiAgICJpZF90b2tlbiI6IA0KICAgIH 461 sNCiAgICAgImdlbmRlciI6IG51bGwsDQogICAgICJiaXJ0aGRhdGUiOiB7ImVzc2Vu 462 dGlhbCI6IHRydWV9LA0KICAgICAiYWNyIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOm 463 luY29tbW9uOmlhcDpzaWx2ZXIiXX0NCiAgICB9DQogIH0NCn0.nwwnNsk1-Zkbmnvs 464 F6zTHm8CHERFMGQPhos-EJcaH4Hh-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyF 465 KzuMXZFSZ3p6Mb8dkxtVyjoy2GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx 466 0GxFbuPbj96tVuj11pTnmFCUR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8K 467 ol-cSLWoYE9l5QqholImzjT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPG 468 iyon_-Te111V8uE83IlzCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 470 5.2.1. URI Referencing the Request Object 472 The Client stores the Request Object resource either locally or 473 remotely at a URI the Authorization Server can access. Such facility 474 may be provided by the authorization server or a third party. For 475 example, the authorization server may provide a URL to which the 476 client POSTs the request object and obtains the Requiest URI. This 477 URI is the Request Object URI, "request_uri". 479 It is possible for the Request Object to include values that are to 480 be revealed only to the Authorization Server. As such, the 481 "request_uri" MUST have appropriate entropy for its lifetime. For 482 the guidance, refer to 5.1.4.2.2 of [RFC6819]. It is RECOMMENDED 483 that it be removed after a reasonable timeout unless access control 484 measures are taken. 486 The following is an example of a Request Object URI value (with line 487 wraps within values for display purposes only): 489 https://tfp.example.org/request.jwt# 490 GkurKxf5T0Y-mnPFCHqWOMiZi4VS138cQO_V7PZHAdM 492 5.2.2. Request using the "request_uri" Request Parameter 494 The Client sends the Authorization Request to the Authorization 495 Endpoint. 497 The following is an example of an Authorization Request using the 498 "request_uri" parameter (with line wraps within values for display 499 purposes only): 501 https://server.example.com/authorize? 502 response_type=code%20id_token 503 &client_id=s6BhdRkqt3 504 &request_uri=https%3A%2F%2Ftfp.example.org%2Frequest.jwt 505 %23GkurKxf5T0Y-mnPFCHqWOMiZi4VS138cQO_V7PZHAdM 506 &state=af0ifjsldkj 508 5.2.3. Authorization Server Fetches Request Object 510 Upon receipt of the Request, the Authorization Server MUST send an 511 HTTP "GET" request to the "request_uri" to retrieve the referenced 512 Request Object, unless it is stored in a way so that it can retrieve 513 it through other mechanism securely, and parse it to recreate the 514 Authorization Request parameters. 516 The following is an example of this fetch process: 518 GET /request.jwt HTTP/1.1 519 Host: tfp.example.org 521 The following is an example of the fetch response: 523 HTTP/1.1 200 OK 524 Date: Thu, 16 Feb 2017 23:52:39 GMT 525 Server: Apache/2.2.22 (tfp.example.org) 526 Content-type: application/jwt 527 Content-Length: 1250 528 Last-Modified: Wed, 15 Feb 2017 23:52:32 GMT 530 eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiAiczZCaGRSa3 531 F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmNvbSIsDQogInJl 532 c3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWVudF9pZCI6ICJzNk 533 JoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8vY2xpZW50LmV4YW1w 534 bGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiAic3RhdGUiOiAiYWYwaW 535 Zqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWoiLA0KICJtYXhfYWdlIjog 536 ODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXNlcmluZm8iOiANCiAgICB7DQ 537 ogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgIm5p 538 Y2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjogeyJlc3NlbnRpYWwiOiB0cnVlfS 539 wNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAg 540 ICAgInBpY3R1cmUiOiBudWxsDQogICAgfSwNCiAgICJpZF90b2tlbiI6IA0KICAgIH 541 sNCiAgICAgImdlbmRlciI6IG51bGwsDQogICAgICJiaXJ0aGRhdGUiOiB7ImVzc2Vu 542 dGlhbCI6IHRydWV9LA0KICAgICAiYWNyIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOm 543 luY29tbW9uOmlhcDpzaWx2ZXIiXX0NCiAgICB9DQogIH0NCn0.nwwnNsk1-Zkbmnvs 544 F6zTHm8CHERFMGQPhos-EJcaH4Hh-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyF 545 KzuMXZFSZ3p6Mb8dkxtVyjoy2GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx 546 0GxFbuPbj96tVuj11pTnmFCUR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8K 547 ol-cSLWoYE9l5QqholImzjT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPG 548 iyon_-Te111V8uE83IlzCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 550 6. Validating JWT-Based Requests 552 6.1. Encrypted Request Object 554 If the request object is encrypted, the Authorization Server MUST 555 decrypt the JWT in accordance with the JSON Web Encryption [RFC7516] 556 specification. 558 The result is a signed request object. 560 If decryption fails, the Authorization Server MUST return an 561 "invalid_request_object" error. 563 6.2. JWS Signed Request Object 565 The Authorization Server MUST perform the signature validation of the 566 JSON Web Signature [RFC7515] signed request object. For this, the 567 "alg" Header Parameter in its JOSE Header MUST match the value of the 568 pre-registered algorithm. The signature MUST be validated against 569 the appropriate key for that "client_id" and algorithm. 571 If signature validation fails, the Authorization Server MUST return 572 an "invalid_request_object" error. 574 6.3. Request Parameter Assembly and Validation 576 The Authorization Server MUST extract the set of Authorization 577 Request parameters from the Request Object value. The Authorization 578 Server MUST only use the parameters in the Request Object even if the 579 same parameter is provided in the query parameter. The Authorization 580 Server then validates the request as specified in OAuth 2.0 581 [RFC6749]. 583 If the validation fails, then the Authorization Server MUST return an 584 error as specified in OAuth 2.0 [RFC6749]. 586 7. Authorization Server Response 588 Authorization Server Response is created and sent to the client as in 589 Section 4 of OAuth 2.0 [RFC6749] . 591 In addition, this document uses these additional error values: 593 invalid_request_uri The "request_uri" in the Authorization Request 594 returns an error or contains invalid data. 596 invalid_request_object The request parameter contains an invalid 597 Request Object. 599 request_not_supported The Authorization Server does not support the 600 use of the "request" parameter. 602 request_uri_not_supported The Authorization Server does not support 603 the use of the "request_uri" parameter. 605 8. TLS Requirements 607 Client implementations supporting the Request Object URI method MUST 608 support TLS following Recommendations for Secure Use of Transport 609 Layer Security (TLS) and Datagram Transport Layer Security (DTLS) 610 [BCP195]. 612 To protect against information disclosure and tampering, 613 confidentiality protection MUST be applied using TLS with a cipher 614 suite that provides confidentiality and integrity protection. 616 HTTP clients MUST also verify the TLS server certificate, using 617 subjectAltName dNSName identities as described in [RFC6125], to avoid 618 man-in-the-middle attacks. The rules and guidelines defined in 619 [RFC6125] apply here, with the following considerations: 621 o Support for DNS-ID identifier type (that is, the dNSName identity 622 in the subjectAltName extension) is REQUIRED. Certification 623 authorities which issue server certificates MUST support the DNS- 624 ID identifier type, and the DNS-ID identifier type MUST be present 625 in server certificates. 627 o DNS names in server certificates MAY contain the wildcard 628 character "*". 630 o Clients MUST NOT use CN-ID identifiers; a CN field may be present 631 in the server certificate's subject name, but MUST NOT be used for 632 authentication within the rules described in [BCP195] . 634 o SRV-ID and URI-ID as described in Section 6.5 of [RFC6125] MUST 635 NOT be used for comparison. 637 9. IANA Considerations 639 This specification requests no actions by IANA. 641 10. Security Considerations 643 In addition to the all the security considerations discussed in OAuth 644 2.0 [RFC6819], the security considerations in [RFC7515], [RFC7516], 645 and [RFC7518] needs to be considered. Also, there are several 646 academic papers such as [BASIN] that provide useful insight into the 647 security properties of protocols like OAuth. 649 In consideration of the above, this document advises taking the 650 following security considerations into account. 652 10.1. Choice of Algorithms 654 When sending the authorization request object through "request" 655 parameter, it MUST either be signed using JWS [RFC7515] or encrypted 656 using JWE [RFC7516] with then considered appropriate algorithm. 658 10.2. Request Source Authentication 660 The source of the Authorization Request MUST always be verified. 661 There are several ways to do it in this specification. 663 (a) Verifying the JWS Signature of the Request Object. 665 (b) Verifying that the symmetric key for the JWE encryption is the 666 correct one if the JWE is using symmetric encryption. 668 (c) Verifying the TLS Server Identity of the Request Object URI. In 669 this case, the Authorization Server MUST know out-of-band that 670 the Client uses Request Object URI and only the Client is 671 covered by the TLS certificate. In general, it is not a 672 reliable method. 674 (d) Authorization Server is providing an endpoint that provides a 675 Request Object URI in exchange for a Request Object. In this 676 case, the Authorization Server MUST perform Client 677 Authentication to accept the Request Object and bind the Client 678 Identifier to the Request Object URI it is providing. Since 679 Request Object URI can be replayed, the lifetime of the Request 680 Object URI MUST be short and preferably one-time use. The 681 entropy of the Request Object URI MUST be sufficiently large. 682 The adequate shortness of the validity and the entropy of the 683 Request Object URI depends on the risk calculation based on the 684 value of the resource being protected. A general guidance for 685 the validity time would be less than a minute and the Request 686 Object URI is to include a cryptographic random value of 128bit 687 or more at the time of the writing of this specification. 689 (e) A third party, such as a Trust Framework Provider, provides an 690 endpoint that provides a Request Object URI in exchange for a 691 Request Object. The same requirements as (b) above apply. In 692 addition, the Authorization Server MUST know out-of-band that 693 the Client utilizes the Trust Framework Operator. 695 10.3. Explicit Endpoints 697 Although this specification does not require them, research such as 698 [BASIN] points out that it is a good practice to explicitly state the 699 intended interaction endpoints and the message position in the 700 sequence in a tamper evident manner so that the intent of the 701 initiator is unambiguous. The endpoints that come into question in 702 this specification are : 704 (a) Protected Resources ("protected_resources") 705 (b) Authorization Endpoint ("authorization_endpoint") 707 (c) Redirection URI ("redirect_uri") 709 (d) Token Endpoint ("token_endpoint") 711 Further, if dynamic discovery is used, then the discovery related 712 endpoints also come into question. 714 In [RFC6749], while Redirection URI is included, others are not 715 included in the Authorization Request. As the result, the same 716 applies to Authorization Request Object. 718 The lack of the link among those endpoints are sited as the cause of 719 Cross-Phase Attacks introduced in [FETT]. An extension specification 720 should be created as a measure to address the risk. 722 10.4. Risks Associated with request_uri 724 The introdcution of "redirect_uri" introduces several attack 725 possibilities. 727 10.4.1. DDoS Attack on the Authorization Server 729 A set of malicious client can launch a DoS attack to the 730 authorization server by pointing the "request_uri" to a uri that 731 returns extremely large content or extremely slow to respond. Under 732 such an attack, the server may use up its resource and start failing. 734 Similarly, a malicious client can specify the "request_uri" value 735 that itself points to an authorization request URI that uses 736 "request_uri" to cause the recursive lookup. 738 To prevent such attack to succeed, the server should (a) check that 739 the value of "request_uri" parameter does not point to an unexpected 740 location, (b) check the content type of the response is "application/ 741 jose" (c) implement a time-out for obtaining the content of 742 "request_uri", and (d) do not perform recursive GET on the 743 "request_uri". 745 10.4.2. Request URI Rewrite 747 The value of "request_uri" is not signed thus it can be tampered by 748 Man-in-the-browser attacker. Several attack possibilities rise 749 because of this, e.g., (a) attacker may create another file that the 750 rewritten URI points to making it possible to request extra scope (b) 751 attacker launches a DoS attack to a victim site by setting the value 752 of "request_uri" to be that of the victim. 754 To prevent such attack to succeed, the server should (a) check that 755 the value of "request_uri" parameter does not point to an unexpected 756 location, (b) check the content type of the response is "application/ 757 json" (c) implement a time-out for obtaining the content of 758 "request_uri". 760 11. TLS security considerations 762 Curent security considerations can be found in Recommendations for 763 Secure Use of TLS and DTLS [BCP195]. This supersedes the TLS version 764 recommendations in OAuth 2.0 [RFC6749]. 766 12. Privacy Considerations 768 When the Client is being granted access to a protected resource 769 containing personal data, both the Client and the Authorization 770 Server need to adhere to Privacy Principles. RFC 6973 Privacy 771 Considerations for Internet Protocols [RFC6973] gives excellent 772 guidance on the enhancement of protocol design and implementation. 773 The provision listed in it should be followed. 775 Most of the provision would apply to The OAuth 2.0 Authorization 776 Framework [RFC6749] and The OAuth 2.0 Authorization Framework: Bearer 777 Token Usage [RFC6750] and are not specific to this specification. In 778 what follows, only the specific provisions to this specification are 779 noted. 781 12.1. Collection limitation 783 When the Client is being granted access to a protected resource 784 containing personal data, the Client SHOULD limit the collection of 785 personal data to that which is within the bounds of applicable law 786 and strictly necessary for the specified purpose(s). 788 It is often hard for the user to find out if the personal data asked 789 for is strictly necessary. A Trust Framework Provider can help the 790 user by examining the Client request and comparing to the proposed 791 processing by the Client and certifying the request. After the 792 certification, the Client, when making an Authorization Request, can 793 submit Authorization Request to the Trust Framework Provider to 794 obtain the Request Object URI. 796 Upon receiving such Request Object URI in the Authorization Request, 797 the Authorization Server first verifies that the authority portion of 798 the Request Object URI is a legitimate one for the Trust Framework 799 Provider. Then, the Authorization Server issues HTTP GET request to 800 the Request Object URI. Upon connecting, the Authorization Server 801 MUST verify the server identity represented in the TLS certificate is 802 legitimate for the Request Object URI. Then, the Authorization 803 Server can obtain the Request Object, which includes the "client_id" 804 representing the Client. 806 The Consent screen MUST indicate the Client and SHOULD indicate that 807 the request has been vetted by the Trust Framework Operator for the 808 adherence to the Collection Limitation principle. 810 12.2. Disclosure Limitation 812 12.2.1. Request Disclosure 814 This specification allows extension parameters. These may include 815 potentially sensitive information. Since URI query parameter may 816 leak through various means but most notably through referrer and 817 browser history, if the authorization request contains a potentially 818 sensitive parameter, the Client SHOULD JWE [RFC7516] encrypt the 819 request object. 821 Where Request Object URI method is being used, if the request object 822 contains personally identifiable or sensitive information, the 823 "request_uri" SHOULD be used only once, have a short validity period, 824 and MUST have large enough entropy deemed necessary with applicable 825 security policy unless the Request Object itself is JWE [RFC7516] 826 Encrypted. The adequate shortness of the validity and the entropy of 827 the Request Object URI depends on the risk calculation based on the 828 value of the resource being protected. A general guidance for the 829 validity time would be less than a minute and the Request Object URI 830 is to include a cryptographic random value of 128bit or more at the 831 time of the writing of this specification. 833 12.2.2. Tracking using Request Object URI 835 Even if the protected resource does not include a personally 836 identifiable information, it is sometimes possible to identify the 837 user through the Request Object URI if persistent per-user Request 838 Object URI is used. A third party may observe it through browser 839 history etc. and start correlating the user's activity using it. In 840 a way, it is a data disclosure as well and should be avoided. 842 Therefore, per-user Request Object URI should be avoided. 844 13. Acknowledgements 846 The following people contributed to the creation of this document in 847 the OAuth WG. (Affiliations at the time of the contribution are 848 used.) 849 Sergey Beryozkin, Brian Campbell (Ping Identity), Vladimir Dzhuvinov 850 (Connect2id), Michael B. Jones (Microsoft), Torsten Lodderstedt 851 (YES) Jim Manico, Axel Nenker(Deutsche Telecom), Hannes Tschofenig 852 (ARM), Ben Campbell, Kathleen Moriarty (as AD), and Steve Kent (as 853 SECDIR). 855 The following people contributed to creating this document through 856 the OpenID Connect Core 1.0 [OpenID.Core]. 858 Brian Campbell (Ping Identity), George Fletcher (AOL), Ryo Itou 859 (Mixi), Edmund Jay (Illumila), Michael B. Jones (Microsoft), Breno 860 de Medeiros (Google), Hideki Nara (TACT), Justin Richer (MITRE). 862 In addition, the following people contributed to this and previous 863 versions through the OAuth Working Group. 865 Dirk Balfanz (Google), James H. Manger (Telstra), John Panzer 866 (Google), David Recordon (Facebook), Marius Scurtescu (Google), Luke 867 Shepard (Facebook). 869 14. Revision History 871 Note to the RFC Editor: Please remove this section from the final 872 RFC. 874 -16 876 o Treated remaining Ben Campbell comments. 878 -15 880 o Removed further duplication 882 -14 884 o #71 Reiterate dynamic params are included. 886 o #70 Made clear that AS must return error. 888 o #69 Inconsistency of the need to sign. 890 o Fixed Mimetype. 892 o #67 Incosistence in requiring HTTPS in request uri. 894 o #66 Dropped ISO 29100 reference. 896 o #25 Removed Encrypt only option. 898 o #59 Same with #25. 900 -13 902 o add TLS Security Consideration section 904 o replace RFC7525 reference with BCP195 906 o moved front tag in FETT reference to fix XML structure 908 o changes reference from SoK to FETT 910 -12 912 o fixes #62 - Alexey Melnikov Discuss 914 o fixes #48 - OPSDIR Review : General - delete semicolors after list 915 items 917 o fixes #58 - DP Comments for the Last Call 919 o fixes #57 - GENART - Remove "non-normative ... " from examples. 921 o fixes #45 - OPSDIR Review : Introduction - are attacks discovered 922 or already opened 924 o fixes #49 - OPSDIR Review : Introduction - Inconsistent colons 925 after initial sentence of list items. 927 o fixes #53 - OPSDIR Review : 6.2 JWS Signed Request Object - 928 Clarify JOSE Header 930 o fixes #42 - OPSDIR Review : Introduction - readability of 'and' is 931 confusing 933 o fixes #50 - OPSDIR Review : Section 4 Request Object - Clarify 934 'signed, encrypted, or signed and encrypted' 936 o fixes #39 - OPSDIR Review : Abstract - Explain/Clarify JWS and JWE 938 o fixed #50 - OPSDIR Review : Section 4 Request Object - Clarify 939 'signed, encrypted, or signed and encrypted' 941 o fixes #43 - OPSDIR Review : Introduction - 'properties' sounds 942 awkward and are not exactly 'properties' 944 o fixes #56 - OPSDIR Review : 12 Acknowledgements - 'contribution 945 is' => 'contribution are' 947 o fixes #55 - OPSDIR Review : 11.2.2 Privacy Considerations - ' It 948 is in a way' => 'In a way, it is' 950 o fixes #54 - OPSDIR Review : 11 Privacy Considerations - 'and not 951 specific' => 'and are not specific' 953 o fixes #51 - OPSDIR Review : Section 4 Request Object - 'It is 954 fine' => 'It is recommended' 956 o fixes #47 - OPSDIR Review : Introduction - 'over- the- wire' => 957 'over-the-wire' 959 o fixes #46 - OPSDIR Review : Introduction - 'It allows' => 'The use 960 of application security' for 962 o fixes #44 - OPSDIR Review : Introduction - 'has' => 'have' 964 o fixes #41 - OPSDIR Review : Introduction - missing 'is' before 965 'typically sent' 967 o fixes #38 - OPSDIR Review : Section 11 - Delete 'freely 968 accessible' regarding ISO 29100 970 -11 972 o s/bing/being/ 974 o Added history for -10 976 -10 978 o #20: KM1 -- some wording that is awkward in the TLS section. 980 o #21: KM2 - the additional attacks against OAuth 2.0 should also 981 have a pointer 983 o #22: KM3 -- Nit: in the first line of 10.4: 985 o #23: KM4 -- Mention RFC6973 in Section 11 in addition to ISO 29100 987 o #24: SECDIR review: Section 4 -- Confusing requirements for 988 sign+encrypt 990 o #25: SECDIR review: Section 6 -- authentication and integrity need 991 not be provided if the requestor encrypts the token? 993 o #26: SECDIR Review: Section 10 -- why no reference for JWS 994 algorithms? 996 o #27: SECDIR Review: Section 10.2 - how to do the agreement between 997 client and server "a priori"? 999 o #28: SECDIR Review: Section 10.3 - Indication on "large entropy" 1000 and "short lifetime" should be indicated 1002 o #29: SECDIR Review: Section 10.3 - Typo 1004 o #30: SECDIR Review: Section 10.4 - typos and missing articles 1006 o #31: SECDIR Review: Section 10.4 - Clearer statement on the lack 1007 of endpoint identifiers needed 1009 o #32: SECDIR Review: Section 11 - ISO29100 needs to be moved to 1010 normative reference 1012 o #33: SECDIR Review: Section 11 - Better English and Entropy 1013 language needed 1015 o #34: Section 4: Typo 1017 o #35: More Acknowledgment 1019 o #36: DP - More precise qualification on Encryption needed. 1021 -09 1023 o Minor Editorial Nits. 1025 o Section 10.4 added. 1027 o Explicit reference to Security consideration (10.2) added in 1028 section 5 and section 5.2. 1030 o , (add yourself) removed from the acknowledgment. 1032 -08 1034 o Applied changes proposed by Hannes on 2016-06-29 on IETF OAuth 1035 list recorded as https://bitbucket.org/Nat/oauth-jwsreq/ 1036 issues/12/. 1038 o TLS requirements added. 1040 o Security Consideration reinforced. 1042 o Privacy Consideration added. 1044 o Introduction improved. 1046 -07 1048 o Changed the abbrev to OAuth JAR from oauth-jar. 1050 o Clarified sig and enc methods. 1052 o Better English. 1054 o Removed claims from one of the example. 1056 o Re-worded the URI construction. 1058 o Changed the example to use request instead of request_uri. 1060 o Clarified that Request Object parameters take precedence 1061 regardless of request or request_uri parameters were used. 1063 o Generalized the language in 4.2.1 to convey the intent more 1064 clearly. 1066 o Changed "Server" to "Authorization Server" as a clarification. 1068 o Stopped talking about request_object_signing_alg. 1070 o IANA considerations now reflect the current status. 1072 o Added Brian Campbell to the contributors list. Made the lists 1073 alphabetic order based on the last names. Clarified that the 1074 affiliation is at the time of the contribution. 1076 o Added "older versions of " to the reference to IE uri length 1077 limitations. 1079 o Stopped talking about signed or unsigned JWS etc. 1081 o 1.Introduction improved. 1083 -06 1085 o Added explanation on the 512 chars URL restriction. 1087 o Updated Acknowledgements. 1089 -05 1091 o More alignment with OpenID Connect. 1093 -04 1095 o Fixed typos in examples. (request_url -> request_uri, cliend_id -> 1096 client_id) 1098 o Aligned the error messages with the OAuth IANA registry. 1100 o Added another rationale for having request object. 1102 -03 1104 o Fixed the non-normative description about the advantage of static 1105 signature. 1107 o Changed the requirement for the parameter values in the request 1108 itself and the request object from 'MUST MATCH" to 'Req Obj takes 1109 precedence. 1111 -02 1113 o Now that they are RFCs, replaced JWS, JWE, etc. with RFC numbers. 1115 -01 1117 o Copy Edits. 1119 15. References 1121 15.1. Normative References 1123 [BCP195] Sheffer, Y., Holz, R., and P. Saint-Andre, 1124 "Recommendations for Secure Use of Transport Layer 1125 Security (TLS) and Datagram Transport Layer Security 1126 (DTLS)", BCP 195, RFC 7525, May 2015. 1128 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 1129 Requirement Levels", BCP 14, RFC 2119, 1130 DOI 10.17487/RFC2119, March 1997, 1131 . 1133 [RFC3629] Yergeau, F., "UTF-8, a transformation format of ISO 1134 10646", STD 63, RFC 3629, DOI 10.17487/RFC3629, November 1135 2003, . 1137 [RFC3986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform 1138 Resource Identifier (URI): Generic Syntax", STD 66, 1139 RFC 3986, DOI 10.17487/RFC3986, January 2005, 1140 . 1142 [RFC6125] Saint-Andre, P. and J. Hodges, "Representation and 1143 Verification of Domain-Based Application Service Identity 1144 within Internet Public Key Infrastructure Using X.509 1145 (PKIX) Certificates in the Context of Transport Layer 1146 Security (TLS)", RFC 6125, DOI 10.17487/RFC6125, March 1147 2011, . 1149 [RFC6749] Hardt, D., Ed., "The OAuth 2.0 Authorization Framework", 1150 RFC 6749, DOI 10.17487/RFC6749, October 2012, 1151 . 1153 [RFC6750] Jones, M. and D. Hardt, "The OAuth 2.0 Authorization 1154 Framework: Bearer Token Usage", RFC 6750, 1155 DOI 10.17487/RFC6750, October 2012, 1156 . 1158 [RFC6819] Lodderstedt, T., Ed., McGloin, M., and P. Hunt, "OAuth 2.0 1159 Threat Model and Security Considerations", RFC 6819, 1160 DOI 10.17487/RFC6819, January 2013, 1161 . 1163 [RFC6973] Cooper, A., Tschofenig, H., Aboba, B., Peterson, J., 1164 Morris, J., Hansen, M., and R. Smith, "Privacy 1165 Considerations for Internet Protocols", RFC 6973, 1166 DOI 10.17487/RFC6973, July 2013, 1167 . 1169 [RFC7159] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data 1170 Interchange Format", RFC 7159, DOI 10.17487/RFC7159, March 1171 2014, . 1173 [RFC7230] Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer 1174 Protocol (HTTP/1.1): Message Syntax and Routing", 1175 RFC 7230, DOI 10.17487/RFC7230, June 2014, 1176 . 1178 [RFC7515] Jones, M., Bradley, J., and N. Sakimura, "JSON Web 1179 Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May 1180 2015, . 1182 [RFC7516] Jones, M. and J. Hildebrand, "JSON Web Encryption (JWE)", 1183 RFC 7516, DOI 10.17487/RFC7516, May 2015, 1184 . 1186 [RFC7518] Jones, M., "JSON Web Algorithms (JWA)", RFC 7518, 1187 DOI 10.17487/RFC7518, May 2015, 1188 . 1190 [RFC7519] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token 1191 (JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015, 1192 . 1194 [RFC8141] Saint-Andre, P. and J. Klensin, "Uniform Resource Names 1195 (URNs)", RFC 8141, DOI 10.17487/RFC8141, April 2017, 1196 . 1198 [RFC8259] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data 1199 Interchange Format", STD 90, RFC 8259, 1200 DOI 10.17487/RFC8259, December 2017, 1201 . 1203 15.2. Informative References 1205 [BASIN] Basin, D., Cremers, C., and S. Meier, "Provably Repairing 1206 the ISO/IEC 9798 Standard for Entity Authentication", 1207 Journal of Computer Security - Security and Trust 1208 Principles Volume 21 Issue 6, Pages 817-846, November 1209 2013, 1210 . 1213 [FETT] Fett, D., Kusters, R., and G. Schmitz, "A Comprehensive 1214 Formal Security Analysis of OAuth 2.0", CCS '16 1215 Proceedings of the 2016 ACM SIGSAC Conference on Computer 1216 and Communications Security Pages 1204-1215 , October 1217 2016, . 1221 [OpenID.Core] 1222 Sakimura, N., Bradley, J., Jones, M., de Medeiros, B., and 1223 C. Mortimore, "OpenID Connect Core 1.0", OpenID 1224 Foundation Standards, February 2014, 1225 . 1227 Authors' Addresses 1229 Nat Sakimura 1230 Nomura Research Institute 1231 Otemachi Financial City Grand Cube, 1-9-2 Otemachi 1232 Chiyoda-ku, Tokyo 100-0004 1233 Japan 1235 Phone: +81-3-5533-2111 1236 Email: n-sakimura@nri.co.jp 1237 URI: http://nat.sakimura.org/ 1238 John Bradley 1239 Yubico 1240 Casilla 177, Sucursal Talagante 1241 Talagante, RM 1242 Chile 1244 Phone: +1.202.630.5272 1245 Email: ve7jtb@ve7jtb.com 1246 URI: http://www.thread-safe.com/