wdiff draft-ietf-oauth-pop-architecture-04.txt draft-ietf-oauth-pop-architecture-05.txt

OAuth P. Hunt, Ed.
Internet-Draft Oracle Corporation
Intended status: Informational J. Richer
Expires: April 21, 2016
W. Mills

P. Mishra
Oracle Corporation
H. Tschofenig
ARM Limited
October 19, 2015

OAuth 2.0 Proof-of-Possession (PoP) Security Architecture
draft-ietf-oauth-pop-architecture-04.txt
draft-ietf-oauth-pop-architecture-05.txt

Abstract

The OAuth 2.0 bearer token specification, as defined in RFC 6750,
allows any party in possession of a bearer token (a "bearer") to get
access to the associated resources (without demonstrating possession
of a cryptographic key). To prevent misuse, bearer tokens must to be
protected from disclosure in transit and at rest.

Some scenarios demand additional security protection whereby a client
needs to demonstrate possession of cryptographic keying material when
accessing a protected resource. This document motivates the
development of the OAuth 2.0 proof-of-possession security mechanism.

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 April 21, 2016.

This document is subject to BCP 78 and the IETF Trust's Legal
Provisions Relating to IETF Documents
(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 3
2. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 3
3. Use Cases . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.1. Preventing Access Token Re-Use by the Resource Server . . 3 4
3.2. TLS Channel Binding Support . . . . . . . . . . . . . . . 4
3.3. Access to a Non-TLS Protected Resource . . . . . . . . . 4
3.4. Offering Application Layer End-to-End Security . . . . . 5
4. Security and Privacy Threats . . . . . . . . . . . . . . . . 5
5. Requirements . . . . . . . . . . . . . . . . . . . . . . . . 6
6. Threat Mitigation . . . . . . . . . . . . . . . . . . . . . . 6
5.1. 10
6.1. Confidentiality Protection . . . . . . . . . . . . . . . 7
5.2. 11
6.2. Sender Constraint . . . . . . . . . . . . . . . . . . . . 7
5.3. 11
6.3. Key Confirmation . . . . . . . . . . . . . . . . . . . . 8
5.4. 12
6.4. Summary . . . . . . . . . . . . . . . . . . . . . . . . . 9
6. 13
7. Architecture . . . . . . . . . . . . . . . . . . . . . . . . 10
7. Requirements 14
7.1. Client and Authorization Server Interaction . . . . . . . 14
7.1.1. Symmetric Keys . . . . . . . . . . . . . . . . . . . 14
7.1.2. Asymmetric Keys . . . . . . . . . . . . . . . . . . . 16
7.2. Client and Resource Server Interaction . . . . . . . . . 17
7.3. Resource and Authorization Server Interaction (Token
Introspection) . . . . . . . . . . . . . . . . . . . 15 . . 18
8. Security Considerations . . . . . . . . . . . . . . . . . . . 18 19
9. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 19
10. Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . 19
11. References . . . . . . . . . . . . . . . . . . . . . . . . . 19
11.1. Normative References . . . . . . . . . . . . . . . . . . 19
11.2. Informative References . . . . . . . . . . . . . . . . . 19 20
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 21

1. Introduction

At the time of writing the

The OAuth 2.0 protocol family ([RFC6749], [RFC6750], and [RFC6819])
offer a single standardized security
mechanism token type known as the "bearer" token to access
protected resources, namely the bearer token. resources. RFC 6750 [RFC6750] specifies the bearer token
mechanism and defines it as follows:

"A security token with the property that any party in possession
of the token (a "bearer") can use the token in any way that any
other party in possession of it can. Using a bearer token does
not require a bearer to prove possession of cryptographic key
material."

The bearer token meets the security needs of a number of use cases
the OAuth 2.0 protocol had originally been designed for. There are,
however, other scenarios that require stronger security properties
and ask for active participation of the OAuth client in form of
cryptographic computations when presenting an access token to a
resource server.

This document outlines additional use cases requiring stronger
security protection in Section 3, identifies threats in Section 4,
proposes different ways to mitigate those threats in Section 5, 6,
outlines an architecture for a solution that builds on top of the
existing OAuth 2.0 framework in Section 6, 7, and concludes with a
requirements list in Section 7. 5.

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], with
the important qualification that, unless otherwise stated, these
terms apply to the design of the protocol, not its implementation or
application.

3. Use Cases

The main use case that motivates better-than-bearer improvement upon "bearer" token
security is the desire of resource servers to obtain additional
assurance that the client is indeed authorized to present an access
token. The expectation is that the use of additional credentials
(symmetric or asymmetric keying material) will encourage developers
to take additional precautions when transferring and storing access
token in combination with these credentials.

Additional use cases listed below provide further requirements for
the solution development. Note that a single solution does not
necessarily need to offer support for all use cases.

3.1. Preventing Access Token Re-Use by the Resource Server

Imagine

In a scenario where a resource server that receives a valid access token token,
the resource server then re-uses it with other resource server. The
reason for re-use may be malicious or may well be legitimate. In a
legitimate
use case consider case, the intent is to support chaining of computations
whereby a resource server needs to consult other third party resource
servers to complete the a requested operation. In both cases it may be
assumed that the scope of the access token is sufficiently large that
it allows such a re-
use. re-use. For example, imagine a case where a company
operates email services as well as picture sharing services and that
company had decided to issue access tokens with a scope that allows
access to both services.

With this use case the desire is to prevent such access token re-use.
This also implies that the legitimate use cases require additional
enhancements for request chaining.

3.2. TLS Channel Binding Support

In this use case we consider the scenario where an OAuth 2.0 request
to a protected resource is secured using TLS but the client and the
resource server demand that the underlying TLS exchange is bound to
additional application layer security to prevent cases where the TLS
connection is terminated at a TLS intermediary, which splits the TLS
connection into two separate connections.

In this use case additional information is should be conveyed to the
resource server to ensure that no entity entity has tampered with the
TLS connection.

3.3. Access to a Non-TLS Protected Resource

