| 1 |
<pre>Internet Engineering Task Force (IETF) A. Popov |
| 2 |
Request for Comments: 8473 M. Nystroem |
| 3 |
Category: Standards Track Microsoft Corp. |
| 4 |
ISSN: 2070-1721 D. Balfanz, Ed. |
| 5 |
N. Harper |
| 6 |
Google Inc. |
| 7 |
J. Hodges |
| 8 |
Kings Mountain Systems |
| 9 |
October 2018 |
| 10 |
|
| 11 |
|
| 12 |
<span class="h1">Token Binding over HTTP</span> |
| 13 |
|
| 14 |
Abstract |
| 15 |
|
| 16 |
This document describes a collection of mechanisms that allow HTTP |
| 17 |
servers to cryptographically bind security tokens (such as cookies |
| 18 |
and OAuth tokens) to TLS connections. |
| 19 |
|
| 20 |
We describe both first-party and federated scenarios. In a first- |
| 21 |
party scenario, an HTTP server is able to cryptographically bind the |
| 22 |
security tokens that it issues to a client -- and that the client |
| 23 |
subsequently returns to the server -- to the TLS connection between |
| 24 |
the client and the server. Such bound security tokens are protected |
| 25 |
from misuse, since the server can generally detect if they are |
| 26 |
replayed inappropriately, e.g., over other TLS connections. |
| 27 |
|
| 28 |
Federated Token Bindings, on the other hand, allow servers to |
| 29 |
cryptographically bind security tokens to a TLS connection that the |
| 30 |
client has with a different server than the one issuing the token. |
| 31 |
|
| 32 |
This document is a companion document to "The Token Binding Protocol |
| 33 |
Version 1.0" (<a href="./rfc8471">RFC 8471</a>). |
| 34 |
|
| 35 |
Status of This Memo |
| 36 |
|
| 37 |
This is an Internet Standards Track document. |
| 38 |
|
| 39 |
This document is a product of the Internet Engineering Task Force |
| 40 |
(IETF). It represents the consensus of the IETF community. It has |
| 41 |
received public review and has been approved for publication by the |
| 42 |
Internet Engineering Steering Group (IESG). Further information on |
| 43 |
Internet Standards is available in <a href="./rfc7841#section-2">Section 2 of RFC 7841</a>. |
| 44 |
|
| 45 |
Information about the current status of this document, any errata, |
| 46 |
and how to provide feedback on it may be obtained at |
| 47 |
<a href="https://www.rfc-editor.org/info/rfc8473">https://www.rfc-editor.org/info/rfc8473</a>. |
| 48 |
|
| 49 |
|
| 50 |
|
| 51 |
|
| 52 |
<span class="grey">Popov, et al. Standards Track [Page 1]</span></pre> |
| 53 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-2" ></span> |
| 54 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 55 |
|
| 56 |
|
| 57 |
Copyright Notice |
| 58 |
|
| 59 |
Copyright (c) 2018 IETF Trust and the persons identified as the |
| 60 |
document authors. All rights reserved. |
| 61 |
|
| 62 |
This document is subject to <a href="https://www.rfc-editor.org/bcp/bcp78">BCP 78</a> and the IETF Trust's Legal |
| 63 |
Provisions Relating to IETF Documents |
| 64 |
(<a href="https://trustee.ietf.org/license-info">https://trustee.ietf.org/license-info</a>) in effect on the date of |
| 65 |
publication of this document. Please review these documents |
| 66 |
carefully, as they describe your rights and restrictions with respect |
| 67 |
to this document. Code Components extracted from this document must |
| 68 |
include Simplified BSD License text as described in Section 4.e of |
| 69 |
the Trust Legal Provisions and are provided without warranty as |
| 70 |
described in the Simplified BSD License. |
| 71 |
|
| 72 |
Table of Contents |
| 73 |
|
| 74 |
<a href="#section-1">1</a>. Introduction . . . . . . . . . . . . . . . . . . . . . . . . <a href="#page-3">3</a> |
| 75 |
<a href="#section-1.1">1.1</a>. Requirements Language . . . . . . . . . . . . . . . . . . <a href="#page-3">3</a> |
| 76 |
<a href="#section-2">2</a>. The Sec-Token-Binding HTTP Request Header Field . . . . . . . <a href="#page-4">4</a> |
| 77 |
<a href="#section-2.1">2.1</a>. HTTPS Token Binding Key-Pair Scoping . . . . . . . . . . <a href="#page-5">5</a> |
| 78 |
<a href="#section-3">3</a>. TLS Renegotiation . . . . . . . . . . . . . . . . . . . . . . <a href="#page-6">6</a> |
| 79 |
<a href="#section-4">4</a>. First-Party Use Cases . . . . . . . . . . . . . . . . . . . . <a href="#page-7">7</a> |
| 80 |
<a href="#section-5">5</a>. Federation Use Cases . . . . . . . . . . . . . . . . . . . . <a href="#page-7">7</a> |
| 81 |
<a href="#section-5.1">5.1</a>. Introduction . . . . . . . . . . . . . . . . . . . . . . <a href="#page-7">7</a> |
| 82 |
<a href="#section-5.2">5.2</a>. Overview . . . . . . . . . . . . . . . . . . . . . . . . <a href="#page-8">8</a> |
| 83 |
<a href="#section-5.3">5.3</a>. HTTP Redirects . . . . . . . . . . . . . . . . . . . . . <a href="#page-10">10</a> |
| 84 |
<a href="#section-5.4">5.4</a>. Negotiated Key Parameters . . . . . . . . . . . . . . . . <a href="#page-12">12</a> |
| 85 |
<a href="#section-5.5">5.5</a>. Federation Example . . . . . . . . . . . . . . . . . . . <a href="#page-13">13</a> |
| 86 |
<a href="#section-6">6</a>. Implementation Considerations . . . . . . . . . . . . . . . . <a href="#page-15">15</a> |
| 87 |
<a href="#section-7">7</a>. Security Considerations . . . . . . . . . . . . . . . . . . . <a href="#page-16">16</a> |
| 88 |
<a href="#section-7.1">7.1</a>. Security Token Replay . . . . . . . . . . . . . . . . . . <a href="#page-16">16</a> |
| 89 |
<a href="#section-7.2">7.2</a>. Sensitivity of the Sec-Token-Binding Header . . . . . . . <a href="#page-16">16</a> |
| 90 |
<a href="#section-7.3">7.3</a>. Securing Federated Sign-On Protocols . . . . . . . . . . <a href="#page-17">17</a> |
| 91 |
<a href="#section-8">8</a>. Privacy Considerations . . . . . . . . . . . . . . . . . . . <a href="#page-20">20</a> |
| 92 |
<a href="#section-8.1">8.1</a>. Scoping of Token Binding Key Pairs . . . . . . . . . . . <a href="#page-20">20</a> |
| 93 |
<a href="#section-8.2">8.2</a>. Lifetime of Token Binding Key Pairs . . . . . . . . . . . <a href="#page-20">20</a> |
| 94 |
<a href="#section-8.3">8.3</a>. Correlation . . . . . . . . . . . . . . . . . . . . . . . <a href="#page-21">21</a> |
| 95 |
<a href="#section-9">9</a>. IANA Considerations . . . . . . . . . . . . . . . . . . . . . <a href="#page-22">22</a> |
| 96 |
<a href="#section-10">10</a>. References . . . . . . . . . . . . . . . . . . . . . . . . . <a href="#page-22">22</a> |
| 97 |
<a href="#section-10.1">10.1</a>. Normative References . . . . . . . . . . . . . . . . . . <a href="#page-22">22</a> |
| 98 |
<a href="#section-10.2">10.2</a>. Informative References . . . . . . . . . . . . . . . . . <a href="#page-23">23</a> |
| 99 |
Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . <a href="#page-25">25</a> |
| 100 |
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . <a href="#page-25">25</a> |
| 101 |
|
| 102 |
|
| 103 |
|
| 104 |
|
| 105 |
|
| 106 |
|
| 107 |
|
| 108 |
<span class="grey">Popov, et al. Standards Track [Page 2]</span></pre> |
| 109 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-3" ></span> |
| 110 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 111 |
|
| 112 |
|
| 113 |
<span class="h2"><a class="selflink" id="section-1" href="#section-1">1</a>. Introduction</span> |
| 114 |
|
| 115 |
The Token Binding protocol [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>] defines a Token Binding ID for a |
| 116 |
TLS connection between a client and a server. The Token Binding ID |
| 117 |
of a TLS connection is constructed using the public key of a |
| 118 |
private-public key pair. The client proves possession of the |
| 119 |
corresponding private key. This Token Binding key pair is |
| 120 |
long-lived. That is, subsequent TLS connections between the same |
| 121 |
client and server have the same Token Binding ID, unless specifically |
| 122 |
reset, e.g., by the user. When issuing a security token (e.g., an |
| 123 |
HTTP cookie or an OAuth token [<a href="./rfc6749" title=""The OAuth 2.0 Authorization Framework"">RFC6749</a>]) to a client, the server can |
| 124 |
include the Token Binding ID in the token, thus cryptographically |
| 125 |
binding the token to TLS connections between that particular client |
| 126 |
and server, and inoculating the token against abuse (reuse, attempted |
| 127 |
impersonation, etc.) by attackers. |
| 128 |
|
| 129 |
While the Token Binding protocol [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>] defines a message format |
| 130 |
for establishing a Token Binding ID, it does not specify how this |
| 131 |
message is embedded in higher-level protocols. The purpose of this |
| 132 |
specification is to define how TokenBindingMessages are embedded in |
| 133 |
HTTP (both versions 1.1 [<a href="./rfc7230" title=""Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing"">RFC7230</a>] and 2 [<a href="./rfc7540" title=""Hypertext Transfer Protocol Version 2 (HTTP/2)"">RFC7540</a>]). Note that |
| 134 |
TokenBindingMessages are only defined if the underlying transport |
| 135 |
uses TLS. This means that Token Binding over HTTP is only defined |
| 136 |
when HTTP is layered on top of TLS (commonly referred to as HTTPS |
| 137 |
[<a href="./rfc2818" title=""HTTP Over TLS"">RFC2818</a>]). |
| 138 |
|
| 139 |
HTTP clients establish a Token Binding ID with a server by including |
| 140 |
a special HTTP header field in HTTP requests. The HTTP header field |
| 141 |
value is a base64url-encoded TokenBindingMessage. |
| 142 |
|
| 143 |
A TokenBindingMessage allows a client to establish multiple Token |
| 144 |
Binding IDs with the server by including multiple TokenBinding |
| 145 |
structures. By default, a client will establish a Provided Token |
| 146 |
Binding ID with the server, indicating a Token Binding ID that the |
| 147 |
client will persistently use with the server. Under certain |
| 148 |
conditions, the client can also include a Referred Token Binding ID |
| 149 |
in the TokenBindingMessage, indicating a Token Binding ID that the |
| 150 |
client is using with a different server than the one that the |
| 151 |
TokenBindingMessage is sent to. This is useful in federation |
| 152 |
scenarios. |
| 153 |
|
| 154 |
<span class="h3"><a class="selflink" id="section-1.1" href="#section-1.1">1.1</a>. Requirements Language</span> |
| 155 |
|
| 156 |
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", |
| 157 |
"SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and |
| 158 |
"OPTIONAL" in this document are to be interpreted as described in |
| 159 |
<a href="https://www.rfc-editor.org/bcp/bcp14">BCP 14</a> [<a href="./rfc2119" title=""Key words for use in RFCs to Indicate Requirement Levels"">RFC2119</a>] [<a href="./rfc8174" title=""Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words"">RFC8174</a>] when, and only when, they appear in all |
| 160 |
capitals, as shown here. |
| 161 |
|
| 162 |
|
| 163 |
|
| 164 |
<span class="grey">Popov, et al. Standards Track [Page 3]</span></pre> |
| 165 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-4" ></span> |
| 166 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 167 |
|
| 168 |
|
| 169 |
<span class="h2"><a class="selflink" id="section-2" href="#section-2">2</a>. The Sec-Token-Binding HTTP Request Header Field</span> |
| 170 |
|
| 171 |
Once a client and server have negotiated the Token Binding protocol |
| 172 |
with HTTP/1.1 or HTTP/2 (see [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>] and [<a href="./rfc8472" title=""Transport Layer Security (TLS) Extension for Token Binding Protocol Negotiation"">RFC8472</a>]), clients MUST |
| 173 |
include a Sec-Token-Binding header field in their HTTP requests and |
| 174 |
MUST include only one such header field per HTTP request. Also, the |
| 175 |
Sec-Token-Binding header field MUST NOT be included in HTTP |
| 176 |
responses. The ABNF of the Sec-Token-Binding header field is (per |
| 177 |
the style of [<a href="./rfc7230" title=""Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing"">RFC7230</a>]; see also <a href="./rfc7231#section-8.3">Section 8.3 of [RFC7231]</a>): |
| 178 |
|
| 179 |
Sec-Token-Binding = EncodedTokenBindingMessage |
| 180 |
|
| 181 |
The header field name is Sec-Token-Binding, and its single value, |
| 182 |
EncodedTokenBindingMessage, is a base64url encoding of a single |
| 183 |
TokenBindingMessage, as defined in [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>]. The base64url encoding |
| 184 |
uses the URL and filename safe character set described in <a href="./rfc4648#section-5">Section 5 |
| 185 |
of [RFC4648]</a>, with all trailing padding characters (i.e., "=") |
| 186 |
omitted and without the inclusion of any line breaks, whitespace, or |
| 187 |
other additional characters. |
| 188 |
|
| 189 |
For example: |
| 190 |
|
| 191 |
Sec-Token-Binding: AIkAAgBBQFzK4_bhAqLDwRQxqJWte33d7hZ0hZWHwk-miKPg4E\ |
| 192 |
9fcgs7gBPoz-9RfuDfN9WCw6keHEw1ZPQMGs9CxpuHm-YAQM_j\ |
| 193 |
aOwwej6a-cQBGU7CJpUHOvXG4VvjNq8jDsvta9Y8_bPEPj25Gg\ |
| 194 |
mKiPjhJEtZA6mJ_9SNifLvVBTi7fR9wSAAAA |
| 195 |
|
| 196 |
(Note that the backslashes and line breaks are provided to ease |
| 197 |
readability; they are not part of the actual encoded message.) |
| 198 |
|
| 199 |
If the server receives more than one Sec-Token-Binding header field |
| 200 |
in an HTTP request, then the server MUST reject the message with a |
| 201 |
400 (Bad Request) HTTP status code. Additionally, the |
| 202 |
Sec-Token-Binding header field: |
| 203 |
|
| 204 |
o SHOULD NOT be stored by origin servers on PUT requests, |
| 205 |
|
| 206 |
o MAY be listed by a server in a Vary response header field, and |
| 207 |
|
| 208 |
o MUST NOT be used in HTTP trailers. |
| 209 |
|
| 210 |
The TokenBindingMessage MUST contain exactly one TokenBinding |
| 211 |
structure with a TokenBindingType value of provided_token_binding, |
| 212 |
which MUST be signed with the Token Binding private key used by the |
| 213 |
client for connections between itself and the server that the HTTP |
| 214 |
request is sent to (clients use different Token Binding key pairs for |
| 215 |
different servers; see <a href="#section-2.1">Section 2.1</a> below). The Token Binding ID |
| 216 |
|
| 217 |
|
| 218 |
|
| 219 |
|
| 220 |
<span class="grey">Popov, et al. Standards Track [Page 4]</span></pre> |
| 221 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-5" ></span> |
| 222 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 223 |
|
| 224 |
|
| 225 |
established by this TokenBinding is called a "Provided Token |
| 226 |
Binding ID". |
| 227 |
|
| 228 |
The TokenBindingMessage MAY also contain exactly one TokenBinding |
| 229 |
structure with a TokenBindingType value of referred_token_binding, as |
| 230 |
specified in <a href="#section-5.3">Section 5.3</a>. In addition to the latter, or rather than |
| 231 |
the latter, the TokenBindingMessage MAY contain other TokenBinding |
| 232 |
structures. This is specific to the use case in question; such use |
| 233 |
cases are outside the scope of this specification. |
| 234 |
|
| 235 |
A TokenBindingMessage is validated by the server as described in |
| 236 |
<a href="#section-4.2">Section 4.2</a> ("Server Processing Rules") of [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>]. If validation |
| 237 |
fails and a Token Binding is rejected, any associated bound tokens |
| 238 |
MUST also be rejected by the server. HTTP requests containing |
| 239 |
invalid tokens MUST be rejected. In this case, the server |
| 240 |
application MAY return HTTP status code 400 (Bad Request) or proceed |
| 241 |
with an application-specific "invalid token" response (e.g., |
| 242 |
directing the client to re-authenticate and present a different |
| 243 |
token), or terminate the connection. |
| 244 |
|
| 245 |
In HTTP/2, the client SHOULD use header compression [<a href="./rfc7541" title=""HPACK: Header Compression for HTTP/2"">RFC7541</a>] to |
| 246 |
avoid the overhead of repeating the same header field in subsequent |
| 247 |
HTTP requests. |
| 248 |
|
| 249 |
<span class="h3"><a class="selflink" id="section-2.1" href="#section-2.1">2.1</a>. HTTPS Token Binding Key-Pair Scoping</span> |
| 250 |
|
| 251 |
HTTPS is used in conjunction with various application protocols and |
| 252 |
application contexts, in various ways. For example, general-purpose |
| 253 |
web browsing is one such HTTP-based application context. Within that |
| 254 |
context, HTTP cookies [<a href="./rfc6265" title=""HTTP State Management Mechanism"">RFC6265</a>] are typically utilized for state |
| 255 |
management, including client authentication. A related, though |
| 256 |
distinct, example of other HTTP-based application contexts is where |
| 257 |
OAuth tokens [<a href="./rfc6749" title=""The OAuth 2.0 Authorization Framework"">RFC6749</a>] are utilized to manage authorization for |
| 258 |
third-party application access to resources. The token-scoping rules |
| 259 |
of these two examples can differ: the scoping rules for cookies are |
| 260 |
concisely specified in [<a href="./rfc6265" title=""HTTP State Management Mechanism"">RFC6265</a>], whereas OAuth is a framework and |
| 261 |
defines various token types with various scopings, some of which are |
| 262 |
determined by the encompassing application. |
| 263 |
|
| 264 |
The scoping of Token Binding key pairs generated by web browsers for |
| 265 |
the purpose of binding HTTP cookies MUST be no wider than the |
| 266 |
granularity of a "registered domain" (also known as "effective |
| 267 |
top-level domain + 1", or "eTLD+1"). An origin's "registered domain" |
| 268 |
is the origin's host's public suffix plus the label to its left |
| 269 |
(where the term "public suffix" is defined in the "NOTE:" paragraph |
| 270 |
in <a href="./rfc6265#section-5.3">Section 5.3 of [RFC6265]</a> as "a domain that is controlled by a |
| 271 |
public registry"). For example, for "https://www.example.com", the |
| 272 |
public suffix (eTLD) is "com", and the registered domain (eTLD+1) is |
| 273 |
|
| 274 |
|
| 275 |
|
| 276 |
<span class="grey">Popov, et al. Standards Track [Page 5]</span></pre> |
| 277 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-6" ></span> |
| 278 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 279 |
|
| 280 |
|
| 281 |
"example.com". User Agents SHOULD use an up-to-date public suffix |
| 282 |
list, such as the one maintained by Mozilla [<a href="#ref-PSL" title=""Public Suffix List"">PSL</a>]. |
| 283 |
|
| 284 |
This means that in practice the scope of a Token Binding key pair is |
| 285 |
no larger than the scope of a cookie allowed by a web browser. If a |
| 286 |
web browser restricts cookies to a narrower scope than registered |
| 287 |
domains, the scope of Token Binding key pairs MAY also be narrower. |
| 288 |
This applies to the use of Token Binding key pairs in first-party use |
| 289 |
cases, as well as in federation use cases defined in this |
| 290 |
specification (<a href="#section-5">Section 5</a>). |
| 291 |
|
| 292 |
Key pairs used to bind other application tokens, such as OAuth tokens |
| 293 |
or "OpenID Connect" ID Tokens [<a href="#ref-OpenID.Core">OpenID.Core</a>], SHOULD adhere to the |
| 294 |
above eTLD+1 scoping requirement for those tokens being employed in |
| 295 |
first-party or federation scenarios. Applications other than web |
| 296 |
browsers MAY use different key-pair scoping rules. See also |
| 297 |
<a href="#section-8.1">Section 8.1</a> below. |
| 298 |
|
| 299 |
Scoping rules for other HTTP-based application contexts are outside |
| 300 |
the scope of this specification. |
| 301 |
|
| 302 |
<span class="h2"><a class="selflink" id="section-3" href="#section-3">3</a>. TLS Renegotiation</span> |
| 303 |
|
| 304 |
Token Binding over HTTP/1.1 [<a href="./rfc7230" title=""Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing"">RFC7230</a>] can be performed in combination |
| 305 |
with TLS renegotiation. In this case, renegotiation MUST only occur |
| 306 |
between a client's HTTP request and the server's response, the client |
| 307 |
MUST NOT send any pipelined requests, and the client MUST NOT |
| 308 |
initiate renegotiation. (That is, the client may only send a |
| 309 |
renegotiation ClientHello in response to the server's HelloRequest.) |
| 310 |
These conditions ensure that both the client and the server can |
| 311 |
clearly identify which TLS Exported Keying Material value [<a href="./rfc5705" title=""Keying Material Exporters for Transport Layer Security (TLS)"">RFC5705</a>] |
| 312 |
to use when generating or verifying the TokenBindingMessage. This |
| 313 |
also prevents a TokenBindingMessage from being split across TLS |
| 314 |
renegotiation boundaries due to TLS message fragmentation; see |
| 315 |
<a href="./rfc5246#section-6.2.1">Section 6.2.1 of [RFC5246]</a>. |
| 316 |
|
| 317 |
(Note: This document deals with TLS 1.2 and therefore refers to |
| 318 |
<a href="./rfc5246">RFC 5246</a> (which has been obsoleted by <a href="./rfc8446">RFC 8446</a>); [<a href="#ref-TOKENBIND-TLS13">TOKENBIND-TLS13</a>] |
| 319 |
addresses Token Binding in TLS 1.3.) |
| 320 |
|
| 321 |
|
| 322 |
|
| 323 |
|
| 324 |
|
| 325 |
|
| 326 |
|
| 327 |
|
| 328 |
|
| 329 |
|
| 330 |
|
| 331 |
|
| 332 |
<span class="grey">Popov, et al. Standards Track [Page 6]</span></pre> |
| 333 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-7" ></span> |
| 334 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 335 |
|
| 336 |
|
| 337 |
<span class="h2"><a class="selflink" id="section-4" href="#section-4">4</a>. First-Party Use Cases</span> |
| 338 |
|
| 339 |
In a first-party use case (also known as a "same-site" use case), an |
| 340 |
HTTP server issues a security token such as a cookie (or similar) to |
| 341 |
a client and expects the client to return the security token at a |
| 342 |
later time, e.g., in order to authenticate. Binding the security |
| 343 |
token to the TLS connection between the client and the server |
| 344 |
protects the security token from misuse, since the server can detect |
| 345 |
if the security token is replayed inappropriately, e.g., over other |
| 346 |
TLS connections. |
| 347 |
|
| 348 |
See <a href="./rfc8471#section-5">Section 5 of [RFC8471]</a> for general guidance regarding the binding |
| 349 |
of security tokens and their subsequent validation. |
| 350 |
|
| 351 |
<span class="h2"><a class="selflink" id="section-5" href="#section-5">5</a>. Federation Use Cases</span> |
| 352 |
|
| 353 |
<span class="h3"><a class="selflink" id="section-5.1" href="#section-5.1">5.1</a>. Introduction</span> |
| 354 |
|
| 355 |
For privacy reasons, clients use different Token Binding key pairs to |
| 356 |
establish Provided Token Binding IDs with different servers. As a |
| 357 |
result, a server cannot bind a security token (such as an OAuth token |
| 358 |
or an OpenID Connect ID Token [<a href="#ref-OpenID.Core">OpenID.Core</a>]) to a TLS connection that |
| 359 |
the client has with a different server. This is, however, a common |
| 360 |
requirement in federation scenarios: for example, an Identity |
| 361 |
Provider may wish to issue an identity token to a client and |
| 362 |
cryptographically bind that token to the TLS connection between the |
| 363 |
client and a Relying Party. |
| 364 |
|
| 365 |
In this section, we describe mechanisms to achieve this. The common |
| 366 |
idea among these mechanisms is that a server (called the "Token |
| 367 |
Consumer" in this document) signals to the client that it should |
| 368 |
reveal the Provided Token Binding ID that is used between the client |
| 369 |
and itself to another server (called the "Token Provider" in this |
| 370 |
document). Also common across the mechanisms is how the Token |
| 371 |
Binding ID is revealed to the Token Provider: the client uses the |
| 372 |
Token Binding protocol [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>] and includes a TokenBinding |
| 373 |
structure in the Sec-Token-Binding HTTP header field defined above. |
| 374 |
What differs between the various mechanisms is how the Token Consumer |
| 375 |
signals to the client that it should reveal the Token Binding ID to |
| 376 |
the Token Provider. Below, we specify one such mechanism, which is |
| 377 |
suitable for redirect-based interactions between Token Consumers and |
| 378 |
Token Providers. |
| 379 |
|
| 380 |
|
| 381 |
|
| 382 |
|
| 383 |
|
| 384 |
|
| 385 |
|
| 386 |
|
| 387 |
|
| 388 |
<span class="grey">Popov, et al. Standards Track [Page 7]</span></pre> |
| 389 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-8" ></span> |
| 390 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 391 |
|
| 392 |
|
| 393 |
Client Token Consumer Token Provider |
| 394 |
+--------+ +----+ +-----+ |
| 395 |
| Client | | TC | | TP | |
| 396 |
+--------+ +----+ +-----+ |
| 397 |
| | | |
| 398 |
| | | |
| 399 |
| | | |
| 400 |
| Client interacts w/TC | | |
| 401 |
| using TokenBindingID TBID1: | | |
| 402 |
| TBMSG[[provided_token_binding,| | |
| 403 |
| TBID1, signature]] | | |
| 404 |
|------------------------------>| | |
| 405 |
| | | |
| 406 |
| Client interacts w/TP | |
| 407 |
| using TokenBindingID TBID2: | |
| 408 |
| TBMSG[[provided_token_binding, | |
| 409 |
| TBID2, signature]] | |
| 410 |
|----------------------------------------------------->| |
| 411 |
| | |
| 412 |
| | | |
| 413 |
| TC signals permission to | | |
| 414 |
| reveal TBID1 to TP | | |
| 415 |
|<------------------------------| | |
| 416 |
| | | |
| 417 |
| | |
| 418 |
| Client interacts w/TP | |
| 419 |
| using TokenBindingID TBID1 and TBID2: | |
| 420 |
| TBMSG[[provided_token_binding, | |
| 421 |
| TBID2, signature], | |
| 422 |
| [referred_token_binding, | |
| 423 |
| TBID1, signature]] | |
| 424 |
|----------------------------------------------------->| |
| 425 |
| | |
| 426 |
| | | |
| 427 |
| | | |
| 428 |
|
| 429 |
<span class="h3"><a class="selflink" id="section-5.2" href="#section-5.2">5.2</a>. Overview</span> |
| 430 |
|
| 431 |
In a federated sign-on protocol, an Identity Provider issues an |
| 432 |
identity token to a client, which sends the identity token to a |
| 433 |
Relying Party to authenticate itself. Examples of this include |
| 434 |
OpenID Connect (in which the identity token is called an "ID Token") |
| 435 |
and the Security Assertion Markup Language (SAML) |
| 436 |
[<a href="#ref-OASIS.saml-core-2.0-os">OASIS.saml-core-2.0-os</a>] (in which the identity token is a SAML |
| 437 |
assertion). |
| 438 |
|
| 439 |
|
| 440 |
|
| 441 |
|
| 442 |
|
| 443 |
|
| 444 |
<span class="grey">Popov, et al. Standards Track [Page 8]</span></pre> |
| 445 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-9" ></span> |
| 446 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 447 |
|
| 448 |
|
| 449 |
To better protect the security of the identity token, the Identity |
| 450 |
Provider may wish to bind the identity token to the TLS connection |
| 451 |
between the client and the Relying Party, thus ensuring that only |
| 452 |
said client can use the identity token. The Relying Party will |
| 453 |
compare the Token Binding ID (or a cryptographic hash of it) in the |
| 454 |
identity token with the Token Binding ID (or a hash thereof) of the |
| 455 |
TLS connection between this Relying Party and the client. |
| 456 |
|
| 457 |
This is an example of a federation scenario, which more generally can |
| 458 |
be described as follows: |
| 459 |
|
| 460 |
o A Token Consumer causes the client to issue a token request to the |
| 461 |
Token Provider. The goal is for the client to obtain a token and |
| 462 |
then use it with the Token Consumer. |
| 463 |
|
| 464 |
o The client delivers the token request to the Token Provider. |
| 465 |
|
| 466 |
o The Token Provider issues the token. The token is issued for the |
| 467 |
specific Token Consumer who requested it (thus preventing |
| 468 |
malicious Token Consumers from using tokens with other Token |
| 469 |
Consumers). The token is, however, typically a bearer token, |
| 470 |
meaning that any client can use it with the Token Consumer -- not |
| 471 |
just the client to which it was issued. |
| 472 |
|
| 473 |
o Therefore, in the previous step, the Token Provider may want to |
| 474 |
include in the token the Token Binding ID (or a cryptographic hash |
| 475 |
of it) that the client uses when communicating with the Token |
| 476 |
Consumer, thus binding the token to the client's Token Binding key |
| 477 |
pair. The client proves possession of the private key when |
| 478 |
communicating with the Token Consumer through the Token Binding |
| 479 |
protocol [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>] and uses the corresponding public key of this |
| 480 |
key pair as a component of the Token Binding ID. Comparing the |
| 481 |
Token Binding ID from the token to the Token Binding ID |
| 482 |
established with the client allows the Token Consumer to verify |
| 483 |
that the token was sent to it by the legitimate client. |
| 484 |
|
| 485 |
o To allow the Token Provider to include the Token Binding ID in the |
| 486 |
token, the Token Binding ID between the client and the Token |
| 487 |
Consumer must therefore be communicated to the Token Provider |
| 488 |
along with the token request. Communicating a Token Binding ID |
| 489 |
involves proving possession of a private key and is described in |
| 490 |
the Token Binding protocol [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>]. |
| 491 |
|
| 492 |
The client will perform this last operation only if the Token |
| 493 |
Consumer requests the client to do so. |
| 494 |
|
| 495 |
|
| 496 |
|
| 497 |
|
| 498 |
|
| 499 |
|
| 500 |
<span class="grey">Popov, et al. Standards Track [Page 9]</span></pre> |
| 501 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-10" ></span> |
| 502 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 503 |
|
| 504 |
|
| 505 |
Below, we specify how Token Consumers can signal this request in |
| 506 |
redirect-based federation protocols. Note that this assumes that the |
| 507 |
federated sign-on flow starts at the Token Consumer or, at the very |
| 508 |
least, includes a redirect from the Token Consumer to the Token |
| 509 |
Provider. It is outside the scope of this document to specify |
| 510 |
similar mechanisms for flows that do not include such redirects. |
| 511 |
|
| 512 |
<span class="h3"><a class="selflink" id="section-5.3" href="#section-5.3">5.3</a>. HTTP Redirects</span> |
| 513 |
|
| 514 |
When a Token Consumer redirects the client to a Token Provider as a |
| 515 |
means to deliver the token request, it SHOULD include an |
| 516 |
Include-Referred-Token-Binding-ID HTTP response header field in its |
| 517 |
HTTP response. The ABNF of the Include-Referred-Token-Binding-ID |
| 518 |
header is (per the style of [<a href="./rfc7230" title=""Hypertext Transfer Protocol (HTTP/1.1): Message Syntax and Routing"">RFC7230</a>]; see also <a href="./rfc7231#section-8.3">Section 8.3 of |
| 519 |
[RFC7231]</a>): |
| 520 |
|
| 521 |
Include-Referred-Token-Binding-ID = "true" |
| 522 |
|
| 523 |
Where the header field name is "Include-Referred-Token-Binding-ID" |
| 524 |
and the field value of "true" is case insensitive. For example: |
| 525 |
|
| 526 |
Include-Referred-Token-Binding-ID: true |
| 527 |
|
| 528 |
Including this response header field signals to the client that it |
| 529 |
should reveal, to the Token Provider, the Token Binding ID used |
| 530 |
between itself and the Token Consumer. In the absence of this |
| 531 |
response header field, the client will not disclose any information |
| 532 |
about the Token Binding used between the client and the Token |
| 533 |
Consumer to the Token Provider. |
| 534 |
|
| 535 |
As illustrated in <a href="#section-5.5">Section 5.5</a>, when a client receives this header |
| 536 |
field, it should take the TokenBindingID [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>] of the provided |
| 537 |
TokenBinding from the referrer and create a referred TokenBinding |
| 538 |
with it to include in the TokenBindingMessage in the redirect |
| 539 |
request. In other words, the Token Binding message in the redirect |
| 540 |
request to the Token Provider now includes one provided binding and |
| 541 |
one referred binding, the latter constructed from the binding between |
| 542 |
the client and the Token Consumer. |
| 543 |
|
| 544 |
When a client receives the Include-Referred-Token-Binding-ID header, |
| 545 |
it includes the referred Token Binding even if both the Token |
| 546 |
Provider and the Token Consumer fall under the same eTLD+1 and the |
| 547 |
provided and Referred Token Binding IDs are the same. |
| 548 |
|
| 549 |
The referred Token Binding is sent only in the initial request |
| 550 |
resulting from the HTTP response that included the |
| 551 |
Include-Referred-Token-Binding-ID header. Should the response to |
| 552 |
that initial request be a further redirect, the original referred |
| 553 |
|
| 554 |
|
| 555 |
|
| 556 |
<span class="grey">Popov, et al. Standards Track [Page 10]</span></pre> |
| 557 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-11" ></span> |
| 558 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 559 |
|
| 560 |
|
| 561 |
Token Binding is no longer included in subsequent requests. (A new |
| 562 |
referred Token Binding may be included if the redirecting endpoint |
| 563 |
itself responded with an Include-Referred-Token-Binding-ID response |
| 564 |
header.) |
| 565 |
|
| 566 |
If the Include-Referred-Token-Binding-ID header field is |
| 567 |
received in response to a request that did not include the |
| 568 |
Sec-Token-Binding header field, the client MUST ignore the |
| 569 |
Include-Referred-Token-Binding-ID header field. |
| 570 |
|
| 571 |
This header field only has meaning if the HTTP status code is a |
| 572 |
redirection code (300-399) and MUST be ignored by the client for any |
| 573 |
other status codes. As described in <a href="#section-2">Section 2</a>, if the client |
| 574 |
supports the Token Binding protocol and has negotiated the Token |
| 575 |
Binding protocol with both the Token Consumer and the Token Provider, |
| 576 |
it sends the Sec-Token-Binding header field to the Token Provider |
| 577 |
with each HTTP request. |
| 578 |
|
| 579 |
The TokenBindingMessage included in the redirect request to the Token |
| 580 |
Provider SHOULD contain a TokenBinding with a TokenBindingType value |
| 581 |
of referred_token_binding. If included, this TokenBinding MUST be |
| 582 |
signed with the Token Binding private key used by the client for |
| 583 |
connections between itself and the Token Consumer (more specifically, |
| 584 |
the server that issued the Include-Referred-Token-Binding-ID response |
| 585 |
header field). The Token Binding ID established by this TokenBinding |
| 586 |
is called a "Referred Token Binding ID". |
| 587 |
|
| 588 |
As described above, the TokenBindingMessage MUST additionally contain |
| 589 |
a Provided Token Binding ID, i.e., a TokenBinding structure with a |
| 590 |
TokenBindingType value of provided_token_binding, which MUST be |
| 591 |
signed with the Token Binding private key used by the client for |
| 592 |
connections between itself and the Token Provider (more specifically, |
| 593 |
the server that the token request is being sent to). |
| 594 |
|
| 595 |
If, for some deployment-specific reason, the initial Token Provider |
| 596 |
("TP1") needs to redirect the client to another Token Provider |
| 597 |
("TP2") rather than directly back to the Token Consumer, it can be |
| 598 |
accommodated using the header fields defined in this specification in |
| 599 |
the following fashion ("the redirect-chain approach"): |
| 600 |
|
| 601 |
Initially, the client is redirected to TP1 by the Token Consumer |
| 602 |
("TC"), as described above. Upon receiving a client's request |
| 603 |
that contains a TokenBindingMessage that in turn contains both |
| 604 |
provided and referred TokenBindings (for TP1 and TC, |
| 605 |
respectively), TP1 responds to the client with a redirect response |
| 606 |
that (1) contains the Include-Referred-Token-Binding-ID header |
| 607 |
field and (2) directs the client to send a request to TP2. This |
| 608 |
causes the client to follow the same pattern and send a request |
| 609 |
|
| 610 |
|
| 611 |
|
| 612 |
<span class="grey">Popov, et al. Standards Track [Page 11]</span></pre> |
| 613 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-12" ></span> |
| 614 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 615 |
|
| 616 |
|
| 617 |
containing a TokenBindingMessage that contains both provided and |
| 618 |
referred TokenBindings (for TP2 and TP1, respectively) to TP2. |
| 619 |
Note that this pattern can continue to additional Token Providers. |
| 620 |
In this case, TP2 issues a security token, bound to the client's |
| 621 |
TokenBinding with TP1, and sends a redirect response to the client |
| 622 |
pointing to TP1. TP1 in turn constructs a security token for the |
| 623 |
Token Consumer, bound to the TC's referred TokenBinding that had |
| 624 |
been conveyed earlier, and sends a redirect response pointing to |
| 625 |
the TC, containing the bound security token, to the client. |
| 626 |
|
| 627 |
The above is intended as only a non-normative example. Details are |
| 628 |
specific to deployment contexts. Other approaches are possible but |
| 629 |
are outside the scope of this specification. |
| 630 |
|
| 631 |
<span class="h3"><a class="selflink" id="section-5.4" href="#section-5.4">5.4</a>. Negotiated Key Parameters</span> |
| 632 |
|
| 633 |
The TLS extension for Token Binding protocol negotiation [<a href="./rfc8472" title=""Transport Layer Security (TLS) Extension for Token Binding Protocol Negotiation"">RFC8472</a>] |
| 634 |
allows the server and client to negotiate the parameters (signature |
| 635 |
algorithm, length) of the Token Binding key pair. It is possible |
| 636 |
that the Token Binding ID used between the client and the Token |
| 637 |
Consumer, and the Token Binding ID used between the client and the |
| 638 |
Token Provider, use different key parameters. The client MUST use |
| 639 |
the key parameters negotiated with the Token Consumer in the |
| 640 |
referred_token_binding TokenBinding of the TokenBindingMessage, even |
| 641 |
if those key parameters are different from the ones negotiated with |
| 642 |
the server that the header field is sent to. |
| 643 |
|
| 644 |
Token Providers SHOULD support all the Token Binding key parameters |
| 645 |
specified in [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>]. If a Token Provider does not support the key |
| 646 |
parameters specified in the referred_token_binding TokenBinding in |
| 647 |
the TokenBindingMessage, it MUST NOT issue a bound token. |
| 648 |
|
| 649 |
|
| 650 |
|
| 651 |
|
| 652 |
|
| 653 |
|
| 654 |
|
| 655 |
|
| 656 |
|
| 657 |
|
| 658 |
|
| 659 |
|
| 660 |
|
| 661 |
|
| 662 |
|
| 663 |
|
| 664 |
|
| 665 |
|
| 666 |
|
| 667 |
|
| 668 |
<span class="grey">Popov, et al. Standards Track [Page 12]</span></pre> |
| 669 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-13" ></span> |
| 670 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 671 |
|
| 672 |
|
| 673 |
<span class="h3"><a class="selflink" id="section-5.5" href="#section-5.5">5.5</a>. Federation Example</span> |
| 674 |
|
| 675 |
The diagram below shows a typical HTTP redirect-based web browser |
| 676 |
single sign-on (SSO) profile (Section 4.1 of |
| 677 |
[<a href="#ref-OASIS.saml-prof-2.0-os">OASIS.saml-prof-2.0-os</a>]) (no artifact, no callbacks), featuring the |
| 678 |
binding of, for example, a TLS Token Binding ID into an OpenID |
| 679 |
Connect ID Token. |
| 680 |
|
| 681 |
Legend: |
| 682 |
|
| 683 |
+------------+------------------------------------------------------+ |
| 684 |
| EKM: | TLS Exported Keying Material [<a href="./rfc5705" title=""Keying Material Exporters for Transport Layer Security (TLS)"">RFC5705</a>] | |
| 685 |
| | | |
| 686 |
| {EKMn}Ksm: | EKM for server "n", signed by the private key of | |
| 687 |
| | TBID "m", where "n" must represent the server | |
| 688 |
| | receiving the ETBMSG. If a conveyed TB's type is | |
| 689 |
| | provided_token_binding, then m = n, else if TB's | |
| 690 |
| | type is referred_token_binding, then m != n. For | |
| 691 |
| | example, see step 1b in the diagram below. | |
| 692 |
| | | |
| 693 |
| ETBMSG: | "Sec-Token-Binding" HTTP header field conveying an | |
| 694 |
| | EncodedTokenBindingMessage, in turn conveying | |
| 695 |
| | TokenBinding (TB)struct(s), e.g., ETBMSG[[TB]] or | |
| 696 |
| | ETBMSG[[TB1],[TB2]] | |
| 697 |
| | | |
| 698 |
| ID Token: | the ID Token in OpenID Connect. It is the semantic | |
| 699 |
| | equivalent of a SAML "authentication assertion". | |
| 700 |
| | "ID Token w/TBIDn" denotes a "token bound" ID Token | |
| 701 |
| | containing TBIDn. | |
| 702 |
| | | |
| 703 |
| Ks and Kp: | private (aka secret) key and public key, | |
| 704 |
| | respectively, of the client-side Token Binding key | |
| 705 |
| | pair | |
| 706 |
| | | |
| 707 |
| OIDC: | OpenID Connect | |
| 708 |
| | | |
| 709 |
| TB: | TokenBinding struct containing a signed EKM, TBID, | |
| 710 |
| | and TB type, e.g., | |
| 711 |
| | [{EKM1}Ks1,TBID1,provided_token_binding] | |
| 712 |
| | | |
| 713 |
| TBIDn: | Token Binding ID for client and server n's token- | |
| 714 |
| | bound TLS association. TBIDn contains Kpn. | |
| 715 |
+------------+------------------------------------------------------+ |
| 716 |
|
| 717 |
|
| 718 |
|
| 719 |
|
| 720 |
|
| 721 |
|
| 722 |
|
| 723 |
|
| 724 |
<span class="grey">Popov, et al. Standards Track [Page 13]</span></pre> |
| 725 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-14" ></span> |
| 726 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 727 |
|
| 728 |
|
| 729 |
Client, aka Token Consumer, aka Token Provider, aka |
| 730 |
User Agent OpenID Client, OpenID Provider, |
| 731 |
OIDC Relying Party, OIDC Provider, |
| 732 |
SAML Relying Party SAML Identity Provider |
| 733 |
[ server "1" ] [ server "2" ] |
| 734 |
+--------+ +----+ +-----+ |
| 735 |
| Client | | TC | | TP | |
| 736 |
+--------+ +----+ +-----+ |
| 737 |
| | | |
| 738 |
| | | |
| 739 |
| | | |
| 740 |
| 0. Client interacts w/TC | | |
| 741 |
| over HTTPS, establishes Ks1 and Kp1, TBID1 | |
| 742 |
| ETBMSG[[{EKM1}Ks1,TBID1,provided_token_binding]] | |
| 743 |
|------------------------------>| | |
| 744 |
| | | |
| 745 |
| | | |
| 746 |
| | | |
| 747 |
| 1a. OIDC ID Token request, aka| | |
| 748 |
| "Authentication Request", conveyed with | |
| 749 |
| an HTTP response header field of | |
| 750 |
| Include-Referred-Token-Binding-ID:true. | |
| 751 |
| Any security-relevant cookies | | |
| 752 |
| should contain TBID1. | | |
| 753 |
+<- - - - - - - - - - - - - - - - | | |
| 754 |
. | (redirect to TP via 301, 302, | | |
| 755 |
. | 303, 307, or 308) | | |
| 756 |
. | | | |
| 757 |
+------------------------------------------------------->| |
| 758 |
| 1b. opens HTTPS w/TP, | |
| 759 |
| establishes Ks2, Kp2, TBID2; | |
| 760 |
| sends a GET or POST with | |
| 761 |
| ETBMSG[[{EKM2}Ks2,TBID2,provided_token_binding], | |
| 762 |
| [{EKM2}Ks1,TBID1,referred_token_binding]] | |
| 763 |
| as well as the ID Token request | |
| 764 |
| | | |
| 765 |
| | | |
| 766 |
| | | |
| 767 |
| 2. user authentication (if applicable; | |
| 768 |
| methods vary; particulars are out of scope) | |
| 769 |
|<====================================================>| |
| 770 |
| (TP generates ID Token for TC containing TBID1; may | |
| 771 |
| also set cookie(s) containing TBID2 and/or TBID1; | |
| 772 |
| details vary; particulars are out of scope) | |
| 773 |
| | | |
| 774 |
| | | |
| 775 |
|
| 776 |
|
| 777 |
|
| 778 |
|
| 779 |
|
| 780 |
<span class="grey">Popov, et al. Standards Track [Page 14]</span></pre> |
| 781 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-15" ></span> |
| 782 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 783 |
|
| 784 |
|
| 785 |
| | | |
| 786 |
| 3a. ID Token containing Kp1, issued for TC, | |
| 787 |
| conveyed via OIDC "Authentication Response" | |
| 788 |
+<- - - - - - - - - - - - - - - - - - - - - - - - - - - -| |
| 789 |
. | (redirect to TC) | | |
| 790 |
. | | | |
| 791 |
. | | | |
| 792 |
+-------------------------------->| | |
| 793 |
| 3b. HTTPS GET or POST with | |
| 794 |
| ETBMSG[[{EKM1}Ks1,TBID1,provided_token_binding]] | |
| 795 |
| conveying an Authentication Response containing | |
| 796 |
| an ID Token w/TBID1, issued for TC | |
| 797 |
| | | |
| 798 |
| | | |
| 799 |
| | | |
| 800 |
| 4. user is signed on; any security-relevant cookie(s)| |
| 801 |
| that is set SHOULD contain TBID1 | |
| 802 |
|<------------------------------| | |
| 803 |
| | | |
| 804 |
| | | |
| 805 |
|
| 806 |
<span class="h2"><a class="selflink" id="section-6" href="#section-6">6</a>. Implementation Considerations</span> |
| 807 |
|
| 808 |
HTTPS-based applications may have multi-party use cases other than, |
| 809 |
or in addition to, the HTTP redirect-based signaling and conveyance |
| 810 |
of referred Token Bindings, as presented above in <a href="#section-5.3">Section 5.3</a>. |
| 811 |
|
| 812 |
Thus, Token Binding implementations should provide APIs for such |
| 813 |
applications to generate Token Binding messages containing Token |
| 814 |
Binding IDs of various application-specified Token Binding types, to |
| 815 |
be conveyed by the Sec-Token-Binding header field. |
| 816 |
|
| 817 |
However, Token Binding implementations MUST only convey Token Binding |
| 818 |
IDs to servers if signaled to do so by an application. Signaling |
| 819 |
mechanisms other than the Include-Referred-Token-Binding-ID HTTP |
| 820 |
response header field are possible, but these mechanisms are outside |
| 821 |
the scope of this specification. |
| 822 |
|
| 823 |
NOTE: See <a href="#section-8">Section 8</a> ("Privacy Considerations") for privacy guidance |
| 824 |
regarding the use of this functionality. |
| 825 |
|
| 826 |
|
| 827 |
|
| 828 |
|
| 829 |
|
| 830 |
|
| 831 |
|
| 832 |
|
| 833 |
|
| 834 |
|
| 835 |
|
| 836 |
<span class="grey">Popov, et al. Standards Track [Page 15]</span></pre> |
| 837 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-16" ></span> |
| 838 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 839 |
|
| 840 |
|
| 841 |
<span class="h2"><a class="selflink" id="section-7" href="#section-7">7</a>. Security Considerations</span> |
| 842 |
|
| 843 |
<span class="h3"><a class="selflink" id="section-7.1" href="#section-7.1">7.1</a>. Security Token Replay</span> |
| 844 |
|
| 845 |
The goal of the federated Token Binding mechanisms is to prevent |
| 846 |
attackers from exporting and replaying tokens used in protocols |
| 847 |
between the client and the Token Consumer, thereby impersonating |
| 848 |
legitimate users and gaining access to protected resources. Although |
| 849 |
bound tokens can still be replayed by any malware present in clients |
| 850 |
(which may be undetectable to a server), in order to export bound |
| 851 |
tokens to other machines and successfully replay them, attackers also |
| 852 |
need to export the corresponding Token Binding private keys. Token |
| 853 |
Binding private keys are therefore high-value assets and SHOULD be |
| 854 |
strongly protected, ideally by generating them in a hardware security |
| 855 |
module that prevents key export. |
| 856 |
|
| 857 |
This consideration is a special case of the scenario described in |
| 858 |
<a href="#section-7.1">Section 7.1</a> ("Security Token Replay") of [<a href="./rfc8471" title=""The Token Binding Protocol Version 1.0"">RFC8471</a>]. |
| 859 |
|
| 860 |
<span class="h3"><a class="selflink" id="section-7.2" href="#section-7.2">7.2</a>. Sensitivity of the Sec-Token-Binding Header</span> |
| 861 |
|
| 862 |
The purpose of the Token Binding protocol is to convince the server |
| 863 |
that the client that initiated the TLS connection controls a certain |
| 864 |
key pair. For the server to correctly draw this conclusion after |
| 865 |
processing the Sec-Token-Binding header field, certain secrecy and |
| 866 |
integrity requirements must be met. |
| 867 |
|
| 868 |
For example, the client must keep its Token Binding private key |
| 869 |
secret. If the private key is not secret, then another actor in the |
| 870 |
system could create a valid Token Binding header field and thereby |
| 871 |
impersonate the client. This can render the main purpose of the |
| 872 |
protocol -- to bind bearer tokens to certain clients -- moot. |
| 873 |
Consider, for example, an attacker who obtained (perhaps through a |
| 874 |
network intrusion) an authentication cookie that a client uses with a |
| 875 |
certain server. Consider further that the server bound that cookie |
| 876 |
to the client's Token Binding ID precisely to thwart misuse of the |
| 877 |
cookie. If the attacker were to come into possession of the client's |
| 878 |
private key, they could then establish a TLS connection with the |
| 879 |
server and craft a Sec-Token-Binding header field that matches the |
| 880 |
binding present in the cookie, thus successfully authenticating as |
| 881 |
the client and gaining access to the client's data at the server. |
| 882 |
The Token Binding protocol, in this case, did not successfully bind |
| 883 |
the cookie to the client. |
| 884 |
|
| 885 |
Likewise, we need integrity protection of the Sec-Token-Binding |
| 886 |
header field. A client should not be tricked into sending to a |
| 887 |
server a Sec-Token-Binding header field that contains Token Bindings |
| 888 |
signed with any Token Binding keys that the client does not control. |
| 889 |
|
| 890 |
|
| 891 |
|
| 892 |
<span class="grey">Popov, et al. Standards Track [Page 16]</span></pre> |
| 893 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-17" ></span> |
| 894 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 895 |
|
| 896 |
|
| 897 |
Consider an attacker A that somehow has knowledge of the Exported |
| 898 |
Keying Material (EKM) for a TLS connection between a client C and a |
| 899 |
server S. (While that is somewhat unlikely, it is also not entirely |
| 900 |
out of the question, since the client might not treat the EKM as a |
| 901 |
secret -- after all, a pre-image-resistant hash function has been |
| 902 |
applied to the TLS master secret, making it impossible for someone |
| 903 |
knowing the EKM to recover the TLS master secret. Such |
| 904 |
considerations might lead some clients to not treat the EKM as a |
| 905 |
secret.) Such an attacker A could craft a Sec-Token-Binding header |
| 906 |
field with A's key pair over C's EKM. If the attacker could now |
| 907 |
trick C into sending such a header field to S, it would appear to S |
| 908 |
as if C controls a certain key pair, when in fact it does not (the |
| 909 |
attacker A controls the key pair). |
| 910 |
|
| 911 |
If A has a pre-existing relationship with S (e.g., perhaps has an |
| 912 |
account on S), it now appears to the server S as if A is connecting |
| 913 |
to it, even though it is really C. (If the server S does not simply |
| 914 |
use Token Binding IDs to identify clients but also uses bound |
| 915 |
authentication cookies, then A would also have to trick C into |
| 916 |
sending one of A's cookies to S, which it can do through a variety of |
| 917 |
means -- inserting cookies through JavaScript APIs, setting cookies |
| 918 |
through related-domain attacks, etc.) In other words, in this |
| 919 |
scenario, A can trick C into logging into A's account on S. This |
| 920 |
could lead to a loss of privacy for C, since A presumably has some |
| 921 |
other way to also access the account and can thus indirectly observe |
| 922 |
C's behavior (for example, if S has a feature that lets account |
| 923 |
holders see their activity history on S). |
| 924 |
|
| 925 |
Therefore, we need to protect the integrity of the Sec-Token-Binding |
| 926 |
header field. One eTLD+1 should not be able to set the |
| 927 |
Sec-Token-Binding header field (through a Document Object Model (DOM) |
| 928 |
API [<a href="#ref-W3C.REC-DOM-Level-3-Core-20040407">W3C.REC-DOM-Level-3-Core-20040407</a>] or otherwise) that the User |
| 929 |
Agent uses with another eTLD+1. Employing the "Sec-" header field |
| 930 |
prefix helps to meet this requirement by denoting the header field |
| 931 |
name as a "forbidden header name"; see [<a href="#ref-fetch-spec">fetch-spec</a>]. |
| 932 |
|
| 933 |
<span class="h3"><a class="selflink" id="section-7.3" href="#section-7.3">7.3</a>. Securing Federated Sign-On Protocols</span> |
| 934 |
|
| 935 |
As explained above, in a federated sign-on scenario, a client will |
| 936 |
prove possession of two different Token Binding private keys to a |
| 937 |
Token Provider: one private key corresponds to the "provided" Token |
| 938 |
Binding ID (which the client normally uses with the Token Provider), |
| 939 |
and the other is the Token Binding private key corresponding to the |
| 940 |
"referred" Token Binding ID (which the client normally uses with the |
| 941 |
Token Consumer). The Token Provider is expected to issue a token |
| 942 |
that is bound to the Referred Token Binding ID. |
| 943 |
|
| 944 |
|
| 945 |
|
| 946 |
|
| 947 |
|
| 948 |
<span class="grey">Popov, et al. Standards Track [Page 17]</span></pre> |
| 949 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-18" ></span> |
| 950 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 951 |
|
| 952 |
|
| 953 |
Both proofs (that of the provided Token Binding private key and that |
| 954 |
of the referred Token Binding private key) are necessary. To show |
| 955 |
this, consider the following scenario: |
| 956 |
|
| 957 |
o The client has an authentication token with the Token Provider |
| 958 |
that is bound to the client's Token Binding ID used with that |
| 959 |
Token Provider. |
| 960 |
|
| 961 |
o The client wants to establish a secure (i.e., free of men-in-the- |
| 962 |
middle) authenticated session with the Token Consumer but has not |
| 963 |
yet done so (in other words, we are about to run the federated |
| 964 |
sign-on protocol). |
| 965 |
|
| 966 |
o A man-in-the-middle is allowed to intercept the connection between |
| 967 |
the client and the Token Consumer or between the client and the |
| 968 |
Token Provider (or both). |
| 969 |
|
| 970 |
The goal is to detect the presence of the man-in-the-middle in these |
| 971 |
scenarios. |
| 972 |
|
| 973 |
First, consider a man-in-the-middle between the client and the Token |
| 974 |
Provider. Recall that we assume that the client possesses a bound |
| 975 |
authentication token (e.g., cookie) for the Token Provider. The |
| 976 |
man-in-the-middle can intercept and modify any message sent by the |
| 977 |
client to the Token Provider and any message sent by the Token |
| 978 |
Provider to the client. (This means, among other things, that the |
| 979 |
man-in-the-middle controls the JavaScript running at the client in |
| 980 |
the origin of the Token Provider.) It is not, however, in possession |
| 981 |
of the client's Token Binding private key. Therefore, it can choose |
| 982 |
to either (1) replace the Token Binding ID in requests from the |
| 983 |
client to the Token Provider and create a Sec-Token-Binding header |
| 984 |
field that matches the TLS connection between the man-in-the-middle |
| 985 |
and the Token Provider or (2) leave the Sec-Token-Binding header |
| 986 |
field unchanged. If it chooses the latter, the signature in the |
| 987 |
Token Binding message (created by the original client on the EKM for |
| 988 |
the connection between the client and the man-in-the-middle) will not |
| 989 |
match a signature on the EKM between the man-in-the-middle and the |
| 990 |
Token Provider. If it chooses the former (and creates its own |
| 991 |
signature, using its own Token Binding private key, over the EKM for |
| 992 |
the connection between itself, the man-in-the-middle, and the Token |
| 993 |
Provider), then the Token Binding message will match the connection |
| 994 |
between the man-in-the-middle and the Token Provider, but the Token |
| 995 |
Binding ID in the message will not match the Token Binding ID that |
| 996 |
the client's authentication token is bound to. Either way, the |
| 997 |
man-in-the-middle is detected by the Token Provider, but only if the |
| 998 |
proof of possession of the provided Token Binding private key is |
| 999 |
required in the protocol (as is done above). |
| 1000 |
|
| 1001 |
|
| 1002 |
|
| 1003 |
|
| 1004 |
<span class="grey">Popov, et al. Standards Track [Page 18]</span></pre> |
| 1005 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-19" ></span> |
| 1006 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 1007 |
|
| 1008 |
|
| 1009 |
Next, consider the presence of a man-in-the-middle between the client |
| 1010 |
and the Token Consumer. That man-in-the-middle can intercept and |
| 1011 |
modify any message sent by the client to the Token Consumer and any |
| 1012 |
message sent by the Token Consumer to the client. The Token Consumer |
| 1013 |
is the party that redirects the client to the Token Provider. In |
| 1014 |
this case, the man-in-the-middle controls the redirect URL and can |
| 1015 |
tamper with any redirect URL issued by the Token Consumer (as well as |
| 1016 |
with any JavaScript running in the origin of the Token Consumer). |
| 1017 |
The goal of the man-in-the-middle is to trick the Token Provider into |
| 1018 |
issuing a token bound to its Token Binding ID and not to the Token |
| 1019 |
Binding ID of the legitimate client. To thwart this goal of the |
| 1020 |
man-in-the-middle, the client's Referred Token Binding ID must be |
| 1021 |
communicated to the Token Provider in a manner that cannot be |
| 1022 |
affected by the man-in-the-middle (who, as mentioned above, can |
| 1023 |
modify redirect URLs and JavaScript at the client). Including the |
| 1024 |
referred TokenBinding structure in the Sec-Token-Binding header field |
| 1025 |
(as opposed to, say, including the Referred Token Binding ID in an |
| 1026 |
application-level message as part of the redirect URL) is one way to |
| 1027 |
assure that the man-in-the-middle between the client and the Token |
| 1028 |
Consumer cannot affect the communication of the Referred Token |
| 1029 |
Binding ID to the Token Provider. |
| 1030 |
|
| 1031 |
Therefore, the Sec-Token-Binding header field in the federated |
| 1032 |
sign-on use case contains both a proof of possession of the provided |
| 1033 |
Token Binding key and a proof of possession of the referred Token |
| 1034 |
Binding key. |
| 1035 |
|
| 1036 |
Note that the presence of Token Binding does not relieve the Token |
| 1037 |
Provider and Token Consumer from performing various checks to ensure |
| 1038 |
the security of clients during the use of federated sign-on |
| 1039 |
protocols. These include the following: |
| 1040 |
|
| 1041 |
o The Token Provider should not issue tokens to Token Consumers that |
| 1042 |
have been shown to act maliciously. To aid in this, the |
| 1043 |
federation protocol should identify the Token Consumer to the |
| 1044 |
Token Provider (e.g., through OAuth client IDs or similar |
| 1045 |
mechanisms), and the Token Provider should ensure that tokens are |
| 1046 |
indeed issued to the Token Consumer identified in the token |
| 1047 |
request (e.g., by verifying that the redirect URI is associated |
| 1048 |
with the OAuth client ID). |
| 1049 |
|
| 1050 |
|
| 1051 |
|
| 1052 |
|
| 1053 |
|
| 1054 |
|
| 1055 |
|
| 1056 |
|
| 1057 |
|
| 1058 |
|
| 1059 |
|
| 1060 |
<span class="grey">Popov, et al. Standards Track [Page 19]</span></pre> |
| 1061 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-20" ></span> |
| 1062 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 1063 |
|
| 1064 |
|
| 1065 |
o The Token Consumer should verify that the tokens were issued for |
| 1066 |
it and not for some other Token Consumer. To aid in this, the |
| 1067 |
federation protocol should include an audience parameter in the |
| 1068 |
token response or apply equivalent mechanisms (the implicit OAuth |
| 1069 |
flow requires Token Consumers to identify themselves when they |
| 1070 |
exchange OAuth authorization codes for OAuth refresh tokens, |
| 1071 |
leaving it up to the Token Provider to verify that the OAuth |
| 1072 |
authorization was delivered to the correct Token Consumer). |
| 1073 |
|
| 1074 |
<span class="h2"><a class="selflink" id="section-8" href="#section-8">8</a>. Privacy Considerations</span> |
| 1075 |
|
| 1076 |
<span class="h3"><a class="selflink" id="section-8.1" href="#section-8.1">8.1</a>. Scoping of Token Binding Key Pairs</span> |
| 1077 |
|
| 1078 |
Clients use different Token Binding key pairs for different servers, |
| 1079 |
so as to not allow Token Binding to become a tracking tool across |
| 1080 |
different servers. However, the scoping of the Token Binding key |
| 1081 |
pairs to servers varies according to the scoping rules of the |
| 1082 |
application protocol (<a href="./rfc8471#section-4.1">Section 4.1 of [RFC8471]</a>). |
| 1083 |
|
| 1084 |
In the case of HTTP cookies, servers may use Token Binding to secure |
| 1085 |
their cookies. These cookies can be attached to any subdomain of |
| 1086 |
effective top-level domains (eTLDs), and clients therefore should use |
| 1087 |
the same Token Binding key pair across such subdomains. This will |
| 1088 |
ensure that any server capable of receiving the cookie will see the |
| 1089 |
same Token Binding ID from the client and thus be able to verify the |
| 1090 |
Token Binding of the cookie. See <a href="#section-2.1">Section 2.1</a> above. |
| 1091 |
|
| 1092 |
If the client application is not a web browser, it may have |
| 1093 |
additional knowledge about the relationship between different |
| 1094 |
servers. For example, the client application might be aware of the |
| 1095 |
fact that two servers play the roles of Relying Party and Identity |
| 1096 |
Provider, respectively, in a federated sign-on protocol and that they |
| 1097 |
therefore share the identity of the user. In such cases, it is |
| 1098 |
permissible to use different Token Binding key-pair scoping rules, |
| 1099 |
such as using the same Token Binding key pair for both the Relying |
| 1100 |
Party and the Identity Provider. Absent such special knowledge, |
| 1101 |
conservative key-pair scoping rules should be used, assuring that |
| 1102 |
clients use different Token Binding key pairs with different servers. |
| 1103 |
|
| 1104 |
<span class="h3"><a class="selflink" id="section-8.2" href="#section-8.2">8.2</a>. Lifetime of Token Binding Key Pairs</span> |
| 1105 |
|
| 1106 |
Token Binding key pairs do not have an expiration time. This means |
| 1107 |
that they can potentially be used by a server to track a user for an |
| 1108 |
extended period of time (similar to a long-lived cookie). HTTPS |
| 1109 |
clients such as web User Agents SHOULD therefore provide a user |
| 1110 |
interface for discarding Token Binding key pairs (similar to the |
| 1111 |
controls provided for deleting cookies). |
| 1112 |
|
| 1113 |
|
| 1114 |
|
| 1115 |
|
| 1116 |
<span class="grey">Popov, et al. Standards Track [Page 20]</span></pre> |
| 1117 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-21" ></span> |
| 1118 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 1119 |
|
| 1120 |
|
| 1121 |
If a User Agent provides modes such as private browsing mode in which |
| 1122 |
the user is promised that browsing state such as cookies are |
| 1123 |
discarded after the session is over, the User Agent MUST also discard |
| 1124 |
Token Binding key pairs from such modes after the session is over. |
| 1125 |
Generally speaking, users should be given the same level of control |
| 1126 |
over the lifetime of Token Binding key pairs as they have over |
| 1127 |
cookies or other potential tracking mechanisms. |
| 1128 |
|
| 1129 |
<span class="h3"><a class="selflink" id="section-8.3" href="#section-8.3">8.3</a>. Correlation</span> |
| 1130 |
|
| 1131 |
An application's various communicating endpoints that receive Token |
| 1132 |
Binding IDs for TLS connections other than their own obtain |
| 1133 |
information about the application's other TLS connections. (In this |
| 1134 |
context, "an application" is a combination of client-side and |
| 1135 |
server-side components, communicating over HTTPS, where the client |
| 1136 |
side may be web-browser-based, native-application-based, or both.) |
| 1137 |
These other Token Binding IDs can serve as correlation handles for |
| 1138 |
the endpoints of the other connections. If the receiving endpoints |
| 1139 |
are otherwise aware of these other connections, then no additional |
| 1140 |
information is being exposed. For instance, if in a redirect-based |
| 1141 |
federation protocol the Identity Provider and Relying Party already |
| 1142 |
possess URLs for one another, then also having Token Binding IDs for |
| 1143 |
these connections does not provide additional correlation |
| 1144 |
information. If not, by providing the other Token Binding IDs, |
| 1145 |
additional information is then exposed that can be used to correlate |
| 1146 |
the other endpoints. In such cases, a privacy analysis of enabled |
| 1147 |
correlations and their potential privacy impacts should be performed |
| 1148 |
as part of the application design decisions of how, and whether, to |
| 1149 |
utilize Token Binding. |
| 1150 |
|
| 1151 |
Also, Token Binding implementations must take care to only reveal |
| 1152 |
Token Binding IDs to other endpoints if signaled to do so by the |
| 1153 |
application associated with a Token Binding ID; see <a href="#section-6">Section 6</a> |
| 1154 |
("Implementation Considerations"). |
| 1155 |
|
| 1156 |
Finally, care should be taken to ensure that unrelated applications |
| 1157 |
do not obtain information about each other's Token Bindings. For |
| 1158 |
instance, a Token Binding implementation shared between multiple |
| 1159 |
applications on a given system should prevent unrelated applications |
| 1160 |
from obtaining each other's Token Binding information. This may be |
| 1161 |
accomplished by using techniques such as application isolation and |
| 1162 |
key segregation, depending upon system capabilities. |
| 1163 |
|
| 1164 |
|
| 1165 |
|
| 1166 |
|
| 1167 |
|
| 1168 |
|
| 1169 |
|
| 1170 |
|
| 1171 |
|
| 1172 |
<span class="grey">Popov, et al. Standards Track [Page 21]</span></pre> |
| 1173 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-22" ></span> |
| 1174 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 1175 |
|
| 1176 |
|
| 1177 |
<span class="h2"><a class="selflink" id="section-9" href="#section-9">9</a>. IANA Considerations</span> |
| 1178 |
|
| 1179 |
Below is the Internet Assigned Numbers Authority (IANA) "Permanent |
| 1180 |
Message Header Field Names" registration information per [<a href="./rfc3864" title=""Registration Procedures for Message Header Fields"">RFC3864</a>]. |
| 1181 |
|
| 1182 |
Header Field name: Sec-Token-Binding |
| 1183 |
Protocol: HTTP |
| 1184 |
Status: standard |
| 1185 |
Reference: This document |
| 1186 |
|
| 1187 |
Header Field name: Include-Referred-Token-Binding-ID |
| 1188 |
Protocol: HTTP |
| 1189 |
Status: standard |
| 1190 |
Reference: This document |
| 1191 |
|
| 1192 |
<span class="h2"><a class="selflink" id="section-10" href="#section-10">10</a>. References</span> |
| 1193 |
|
| 1194 |
<span class="h3"><a class="selflink" id="section-10.1" href="#section-10.1">10.1</a>. Normative References</span> |
| 1195 |
|
| 1196 |
[<a id="ref-PSL">PSL</a>] Mozilla, "Public Suffix List", |
| 1197 |
<<a href="https://publicsuffix.org/">https://publicsuffix.org/</a>>. |
| 1198 |
|
| 1199 |
[<a id="ref-RFC2119">RFC2119</a>] Bradner, S., "Key words for use in RFCs to Indicate |
| 1200 |
Requirement Levels", <a href="https://www.rfc-editor.org/bcp/bcp14">BCP 14</a>, <a href="./rfc2119">RFC 2119</a>, |
| 1201 |
DOI 10.17487/RFC2119, March 1997, |
| 1202 |
<<a href="https://www.rfc-editor.org/info/rfc2119">https://www.rfc-editor.org/info/rfc2119</a>>. |
| 1203 |
|
| 1204 |
[<a id="ref-RFC2818">RFC2818</a>] Rescorla, E., "HTTP Over TLS", <a href="./rfc2818">RFC 2818</a>, |
| 1205 |
DOI 10.17487/RFC2818, May 2000, |
| 1206 |
<<a href="https://www.rfc-editor.org/info/rfc2818">https://www.rfc-editor.org/info/rfc2818</a>>. |
| 1207 |
|
| 1208 |
[<a id="ref-RFC3864">RFC3864</a>] Klyne, G., Nottingham, M., and J. Mogul, "Registration |
| 1209 |
Procedures for Message Header Fields", <a href="https://www.rfc-editor.org/bcp/bcp90">BCP 90</a>, <a href="./rfc3864">RFC 3864</a>, |
| 1210 |
DOI 10.17487/RFC3864, September 2004, |
| 1211 |
<<a href="https://www.rfc-editor.org/info/rfc3864">https://www.rfc-editor.org/info/rfc3864</a>>. |
| 1212 |
|
| 1213 |
[<a id="ref-RFC4648">RFC4648</a>] Josefsson, S., "The Base16, Base32, and Base64 Data |
| 1214 |
Encodings", <a href="./rfc4648">RFC 4648</a>, DOI 10.17487/RFC4648, October 2006, |
| 1215 |
<<a href="https://www.rfc-editor.org/info/rfc4648">https://www.rfc-editor.org/info/rfc4648</a>>. |
| 1216 |
|
| 1217 |
[<a id="ref-RFC5246">RFC5246</a>] Dierks, T. and E. Rescorla, "The Transport Layer Security |
| 1218 |
(TLS) Protocol Version 1.2", <a href="./rfc5246">RFC 5246</a>, |
| 1219 |
DOI 10.17487/RFC5246, August 2008, |
| 1220 |
<<a href="https://www.rfc-editor.org/info/rfc5246">https://www.rfc-editor.org/info/rfc5246</a>>. |
| 1221 |
|
| 1222 |
[<a id="ref-RFC5705">RFC5705</a>] Rescorla, E., "Keying Material Exporters for Transport |
| 1223 |
Layer Security (TLS)", <a href="./rfc5705">RFC 5705</a>, DOI 10.17487/RFC5705, |
| 1224 |
March 2010, <<a href="https://www.rfc-editor.org/info/rfc5705">https://www.rfc-editor.org/info/rfc5705</a>>. |
| 1225 |
|
| 1226 |
|
| 1227 |
|
| 1228 |
<span class="grey">Popov, et al. Standards Track [Page 22]</span></pre> |
| 1229 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-23" ></span> |
| 1230 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 1231 |
|
| 1232 |
|
| 1233 |
[<a id="ref-RFC6265">RFC6265</a>] Barth, A., "HTTP State Management Mechanism", <a href="./rfc6265">RFC 6265</a>, |
| 1234 |
DOI 10.17487/RFC6265, April 2011, |
| 1235 |
<<a href="https://www.rfc-editor.org/info/rfc6265">https://www.rfc-editor.org/info/rfc6265</a>>. |
| 1236 |
|
| 1237 |
[<a id="ref-RFC7230">RFC7230</a>] Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer |
| 1238 |
Protocol (HTTP/1.1): Message Syntax and Routing", |
| 1239 |
<a href="./rfc7230">RFC 7230</a>, DOI 10.17487/RFC7230, June 2014, |
| 1240 |
<<a href="https://www.rfc-editor.org/info/rfc7230">https://www.rfc-editor.org/info/rfc7230</a>>. |
| 1241 |
|
| 1242 |
[<a id="ref-RFC7231">RFC7231</a>] Fielding, R., Ed. and J. Reschke, Ed., "Hypertext Transfer |
| 1243 |
Protocol (HTTP/1.1): Semantics and Content", <a href="./rfc7231">RFC 7231</a>, |
| 1244 |
DOI 10.17487/RFC7231, June 2014, |
| 1245 |
<<a href="https://www.rfc-editor.org/info/rfc7231">https://www.rfc-editor.org/info/rfc7231</a>>. |
| 1246 |
|
| 1247 |
[<a id="ref-RFC7541">RFC7541</a>] Peon, R. and H. Ruellan, "HPACK: Header Compression for |
| 1248 |
HTTP/2", <a href="./rfc7541">RFC 7541</a>, DOI 10.17487/RFC7541, May 2015, |
| 1249 |
<<a href="https://www.rfc-editor.org/info/rfc7541">https://www.rfc-editor.org/info/rfc7541</a>>. |
| 1250 |
|
| 1251 |
[<a id="ref-RFC8174">RFC8174</a>] Leiba, B., "Ambiguity of Uppercase vs Lowercase in <a href="./rfc2119">RFC</a> |
| 1252 |
<a href="./rfc2119">2119</a> Key Words", <a href="https://www.rfc-editor.org/bcp/bcp14">BCP 14</a>, <a href="./rfc8174">RFC 8174</a>, DOI 10.17487/RFC8174, |
| 1253 |
May 2017, <<a href="https://www.rfc-editor.org/info/rfc8174">https://www.rfc-editor.org/info/rfc8174</a>>. |
| 1254 |
|
| 1255 |
[<a id="ref-RFC8471">RFC8471</a>] Popov, A., Ed., Nystroem, M., Balfanz, D., and J. Hodges, |
| 1256 |
"The Token Binding Protocol Version 1.0", <a href="./rfc8471">RFC 8471</a>, |
| 1257 |
DOI 10.17487/RFC8471, October 2018, |
| 1258 |
<<a href="https://www.rfc-editor.org/info/rfc8471">https://www.rfc-editor.org/info/rfc8471</a>>. |
| 1259 |
|
| 1260 |
[<a id="ref-RFC8472">RFC8472</a>] Popov, A., Ed., Nystroem, M., and D. Balfanz, "Transport |
| 1261 |
Layer Security (TLS) Extension for Token Binding Protocol |
| 1262 |
Negotiation", <a href="./rfc8472">RFC 8472</a>, DOI 10.17487/RFC8472, October |
| 1263 |
2018, <<a href="https://www.rfc-editor.org/info/rfc8472">https://www.rfc-editor.org/info/rfc8472</a>>. |
| 1264 |
|
| 1265 |
<span class="h3"><a class="selflink" id="section-10.2" href="#section-10.2">10.2</a>. Informative References</span> |
| 1266 |
|
| 1267 |
[<a id="ref-fetch-spec">fetch-spec</a>] |
| 1268 |
WhatWG, "Fetch", Living Standard, |
| 1269 |
<<a href="https://fetch.spec.whatwg.org/">https://fetch.spec.whatwg.org/</a>>. |
| 1270 |
|
| 1271 |
[<a id="ref-OASIS.saml-core-2.0-os">OASIS.saml-core-2.0-os</a>] |
| 1272 |
Cantor, S., Kemp, J., Philpott, R., and E. Maler, |
| 1273 |
"Assertions and Protocols for the OASIS Security Assertion |
| 1274 |
Markup Language (SAML) V2.0", OASIS Standard |
| 1275 |
saml-core-2.0-os, March 2005, <<a href="http://docs.oasis-open.org/security/saml/v2.0/saml-core-2.0-os.pdf">http://docs.oasis-open.org/</a> |
| 1276 |
<a href="http://docs.oasis-open.org/security/saml/v2.0/saml-core-2.0-os.pdf">security/saml/v2.0/saml-core-2.0-os.pdf</a>>. |
| 1277 |
|
| 1278 |
|
| 1279 |
|
| 1280 |
|
| 1281 |
|
| 1282 |
|
| 1283 |
|
| 1284 |
<span class="grey">Popov, et al. Standards Track [Page 23]</span></pre> |
| 1285 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-24" ></span> |
| 1286 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 1287 |
|
| 1288 |
|
| 1289 |
[<a id="ref-OASIS.saml-prof-2.0-os">OASIS.saml-prof-2.0-os</a>] |
| 1290 |
Hughes, J., Ed., Cantor, S., Ed., Hodges, J., Ed., Hirsch, |
| 1291 |
F., Ed., Mishra, P., Ed., Philpott, R., Ed., and E. Maler, |
| 1292 |
Ed., "Profiles for the OASIS Security Assertion Markup |
| 1293 |
Language (SAML) V2.0", OASIS Standard |
| 1294 |
OASIS.saml-profiles-2.0-os, March 2005, |
| 1295 |
<<a href="http://docs.oasis-open.org/security/saml/v2.0/saml-profiles-2.0-os.pdf">http://docs.oasis-open.org/security/</a> |
| 1296 |
<a href="http://docs.oasis-open.org/security/saml/v2.0/saml-profiles-2.0-os.pdf">saml/v2.0/saml-profiles-2.0-os.pdf</a>>. |
| 1297 |
|
| 1298 |
[<a id="ref-OpenID.Core">OpenID.Core</a>] |
| 1299 |
Sakimura, N., Bradley, J., Jones, M., de Medeiros, B., and |
| 1300 |
C. Mortimore, "OpenID Connect Core 1.0 incorporating |
| 1301 |
errata set 1", November 2014, |
| 1302 |
<<a href="http://openid.net/specs/openid-connect-core-1_0.html">http://openid.net/specs/openid-connect-core-1_0.html</a>>. |
| 1303 |
|
| 1304 |
[<a id="ref-RFC6749">RFC6749</a>] Hardt, D., Ed., "The OAuth 2.0 Authorization Framework", |
| 1305 |
<a href="./rfc6749">RFC 6749</a>, DOI 10.17487/RFC6749, October 2012, |
| 1306 |
<<a href="https://www.rfc-editor.org/info/rfc6749">https://www.rfc-editor.org/info/rfc6749</a>>. |
| 1307 |
|
| 1308 |
[<a id="ref-RFC7540">RFC7540</a>] Belshe, M., Peon, R., and M. Thomson, Ed., "Hypertext |
| 1309 |
Transfer Protocol Version 2 (HTTP/2)", <a href="./rfc7540">RFC 7540</a>, |
| 1310 |
DOI 10.17487/RFC7540, May 2015, |
| 1311 |
<<a href="https://www.rfc-editor.org/info/rfc7540">https://www.rfc-editor.org/info/rfc7540</a>>. |
| 1312 |
|
| 1313 |
[<a id="ref-TOKENBIND-TLS13">TOKENBIND-TLS13</a>] |
| 1314 |
Harper, N., "Token Binding for Transport Layer Security |
| 1315 |
(TLS) Version 1.3 Connections", Work in Progress, |
| 1316 |
<a href="./draft-ietf-tokbind-tls13-01">draft-ietf-tokbind-tls13-01</a>, May 2018. |
| 1317 |
|
| 1318 |
[<a id="ref-W3C.REC-DOM-Level-3-Core-20040407">W3C.REC-DOM-Level-3-Core-20040407</a>] |
| 1319 |
Le Hors, A., Ed., Le Hegaret, P., Ed., Wood, L., Ed., |
| 1320 |
Nicol, G., Ed., Robie, J., Ed., Champion, M., Ed., and S. |
| 1321 |
Byrne, Ed., "Document Object Model (DOM) Level 3 Core |
| 1322 |
Specification", World Wide Web Consortium Recommendation |
| 1323 |
REC-DOM-Level-3-Core-20040407, April 2004, |
| 1324 |
<<a href="https://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407">https://www.w3.org/TR/2004/</a> |
| 1325 |
<a href="https://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407">REC-DOM-Level-3-Core-20040407</a>>. |
| 1326 |
|
| 1327 |
|
| 1328 |
|
| 1329 |
|
| 1330 |
|
| 1331 |
|
| 1332 |
|
| 1333 |
|
| 1334 |
|
| 1335 |
|
| 1336 |
|
| 1337 |
|
| 1338 |
|
| 1339 |
|
| 1340 |
<span class="grey">Popov, et al. Standards Track [Page 24]</span></pre> |
| 1341 |
<hr class='noprint'/><!--NewPage--><pre class='newpage'><span id="page-25" ></span> |
| 1342 |
<span class="grey"><a href="./rfc8473">RFC 8473</a> Token Binding over HTTP October 2018</span> |
| 1343 |
|
| 1344 |
|
| 1345 |
Acknowledgements |
| 1346 |
|
| 1347 |
This document incorporates comments and suggestions offered by Eric |
| 1348 |
Rescorla, Gabriel Montenegro, Martin Thomson, Vinod Anupam, Anthony |
| 1349 |
Nadalin, Michael B. Jones, Bill Cox, Brian Campbell, and others. |
| 1350 |
|
| 1351 |
This document was produced under the chairmanship of John Bradley and |
| 1352 |
Leif Johansson. The area directors included Eric Rescorla, Kathleen |
| 1353 |
Moriarty, and Stephen Farrell. |
| 1354 |
|
| 1355 |
Authors' Addresses |
| 1356 |
|
| 1357 |
Andrei Popov |
| 1358 |
Microsoft Corp. |
| 1359 |
United States of America |
| 1360 |
|
| 1361 |
Email: [email protected] |
| 1362 |
|
| 1363 |
|
| 1364 |
Magnus Nystroem |
| 1365 |
Microsoft Corp. |
| 1366 |
United States of America |
| 1367 |
|
| 1368 |
Email: [email protected] |
| 1369 |
|
| 1370 |
|
| 1371 |
Dirk Balfanz (editor) |
| 1372 |
Google Inc. |
| 1373 |
United States of America |
| 1374 |
|
| 1375 |
Email: [email protected] |
| 1376 |
|
| 1377 |
|
| 1378 |
Nick Harper |
| 1379 |
Google Inc. |
| 1380 |
United States of America |
| 1381 |
|
| 1382 |
Email: [email protected] |
| 1383 |
|
| 1384 |
|
| 1385 |
Jeff Hodges |
| 1386 |
Kings Mountain Systems |
| 1387 |
United States of America |
| 1388 |
|
| 1389 |
Email: [email protected] |
| 1390 |
|
| 1391 |
|
| 1392 |
|
| 1393 |
|
| 1394 |
|
| 1395 |
|
| 1396 |
Popov, et al. Standards Track [Page 25] |
| 1397 |
</pre> |