Fix some style issues identified during review
[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     tls13_setup_key_block,
85     tls13_generate_master_secret,
86     tls13_change_cipher_state,
87     tls13_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) || SSL_IS_TLS13(s))
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     int min_version, max_version, reason;
1033
1034     /* See if we support any ECC ciphersuites */
1035     if ((s->version >= TLS1_VERSION && s->version <= TLS1_3_VERSION)
1036             || SSL_IS_DTLS(s)) {
1037         int i;
1038         unsigned long alg_k, alg_a;
1039         STACK_OF(SSL_CIPHER) *cipher_stack = SSL_get_ciphers(s);
1040
1041         for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
1042             const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
1043
1044             alg_k = c->algorithm_mkey;
1045             alg_a = c->algorithm_auth;
1046             if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
1047                 || (alg_a & SSL_aECDSA)
1048                 || c->min_tls >= TLS1_3_VERSION) {
1049                 using_ecc = 1;
1050                 break;
1051             }
1052         }
1053     }
1054 #else
1055     if (SSL_IS_TLS13(s)) {
1056         /* Shouldn't happen! */
1057         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1058         return 0;
1059     }
1060 #endif
1061
1062     /* Add RI if renegotiating */
1063     if (s->renegotiate) {
1064         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
1065                 || !WPACKET_start_sub_packet_u16(pkt)
1066                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
1067                                    s->s3->previous_client_finished_len)
1068                 || !WPACKET_close(pkt)) {
1069             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1070             return 0;
1071         }
1072     }
1073     /* Only add RI for SSLv3 */
1074     if (s->client_version == SSL3_VERSION)
1075         goto done;
1076
1077     if (s->tlsext_hostname != NULL) {
1078         /* Add TLS extension servername to the Client Hello message */
1079         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1080                    /* Sub-packet for server_name extension */
1081                 || !WPACKET_start_sub_packet_u16(pkt)
1082                    /* Sub-packet for servername list (always 1 hostname)*/
1083                 || !WPACKET_start_sub_packet_u16(pkt)
1084                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
1085                 || !WPACKET_sub_memcpy_u16(pkt, s->tlsext_hostname,
1086                                            strlen(s->tlsext_hostname))
1087                 || !WPACKET_close(pkt)
1088                 || !WPACKET_close(pkt)) {
1089             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1090             return 0;
1091         }
1092     }
1093 #ifndef OPENSSL_NO_SRP
1094     /* Add SRP username if there is one */
1095     if (s->srp_ctx.login != NULL) {
1096         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
1097                    /* Sub-packet for SRP extension */
1098                 || !WPACKET_start_sub_packet_u16(pkt)
1099                 || !WPACKET_start_sub_packet_u8(pkt)
1100                    /* login must not be zero...internal error if so */
1101                 || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
1102                 || !WPACKET_memcpy(pkt, s->srp_ctx.login,
1103                                    strlen(s->srp_ctx.login))
1104                 || !WPACKET_close(pkt)
1105                 || !WPACKET_close(pkt)) {
1106             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1107             return 0;
1108         }
1109     }
1110 #endif
1111
1112 #ifndef OPENSSL_NO_EC
1113     if (using_ecc) {
1114         /*
1115          * Add TLS extension ECPointFormats to the ClientHello message
1116          */
1117         const unsigned char *pformats, *pcurvestmp;
1118         size_t num_formats;
1119         size_t i;
1120
1121         tls1_get_formatlist(s, &pformats, &num_formats);
1122
1123         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1124                    /* Sub-packet for formats extension */
1125                 || !WPACKET_start_sub_packet_u16(pkt)
1126                 || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
1127                 || !WPACKET_close(pkt)) {
1128             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1129             return 0;
1130         }
1131
1132         /*
1133          * Add TLS extension supported_groups to the ClientHello message
1134          */
1135         /* TODO(TLS1.3): Add support for DHE groups */
1136         pcurves = s->tlsext_supportedgroupslist;
1137         if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
1138             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1139             return 0;
1140         }
1141         pcurvestmp = pcurves;
1142
1143         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
1144                    /* Sub-packet for supported_groups extension */
1145                 || !WPACKET_start_sub_packet_u16(pkt)
1146                 || !WPACKET_start_sub_packet_u16(pkt)) {
1147             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1148             return 0;
1149         }
1150         /* Copy curve ID if supported */
1151         for (i = 0; i < num_curves; i++, pcurvestmp += 2) {
1152             if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
1153                 if (!WPACKET_put_bytes_u8(pkt, pcurvestmp[0])
1154                     || !WPACKET_put_bytes_u8(pkt, pcurvestmp[1])) {
1155                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1156                                ERR_R_INTERNAL_ERROR);
1157                         return 0;
1158                     }
1159             }
1160         }
1161         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1162             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1163             return 0;
1164         }
1165     }
1166 #endif                          /* OPENSSL_NO_EC */
1167
1168     if (tls_use_ticket(s)) {
1169         size_t ticklen;
1170         if (!s->new_session && s->session && s->session->tlsext_tick)
1171             ticklen = s->session->tlsext_ticklen;
1172         else if (s->session && s->tlsext_session_ticket &&
1173                  s->tlsext_session_ticket->data) {
1174             ticklen = s->tlsext_session_ticket->length;
1175             s->session->tlsext_tick = OPENSSL_malloc(ticklen);
1176             if (s->session->tlsext_tick == NULL) {
1177                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1178                 return 0;
1179             }
1180             memcpy(s->session->tlsext_tick,
1181                    s->tlsext_session_ticket->data, ticklen);
1182             s->session->tlsext_ticklen = ticklen;
1183         } else
1184             ticklen = 0;
1185         if (ticklen == 0 && s->tlsext_session_ticket &&
1186             s->tlsext_session_ticket->data == NULL)
1187             goto skip_ext;
1188
1189         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1190                 || !WPACKET_sub_memcpy_u16(pkt, s->session->tlsext_tick,
1191                                            ticklen)) {
1192             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1193             return 0;
1194         }
1195     }
1196  skip_ext:
1197
1198     if (SSL_CLIENT_USE_SIGALGS(s)) {
1199         size_t salglen;
1200         const unsigned char *salg;
1201
1202         salglen = tls12_get_psigalgs(s, &salg);
1203
1204         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
1205                    /* Sub-packet for sig-algs extension */
1206                 || !WPACKET_start_sub_packet_u16(pkt)
1207                    /* Sub-packet for the actual list */
1208                 || !WPACKET_start_sub_packet_u16(pkt)
1209                 || !tls12_copy_sigalgs(s, pkt, salg, salglen)
1210                 || !WPACKET_close(pkt)
1211                 || !WPACKET_close(pkt)) {
1212             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1213             return 0;
1214         }
1215     }
1216 #ifndef OPENSSL_NO_OCSP
1217     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
1218         int i;
1219
1220         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1221                    /* Sub-packet for status request extension */
1222                 || !WPACKET_start_sub_packet_u16(pkt)
1223                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
1224                    /* Sub-packet for the ids */
1225                 || !WPACKET_start_sub_packet_u16(pkt)) {
1226             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1227             return 0;
1228         }
1229         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
1230             unsigned char *idbytes;
1231             int idlen;
1232             OCSP_RESPID *id;
1233
1234             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
1235             idlen = i2d_OCSP_RESPID(id, NULL);
1236             if (idlen <= 0
1237                        /* Sub-packet for an individual id */
1238                     || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
1239                     || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
1240                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1241                 return 0;
1242             }
1243         }
1244         if (!WPACKET_close(pkt)
1245                 || !WPACKET_start_sub_packet_u16(pkt)) {
1246             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1247             return 0;
1248         }
1249         if (s->tlsext_ocsp_exts) {
1250             unsigned char *extbytes;
1251             int extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
1252
1253             if (extlen < 0) {
1254                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1255                 return 0;
1256             }
1257             if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
1258                     || i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &extbytes)
1259                        != extlen) {
1260                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1261                 return 0;
1262            }
1263         }
1264         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1265             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1266             return 0;
1267         }
1268     }
1269 #endif
1270
1271 #ifndef OPENSSL_NO_NEXTPROTONEG
1272     if (s->ctx->next_proto_select_cb && !s->s3->tmp.finish_md_len) {
1273         /*
1274          * The client advertises an empty extension to indicate its support
1275          * for Next Protocol Negotiation
1276          */
1277         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1278                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1279             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1280             return 0;
1281         }
1282     }
1283 #endif
1284
1285     /*
1286      * finish_md_len is non-zero during a renegotiation, so
1287      * this avoids sending ALPN during the renegotiation
1288      * (see longer comment below)
1289      */
1290     if (s->alpn_client_proto_list && !s->s3->tmp.finish_md_len) {
1291         if (!WPACKET_put_bytes_u16(pkt,
1292                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1293                    /* Sub-packet ALPN extension */
1294                 || !WPACKET_start_sub_packet_u16(pkt)
1295                 || !WPACKET_sub_memcpy_u16(pkt, s->alpn_client_proto_list,
1296                                            s->alpn_client_proto_list_len)
1297                 || !WPACKET_close(pkt)) {
1298             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1299             return 0;
1300         }
1301         s->s3->alpn_sent = 1;
1302     }
1303 #ifndef OPENSSL_NO_SRTP
1304     if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)) {
1305         STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
1306         SRTP_PROTECTION_PROFILE *prof;
1307         int i, ct;
1308
1309         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1310                    /* Sub-packet for SRTP extension */
1311                 || !WPACKET_start_sub_packet_u16(pkt)
1312                    /* Sub-packet for the protection profile list */
1313                 || !WPACKET_start_sub_packet_u16(pkt)) {
1314             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1315             return 0;
1316         }
1317         ct = sk_SRTP_PROTECTION_PROFILE_num(clnt);
1318         for (i = 0; i < ct; i++) {
1319             prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
1320             if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
1321                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1322                 return 0;
1323             }
1324         }
1325         if (!WPACKET_close(pkt)
1326                    /* Add an empty use_mki value */
1327                 || !WPACKET_put_bytes_u8(pkt, 0)
1328                 || !WPACKET_close(pkt)) {
1329             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1330             return 0;
1331         }
1332     }
1333 #endif
1334     custom_ext_init(&s->cert->cli_ext);
1335     /* Add custom TLS Extensions to ClientHello */
1336     if (!custom_ext_add(s, 0, pkt, al)) {
1337         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1338         return 0;
1339     }
1340
1341     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) {
1342         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1343             || !WPACKET_put_bytes_u16(pkt, 0)) {
1344             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1345             return 0;
1346         }
1347     }
1348
1349 #ifndef OPENSSL_NO_CT
1350     if (s->ct_validation_callback != NULL) {
1351         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
1352                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1353             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1354             return 0;
1355         }
1356     }
1357 #endif
1358
1359     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1360             || !WPACKET_put_bytes_u16(pkt, 0)) {
1361         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1362         return 0;
1363     }
1364
1365     reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
1366     if (reason != 0) {
1367         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, reason);
1368         return 0;
1369     }
1370
1371     /* TLS1.3 specific extensions */
1372     if (!SSL_IS_DTLS(s) && max_version >= TLS1_3_VERSION) {
1373         int currv;
1374         size_t i, sharessent = 0;
1375
1376         /* TODO(TLS1.3): Should we add this extension for versions < TLS1.3? */
1377         /* supported_versions extension */
1378         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
1379                 || !WPACKET_start_sub_packet_u16(pkt)
1380                 || !WPACKET_start_sub_packet_u8(pkt)) {
1381             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1382             return 0;
1383         }
1384
1385         /*
1386          * TODO(TLS1.3): There is some discussion on the TLS list as to wheter
1387          * we should include versions <TLS1.2. For the moment we do. To be
1388          * reviewed later.
1389          */
1390         for (currv = max_version; currv >= min_version; currv--) {
1391             /* TODO(TLS1.3): Remove this first if clause prior to release!! */
1392             if (currv == TLS1_3_VERSION) {
1393                 if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
1394                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1395                            ERR_R_INTERNAL_ERROR);
1396                     return 0;
1397                 }
1398             } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
1399                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1400                 return 0;
1401             }
1402         }
1403         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1404             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1405             return 0;
1406         }
1407
1408
1409         /* key_share extension */
1410         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1411                    /* Extension data sub-packet */
1412                 || !WPACKET_start_sub_packet_u16(pkt)
1413                    /* KeyShare list sub-packet */
1414                 || !WPACKET_start_sub_packet_u16(pkt)) {
1415             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1416             return 0;
1417         }
1418
1419         /*
1420          * TODO(TLS1.3): Make the number of key_shares sent configurable. For
1421          * now, just send one
1422          */
1423         for (i = 0; i < num_curves && sharessent < 1; i++, pcurves += 2) {
1424             unsigned char *encodedPoint = NULL;
1425             unsigned int curve_id = 0;
1426             EVP_PKEY *key_share_key = NULL;
1427             size_t encodedlen;
1428
1429             if (!tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED))
1430                 continue;
1431
1432             if (s->s3->tmp.pkey != NULL) {
1433                 /* Shouldn't happen! */
1434                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1435                        ERR_R_INTERNAL_ERROR);
1436                 return 0;
1437             }
1438
1439             /* Generate a key for this key_share */
1440             curve_id = (pcurves[0] << 8) | pcurves[1];
1441             key_share_key = ssl_generate_pkey_curve(curve_id);
1442             if (key_share_key == NULL) {
1443                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_EVP_LIB);
1444                 return 0;
1445             }
1446
1447             /* Encode the public key. */
1448             encodedlen = EVP_PKEY_get1_tls_encodedpoint(key_share_key,
1449                                                         &encodedPoint);
1450             if (encodedlen == 0) {
1451                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_EC_LIB);
1452                 EVP_PKEY_free(key_share_key);
1453                 return 0;
1454             }
1455
1456             /* Create KeyShareEntry */
1457             if (!WPACKET_put_bytes_u16(pkt, curve_id)
1458                     || !WPACKET_sub_memcpy_u16(pkt, encodedPoint, encodedlen)) {
1459                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1460                        ERR_R_INTERNAL_ERROR);
1461                 EVP_PKEY_free(key_share_key);
1462                 OPENSSL_free(encodedPoint);
1463                 return 0;
1464             }
1465
1466             /*
1467              * TODO(TLS1.3): When changing to send more than one key_share we're
1468              * going to need to be able to save more than one EVP_PKEY. For now
1469              * we reuse the existing tmp.pkey
1470              */
1471             s->s3->group_id = curve_id;
1472             s->s3->tmp.pkey = key_share_key;
1473             sharessent++;
1474             OPENSSL_free(encodedPoint);
1475         }
1476         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1477             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1478             return 0;
1479         }
1480     }
1481
1482     /*
1483      * Add padding to workaround bugs in F5 terminators. See
1484      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
1485      * code works out the length of all existing extensions it MUST always
1486      * appear last.
1487      */
1488     if (s->options & SSL_OP_TLSEXT_PADDING) {
1489         unsigned char *padbytes;
1490         size_t hlen;
1491
1492         if (!WPACKET_get_total_written(pkt, &hlen)) {
1493             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1494             return 0;
1495         }
1496
1497         if (hlen > 0xff && hlen < 0x200) {
1498             hlen = 0x200 - hlen;
1499             if (hlen >= 4)
1500                 hlen -= 4;
1501             else
1502                 hlen = 0;
1503
1504             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
1505                     || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
1506                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1507                 return 0;
1508             }
1509             memset(padbytes, 0, hlen);
1510         }
1511     }
1512
1513  done:
1514     return 1;
1515 }
1516
1517 /*
1518  * Add the key_share extension.
1519  *
1520  * Returns 1 on success or 0 on failure.
1521  */
1522 static int add_client_key_share_ext(SSL *s, WPACKET *pkt, int *al)
1523 {
1524     unsigned char *encodedPoint;
1525     size_t encoded_pt_len = 0;
1526     EVP_PKEY *ckey = s->s3->peer_tmp, *skey = NULL;
1527
1528     if (ckey == NULL) {
1529         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1530         return 0;
1531     }
1532
1533     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1534             || !WPACKET_start_sub_packet_u16(pkt)
1535             || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)) {
1536         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1537         return 0;
1538     }
1539
1540     skey = ssl_generate_pkey(ckey);
1541
1542     /* Generate encoding of server key */
1543     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(skey, &encodedPoint);
1544     if (encoded_pt_len == 0) {
1545         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_EC_LIB);
1546         EVP_PKEY_free(skey);
1547         return 0;
1548     }
1549
1550     if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len)
1551             || !WPACKET_close(pkt)) {
1552         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1553         EVP_PKEY_free(skey);
1554         OPENSSL_free(encodedPoint);
1555         return 0;
1556     }
1557     OPENSSL_free(encodedPoint);
1558
1559     /* This causes the crypto state to be updated based on the derived keys */
1560     s->s3->tmp.pkey = skey;
1561     if (ssl_derive(s, skey, ckey, 1) == 0) {
1562         *al = SSL_AD_INTERNAL_ERROR;
1563         SSLerr(SSL_F_ADD_CLIENT_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1564         return 0;
1565     }
1566
1567     return 1;
1568 }
1569
1570 int ssl_add_serverhello_tlsext(SSL *s, WPACKET *pkt, int *al)
1571 {
1572 #ifndef OPENSSL_NO_NEXTPROTONEG
1573     int next_proto_neg_seen;
1574 #endif
1575 #ifndef OPENSSL_NO_EC
1576     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1577     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1578     int using_ecc = (alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA);
1579     using_ecc = using_ecc && (s->session->tlsext_ecpointformatlist != NULL);
1580 #endif
1581
1582     if (!WPACKET_start_sub_packet_u16(pkt)
1583             || !WPACKET_set_flags(pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)) {
1584         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1585         return 0;
1586     }
1587
1588     if (s->s3->send_connection_binding &&
1589             !ssl_add_serverhello_renegotiate_ext(s, pkt)) {
1590         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1591         return 0;
1592     }
1593
1594     /* Only add RI for SSLv3 */
1595     if (s->version == SSL3_VERSION)
1596         goto done;
1597
1598     if (!s->hit && s->servername_done == 1
1599             && s->session->tlsext_hostname != NULL) {
1600         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1601                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1602             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1603             return 0;
1604         }
1605     }
1606 #ifndef OPENSSL_NO_EC
1607     if (using_ecc) {
1608         const unsigned char *plist;
1609         size_t plistlen;
1610         /*
1611          * Add TLS extension ECPointFormats to the ServerHello message
1612          */
1613         tls1_get_formatlist(s, &plist, &plistlen);
1614
1615         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1616                 || !WPACKET_start_sub_packet_u16(pkt)
1617                 || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
1618                 || !WPACKET_close(pkt)) {
1619             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1620             return 0;
1621         }
1622     }
1623     /*
1624      * Currently the server should not respond with a SupportedCurves
1625      * extension
1626      */
1627 #endif                          /* OPENSSL_NO_EC */
1628
1629     if (s->tlsext_ticket_expected && tls_use_ticket(s)) {
1630         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1631                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1632             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1633             return 0;
1634         }
1635     } else {
1636         /*
1637          * if we don't add the above TLSEXT, we can't add a session ticket
1638          * later
1639          */
1640         s->tlsext_ticket_expected = 0;
1641     }
1642
1643     if (s->tlsext_status_expected) {
1644         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1645                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1646             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1647             return 0;
1648         }
1649     }
1650 #ifndef OPENSSL_NO_SRTP
1651     if (SSL_IS_DTLS(s) && s->srtp_profile) {
1652         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1653                 || !WPACKET_start_sub_packet_u16(pkt)
1654                 || !WPACKET_put_bytes_u16(pkt, 2)
1655                 || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
1656                 || !WPACKET_put_bytes_u8(pkt, 0)
1657                 || !WPACKET_close(pkt)) {
1658             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1659             return 0;
1660         }
1661     }
1662 #endif
1663
1664     if (((s->s3->tmp.new_cipher->id & 0xFFFF) == 0x80
1665          || (s->s3->tmp.new_cipher->id & 0xFFFF) == 0x81)
1666         && (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG)) {
1667         const unsigned char cryptopro_ext[36] = {
1668             0xfd, 0xe8,         /* 65000 */
1669             0x00, 0x20,         /* 32 bytes length */
1670             0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1671             0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1672             0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1673             0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1674         };
1675         if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
1676             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1677             return 0;
1678         }
1679     }
1680
1681 #ifndef OPENSSL_NO_NEXTPROTONEG
1682     next_proto_neg_seen = s->s3->next_proto_neg_seen;
1683     s->s3->next_proto_neg_seen = 0;
1684     if (next_proto_neg_seen && s->ctx->next_protos_advertised_cb) {
1685         const unsigned char *npa;
1686         unsigned int npalen;
1687         int r;
1688
1689         r = s->ctx->next_protos_advertised_cb(s, &npa, &npalen,
1690                                               s->
1691                                               ctx->next_protos_advertised_cb_arg);
1692         if (r == SSL_TLSEXT_ERR_OK) {
1693             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1694                     || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
1695                 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1696                 return 0;
1697             }
1698             s->s3->next_proto_neg_seen = 1;
1699         }
1700     }
1701 #endif
1702
1703     if (SSL_IS_TLS13(s) && !s->hit && !add_client_key_share_ext(s, pkt, al))
1704         return 0;
1705
1706     if (!custom_ext_add(s, 1, pkt, al)) {
1707         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1708         return 0;
1709     }
1710
1711     if (s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC) {
1712         /*
1713          * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
1714          * for other cases too.
1715          */
1716         if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
1717             || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
1718             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
1719             || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12)
1720             s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1721         else {
1722             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1723                     || !WPACKET_put_bytes_u16(pkt, 0)) {
1724                 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1725                 return 0;
1726             }
1727         }
1728     }
1729     if (s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) {
1730         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1731                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1732             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1733             return 0;
1734         }
1735     }
1736
1737     if (s->s3->alpn_selected != NULL) {
1738         if (!WPACKET_put_bytes_u16(pkt,
1739                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1740                 || !WPACKET_start_sub_packet_u16(pkt)
1741                 || !WPACKET_start_sub_packet_u16(pkt)
1742                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
1743                                           s->s3->alpn_selected_len)
1744                 || !WPACKET_close(pkt)
1745                 || !WPACKET_close(pkt)) {
1746             SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1747             return 0;
1748         }
1749     }
1750
1751  done:
1752     if (!WPACKET_close(pkt)) {
1753         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1754         return 0;
1755     }
1756     return 1;
1757 }
1758
1759 /*
1760  * Save the ALPN extension in a ClientHello.
1761  * pkt: the contents of the ALPN extension, not including type and length.
1762  * al: a pointer to the  alert value to send in the event of a failure.
1763  * returns: 1 on success, 0 on error.
1764  */
1765 static int tls1_alpn_handle_client_hello(SSL *s, PACKET *pkt, int *al)
1766 {
1767     PACKET protocol_list, save_protocol_list, protocol;
1768
1769     *al = SSL_AD_DECODE_ERROR;
1770
1771     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
1772         || PACKET_remaining(&protocol_list) < 2) {
1773         return 0;
1774     }
1775
1776     save_protocol_list = protocol_list;
1777     do {
1778         /* Protocol names can't be empty. */
1779         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
1780             || PACKET_remaining(&protocol) == 0) {
1781             return 0;
1782         }
1783     } while (PACKET_remaining(&protocol_list) != 0);
1784
1785     if (!PACKET_memdup(&save_protocol_list,
1786                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
1787         *al = TLS1_AD_INTERNAL_ERROR;
1788         return 0;
1789     }
1790
1791     return 1;
1792 }
1793
1794 /*
1795  * Process the ALPN extension in a ClientHello.
1796  * al: a pointer to the alert value to send in the event of a failure.
1797  * returns 1 on success, 0 on error.
1798  */
1799 static int tls1_alpn_handle_client_hello_late(SSL *s, int *al)
1800 {
1801     const unsigned char *selected = NULL;
1802     unsigned char selected_len = 0;
1803
1804     if (s->ctx->alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
1805         int r = s->ctx->alpn_select_cb(s, &selected, &selected_len,
1806                                        s->s3->alpn_proposed,
1807                                        (unsigned int)s->s3->alpn_proposed_len,
1808                                        s->ctx->alpn_select_cb_arg);
1809
1810         if (r == SSL_TLSEXT_ERR_OK) {
1811             OPENSSL_free(s->s3->alpn_selected);
1812             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
1813             if (s->s3->alpn_selected == NULL) {
1814                 *al = SSL_AD_INTERNAL_ERROR;
1815                 return 0;
1816             }
1817             s->s3->alpn_selected_len = selected_len;
1818 #ifndef OPENSSL_NO_NEXTPROTONEG
1819             /* ALPN takes precedence over NPN. */
1820             s->s3->next_proto_neg_seen = 0;
1821 #endif
1822         } else {
1823             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
1824             return 0;
1825         }
1826     }
1827
1828     return 1;
1829 }
1830
1831 #ifndef OPENSSL_NO_EC
1832 /*-
1833  * ssl_check_for_safari attempts to fingerprint Safari using OS X
1834  * SecureTransport using the TLS extension block in |hello|.
1835  * Safari, since 10.6, sends exactly these extensions, in this order:
1836  *   SNI,
1837  *   elliptic_curves
1838  *   ec_point_formats
1839  *
1840  * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8,
1841  * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them.
1842  * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from
1843  * 10.8..10.8.3 (which don't work).
1844  */
1845 static void ssl_check_for_safari(SSL *s, const CLIENTHELLO_MSG *hello)
1846 {
1847     unsigned int type;
1848     PACKET sni, tmppkt;
1849     size_t ext_len;
1850
1851     static const unsigned char kSafariExtensionsBlock[] = {
1852         0x00, 0x0a,             /* elliptic_curves extension */
1853         0x00, 0x08,             /* 8 bytes */
1854         0x00, 0x06,             /* 6 bytes of curve ids */
1855         0x00, 0x17,             /* P-256 */
1856         0x00, 0x18,             /* P-384 */
1857         0x00, 0x19,             /* P-521 */
1858
1859         0x00, 0x0b,             /* ec_point_formats */
1860         0x00, 0x02,             /* 2 bytes */
1861         0x01,                   /* 1 point format */
1862         0x00,                   /* uncompressed */
1863         /* The following is only present in TLS 1.2 */
1864         0x00, 0x0d,             /* signature_algorithms */
1865         0x00, 0x0c,             /* 12 bytes */
1866         0x00, 0x0a,             /* 10 bytes */
1867         0x05, 0x01,             /* SHA-384/RSA */
1868         0x04, 0x01,             /* SHA-256/RSA */
1869         0x02, 0x01,             /* SHA-1/RSA */
1870         0x04, 0x03,             /* SHA-256/ECDSA */
1871         0x02, 0x03,             /* SHA-1/ECDSA */
1872     };
1873
1874     /* Length of the common prefix (first two extensions). */
1875     static const size_t kSafariCommonExtensionsLength = 18;
1876
1877     tmppkt = hello->extensions;
1878
1879     if (!PACKET_forward(&tmppkt, 2)
1880         || !PACKET_get_net_2(&tmppkt, &type)
1881         || !PACKET_get_length_prefixed_2(&tmppkt, &sni)) {
1882         return;
1883     }
1884
1885     if (type != TLSEXT_TYPE_server_name)
1886         return;
1887
1888     ext_len = TLS1_get_client_version(s) >= TLS1_2_VERSION ?
1889         sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength;
1890
1891     s->s3->is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock,
1892                                              ext_len);
1893 }
1894 #endif                          /* !OPENSSL_NO_EC */
1895
1896
1897 /*
1898  * Process the supported_groups extension if present. Returns success if the
1899  * extension is absent, or if it has been successfully processed.
1900  *
1901  * Returns 1 on success or 0 on failure
1902  */
1903 static int tls_process_supported_groups(SSL *s, CLIENTHELLO_MSG *hello)
1904 {
1905 #ifndef OPENSSL_NO_EC
1906     PACKET supported_groups_list;
1907     RAW_EXTENSION *suppgroups = tls_get_extension_by_type(hello->pre_proc_exts,
1908                                     hello->num_extensions,
1909                                     TLSEXT_TYPE_supported_groups);
1910
1911     if (suppgroups == NULL)
1912         return 1;
1913
1914     /* Each group is 2 bytes and we must have at least 1. */
1915     if (!PACKET_as_length_prefixed_2(&suppgroups->data,
1916                                      &supported_groups_list)
1917         || PACKET_remaining(&supported_groups_list) == 0
1918         || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
1919         return 0;
1920     }
1921
1922     if (!s->hit
1923             && !PACKET_memdup(&supported_groups_list,
1924                               &s->session->tlsext_supportedgroupslist,
1925                               &s->session->tlsext_supportedgroupslist_length)) {
1926         return 0;
1927     }
1928 #endif
1929     return 1;
1930 }
1931
1932 /*
1933  * Checks a list of |groups| to determine if the |group_id| is in it. If it is
1934  * and |checkallow| is 1 then additionally check if the group is allowed to be
1935  * used. Returns 1 if the group is in the list (and allowed if |checkallow| is
1936  * 1) or 0 otherwise.
1937  */
1938 static int check_in_list(SSL *s, unsigned int group_id,
1939                          const unsigned char *groups, size_t num_groups,
1940                          int checkallow)
1941 {
1942     size_t i;
1943
1944     if (groups == NULL || num_groups == 0)
1945         return 0;
1946
1947     for (i = 0; i < num_groups; i++, groups += 2) {
1948         unsigned int share_id = (groups[0] << 8) | (groups[1]);
1949
1950         if (group_id == share_id
1951                 && (!checkallow || tls_curve_allowed(s, groups,
1952                                                      SSL_SECOP_CURVE_CHECK))) {
1953             break;
1954         }
1955     }
1956
1957     /* If i == num_groups then not in the list */
1958     return i < num_groups;
1959 }
1960
1961 /*
1962  * Process a key_share extension received in the ClientHello. |pkt| contains
1963  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
1964  * If a failure occurs then |*al| is set to an appropriate alert value.
1965  */
1966 static int process_key_share_ext(SSL *s, PACKET *pkt, int *al)
1967 {
1968     unsigned int group_id;
1969     PACKET key_share_list, encoded_pt;
1970     const unsigned char *clntcurves, *srvrcurves;
1971     size_t clnt_num_curves, srvr_num_curves;
1972     int group_nid, found = 0;
1973     unsigned int curve_flags;
1974
1975     /* Sanity check */
1976     if (s->s3->peer_tmp != NULL) {
1977         *al = SSL_AD_INTERNAL_ERROR;
1978         SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT, ERR_R_INTERNAL_ERROR);
1979         return 0;
1980     }
1981
1982     if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) {
1983         *al = SSL_AD_HANDSHAKE_FAILURE;
1984         SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
1985                SSL_R_LENGTH_MISMATCH);
1986         return 0;
1987     }
1988
1989     /* Get our list of supported curves */
1990     if (!tls1_get_curvelist(s, 0, &srvrcurves, &srvr_num_curves)) {
1991         *al = SSL_AD_INTERNAL_ERROR;
1992         SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
1993                ERR_R_INTERNAL_ERROR);
1994         return 0;
1995     }
1996
1997     /* Get the clients list of supported curves */
1998     if (!tls1_get_curvelist(s, 1, &clntcurves, &clnt_num_curves)) {
1999         *al = SSL_AD_INTERNAL_ERROR;
2000         SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
2001                ERR_R_INTERNAL_ERROR);
2002         return 0;
2003     }
2004
2005     while (PACKET_remaining(&key_share_list) > 0) {
2006         if (!PACKET_get_net_2(&key_share_list, &group_id)
2007                 || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt)
2008                 || PACKET_remaining(&encoded_pt) == 0) {
2009             *al = SSL_AD_HANDSHAKE_FAILURE;
2010             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
2011                    SSL_R_LENGTH_MISMATCH);
2012             return 0;
2013         }
2014
2015         /*
2016          * If we already found a suitable key_share we loop through the
2017          * rest to verify the structure, but don't process them.
2018          */
2019         if (found)
2020             continue;
2021
2022         /* Check if this share is in supported_groups sent from client */
2023         if (!check_in_list(s, group_id, clntcurves, clnt_num_curves, 0)) {
2024             *al = SSL_AD_HANDSHAKE_FAILURE;
2025             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
2026                    SSL_R_BAD_KEY_SHARE);
2027             return 0;
2028         }
2029
2030         /* Check if this share is for a group we can use */
2031         if (!check_in_list(s, group_id, srvrcurves, srvr_num_curves, 1)) {
2032             /* Share not suitable */
2033             continue;
2034         }
2035
2036         group_nid = tls1_ec_curve_id2nid(group_id, &curve_flags);
2037
2038         if (group_nid == 0) {
2039             *al = SSL_AD_INTERNAL_ERROR;
2040             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT,
2041                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
2042             return 0;
2043         }
2044
2045         if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
2046             /* Can happen for some curves, e.g. X25519 */
2047             EVP_PKEY *key = EVP_PKEY_new();
2048
2049             if (key == NULL || !EVP_PKEY_set_type(key, group_nid)) {
2050                 *al = SSL_AD_INTERNAL_ERROR;
2051                 SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT, ERR_R_EVP_LIB);
2052                 EVP_PKEY_free(key);
2053                 return 0;
2054             }
2055             s->s3->peer_tmp = key;
2056         } else {
2057             /* Set up EVP_PKEY with named curve as parameters */
2058             EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
2059             if (pctx == NULL
2060                     || EVP_PKEY_paramgen_init(pctx) <= 0
2061                     || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2062                                                               group_nid) <= 0
2063                     || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
2064                 *al = SSL_AD_INTERNAL_ERROR;
2065                 SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT, ERR_R_EVP_LIB);
2066                 EVP_PKEY_CTX_free(pctx);
2067                 return 0;
2068             }
2069             EVP_PKEY_CTX_free(pctx);
2070             pctx = NULL;
2071         }
2072         s->s3->group_id = group_id;
2073
2074         if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
2075                 PACKET_data(&encoded_pt),
2076                 PACKET_remaining(&encoded_pt))) {
2077             *al = SSL_AD_DECODE_ERROR;
2078             SSLerr(SSL_F_PROCESS_KEY_SHARE_EXT, SSL_R_BAD_ECPOINT);
2079             return 0;
2080         }
2081
2082         found = 1;
2083     }
2084
2085     return 1;
2086 }
2087
2088 /*
2089  * Loop through all remaining ClientHello extensions that we collected earlier
2090  * and haven't already processed. For each one parse it and update the SSL
2091  * object as required.
2092  *
2093  * Behaviour upon resumption is extension-specific. If the extension has no
2094  * effect during resumption, it is parsed (to verify its format) but otherwise
2095  * ignored.
2096  *
2097  * Returns 1 on success and 0 on failure.
2098  * Upon failure, sets |al| to the appropriate alert.
2099  */
2100 static int ssl_scan_clienthello_tlsext(SSL *s, CLIENTHELLO_MSG *hello, int *al)
2101 {
2102     size_t loop;
2103     int renegotiate_seen = 0;
2104
2105     *al = SSL_AD_DECODE_ERROR;
2106     s->servername_done = 0;
2107     s->tlsext_status_type = -1;
2108 #ifndef OPENSSL_NO_NEXTPROTONEG
2109     s->s3->next_proto_neg_seen = 0;
2110 #endif
2111
2112     OPENSSL_free(s->s3->alpn_selected);
2113     s->s3->alpn_selected = NULL;
2114     s->s3->alpn_selected_len = 0;
2115     OPENSSL_free(s->s3->alpn_proposed);
2116     s->s3->alpn_proposed = NULL;
2117     s->s3->alpn_proposed_len = 0;
2118
2119 #ifndef OPENSSL_NO_EC
2120     if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
2121         ssl_check_for_safari(s, hello);
2122 #endif                          /* !OPENSSL_NO_EC */
2123
2124     /* Clear any signature algorithms extension received */
2125     OPENSSL_free(s->s3->tmp.peer_sigalgs);
2126     s->s3->tmp.peer_sigalgs = NULL;
2127     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
2128
2129 #ifndef OPENSSL_NO_SRP
2130     OPENSSL_free(s->srp_ctx.login);
2131     s->srp_ctx.login = NULL;
2132 #endif
2133
2134     s->srtp_profile = NULL;
2135
2136     /*
2137      * We process the supported_groups extension first so that is done before
2138      * we get to key_share which needs to use the information in it.
2139      */
2140     if (!tls_process_supported_groups(s, hello)) {
2141         *al = TLS1_AD_INTERNAL_ERROR;
2142         return 0;
2143     }
2144
2145     /*
2146      * We parse all extensions to ensure the ClientHello is well-formed but,
2147      * unless an extension specifies otherwise, we ignore extensions upon
2148      * resumption.
2149      */
2150     for (loop = 0; loop < hello->num_extensions; loop++) {
2151         RAW_EXTENSION *currext = &hello->pre_proc_exts[loop];
2152
2153         if (s->tlsext_debug_cb)
2154             s->tlsext_debug_cb(s, 0, currext->type,
2155                                PACKET_data(&currext->data),
2156                                PACKET_remaining(&currext->data),
2157                                s->tlsext_debug_arg);
2158
2159         if (currext->type == TLSEXT_TYPE_renegotiate) {
2160             if (!ssl_parse_clienthello_renegotiate_ext(s,
2161                     &currext->data, al))
2162                 return 0;
2163             renegotiate_seen = 1;
2164         } else if (s->version == SSL3_VERSION) {
2165         }
2166 /*-
2167  * The servername extension is treated as follows:
2168  *
2169  * - Only the hostname type is supported with a maximum length of 255.
2170  * - The servername is rejected if too long or if it contains zeros,
2171  *   in which case an fatal alert is generated.
2172  * - The servername field is maintained together with the session cache.
2173  * - When a session is resumed, the servername call back invoked in order
2174  *   to allow the application to position itself to the right context.
2175  * - The servername is acknowledged if it is new for a session or when
2176  *   it is identical to a previously used for the same session.
2177  *   Applications can control the behaviour.  They can at any time
2178  *   set a 'desirable' servername for a new SSL object. This can be the
2179  *   case for example with HTTPS when a Host: header field is received and
2180  *   a renegotiation is requested. In this case, a possible servername
2181  *   presented in the new client hello is only acknowledged if it matches
2182  *   the value of the Host: field.
2183  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
2184  *   if they provide for changing an explicit servername context for the
2185  *   session, i.e. when the session has been established with a servername
2186  *   extension.
2187  * - On session reconnect, the servername extension may be absent.
2188  *
2189  */
2190
2191         else if (currext->type == TLSEXT_TYPE_server_name) {
2192             unsigned int servname_type;
2193             PACKET sni, hostname;
2194
2195             if (!PACKET_as_length_prefixed_2(&currext->data, &sni)
2196                 /* ServerNameList must be at least 1 byte long. */
2197                 || PACKET_remaining(&sni) == 0) {
2198                 return 0;
2199             }
2200
2201             /*
2202              * Although the server_name extension was intended to be
2203              * extensible to new name types, RFC 4366 defined the
2204              * syntax inextensibility and OpenSSL 1.0.x parses it as
2205              * such.
2206              * RFC 6066 corrected the mistake but adding new name types
2207              * is nevertheless no longer feasible, so act as if no other
2208              * SNI types can exist, to simplify parsing.
2209              *
2210              * Also note that the RFC permits only one SNI value per type,
2211              * i.e., we can only have a single hostname.
2212              */
2213             if (!PACKET_get_1(&sni, &servname_type)
2214                 || servname_type != TLSEXT_NAMETYPE_host_name
2215                 || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
2216                 return 0;
2217             }
2218
2219             if (!s->hit) {
2220                 if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
2221                     *al = TLS1_AD_UNRECOGNIZED_NAME;
2222                     return 0;
2223                 }
2224
2225                 if (PACKET_contains_zero_byte(&hostname)) {
2226                     *al = TLS1_AD_UNRECOGNIZED_NAME;
2227                     return 0;
2228                 }
2229
2230                 if (!PACKET_strndup(&hostname, &s->session->tlsext_hostname)) {
2231                     *al = TLS1_AD_INTERNAL_ERROR;
2232                     return 0;
2233                 }
2234
2235                 s->servername_done = 1;
2236             } else {
2237                 /*
2238                  * TODO(openssl-team): if the SNI doesn't match, we MUST
2239                  * fall back to a full handshake.
2240                  */
2241                 s->servername_done = s->session->tlsext_hostname
2242                     && PACKET_equal(&hostname, s->session->tlsext_hostname,
2243                                     strlen(s->session->tlsext_hostname));
2244             }
2245         }
2246 #ifndef OPENSSL_NO_SRP
2247         else if (currext->type == TLSEXT_TYPE_srp) {
2248             PACKET srp_I;
2249
2250             if (!PACKET_as_length_prefixed_1(&currext->data, &srp_I))
2251                 return 0;
2252
2253             if (PACKET_contains_zero_byte(&srp_I))
2254                 return 0;
2255
2256             /*
2257              * TODO(openssl-team): currently, we re-authenticate the user
2258              * upon resumption. Instead, we MUST ignore the login.
2259              */
2260             if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
2261                 *al = TLS1_AD_INTERNAL_ERROR;
2262                 return 0;
2263             }
2264         }
2265 #endif
2266
2267 #ifndef OPENSSL_NO_EC
2268         else if (currext->type == TLSEXT_TYPE_ec_point_formats) {
2269             PACKET ec_point_format_list;
2270
2271             if (!PACKET_as_length_prefixed_1(&currext->data,
2272                                              &ec_point_format_list)
2273                 || PACKET_remaining(&ec_point_format_list) == 0) {
2274                 return 0;
2275             }
2276
2277             if (!s->hit) {
2278                 if (!PACKET_memdup(&ec_point_format_list,
2279                                    &s->session->tlsext_ecpointformatlist,
2280                                    &s->
2281                                    session->tlsext_ecpointformatlist_length)) {
2282                     *al = TLS1_AD_INTERNAL_ERROR;
2283                     return 0;
2284                 }
2285             }
2286         }
2287 #endif                          /* OPENSSL_NO_EC */
2288         else if (currext->type == TLSEXT_TYPE_session_ticket
2289                 && !SSL_IS_TLS13(s)) {
2290             if (s->tls_session_ticket_ext_cb &&
2291                 !s->tls_session_ticket_ext_cb(s,
2292                     PACKET_data(&currext->data),
2293                     PACKET_remaining(&currext->data),
2294                     s->tls_session_ticket_ext_cb_arg)) {
2295                 *al = TLS1_AD_INTERNAL_ERROR;
2296                 return 0;
2297             }
2298         } else if (currext->type == TLSEXT_TYPE_signature_algorithms) {
2299             PACKET supported_sig_algs;
2300
2301             if (!PACKET_as_length_prefixed_2(&currext->data,
2302                                              &supported_sig_algs)
2303                 || (PACKET_remaining(&supported_sig_algs) % 2) != 0
2304                 || PACKET_remaining(&supported_sig_algs) == 0) {
2305                 return 0;
2306             }
2307
2308             if (!s->hit) {
2309                 if (!tls1_save_sigalgs(s, PACKET_data(&supported_sig_algs),
2310                                        PACKET_remaining(&supported_sig_algs))) {
2311                     return 0;
2312                 }
2313             }
2314         } else if (currext->type == TLSEXT_TYPE_status_request) {
2315             if (!PACKET_get_1(&currext->data,
2316                               (unsigned int *)&s->tlsext_status_type)) {
2317                 return 0;
2318             }
2319 #ifndef OPENSSL_NO_OCSP
2320             if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
2321                 const unsigned char *ext_data;
2322                 PACKET responder_id_list, exts;
2323                 if (!PACKET_get_length_prefixed_2
2324                     (&currext->data, &responder_id_list))
2325                     return 0;
2326
2327                 /*
2328                  * We remove any OCSP_RESPIDs from a previous handshake
2329                  * to prevent unbounded memory growth - CVE-2016-6304
2330                  */
2331                 sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids,
2332                                         OCSP_RESPID_free);
2333                 if (PACKET_remaining(&responder_id_list) > 0) {
2334                     s->tlsext_ocsp_ids = sk_OCSP_RESPID_new_null();
2335                     if (s->tlsext_ocsp_ids == NULL) {
2336                         *al = SSL_AD_INTERNAL_ERROR;
2337                         return 0;
2338                     }
2339                 } else {
2340                     s->tlsext_ocsp_ids = NULL;
2341                 }
2342
2343                 while (PACKET_remaining(&responder_id_list) > 0) {
2344                     OCSP_RESPID *id;
2345                     PACKET responder_id;
2346                     const unsigned char *id_data;
2347
2348                     if (!PACKET_get_length_prefixed_2(&responder_id_list,
2349                                                       &responder_id)
2350                         || PACKET_remaining(&responder_id) == 0) {
2351                         return 0;
2352                     }
2353
2354                     id_data = PACKET_data(&responder_id);
2355                     /* TODO(size_t): Convert d2i_* to size_t */
2356                     id = d2i_OCSP_RESPID(NULL, &id_data,
2357                                          (int)PACKET_remaining(&responder_id));
2358                     if (id == NULL)
2359                         return 0;
2360
2361                     if (id_data != PACKET_end(&responder_id)) {
2362                         OCSP_RESPID_free(id);
2363                         return 0;
2364                     }
2365
2366                     if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
2367                         OCSP_RESPID_free(id);
2368                         *al = SSL_AD_INTERNAL_ERROR;
2369                         return 0;
2370                     }
2371                 }
2372
2373                 /* Read in request_extensions */
2374                 if (!PACKET_as_length_prefixed_2(
2375                         &currext->data, &exts))
2376                     return 0;
2377
2378                 if (PACKET_remaining(&exts) > 0) {
2379                     ext_data = PACKET_data(&exts);
2380                     sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
2381                                                X509_EXTENSION_free);
2382                     s->tlsext_ocsp_exts =
2383                         d2i_X509_EXTENSIONS(NULL, &ext_data,
2384                                             (int)PACKET_remaining(&exts));
2385                     if (s->tlsext_ocsp_exts == NULL
2386                         || ext_data != PACKET_end(&exts)) {
2387                         return 0;
2388                     }
2389                 }
2390             } else
2391 #endif
2392             {
2393                 /*
2394                  * We don't know what to do with any other type so ignore it.
2395                  */
2396                 s->tlsext_status_type = -1;
2397             }
2398         }
2399 #ifndef OPENSSL_NO_NEXTPROTONEG
2400         else if (currext->type == TLSEXT_TYPE_next_proto_neg
2401                  && s->s3->tmp.finish_md_len == 0) {
2402             /*-
2403              * We shouldn't accept this extension on a
2404              * renegotiation.
2405              *
2406              * s->new_session will be set on renegotiation, but we
2407              * probably shouldn't rely that it couldn't be set on
2408              * the initial renegotiation too in certain cases (when
2409              * there's some other reason to disallow resuming an
2410              * earlier session -- the current code won't be doing
2411              * anything like that, but this might change).
2412              *
2413              * A valid sign that there's been a previous handshake
2414              * in this connection is if s->s3->tmp.finish_md_len >
2415              * 0.  (We are talking about a check that will happen
2416              * in the Hello protocol round, well before a new
2417              * Finished message could have been computed.)
2418              */
2419             s->s3->next_proto_neg_seen = 1;
2420         }
2421 #endif
2422
2423         else if (currext->type
2424                      == TLSEXT_TYPE_application_layer_protocol_negotiation
2425                  && s->s3->tmp.finish_md_len == 0) {
2426             if (!tls1_alpn_handle_client_hello(s,
2427                     &currext->data, al))
2428                 return 0;
2429         }
2430
2431         /* session ticket processed earlier */
2432 #ifndef OPENSSL_NO_SRTP
2433         else if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)
2434                  && currext->type == TLSEXT_TYPE_use_srtp) {
2435             if (ssl_parse_clienthello_use_srtp_ext(s,
2436                     &currext->data, al))
2437                 return 0;
2438         }
2439 #endif
2440         else if (currext->type == TLSEXT_TYPE_encrypt_then_mac
2441                  && !(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) {
2442             s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2443         } else if (currext->type == TLSEXT_TYPE_key_share
2444                    && SSL_IS_TLS13(s) && !s->hit
2445                    && !process_key_share_ext(s, &currext->data, al)) {
2446             return 0;
2447         }
2448         /*
2449          * Note: extended master secret extension handled in
2450          * tls_check_client_ems_support()
2451          */
2452
2453         /*
2454          * If this ClientHello extension was unhandled and this is a
2455          * nonresumed connection, check whether the extension is a custom
2456          * TLS Extension (has a custom_srv_ext_record), and if so call the
2457          * callback and record the extension number so that an appropriate
2458          * ServerHello may be later returned.
2459          */
2460         else if (!s->hit) {
2461             if (custom_ext_parse(s, 1, currext->type,
2462                     PACKET_data(&currext->data),
2463                     PACKET_remaining(&currext->data), al) <= 0)
2464                 return 0;
2465         }
2466     }
2467
2468     /* Need RI if renegotiating */
2469
2470     if (!renegotiate_seen && s->renegotiate &&
2471         !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2472         *al = SSL_AD_HANDSHAKE_FAILURE;
2473         SSLerr(SSL_F_SSL_SCAN_CLIENTHELLO_TLSEXT,
2474                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2475         return 0;
2476     }
2477
2478     /*
2479      * This function currently has no state to clean up, so it returns directly.
2480      * If parsing fails at any point, the function returns early.
2481      * The SSL object may be left with partial data from extensions, but it must
2482      * then no longer be used, and clearing it up will free the leftovers.
2483      */
2484     return 1;
2485 }
2486
2487 int ssl_parse_clienthello_tlsext(SSL *s, CLIENTHELLO_MSG *hello)
2488 {
2489     int al = -1;
2490     custom_ext_init(&s->cert->srv_ext);
2491     if (ssl_scan_clienthello_tlsext(s, hello, &al) <= 0) {
2492         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2493         return 0;
2494     }
2495     if (ssl_check_clienthello_tlsext_early(s) <= 0) {
2496         SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT, SSL_R_CLIENTHELLO_TLSEXT);
2497         return 0;
2498     }
2499     return 1;
2500 }
2501
2502 #ifndef OPENSSL_NO_NEXTPROTONEG
2503 /*
2504  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
2505  * elements of zero length are allowed and the set of elements must exactly
2506  * fill the length of the block.
2507  */
2508 static char ssl_next_proto_validate(PACKET *pkt)
2509 {
2510     PACKET tmp_protocol;
2511
2512     while (PACKET_remaining(pkt)) {
2513         if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol)
2514             || PACKET_remaining(&tmp_protocol) == 0)
2515             return 0;
2516     }
2517
2518     return 1;
2519 }
2520 #endif
2521
2522 static int ssl_scan_serverhello_tlsext(SSL *s, PACKET *pkt, int *al)
2523 {
2524     unsigned int length, type, size;
2525     int tlsext_servername = 0;
2526     int renegotiate_seen = 0;
2527
2528 #ifndef OPENSSL_NO_NEXTPROTONEG
2529     s->s3->next_proto_neg_seen = 0;
2530 #endif
2531     s->tlsext_ticket_expected = 0;
2532
2533     OPENSSL_free(s->s3->alpn_selected);
2534     s->s3->alpn_selected = NULL;
2535
2536     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
2537
2538     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
2539
2540     if (!PACKET_get_net_2(pkt, &length))
2541         goto ri_check;
2542
2543     if (PACKET_remaining(pkt) != length) {
2544         *al = SSL_AD_DECODE_ERROR;
2545         return 0;
2546     }
2547
2548     if (!tls1_check_duplicate_extensions(pkt)) {
2549         *al = SSL_AD_DECODE_ERROR;
2550         return 0;
2551     }
2552
2553     while (PACKET_get_net_2(pkt, &type) && PACKET_get_net_2(pkt, &size)) {
2554         const unsigned char *data;
2555         PACKET spkt;
2556
2557         if (!PACKET_get_sub_packet(pkt, &spkt, size)
2558             || !PACKET_peek_bytes(&spkt, &data, size))
2559             goto ri_check;
2560
2561         if (s->tlsext_debug_cb)
2562             s->tlsext_debug_cb(s, 1, type, data, size, s->tlsext_debug_arg);
2563
2564         if (type == TLSEXT_TYPE_renegotiate) {
2565             if (!ssl_parse_serverhello_renegotiate_ext(s, &spkt, al))
2566                 return 0;
2567             renegotiate_seen = 1;
2568         } else if (s->version == SSL3_VERSION) {
2569         } else if (type == TLSEXT_TYPE_server_name) {
2570             if (s->tlsext_hostname == NULL || size > 0) {
2571                 *al = TLS1_AD_UNRECOGNIZED_NAME;
2572                 return 0;
2573             }
2574             tlsext_servername = 1;
2575         }
2576 #ifndef OPENSSL_NO_EC
2577         else if (type == TLSEXT_TYPE_ec_point_formats) {
2578             unsigned int ecpointformatlist_length;
2579             if (!PACKET_get_1(&spkt, &ecpointformatlist_length)
2580                 || ecpointformatlist_length != size - 1) {
2581                 *al = TLS1_AD_DECODE_ERROR;
2582                 return 0;
2583             }
2584             if (!s->hit) {
2585                 s->session->tlsext_ecpointformatlist_length = 0;
2586                 OPENSSL_free(s->session->tlsext_ecpointformatlist);
2587                 if ((s->session->tlsext_ecpointformatlist =
2588                      OPENSSL_malloc(ecpointformatlist_length)) == NULL) {
2589                     *al = TLS1_AD_INTERNAL_ERROR;
2590                     return 0;
2591                 }
2592                 s->session->tlsext_ecpointformatlist_length =
2593                     ecpointformatlist_length;
2594                 if (!PACKET_copy_bytes(&spkt,
2595                                        s->session->tlsext_ecpointformatlist,
2596                                        ecpointformatlist_length)) {
2597                     *al = TLS1_AD_DECODE_ERROR;
2598                     return 0;
2599                 }
2600
2601             }
2602         }
2603 #endif                          /* OPENSSL_NO_EC */
2604
2605         else if (type == TLSEXT_TYPE_session_ticket) {
2606             if (s->tls_session_ticket_ext_cb &&
2607                 !s->tls_session_ticket_ext_cb(s, data, size,
2608                                               s->tls_session_ticket_ext_cb_arg))
2609             {
2610                 *al = TLS1_AD_INTERNAL_ERROR;
2611                 return 0;
2612             }
2613             if (!tls_use_ticket(s) || (size > 0)) {
2614                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2615                 return 0;
2616             }
2617             s->tlsext_ticket_expected = 1;
2618         } else if (type == TLSEXT_TYPE_status_request) {
2619             /*
2620              * MUST be empty and only sent if we've requested a status
2621              * request message.
2622              */
2623             if ((s->tlsext_status_type == -1) || (size > 0)) {
2624                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2625                 return 0;
2626             }
2627             /* Set flag to expect CertificateStatus message */
2628             s->tlsext_status_expected = 1;
2629         }
2630 #ifndef OPENSSL_NO_CT
2631         /*
2632          * Only take it if we asked for it - i.e if there is no CT validation
2633          * callback set, then a custom extension MAY be processing it, so we
2634          * need to let control continue to flow to that.
2635          */
2636         else if (type == TLSEXT_TYPE_signed_certificate_timestamp &&
2637                  s->ct_validation_callback != NULL) {
2638             /* Simply copy it off for later processing */
2639             if (s->tlsext_scts != NULL) {
2640                 OPENSSL_free(s->tlsext_scts);
2641                 s->tlsext_scts = NULL;
2642             }
2643             s->tlsext_scts_len = size;
2644             if (size > 0) {
2645                 s->tlsext_scts = OPENSSL_malloc(size);
2646                 if (s->tlsext_scts == NULL) {
2647                     *al = TLS1_AD_INTERNAL_ERROR;
2648                     return 0;
2649                 }
2650                 memcpy(s->tlsext_scts, data, size);
2651             }
2652         }
2653 #endif
2654 #ifndef OPENSSL_NO_NEXTPROTONEG
2655         else if (type == TLSEXT_TYPE_next_proto_neg &&
2656                  s->s3->tmp.finish_md_len == 0) {
2657             unsigned char *selected;
2658             unsigned char selected_len;
2659             /* We must have requested it. */
2660             if (s->ctx->next_proto_select_cb == NULL) {
2661                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2662                 return 0;
2663             }
2664             /* The data must be valid */
2665             if (!ssl_next_proto_validate(&spkt)) {
2666                 *al = TLS1_AD_DECODE_ERROR;
2667                 return 0;
2668             }
2669             if (s->ctx->next_proto_select_cb(s, &selected, &selected_len, data,
2670                                              size,
2671                                              s->
2672                                              ctx->next_proto_select_cb_arg) !=
2673                 SSL_TLSEXT_ERR_OK) {
2674                 *al = TLS1_AD_INTERNAL_ERROR;
2675                 return 0;
2676             }
2677             /*
2678              * Could be non-NULL if server has sent multiple NPN extensions in
2679              * a single Serverhello
2680              */
2681             OPENSSL_free(s->next_proto_negotiated);
2682             s->next_proto_negotiated = OPENSSL_malloc(selected_len);
2683             if (s->next_proto_negotiated == NULL) {
2684                 *al = TLS1_AD_INTERNAL_ERROR;
2685                 return 0;
2686             }
2687             memcpy(s->next_proto_negotiated, selected, selected_len);
2688             s->next_proto_negotiated_len = selected_len;
2689             s->s3->next_proto_neg_seen = 1;
2690         }
2691 #endif
2692
2693         else if (type == TLSEXT_TYPE_application_layer_protocol_negotiation) {
2694             unsigned len;
2695             /* We must have requested it. */
2696             if (!s->s3->alpn_sent) {
2697                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
2698                 return 0;
2699             }
2700             /*-
2701              * The extension data consists of:
2702              *   uint16 list_length
2703              *   uint8 proto_length;
2704              *   uint8 proto[proto_length];
2705              */
2706             if (!PACKET_get_net_2(&spkt, &len)
2707                 || PACKET_remaining(&spkt) != len || !PACKET_get_1(&spkt, &len)
2708                 || PACKET_remaining(&spkt) != len) {
2709                 *al = TLS1_AD_DECODE_ERROR;
2710                 return 0;
2711             }
2712             OPENSSL_free(s->s3->alpn_selected);
2713             s->s3->alpn_selected = OPENSSL_malloc(len);
2714             if (s->s3->alpn_selected == NULL) {
2715                 *al = TLS1_AD_INTERNAL_ERROR;
2716                 return 0;
2717             }
2718             if (!PACKET_copy_bytes(&spkt, s->s3->alpn_selected, len)) {
2719                 *al = TLS1_AD_DECODE_ERROR;
2720                 return 0;
2721             }
2722             s->s3->alpn_selected_len = len;
2723         }
2724 #ifndef OPENSSL_NO_SRTP
2725         else if (SSL_IS_DTLS(s) && type == TLSEXT_TYPE_use_srtp) {
2726             if (ssl_parse_serverhello_use_srtp_ext(s, &spkt, al))
2727                 return 0;
2728         }
2729 #endif
2730         else if (type == TLSEXT_TYPE_encrypt_then_mac) {
2731             /* Ignore if inappropriate ciphersuite */
2732             if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) &&
2733                 s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
2734                 && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
2735                 s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
2736         } else if (type == TLSEXT_TYPE_extended_master_secret &&
2737                 (SSL_IS_DTLS(s) || !SSL_IS_TLS13(s))) {
2738             s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
2739             if (!s->hit)
2740                 s->session->flags |= SSL_SESS_FLAG_EXTMS;
2741         } else if (type == TLSEXT_TYPE_key_share
2742                 && SSL_IS_TLS13(s)) {
2743             unsigned int group_id;
2744             PACKET encoded_pt;
2745             EVP_PKEY *ckey = s->s3->tmp.pkey, *skey = NULL;
2746
2747             /* Sanity check */
2748             if (ckey == NULL) {
2749                 *al = SSL_AD_INTERNAL_ERROR;
2750                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
2751                 return 0;
2752             }
2753
2754             if (!PACKET_get_net_2(&spkt, &group_id)) {
2755                 *al = SSL_AD_HANDSHAKE_FAILURE;
2756                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2757                        SSL_R_LENGTH_MISMATCH);
2758                 return 0;
2759             }
2760
2761             if (group_id != s->s3->group_id) {
2762                 /*
2763                  * This isn't for the group that we sent in the original
2764                  * key_share!
2765                  */
2766                 *al = SSL_AD_HANDSHAKE_FAILURE;
2767                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2768                        SSL_R_BAD_KEY_SHARE);
2769                 return 0;
2770             }
2771
2772             if (!PACKET_as_length_prefixed_2(&spkt, &encoded_pt)
2773                     || PACKET_remaining(&encoded_pt) == 0) {
2774                 *al = SSL_AD_DECODE_ERROR;
2775                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2776                        SSL_R_LENGTH_MISMATCH);
2777                 return 0;
2778             }
2779
2780             skey = ssl_generate_pkey(ckey);
2781             if (!EVP_PKEY_set1_tls_encodedpoint(skey, PACKET_data(&encoded_pt),
2782                                                 PACKET_remaining(&encoded_pt))) {
2783                 *al = SSL_AD_DECODE_ERROR;
2784                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_BAD_ECPOINT);
2785                 return 0;
2786             }
2787
2788             if (ssl_derive(s, ckey, skey, 1) == 0) {
2789                 *al = SSL_AD_INTERNAL_ERROR;
2790                 SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
2791                 EVP_PKEY_free(skey);
2792                 return 0;
2793             }
2794             EVP_PKEY_free(skey);
2795         /*
2796          * If this extension type was not otherwise handled, but matches a
2797          * custom_cli_ext_record, then send it to the c callback
2798          */
2799         } else if (custom_ext_parse(s, 0, type, data, size, al) <= 0)
2800             return 0;
2801     }
2802
2803     if (PACKET_remaining(pkt) != 0) {
2804         *al = SSL_AD_DECODE_ERROR;
2805         return 0;
2806     }
2807
2808     if (!s->hit && tlsext_servername == 1) {
2809         if (s->tlsext_hostname) {
2810             if (s->session->tlsext_hostname == NULL) {
2811                 s->session->tlsext_hostname =
2812                     OPENSSL_strdup(s->tlsext_hostname);
2813                 if (!s->session->tlsext_hostname) {
2814                     *al = SSL_AD_UNRECOGNIZED_NAME;
2815                     return 0;
2816                 }
2817             } else {
2818                 *al = SSL_AD_DECODE_ERROR;
2819                 return 0;
2820             }
2821         }
2822     }
2823
2824  ri_check:
2825
2826     /*
2827      * Determine if we need to see RI. Strictly speaking if we want to avoid
2828      * an attack we should *always* see RI even on initial server hello
2829      * because the client doesn't see any renegotiation during an attack.
2830      * However this would mean we could not connect to any server which
2831      * doesn't support RI so for the immediate future tolerate RI absence
2832      */
2833     if (!renegotiate_seen && !(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
2834         && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
2835         *al = SSL_AD_HANDSHAKE_FAILURE;
2836         SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
2837                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
2838         return 0;
2839     }
2840
2841     if (s->hit) {
2842         /*
2843          * Check extended master secret extension is consistent with
2844          * original session.
2845          */
2846         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
2847             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
2848             *al = SSL_AD_HANDSHAKE_FAILURE;
2849             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_INCONSISTENT_EXTMS);
2850             return 0;
2851         }
2852     }
2853
2854     return 1;
2855 }
2856
2857 int ssl_prepare_clienthello_tlsext(SSL *s)
2858 {
2859     s->s3->alpn_sent = 0;
2860     return 1;
2861 }
2862
2863 int ssl_prepare_serverhello_tlsext(SSL *s)
2864 {
2865     return 1;
2866 }
2867
2868 static int ssl_check_clienthello_tlsext_early(SSL *s)
2869 {
2870     int ret = SSL_TLSEXT_ERR_NOACK;
2871     int al = SSL_AD_UNRECOGNIZED_NAME;
2872
2873 #ifndef OPENSSL_NO_EC
2874     /*
2875      * The handling of the ECPointFormats extension is done elsewhere, namely
2876      * in ssl3_choose_cipher in s3_lib.c.
2877      */
2878     /*
2879      * The handling of the EllipticCurves extension is done elsewhere, namely
2880      * in ssl3_choose_cipher in s3_lib.c.
2881      */
2882 #endif
2883
2884     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
2885         ret =
2886             s->ctx->tlsext_servername_callback(s, &al,
2887                                                s->ctx->tlsext_servername_arg);
2888     else if (s->initial_ctx != NULL
2889              && s->initial_ctx->tlsext_servername_callback != 0)
2890         ret =
2891             s->initial_ctx->tlsext_servername_callback(s, &al,
2892                                                        s->
2893                                                        initial_ctx->tlsext_servername_arg);
2894
2895     switch (ret) {
2896     case SSL_TLSEXT_ERR_ALERT_FATAL:
2897         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2898         return -1;
2899
2900     case SSL_TLSEXT_ERR_ALERT_WARNING:
2901         ssl3_send_alert(s, SSL3_AL_WARNING, al);
2902         return 1;
2903
2904     case SSL_TLSEXT_ERR_NOACK:
2905         s->servername_done = 0;
2906     default:
2907         return 1;
2908     }
2909 }
2910
2911 /* Initialise digests to default values */
2912 void ssl_set_default_md(SSL *s)
2913 {
2914     const EVP_MD **pmd = s->s3->tmp.md;
2915 #ifndef OPENSSL_NO_DSA
2916     pmd[SSL_PKEY_DSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2917 #endif
2918 #ifndef OPENSSL_NO_RSA
2919     if (SSL_USE_SIGALGS(s))
2920         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
2921     else
2922         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_MD5_SHA1_IDX);
2923     pmd[SSL_PKEY_RSA_ENC] = pmd[SSL_PKEY_RSA_SIGN];
2924 #endif
2925 #ifndef OPENSSL_NO_EC
2926     pmd[SSL_PKEY_ECC] = ssl_md(SSL_MD_SHA1_IDX);
2927 #endif
2928 #ifndef OPENSSL_NO_GOST
2929     pmd[SSL_PKEY_GOST01] = ssl_md(SSL_MD_GOST94_IDX);
2930     pmd[SSL_PKEY_GOST12_256] = ssl_md(SSL_MD_GOST12_256_IDX);
2931     pmd[SSL_PKEY_GOST12_512] = ssl_md(SSL_MD_GOST12_512_IDX);
2932 #endif
2933 }
2934
2935 int tls1_set_server_sigalgs(SSL *s)
2936 {
2937     int al;
2938     size_t i;
2939
2940     /* Clear any shared signature algorithms */
2941     OPENSSL_free(s->cert->shared_sigalgs);
2942     s->cert->shared_sigalgs = NULL;
2943     s->cert->shared_sigalgslen = 0;
2944     /* Clear certificate digests and validity flags */
2945     for (i = 0; i < SSL_PKEY_NUM; i++) {
2946         s->s3->tmp.md[i] = NULL;
2947         s->s3->tmp.valid_flags[i] = 0;
2948     }
2949
2950     /* If sigalgs received process it. */
2951     if (s->s3->tmp.peer_sigalgs) {
2952         if (!tls1_process_sigalgs(s)) {
2953             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS, ERR_R_MALLOC_FAILURE);
2954             al = SSL_AD_INTERNAL_ERROR;
2955             goto err;
2956         }
2957         /* Fatal error is no shared signature algorithms */
2958         if (!s->cert->shared_sigalgs) {
2959             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS,
2960                    SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
2961             al = SSL_AD_ILLEGAL_PARAMETER;
2962             goto err;
2963         }
2964     } else {
2965         ssl_set_default_md(s);
2966     }
2967     return 1;
2968  err:
2969     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2970     return 0;
2971 }
2972
2973 /*
2974  * Upon success, returns 1.
2975  * Upon failure, returns 0 and sets |al| to the appropriate fatal alert.
2976  */
2977 int ssl_check_clienthello_tlsext_late(SSL *s, int *al)
2978 {
2979     s->tlsext_status_expected = 0;
2980
2981     /*
2982      * If status request then ask callback what to do. Note: this must be
2983      * called after servername callbacks in case the certificate has changed,
2984      * and must be called after the cipher has been chosen because this may
2985      * influence which certificate is sent
2986      */
2987     if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb) {
2988         int ret;
2989         CERT_PKEY *certpkey;
2990         certpkey = ssl_get_server_send_pkey(s);
2991         /* If no certificate can't return certificate status */
2992         if (certpkey != NULL) {
2993             /*
2994              * Set current certificate to one we will use so SSL_get_certificate
2995              * et al can pick it up.
2996              */
2997             s->cert->key = certpkey;
2998             ret = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
2999             switch (ret) {
3000                 /* We don't want to send a status request response */
3001             case SSL_TLSEXT_ERR_NOACK:
3002                 s->tlsext_status_expected = 0;
3003                 break;
3004                 /* status request response should be sent */
3005             case SSL_TLSEXT_ERR_OK:
3006                 if (s->tlsext_ocsp_resp)
3007                     s->tlsext_status_expected = 1;
3008                 break;
3009                 /* something bad happened */
3010             case SSL_TLSEXT_ERR_ALERT_FATAL:
3011             default:
3012                 *al = SSL_AD_INTERNAL_ERROR;
3013                 return 0;
3014             }
3015         }
3016     }
3017
3018     if (!tls1_alpn_handle_client_hello_late(s, al)) {
3019         return 0;
3020     }
3021
3022     return 1;
3023 }
3024
3025 int ssl_check_serverhello_tlsext(SSL *s)
3026 {
3027     int ret = SSL_TLSEXT_ERR_NOACK;
3028     int al = SSL_AD_UNRECOGNIZED_NAME;
3029
3030 #ifndef OPENSSL_NO_EC
3031     /*
3032      * If we are client and using an elliptic curve cryptography cipher
3033      * suite, then if server returns an EC point formats lists extension it
3034      * must contain uncompressed.
3035      */
3036     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3037     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
3038     if ((s->tlsext_ecpointformatlist != NULL)
3039         && (s->tlsext_ecpointformatlist_length > 0)
3040         && (s->session->tlsext_ecpointformatlist != NULL)
3041         && (s->session->tlsext_ecpointformatlist_length > 0)
3042         && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
3043         /* we are using an ECC cipher */
3044         size_t i;
3045         unsigned char *list;
3046         int found_uncompressed = 0;
3047         list = s->session->tlsext_ecpointformatlist;
3048         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
3049             if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed) {
3050                 found_uncompressed = 1;
3051                 break;
3052             }
3053         }
3054         if (!found_uncompressed) {
3055             SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,
3056                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
3057             return -1;
3058         }
3059     }
3060     ret = SSL_TLSEXT_ERR_OK;
3061 #endif                          /* OPENSSL_NO_EC */
3062
3063     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
3064         ret =
3065             s->ctx->tlsext_servername_callback(s, &al,
3066                                                s->ctx->tlsext_servername_arg);
3067     else if (s->initial_ctx != NULL
3068              && s->initial_ctx->tlsext_servername_callback != 0)
3069         ret =
3070             s->initial_ctx->tlsext_servername_callback(s, &al,
3071                                                        s->
3072                                                        initial_ctx->tlsext_servername_arg);
3073
3074     /*
3075      * Ensure we get sensible values passed to tlsext_status_cb in the event
3076      * that we don't receive a status message
3077      */
3078     OPENSSL_free(s->tlsext_ocsp_resp);
3079     s->tlsext_ocsp_resp = NULL;
3080     s->tlsext_ocsp_resplen = 0;
3081
3082     switch (ret) {
3083     case SSL_TLSEXT_ERR_ALERT_FATAL:
3084         ssl3_send_alert(s, SSL3_AL_FATAL, al);
3085         return -1;
3086
3087     case SSL_TLSEXT_ERR_ALERT_WARNING:
3088         ssl3_send_alert(s, SSL3_AL_WARNING, al);
3089         return 1;
3090
3091     case SSL_TLSEXT_ERR_NOACK:
3092         s->servername_done = 0;
3093     default:
3094         return 1;
3095     }
3096 }
3097
3098 int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt)
3099 {
3100     int al = -1;
3101     if (s->version < SSL3_VERSION)
3102         return 1;
3103     if (ssl_scan_serverhello_tlsext(s, pkt, &al) <= 0) {
3104         ssl3_send_alert(s, SSL3_AL_FATAL, al);
3105         return 0;
3106     }
3107
3108     if (ssl_check_serverhello_tlsext(s) <= 0) {
3109         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT, SSL_R_SERVERHELLO_TLSEXT);
3110         return 0;
3111     }
3112     return 1;
3113 }
3114
3115 /*
3116  * Given a list of extensions that we collected earlier, find one of a given
3117  * type and return it.
3118  *
3119  * |exts| is the set of extensions previously collected.
3120  * |numexts| is the number of extensions that we have.
3121  * |type| the type of the extension that we are looking for.
3122  *
3123  * Returns a pointer to the found RAW_EXTENSION data, or NULL if not found.
3124  */
3125 RAW_EXTENSION *tls_get_extension_by_type(RAW_EXTENSION *exts, size_t numexts,
3126                                          unsigned int type)
3127 {
3128     size_t loop;
3129
3130     for (loop = 0; loop < numexts; loop++) {
3131         if (exts[loop].type == type)
3132             return &exts[loop];
3133     }
3134
3135     return NULL;
3136 }
3137
3138 /*-
3139  * Gets the ticket information supplied by the client if any.
3140  *
3141  *   hello: The parsed ClientHello data
3142  *   ret: (output) on return, if a ticket was decrypted, then this is set to
3143  *       point to the resulting session.
3144  *
3145  * If s->tls_session_secret_cb is set then we are expecting a pre-shared key
3146  * ciphersuite, in which case we have no use for session tickets and one will
3147  * never be decrypted, nor will s->tlsext_ticket_expected be set to 1.
3148  *
3149  * Returns:
3150  *   -1: fatal error, either from parsing or decrypting the ticket.
3151  *    0: no ticket was found (or was ignored, based on settings).
3152  *    1: a zero length extension was found, indicating that the client supports
3153  *       session tickets but doesn't currently have one to offer.
3154  *    2: either s->tls_session_secret_cb was set, or a ticket was offered but
3155  *       couldn't be decrypted because of a non-fatal error.
3156  *    3: a ticket was successfully decrypted and *ret was set.
3157  *
3158  * Side effects:
3159  *   Sets s->tlsext_ticket_expected to 1 if the server will have to issue
3160  *   a new session ticket to the client because the client indicated support
3161  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
3162  *   a session ticket or we couldn't use the one it gave us, or if
3163  *   s->ctx->tlsext_ticket_key_cb asked to renew the client's ticket.
3164  *   Otherwise, s->tlsext_ticket_expected is set to 0.
3165  */
3166 int tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
3167                                SSL_SESSION **ret)
3168 {
3169     int retv;
3170     const unsigned char *etick;
3171     size_t size;
3172     RAW_EXTENSION *ticketext;
3173
3174     *ret = NULL;
3175     s->tlsext_ticket_expected = 0;
3176
3177     /*
3178      * If tickets disabled or not supported by the protocol version
3179      * (e.g. TLSv1.3) behave as if no ticket present to permit stateful
3180      * resumption.
3181      */
3182     if (s->version <= SSL3_VERSION || !tls_use_ticket(s))
3183         return 0;
3184
3185     ticketext = tls_get_extension_by_type(hello->pre_proc_exts,
3186                                           hello->num_extensions,
3187                                           TLSEXT_TYPE_session_ticket);
3188     if (ticketext == NULL)
3189         return 0;
3190
3191     size = PACKET_remaining(&ticketext->data);
3192     if (size == 0) {
3193         /*
3194          * The client will accept a ticket but doesn't currently have
3195          * one.
3196          */
3197         s->tlsext_ticket_expected = 1;
3198         return 1;
3199     }
3200     if (s->tls_session_secret_cb) {
3201         /*
3202          * Indicate that the ticket couldn't be decrypted rather than
3203          * generating the session from ticket now, trigger
3204          * abbreviated handshake based on external mechanism to
3205          * calculate the master secret later.
3206          */
3207         return 2;
3208     }
3209     if (!PACKET_get_bytes(&ticketext->data, &etick, size)) {
3210         /* Shouldn't ever happen */
3211         return -1;
3212     }
3213     retv = tls_decrypt_ticket(s, etick, size, hello->session_id,
3214                            hello->session_id_len, ret);
3215     switch (retv) {
3216     case 2:            /* ticket couldn't be decrypted */
3217         s->tlsext_ticket_expected = 1;
3218         return 2;
3219
3220     case 3:            /* ticket was decrypted */
3221         return 3;
3222
3223     case 4:            /* ticket decrypted but need to renew */
3224         s->tlsext_ticket_expected = 1;
3225         return 3;
3226
3227     default:           /* fatal error */
3228         return -1;
3229     }
3230 }
3231
3232 /*
3233  * Sets the extended master secret flag if the extension is present in the
3234  * ClientHello and we can support it
3235  * Returns:
3236  *  1 on success
3237  *  0 on error
3238  */
3239 int tls_check_client_ems_support(SSL *s, const CLIENTHELLO_MSG *hello)
3240 {
3241     RAW_EXTENSION *emsext;
3242
3243     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
3244
3245     if (!SSL_IS_DTLS(s) && (s->version < TLS1_VERSION
3246                             || s->version > TLS1_2_VERSION))
3247         return 1;
3248
3249     emsext = tls_get_extension_by_type(hello->pre_proc_exts,
3250                                        hello->num_extensions,
3251                                        TLSEXT_TYPE_extended_master_secret);
3252
3253     /*
3254      * No extensions is a success - we have successfully discovered that the
3255      * client doesn't support EMS.
3256      */
3257     if (emsext == NULL)
3258         return 1;
3259
3260     /* The extensions must always be empty */
3261     if (PACKET_remaining(&emsext->data) != 0)
3262         return 0;
3263
3264     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
3265
3266     return 1;
3267 }
3268
3269 /*-
3270  * tls_decrypt_ticket attempts to decrypt a session ticket.
3271  *
3272  *   etick: points to the body of the session ticket extension.
3273  *   eticklen: the length of the session tickets extension.
3274  *   sess_id: points at the session ID.
3275  *   sesslen: the length of the session ID.
3276  *   psess: (output) on return, if a ticket was decrypted, then this is set to
3277  *       point to the resulting session.
3278  *
3279  * Returns:
3280  *   -2: fatal error, malloc failure.
3281  *   -1: fatal error, either from parsing or decrypting the ticket.
3282  *    2: the ticket couldn't be decrypted.
3283  *    3: a ticket was successfully decrypted and *psess was set.
3284  *    4: same as 3, but the ticket needs to be renewed.
3285  */
3286 static int tls_decrypt_ticket(SSL *s, const unsigned char *etick,
3287                               size_t eticklen, const unsigned char *sess_id,
3288                               size_t sesslen, SSL_SESSION **psess)
3289 {
3290     SSL_SESSION *sess;
3291     unsigned char *sdec;
3292     const unsigned char *p;
3293     int slen, renew_ticket = 0, ret = -1, declen;
3294     size_t mlen;
3295     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
3296     HMAC_CTX *hctx = NULL;
3297     EVP_CIPHER_CTX *ctx;
3298     SSL_CTX *tctx = s->initial_ctx;
3299
3300     /* Initialize session ticket encryption and HMAC contexts */
3301     hctx = HMAC_CTX_new();
3302     if (hctx == NULL)
3303         return -2;
3304     ctx = EVP_CIPHER_CTX_new();
3305     if (ctx == NULL) {
3306         ret = -2;
3307         goto err;
3308     }
3309     if (tctx->tlsext_ticket_key_cb) {
3310         unsigned char *nctick = (unsigned char *)etick;
3311         int rv = tctx->tlsext_ticket_key_cb(s, nctick, nctick + 16,
3312                                             ctx, hctx, 0);
3313         if (rv < 0)
3314             goto err;
3315         if (rv == 0) {
3316             ret = 2;
3317             goto err;
3318         }
3319         if (rv == 2)
3320             renew_ticket = 1;
3321     } else {
3322         /* Check key name matches */
3323         if (memcmp(etick, tctx->tlsext_tick_key_name,
3324                    sizeof(tctx->tlsext_tick_key_name)) != 0) {
3325             ret = 2;
3326             goto err;
3327         }
3328         if (HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
3329                          sizeof(tctx->tlsext_tick_hmac_key),
3330                          EVP_sha256(), NULL) <= 0
3331             || EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL,
3332                                   tctx->tlsext_tick_aes_key,
3333                                   etick + sizeof(tctx->tlsext_tick_key_name)) <=
3334             0) {
3335             goto err;
3336         }
3337     }
3338     /*
3339      * Attempt to process session ticket, first conduct sanity and integrity
3340      * checks on ticket.
3341      */
3342     mlen = HMAC_size(hctx);
3343     if (mlen == 0) {
3344         goto err;
3345     }
3346     /* Sanity check ticket length: must exceed keyname + IV + HMAC */
3347     if (eticklen <=
3348         TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_iv_length(ctx) + mlen) {
3349         ret = 2;
3350         goto err;
3351     }
3352     eticklen -= mlen;
3353     /* Check HMAC of encrypted ticket */
3354     if (HMAC_Update(hctx, etick, eticklen) <= 0
3355         || HMAC_Final(hctx, tick_hmac, NULL) <= 0) {
3356         goto err;
3357     }
3358     HMAC_CTX_free(hctx);
3359     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
3360         EVP_CIPHER_CTX_free(ctx);
3361         return 2;
3362     }
3363     /* Attempt to decrypt session data */
3364     /* Move p after IV to start of encrypted ticket, update length */
3365     p = etick + 16 + EVP_CIPHER_CTX_iv_length(ctx);
3366     eticklen -= 16 + EVP_CIPHER_CTX_iv_length(ctx);
3367     sdec = OPENSSL_malloc(eticklen);
3368     if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p,
3369                                           (int)eticklen) <= 0) {
3370         EVP_CIPHER_CTX_free(ctx);
3371         OPENSSL_free(sdec);
3372         return -1;
3373     }
3374     if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) {
3375         EVP_CIPHER_CTX_free(ctx);
3376         OPENSSL_free(sdec);
3377         return 2;
3378     }
3379     slen += declen;
3380     EVP_CIPHER_CTX_free(ctx);
3381     ctx = NULL;
3382     p = sdec;
3383
3384     sess = d2i_SSL_SESSION(NULL, &p, slen);
3385     OPENSSL_free(sdec);
3386     if (sess) {
3387         /*
3388          * The session ID, if non-empty, is used by some clients to detect
3389          * that the ticket has been accepted. So we copy it to the session
3390          * structure. If it is empty set length to zero as required by
3391          * standard.
3392          */
3393         if (sesslen)
3394             memcpy(sess->session_id, sess_id, sesslen);
3395         sess->session_id_length = sesslen;
3396         *psess = sess;
3397         if (renew_ticket)
3398             return 4;
3399         else
3400             return 3;
3401     }
3402     ERR_clear_error();
3403     /*
3404      * For session parse failure, indicate that we need to send a new ticket.
3405      */
3406     return 2;
3407  err:
3408     EVP_CIPHER_CTX_free(ctx);
3409     HMAC_CTX_free(hctx);
3410     return ret;
3411 }
3412
3413 /* Tables to translate from NIDs to TLS v1.2 ids */
3414
3415 typedef struct {
3416     int nid;
3417     int id;
3418 } tls12_lookup;
3419
3420 static const tls12_lookup tls12_md[] = {
3421     {NID_md5, TLSEXT_hash_md5},
3422     {NID_sha1, TLSEXT_hash_sha1},
3423     {NID_sha224, TLSEXT_hash_sha224},
3424     {NID_sha256, TLSEXT_hash_sha256},
3425     {NID_sha384, TLSEXT_hash_sha384},
3426     {NID_sha512, TLSEXT_hash_sha512},
3427     {NID_id_GostR3411_94, TLSEXT_hash_gostr3411},
3428     {NID_id_GostR3411_2012_256, TLSEXT_hash_gostr34112012_256},
3429     {NID_id_GostR3411_2012_512, TLSEXT_hash_gostr34112012_512},
3430 };
3431
3432 static const tls12_lookup tls12_sig[] = {
3433     {EVP_PKEY_RSA, TLSEXT_signature_rsa},
3434     {EVP_PKEY_DSA, TLSEXT_signature_dsa},
3435     {EVP_PKEY_EC, TLSEXT_signature_ecdsa},
3436     {NID_id_GostR3410_2001, TLSEXT_signature_gostr34102001},
3437     {NID_id_GostR3410_2012_256, TLSEXT_signature_gostr34102012_256},
3438     {NID_id_GostR3410_2012_512, TLSEXT_signature_gostr34102012_512}
3439 };
3440
3441 static int tls12_find_id(int nid, const tls12_lookup *table, size_t tlen)
3442 {
3443     size_t i;
3444     for (i = 0; i < tlen; i++) {
3445         if (table[i].nid == nid)
3446             return table[i].id;
3447     }
3448     return -1;
3449 }
3450
3451 static int tls12_find_nid(int id, const tls12_lookup *table, size_t tlen)
3452 {
3453     size_t i;
3454     for (i = 0; i < tlen; i++) {
3455         if ((table[i].id) == id)
3456             return table[i].nid;
3457     }
3458     return NID_undef;
3459 }
3460
3461 int tls12_get_sigandhash(WPACKET *pkt, const EVP_PKEY *pk, const EVP_MD *md)
3462 {
3463     int sig_id, md_id;
3464
3465     if (md == NULL)
3466         return 0;
3467     md_id = tls12_find_id(EVP_MD_type(md), tls12_md, OSSL_NELEM(tls12_md));
3468     if (md_id == -1)
3469         return 0;
3470     sig_id = tls12_get_sigid(pk);
3471     if (sig_id == -1)
3472         return 0;
3473     if (!WPACKET_put_bytes_u8(pkt, md_id) || !WPACKET_put_bytes_u8(pkt, sig_id))
3474         return 0;
3475
3476     return 1;
3477 }
3478
3479 int tls12_get_sigid(const EVP_PKEY *pk)
3480 {
3481     return tls12_find_id(EVP_PKEY_id(pk), tls12_sig, OSSL_NELEM(tls12_sig));
3482 }
3483
3484 typedef struct {
3485     int nid;
3486     int secbits;
3487     int md_idx;
3488     unsigned char tlsext_hash;
3489 } tls12_hash_info;
3490
3491 static const tls12_hash_info tls12_md_info[] = {
3492     {NID_md5, 64, SSL_MD_MD5_IDX, TLSEXT_hash_md5},
3493     {NID_sha1, 80, SSL_MD_SHA1_IDX, TLSEXT_hash_sha1},
3494     {NID_sha224, 112, SSL_MD_SHA224_IDX, TLSEXT_hash_sha224},
3495     {NID_sha256, 128, SSL_MD_SHA256_IDX, TLSEXT_hash_sha256},
3496     {NID_sha384, 192, SSL_MD_SHA384_IDX, TLSEXT_hash_sha384},
3497     {NID_sha512, 256, SSL_MD_SHA512_IDX, TLSEXT_hash_sha512},
3498     {NID_id_GostR3411_94, 128, SSL_MD_GOST94_IDX, TLSEXT_hash_gostr3411},
3499     {NID_id_GostR3411_2012_256, 128, SSL_MD_GOST12_256_IDX,
3500      TLSEXT_hash_gostr34112012_256},
3501     {NID_id_GostR3411_2012_512, 256, SSL_MD_GOST12_512_IDX,
3502      TLSEXT_hash_gostr34112012_512},
3503 };
3504
3505 static const tls12_hash_info *tls12_get_hash_info(unsigned char hash_alg)
3506 {
3507     unsigned int i;
3508     if (hash_alg == 0)
3509         return NULL;
3510
3511     for (i = 0; i < OSSL_NELEM(tls12_md_info); i++) {
3512         if (tls12_md_info[i].tlsext_hash == hash_alg)
3513             return tls12_md_info + i;
3514     }
3515
3516     return NULL;
3517 }
3518
3519 const EVP_MD *tls12_get_hash(unsigned char hash_alg)
3520 {
3521     const tls12_hash_info *inf;
3522     if (hash_alg == TLSEXT_hash_md5 && FIPS_mode())
3523         return NULL;
3524     inf = tls12_get_hash_info(hash_alg);
3525     if (!inf)
3526         return NULL;
3527     return ssl_md(inf->md_idx);
3528 }
3529
3530 static int tls12_get_pkey_idx(unsigned char sig_alg)
3531 {
3532     switch (sig_alg) {
3533 #ifndef OPENSSL_NO_RSA
3534     case TLSEXT_signature_rsa:
3535         return SSL_PKEY_RSA_SIGN;
3536 #endif
3537 #ifndef OPENSSL_NO_DSA
3538     case TLSEXT_signature_dsa:
3539         return SSL_PKEY_DSA_SIGN;
3540 #endif
3541 #ifndef OPENSSL_NO_EC
3542     case TLSEXT_signature_ecdsa:
3543         return SSL_PKEY_ECC;
3544 #endif
3545 #ifndef OPENSSL_NO_GOST
3546     case TLSEXT_signature_gostr34102001:
3547         return SSL_PKEY_GOST01;
3548
3549     case TLSEXT_signature_gostr34102012_256:
3550         return SSL_PKEY_GOST12_256;
3551
3552     case TLSEXT_signature_gostr34102012_512:
3553         return SSL_PKEY_GOST12_512;
3554 #endif
3555     }
3556     return -1;
3557 }
3558
3559 /* Convert TLS 1.2 signature algorithm extension values into NIDs */
3560 static void tls1_lookup_sigalg(int *phash_nid, int *psign_nid,
3561                                int *psignhash_nid, const unsigned char *data)
3562 {
3563     int sign_nid = NID_undef, hash_nid = NID_undef;
3564     if (!phash_nid && !psign_nid && !psignhash_nid)
3565         return;
3566     if (phash_nid || psignhash_nid) {
3567         hash_nid = tls12_find_nid(data[0], tls12_md, OSSL_NELEM(tls12_md));
3568         if (phash_nid)
3569             *phash_nid = hash_nid;
3570     }
3571     if (psign_nid || psignhash_nid) {
3572         sign_nid = tls12_find_nid(data[1], tls12_sig, OSSL_NELEM(tls12_sig));
3573         if (psign_nid)
3574             *psign_nid = sign_nid;
3575     }
3576     if (psignhash_nid) {
3577         if (sign_nid == NID_undef || hash_nid == NID_undef
3578             || OBJ_find_sigid_by_algs(psignhash_nid, hash_nid, sign_nid) <= 0)
3579             *psignhash_nid = NID_undef;
3580     }
3581 }
3582
3583 /* Check to see if a signature algorithm is allowed */
3584 static int tls12_sigalg_allowed(SSL *s, int op, const unsigned char *ptmp)
3585 {
3586     /* See if we have an entry in the hash table and it is enabled */
3587     const tls12_hash_info *hinf = tls12_get_hash_info(ptmp[0]);
3588     if (hinf == NULL || ssl_md(hinf->md_idx) == NULL)
3589         return 0;
3590     /* See if public key algorithm allowed */
3591     if (tls12_get_pkey_idx(ptmp[1]) == -1)
3592         return 0;
3593     /* Finally see if security callback allows it */
3594     return ssl_security(s, op, hinf->secbits, hinf->nid, (void *)ptmp);
3595 }
3596
3597 /*
3598  * Get a mask of disabled public key algorithms based on supported signature
3599  * algorithms. For example if no signature algorithm supports RSA then RSA is
3600  * disabled.
3601  */
3602
3603 void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op)
3604 {
3605     const unsigned char *sigalgs;
3606     size_t i, sigalgslen;
3607     int have_rsa = 0, have_dsa = 0, have_ecdsa = 0;
3608     /*
3609      * Now go through all signature algorithms seeing if we support any for
3610      * RSA, DSA, ECDSA. Do this for all versions not just TLS 1.2. To keep
3611      * down calls to security callback only check if we have to.
3612      */
3613     sigalgslen = tls12_get_psigalgs(s, &sigalgs);
3614     for (i = 0; i < sigalgslen; i += 2, sigalgs += 2) {
3615         switch (sigalgs[1]) {
3616 #ifndef OPENSSL_NO_RSA
3617         case TLSEXT_signature_rsa:
3618             if (!have_rsa && tls12_sigalg_allowed(s, op, sigalgs))
3619                 have_rsa = 1;
3620             break;
3621 #endif
3622 #ifndef OPENSSL_NO_DSA
3623         case TLSEXT_signature_dsa:
3624             if (!have_dsa && tls12_sigalg_allowed(s, op, sigalgs))
3625                 have_dsa = 1;
3626             break;
3627 #endif
3628 #ifndef OPENSSL_NO_EC
3629         case TLSEXT_signature_ecdsa:
3630             if (!have_ecdsa && tls12_sigalg_allowed(s, op, sigalgs))
3631                 have_ecdsa = 1;
3632             break;
3633 #endif
3634         }
3635     }
3636     if (!have_rsa)
3637         *pmask_a |= SSL_aRSA;
3638     if (!have_dsa)
3639         *pmask_a |= SSL_aDSS;
3640     if (!have_ecdsa)
3641         *pmask_a |= SSL_aECDSA;
3642 }
3643
3644 int tls12_copy_sigalgs(SSL *s, WPACKET *pkt,
3645                        const unsigned char *psig, size_t psiglen)
3646 {
3647     size_t i;
3648
3649     for (i = 0; i < psiglen; i += 2, psig += 2) {
3650         if (tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, psig)) {
3651             if (!WPACKET_put_bytes_u8(pkt, psig[0])
3652                     || !WPACKET_put_bytes_u8(pkt, psig[1]))
3653                 return 0;
3654         }
3655     }
3656     return 1;
3657 }
3658
3659 /* Given preference and allowed sigalgs set shared sigalgs */
3660 static size_t tls12_shared_sigalgs(SSL *s, TLS_SIGALGS *shsig,
3661                                    const unsigned char *pref, size_t preflen,
3662                                    const unsigned char *allow, size_t allowlen)
3663 {
3664     const unsigned char *ptmp, *atmp;
3665     size_t i, j, nmatch = 0;
3666     for (i = 0, ptmp = pref; i < preflen; i += 2, ptmp += 2) {
3667         /* Skip disabled hashes or signature algorithms */
3668         if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, ptmp))
3669             continue;
3670         for (j = 0, atmp = allow; j < allowlen; j += 2, atmp += 2) {
3671             if (ptmp[0] == atmp[0] && ptmp[1] == atmp[1]) {
3672                 nmatch++;
3673                 if (shsig) {
3674                     shsig->rhash = ptmp[0];
3675                     shsig->rsign = ptmp[1];
3676                     tls1_lookup_sigalg(&shsig->hash_nid,
3677                                        &shsig->sign_nid,
3678                                        &shsig->signandhash_nid, ptmp);
3679                     shsig++;
3680                 }
3681                 break;
3682             }
3683         }
3684     }
3685     return nmatch;
3686 }
3687
3688 /* Set shared signature algorithms for SSL structures */
3689 static int tls1_set_shared_sigalgs(SSL *s)
3690 {
3691     const unsigned char *pref, *allow, *conf;
3692     size_t preflen, allowlen, conflen;
3693     size_t nmatch;
3694     TLS_SIGALGS *salgs = NULL;
3695     CERT *c = s->cert;
3696     unsigned int is_suiteb = tls1_suiteb(s);
3697
3698     OPENSSL_free(c->shared_sigalgs);
3699     c->shared_sigalgs = NULL;
3700     c->shared_sigalgslen = 0;
3701     /* If client use client signature algorithms if not NULL */
3702     if (!s->server && c->client_sigalgs && !is_suiteb) {
3703         conf = c->client_sigalgs;
3704         conflen = c->client_sigalgslen;
3705     } else if (c->conf_sigalgs && !is_suiteb) {
3706         conf = c->conf_sigalgs;
3707         conflen = c->conf_sigalgslen;
3708     } else
3709         conflen = tls12_get_psigalgs(s, &conf);
3710     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) {
3711         pref = conf;
3712         preflen = conflen;
3713         allow = s->s3->tmp.peer_sigalgs;
3714         allowlen = s->s3->tmp.peer_sigalgslen;
3715     } else {
3716         allow = conf;
3717         allowlen = conflen;
3718         pref = s->s3->tmp.peer_sigalgs;
3719         preflen = s->s3->tmp.peer_sigalgslen;
3720     }
3721     nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen);
3722     if (nmatch) {
3723         salgs = OPENSSL_malloc(nmatch * sizeof(TLS_SIGALGS));
3724         if (salgs == NULL)
3725             return 0;
3726         nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen);
3727     } else {
3728         salgs = NULL;
3729     }
3730     c->shared_sigalgs = salgs;
3731     c->shared_sigalgslen = nmatch;
3732     return 1;
3733 }
3734
3735 /* Set preferred digest for each key type */
3736
3737 int tls1_save_sigalgs(SSL *s, const unsigned char *data, size_t dsize)
3738 {
3739     CERT *c = s->cert;
3740     /* Extension ignored for inappropriate versions */
3741     if (!SSL_USE_SIGALGS(s))
3742         return 1;
3743     /* Should never happen */
3744     if (!c)
3745         return 0;
3746
3747     OPENSSL_free(s->s3->tmp.peer_sigalgs);
3748     s->s3->tmp.peer_sigalgs = OPENSSL_malloc(dsize);
3749     if (s->s3->tmp.peer_sigalgs == NULL)
3750         return 0;
3751     s->s3->tmp.peer_sigalgslen = dsize;
3752     memcpy(s->s3->tmp.peer_sigalgs, data, dsize);
3753     return 1;
3754 }
3755
3756 int tls1_process_sigalgs(SSL *s)
3757 {
3758     int idx;
3759     size_t i;
3760     const EVP_MD *md;
3761     const EVP_MD **pmd = s->s3->tmp.md;
3762     uint32_t *pvalid = s->s3->tmp.valid_flags;
3763     CERT *c = s->cert;
3764     TLS_SIGALGS *sigptr;
3765     if (!tls1_set_shared_sigalgs(s))
3766         return 0;
3767
3768     for (i = 0, sigptr = c->shared_sigalgs;
3769          i < c->shared_sigalgslen; i++, sigptr++) {
3770         idx = tls12_get_pkey_idx(sigptr->rsign);
3771         if (idx > 0 && pmd[idx] == NULL) {
3772             md = tls12_get_hash(sigptr->rhash);
3773             pmd[idx] = md;
3774             pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN;
3775             if (idx == SSL_PKEY_RSA_SIGN) {
3776                 pvalid[SSL_PKEY_RSA_ENC] = CERT_PKEY_EXPLICIT_SIGN;
3777                 pmd[SSL_PKEY_RSA_ENC] = md;
3778             }
3779         }
3780
3781     }
3782     /*
3783      * In strict mode leave unset digests as NULL to indicate we can't use
3784      * the certificate for signing.
3785      */
3786     if (!(s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
3787         /*
3788          * Set any remaining keys to default values. NOTE: if alg is not
3789          * supported it stays as NULL.
3790          */
3791 #ifndef OPENSSL_NO_DSA
3792         if (pmd[SSL_PKEY_DSA_SIGN] == NULL)
3793             pmd[SSL_PKEY_DSA_SIGN] = EVP_sha1();
3794 #endif
3795 #ifndef OPENSSL_NO_RSA
3796         if (pmd[SSL_PKEY_RSA_SIGN] == NULL) {
3797             pmd[SSL_PKEY_RSA_SIGN] = EVP_sha1();
3798             pmd[SSL_PKEY_RSA_ENC] = EVP_sha1();
3799         }
3800 #endif
3801 #ifndef OPENSSL_NO_EC
3802         if (pmd[SSL_PKEY_ECC] == NULL)
3803             pmd[SSL_PKEY_ECC] = EVP_sha1();
3804 #endif
3805 #ifndef OPENSSL_NO_GOST
3806         if (pmd[SSL_PKEY_GOST01] == NULL)
3807             pmd[SSL_PKEY_GOST01] = EVP_get_digestbynid(NID_id_GostR3411_94);
3808         if (pmd[SSL_PKEY_GOST12_256] == NULL)
3809             pmd[SSL_PKEY_GOST12_256] =
3810                 EVP_get_digestbynid(NID_id_GostR3411_2012_256);
3811         if (pmd[SSL_PKEY_GOST12_512] == NULL)
3812             pmd[SSL_PKEY_GOST12_512] =
3813                 EVP_get_digestbynid(NID_id_GostR3411_2012_512);
3814 #endif
3815     }
3816     return 1;
3817 }
3818
3819 int SSL_get_sigalgs(SSL *s, int idx,
3820                     int *psign, int *phash, int *psignhash,
3821                     unsigned char *rsig, unsigned char *rhash)
3822 {
3823     const unsigned char *psig = s->s3->tmp.peer_sigalgs;
3824     size_t numsigalgs = s->s3->tmp.peer_sigalgslen / 2;
3825     if (psig == NULL || numsigalgs > INT_MAX)
3826         return 0;
3827     if (idx >= 0) {
3828         idx <<= 1;
3829         if (idx >= (int)s->s3->tmp.peer_sigalgslen)
3830             return 0;
3831         psig += idx;
3832         if (rhash)
3833             *rhash = psig[0];
3834         if (rsig)
3835             *rsig = psig[1];
3836         tls1_lookup_sigalg(phash, psign, psignhash, psig);
3837     }
3838     return (int)numsigalgs;
3839 }
3840
3841 int SSL_get_shared_sigalgs(SSL *s, int idx,
3842                            int *psign, int *phash, int *psignhash,
3843                            unsigned char *rsig, unsigned char *rhash)
3844 {
3845     TLS_SIGALGS *shsigalgs = s->cert->shared_sigalgs;
3846     if (!shsigalgs || idx >= (int)s->cert->shared_sigalgslen
3847             || s->cert->shared_sigalgslen > INT_MAX)
3848         return 0;
3849     shsigalgs += idx;
3850     if (phash)
3851         *phash = shsigalgs->hash_nid;
3852     if (psign)
3853         *psign = shsigalgs->sign_nid;
3854     if (psignhash)
3855         *psignhash = shsigalgs->signandhash_nid;
3856     if (rsig)
3857         *rsig = shsigalgs->rsign;
3858     if (rhash)
3859         *rhash = shsigalgs->rhash;
3860     return (int)s->cert->shared_sigalgslen;
3861 }
3862
3863 #define MAX_SIGALGLEN   (TLSEXT_hash_num * TLSEXT_signature_num * 2)
3864
3865 typedef struct {
3866     size_t sigalgcnt;
3867     int sigalgs[MAX_SIGALGLEN];
3868 } sig_cb_st;
3869
3870 static void get_sigorhash(int *psig, int *phash, const char *str)
3871 {
3872     if (strcmp(str, "RSA") == 0) {
3873         *psig = EVP_PKEY_RSA;
3874     } else if (strcmp(str, "DSA") == 0) {
3875         *psig = EVP_PKEY_DSA;
3876     } else if (strcmp(str, "ECDSA") == 0) {
3877         *psig = EVP_PKEY_EC;
3878     } else {
3879         *phash = OBJ_sn2nid(str);
3880         if (*phash == NID_undef)
3881             *phash = OBJ_ln2nid(str);
3882     }
3883 }
3884
3885 static int sig_cb(const char *elem, int len, void *arg)
3886 {
3887     sig_cb_st *sarg = arg;
3888     size_t i;
3889     char etmp[20], *p;
3890     int sig_alg = NID_undef, hash_alg = NID_undef;
3891     if (elem == NULL)
3892         return 0;
3893     if (sarg->sigalgcnt == MAX_SIGALGLEN)
3894         return 0;
3895     if (len > (int)(sizeof(etmp) - 1))
3896         return 0;
3897     memcpy(etmp, elem, len);
3898     etmp[len] = 0;
3899     p = strchr(etmp, '+');
3900     if (!p)
3901         return 0;
3902     *p = 0;
3903     p++;
3904     if (!*p)
3905         return 0;
3906
3907     get_sigorhash(&sig_alg, &hash_alg, etmp);
3908     get_sigorhash(&sig_alg, &hash_alg, p);
3909
3910     if (sig_alg == NID_undef || hash_alg == NID_undef)
3911         return 0;
3912
3913     for (i = 0; i < sarg->sigalgcnt; i += 2) {
3914         if (sarg->sigalgs[i] == sig_alg && sarg->sigalgs[i + 1] == hash_alg)
3915             return 0;
3916     }
3917     sarg->sigalgs[sarg->sigalgcnt++] = hash_alg;
3918     sarg->sigalgs[sarg->sigalgcnt++] = sig_alg;
3919     return 1;
3920 }
3921
3922 /*
3923  * Set supported signature algorithms based on a colon separated list of the
3924  * form sig+hash e.g. RSA+SHA512:DSA+SHA512
3925  */
3926 int tls1_set_sigalgs_list(CERT *c, const char *str, int client)
3927 {
3928     sig_cb_st sig;
3929     sig.sigalgcnt = 0;
3930     if (!CONF_parse_list(str, ':', 1, sig_cb, &sig))
3931         return 0;
3932     if (c == NULL)
3933         return 1;
3934     return tls1_set_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client);
3935 }
3936
3937 int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client)
3938 {
3939     unsigned char *sigalgs, *sptr;
3940     int rhash, rsign;
3941     size_t i;
3942     if (salglen & 1)
3943         return 0;
3944     sigalgs = OPENSSL_malloc(salglen);
3945     if (sigalgs == NULL)
3946         return 0;
3947     for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
3948         rhash = tls12_find_id(*psig_nids++, tls12_md, OSSL_NELEM(tls12_md));
3949         rsign = tls12_find_id(*psig_nids++, tls12_sig, OSSL_NELEM(tls12_sig));
3950
3951         if (rhash == -1 || rsign == -1)
3952             goto err;
3953         *sptr++ = rhash;
3954         *sptr++ = rsign;
3955     }
3956
3957     if (client) {
3958         OPENSSL_free(c->client_sigalgs);
3959         c->client_sigalgs = sigalgs;
3960         c->client_sigalgslen = salglen;
3961     } else {
3962         OPENSSL_free(c->conf_sigalgs);
3963         c->conf_sigalgs = sigalgs;
3964         c->conf_sigalgslen = salglen;
3965     }
3966
3967     return 1;
3968
3969  err:
3970     OPENSSL_free(sigalgs);
3971     return 0;
3972 }
3973
3974 static int tls1_check_sig_alg(CERT *c, X509 *x, int default_nid)
3975 {
3976     int sig_nid;
3977     size_t i;
3978     if (default_nid == -1)
3979         return 1;
3980     sig_nid = X509_get_signature_nid(x);
3981     if (default_nid)
3982         return sig_nid == default_nid ? 1 : 0;
3983     for (i = 0; i < c->shared_sigalgslen; i++)
3984         if (sig_nid == c->shared_sigalgs[i].signandhash_nid)
3985             return 1;
3986     return 0;
3987 }
3988
3989 /* Check to see if a certificate issuer name matches list of CA names */
3990 static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
3991 {
3992     X509_NAME *nm;
3993     int i;
3994     nm = X509_get_issuer_name(x);
3995     for (i = 0; i < sk_X509_NAME_num(names); i++) {
3996         if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i)))
3997             return 1;
3998     }
3999     return 0;
4000 }
4001
4002 /*
4003  * Check certificate chain is consistent with TLS extensions and is usable by
4004  * server. This servers two purposes: it allows users to check chains before
4005  * passing them to the server and it allows the server to check chains before
4006  * attempting to use them.
4007  */
4008
4009 /* Flags which need to be set for a certificate when stict mode not set */
4010
4011 #define CERT_PKEY_VALID_FLAGS \
4012         (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM)
4013 /* Strict mode flags */
4014 #define CERT_PKEY_STRICT_FLAGS \
4015          (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
4016          | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
4017
4018 int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
4019                      int idx)
4020 {
4021     int i;
4022     int rv = 0;
4023     int check_flags = 0, strict_mode;
4024     CERT_PKEY *cpk = NULL;
4025     CERT *c = s->cert;
4026     uint32_t *pvalid;
4027     unsigned int suiteb_flags = tls1_suiteb(s);
4028     /* idx == -1 means checking server chains */
4029     if (idx != -1) {
4030         /* idx == -2 means checking client certificate chains */
4031         if (idx == -2) {
4032             cpk = c->key;
4033             idx = (int)(cpk - c->pkeys);
4034         } else
4035             cpk = c->pkeys + idx;
4036         pvalid = s->s3->tmp.valid_flags + idx;
4037         x = cpk->x509;
4038         pk = cpk->privatekey;
4039         chain = cpk->chain;
4040         strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT;
4041         /* If no cert or key, forget it */
4042         if (!x || !pk)
4043             goto end;
4044     } else {
4045         if (!x || !pk)
4046             return 0;
4047         idx = ssl_cert_type(x, pk);
4048         if (idx == -1)
4049             return 0;
4050         pvalid = s->s3->tmp.valid_flags + idx;
4051
4052         if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)
4053             check_flags = CERT_PKEY_STRICT_FLAGS;
4054         else
4055             check_flags = CERT_PKEY_VALID_FLAGS;
4056         strict_mode = 1;
4057     }
4058
4059     if (suiteb_flags) {
4060         int ok;
4061         if (check_flags)
4062             check_flags |= CERT_PKEY_SUITEB;
4063         ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags);
4064         if (ok == X509_V_OK)
4065             rv |= CERT_PKEY_SUITEB;
4066         else if (!check_flags)
4067             goto end;
4068     }
4069
4070     /*
4071      * Check all signature algorithms are consistent with signature
4072      * algorithms extension if TLS 1.2 or later and strict mode.
4073      */
4074     if (TLS1_get_version(s) >= TLS1_2_VERSION && strict_mode) {
4075         int default_nid;
4076         unsigned char rsign = 0;
4077         if (s->s3->tmp.peer_sigalgs)
4078             default_nid = 0;
4079         /* If no sigalgs extension use defaults from RFC5246 */
4080         else {
4081             switch (idx) {
4082             case SSL_PKEY_RSA_ENC:
4083             case SSL_PKEY_RSA_SIGN:
4084                 rsign = TLSEXT_signature_rsa;
4085                 default_nid = NID_sha1WithRSAEncryption;
4086                 break;
4087
4088             case SSL_PKEY_DSA_SIGN:
4089                 rsign = TLSEXT_signature_dsa;
4090                 default_nid = NID_dsaWithSHA1;
4091                 break;
4092
4093             case SSL_PKEY_ECC:
4094                 rsign = TLSEXT_signature_ecdsa;
4095                 default_nid = NID_ecdsa_with_SHA1;
4096                 break;
4097
4098             case SSL_PKEY_GOST01:
4099                 rsign = TLSEXT_signature_gostr34102001;
4100                 default_nid = NID_id_GostR3411_94_with_GostR3410_2001;
4101                 break;
4102
4103             case SSL_PKEY_GOST12_256:
4104                 rsign = TLSEXT_signature_gostr34102012_256;
4105                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_256;
4106                 break;
4107
4108             case SSL_PKEY_GOST12_512:
4109                 rsign = TLSEXT_signature_gostr34102012_512;
4110                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_512;
4111                 break;
4112
4113             default:
4114                 default_nid = -1;
4115                 break;
4116             }
4117         }
4118         /*
4119          * If peer sent no signature algorithms extension and we have set
4120          * preferred signature algorithms check we support sha1.
4121          */
4122         if (default_nid > 0 && c->conf_sigalgs) {
4123             size_t j;
4124             const unsigned char *p = c->conf_sigalgs;
4125             for (j = 0; j < c->conf_sigalgslen; j += 2, p += 2) {
4126                 if (p[0] == TLSEXT_hash_sha1 && p[1] == rsign)
4127                     break;
4128             }
4129             if (j == c->conf_sigalgslen) {
4130                 if (check_flags)
4131                     goto skip_sigs;
4132                 else
4133                     goto end;
4134             }
4135         }
4136         /* Check signature algorithm of each cert in chain */
4137         if (!tls1_check_sig_alg(c, x, default_nid)) {
4138             if (!check_flags)
4139                 goto end;
4140         } else
4141             rv |= CERT_PKEY_EE_SIGNATURE;
4142         rv |= CERT_PKEY_CA_SIGNATURE;
4143         for (i = 0; i < sk_X509_num(chain); i++) {
4144             if (!tls1_check_sig_alg(c, sk_X509_value(chain, i), default_nid)) {
4145                 if (check_flags) {
4146                     rv &= ~CERT_PKEY_CA_SIGNATURE;
4147                     break;
4148                 } else
4149                     goto end;
4150             }
4151         }
4152     }
4153     /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */
4154     else if (check_flags)
4155         rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE;
4156  skip_sigs:
4157     /* Check cert parameters are consistent */
4158     if (tls1_check_cert_param(s, x, check_flags ? 1 : 2))
4159         rv |= CERT_PKEY_EE_PARAM;
4160     else if (!check_flags)
4161         goto end;
4162     if (!s->server)
4163         rv |= CERT_PKEY_CA_PARAM;
4164     /* In strict mode check rest of chain too */
4165     else if (strict_mode) {
4166         rv |= CERT_PKEY_CA_PARAM;
4167         for (i = 0; i < sk_X509_num(chain); i++) {
4168             X509 *ca = sk_X509_value(chain, i);
4169             if (!tls1_check_cert_param(s, ca, 0)) {
4170                 if (check_flags) {
4171                     rv &= ~CERT_PKEY_CA_PARAM;
4172                     break;
4173                 } else
4174                     goto end;
4175             }
4176         }
4177     }
4178     if (!s->server && strict_mode) {
4179         STACK_OF(X509_NAME) *ca_dn;
4180         int check_type = 0;
4181         switch (EVP_PKEY_id(pk)) {
4182         case EVP_PKEY_RSA:
4183             check_type = TLS_CT_RSA_SIGN;
4184             break;
4185         case EVP_PKEY_DSA:
4186             check_type = TLS_CT_DSS_SIGN;
4187             break;
4188         case EVP_PKEY_EC:
4189             check_type = TLS_CT_ECDSA_SIGN;
4190             break;
4191         }
4192         if (check_type) {
4193             const unsigned char *ctypes;
4194             int ctypelen;
4195             if (c->ctypes) {
4196                 ctypes = c->ctypes;
4197                 ctypelen = (int)c->ctype_num;
4198             } else {
4199                 ctypes = (unsigned char *)s->s3->tmp.ctype;
4200                 ctypelen = s->s3->tmp.ctype_num;
4201             }
4202             for (i = 0; i < ctypelen; i++) {
4203                 if (ctypes[i] == check_type) {
4204                     rv |= CERT_PKEY_CERT_TYPE;
4205                     break;
4206                 }
4207             }
4208             if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags)
4209                 goto end;
4210         } else
4211   &nbs