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.

Copyright Notice

   Copyright (c) 2012 2013 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   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  . . . . . . . . . . . . . . . . . . . . . . . . .  3
     1.2.  Notational Conventions  4
   3.  Architecture . . . . . . . . . . . . . . . . . .  5
   2.  Issuing MAC Credentials . . . . . . .  5
   4.  Key Distribution . . . . . . . . . . . .  5
   3.  Making Requests . . . . . . . . . . .  7
     4.1.  Session Key Transport to Client  . . . . . . . . . . . .  6
     3.1.  The "Authorization" Request Header .  7
     4.2.  Session Key Transport to Resource Server . . . . . . . . .  9
   5.  The Authenticator  . .  6
     3.2.  Request MAC . . . . . . . . . . . . . . . . . . . . 10
     5.1.  The Authenticator  . . .  7
       3.2.1.  Normalized Request String . . . . . . . . . . . . . .  7
       3.2.2.  hmac-sha-1 . . . 10
     5.2.  MAC Input String . . . . . . . . . . . . . . . . . . .  8
       3.2.3.  hmac-sha-256 . . 13
     5.3.  Keyed Message Digest Algorithms  . . . . . . . . . . . . . 14
       5.3.1.  hmac-sha-1 . . . . . .  9
   4.  Verifying Requests . . . . . . . . . . . . . . . . 14
       5.3.2.  hmac-sha-256 . . . . . .  9
     4.1.  Timestamp Verification . . . . . . . . . . . . . . . 14
   6.  Verifying the Authenticator  . . .  9
     4.2.  The "WWW-Authenticate" Response Header Field . . . . . . . 10
   5.  Use with OAuth 2.0 . . . . . . . 15
     6.1.  Timestamp Verification . . . . . . . . . . . . . . . 11
     5.1.  Issuing MAC-Type Access Tokens . . . 15
     6.2.  Error Handling . . . . . . . . . . . 11
   6.  Security Considerations . . . . . . . . . . . 16
   7.  Example  . . . . . . . . 12
     6.1.  MAC Keys Transmission . . . . . . . . . . . . . . . . . . 12
     6.2.  Confidentiality of Requests . 17
   8.  Security Considerations  . . . . . . . . . . . . . . 12
     6.3.  Spoofing by Counterfeit Servers . . . . . 17
     8.1.  Key Distribution . . . . . . . . 12
     6.4.  Plaintext Storage of Credentials . . . . . . . . . . . . . 12
     6.5.  Entropy of MAC Keys 17
     8.2.  Offering Confidentiality Protection for Access to
           Protected Resources  . . . . . . . . . . . . . . . . . . . 13
     6.6.  Denial 17
     8.3.  Authentication of Service / Resource Exhaustion Attacks  . Servers . . . . 13
     6.7.  Timing Attacks . . . . . . . . 18
     8.4.  Plaintext Storage of Credentials . . . . . . . . . . . . . 18
     8.5.  Entropy of Session Keys  . 14
     6.8.  CSRF Attacks . . . . . . . . . . . . . . . . 18
     8.6.  Denial of Service / Resource Exhaustion Attacks  . . . . . 19
     8.7.  Timing Attacks . . 14
     6.9.  Coverage Limitations . . . . . . . . . . . . . . . . . . . 14
   7. . 19
     8.8.  CSRF Attacks . . . . . . . . . . . . . . . . . . . . . . . 19
     8.9.  Protecting HTTP Header Fields  . . . . . . . . . . . . . . 20
   9.  IANA Considerations  . . . . . . . . . . . . . . . . . . . . . 15
     7.1.  The HTTP 20
     9.1.  JSON Web Token Claims  . . . . . . . . . . . . . . . . . . 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 client using
   OAuth 2.0 in the form of a MAC-type access token.

   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 authorization server
   to establish a shared secret between the client and the resource server.

   The shared secret design goal for this mechanism 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
   resource server if the client uses some form of dynamic configuration to determine where
   to send an authenticated request, or when provided information about the client fails resource
   server it wants 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 interact with in the server request to prevent replay attacks.
   Instead, the client provides both authorization
   server.

   Since a nonce keyed message digest only provides integrity protection and a timestamp, which the
   server
   data-origin authentication confidentiality protection can use to prevent replay attacks using a bounded amount only be
   added by the usage of
   storage.  Also unlike Digest, this Transport Layer Security (TLS).  This
   specification provides a mechanism for channel binding is not intended included to
   protect the user's password itself because the client
   ensure that a TLS channel is not terminated prematurely and server both
   have access to indeed
   covers the entire end-to-end communication.

