idnits 2.17.1 draft-ietf-oauth-jwsreq-15.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 (July 21, 2017) is 2471 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: January 22, 2018 Yubico 6 July 21, 2017 8 The OAuth 2.0 Authorization Framework: JWT Secured Authorization Request 9 (JAR) 10 draft-ietf-oauth-jwsreq-15 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 http://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 January 22, 2018. 48 Copyright Notice 50 Copyright (c) 2017 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 (http://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 . . . . . . . . . 10 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 . . . . . . . . . . . . . . . . 12 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 . . . . . . . . . . . . . 14 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 it is a JWT, JSON strings MUST be represented 268 in UTF-8. Numerical values MUST be included as JSON numbers. It MAY 269 include any extension parameters. This JSON [RFC7159] constitutes 270 the JWT Claims Set defined in JWT [RFC7519]. The JWT Claims Set is 271 then 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 WAP / feature phones do not accept large payloads. The 428 restriction is typically either 512 or 1024 ASCII characters. 430 2. The maximum URL length supported by older versions of Internet 431 Explorer is 2083 ASCII characters. 433 3. On a slow connection such as 2G mobile connection, a large URL 434 would cause the slow response and therefore the use of such is 435 not advisable from the user experience point of view. 437 The contents of the resource referenced by the URI MUST be a Request 438 Object. The "request_uri" value MUST be either URN as defined in 439 RFC8141 [RFC8141] or "https" URI, as defined in 2.7.2 of RFC7230 440 [RFC7230] . The "request_uri" value MUST be reachable by the 441 Authorization Server. 443 The following is an example of the contents of a Request Object 444 resource that can be referenced by a "request_uri" (with line wraps 445 within values for display purposes only): 447 eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiAiczZCaGRSa3 448 F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmNvbSIsDQogInJl 449 c3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWVudF9pZCI6ICJzNk 450 JoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8vY2xpZW50LmV4YW1w 451 bGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiAic3RhdGUiOiAiYWYwaW 452 Zqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWoiLA0KICJtYXhfYWdlIjog 453 ODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXNlcmluZm8iOiANCiAgICB7DQ 454 ogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgIm5p 455 Y2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjogeyJlc3NlbnRpYWwiOiB0cnVlfS 456 wNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAg 457 ICAgInBpY3R1cmUiOiBudWxsDQogICAgfSwNCiAgICJpZF90b2tlbiI6IA0KICAgIH 458 sNCiAgICAgImdlbmRlciI6IG51bGwsDQogICAgICJiaXJ0aGRhdGUiOiB7ImVzc2Vu 459 dGlhbCI6IHRydWV9LA0KICAgICAiYWNyIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOm 460 luY29tbW9uOmlhcDpzaWx2ZXIiXX0NCiAgICB9DQogIH0NCn0.nwwnNsk1-Zkbmnvs 461 F6zTHm8CHERFMGQPhos-EJcaH4Hh-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyF 462 KzuMXZFSZ3p6Mb8dkxtVyjoy2GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx 463 0GxFbuPbj96tVuj11pTnmFCUR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8K 464 ol-cSLWoYE9l5QqholImzjT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPG 465 iyon_-Te111V8uE83IlzCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 467 5.2.1. URI Referencing the Request Object 469 The Client stores the Request Object resource either locally or 470 remotely at a URI the Authorization Server can access. Such facility 471 may be provided by the authorization server or a third party. For 472 example, the authorization server may provide a URL to which the 473 client POSTs the request object and obtains the Requiest URI. This 474 URI is the Request Object URI, "request_uri". 476 It is possible for the Request Object to include values that are to 477 be revealed only to the Authorization Server. As such, the 478 "request_uri" MUST have appropriate entropy for its lifetime. It is 479 RECOMMENDED that it be removed after a reasonable timeout unless 480 access control measures are taken. 482 The following is an example of a Request Object URI value (with line 483 wraps within values for display purposes only): 485 https://tfp.example.org/request.jwt# 486 GkurKxf5T0Y-mnPFCHqWOMiZi4VS138cQO_V7PZHAdM 488 5.2.2. Request using the "request_uri" Request Parameter 490 The Client sends the Authorization Request to the Authorization 491 Endpoint. 493 The following is an example of an Authorization Request using the 494 "request_uri" parameter (with line wraps within values for display 495 purposes only): 497 https://server.example.com/authorize? 498 response_type=code%20id_token 499 &client_id=s6BhdRkqt3 500 &request_uri=https%3A%2F%2Ftfp.example.org%2Frequest.jwt 501 %23GkurKxf5T0Y-mnPFCHqWOMiZi4VS138cQO_V7PZHAdM 502 &state=af0ifjsldkj 504 5.2.3. Authorization Server Fetches Request Object 506 Upon receipt of the Request, the Authorization Server MUST send an 507 HTTP "GET" request to the "request_uri" to retrieve the referenced 508 Request Object, unless it is stored in a way so that it can retrieve 509 it through other mechanism securely, and parse it to recreate the 510 Authorization Request parameters. 512 The following is an example of this fetch process: 514 GET /request.jwt HTTP/1.1 515 Host: tfp.example.org 517 The following is an example of the fetch response: 519 HTTP/1.1 200 OK 520 Date: Thu, 16 Feb 2017 23:52:39 GMT 521 Server: Apache/2.2.22 (tfp.example.org) 522 Content-type: application/jwt 523 Content-Length: 1250 524 Last-Modified: Wed, 15 Feb 2017 23:52:32 GMT 526 eyJhbGciOiJSUzI1NiIsImtpZCI6ImsyYmRjIn0.ew0KICJpc3MiOiAiczZCaGRSa3 527 F0MyIsDQogImF1ZCI6ICJodHRwczovL3NlcnZlci5leGFtcGxlLmNvbSIsDQogInJl 528 c3BvbnNlX3R5cGUiOiAiY29kZSBpZF90b2tlbiIsDQogImNsaWVudF9pZCI6ICJzNk 529 JoZFJrcXQzIiwNCiAicmVkaXJlY3RfdXJpIjogImh0dHBzOi8vY2xpZW50LmV4YW1w 530 bGUub3JnL2NiIiwNCiAic2NvcGUiOiAib3BlbmlkIiwNCiAic3RhdGUiOiAiYWYwaW 531 Zqc2xka2oiLA0KICJub25jZSI6ICJuLTBTNl9XekEyTWoiLA0KICJtYXhfYWdlIjog 532 ODY0MDAsDQogImNsYWltcyI6IA0KICB7DQogICAidXNlcmluZm8iOiANCiAgICB7DQ 533 ogICAgICJnaXZlbl9uYW1lIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAgICAgIm5p 534 Y2tuYW1lIjogbnVsbCwNCiAgICAgImVtYWlsIjogeyJlc3NlbnRpYWwiOiB0cnVlfS 535 wNCiAgICAgImVtYWlsX3ZlcmlmaWVkIjogeyJlc3NlbnRpYWwiOiB0cnVlfSwNCiAg 536 ICAgInBpY3R1cmUiOiBudWxsDQogICAgfSwNCiAgICJpZF90b2tlbiI6IA0KICAgIH 537 sNCiAgICAgImdlbmRlciI6IG51bGwsDQogICAgICJiaXJ0aGRhdGUiOiB7ImVzc2Vu 538 dGlhbCI6IHRydWV9LA0KICAgICAiYWNyIjogeyJ2YWx1ZXMiOiBbInVybjptYWNlOm 539 luY29tbW9uOmlhcDpzaWx2ZXIiXX0NCiAgICB9DQogIH0NCn0.nwwnNsk1-Zkbmnvs 540 F6zTHm8CHERFMGQPhos-EJcaH4Hh-sMgk8ePrGhw_trPYs8KQxsn6R9Emo_wHwajyF 541 KzuMXZFSZ3p6Mb8dkxtVyjoy2GIzvuJT_u7PkY2t8QU9hjBcHs68PkgjDVTrG1uRTx 542 0GxFbuPbj96tVuj11pTnmFCUR6IEOXKYr7iGOCRB3btfJhM0_AKQUfqKnRlrRscc8K 543 ol-cSLWoYE9l5QqholImzjT_cMnNIznW9E7CDyWXTsO70xnB4SkG6pXfLSjLLlxmPG 544 iyon_-Te111V8uE83IlzCYIb_NMXvtTIVc1jpspnTSD7xMbpL-2QgwUsAlMGzw 546 6. Validating JWT-Based Requests 548 6.1. Encrypted Request Object 550 If the request object is encrypted, the Authorization Server MUST 551 decrypt the JWT in accordance with the JSON Web Encryption [RFC7516] 552 specification. 554 The result is a signed request object and the signature validation 555 MUST be performed as defined in Section 6.2 as well. 557 If decryption fails, the Authorization Server MUST return an 558 "invalid_request_object" error. 560 6.2. JWS Signed Request Object 562 To perform signature validation of a JSON Web Signature [RFC7515] 563 signed request object, the "alg" Header Parameter in its JOSE Header 564 MUST match the value of the pre-registered algorithm. The signature 565 MUST be validated against the appropriate key for that "client_id" 566 and algorithm. 568 If signature validation fails, the Authorization Server MUST return 569 an "invalid_request_object" error. 571 6.3. Request Parameter Assembly and Validation 573 The Authorization Server MUST extract the set of Authorization 574 Request parameters from the Request Object value. The Authorization 575 Server MUST only use the parameters in the Request Object even if the 576 same parameter is provided in the query parameter. The Authorization 577 Server then validates the request as specified in OAuth 2.0 578 [RFC6749]. 580 If the validation fails, then the Authorization Server MUST return an 581 error as specified in OAuth 2.0 [RFC6749]. 583 7. Authorization Server Response 585 Authorization Server Response is created and sent to the client as in 586 Section 4 of OAuth 2.0 [RFC6749] . 588 In addition, this document uses these additional error values: 590 invalid_request_uri The "request_uri" in the Authorization Request 591 returns an error or contains invalid data. 593 invalid_request_object The request parameter contains an invalid 594 Request Object. 596 request_not_supported The Authorization Server does not support the 597 use of the "request" parameter. 599 request_uri_not_supported The Authorization Server does not support 600 the use of the "request_uri" parameter. 602 8. TLS Requirements 604 Client implementations supporting the Request Object URI method MUST 605 support TLS following Recommendations for Secure Use of Transport 606 Layer Security (TLS) and Datagram Transport Layer Security (DTLS) 607 [BCP195]. 609 To protect against information disclosure and tampering, 610 confidentiality protection MUST be applied using TLS with a cipher 611 suite that provides confidentiality and integrity protection. 613 HTTP clients MUST also verify the TLS server certificate, using 614 subjectAltName dNSName identities as described in [RFC6125], to avoid 615 man-in-the-middle attacks. The rules and guidelines defined in 616 [RFC6125] apply here, with the following considerations: 618 o Support for DNS-ID identifier type (that is, the dNSName identity 619 in the subjectAltName extension) is REQUIRED. Certification 620 authorities which issue server certificates MUST support the DNS- 621 ID identifier type, and the DNS-ID identifier type MUST be present 622 in server certificates. 624 o DNS names in server certificates MAY contain the wildcard 625 character "*". 627 o Clients MUST NOT use CN-ID identifiers; a CN field may be present 628 in the server certificate's subject name, but MUST NOT be used for 629 authentication within the rules described in [BCP195] . 631 o SRV-ID and URI-ID as described in Section 6.5 of [RFC6125] MUST 632 NOT be used for comparison. 634 9. IANA Considerations 636 This specification requests no actions by IANA. 638 10. Security Considerations 640 In addition to the all the security considerations discussed in OAuth 641 2.0 [RFC6819], the security considerations in [RFC7515], [RFC7516], 642 and [RFC7518] needs to be considered. Also, there are several 643 academic papers such as [BASIN] that provide useful insight into the 644 security properties of protocols like OAuth. 646 In consideration of the above, this document advises taking the 647 following security considerations into account. 649 10.1. Choice of Algorithms 651 When sending the authorization request object through "request" 652 parameter, it MUST either be signed using JWS [RFC7515] or encrypted 653 using JWE [RFC7516] with then considered appropriate algorithm. 655 10.2. Request Source Authentication 657 The source of the Authorization Request MUST always be verified. 658 There are several ways to do it in this specification. 660 (a) Verifying the JWS Signature of the Request Object. 662 (b) Verifying that the symmetric key for the JWE encryption is the 663 correct one if the JWE is using symmetric encryption. 665 (c) Verifying the TLS Server Identity of the Request Object URI. In 666 this case, the Authorization Server MUST know out-of-band that 667 the Client uses Request Object URI and only the Client is 668 covered by the TLS certificate. In general, it is not a 669 reliable method. 671 (d) Authorization Server is providing an endpoint that provides a 672 Request Object URI in exchange for a Request Object. In this 673 case, the Authorization Server MUST perform Client 674 Authentication to accept the Request Object and bind the Client 675 Identifier to the Request Object URI it is providing. Since 676 Request Object URI can be replayed, the lifetime of the Request 677 Object URI MUST be short and preferably one-time use. The 678 entropy of the Request Object URI MUST be sufficiently large. 679 The adequate shortness of the validity and the entropy of the 680 Request Object URI depends on the risk calculation based on the 681 value of the resource being protected. A general guidance for 682 the validity time would be less than a minute and the Request 683 Object URI is to include a cryptographic random value of 128bit 684 or more at the time of the writing of this specification. 686 (e) A third party, such as a Trust Framework Provider, provides an 687 endpoint that provides a Request Object URI in exchange for a 688 Request Object. The same requirements as (b) above apply. In 689 addition, the Authorization Server MUST know out-of-band that 690 the Client utilizes the Trust Framework Operator. 692 10.3. Explicit Endpoints 694 Although this specification does not require them, research such as 695 [BASIN] points out that it is a good practice to explicitly state the 696 intended interaction endpoints and the message position in the 697 sequence in a tamper evident manner so that the intent of the 698 initiator is unambiguous. The endpoints that come into question in 699 this specification are : 701 (a) Protected Resources ("protected_resources") 703 (b) Authorization Endpoint ("authorization_endpoint") 705 (c) Redirection URI ("redirect_uri") 707 (d) Token Endpoint ("token_endpoint") 708 Further, if dynamic discovery is used, then the discovery related 709 endpoints also come into question. 711 In [RFC6749], while Redirection URI is included, others are not 712 included in the Authorization Request. As the result, the same 713 applies to Authorization Request Object. 715 The lack of the link among those endpoints are sited as the cause of 716 Cross-Phase Attacks introduced in [FETT]. An extension specification 717 should be created as a measure to address the risk. 719 10.4. Risks Associated with request_uri 721 The introdcution of "redirect_uri" introduces several attack 722 possibilities. 724 10.4.1. DDoS Attack on the Authorization Server 726 A set of malicious client can launch a DoS attack to the 727 authorization server by pointing the "request_uri" to a uri that 728 returns extremely large content or extremely slow to respond. Under 729 such an attack, the server may use up its resource and start failing. 731 Similarly, a malicious client can specify the "request_uri" value 732 that itself points to an authorization request URI that uses 733 "request_uri" to cause the recursive lookup. 735 To prevent such attack to succeed, the server should (a) check that 736 the value of "request_uri" parameter does not point to an unexpected 737 location, (b) check the content type of the response is "application/ 738 jose" (c) implement a time-out for obtaining the content of 739 "request_uri", and (d) do not perform recursive GET on the 740 "request_uri". 742 10.4.2. Request URI Rewrite 744 The value of "request_uri" is not signed thus it can be tampered by 745 Man-in-the-browser attacker. Several attack possibilities rise 746 because of this, e.g., (a) attacker may create another file that the 747 rewritten URI points to making it possible to request extra scope (b) 748 attacker launches a DoS attack to a victim site by setting the value 749 of "request_uri" to be that of the victim. 751 To prevent such attack to succeed, the server should (a) check that 752 the value of "request_uri" parameter does not point to an unexpected 753 location, (b) check the content type of the response is "application/ 754 json" (c) implement a time-out for obtaining the content of 755 "request_uri". 757 11. TLS security considerations 759 Curent security considerations can be found in Recommendations for 760 Secure Use of TLS and DTLS [BCP195]. This supersedes the TLS version 761 recommendations in OAuth 2.0 [RFC6749]. 763 12. Privacy Considerations 765 When the Client is being granted access to a protected resource 766 containing personal data, both the Client and the Authorization 767 Server need to adhere to Privacy Principles. RFC 6973 Privacy 768 Considerations for Internet Protocols [RFC6973] gives excellent 769 guidance on the enhancement of protocol design and implementation. 770 The provision listed in it should be followed. 772 Most of the provision would apply to The OAuth 2.0 Authorization 773 Framework [RFC6749] and The OAuth 2.0 Authorization Framework: Bearer 774 Token Usage [RFC6750] and are not specific to this specification. In 775 what follows, only the specific provisions to this specification are 776 noted. 778 12.1. Collection limitation 780 When the Client is being granted access to a protected resource 781 containing personal data, the Client SHOULD limit the collection of 782 personal data to that which is within the bounds of applicable law 783 and strictly necessary for the specified purpose(s). 785 It is often hard for the user to find out if the personal data asked 786 for is strictly necessary. A Trust Framework Provider can help the 787 user by examining the Client request and comparing to the proposed 788 processing by the Client and certifying the request. After the 789 certification, the Client, when making an Authorization Request, can 790 submit Authorization Request to the Trust Framework Provider to 791 obtain the Request Object URI. 793 Upon receiving such Request Object URI in the Authorization Request, 794 the Authorization Server first verifies that the authority portion of 795 the Request Object URI is a legitimate one for the Trust Framework 796 Provider. Then, the Authorization Server issues HTTP GET request to 797 the Request Object URI. Upon connecting, the Authorization Server 798 MUST verify the server identity represented in the TLS certificate is 799 legitimate for the Request Object URI. Then, the Authorization 800 Server can obtain the Request Object, which includes the "client_id" 801 representing the Client. 803 The Consent screen MUST indicate the Client and SHOULD indicate that 804 the request has been vetted by the Trust Framework Operator for the 805 adherence to the Collection Limitation principle. 807 12.2. Disclosure Limitation 809 12.2.1. Request Disclosure 811 This specification allows extension parameters. These may include 812 potentially sensitive information. Since URI query parameter may 813 leak through various means but most notably through referrer and 814 browser history, if the authorization request contains a potentially 815 sensitive parameter, the Client SHOULD JWE [RFC7516] encrypt the 816 request object. 818 Where Request Object URI method is being used, if the request object 819 contains personally identifiable or sensitive information, the 820 "request_uri" SHOULD be used only once, have a short validity period, 821 and MUST have large enough entropy deemed necessary with applicable 822 security policy unless the Request Object itself is JWE [RFC7516] 823 Encrypted. The adequate shortness of the validity and the entropy of 824 the Request Object URI depends on the risk calculation based on the 825 value of the resource being protected. A general guidance for the 826 validity time would be less than a minute and the Request Object URI 827 is to include a cryptographic random value of 128bit or more at the 828 time of the writing of this specification. 830 12.2.2. Tracking using Request Object URI 832 Even if the protected resource does not include a personally 833 identifiable information, it is sometimes possible to identify the 834 user through the Request Object URI if persistent per-user Request 835 Object URI is used. A third party may observe it through browser 836 history etc. and start correlating the user's activity using it. In 837 a way, it is a data disclosure as well and should be avoided. 839 Therefore, per-user Request Object URI should be avoided. 841 13. Acknowledgements 843 The following people contributed to the creation of this document in 844 the OAuth WG. (Affiliations at the time of the contribution are 845 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), Kathleen Moriarty (as AD), and Steve Kent (as SECDIR). 852 The following people contributed to creating this document through 853 the OpenID Connect Core 1.0 [OpenID.Core]. 855 Brian Campbell (Ping Identity), George Fletcher (AOL), Ryo Itou 856 (Mixi), Edmund Jay (Illumila), Michael B. Jones (Microsoft), Breno 857 de Medeiros (Google), Hideki Nara (TACT), Justin Richer (MITRE). 859 In addition, the following people contributed to this and previous 860 versions through the OAuth Working Group. 862 Dirk Balfanz (Google), James H. Manger (Telstra), John Panzer 863 (Google), David Recordon (Facebook), Marius Scurtescu (Google), Luke 864 Shepard (Facebook). 866 14. Revision History 868 -15 870 o Removed further duplication 872 -14 874 o #71 Reiterate dynamic params are included. 876 o #70 Made clear that AS must return error. 878 o #69 Inconsistency of the need to sign. 880 o Fixed Mimetype. 882 o #67 Incosistence in requiring HTTPS in request uri. 884 o #66 Dropped ISO 29100 reference. 886 o #25 Removed Encrypt only option. 888 o #59 Same with #25. 890 -13 892 o add TLS Security Consideration section 894 o replace RFC7525 reference with BCP195 896 o moved front tag in FETT reference to fix XML structure 898 o changes reference from SoK to FETT 899 -12 901 o fixes #62 - Alexey Melnikov Discuss 903 o fixes #48 - OPSDIR Review : General - delete semicolors after list 904 items 906 o fixes #58 - DP Comments for the Last Call 908 o fixes #57 - GENART - Remove "non-normative ... " from examples. 910 o fixes #45 - OPSDIR Review : Introduction - are attacks discovered 911 or already opened 913 o fixes #49 - OPSDIR Review : Introduction - Inconsistent colons 914 after initial sentence of list items. 916 o fixes #53 - OPSDIR Review : 6.2 JWS Signed Request Object - 917 Clarify JOSE Header 919 o fixes #42 - OPSDIR Review : Introduction - readability of 'and' is 920 confusing 922 o fixes #50 - OPSDIR Review : Section 4 Request Object - Clarify 923 'signed, encrypted, or signed and encrypted' 925 o fixes #39 - OPSDIR Review : Abstract - Explain/Clarify JWS and JWE 927 o fixed #50 - OPSDIR Review : Section 4 Request Object - Clarify 928 'signed, encrypted, or signed and encrypted' 930 o fixes #43 - OPSDIR Review : Introduction - 'properties' sounds 931 awkward and are not exactly 'properties' 933 o fixes #56 - OPSDIR Review : 12 Acknowledgements - 'contribution 934 is' => 'contribution are' 936 o fixes #55 - OPSDIR Review : 11.2.2 Privacy Considerations - ' It 937 is in a way' => 'In a way, it is' 939 o fixes #54 - OPSDIR Review : 11 Privacy Considerations - 'and not 940 specific' => 'and are not specific' 942 o fixes #51 - OPSDIR Review : Section 4 Request Object - 'It is 943 fine' => 'It is recommended' 945 o fixes #47 - OPSDIR Review : Introduction - 'over- the- wire' => 946 'over-the-wire' 948 o fixes #46 - OPSDIR Review : Introduction - 'It allows' => 'The use 949 of application security' for 951 o fixes #44 - OPSDIR Review : Introduction - 'has' => 'have' 953 o fixes #41 - OPSDIR Review : Introduction - missing 'is' before 954 'typically sent' 956 o fixes #38 - OPSDIR Review : Section 11 - Delete 'freely 957 accessible' regarding ISO 29100 959 -11 961 o s/bing/being/ 963 o Added history for -10 965 -10 967 o #20: KM1 -- some wording that is awkward in the TLS section. 969 o #21: KM2 - the additional attacks against OAuth 2.0 should also 970 have a pointer 972 o #22: KM3 -- Nit: in the first line of 10.4: 974 o #23: KM4 -- Mention RFC6973 in Section 11 in addition to ISO 29100 976 o #24: SECDIR review: Section 4 -- Confusing requirements for 977 sign+encrypt 979 o #25: SECDIR review: Section 6 -- authentication and integrity need 980 not be provided if the requestor encrypts the token? 982 o #26: SECDIR Review: Section 10 -- why no reference for JWS 983 algorithms? 985 o #27: SECDIR Review: Section 10.2 - how to do the agreement between 986 client and server "a priori"? 988 o #28: SECDIR Review: Section 10.3 - Indication on "large entropy" 989 and "short lifetime" should be indicated 991 o #29: SECDIR Review: Section 10.3 - Typo 993 o #30: SECDIR Review: Section 10.4 - typos and missing articles 994 o #31: SECDIR Review: Section 10.4 - Clearer statement on the lack 995 of endpoint identifiers needed 997 o #32: SECDIR Review: Section 11 - ISO29100 needs to be moved to 998 normative reference 1000 o #33: SECDIR Review: Section 11 - Better English and Entropy 1001 language needed 1003 o #34: Section 4: Typo 1005 o #35: More Acknowledgment 1007 o #36: DP - More precise qualification on Encryption needed. 1009 -09 1011 o Minor Editorial Nits. 1013 o Section 10.4 added. 1015 o Explicit reference to Security consideration (10.2) added in 1016 section 5 and section 5.2. 1018 o , (add yourself) removed from the acknowledgment. 1020 -08 1022 o Applied changes proposed by Hannes on 2016-06-29 on IETF OAuth 1023 list recorded as https://bitbucket.org/Nat/oauth-jwsreq/ 1024 issues/12/. 1026 o TLS requirements added. 1028 o Security Consideration reinforced. 1030 o Privacy Consideration added. 1032 o Introduction improved. 1034 -07 1036 o Changed the abbrev to OAuth JAR from oauth-jar. 1038 o Clarified sig and enc methods. 1040 o Better English. 1042 o Removed claims from one of the example. 1044 o Re-worded the URI construction. 1046 o Changed the example to use request instead of request_uri. 1048 o Clarified that Request Object parameters take precedence 1049 regardless of request or request_uri parameters were used. 1051 o Generalized the language in 4.2.1 to convey the intent more 1052 clearly. 1054 o Changed "Server" to "Authorization Server" as a clarification. 1056 o Stopped talking about request_object_signing_alg. 1058 o IANA considerations now reflect the current status. 1060 o Added Brian Campbell to the contributors list. Made the lists 1061 alphabetic order based on the last names. Clarified that the 1062 affiliation is at the time of the contribution. 1064 o Added "older versions of " to the reference to IE uri length 1065 limitations. 1067 o Stopped talking about signed or unsigned JWS etc. 1069 o 1.Introduction improved. 1071 -06 1073 o Added explanation on the 512 chars URL restriction. 1075 o Updated Acknowledgements. 1077 -05 1079 o More alignment with OpenID Connect. 1081 -04 1083 o Fixed typos in examples. (request_url -> request_uri, cliend_id -> 1084 client_id) 1086 o Aligned the error messages with the OAuth IANA registry. 1088 o Added another rationale for having request object. 1090 -03 1092 o Fixed the non-normative description about the advantage of static 1093 signature. 1095 o Changed the requirement for the parameter values in the request 1096 itself and the request object from 'MUST MATCH" to 'Req Obj takes 1097 precedence. 1099 -02 1101 o Now that they are RFCs, replaced JWS, JWE, etc. with RFC numbers. 1103 -01 1105 o Copy Edits. 1107 15. References 1109 15.1. Normative References 1111 [BCP195] Sheffer, Y., Holz, R., and P. Saint-Andre, 1112 "Recommendations for Secure Use of Transport Layer 1113 Security (TLS) and Datagram Transport Layer Security 1114 (DTLS)", BCP 195, RFC 7525, May 2015. 1116 [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate 1117 Requirement Levels", BCP 14, RFC 2119, 1118 DOI 10.17487/RFC2119, March 1997, 1119 . 1121 [RFC3986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform 1122 Resource Identifier (URI): Generic Syntax", STD 66, 1123 RFC 3986, DOI 10.17487/RFC3986, January 2005, 1124 . 1126 [RFC6125] Saint-Andre, P. and J. Hodges, "Representation and 1127 Verification of Domain-Based Application Service Identity 1128 within Internet Public Key Infrastructure Using X.509 1129 (PKIX) Certificates in the Context of Transport Layer 1130 Security (TLS)", RFC 6125, DOI 10.17487/RFC6125, March 1131 2011, . 1133 [RFC6749] Hardt, D., Ed., "The OAuth 2.0 Authorization Framework", 1134 RFC 6749, DOI 10.17487/RFC6749, October 2012, 1135 . 1137 [RFC6750] Jones, M. and D. Hardt, "The OAuth 2.0 Authorization 1138 Framework: Bearer Token Usage", RFC 6750, 1139 DOI 10.17487/RFC6750, October 2012, 1140 . 1142 [RFC6819] Lodderstedt, T., Ed., McGloin, M., and P. Hunt, "OAuth 2.0 1143 Threat Model and Security Considerations", RFC 6819, 1144 DOI 10.17487/RFC6819, January 2013, 1145 . 1147 [RFC6973] Cooper, A., Tschofenig, H., Aboba, B., Peterson, J., 1148 Morris, J., Hansen, M., and R. Smith, "Privacy 1149 Considerations for Internet Protocols", RFC 6973, 1150 DOI 10.17487/RFC6973, July 2013, 1151 . 1153 [RFC7159] Bray, T., Ed., "The JavaScript Object Notation (JSON) Data 1154 Interchange Format", RFC 7159, DOI 10.17487/RFC7159, March 1155 2014, . 1157 [RFC7230] Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer 1158 Protocol (HTTP/1.1): Message Syntax and Routing", 1159 RFC 7230, DOI 10.17487/RFC7230, June 2014, 1160 . 1162 [RFC7515] Jones, M., Bradley, J., and N. Sakimura, "JSON Web 1163 Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, May 1164 2015, . 1166 [RFC7516] Jones, M. and J. Hildebrand, "JSON Web Encryption (JWE)", 1167 RFC 7516, DOI 10.17487/RFC7516, May 2015, 1168 . 1170 [RFC7518] Jones, M., "JSON Web Algorithms (JWA)", RFC 7518, 1171 DOI 10.17487/RFC7518, May 2015, 1172 . 1174 [RFC7519] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token 1175 (JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015, 1176 . 1178 [RFC8141] Saint-Andre, P. and J. Klensin, "Uniform Resource Names 1179 (URNs)", RFC 8141, DOI 10.17487/RFC8141, April 2017, 1180 . 1182 15.2. Informative References 1184 [BASIN] Basin, D., Cremers, C., and S. Meier, "Provably Repairing 1185 the ISO/IEC 9798 Standard for Entity Authentication", 1186 Journal of Computer Security - Security and Trust 1187 Principles Volume 21 Issue 6, Pages 817-846, November 1188 2013, 1189 . 1192 [FETT] Fett, D., Kusters, R., and G. Schmitz, "A Comprehensive 1193 Formal Security Analysis of OAuth 2.0", CCS '16 1194 Proceedings of the 2016 ACM SIGSAC Conference on Computer 1195 and Communications Security Pages 1204-1215 , October 1196 2016, . 1200 [OpenID.Core] 1201 Sakimura, N., Bradley, J., Jones, M., de Medeiros, B., and 1202 C. Mortimore, "OpenID Connect Core 1.0", OpenID 1203 Foundation Standards, February 2014, 1204 . 1206 Authors' Addresses 1208 Nat Sakimura 1209 Nomura Research Institute 1210 Otemachi Financial City Grand Cube, 1-9-2 Otemachi 1211 Chiyoda-ku, Tokyo 100-0004 1212 Japan 1214 Phone: +81-3-5533-2111 1215 Email: n-sakimura@nri.co.jp 1216 URI: http://nat.sakimura.org/ 1218 John Bradley 1219 Yubico 1220 Casilla 177, Sucursal Talagante 1221 Talagante, RM 1222 Chile 1224 Phone: +1.202.630.5272 1225 Email: ve7jtb@ve7jtb.com 1226 URI: http://www.thread-safe.com/