82f1565a95d979bcf2204d1076ae80d677328209
[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 <openssl/ocsp.h>
12 #include "../ssl_locl.h"
13 #include "statem_locl.h"
14
15 static int tls_parse_clienthello_renegotiate(SSL *s, PACKET *pkt, int *al);
16 static int tls_parse_clienthello_server_name(SSL *s, PACKET *pkt, int *al);
17 #ifndef OPENSSL_NO_SRP
18 static int tls_parse_clienthello_srp(SSL *s, PACKET *pkt, int *al);
19 #endif
20 #ifndef OPENSSL_NO_EC
21 static int tls_parse_clienthello_ec_pt_formats(SSL *s, PACKET *pkt, int *al);
22 static int tls_parse_clienthello_supported_groups(SSL *s, PACKET *pkt, int *al);
23 #endif
24 static int tls_parse_clienthello_session_ticket(SSL *s, PACKET *pkt, int *al);
25 static int tls_parse_clienthello_sig_algs(SSL *s, PACKET *pkt, int *al);
26 static int tls_parse_clienthello_status_request(SSL *s, PACKET *pkt, int *al);
27 #ifndef OPENSSL_NO_NEXTPROTONEG
28 static int tls_parse_clienthello_npn(SSL *s, PACKET *pkt, int *al);
29 #endif
30 static int tls_parse_clienthello_alpn(SSL *s, PACKET *pkt, int *al);
31 #ifndef OPENSSL_NO_SRTP
32 static int tls_parse_clienthello_use_srtp(SSL *s, PACKET *pkt, int *al);
33 #endif
34 static int tls_parse_clienthello_etm(SSL *s, PACKET *pkt, int *al);
35 static int tls_parse_clienthello_key_share(SSL *s, PACKET *pkt, int *al);
36 static int tls_parse_clienthello_ems(SSL *s, PACKET *pkt, int *al);
37
38 typedef struct {
39     /* The ID for the extension */
40     unsigned int type;
41     int (*server_parse)(SSL *s, PACKET *pkt, int *al);
42     int (*client_parse)(SSL *s, PACKET *pkt, int *al);
43     int (*server_construct)(SSL *s, WPACKET *pkt, int *al);
44     int (*client_construct)(SSL *s, WPACKET *pkt, int *al);
45     unsigned int context;
46 } EXTENSION_DEFINITION;
47
48 static const EXTENSION_DEFINITION ext_defs[] = {
49     {
50         TLSEXT_TYPE_renegotiate,
51         tls_parse_clienthello_renegotiate,
52         NULL,
53         NULL,
54         NULL,
55         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_SSL3_ALLOWED
56         | EXT_TLS1_2_AND_BELOW_ONLY
57     },
58     {
59         TLSEXT_TYPE_server_name,
60         tls_parse_clienthello_server_name,
61         NULL,
62         NULL,
63         NULL,
64         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
65         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
66     },
67 #ifndef OPENSSL_NO_SRP
68     {
69         TLSEXT_TYPE_srp,
70         tls_parse_clienthello_srp,
71         NULL,
72         NULL,
73         NULL,
74         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
75     },
76 #endif
77 #ifndef OPENSSL_NO_EC
78     {
79         TLSEXT_TYPE_ec_point_formats,
80         tls_parse_clienthello_ec_pt_formats,
81         NULL,
82         NULL,
83         NULL,
84         EXT_CLIENT_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
85     },
86     {
87         TLSEXT_TYPE_supported_groups,
88         tls_parse_clienthello_supported_groups,
89         NULL,
90         NULL,
91         NULL,
92         EXT_CLIENT_HELLO | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
93     },
94 #endif
95     {
96         TLSEXT_TYPE_session_ticket,
97         tls_parse_clienthello_session_ticket,
98         NULL,
99         NULL,
100         NULL,
101         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
102     },
103     {
104         TLSEXT_TYPE_signature_algorithms,
105         tls_parse_clienthello_sig_algs,
106         NULL,
107         NULL,
108         NULL,
109         EXT_CLIENT_HELLO
110     },
111     {
112         TLSEXT_TYPE_status_request,
113         tls_parse_clienthello_status_request,
114         NULL,
115         NULL,
116         NULL,
117         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_3_CERTIFICATE
118     },
119 #ifndef OPENSSL_NO_NEXTPROTONEG
120     {
121         TLSEXT_TYPE_next_proto_neg,
122         tls_parse_clienthello_npn,
123         NULL,
124         NULL,
125         NULL,
126         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
127     },
128 #endif
129     {
130         TLSEXT_TYPE_application_layer_protocol_negotiation,
131         tls_parse_clienthello_alpn,
132         NULL,
133         NULL,
134         NULL,
135         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
136         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
137     },
138     {
139         TLSEXT_TYPE_use_srtp,
140         tls_parse_clienthello_use_srtp,
141         NULL,
142         NULL,
143         NULL,
144         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
145         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS | EXT_DTLS_ONLY
146     },
147     {
148         TLSEXT_TYPE_encrypt_then_mac,
149         tls_parse_clienthello_etm,
150         NULL,
151         NULL,
152         NULL,
153         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
154     },
155     {
156         TLSEXT_TYPE_signed_certificate_timestamp,
157         /*
158          * No server side support for this, but can be provided by a custom
159          * extension. This is an exception to the rule that custom extensions
160          * cannot override built in ones.
161          */
162         NULL,
163         NULL,
164         NULL,
165         NULL,
166         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_3_CERTIFICATE
167     },
168     {
169         TLSEXT_TYPE_extended_master_secret,
170         tls_parse_clienthello_ems,
171         NULL,
172         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
173     },
174     {
175         TLSEXT_TYPE_supported_versions,
176         /* Processed inline as part of version selection */
177         NULL,
178         NULL,
179         NULL,
180         NULL,
181         EXT_CLIENT_HELLO | EXT_TLS_IMPLEMENTATION_ONLY
182     },
183     {
184         TLSEXT_TYPE_padding,
185         /* We send this, but don't read it */
186         NULL,
187         NULL,
188         NULL,
189         NULL,
190         EXT_CLIENT_HELLO
191     },
192     {
193         TLSEXT_TYPE_key_share,
194         tls_parse_clienthello_key_share,
195         NULL,
196         NULL,
197         NULL,
198         EXT_CLIENT_HELLO | EXT_TLS1_3_SERVER_HELLO
199         | EXT_TLS1_3_HELLO_RETRY_REQUEST | EXT_TLS_IMPLEMENTATION_ONLY
200         | EXT_TLS1_3_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, RAW_EXTENSION *exts, size_t numexts,
369                              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,  RAW_EXTENSION *exts, size_t numexts,
441                         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, 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     if (!WPACKET_start_sub_packet_u16(pkt)
458                /*
459                 * If extensions are of zero length then we don't even add the
460                 * extensions length bytes to a ClientHello
461                 */
462             || ((context & EXT_CLIENT_HELLO) != 0
463                && !WPACKET_set_flags(pkt,
464                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
465         *al = SSL_AD_INTERNAL_ERROR;
466         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
467         return 0;
468     }
469
470     for (loop = 0; loop < OSSL_NELEM(ext_defs); loop++) {
471         /* Skip if not relevant for our context */
472         if ((ext_defs[loop].context & context) == 0)
473             continue;
474
475         construct = s->server ? extdef->server_construct
476                               : extdef->client_construct;
477
478         /* Check if this extension is defined for our protocol. If not, skip */
479         if ((SSL_IS_DTLS(s)
480                     && (extdef->context & EXT_TLS_IMPLEMENTATION_ONLY) != 0)
481                 || (s->version == SSL3_VERSION
482                         && (extdef->context & EXT_SSL3_ALLOWED) == 0)
483                 || (SSL_IS_TLS13(s)
484                     && (extdef->context & EXT_TLS1_2_AND_BELOW_ONLY) != 0)
485                 || (!SSL_IS_TLS13(s)
486                     && ((extdef->context & EXT_TLS1_3_ONLY) != 0
487                         || (context & EXT_CLIENT_HELLO) != 0))
488                 || construct == NULL)
489             continue;
490
491         if (!construct(s, pkt, al))
492             return 0;
493     }
494
495
496     /* Add custom extensions */
497     if ((context & EXT_CLIENT_HELLO) != 0) {
498         custom_ext_init(&s->cert->cli_ext);
499         addcustom = 1;
500     } else if (context & (EXT_TLS1_2_SERVER_HELLO) {
501         /*
502          * We already initialised the custom extensions during ClientHello
503          * parsing.
504          * 
505          * TODO(TLS1.3): We're going to need a new custom extension mechanism
506          * for TLS1.3, so that custom extensions can specify which of the
507          * multiple message they wish to add themselves to.
508          */
509         addcustom = 1;
510     }
511     if (addcustom && !custom_ext_add(s, s->server, pkt, al)) {
512         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
513         return 0;
514     }
515
516     if (!WPACKET_close(pkt)) {
517         *sl = SSL_AD_INTERNAL_ERROR;
518         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
519         return 0;
520     }
521
522     return 1;
523 }
524
525
526 /*
527  * Parse the client's renegotiation binding and abort if it's not right
528  */
529 static int tls_parse_clienthello_renegotiate(SSL *s, PACKET *pkt, int *al)
530 {
531     unsigned int ilen;
532     const unsigned char *data;
533
534     /* Parse the length byte */
535     if (!PACKET_get_1(pkt, &ilen)
536         || !PACKET_get_bytes(pkt, &data, ilen)) {
537         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT,
538                SSL_R_RENEGOTIATION_ENCODING_ERR);
539         *al = SSL_AD_ILLEGAL_PARAMETER;
540         return 0;
541     }
542
543     /* Check that the extension matches */
544     if (ilen != s->s3->previous_client_finished_len) {
545         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT,
546                SSL_R_RENEGOTIATION_MISMATCH);
547         *al = SSL_AD_HANDSHAKE_FAILURE;
548         return 0;
549     }
550
551     if (memcmp(data, s->s3->previous_client_finished,
552                s->s3->previous_client_finished_len)) {
553         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT,
554                SSL_R_RENEGOTIATION_MISMATCH);
555         *al = SSL_AD_HANDSHAKE_FAILURE;
556         return 0;
557     }
558
559     s->s3->send_connection_binding = 1;
560
561     return 1;
562 }
563
564 static int tls_parse_clienthello_server_name(SSL *s, PACKET *pkt, int *al)
565 {
566     unsigned int servname_type;
567     PACKET sni, hostname;
568
569     /*-
570      * The servername extension is treated as follows:
571      *
572      * - Only the hostname type is supported with a maximum length of 255.
573      * - The servername is rejected if too long or if it contains zeros,
574      *   in which case an fatal alert is generated.
575      * - The servername field is maintained together with the session cache.
576      * - When a session is resumed, the servername call back invoked in order
577      *   to allow the application to position itself to the right context.
578      * - The servername is acknowledged if it is new for a session or when
579      *   it is identical to a previously used for the same session.
580      *   Applications can control the behaviour.  They can at any time
581      *   set a 'desirable' servername for a new SSL object. This can be the
582      *   case for example with HTTPS when a Host: header field is received and
583      *   a renegotiation is requested. In this case, a possible servername
584      *   presented in the new client hello is only acknowledged if it matches
585      *   the value of the Host: field.
586      * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
587      *   if they provide for changing an explicit servername context for the
588      *   session, i.e. when the session has been established with a servername
589      *   extension.
590      * - On session reconnect, the servername extension may be absent.
591      *
592      */
593     if (!PACKET_as_length_prefixed_2(pkt, &sni)
594         /* ServerNameList must be at least 1 byte long. */
595         || PACKET_remaining(&sni) == 0) {
596         *al = SSL_AD_DECODE_ERROR;
597         return 0;
598     }
599
600     /*
601      * Although the server_name extension was intended to be
602      * extensible to new name types, RFC 4366 defined the
603      * syntax inextensibility and OpenSSL 1.0.x parses it as
604      * such.
605      * RFC 6066 corrected the mistake but adding new name types
606      * is nevertheless no longer feasible, so act as if no other
607      * SNI types can exist, to simplify parsing.
608      *
609      * Also note that the RFC permits only one SNI value per type,
610      * i.e., we can only have a single hostname.
611      */
612     if (!PACKET_get_1(&sni, &servname_type)
613         || servname_type != TLSEXT_NAMETYPE_host_name
614         || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
615         *al = SSL_AD_DECODE_ERROR;
616         return 0;
617     }
618
619     if (!s->hit) {
620         if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
621             *al = TLS1_AD_UNRECOGNIZED_NAME;
622             return 0;
623         }
624
625         if (PACKET_contains_zero_byte(&hostname)) {
626             *al = TLS1_AD_UNRECOGNIZED_NAME;
627             return 0;
628         }
629
630         if (!PACKET_strndup(&hostname, &s->session->tlsext_hostname)) {
631             *al = TLS1_AD_INTERNAL_ERROR;
632             return 0;
633         }
634
635         s->servername_done = 1;
636     } else {
637         /*
638          * TODO(openssl-team): if the SNI doesn't match, we MUST
639          * fall back to a full handshake.
640          */
641         s->servername_done = s->session->tlsext_hostname
642             && PACKET_equal(&hostname, s->session->tlsext_hostname,
643                             strlen(s->session->tlsext_hostname));
644     }
645
646     return 1;
647 }
648
649 #ifndef OPENSSL_NO_SRP
650 static int tls_parse_clienthello_srp(SSL *s, PACKET *pkt, int *al)
651 {
652     PACKET srp_I;
653
654     if (!PACKET_as_length_prefixed_1(pkt, &srp_I)
655             || PACKET_contains_zero_byte(&srp_I)) {
656         *al = SSL_AD_DECODE_ERROR;
657         return 0;
658     }
659
660     /*
661      * TODO(openssl-team): currently, we re-authenticate the user
662      * upon resumption. Instead, we MUST ignore the login.
663      */
664     if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
665         *al = TLS1_AD_INTERNAL_ERROR;
666         return 0;
667     }
668
669     return 1;
670 }
671 #endif
672
673 #ifndef OPENSSL_NO_EC
674 static int tls_parse_clienthello_ec_pt_formats(SSL *s, PACKET *pkt, int *al)
675 {
676     PACKET ec_point_format_list;
677
678     if (!PACKET_as_length_prefixed_1(pkt, &ec_point_format_list)
679         || PACKET_remaining(&ec_point_format_list) == 0) {
680         *al = SSL_AD_DECODE_ERROR;
681         return 0;
682     }
683
684     if (!s->hit) {
685         if (!PACKET_memdup(&ec_point_format_list,
686                            &s->session->tlsext_ecpointformatlist,
687                            &s->session->tlsext_ecpointformatlist_length)) {
688             *al = TLS1_AD_INTERNAL_ERROR;
689             return 0;
690         }
691     }
692
693     return 1;
694 }
695 #endif                          /* OPENSSL_NO_EC */
696
697 static int tls_parse_clienthello_session_ticket(SSL *s, PACKET *pkt, int *al)
698 {
699     if (s->tls_session_ticket_ext_cb &&
700             !s->tls_session_ticket_ext_cb(s, PACKET_data(pkt),
701                                           PACKET_remaining(pkt),
702                                           s->tls_session_ticket_ext_cb_arg)) {
703         *al = TLS1_AD_INTERNAL_ERROR;
704         return 0;
705     }
706
707     return 1;
708 }
709
710 static int tls_parse_clienthello_sig_algs(SSL *s, PACKET *pkt, int *al)
711 {
712     PACKET supported_sig_algs;
713
714     if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs)
715             || (PACKET_remaining(&supported_sig_algs) % 2) != 0
716             || PACKET_remaining(&supported_sig_algs) == 0) {
717         *al = SSL_AD_DECODE_ERROR;
718         return 0;
719     }
720
721     if (!s->hit && !tls1_save_sigalgs(s, PACKET_data(&supported_sig_algs),
722                                       PACKET_remaining(&supported_sig_algs))) {
723         *al = TLS1_AD_INTERNAL_ERROR;
724         return 0;
725     }
726
727     return 1;
728 }
729
730 static int tls_parse_clienthello_status_request(SSL *s, PACKET *pkt, int *al)
731 {
732     if (!PACKET_get_1(pkt, (unsigned int *)&s->tlsext_status_type)) {
733         *al = SSL_AD_DECODE_ERROR;
734         return 0;
735     }
736 #ifndef OPENSSL_NO_OCSP
737     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
738         const unsigned char *ext_data;
739         PACKET responder_id_list, exts;
740         if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) {
741             *al = SSL_AD_DECODE_ERROR;
742             return 0;
743         }
744
745         /*
746          * We remove any OCSP_RESPIDs from a previous handshake
747          * to prevent unbounded memory growth - CVE-2016-6304
748          */
749         sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
750         if (PACKET_remaining(&responder_id_list) > 0) {
751             s->tlsext_ocsp_ids = sk_OCSP_RESPID_new_null();
752             if (s->tlsext_ocsp_ids == NULL) {
753                 *al = SSL_AD_INTERNAL_ERROR;
754                 return 0;
755             }
756         } else {
757             s->tlsext_ocsp_ids = NULL;
758         }
759
760         while (PACKET_remaining(&responder_id_list) > 0) {
761             OCSP_RESPID *id;
762             PACKET responder_id;
763             const unsigned char *id_data;
764
765             if (!PACKET_get_length_prefixed_2(&responder_id_list,
766                                               &responder_id)
767                     || PACKET_remaining(&responder_id) == 0) {
768                 *al = SSL_AD_DECODE_ERROR;
769                 return 0;
770             }
771
772             id_data = PACKET_data(&responder_id);
773             /* TODO(size_t): Convert d2i_* to size_t */
774             id = d2i_OCSP_RESPID(NULL, &id_data,
775                                  (int)PACKET_remaining(&responder_id));
776             if (id == NULL) {
777                 *al = SSL_AD_DECODE_ERROR;
778                 return 0;
779             }
780
781             if (id_data != PACKET_end(&responder_id)) {
782                 OCSP_RESPID_free(id);
783                 *al = SSL_AD_DECODE_ERROR;
784                 return 0;
785             }
786
787             if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
788                 OCSP_RESPID_free(id);
789                 *al = SSL_AD_INTERNAL_ERROR;
790                 return 0;
791             }
792         }
793
794         /* Read in request_extensions */
795         if (!PACKET_as_length_prefixed_2(pkt, &exts)) {
796             *al = SSL_AD_DECODE_ERROR;
797             return 0;
798         }
799
800         if (PACKET_remaining(&exts) > 0) {
801             ext_data = PACKET_data(&exts);
802             sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
803                                        X509_EXTENSION_free);
804             s->tlsext_ocsp_exts =
805                 d2i_X509_EXTENSIONS(NULL, &ext_data,
806                                     (int)PACKET_remaining(&exts));
807             if (s->tlsext_ocsp_exts == NULL || ext_data != PACKET_end(&exts)) {
808                 *al = SSL_AD_DECODE_ERROR;
809                 return 0;
810             }
811         }
812     } else
813 #endif
814     {
815         /*
816          * We don't know what to do with any other type so ignore it.
817          */
818         s->tlsext_status_type = -1;
819     }
820
821     return 1;
822 }
823
824 #ifndef OPENSSL_NO_NEXTPROTONEG
825 static int tls_parse_clienthello_npn(SSL *s, PACKET *pkt, int *al)
826 {
827     if (s->s3->tmp.finish_md_len == 0) {
828         /*-
829          * We shouldn't accept this extension on a
830          * renegotiation.
831          *
832          * s->new_session will be set on renegotiation, but we
833          * probably shouldn't rely that it couldn't be set on
834          * the initial renegotiation too in certain cases (when
835          * there's some other reason to disallow resuming an
836          * earlier session -- the current code won't be doing
837          * anything like that, but this might change).
838          *
839          * A valid sign that there's been a previous handshake
840          * in this connection is if s->s3->tmp.finish_md_len >
841          * 0.  (We are talking about a check that will happen
842          * in the Hello protocol round, well before a new
843          * Finished message could have been computed.)
844          */
845         s->s3->next_proto_neg_seen = 1;
846     }
847
848     return 1;
849 }
850 #endif
851
852 /*
853  * Save the ALPN extension in a ClientHello.
854  * pkt: the contents of the ALPN extension, not including type and length.
855  * al: a pointer to the  alert value to send in the event of a failure.
856  * returns: 1 on success, 0 on error.
857  */
858 static int tls_parse_clienthello_alpn(SSL *s, PACKET *pkt, int *al)
859 {
860     PACKET protocol_list, save_protocol_list, protocol;
861
862     if (s->s3->tmp.finish_md_len != 0)
863         return 1;
864
865     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
866         || PACKET_remaining(&protocol_list) < 2) {
867         *al = SSL_AD_DECODE_ERROR;
868         return 0;
869     }
870
871     save_protocol_list = protocol_list;
872     do {
873         /* Protocol names can't be empty. */
874         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
875                 || PACKET_remaining(&protocol) == 0) {
876             *al = SSL_AD_DECODE_ERROR;
877             return 0;
878         }
879     } while (PACKET_remaining(&protocol_list) != 0);
880
881     if (!PACKET_memdup(&save_protocol_list,
882                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
883         *al = TLS1_AD_INTERNAL_ERROR;
884         return 0;
885     }
886
887     return 1;
888 }
889
890 #ifndef OPENSSL_NO_SRTP
891 static int tls_parse_clienthello_use_srtp(SSL *s, PACKET *pkt, int *al)
892 {
893     SRTP_PROTECTION_PROFILE *sprof;
894     STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
895     unsigned int ct, mki_len, id;
896     int i, srtp_pref;
897     PACKET subpkt;
898
899     /* Ignore this if we have no SRTP profiles */
900     if (SSL_get_srtp_profiles(s) == NULL)
901         return 1;
902
903     /* Pull off the length of the cipher suite list  and check it is even */
904     if (!PACKET_get_net_2(pkt, &ct)
905         || (ct & 1) != 0 || !PACKET_get_sub_packet(pkt, &subpkt, ct)) {
906         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_USE_SRTP,
907                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
908         *al = SSL_AD_DECODE_ERROR;
909         return 0;
910     }
911
912     srvr = SSL_get_srtp_profiles(s);
913     s->srtp_profile = NULL;
914     /* Search all profiles for a match initially */
915     srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr);
916
917     while (PACKET_remaining(&subpkt)) {
918         if (!PACKET_get_net_2(&subpkt, &id)) {
919             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_USE_SRTP,
920                    SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
921             *al = SSL_AD_DECODE_ERROR;
922             return 0;
923         }
924
925         /*
926          * Only look for match in profiles of higher preference than
927          * current match.
928          * If no profiles have been have been configured then this
929          * does nothing.
930          */
931         for (i = 0; i < srtp_pref; i++) {
932             sprof = sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
933             if (sprof->id == id) {
934                 s->srtp_profile = sprof;
935                 srtp_pref = i;
936                 break;
937             }
938         }
939     }
940
941     /*
942      * Now extract the MKI value as a sanity check, but discard it for now
943      */
944     if (!PACKET_get_1(pkt, &mki_len)) {
945         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_USE_SRTP,
946                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
947         *al = SSL_AD_DECODE_ERROR;
948         return 0;
949     }
950
951     if (!PACKET_forward(pkt, mki_len)
952         || PACKET_remaining(pkt)) {
953         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_USE_SRTP, SSL_R_BAD_SRTP_MKI_VALUE);
954         *al = SSL_AD_DECODE_ERROR;
955         return 0;
956     }
957
958     return 1;
959 }
960 #endif
961
962 static int tls_parse_clienthello_etm(SSL *s, PACKET *pkt, int *al)
963 {
964     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
965         s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
966
967     return 1;
968 }
969
970 /*
971  * Checks a list of |groups| to determine if the |group_id| is in it. If it is
972  * and |checkallow| is 1 then additionally check if the group is allowed to be
973  * used. Returns 1 if the group is in the list (and allowed if |checkallow| is
974  * 1) or 0 otherwise.
975  */
976 static int check_in_list(SSL *s, unsigned int group_id,
977                          const unsigned char *groups, size_t num_groups,
978                          int checkallow)
979 {
980     size_t i;
981
982     if (groups == NULL || num_groups == 0)
983         return 0;
984
985     for (i = 0; i < num_groups; i++, groups += 2) {
986         unsigned int share_id = (groups[0] << 8) | (groups[1]);
987
988         if (group_id == share_id
989                 && (!checkallow || tls_curve_allowed(s, groups,
990                                                      SSL_SECOP_CURVE_CHECK))) {
991             break;
992         }
993     }
994
995     /* If i == num_groups then not in the list */
996     return i < num_groups;
997 }
998
999 /*
1000  * Process a key_share extension received in the ClientHello. |pkt| contains
1001  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
1002  * If a failure occurs then |*al| is set to an appropriate alert value.
1003  */
1004 static int tls_parse_clienthello_key_share(SSL *s, PACKET *pkt, int *al)
1005 {
1006     unsigned int group_id;
1007     PACKET key_share_list, encoded_pt;
1008     const unsigned char *clntcurves, *srvrcurves;
1009     size_t clnt_num_curves, srvr_num_curves;
1010     int group_nid, found = 0;
1011     unsigned int curve_flags;
1012
1013     if (s->hit)
1014         return 1;
1015
1016     /* Sanity check */
1017     if (s->s3->peer_tmp != NULL) {
1018         *al = SSL_AD_INTERNAL_ERROR;
1019         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1020         return 0;
1021     }
1022
1023     if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) {
1024         *al = SSL_AD_HANDSHAKE_FAILURE;
1025         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
1026         return 0;
1027     }
1028
1029     /* Get our list of supported curves */
1030     if (!tls1_get_curvelist(s, 0, &srvrcurves, &srvr_num_curves)) {
1031         *al = SSL_AD_INTERNAL_ERROR;
1032         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1033         return 0;
1034     }
1035
1036     /* Get the clients list of supported curves */
1037     if (!tls1_get_curvelist(s, 1, &clntcurves, &clnt_num_curves)) {
1038         *al = SSL_AD_INTERNAL_ERROR;
1039         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1040         return 0;
1041     }
1042
1043     while (PACKET_remaining(&key_share_list) > 0) {
1044         if (!PACKET_get_net_2(&key_share_list, &group_id)
1045                 || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt)
1046                 || PACKET_remaining(&encoded_pt) == 0) {
1047             *al = SSL_AD_HANDSHAKE_FAILURE;
1048             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE,
1049                    SSL_R_LENGTH_MISMATCH);
1050             return 0;
1051         }
1052
1053         /*
1054          * If we already found a suitable key_share we loop through the
1055          * rest to verify the structure, but don't process them.
1056          */
1057         if (found)
1058             continue;
1059
1060         /* Check if this share is in supported_groups sent from client */
1061         if (!check_in_list(s, group_id, clntcurves, clnt_num_curves, 0)) {
1062             *al = SSL_AD_HANDSHAKE_FAILURE;
1063             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
1064             return 0;
1065         }
1066
1067         /* Check if this share is for a group we can use */
1068         if (!check_in_list(s, group_id, srvrcurves, srvr_num_curves, 1)) {
1069             /* Share not suitable */
1070             continue;
1071         }
1072
1073         group_nid = tls1_ec_curve_id2nid(group_id, &curve_flags);
1074
1075         if (group_nid == 0) {
1076             *al = SSL_AD_INTERNAL_ERROR;
1077             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE,
1078                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
1079             return 0;
1080         }
1081
1082         if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
1083             /* Can happen for some curves, e.g. X25519 */
1084             EVP_PKEY *key = EVP_PKEY_new();
1085
1086             if (key == NULL || !EVP_PKEY_set_type(key, group_nid)) {
1087                 *al = SSL_AD_INTERNAL_ERROR;
1088                 SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_EVP_LIB);
1089                 EVP_PKEY_free(key);
1090                 return 0;
1091             }
1092             s->s3->peer_tmp = key;
1093         } else {
1094             /* Set up EVP_PKEY with named curve as parameters */
1095             EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
1096             if (pctx == NULL
1097                     || EVP_PKEY_paramgen_init(pctx) <= 0
1098                     || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
1099                                                               group_nid) <= 0
1100                     || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
1101                 *al = SSL_AD_INTERNAL_ERROR;
1102                 SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_EVP_LIB);
1103                 EVP_PKEY_CTX_free(pctx);
1104                 return 0;
1105             }
1106             EVP_PKEY_CTX_free(pctx);
1107             pctx = NULL;
1108         }
1109         s->s3->group_id = group_id;
1110
1111         if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
1112                 PACKET_data(&encoded_pt),
1113                 PACKET_remaining(&encoded_pt))) {
1114             *al = SSL_AD_DECODE_ERROR;
1115             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, SSL_R_BAD_ECPOINT);
1116             return 0;
1117         }
1118
1119         found = 1;
1120     }
1121
1122     return 1;
1123 }
1124
1125 #ifndef OPENSSL_NO_EC
1126 static int tls_parse_clienthello_supported_groups(SSL *s, PACKET *pkt, int *al)
1127 {
1128     PACKET supported_groups_list;
1129
1130     /* Each group is 2 bytes and we must have at least 1. */
1131     if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list)
1132             || PACKET_remaining(&supported_groups_list) == 0
1133             || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
1134         *al = SSL_AD_DECODE_ERROR;
1135         return 0;
1136     }
1137
1138     if (!s->hit
1139             && !PACKET_memdup(&supported_groups_list,
1140                               &s->session->tlsext_supportedgroupslist,
1141                               &s->session->tlsext_supportedgroupslist_length)) {
1142         *al = SSL_AD_DECODE_ERROR;
1143         return 0;
1144     }
1145
1146     return 1;
1147 }
1148 #endif
1149
1150 static int tls_parse_clienthello_ems(SSL *s, PACKET *pkt, int *al)
1151 {
1152     /* The extension must always be empty */
1153     if (PACKET_remaining(pkt) != 0) {
1154         *al = SSL_AD_DECODE_ERROR;
1155         return 0;
1156     }
1157
1158     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
1159
1160     return 1;
1161 }