Skip to main content

Transport Layer Security (TLS) Authorization Using KeyNote

The information below is for an old version of the document that is already published as an RFC.
Document Type
This is an older version of an Internet-Draft that was ultimately published as RFC 6042.
Author Angelos D. Keromytis
Last updated 2015-10-14 (Latest revision 2010-07-02)
RFC stream Independent Submission
Intended RFC status Informational
Stream ISE state (None)
Consensus boilerplate Unknown
Document shepherd (None)
IESG IESG state Became RFC 6042 (Informational)
Action Holders
Telechat date (None)
Responsible AD Tim Polk
Send notices to
Internet-Draft                                    Keromytis, Angelos D.
Expires: December 2, 2010                           Columbia University
Intended Status: Informational                             July 2, 2010
Filename: draft-keromytis-tls-authz-keynote-07.txt

        Transport Layer Security (TLS) Authorization Using KeyNote

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), its areas, and its working groups.  Note that
   other groups may also distribute working documents as Internet-

   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

   The list of current Internet-Drafts can be accessed at

   The list of Internet-Draft Shadow Directories can be accessed at

Copyright Notice

   Copyright (c) 2010 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
   ( 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 BSD License.


   This document specifies the use of the KeyNote trust-management
   system as an authorization extension in the Transport Layer
   Security (TLS) Handshake Protocol, according to [AUTHZ].
   Extensions carried in the client and server hello messages
   confirm that both parties support the desired authorization
   data types. Then, if supported by both the client and the
   server, KeyNote credentials are exchanged during the
   supplemental data handshake message.

1. Introduction

   This document describes the identifiers necessary to exchange
   KeyNote [KEYNOTE] credential assertions inside a TLS [TLS1.0]
   [TLS1.1] [TLS1.2] exchange.  Such credential assertions can
   authorize the client and/or the server to perform certain
   actions. In most usage scenarios, the KeyNote credential
   assertions will be signed by a cryptographic public key
   [RFC2792].  By using the X.509 key and signature encoding
   [X509KEY], it is possible to add KeyNote-based authorization and
   policy compliance support to the existing, unmodified X.509
   authentication exchange in TLS.

   A list of KeyNote credentials (e.g., forming a delegation chain)
   may be sent as part of the same payload.  Alternatively, a URL
   [RFC3986] pointing to the location of such a list of KeyNote
   credentials may be provided.

   In most scenarios, at least one of these credentials will be
   issued to the public key of the transmitter of the credentials,
   i.e., said public key will appear in the ``Licensees'' field of
   at least one KeyNote credential assertion.  The same public key
   will generally be used by the transmitter of the same credentials
   to authenticate as part of the TLS exchange.  The
   authentication material (e.g., cryptographic public key) that was
   used by the transmitter to authenticate in the TLS exchange will
   be provided to the KeyNote evaluation engine as an ``Action

2. KeyNote Credential Assertion Lists

   The KeyNote Assertion List type definition in the TLS Authorization
   Data Formats registry is:


   When the keynote_assertion_list value is present, the authorization
   data is a list of KeyNote credential assertions that conforms to
   the profile in RFC 2704 [KEYNOTE].

   A KeyNote assertion list is transmitted inside an
   AuthorizationDataEntry structure as an opaque sequence
   of 1 - 2^16-1 bytes:

      opaque KeyNoteAssertionList<1..2^16-1>;

   When KeyNoteAssertionList is used, the field contains an ASCII-
   encoded list of signed KeyNote assertions, as described in RFC 2704
   [KEYNOTE].  The assertions are separated by two '\n' (newline)
   characters.  A KeyNote assertion is a structure similar to a public
   key certificate; the main difference is that instead of a binding
   between a name and a public key, KeyNote assertions bind public keys
   to authorization rules that are evaluated by the peer when the sender
   later issues specific requests.

   When making an authorization decision based on a list of KeyNote
   assertions, proper linkage between the KeyNote assertions and the
   public key certificate that is transferred in the TLS Certificate
   message is needed.  Receivers of a KeyNote assertion list should
   initialize the ACTION_AUTHORIZER variable to be the sender's public
   key, which was used to authenticate the TLS exchange.  If a
   different authentication mechanism is used, it is the responsibility
   of the credential issuer to issue the appropriate credentials.

3. KeyNote Credential Assertion List URL

   The KeyNote Assertion List URL type definition in the TLS
   Authorization Data Formats registry is:


   A KeyNote Assertion List URL is transmitted inside an
   AuthorizationDataEntry structure as a URLandHash structure [AUTHZ].

   When the keynote_assertion_list_url value is present, the
   authorization data is a list of KeyNote assertions as described
   in Section 2; however the KeyNote assertion list is fetched with
   the supplies URL.  A one-way hash value is provided to ensure
   that the intended KeyNote credential assertion is obtained.

   Implementations that support keynote_assertion_list_url MUST
   support URLs that employ the http scheme [HTTP].  These
   implementations MUST confirm that the hash value computed on the
   fetched authorization matches the one received in the handshake.
   Mismatch of the hash values SHOULD be treated as though the
   authorization was not provided, which will result in a
   bad_certificate alert [AUTHZ].

  Other schemes may also be supported.  When dereferencing these URLs,
  circular dependencies MUST be avoided.  Avoiding TLS when
  dereferencing these URLs is one way to avoid circular dependencies.
  Therefore, clients using the HTTP scheme MUST NOT use these TLS
  extensions if UPGRADE in HTTP [UPGRADE] is used.  For other schemes,
  similar care must be taken to avoid using these TLS extensions.

4. IANA Considerations

   This document requires two new entries in the IANA-maintained TLS 
   Authorization Data Formats registry, keynote_assertion_list(TBA)
   and keynote_assertion_list_url(TBA).  This registry is defined in
   [AUTHZ].  The numbers should be allocated from the Specification
   Required space.

5. Security Considerations

   There are no security considerations beyond those discussed in
   [KEYNOTE], [RFC2792], and [AUTHZ].

6. Normative References

   [IANA]       Narten, T., and H. Alvestrand, "Guidelines for Writing
                an IANA Considerations Section in RFCs", RFC 3434,
                October 1998.

   [TLS1.0]     Dierks, T., and C. Allen, "The TLS Protocol, Version
                1.0", RFC 2246, January 1999.

   [TLS1.1]     Dierks, T., and E. Rescorla, "The Transport Layer
                Security (TLS) Protocol, Version 1.1", RFC 4346,
                February 2006.

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

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

   [UPGRADE]    Khare, R., and S. Lawrence, "Upgrading to TLS Within
                HTTP/1.1", RFC 2817, May 2000.

   [KEYNOTE]    Blaze, M., Feigenbaum, J., Ioannidis, J., and
                A. Keromytis, "The KeyNote Trust-Management System,
                Version 2", RFC 2704, September 1999.

   [AUTHZ]      Brown, M., and R. Housley, "Transport Layer Security
                (TLS) Authorization Extensions", RFC 5878, May 2010.

7. Informative References

   [RFC2792]    Blaze, M., Ioannidis, J., and A. Keromytis, "DSA and RSA
                Key and Signature Encoding for the KeyNote Trust
                Management System", RFC 2792, March 2000.

   [X509KEY]    A. D. Keromytis, "X.509 Key and Signature Encoding for
                the KeyNote Trust Management System", RFC 5708,
                January 2010.

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

Appendix A.  Updated TLS Authorization Data Structures

    For clarity, this Appendix shows an updated version of the relevant
    data structures from Section 3.3 in [AUTHZ] with the new entries
    described in this document.  The added elements are denoted with two
    asterisks ('**') at the end of the respective lines.

      struct {
         AuthorizationDataEntry authz_data_list<1..2^16-1>;
      } AuthorizationData;

      struct {
         AuthzDataFormat authz_format;
         select (AuthzDataFormat) {
            case x509_attr_cert:              X509AttrCert;
            case saml_assertion:              SAMLAssertion;
            case x509_attr_cert_url:          URLandHash;
            case saml_assertion_url:          URLandHash;
            case keynote_assertion_list:      KeyNoteAssertionList;    **
            case keynote_assertion_list_url:  URLandHash;              **
      } AuthorizationDataEntry;

      enum {
         x509_attr_cert(0), saml_assertion(1), x509_attr_cert_url(2),
         keynote_assertion_list(TBA), keynote_assertion_list_url(TBA), **
      } AuthzDataFormat;

      opaque X509AttrCert<1..2^16-1>;

      opaque SAMLAssertion<1..2^16-1>;

      opaque KeyNoteAssertionList<1..2^16-1>;                          **

      struct {
         opaque url<1..2^16-1>;
         HashAlgorithm hash_alg;
         select (hash_alg) {
            case md5:    MD5Hash;
            case sha1:   SHA1Hash;
            case sha224: SHA224Hash;
            case sha256: SHA256Hash;
            case sha384: SHA384Hash;
            case sha512: SHA512Hash;
         } hash;
      } URLandHash;

      enum {
         none(0), md5(1), sha1(2), sha224(3), sha256(4), sha384(5),
         sha512(6), (255)
      } HashAlgorithm;

      opaque MD5Hash[16];

      opaque SHA1Hash[20];

      opaque SHA224Hash[28];

      opaque SHA256Hash[32];

      opaque SHA384Hash[48];

      opaque SHA512Hash[64];

Authors' Addresses

   Angelos D. Keromytis
   Department of Computer Science
   Columbia University
   Mail Code 0401
   1214 Amsterdam Avenue
   New York, New York 1007
   angelos <at> cs <dot> columbia <dot> edu