wdiff draft-ietf-oauth-v2-http-mac-02.txt draft-ietf-oauth-v2-http-mac-03.txt

OAuth J. Richer, Ed.
Network Working Group Richer
Internet-Draft The MITRE Corporation
Intended status: Standards Track W. Mills, Ed. Mills
Expires: May 30, August 29, 2013 Yahoo! Inc.
H. Tschofenig, Ed.
Nokia Siemens Networks
November 28, 2012
February 25, 2013

OAuth 2.0 Message Authentication Code (MAC) Tokens
draft-ietf-oauth-v2-http-mac-02
draft-ietf-oauth-v2-http-mac-03

Abstract

This document specifies the HTTP specification describes how to use MAC access authentication scheme, an Tokens in HTTP authentication method requests
to access OAuth 2.0 protected resources. An OAuth client willing to
access a protected resource needs to demonstrate possession of a
crytographic key by using it with a keyed message authentication code (MAC)
algorithm digest function to provide cryptographic verification of portions of HTTP
requests.
the request.

The document also defines an OAuth 2.0 binding a key distribution protocol for use as
an access token type.

NOTE: This document (and other OAuth 2.0 security documents, such as
[I-D.tschofenig-oauth-hotk]) are still work in progress in the OAuth
working group. As such, the content of this document may change.
For obtaining a discussion about security requirements please consult [I-D
.tschofenig-oauth-security]. Your input on the detailed security
requirements is highly appreciated.
fresh session key.

Status of this Memo

This Internet-Draft is submitted in full conformance with the
provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering
Task Force (IETF). Note that other groups may also distribute
working documents as Internet-Drafts. The list of current Internet-
Drafts is at http://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months
and may be updated, replaced, or obsoleted by other documents at any
time. It is inappropriate to use Internet-Drafts as reference
material or to cite them other than as "work in progress."

This Internet-Draft will expire on May 30, August 29, 2013.

