RFC 7924
Transport Layer Security (TLS) Cached Information Extension
Transport Layer Security (TLS) Cached Information Extension 💖 (RFC 7924)
- Authors: S. Santesson (3xA Security AB) and H. Tschofenig (ARM Ltd.) 👯
- Category: Standards Track 🛤️
- Date: July 2016 📅
- ISSN: 2070-1721
- Obsoletes / Updates: There's no Obsoletes or Updates line in the header, so this one doesn't replace or change any other RFC. 🧼
Abstract ✨
Okay so TLS handshakes keep sending the same boring stuff over and over, like the server certificate and the list of trusted CAs. 🙄 That info can be huge, especially when the server cert comes bundled with the whole chain (the intermediate CAs all the way up to the root CA). Bestie, that's a lot of bytes for no reason.
This document defines an extension that lets a TLS client tell the server what it already has cached, so the server can skip sending it again. 🦋
Status of This Memo 📜
This is an Internet Standards Track document. 🌟
This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community, received public review, and was approved for publication by the Internet Engineering Steering Group (IESG). For more on Internet Standards, check Section 2 of RFC 7841. 🎀
For info on the current status of this document, any errata, and how to send feedback, go to http://www.rfc-editor.org/info/rfc7924. 🔗
Copyright Notice ⚖️
Copyright (c) 2016 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) as they stand on the date of publication. Please read these carefully, because they spell out your rights and restrictions for this document. 📖 Code Components pulled out of this document must include Simplified BSD License text, as described in Section 4.e of the Trust Legal Provisions, and they come without warranty, as described in the Simplified BSD License. 💜
Table of Contents 🗂️
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3
2. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 3
3. Cached Information Extension . . . . . . . . . . . . . . . . 3
4. Exchange Specification . . . . . . . . . . . . . . . . . . . 5
4.1. Server Certificate Message . . . . . . . . . . . . . . . 6
4.2. CertificateRequest Message . . . . . . . . . . . . . . . 7
5. Fingerprint Calculation . . . . . . . . . . . . . . . . . . . 7
6. Example . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
7. Security Considerations . . . . . . . . . . . . . . . . . . . 10
8. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 10
8.1. New Entry to the TLS ExtensionType Registry . . . . . . . 10
8.2. New Registry for CachedInformationType . . . . . . . . . 11
9. References . . . . . . . . . . . . . . . . . . . . . . . . . 11
9.1. Normative References . . . . . . . . . . . . . . . . . . 11
9.2. Informative References . . . . . . . . . . . . . . . . . 12
Appendix A. Example . . . . . . . . . . . . . . . . . . . . . . 13
Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . 18
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . 191. Introduction 🦋
Okay, bestie, so cutting down the amount of info exchanged during a TLS handshake to the bare minimum makes things way faster in places where devices are on a slow, lossy radio network. 📉 Think Internet of Things stuff, like devices using IEEE 802.15.4, Bluetooth Low Energy, or low power wide area networks. If you want the full story on the challenges of smart object deployments, check out [RFC6574]. 🧚
This spec defines a TLS extension that lets a client and a server skip sending transmission info that was already cached during an earlier TLS handshake. 🫶
Here's a typical vibe check of how this goes down. First, the client and the server run the full TLS handshake. 🤝 The client then caches the certificate the server gave it. Later, when the client connects to that server again, without using session resumption, it attaches the "cached_info" extension defined in this document to its ClientHello. That tells the server, "hey, I've got this cert cached," and it includes the fingerprint of the cert. 🔑 If the server's certificate hasn't changed, the server doesn't need to send its certificate and the matching certificate chain again. 🙌 But if something changed, which the server can spot from the fingerprint the client sent, the certificate payload gets sent to the client so it can update its cache. 💅
2. Terminology 📚
The key words "MUST", "MUST NOT", "REQUIRED", "MUST", "MUST NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [RFC2119]. 🧠
This document talks about the TLS protocol, but everything in it applies just as well to Datagram Transport Layer Security (DTLS). 🌸
3. Cached Information Extension 🎀
This document defines a new extension type, cached_info(25), which shows up in ClientHello and ServerHello messages. ✨ The extension type is specified like this:
enum {
cached_info(25), (65535)
} ExtensionType;The extension_data field of this extension, when it's included in the ClientHello, MUST contain the CachedInformation structure. 🧁 The client MAY send multiple CachedObjects of the same CachedInformationType. This might happen, for example, when the client has cached several certificates from one server. 🍓
enum {
cert(1), cert_req(2) (255)
} CachedInformationType;
struct {
select (type) {
case client:
CachedInformationType type;
opaque hash_value<1..255>;
case server:
CachedInformationType type;
} body;
} CachedObject;
struct {
CachedObject cached_info<1..2^16-1>;
} CachedInformation;This document defines the following two types. 👑
The cert type is for not sending the complete server certificate message. 📜 With the type field set to cert, the client MUST include the fingerprint of the Certificate message in the hash_value field. For this type, the fingerprint MUST be calculated using the procedure described in Section 5 with the Certificate message as input data. 🔐
The cert_req type is for not sending the complete CertificateRequest message. 🙈 With the type set to cert_req, the client MUST include the fingerprint of the CertificateRequest message in the hash_value field. For this type, the fingerprint MUST be calculated using the procedure described in Section 5 with the CertificateRequest message as input data. 🫣
New cached info types can be added following the policy in the IANA Considerations (Section 8). 📋 New message digest algorithms can also be added for use with these types, by registering a new type that uses the updated digest algorithm. 🌈 For practical reasons, we recommend reusing hash algorithms that are already available with TLS ciphersuites, so you don't end up with extra code and the collision probability stays low. New hash algorithms MUST NOT have a collision resistance worse than SHA-256. 🚫
4. Exchange Specification 🤝
Clients that support this extension MAY include the "cached_info" extension in the (extended) ClientHello. If the client includes the extension, then it MUST contain one or more CachedObject attributes. 💜
A server that supports this extension MAY include the "cached_info" extension in the (extended) ServerHello. By returning the "cached_info" extension, the server says it supports the cached info types. For each cached info type it indicates, the server MUST alter the transmission of the respective payloads, according to the rules outlined with each type. If the server includes the extension, it MUST only include CachedObjects of a type that the client also supports (as expressed in the ClientHello). For example, if a client indicates support for 'cert' and 'cert_req', then the server can't respond with a "cached_info" attribute claiming support for ('foo-bar'). 🙅♀️
Since the client includes a fingerprint of the info it cached (for each indicated type), the server can figure out whether that cached info is stale. 🕵️♀️ If the server supports this specification and notices a mismatch between the data the client cached and its own info, then the server MUST include the information in full and MUST NOT list the respective type in the "cached_info" extension. 🚨
Note: If a server is part of a hosting environment, the client may have cached multiple data items for a single server. To let the client pick the right info out of the cache, it is RECOMMENDED that the client uses the Server Name Indication (SNI) extension [RFC6066]. 🏠✨
After a successful exchange of the "cached_info" extension in the ClientHello and ServerHello, the server changes how it sends the corresponding handshake message. 🔄 How the info is altered from the handshake messages, for the types defined in this specification, is covered in Sections 4.1 and 4.2, respectively. 💫
Appendix A shows an example hash calculation, and Section 6 illustrates an example protocol exchange. 🧩
4.1. Server Certificate Message
Okay so when a ClientHello has the "cached_info" extension with a type set to 'cert', the server MAY send the Certificate message from Figure 1 🦋 but only if ALL of these are true:
- The server software implements the
"cached_info"extension defined in this specification. 💅 - The
'cert'"cached_info"extension is enabled (for example, a policy allows the use of this extension). 🎀 - The server compared the value in the
hash_valuefield of the client-provided"cached_info"extension with the fingerprint of the Certificate message it normally sends to clients. This check makes sure the info the client cached is still current. The procedure for calculating the fingerprint is described in Section 5. 🔥
The original certificate handshake message syntax is defined in [RFC5246] and has been extended with [RFC7250]. RFC 7250 lets the certificate payload contain only the SubjectPublicKeyInfo instead of the full info you'd usually find in a certificate. 🌸 So when this specification is used together with [RFC7250] and the negotiated certificate type is a raw public key, the TLS server leaves out the certificate payload (the ASN.1 certificate structure with the included SubjectPublicKeyInfo) and skips the full certificate chain. Which means this extension is compatible with the raw public key extension from RFC 7250. ✨
Note: We assume that the server implementation is able to select the appropriate certificate or SubjectPublicKeyInfo from the received hash value. If the SNI extension is used by the client, then the server has additional information to guide the selection of the appropriate cached info. 🙈
When the cached info specification is used, a modified version of the Certificate message gets exchanged. Here's the modified structure:
struct {
opaque hash_value<1..255>;
} Certificate;Figure 1: Cached Info Certificate Message
4.2. CertificateRequest Message
When a fingerprint for an object of type 'cert_req' is provided in the ClientHello, the server MAY send the CertificateRequest message from Figure 2 under these conditions: 🧚
- The server software implements the
"cached_info"extension defined in this specification. - The
'cert_req'"cached_info"extension is enabled (for example, a policy allows the use of this extension). - The server compared the value in the
hash_valuefield of the client-provided"cached_info"extension with the fingerprint of the CertificateRequest message it normally sends to clients. This check makes sure the info the client cached is current. The procedure for calculating the fingerprint is described in Section 5. - The server wants to request a certificate from the client.
The original CertificateRequest handshake message syntax is defined in [RFC5246]. The modified CertificateRequest message structure is shown in Figure 2. 💜
struct {
opaque hash_value<1..255>;
} CertificateRequest;Figure 2: Cached Info CertificateRequest Message
The CertificateRequest payload is the input parameter to the fingerprint calculation described in Section 5. 🫶
5. Fingerprint Calculation 🔥
The fingerprint for the two cached info objects defined in this document MUST be computed as follows:
- Compute the SHA-256 [RFC6234] hash of the input data. The input data depends on the cached info type. This document defines two cached info types, described in Sections 4.1 and in 4.2. Heads up: the computed hash only covers the input data structure (and not any type and length information of the record layer). Appendix A shows an example. 👑
- Use the output of the SHA-256 hash.
The whole point of the fingerprint the client sends is to help the server pick the correct information. For example, with a Certificate message, the fingerprint identifies the server certificate (and the matching private key) to use for the rest of the handshake. 🌈 Servers may have more than one certificate, so the hash needs to be long enough to keep the probability of hash collisions low. BUT the cached info design is all about cutting down how much data gets exchanged, so the security of the handshake depends on the private key and NOT on the size of the fingerprint. 💅 Basically, the fingerprint is a way to stop the server from accidentally grabbing the wrong info.
If an attacker injects an incorrect fingerprint, two things can happen: (1) the fingerprint doesn't relate to any cached state and the server has to fall back to a full exchange, or (2) if the attacker manages to inject a fingerprint that refers to data the client has NOT cached, the exchange fails later when the client continues the handshake and tries to verify the digital signature. 😭 That signature verification fails because the public key cached by the client won't match the private key the server used to sign the message.
6. Example ✨
In the regular, full TLS handshake exchange shown in Figure 3, the TLS server gives its certificate to the client in the certificate payload; see step (1). That lets the client store the certificate for later. 🎀 After some time, the TLS client talks to the same TLS server again and uses the TLS "cached_info" extension, as shown in Figure 4. The TLS client signals support for this specification via the "cached_info" extension (step (2)) and says it has stored the certificate from the earlier exchange by indicating the 'cert' type. 🦋 In step (3), the TLS server acknowledges the 'cert' type, and by including the value in the ServerHello, it tells the client that the certificate payload now holds the fingerprint of the certificate instead of the payload defined for the Certificate message in RFC 5246; see step (4). 🧚
ClientHello ->
<- ServerHello
Certificate* // (1)
ServerKeyExchange*
CertificateRequest*
ServerHelloDone
Certificate*
ClientKeyExchange
CertificateVerify*
[ChangeCipherSpec]
Finished ->
<- [ChangeCipherSpec]
Finished
Application Data <-------> Application DataFigure 3: Example Message Exchange: Initial (Full) Exchange
ClientHello
cached_info=(cert) -> // (2)
<- ServerHello
cached_info=(cert) (3)
Certificate (4)
ServerKeyExchange*
ServerHelloDone
ClientKeyExchange
CertificateVerify*
[ChangeCipherSpec]
Finished ->
<- [ChangeCipherSpec]
Finished
Application Data <-------> Application DataFigure 4: Example Message Exchange: TLS Cached Extension Usage
7. Security Considerations 🔐
This specification defines a mechanism to reference stored state using a fingerprint. Sending a fingerprint of cached information in an unencrypted handshake, as the ClientHello and ServerHello do, may let an attacker or observer correlate independent TLS exchanges. 👀 Some info elements used in this specification, like server certificates, are public objects and usually don't contain sensitive info, but other types that aren't defined yet might. So anyone who implements and deploys this specification should make an informed decision about whether the cached information lines up with their security and privacy goals. If there are concerns, it's advised to avoid sending the fingerprint of the data objects in the clear. 💀
Using the "cached_info" extension lets the server send significantly smaller TLS messages. As a result, the omitted parts of the messages are NOT included in the handshake transcript used in the TLS Finish message. However, since the client and server communicate the hash values of the cached data in the initial handshake messages, the fingerprints ARE included in the TLS Finish message. 🧠
Clients MUST ensure that they only cache information from legitimate sources. For example, when the client populates the cache from a TLS exchange, it must only cache information after the successful completion of that TLS exchange, so an attacker can't inject incorrect information into the cache. Failing to do this allows man-in-the-middle attacks. 🚨
Security considerations for the fingerprint calculation are discussed in Section 5. 🌸
8. IANA Considerations 🌷
8.1. New Entry to the TLS ExtensionType Registry
IANA has added an entry to the existing TLS "ExtensionType Values" registry, defined in [RFC5246], for cached_info(25) defined in this document. 🍓
8.2. New Registry for CachedInformationType
IANA has established a registry titled "TLS CachedInformationType Values". The entries in the registry are:
Value Description
----- -----------
0 Reserved
1 cert
2 cert_req
224-255 Reserved for Private UseThe policy for adding new values to this registry, following the terminology defined in [RFC5226], is as follows:
- 0-63 (decimal): Standards Action
- 64-223 (decimal): Specification Required
9. References 📚
9.1. Normative References
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, March 1997, <http://www.rfc-editor.org/info/rfc2119>.
[RFC5246] Dierks, T. and E. Rescorla, "The Transport Layer Security (TLS) Protocol Version 1.2", RFC 5246, DOI 10.17487/RFC5246, August 2008, <http://www.rfc-editor.org/info/rfc5246>.
[RFC6066] Eastlake 3rd, D., "Transport Layer Security (TLS) Extensions: Extension Definitions", RFC 6066, DOI 10.17487/RFC6066, January 2011, <http://www.rfc-editor.org/info/rfc6066>.
[RFC6234] Eastlake 3rd, D. and T. Hansen, "US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF)", RFC 6234, DOI 10.17487/RFC6234, May 2011, <http://www.rfc-editor.org/info/rfc6234>.
9.2. Informative References
[ASN.1-Dump] Gutmann, P., "ASN.1 Object Dump Program", November 2010, <http://manpages.ubuntu.com/manpages/precise/man1/dumpasn1.1.html>.
[RFC5226] Narten, T. and H. Alvestrand, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 5226, DOI 10.17487/RFC5226, May 2008, <http://www.rfc-editor.org/info/rfc5226>.
[RFC6574] Tschofenig, H. and J. Arkko, "Report from the Smart Object Workshop", RFC 6574, DOI 10.17487/RFC6574, April 2012, <http://www.rfc-editor.org/info/rfc6574>.
[RFC7250] Wouters, P., Ed., Tschofenig, H., Ed., Gilmore, J., Weiler, S., and T. Kivinen, "Using Raw Public Keys in Transport Layer Security (TLS) and Datagram Transport Layer Security (DTLS)", RFC 7250, DOI 10.17487/RFC7250, June 2014, <http://www.rfc-editor.org/info/rfc7250>. 💖
Appendix A. Example ✨
okay bestie, this is the part where we get to see a real certificate, and it's giving pure eye candy 🎀. The example uses a NIST P256 elliptic curve public key, and we're reading it with Peter Gutmann's ASN.1 decoder [ASN.1-Dump]. Here's the whole thing in Figure 5 💅.
0 556: SEQUENCE {
4 434: SEQUENCE {
8 3: [0] {
10 1: INTEGER 2
: }
13 1: INTEGER 13
16 10: SEQUENCE {
18 8: OBJECT IDENTIFIER ecdsaWithSHA256 (1 2 840 10045 4 3 2)
: }
28 62: SEQUENCE {
30 11: SET {
32 9: SEQUENCE {
34 3: OBJECT IDENTIFIER countryName (2 5 4 6)
39 2: PrintableString 'NL'
: }
: }
43 17: SET {
45 15: SEQUENCE {
47 3: OBJECT IDENTIFIER organizationName (2 5 4 10)
52 8: PrintableString 'PolarSSL'
: }
: }
62 28: SET {
64 26: SEQUENCE {
66 3: OBJECT IDENTIFIER commonName (2 5 4 3)
71 19: PrintableString 'Polarssl Test EC CA'
: }
: }
: }
92 30: SEQUENCE {
94 13: UTCTime 24/09/2013 15:52:04 GMT
109 13: UTCTime 22/09/2023 15:52:04 GMT
: }
124 65: SEQUENCE {
126 11: SET {
128 9: SEQUENCE {
130 3: OBJECT IDENTIFIER countryName (2 5 4 6)
135 2: PrintableString 'NL'
: }
: }
139 17: SET {
141 15: SEQUENCE {
143 3: OBJECT IDENTIFIER organizationName (2 5 4 10)
148 8: PrintableString 'PolarSSL'
: }
: }
158 31: SET {
160 29: SEQUENCE {
162 3: OBJECT IDENTIFIER commonName (2 5 4 3)
167 22: PrintableString 'PolarSSL Test Client 2'
: }
: }
: }
191 89: SEQUENCE {
193 19: SEQUENCE {
195 7: OBJECT IDENTIFIER ecPublicKey (1 2 840 10045 2 1)
204 8: OBJECT IDENTIFIER prime256v1 (1 2 840 10045 3 1 7)
: }
214 66: BIT STRING
: 04 57 E5 AE B1 73 DF D3 AC BB 93 B8 81 FF 12 AE
: EE E6 53 AC CE 55 53 F6 34 0E CC 2E E3 63 25 0B
: DF 98 E2 F3 5C 60 36 96 C0 D5 18 14 70 E5 7F 9F
: D5 4B 45 18 E5 B0 6C D5 5C F8 96 8F 87 70 A3 E4
: C7
: }
282 157: [3] {
285 154: SEQUENCE {
288 9: SEQUENCE {
290 3: OBJECT IDENTIFIER basicConstraints (2 5 29 19)
295 2: OCTET STRING, encapsulates {
297 0: SEQUENCE {}
: }
: }
299 29: SEQUENCE {
301 3: OBJECT IDENTIFIER subjectKeyIdentifier (2 5 29 14)
306 22: OCTET STRING, encapsulates {
308 20: OCTET STRING
: 7A 00 5F 86 64 FC E0 5D E5 11 10 3B B2 E6 3B C4
: 26 3F CF E2
: }
: }
330 110: SEQUENCE {
332 3: OBJECT IDENTIFIER authorityKeyIdentifier (2 5 29 35)
337 103: OCTET STRING, encapsulates {
339 101: SEQUENCE {
341 20: [0]
: 9D 6D 20 24 49 01 3F 2B CB 78 B5 19 BC 7E 24
: C9 DB FB 36 7C
363 66: [1] {
365 64: [4] {
367 62: SEQUENCE {
369 11: SET {
371 9: SEQUENCE {
373 3: OBJECT IDENTIFIER countryName (2 5 4 6)
378 2: PrintableString 'NL'
: }
: }
382 17: SET {
384 15: SEQUENCE {
386 3: OBJECT IDENTIFIER organizationName
: (2 5 4 10)
391 8: PrintableString 'PolarSSL'
: }
: }
401 28: SET {
403 26: SEQUENCE {
405 3: OBJECT IDENTIFIER commonName (2 5 4 3)
410 19: PrintableString 'Polarssl Test EC CA'
: }
: }
: }
: }
: }
431 9: [2] 00 C1 43 E2 7E 62 43 CC E8
: }
: }
: }
: }
: }
: }
442 10: SEQUENCE {
444 8: OBJECT IDENTIFIER ecdsaWithSHA256 (1 2 840 10045 4 3 2)
: }
454 104: BIT STRING, encapsulates {
457 101: SEQUENCE {
459 48: INTEGER
: 4A 65 0D 7B 20 83 A2 99 B9 A8 0F FC 8D EE 8F 3D
: BB 70 4C 96 03 AC 8E 78 70 DD F2 0E A0 B2 16 CB
: 65 8E 1A C9 3F 2C 61 7E F8 3C EF AD 1C EE 36 20
509 49: INTEGER
: 00 9D F2 27 A6 D5 74 B8 24 AE E1 6A 3F 31 A1 CA
: 54 2F 08 D0 8D EE 4F 0C 61 DF 77 78 7D B4 FD FC
: 42 49 EE E5 B2 6A C2 CD 26 77 62 8E 28 7C 9E 57
: 45
: }
: }
: }Figure 5: ASN.1-Based Certificate: Example
To put the Figure 5 certificate into a TLS/DTLS Certificate message, we stick a message header on the front 🦋. In our example that header is 0b 00 02 36 00 02 33 00 02 00 02 30, and here's what each bit says:
- Message Type:
0b, a 1-byte type field saying this is a Certificate message - Length:
00 02 36, a 3-byte length field saying the payload is 566 bytes - Certificates Length:
00 02 33, a 3-byte length field saying the entire certificates_list structure is 563 bytes. It may hold multiple certificates, but in our example only one is included. - Certificate Length:
00 02 30, a 3-byte length field saying the actual certificate right after it is 560 bytes. In our example that's the certificate content starting with30 82 02 ....and ending with9E 57 45, which you can see in Figure 6 🧚.
The hex encoding of the ASN.1-encoded certificate from Figure 5 looks like this:
30 82 02 2C 30 82 01 B2 A0 03 02 01 02 02 01 0D
30 0A 06 08 2A 86 48 CE 3D 04 03 02 30 3E 31 0B
30 09 06 03 55 04 06 13 02 4E 4C 31 11 30 0F 06
03 55 04 0A 13 08 50 6F 6C 61 72 53 53 4C 31 1C
30 1A 06 03 55 04 03 13 13 50 6F 6C 61 72 73 73
6C 20 54 65 73 74 20 45 43 20 43 41 30 1E 17 0D
31 33 30 39 32 34 31 35 35 32 30 34 5A 17 0D 32
33 30 39 32 32 31 35 35 32 30 34 5A 30 41 31 0B
30 09 06 03 55 04 06 13 02 4E 4C 31 11 30 0F 06
03 55 04 0A 13 08 50 6F 6C 61 72 53 53 4C 31 1F
30 1D 06 03 55 04 03 13 16 50 6F 6C 61 72 53 53
4C 20 54 65 73 74 20 43 6C 69 65 6E 74 20 32 30
59 30 13 06 07 2A 86 48 CE 3D 02 01 06 08 2A 86
48 CE 3D 03 01 07 03 42 00 04 57 E5 AE B1 73 DF
D3 AC BB 93 B8 81 FF 12 AE EE E6 53 AC CE 55 53
F6 34 0E CC 2E E3 63 25 0B DF 98 E2 F3 5C 60 36
96 C0 D5 18 14 70 E5 7F 9F D5 4B 45 18 E5 B0 6C
D5 5C F8 96 8F 87 70 A3 E4 C7 A3 81 9D 30 81 9A
30 09 06 03 55 1D 13 04 02 30 00 30 1D 06 03 55
1D 0E 04 16 04 14 7A 00 5F 86 64 FC E0 5D E5 11
10 3B B2 E6 3B C4 26 3F CF E2 30 6E 06 03 55 1D
23 04 67 30 65 80 14 9D 6D 20 24 49 01 3F 2B CB
78 B5 19 BC 7E 24 C9 DB FB 36 7C A1 42 A4 40 30
3E 31 0B 30 09 06 03 55 04 06 13 02 4E 4C 31 11
30 0F 06 03 55 04 0A 13 08 50 6F 6C 61 72 53 53
4C 31 1C 30 1A 06 03 55 04 03 13 13 50 6F 6C 61
72 73 73 6C 20 54 65 73 74 20 45 43 20 43 41 82
09 00 C1 43 E2 7E 62 43 CC E8 30 0A 06 08 2A 86
48 CE 3D 04 03 02 03 68 00 30 65 02 30 4A 65 0D
7B 20 83 A2 99 B9 A8 0F FC 8D EE 8F 3D BB 70 4C
96 03 AC 8E 78 70 DD F2 0E A0 B2 16 CB 65 8E 1A
C9 3F 2C 61 7E F8 3C EF AD 1C EE 36 20 02 31 00
9D F2 27 A6 D5 74 B8 24 AE E1 6A 3F 31 A1 CA 54
2F 08 D0 8D EE 4F 0C 61 DF 77 78 7D B4 FD FC 42
49 EE E5 B2 6A C2 CD 26 77 62 8E 28 7C 9E 57 45Figure 6: Hex Encoding of the Example Certificate
Last step: we run SHA-256 over the Certificate message, the bit that starts with 0b 00 02 and ends with 9E 57 45, and get the fingerprint 0x086eefb4859adfe977defac494fff6b73033b4ce1f86b8f2a9fc0c6bf98605af 🔥. Ta-da, that's the example, bestie 💜.
Acknowledgments 🫶
We would like to thank the following persons for your detailed document reviews:
- Paul Wouters and Nikos Mavrogiannopoulos (December 2011)
- Rob Stradling (February 2012)
- Ondrej Mikle (March 2012)
- Ilari Liusvaara, Adam Langley, and Eric Rescorla (July 2014)
- Sean Turner (August 2014)
- Martin Thomson (August 2015)
- Jouni Korhonen (November 2015)
- Dave Garrett (December 2015)
- Matt Miller (December 2015)
- Anirudh Ramachandran (March 2016)
We would also like to thank Martin Thomson, Karthikeyan Bhargavan, Sankalp Bagaria, and Eric Rescorla for their feedback regarding the fingerprint calculation.
Finally, we would like to thank the TLS working group chairs, Sean Turner and Joe Salowey, as well as the responsible Security Area Director, Stephen Farrell, for their support and their reviews 👑. The whole crew is iconic.
Authors' Addresses 🦋
Stefan Santesson
3xA Security AB
Forskningsbyn Ideon
Lund 223 70
Sweden
Email: sts@aaa-sec.comHannes Tschofenig
ARM Ltd.
Hall in Tirol 6060
Austria
Email: Hannes.tschofenig@gmx.net
URI: http://www.tschofenig.priv.at📦 where this page comes from
- ietf: rfc7924 2016-07
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms