56b6f27e0aafb64242b10e26b71900e4c98e467c
[openssl.git] / ssl / t1_lib.c
1 /*
2  * Copyright 1995-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 <stdio.h>
11 #include <stdlib.h>
12 #include <openssl/objects.h>
13 #include <openssl/evp.h>
14 #include <openssl/hmac.h>
15 #include <openssl/ocsp.h>
16 #include <openssl/conf.h>
17 #include <openssl/x509v3.h>
18 #include <openssl/dh.h>
19 #include <openssl/bn.h>
20 #include "ssl_locl.h"
21 #include <openssl/ct.h>
22
23 static int tls_decrypt_ticket(SSL *s, const unsigned char *tick, size_t ticklen,
24                               const unsigned char *sess_id, size_t sesslen,
25                               SSL_SESSION **psess);
26 static int ssl_check_clienthello_tlsext_early(SSL *s);
27 static int ssl_check_serverhello_tlsext(SSL *s);
28
29 SSL3_ENC_METHOD const TLSv1_enc_data = {
30     tls1_enc,
31     tls1_mac,
32     tls1_setup_key_block,
33     tls1_generate_master_secret,
34     tls1_change_cipher_state,
35     tls1_final_finish_mac,
36     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
37     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
38     tls1_alert_code,
39     tls1_export_keying_material,
40     0,
41     ssl3_set_handshake_header,
42     tls_close_construct_packet,
43     ssl3_handshake_write
44 };
45
46 SSL3_ENC_METHOD const TLSv1_1_enc_data = {
47     tls1_enc,
48     tls1_mac,
49     tls1_setup_key_block,
50     tls1_generate_master_secret,
51     tls1_change_cipher_state,
52     tls1_final_finish_mac,
53     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
54     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
55     tls1_alert_code,
56     tls1_export_keying_material,
57     SSL_ENC_FLAG_EXPLICIT_IV,
58     ssl3_set_handshake_header,
59     tls_close_construct_packet,
60     ssl3_handshake_write
61 };
62
63 SSL3_ENC_METHOD const TLSv1_2_enc_data = {
64     tls1_enc,
65     tls1_mac,
66     tls1_setup_key_block,
67     tls1_generate_master_secret,
68     tls1_change_cipher_state,
69     tls1_final_finish_mac,
70     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
71     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
72     tls1_alert_code,
73     tls1_export_keying_material,
74     SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF
75         | SSL_ENC_FLAG_TLS1_2_CIPHERS,
76     ssl3_set_handshake_header,
77     tls_close_construct_packet,
78     ssl3_handshake_write
79 };
80
81 SSL3_ENC_METHOD const TLSv1_3_enc_data = {
82     tls1_enc,
83     tls1_mac,
84     tls1_setup_key_block,
85     tls1_generate_master_secret,
86     tls1_change_cipher_state,
87     tls1_final_finish_mac,
88     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
89     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
90     tls1_alert_code,
91     tls1_export_keying_material,
92     SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF
93         | SSL_ENC_FLAG_TLS1_2_CIPHERS,
94     ssl3_set_handshake_header,
95     tls_close_construct_packet,
96     ssl3_handshake_write
97 };
98
99 long tls1_default_timeout(void)
100 {
101     /*
102      * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for
103      * http, the cache would over fill
104      */
105     return (60 * 60 * 2);
106 }
107
108 int tls1_new(SSL *s)
109 {
110     if (!ssl3_new(s))
111         return (0);
112     s->method->ssl_clear(s);
113     return (1);
114 }
115
116 void tls1_free(SSL *s)
117 {
118     OPENSSL_free(s->tlsext_session_ticket);
119     ssl3_free(s);
120 }
121
122 void tls1_clear(SSL *s)
123 {
124     ssl3_clear(s);
125     if (s->method->version == TLS_ANY_VERSION)
126         s->version = TLS_MAX_VERSION;
127     else
128         s->version = s->method->version;
129 }
130
131 #ifndef OPENSSL_NO_EC
132
133 typedef struct {
134     int nid;                    /* Curve NID */
135     int secbits;                /* Bits of security (from SP800-57) */
136     unsigned int flags;         /* Flags: currently just field type */
137 } tls_curve_info;
138
139 /*
140  * Table of curve information.
141  * Do not delete entries or reorder this array! It is used as a lookup
142  * table: the index of each entry is one less than the TLS curve id.
143  */
144 static const tls_curve_info nid_list[] = {
145     {NID_sect163k1, 80, TLS_CURVE_CHAR2}, /* sect163k1 (1) */
146     {NID_sect163r1, 80, TLS_CURVE_CHAR2}, /* sect163r1 (2) */
147     {NID_sect163r2, 80, TLS_CURVE_CHAR2}, /* sect163r2 (3) */
148     {NID_sect193r1, 80, TLS_CURVE_CHAR2}, /* sect193r1 (4) */
149     {NID_sect193r2, 80, TLS_CURVE_CHAR2}, /* sect193r2 (5) */
150     {NID_sect233k1, 112, TLS_CURVE_CHAR2}, /* sect233k1 (6) */
151     {NID_sect233r1, 112, TLS_CURVE_CHAR2}, /* sect233r1 (7) */
152     {NID_sect239k1, 112, TLS_CURVE_CHAR2}, /* sect239k1 (8) */
153     {NID_sect283k1, 128, TLS_CURVE_CHAR2}, /* sect283k1 (9) */
154     {NID_sect283r1, 128, TLS_CURVE_CHAR2}, /* sect283r1 (10) */
155     {NID_sect409k1, 192, TLS_CURVE_CHAR2}, /* sect409k1 (11) */
156     {NID_sect409r1, 192, TLS_CURVE_CHAR2}, /* sect409r1 (12) */
157     {NID_sect571k1, 256, TLS_CURVE_CHAR2}, /* sect571k1 (13) */
158     {NID_sect571r1, 256, TLS_CURVE_CHAR2}, /* sect571r1 (14) */
159     {NID_secp160k1, 80, TLS_CURVE_PRIME}, /* secp160k1 (15) */
160     {NID_secp160r1, 80, TLS_CURVE_PRIME}, /* secp160r1 (16) */
161     {NID_secp160r2, 80, TLS_CURVE_PRIME}, /* secp160r2 (17) */
162     {NID_secp192k1, 80, TLS_CURVE_PRIME}, /* secp192k1 (18) */
163     {NID_X9_62_prime192v1, 80, TLS_CURVE_PRIME}, /* secp192r1 (19) */
164     {NID_secp224k1, 112, TLS_CURVE_PRIME}, /* secp224k1 (20) */
165     {NID_secp224r1, 112, TLS_CURVE_PRIME}, /* secp224r1 (21) */
166     {NID_secp256k1, 128, TLS_CURVE_PRIME}, /* secp256k1 (22) */
167     {NID_X9_62_prime256v1, 128, TLS_CURVE_PRIME}, /* secp256r1 (23) */
168     {NID_secp384r1, 192, TLS_CURVE_PRIME}, /* secp384r1 (24) */
169     {NID_secp521r1, 256, TLS_CURVE_PRIME}, /* secp521r1 (25) */
170     {NID_brainpoolP256r1, 128, TLS_CURVE_PRIME}, /* brainpoolP256r1 (26) */
171     {NID_brainpoolP384r1, 192, TLS_CURVE_PRIME}, /* brainpoolP384r1 (27) */
172     {NID_brainpoolP512r1, 256, TLS_CURVE_PRIME}, /* brainpool512r1 (28) */
173     {NID_X25519, 128, TLS_CURVE_CUSTOM}, /* X25519 (29) */
174 };
175
176 static const unsigned char ecformats_default[] = {
177     TLSEXT_ECPOINTFORMAT_uncompressed,
178     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime,
179     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2
180 };
181
182 /* The default curves */
183 static const unsigned char eccurves_default[] = {
184     0, 29,                      /* X25519 (29) */
185     0, 23,                      /* secp256r1 (23) */
186     0, 25,                      /* secp521r1 (25) */
187     0, 24,                      /* secp384r1 (24) */
188 };
189
190 static const unsigned char eccurves_all[] = {
191     0, 29,                      /* X25519 (29) */
192     0, 23,                      /* secp256r1 (23) */
193     0, 25,                      /* secp521r1 (25) */
194     0, 24,                      /* secp384r1 (24) */
195     0, 26,                      /* brainpoolP256r1 (26) */
196     0, 27,                      /* brainpoolP384r1 (27) */
197     0, 28,                      /* brainpool512r1 (28) */
198
199     /*
200      * Remaining curves disabled by default but still permitted if set
201      * via an explicit callback or parameters.
202      */
203     0, 22,                      /* secp256k1 (22) */
204     0, 14,                      /* sect571r1 (14) */
205     0, 13,                      /* sect571k1 (13) */
206     0, 11,                      /* sect409k1 (11) */
207     0, 12,                      /* sect409r1 (12) */
208     0, 9,                       /* sect283k1 (9) */
209     0, 10,                      /* sect283r1 (10) */
210     0, 20,                      /* secp224k1 (20) */
211     0, 21,                      /* secp224r1 (21) */
212     0, 18,                      /* secp192k1 (18) */
213     0, 19,                      /* secp192r1 (19) */
214     0, 15,                      /* secp160k1 (15) */
215     0, 16,                      /* secp160r1 (16) */
216     0, 17,                      /* secp160r2 (17) */
217     0, 8,                       /* sect239k1 (8) */
218     0, 6,                       /* sect233k1 (6) */
219     0, 7,                       /* sect233r1 (7) */
220     0, 4,                       /* sect193r1 (4) */
221     0, 5,                       /* sect193r2 (5) */
222     0, 1,                       /* sect163k1 (1) */
223     0, 2,                       /* sect163r1 (2) */
224     0, 3,                       /* sect163r2 (3) */
225 };
226
227 static const unsigned char suiteb_curves[] = {
228     0, TLSEXT_curve_P_256,
229     0, TLSEXT_curve_P_384
230 };
231
232 int tls1_ec_curve_id2nid(int curve_id, unsigned int *pflags)
233 {
234     const tls_curve_info *cinfo;
235     /* ECC curves from RFC 4492 and RFC 7027 */
236     if ((curve_id < 1) || ((unsigned int)curve_id > OSSL_NELEM(nid_list)))
237         return 0;
238     cinfo = nid_list + curve_id - 1;
239     if (pflags)
240         *pflags = cinfo->flags;
241     return cinfo->nid;
242 }
243
244 int tls1_ec_nid2curve_id(int nid)
245 {
246     size_t i;
247     for (i = 0; i < OSSL_NELEM(nid_list); i++) {
248         if (nid_list[i].nid == nid)
249             return (int)(i + 1);
250     }
251     return 0;
252 }
253
254 /*
255  * Get curves list, if "sess" is set return client curves otherwise
256  * preferred list.
257  * Sets |num_curves| to the number of curves in the list, i.e.,
258  * the length of |pcurves| is 2 * num_curves.
259  * Returns 1 on success and 0 if the client curves list has invalid format.
260  * The latter indicates an internal error: we should not be accepting such
261  * lists in the first place.
262  * TODO(emilia): we should really be storing the curves list in explicitly
263  * parsed form instead. (However, this would affect binary compatibility
264  * so cannot happen in the 1.0.x series.)
265  */
266 static int tls1_get_curvelist(SSL *s, int sess,
267                               const unsigned char **pcurves, size_t *num_curves)
268 {
269     size_t pcurveslen = 0;
270     if (sess) {
271         *pcurves = s->session->tlsext_supportedgroupslist;
272         pcurveslen = s->session->tlsext_supportedgroupslist_length;
273     } else {
274         /* For Suite B mode only include P-256, P-384 */
275         switch (tls1_suiteb(s)) {
276         case SSL_CERT_FLAG_SUITEB_128_LOS:
277             *pcurves = suiteb_curves;
278             pcurveslen = sizeof(suiteb_curves);
279             break;
280
281         case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
282             *pcurves = suiteb_curves;
283             pcurveslen = 2;
284             break;
285
286         case SSL_CERT_FLAG_SUITEB_192_LOS:
287             *pcurves = suiteb_curves + 2;
288             pcurveslen = 2;
289             break;
290         default:
291             *pcurves = s->tlsext_supportedgroupslist;
292             pcurveslen = s->tlsext_supportedgroupslist_length;
293         }
294         if (!*pcurves) {
295             *pcurves = eccurves_default;
296             pcurveslen = sizeof(eccurves_default);
297         }
298     }
299
300     /* We do not allow odd length arrays to enter the system. */
301     if (pcurveslen & 1) {
302         SSLerr(SSL_F_TLS1_GET_CURVELIST, ERR_R_INTERNAL_ERROR);
303         *num_curves = 0;
304         return 0;
305     } else {
306         *num_curves = pcurveslen / 2;
307         return 1;
308     }
309 }
310
311 /* See if curve is allowed by security callback */
312 static int tls_curve_allowed(SSL *s, const unsigned char *curve, int op)
313 {
314     const tls_curve_info *cinfo;
315     if (curve[0])
316         return 1;
317     if ((curve[1] < 1) || ((size_t)curve[1] > OSSL_NELEM(nid_list)))
318         return 0;
319     cinfo = &nid_list[curve[1] - 1];
320 # ifdef OPENSSL_NO_EC2M
321     if (cinfo->flags & TLS_CURVE_CHAR2)
322         return 0;
323 # endif
324     return ssl_security(s, op, cinfo->secbits, cinfo->nid, (void *)curve);
325 }
326
327 /* Check a curve is one of our preferences */
328 int tls1_check_curve(SSL *s, const unsigned char *p, size_t len)
329 {
330     const unsigned char *curves;
331     size_t num_curves, i;
332     unsigned int suiteb_flags = tls1_suiteb(s);
333     if (len != 3 || p[0] != NAMED_CURVE_TYPE)
334         return 0;
335     /* Check curve matches Suite B preferences */
336     if (suiteb_flags) {
337         unsigned long cid = s->s3->tmp.new_cipher->id;
338         if (p[1])
339             return 0;
340         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) {
341             if (p[2] != TLSEXT_curve_P_256)
342                 return 0;
343         } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) {
344             if (p[2] != TLSEXT_curve_P_384)
345                 return 0;
346         } else                  /* Should never happen */
347             return 0;
348     }
349     if (!tls1_get_curvelist(s, 0, &curves, &num_curves))
350         return 0;
351     for (i = 0; i < num_curves; i++, curves += 2) {
352         if (p[1] == curves[0] && p[2] == curves[1])
353             return tls_curve_allowed(s, p + 1, SSL_SECOP_CURVE_CHECK);
354     }
355     return 0;
356 }
357
358 /*-
359  * For nmatch >= 0, return the NID of the |nmatch|th shared group or NID_undef
360  * if there is no match.
361  * For nmatch == -1, return number of matches
362  * For nmatch == -2, return the NID of the group to use for
363  * an EC tmp key, or NID_undef if there is no match.
364  */
365 int tls1_shared_group(SSL *s, int nmatch)
366 {
367     const unsigned char *pref, *supp;
368     size_t num_pref, num_supp, i, j;
369     int k;
370     /* Can't do anything on client side */
371     if (s->server == 0)
372         return -1;
373     if (nmatch == -2) {
374         if (tls1_suiteb(s)) {
375             /*
376              * For Suite B ciphersuite determines curve: we already know
377              * these are acceptable due to previous checks.
378              */
379             unsigned long cid = s->s3->tmp.new_cipher->id;
380             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
381                 return NID_X9_62_prime256v1; /* P-256 */
382             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
383                 return NID_secp384r1; /* P-384 */
384             /* Should never happen */
385             return NID_undef;
386         }
387         /* If not Suite B just return first preference shared curve */
388         nmatch = 0;
389     }
390     /*
391      * Avoid truncation. tls1_get_curvelist takes an int
392      * but s->options is a long...
393      */
394     if (!tls1_get_curvelist
395         (s, (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) != 0, &supp,
396          &num_supp))
397         /* In practice, NID_undef == 0 but let's be precise. */
398         return nmatch == -1 ? 0 : NID_undef;
399     if (!tls1_get_curvelist
400         (s, !(s->options & SSL_OP_CIPHER_SERVER_PREFERENCE), &pref, &num_pref))
401         return nmatch == -1 ? 0 : NID_undef;
402
403     /*
404      * If the client didn't send the elliptic_curves extension all of them
405      * are allowed.
406      */
407     if (num_supp == 0 && (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) != 0) {
408         supp = eccurves_all;
409         num_supp = sizeof(eccurves_all) / 2;
410     } else if (num_pref == 0 &&
411                (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) == 0) {
412         pref = eccurves_all;
413         num_pref = sizeof(eccurves_all) / 2;
414     }
415
416     k = 0;
417     for (i = 0; i < num_pref; i++, pref += 2) {
418         const unsigned char *tsupp = supp;
419         for (j = 0; j < num_supp; j++, tsupp += 2) {
420             if (pref[0] == tsupp[0] && pref[1] == tsupp[1]) {
421                 if (!tls_curve_allowed(s, pref, SSL_SECOP_CURVE_SHARED))
422                     continue;
423                 if (nmatch == k) {
424                     int id = (pref[0] << 8) | pref[1];
425                     return tls1_ec_curve_id2nid(id, NULL);
426                 }
427                 k++;
428             }
429         }
430     }
431     if (nmatch == -1)
432         return k;
433     /* Out of range (nmatch > k). */
434     return NID_undef;
435 }
436
437 int tls1_set_groups(unsigned char **pext, size_t *pextlen,
438                     int *groups, size_t ngroups)
439 {
440     unsigned char *glist, *p;
441     size_t i;
442     /*
443      * Bitmap of groups included to detect duplicates: only works while group
444      * ids < 32
445      */
446     unsigned long dup_list = 0;
447     glist = OPENSSL_malloc(ngroups * 2);
448     if (glist == NULL)
449         return 0;
450     for (i = 0, p = glist; i < ngroups; i++) {
451         unsigned long idmask;
452         int id;
453         /* TODO(TLS1.3): Convert for DH groups */
454         id = tls1_ec_nid2curve_id(groups[i]);
455         idmask = 1L << id;
456         if (!id || (dup_list & idmask)) {
457             OPENSSL_free(glist);
458             return 0;
459         }
460         dup_list |= idmask;
461         s2n(id, p);
462     }
463     OPENSSL_free(*pext);
464     *pext = glist;
465     *pextlen = ngroups * 2;
466     return 1;
467 }
468
469 # define MAX_CURVELIST   28
470
471 typedef struct {
472     size_t nidcnt;
473     int nid_arr[MAX_CURVELIST];
474 } nid_cb_st;
475
476 static int nid_cb(const char *elem, int len, void *arg)
477 {
478     nid_cb_st *narg = arg;
479     size_t i;
480     int nid;
481     char etmp[20];
482     if (elem == NULL)
483         return 0;
484     if (narg->nidcnt == MAX_CURVELIST)
485         return 0;
486     if (len > (int)(sizeof(etmp) - 1))
487         return 0;
488     memcpy(etmp, elem, len);
489     etmp[len] = 0;
490     nid = EC_curve_nist2nid(etmp);
491     if (nid == NID_undef)
492         nid = OBJ_sn2nid(etmp);
493     if (nid == NID_undef)
494         nid = OBJ_ln2nid(etmp);
495     if (nid == NID_undef)
496         return 0;
497     for (i = 0; i < narg->nidcnt; i++)
498         if (narg->nid_arr[i] == nid)
499             return 0;
500     narg->nid_arr[narg->nidcnt++] = nid;
501     return 1;
502 }
503
504 /* Set groups based on a colon separate list */
505 int tls1_set_groups_list(unsigned char **pext, size_t *pextlen, const char *str)
506 {
507     nid_cb_st ncb;
508     ncb.nidcnt = 0;
509     if (!CONF_parse_list(str, ':', 1, nid_cb, &ncb))
510         return 0;
511     if (pext == NULL)
512         return 1;
513     return tls1_set_groups(pext, pextlen, ncb.nid_arr, ncb.nidcnt);
514 }
515
516 /* For an EC key set TLS id and required compression based on parameters */
517 static int tls1_set_ec_id(unsigned char *curve_id, unsigned char *comp_id,
518                           EC_KEY *ec)
519 {
520     int id;
521     const EC_GROUP *grp;
522     if (!ec)
523         return 0;
524     /* Determine if it is a prime field */
525     grp = EC_KEY_get0_group(ec);
526     if (!grp)
527         return 0;
528     /* Determine curve ID */
529     id = EC_GROUP_get_curve_name(grp);
530     id = tls1_ec_nid2curve_id(id);
531     /* If no id return error: we don't support arbitrary explicit curves */
532     if (id == 0)
533         return 0;
534     curve_id[0] = 0;
535     curve_id[1] = (unsigned char)id;
536     if (comp_id) {
537         if (EC_KEY_get0_public_key(ec) == NULL)
538             return 0;
539         if (EC_KEY_get_conv_form(ec) == POINT_CONVERSION_UNCOMPRESSED) {
540             *comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
541         } else {
542             if ((nid_list[id - 1].flags & TLS_CURVE_TYPE) == TLS_CURVE_PRIME)
543                 *comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
544             else
545                 *comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
546         }
547     }
548     return 1;
549 }
550
551 /* Check an EC key is compatible with extensions */
552 static int tls1_check_ec_key(SSL *s,
553                              unsigned char *curve_id, unsigned char *comp_id)
554 {
555     const unsigned char *pformats, *pcurves;
556     size_t num_formats, num_curves, i;
557     int j;
558     /*
559      * If point formats extension present check it, otherwise everything is
560      * supported (see RFC4492).
561      */
562     if (comp_id && s->session->tlsext_ecpointformatlist) {
563         pformats = s->session->tlsext_ecpointformatlist;
564         num_formats = s->session->tlsext_ecpointformatlist_length;
565         for (i = 0; i < num_formats; i++, pformats++) {
566             if (*comp_id == *pformats)
567                 break;
568         }
569         if (i == num_formats)
570             return 0;
571     }
572     if (!curve_id)
573         return 1;
574     /* Check curve is consistent with client and server preferences */
575     for (j = 0; j <= 1; j++) {
576         if (!tls1_get_curvelist(s, j, &pcurves, &num_curves))
577             return 0;
578         if (j == 1 && num_curves == 0) {
579             /*
580              * If we've not received any curves then skip this check.
581              * RFC 4492 does not require the supported elliptic curves extension
582              * so if it is not sent we can just choose any curve.
583              * It is invalid to send an empty list in the elliptic curves
584              * extension, so num_curves == 0 always means no extension.
585              */
586             break;
587         }
588         for (i = 0; i < num_curves; i++, pcurves += 2) {
589             if (pcurves[0] == curve_id[0] && pcurves[1] == curve_id[1])
590                 break;
591         }
592         if (i == num_curves)
593             return 0;
594         /* For clients can only check sent curve list */
595         if (!s->server)
596             break;
597     }
598     return 1;
599 }
600
601 static void tls1_get_formatlist(SSL *s, const unsigned char **pformats,
602                                 size_t *num_formats)
603 {
604     /*
605      * If we have a custom point format list use it otherwise use default
606      */
607     if (s->tlsext_ecpointformatlist) {
608         *pformats = s->tlsext_ecpointformatlist;
609         *num_formats = s->tlsext_ecpointformatlist_length;
610     } else {
611         *pformats = ecformats_default;
612         /* For Suite B we don't support char2 fields */
613         if (tls1_suiteb(s))
614             *num_formats = sizeof(ecformats_default) - 1;
615         else
616             *num_formats = sizeof(ecformats_default);
617     }
618 }
619
620 /*
621  * Check cert parameters compatible with extensions: currently just checks EC
622  * certificates have compatible curves and compression.
623  */
624 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
625 {
626     unsigned char comp_id, curve_id[2];
627     EVP_PKEY *pkey;
628     int rv;
629     pkey = X509_get0_pubkey(x);
630     if (!pkey)
631         return 0;
632     /* If not EC nothing to do */
633     if (EVP_PKEY_id(pkey) != EVP_PKEY_EC)
634         return 1;
635     rv = tls1_set_ec_id(curve_id, &comp_id, EVP_PKEY_get0_EC_KEY(pkey));
636     if (!rv)
637         return 0;
638     /*
639      * Can't check curve_id for client certs as we don't have a supported
640      * curves extension.
641      */
642     rv = tls1_check_ec_key(s, s->server ? curve_id : NULL, &comp_id);
643     if (!rv)
644         return 0;
645     /*
646      * Special case for suite B. We *MUST* sign using SHA256+P-256 or
647      * SHA384+P-384, adjust digest if necessary.
648      */
649     if (set_ee_md && tls1_suiteb(s)) {
650         int check_md;
651         size_t i;
652         CERT *c = s->cert;
653         if (curve_id[0])
654             return 0;
655         /* Check to see we have necessary signing algorithm */
656         if (curve_id[1] == TLSEXT_curve_P_256)
657             check_md = NID_ecdsa_with_SHA256;
658         else if (curve_id[1] == TLSEXT_curve_P_384)
659             check_md = NID_ecdsa_with_SHA384;
660         else
661             return 0;           /* Should never happen */
662         for (i = 0; i < c->shared_sigalgslen; i++)
663             if (check_md == c->shared_sigalgs[i].signandhash_nid)
664                 break;
665         if (i == c->shared_sigalgslen)
666             return 0;
667         if (set_ee_md == 2) {
668             if (check_md == NID_ecdsa_with_SHA256)
669                 s->s3->tmp.md[SSL_PKEY_ECC] = EVP_sha256();
670             else
671                 s->s3->tmp.md[SSL_PKEY_ECC] = EVP_sha384();
672         }
673     }
674     return rv;
675 }
676
677 # ifndef OPENSSL_NO_EC
678 /*
679  * tls1_check_ec_tmp_key - Check EC temporary key compatibility
680  * @s: SSL connection
681  * @cid: Cipher ID we're considering using
682  *
683  * Checks that the kECDHE cipher suite we're considering using
684  * is compatible with the client extensions.
685  *
686  * Returns 0 when the cipher can't be used or 1 when it can.
687  */
688 int tls1_check_ec_tmp_key(SSL *s, unsigned long cid)
689 {
690     /*
691      * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other
692      * curves permitted.
693      */
694     if (tls1_suiteb(s)) {
695         unsigned char curve_id[2];
696         /* Curve to check determined by ciphersuite */
697         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
698             curve_id[1] = TLSEXT_curve_P_256;
699         else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
700             curve_id[1] = TLSEXT_curve_P_384;
701         else
702             return 0;
703         curve_id[0] = 0;
704         /* Check this curve is acceptable */
705         if (!tls1_check_ec_key(s, curve_id, NULL))
706             return 0;
707         return 1;
708     }
709     /* Need a shared curve */
710     if (tls1_shared_group(s, 0))
711         return 1;
712     return 0;
713 }
714 # endif                         /* OPENSSL_NO_EC */
715
716 #else
717
718 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
719 {
720     return 1;
721 }
722
723 #endif                          /* OPENSSL_NO_EC */
724
725 /*
726  * List of supported signature algorithms and hashes. Should make this
727  * customisable at some point, for now include everything we support.
728  */
729
730 #ifdef OPENSSL_NO_RSA
731 # define tlsext_sigalg_rsa(md)  /* */
732 #else
733 # define tlsext_sigalg_rsa(md) md, TLSEXT_signature_rsa,
734 #endif
735
736 #ifdef OPENSSL_NO_DSA
737 # define tlsext_sigalg_dsa(md)  /* */
738 #else
739 # define tlsext_sigalg_dsa(md) md, TLSEXT_signature_dsa,
740 #endif
741
742 #ifdef OPENSSL_NO_EC
743 # define tlsext_sigalg_ecdsa(md)/* */
744 #else
745 # define tlsext_sigalg_ecdsa(md) md, TLSEXT_signature_ecdsa,
746 #endif
747
748 #define tlsext_sigalg(md) \
749                 tlsext_sigalg_rsa(md) \
750                 tlsext_sigalg_dsa(md) \
751                 tlsext_sigalg_ecdsa(md)
752
753 static const unsigned char tls12_sigalgs[] = {
754     tlsext_sigalg(TLSEXT_hash_sha512)
755         tlsext_sigalg(TLSEXT_hash_sha384)
756         tlsext_sigalg(TLSEXT_hash_sha256)
757         tlsext_sigalg(TLSEXT_hash_sha224)
758         tlsext_sigalg(TLSEXT_hash_sha1)
759 #ifndef OPENSSL_NO_GOST
760         TLSEXT_hash_gostr3411, TLSEXT_signature_gostr34102001,
761     TLSEXT_hash_gostr34112012_256, TLSEXT_signature_gostr34102012_256,
762     TLSEXT_hash_gostr34112012_512, TLSEXT_signature_gostr34102012_512
763 #endif
764 };
765
766 #ifndef OPENSSL_NO_EC
767 static const unsigned char suiteb_sigalgs[] = {
768     tlsext_sigalg_ecdsa(TLSEXT_hash_sha256)
769         tlsext_sigalg_ecdsa(TLSEXT_hash_sha384)
770 };
771 #endif
772 size_t tls12_get_psigalgs(SSL *s, const unsigned char **psigs)
773 {
774     /*
775      * If Suite B mode use Suite B sigalgs only, ignore any other
776      * preferences.
777      */
778 #ifndef OPENSSL_NO_EC
779     switch (tls1_suiteb(s)) {
780     case SSL_CERT_FLAG_SUITEB_128_LOS:
781         *psigs = suiteb_sigalgs;
782         return sizeof(suiteb_sigalgs);
783
784     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
785         *psigs = suiteb_sigalgs;
786         return 2;
787
788     case SSL_CERT_FLAG_SUITEB_192_LOS:
789         *psigs = suiteb_sigalgs + 2;
790         return 2;
791     }
792 #endif
793     /* If server use client authentication sigalgs if not NULL */
794     if (s->server && s->cert->client_sigalgs) {
795         *psigs = s->cert->client_sigalgs;
796         return s->cert->client_sigalgslen;
797     } else if (s->cert->conf_sigalgs) {
798         *psigs = s->cert->conf_sigalgs;
799         return s->cert->conf_sigalgslen;
800     } else {
801         *psigs = tls12_sigalgs;
802         return sizeof(tls12_sigalgs);
803     }
804 }
805
806 /*
807  * Check signature algorithm is consistent with sent supported signature
808  * algorithms and if so return relevant digest.
809  */
810 int tls12_check_peer_sigalg(const EVP_MD **pmd, SSL *s,
811                             const unsigned char *sig, EVP_PKEY *pkey)
812 {
813     const unsigned char *sent_sigs;
814     size_t sent_sigslen, i;
815     int sigalg = tls12_get_sigid(pkey);
816     /* Should never happen */
817     if (sigalg == -1)
818         return -1;
819     /* Check key type is consistent with signature */
820     if (sigalg != (int)sig[1]) {
821         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
822         return 0;
823     }
824 #ifndef OPENSSL_NO_EC
825     if (EVP_PKEY_id(pkey) == EVP_PKEY_EC) {
826         unsigned char curve_id[2], comp_id;
827         /* Check compression and curve matches extensions */
828         if (!tls1_set_ec_id(curve_id, &comp_id, EVP_PKEY_get0_EC_KEY(pkey)))
829             return 0;
830         if (!s->server && !tls1_check_ec_key(s, curve_id, &comp_id)) {
831             SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_CURVE);
832             return 0;
833         }
834         /* If Suite B only P-384+SHA384 or P-256+SHA-256 allowed */
835         if (tls1_suiteb(s)) {
836             if (curve_id[0])
837                 return 0;
838             if (curve_id[1] == TLSEXT_curve_P_256) {
839                 if (sig[0] != TLSEXT_hash_sha256) {
840                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
841                            SSL_R_ILLEGAL_SUITEB_DIGEST);
842                     return 0;
843                 }
844             } else if (curve_id[1] == TLSEXT_curve_P_384) {
845                 if (sig[0] != TLSEXT_hash_sha384) {
846                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
847                            SSL_R_ILLEGAL_SUITEB_DIGEST);
848                     return 0;
849                 }
850             } else
851                 return 0;
852         }
853     } else if (tls1_suiteb(s))
854         return 0;
855 #endif
856
857     /* Check signature matches a type we sent */
858     sent_sigslen = tls12_get_psigalgs(s, &sent_sigs);
859     for (i = 0; i < sent_sigslen; i += 2, sent_sigs += 2) {
860         if (sig[0] == sent_sigs[0] && sig[1] == sent_sigs[1])
861             break;
862     }
863     /* Allow fallback to SHA1 if not strict mode */
864     if (i == sent_sigslen
865         && (sig[0] != TLSEXT_hash_sha1
866             || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
867         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
868         return 0;
869     }
870     *pmd = tls12_get_hash(sig[0]);
871     if (*pmd == NULL) {
872         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_UNKNOWN_DIGEST);
873         return 0;
874     }
875     /* Make sure security callback allows algorithm */
876     if (!ssl_security(s, SSL_SECOP_SIGALG_CHECK,
877                       EVP_MD_size(*pmd) * 4, EVP_MD_type(*pmd), (void *)sig)) {
878         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
879         return 0;
880     }
881     /*
882      * Store the digest used so applications can retrieve it if they wish.
883      */
884     s->s3->tmp.peer_md = *pmd;
885     return 1;
886 }
887
888 /*
889  * Set a mask of disabled algorithms: an algorithm is disabled if it isn't
890  * supported, doesn't appear in supported signature algorithms, isn't supported
891  * by the enabled protocol versions or by the security level.
892  *
893  * This function should only be used for checking which ciphers are supported
894  * by the client.
895  *
896  * Call ssl_cipher_disabled() to check that it's enabled or not.
897  */
898 void ssl_set_client_disabled(SSL *s)
899 {
900     s->s3->tmp.mask_a = 0;
901     s->s3->tmp.mask_k = 0;
902     ssl_set_sig_mask(&s->s3->tmp.mask_a, s, SSL_SECOP_SIGALG_MASK);
903     ssl_get_client_min_max_version(s, &s->s3->tmp.min_ver, &s->s3->tmp.max_ver);
904 #ifndef OPENSSL_NO_PSK
905     /* with PSK there must be client callback set */
906     if (!s->psk_client_callback) {
907         s->s3->tmp.mask_a |= SSL_aPSK;
908         s->s3->tmp.mask_k |= SSL_PSK;
909     }
910 #endif                          /* OPENSSL_NO_PSK */
911 #ifndef OPENSSL_NO_SRP
912     if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) {
913         s->s3->tmp.mask_a |= SSL_aSRP;
914         s->s3->tmp.mask_k |= SSL_kSRP;
915     }
916 #endif
917 }
918
919 /*
920  * ssl_cipher_disabled - check that a cipher is disabled or not
921  * @s: SSL connection that you want to use the cipher on
922  * @c: cipher to check
923  * @op: Security check that you want to do
924  *
925  * Returns 1 when it's disabled, 0 when enabled.
926  */
927 int ssl_cipher_disabled(SSL *s, const SSL_CIPHER *c, int op)
928 {
929     if (c->algorithm_mkey & s->s3->tmp.mask_k
930         || c->algorithm_auth & s->s3->tmp.mask_a)
931         return 1;
932     if (s->s3->tmp.max_ver == 0)
933         return 1;
934     if (!SSL_IS_DTLS(s) && ((c->min_tls > s->s3->tmp.max_ver)
935                             || (c->max_tls < s->s3->tmp.min_ver)))
936         return 1;
937     if (SSL_IS_DTLS(s) && (DTLS_VERSION_GT(c->min_dtls, s->s3->tmp.max_ver)
938                            || DTLS_VERSION_LT(c->max_dtls, s->s3->tmp.min_ver)))
939         return 1;
940
941     return !ssl_security(s, op, c->strength_bits, 0, (void *)c);
942 }
943
944 static int tls_use_ticket(SSL *s)
945 {
946     if (s->options & SSL_OP_NO_TICKET)
947         return 0;
948     return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL);
949 }
950
951 static int compare_uint(const void *p1, const void *p2)
952 {
953     unsigned int u1 = *((const unsigned int *)p1);
954     unsigned int u2 = *((const unsigned int *)p2);
955     if (u1 < u2)
956         return -1;
957     else if (u1 > u2)
958         return 1;
959     else
960         return 0;
961 }
962
963 /*
964  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
965  * more than one extension of the same type in a ClientHello or ServerHello.
966  * This function does an initial scan over the extensions block to filter those
967  * out. It returns 1 if all extensions are unique, and 0 if the extensions
968  * contain duplicates, could not be successfully parsed, or an internal error
969  * occurred.
970  */
971 static int tls1_check_duplicate_extensions(const PACKET *packet)
972 {
973     PACKET extensions = *packet;
974     size_t num_extensions = 0, i = 0;
975     unsigned int *extension_types = NULL;
976     int ret = 0;
977
978     /* First pass: count the extensions. */
979     while (PACKET_remaining(&extensions) > 0) {
980         unsigned int type;
981         PACKET extension;
982         if (!PACKET_get_net_2(&extensions, &type) ||
983             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
984             goto done;
985         }
986         num_extensions++;
987     }
988
989     if (num_extensions <= 1)
990         return 1;
991
992     extension_types = OPENSSL_malloc(sizeof(unsigned int) * num_extensions);
993     if (extension_types == NULL) {
994         SSLerr(SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS, ERR_R_MALLOC_FAILURE);
995         goto done;
996     }
997
998     /* Second pass: gather the extension types. */
999     extensions = *packet;
1000     for (i = 0; i < num_extensions; i++) {
1001         PACKET extension;
1002         if (!PACKET_get_net_2(&extensions, &extension_types[i]) ||
1003             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
1004             /* This should not happen. */
1005             SSLerr(SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS, ERR_R_INTERNAL_ERROR);
1006             goto done;
1007         }
1008     }
1009
1010     if (PACKET_remaining(&extensions) != 0) {
1011         SSLerr(SSL_F_TLS1_CHECK_DUPLICATE_EXTENSIONS, ERR_R_INTERNAL_ERROR);
1012         goto done;
1013     }
1014     /* Sort the extensions and make sure there are no duplicates. */
1015     qsort(extension_types, num_extensions, sizeof(unsigned int), compare_uint);
1016     for (i = 1; i < num_extensions; i++) {
1017         if (extension_types[i - 1] == extension_types[i])
1018             goto done;
1019     }
1020     ret = 1;
1021  done:
1022     OPENSSL_free(extension_types);
1023     return ret;
1024 }
1025
1026 int ssl_add_clienthello_tlsext(SSL *s, WPACKET *pkt, int *al)
1027 {
1028 #ifndef OPENSSL_NO_EC
1029     const unsigned char *pcurves = NULL;
1030     size_t num_curves = 0;
1031     int using_ecc = 0;
1032
1033     /* See if we support any ECC ciphersuites */
1034     if ((s->version >= TLS1_VERSION && s->version <= TLS1_2_VERSION)
1035             || SSL_IS_DTLS(s)) {
1036         int i;
1037         unsigned long alg_k, alg_a;
1038         STACK_OF(SSL_CIPHER) *cipher_stack = SSL_get_ciphers(s);
1039
1040         for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
1041             const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
1042
1043             alg_k = c->algorithm_mkey;
1044             alg_a = c->algorithm_auth;
1045             if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
1046                 || (alg_a & SSL_aECDSA)) {
1047                 using_ecc = 1;
1048                 break;
1049             }
1050         }
1051     } else if (SSL_IS_TLS13(s)) {
1052         /*
1053          * TODO(TLS1.3): We always use ECC for TLSv1.3 at the moment. This will
1054          * change if we implement DH key shares
1055          */
1056         using_ecc = 1;
1057     }
1058 #else
1059     if (SSL_IS_TLS13(s)) {
1060         /* Shouldn't happen! */
1061         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1062         return 0;
1063     }
1064 #endif
1065
1066     /* Add RI if renegotiating */
1067     if (s->renegotiate) {
1068         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
1069                 || !WPACKET_start_sub_packet_u16(pkt)
1070                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
1071                                    s->s3->previous_client_finished_len)
1072                 || !WPACKET_close(pkt)) {
1073             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1074             return 0;
1075         }
1076     }
1077     /* Only add RI for SSLv3 */
1078     if (s->client_version == SSL3_VERSION)
1079         goto done;
1080
1081     if (s->tlsext_hostname != NULL) {
1082         /* Add TLS extension servername to the Client Hello message */
1083         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1084                    /* Sub-packet for server_name extension */
1085                 || !WPACKET_start_sub_packet_u16(pkt)
1086                    /* Sub-packet for servername list (always 1 hostname)*/
1087                 || !WPACKET_start_sub_packet_u16(pkt)
1088                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
1089                 || !WPACKET_sub_memcpy_u16(pkt, s->tlsext_hostname,
1090                                            strlen(s->tlsext_hostname))
1091                 || !WPACKET_close(pkt)
1092                 || !WPACKET_close(pkt)) {
1093             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1094             return 0;
1095         }
1096     }
1097 #ifndef OPENSSL_NO_SRP
1098     /* Add SRP username if there is one */
1099     if (s->srp_ctx.login != NULL) {
1100         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
1101                    /* Sub-packet for SRP extension */
1102                 || !WPACKET_start_sub_packet_u16(pkt)
1103                 || !WPACKET_start_sub_packet_u8(pkt)
1104                    /* login must not be zero...internal error if so */
1105                 || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
1106                 || !WPACKET_memcpy(pkt, s->srp_ctx.login,
1107                                    strlen(s->srp_ctx.login))
1108                 || !WPACKET_close(pkt)
1109                 || !WPACKET_close(pkt)) {
1110             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1111             return 0;
1112         }
1113     }
1114 #endif
1115
1116 #ifndef OPENSSL_NO_EC
1117     if (using_ecc) {
1118         /*
1119          * Add TLS extension ECPointFormats to the ClientHello message
1120          */
1121         const unsigned char *pformats, *pcurvestmp;
1122         size_t num_formats;
1123         size_t i;
1124
1125         tls1_get_formatlist(s, &pformats, &num_formats);
1126
1127         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1128                    /* Sub-packet for formats extension */
1129                 || !WPACKET_start_sub_packet_u16(pkt)
1130                 || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
1131                 || !WPACKET_close(pkt)) {
1132             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1133             return 0;
1134         }
1135
1136         /*
1137          * Add TLS extension supported_groups to the ClientHello message
1138          */
1139         /* TODO(TLS1.3): Add support for DHE groups */
1140         pcurves = s->tlsext_supportedgroupslist;
1141         if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
1142             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1143             return 0;
1144         }
1145         pcurvestmp = pcurves;
1146
1147         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
1148                    /* Sub-packet for supported_groups extension */
1149                 || !WPACKET_start_sub_packet_u16(pkt)
1150                 || !WPACKET_start_sub_packet_u16(pkt)) {
1151             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1152             return 0;
1153         }
1154         /* Copy curve ID if supported */
1155         for (i = 0; i < num_curves; i++, pcurvestmp += 2) {
1156             if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
1157                 if (!WPACKET_put_bytes_u8(pkt, pcurvestmp[0])
1158                     || !WPACKET_put_bytes_u8(pkt, pcurvestmp[1])) {
1159                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1160                                ERR_R_INTERNAL_ERROR);
1161                         return 0;
1162                     }
1163             }
1164         }
1165         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1166             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1167             return 0;
1168         }
1169     }
1170 #endif                          /* OPENSSL_NO_EC */
1171
1172     if (tls_use_ticket(s)) {
1173         size_t ticklen;
1174         if (!s->new_session && s->session && s->session->tlsext_tick)
1175             ticklen = s->session->tlsext_ticklen;
1176         else if (s->session && s->tlsext_session_ticket &&
1177                  s->tlsext_session_ticket->data) {
1178             ticklen = s->tlsext_session_ticket->length;
1179             s->session->tlsext_tick = OPENSSL_malloc(ticklen);
1180             if (s->session->tlsext_tick == NULL) {
1181                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1182                 return 0;
1183             }
1184             memcpy(s->session->tlsext_tick,
1185                    s->tlsext_session_ticket->data, ticklen);
1186             s->session->tlsext_ticklen = ticklen;
1187         } else
1188             ticklen = 0;
1189         if (ticklen == 0 && s->tlsext_session_ticket &&
1190             s->tlsext_session_ticket->data == NULL)
1191             goto skip_ext;
1192
1193         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1194                 || !WPACKET_sub_memcpy_u16(pkt, s->session->tlsext_tick,
1195                                            ticklen)) {
1196             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1197             return 0;
1198         }
1199     }
1200  skip_ext:
1201
1202     if (SSL_CLIENT_USE_SIGALGS(s)) {
1203         size_t salglen;
1204         const unsigned char *salg;
1205
1206         salglen = tls12_get_psigalgs(s, &salg);
1207
1208         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
1209                    /* Sub-packet for sig-algs extension */
1210                 || !WPACKET_start_sub_packet_u16(pkt)
1211                    /* Sub-packet for the actual list */
1212                 || !WPACKET_start_sub_packet_u16(pkt)
1213                 || !tls12_copy_sigalgs(s, pkt, salg, salglen)
1214                 || !WPACKET_close(pkt)
1215                 || !WPACKET_close(pkt)) {
1216             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1217             return 0;
1218         }
1219     }
1220 #ifndef OPENSSL_NO_OCSP
1221     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
1222         int i;
1223
1224         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1225                    /* Sub-packet for status request extension */
1226                 || !WPACKET_start_sub_packet_u16(pkt)
1227                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
1228                    /* Sub-packet for the ids */
1229                 || !WPACKET_start_sub_packet_u16(pkt)) {
1230             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1231             return 0;
1232         }
1233         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
1234             unsigned char *idbytes;
1235             int idlen;
1236             OCSP_RESPID *id;
1237
1238             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
1239             idlen = i2d_OCSP_RESPID(id, NULL);
1240             if (idlen <= 0
1241                        /* Sub-packet for an individual id */
1242                     || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
1243                     || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
1244                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1245                 return 0;
1246             }
1247         }
1248         if (!WPACKET_close(pkt)
1249                 || !WPACKET_start_sub_packet_u16(pkt)) {
1250             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1251             return 0;
1252         }
1253         if (s->tlsext_ocsp_exts) {
1254             unsigned char *extbytes;
1255             int extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
1256
1257             if (extlen < 0) {
1258                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1259                 return 0;
1260             }
1261             if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
1262                     || i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &extbytes)
1263                        != extlen) {
1264                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1265                 return 0;
1266            }
1267         }
1268         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1269             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1270             return 0;
1271         }
1272     }
1273 #endif
1274
1275 #ifndef OPENSSL_NO_NEXTPROTONEG
1276     if (s->ctx->next_proto_select_cb && !s->s3->tmp.finish_md_len) {
1277         /*
1278          * The client advertises an empty extension to indicate its support
1279          * for Next Protocol Negotiation
1280          */
1281         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1282                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1283             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1284             return 0;
1285         }
1286     }
1287 #endif
1288
1289     /*
1290      * finish_md_len is non-zero during a renegotiation, so
1291      * this avoids sending ALPN during the renegotiation
1292      * (see longer comment below)
1293      */
1294     if (s->alpn_client_proto_list && !s->s3->tmp.finish_md_len) {
1295         if (!WPACKET_put_bytes_u16(pkt,
1296                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1297                    /* Sub-packet ALPN extension */
1298                 || !WPACKET_start_sub_packet_u16(pkt)
1299                 || !WPACKET_sub_memcpy_u16(pkt, s->alpn_client_proto_list,
1300                                            s->alpn_client_proto_list_len)
1301                 || !WPACKET_close(pkt)) {
1302             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1303             return 0;
1304         }
1305         s->s3->alpn_sent = 1;
1306     }
1307 #ifndef OPENSSL_NO_SRTP
1308     if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)) {
1309         STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
1310         SRTP_PROTECTION_PROFILE *prof;
1311         int i, ct;
1312
1313         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1314                    /* Sub-packet for SRTP extension */
1315                 || !WPACKET_start_sub_packet_u16(pkt)
1316                    /* Sub-packet for the protection profile list */
1317                 || !WPACKET_start_sub_packet_u16(pkt)) {
1318             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1319             return 0;
1320         }
1321         ct = sk_SRTP_PROTECTION_PROFILE_num(clnt);
1322         for (i = 0; i < ct; i++) {
1323             prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
1324             if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
1325                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1326                 return 0;
1327             }
1328         }
1329         if (!WPACKET_close(pkt)
1330                    /* Add an empty use_mki value */
1331                 || !WPACKET_put_bytes_u8(pkt, 0)
1332                 || !WPACKET_close(pkt)) {
1333             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1334             return 0;
1335         }
1336     }
1337 #endif
1338     custom_ext_init(&s->cert->cli_ext);
1339     /* Add custom TLS Extensions to ClientHello */
1340     if (!custom_ext_add(s, 0, pkt, al)) {
1341         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1342         return 0;
1343     }
1344
1345     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) {
1346         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1347             || !WPACKET_put_bytes_u16(pkt, 0)) {
1348             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1349             return 0;
1350         }
1351     }
1352
1353 #ifndef OPENSSL_NO_CT
1354     if (s->ct_validation_callback != NULL) {
1355         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
1356                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1357             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1358             return 0;
1359         }
1360     }
1361 #endif
1362
1363     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1364             || !WPACKET_put_bytes_u16(pkt, 0)) {
1365         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1366         return 0;
1367     }
1368
1369     /* TLS1.3 specific extensions */
1370     if (SSL_IS_TLS13(s)) {
1371         int min_version, max_version, reason, currv;
1372         size_t i, sharessent = 0;
1373
1374         /* TODO(TLS1.3): Should we add this extension for versions < TLS1.3? */
1375         /* supported_versions extension */
1376         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
1377                 || !WPACKET_start_sub_packet_u16(pkt)
1378                 || !WPACKET_start_sub_packet_u8(pkt)) {
1379             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1380             return 0;
1381         }
1382         reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
1383         if (reason != 0) {
1384             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, reason);
1385             return 0;
1386         }
1387         /*
1388          * TODO(TLS1.3): There is some discussion on the TLS list as to wheter
1389          * we should include versions <TLS1.2. For the moment we do. To be
1390          * reviewed later.
1391          */
1392         for (currv = max_version; currv >= min_version; currv--) {
1393             /* TODO(TLS1.3): Remove this first if clause prior to release!! */
1394             if (currv == TLS1_3_VERSION) {
1395                 if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
1396                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1397                            ERR_R_INTERNAL_ERROR);
1398                     return 0;
1399                 }
1400             } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
1401                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1402                 return 0;
1403             }
1404         }
1405         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1406             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1407             return 0;
1408         }
1409
1410
1411         /* key_share extension */
1412         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1413                    /* Extension data sub-packet */
1414                 || !WPACKET_start_sub_packet_u16(pkt)
1415                    /* KeyShare list sub-packet */
1416                 || !WPACKET_start_sub_packet_u16(pkt)) {
1417             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1418             return 0;
1419         }
1420
1421         /*
1422          * TODO(TLS1.3): Make the number of key_shares sent configurable. For
1423          * now, just send one
1424          */
1425         for (i = 0; i < num_curves && sharessent < 1; i++, pcurves += 2) {
1426             unsigned char *encodedPoint = NULL;
1427             unsigned int curve_id = 0;
1428             EVP_PKEY *key_share_key = NULL;
1429             size_t encodedlen;
1430
1431             if (!tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED))
1432                 continue;
1433
1434             if (s->s3->tmp.pkey != NULL) {
1435                 /* Shouldn't happen! */
1436                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1437                        ERR_R_INTERNAL_ERROR);
1438                 return 0;
1439             }
1440
1441             /* Generate a key for this key_share */
1442             curve_id = (pcurves[0] << 8) | pcurves[1];
1443             key_share_key = ssl_generate_pkey_curve(curve_id);
1444             if (key_share_key == NULL) {
1445                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_EVP_LIB);
1446                 return 0;
1447             }
1448
1449             /* Encode the public key. */
1450             encodedlen = EVP_PKEY_get1_tls_encodedpoint(key_share_key,
1451                                                         &encodedPoint);
1452             if (encodedlen == 0) {
1453                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_EC_LIB);
1454                 EVP_PKEY_free(key_share_key);
1455                 return 0;
1456             }
1457
1458             /* Create KeyShareEntry */
1459             if (!WPACKET_put_bytes_u16(pkt, curve_id)
1460                     || !WPACKET_sub_memcpy_u16(pkt, encodedPoint, encodedlen)) {
1461                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1462                        ERR_R_INTERNAL_ERROR);
1463                 EVP_PKEY_free(key_share_key);
1464                 OPENSSL_free(encodedPoint);
1465                 return 0;
1466             }
1467
1468             /*
1469              * TODO(TLS1.3): When changing to send more than one key_share we're
1470              * going to need to be able to save more than one EVP_PKEY. For now
1471              * we reuse the existing tmp.pkey
1472              */
1473             s->s3->group_id = curve_id;
1474             s->s3->tmp.pkey = key_share_key;
1475             sharessent++;
1476             OPENSSL_free(encodedPoint);
1477         }
1478         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1479             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1480             return 0;
1481         }
1482     }
1483
1484     /*
1485      * Add padding to workaround bugs in F5 terminators. See
1486      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
1487      * code works out the length of all existing extensions it MUST always
1488      * appear last.
1489      */
1490     if (s->options & SSL_OP_TLSEXT_PADDING) {
1491         unsigned char *padbytes;
1492         size_t hlen;
1493
1494         if (!WPACKET_get_total_written(pkt, &hlen)) {
1495             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1496             return 0;
1497         }
1498
1499         if (hlen > 0xff && hlen < 0x200) {
1500             hlen = 0x200 - hlen;
1501             if (hlen >= 4)
1502                 hlen -= 4;
1503             else
1504                 hlen = 0;
1505
1506             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
1507                     || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
1508                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1509                 return 0;
1510             }
1511             memset(padbytes, 0, hlen);
1512         }
1513     }
1514
1515  done:
1516     return 1;
1517 }
1518
1519 /*
1520  * Add the key_share extension.
1521  *
1522  * Returns 1 on success or 0 on failure.
1523  */
1524 static int add_client_key_share_ext(SSL *s, WPACKET *pkt, int *al)
1525 {
1526     unsigned char *encodedPoint;
1527     size_t encoded_pt_len = 0;
1528     EVP_PKEY *ckey = s->s3->peer_tmp, *skey = NULL;
1529
1530     if (ckey == NULL) {
1531         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1532         return 0;
1533     }
1534
1535     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1536             || !WPACKET_start_sub_packet_u16(pkt)
1537             || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)) {
1538         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1539         return 0;
1540     }
1541
1542     skey = ssl_generate_pkey(ckey);
1543
1544     /* Generate encoding of server key */
1545     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(skey, &encodedPoint);
1546     if (encoded_pt_len == 0) {
1547         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_EC_LIB);
1548         EVP_PKEY_free(skey);
1549         return 0;
1550     }
1551
1552     if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len)
1553             || !WPACKET_close(pkt)) {
1554         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1555         EVP_PKEY_free(skey);
1556         OPENSSL_free(encodedPoint);
1557         return 0;
1558     }
1559     OPENSSL_free(encodedPoint);
1560
1561     /* This causes the crypto state to be updated based on the derived keys */
1562     s->s3->tmp.pkey = skey;
1563     if (ssl_derive(s, skey, ckey, 1) == 0) {
1564         *al = SSL_AD_INTERNAL_ERROR;
1565         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1566         return 0;
1567     }
1568
1569     return 1;
1570 }
1571
1572 int ssl_add_serverhello_tlsext(SSL *s, WPACKET *pkt, int *al)
1573 {
1574 #ifndef OPENSSL_NO_NEXTPROTONEG
1575     int next_proto_neg_seen;
1576 #endif
1577 #ifndef OPENSSL_NO_EC
1578     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1579     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1580     int using_ecc = (alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA);
1581     using_ecc = using_ecc && (s->session->tlsext_ecpointformatlist != NULL);
1582 #endif
1583
1584     if (!WPACKET_start_sub_packet_u16(pkt)
1585             || !WPACKET_set_flags(pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)) {
1586         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1587         return 0;
1588     }
1589
1590     if (s->s3->send_connection_binding &&
1591             !ssl_add_serverhello_renegotiate_ext(s, pkt)) {
1592         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1593         return 0;
1594     }
1595
1596     /* Only add RI for SSLv3 */
1597     if (s->version == SSL3_VERSION)
1598         goto done;
1599
1600     if (!s->hit && s->servername_done == 1
1601             && s->session->tlsext_hostname != NULL) {
1602         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1603                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1604             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1605             return 0;
1606         }
1607     }
1608 #ifndef OPENSSL_NO_EC
1609     if (using_ecc) {
1610         const unsigned char *plist;
1611         size_t plistlen;
1612         /*
1613          * Add TLS extension ECPointFormats to the ServerHello message
1614          */
1615         tls1_get_formatlist(s, &plist, &plistlen);
1616
1617         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1618                 || !WPACKET_start_sub_packet_u16(pkt)
1619                 || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
1620                 || !WPACKET_close(pkt)) {
1621             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1622             return 0;
1623         }
1624     }
1625     /*
1626      * Currently the server should not respond with a SupportedCurves
1627      * extension
1628      */
1629 #endif                          /* OPENSSL_NO_EC */
1630
1631     if (s->tlsext_ticket_expected && tls_use_ticket(s)) {
1632         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1633                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1634             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1635             return 0;
1636         }
1637     } else {
1638         /*
1639          * if we don't add the above TLSEXT, we can't add a session ticket
1640          * later
1641          */
1642         s->tlsext_ticket_expected = 0;
1643     }
1644
1645     if (s->tlsext_status_expected) {
1646         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1647                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1648             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1649             return 0;
1650         }
1651     }
1652 #ifndef OPENSSL_NO_SRTP
1653     if (SSL_IS_DTLS(s) && s->srtp_profile) {
1654         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1655                 || !WPACKET_start_sub_packet_u16(pkt)
1656                 || !WPACKET_put_bytes_u16(pkt, 2)
1657                 || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
1658                 || !WPACKET_put_bytes_u8(pkt, 0)
1659                 || !WPACKET_close(pkt)) {
1660             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1661             return 0;
1662         }
1663     }
1664 #endif
1665
1666     if (((s->s3->tmp.new_cipher->id & 0xFFFF) == 0x80
1667          || (s->s3->tmp.new_cipher->id & 0xFFFF) == 0x81)
1668         && (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG)) {
1669         const unsigned char cryptopro_ext[36] = {
1670             0xfd, 0xe8,         /* 65000 */
1671             0x00, 0x20,         /* 32 bytes length */
1672             0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1673             0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1674             0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1675             0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1676         };
1677         if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
1678             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1679             return 0;
1680         }
1681     }
1682
1683 #ifndef OPENSSL_NO_NEXTPROTONEG
1684     next_proto_neg_seen = s->s3->next_proto_neg_seen;
1685     s->s3->next_proto_neg_seen = 0;
1686     if (next_proto_neg_seen && s->ctx->next_protos_advertised_cb) {
1687         const unsigned char *npa;
1688         unsigned int npalen;
1689         int r;
1690
1691         r = s->ctx->next_protos_advertised_cb(s, &npa, &npalen,
1692                                               s->
1693                                               ctx->next_protos_advertised_cb_arg);
1694         if (r == SSL_TLSEXT_ERR_OK) {
1695             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1696                     || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
1697                 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1698                 return 0;
1699             }
1700             s->s3->next_proto_neg_seen = 1;
1701         }
1702     }
1703 #endif
1704
1705     if (SSL_IS_TLS13(s) && !s->hit && !add_client_key_share_ext(s, pkt, al))
1706         return 0;
1707
1708     if (!custom_ext_add(s, 1, pkt, al)) {
1709         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1710         return 0;
1711     }
1712
1713     if (s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC) {
1714         /*
1715          * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
1716          * for other cases too.
1717          */
1718         if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
1719             || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
1720             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
1721             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12)
1722             s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1723         else {
1724             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1725                     || !WPACKET_put_bytes_u16(pkt, 0)) {
1726                 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1727                 return 0;
1728             }
1729         }
1730     }
1731     if (s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) {
1732         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1733                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1734             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1735             return 0;
1736         }
1737     }
1738
1739     if (s->s3->alpn_selected != NULL) {
1740         if (!WPACKET_put_bytes_u16(pkt,
1741                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1742                 || !WPACKET_start_sub_packet_u16(pkt)
1743                 || !WPACKET_start_sub_packet_u16(pkt)
1744                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
1745                                           s->s3->alpn_selected_len)
1746                 || !WPACKET_close(pkt)
1747                 || !WPACKET_close(pkt)) {
1748             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1749             return 0;
1750         }
1751     }
1752
1753  done:
1754     if (!WPACKET_close(pkt)) {
1755         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1756         return 0;
1757     }
1758     return 1;
1759 }
1760
1761 /*
1762  * Save the ALPN extension in a ClientHello.
1763  * pkt: the contents of the ALPN extension, not including type and length.
1764  * al: a pointer to the  alert value to send in the event of a failure.
1765  * returns: 1 on success, 0 on error.
1766  */
1767 static int tls1_alpn_handle_client_hello(SSL *s, PACKET *pkt, int *al)
1768 {
1769     PACKET protocol_list, save_protocol_list, protocol;
1770
1771     *al = SSL_AD_DECODE_ERROR;
1772
1773     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
1774         || PACKET_remaining(&protocol_list) < 2) {
1775         return 0;
1776     }
1777
1778     save_protocol_list = protocol_list;
1779     do {
1780         /* Protocol names can't be empty. */
1781         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
1782             || PACKET_remaining(&protocol) == 0) {
1783             return 0;
1784         }
1785     } while (PACKET_remaining(&protocol_list) != 0);
1786
1787     if (!PACKET_memdup(&save_protocol_list,
1788                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
1789         *al = TLS1_AD_INTERNAL_ERROR;
1790         return 0;
1791     }
1792
1793     return 1;
1794 }
1795
1796 /*
1797  * Process the ALPN extension in a ClientHello.
1798  * al: a pointer to the alert value to send in the event of a failure.
1799  * returns 1 on success, 0 on error.
1800  */
1801 static int tls1_alpn_handle_client_hello_late(SSL *s, int *al)
1802 {
1803     const unsigned char *selected = NULL;
1804     unsigned char selected_len = 0;
1805
1806     if (s->ctx->alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
1807         int r = s->ctx->alpn_select_cb(s, &selected, &selected_len,
1808                                        s->s3->alpn_proposed,
1809                                        (unsigned int)s->s3->alpn_proposed_len,
1810                                        s->ctx->alpn_select_cb_arg);
1811
1812         if (r == SSL_TLSEXT_ERR_OK) {
1813             OPENSSL_free(s->s3->alpn_selected);
1814             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
1815             if (s->s3->alpn_selected == NULL) {
1816                 *al = SSL_AD_INTERNAL_ERROR;
1817                 return 0;
1818             }
1819             s->s3->alpn_selected_len = selected_len;
1820 #ifndef OPENSSL_NO_NEXTPROTONEG
1821             /* ALPN takes precedence over NPN. */
1822             s->s3->next_proto_neg_seen = 0;
1823 #endif
1824         } else {
1825             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
1826             return 0;
1827         }
1828     }
1829
1830     return 1;
1831 }
1832
1833 #ifndef OPENSSL_NO_EC
1834 /*-
1835  * ssl_check_for_safari attempts to fingerprint Safari using OS X
1836  * SecureTransport using the TLS extension block in |hello|.
1837  * Safari, since 10.6, sends exactly these extensions, in this order:
1838  *   SNI,
1839  *   elliptic_curves
1840  *   ec_point_formats
1841  *
1842  * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8,
1843  * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them.
1844  * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from
1845  * 10.8..10.8.3 (which don't work).
1846  */
1847 static void ssl_check_for_safari(SSL *s, const CLIENTHELLO_MSG *hello)
1848 {
1849     unsigned int type;
1850     PACKET sni, tmppkt;
1851     size_t ext_len;
1852
1853     static const unsigned char kSafariExtensionsBlock[] = {
1854         0x00, 0x0a,             /* elliptic_curves extension */
1855         0x00, 0x08,             /* 8 bytes */
1856         0x00, 0x06,             /* 6 bytes of curve ids */
1857         0x00, 0x17,             /* P-256 */
1858         0x00, 0x18,             /* P-384 */
1859         0x00, 0x19,             /* P-521 */
1860
1861         0x00, 0x0b,             /* ec_point_formats */
1862         0x00, 0x02,             /* 2 bytes */
1863         0x01,                   /* 1 point format */
1864         0x00,                   /* uncompressed */
1865         /* The following is only present in TLS 1.2 */
1866         0x00, 0x0d,             /* signature_algorithms */
1867         0x00, 0x0c,             /* 12 bytes */
1868         0x00, 0x0a,             /* 10 bytes */
1869         0x05, 0x01,             /* SHA-384/RSA */
1870         0x04, 0x01,             /* SHA-256/RSA */
1871         0x02, 0x01,             /* SHA-1/RSA */
1872         0x04, 0x03,             /* SHA-256/ECDSA */
1873         0x02, 0x03,             /* SHA-1/ECDSA */
1874     };
1875
1876     /* Length of the common prefix (first two extensions). */
1877     static const size_t kSafariCommonExtensionsLength = 18;
1878
1879     tmppkt = hello->extensions;
1880
1881     if (!PACKET_forward(&tmppkt, 2)
1882         || !PACKET_get_net_2(&tmppkt, &type)
1883         || !PACKET_get_length_prefixed_2(&tmppkt, &sni)) {
1884         return;
1885     }
1886
1887     if (type != TLSEXT_TYPE_server_name)
1888         return;
1889
1890     ext_len = TLS1_get_client_version(s) >= TLS1_2_VERSION ?
1891         sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength;
1892
1893     s->s3->is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock,
1894                                              ext_len);
1895 }
1896 #endif                          /* !OPENSSL_NO_EC */
1897
1898
1899 /*
1900  * Process the supported_groups extension if present. Returns success if the
1901  * extension is absent, or if it has been successfully processed.
1902  *
1903  * Returns 1 on success or 0 on failure
1904  */
1905 static int tls_process_supported_groups(SSL *s, CLIENTHELLO_MSG *hello)
1906 {
1907 #ifndef OPENSSL_NO_EC
1908     PACKET supported_groups_list;
1909     RAW_EXTENSION *suppgroups = tls_get_extension_by_type(hello->pre_proc_exts,
1910                                     hello->num_extensions,
1911                                     TLSEXT_TYPE_supported_groups);
1912
1913     if (suppgroups == NULL)
1914         return 1;
1915
1916     /* Each group is 2 bytes and we must have at least 1. */
1917     if (!PACKET_as_length_prefixed_2(&suppgroups->data,
1918                                      &supported_groups_list)
1919         || PACKET_remaining(&supported_groups_list) == 0
1920         || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
1921         return 0;
1922     }
1923
1924     if (!s->hit
1925             && !PACKET_memdup(&supported_groups_list,
1926                               &s->session->tlsext_supportedgroupslist,
1927                               &s->session->tlsext_supportedgroupslist_length)) {
1928         return 0;
1929     }
1930 #endif
1931     return 1;
1932 }
1933
1934 /*
1935  * Checks a list of |groups| to determine if the |group_id| is in it. If it is
1936  * and |checkallow| is 1 then additionally check if the group is allowed to be
1937  * used. Returns 1 if the group is in the list (and allowed if |checkallow| is
1938  * 1) or 0 otherwise.
1939  */
1940 static int check_in_list(SSL *s, unsigned int group_id,
1941                          const unsigned char *groups, size_t num_groups,
1942                          int checkallow)
1943 {
1944     size_t i;
1945
1946     if (groups == NULL || num_groups == 0)
1947         return 0;
1948
1949     for (i = 0; i < num_groups; i++, groups += 2) {
1950         unsigned int share_id = (groups[0] << 8) | (groups[1]);
1951
1952         if (group_id == share_id
1953                 && (!checkallow || tls_curve_allowed(s, groups,
1954                                                      SSL_SECOP_CURVE_CHECK))) {
1955             break;
1956         }
1957     }
1958
1959     /* If i == num_groups then not in the list */
1960     return i < num_groups;
1961 }
1962
1963 /*
1964  * Process a key_share extension received in the ClientHello. |pkt| contains
1965  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
1966  * If a failure occurs then |*al| is set to an appropriate alert value.
1967  */
1968 static int process_key_share_ext(SSL *s, PACKET *pkt, int *al)
1969 {
1970     unsigned int group_id;
1971     PACKET key_share_list, encoded_pt;
1972     const unsigned char *curves;
1973     size_t num_curves;
1974     int group_nid, found = 0;
1975     unsigned int curve_flags;
1976
1977     /* Sanity check */
1978     if (s->s3->peer_tmp != NULL) {
1979         *al = SSL_AD_INTERNAL_ERROR;
1980         SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1981         return 0;
1982     }
1983
1984     if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) {
1985         *al = SSL_AD_HANDSHAKE_FAILURE;
1986         SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
1987                SSL_R_LENGTH_MISMATCH);
1988         return 0;
1989     }
1990
1991     while (PACKET_remaining(&key_share_list) > 0) {
1992         if (!PACKET_get_net_2(&key_share_list, &group_id)
1993                 || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt)
1994                 || PACKET_remaining(&encoded_pt) == 0) {
1995             *al = SSL_AD_HANDSHAKE_FAILURE;
1996             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
1997                    SSL_R_LENGTH_MISMATCH);
1998             return 0;
1999         }
2000
2001         /*
2002          * If we already found a suitable key_share we loop through the
2003          * rest to verify the structure, but don't process them.
2004          */
2005         if (found)
2006             continue;
2007
2008         /* Check if this share is in supported_groups sent from client */
2009         if (!tls1_get_curvelist(s, 1, &curves, &num_curves)) {
2010             *al = SSL_AD_INTERNAL_ERROR;
2011             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
2012                    ERR_R_INTERNAL_ERROR);
2013             return 0;
2014         }
2015         if (!check_in_list(s, group_id, curves, num_curves, 0)) {
2016             *al = SSL_AD_HANDSHAKE_FAILURE;
2017             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
2018                    SSL_R_BAD_KEY_SHARE);
2019             return 0;
2020         }
2021
2022         /* Check if this share is for a group we can use */
2023         if (!tls1_get_curvelist(s, 0, &curves, &num_curves)) {
2024             *al = SSL_AD_INTERNAL_ERROR;
2025             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
2026                    ERR_R_INTERNAL_ERROR);
2027             return 0;
2028         }
2029         if (!check_in_list(s, group_id, curves, num_curves, 1)) {
2030             /* Share not suitable */
2031             continue;
2032         }
2033
2034         group_nid = tls1_ec_curve_id2nid(group_id, &curve_flags);
2035
2036         if (group_nid == 0) {
2037             *al = SSL_AD_INTERNAL_ERROR;
2038             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
2039                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
2040             return 0;
2041         }
2042
2043         if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
2044             /* Can happen for some curves, e.g. X25519 */
2045             EVP_PKEY *key = EVP_PKEY_new();
2046
2047             if (key == NULL || !EVP_PKEY_set_type(key, group_nid)) {
2048                 *al = SSL_AD_INTERNAL_ERROR;
2049                 SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT, ERR_R_EVP_LIB);
2050                 EVP_PKEY_free(key);
2051                 return 0;
2052             }
2053             s->s3->peer_tmp = key;
2054         } else {
2055             /* Set up EVP_PKEY with named curve as parameters */
2056             EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
2057             if (pctx == NULL
2058                     || EVP_PKEY_paramgen_init(pctx) <= 0
2059                     || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2060                                                               group_nid) <= 0
2061                     || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
2062                 *al = SSL_AD_INTERNAL_ERROR;
2063                 SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT, ERR_R_EVP_LIB);
2064                 EVP_PKEY_CTX_free(pctx);
2065                 return 0;
2066             }
2067             EVP_PKEY_CTX_free(pctx);
2068             pctx = NULL;
2069         }
2070         s->s3->group_id = group_id;
2071
2072         if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
2073                 PACKET_data(&encoded_pt),
2074                 PACKET_remaining(&encoded_pt))) {
2075             *al = SSL_AD_DECODE_ERROR;
2076             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT, SSL_R_BAD_ECPOINT);
2077             return 0;
2078         }
2079
2080         found = 1;
2081     }
2082
2083     return 1;
2084 }
2085
2086 /*
2087  * Loop through all remaining ClientHello extensions that we collected earlier
2088  * and haven't already processed. For each one parse it and update the SSL
2089  * object as required.
2090  *
2091  * Behaviour upon resumption is extension-specific. If the extension has no
2092  * effect during resumption, it is parsed (to verify its format) but otherwise
2093  * ignored.
2094  *
2095  * Returns 1 on success and 0 on failure.
2096  * Upon failure, sets |al| to the appropriate alert.
2097  */
2098 static int ssl_scan_clienthello_tlsext(SSL *s, CLIENTHELLO_MSG *hello, int *al)
2099 {
2100     size_t loop;
2101     int renegotiate_seen = 0;
2102
2103     *al = SSL_AD_DECODE_ERROR;
2104     s->servername_done = 0;
2105     s->tlsext_status_type = -1;
2106 #ifndef OPENSSL_NO_NEXTPROTONEG
2107     s->s3->next_proto_neg_seen = 0;
2108 #endif
2109
2110     OPENSSL_free(s->s3->alpn_selected);
2111     s->s3->alpn_selected = NULL;
2112     s->s3->alpn_selected_len = 0;
2113     OPENSSL_free(s->s3->alpn_proposed);
2114     s->s3->alpn_proposed = NULL;
2115     s->s3->alpn_proposed_len = 0;
2116
2117 #ifndef OPENSSL_NO_EC
2118     if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
2119         ssl_check_for_safari(s, hello);
2120 #endif                          /* !OPENSSL_NO_EC */
2121
2122     /* Clear any signature algorithms extension received */
2123     OPENSSL_free(s->s3->tmp.peer_sigalgs);
2124     s->s3->tmp.peer_sigalgs = NULL;
2125     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
2126
2127 #ifndef OPENSSL_NO_SRP
2128     OPENSSL_free(s->srp_ctx.login);
2129     s->srp_ctx.login = NULL;
2130 #endif
2131
2132     s->srtp_profile = NULL;
2133
2134     /*
2135      * We process the supported_groups extension first so that is done before
2136      * we get to key_share which needs to use the information in it.
2137      */
2138     if (!tls_process_supported_groups(s, hello)) {
2139         *al = TLS1_AD_INTERNAL_ERROR;
2140         return 0;
2141     }
2142
2143     /*
2144      * We parse all extensions to ensure the ClientHello is well-formed but,
2145      * unless an extension specifies otherwise, we ignore extensions upon
2146      * resumption.
2147      */
2148     for (loop = 0; loop < hello->num_extensions; loop++) {
2149         RAW_EXTENSION *currext = &hello->pre_proc_exts[loop];
2150
2151         if (s->tlsext_debug_cb)
2152             s->tlsext_debug_cb(s, 0, currext->type,
2153                                PACKET_data(&currext->data),
2154                                PACKET_remaining(&currext->data),
2155                                s->tlsext_debug_arg);
2156
2157         if (currext->type == TLSEXT_TYPE_renegotiate) {
2158             if (!ssl_parse_clienthello_renegotiate_ext(s,
2159                     &currext->data, al))
2160                 return 0;
2161             renegotiate_seen = 1;
2162         } else if (s->version == SSL3_VERSION) {
2163         }
2164 /*-
2165  * The servername extension is treated as follows:
2166  *
2167  * - Only the hostname type is supported with a maximum length of 255.
2168  * - The servername is rejected if too long or if it contains zeros,
2169  *   in which case an fatal alert is generated.
2170  * - The servername field is maintained together with the session cache.
2171  * - When a session is resumed, the servername call back invoked in order
2172  *   to allow the application to position itself to the right context.
2173  * - The servername is acknowledged if it is new for a session or when
2174  *   it is identical to a previously used for the same session.
2175  *   Applications can control the behaviour.  They can at any time
2176  *   set a 'desirable' servername for a new SSL object. This can be the
2177  *   case for example with HTTPS when a Host: header field is received and
2178  *   a renegotiation is requested. In this case, a possible servername
2179  *   presented in the new client hello is only acknowledged if it matches
2180  *   the value of the Host: field.
2181  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
2182  *   if they provide for changing an explicit servername context for the
2183  *   session, i.e. when the session has been established with a servername
2184  *   extension.
2185  * - On session reconnect, the servername extension may be absent.
2186  *
2187  */
2188
2189         else if (currext->type == TLSEXT_TYPE_server_name) {
2190             unsigned int servname_type;
2191             PACKET sni, hostname;
2192
2193             if (!PACKET_as_length_prefixed_2(&currext->data, &sni)
2194                 /* ServerNameList must be at least 1 byte long. */
2195                 || PACKET_remaining(&sni) == 0) {
2196                 return 0;
2197             }
2198
2199             /*
2200              * Although the server_name extension was intended to be
2201              * extensible to new name types, RFC 4366 defined the
2202              * syntax inextensibility and OpenSSL 1.0.x parses it as
2203              * such.
2204              * RFC 6066 corrected the mistake but adding new name types
2205              * is nevertheless no longer feasible, so act as if no other
2206              * SNI types can exist, to simplify parsing.
2207              *
2208              * Also note that the RFC permits only one SNI value per type,
2209              * i.e., we can only have a single hostname.
2210              */
2211             if (!PACKET_get_1(&sni, &servname_type)
2212                 || servname_type != TLSEXT_NAMETYPE_host_name
2213                 || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
2214                 return 0;
2215             }
2216
2217             if (!s->hit) {
2218                 if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
2219                     *al = TLS1_AD_UNRECOGNIZED_NAME;
2220                     return 0;
2221                 }
2222
2223                 if (PACKET_contains_zero_byte(&hostname)) {
2224                     *al = TLS1_AD_UNRECOGNIZED_NAME;
2225                     return 0;
2226                 }
2227
2228                 if (!PACKET_strndup(&hostname, &s->session->tlsext_hostname)) {
2229                     *al = TLS1_AD_INTERNAL_ERROR;
2230                     return 0;
2231                 }
2232
2233                 s->servername_done = 1;
2234             } else {
2235                 /*
2236                  * TODO(openssl-team): if the SNI doesn't match, we MUST
2237                  * fall back to a full handshake.
2238                  */
2239                 s->servername_done = s->session->tlsext_hostname
2240                     && PACKET_equal(&hostname, s->session->tlsext_hostname,
2241                                     strlen(s->session->tlsext_hostname));
2242             }
2243         }
2244 #ifndef OPENSSL_NO_SRP
2245         else if (currext->type == TLSEXT_TYPE_srp) {
2246             PACKET srp_I;
2247
2248             if (!PACKET_as_length_prefixed_1(&currext->data, &srp_I))
2249                 return 0;
2250
2251             if (PACKET_contains_zero_byte(&srp_I))
2252                 return 0;
2253
2254             /*
2255              * TODO(openssl-team): currently, we re-authenticate the user
2256              * upon resumption. Instead, we MUST ignore the login.
2257              */
2258             if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
2259                 *al = TLS1_AD_INTERNAL_ERROR;
2260                 return 0;
2261             }
2262         }
2263 #endif
2264
2265 #ifndef OPENSSL_NO_EC
2266         else if (currext->type == TLSEXT_TYPE_ec_point_formats) {
2267             PACKET ec_point_format_list;
2268
2269             if (!PACKET_as_length_prefixed_1(&currext->data,
2270                                              &ec_point_format_list)
2271                 || PACKET_remaining(&ec_point_format_list) == 0) {
2272                 return 0;
2273             }
2274
2275             if (!s->hit) {
2276                 if (!PACKET_memdup(&ec_point_format_list,
2277                                    &s->session->tlsext_ecpointformatlist,
2278                                    &s->
2279                                    session->tlsext_ecpointformatlist_length)) {
2280                     *al = TLS1_AD_INTERNAL_ERROR;
2281                     return 0;
2282                 }
2283             }
2284         }
2285 #endif                          /* OPENSSL_NO_EC */
2286         else if (currext->type == TLSEXT_TYPE_session_ticket) {
2287             if (s->tls_session_ticket_ext_cb &&
2288                 !s->tls_session_ticket_ext_cb(s,
2289                     PACKET_data(&currext->data),
2290                     PACKET_remaining(&currext->data),
2291                     s->tls_session_ticket_ext_cb_arg)) {
2292                 *al = TLS1_AD_INTERNAL_ERROR;
2293                 return 0;
2294             }
2295         } else if (currext->type == TLSEXT_TYPE_signature_algorithms) {
2296             PACKET supported_sig_algs;
2297
2298             if (!PACKET_as_length_prefixed_2(&currext->data,
2299                                              &supported_sig_algs)
2300                 || (PACKET_remaining(&supported_sig_algs) % 2) != 0
2301                 || PACKET_remaining(&supported_sig_algs) == 0) {
2302                 return 0;
2303             }
2304
2305             if (!s->hit) {
2306                 if (!tls1_save_sigalgs(s, PACKET_data(&supported_sig_algs),
2307                                        PACKET_remaining(&supported_sig_algs))) {
2308                     return 0;
2309                 }
2310             }
2311         } else if (currext->type == TLSEXT_TYPE_status_request) {
2312             if (!PACKET_get_1(&currext->data,
2313                               (unsigned int *)&s->tlsext_status_type)) {
2314                 return 0;
2315             }
2316 #ifndef OPENSSL_NO_OCSP
2317             if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
2318                 const unsigned char *ext_data;
2319                 PACKET responder_id_list, exts;
2320                 if (!PACKET_get_length_prefixed_2
2321                     (&currext->data, &responder_id_list))
2322                     return 0;
2323
2324                 /*
2325                  * We remove any OCSP_RESPIDs from a previous handshake
2326                  * to prevent unbounded memory growth - CVE-2016-6304
2327                  */
2328                 sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids,
2329                                         OCSP_RESPID_free);
2330                 if (PACKET_remaining(&responder_id_list) > 0) {
2331                     s->tlsext_ocsp_ids = sk_OCSP_RESPID_new_null();
2332                     if (s->tlsext_ocsp_ids == NULL) {
2333                         *al = SSL_AD_INTERNAL_ERROR;
2334                         return 0;
2335                     }
2336                 } else {
2337                     s->tlsext_ocsp_ids = NULL;
2338                 }
2339
2340                 while (PACKET_remaining(&responder_id_list) > 0) {
2341                     OCSP_RESPID *id;
2342                     PACKET responder_id;
2343                     const unsigned char *id_data;
2344
2345                     if (!PACKET_get_length_prefixed_2(&responder_id_list,
2346                                                       &responder_id)
2347                         || PACKET_remaining(&responder_id) == 0) {
2348                         return 0;
2349                     }
2350
2351                     id_data = PACKET_data(&responder_id);
2352                     /* TODO(size_t): Convert d2i_* to size_t */
2353                     id = d2i_OCSP_RESPID(NULL, &id_data,
2354                                          (int)PACKET_remaining(&responder_id));
2355                     if (id == NULL)
2356                         return 0;
2357
2358                     if (id_data != PACKET_end(&responder_id)) {
2359                         OCSP_RESPID_free(id);
2360                         return 0;
2361                     }
2362
2363                     if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
2364                         OCSP_RESPID_free(id);
2365                         *al = SSL_AD_INTERNAL_ERROR;
2366                         return 0;
2367                     }
2368                 }
2369
2370                 /* Read in request_extensions */
2371                 if (!PACKET_as_length_prefixed_2(
2372                         &currext->data, &exts))
2373                     return 0;
2374
2375                 if (PACKET_remaining(&exts) > 0) {
2376                     ext_data = PACKET_data(&exts);
2377                     sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
2378                                                X509_EXTENSION_free);
2379                     s->tlsext_ocsp_exts =
2380                         d2i_X509_EXTENSIONS(NULL, &ext_data,
2381                                             (int)PACKET_remaining(&exts));
2382                     if (s->tlsext_ocsp_exts == NULL
2383                         || ext_data != PACKET_end(&exts)) {
2384                         return 0;
2385                     }
2386                 }
2387             } else
2388 #endif
2389             {
2390                 /*
2391                  * We don't know what to do with any other type so ignore it.
2392                  */
2393                 s->tlsext_status_type = -1;
2394             }
2395         }
2396 #ifndef OPENSSL_NO_NEXTPROTONEG
2397         else if (currext->type == TLSEXT_TYPE_next_proto_neg
2398                  && s->s3->tmp.finish_md_len == 0) {
2399             /*-
2400              * We shouldn't accept this extension on a
2401              * renegotiation.
2402              *
2403              * s->new_session will be set on renegotiation, but we
2404              * probably shouldn't rely that it couldn't be set on
2405              * the initial renegotiation too in certain cases (when
2406              * there's some other reason to disallow resuming an
2407              * earlier session -- the current code won't be doing
2408              * anything like that, but this might change).
2409              *
2410              * A valid sign that there's been a previous handshake
2411              * in this connection is if s->s3->tmp.finish_md_len >
2412              * 0.  (We are talking about a check that will happen
2413              * in the Hello protocol round, well before a new
2414              * Finished message could have been computed.)
2415              */
2416             s->s3->next_proto_neg_seen = 1;
2417         }
2418 #endif
2419
2420         else if (currext->type
2421                      == TLSEXT_TYPE_application_layer_protocol_negotiation
2422                  && s->s3->tmp.finish_md_len == 0) {
2423             if (!tls1_alpn_handle_client_hello(s,
2424                     &currext->data, al))
2425                 return 0;
2426         }
2427
2428         /* session ticket processed earlier */
2429 #ifndef OPENSSL_NO_SRTP
2430         else if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)
2431                  && currext->type == TLSEXT_TYPE_use_srtp) {
2432             if (ssl_parse_clienthello_use_srtp_ext(s,
2433                     &currext->data, al))
2434                 return 0;
2435         }
2436 #endif
2437         else if (currext->type == TLSEXT_TYPE_encrypt_then_mac
2438                  && !(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) {
2439             s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2440         } else if (currext->type == TLSEXT_TYPE_key_share
2441                    && SSL_IS_TLS13(s) && !s->hit
2442                    && !process_key_share_ext(s, &currext->data, al)) {
2443             return 0;
2444         }
2445         /*
2446          * Note: extended master secret extension handled in
2447          * tls_check_client_ems_support()
2448          */
2449
2450         /*
2451          * If this ClientHello extension was unhandled and this is a
2452          * nonresumed connection, check whether the extension is a custom
2453          * TLS Extension (has a custom_srv_ext_record), and if so call the
2454          * callback and record the extension number so that an appropriate
2455          * ServerHello may be later returned.
2456          */
2457         else if (!s->hit) {
2458             if (custom_ext_parse(s, 1, currext->type,
2459                     PACKET_data(&currext->data),
2460                     PACKET_remaining(&currext->data), al) <= 0)
2461                 return 0;
2462         }
2463     }
2464
2465     /* Need RI if renegotiating */
2466
2467     if (!renegotiate_seen && s->renegotiate &&
2468         !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2469         *al = SSL_AD_HANDSHAKE_FAILURE;
2470         SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2471                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2472         return 0;
2473     }
2474
2475     /*
2476      * This function currently has no state to clean up, so it returns directly.
2477      * If parsing fails at any point, the function returns early.
2478      * The SSL object may be left with partial data from extensions, but it must
2479      * then no longer be used, and clearing it up will free the leftovers.
2480      */
2481     return 1;
2482 }
2483
2484 int ssl_parse_clienthello_tlsext(SSL *s, CLIENTHELLO_MSG *hello)
2485 {
2486     int al = -1;
2487     custom_ext_init(&s->cert->srv_ext);
2488     if (ssl_scan_clienthello_tlsext(s, hello, &al) <= 0) {
2489         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2490         return 0;
2491     }
2492     if (ssl_check_clienthello_tlsext_early(s) <= 0) {
2493         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT, SSL_R_CLIENTHELLO_TLSEXT);
2494         return 0;
2495     }
2496     return 1;
2497 }
2498
2499 #ifndef OPENSSL_NO_NEXTPROTONEG
2500 /*
2501  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
2502  * elements of zero length are allowed and the set of elements must exactly
2503  * fill the length of the block.
2504  */
2505 static char ssl_next_proto_validate(PACKET *pkt)
2506 {
2507     PACKET tmp_protocol;
2508
2509     while (PACKET_remaining(pkt)) {
2510         if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol)
2511             || PACKET_remaining(&tmp_protocol) == 0)
2512             return 0;
2513     }
2514
2515     return 1;
2516 }
2517 #endif
2518
2519 static int ssl_scan_serverhello_tlsext(SSL *s, PACKET *pkt, int *al)
2520 {
2521     unsigned int length, type, size;
2522     int tlsext_servername = 0;
2523     int renegotiate_seen = 0;
2524
2525 #ifndef OPENSSL_NO_NEXTPROTONEG
2526     s->s3->next_proto_neg_seen = 0;
2527 #endif
2528     s->tlsext_ticket_expected = 0;
2529
2530     OPENSSL_free(s->s3->alpn_selected);
2531     s->s3->alpn_selected = NULL;
2532
2533     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
2534
2535     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
2536
2537     if (!PACKET_get_net_2(pkt, &length))
2538         goto ri_check;
2539
2540     if (PACKET_remaining(pkt) != length) {
2541         *al = SSL_AD_DECODE_ERROR;
2542         return 0;
2543     }
2544
2545     if (!tls1_check_duplicate_extensions(pkt)) {
2546         *al = SSL_AD_DECODE_ERROR;
2547         return 0;
2548     }
2549
2550     while (PACKET_get_net_2(pkt, &type) && PACKET_get_net_2(pkt, &size)) {
2551         const unsigned char *data;
2552         PACKET spkt;
2553
2554         if (!PACKET_get_sub_packet(pkt, &spkt, size)
2555             || !PACKET_peek_bytes(&spkt, &data, size))
2556             goto ri_check;
2557
2558         if (s->tlsext_debug_cb)
2559             s->tlsext_debug_cb(s, 1, type, data, size, s->tlsext_debug_arg);
2560
2561         if (type == TLSEXT_TYPE_renegotiate) {
2562             if (!ssl_parse_serverhello_renegotiate_ext(s, &spkt, al))
2563                 return 0;
2564             renegotiate_seen = 1;
2565         } else if (s->version == SSL3_VERSION) {
2566         } else if (type == TLSEXT_TYPE_server_name) {
2567             if (s->tlsext_hostname == NULL || size > 0) {
2568                 *al = TLS1_AD_UNRECOGNIZED_NAME;
2569                 return 0;
2570             }
2571             tlsext_servername = 1;
2572         }
2573 #ifndef OPENSSL_NO_EC
2574         else if (type == TLSEXT_TYPE_ec_point_formats) {
2575             unsigned int ecpointformatlist_length;
2576             if (!PACKET_get_1(&spkt, &ecpointformatlist_length)
2577                 || ecpointformatlist_length != size - 1) {
2578                 *al = TLS1_AD_DECODE_ERROR;
2579                 return 0;
2580             }
2581             if (!s->hit) {
2582                 s->session->tlsext_ecpointformatlist_length = 0;
2583                 OPENSSL_free(s->session->tlsext_ecpointformatlist);
2584                 if ((s->session->tlsext_ecpointformatlist =
2585                      OPENSSL_malloc(ecpointformatlist_length)) == NULL) {
2586                     *al = TLS1_AD_INTERNAL_ERROR;
2587                     return 0;
2588                 }
2589                 s->session->tlsext_ecpointformatlist_length =
2590                     ecpointformatlist_length;
2591                 if (!PACKET_copy_bytes(&spkt,
2592                                        s->session->tlsext_ecpointformatlist,
2593                                        ecpointformatlist_length)) {
2594                     *al = TLS1_AD_DECODE_ERROR;
2595                     return 0;
2596                 }
2597
2598             }
2599         }
2600 #endif                          /* OPENSSL_NO_EC */
2601
2602         else if (type == TLSEXT_TYPE_session_ticket) {
2603             if (s->tls_session_ticket_ext_cb &&
2604                 !s->tls_session_ticket_ext_cb(s, data, size,
2605                                               s->tls_session_ticket_ext_cb_arg))
2606             {
2607                 *al = TLS1_AD_INTERNAL_ERROR;
2608                 return 0;
2609             }
2610             if (!tls_use_ticket(s) || (size > 0)) {
2611                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2612                 return 0;
2613             }
2614             s->tlsext_ticket_expected = 1;
2615         } else if (type == TLSEXT_TYPE_status_request) {
2616             /*
2617              * MUST be empty and only sent if we've requested a status
2618              * request message.
2619              */
2620             if ((s->tlsext_status_type == -1) || (size > 0)) {
2621                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2622                 return 0;
2623             }
2624             /* Set flag to expect CertificateStatus message */
2625             s->tlsext_status_expected = 1;
2626         }
2627 #ifndef OPENSSL_NO_CT
2628         /*
2629          * Only take it if we asked for it - i.e if there is no CT validation
2630          * callback set, then a custom extension MAY be processing it, so we
2631          * need to let control continue to flow to that.
2632          */
2633         else if (type == TLSEXT_TYPE_signed_certificate_timestamp &&
2634                  s->ct_validation_callback != NULL) {
2635             /* Simply copy it off for later processing */
2636             if (s->tlsext_scts != NULL) {
2637                 OPENSSL_free(s->tlsext_scts);
2638                 s->tlsext_scts = NULL;
2639             }
2640             s->tlsext_scts_len = size;
2641             if (size > 0) {
2642                 s->tlsext_scts = OPENSSL_malloc(size);
2643                 if (s->tlsext_scts == NULL) {
2644                     *al = TLS1_AD_INTERNAL_ERROR;
2645                     return 0;
2646                 }
2647                 memcpy(s->tlsext_scts, data, size);
2648             }
2649         }
2650 #endif
2651 #ifndef OPENSSL_NO_NEXTPROTONEG
2652         else if (type == TLSEXT_TYPE_next_proto_neg &&
2653                  s->s3->tmp.finish_md_len == 0) {
2654             unsigned char *selected;
2655             unsigned char selected_len;
2656             /* We must have requested it. */
2657             if (s->ctx->next_proto_select_cb == NULL) {
2658                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2659                 return 0;
2660             }
2661             /* The data must be valid */
2662             if (!ssl_next_proto_validate(&spkt)) {
2663                 *al = TLS1_AD_DECODE_ERROR;
2664                 return 0;
2665             }
2666             if (s->ctx->next_proto_select_cb(s, &selected, &selected_len, data,
2667                                              size,
2668                                              s->
2669                                              ctx->next_proto_select_cb_arg) !=
2670                 SSL_TLSEXT_ERR_OK) {
2671                 *al = TLS1_AD_INTERNAL_ERROR;
2672                 return 0;
2673             }
2674             /*
2675              * Could be non-NULL if server has sent multiple NPN extensions in
2676              * a single Serverhello
2677              */
2678             OPENSSL_free(s->next_proto_negotiated);
2679             s->next_proto_negotiated = OPENSSL_malloc(selected_len);
2680             if (s->next_proto_negotiated == NULL) {
2681                 *al = TLS1_AD_INTERNAL_ERROR;
2682                 return 0;
2683             }
2684             memcpy(s->next_proto_negotiated, selected, selected_len);
2685             s->next_proto_negotiated_len = selected_len;
2686             s->s3->next_proto_neg_seen = 1;
2687         }
2688 #endif
2689
2690         else if (type == TLSEXT_TYPE_application_layer_protocol_negotiation) {
2691             unsigned len;
2692             /* We must have requested it. */
2693             if (!s->s3->alpn_sent) {
2694                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2695                 return 0;
2696             }
2697             /*-
2698              * The extension data consists of:
2699              *   uint16 list_length
2700              *   uint8 proto_length;
2701              *   uint8 proto[proto_length];
2702              */
2703             if (!PACKET_get_net_2(&spkt, &len)
2704                 || PACKET_remaining(&spkt) != len || !PACKET_get_1(&spkt, &len)
2705                 || PACKET_remaining(&spkt) != len) {
2706                 *al = TLS1_AD_DECODE_ERROR;
2707                 return 0;
2708             }
2709             OPENSSL_free(s->s3->alpn_selected);
2710             s->s3->alpn_selected = OPENSSL_malloc(len);
2711             if (s->s3->alpn_selected == NULL) {
2712                 *al = TLS1_AD_INTERNAL_ERROR;
2713                 return 0;
2714             }
2715             if (!PACKET_copy_bytes(&spkt, s->s3->alpn_selected, len)) {
2716                 *al = TLS1_AD_DECODE_ERROR;
2717                 return 0;
2718             }
2719             s->s3->alpn_selected_len = len;
2720         }
2721 #ifndef OPENSSL_NO_SRTP
2722         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_use_srtp) {
2723             if (ssl_parse_serverhello_use_srtp_ext(s, &spkt, al))
2724                 return 0;
2725         }
2726 #endif
2727         else if (type == TLSEXT_TYPE_encrypt_then_mac) {
2728             /* Ignore if inappropriate ciphersuite */
2729             if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) &&
2730                 s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
2731                 && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
2732                 s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2733         } else if (type == TLSEXT_TYPE_extended_master_secret &&
2734                 (SSL_IS_DTLS(s) || !SSL_IS_TLS13(s))) {
2735             s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
2736             if (!s->hit)
2737                 s->session->flags |= SSL_SESS_FLAG_EXTMS;
2738         } else if (type == TLSEXT_TYPE_key_share
2739                 && SSL_IS_TLS13(s)) {
2740             unsigned int group_id;
2741             PACKET encoded_pt;
2742             EVP_PKEY *ckey = s->s3->tmp.pkey, *skey = NULL;
2743
2744             /* Sanity check */
2745             if (ckey == NULL) {
2746                 *al = SSL_AD_INTERNAL_ERROR;
2747                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
2748                 return 0;
2749             }
2750
2751             if (!PACKET_get_net_2(&spkt, &group_id)) {
2752                 *al = SSL_AD_HANDSHAKE_FAILURE;
2753                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2754                        SSL_R_LENGTH_MISMATCH);
2755                 return 0;
2756             }
2757
2758             if (group_id != s->s3->group_id) {
2759                 /*
2760                  * This isn't for the group that we sent in the original
2761                  * key_share!
2762                  */
2763                 *al = SSL_AD_HANDSHAKE_FAILURE;
2764                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2765                        SSL_R_BAD_KEY_SHARE);
2766                 return 0;
2767             }
2768
2769             if (!PACKET_as_length_prefixed_2(&spkt, &encoded_pt)
2770                     || PACKET_remaining(&encoded_pt) == 0) {
2771                 *al = SSL_AD_DECODE_ERROR;
2772                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2773                        SSL_R_LENGTH_MISMATCH);
2774                 return 0;
2775             }
2776
2777             skey = ssl_generate_pkey(ckey);
2778             if (!EVP_PKEY_set1_tls_encodedpoint(skey, PACKET_data(&encoded_pt),
2779                                                 PACKET_remaining(&encoded_pt))) {
2780                 *al = SSL_AD_DECODE_ERROR;
2781                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_BAD_ECPOINT);
2782                 return 0;
2783             }
2784
2785             if (ssl_derive(s, ckey, skey, 1) == 0) {
2786                 *al = SSL_AD_INTERNAL_ERROR;
2787                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
2788                 EVP_PKEY_free(skey);
2789                 return 0;
2790             }
2791             EVP_PKEY_free(skey);
2792         /*
2793          * If this extension type was not otherwise handled, but matches a
2794          * custom_cli_ext_record, then send it to the c callback
2795          */
2796         } else if (custom_ext_parse(s, 0, type, data, size, al) <= 0)
2797             return 0;
2798     }
2799
2800     if (PACKET_remaining(pkt) != 0) {
2801         *al = SSL_AD_DECODE_ERROR;
2802         return 0;
2803     }
2804
2805     if (!s->hit && tlsext_servername == 1) {
2806         if (s->tlsext_hostname) {
2807             if (s->session->tlsext_hostname == NULL) {
2808                 s->session->tlsext_hostname =
2809                     OPENSSL_strdup(s->tlsext_hostname);
2810                 if (!s->session->tlsext_hostname) {
2811                     *al = SSL_AD_UNRECOGNIZED_NAME;
2812                     return 0;
2813                 }
2814             } else {
2815                 *al = SSL_AD_DECODE_ERROR;
2816                 return 0;
2817             }
2818         }
2819     }
2820
2821  ri_check:
2822
2823     /*
2824      * Determine if we need to see RI. Strictly speaking if we want to avoid
2825      * an attack we should *always* see RI even on initial server hello
2826      * because the client doesn't see any renegotiation during an attack.
2827      * However this would mean we could not connect to any server which
2828      * doesn't support RI so for the immediate future tolerate RI absence
2829      */
2830     if (!renegotiate_seen && !(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
2831         && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2832         *al = SSL_AD_HANDSHAKE_FAILURE;
2833         SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2834                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2835         return 0;
2836     }
2837
2838     if (s->hit) {
2839         /*
2840          * Check extended master secret extension is consistent with
2841          * original session.
2842          */
2843         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
2844             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
2845             *al = SSL_AD_HANDSHAKE_FAILURE;
2846             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_INCONSISTENT_EXTMS);
2847             return 0;
2848         }
2849     }
2850
2851     return 1;
2852 }
2853
2854 int ssl_prepare_clienthello_tlsext(SSL *s)
2855 {
2856     s->s3->alpn_sent = 0;
2857     return 1;
2858 }
2859
2860 int ssl_prepare_serverhello_tlsext(SSL *s)
2861 {
2862     return 1;
2863 }
2864
2865 static int ssl_check_clienthello_tlsext_early(SSL *s)
2866 {
2867     int ret = SSL_TLSEXT_ERR_NOACK;
2868     int al = SSL_AD_UNRECOGNIZED_NAME;
2869
2870 #ifndef OPENSSL_NO_EC
2871     /*
2872      * The handling of the ECPointFormats extension is done elsewhere, namely
2873      * in ssl3_choose_cipher in s3_lib.c.
2874      */
2875     /*
2876      * The handling of the EllipticCurves extension is done elsewhere, namely
2877      * in ssl3_choose_cipher in s3_lib.c.
2878      */
2879 #endif
2880
2881     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2882         ret =
2883             s->ctx->tlsext_servername_callback(s, &al,
2884                                                s->ctx->tlsext_servername_arg);
2885     else if (s->initial_ctx != NULL
2886              && s->initial_ctx->tlsext_servername_callback != 0)
2887         ret =
2888             s->initial_ctx->tlsext_servername_callback(s, &al,
2889                                                        s->
2890                                                        initial_ctx->tlsext_servername_arg);
2891
2892     switch (ret) {
2893     case SSL_TLSEXT_ERR_ALERT_FATAL:
2894         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2895         return -1;
2896
2897     case SSL_TLSEXT_ERR_ALERT_WARNING:
2898         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2899         return 1;
2900
2901     case SSL_TLSEXT_ERR_NOACK:
2902         s->servername_done = 0;
2903     default:
2904         return 1;
2905     }
2906 }
2907
2908 /* Initialise digests to default values */
2909 void ssl_set_default_md(SSL *s)
2910 {
2911     const EVP_MD **pmd = s->s3->tmp.md;
2912 #ifndef OPENSSL_NO_DSA
2913     pmd[SSL_PKEY_DSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2914 #endif
2915 #ifndef OPENSSL_NO_RSA
2916     if (SSL_USE_SIGALGS(s))
2917         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2918     else
2919         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_MD5_SHA1_IDX);
2920     pmd[SSL_PKEY_RSA_ENC] = pmd[SSL_PKEY_RSA_SIGN];
2921 #endif
2922 #ifndef OPENSSL_NO_EC
2923     pmd[SSL_PKEY_ECC] = ssl_md(SSL_MD_SHA1_IDX);
2924 #endif
2925 #ifndef OPENSSL_NO_GOST
2926     pmd[SSL_PKEY_GOST01] = ssl_md(SSL_MD_GOST94_IDX);
2927     pmd[SSL_PKEY_GOST12_256] = ssl_md(SSL_MD_GOST12_256_IDX);
2928     pmd[SSL_PKEY_GOST12_512] = ssl_md(SSL_MD_GOST12_512_IDX);
2929 #endif
2930 }
2931
2932 int tls1_set_server_sigalgs(SSL *s)
2933 {
2934     int al;
2935     size_t i;
2936
2937     /* Clear any shared signature algorithms */
2938     OPENSSL_free(s->cert->shared_sigalgs);
2939     s->cert->shared_sigalgs = NULL;
2940     s->cert->shared_sigalgslen = 0;
2941     /* Clear certificate digests and validity flags */
2942     for (i = 0; i < SSL_PKEY_NUM; i++) {
2943         s->s3->tmp.md[i] = NULL;
2944         s->s3->tmp.valid_flags[i] = 0;
2945     }
2946
2947     /* If sigalgs received process it. */
2948     if (s->s3->tmp.peer_sigalgs) {
2949         if (!tls1_process_sigalgs(s)) {
2950             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS, ERR_R_MALLOC_FAILURE);
2951             al = SSL_AD_INTERNAL_ERROR;
2952             goto err;
2953         }
2954         /* Fatal error is no shared signature algorithms */
2955         if (!s->cert->shared_sigalgs) {
2956             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS,
2957                    SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
2958             al = SSL_AD_ILLEGAL_PARAMETER;
2959             goto err;
2960         }
2961     } else {
2962         ssl_set_default_md(s);
2963     }
2964     return 1;
2965  err:
2966     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2967     return 0;
2968 }
2969
2970 /*
2971  * Upon success, returns 1.
2972  * Upon failure, returns 0 and sets |al| to the appropriate fatal alert.
2973  */
2974 int ssl_check_clienthello_tlsext_late(SSL *s, int *al)
2975 {
2976     s->tlsext_status_expected = 0;
2977
2978     /*
2979      * If status request then ask callback what to do. Note: this must be
2980      * called after servername callbacks in case the certificate has changed,
2981      * and must be called after the cipher has been chosen because this may
2982      * influence which certificate is sent
2983      */
2984     if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb) {
2985         int ret;
2986         CERT_PKEY *certpkey;
2987         certpkey = ssl_get_server_send_pkey(s);
2988         /* If no certificate can't return certificate status */
2989         if (certpkey != NULL) {
2990             /*
2991              * Set current certificate to one we will use so SSL_get_certificate
2992              * et al can pick it up.
2993              */
2994             s->cert->key = certpkey;
2995             ret = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2996             switch (ret) {
2997                 /* We don't want to send a status request response */
2998             case SSL_TLSEXT_ERR_NOACK:
2999                 s->tlsext_status_expected = 0;
3000                 break;
3001                 /* status request response should be sent */
3002             case SSL_TLSEXT_ERR_OK:
3003                 if (s->tlsext_ocsp_resp)
3004                     s->tlsext_status_expected = 1;
3005                 break;
3006                 /* something bad happened */
3007             case SSL_TLSEXT_ERR_ALERT_FATAL:
3008             default:
3009                 *al = SSL_AD_INTERNAL_ERROR;
3010                 return 0;
3011             }
3012         }
3013     }
3014
3015     if (!tls1_alpn_handle_client_hello_late(s, al)) {
3016         return 0;
3017     }
3018
3019     return 1;
3020 }
3021
3022 int ssl_check_serverhello_tlsext(SSL *s)
3023 {
3024     int ret = SSL_TLSEXT_ERR_NOACK;
3025     int al = SSL_AD_UNRECOGNIZED_NAME;
3026
3027 #ifndef OPENSSL_NO_EC
3028     /*
3029      * If we are client and using an elliptic curve cryptography cipher
3030      * suite, then if server returns an EC point formats lists extension it
3031      * must contain uncompressed.
3032      */
3033     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3034     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
3035     if ((s->tlsext_ecpointformatlist != NULL)
3036         && (s->tlsext_ecpointformatlist_length > 0)
3037         && (s->session->tlsext_ecpointformatlist != NULL)
3038         && (s->session->tlsext_ecpointformatlist_length > 0)
3039         && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
3040         /* we are using an ECC cipher */
3041         size_t i;
3042         unsigned char *list;
3043         int found_uncompressed = 0;
3044         list = s->session->tlsext_ecpointformatlist;
3045         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
3046             if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed) {
3047                 found_uncompressed = 1;
3048                 break;
3049             }
3050         }
3051         if (!found_uncompressed) {
3052             SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,
3053                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
3054             return -1;
3055         }
3056     }
3057     ret = SSL_TLSEXT_ERR_OK;
3058 #endif                          /* OPENSSL_NO_EC */
3059
3060     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
3061         ret =
3062             s->ctx->tlsext_servername_callback(s, &al,
3063                                                s->ctx->tlsext_servername_arg);
3064     else if (s->initial_ctx != NULL
3065              && s->initial_ctx->tlsext_servername_callback != 0)
3066         ret =
3067             s->initial_ctx->tlsext_servername_callback(s, &al,
3068                                                        s->
3069                                                        initial_ctx->tlsext_servername_arg);
3070
3071     /*
3072      * Ensure we get sensible values passed to tlsext_status_cb in the event
3073      * that we don't receive a status message
3074      */
3075     OPENSSL_free(s->tlsext_ocsp_resp);
3076     s->tlsext_ocsp_resp = NULL;
3077     s->tlsext_ocsp_resplen = 0;
3078
3079     switch (ret) {
3080     case SSL_TLSEXT_ERR_ALERT_FATAL:
3081         ssl3_send_alert(s, SSL3_AL_FATAL, al);
3082         return -1;
3083
3084     case SSL_TLSEXT_ERR_ALERT_WARNING:
3085         ssl3_send_alert(s, SSL3_AL_WARNING, al);
3086         return 1;
3087
3088     case SSL_TLSEXT_ERR_NOACK:
3089         s->servername_done = 0;
3090     default:
3091         return 1;
3092     }
3093 }
3094
3095 int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt)
3096 {
3097     int al = -1;
3098     if (s->version < SSL3_VERSION)
3099         return 1;
3100     if (ssl_scan_serverhello_tlsext(s, pkt, &al) <= 0) {
3101         ssl3_send_alert(s, SSL3_AL_FATAL, al);
3102         return 0;
3103     }
3104
3105     if (ssl_check_serverhello_tlsext(s) <= 0) {
3106         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT, SSL_R_SERVERHELLO_TLSEXT);
3107         return 0;
3108     }
3109     return 1;
3110 }
3111
3112 /*
3113  * Given a list of extensions that we collected earlier, find one of a given
3114  * type and return it.
3115  *
3116  * |exts| is the set of extensions previously collected.
3117  * |numexts| is the number of extensions that we have.
3118  * |type| the type of the extension that we are looking for.
3119  *
3120  * Returns a pointer to the found RAW_EXTENSION data, or NULL if not found.
3121  */
3122 RAW_EXTENSION *tls_get_extension_by_type(RAW_EXTENSION *exts, size_t numexts,
3123                                          unsigned int type)
3124 {
3125     size_t loop;
3126
3127     for (loop = 0; loop < numexts; loop++) {
3128         if (exts[loop].type == type)
3129             return &exts[loop];
3130     }
3131
3132     return NULL;
3133 }
3134
3135 /*-
3136  * Gets the ticket information supplied by the client if any.
3137  *
3138  *   hello: The parsed ClientHello data
3139  *   ret: (output) on return, if a ticket was decrypted, then this is set to
3140  *       point to the resulting session.
3141  *
3142  * If s->tls_session_secret_cb is set then we are expecting a pre-shared key
3143  * ciphersuite, in which case we have no use for session tickets and one will
3144  * never be decrypted, nor will s->tlsext_ticket_expected be set to 1.
3145  *
3146  * Returns:
3147  *   -1: fatal error, either from parsing or decrypting the ticket.
3148  *    0: no ticket was found (or was ignored, based on settings).
3149  *    1: a zero length extension was found, indicating that the client supports
3150  *       session tickets but doesn't currently have one to offer.
3151  *    2: either s->tls_session_secret_cb was set, or a ticket was offered but
3152  *       couldn't be decrypted because of a non-fatal error.
3153  *    3: a ticket was successfully decrypted and *ret was set.
3154  *
3155  * Side effects:
3156  *   Sets s->tlsext_ticket_expected to 1 if the server will have to issue
3157  *   a new session ticket to the client because the client indicated support
3158  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
3159  *   a session ticket or we couldn't use the one it gave us, or if
3160  *   s->ctx->tlsext_ticket_key_cb asked to renew the client's ticket.
3161  *   Otherwise, s->tlsext_ticket_expected is set to 0.
3162  */
3163 int tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
3164                                SSL_SESSION **ret)
3165 {
3166     int retv;
3167     const unsigned char *etick;
3168     size_t size;
3169     RAW_EXTENSION *ticketext;
3170
3171     *ret = NULL;
3172     s->tlsext_ticket_expected = 0;
3173
3174     /*
3175      * If tickets disabled behave as if no ticket present to permit stateful
3176      * resumption.
3177      */
3178     if (s->version <= SSL3_VERSION || !tls_use_ticket(s))
3179         return 0;
3180
3181     ticketext = tls_get_extension_by_type(hello->pre_proc_exts,
3182                                           hello->num_extensions,
3183                                           TLSEXT_TYPE_session_ticket);
3184     if (ticketext == NULL)
3185         return 0;
3186
3187     size = PACKET_remaining(&ticketext->data);
3188     if (size == 0) {
3189         /*
3190          * The client will accept a ticket but doesn't currently have
3191          * one.
3192          */
3193         s->tlsext_ticket_expected = 1;
3194         return 1;
3195     }
3196     if (s->tls_session_secret_cb) {
3197         /*
3198          * Indicate that the ticket couldn't be decrypted rather than
3199          * generating the session from ticket now, trigger
3200          * abbreviated handshake based on external mechanism to
3201          * calculate the master secret later.
3202          */
3203         return 2;
3204     }
3205     if (!PACKET_get_bytes(&ticketext->data, &etick, size)) {
3206         /* Shouldn't ever happen */
3207         return -1;
3208     }
3209     retv = tls_decrypt_ticket(s, etick, size, hello->session_id,
3210                            hello->session_id_len, ret);
3211     switch (retv) {
3212     case 2:            /* ticket couldn't be decrypted */
3213         s->tlsext_ticket_expected = 1;
3214         return 2;
3215
3216     case 3:            /* ticket was decrypted */
3217         return 3;
3218
3219     case 4:            /* ticket decrypted but need to renew */
3220         s->tlsext_ticket_expected = 1;
3221         return 3;
3222
3223     default:           /* fatal error */
3224         return -1;
3225     }
3226 }
3227
3228 /*
3229  * Sets the extended master secret flag if the extension is present in the
3230  * ClientHello and we can support it
3231  * Returns:
3232  *  1 on success
3233  *  0 on error
3234  */
3235 int tls_check_client_ems_support(SSL *s, const CLIENTHELLO_MSG *hello)
3236 {
3237     RAW_EXTENSION *emsext;
3238
3239     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
3240
3241     if (!SSL_IS_DTLS(s) && (s->version < TLS1_VERSION
3242                             || s->version > TLS1_2_VERSION))
3243         return 1;
3244
3245     emsext = tls_get_extension_by_type(hello->pre_proc_exts,
3246                                        hello->num_extensions,
3247                                        TLSEXT_TYPE_extended_master_secret);
3248
3249     /*
3250      * No extensions is a success - we have successfully discovered that the
3251      * client doesn't support EMS.
3252      */
3253     if (emsext == NULL)
3254         return 1;
3255
3256     /* The extensions must always be empty */
3257     if (PACKET_remaining(&emsext->data) != 0)
3258         return 0;
3259
3260     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
3261
3262     return 1;
3263 }
3264
3265 /*-
3266  * tls_decrypt_ticket attempts to decrypt a session ticket.
3267  *
3268  *   etick: points to the body of the session ticket extension.
3269  *   eticklen: the length of the session tickets extension.
3270  *   sess_id: points at the session ID.
3271  *   sesslen: the length of the session ID.
3272  *   psess: (output) on return, if a ticket was decrypted, then this is set to
3273  *       point to the resulting session.
3274  *
3275  * Returns:
3276  *   -2: fatal error, malloc failure.
3277  *   -1: fatal error, either from parsing or decrypting the ticket.
3278  *    2: the ticket couldn't be decrypted.
3279  *    3: a ticket was successfully decrypted and *psess was set.
3280  *    4: same as 3, but the ticket needs to be renewed.
3281  */
3282 static int tls_decrypt_ticket(SSL *s, const unsigned char *etick,
3283                               size_t eticklen, const unsigned char *sess_id,
3284                               size_t sesslen, SSL_SESSION **psess)
3285 {
3286     SSL_SESSION *sess;
3287     unsigned char *sdec;
3288     const unsigned char *p;
3289     int slen, renew_ticket = 0, ret = -1, declen;
3290     size_t mlen;
3291     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
3292     HMAC_CTX *hctx = NULL;
3293     EVP_CIPHER_CTX *ctx;
3294     SSL_CTX *tctx = s->initial_ctx;
3295
3296     /* Initialize session ticket encryption and HMAC contexts */
3297     hctx = HMAC_CTX_new();
3298     if (hctx == NULL)
3299         return -2;
3300     ctx = EVP_CIPHER_CTX_new();
3301     if (ctx == NULL) {
3302         ret = -2;
3303         goto err;
3304     }
3305     if (tctx->tlsext_ticket_key_cb) {
3306         unsigned char *nctick = (unsigned char *)etick;
3307         int rv = tctx->tlsext_ticket_key_cb(s, nctick, nctick + 16,
3308                                             ctx, hctx, 0);
3309         if (rv < 0)
3310             goto err;
3311         if (rv == 0) {
3312             ret = 2;
3313             goto err;
3314         }
3315         if (rv == 2)
3316             renew_ticket = 1;
3317     } else {
3318         /* Check key name matches */
3319         if (memcmp(etick, tctx->tlsext_tick_key_name,
3320                    sizeof(tctx->tlsext_tick_key_name)) != 0) {
3321             ret = 2;
3322             goto err;
3323         }
3324         if (HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
3325                          sizeof(tctx->tlsext_tick_hmac_key),
3326                          EVP_sha256(), NULL) <= 0
3327             || EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL,
3328                                   tctx->tlsext_tick_aes_key,
3329                                   etick + sizeof(tctx->tlsext_tick_key_name)) <=
3330             0) {
3331             goto err;
3332         }
3333     }
3334     /*
3335      * Attempt to process session ticket, first conduct sanity and integrity
3336      * checks on ticket.
3337      */
3338     mlen = HMAC_size(hctx);
3339     if (mlen == 0) {
3340         goto err;
3341     }
3342     /* Sanity check ticket length: must exceed keyname + IV + HMAC */
3343     if (eticklen <=
3344         TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_iv_length(ctx) + mlen) {
3345         ret = 2;
3346         goto err;
3347     }
3348     eticklen -= mlen;
3349     /* Check HMAC of encrypted ticket */
3350     if (HMAC_Update(hctx, etick, eticklen) <= 0
3351         || HMAC_Final(hctx, tick_hmac, NULL) <= 0) {
3352         goto err;
3353     }
3354     HMAC_CTX_free(hctx);
3355     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
3356         EVP_CIPHER_CTX_free(ctx);
3357         return 2;
3358     }
3359     /* Attempt to decrypt session data */
3360     /* Move p after IV to start of encrypted ticket, update length */
3361     p = etick + 16 + EVP_CIPHER_CTX_iv_length(ctx);
3362     eticklen -= 16 + EVP_CIPHER_CTX_iv_length(ctx);
3363     sdec = OPENSSL_malloc(eticklen);
3364     if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p,
3365                                           (int)eticklen) <= 0) {
3366         EVP_CIPHER_CTX_free(ctx);
3367         OPENSSL_free(sdec);
3368         return -1;
3369     }
3370     if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) {
3371         EVP_CIPHER_CTX_free(ctx);
3372         OPENSSL_free(sdec);
3373         return 2;
3374     }
3375     slen += declen;
3376     EVP_CIPHER_CTX_free(ctx);
3377     ctx = NULL;
3378     p = sdec;
3379
3380     sess = d2i_SSL_SESSION(NULL, &p, slen);
3381     OPENSSL_free(sdec);
3382     if (sess) {
3383         /*
3384          * The session ID, if non-empty, is used by some clients to detect
3385          * that the ticket has been accepted. So we copy it to the session
3386          * structure. If it is empty set length to zero as required by
3387          * standard.
3388          */
3389         if (sesslen)
3390             memcpy(sess->session_id, sess_id, sesslen);
3391         sess->session_id_length = sesslen;
3392         *psess = sess;
3393         if (renew_ticket)
3394             return 4;
3395         else
3396             return 3;
3397     }
3398     ERR_clear_error();
3399     /*
3400      * For session parse failure, indicate that we need to send a new ticket.
3401      */
3402     return 2;
3403  err:
3404     EVP_CIPHER_CTX_free(ctx);
3405     HMAC_CTX_free(hctx);
3406     return ret;
3407 }
3408
3409 /* Tables to translate from NIDs to TLS v1.2 ids */
3410
3411 typedef struct {
3412     int nid;
3413     int id;
3414 } tls12_lookup;
3415
3416 static const tls12_lookup tls12_md[] = {
3417     {NID_md5, TLSEXT_hash_md5},
3418     {NID_sha1, TLSEXT_hash_sha1},
3419     {NID_sha224, TLSEXT_hash_sha224},
3420     {NID_sha256, TLSEXT_hash_sha256},
3421     {NID_sha384, TLSEXT_hash_sha384},
3422     {NID_sha512, TLSEXT_hash_sha512},
3423     {NID_id_GostR3411_94, TLSEXT_hash_gostr3411},
3424     {NID_id_GostR3411_2012_256, TLSEXT_hash_gostr34112012_256},
3425     {NID_id_GostR3411_2012_512, TLSEXT_hash_gostr34112012_512},
3426 };
3427
3428 static const tls12_lookup tls12_sig[] = {
3429     {EVP_PKEY_RSA, TLSEXT_signature_rsa},
3430     {EVP_PKEY_DSA, TLSEXT_signature_dsa},
3431     {EVP_PKEY_EC, TLSEXT_signature_ecdsa},
3432     {NID_id_GostR3410_2001, TLSEXT_signature_gostr34102001},
3433     {NID_id_GostR3410_2012_256, TLSEXT_signature_gostr34102012_256},
3434     {NID_id_GostR3410_2012_512, TLSEXT_signature_gostr34102012_512}
3435 };
3436
3437 static int tls12_find_id(int nid, const tls12_lookup *table, size_t tlen)
3438 {
3439     size_t i;
3440     for (i = 0; i < tlen; i++) {
3441         if (table[i].nid == nid)
3442             return table[i].id;
3443     }
3444     return -1;
3445 }
3446
3447 static int tls12_find_nid(int id, const tls12_lookup *table, size_t tlen)
3448 {
3449     size_t i;
3450     for (i = 0; i < tlen; i++) {
3451         if ((table[i].id) == id)
3452             return table[i].nid;
3453     }
3454     return NID_undef;
3455 }
3456
3457 int tls12_get_sigandhash(WPACKET *pkt, const EVP_PKEY *pk, const EVP_MD *md)
3458 {
3459     int sig_id, md_id;
3460
3461     if (md == NULL)
3462         return 0;
3463     md_id = tls12_find_id(EVP_MD_type(md), tls12_md, OSSL_NELEM(tls12_md));
3464     if (md_id == -1)
3465         return 0;
3466     sig_id = tls12_get_sigid(pk);
3467     if (sig_id == -1)
3468         return 0;
3469     if (!WPACKET_put_bytes_u8(pkt, md_id) || !WPACKET_put_bytes_u8(pkt, sig_id))
3470         return 0;
3471
3472     return 1;
3473 }
3474
3475 int tls12_get_sigid(const EVP_PKEY *pk)
3476 {
3477     return tls12_find_id(EVP_PKEY_id(pk), tls12_sig, OSSL_NELEM(tls12_sig));
3478 }
3479
3480 typedef struct {
3481     int nid;
3482     int secbits;
3483     int md_idx;
3484     unsigned char tlsext_hash;
3485 } tls12_hash_info;
3486
3487 static const tls12_hash_info tls12_md_info[] = {
3488     {NID_md5, 64, SSL_MD_MD5_IDX, TLSEXT_hash_md5},
3489     {NID_sha1, 80, SSL_MD_SHA1_IDX, TLSEXT_hash_sha1},
3490     {NID_sha224, 112, SSL_MD_SHA224_IDX, TLSEXT_hash_sha224},
3491     {NID_sha256, 128, SSL_MD_SHA256_IDX, TLSEXT_hash_sha256},
3492     {NID_sha384, 192, SSL_MD_SHA384_IDX, TLSEXT_hash_sha384},
3493     {NID_sha512, 256, SSL_MD_SHA512_IDX, TLSEXT_hash_sha512},
3494     {NID_id_GostR3411_94, 128, SSL_MD_GOST94_IDX, TLSEXT_hash_gostr3411},
3495     {NID_id_GostR3411_2012_256, 128, SSL_MD_GOST12_256_IDX,
3496      TLSEXT_hash_gostr34112012_256},
3497     {NID_id_GostR3411_2012_512, 256, SSL_MD_GOST12_512_IDX,
3498      TLSEXT_hash_gostr34112012_512},
3499 };
3500
3501 static const tls12_hash_info *tls12_get_hash_info(unsigned char hash_alg)
3502 {
3503     unsigned int i;
3504     if (hash_alg == 0)
3505         return NULL;
3506
3507     for (i = 0; i < OSSL_NELEM(tls12_md_info); i++) {
3508         if (tls12_md_info[i].tlsext_hash == hash_alg)
3509             return tls12_md_info + i;
3510     }
3511
3512     return NULL;
3513 }
3514
3515 const EVP_MD *tls12_get_hash(unsigned char hash_alg)
3516 {
3517     const tls12_hash_info *inf;
3518     if (hash_alg == TLSEXT_hash_md5 && FIPS_mode())
3519         return NULL;
3520     inf = tls12_get_hash_info(hash_alg);
3521     if (!inf)
3522         return NULL;
3523     return ssl_md(inf->md_idx);
3524 }
3525
3526 static int tls12_get_pkey_idx(unsigned char sig_alg)
3527 {
3528     switch (sig_alg) {
3529 #ifndef OPENSSL_NO_RSA
3530     case TLSEXT_signature_rsa:
3531         return SSL_PKEY_RSA_SIGN;
3532 #endif
3533 #ifndef OPENSSL_NO_DSA
3534     case TLSEXT_signature_dsa:
3535         return SSL_PKEY_DSA_SIGN;
3536 #endif
3537 #ifndef OPENSSL_NO_EC
3538     case TLSEXT_signature_ecdsa:
3539         return SSL_PKEY_ECC;
3540 #endif
3541 #ifndef OPENSSL_NO_GOST
3542     case TLSEXT_signature_gostr34102001:
3543         return SSL_PKEY_GOST01;
3544
3545     case TLSEXT_signature_gostr34102012_256:
3546         return SSL_PKEY_GOST12_256;
3547
3548     case TLSEXT_signature_gostr34102012_512:
3549         return SSL_PKEY_GOST12_512;
3550 #endif
3551     }
3552     return -1;
3553 }
3554
3555 /* Convert TLS 1.2 signature algorithm extension values into NIDs */
3556 static void tls1_lookup_sigalg(int *phash_nid, int *psign_nid,
3557                                int *psignhash_nid, const unsigned char *data)
3558 {
3559     int sign_nid = NID_undef, hash_nid = NID_undef;
3560     if (!phash_nid && !psign_nid && !psignhash_nid)
3561         return;
3562     if (phash_nid || psignhash_nid) {
3563         hash_nid = tls12_find_nid(data[0], tls12_md, OSSL_NELEM(tls12_md));
3564         if (phash_nid)
3565             *phash_nid = hash_nid;
3566     }
3567     if (psign_nid || psignhash_nid) {
3568         sign_nid = tls12_find_nid(data[1], tls12_sig, OSSL_NELEM(tls12_sig));
3569         if (psign_nid)
3570             *psign_nid = sign_nid;
3571     }
3572     if (psignhash_nid) {
3573         if (sign_nid == NID_undef || hash_nid == NID_undef
3574             || OBJ_find_sigid_by_algs(psignhash_nid, hash_nid, sign_nid) <= 0)
3575             *psignhash_nid = NID_undef;
3576     }
3577 }