This use case is for a web client that needs to access a resource
that makes data available (such as videos) without offering integrity
and confidentiality protection using TLS. Still, the initial
resource request using OAuth, which includes the access token, must
be protected against various threats (e.g., token replay, token
modification).

While it is possible to utilize bearer tokens in this scenario with
TLS protection when the request to the protected resource is made, as
described in [RFC6750], there may be the desire to avoid using TLS
between the client and the resource server at all. In such a case
the bearer token approach is not possible since it relies on TLS for
ensuring integrity and confidentiality protection of the access token
exchange since otherwise replay attacks are possible: First, an
eavesdropper may steal an access token and represent present it at a different
resource server. Second, an eavesdropper may steal an access token
and replay it against the same resource server at a later point in
time. In both cases, if the attack is successful, the adversary gets
access to the resource owners data or may perform an operation
selected by the adversary (e.g., sending a message). Note that the
adversary may obtain the access token (if the recommendations in
[RFC6749] and [RFC6750] are not followed) using a number of ways,
including eavesdropping the communication on the wireless link.

Consequently, the important assumption in this use case is that a
resource server does not have TLS support and the security solution
should work in such a scenario. Furthermore, it may not be necessary
to provide authentication of the resource server towards the client.

3.4. Offering Application Layer End-to-End Security

In Web deployments resource servers are often placed behind load
balancers, which are deployed by the same organization that operates
the resource servers. These load balancers may terminate the TLS
connection setup and HTTP traffic is transmitted in the clear without TLS
protection from the load balancer to the resource server. With
application layer security in addition to the underlying TLS security
it is possible to allow application servers to perform cryptographic
verification on an end-to-end basis.

The key aspect in this use case is therefore to offer end-to-end
security in the presence of load balancers via application layer
security. Enterprise networks also deploy proxies that inspect
traffic and thereby break TLS.

4. Security and Privacy Threats

The following list presents several common threats against protocols
utilizing some form of tokens. token. This list of threats is based on NIST
Special Publication 800-63 [NIST800-63]. We exclude a discussion of
threats related to any form of identity proofing and authentication
of the resource owner to the authorization server since these
procedures are not part of the OAuth 2.0 protocol specification
itself.

Token manufacture/modification:

An attacker may generate a bogus tokens or modify the token
content (such as authentication or attribute statements) of an
existing token, causing resource server to grant inappropriate
access to the client. For example, an attacker may modify the
token to extend the validity period. A client may modify the
token to have access to information that they should not be able
to view.

Token disclosure:

Tokens may contain personal data, such as real name, age or
birthday, payment information, etc.

Token redirect:

An attacker uses the token generated for consumption by the
resource server to obtain access to another resource server.

Token reuse:

An attacker attempts to use a token that has already been used
once with a resource server. The attacker may be an eavesdropper
who observes the communication exchange or, worse, one of the
communication end points. A client may, for example, leak access
tokens because it cannot keep secrets confidential. A client may
also re-use reuse access tokens for some other resource servers.
Finally, a resource server may use a token it had obtained from a
client and use it with another resource server that the client
interacts with. A resource server, offering relatively
unimportant application services, may attempt to use an access
token obtained from a client to access a high-value service, such
as a payment service, on behalf of the client using the same
access token.

Token repudiation:

Token repudiation refers to a property whereby a resource server
is given an assurance that the authorization server cannot deny to
have created a token for the client.

5. Threat Mitigation

A large range Requirements

RFC 4962 [RFC4962] gives useful guidelines for designers of threats can be mitigated by protecting
authentication and key management protocols. While RFC 4962 was
written with the content
of AAA framework used for network access authentication
in mind the token, offered suggestions are useful for example using a digital signature or a keyed
message digest. Alternatively, the content design of the token could be
passed by reference rather than by value (requiring a separate
message exchange other
key management systems as well. The following requirements list
applies OAuth 2.0 terminology to resolve the reference to the token content). To
simplify the subsequent description we assume requirements outlined in RFC
4962.

These requirements include

Cryptographic Algorithm Independent:

The key management protocol MUST be cryptographic algorithm
independent.

Strong, fresh session keys:

Session keys MUST be strong and fresh. Each session deserves an
independent session key, i.e., one that is generated specifically
for the token itself intended use. In context of OAuth this means that keying
material is digitally signed created in such a way that can only be used by the authorization server
combination of a client instance, protected resource, and therefore cannot
be modified.

To deal with token redirect it is important for the
authorization
server to include scope.

Limit Key Scope:

Following the identifier principle of the intended recipient - the
resource server. A resource server must not be allowed to accept least privilege, parties MUST NOT have
access tokens to keying material that are not meant for its consumption.

To provide protection against token disclosure two approaches are
possible, namely (a) is not needed to include sensitive information inside the
token or (b) perform their
role. Any protocol that is used to ensure confidentiality protection. The latter
approach requires at least the communication interaction between the
client and the authorization server as well as the interaction
between establish session keys MUST
specify the client and scope for session keys, clearly identifying the resource server to experience
confidentiality protection. As an example, TLS with a ciphersuite
that offers confidentiality protection has
parties to be applied (which is
currently true for all ciphersuites, except for one). Encrypting whom the
token content itself session key is another alternative. In our scenario the
authorization server would, for example, encrypt the token content
with a symmetric key shared with the resource server.

To deal with token reuse more choices are available.

5.1. Confidentiality Protection

In this approach confidentiality protection of the exchange is
provided on the communication interfaces between the client and the
resource server, and between the client and the authorization server.
No eavesdropper on the wire is able to observe the token exchange.
Consequently, a

Replay Detection Mechanism:

The key management protocol exchanges MUST be replay by protected.
Replay protection allows a third party is not possible. An
authorization server wants protocol message recipient to ensure discard
any message that it only hands out tokens to
clients it has authenticated first and who are authorized. For this
purpose, authentication of the client to the authorization server
will be was recorded during a requirement previous legitimate
dialogue and presented as though it belonged to ensure adequate protection against a range
of attacks. This is, however, true for the description current
dialogue.

Authenticate All Parties:

