Re: [TLS] AD evaluation of draft-ietf-tls-ticketrequests-05

[Christopher Wood <[e-mail]>]

Thanks for the review, Ben! We addressed most of your comments here:

   https://github.com/tlswg/draft-ietf-tls-ticketrequest/pull/22

Please see inline below for followup responses specific points. If there are no objections, we'll spin a new version of the document when the submission system opens.

On Wed, Oct 28, 2020, at 3:27 PM, Benjamin Kaduk wrote:
> Section 2
> 
>    *  Connection priming: In some systems, connections can be primed or
>       bootstrapped by a centralized service or daemon for faster
>       connection establishment.  Requesting tickets on demand allows
>       such services to vend tickets to clients to use for accelerated
>       handshakes with early data.  (Note that if early data is not
>       needed by these connections, this method SHOULD NOT be used.
>       Fresh handshakes SHOULD be performed instead.)
> 
> This doesn't seem to paint a very clear picture of the use case.  It
> doesn't even seem to be clear about whether the "centralized service or
> daemon" is a helper on the TLS client or server side!
> I also want to check my understanding here, in that the recommendation
> for only doing this when early data is needed is due to the fact that
> you need to have an initial handshake with which to negotiate the
> ability to use early data in the subsequent handshake, and having the
> central service do a bunch of full handshakes just to get a ticket for
> use on a subsequent connection that does user early data is a lot of
> overhead, whereas if you don't need early data then you only do as many
> full handshakes as you need connections (vs 2x that number to get a
> ticket and then do early data) and get fully independent keys.  Since
> you have this central service the extra latency for a full handshake is
> irrelevant because you're priming connections in advance, not on-demand.

Describing this in more detail would lead to more text that probably just distracts from the document. To keep things simple, we just deleted this item, since there are plenty of motivating use cases already.

> 
>    *  Less ticket waste: Currently, TLS servers use application-
>       specific, and often implementation-specific, logic to determine
>       how many tickets to issue.  By moving the burden of ticket count
>       to clients, servers do not generate wasteful tickets.  As an
>       example, clients might only request one ticket during resumption.
>       Moreover, as ticket generation might involve expensive
>       computation, e.g., public key cryptographic operations, avoiding
>       waste is desirable.
> 
> (I assume we have a particular case in mind that does use public-key
> crypto when issuing a ticket, or we wouldn't have mentioned it.)

This just reflects the fact that ticket encryption is not required to be done with a symmetric key. Servers are free to choose any type of encryption. (We didn't change anything here.)

>    When a client presenting a previously obtained ticket finds that the
>    server nevertheless negotiates a fresh session, the client SHOULD
>    assume that any other tickets associated with the same session as the
>    presented ticket are also no longer valid for resumption.  This
> 
> Unfortunately, RFC 8446 does not seem to be consistent about "session"
> (persists across multiple resumption handshakes) vs "connection" (a
> single handshake) terminology.  We may want to consider just discussing
> "full handshake" and "initial full handshake" instead of trying to use
> the "session" shorthand.

We converged on "connection" to avoid confusion, since that seems to be the more natural term. 

>    and the number requested.  Servers MAY send additional tickets, up to
>    the same limit, if the tickets that are originally sent are somehow
>    invalidated.
> 
> (nit) pedantically, the server can send whatever tickets it likes
> whenever it likes.  The current "up to the same limit" looks a little
> bit like it's trying to restrict the server's behavior, so "typically
> using the same limit" might be better.
> 
>    Servers MUST NOT send the "ticket_request" extension in ServerHello
>    or HelloRetryRequest messages.  A client MUST abort the connection
>    with an "illegal_parameter" alert if the "ticket_request" extension
>    is present in either of these messages.
> 
> I note that we do have other messages (Certificate, CertificateRequest,
> NewSessionTicket itself, maybe soon ClientEncryptedExtensions) that can
> carry extensions, so in that sense it's strange to only explicitly
> prohibit these two.  That said, they are the two that would be most
> tempting to (inadvertently) put this extension in, so I don't
> particularly mind leaving it this way.

We clarified that it shouldn't be present in any handshake message.

Thanks again for the thorough and thoughtful review!

Best,
Chris