2.  Terminology

   The key material words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL NOT',
   'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'MAY', and 'OPTIONAL' 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
   specification are to be interpreted as described in [RFC2119].

   This specification uses 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 Augmented Backus-Naur Form (ABNF)
   notation of MAC credentials for
   accessing resources on [I-D.ietf-httpbis-p1-messaging].  Additionally, the "http://example.com/" server.
   following rules are included from [RFC2617]: auth-param.

   Session Key:

      The MAC
   credentials issued terms mac key, session key, and symmetric key are used
      interchangably and refer to the cryptographic keying material
      established between the client include and the following attributes:

   MAC resource server.  This
      temporary key identifier: h480djs93hd8

   MAC key: 489dks293j39

   MAC algorithm: hmac-sha-1

   The used between the client constructs and the authentication header by calculating resource server,
      with a
   timestamp (e.g. lifetime limited to the number lifetime of seconds since January 1, 1970 00:00:00
   GMT) and generating a random string used as a nonce:

   Timestamp: 1336363200

   Nonce: dj83hs9s

   The client constructs the normalized request string (the new line
   separator character access token.  This
      session key is represented generated by "\n" for display purposes only; the trailing new line separator signify authorization server.

   Authenticator:

      A record containing information that no extension value 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 can be shown to have been
      recently generated using the specified MAC algorithm
   "hmac-sha-1" and the MAC session key over known only by the normalized request string. 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
      fixed-size output.  The
   result design goal is base64-encoded that it is
      practically infeasible to produce the request MAC:

     bhCQXTVyfj5cmA9uKkPFx1zeOXM=

   The client includes same output without
      knowledge of the MAC key identifier, nonce, key.  The terms keyed message digest functions
      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=" MACs are used interchangably.

3.  Architecture

   The server validates the request by calculating architecture of the request MAC again
   based on proposal described in this document assumes
   that the request received authorization server acts as a trusted third party that
   provides session keys to clients and verifies to resource servers.  These
   session keys are used by the validity client and scope of the MAC credentials.  If valid, resource server as input
   to a MAC.  In order to obtain the session key the client interacts
   with the authorization server responds as part of the a normal grant exchange.
   This is shown in an abstract way in Figure 1.  Together with the
   requested resource representation.

1.2.  Notational Conventions

   The
   access token the authorization server returns a session key words 'MUST', 'MUST NOT', 'REQUIRED', 'SHALL', 'SHALL NOT',
   'SHOULD', 'SHOULD NOT', 'RECOMMENDED', 'MAY', (in the
   mac_key parameter) and 'OPTIONAL' in this
   specification are to be interpreted as described in [RFC2119].

   This specification uses several other parameters.  The resource server
   obtains the Augmented Backus-Naur Form (ABNF)
   notation of [I-D.ietf-httpbis-p1-messaging].  Additionally, session key via the
   following rules access token.  Both of these two key
   distribution steps 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 more detail in Section 5. This specification does
   not mandate servers to support any particular method for issuing MAC
   credentials, and other methods MAY be defined 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 used.  Whenever MAC
   credentials are issued, the credentials MUST include
                           Authorization Server.

   Once the following
   attributes:

   MAC client has obtained the necessary access token and the
   session key identifier
         A string identifying (including parameters) it can start to interact with the MAC
   resource server.  To demonstrate possession of the session key used it
   computes a MAC and adds various fields to calculate the outgoing request
         MAC. The string is usually opaque to
   message.  We call this structure the client. "Authenticator".  The server
         typically assigns a specific scope
   evaluates the request, includes an Authenticator and lifetime to each set of
         MAC credentials.  The identifier MAY denote returns a unique value used
   response back to retrieve the authorization information (e.g.  from a
         database), or self-contain client.  Since the authorization information in a
         verifiable manner (i.e. access token is valid for a string consisting
   period of some data and a
         signature).

   MAC key
         A shared symmetric secret used as time the MAC algorithm key.  The resource server MUST NOT reissue 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 previously issued MAC session key must be available to the
   client and the resource server, which is then used as a parameter in
   the keyed message digest function.  This document describes the key
   distribution mechanism that uses the authorization server as a
   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 the MAC algorithm 9.2.  The
         authorization server is
         not understood by assumed to know the client, set of algorithms
         supported by the client MUST NOT use the MAC
         credentials and continue as if no MAC credentials were issued.

   The MAC key identifier, MAC key, MAC the resource server.  It selects an
         algorithm strings MUST NOT
   include characters other than:

     %x20-21 / %x23-5B / %x5D-7E
     ; Any printable ASCII character except that meets the security policies and is 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 encrypting mac_key
   inside the 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 contain a key id (kid) in the 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 <\>

3.  Making Requests the
   authorization server, as shown in Figure 1 as AS-RS key.  The
   establishment of this long-term key 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 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 framework defined
   by [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:

   id

   kid

         REQUIRED.  The MAC key identifier.

   ts

         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 by JavaScript getTime() function or the client.  The value
         MUST Java
         System.currentTimeMillis() function, for example, produce such
         a timestamp.

   seq-nr

         OPTIONAL.  This optional field includes the initial sequence
         number to be unique across all requests with used by the same timestamp messages exchange between the client
         and
         MAC key identifier combination.

   ext
         OPTIONAL. A string used 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 include additional information which the server.  When included in the response
         message, the initial sequence number is covered by that for messages from
         the request MAC. server to the client.  Sequence numbers fall in the range 0
         through 2^64 - 1 and wrap to zero following the value 2^64 - 1.

         The content initial sequence number SHOULD be random and format uniformly
         distributed across the full space of possible sequence numbers,
         so that it cannot be guessed by an attacker and so that it and
         the
         string is beyond successive sequence numbers do not repeat other sequences.
         In the scope event that more than 2^64 messages are to be generated
         in a series of this specification. 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 HTTP request MAC result of the keyed message digest computation,
         as described in Section 3.2.

   Attributes MUST NOT appear more than once.  Attribute values are
   limited to a subset 5.3.

   cb

         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 ASCII, channel bindings for TLS.  First, there is the 'tls-
         server-end-point' channel binding, which does not require escaping, uses a hash of the TLS
         server's certificate as
   defined by it appears, octet for octet, in the plain-string ABNF.

3.2.  Request MAC
         server's Certificate message.  The client second channel binding is
         'tls-unique', which uses the MAC algorithm and first TLS Finished message sent
         (note: the MAC key to calculate Finished struct, not 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 TLS record layer message
         containing it) in the most recent TLS handshake of the HTTP request elements into a single
   string.  By normalizing TLS
         connection being bound to.  As an example, the request into cb field may
         contain cb=tls-unique:9382c93673d814579ed1610d3
   h

         OPTIONAL.  This field contains a reproducible string, colon-separated list of header
         field names that identify the
   client and server can both calculate header fields presented to the request MAC over
         keyed message digest algorithm.  If the exact
   same value.

   The string 'h' header field is constructed by concatenating together, in order,
         absent then the following HTTP request elements, each followed by a new line
   character (%x0A):

   1.  The timestamp value calculated for the request.

   2. is set by default: h="host".
         The nonce value generated for field MUST contain the request.

   3.  The HTTP request method complete list of header fields in upper case.  For example: "HEAD",
       "GET", "POST", etc.

   4.
         the order presented to the keyed message digest algorithm.  The HTTP request-URI
         field MAY contain names of header fields that do not exist at
         the time of computing the keyed message digest; nonexistent
         header fields do not contribute to the keyed message digest
         computation (that is, they are treated as defined 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 [RFC2616] section 5.1.2.

   5.  The hostname included intermediaries.
         However, since the client cannot possibly know what header
         fields might be defined in the HTTP request using future, this mechanism cannot be
         used to prevent the "Host"
       request addition of any possible unknown header field in lower case.

   6.
         fields.  The port as field MAY contain multiple instances of a header
         field name, meaning multiple occurrences of the corresponding
         header field are included in the HTTP request using header hash.  The field MUST
         NOT include the "Host" request mac header field.  If  Folding whitespace (FWS) MAY
         be included on either side of the colon separator.  Header
         field names MUST be compared against actual header field does not include names
         in a port, the
       default value for the scheme case-insensitive manner.  This list MUST NOT be used (e.g.  80 for HTTP and
       443 empty.
         See Section 8 for HTTPS).

   7.  The value 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 "ext" "Authorization" plain-string ABNF.

5.2.  MAC Input String

   An HTTP message can either be a request header field
       attribute if one was included from client to server or a
   response from server to client.  Syntactically, the two types of
   message differ only in the request, otherwise, start-line, which is either a request-line
   (for requests) or a status-line (for responses).

   Two parameters serve as input to a keyed message digest function: a
   key and an empty input string.

   Each element  Depending on the communication direction
   either the request-line or the status-line is used as the first value
   followed by a new line character (%x0A) including the
   last element HTTP header fields listed in the 'h' parameter.
   Then, the timestamp field and even when an element value the seq-nr field (if present) is
   concatenated.

   As an empty string.

   For example, consider the HTTP request: request with the new line separator
   character represented by "\n" for editorial purposes only.  The h
   parameter is set to h=host, the kid is 314906b0-7c55, and the
   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 explanation why the access request was declined to assist
   the client developer in Section
         7.1. identifying the problem.

   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. 401 Unauthorized
     WWW-Authenticate: MAC error="The MAC credentials expired"

7.  Example

   [Editor's Note: Full example goes in 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 client and
   the resource server.  This could be problematic when data is
   exchanged that requires care, such as personal data.

   When TLS is used then confidentiality can be ensured and 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
   superiour to the OAuth Bearer Token.

   The use of TLS in combination with the MAC token is highly
   recommended to ensure the
   kinds confidentiality of data likely to be sent as part the user's data.

8.3.  Authentication of such requests, and should
   employ transport-layer security mechanisms to protect sensitive
   resources.

6.3.  Spoofing by Counterfeit 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

9.4.2.  The "mac_key" "mac_algorithm" OAuth Parameter

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

7.3.2.

9.4.3.  The "mac_algorithm" "kid" OAuth Parameter

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

8.  Contributors

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