Re: [TLS] draft-ietf-tls-cached-info-02 / New "Fast-Track" draft

Brian Smith <> Tue, 23 February 2010 17:17 UTC

Return-Path: <>
Received: from localhost (localhost []) by (Postfix) with ESMTP id 07D473A830E for <>; Tue, 23 Feb 2010 09:17:52 -0800 (PST)
X-Virus-Scanned: amavisd-new at
X-Spam-Flag: NO
X-Spam-Score: -1.978
X-Spam-Status: No, score=-1.978 tagged_above=-999 required=5 tests=[AWL=0.620, BAYES_00=-2.599, HTML_MESSAGE=0.001]
Received: from ([]) by localhost ( []) (amavisd-new, port 10024) with ESMTP id WDpVmb3H1WaT for <>; Tue, 23 Feb 2010 09:17:51 -0800 (PST)
Received: from ( []) by (Postfix) with ESMTP id AA5D23A830D for <>; Tue, 23 Feb 2010 09:17:50 -0800 (PST)
Received: from [] (unknown []) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (No client certificate requested) by (Postfix) with ESMTPSA id DAABA509DD; Tue, 23 Feb 2010 12:19:52 -0500 (EST)
Message-ID: <>
Date: Tue, 23 Feb 2010 11:19:52 -0600
From: Brian Smith <>
User-Agent: Postbox 1.1.1 (Windows/20100208)
MIME-Version: 1.0
References: <>
In-Reply-To: <>
Content-Type: multipart/alternative; boundary="------------030706090008060908070208"
Subject: Re: [TLS] draft-ietf-tls-cached-info-02 / New "Fast-Track" draft
X-Mailman-Version: 2.1.9
Precedence: list
List-Id: "This is the mailing list for the Transport Layer Security working group of the IETF." <>
List-Unsubscribe: <>, <>
List-Archive: <>
List-Post: <>
List-Help: <>
List-Subscribe: <>, <>
X-List-Received-Date: Tue, 23 Feb 2010 17:17:52 -0000

Martin Rex wrote:
> Brian Smith wrote:
>> Perhaps this all can be avoided by simply not having the client
>> calculate hashes at all for . For example, would this work?:
>> struct {
>>       CachedInformationType type;
>>       opaque token<0..255>;
>> } CachedObject;
> I've been advocating the use of a hash value over the real data
> so that the handshake will do the right thing automatically if
> the data cached by the client and the data the server is going
> to return no longer match: the server is going to send the new
> data in full, and the client can update his cache.
> You definitely do not want a handshake failure (which always
> requires application involvement to recover from and a
> new connection) if the data cached by the client is out of
> sync with what the server wants to return.
This already happens with session resumption, when the server re-uses a 
session ID (so that the client's mapping of session ID -> session state 
doesn't match the server's mapping of session ID -> session state). The 
solution there was basically to tell the server "don't do that," and I 
think the same solution can be used here. That is why I suggested 
recommending the server to use a SHA-2 hash of the cached data.

> The client needs to be able to distinguish omitted handshake
> data (which he has cached) from new real data
I believe my proposed scheme already does this. If the client cached a 
zero-length string, he will have a non-zero-length token for it. If the 
server wants to send a new non-zero-length value for that cached item, 
then it would either send no token at all for that item (indicating that 
the new value can't be cached) or it would send a new token.
> and the server should not be forced to precompute all handshake
> messages when composing the server hello handshake message
> in order to confirm matches to the data that the client
> has indicated to have cached.
The items that are useful to be cached are all sent directly after the 
server hello (certificate, certificate request, and key exchange). 
There's nothing else that's large in the handshake. And, in practice, 
the server has to do this anyway if it supports session resumption. 
Regardless, it isn't a burden for the server anyway. Every time the 
server sends a new cachable item, it would calculate the token and cache it.

Regardless of the SHA1 issue, if the extension can be designed so that 
the client doesn't have to do any calculations in order to use the 
extension, that is a big win, because it makes the client much easier to 
implement and much simpler to maintain. It is much easier to perform 
maintenance on servers than on clients, especially clients that have 
their TLS implementation baked into firmware of consumer devices.