0b82ad7ea7eff2f1c54f3e4219f061194d1a2b89
[openssl.git] / ssl / statem / extensions.c
1 /*
2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdlib.h>
11 #include "../ssl_locl.h"
12 #include "statem_locl.h"
13
14 typedef struct {
15     /* The ID for the extension */
16     unsigned int type;
17     int (*server_parse)(SSL *s, PACKET *pkt, int *al);
18     int (*client_parse)(SSL *s, PACKET *pkt, int *al);
19     int (*server_construct)(SSL *s, WPACKET *pkt, int *al);
20     int (*client_construct)(SSL *s, WPACKET *pkt, int *al);
21     unsigned int context;
22 } EXTENSION_DEFINITION;
23
24 /*
25  * TODO(TLS1.3): Temporarily modified the definitions below to put all TLS1.3
26  * extensions in the ServerHello for now. That needs to be put back to correct
27  * setting once encrypted extensions is working properly.
28  */
29 static const EXTENSION_DEFINITION ext_defs[] = {
30     {
31         TLSEXT_TYPE_renegotiate,
32         tls_parse_clienthello_renegotiate,
33         NULL,
34         tls_construct_server_renegotiate,
35         NULL,
36         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_SSL3_ALLOWED
37         | EXT_TLS1_2_AND_BELOW_ONLY
38     },
39     {
40         TLSEXT_TYPE_server_name,
41         tls_parse_clienthello_server_name,
42         NULL,
43         tls_construct_server_server_name,
44         NULL,
45         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
46         | /*EXT_TLS1_3_ENCRYPTED_EXTENSIONS*/EXT_TLS1_3_SERVER_HELLO
47     },
48 #ifndef OPENSSL_NO_SRP
49     {
50         TLSEXT_TYPE_srp,
51         tls_parse_clienthello_srp,
52         NULL,
53         NULL,
54         NULL,
55         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
56     },
57 #endif
58 #ifndef OPENSSL_NO_EC
59     {
60         TLSEXT_TYPE_ec_point_formats,
61         tls_parse_clienthello_ec_pt_formats,
62         NULL,
63         tls_construct_server_ec_pt_formats,
64         NULL,
65         EXT_CLIENT_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
66     },
67     {
68         TLSEXT_TYPE_supported_groups,
69         tls_parse_clienthello_supported_groups,
70         NULL,
71         NULL /* TODO(TLS1.3): Need to add this */,
72         NULL,
73         EXT_CLIENT_HELLO
74         | /*EXT_TLS1_3_ENCRYPTED_EXTENSIONS*/EXT_TLS1_3_SERVER_HELLO
75     },
76 #endif
77     {
78         TLSEXT_TYPE_session_ticket,
79         tls_parse_clienthello_session_ticket,
80         NULL,
81         tls_construct_server_session_ticket,
82         NULL,
83         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
84     },
85     {
86         TLSEXT_TYPE_signature_algorithms,
87         tls_parse_clienthello_sig_algs,
88         NULL,
89         NULL,
90         NULL,
91         EXT_CLIENT_HELLO
92     },
93     {
94         TLSEXT_TYPE_status_request,
95         tls_parse_clienthello_status_request,
96         NULL,
97         tls_construct_server_status_request,
98         NULL,
99         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
100         | /*EXT_TLS1_3_CERTIFICATE*/EXT_TLS1_3_SERVER_HELLO
101     },
102 #ifndef OPENSSL_NO_NEXTPROTONEG
103     {
104         TLSEXT_TYPE_next_proto_neg,
105         tls_parse_clienthello_npn,
106         NULL,
107         tls_construct_server_next_proto_neg,
108         NULL,
109         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
110     },
111 #endif
112     {
113         TLSEXT_TYPE_application_layer_protocol_negotiation,
114         tls_parse_clienthello_alpn,
115         NULL,
116         tls_construct_server_alpn,
117         NULL,
118         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
119         | /*EXT_TLS1_3_ENCRYPTED_EXTENSIONS*/EXT_TLS1_3_SERVER_HELLO
120     },
121 #ifndef OPENSSL_NO_SRTP
122     {
123         TLSEXT_TYPE_use_srtp,
124         tls_parse_clienthello_use_srtp,
125         NULL,
126         tls_construct_server_use_srtp,
127         NULL,
128         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
129         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS | EXT_DTLS_ONLY
130     },
131 #endif
132     {
133         TLSEXT_TYPE_encrypt_then_mac,
134         tls_parse_clienthello_etm,
135         NULL,
136         tls_construct_server_etm,
137         NULL,
138         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
139     },
140     {
141         TLSEXT_TYPE_signed_certificate_timestamp,
142         /*
143          * No server side support for this, but can be provided by a custom
144          * extension. This is an exception to the rule that custom extensions
145          * cannot override built in ones.
146          */
147         NULL,
148         NULL,
149         NULL,
150         NULL,
151         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
152         | /*EXT_TLS1_3_CERTIFICATE*/EXT_TLS1_3_SERVER_HELLO
153     },
154     {
155         TLSEXT_TYPE_extended_master_secret,
156         tls_parse_clienthello_ems,
157         NULL,
158         tls_construct_server_ems,
159         NULL,
160         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
161     },
162     {
163         TLSEXT_TYPE_supported_versions,
164         /* Processed inline as part of version selection */
165         NULL,
166         NULL,
167         NULL,
168         NULL,
169         EXT_CLIENT_HELLO | EXT_TLS_IMPLEMENTATION_ONLY
170     },
171     {
172         TLSEXT_TYPE_padding,
173         /* We send this, but don't read it */
174         NULL,
175         NULL,
176         NULL,
177         NULL,
178         EXT_CLIENT_HELLO
179     },
180     {
181         TLSEXT_TYPE_key_share,
182         tls_parse_clienthello_key_share,
183         NULL,
184         tls_construct_server_key_share,
185         NULL,
186         EXT_CLIENT_HELLO | EXT_TLS1_3_SERVER_HELLO
187         | EXT_TLS1_3_HELLO_RETRY_REQUEST | EXT_TLS_IMPLEMENTATION_ONLY
188         | EXT_TLS1_3_ONLY
189     },
190     {
191         /*
192          * Special unsolicited ServerHello extension only used when
193          * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set
194          */
195         TLSEXT_TYPE_cryptopro_bug,
196         NULL,
197         NULL,
198         tls_construct_server_cryptopro_bug,
199         NULL,
200         EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
201     }
202 };
203
204 /*
205  * Comparison function used in a call to qsort (see tls_collect_extensions()
206  * below.)
207  * The two arguments |p1| and |p2| are expected to be pointers to RAW_EXTENSIONs
208  *
209  * Returns:
210  *  1 if the type for p1 is greater than p2
211  *  0 if the type for p1 and p2 are the same
212  * -1 if the type for p1 is less than p2
213  */
214 static int compare_extensions(const void *p1, const void *p2)
215 {
216     const RAW_EXTENSION *e1 = (const RAW_EXTENSION *)p1;
217     const RAW_EXTENSION *e2 = (const RAW_EXTENSION *)p2;
218
219     if (e1->type < e2->type)
220         return -1;
221     else if (e1->type > e2->type)
222         return 1;
223
224     return 0;
225 }
226
227 /*
228  * Verify whether we are allowed to use the extension |type| in the current
229  * |context|. Returns 1 to indicate the extension is allowed or unknown or 0 to
230  * indicate the extension is not allowed.
231  */
232 static int verify_extension(SSL *s, unsigned int context, unsigned int type)
233 {
234     size_t i;
235
236     for (i = 0; i < OSSL_NELEM(ext_defs); i++) {
237         if (type == ext_defs[i].type) {
238             /* Check we're allowed to use this extension in this context */
239             if ((context & ext_defs[i].context) == 0)
240                 return 0;
241
242             if (SSL_IS_DTLS(s)) {
243                 if ((ext_defs[i].context & EXT_TLS_ONLY) != 0)
244                     return 0;
245             } else if ((ext_defs[i].context & EXT_DTLS_ONLY) != 0) {
246                     return 0;
247             }
248
249             return 1;
250         }
251     }
252
253     /* Unknown extension. We allow it */
254     return 1;
255 }
256
257 /*
258  * Finds an extension definition for the give extension |type|.
259  * Returns 1 if found and stores the definition in |*def|, or returns 0
260  * otherwise.
261  */
262 static int find_extension_definition(SSL *s, unsigned int type,
263                                      const EXTENSION_DEFINITION **def)
264 {
265     size_t i;
266
267     for (i = 0; i < OSSL_NELEM(ext_defs); i++) {
268         if (type == ext_defs[i].type) {
269             *def = &ext_defs[i];
270             return 1;
271         }
272     }
273
274     /* Unknown extension */
275     return 0;
276 }
277
278 /*
279  * Gather a list of all the extensions from the data in |packet]. |context|
280  * tells us which message this extension is for. The raw extension data is
281  * stored in |*res| with the number of found extensions in |*numfound|. In the
282  * event of an error the alert type to use is stored in |*ad|. We don't actually
283  * process the content of the extensions yet, except to check their types.
284  *
285  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
286  * more than one extension of the same type in a ClientHello or ServerHello.
287  * This function returns 1 if all extensions are unique and we have parsed their
288  * types, and 0 if the extensions contain duplicates, could not be successfully
289  * parsed, or an internal error occurred.
290  */
291 /*
292  * TODO(TLS1.3): Refactor ServerHello extension parsing to use this and then
293  * remove tls1_check_duplicate_extensions()
294  */
295 int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
296                            RAW_EXTENSION **res, size_t *numfound, int *ad)
297 {
298     PACKET extensions = *packet;
299     size_t num_extensions = 0, i = 0;
300     RAW_EXTENSION *raw_extensions = NULL;
301
302     /* First pass: count the extensions. */
303     while (PACKET_remaining(&extensions) > 0) {
304         unsigned int type;
305         PACKET extension;
306
307         if (!PACKET_get_net_2(&extensions, &type) ||
308             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
309             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
310             *ad = SSL_AD_DECODE_ERROR;
311             goto err;
312         }
313         /* Verify this extension is allowed */
314         if (!verify_extension(s, context, type)) {
315             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
316             *ad = SSL_AD_ILLEGAL_PARAMETER;
317             goto err;
318         }
319         num_extensions++;
320     }
321
322     if (num_extensions > 0) {
323         raw_extensions = OPENSSL_zalloc(sizeof(*raw_extensions)
324                                         * num_extensions);
325         if (raw_extensions == NULL) {
326             *ad = SSL_AD_INTERNAL_ERROR;
327             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, ERR_R_MALLOC_FAILURE);
328             goto err;
329         }
330
331         /* Second pass: collect the extensions. */
332         for (i = 0; i < num_extensions; i++) {
333             if (!PACKET_get_net_2(packet, &raw_extensions[i].type) ||
334                 !PACKET_get_length_prefixed_2(packet,
335                                               &raw_extensions[i].data)) {
336                 /* This should not happen. */
337                 *ad = SSL_AD_INTERNAL_ERROR;
338                 SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
339                 goto err;
340             }
341         }
342
343         if (PACKET_remaining(packet) != 0) {
344             *ad = SSL_AD_DECODE_ERROR;
345             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_LENGTH_MISMATCH);
346             goto err;
347         }
348         /* Sort the extensions and make sure there are no duplicates. */
349         qsort(raw_extensions, num_extensions, sizeof(*raw_extensions),
350               compare_extensions);
351         for (i = 1; i < num_extensions; i++) {
352             if (raw_extensions[i - 1].type == raw_extensions[i].type) {
353                 *ad = SSL_AD_DECODE_ERROR;
354                 goto err;
355             }
356         }
357     }
358
359     *res = raw_extensions;
360     *numfound = num_extensions;
361     return 1;
362
363  err:
364     OPENSSL_free(raw_extensions);
365     return 0;
366 }
367
368 int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts,
369                              size_t numexts, int *al)
370 {
371     size_t loop;
372
373     for (loop = 0; loop < numexts; loop++) {
374         RAW_EXTENSION *currext = &exts[loop];
375         const EXTENSION_DEFINITION *extdef = NULL;
376         int (*parser)(SSL *s, PACKET *pkt, int *al) = NULL;
377
378         if (s->tlsext_debug_cb)
379             s->tlsext_debug_cb(s, 0, currext->type,
380                                PACKET_data(&currext->data),
381                                PACKET_remaining(&currext->data),
382                                s->tlsext_debug_arg);
383
384         /* Skip if we've already parsed this extension */
385         if (currext->parsed)
386             continue;
387
388         currext->parsed = 1;
389
390         parser = NULL;
391         if (find_extension_definition(s, currext->type, &extdef)) {
392             parser = s->server ? extdef->server_parse : extdef->client_parse;
393
394             /* Check if extension is defined for our protocol. If not, skip */
395             if ((SSL_IS_DTLS(s)
396                         && (extdef->context & EXT_TLS_IMPLEMENTATION_ONLY) != 0)
397                     || (s->version == SSL3_VERSION
398                             && (extdef->context & EXT_SSL3_ALLOWED) == 0)
399                     || (SSL_IS_TLS13(s)
400                         && (extdef->context & EXT_TLS1_2_AND_BELOW_ONLY) != 0)
401                     || (!SSL_IS_TLS13(s)
402                         && (extdef->context & EXT_TLS1_3_ONLY) != 0))
403                 continue;
404         }
405
406         if (parser == NULL) {
407             /*
408              * Could be a custom extension. We only allow this if it is a non
409              * resumed session on the server side.
410              * 
411              * TODO(TLS1.3): We only allow old style <=TLS1.2 custom extensions.
412              * We're going to need a new mechanism for TLS1.3 to specify which
413              * messages to add the custom extensions to.
414              */
415             if ((!s->hit || !s->server)
416                     && (context
417                         & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
418                     && custom_ext_parse(s, s->server, currext->type,
419                                         PACKET_data(&currext->data),
420                                         PACKET_remaining(&currext->data),
421                                         al) <= 0)
422                 return 0;
423
424             continue;
425         }
426
427         if (!parser(s, &currext->data, al))
428             return 0;
429     }
430
431     return 1;
432 }
433
434 /*
435  * Find a specific extension by |type| in the list |exts| containing |numexts|
436  * extensions, and the parse it immediately. Returns 1 on success, or 0 on
437  * failure. If a failure has occurred then |*al| will also be set to the alert
438  * to be sent.
439  */
440 int tls_parse_extension(SSL *s, int type, int context, RAW_EXTENSION *exts,
441                         size_t numexts, int *al)
442 {
443     RAW_EXTENSION *ext = tls_get_extension_by_type(exts, numexts, type);
444
445     if (ext == NULL)
446         return 1;
447
448     return tls_parse_all_extensions(s, context, ext, 1, al);
449 }
450
451 int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
452                              int *al)
453 {
454     size_t loop;
455     int addcustom = 0;
456
457     /*
458      * Normally if something goes wrong during construction its an internal
459      * error. We can always override this later.
460      */
461     *al = SSL_AD_INTERNAL_ERROR;
462
463     if (!WPACKET_start_sub_packet_u16(pkt)
464                /*
465                 * If extensions are of zero length then we don't even add the
466                 * extensions length bytes to a ClientHello/ServerHello in SSLv3
467                 */
468             || ((context & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
469                && s->version == SSL3_VERSION
470                && !WPACKET_set_flags(pkt,
471                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
472         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
473         return 0;
474     }
475
476     for (loop = 0; loop < OSSL_NELEM(ext_defs); loop++) {
477         int (*construct)(SSL *s, WPACKET *pkt, int *al);
478
479         /* Skip if not relevant for our context */
480         if ((ext_defs[loop].context & context) == 0)
481             continue;
482
483         construct = s->server ? ext_defs[loop].server_construct
484                               : ext_defs[loop].client_construct;
485
486         /* Check if this extension is defined for our protocol. If not, skip */
487         if ((SSL_IS_DTLS(s)
488                     && (ext_defs[loop].context & EXT_TLS_IMPLEMENTATION_ONLY)
489                        != 0)
490                 || (s->version == SSL3_VERSION
491                         && (ext_defs[loop].context & EXT_SSL3_ALLOWED) == 0)
492                 || (SSL_IS_TLS13(s)
493                     && (ext_defs[loop].context & EXT_TLS1_2_AND_BELOW_ONLY)
494                        != 0)
495                 || (!SSL_IS_TLS13(s)
496                     && (ext_defs[loop].context & EXT_TLS1_3_ONLY) != 0
497                     && (context & EXT_CLIENT_HELLO) == 0)
498                 || construct == NULL)
499             continue;
500
501         if (!construct(s, pkt, al))
502             return 0;
503     }
504
505     /* Add custom extensions */
506     if ((context & EXT_CLIENT_HELLO) != 0) {
507         custom_ext_init(&s->cert->cli_ext);
508         addcustom = 1;
509     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
510         /*
511          * We already initialised the custom extensions during ClientHello
512          * parsing.
513          * 
514          * TODO(TLS1.3): We're going to need a new custom extension mechanism
515          * for TLS1.3, so that custom extensions can specify which of the
516          * multiple message they wish to add themselves to.
517          */
518         addcustom = 1;
519     }
520
521     if (addcustom && !custom_ext_add(s, s->server, pkt, al)) {
522         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
523         return 0;
524     }
525
526     if (!WPACKET_close(pkt)) {
527         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
528         return 0;
529     }
530
531     return 1;
532 }