Each party in
Section 5.2 and Section 5.3 as well. Furthermore, the client has key management protocol MUST be authenticated to
make sure it does not distribute (or leak)
the access token to
entities other than the intended parties with whom they communicate. Authentication
mechanisms MUST maintain the resource server. For that
purpose confidentiality of any secret values
used in the client will have authentication process. Secrets MUST NOT be sent to authenticate the
another party without confidentiality protection.

Authorization:

Client and resource server
before transmitting the access token.

5.2. Sender Constraint

Instead authorization MUST be performed. These
entities MUST demonstrate possession of providing confidentiality protection the authorization
server could also put the identifier of the client into the protected
token with the following semantic: 'This token appropriate keying
material, without disclosing it. Authorization is only valid when
presented by REQUIRED
whenever a client interacts with an authorization server.
Authorization checking prevents an elevation of privilege attack.

Keying Material Confidentiality and Integrity:

While preserving algorithm independence, confidentiality and
integrity of all keying material MUST be maintained.

Confirm Cryptographic Algorithm Selection:

The selection of the following identifier.' When the
access token "best" cryptographic algorithms SHOULD be
securely confirmed. The mechanism SHOULD detect attempted roll-
back attacks.

Uniquely Named Keys:

Key management proposals require a robust key naming scheme,
particularly where key caching is then presented supported. The key name
provides a way to the resource server how does it
know refer to a key in a protocol so that it was provided by the client? It has is clear
to authenticate all parties which key is being referenced. Objects that cannot
be named cannot be managed. All keys MUST be uniquely named, and
the
client! There are many choices for authenticating key name MUST NOT directly or indirectly disclose the client to keying
material.

Prevent the
resource server, for example Domino Effect:

Compromise of a single client MUST NOT compromise keying material
held by using any other client certificates in TLS
[RFC5246], or pre-shared secrets within TLS [RFC4279]. The choice of the preferred authentication mechanism system, including session keys
and credential type may depend
on long-term keys. Likewise, compromise of a number single resource
server MUST NOT compromise keying material held by any other
Resource Server within the system. In the context of factors, including

o security properties

o available infrastructure
o library support

o credential cost (financial)

o performance

o integration into the existing IT infrastructure

o operational overhead for configuration and distribution of
credentials

This long list hints to a key
hierarchy, this means that the challenge compromise of selecting at least one
mandatory-to-implement client authentication mechanism.

5.3. Key Confirmation

A variation of the mechanism of sender authentication, described node in
Section 5.2, is to replace authentication with the proof-of-
possession of a specific (session) key, i.e., key confirmation. In
this model the resource server would
hierarchy must not authenticate the client
itself but would rather verify whether disclose the client knows information necessary to
compromise other branches in the session key associated with a specific access token. Examples of this
approach can be found with hierarchy. Obviously, the OAuth 1.0 MAC token [RFC5849], and
Kerberos [RFC4120] when utilizing
compromise of the AP_REQ/AP_REP exchange (see
also [I-D.hardjono-oauth-kerberos] for a comparison between Kerberos
and OAuth).

To illustrate key confirmation root of the first examples borrow from
Kerberos and use symmetric key cryptography. Assume that hierarchy will compromise all of
the
authorization server shares keys; however, a long-term secret with compromise in one branch MUST NOT result in
the resource
server, called K(Authorization Server-Resource Server). This secret
would be established between them out-of-band. When compromise of other branches. There are many implications of
this requirement; however, two implications deserve highlighting.
First, the client
requests an access token scope of the authorization server creates a fresh and
unique session key Ks keying material must be defined and places it into the token encrypted
understood by all parties that communicate with a party that holds
that keying material. Second, a party that holds keying material
in a key hierarchy must not share that keying material with
parties that are associated with other branches in the
long term key K(Authorization Server-Resource Server). Additionally,
the authorization server attaches Ks key
hierarchy.

Bind Key to the response message its Context:

Keying material MUST be bound to the
client (in addition to appropriate context. The
context includes the access token itself) over a
confidentiality protected channel. When following.

* The manner in which the client sends a request keying material is expected to the resource server it has be used.

* The other parties that are expected to use Ks have access to compute a keyed message
digest for the request (in whatever form or whatever layer).
keying material.

* The
resource server, when receiving expected lifetime of the message, retrieves keying material. Lifetime of a
child key SHOULD NOT be greater than the lifetime of its parent
in the key hierarchy.

Any party with legitimate access
token, verifies it and extracts K(Authorization Server-Resource
Server) to obtain Ks. This key Ks is then used keying material can determine
its context. In addition, the protocol MUST ensure that all
parties with legitimate access to verify keying material have the keyed
message digest of same
context for the request message.

Note keying material. This requires that in this example one could imagine the parties
are properly identified and authenticated, so that all of the mechanism
parties that have access to
protect the token itself keying material can be determined.
The context will include the client and the resource server
identities in more than one form.

Authorization Restriction:

If client authorization is based on a symmetric key based mechanism
to avoid any form of public key infrastructure but this aspect is not
further elaborated in restricted, then the scenario.

A similar mechanism can also client SHOULD be designed using asymmetric
cryptography. When
made aware of the restriction.

Client Identity Confidentiality:

A client requests an access token has identity confidentiality when any party other than
the
authorization resource server creates an ephemeral public / privacy key pair
(PK/SK) and places the public key PK into the protected token. When the authorization server returns the access token to cannot
sufficiently identify the client it
also provides within the PK/SK key pair over a anonymity set. In
comparison to anonymity and pseudonymity, identity confidentiality protected
channel. When
is concerned with eavesdroppers and intermediaries. A key
management protocol SHOULD provide this property.

Resource Owner Identity Confidentiality:

Resource servers SHOULD be prevented from knowing the client sends a request to real or
pseudonymous identity of the resource owner, since the
authorization server it
has to use is the privacy key SK to sign only entity involved in verifying the request. The
resource
server, when receiving the message, retrieves the access token,
verifies it and extracts the public key PK. It uses this ephemeral
public key owner's identity.

Collusion:

Resource servers that collude can be prevented from using
information related to verify the attached signature.

5.4. Summary

