RFC 4279
Pre-Shared Key Ciphersuites for Transport Layer Security (TLS)
RFC 4279 🎀 (Network Working Group) Title: Pre-Shared Key Ciphersuites for Transport Layer Security (TLS) 💖 Authors: P. Eronen, Ed. (Nokia) and H. Tschofenig, Ed. (Siemens) 👯♀️ Category: Standards Track 🔥 Date: December 2005 🌸 Obsoletes / Updates: the title block doesn't list anything it obsoletes or updates 🙈
Status of This Memo ✨
okay so this doc is an Internet standards track protocol for the Internet community, and it's literally asking for discussion and suggestions for improvements 🫶 If you want the current standardization state and status of this protocol, check the current edition of the "Internet Official Protocol Standards" (STD 1). Distribution of this memo is unlimited, so share the vibes 💅
Copyright Notice 🦋
Copyright (C) The Internet Society (2005).
Abstract 💜
bestie, this doc adds three sets of new ciphersuites to TLS so it can do authentication with pre-shared keys (PSKs) 🔑 These are symmetric keys that the communicating parties share in advance. The first set only uses symmetric key operations for authentication. The second set runs a Diffie-Hellman exchange that's authenticated with a pre-shared key. The third set combines public key authentication of the server with pre-shared key authentication of the client. It's giving variety 🧚
Table of Contents 📋
1. Introduction ....................................................2
1.1. Applicability Statement ....................................3
1.2. Conventions Used in This Document ..........................4
2. PSK Key Exchange Algorithm ......................................4
3. DHE_PSK Key Exchange Algorithm ..................................6
4. RSA_PSK Key Exchange Algorithm ..................................7
5. Conformance Requirements ........................................8
5.1. PSK Identity Encoding ......................................8
5.2. Identity Hint ..............................................9
5.3. Requirements for TLS Implementations .......................9
5.4. Requirements for Management Interfaces .....................9
6. IANA Considerations ............................................10
7. Security Considerations ........................................10
7.1. Perfect Forward Secrecy (PFS) .............................10
7.2. Brute-Force and Dictionary Attacks ........................10
7.3. Identity Privacy ..........................................11
7.4. Implementation Notes ......................................11
8. Acknowledgements ...............................................11
9. References .....................................................12
9.1. Normative References ......................................12
9.2. Informative References ....................................121. Introduction 🌷
Usually TLS gets its authentication from public key certificates [TLS] or Kerberos [KERB] 🪪 This doc is all about using symmetric keys instead, which are called pre-shared keys or PSKs for short. They get shared in advance among the communicating parties, and then they're used to set up a TLS connection. Main character energy 👑
There are basically two reasons why someone might want to do this:
- First, depending on the ciphersuite, pre-shared keys can skip the need for public key operations 🧮 That's super useful when TLS is running in performance-constrained environments with limited CPU power 🐢
- Second, pre-shared keys can be more convenient from a key management point of view ✨ For example, in closed environments where connections are mostly configured by hand ahead of time, setting up a PSK can be easier than dealing with certificates. Another case is when the parties already have a way to set up a shared secret key, and that mechanism could be used to "bootstrap" a key for authenticating a TLS connection. Big brain move 🧠
This document specifies three sets of new ciphersuites for TLS 💅 They use new key exchange algorithms, and they reuse existing cipher and MAC algorithms from [TLS] and [AES]. Here's a quick summary of the ciphersuites:
CipherSuite Key Exchange Cipher Hash
TLS_PSK_WITH_RC4_128_SHA PSK RC4_128 SHA
TLS_PSK_WITH_3DES_EDE_CBC_SHA PSK 3DES_EDE_CBC SHA
TLS_PSK_WITH_AES_128_CBC_SHA PSK AES_128_CBC SHA
TLS_PSK_WITH_AES_256_CBC_SHA PSK AES_256_CBC SHA
TLS_DHE_PSK_WITH_RC4_128_SHA DHE_PSK RC4_128 SHA
TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA DHE_PSK 3DES_EDE_CBC SHA
TLS_DHE_PSK_WITH_AES_128_CBC_SHA DHE_PSK AES_128_CBC SHA
TLS_DHE_PSK_WITH_AES_256_CBC_SHA DHE_PSK AES_256_CBC SHA
TLS_RSA_PSK_WITH_RC4_128_SHA RSA_PSK RC4_128 SHA
TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA RSA_PSK 3DES_EDE_CBC SHA
TLS_RSA_PSK_WITH_AES_128_CBC_SHA RSA_PSK AES_128_CBC SHA
TLS_RSA_PSK_WITH_AES_256_CBC_SHA RSA_PSK AES_256_CBC SHAThe ciphersuites in Section 2 (with PSK key exchange algorithm) use only symmetric key algorithms, so they're especially suitable for performance-constrained environments 🐣
The ciphersuites in Section 3 (with DHE_PSK key exchange algorithm) use a PSK to authenticate a Diffie-Hellman exchange 🤝 They protect against dictionary attacks by passive eavesdroppers (but not active attackers), and they also provide Perfect Forward Secrecy (PFS) 🔐
The ciphersuites in Section 4 (with RSA_PSK key exchange algorithm) combine public-key-based authentication of the server (using RSA and certificates) with mutual authentication using a PSK 🦋
1.1. Applicability Statement 🎯
The ciphersuites in this document are meant for a pretty limited set of applications, usually with only a very small number of clients and servers 🥺 Even in those environments, other alternatives may be a better fit.
If the main goal is to avoid Public-Key Infrastructures (PKIs), another option worth considering is using self-signed certificates with public key fingerprints 🧾 Instead of manually configuring a shared secret in something like a configuration file, you could put in a fingerprint (hash) of the other party's public key (or certificate) instead.
It's also possible to use the SRP (Secure Remote Password) ciphersuites for shared secret authentication [SRP] 🔒 SRP was designed to be used with passwords, and it has protection against dictionary attacks built in. However, it's computationally more expensive than the PSK ciphersuites in Section 2 🥵
1.2. Conventions Used in This Document 📖
Okay, important keyword alert 🚨 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 [KEYWORDS]. Read those carefully, no cap 🙏
2. PSK Key Exchange Algorithm 🗝️
This section defines the PSK key exchange algorithm and its associated ciphersuites. These ciphersuites only use symmetric key algorithms ✨
It's assumed you already know the ordinary TLS handshake, which looks like this. The elements in parentheses are not included when the PSK key exchange algorithm is used, and "*" marks a situation-dependent message that isn't always sent 💫
Client Server
------ ------
ClientHello -------->
ServerHello
(Certificate)
ServerKeyExchange*
(CertificateRequest)
<-------- ServerHelloDone
(Certificate)
ClientKeyExchange
(CertificateVerify)
ChangeCipherSpec
Finished -------->
ChangeCipherSpec
<-------- Finished
Application Data <-------> Application DataSo the client says it's willing to use pre-shared key authentication by including one or more PSK ciphersuites in its ClientHello message 💌 If the TLS server wants to use pre-shared keys too, it picks one of the PSK ciphersuites, puts the selected ciphersuite in its ServerHello message, and includes an appropriate ServerKeyExchange message (more on that below). The Certificate and CertificateRequest payloads get left out of the response 🙅♀️
Both clients and servers can have pre-shared keys with several different parties 👯 The client indicates which key to use by including a "PSK identity" in its ClientKeyExchange message. (Note that unlike in [SHAREDKEYS], the session_id field in the ClientHello message keeps its usual meaning, so don't mix them up 🙃) To help the client pick which identity to use, the server can provide a "PSK identity hint" in its ServerKeyExchange message. If no hint is provided, the ServerKeyExchange message is omitted. See Section 5 for a more detailed description of these fields 📝
Here's the format of the ServerKeyExchange and ClientKeyExchange messages:
struct {
select (KeyExchangeAlgorithm) {
/* other cases for rsa, diffie_hellman, etc. */
case psk: /* NEW */
opaque psk_identity_hint<0..2^16-1>;
};
} ServerKeyExchange;
struct {
select (KeyExchangeAlgorithm) {
/* other cases for rsa, diffie_hellman, etc. */
case psk: /* NEW */
opaque psk_identity<0..2^16-1>;
} exchange_keys;
} ClientKeyExchange;Now the premaster secret. If the PSK is N octets long, you concatenate a uint16 with the value N, then N zero octets, then a second uint16 with the value N, and then the PSK itself 🧁
Note 1: All the ciphersuites in this document share the same general structure for the premaster secret, which looks like this:
struct {
opaque other_secret<0..2^16-1>;
opaque psk<0..2^16-1>;
};Here "other_secret" is either zeroes (the plain PSK case) or comes from the Diffie-Hellman or RSA exchange (DHE_PSK and RSA_PSK, respectively). See Sections 3 and 4 for a more detailed description 💕
Note 2: Using zeroes for "other_secret" effectively means that only the HMAC-SHA1 part (but not the HMAC-MD5 part) of the TLS PRF is used when constructing the master secret. This was considered more elegant from an analytical viewpoint than, for instance, using the same key for both the HMAC-MD5 and HMAC-SHA1 parts. See [KRAWCZYK] for a more detailed rationale 🧐
The TLS handshake is authenticated using the Finished messages, as usual ✅
Last bit for this part 🫶 If the server doesn't recognize the PSK identity, it MAY respond with an "unknown_psk_identity" alert message. Or, if the server wants to hide the fact that the PSK identity wasn't known, it MAY keep going as if the PSK identity existed but the key was just incorrect. In other words, it responds with a decrypt_error alert 🙈
3. DHE_PSK Key Exchange Algorithm ✨
okay so this section is where the PSK stuff gets extra spicy 🌶️ these ciphersuites use a PSK to authenticate a Diffie-Hellman exchange, which gives you some extra protection against dictionary attacks AND Perfect Forward Secrecy (PFS) 🔐✨ no cap, this is the glow-up. see Section 7 for the security tea ☕
when these ciphersuites are in use, the ServerKeyExchange and ClientKeyExchange messages also carry the Diffie-Hellman parameters 🎀 the PSK identity and identity hint fields mean the same thing as in the last section (and rn it's giving "ServerKeyExchange is ALWAYS sent, even if there's no PSK identity hint" 🙈 so don't skip it bestie)
here's what those messages look like:
struct {
select (KeyExchangeAlgorithm) {
/* other cases for rsa, diffie_hellman, etc. */
case diffie_hellman_psk: /* NEW */
opaque psk_identity_hint<0..2^16-1>;
ServerDHParams params;
};
} ServerKeyExchange;
struct {
select (KeyExchangeAlgorithm) {
/* other cases for rsa, diffie_hellman, etc. */
case diffie_hellman_psk: /* NEW */
opaque psk_identity<0..2^16-1>;
ClientDiffieHellmanPublic public;
} exchange_keys;
} ClientKeyExchange;now the premaster secret, which is literally the main event 💅 first you do the Diffie-Hellman computation the same way every other Diffie-Hellman-based ciphersuite in [TLS] does it. call the result Z (leading zero bytes get stripped, same as always 🧹). then you concatenate: a uint16 holding the length of Z in octets, Z itself, a uint16 holding the length of the PSK in octets, and then the PSK itself. iconic structure, no notes 🦋
this lines up with the general premaster secret structure (see Note 1 in Section 2) with "other_secret" holding Z ✨
4. RSA_PSK Key Exchange Algorithm 🌸
the ciphersuites here use RSA and certificates to authenticate the server, PLUS they use a PSK. double the security, double the slay 👑
like normal RSA ciphersuites, the server must send a Certificate message. the ServerKeyExchange and ClientKeyExchange formats are below. if there's no PSK identity hint, the ServerKeyExchange message gets omitted 🫥
struct {
select (KeyExchangeAlgorithm) {
/* other cases for rsa, diffie_hellman, etc. */
case rsa_psk: /* NEW */
opaque psk_identity_hint<0..2^16-1>;
};
} ServerKeyExchange;
struct {
select (KeyExchangeAlgorithm) {
/* other cases for rsa, diffie_hellman, etc. */
case rsa_psk: /* NEW */
opaque psk_identity<0..2^16-1>;
EncryptedPreMasterSecret;
} exchange_keys;
} ClientKeyExchange;the EncryptedPreMasterSecret that the client sends to the server holds a 2-byte version number and a 46-byte random value. it's encrypted with the server's RSA public key, as described in Section 7.4.7.1 of [TLS] 🔐
to form the actual premaster secret, both parties do this: concatenate a uint16 with the value 48, the 2-byte version number and the 46-byte random value, a uint16 holding the length of the PSK in octets, and then the PSK itself. (so the premaster secret ends up 52 octets longer than the PSK, which is a fun little fact 🧚) this matches the general premaster structure (see Note 1 in Section 2) with "other_secret" holding both the version number and the random value 💜
now the tea ☕ neither the normal RSA ciphersuites nor these RSA_PSK ones say what the certificates contain (beyond the RSA public key), or how they get validated. so it's possible to use RSA_PSK with unvalidated self-signed certificates to get somewhat similar protection against dictionary attacks, the same way DHE_PSK does in Section 3. (not saying you SHOULD do this lol, just that it's technically a thing 🙈)
5. Conformance Requirements 📋
different apps running over TLS are gonna want different kinds of identities, so this document doesn't force any particular identity type (like an IPv4 address or a Fully Qualified Domain Name (FQDN)) 🦋
BUT the TLS client and server still have to agree on the identities and keys they're using 🤝 so to keep things interoperable, this document sets rules for how the identity gets encoded and what kinds of identities and keys implementations have to support.
the requirements are split into two categories: requirements for TLS implementations, and requirements for management interfaces. a "TLS implementation" is a TLS library or module meant to be used for lots of different purposes, while a "management interface" is usually built into a particular application that uses TLS 💅
this document doesn't spec how the server stores keys and identities, or how exactly it finds the key that matches the identity it gets. for example, if the identity is a domain name, a case-insensitive lookup might make sense. it is RECOMMENDED that the server processes the PSK identity with a stringprep profile [STRINGPREP] that fits the identity before looking up the key (like Nameprep [NAMEPREP] for parts of domain names, or SASLprep for usernames [SASLPREP]) ✨
5.1. PSK Identity Encoding 🔤
the PSK identity MUST first be converted to a character string, and then encoded to octets using UTF-8 [UTF8]. examples:
- IPv4 addresses get sent as dotted-decimal strings (e.g., "192.0.2.1"), NOT as 32-bit integers in network byte order 🙅♀️
- Domain names get sent in their usual text form [DNS] (e.g., "www.example.com" or "embedded.dot.example.net"), NOT in DNS protocol format 🌐
- X.500 Distinguished Names get sent in their string representation [LDAPDN], NOT as BER-encoded ASN.1 📜
ok this encoding isn't optimal for a lot of identity types, not gonna lie 😭 but it was chosen so implementations don't need identity-type-specific parsing and encoding code, since the identity is often configured by a person through some kind of management interface. requiring that type-specific code would also raise the odds of interop problems when different implementations support different identity types 💀
5.2. Identity Hint 🫧
unless an application profile spec says otherwise, servers SHOULD NOT provide an identity hint, and clients MUST ignore the identity hint field. apps that DO use this field MUST specify what its contents are, how the TLS server picks the value, and what the TLS client is expected to do with it 🎀
5.3. Requirements for TLS Implementations 🛠️
TLS implementations supporting these ciphersuites MUST support arbitrary PSK identities up to 128 octets in length, and arbitrary PSKs up to 64 octets in length. supporting longer identities and keys is RECOMMENDED 🌈
5.4. Requirements for Management Interfaces ⚙️
unless an application profile spec says otherwise, a management interface for entering the PSK and/or PSK identity MUST support the following:
- entering PSK identities made of up to 128 printable Unicode characters. supporting as wide a character repertoire, and as long identities, as feasible is RECOMMENDED 🌍
- entering PSKs up to 64 octets in length as ASCII strings AND in hexadecimal encoding 🔢
6. IANA Considerations 🗂️
IANA doesn't currently have a registry for TLS ciphersuite or alert numbers, so there are no IANA actions tied to this document 🙃
for easy reference later, here's a summary of the ciphersuite numbers defined in this document 💖
CipherSuite TLS_PSK_WITH_RC4_128_SHA = { 0x00, 0x8A };
CipherSuite TLS_PSK_WITH_3DES_EDE_CBC_SHA = { 0x00, 0x8B };
CipherSuite TLS_PSK_WITH_AES_128_CBC_SHA = { 0x00, 0x8C };
CipherSuite TLS_PSK_WITH_AES_256_CBC_SHA = { 0x00, 0x8D };
CipherSuite TLS_DHE_PSK_WITH_RC4_128_SHA = { 0x00, 0x8E };
CipherSuite TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA = { 0x00, 0x8F };
CipherSuite TLS_DHE_PSK_WITH_AES_128_CBC_SHA = { 0x00, 0x90 };
CipherSuite TLS_DHE_PSK_WITH_AES_256_CBC_SHA = { 0x00, 0x91 };
CipherSuite TLS_RSA_PSK_WITH_RC4_128_SHA = { 0x00, 0x92 };
CipherSuite TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA = { 0x00, 0x93 };
CipherSuite TLS_RSA_PSK_WITH_AES_128_CBC_SHA = { 0x00, 0x94 };
CipherSuite TLS_RSA_PSK_WITH_AES_256_CBC_SHA = { 0x00, 0x95 };this document also defines a brand new TLS alert message, unknown_psk_identity(115) 🚨
7. Security Considerations 🔐💀
okay this part is SERIOUS, bestie. as with ANY scheme that uses shared keys, you have to take special care to protect the shared values and limit how exposed they are over time 🫶
7.1. Perfect Forward Secrecy (PFS) 🕰️
the PSK and RSA_PSK ciphersuites in this document do NOT provide Perfect Forward Secrecy (PFS). so if the shared secret key (in PSK ciphersuites), or both the shared secret key AND the RSA private key (in RSA_PSK ciphersuites), gets compromised somehow, an attacker can decrypt old conversations 😱
the DHE_PSK ciphersuites DO provide PFS, as long as a fresh Diffie-Hellman private key is generated for each handshake ✨
7.2. Brute-Force and Dictionary Attacks 🎯
using a fixed shared secret with limited entropy is a big red flag 🚩 (think a PSK that's fairly short, or one a human picked, which may have less entropy than its length suggests). that can let an attacker run a brute-force or dictionary attack to recover the secret. it could be off-line (against captured TLS handshake messages) or on-line (where the attacker connects to the server and just tries different keys) 🙈
for the PSK ciphersuites, an attacker can grab what they need for an off-line attack by eavesdropping on a TLS handshake, or by getting a valid client to attempt a connection with the attacker. (like tricking the client into connecting to the wrong address, or intercepting a connection attempt to the correct address, for instance 👀)
for the DHE_PSK ciphersuites, an attacker can get the info by getting a valid client to attempt a connection with them. passive eavesdropping alone is NOT enough 🫣
for the RSA_PSK ciphersuites, only the server (authenticated using RSA and certificates) can get enough info for an off-line attack 🔒
it is RECOMMENDED that implementations letting the admin manually configure the PSK also offer a way to generate a new random PSK, taking [RANDOMNESS] into account 🎲✨
7.3. Identity Privacy 👀
the PSK identity is sent in cleartext 📢 using a user name or similar string as the identity is the most straightforward option, BUT it may cause problems in some environments, since an eavesdropper can figure out who the communicating parties are. even when the identity doesn't reveal anything by itself, reusing the same identity over time may eventually let an attacker do traffic analysis to identify the parties 🕵️♀️ fwiw this is no worse than client certificates, since those get sent in cleartext too 🫶
7.4. Implementation Notes 💅
okay bestie, quick one: the implementation notes in [TLS11] about doing RSA right (that's Section 7.4.7.1) and doing Diffie-Hellman right (that's Appendix F.1.1.3) apply to the DHE_PSK and RSA_PSK ciphersuites too 🔐✨ so go read those sections before you ship anything, no skipping!!
8. Acknowledgements 🫶
okay this protocol is heavily based on work by Tim Dierks and Peter Gutmann 🌸 it also borrows some text from [SHAREDKEYS] and [AES]. the DHE_PSK and RSA_PSK ciphersuites come from earlier work in [KEYEX] 💜
a huge thank you also to everyone who gave feedback: Bernard Aboba, Lakshminath Dondeti, Philip Ginzboorg, Peter Gutmann, Sam Hartman, Russ Housley, David Jablon, Nikos Mavroyanopoulos, Bodo Moeller, Eric Rescorla, and Mika Tervonen 👑🦋
and get this, when the first version was almost ready, the authors found out something similar had already been proposed back in 1996 [PASSAUTH] 😭 but this doc isn't meant for web password auth, it's for other uses of TLS 🧚
9.1. Normative References 📚
[AES] Chown, P., "Advanced Encryption Standard (AES)
Ciphersuites for Transport Layer Security (TLS)", RFC
3268, June 2002.
[KEYWORDS] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119, March 1997.
[RANDOMNESS] Eastlake, D., 3rd, Schiller, J., and S. Crocker,
"Randomness Requirements for Security", BCP 106, RFC
4086, June 2005.
[TLS] Dierks, T. and C. Allen, "The TLS Protocol Version 1.0",
RFC 2246, January 1999.
[UTF8] Yergeau, F., "UTF-8, a transformation format of ISO
10646", STD 63, RFC 3629, November 2003.9.2. Informative References 🍓
[DNS] Mockapetris, P., "Domain names - implementation and
specification", STD 13, RFC 1035, November 1987.
[KERB] Medvinsky, A. and M. Hur, "Addition of Kerberos Cipher
Suites to Transport Layer Security (TLS)", RFC 2712,
October 1999.
[KEYEX] Badra, M., Cherkaoui, O., Hajjeh, I. and A. Serhrouchni,
"Pre-Shared-Key key Exchange methods for TLS", Work in
Progress, August 2004.
[KRAWCZYK] Krawczyk, H., "Re: TLS shared keys PRF", message on
ietf-tls@lists.certicom.com mailing list 2004-01-13,
http://www.imc.org/ietf-tls/mail-archive/msg04098.html.
[LDAPDN] Zeilenga, K., "LDAP: String Representation of
Distinguished Names", Work in Progress, February 2005.
[NAMEPREP] Hoffman, P. and M. Blanchet, "Nameprep: A Stringprep
Profile for Internationalized Domain Names (IDN)", RFC
3491, March 2003.
[PASSAUTH] Simon, D., "Addition of Shared Key Authentication to
Transport Layer Security (TLS)", Work in Progress,
November 1996.
[SASLPREP] Zeilenga, K., "SASLprep: Stringprep Profile for User
Names and Passwords", RFC 4013, February 2005.
[SHAREDKEYS] Gutmann, P., "Use of Shared Keys in the TLS Protocol",
Work in Progress, October 2003.
[SRP] Taylor, D., Wu, T., Mavroyanopoulos, N. and T. Perrin,
"Using SRP for TLS Authentication", Work in Progress,
March 2005.
[STRINGPREP] Hoffman, P. and M. Blanchet, "Preparation of
Internationalized Strings ("stringprep")", RFC 3454,
December 2002.
[TLS11] Dierks, T. and E. Rescorla, "The TLS Protocol Version
1.1", Work in Progress, June 2005.Authors' and Contributors' Addresses 🌈
Pasi Eronen
Nokia Research Center
P.O. Box 407
FIN-00045 Nokia Group
Finland
EMail: pasi.eronen@nokia.com
Hannes Tschofenig
Siemens
Otto-Hahn-Ring 6
Munich, Bayern 81739
Germany
EMail: Hannes.Tschofenig@siemens.com
Mohamad Badra
ENST Paris
46 rue Barrault
75634 Paris
France
EMail: Mohamad.Badra@enst.fr
Omar Cherkaoui
UQAM University
Montreal (Quebec)
Canada
EMail: cherkaoui.omar@uqam.ca
Ibrahim Hajjeh
ESRGroups
17 passage Barrault
75013 Paris
France
EMail: Ibrahim.Hajjeh@esrgroups.org
Ahmed Serhrouchni
ENST Paris
46 rue Barrault
75634 Paris
France
EMail: Ahmed.Serhrouchni@enst.frFull Copyright Statement ⭐
Copyright (C) The Internet Society (2005).
this document is subject to the rights, licenses and restrictions in BCP 78, and except as stated there, the authors keep all their rights 💖
the document and everything in it is provided "AS IS", and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED. that includes (but isn't limited to) any warranty that using the info won't infringe anyone's rights, and any implied warranty of merchantability or fitness for a particular purpose 💀
Intellectual Property 🔮
the IETF doesn't take a position on whether any Intellectual Property Rights or other rights that might be claimed to cover the implementation or use of the technology in this document are valid or in scope, or whether any license under those rights might be available. it also doesn't claim it has made any independent effort to find such rights 🙈 info about how rights work for RFC documents is in BCP 78 and BCP 79 ✨
copies of IPR disclosures sent to the IETF Secretariat, any assurances of licenses that will be made available, and the results of any attempt to get a general license or permission to use those proprietary rights for implementers or users of this spec can be found in the IETF's online IPR repository at http://www.ietf.org/ipr 🦋
the IETF invites anyone who's interested to point out any copyrights, patents, patent applications, or other proprietary rights that might cover technology needed to implement this standard. send that info to the IETF at ietf-ipr@ietf.org 💌
Acknowledgement 🎀
Funding for the RFC Editor function is currently provided by the Internet Society. 🌸💅
📦 where this page comes from
- ietf: rfc4279 2005-12
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms