TL;DR
This paper introduces two novel mechanisms, "fast-track" and "client-side session caching" (CSSC), to improve the efficiency of TLS handshakes. Fast-track reduces network traffic and round trips by caching server parameters on the client, while CSSC shifts session caching responsibility to the client, allowing servers to handle more concurrent connections with less memory.
What Problem Does This Paper Address?
The Transport Layer Security (TLS) protocol is crucial for securing network traffic, but its handshake process can be computationally expensive and bandwidth-intensive. This is particularly problematic in high-latency environments like wireless networks. The standard TLS handshake involves a full exchange of information to establish a secure connection. While TLS offers session resumption to speed up subsequent connections, servers often have limited memory to store active sessions, leading to frequent full handshakes even for returning clients. This paper addresses these inefficiencies by proposing client-side caching mechanisms to reduce both network overhead and server memory burden.
Methods
The paper proposes two main mechanisms:
- Fast-Track: This mechanism allows clients to cache long-lived server parameters (like certificates, Diffie-Hellman groups, and preferred cipher suites) during an initial handshake. For subsequent handshakes, the client uses these cached parameters to construct its messages, effectively bypassing the "discovery" phase of the TLS handshake. This reduces the number of handshake flows from four to three and significantly cuts down on network traffic. Fast-track is negotiated via TLS extensions and is designed to be backward-compatible, falling back to a standard handshake if either party doesn't support it or if server configurations change.
- Client-Side Session Caching (CSSC): This mechanism addresses the server memory burden associated with session caching. Instead of the server storing session state, it encrypts this state into a "token" and sends it to the client. The client then stores this token and presents it to the server when attempting to resume a session. This token is authenticated using a MAC (Message Authentication Code) to ensure its integrity. CSSC requires modifications to the TLS handshake flow to accommodate the larger token size and ensure proper timing for authentication. It also introduces mechanisms for cache invalidation, using techniques like blacklists or Bloom filters.
Datasets
Not discussed in the paper. The paper focuses on protocol design and theoretical analysis, with performance measurements based on implementation rather than specific datasets.
Key Insights and Ideas
- Client-Side Caching is Versatile: The paper demonstrates that client-side caching is a powerful paradigm for rebalancing costs in security protocols, applicable to both bandwidth/latency issues (fast-track) and server memory constraints (CSSC).
- Leveraging Client Capabilities: The core idea is to leverage the fact that clients typically connect to a limited number of servers and can therefore afford to store more information than a server that handles many clients.
- Backward Compatibility is Key: Both proposed mechanisms are designed to be fully backward-compatible with existing TLS implementations, allowing for gradual deployment and interoperability.
- Trade-offs in Cache Invalidation: CSSC highlights the challenge of invalidating sessions when state is moved to the client. The paper explores various data structures (hash tables, bitmasks, Bloom filters) to manage invalidated sessions efficiently.
- Fast-Track for High-Latency, CSSC for High-Load: The paper clearly delineates the ideal use cases: fast-track excels in bandwidth-constrained, high-latency environments, while CSSC is best suited for servers facing high connection loads.
Key Results
- Fast-Track Performance: The fast-track mechanism can reduce handshake bytes sent by the client by up to 14% and by the server by up to 89%, leading to overall savings of up to 72% in bytes sent for certain cipher suites. It also reduces the number of handshake flows from four to three.
- CSSC Memory Savings: CSSC significantly reduces server memory consumption compared to traditional session caching. For example, with a session lifetime of 3600 seconds and 600 connections per second, CSSC with a Bloom filter can use as little as 25,879 bytes, compared to millions of bytes for a standard session cache.
- CSSC Performance Overhead: The performance overhead for CSSC (token decryption and MAC verification) is comparable to or better than the cost of locking a shared session cache on the server. For instance, token operations can be performed at a rate of millions per second.
Limitations and Future Work
- Formal Security Proofs: The paper acknowledges the difficulty of providing formal security proofs for fast-track due to the complexity of TLS and the reordering of messages. They rely on common arguments and the existing security of TLS mechanisms.
- Fast-Track RSA Export Authentication: Fast-track explicitly does not support RSA export authentication due to the frequent changes in temporary RSA keys, though this is noted as a minor constraint as RSA export is being phased out.
- Client Certificate Handling in CSSC: The paper notes that if CSSC tokens include client certificates, they might exceed the length of a standard TLS session ID, necessitating the use of an extended session ID extension.
- Potential for Timing Attacks in CSSC: While the paper argues that timing attacks on the master secret are not practical, it acknowledges that if sessions are not invalidated, an attacker might attempt to deduce information through timing signals.
- Future Work: The paper mentions that a prototype implementation of fast-track is available and an Internet Draft describing it exists. Further work could explore more sophisticated cache invalidation techniques for CSSC and more rigorous security analyses.
Summary updated