As a high level message, there are various ways how resource owner to track the threats individual.
That is, two different resource servers can be mitigated and while prevented from
determining that the details same resource owner has authenticated to both
of each solution is somewhat them. Authorization servers MUST bind different they all ultimately accomplish the goal.

The three approaches are:

Confidentiality Protection:

The weak point with this approach, which is briefly described in
Section 5.1, is that the client has to be careful keying
material to whom it
discloses the access token. What can be done with the token
entirely depends on what rights the token entitles the presenter
and what constraints it contains. A token could encode the
identifier of tokens used for resource servers from different
origins (or similar concepts in the client but there are scenarios where app world).

AS-to-RS Relationship Anonymity:

For solutions using asymmetric key cryptography the client
is not authenticated to MAY
conceal information about the resource server or where the
identifier of the client rather represents it wants to interact
with. The authorization server MAY reject such an application class
rather than a single application instance. As such, attempt since
it is
possible that certain deployments choose a rather liberal approach may not be able to security and that everyone who is in possession of the access
token is granted enforce access to the data.

Sender Constraint: control decisions.

Channel Binding:

A solution MUST enable support for channel bindings. The weak point with this approach, which is briefly described concept
of channel binding, as defined in
Section 5.2, is [RFC5056], allows applications
to setup the authentication infrastructure such establish that clients can be authenticated towards resource servers.
Additionally, the authorization server must encode the identifier two end-points of a secure channel at one
network layer are the client in the token for later verification same as at a higher layer by binding
authentication at the resource
server. Depending on the chosen higher layer for providing client-side
authentication there may be additional challenges due Web server
load balancing, lack of API access to identity information, etc.

Key Confirmation:

The weak point with this approach, see Section 5.3, is the
increased complexity: a complete key distribution protocol has to
be defined.

In all cases above it has to be ensured that channel at the client is able to
keep lower
layer.

There are performance concerns with the credentials secret.

6. Architecture

The proof-of-possession use of asymmetric
cryptography. Although symmetric key cryptography offers better
performance asymmetric cryptography offers additional security concept assumes that
properties. A solution MUST therefore offer the
authorization server acts as a trusted third party that binds keys capability to
access tokens. These keys
support both symmetric as well as asymmetric keys.

There are then used by the client threats that relate to demonstrate the possession experience of the secret to the resource server when accessing
the resource. The resource server, when receiving an access token,
needs to verify that the key used by the client matches software
developer as well as operational practices. Verifying the one
included servers
identity in TLS is discussed at length in [RFC6125].

A number of the access token.

There are slight differences between the use threats listed in Section 4 demand protection of symmetric keys and
asymmetric keys when they are bound to the
access token content and a standardized solution, in form of a JSON-
based format, is available with the
subsequent interaction between the client and JWT [RFC7519].

6. Threat Mitigation

A large range of threats can be mitigated by protecting the authorization
server when demonstrating possession content
of these keys. Figure 1 shows the symmetric key procedure and Figure 2 illustrates how asymmetric
keys are used. While symmetric cryptography provides better
performance properties token, for example using a digital signature or a keyed
message digest. Alternatively, the use content of asymmetric cryptography allows the
client token could be
passed by reference rather than by value (requiring a separate
message exchange to keep resolve the private key locally reference to the token content). To
simplify the subsequent description we assume that the token itself
is digitally signed by the authorization server and never expose therefore cannot
be modified.

To deal with token redirect it is important for the authorization
server to any
other party.

With include the JSON Web Token (JWT) [RFC7519] a standardized format for identifier of the intended recipient - the
resource server. A resource server must not be allowed to accept
access tokens is available. The necessary elements that are not meant for its consumption.

To provide protection against token disclosure two approaches are
possible, namely (a) not to bind symmetric include sensitive information inside the
token or asymmetric keys (b) to a JWT are described in
[I-D.ietf-oauth-proof-of-possession].

Note: ensure confidentiality protection. The negotiation of cryptographic algorithms latter
approach requires at least the communication interaction between the
client and the authorization server is not shown in as well as the examples below interaction
between the client and
assumed the resource server to be present in experience
confidentiality protection. As an example, TLS with a protocol solution ciphersuite
that offers confidentiality protection has to meet be applied (which is
currently true for all ciphersuites, except for one). Encrypting the requirements
token content itself is another alternative. In our scenario the
authorization server would, for crypto-agility.

+---------------+
^| |
// | Authorization |
/ | Server |
// | |
/ | |
(I) // /+---------------+
Access / //
Token / /
Request // // (II) Access Token
+Params / / +Symmetric Key
// //
/ v
+-----------+ +------------+
| | | |
| | | Resource |
| Client | | Server |
| | | |
| | | |
+-----------+ +------------+

Figure 1: Interaction between the Client and example, encrypt the Authorization Server
(Symmetric Keys).

In order to request an access token the client interacts content
with the
authorization server as part of the a normal grant exchange, as shown
in Figure 1. However, it needs to include additional information
elements for use symmetric key shared with the PoP security mechanism, as depicted in
message (I). resource server.

To deal with token reuse more choices are available.

6.1. Confidentiality Protection

In message (II) this approach confidentiality protection of the authorization server then returns exchange is
provided on the requested access token. In addition to communication interfaces between the access token itself, client and the symmetric key is communicated to
resource server, and between the client. This symmetric key
is a unique client and fresh session key with sufficient entropy for the
given lifetime. Furthermore, information within authorization server.
No eavesdropper on the wire is able to observe the access token
ties exchange.
Consequently, a replay by a third party is not possible. An
authorization server wants to ensure that it only hands out tokens to this specific symmetric key.

Note:
clients it has authenticated first and who are authorized. For this security mechanism to work
purpose, authentication of the client as well as to the
resource authorization server need to have access
will be a requirement to ensure adequate protection against a range
of attacks. This is, however, true for the session key. While the
key transport mechanism from the authorization server to description in
Section 6.2 and Section 6.3 as well. Furthermore, the client has been explained in the previous paragraph there are three ways for
communicating this session key from the authorization server to the
resource server, namely