This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents (http://trustee.ietf.org/
license-info)
(http://trustee.ietf.org/license-info) in effect on the date of
publication of this document. Please review these documents
carefully, as they describe your rights and restrictions with respect
to this document. Code Components extracted from this document must
include Simplified BSD License text as described in Section 4.e of
the Trust Legal Provisions and are provided without warranty as
described in the Simplified BSD License.

Table of Contents

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1. Example 4
2. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 4
3. Architecture . . . . . . . 3
1.2. Notational Conventions . . . . . . . . . . . . . . . . . . 5
2. Issuing MAC Credentials
4. Key Distribution . . . . . . . . . . . . . . . . . . . 5
3. Making Requests . . . . 7
4.1. Session Key Transport to Client . . . . . . . . . . . . . 7
4.2. Session Key Transport to Resource Server . . . . . . 6
3.1. . . . 9
5. The "Authorization" Request Header Authenticator . . . . . . . . . . . . . . 6
3.2. Request MAC . . . . . . . . 10
5.1. The Authenticator . . . . . . . . . . . . . . . 7
3.2.1. Normalized Request . . . . . 10
5.2. MAC Input String . . . . . . . . . . . . . . 7
3.2.2. . . . . . . . 13
5.3. Keyed Message Digest Algorithms . . . . . . . . . . . . . 14
5.3.1. hmac-sha-1 . . . . . . . . . . . . . . . . . . . . . . 8
3.2.3. 14
5.3.2. hmac-sha-256 . . . . . . . . . . . . . . . . . . . . . 9
4. 14
6. Verifying Requests the Authenticator . . . . . . . . . . . . . . . . . 15
6.1. Timestamp Verification . . . . . 9
4.1. Timestamp Verification . . . . . . . . . . . . . 15
6.2. Error Handling . . . . . 9
4.2. The "WWW-Authenticate" Response Header Field . . . . . . . 10
5. Use with OAuth 2.0 . . . . . . . . . . 16
7. Example . . . . . . . . . . . . 11
5.1. Issuing MAC-Type Access Tokens . . . . . . . . . . . . . . 11
6. . 17
8. Security Considerations . . . . . . . . . . . . . . . . . . . 12
6.1. MAC Keys Transmission 17
8.1. Key Distribution . . . . . . . . . . . . . . . . . . 12
6.2. . . . 17
8.2. Offering Confidentiality of Requests Protection for Access to
Protected Resources . . . . . . . . . . . . . . . 12
6.3. Spoofing by Counterfeit Servers . . . . 17
8.3. Authentication of Resource Servers . . . . . . . . . . . 12
6.4. . 18
8.4. Plaintext Storage of Credentials . . . . . . . . . . . . . 12
6.5. 18
8.5. Entropy of MAC Session Keys . . . . . . . . . . . . . . . . . . . 13
6.6. 18
8.6. Denial of Service / Resource Exhaustion Attacks . . . . . 13
6.7. 19
8.7. Timing Attacks . . . . . . . . . . . . . . . . . . . . . . 14
6.8. 19
8.8. CSRF Attacks . . . . . . . . . . . . . . . . . . . . . . . 14
6.9. Coverage Limitations 19
8.9. Protecting HTTP Header Fields . . . . . . . . . . . . . . 20
9. IANA Considerations . . . . . 14
7. IANA Considerations . . . . . . . . . . . . . . . . 20
9.1. JSON Web Token Claims . . . . . 15
7.1. The HTTP . . . . . . . . . . . . . 20
9.2. MAC Authentication Scheme Token Algorithm Registry . . 15
7.1.1. . . . . . . . . . . . . . 20
9.2.1. Registration Template . . . . . . . . . . . . . . . . 15
7.1.2. 21
9.2.2. Initial Registry Contents . . . . . . . . . . . . . . 16
7.2. 21
9.3. OAuth Access Token Type Registration . . . . . . . . . . . 16
7.2.1. 22
9.3.1. The "mac" OAuth Access Token Type . . . . . . . . . . 16
7.3. 22
9.4. OAuth Parameters Registration . . . . . . . . . . . . . . 17
7.3.1. 22
9.4.1. The "mac_key" OAuth Parameter . . . . . . . . . . . . 17
7.3.2. 22
9.4.2. The "mac_algorithm" OAuth Parameter . . . . . . . . . 17
8. Contributors . . . . . . . . . . . 22
9.4.3. The "kid" OAuth Parameter . . . . . . . . . . . . . . 17
9. 23
10. Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . 17
10. 23
11. References . . . . . . . . . . . . . . . . . . . . . . . . . . 17
10.1. 23
11.1. Normative References . . . . . . . . . . . . . . . . . . 17
10.2. . 23
11.2. Informative References . . . . . . . . . . . . . . . . . 18 . 25
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 19 25

1. Introduction

This specification defines the HTTP describes how to use MAC access authentication scheme,
providing a method for making authenticated Tokens in HTTP requests with
partial cryptographic verification of the request, covering the HTTP
method, request URI,
and host.

Similar responses to the HTTP Basic access authentication scheme [RFC2617], protected resources via the
MAC scheme utilizes OAuth 2.0
protocol [RFC6749]. An OAuth client willing to access a set protected
resource needs to demonstrate possession of client credentials which include an
identifier and key. However, in contrast with the Basic scheme, the a symmetric key is never included in authenticated requests but is used by using
it with a keyed message digest function to
calculate the request MAC value which request. The keyed
message digest function is included instead. computed over a flexible set of parameters
from the HTTP message.

The MAC scheme Token mechanism requires the establishment of a shared
symmetric key between the client and the resource server. This
specification offers one
such method for issuing defines a set of MAC credentials three party key distribution protocol to
dynamically distribute this session key from the authorization server
to the client using
OAuth 2.0 in and the form of a MAC-type access token. resource server.

The primary design goal of this mechanism is to simplify and improve
HTTP authentication for services that are unwilling or unable to
employ TLS for every request. In particular, this mechanism leverage
an initial TLS setup phase to establish a shared secret between the
client and the server. The shared secret is then used over an
insecure channel to provide protection against a passive network
attacker. support the requirements
outlined in [I-D.tschofenig-oauth-security]. In particular, when a
server uses this mechanism, a passive network attacker will be unable to "steal" use
an eavesdropped access token exchanged between the user's session token, as is
possible today with cookies client and other bearer tokens. the
resource server. In addition, this mechanism helps secure the session access
token against leakage when sent over a secure channel to the wrong server. For example, when
the client uses some form of dynamic configuration to determine where
to send an authenticated request, or when the client fails to
properly validate the server's identity as part of its TLS handshake.

Unlike the HTTP Digest authentication scheme, this mechanism does not
require interacting with the
resource server to prevent replay attacks.
Instead, if the client provides both a nonce and a timestamp, which the
server can use to prevent replay attacks using a bounded amount of
storage. Also unlike Digest, this mechanism is not intended to
protect the user's password itself because provided information about the client and resource
server both
have access it wants to the key material interact with in the clear. Instead, servers
should issue a short-lived derivative credential for this mechanism
during the initial TLS setup phase.

1.1. Example

The client attempts to access a protected resource without
authentication, making the following HTTP request to the resource
server:

GET /resource/1?b=1&a=2 HTTP/1.1
Host: example.com

The resource server returns the following authentication challenge:

HTTP/1.1 401 Unauthorized
WWW-Authenticate: MAC

The client has previously obtained a set of MAC credentials for
accessing resources on the "http://example.com/" authorization
server. The MAC
credentials issued to the client include the following attributes:

MAC key identifier: h480djs93hd8

MAC key: 489dks293j39

MAC algorithm: hmac-sha-1

The client constructs the

Since a keyed message digest only provides integrity protection and
data-origin authentication header confidentiality protection can only be
added by calculating a
timestamp (e.g. the number usage of seconds since January 1, 1970 00:00:00
GMT) and generating a random string used as Transport Layer Security (TLS). This
specification provides a nonce:

Timestamp: 1336363200

Nonce: dj83hs9s

The client constructs the normalized request string (the new line
separator character is represented by "\n" mechanism for display purposes only;
the trailing new line separator signify that no extension value channel binding is included with the request, explained below):

1336363200\n
dj83hs9s\n
GET\n
/resource/1?b=1&a=2\n
example.com\n
80\n
\n

The request MAC is calculated using the specified MAC algorithm
"hmac-sha-1" and the MAC key over the normalized request string. The
result is base64-encoded to produce the request MAC:

bhCQXTVyfj5cmA9uKkPFx1zeOXM=

The client includes the MAC key identifier, nonce, and request MAC
with the request using the "Authorization" request header field:

GET /resource/1?b=1&a=2 HTTP/1.1
Host: example.com
Authorization: MAC id="h480djs93hd8",
ts="1336363200",
nonce="dj83hs9s",
mac="bhCQXTVyfj5cmA9uKkPFx1zeOXM="

The server validates the request by calculating the request MAC again
based on the request received and verifies the validity
ensure that a TLS channel is not terminated prematurely and scope of
the MAC credentials. If valid, the server responds with indeed
covers the
requested resource representation.

1.2. Notational Conventions entire end-to-end communication.

2. Terminology

The key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL NOT',
'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'MAY', and 'OPTIONAL' in this
specification are to be interpreted as described in [RFC2119].

This specification uses the Augmented Backus-Naur Form (ABNF)
notation of [I-D.ietf-httpbis-p1-messaging]. Additionally, the
following rules are included from [RFC2617]: auth-param.

2. Issuing MAC Credentials

This specification provides one method for issuing MAC credentials
using OAuth 2.0 as described in Section 5. This specification does
not mandate servers

Session Key:

The terms mac key, session key, and symmetric key are used
interchangably and refer to support any particular method for issuing MAC
credentials, the cryptographic keying material
established between the client and other methods MAY be defined the resource server. This
temporary key used between the client and used. Whenever MAC
credentials are issued, the credentials MUST include resource server,
with a lifetime limited to the following
attributes:

MAC lifetime of the access token. This
session key identifier is generated by the authorization server.

Authenticator:

A string identifying record containing information that can be shown to have been
recently generated using the MAC session key used to calculate known only by the request
MAC. client
and the resource server.

Message Authentication Code (MAC):

Message authentication codes (MACs) are hash functions that take
two distinct inputs, a message and a secret key, and produce a
&#64257;xed-size output. The string design goal is usually opaque that it is
practically infeasible to produce the client. same output without
knowledge of the key. The terms keyed message digest functions
and MACs are used interchangably.

3. Architecture

The architecture of the proposal described in this document assumes
that the authorization server
typically assigns acts as a specific scope trusted third party that
provides session keys to clients and lifetime to each set of
MAC credentials. The identifier MAY denote a unique value resource servers. These
session keys are used by the client and the resource server as input
to retrieve a MAC. In order to obtain the session key the client interacts
with the authorization information (e.g. from server as part of the a
database), or self-contain normal grant exchange.
This is shown in an abstract way in Figure 1. Together with the
access token the authorization information server returns a session key (in the
mac_key parameter) and several other parameters. The resource server
obtains the session key via the access token. Both of these two key
distribution steps are described in more detail in Section 4.

+---------------+
^| | AS-RS Key
// | Authorization |<*******
/ | Server | *
// | | *
/ | | *
(I) // /+---------------+ *
Access / // *
Token / / *
Request// // (II) Access Token *
/ / +Session Key (SK) *
// // *
/ v v
+-----------+ +------------+
| | | |
| | | Resource |
| Client | | Server |
| | | |
| | | |
+-----------+ +------------+

****: Out-of-Band Long-Term Key Establishment
----: Dynamic Session Key Distribution

Figure 1: Architecture: Interaction between the Client and the
Authorization Server.

Once the client has obtained the necessary access token and the
session key (including parameters) it can start to interact with the
resource server. To demonstrate possession of the session key it
computes a MAC and adds various fields to the outgoing request
message. We call this structure the "Authenticator". The server
evaluates the request, includes an Authenticator and returns a
verifiable manner (i.e.
response back to the client. Since the access token is valid for a string consisting
period of some data time the resource server may decide to cache it so that it
does not need to be provided in every request from the client. This
interaction is shown in Figure 2.

+---------------+
| |
| Authorization |
| Server |
| |
| |
+---------------+

+-----------+ Authenticator (a) +------------+
| |---------------------->| |
| | [+Access Token] | Resource |
| Client | | Server |
| | Authenticator (b) | |
| |<----------------------| |
+-----------+ +------------+

^ ^
| |
| |
SK SK
+param +param

Figure 2: Architecture: Interaction between the Client and the
Resource Server.

4. Key Distribution

For this scheme to function a
signature).

MAC session key
A shared symmetric secret must be available to the
client and the resource server, which is then used as a parameter in
the MAC algorithm key. The keyed message digest function. This document describes the key
distribution mechanism that uses the authorization server MUST NOT reissue as a previously issued MAC
trusted third party, which ensures that the session key is
transported from the authorization server to the client and the
resource server.

4.1. Session Key Transport to Client

Authorization servers issue MAC Tokens based on requests from
clients. The request MUST include the audience parameter defined in
[I-D.tschofenig-oauth-audience], which indicates the resource server
the client wants to interact with. This specification assumes use of
the 'Authorization Code' grant. If the request is processed
successfully by the authorization server it MUST return at least the
following parameters to the client:

kid

The name of the key (key id), which is an identifier combination.

MAC algorithm
A generated
by the resource server. It is RECOMMENDED that the
authorization server generates this key id by computing a hash
over the access_token, for example using SHA-1, and to encode
it in a base64 format.

access_token

The OAuth 2.0 access token.

mac_key

The session key generated by the authorization server. Note
that the lifetime of the session key is equal to the lifetime
of the access token.

mac_algorithm

The MAC algorithm used to calculate the request MAC. Value The value
MUST be one of "hmac-sha-1", "hmac-sha-256", or a registered
extension algorithm name as described in Section 7.1.
Algorithm names are case-sensitive. If 9.2. The
authorization server is assumed to know the MAC set of algorithms
supported by the client and the resource server. It selects an
algorithm that meets the security policies and is
not understood supported by
both nodes.

For example:

HTTP/1.1 200 OK
Content-Type: application/json
Cache-Control: no-store

{
"access_token":
"eyJhbGciOiJSU0ExXzUiLCJlbmMiOiJBMTI4Q0JDK0hTMjU2In0.
pwaFh7yJPivLjjPkzC-GeAyHuy7AinGcS51AZ7TXnwkC80Ow1aW47kcT_UV54ubo
nONbeArwOVuR7shveXnwPmucwrk_3OCcHrCbE1HR-Jfme2mF_WR3zUMcwqmU0RlH
kwx9txo_sKRasjlXc8RYP-evLCmT1XRXKjtY5l44Gnh0A84hGvVfMxMfCWXh38hi
2h8JMjQHGQ3mivVui5lbf-zzb3qXXxNO1ZYoWgs5tP1-T54QYc9Bi9wodFPWNPKB
kY-BgewG-Vmc59JqFeprk1O08qhKQeOGCWc0WPC_n_LIpGWH6spRm7KGuYdgDMkQ
bd4uuB0uPPLx_euVCdrVrA.
AxY8DCtDaGlsbGljb3RoZQ.
7MI2lRCaoyYx1HclVXkr8DhmDoikTmOp3IdEmm4qgBThFkqFqOs3ivXLJTku4M0f
laMAbGG_X6K8_B-0E-7ak-Olm_-_V03oBUUGTAc-F0A.
OwWNxnC-BMEie-GkFHzVWiNiaV3zUHf6fCOGTwbRckU",
"token_type":"mac",
"expires_in":3600,
"refresh_token":"8xLOxBtZp8",
"kid":"22BIjxU93h/IgwEb4zCRu5WF37s=",
"mac_key":"adijq39jdlaska9asud",
"mac_algorithm":"hmac-sha-256"
}

4.2. Session Key Transport to Resource Server

The transport of the mac_key from the authorization server to the
resource server is accomplished by conveying the client, encrypting mac_key
inside the client access token. At the time of writing only one
standardized format for carrying the access token is defined: the
JSON Web Token (JWT) [I-D.ietf-oauth-json-web-token]. Note that the
header of the JSON Web Encryption (JWE) structure
[I-D.ietf-jose-json-web-encryption], which is a JWT with encrypted
content, MUST NOT use contain a key id (kid) in the MAC
credentials header to allow the
resource server to select the appropriate keying material for
decryption. This keying material is a symmetric or an asymmetric
long-term key established between the resource server and continue the
authorization server, as if no MAC credentials were issued. shown in Figure 1 as AS-RS key. The MAC
establishment of this long-term key identifier, MAC key, MAC algorithm strings MUST NOT
include characters other than:

%x20-21 / %x23-5B / %x5D-7E
; Any printable ASCII character except for <"> is outside the scope of this
specification.

This document defines two new claims to be carried in the JWT:
mac_key, kid. These two parameters match the content of the mac_key
and <\>

3. Making Requests the kid conveyed to the client, as shown in Section 4.1.

kid

The name of the key (key id), which is an identifier generated
by the resource server.

mac_key

The session key generated by the authorization server.

This example shows a JWT claim set without header and without
encryption:

{"iss":"authorization-server.example.com",
"exp":1300819380,
"kid":"22BIjxU93h/IgwEb4zCRu5WF37s=",
"mac_key":"adijq39jdlaska9asud",
"aud":"apps.example.com"
}

QUESTIONS: An alternative to the use of a JWT to convey the access
token with the encrypted mac_key is use the token introspect
[I-D.richer-oauth-introspection]. What mechanism should be
described? What should be mandatory to implement?
QUESTIONS: The above description assumes that the entire access
token is encrypted but it would be possible to only encrypt the
session key and to only apply integrity protection to other
fields. Is this desireable?

5. The Authenticator

To make authenticated requests, access a protected resource the client must be in the possession
of a valid set of MAC credentials accepted session key provided by the authorization server.
The client constructs the request by calculating a set of attributes, authenticator, as described in Section 5.1.

5.1. The Authenticator

The client constructs the authenticator and adding
them adds the resulting fields
to the HTTP request using the "Authorization" request header
field as described in Section 3.1.

3.1. The "Authorization" Request Header field.
The "Authorization" request header field uses the framework defined
by [RFC2617] as follows:

credentials [RFC2617]. To include the authenticator in a subsequent response
from the authorization server to the client the WWW-Authenticate
header is used. For further exchanges a new, yet-to-be-defined
header will be used.

authenticator = "MAC" 1*SP #params

params = id / ts / nonce seq-nr / ext access_token / mac

id / h / cb

kid = "id" "kid" "=" string-value
ts = "ts" "=" ( <"> timestamp <"> ) / timestamp
nonce
seq-nr = "nonce" "seq-nr" "=" string-value
ext
access_token = "ext" "access_token" "=" string-value b64token
mac = "mac" "=" string-value
cb = "cb" "=" token
h = "h" "=" h-tag
h-tag = %x68 [FWS] "=" [FWS] hdr-name
*( [FWS] ":" [FWS] hdr-name )
hdr-name = token

timestamp = 1*DIGIT
string-value = ( <"> plain-string <"> ) / plain-string
plain-string = 1*( %x20-21 / %x23-5B / %x5D-7E )

b64token = 1*( ALPHA / DIGIT /
"-" / "." / "_" / "~" / "+" / "/" ) *"="

The header attributes are set as follows:

kid

REQUIRED. The MAC key identifier.

REQUIRED. The request timestamp. The value MUST be a positive integer
set by the client when making each request to the number of seconds elapsed from a fixed point in time (e.g.
milliseconds since 1 January 1, 1970 00:00:00 GMT). 1970.

The value MUST NOT include
leading zeros (e.g. "000273154346").

nonce
REQUIRED. A unique string generated JavaScript getTime() function or the Java
System.currentTimeMillis() function, for example, produce such
a timestamp.

seq-nr

OPTIONAL. This optional field includes the initial sequence
number to be used by the messages exchange between the client
and the server when the replay protection provided by the
timestamp is not sufficient enough replay protection. This
field specifies the initial sequence number for messages from
the client to the server. When included in the response
message, the initial sequence number is that for messages from
the server to the client. The Sequence numbers fall in the range 0
through 2^64 - 1 and wrap to zero following the value
MUST 2^64 - 1.

The initial sequence number SHOULD be unique random and uniformly
distributed across all requests with the same timestamp full space of possible sequence numbers,
so that it cannot be guessed by an attacker and
MAC key identifier combination.

ext
OPTIONAL. A string used so that it and
the successive sequence numbers do not repeat other sequences.
In the event that more than 2^64 messages are to include additional information be generated
in a series of messages, rekeying MUST be performed before
sequence numbers are reused. Rekeying requires a new access
token to be requested.

access_token

CONDITIONAL. The access_token MUST be included in the first
request from the client to the server but MUST NOT be included
in a subsequent response and in a further protocol exchange.

mac

REQUIRED. The result of the keyed message digest computation,
as described in Section 5.3.

OPTIONAL. This field carries the channel binding value from
RFC 5929 [RFC5929] in the following format: cb= channel-
binding-type ":" channel-binding-content. RFC 5929 offers two
types of channel bindings for TLS. First, there is the 'tls-
server-end-point' channel binding, which uses a hash of the TLS
server's certificate as it appears, octet for octet, in the
server's Certificate message. The second channel binding is
'tls-unique', which uses the first TLS Finished message sent
(note: the Finished struct, not the TLS record layer message
containing it) in the most recent TLS handshake of the TLS
connection being bound to. As an example, the cb field may
contain cb=tls-unique:9382c93673d814579ed1610d3
h

OPTIONAL. This field contains a colon-separated list of header
field names that identify the header fields presented to the
keyed message digest algorithm. If the 'h' header field is covered
absent then the following value is set by default: h="host".
The field MUST contain the request MAC. complete list of header fields in
the order presented to the keyed message digest algorithm. The content and format
field MAY contain names of header fields that do not exist at
the
string is beyond time of computing the scope keyed message digest; nonexistent
header fields do not contribute to the keyed message digest
computation (that is, they are treated as the null input,
including the header field name, the separating colon, the
header field value, and any CRLF terminator). By including
header fields that do not actually exist in the keyed message
digest computation, the client can allow the resource server to
detect insertion of those header fields by intermediaries.
However, since the client cannot possibly know what header
fields might be defined in the future, this specification.

mac
REQUIRED. mechanism cannot be
used to prevent the addition of any possible unknown header
fields. The HTTP request MAC as described field MAY contain multiple instances of a header
field name, meaning multiple occurrences of the corresponding
header field are included in the header hash. The field MUST
NOT include the mac header field. Folding whitespace (FWS) MAY
be included on either side of the colon separator. Header
field names MUST be compared against actual header field names
in a case-insensitive manner. This list MUST NOT be empty.
See Section 3.2. 8 for a discussion of choosing header fields.

Attributes MUST NOT appear more than once. Attribute values are
limited to a subset of ASCII, which does not require escaping, as
defined by the plain-string ABNF.

3.2. Request

5.2. MAC

The Input String

An HTTP message can either be a request from client uses the MAC algorithm and the MAC key to calculate server or a
response from server to client. Syntactically, the
request MAC. This specification defines two algorithms: "hmac-sha-1"
and "hmac-sha-256", and provides an extension registry for additional
algorithms.

3.2.1. Normalized Request String

The normalized request string is a consistent, reproducible
concatenation of several types of
message differ only in the HTTP request elements into start-line, which is either a single
string. By normalizing the request into request-line
(for requests) or a reproducible string, the
client status-line (for responses).

Two parameters serve as input to a keyed message digest function: a
key and server can both calculate an input string. Depending on the request MAC over communication direction
either the exact
same value.

The string is constructed by concatenating together, in order, request-line or the
following HTTP request elements, each followed by a new line
character (%x0A):

1. The timestamp value calculated for status-line is used as the request.

2. The nonce first value generated for the request.

3. The HTTP request method in upper case. For example: "HEAD",
"GET", "POST", etc.

4. The HTTP request-URI as defined
followed by [RFC2616] section 5.1.2.

5. The hostname included in the HTTP request using the "Host"
request header field in lower case.

6. The port as included fields listed in the HTTP request using the "Host" request
header field. If 'h' parameter.
Then, the header timestamp field does not include a port, and the
default value for seq-nr field (if present) is
concatenated.

As an example, consider the scheme MUST be used (e.g. 80 for HTTP and
443 for HTTPS).

7. The value of the "ext" "Authorization" request header field
attribute if one was included in with the request, otherwise, an empty
string.

Each element is followed by a new line separator
character (%x0A) including represented by "\n" for editorial purposes only. The h
parameter is set to h=host, the
last element and even when an element value kid is an empty string.

For example, 314906b0-7c55, and the HTTP request:
timstamp is 1361471629.

POST /request?b5=%3D%253D&a3=a&c%40=&a2=r%20b&c2&a3=2+q HTTP/1.1
Host: example.com
Hello World!

using timestamp "264095:7d8f3e4a", nonce "7d8f3e4a",

The resulting string is:

POST /request?b5=%3D%253D&a3=a&c%40=&a2=r%20b&c2&a3=2+q HTTP/1.1\n
1361471629\n
example.com\n

5.3. Keyed Message Digest Algorithms

The client uses a cryptographic algorithm together with a session key
to calculate a keyed message digest. This specification defines two
algorithms: "hmac-sha-1" and "hmac-sha-256", and provides an
extension
string "a,b,c" is normalized into the following string (the new line
separator character is represented by "\n" registry for display purposes
only):

264095\n
7d8f3e4a\n
POST\n
/request?b5=%3D%253D&a3=a&c%40=&a2=r%20b&c2&a3=2+q\n
example.com\n
80\n
a,b,c\n

3.2.2. additional algorithms.

5.3.1. hmac-sha-1

"hmac-sha-1" uses the HMAC-SHA1 algorithm algorithm, as defined in [RFC2104]:

mac = HMAC-SHA1 (key, text)

Where:

text

is set to the value of the normalized request input string as described in
Section 3.2.1, 5.2,
key

is set to the MAC session key provided by the authorization server,
and
mac

is used to set the value of the "mac" attribute, after the
result octet string is base64-encoded per [RFC2045] section
6.8.

3.2.3. Section 6.8 of [RFC2045].

5.3.2. hmac-sha-256

"hmac-sha-256" uses the HMAC algorithm algorithm, as defined in [RFC2104]
together [RFC2104], with
the SHA-256 hash function function, defined in [NIST-FIPS-180-3]:

mac = HMAC-SHA256 (key, text)

Where:

text

is set to the value of the normalize request input string as described in
Section 3.2.1, 5.2,
key

is set to the MAC session key provided by the authorization server,
and
mac

is used to set the value of the "mac" attribute, after the
result octet string is base64-encoded per [RFC2045] section
6.8.

4. Section 6.8 of [RFC2045].

6. Verifying Requests

A server the Authenticator

When receiving a message with an authenticated request validates it by
performing authenticator the following REQUIRED steps: steps
are performed:

1. When the authorization server receives a message with a new
access token (and consequently a new session key) then it obtains
the session key by retrieving the content of the access token
(which requires decryption of the session key contained inside
the token). The content of the access token, in particular the
audience field and the scope, MUST be verified as described in
Alternatively, the kid parameter is used to look-up a cached
session key from a previous exchange.
2. Recalculate the request MAC keyed message digest, as described in
Section 3.2 5.3, and compare the request MAC to the value received
from the client via the "mac" attribute.

2. Ensure
3. Verify that no replay took place by comparing the combination value of timestamp, nonce, and MAC key
identifier received from the client has not been received before
in a previous request. ts
(timestamp) header with the local time. The server MAY reject requests processing of
authenticators with stale timestamps as is described in Section 4.1.

3. Verify the scope and validity of the MAC credentials.

If the request fails verification, the server SHOULD respond using
the 401 (Unauthorized) HTTP status code and include the "WWW-
Authenticate" response header field as 6.1.

Error handling is described in Section 4.2.

4.1. 6.2.

6.1. Timestamp Verification

The timestamp, nonce, and MAC key identifier combination provide a
unique identifier which timestamp field enables the server to prevent detect replay attacks.
Without replay protection, an attacker can use a compromised (but
otherwise valid and authenticated) an eavesdropped
request more than once, gaining
long term to gain access to a protected resource.

Including a timestamp with the nonce removes the need to retain an
infinite number of nonce values for future checks, by enabling the
server to restrict the time period after which a request with an old
timestamp is rejected. If such a restriction The following
procedure is enforced, the server
MUST: used to detect replays:

o At the time the first request is received from the client for each
MAC
key identifier, calculate the difference (in seconds) between the
request timestamp and the server's local clock. The difference -
the request time delta - MUST be kept as long as the MAC key
credentials are valid. is stored
locally for later use.
o For each subsequent client request, apply the request time delta to request the
timestamp included in the message to calculate the adjusted
request time - the
time when the request MAC has been generated by the client,
adjusted to the server's clock. time.
o Verify that the adjusted request time is within the allowed time
period defined by the authorization server. The server SHOULD allow for a
sufficiently large window to accommodate network delays (between If the local time and
the calculated time based in the request has been generated differ by more than the client
allowable clock skew (e.g., 5 minutes) a replay has to the time
it is received by the server and processed).

4.2. The "WWW-Authenticate" Response Header Field be assumed.

6.2. Error Handling

If the protected resource request does not include authentication
credentials, an access token,
lacks the keyed message digest, contains an invalid MAC key identifier,
or is malformed, the server SHOULD include the return a 401 (Unauthorized) HTTP "WWW-Authenticate" response header
field.
status code.

For example:

HTTP/1.1 401 Unauthorized
WWW-Authenticate: MAC

The "WWW-Authenticate" request header field uses the framework
defined by [RFC2617] as follows:

challenge = "MAC" [ 1*SP #param ]
param = error / auth-param
error = "error" "=" ( token / quoted-string)

Each attribute MUST NOT appear more than once.

If the protected resource request included a MAC "Authorization"
request header field and failed authentication, the server MAY
include the "error" attribute to provide the client with a human-
readable explanation why the access request was declined to assist
the client developer in identifying the problem.

For example:

HTTP/1.1 401 Unauthorized
WWW-Authenticate: MAC error="The MAC credentials expired"

5. Use with OAuth 2.0

OAuth 2.0 ([RFC6749]) defines an extensible token-based
authentication framework. The MAC authentication scheme can be used
to make OAuth-based requests by issuing MAC-type access tokens.

This specification does not define methods for the client to
specifically request a MAC-type token from the authorization server.
Additionally, it does not include any discovery facilities for
identifying which HMAC algorithms are supported by a resource server,
or how the client may go about obtaining MAC access tokens for any
given protected resource.

5.1. Issuing MAC-Type Access Tokens

Authorization servers issuing MAC-type access tokens MUST include the
following parameters whenever a response includes the "access_token"
parameter:

access_token
REQUIRED. The MAC key identifier.

mac_key
REQUIRED. The MAC key.

mac_algorithm
REQUIRED. The MAC algorithm used to calculate the request MAC.
Value MUST be one of "hmac-sha-1", "hmac-sha-256", or a
registered extension algorithm name as described

7. Example

[Editor's Note: Full example goes in Section
7.1.

For example:

HTTP/1.1 200 OK
Content-Type: application/json
Cache-Control: no-store

{
"access_token":"SlAV32hkKG",
"token_type":"mac",
"expires_in":3600,
"refresh_token":"8xLOxBtZp8",
"mac_key":"adijq39jdlaska9asud",
"mac_algorithm":"hmac-sha-256"
}

6. here.]

8. Security Considerations

As stated in [RFC2617], the greatest sources of risks are usually
found not in the core protocol itself but in policies and procedures
surrounding its use. Implementers are strongly encouraged to assess
how this protocol addresses their security requirements.

6.1. MAC Keys Transmission requirements and the
security threats they want to mitigate.

8.1. Key Distribution

This specification describes two a key distribution mechanism for obtaining or
transmitting MAC keys, both require
providing the use of session key (and parameters) from the authorization
server to the client. The interaction between the client and the
authorization server requires Transport Layer Security (TLS) with a transport-layer
ciphersuite offering confidentiality protection. The session key
MUST NOT be transmitted in clear since this would completely destroy
the security mechanism when sending MAC keys benefits of the proposed scheme. Furthermore, the
obtained session key MUST be stored so that only the client instance
has access to it. Storing the client. Additional
methods used session key, for example, in a cookie
allows other parties to obtain MAC credentials must ensure that these
transmissions are protected using transport-layer mechanisms such as
TLS or SSL.

6.2. Confidentiality gain access to this confidential information
and compromises the security of Requests

While the protocol.

8.2. Offering Confidentiality Protection for Access to Protected
Resources

This specification can be used with and without Transport Layer
Security (TLS).

Without TLS this protocol provides a mechanism for verifying the
integrity of requests, requests and responses, it provides no guarantee of request confidentiality.
Unless further precautions are taken, confidentiality
protection. Consequently, eavesdroppers will have full access to
request content. Servers should carefully consider content and further messages exchanged between the
kinds of data likely to client and
the resource server. This could be sent as part of problematic when data is
exchanged that requires care, such requests, as personal data.

When TLS is used then confidentiality can be ensured and should
employ transport-layer with the use
of the TLS channel binding feature it ensures that the TLS channel is
cryptographically bound to the used MAC token. TLS in combination
with channel bindings bound to the MAC token provide security mechanisms
superiour to protect sensitive
resources.

6.3. Spoofing by Counterfeit the OAuth Bearer Token.

The use of TLS in combination with the MAC token is highly
recommended to ensure the confidentiality of the user's data.

8.3. Authentication of Resource Servers

This protocol makes no attempt allows clients to verify the authenticity of the
server. A hostile party could take advantage resource
servers in two ways:
1. The resource server demonstrates possession of this the session key by intercepting
computing a keyed message digest function over a number of HTTP
fields in the client's requests and returning misleading or otherwise incorrect
responses. Service providers should consider such attacks when
developing services using this protocol, and should require
transport-layer security for any requests where response to the authenticity of request from the client.
2. When TLS is used the resource server or of request responses is an issue.

6.4. authenticated as part of
the TLS handshake.

8.4. Plaintext Storage of Credentials

The MAC key functions works in the same way passwords do in traditional
authentication systems. In order to compute the request MAC, keyed message
digest, the client and the resource server must have access to the
MAC key in plaintext form. This is in
contrast, for example, to modern operating systems, which store only
a one-way hash of user credentials.

If an attacker were to gain access to these MAC keys - or worse, to
the resource server's or the authorization server's database of all
such MAC keys - he or she would be able to perform any action on
behalf of any resource owner. Accordingly,
it client.

It is critical therefore paramount to the security of the protocol that servers protect these MAC
session keys are protected from unauthorized access.

6.5.

8.5. Entropy of MAC Session Keys

Unless a transport-layer security protocol TLS is used, used between the client and the resource server,
eavesdroppers will have full access to authenticated requests and request MAC
values, and sent by the client.
They will thus be able to mount offline brute-force attacks to
recover the MAC session key used. Servers used to compute the keyed message digest.
Authorization servers should be careful to assign MAC
keys which are long enough, generate fresh and random enough, unique
session keys with sufficient entrophy to resist such attacks for at
least the length of time that the MAC credentials session keys are valid.

For example, if the MAC credentials are a session key is valid for two weeks, one day, authorization
servers
should must ensure that it is not possible to mount a brute force
attack that recovers the MAC session key in less than two weeks. one day. Of
course, servers are urged to err on the side of caution, and use the
longest MAC session key reasonable.

It is equally important that the pseudo-random number generator
(PRNG) used to generate these MAC session keys be of sufficiently high
quality. Many PRNG implementations generate number sequences that
may appear to be random, but which nevertheless exhibit patterns or
other weaknesses patterns,
which make cryptanalysis or brute force attacks easier. Implementers should be careful to use cryptographically
secure PRNGs are advised to avoid these problems.

6.6. follow
the guidance on random number generation in [RFC4086].

8.6. Denial of Service / Resource Exhaustion Attacks

This specification includes a number of features which may make
resource exhaustion attacks against resource servers possible. For
example,
this protocol requires servers a resource server may need to track used nonces. If an attacker
is able need to use many nonces quickly, consult backend
databases and the resources required to track
them may exhaust available capacity. And again, this protocol can
require servers to perform potentially expensive computations in
order authorization server to verify the request MAC on an incoming requests. request
including an access token before granting access to the protected
resource.

An attacker may exploit this to perform a denial of service attack by
sending a large number of invalid requests to the server.

Resource Exhaustion attacks are by no means specific The
computational overhead of verifying the keyed message digest alone
is, however, not sufficient to this
specification. However, implementers should be careful mount a denial of service attack since
keyed message digest functions belong to consider the additional avenues computationally fastest
cryptographic algorithms. The usage of attack that this protocol exposes, and
design their implementations accordingly. TLS does, however, require
additional computational capabity to perform the asymmetric
cryptographic operations. For example, entropy
starvation typically results in either a complete brief discussion about denial of
service
while the system waits for new entropy or else in weak (easily
guessable) MAC keys. When implementing this protocol, servers should
consider which vulnerabilities of these presents a more serious risk for their
application and design accordingly.

6.7. TLS please consult Appendix F.5 of RFC
5246 [RFC5246].

8.7. Timing Attacks

This specification makes use of HMACs, for which a signature
verification involves comparing the received MAC string to the
expected one. If the string comparison operator operates in
observably different times depending on inputs, e.g. because it
compares the strings character by character and returns a negative
result as soon as two characters fail to match, then it may be
possible to use this timing information to determine the expected
MAC, character by character.

Service implementers

Implementers are encouraged to use fixed-time string comparators for
MAC verification.

6.8. This means that the comparison operation is not
terminated once a mismatch is found.

8.8. CSRF Attacks

A Cross-Site Request Forgery attack occurs when a site, evil.com,
initiates within the victim's browser the loading of a URL from or
the posting of a form to a web site where a side-effect will occur,
e.g. transfer of money, change of status message, etc. To prevent
this kind of attack, web sites may use various techniques to
determine that the originator of the request is indeed the site
itself, rather than a third party. The classic approach is to
include, in the set of URL parameters or form content, a nonce
generated by the server and tied to the user's session, which
indicates that only the server could have triggered the action.

Recently, the Origin HTTP header has been proposed and deployed in
some browsers. This header indicates the scheme, host, and port of
the originator of a request. Some web applications may use this
Origin header as a defense against CSRF.

To keep this specification simple, HTTP headers are not part of the
string to be MAC'ed. As a result, MAC authentication cannot defend
against header spoofing, and a web site that uses the Host header to
defend against CSRF attacks cannot use MAC authentication to defend
against active network attackers. Sites that want the full
protection of MAC Authentication should use traditional, cookie-tied
CSRF defenses.

6.9. Coverage Limitations
The normalized request string has been designed to support the
authentication methods defined in this specification. Those
designing additional methods, should evaluated the compatibility of
the normalized request string with their security requirements.
Since the normalized request string does not cover the entire

8.9. Protecting HTTP
request, servers should employ additional mechanisms to protect such
elements.

The request MAC does not cover entity-header Header Fields

This specification provides flexibility for selectively protecting
header fields which can often
affect how and even the request body is interpreted by the server (i.e.
Content-Type). If of the server behavior is influenced by message. At a minimum the presence
or value of such header fields, an attacker can manipulate
following fields are included in the
request header without being detected.

7. keyed message digest.

9. IANA Considerations

7.1. The HTTP

9.1. JSON Web Token Claims

This document adds the following claims to the JSON Web Token Claims
registry established with [I-D.ietf-oauth-json-web-token]:
o Claim Name: "kid"
o Change Controller: IETF
o Specification Document(s): [[ this document ]]
o Claim Name: "mac_key"
o Change Controller: IETF
o Specification Document(s): [[ this document ]]

9.2. MAC Authentication Scheme Token Algorithm Registry

This specification establishes the HTTP MAC authentication scheme
algorithm Token Algorithm registry.

Additional MAC keyed message digest algorithms are registered on the
advice of one or more Designated Experts (appointed by the IESG or
their delegate), with a Specification Required (using terminology
from [RFC5226]). However, to allow for the allocation of values
prior to publication, the Designated Expert(s) may approve
registration once they are satisfied that such a specification will
be published.

Registration requests should be sent to the [TBD]@ietf.org mailing
list for review and comment, with an appropriate subject (e.g.,
"Request for MAC Algorithm: example"). [[ Note to RFC-EDITOR: The
name of the mailing list should be determined in consultation with
the IESG and IANA. Suggested name: http-mac-ext-review. ]]

Within at most 14 days of the request, the Designated Expert(s) will
either approve or deny the registration request, communicating this
decision to the review list and IANA. Denials should include an
explanation and, if applicable, suggestions as to how to make the
request successful.

Decisions (or lack thereof) made by the Designated Expert can be
first appealed to Application Area Directors (contactable using app-
ads@tools.ietf.org
app-ads@tools.ietf.org email address or directly by looking up their
email addresses on http://www.iesg.org/ website) and, if the
appellant is not satisfied with the response, to the full IESG (using
the iesg@iesg.org mailing list).

IANA should only accept registry updates from the Designated
Expert(s), and should direct all requests for registration to the
review mailing list.

7.1.1.

9.2.1. Registration Template

Algorithm name:

The name requested (e.g., "example").
Change controller:

For standards-track RFCs, state "IETF". For others, give the name
of the responsible party. Other details (e.g., postal address,
e-mail address, home page URI) may also be included.
Specification document(s):

Reference to document that specifies the algorithm, preferably
including a URI that can be used to retrieve a copy of the
document. An indication of the relevant sections may also be
included, but is not required.

7.1.2.

9.2.2. Initial Registry Contents

The HTTP MAC authentication scheme algorithm registry's initial
contents are:

o Algorithm name: hmac-sha-1
o Change controller: IETF
o Specification document(s): [[ this document ]]
o Algorithm name: hmac-sha-256
o Change controller: IETF
o Specification document(s): [[ this document ]]

7.2.

9.3. OAuth Access Token Type Registration

This specification registers the following access token type in the
OAuth Access Token Type Registry.

7.2.1.

9.3.1. The "mac" OAuth Access Token Type

Type name:

mac
Additional Token Endpoint Response Parameters:

secret, algorithm
HTTP Authentication Scheme(s):

MAC
Change controller:

IETF
Specification document(s):

[[ this document ]]

7.3.

9.4. OAuth Parameters Registration

This specification registers the following parameters in the OAuth
Parameters Registry established by [RFC6749].

7.3.1.

9.4.1. The "mac_key" OAuth Parameter

Parameter name: mac_key
Parameter usage location: authorization response, token response
Change controller: IETF
Specification document(s): [[ this document ]]
Related information: None

7.3.2.

9.4.2. The "mac_algorithm" OAuth Parameter

Parameter name: mac_algorithm
Parameter usage location: authorization response, token response
Change controller: IETF
Specification document(s): [[ this document ]]
Related information: None

8. Contributors

9.4.3. The "kid" OAuth Parameter

Parameter name: kid
Parameter usage location: authorization response, token response
Change controller: IETF
Specification document(s): [[ this document ]]
Related information: None

10. Acknowledgments

This document is based on OAuth 1.0 and we would like to thank Eran
Hammer-Lahav for his work on incorporating the ideas into OAuth 2.0.

9. Acknowledgments

The author would like to thank
As part of this initial work the following persons provided feedback:
Ben Adida, Adam Barth, Phil Hunt, Rasmus Lerdorf, James Manger,
William Mills, Scott Renfro, Justin Richer, Toby White, Peter
Wolanin, and Skylar Woodward for their
contributions, suggestions,

Further work in this document was done as part of OAuth working group
conference calls late 2012/early 2013 and feedback.

10. in design team conference
calls February 2013. The following persons (in addition to the OAuth
WG chairs, Hannes Tschofenig, and Derek Atkins) provided their input
during these calls: Bill Mills, Justin Richer, Phil Hunt, Prateek
Mishra, Mike Jones, George Fletcher, John Bradley, Tony Nadalin,
Thomas Hardjono, Brian Campbell

11. References

10.1.

11.1. Normative References

[10]

[I-D.ietf-httpbis-p1-messaging]
Fielding, R. and J. Reschke, "Hypertext Transfer Protocol
(HTTP/1.1): Message Syntax and Routing", Internet-Draft
draft-ietf-httpbis-p1-messaging-21, October 2012.

[11] Hardt, D., "The OAuth 2.0 Authorization Framework", RFC
6749, October
draft-ietf-httpbis-p1-messaging-22 (work in progress),
February 2013.

[I-D.ietf-jose-json-web-encryption]
Jones, M., Rescorla, E., and J. Hildebrand, "JSON Web
Encryption (JWE)", draft-ietf-jose-json-web-encryption-08
(work in progress), December 2012.

[12] Hors, A., Raggett, D.

[I-D.ietf-oauth-json-web-token]
Jones, M., Bradley, J., and I. Jacobs, "HTML 4.01
Specification", World Wide N. Sakimura, "JSON Web Consortium Recommendation
REC-html401-19991224, Token
(JWT)", draft-ietf-oauth-json-web-token-06 (work in
progress), December 1999, <http://www.w3.org/TR
/1999/REC-html401-19991224>.

[13] 2012.

[I-D.richer-oauth-introspection]
Richer, J., "OAuth Token Introspection",
draft-richer-oauth-introspection-03 (work in progress),
February 2013.

[I-D.tschofenig-oauth-audience]
Tschofenig, H., "OAuth 2.0: Audience Information",
draft-tschofenig-oauth-audience-00 (work in progress),
February 2013.

[NIST-FIPS-180-3]
National Institute of Standards and Technology, "Secure
Hash Standard (SHS). FIPS PUB 180-3, October 2008", .

[1] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119, March 1997.

[2] 2008".

[RFC2045] Freed, N. and N.S. N. Borenstein, "Multipurpose Internet Mail
Extensions (MIME) Part One: Format of Internet Message
Bodies", RFC 2045, November 1996.

[3]

[RFC2104] Krawczyk, H., Bellare, M. M., and R. Canetti, "HMAC: Keyed-
Hashing for Message Authentication", RFC 2104,
February 1997.

[4]

[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119, March 1997.

[RFC2616] Fielding, R., Gettys, J., Mogul, J., Frystyk, H.,
Masinter, L., Leach, P. P., and T. Berners-Lee, "Hypertext
Transfer Protocol -- HTTP/1.1", RFC 2616, June 1999.

[5]

[RFC2617] Franks, J., Hallam-Baker, P.M., P., Hostetler, J.L., J., Lawrence,
S.D., S.,
Leach, P.J., P., Luotonen, A. A., and L. Stewart, "HTTP
Authentication: Basic and Digest Access Authentication",
RFC 2617, June 1999.

[6]

[RFC3986] Berners-Lee, T., Fielding, R. R., and L. Masinter, "Uniform
Resource Identifier (URI): Generic Syntax", STD 66,
RFC 3986, January 2005.

[7]

[RFC4086] Eastlake, D., Schiller, J., and S. Crocker, "Randomness
Requirements for Security", BCP 106, RFC 4086, June 2005.

[RFC5226] Narten, T. and H. Alvestrand, "Guidelines for Writing an
IANA Considerations Section in RFCs", BCP 26, RFC 5226,
May 2008.

[8]

[RFC5246] Dierks, T. and E. Rescorla, "The Transport Layer Security
(TLS) Protocol Version 1.2", RFC 5246, August 2008.

[9]

[RFC5929] Altman, J., Williams, N., and L. Zhu, "Channel Bindings
for TLS", RFC 5929, July 2010.

[RFC6265] Barth, A., "HTTP State Management Mechanism", RFC 6265,
April 2011.

10.2.

[RFC6749] Hardt, D., "The OAuth 2.0 Authorization Framework",
RFC 6749, October 2012.

[W3C.REC-html401-19991224]
Hors, A., Raggett, D., and I. Jacobs, "HTML 4.01
Specification", World Wide Web Consortium
Recommendation REC-html401-19991224, December 1999,
<http://www.w3.org/TR/1999/REC-html401-19991224>.

11.2. Informative References

[1]

[I-D.tschofenig-oauth-security]
Tschofenig, H. and P. Hunt, "OAuth 2.0 Security: Going
Beyond Bearer Tokens", Internet-Draft draft-tschofenig-
oauth-security-00, September 2012.

[2] Bradley, J., Hunt, P., Nadalin, A. and H. Tschofenig, "The
OAuth 2.0 Authorization Framework: Holder-of-the-Key Token
Usage", Internet-Draft draft-tschofenig-oauth-hotk-01,
July draft-tschofenig-oauth-security-01
(work in progress), December 2012.

[3] Hammer-Lahav, E., "The OAuth 1.0 Protocol", RFC 5849,
April 2010.

Authors' Addresses

Justin Richer, editor Richer
The MITRE Corporation

Email: jricher@mitre.org

William Mills, editor Mills
Yahoo! Inc.

Phone:
Email: wmills@yahoo-inc.com
Hannes Tschofenig, editor Tschofenig (editor)
Nokia Siemens Networks
Linnoitustie 6
Espoo,
Espoo 02600
Finland

Phone: +358 (50) 4871445
Email: Hannes.Tschofenig@gmx.net
URI: http://www.tschofenig.priv.at