RFC 6042

Transport Layer Security (TLS) Authorization Using KeyNote ✨

🎀 Okay bestie, the title block is giving main character energy 💅 It's an Independent Submission 🌸 written by A. Keromytis from Columbia University. It's Informational 🦋 (so not a Standards Track thing, ngl) and it dropped in October 2010 🍓. It's got ISSN 2070-1721 💜. The title block doesn't list anything it obsoletes or updates, so it's not replacing or changing any other RFC 🫶

Abstract

okay so this doc explains how to use the KeyNote trust-management system as an authorization extension in the TLS Handshake Protocol 🔐 It follows the guidelines in RFC 5878 💖 The vibe is: the client and server hello messages carry extensions that confirm both sides actually support the authorization data types they want to use ✨ Then, if both the client and server support it, KeyNote credentials get swapped in the supplemental data handshake message 🎀

Status of This Memo

this is not an Internet Standards Track spec 🙈 it's just published for info 🌈

this is a contribution to the RFC Series, totally independent of any other RFC stream 💅 The RFC Editor picked to publish it at their discretion, and they make zero statement about whether it's good for implementing or deploying 💀 Docs the RFC Editor approves for publication are not a candidate for any level of Internet Standard, see Section 2 of RFC 5741 🦋

for the current status, errata, and how to send feedback, check http://www.rfc-editor.org/info/rfc6042 🧚

Copyright Notice

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

this doc is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (http://trustee.ietf.org/license-info) as they were on the publication date 📜 Please actually read these, because they spell out your rights and restrictions for this doc 🫶

---

1. Introduction 🧚

okay so this doc describes the identifiers you need to swap KeyNote [KEYNOTE] credential assertions inside a TLS [TLS1.0] [TLS1.1] [TLS1.2] exchange 🔥 These credential assertions can authorize the client, the server, or both to do certain things 👑 In most setups, the KeyNote credential assertions get signed by a cryptographic public key [RFC2792] 🔑 By using the X.509 key and signature encoding [X509KEY], you can add KeyNote-based authorization and policy compliance support to the existing, unmodified X.509 authentication exchange in TLS, which is literally so clean 😭

a list of KeyNote credentials (like a delegation chain) can be sent in the same payload 🌸 Or you can send a URL [RFC3986] that points to where that list lives ✨

usually at least one of those credentials gets issued to the public key of whoever sent them, meaning that public key shows up in the "Licensees" field of at least one KeyNote credential assertion 💅 The same public key is generally what the sender uses to authenticate during the TLS exchange 🫶 The authentication material (like that public key) that the sender used to authenticate in TLS gets handed to the KeyNote evaluation engine as an "Action Authorizer" 🦋

1.1. Conventions

the key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119] 📖 (these are the official requirement-level words, so treat them seriously bestie 🙏)

2. KeyNote Credential Assertion Lists 💖

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

keynote_assertion_list(64)

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 gets sent 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 holds 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 basically like a public key certificate, except the difference is that instead of binding a name to a public key, KeyNote assertions bind public keys to authorization rules 🌈 Those rules get evaluated by the peer when the sender later makes specific requests 👑

when you're making an authorization decision based on a list of KeyNote assertions, the KeyNote assertions need proper linkage to the public key certificate that's transferred in the TLS Certificate message 🔗 Receivers of a KeyNote assertion list should initialize the ACTION_AUTHORIZER variable to be the sender's public key, the one used to authenticate the TLS exchange 🦋 If a different authentication mechanism is used, it's on the credential issuer to issue the appropriate credentials 🙈

3. KeyNote Credential Assertion List URL 🧚

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

keynote_assertion_list_url(65)

a KeyNote Assertion List URL gets sent inside an AuthorizationDataEntry structure as a URLandHash structure [AUTHZ] 🌸

when keynote_assertion_list_url is present, the authorization data is a list of KeyNote assertions as described in Section 2 💖 The difference is that the KeyNote assertion list gets fetched from the supplied URL 🌈 A one-way hash value is included to make sure you got the intended KeyNote credential assertion 🔒

⚠️ 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 🫶 So clients using the HTTP scheme MUST NOT use these TLS extensions if the Upgrade mechanism in HTTP [UPGRADE] is used 🙅‍♀️ For other schemes, similar care must be taken to avoid using these TLS extensions 💜

4. IANA Considerations 📋

with this doc, IANA registered two new entries in the TLS Authorization Data Formats registry: keynote_assertion_list(64) and keynote_assertion_list_url(65) 🎀 That registry is defined in [AUTHZ] ✨

5. Security Considerations 🔐

there are no security considerations beyond those discussed in [KEYNOTE], [RFC2792], and [AUTHZ] 🙈 go read those too, because security is never something to skip, periodt 💀

6. References

6.1. Normative References

• [RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997. 📖
• [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, April 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 T. Berners-Lee, "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. ✨

6.2. 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] Keromytis, A., "X.509 Key and Signature Encoding for the KeyNote Trust Management System", RFC 5708, January 2010. 🌸
• [RFC3986] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, 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 from this doc 💅 The added elements are marked with two asterisks ("**") at the end of each line 🌈

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),
   saml_assertion_url(3),
   keynote_assertion_list(64), keynote_assertion_list_url(65),  **
   (255)
} 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];

Author's Address 🧚

Angelos D. Keromytis
Department of Computer Science
Columbia University
Mail Code 0401
1214 Amsterdam Avenue
New York, NY  10027
USA

EMail: angelos@cs.columbia.edu