Embedding the symmetric key inside
make sure it does not distribute (or leak) the access token itself. This
requires to
entities other than the intended the resource server. For that
purpose the client will have to authenticate the symmetric key is confidentiality protected.

The resource server queries
before transmitting the access token.

6.2. Sender Constraint

Instead of providing confidentiality protection the authorization
server for could also put the
symmetric key. This identifier of the client into the protected
token with the following semantic: 'This token is an approach envisioned only valid when
presented by a client with the following identifier.' When the
access token
introspection endpoint [I-D.ietf-oauth-introspection].

The authorization server and is then presented to the resource server both have access how does it
know that it was provided by the client? It has to authenticate the same back-end database. Smaller, tightly coupled systems
might prefer such
client! There are many choices for authenticating the client to the
resource server, for example by using client certificates in TLS
[RFC5246], or pre-shared secrets within TLS [RFC4279]. The choice of
the preferred authentication mechanism and credential type may depend
on a deployment strategy.

Figure 2: Interaction between number of factors, including

o security properties

o available infrastructure

o library support
o credential cost (financial)

o performance

o integration into the Client existing IT infrastructure

o operational overhead for configuration and the Authorization Server
(Asymmetric Keys).

The use distribution of asymmetric keys is slightly different since
credentials

This long list hints to the challenge of selecting at least one
mandatory-to-implement client or authentication mechanism.

6.3. Key Confirmation

A variation of the server could be involved mechanism of sender authentication, described in
Section 6.2, is to replace authentication with the generation proof-of-
possession of the ephemeral a specific (session) key, i.e., key
pair. This exchange is shown in Figure 1. If confirmation. In
this model the resource server would not authenticate the client generates
itself but would rather verify whether the client knows the session
key pair it either includes associated with a fingerprint specific access token. Examples of the public key or
the public key in the request to the authorization server. The
authorization server would include this fingerprint or public key in
the confirmation claim inside
approach can be found with the access OAuth 1.0 MAC token [RFC5849], and thereby bind the
asymmetric key pair to the token. If
Kerberos [RFC4120] when utilizing the client did not provide a
fingerprint or AP_REQ/AP_REP exchange (see
also [I-D.hardjono-oauth-kerberos] for a public comparison between Kerberos
and OAuth).

To illustrate key in the request then confirmation, the authorization
server first example is asked to create an ephemeral asymmetric borrowed from
Kerberos and use symmetric key pair, binds cryptography. Assume that the
fingerprint of
authorization server shares a long-term secret with the public key to resource
server, called K(Authorization Server-Resource Server). This secret
would be established between them out-of-band. When the client
requests an access token, and returns token the
asymmetric authorization server creates a fresh and
unique session key pair (public Ks and private key) to places it into the client. Note
that there is a strong preference for generating token encrypted with the private/public
long term key pair locally at the client rather than at the server.

The specification describing the interaction between the client and K(Authorization Server-Resource Server). Additionally,
the authorization server, as shown in Figure 1 and in Figure 2, can
be found in [I-D.ietf-oauth-pop-key-distribution].

Once server attaches Ks to the response message to the
client has obtained (in addition to the necessary access token and keying
material it can start to interact with the resource server. To
demonstrate possession of itself) over a
confidentiality protected channel. When the key bound client sends a request
to the access token resource server it needs has to apply this key use Ks to the request by computing compute a keyed message
digest
(i.e., a symmetric key-based cryptographic primitive) or a digital
signature (i.e., an asymmetric cryptographic computation). When for the request (in whatever form or whatever layer). The
resource server receives server, when receiving the request it message, retrieves the access
token, verifies it and decides
whether access extracts K(Authorization Server-Resource
Server) to the protected resource can be granted. obtain Ks. This
exchange key Ks is shown then used to verify the keyed
message digest of the request message.

Note that in Figure 3.

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

Request
+-----------+ + Signature/MAC (a) +------------+
| |---------------------->| |
| | [+Access Token] | Resource |
| Client | | Server |
| | Response (b) | |
| |<----------------------| |
+-----------+ [+ Signature/MAC] +------------+

^ ^
| |
| |
Symmetric Key Symmetric Key
or or
Asymmetric Key Pair Public Key (Client)
+ +
Parameters Parameters

Figure 3: Client demonstrates PoP.

The specification describing this example one could imagine that the ability mechanism to sign the HTTP request
from
protect the client token itself is based on a symmetric key based mechanism
to avoid any form of public key infrastructure but this aspect is not
further elaborated in the resource server scenario.

A similar mechanism can also be found in
[I-D.ietf-oauth-signed-http-request].

So far designed using asymmetric
cryptography. When the examples talked about client requests an access tokens that are passed by
value and allow token the resource server to make
authorization decisions
immediately after verifying server creates an ephemeral public / privacy key pair
(PK/SK) and places the request from public key PK into the client. In some
deployments a real-time interaction between protected token. When
the authorization server
and the resource server is envisioned that lowers the need to pass
self-contained access tokens around. In that case returns the access token
merely serves as a handle or a reference to state stored at the
authorization server. As client it
also provides the PK/SK key pair over a consequence, confidentiality protected
channel. When the resource server cannot
autonomously make an authorization decision when receiving client sends a request
from a client but to the resource server it
has to consult use the authorization server. This can, privacy key SK to sign the request. The resource
server, when receiving the message, retrieves the access token,
verifies it and extracts the public key PK. It uses this ephemeral
public key to verify the attached signature.

6.4. Summary

As a high level message, there are various ways the threats can be
mitigated. While the details of each solution are somewhat
different, they all accomplish the goal of mitigating the threats.

The three approaches are:

Confidentiality Protection:

The weak point with this approach, which is briefly described in
Section 6.1, is that the client has to be careful to whom it
discloses the access token. What can be done with the token
entirely depends on what rights the token entitles the presenter
and what constraints it contains. A token could encode the
identifier of the client but there are scenarios where the client
is not authenticated to the resource server or where the
identifier of the client rather represents an application class
rather than a single application instance. As such, it is
possible that certain deployments choose a rather liberal approach
to security and that everyone who is in possession of the access
token is granted access to the data.

Sender Constraint:

The weak point with this approach, which is briefly described in
Section 6.2, is to setup the authentication infrastructure such
that clients can be authenticated towards resource servers.
Additionally, the authorization server must encode the identifier
of the client in the token for example, later verification by the resource
server. Depending on the chosen layer for providing client-side
authentication there may be additional challenges due to Web
server load balancing, lack of API access to identity information,
etc.

Key Confirmation:

The weak point with this approach, see Section 6.3, is the
increased complexity: a complete key distribution protocol has to
be done using defined.

In all cases above it has to be ensured that the client is able to
keep the credentials secret.

7. Architecture

The proof-of-possession security concept assumes that the
authorization server acts as a trusted third party that binds keys to
access tokens. These keys are then used by the client to demonstrate
the possession of the secret to the resource server when accessing
the resource. The resource server, when receiving an access token,
needs to verify that the key used by the client matches the one
included in the access token.

There are slight differences between the use of symmetric keys and
asymmetric keys when they are bound to the access token introspection endpoint (see
[I-D.ietf-oauth-introspection]). Figure 4 shows and the protocol
subsequent interaction graphically. Despite between the client and the authorization
server when demonstrating possession of these keys. Figure 1 shows
the additional token exchange
previous descriptions about associating symmetric key procedure and Figure 2 illustrates how asymmetric
keys are used. While symmetric cryptography provides better
performance properties the use of asymmetric cryptography allows the
client to keep the private key locally and never expose it to any
other party.

With the JSON Web Token (JWT) [RFC7519] a standardized format for
access token tokens is available. The necessary elements to bind symmetric
or asymmetric keys to a JWT are still applicable described in
[I-D.ietf-oauth-proof-of-possession].

Note: The negotiation of cryptographic algorithms between the client
and the authorization server is not shown in the examples below and
assumed to be present in a protocol solution to this scenario. meet the requirements
for crypto-agility.

7.1. Client and Authorization Server Interaction

7.1.1. Symmetric Keys
+---------------+
Access
^| |
Token Req.
// | Authorization |^
(I) |
/ | Server | \ (IV) Token
// | | \ Introspection Req.
/ | | \ +Access
(I) // /+---------------+ \ Token
Access / // (II) \ \\
Token / / Access \ \
Request // // (II) Access Token \ (V) \
+Params / / \Resp.\ +Symmetric Key
// // \ \
/ v V \
+-----------+ Request +Signature/MAC+------------+ +------------+
| | | | (III) +Access Token
| | | |---------------------->| Resource |
| Client | (VI) Success or | Server |
| | Failure | |
| |<----------------------| | | |
+-----------+ +------------+

Figure 4: Token Introspection and Access Token Handles.

7. Requirements

RFC 4962 [RFC4962] gives useful guidelines for designers of
authentication and key management protocols. While RFC 4962 was
written with the AAA framework used for network access authentication
in mind the offered suggestions are useful for the design of other
key management systems as well. The following requirements list
applies OAuth 2.0 terminology to 1: Interaction between the requirements outlined in RFC
4962.

These requirements include

Cryptographic Algorithm Independent:

The key management protocol MUST be cryptographic algorithm
independent.

Strong, fresh session keys:

Session keys MUST be strong Client and fresh. Each session deserves an
independent session key, i.e., one that is generated specifically
for the intended use. Authorization Server
(Symmetric Keys).

In context of OAuth this means that keying
material is created in such a way that can only be used by the
combination of a client instance, protected resource, and
authorization scope.

Limit Key Scope:

Following the principle of least privilege, parties MUST NOT have
access to keying material that is not needed to perform their
role. Any protocol that is used order to establish session keys MUST
specify request an access token the scope for session keys, clearly identifying client interacts with the
parties to whom
authorization server as part of the session key is available.

Replay Detection Mechanism:

The key management protocol exchanges MUST be replay protected.
Replay protection allows a protocol message recipient to discard
any message that was recorded during a previous legitimate
dialogue and presented normal grant exchange, as though shown
in Figure 1. However, it belonged needs to include additional information
elements for use with the current
dialogue.

Authenticate All Parties:

Each party PoP security mechanism, as depicted in
message (I). In message (II) the key management protocol MUST be authenticated to authorization server then returns
the other parties with whom they communicate. Authentication
mechanisms MUST maintain requested access token. In addition to the confidentiality of any secret values
used in access token itself,
the authentication process. Secrets MUST NOT be sent symmetric key is communicated to
another party without confidentiality protection.

Authorization:

Client and resource server authorization MUST be performed. These
entities MUST demonstrate possession of the appropriate keying
material, without disclosing it. Authorization client. This symmetric key
is REQUIRED
whenever a client interacts with an authorization server. The
authorization checking prevents an elevation of privilege attack,
and it ensures that an unauthorized authorized is detected.

Keying Material Confidentiality and Integrity:

While preserving algorithm independence, confidentiality unique and
integrity of all keying material MUST be maintained.

Confirm Cryptographic Algorithm Selection:

The selection of the "best" cryptographic algorithms SHOULD be
securely confirmed. The mechanism SHOULD detect attempted roll-
back attacks.

Uniquely Named Keys:

Key management proposals require a robust key naming scheme,
particularly where key caching is supported. The fresh session key name
provides a way with sufficient entropy for the
given lifetime. Furthermore, information within the access token
ties it to refer this specific symmetric key.

Note: For this security mechanism to a work the client as well as the
resource server need to have access to the session key. While the
key transport mechanism from the authorization server to the client
has been explained in a protocol so that it is clear the previous paragraph there are three ways for
communicating this session key from the authorization server to all parties which the
resource server, namely

Embedding the symmetric key is being referenced. Objects inside the access token itself. This
requires that cannot
be named cannot be managed. All keys MUST be uniquely named, and the symmetric key name MUST NOT directly or indirectly disclose is confidentiality protected.

The resource server queries the keying
material.

Prevent authorization server for the Domino Effect:

Compromise of a single client MUST NOT compromise keying material
held
symmetric key. This is an approach envisioned by any other client within the system, including session keys token
introspection endpoint [I-D.ietf-oauth-introspection].

The authorization server and long-term keys. Likewise, compromise of a single the resource server MUST NOT compromise keying material held by any other both have access
to the same back-end database. Smaller, tightly coupled systems
might prefer such a deployment strategy.

7.1.2. Asymmetric Keys

Figure 2: Interaction between the context of a key
hierarchy, this means that Client and the compromise Authorization Server
(Asymmetric Keys).

The use of one node in asymmetric keys is slightly different since the key
hierarchy must not disclose client or
the information necessary to
compromise other branches server could be involved in the key hierarchy. Obviously, the
compromise of the root generation of the ephemeral key hierarchy will compromise all of
the keys; however, a compromise in one branch MUST NOT result
pair. This exchange is shown in Figure 1. If the compromise of other branches. There are many implications of
this requirement; however, two implications deserve highlighting.
First, client generates
the scope key pair it either includes a fingerprint of the keying material must be defined and
understood by all parties that communicate with a party that holds
that keying material. Second, a party that holds keying material
in a public key hierarchy must not share that keying material with
parties that are associated with other branches in or
the public key
hierarchy.

Bind Key to its Context:

Keying material MUST be bound to in the appropriate context. The
context includes request to the following.

* authorization server. The manner
authorization server would include this fingerprint or public key in which
the keying material is expected to be used.

* The other parties that are expected to have confirmation claim inside the access token and thereby bind the
asymmetric key pair to the
keying material.

* The expected lifetime of token. If the client did not provide a
fingerprint or a public key in the request then the keying material. Lifetime of a
child authorization
server is asked to create an ephemeral asymmetric key SHOULD NOT be greater than pair, binds the lifetime
fingerprint of its parent
in the public key hierarchy.

Any party with legitimate access to keying material can determine
its context. In addition, the protocol MUST ensure that all
parties with legitimate access to keying material have token, and returns the same
context for
asymmetric key pair (public and private key) to the keying material. This requires client. Note
that there is a strong preference for generating the parties
are properly identified and authenticated, so that all of private/public
key pair locally at the
parties that have access to client rather than at the keying material can be determined. server.

7.2. Client and Resource Server Interaction

The context will include specification describing the interaction between the client and
the resource server
identities in more than one form.

Authorization Restriction:

If client authorization is restricted, then the client SHOULD server, as shown in Figure 1 and in Figure 2, can
be
made aware of found in [I-D.ietf-oauth-pop-key-distribution].

Once the restriction.

Client Identity Confidentiality:

A client has identity confidentiality when any party other than obtained the resource server necessary access token and keying
material it can start to interact with the authorization server cannot
sufficiently identify resource server. To
demonstrate possession of the client within key bound to the anonymity set. In
comparison access token it needs
to anonymity and pseudonymity, identity confidentiality
is concerned with eavesdroppers and intermediaries. A key
management protocol SHOULD provide apply this property.

Resource Owner Identity Confidentiality:

Resource servers SHOULD be prevented from knowing key to the real request by computing a keyed message digest
(i.e., a symmetric key-based cryptographic primitive) or
pseudonymous identity of a digital
signature (i.e., an asymmetric cryptographic computation). When the
resource owner, since the
authorization server is receives the only entity involved in verifying request it verifies it and decides
whether access to the protected resource owner's identity.

Collusion:

Resource servers that collude can be prevented from using
information related to granted. This
exchange is shown in Figure 3.

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

^ ^
| |
| |
Symmetric Key Symmetric Key
or or
Asymmetric Key Pair Public Key (Client)
+ +
Parameters Parameters

Figure 3: Client Demonstrates PoP.

The specification describing the resource owner ability to track sign the individual.
That is, two different resource servers can be prevented HTTP request
from
determining that the same resource owner has authenticated to both
of them. Authorization servers MUST bind different keying
material client to access tokens used for the resource servers from different
origins (or similar concepts server can be found in
[I-D.ietf-oauth-signed-http-request].

7.3. Resource and Authorization Server Interaction (Token
Introspection)

So far the app world).

AS-to-RS Relationship Anonymity:

For solutions using asymmetric key cryptography the client MAY
conceal information examples talked about access tokens that are passed by
value and allow the resource server it wants to interact
with. The make authorization decisions
immediately after verifying the request from the client. In some
deployments a real-time interaction between the authorization server MAY reject such an attempt since
it may not be able
and the resource server is envisioned that lowers the need to enforce pass
self-contained access control decisions.

Channel Binding:

A solution MUST enable support for channel bindings. The concept
of channel binding, as defined in [RFC5056], allows applications
to establish tokens around. In that case the two end-points of access token
merely serves as a secure channel handle or a reference to state stored at one
network layer are the same as at
authorization server. As a higher layer by binding
authentication at consequence, the higher layer resource server cannot
autonomously make an authorization decision when receiving a request
from a client but has to consult the channel at authorization server. This can,
for example, be done using the lower
layer.

There are performance concerns with token introspection endpoint (see
[I-D.ietf-oauth-introspection]). Figure 4 shows the use of asymmetric
cryptography. Although symmetric key cryptography offers better
performance asymmetric cryptography offers additional security
properties. A solution MUST therefore offer protocol
interaction graphically. Despite the capability to
support both additional token exchange
previous descriptions about associating symmetric as well as and asymmetric keys.

There are threats that relate keys
to the experience of the software
developer as well as operational practices. Verifying the servers
identity in TLS is discussed at length in [RFC6125].

A number of the threats listed in Section 4 demand protection of the access token content are still applicable to this scenario.

+---------------+
Access ^| |
Token Req. // | Authorization |^
(I) / | Server | \ (IV) Token
// | | \ Introspection Req.
/ | | \ +Access
// /+---------------+ \ Token
/ // (II) \ \\
/ / Access \ \
// // Token \ (V) \
/ / \Resp.\
// // \ \
/ v V \
+-----------+ Request +Signature/MAC+------------+
| | (III) +Access Token | |
| |---------------------->| Resource |
| Client | (VI) Success or | Server |
| | Failure | |
| |<----------------------| |
+-----------+ +------------+

Figure 4: Token Introspection and a standardized solution, in form of a JSON-
based format, is available with the JWT [RFC7519]. Access Token Handles.

8. Security Considerations

The purpose of this document is to provide use cases, requirements,
and motivation for developing an OAuth security solution extending
Bearer Tokens. As such, this document is only about security.

9. IANA Considerations

This document does not require actions by IANA.

10. Acknowledgments

This document is the result of conference calls late 2012/early 2013
and in design team conference calls February 2013 of the IETF OAuth
working group. 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, Leif Johansson, Lucy Lynch, John
Bradley, Tony Nadalin, Klaas Wierenga, Thomas Hardjono, Brian
Campbell

In the appendix of this document we re-use reuse content from [RFC4962] and
the authors would like thank Russ Housely and Bernard Aboba for their
work on RFC 4962.

We would like to thank Reddy Tirumaleswar for his review.

11. References

11.1. Normative References

[I-D.ietf-oauth-introspection]
Richer, J., "OAuth 2.0 Token Introspection", draft-ietf-
oauth-introspection-11 (work in progress), July 2015.

[I-D.ietf-oauth-pop-key-distribution]
Bradley, J., Hunt, P., Jones, M., and H. Tschofenig,
"OAuth 2.0 Proof-of-Possession: Authorization Server to
Client Key Distribution", draft-ietf-oauth-pop-key-
distribution-01 (work in progress), March 2015.

[I-D.ietf-oauth-proof-of-possession]
Jones, M., Bradley, J., and H. Tschofenig, "Proof-of-
Possession Key Semantics for JSON Web Tokens (JWTs)",
draft-ietf-oauth-proof-of-possession-04 (work in
progress), August 2015.

[I-D.ietf-oauth-signed-http-request]
Richer, J., Bradley, J., and H. Tschofenig, "A Method for
Signing an HTTP Requests for OAuth", draft-ietf-oauth-
signed-http-request-01 (work in progress), March 2015.

[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119,
DOI 10.17487/
RFC2119, 10.17487/RFC2119, March 1997,
<http://www.rfc-editor.org/info/rfc2119>.

[RFC5246] Dierks, T. and E. Rescorla, "The Transport Layer Security
(TLS) Protocol Version 1.2", RFC 5246,
DOI 10.17487/
RFC5246, 10.17487/RFC5246, August 2008,
<http://www.rfc-editor.org/info/rfc5246>.

[RFC6749] Hardt, D., Ed., "The OAuth 2.0 Authorization Framework",
RFC 6749, DOI 10.17487/RFC6749, October 2012,
<http://www.rfc-editor.org/info/rfc6749>.

[RFC7519] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token
(JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015,
<http://www.rfc-editor.org/info/rfc7519>.

11.2. Informative References

[I-D.hardjono-oauth-kerberos]
Hardjono, T., "OAuth 2.0 support for the Kerberos V5
Authentication Protocol", draft-hardjono-oauth-kerberos-01
(work in progress), December 2010.

[I-D.ietf-oauth-introspection]
Richer, J., "OAuth 2.0 Token Introspection", draft-ietf-
oauth-introspection-11 (work in progress), July 2015.

[NIST800-63]
Burr, W., Dodson, D., Perlner, R., Polk, T., Gupta, S.,
and E. Nabbus, "NIST Special Publication 800-63-1,
INFORMATION SECURITY", December 2008.

[RFC4120] Neuman, C., Yu, T., Hartman, S., and K. Raeburn, "The
Kerberos Network Authentication Service (V5)", RFC 4120,
DOI 10.17487/RFC4120, July 2005,
<http://www.rfc-editor.org/info/rfc4120>.

[RFC4279] Eronen, P., Ed. and H. Tschofenig, Ed., "Pre-Shared Key
Ciphersuites for Transport Layer Security (TLS)",
RFC 4279, DOI 10.17487/RFC4279, December 2005,
<http://www.rfc-editor.org/info/rfc4279>.

[RFC4962] Housley, R. and B. Aboba, "Guidance for Authentication,
Authorization, and Accounting (AAA) Key Management",
BCP 132, RFC 4962, DOI 10.17487/RFC4962, July 2007,
<http://www.rfc-editor.org/info/rfc4962>.

[RFC5056] Williams, N., "On the Use of Channel Bindings to Secure
Channels", RFC 5056, DOI 10.17487/RFC5056, November 2007,
<http://www.rfc-editor.org/info/rfc5056>.

[RFC5849] Hammer-Lahav, E., Ed., "The OAuth 1.0 Protocol", RFC 5849,
DOI 10.17487/RFC5849, April 2010,
<http://www.rfc-editor.org/info/rfc5849>.

[RFC6125] Saint-Andre, P. and J. Hodges, "Representation and
Verification of Domain-Based Application Service Identity
within Internet Public Key Infrastructure Using X.509
(PKIX) Certificates in the Context of Transport Layer
Security (TLS)", RFC 6125, DOI 10.17487/RFC6125, March
2011, <http://www.rfc-editor.org/info/rfc6125>.

[RFC6750] Jones, M. and D. Hardt, "The OAuth 2.0 Authorization
Framework: Bearer Token Usage", RFC 6750,
DOI 10.17487/
RFC6750, 10.17487/RFC6750, October 2012,
<http://www.rfc-editor.org/info/rfc6750>.

[RFC6819] Lodderstedt, T., Ed., McGloin, M., and P. Hunt, "OAuth 2.0
Threat Model and Security Considerations", RFC 6819,
DOI 10.17487/RFC6819, January 2013,
<http://www.rfc-editor.org/info/rfc6819>.

Authors' Addresses

Phil Hunt (editor)
Oracle Corporation

Email: phil.hunt@yahoo.com

Justin Richer

Email: ietf@justin.richer.org

William Mills

Email: wmills@yahoo-inc.com
Prateek Mishra
Oracle Corporation

Email: prateek.mishra@oracle.com

Hannes Tschofenig
ARM Limited
Hall in Tirol 6060
Austria

Email: Hannes.Tschofenig@gmx.net
URI: http://www.tschofenig.priv.at