Move client parsing of ServerHello extensions into new framework
[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
27 SSL3_ENC_METHOD const TLSv1_enc_data = {
28     tls1_enc,
29     tls1_mac,
30     tls1_setup_key_block,
31     tls1_generate_master_secret,
32     tls1_change_cipher_state,
33     tls1_final_finish_mac,
34     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
35     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
36     tls1_alert_code,
37     tls1_export_keying_material,
38     0,
39     ssl3_set_handshake_header,
40     tls_close_construct_packet,
41     ssl3_handshake_write
42 };
43
44 SSL3_ENC_METHOD const TLSv1_1_enc_data = {
45     tls1_enc,
46     tls1_mac,
47     tls1_setup_key_block,
48     tls1_generate_master_secret,
49     tls1_change_cipher_state,
50     tls1_final_finish_mac,
51     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
52     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
53     tls1_alert_code,
54     tls1_export_keying_material,
55     SSL_ENC_FLAG_EXPLICIT_IV,
56     ssl3_set_handshake_header,
57     tls_close_construct_packet,
58     ssl3_handshake_write
59 };
60
61 SSL3_ENC_METHOD const TLSv1_2_enc_data = {
62     tls1_enc,
63     tls1_mac,
64     tls1_setup_key_block,
65     tls1_generate_master_secret,
66     tls1_change_cipher_state,
67     tls1_final_finish_mac,
68     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
69     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
70     tls1_alert_code,
71     tls1_export_keying_material,
72     SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF
73         | SSL_ENC_FLAG_TLS1_2_CIPHERS,
74     ssl3_set_handshake_header,
75     tls_close_construct_packet,
76     ssl3_handshake_write
77 };
78
79 SSL3_ENC_METHOD const TLSv1_3_enc_data = {
80     tls13_enc,
81     tls1_mac,
82     tls13_setup_key_block,
83     tls13_generate_master_secret,
84     tls13_change_cipher_state,
85     tls13_final_finish_mac,
86     TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,
87     TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,
88     tls1_alert_code,
89     tls1_export_keying_material,
90     SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF,
91     ssl3_set_handshake_header,
92     tls_close_construct_packet,
93     ssl3_handshake_write
94 };
95
96 long tls1_default_timeout(void)
97 {
98     /*
99      * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for
100      * http, the cache would over fill
101      */
102     return (60 * 60 * 2);
103 }
104
105 int tls1_new(SSL *s)
106 {
107     if (!ssl3_new(s))
108         return (0);
109     s->method->ssl_clear(s);
110     return (1);
111 }
112
113 void tls1_free(SSL *s)
114 {
115     OPENSSL_free(s->tlsext_session_ticket);
116     ssl3_free(s);
117 }
118
119 void tls1_clear(SSL *s)
120 {
121     ssl3_clear(s);
122     if (s->method->version == TLS_ANY_VERSION)
123         s->version = TLS_MAX_VERSION;
124     else
125         s->version = s->method->version;
126 }
127
128 #ifndef OPENSSL_NO_EC
129
130 typedef struct {
131     int nid;                    /* Curve NID */
132     int secbits;                /* Bits of security (from SP800-57) */
133     unsigned int flags;         /* Flags: currently just field type */
134 } tls_curve_info;
135
136 /*
137  * Table of curve information.
138  * Do not delete entries or reorder this array! It is used as a lookup
139  * table: the index of each entry is one less than the TLS curve id.
140  */
141 static const tls_curve_info nid_list[] = {
142     {NID_sect163k1, 80, TLS_CURVE_CHAR2}, /* sect163k1 (1) */
143     {NID_sect163r1, 80, TLS_CURVE_CHAR2}, /* sect163r1 (2) */
144     {NID_sect163r2, 80, TLS_CURVE_CHAR2}, /* sect163r2 (3) */
145     {NID_sect193r1, 80, TLS_CURVE_CHAR2}, /* sect193r1 (4) */
146     {NID_sect193r2, 80, TLS_CURVE_CHAR2}, /* sect193r2 (5) */
147     {NID_sect233k1, 112, TLS_CURVE_CHAR2}, /* sect233k1 (6) */
148     {NID_sect233r1, 112, TLS_CURVE_CHAR2}, /* sect233r1 (7) */
149     {NID_sect239k1, 112, TLS_CURVE_CHAR2}, /* sect239k1 (8) */
150     {NID_sect283k1, 128, TLS_CURVE_CHAR2}, /* sect283k1 (9) */
151     {NID_sect283r1, 128, TLS_CURVE_CHAR2}, /* sect283r1 (10) */
152     {NID_sect409k1, 192, TLS_CURVE_CHAR2}, /* sect409k1 (11) */
153     {NID_sect409r1, 192, TLS_CURVE_CHAR2}, /* sect409r1 (12) */
154     {NID_sect571k1, 256, TLS_CURVE_CHAR2}, /* sect571k1 (13) */
155     {NID_sect571r1, 256, TLS_CURVE_CHAR2}, /* sect571r1 (14) */
156     {NID_secp160k1, 80, TLS_CURVE_PRIME}, /* secp160k1 (15) */
157     {NID_secp160r1, 80, TLS_CURVE_PRIME}, /* secp160r1 (16) */
158     {NID_secp160r2, 80, TLS_CURVE_PRIME}, /* secp160r2 (17) */
159     {NID_secp192k1, 80, TLS_CURVE_PRIME}, /* secp192k1 (18) */
160     {NID_X9_62_prime192v1, 80, TLS_CURVE_PRIME}, /* secp192r1 (19) */
161     {NID_secp224k1, 112, TLS_CURVE_PRIME}, /* secp224k1 (20) */
162     {NID_secp224r1, 112, TLS_CURVE_PRIME}, /* secp224r1 (21) */
163     {NID_secp256k1, 128, TLS_CURVE_PRIME}, /* secp256k1 (22) */
164     {NID_X9_62_prime256v1, 128, TLS_CURVE_PRIME}, /* secp256r1 (23) */
165     {NID_secp384r1, 192, TLS_CURVE_PRIME}, /* secp384r1 (24) */
166     {NID_secp521r1, 256, TLS_CURVE_PRIME}, /* secp521r1 (25) */
167     {NID_brainpoolP256r1, 128, TLS_CURVE_PRIME}, /* brainpoolP256r1 (26) */
168     {NID_brainpoolP384r1, 192, TLS_CURVE_PRIME}, /* brainpoolP384r1 (27) */
169     {NID_brainpoolP512r1, 256, TLS_CURVE_PRIME}, /* brainpool512r1 (28) */
170     {NID_X25519, 128, TLS_CURVE_CUSTOM}, /* X25519 (29) */
171 };
172
173 static const unsigned char ecformats_default[] = {
174     TLSEXT_ECPOINTFORMAT_uncompressed,
175     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime,
176     TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2
177 };
178
179 /* The default curves */
180 static const unsigned char eccurves_default[] = {
181     0, 29,                      /* X25519 (29) */
182     0, 23,                      /* secp256r1 (23) */
183     0, 25,                      /* secp521r1 (25) */
184     0, 24,                      /* secp384r1 (24) */
185 };
186
187 static const unsigned char eccurves_all[] = {
188     0, 29,                      /* X25519 (29) */
189     0, 23,                      /* secp256r1 (23) */
190     0, 25,                      /* secp521r1 (25) */
191     0, 24,                      /* secp384r1 (24) */
192     0, 26,                      /* brainpoolP256r1 (26) */
193     0, 27,                      /* brainpoolP384r1 (27) */
194     0, 28,                      /* brainpool512r1 (28) */
195
196     /*
197      * Remaining curves disabled by default but still permitted if set
198      * via an explicit callback or parameters.
199      */
200     0, 22,                      /* secp256k1 (22) */
201     0, 14,                      /* sect571r1 (14) */
202     0, 13,                      /* sect571k1 (13) */
203     0, 11,                      /* sect409k1 (11) */
204     0, 12,                      /* sect409r1 (12) */
205     0, 9,                       /* sect283k1 (9) */
206     0, 10,                      /* sect283r1 (10) */
207     0, 20,                      /* secp224k1 (20) */
208     0, 21,                      /* secp224r1 (21) */
209     0, 18,                      /* secp192k1 (18) */
210     0, 19,                      /* secp192r1 (19) */
211     0, 15,                      /* secp160k1 (15) */
212     0, 16,                      /* secp160r1 (16) */
213     0, 17,                      /* secp160r2 (17) */
214     0, 8,                       /* sect239k1 (8) */
215     0, 6,                       /* sect233k1 (6) */
216     0, 7,                       /* sect233r1 (7) */
217     0, 4,                       /* sect193r1 (4) */
218     0, 5,                       /* sect193r2 (5) */
219     0, 1,                       /* sect163k1 (1) */
220     0, 2,                       /* sect163r1 (2) */
221     0, 3,                       /* sect163r2 (3) */
222 };
223
224 static const unsigned char suiteb_curves[] = {
225     0, TLSEXT_curve_P_256,
226     0, TLSEXT_curve_P_384
227 };
228
229 int tls1_ec_curve_id2nid(int curve_id, unsigned int *pflags)
230 {
231     const tls_curve_info *cinfo;
232     /* ECC curves from RFC 4492 and RFC 7027 */
233     if ((curve_id < 1) || ((unsigned int)curve_id > OSSL_NELEM(nid_list)))
234         return 0;
235     cinfo = nid_list + curve_id - 1;
236     if (pflags)
237         *pflags = cinfo->flags;
238     return cinfo->nid;
239 }
240
241 int tls1_ec_nid2curve_id(int nid)
242 {
243     size_t i;
244     for (i = 0; i < OSSL_NELEM(nid_list); i++) {
245         if (nid_list[i].nid == nid)
246             return (int)(i + 1);
247     }
248     return 0;
249 }
250
251 /*
252  * Get curves list, if "sess" is set return client curves otherwise
253  * preferred list.
254  * Sets |num_curves| to the number of curves in the list, i.e.,
255  * the length of |pcurves| is 2 * num_curves.
256  * Returns 1 on success and 0 if the client curves list has invalid format.
257  * The latter indicates an internal error: we should not be accepting such
258  * lists in the first place.
259  * TODO(emilia): we should really be storing the curves list in explicitly
260  * parsed form instead. (However, this would affect binary compatibility
261  * so cannot happen in the 1.0.x series.)
262  */
263 int tls1_get_curvelist(SSL *s, int sess, const unsigned char **pcurves,
264                        size_t *num_curves)
265 {
266     size_t pcurveslen = 0;
267     if (sess) {
268         *pcurves = s->session->tlsext_supportedgroupslist;
269         pcurveslen = s->session->tlsext_supportedgroupslist_length;
270     } else {
271         /* For Suite B mode only include P-256, P-384 */
272         switch (tls1_suiteb(s)) {
273         case SSL_CERT_FLAG_SUITEB_128_LOS:
274             *pcurves = suiteb_curves;
275             pcurveslen = sizeof(suiteb_curves);
276             break;
277
278         case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
279             *pcurves = suiteb_curves;
280             pcurveslen = 2;
281             break;
282
283         case SSL_CERT_FLAG_SUITEB_192_LOS:
284             *pcurves = suiteb_curves + 2;
285             pcurveslen = 2;
286             break;
287         default:
288             *pcurves = s->tlsext_supportedgroupslist;
289             pcurveslen = s->tlsext_supportedgroupslist_length;
290         }
291         if (!*pcurves) {
292             *pcurves = eccurves_default;
293             pcurveslen = sizeof(eccurves_default);
294         }
295     }
296
297     /* We do not allow odd length arrays to enter the system. */
298     if (pcurveslen & 1) {
299         SSLerr(SSL_F_TLS1_GET_CURVELIST, ERR_R_INTERNAL_ERROR);
300         *num_curves = 0;
301         return 0;
302     } else {
303         *num_curves = pcurveslen / 2;
304         return 1;
305     }
306 }
307
308 /* See if curve is allowed by security callback */
309 int tls_curve_allowed(SSL *s, const unsigned char *curve, int op)
310 {
311     const tls_curve_info *cinfo;
312     if (curve[0])
313         return 1;
314     if ((curve[1] < 1) || ((size_t)curve[1] > OSSL_NELEM(nid_list)))
315         return 0;
316     cinfo = &nid_list[curve[1] - 1];
317 # ifdef OPENSSL_NO_EC2M
318     if (cinfo->flags & TLS_CURVE_CHAR2)
319         return 0;
320 # endif
321     return ssl_security(s, op, cinfo->secbits, cinfo->nid, (void *)curve);
322 }
323
324 /* Check a curve is one of our preferences */
325 int tls1_check_curve(SSL *s, const unsigned char *p, size_t len)
326 {
327     const unsigned char *curves;
328     size_t num_curves, i;
329     unsigned int suiteb_flags = tls1_suiteb(s);
330     if (len != 3 || p[0] != NAMED_CURVE_TYPE)
331         return 0;
332     /* Check curve matches Suite B preferences */
333     if (suiteb_flags) {
334         unsigned long cid = s->s3->tmp.new_cipher->id;
335         if (p[1])
336             return 0;
337         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) {
338             if (p[2] != TLSEXT_curve_P_256)
339                 return 0;
340         } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) {
341             if (p[2] != TLSEXT_curve_P_384)
342                 return 0;
343         } else                  /* Should never happen */
344             return 0;
345     }
346     if (!tls1_get_curvelist(s, 0, &curves, &num_curves))
347         return 0;
348     for (i = 0; i < num_curves; i++, curves += 2) {
349         if (p[1] == curves[0] && p[2] == curves[1])
350             return tls_curve_allowed(s, p + 1, SSL_SECOP_CURVE_CHECK);
351     }
352     return 0;
353 }
354
355 /*-
356  * For nmatch >= 0, return the NID of the |nmatch|th shared group or NID_undef
357  * if there is no match.
358  * For nmatch == -1, return number of matches
359  * For nmatch == -2, return the NID of the group to use for
360  * an EC tmp key, or NID_undef if there is no match.
361  */
362 int tls1_shared_group(SSL *s, int nmatch)
363 {
364     const unsigned char *pref, *supp;
365     size_t num_pref, num_supp, i, j;
366     int k;
367     /* Can't do anything on client side */
368     if (s->server == 0)
369         return -1;
370     if (nmatch == -2) {
371         if (tls1_suiteb(s)) {
372             /*
373              * For Suite B ciphersuite determines curve: we already know
374              * these are acceptable due to previous checks.
375              */
376             unsigned long cid = s->s3->tmp.new_cipher->id;
377             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
378                 return NID_X9_62_prime256v1; /* P-256 */
379             if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
380                 return NID_secp384r1; /* P-384 */
381             /* Should never happen */
382             return NID_undef;
383         }
384         /* If not Suite B just return first preference shared curve */
385         nmatch = 0;
386     }
387     /*
388      * Avoid truncation. tls1_get_curvelist takes an int
389      * but s->options is a long...
390      */
391     if (!tls1_get_curvelist
392         (s, (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) != 0, &supp,
393          &num_supp))
394         /* In practice, NID_undef == 0 but let's be precise. */
395         return nmatch == -1 ? 0 : NID_undef;
396     if (!tls1_get_curvelist
397         (s, !(s->options & SSL_OP_CIPHER_SERVER_PREFERENCE), &pref, &num_pref))
398         return nmatch == -1 ? 0 : NID_undef;
399
400     /*
401      * If the client didn't send the elliptic_curves extension all of them
402      * are allowed.
403      */
404     if (num_supp == 0 && (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) != 0) {
405         supp = eccurves_all;
406         num_supp = sizeof(eccurves_all) / 2;
407     } else if (num_pref == 0 &&
408                (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) == 0) {
409         pref = eccurves_all;
410         num_pref = sizeof(eccurves_all) / 2;
411     }
412
413     k = 0;
414     for (i = 0; i < num_pref; i++, pref += 2) {
415         const unsigned char *tsupp = supp;
416         for (j = 0; j < num_supp; j++, tsupp += 2) {
417             if (pref[0] == tsupp[0] && pref[1] == tsupp[1]) {
418                 if (!tls_curve_allowed(s, pref, SSL_SECOP_CURVE_SHARED))
419                     continue;
420                 if (nmatch == k) {
421                     int id = (pref[0] << 8) | pref[1];
422                     return tls1_ec_curve_id2nid(id, NULL);
423                 }
424                 k++;
425             }
426         }
427     }
428     if (nmatch == -1)
429         return k;
430     /* Out of range (nmatch > k). */
431     return NID_undef;
432 }
433
434 int tls1_set_groups(unsigned char **pext, size_t *pextlen,
435                     int *groups, size_t ngroups)
436 {
437     unsigned char *glist, *p;
438     size_t i;
439     /*
440      * Bitmap of groups included to detect duplicates: only works while group
441      * ids < 32
442      */
443     unsigned long dup_list = 0;
444     glist = OPENSSL_malloc(ngroups * 2);
445     if (glist == NULL)
446         return 0;
447     for (i = 0, p = glist; i < ngroups; i++) {
448         unsigned long idmask;
449         int id;
450         /* TODO(TLS1.3): Convert for DH groups */
451         id = tls1_ec_nid2curve_id(groups[i]);
452         idmask = 1L << id;
453         if (!id || (dup_list & idmask)) {
454             OPENSSL_free(glist);
455             return 0;
456         }
457         dup_list |= idmask;
458         s2n(id, p);
459     }
460     OPENSSL_free(*pext);
461     *pext = glist;
462     *pextlen = ngroups * 2;
463     return 1;
464 }
465
466 # define MAX_CURVELIST   28
467
468 typedef struct {
469     size_t nidcnt;
470     int nid_arr[MAX_CURVELIST];
471 } nid_cb_st;
472
473 static int nid_cb(const char *elem, int len, void *arg)
474 {
475     nid_cb_st *narg = arg;
476     size_t i;
477     int nid;
478     char etmp[20];
479     if (elem == NULL)
480         return 0;
481     if (narg->nidcnt == MAX_CURVELIST)
482         return 0;
483     if (len > (int)(sizeof(etmp) - 1))
484         return 0;
485     memcpy(etmp, elem, len);
486     etmp[len] = 0;
487     nid = EC_curve_nist2nid(etmp);
488     if (nid == NID_undef)
489         nid = OBJ_sn2nid(etmp);
490     if (nid == NID_undef)
491         nid = OBJ_ln2nid(etmp);
492     if (nid == NID_undef)
493         return 0;
494     for (i = 0; i < narg->nidcnt; i++)
495         if (narg->nid_arr[i] == nid)
496             return 0;
497     narg->nid_arr[narg->nidcnt++] = nid;
498     return 1;
499 }
500
501 /* Set groups based on a colon separate list */
502 int tls1_set_groups_list(unsigned char **pext, size_t *pextlen, const char *str)
503 {
504     nid_cb_st ncb;
505     ncb.nidcnt = 0;
506     if (!CONF_parse_list(str, ':', 1, nid_cb, &ncb))
507         return 0;
508     if (pext == NULL)
509         return 1;
510     return tls1_set_groups(pext, pextlen, ncb.nid_arr, ncb.nidcnt);
511 }
512
513 /* For an EC key set TLS id and required compression based on parameters */
514 static int tls1_set_ec_id(unsigned char *curve_id, unsigned char *comp_id,
515                           EC_KEY *ec)
516 {
517     int id;
518     const EC_GROUP *grp;
519     if (!ec)
520         return 0;
521     /* Determine if it is a prime field */
522     grp = EC_KEY_get0_group(ec);
523     if (!grp)
524         return 0;
525     /* Determine curve ID */
526     id = EC_GROUP_get_curve_name(grp);
527     id = tls1_ec_nid2curve_id(id);
528     /* If no id return error: we don't support arbitrary explicit curves */
529     if (id == 0)
530         return 0;
531     curve_id[0] = 0;
532     curve_id[1] = (unsigned char)id;
533     if (comp_id) {
534         if (EC_KEY_get0_public_key(ec) == NULL)
535             return 0;
536         if (EC_KEY_get_conv_form(ec) == POINT_CONVERSION_UNCOMPRESSED) {
537             *comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
538         } else {
539             if ((nid_list[id - 1].flags & TLS_CURVE_TYPE) == TLS_CURVE_PRIME)
540                 *comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
541             else
542                 *comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
543         }
544     }
545     return 1;
546 }
547
548 /* Check an EC key is compatible with extensions */
549 static int tls1_check_ec_key(SSL *s,
550                              unsigned char *curve_id, unsigned char *comp_id)
551 {
552     const unsigned char *pformats, *pcurves;
553     size_t num_formats, num_curves, i;
554     int j;
555     /*
556      * If point formats extension present check it, otherwise everything is
557      * supported (see RFC4492).
558      */
559     if (comp_id && s->session->tlsext_ecpointformatlist) {
560         pformats = s->session->tlsext_ecpointformatlist;
561         num_formats = s->session->tlsext_ecpointformatlist_length;
562         for (i = 0; i < num_formats; i++, pformats++) {
563             if (*comp_id == *pformats)
564                 break;
565         }
566         if (i == num_formats)
567             return 0;
568     }
569     if (!curve_id)
570         return 1;
571     /* Check curve is consistent with client and server preferences */
572     for (j = 0; j <= 1; j++) {
573         if (!tls1_get_curvelist(s, j, &pcurves, &num_curves))
574             return 0;
575         if (j == 1 && num_curves == 0) {
576             /*
577              * If we've not received any curves then skip this check.
578              * RFC 4492 does not require the supported elliptic curves extension
579              * so if it is not sent we can just choose any curve.
580              * It is invalid to send an empty list in the elliptic curves
581              * extension, so num_curves == 0 always means no extension.
582              */
583             break;
584         }
585         for (i = 0; i < num_curves; i++, pcurves += 2) {
586             if (pcurves[0] == curve_id[0] && pcurves[1] == curve_id[1])
587                 break;
588         }
589         if (i == num_curves)
590             return 0;
591         /* For clients can only check sent curve list */
592         if (!s->server)
593             break;
594     }
595     return 1;
596 }
597
598 void tls1_get_formatlist(SSL *s, const unsigned char **pformats,
599                          size_t *num_formats)
600 {
601     /*
602      * If we have a custom point format list use it otherwise use default
603      */
604     if (s->tlsext_ecpointformatlist) {
605         *pformats = s->tlsext_ecpointformatlist;
606         *num_formats = s->tlsext_ecpointformatlist_length;
607     } else {
608         *pformats = ecformats_default;
609         /* For Suite B we don't support char2 fields */
610         if (tls1_suiteb(s))
611             *num_formats = sizeof(ecformats_default) - 1;
612         else
613             *num_formats = sizeof(ecformats_default);
614     }
615 }
616
617 /*
618  * Check cert parameters compatible with extensions: currently just checks EC
619  * certificates have compatible curves and compression.
620  */
621 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
622 {
623     unsigned char comp_id, curve_id[2];
624     EVP_PKEY *pkey;
625     int rv;
626     pkey = X509_get0_pubkey(x);
627     if (!pkey)
628         return 0;
629     /* If not EC nothing to do */
630     if (EVP_PKEY_id(pkey) != EVP_PKEY_EC)
631         return 1;
632     rv = tls1_set_ec_id(curve_id, &comp_id, EVP_PKEY_get0_EC_KEY(pkey));
633     if (!rv)
634         return 0;
635     /*
636      * Can't check curve_id for client certs as we don't have a supported
637      * curves extension.
638      */
639     rv = tls1_check_ec_key(s, s->server ? curve_id : NULL, &comp_id);
640     if (!rv)
641         return 0;
642     /*
643      * Special case for suite B. We *MUST* sign using SHA256+P-256 or
644      * SHA384+P-384, adjust digest if necessary.
645      */
646     if (set_ee_md && tls1_suiteb(s)) {
647         int check_md;
648         size_t i;
649         CERT *c = s->cert;
650         if (curve_id[0])
651             return 0;
652         /* Check to see we have necessary signing algorithm */
653         if (curve_id[1] == TLSEXT_curve_P_256)
654             check_md = NID_ecdsa_with_SHA256;
655         else if (curve_id[1] == TLSEXT_curve_P_384)
656             check_md = NID_ecdsa_with_SHA384;
657         else
658             return 0;           /* Should never happen */
659         for (i = 0; i < c->shared_sigalgslen; i++)
660             if (check_md == c->shared_sigalgs[i].signandhash_nid)
661                 break;
662         if (i == c->shared_sigalgslen)
663             return 0;
664         if (set_ee_md == 2) {
665             if (check_md == NID_ecdsa_with_SHA256)
666                 s->s3->tmp.md[SSL_PKEY_ECC] = EVP_sha256();
667             else
668                 s->s3->tmp.md[SSL_PKEY_ECC] = EVP_sha384();
669         }
670     }
671     return rv;
672 }
673
674 # ifndef OPENSSL_NO_EC
675 /*
676  * tls1_check_ec_tmp_key - Check EC temporary key compatibility
677  * @s: SSL connection
678  * @cid: Cipher ID we're considering using
679  *
680  * Checks that the kECDHE cipher suite we're considering using
681  * is compatible with the client extensions.
682  *
683  * Returns 0 when the cipher can't be used or 1 when it can.
684  */
685 int tls1_check_ec_tmp_key(SSL *s, unsigned long cid)
686 {
687     /*
688      * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other
689      * curves permitted.
690      */
691     if (tls1_suiteb(s)) {
692         unsigned char curve_id[2];
693         /* Curve to check determined by ciphersuite */
694         if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
695             curve_id[1] = TLSEXT_curve_P_256;
696         else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
697             curve_id[1] = TLSEXT_curve_P_384;
698         else
699             return 0;
700         curve_id[0] = 0;
701         /* Check this curve is acceptable */
702         if (!tls1_check_ec_key(s, curve_id, NULL))
703             return 0;
704         return 1;
705     }
706     /* Need a shared curve */
707     if (tls1_shared_group(s, 0))
708         return 1;
709     return 0;
710 }
711 # endif                         /* OPENSSL_NO_EC */
712
713 #else
714
715 static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)
716 {
717     return 1;
718 }
719
720 #endif                          /* OPENSSL_NO_EC */
721
722 /*
723  * List of supported signature algorithms and hashes. Should make this
724  * customisable at some point, for now include everything we support.
725  */
726
727 #ifdef OPENSSL_NO_RSA
728 # define tlsext_sigalg_rsa(md)  /* */
729 #else
730 # define tlsext_sigalg_rsa(md) md, TLSEXT_signature_rsa,
731 #endif
732
733 #ifdef OPENSSL_NO_DSA
734 # define tlsext_sigalg_dsa(md)  /* */
735 #else
736 # define tlsext_sigalg_dsa(md) md, TLSEXT_signature_dsa,
737 #endif
738
739 #ifdef OPENSSL_NO_EC
740 # define tlsext_sigalg_ecdsa(md)/* */
741 #else
742 # define tlsext_sigalg_ecdsa(md) md, TLSEXT_signature_ecdsa,
743 #endif
744
745 #define tlsext_sigalg(md) \
746                 tlsext_sigalg_rsa(md) \
747                 tlsext_sigalg_dsa(md) \
748                 tlsext_sigalg_ecdsa(md)
749
750 static const unsigned char tls12_sigalgs[] = {
751     tlsext_sigalg(TLSEXT_hash_sha512)
752         tlsext_sigalg(TLSEXT_hash_sha384)
753         tlsext_sigalg(TLSEXT_hash_sha256)
754         tlsext_sigalg(TLSEXT_hash_sha224)
755         tlsext_sigalg(TLSEXT_hash_sha1)
756 #ifndef OPENSSL_NO_GOST
757         TLSEXT_hash_gostr3411, TLSEXT_signature_gostr34102001,
758     TLSEXT_hash_gostr34112012_256, TLSEXT_signature_gostr34102012_256,
759     TLSEXT_hash_gostr34112012_512, TLSEXT_signature_gostr34102012_512
760 #endif
761 };
762
763 #ifndef OPENSSL_NO_EC
764 static const unsigned char suiteb_sigalgs[] = {
765     tlsext_sigalg_ecdsa(TLSEXT_hash_sha256)
766         tlsext_sigalg_ecdsa(TLSEXT_hash_sha384)
767 };
768 #endif
769 size_t tls12_get_psigalgs(SSL *s, const unsigned char **psigs)
770 {
771     /*
772      * If Suite B mode use Suite B sigalgs only, ignore any other
773      * preferences.
774      */
775 #ifndef OPENSSL_NO_EC
776     switch (tls1_suiteb(s)) {
777     case SSL_CERT_FLAG_SUITEB_128_LOS:
778         *psigs = suiteb_sigalgs;
779         return sizeof(suiteb_sigalgs);
780
781     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
782         *psigs = suiteb_sigalgs;
783         return 2;
784
785     case SSL_CERT_FLAG_SUITEB_192_LOS:
786         *psigs = suiteb_sigalgs + 2;
787         return 2;
788     }
789 #endif
790     /* If server use client authentication sigalgs if not NULL */
791     if (s->server && s->cert->client_sigalgs) {
792         *psigs = s->cert->client_sigalgs;
793         return s->cert->client_sigalgslen;
794     } else if (s->cert->conf_sigalgs) {
795         *psigs = s->cert->conf_sigalgs;
796         return s->cert->conf_sigalgslen;
797     } else {
798         *psigs = tls12_sigalgs;
799         return sizeof(tls12_sigalgs);
800     }
801 }
802
803 /*
804  * Check signature algorithm is consistent with sent supported signature
805  * algorithms and if so return relevant digest.
806  */
807 int tls12_check_peer_sigalg(const EVP_MD **pmd, SSL *s,
808                             const unsigned char *sig, EVP_PKEY *pkey)
809 {
810     const unsigned char *sent_sigs;
811     size_t sent_sigslen, i;
812     int sigalg = tls12_get_sigid(pkey);
813     /* Should never happen */
814     if (sigalg == -1)
815         return -1;
816     /* Check key type is consistent with signature */
817     if (sigalg != (int)sig[1]) {
818         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
819         return 0;
820     }
821 #ifndef OPENSSL_NO_EC
822     if (EVP_PKEY_id(pkey) == EVP_PKEY_EC) {
823         unsigned char curve_id[2], comp_id;
824         /* Check compression and curve matches extensions */
825         if (!tls1_set_ec_id(curve_id, &comp_id, EVP_PKEY_get0_EC_KEY(pkey)))
826             return 0;
827         if (!s->server && !tls1_check_ec_key(s, curve_id, &comp_id)) {
828             SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_CURVE);
829             return 0;
830         }
831         /* If Suite B only P-384+SHA384 or P-256+SHA-256 allowed */
832         if (tls1_suiteb(s)) {
833             if (curve_id[0])
834                 return 0;
835             if (curve_id[1] == TLSEXT_curve_P_256) {
836                 if (sig[0] != TLSEXT_hash_sha256) {
837                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
838                            SSL_R_ILLEGAL_SUITEB_DIGEST);
839                     return 0;
840                 }
841             } else if (curve_id[1] == TLSEXT_curve_P_384) {
842                 if (sig[0] != TLSEXT_hash_sha384) {
843                     SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG,
844                            SSL_R_ILLEGAL_SUITEB_DIGEST);
845                     return 0;
846                 }
847             } else
848                 return 0;
849         }
850     } else if (tls1_suiteb(s))
851         return 0;
852 #endif
853
854     /* Check signature matches a type we sent */
855     sent_sigslen = tls12_get_psigalgs(s, &sent_sigs);
856     for (i = 0; i < sent_sigslen; i += 2, sent_sigs += 2) {
857         if (sig[0] == sent_sigs[0] && sig[1] == sent_sigs[1])
858             break;
859     }
860     /* Allow fallback to SHA1 if not strict mode */
861     if (i == sent_sigslen
862         && (sig[0] != TLSEXT_hash_sha1
863             || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
864         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
865         return 0;
866     }
867     *pmd = tls12_get_hash(sig[0]);
868     if (*pmd == NULL) {
869         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_UNKNOWN_DIGEST);
870         return 0;
871     }
872     /* Make sure security callback allows algorithm */
873     if (!ssl_security(s, SSL_SECOP_SIGALG_CHECK,
874                       EVP_MD_size(*pmd) * 4, EVP_MD_type(*pmd), (void *)sig)) {
875         SSLerr(SSL_F_TLS12_CHECK_PEER_SIGALG, SSL_R_WRONG_SIGNATURE_TYPE);
876         return 0;
877     }
878     /*
879      * Store the digest used so applications can retrieve it if they wish.
880      */
881     s->s3->tmp.peer_md = *pmd;
882     return 1;
883 }
884
885 /*
886  * Set a mask of disabled algorithms: an algorithm is disabled if it isn't
887  * supported, doesn't appear in supported signature algorithms, isn't supported
888  * by the enabled protocol versions or by the security level.
889  *
890  * This function should only be used for checking which ciphers are supported
891  * by the client.
892  *
893  * Call ssl_cipher_disabled() to check that it's enabled or not.
894  */
895 void ssl_set_client_disabled(SSL *s)
896 {
897     s->s3->tmp.mask_a = 0;
898     s->s3->tmp.mask_k = 0;
899     ssl_set_sig_mask(&s->s3->tmp.mask_a, s, SSL_SECOP_SIGALG_MASK);
900     ssl_get_client_min_max_version(s, &s->s3->tmp.min_ver, &s->s3->tmp.max_ver);
901 #ifndef OPENSSL_NO_PSK
902     /* with PSK there must be client callback set */
903     if (!s->psk_client_callback) {
904         s->s3->tmp.mask_a |= SSL_aPSK;
905         s->s3->tmp.mask_k |= SSL_PSK;
906     }
907 #endif                          /* OPENSSL_NO_PSK */
908 #ifndef OPENSSL_NO_SRP
909     if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) {
910         s->s3->tmp.mask_a |= SSL_aSRP;
911         s->s3->tmp.mask_k |= SSL_kSRP;
912     }
913 #endif
914 }
915
916 /*
917  * ssl_cipher_disabled - check that a cipher is disabled or not
918  * @s: SSL connection that you want to use the cipher on
919  * @c: cipher to check
920  * @op: Security check that you want to do
921  *
922  * Returns 1 when it's disabled, 0 when enabled.
923  */
924 int ssl_cipher_disabled(SSL *s, const SSL_CIPHER *c, int op)
925 {
926     if (c->algorithm_mkey & s->s3->tmp.mask_k
927         || c->algorithm_auth & s->s3->tmp.mask_a)
928         return 1;
929     if (s->s3->tmp.max_ver == 0)
930         return 1;
931     if (!SSL_IS_DTLS(s) && ((c->min_tls > s->s3->tmp.max_ver)
932                             || (c->max_tls < s->s3->tmp.min_ver)))
933         return 1;
934     if (SSL_IS_DTLS(s) && (DTLS_VERSION_GT(c->min_dtls, s->s3->tmp.max_ver)
935                            || DTLS_VERSION_LT(c->max_dtls, s->s3->tmp.min_ver)))
936         return 1;
937
938     return !ssl_security(s, op, c->strength_bits, 0, (void *)c);
939 }
940
941 int tls_use_ticket(SSL *s)
942 {
943     if ((s->options & SSL_OP_NO_TICKET) || SSL_IS_TLS13(s))
944         return 0;
945     return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL);
946 }
947
948 int ssl_add_clienthello_tlsext(SSL *s, WPACKET *pkt, int *al)
949 {
950 #ifndef OPENSSL_NO_EC
951     const unsigned char *pcurves = NULL;
952     size_t num_curves = 0;
953     int using_ecc = 0;
954     int min_version, max_version, reason;
955
956     /* See if we support any ECC ciphersuites */
957     if ((s->version >= TLS1_VERSION && s->version <= TLS1_3_VERSION)
958             || SSL_IS_DTLS(s)) {
959         int i;
960         unsigned long alg_k, alg_a;
961         STACK_OF(SSL_CIPHER) *cipher_stack = SSL_get_ciphers(s);
962
963         for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
964             const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
965
966             alg_k = c->algorithm_mkey;
967             alg_a = c->algorithm_auth;
968             if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
969                 || (alg_a & SSL_aECDSA)
970                 || c->min_tls >= TLS1_3_VERSION) {
971                 using_ecc = 1;
972                 break;
973             }
974         }
975     }
976 #else
977     if (SSL_IS_TLS13(s)) {
978         /* Shouldn't happen! */
979         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
980         return 0;
981     }
982 #endif
983
984     /* Add RI if renegotiating */
985     if (s->renegotiate) {
986         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
987                 || !WPACKET_start_sub_packet_u16(pkt)
988                 || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
989                                    s->s3->previous_client_finished_len)
990                 || !WPACKET_close(pkt)) {
991             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
992             return 0;
993         }
994     }
995     /* Only add RI for SSLv3 */
996     if (s->client_version == SSL3_VERSION)
997         goto done;
998
999     if (s->tlsext_hostname != NULL) {
1000         /* Add TLS extension servername to the Client Hello message */
1001         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1002                    /* Sub-packet for server_name extension */
1003                 || !WPACKET_start_sub_packet_u16(pkt)
1004                    /* Sub-packet for servername list (always 1 hostname)*/
1005                 || !WPACKET_start_sub_packet_u16(pkt)
1006                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
1007                 || !WPACKET_sub_memcpy_u16(pkt, s->tlsext_hostname,
1008                                            strlen(s->tlsext_hostname))
1009                 || !WPACKET_close(pkt)
1010                 || !WPACKET_close(pkt)) {
1011             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1012             return 0;
1013         }
1014     }
1015 #ifndef OPENSSL_NO_SRP
1016     /* Add SRP username if there is one */
1017     if (s->srp_ctx.login != NULL) {
1018         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
1019                    /* Sub-packet for SRP extension */
1020                 || !WPACKET_start_sub_packet_u16(pkt)
1021                 || !WPACKET_start_sub_packet_u8(pkt)
1022                    /* login must not be zero...internal error if so */
1023                 || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
1024                 || !WPACKET_memcpy(pkt, s->srp_ctx.login,
1025                                    strlen(s->srp_ctx.login))
1026                 || !WPACKET_close(pkt)
1027                 || !WPACKET_close(pkt)) {
1028             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1029             return 0;
1030         }
1031     }
1032 #endif
1033
1034 #ifndef OPENSSL_NO_EC
1035     if (using_ecc) {
1036         /*
1037          * Add TLS extension ECPointFormats to the ClientHello message
1038          */
1039         const unsigned char *pformats, *pcurvestmp;
1040         size_t num_formats;
1041         size_t i;
1042
1043         tls1_get_formatlist(s, &pformats, &num_formats);
1044
1045         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1046                    /* Sub-packet for formats extension */
1047                 || !WPACKET_start_sub_packet_u16(pkt)
1048                 || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
1049                 || !WPACKET_close(pkt)) {
1050             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1051             return 0;
1052         }
1053
1054         /*
1055          * Add TLS extension supported_groups to the ClientHello message
1056          */
1057         /* TODO(TLS1.3): Add support for DHE groups */
1058         pcurves = s->tlsext_supportedgroupslist;
1059         if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
1060             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1061             return 0;
1062         }
1063         pcurvestmp = pcurves;
1064
1065         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
1066                    /* Sub-packet for supported_groups extension */
1067                 || !WPACKET_start_sub_packet_u16(pkt)
1068                 || !WPACKET_start_sub_packet_u16(pkt)) {
1069             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1070             return 0;
1071         }
1072         /* Copy curve ID if supported */
1073         for (i = 0; i < num_curves; i++, pcurvestmp += 2) {
1074             if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
1075                 if (!WPACKET_put_bytes_u8(pkt, pcurvestmp[0])
1076                     || !WPACKET_put_bytes_u8(pkt, pcurvestmp[1])) {
1077                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1078                                ERR_R_INTERNAL_ERROR);
1079                         return 0;
1080                     }
1081             }
1082         }
1083         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1084             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1085             return 0;
1086         }
1087     }
1088 #endif                          /* OPENSSL_NO_EC */
1089
1090     if (tls_use_ticket(s)) {
1091         size_t ticklen;
1092         if (!s->new_session && s->session && s->session->tlsext_tick)
1093             ticklen = s->session->tlsext_ticklen;
1094         else if (s->session && s->tlsext_session_ticket &&
1095                  s->tlsext_session_ticket->data) {
1096             ticklen = s->tlsext_session_ticket->length;
1097             s->session->tlsext_tick = OPENSSL_malloc(ticklen);
1098             if (s->session->tlsext_tick == NULL) {
1099                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1100                 return 0;
1101             }
1102             memcpy(s->session->tlsext_tick,
1103                    s->tlsext_session_ticket->data, ticklen);
1104             s->session->tlsext_ticklen = ticklen;
1105         } else
1106             ticklen = 0;
1107         if (ticklen == 0 && s->tlsext_session_ticket &&
1108             s->tlsext_session_ticket->data == NULL)
1109             goto skip_ext;
1110
1111         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1112                 || !WPACKET_sub_memcpy_u16(pkt, s->session->tlsext_tick,
1113                                            ticklen)) {
1114             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1115             return 0;
1116         }
1117     }
1118  skip_ext:
1119
1120     if (SSL_CLIENT_USE_SIGALGS(s)) {
1121         size_t salglen;
1122         const unsigned char *salg;
1123
1124         salglen = tls12_get_psigalgs(s, &salg);
1125
1126         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
1127                    /* Sub-packet for sig-algs extension */
1128                 || !WPACKET_start_sub_packet_u16(pkt)
1129                    /* Sub-packet for the actual list */
1130                 || !WPACKET_start_sub_packet_u16(pkt)
1131                 || !tls12_copy_sigalgs(s, pkt, salg, salglen)
1132                 || !WPACKET_close(pkt)
1133                 || !WPACKET_close(pkt)) {
1134             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1135             return 0;
1136         }
1137     }
1138 #ifndef OPENSSL_NO_OCSP
1139     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
1140         int i;
1141
1142         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1143                    /* Sub-packet for status request extension */
1144                 || !WPACKET_start_sub_packet_u16(pkt)
1145                 || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
1146                    /* Sub-packet for the ids */
1147                 || !WPACKET_start_sub_packet_u16(pkt)) {
1148             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1149             return 0;
1150         }
1151         for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
1152             unsigned char *idbytes;
1153             int idlen;
1154             OCSP_RESPID *id;
1155
1156             id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
1157             idlen = i2d_OCSP_RESPID(id, NULL);
1158             if (idlen <= 0
1159                        /* Sub-packet for an individual id */
1160                     || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
1161                     || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
1162                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1163                 return 0;
1164             }
1165         }
1166         if (!WPACKET_close(pkt)
1167                 || !WPACKET_start_sub_packet_u16(pkt)) {
1168             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1169             return 0;
1170         }
1171         if (s->tlsext_ocsp_exts) {
1172             unsigned char *extbytes;
1173             int extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
1174
1175             if (extlen < 0) {
1176                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1177                 return 0;
1178             }
1179             if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
1180                     || i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &extbytes)
1181                        != extlen) {
1182                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1183                 return 0;
1184            }
1185         }
1186         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1187             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1188             return 0;
1189         }
1190     }
1191 #endif
1192
1193 #ifndef OPENSSL_NO_NEXTPROTONEG
1194     if (s->ctx->next_proto_select_cb && !s->s3->tmp.finish_md_len) {
1195         /*
1196          * The client advertises an empty extension to indicate its support
1197          * for Next Protocol Negotiation
1198          */
1199         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1200                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1201             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1202             return 0;
1203         }
1204     }
1205 #endif
1206
1207     /*
1208      * finish_md_len is non-zero during a renegotiation, so
1209      * this avoids sending ALPN during the renegotiation
1210      * (see longer comment below)
1211      */
1212     if (s->alpn_client_proto_list && !s->s3->tmp.finish_md_len) {
1213         if (!WPACKET_put_bytes_u16(pkt,
1214                     TLSEXT_TYPE_application_layer_protocol_negotiation)
1215                    /* Sub-packet ALPN extension */
1216                 || !WPACKET_start_sub_packet_u16(pkt)
1217                 || !WPACKET_sub_memcpy_u16(pkt, s->alpn_client_proto_list,
1218                                            s->alpn_client_proto_list_len)
1219                 || !WPACKET_close(pkt)) {
1220             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1221             return 0;
1222         }
1223         s->s3->alpn_sent = 1;
1224     }
1225 #ifndef OPENSSL_NO_SRTP
1226     if (SSL_IS_DTLS(s) && SSL_get_srtp_profiles(s)) {
1227         STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
1228         SRTP_PROTECTION_PROFILE *prof;
1229         int i, ct;
1230
1231         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1232                    /* Sub-packet for SRTP extension */
1233                 || !WPACKET_start_sub_packet_u16(pkt)
1234                    /* Sub-packet for the protection profile list */
1235                 || !WPACKET_start_sub_packet_u16(pkt)) {
1236             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1237             return 0;
1238         }
1239         ct = sk_SRTP_PROTECTION_PROFILE_num(clnt);
1240         for (i = 0; i < ct; i++) {
1241             prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
1242             if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
1243                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1244                 return 0;
1245             }
1246         }
1247         if (!WPACKET_close(pkt)
1248                    /* Add an empty use_mki value */
1249                 || !WPACKET_put_bytes_u8(pkt, 0)
1250                 || !WPACKET_close(pkt)) {
1251             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1252             return 0;
1253         }
1254     }
1255 #endif
1256     custom_ext_init(&s->cert->cli_ext);
1257     /* Add custom TLS Extensions to ClientHello */
1258     if (!custom_ext_add(s, 0, pkt, al)) {
1259         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1260         return 0;
1261     }
1262
1263     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) {
1264         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1265             || !WPACKET_put_bytes_u16(pkt, 0)) {
1266             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1267             return 0;
1268         }
1269     }
1270
1271 #ifndef OPENSSL_NO_CT
1272     if (s->ct_validation_callback != NULL) {
1273         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
1274                 || !WPACKET_put_bytes_u16(pkt, 0)) {
1275             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1276             return 0;
1277         }
1278     }
1279 #endif
1280
1281     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1282             || !WPACKET_put_bytes_u16(pkt, 0)) {
1283         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1284         return 0;
1285     }
1286
1287     reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
1288     if (reason != 0) {
1289         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, reason);
1290         return 0;
1291     }
1292
1293     /* TLS1.3 specific extensions */
1294     if (!SSL_IS_DTLS(s) && max_version >= TLS1_3_VERSION) {
1295         int currv;
1296         size_t i, sharessent = 0;
1297
1298         /* TODO(TLS1.3): Should we add this extension for versions < TLS1.3? */
1299         /* supported_versions extension */
1300         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
1301                 || !WPACKET_start_sub_packet_u16(pkt)
1302                 || !WPACKET_start_sub_packet_u8(pkt)) {
1303             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1304             return 0;
1305         }
1306
1307         /*
1308          * TODO(TLS1.3): There is some discussion on the TLS list as to wheter
1309          * we should include versions <TLS1.2. For the moment we do. To be
1310          * reviewed later.
1311          */
1312         for (currv = max_version; currv >= min_version; currv--) {
1313             /* TODO(TLS1.3): Remove this first if clause prior to release!! */
1314             if (currv == TLS1_3_VERSION) {
1315                 if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
1316                     SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1317                            ERR_R_INTERNAL_ERROR);
1318                     return 0;
1319                 }
1320             } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
1321                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1322                 return 0;
1323             }
1324         }
1325         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1326             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1327             return 0;
1328         }
1329
1330
1331         /* key_share extension */
1332         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1333                    /* Extension data sub-packet */
1334                 || !WPACKET_start_sub_packet_u16(pkt)
1335                    /* KeyShare list sub-packet */
1336                 || !WPACKET_start_sub_packet_u16(pkt)) {
1337             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1338             return 0;
1339         }
1340
1341         /*
1342          * TODO(TLS1.3): Make the number of key_shares sent configurable. For
1343          * now, just send one
1344          */
1345         for (i = 0; i < num_curves && sharessent < 1; i++, pcurves += 2) {
1346             unsigned char *encodedPoint = NULL;
1347             unsigned int curve_id = 0;
1348             EVP_PKEY *key_share_key = NULL;
1349             size_t encodedlen;
1350
1351             if (!tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED))
1352                 continue;
1353
1354             if (s->s3->tmp.pkey != NULL) {
1355                 /* Shouldn't happen! */
1356                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1357                        ERR_R_INTERNAL_ERROR);
1358                 return 0;
1359             }
1360
1361             /* Generate a key for this key_share */
1362             curve_id = (pcurves[0] << 8) | pcurves[1];
1363             key_share_key = ssl_generate_pkey_curve(curve_id);
1364             if (key_share_key == NULL) {
1365                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_EVP_LIB);
1366                 return 0;
1367             }
1368
1369             /* Encode the public key. */
1370             encodedlen = EVP_PKEY_get1_tls_encodedpoint(key_share_key,
1371                                                         &encodedPoint);
1372             if (encodedlen == 0) {
1373                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_EC_LIB);
1374                 EVP_PKEY_free(key_share_key);
1375                 return 0;
1376             }
1377
1378             /* Create KeyShareEntry */
1379             if (!WPACKET_put_bytes_u16(pkt, curve_id)
1380                     || !WPACKET_sub_memcpy_u16(pkt, encodedPoint, encodedlen)) {
1381                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT,
1382                        ERR_R_INTERNAL_ERROR);
1383                 EVP_PKEY_free(key_share_key);
1384                 OPENSSL_free(encodedPoint);
1385                 return 0;
1386             }
1387
1388             /*
1389              * TODO(TLS1.3): When changing to send more than one key_share we're
1390              * going to need to be able to save more than one EVP_PKEY. For now
1391              * we reuse the existing tmp.pkey
1392              */
1393             s->s3->group_id = curve_id;
1394             s->s3->tmp.pkey = key_share_key;
1395             sharessent++;
1396             OPENSSL_free(encodedPoint);
1397         }
1398         if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1399             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1400             return 0;
1401         }
1402     }
1403
1404     /*
1405      * Add padding to workaround bugs in F5 terminators. See
1406      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
1407      * code works out the length of all existing extensions it MUST always
1408      * appear last.
1409      */
1410     if (s->options & SSL_OP_TLSEXT_PADDING) {
1411         unsigned char *padbytes;
1412         size_t hlen;
1413
1414         if (!WPACKET_get_total_written(pkt, &hlen)) {
1415             SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1416             return 0;
1417         }
1418
1419         if (hlen > 0xff && hlen < 0x200) {
1420             hlen = 0x200 - hlen;
1421             if (hlen >= 4)
1422                 hlen -= 4;
1423             else
1424                 hlen = 0;
1425
1426             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
1427                     || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
1428                 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
1429                 return 0;
1430             }
1431             memset(padbytes, 0, hlen);
1432         }
1433     }
1434
1435  done:
1436     return 1;
1437 }
1438
1439 int ssl_prepare_clienthello_tlsext(SSL *s)
1440 {
1441     s->s3->alpn_sent = 0;
1442     return 1;
1443 }
1444
1445 /* Initialise digests to default values */
1446 void ssl_set_default_md(SSL *s)
1447 {
1448     const EVP_MD **pmd = s->s3->tmp.md;
1449 #ifndef OPENSSL_NO_DSA
1450     pmd[SSL_PKEY_DSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
1451 #endif
1452 #ifndef OPENSSL_NO_RSA
1453     if (SSL_USE_SIGALGS(s))
1454         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_SHA1_IDX);
1455     else
1456         pmd[SSL_PKEY_RSA_SIGN] = ssl_md(SSL_MD_MD5_SHA1_IDX);
1457     pmd[SSL_PKEY_RSA_ENC] = pmd[SSL_PKEY_RSA_SIGN];
1458 #endif
1459 #ifndef OPENSSL_NO_EC
1460     pmd[SSL_PKEY_ECC] = ssl_md(SSL_MD_SHA1_IDX);
1461 #endif
1462 #ifndef OPENSSL_NO_GOST
1463     pmd[SSL_PKEY_GOST01] = ssl_md(SSL_MD_GOST94_IDX);
1464     pmd[SSL_PKEY_GOST12_256] = ssl_md(SSL_MD_GOST12_256_IDX);
1465     pmd[SSL_PKEY_GOST12_512] = ssl_md(SSL_MD_GOST12_512_IDX);
1466 #endif
1467 }
1468
1469 int tls1_set_server_sigalgs(SSL *s)
1470 {
1471     int al;
1472     size_t i;
1473
1474     /* Clear any shared signature algorithms */
1475     OPENSSL_free(s->cert->shared_sigalgs);
1476     s->cert->shared_sigalgs = NULL;
1477     s->cert->shared_sigalgslen = 0;
1478     /* Clear certificate digests and validity flags */
1479     for (i = 0; i < SSL_PKEY_NUM; i++) {
1480         s->s3->tmp.md[i] = NULL;
1481         s->s3->tmp.valid_flags[i] = 0;
1482     }
1483
1484     /* If sigalgs received process it. */
1485     if (s->s3->tmp.peer_sigalgs) {
1486         if (!tls1_process_sigalgs(s)) {
1487             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS, ERR_R_MALLOC_FAILURE);
1488             al = SSL_AD_INTERNAL_ERROR;
1489             goto err;
1490         }
1491         /* Fatal error is no shared signature algorithms */
1492         if (!s->cert->shared_sigalgs) {
1493             SSLerr(SSL_F_TLS1_SET_SERVER_SIGALGS,
1494                    SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
1495             al = SSL_AD_ILLEGAL_PARAMETER;
1496             goto err;
1497         }
1498     } else {
1499         ssl_set_default_md(s);
1500     }
1501     return 1;
1502  err:
1503     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1504     return 0;
1505 }
1506
1507 /*
1508  * Given a list of extensions that we collected earlier, find one of a given
1509  * type and return it.
1510  *
1511  * |exts| is the set of extensions previously collected.
1512  * |numexts| is the number of extensions that we have.
1513  * |type| the type of the extension that we are looking for.
1514  *
1515  * Returns a pointer to the found RAW_EXTENSION data, or NULL if not found.
1516  */
1517 RAW_EXTENSION *tls_get_extension_by_type(RAW_EXTENSION *exts, size_t numexts,
1518                                          unsigned int type)
1519 {
1520     size_t loop;
1521
1522     for (loop = 0; loop < numexts; loop++) {
1523         if (exts[loop].type == type)
1524             return &exts[loop];
1525     }
1526
1527     return NULL;
1528 }
1529
1530 /*-
1531  * Gets the ticket information supplied by the client if any.
1532  *
1533  *   hello: The parsed ClientHello data
1534  *   ret: (output) on return, if a ticket was decrypted, then this is set to
1535  *       point to the resulting session.
1536  *
1537  * If s->tls_session_secret_cb is set then we are expecting a pre-shared key
1538  * ciphersuite, in which case we have no use for session tickets and one will
1539  * never be decrypted, nor will s->tlsext_ticket_expected be set to 1.
1540  *
1541  * Returns:
1542  *   -1: fatal error, either from parsing or decrypting the ticket.
1543  *    0: no ticket was found (or was ignored, based on settings).
1544  *    1: a zero length extension was found, indicating that the client supports
1545  *       session tickets but doesn't currently have one to offer.
1546  *    2: either s->tls_session_secret_cb was set, or a ticket was offered but
1547  *       couldn't be decrypted because of a non-fatal error.
1548  *    3: a ticket was successfully decrypted and *ret was set.
1549  *
1550  * Side effects:
1551  *   Sets s->tlsext_ticket_expected to 1 if the server will have to issue
1552  *   a new session ticket to the client because the client indicated support
1553  *   (and s->tls_session_secret_cb is NULL) but the client either doesn't have
1554  *   a session ticket or we couldn't use the one it gave us, or if
1555  *   s->ctx->tlsext_ticket_key_cb asked to renew the client's ticket.
1556  *   Otherwise, s->tlsext_ticket_expected is set to 0.
1557  */
1558 int tls_get_ticket_from_client(SSL *s, CLIENTHELLO_MSG *hello,
1559                                SSL_SESSION **ret)
1560 {
1561     int retv;
1562     const unsigned char *etick;
1563     size_t size;
1564     RAW_EXTENSION *ticketext;
1565
1566     *ret = NULL;
1567     s->tlsext_ticket_expected = 0;
1568
1569     /*
1570      * If tickets disabled or not supported by the protocol version
1571      * (e.g. TLSv1.3) behave as if no ticket present to permit stateful
1572      * resumption.
1573      */
1574     if (s->version <= SSL3_VERSION || !tls_use_ticket(s))
1575         return 0;
1576
1577     ticketext = tls_get_extension_by_type(hello->pre_proc_exts,
1578                                           hello->num_extensions,
1579                                           TLSEXT_TYPE_session_ticket);
1580     if (ticketext == NULL)
1581         return 0;
1582
1583     ticketext->parsed = 1;
1584
1585     size = PACKET_remaining(&ticketext->data);
1586     if (size == 0) {
1587         /*
1588          * The client will accept a ticket but doesn't currently have
1589          * one.
1590          */
1591         s->tlsext_ticket_expected = 1;
1592         return 1;
1593     }
1594     if (s->tls_session_secret_cb) {
1595         /*
1596          * Indicate that the ticket couldn't be decrypted rather than
1597          * generating the session from ticket now, trigger
1598          * abbreviated handshake based on external mechanism to
1599          * calculate the master secret later.
1600          */
1601         return 2;
1602     }
1603     if (!PACKET_get_bytes(&ticketext->data, &etick, size)) {
1604         /* Shouldn't ever happen */
1605         return -1;
1606     }
1607     retv = tls_decrypt_ticket(s, etick, size, hello->session_id,
1608                            hello->session_id_len, ret);
1609     switch (retv) {
1610     case 2:            /* ticket couldn't be decrypted */
1611         s->tlsext_ticket_expected = 1;
1612         return 2;
1613
1614     case 3:            /* ticket was decrypted */
1615         return 3;
1616
1617     case 4:            /* ticket decrypted but need to renew */
1618         s->tlsext_ticket_expected = 1;
1619         return 3;
1620
1621     default:           /* fatal error */
1622         return -1;
1623     }
1624 }
1625
1626 /*-
1627  * tls_decrypt_ticket attempts to decrypt a session ticket.
1628  *
1629  *   etick: points to the body of the session ticket extension.
1630  *   eticklen: the length of the session tickets extension.
1631  *   sess_id: points at the session ID.
1632  *   sesslen: the length of the session ID.
1633  *   psess: (output) on return, if a ticket was decrypted, then this is set to
1634  *       point to the resulting session.
1635  *
1636  * Returns:
1637  *   -2: fatal error, malloc failure.
1638  *   -1: fatal error, either from parsing or decrypting the ticket.
1639  *    2: the ticket couldn't be decrypted.
1640  *    3: a ticket was successfully decrypted and *psess was set.
1641  *    4: same as 3, but the ticket needs to be renewed.
1642  */
1643 static int tls_decrypt_ticket(SSL *s, const unsigned char *etick,
1644                               size_t eticklen, const unsigned char *sess_id,
1645                               size_t sesslen, SSL_SESSION **psess)
1646 {
1647     SSL_SESSION *sess;
1648     unsigned char *sdec;
1649     const unsigned char *p;
1650     int slen, renew_ticket = 0, ret = -1, declen;
1651     size_t mlen;
1652     unsigned char tick_hmac[EVP_MAX_MD_SIZE];
1653     HMAC_CTX *hctx = NULL;
1654     EVP_CIPHER_CTX *ctx;
1655     SSL_CTX *tctx = s->initial_ctx;
1656
1657     /* Initialize session ticket encryption and HMAC contexts */
1658     hctx = HMAC_CTX_new();
1659     if (hctx == NULL)
1660         return -2;
1661     ctx = EVP_CIPHER_CTX_new();
1662     if (ctx == NULL) {
1663         ret = -2;
1664         goto err;
1665     }
1666     if (tctx->tlsext_ticket_key_cb) {
1667         unsigned char *nctick = (unsigned char *)etick;
1668         int rv = tctx->tlsext_ticket_key_cb(s, nctick, nctick + 16,
1669                                             ctx, hctx, 0);
1670         if (rv < 0)
1671             goto err;
1672         if (rv == 0) {
1673             ret = 2;
1674             goto err;
1675         }
1676         if (rv == 2)
1677             renew_ticket = 1;
1678     } else {
1679         /* Check key name matches */
1680         if (memcmp(etick, tctx->tlsext_tick_key_name,
1681                    sizeof(tctx->tlsext_tick_key_name)) != 0) {
1682             ret = 2;
1683             goto err;
1684         }
1685         if (HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
1686                          sizeof(tctx->tlsext_tick_hmac_key),
1687                          EVP_sha256(), NULL) <= 0
1688             || EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL,
1689                                   tctx->tlsext_tick_aes_key,
1690                                   etick + sizeof(tctx->tlsext_tick_key_name)) <=
1691             0) {
1692             goto err;
1693         }
1694     }
1695     /*
1696      * Attempt to process session ticket, first conduct sanity and integrity
1697      * checks on ticket.
1698      */
1699     mlen = HMAC_size(hctx);
1700     if (mlen == 0) {
1701         goto err;
1702     }
1703     /* Sanity check ticket length: must exceed keyname + IV + HMAC */
1704     if (eticklen <=
1705         TLSEXT_KEYNAME_LENGTH + EVP_CIPHER_CTX_iv_length(ctx) + mlen) {
1706         ret = 2;
1707         goto err;
1708     }
1709     eticklen -= mlen;
1710     /* Check HMAC of encrypted ticket */
1711     if (HMAC_Update(hctx, etick, eticklen) <= 0
1712         || HMAC_Final(hctx, tick_hmac, NULL) <= 0) {
1713         goto err;
1714     }
1715     HMAC_CTX_free(hctx);
1716     if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) {
1717         EVP_CIPHER_CTX_free(ctx);
1718         return 2;
1719     }
1720     /* Attempt to decrypt session data */
1721     /* Move p after IV to start of encrypted ticket, update length */
1722     p = etick + 16 + EVP_CIPHER_CTX_iv_length(ctx);
1723     eticklen -= 16 + EVP_CIPHER_CTX_iv_length(ctx);
1724     sdec = OPENSSL_malloc(eticklen);
1725     if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p,
1726                                           (int)eticklen) <= 0) {
1727         EVP_CIPHER_CTX_free(ctx);
1728         OPENSSL_free(sdec);
1729         return -1;
1730     }
1731     if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) {
1732         EVP_CIPHER_CTX_free(ctx);
1733         OPENSSL_free(sdec);
1734         return 2;
1735     }
1736     slen += declen;
1737     EVP_CIPHER_CTX_free(ctx);
1738     ctx = NULL;
1739     p = sdec;
1740
1741     sess = d2i_SSL_SESSION(NULL, &p, slen);
1742     OPENSSL_free(sdec);
1743     if (sess) {
1744         /*
1745          * The session ID, if non-empty, is used by some clients to detect
1746          * that the ticket has been accepted. So we copy it to the session
1747          * structure. If it is empty set length to zero as required by
1748          * standard.
1749          */
1750         if (sesslen)
1751             memcpy(sess->session_id, sess_id, sesslen);
1752         sess->session_id_length = sesslen;
1753         *psess = sess;
1754         if (renew_ticket)
1755             return 4;
1756         else
1757             return 3;
1758     }
1759     ERR_clear_error();
1760     /*
1761      * For session parse failure, indicate that we need to send a new ticket.
1762      */
1763     return 2;
1764  err:
1765     EVP_CIPHER_CTX_free(ctx);
1766     HMAC_CTX_free(hctx);
1767     return ret;
1768 }
1769
1770 /* Tables to translate from NIDs to TLS v1.2 ids */
1771
1772 typedef struct {
1773     int nid;
1774     int id;
1775 } tls12_lookup;
1776
1777 static const tls12_lookup tls12_md[] = {
1778     {NID_md5, TLSEXT_hash_md5},
1779     {NID_sha1, TLSEXT_hash_sha1},
1780     {NID_sha224, TLSEXT_hash_sha224},
1781     {NID_sha256, TLSEXT_hash_sha256},
1782     {NID_sha384, TLSEXT_hash_sha384},
1783     {NID_sha512, TLSEXT_hash_sha512},
1784     {NID_id_GostR3411_94, TLSEXT_hash_gostr3411},
1785     {NID_id_GostR3411_2012_256, TLSEXT_hash_gostr34112012_256},
1786     {NID_id_GostR3411_2012_512, TLSEXT_hash_gostr34112012_512},
1787 };
1788
1789 static const tls12_lookup tls12_sig[] = {
1790     {EVP_PKEY_RSA, TLSEXT_signature_rsa},
1791     {EVP_PKEY_DSA, TLSEXT_signature_dsa},
1792     {EVP_PKEY_EC, TLSEXT_signature_ecdsa},
1793     {NID_id_GostR3410_2001, TLSEXT_signature_gostr34102001},
1794     {NID_id_GostR3410_2012_256, TLSEXT_signature_gostr34102012_256},
1795     {NID_id_GostR3410_2012_512, TLSEXT_signature_gostr34102012_512}
1796 };
1797
1798 static int tls12_find_id(int nid, const tls12_lookup *table, size_t tlen)
1799 {
1800     size_t i;
1801     for (i = 0; i < tlen; i++) {
1802         if (table[i].nid == nid)
1803             return table[i].id;
1804     }
1805     return -1;
1806 }
1807
1808 static int tls12_find_nid(int id, const tls12_lookup *table, size_t tlen)
1809 {
1810     size_t i;
1811     for (i = 0; i < tlen; i++) {
1812         if ((table[i].id) == id)
1813             return table[i].nid;
1814     }
1815     return NID_undef;
1816 }
1817
1818 int tls12_get_sigandhash(WPACKET *pkt, const EVP_PKEY *pk, const EVP_MD *md)
1819 {
1820     int sig_id, md_id;
1821
1822     if (md == NULL)
1823         return 0;
1824     md_id = tls12_find_id(EVP_MD_type(md), tls12_md, OSSL_NELEM(tls12_md));
1825     if (md_id == -1)
1826         return 0;
1827     sig_id = tls12_get_sigid(pk);
1828     if (sig_id == -1)
1829         return 0;
1830     if (!WPACKET_put_bytes_u8(pkt, md_id) || !WPACKET_put_bytes_u8(pkt, sig_id))
1831         return 0;
1832
1833     return 1;
1834 }
1835
1836 int tls12_get_sigid(const EVP_PKEY *pk)
1837 {
1838     return tls12_find_id(EVP_PKEY_id(pk), tls12_sig, OSSL_NELEM(tls12_sig));
1839 }
1840
1841 typedef struct {
1842     int nid;
1843     int secbits;
1844     int md_idx;
1845     unsigned char tlsext_hash;
1846 } tls12_hash_info;
1847
1848 static const tls12_hash_info tls12_md_info[] = {
1849     {NID_md5, 64, SSL_MD_MD5_IDX, TLSEXT_hash_md5},
1850     {NID_sha1, 80, SSL_MD_SHA1_IDX, TLSEXT_hash_sha1},
1851     {NID_sha224, 112, SSL_MD_SHA224_IDX, TLSEXT_hash_sha224},
1852     {NID_sha256, 128, SSL_MD_SHA256_IDX, TLSEXT_hash_sha256},
1853     {NID_sha384, 192, SSL_MD_SHA384_IDX, TLSEXT_hash_sha384},
1854     {NID_sha512, 256, SSL_MD_SHA512_IDX, TLSEXT_hash_sha512},
1855     {NID_id_GostR3411_94, 128, SSL_MD_GOST94_IDX, TLSEXT_hash_gostr3411},
1856     {NID_id_GostR3411_2012_256, 128, SSL_MD_GOST12_256_IDX,
1857      TLSEXT_hash_gostr34112012_256},
1858     {NID_id_GostR3411_2012_512, 256, SSL_MD_GOST12_512_IDX,
1859      TLSEXT_hash_gostr34112012_512},
1860 };
1861
1862 static const tls12_hash_info *tls12_get_hash_info(unsigned char hash_alg)
1863 {
1864     unsigned int i;
1865     if (hash_alg == 0)
1866         return NULL;
1867
1868     for (i = 0; i < OSSL_NELEM(tls12_md_info); i++) {
1869         if (tls12_md_info[i].tlsext_hash == hash_alg)
1870             return tls12_md_info + i;
1871     }
1872
1873     return NULL;
1874 }
1875
1876 const EVP_MD *tls12_get_hash(unsigned char hash_alg)
1877 {
1878     const tls12_hash_info *inf;
1879     if (hash_alg == TLSEXT_hash_md5 && FIPS_mode())
1880         return NULL;
1881     inf = tls12_get_hash_info(hash_alg);
1882     if (!inf)
1883         return NULL;
1884     return ssl_md(inf->md_idx);
1885 }
1886
1887 static int tls12_get_pkey_idx(unsigned char sig_alg)
1888 {
1889     switch (sig_alg) {
1890 #ifndef OPENSSL_NO_RSA
1891     case TLSEXT_signature_rsa:
1892         return SSL_PKEY_RSA_SIGN;
1893 #endif
1894 #ifndef OPENSSL_NO_DSA
1895     case TLSEXT_signature_dsa:
1896         return SSL_PKEY_DSA_SIGN;
1897 #endif
1898 #ifndef OPENSSL_NO_EC
1899     case TLSEXT_signature_ecdsa:
1900         return SSL_PKEY_ECC;
1901 #endif
1902 #ifndef OPENSSL_NO_GOST
1903     case TLSEXT_signature_gostr34102001:
1904         return SSL_PKEY_GOST01;
1905
1906     case TLSEXT_signature_gostr34102012_256:
1907         return SSL_PKEY_GOST12_256;
1908
1909     case TLSEXT_signature_gostr34102012_512:
1910         return SSL_PKEY_GOST12_512;
1911 #endif
1912     }
1913     return -1;
1914 }
1915
1916 /* Convert TLS 1.2 signature algorithm extension values into NIDs */
1917 static void tls1_lookup_sigalg(int *phash_nid, int *psign_nid,
1918                                int *psignhash_nid, const unsigned char *data)
1919 {
1920     int sign_nid = NID_undef, hash_nid = NID_undef;
1921     if (!phash_nid && !psign_nid && !psignhash_nid)
1922         return;
1923     if (phash_nid || psignhash_nid) {
1924         hash_nid = tls12_find_nid(data[0], tls12_md, OSSL_NELEM(tls12_md));
1925         if (phash_nid)
1926             *phash_nid = hash_nid;
1927     }
1928     if (psign_nid || psignhash_nid) {
1929         sign_nid = tls12_find_nid(data[1], tls12_sig, OSSL_NELEM(tls12_sig));
1930         if (psign_nid)
1931             *psign_nid = sign_nid;
1932     }
1933     if (psignhash_nid) {
1934         if (sign_nid == NID_undef || hash_nid == NID_undef
1935             || OBJ_find_sigid_by_algs(psignhash_nid, hash_nid, sign_nid) <= 0)
1936             *psignhash_nid = NID_undef;
1937     }
1938 }
1939
1940 /* Check to see if a signature algorithm is allowed */
1941 static int tls12_sigalg_allowed(SSL *s, int op, const unsigned char *ptmp)
1942 {
1943     /* See if we have an entry in the hash table and it is enabled */
1944     const tls12_hash_info *hinf = tls12_get_hash_info(ptmp[0]);
1945     if (hinf == NULL || ssl_md(hinf->md_idx) == NULL)
1946         return 0;
1947     /* See if public key algorithm allowed */
1948     if (tls12_get_pkey_idx(ptmp[1]) == -1)
1949         return 0;
1950     /* Finally see if security callback allows it */
1951     return ssl_security(s, op, hinf->secbits, hinf->nid, (void *)ptmp);
1952 }
1953
1954 /*
1955  * Get a mask of disabled public key algorithms based on supported signature
1956  * algorithms. For example if no signature algorithm supports RSA then RSA is
1957  * disabled.
1958  */
1959
1960 void ssl_set_sig_mask(uint32_t *pmask_a, SSL *s, int op)
1961 {
1962     const unsigned char *sigalgs;
1963     size_t i, sigalgslen;
1964     int have_rsa = 0, have_dsa = 0, have_ecdsa = 0;
1965     /*
1966      * Now go through all signature algorithms seeing if we support any for
1967      * RSA, DSA, ECDSA. Do this for all versions not just TLS 1.2. To keep
1968      * down calls to security callback only check if we have to.
1969      */
1970     sigalgslen = tls12_get_psigalgs(s, &sigalgs);
1971     for (i = 0; i < sigalgslen; i += 2, sigalgs += 2) {
1972         switch (sigalgs[1]) {
1973 #ifndef OPENSSL_NO_RSA
1974         case TLSEXT_signature_rsa:
1975             if (!have_rsa && tls12_sigalg_allowed(s, op, sigalgs))
1976                 have_rsa = 1;
1977             break;
1978 #endif
1979 #ifndef OPENSSL_NO_DSA
1980         case TLSEXT_signature_dsa:
1981             if (!have_dsa && tls12_sigalg_allowed(s, op, sigalgs))
1982                 have_dsa = 1;
1983             break;
1984 #endif
1985 #ifndef OPENSSL_NO_EC
1986         case TLSEXT_signature_ecdsa:
1987             if (!have_ecdsa && tls12_sigalg_allowed(s, op, sigalgs))
1988                 have_ecdsa = 1;
1989             break;
1990 #endif
1991         }
1992     }
1993     if (!have_rsa)
1994         *pmask_a |= SSL_aRSA;
1995     if (!have_dsa)
1996         *pmask_a |= SSL_aDSS;
1997     if (!have_ecdsa)
1998         *pmask_a |= SSL_aECDSA;
1999 }
2000
2001 int tls12_copy_sigalgs(SSL *s, WPACKET *pkt,
2002                        const unsigned char *psig, size_t psiglen)
2003 {
2004     size_t i;
2005
2006     for (i = 0; i < psiglen; i += 2, psig += 2) {
2007         if (tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, psig)) {
2008             if (!WPACKET_put_bytes_u8(pkt, psig[0])
2009                     || !WPACKET_put_bytes_u8(pkt, psig[1]))
2010                 return 0;
2011         }
2012     }
2013     return 1;
2014 }
2015
2016 /* Given preference and allowed sigalgs set shared sigalgs */
2017 static size_t tls12_shared_sigalgs(SSL *s, TLS_SIGALGS *shsig,
2018                                    const unsigned char *pref, size_t preflen,
2019                                    const unsigned char *allow, size_t allowlen)
2020 {
2021     const unsigned char *ptmp, *atmp;
2022     size_t i, j, nmatch = 0;
2023     for (i = 0, ptmp = pref; i < preflen; i += 2, ptmp += 2) {
2024         /* Skip disabled hashes or signature algorithms */
2025         if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, ptmp))
2026             continue;
2027         for (j = 0, atmp = allow; j < allowlen; j += 2, atmp += 2) {
2028             if (ptmp[0] == atmp[0] && ptmp[1] == atmp[1]) {
2029                 nmatch++;
2030                 if (shsig) {
2031                     shsig->rhash = ptmp[0];
2032                     shsig->rsign = ptmp[1];
2033                     tls1_lookup_sigalg(&shsig->hash_nid,
2034                                        &shsig->sign_nid,
2035                                        &shsig->signandhash_nid, ptmp);
2036                     shsig++;
2037                 }
2038                 break;
2039             }
2040         }
2041     }
2042     return nmatch;
2043 }
2044
2045 /* Set shared signature algorithms for SSL structures */
2046 static int tls1_set_shared_sigalgs(SSL *s)
2047 {
2048     const unsigned char *pref, *allow, *conf;
2049     size_t preflen, allowlen, conflen;
2050     size_t nmatch;
2051     TLS_SIGALGS *salgs = NULL;
2052     CERT *c = s->cert;
2053     unsigned int is_suiteb = tls1_suiteb(s);
2054
2055     OPENSSL_free(c->shared_sigalgs);
2056     c->shared_sigalgs = NULL;
2057     c->shared_sigalgslen = 0;
2058     /* If client use client signature algorithms if not NULL */
2059     if (!s->server && c->client_sigalgs && !is_suiteb) {
2060         conf = c->client_sigalgs;
2061         conflen = c->client_sigalgslen;
2062     } else if (c->conf_sigalgs && !is_suiteb) {
2063         conf = c->conf_sigalgs;
2064         conflen = c->conf_sigalgslen;
2065     } else
2066         conflen = tls12_get_psigalgs(s, &conf);
2067     if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) {
2068         pref = conf;
2069         preflen = conflen;
2070         allow = s->s3->tmp.peer_sigalgs;
2071         allowlen = s->s3->tmp.peer_sigalgslen;
2072     } else {
2073         allow = conf;
2074         allowlen = conflen;
2075         pref = s->s3->tmp.peer_sigalgs;
2076         preflen = s->s3->tmp.peer_sigalgslen;
2077     }
2078     nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen);
2079     if (nmatch) {
2080         salgs = OPENSSL_malloc(nmatch * sizeof(TLS_SIGALGS));
2081         if (salgs == NULL)
2082             return 0;
2083         nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen);
2084     } else {
2085         salgs = NULL;
2086     }
2087     c->shared_sigalgs = salgs;
2088     c->shared_sigalgslen = nmatch;
2089     return 1;
2090 }
2091
2092 /* Set preferred digest for each key type */
2093
2094 int tls1_save_sigalgs(SSL *s, const unsigned char *data, size_t dsize)
2095 {
2096     CERT *c = s->cert;
2097     /* Extension ignored for inappropriate versions */
2098     if (!SSL_USE_SIGALGS(s))
2099         return 1;
2100     /* Should never happen */
2101     if (!c)
2102         return 0;
2103
2104     OPENSSL_free(s->s3->tmp.peer_sigalgs);
2105     s->s3->tmp.peer_sigalgs = OPENSSL_malloc(dsize);
2106     if (s->s3->tmp.peer_sigalgs == NULL)
2107         return 0;
2108     s->s3->tmp.peer_sigalgslen = dsize;
2109     memcpy(s->s3->tmp.peer_sigalgs, data, dsize);
2110     return 1;
2111 }
2112
2113 int tls1_process_sigalgs(SSL *s)
2114 {
2115     int idx;
2116     size_t i;
2117     const EVP_MD *md;
2118     const EVP_MD **pmd = s->s3->tmp.md;
2119     uint32_t *pvalid = s->s3->tmp.valid_flags;
2120     CERT *c = s->cert;
2121     TLS_SIGALGS *sigptr;
2122     if (!tls1_set_shared_sigalgs(s))
2123         return 0;
2124
2125     for (i = 0, sigptr = c->shared_sigalgs;
2126          i < c->shared_sigalgslen; i++, sigptr++) {
2127         idx = tls12_get_pkey_idx(sigptr->rsign);
2128         if (idx > 0 && pmd[idx] == NULL) {
2129             md = tls12_get_hash(sigptr->rhash);
2130             pmd[idx] = md;
2131             pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN;
2132             if (idx == SSL_PKEY_RSA_SIGN) {
2133                 pvalid[SSL_PKEY_RSA_ENC] = CERT_PKEY_EXPLICIT_SIGN;
2134                 pmd[SSL_PKEY_RSA_ENC] = md;
2135             }
2136         }
2137
2138     }
2139     /*
2140      * In strict mode leave unset digests as NULL to indicate we can't use
2141      * the certificate for signing.
2142      */
2143     if (!(s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
2144         /*
2145          * Set any remaining keys to default values. NOTE: if alg is not
2146          * supported it stays as NULL.
2147          */
2148 #ifndef OPENSSL_NO_DSA
2149         if (pmd[SSL_PKEY_DSA_SIGN] == NULL)
2150             pmd[SSL_PKEY_DSA_SIGN] = EVP_sha1();
2151 #endif
2152 #ifndef OPENSSL_NO_RSA
2153         if (pmd[SSL_PKEY_RSA_SIGN] == NULL) {
2154             pmd[SSL_PKEY_RSA_SIGN] = EVP_sha1();
2155             pmd[SSL_PKEY_RSA_ENC] = EVP_sha1();
2156         }
2157 #endif
2158 #ifndef OPENSSL_NO_EC
2159         if (pmd[SSL_PKEY_ECC] == NULL)
2160             pmd[SSL_PKEY_ECC] = EVP_sha1();
2161 #endif
2162 #ifndef OPENSSL_NO_GOST
2163         if (pmd[SSL_PKEY_GOST01] == NULL)
2164             pmd[SSL_PKEY_GOST01] = EVP_get_digestbynid(NID_id_GostR3411_94);
2165         if (pmd[SSL_PKEY_GOST12_256] == NULL)
2166             pmd[SSL_PKEY_GOST12_256] =
2167                 EVP_get_digestbynid(NID_id_GostR3411_2012_256);
2168         if (pmd[SSL_PKEY_GOST12_512] == NULL)
2169             pmd[SSL_PKEY_GOST12_512] =
2170                 EVP_get_digestbynid(NID_id_GostR3411_2012_512);
2171 #endif
2172     }
2173     return 1;
2174 }
2175
2176 int SSL_get_sigalgs(SSL *s, int idx,
2177                     int *psign, int *phash, int *psignhash,
2178                     unsigned char *rsig, unsigned char *rhash)
2179 {
2180     const unsigned char *psig = s->s3->tmp.peer_sigalgs;
2181     size_t numsigalgs = s->s3->tmp.peer_sigalgslen / 2;
2182     if (psig == NULL || numsigalgs > INT_MAX)
2183         return 0;
2184     if (idx >= 0) {
2185         idx <<= 1;
2186         if (idx >= (int)s->s3->tmp.peer_sigalgslen)
2187             return 0;
2188         psig += idx;
2189         if (rhash)
2190             *rhash = psig[0];
2191         if (rsig)
2192             *rsig = psig[1];
2193         tls1_lookup_sigalg(phash, psign, psignhash, psig);
2194     }
2195     return (int)numsigalgs;
2196 }
2197
2198 int SSL_get_shared_sigalgs(SSL *s, int idx,
2199                            int *psign, int *phash, int *psignhash,
2200                            unsigned char *rsig, unsigned char *rhash)
2201 {
2202     TLS_SIGALGS *shsigalgs = s->cert->shared_sigalgs;
2203     if (!shsigalgs || idx >= (int)s->cert->shared_sigalgslen
2204             || s->cert->shared_sigalgslen > INT_MAX)
2205         return 0;
2206     shsigalgs += idx;
2207     if (phash)
2208         *phash = shsigalgs->hash_nid;
2209     if (psign)
2210         *psign = shsigalgs->sign_nid;
2211     if (psignhash)
2212         *psignhash = shsigalgs->signandhash_nid;
2213     if (rsig)
2214         *rsig = shsigalgs->rsign;
2215     if (rhash)
2216         *rhash = shsigalgs->rhash;
2217     return (int)s->cert->shared_sigalgslen;
2218 }
2219
2220 #define MAX_SIGALGLEN   (TLSEXT_hash_num * TLSEXT_signature_num * 2)
2221
2222 typedef struct {
2223     size_t sigalgcnt;
2224     int sigalgs[MAX_SIGALGLEN];
2225 } sig_cb_st;
2226
2227 static void get_sigorhash(int *psig, int *phash, const char *str)
2228 {
2229     if (strcmp(str, "RSA") == 0) {
2230         *psig = EVP_PKEY_RSA;
2231     } else if (strcmp(str, "DSA") == 0) {
2232         *psig = EVP_PKEY_DSA;
2233     } else if (strcmp(str, "ECDSA") == 0) {
2234         *psig = EVP_PKEY_EC;
2235     } else {
2236         *phash = OBJ_sn2nid(str);
2237         if (*phash == NID_undef)
2238             *phash = OBJ_ln2nid(str);
2239     }
2240 }
2241
2242 static int sig_cb(const char *elem, int len, void *arg)
2243 {
2244     sig_cb_st *sarg = arg;
2245     size_t i;
2246     char etmp[20], *p;
2247     int sig_alg = NID_undef, hash_alg = NID_undef;
2248     if (elem == NULL)
2249         return 0;
2250     if (sarg->sigalgcnt == MAX_SIGALGLEN)
2251         return 0;
2252     if (len > (int)(sizeof(etmp) - 1))
2253         return 0;
2254     memcpy(etmp, elem, len);
2255     etmp[len] = 0;
2256     p = strchr(etmp, '+');
2257     if (!p)
2258         return 0;
2259     *p = 0;
2260     p++;
2261     if (!*p)
2262         return 0;
2263
2264     get_sigorhash(&sig_alg, &hash_alg, etmp);
2265     get_sigorhash(&sig_alg, &hash_alg, p);
2266
2267     if (sig_alg == NID_undef || hash_alg == NID_undef)
2268         return 0;
2269
2270     for (i = 0; i < sarg->sigalgcnt; i += 2) {
2271         if (sarg->sigalgs[i] == sig_alg && sarg->sigalgs[i + 1] == hash_alg)
2272             return 0;
2273     }
2274     sarg->sigalgs[sarg->sigalgcnt++] = hash_alg;
2275     sarg->sigalgs[sarg->sigalgcnt++] = sig_alg;
2276     return 1;
2277 }
2278
2279 /*
2280  * Set supported signature algorithms based on a colon separated list of the
2281  * form sig+hash e.g. RSA+SHA512:DSA+SHA512
2282  */
2283 int tls1_set_sigalgs_list(CERT *c, const char *str, int client)
2284 {
2285     sig_cb_st sig;
2286     sig.sigalgcnt = 0;
2287     if (!CONF_parse_list(str, ':', 1, sig_cb, &sig))
2288         return 0;
2289     if (c == NULL)
2290         return 1;
2291     return tls1_set_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client);
2292 }
2293
2294 int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client)
2295 {
2296     unsigned char *sigalgs, *sptr;
2297     int rhash, rsign;
2298     size_t i;
2299     if (salglen & 1)
2300         return 0;
2301     sigalgs = OPENSSL_malloc(salglen);
2302     if (sigalgs == NULL)
2303         return 0;
2304     for (i = 0, sptr = sigalgs; i < salglen; i += 2) {
2305         rhash = tls12_find_id(*psig_nids++, tls12_md, OSSL_NELEM(tls12_md));
2306         rsign = tls12_find_id(*psig_nids++, tls12_sig, OSSL_NELEM(tls12_sig));
2307
2308         if (rhash == -1 || rsign == -1)
2309             goto err;
2310         *sptr++ = rhash;
2311         *sptr++ = rsign;
2312     }
2313
2314     if (client) {
2315         OPENSSL_free(c->client_sigalgs);
2316         c->client_sigalgs = sigalgs;
2317         c->client_sigalgslen = salglen;
2318     } else {
2319         OPENSSL_free(c->conf_sigalgs);
2320         c->conf_sigalgs = sigalgs;
2321         c->conf_sigalgslen = salglen;
2322     }
2323
2324     return 1;
2325
2326  err:
2327     OPENSSL_free(sigalgs);
2328     return 0;
2329 }
2330
2331 static int tls1_check_sig_alg(CERT *c, X509 *x, int default_nid)
2332 {
2333     int sig_nid;
2334     size_t i;
2335     if (default_nid == -1)
2336         return 1;
2337     sig_nid = X509_get_signature_nid(x);
2338     if (default_nid)
2339         return sig_nid == default_nid ? 1 : 0;
2340     for (i = 0; i < c->shared_sigalgslen; i++)
2341         if (sig_nid == c->shared_sigalgs[i].signandhash_nid)
2342             return 1;
2343     return 0;
2344 }
2345
2346 /* Check to see if a certificate issuer name matches list of CA names */
2347 static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
2348 {
2349     X509_NAME *nm;
2350     int i;
2351     nm = X509_get_issuer_name(x);
2352     for (i = 0; i < sk_X509_NAME_num(names); i++) {
2353         if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i)))
2354             return 1;
2355     }
2356     return 0;
2357 }
2358
2359 /*
2360  * Check certificate chain is consistent with TLS extensions and is usable by
2361  * server. This servers two purposes: it allows users to check chains before
2362  * passing them to the server and it allows the server to check chains before
2363  * attempting to use them.
2364  */
2365
2366 /* Flags which need to be set for a certificate when stict mode not set */
2367
2368 #define CERT_PKEY_VALID_FLAGS \
2369         (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM)
2370 /* Strict mode flags */
2371 #define CERT_PKEY_STRICT_FLAGS \
2372          (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
2373          | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
2374
2375 int tls1_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain,
2376                      int idx)
2377 {
2378     int i;
2379     int rv = 0;
2380     int check_flags = 0, strict_mode;
2381     CERT_PKEY *cpk = NULL;
2382     CERT *c = s->cert;
2383     uint32_t *pvalid;
2384     unsigned int suiteb_flags = tls1_suiteb(s);
2385     /* idx == -1 means checking server chains */
2386     if (idx != -1) {
2387         /* idx == -2 means checking client certificate chains */
2388         if (idx == -2) {
2389             cpk = c->key;
2390             idx = (int)(cpk - c->pkeys);
2391         } else
2392             cpk = c->pkeys + idx;
2393         pvalid = s->s3->tmp.valid_flags + idx;
2394         x = cpk->x509;
2395         pk = cpk->privatekey;
2396         chain = cpk->chain;
2397         strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT;
2398         /* If no cert or key, forget it */
2399         if (!x || !pk)
2400             goto end;
2401     } else {
2402         if (!x || !pk)
2403             return 0;
2404         idx = ssl_cert_type(x, pk);
2405         if (idx == -1)
2406             return 0;
2407         pvalid = s->s3->tmp.valid_flags + idx;
2408
2409         if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)
2410             check_flags = CERT_PKEY_STRICT_FLAGS;
2411         else
2412             check_flags = CERT_PKEY_VALID_FLAGS;
2413         strict_mode = 1;
2414     }
2415
2416     if (suiteb_flags) {
2417         int ok;
2418         if (check_flags)
2419             check_flags |= CERT_PKEY_SUITEB;
2420         ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags);
2421         if (ok == X509_V_OK)
2422             rv |= CERT_PKEY_SUITEB;
2423         else if (!check_flags)
2424             goto end;
2425     }
2426
2427     /*
2428      * Check all signature algorithms are consistent with signature
2429      * algorithms extension if TLS 1.2 or later and strict mode.
2430      */
2431     if (TLS1_get_version(s) >= TLS1_2_VERSION && strict_mode) {
2432         int default_nid;
2433         unsigned char rsign = 0;
2434         if (s->s3->tmp.peer_sigalgs)
2435             default_nid = 0;
2436         /* If no sigalgs extension use defaults from RFC5246 */
2437         else {
2438             switch (idx) {
2439             case SSL_PKEY_RSA_ENC:
2440             case SSL_PKEY_RSA_SIGN:
2441                 rsign = TLSEXT_signature_rsa;
2442                 default_nid = NID_sha1WithRSAEncryption;
2443                 break;
2444
2445             case SSL_PKEY_DSA_SIGN:
2446                 rsign = TLSEXT_signature_dsa;
2447                 default_nid = NID_dsaWithSHA1;
2448                 break;
2449
2450             case SSL_PKEY_ECC:
2451                 rsign = TLSEXT_signature_ecdsa;
2452                 default_nid = NID_ecdsa_with_SHA1;
2453                 break;
2454
2455             case SSL_PKEY_GOST01:
2456                 rsign = TLSEXT_signature_gostr34102001;
2457                 default_nid = NID_id_GostR3411_94_with_GostR3410_2001;
2458                 break;
2459
2460             case SSL_PKEY_GOST12_256:
2461                 rsign = TLSEXT_signature_gostr34102012_256;
2462                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_256;
2463                 break;
2464
2465             case SSL_PKEY_GOST12_512:
2466                 rsign = TLSEXT_signature_gostr34102012_512;
2467                 default_nid = NID_id_tc26_signwithdigest_gost3410_2012_512;
2468                 break;
2469
2470             default:
2471                 default_nid = -1;
2472                 break;
2473             }
2474         }
2475         /*
2476          * If peer sent no signature algorithms extension and we have set
2477          * preferred signature algorithms check we support sha1.
2478          */
2479         if (default_nid > 0 && c->conf_sigalgs) {
2480             size_t j;
2481             const unsigned char *p = c->conf_sigalgs;
2482             for (j = 0; j < c->conf_sigalgslen; j += 2, p += 2) {
2483                 if (p[0] == TLSEXT_hash_sha1 && p[1] == rsign)
2484                     break;
2485             }
2486             if (j == c->conf_sigalgslen) {
2487                 if (check_flags)
2488                     goto skip_sigs;
2489                 else
2490                     goto end;
2491             }
2492         }
2493         /* Check signature algorithm of each cert in chain */
2494         if (!tls1_check_sig_alg(c, x, default_nid)) {
2495             if (!check_flags)
2496                 goto end;
2497         } else
2498             rv |= CERT_PKEY_EE_SIGNATURE;
2499         rv |= CERT_PKEY_CA_SIGNATURE;
2500         for (i = 0; i < sk_X509_num(chain); i++) {
2501             if (!tls1_check_sig_alg(c, sk_X509_value(chain, i), default_nid)) {
2502                 if (check_flags) {
2503                     rv &= ~CERT_PKEY_CA_SIGNATURE;
2504                     break;
2505                 } else
2506                     goto end;
2507             }
2508         }
2509     }
2510     /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */
2511     else if (check_flags)
2512         rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE;
2513  skip_sigs:
2514     /* Check cert parameters are consistent */
2515     if (tls1_check_cert_param(s, x, check_flags ? 1 : 2))
2516         rv |= CERT_PKEY_EE_PARAM;
2517     else if (!check_flags)
2518         goto end;
2519     if (!s->server)
2520         rv |= CERT_PKEY_CA_PARAM;
2521     /* In strict mode check rest of chain too */
2522     else if (strict_mode) {
2523         rv |= CERT_PKEY_CA_PARAM;
2524         for (i = 0; i < sk_X509_num(chain); i++) {
2525             X509 *ca = sk_X509_value(chain, i);
2526             if (!tls1_check_cert_param(s, ca, 0)) {
2527                 if (check_flags) {
2528                     rv &= ~CERT_PKEY_CA_PARAM;
2529                     break;
2530                 } else
2531                     goto end;
2532             }
2533         }
2534     }
2535     if (!s->server && strict_mode) {
2536         STACK_OF(X509_NAME) *ca_dn;
2537         int check_type = 0;
2538         switch (EVP_PKEY_id(pk)) {
2539         case EVP_PKEY_RSA:
2540             check_type = TLS_CT_RSA_SIGN;
2541             break;
2542         case EVP_PKEY_DSA:
2543             check_type = TLS_CT_DSS_SIGN;
2544             break;
2545         case EVP_PKEY_EC:
2546             check_type = TLS_CT_ECDSA_SIGN;
2547             break;
2548         }
2549         if (check_type) {
2550             const unsigned char *ctypes;
2551             int ctypelen;
2552             if (c->ctypes) {
2553                 ctypes = c->ctypes;
2554                 ctypelen = (int)c->ctype_num;
2555             } else {
2556                 ctypes = (unsigned char *)s->s3->tmp.ctype;
2557                 ctypelen = s->s3->tmp.ctype_num;
2558             }
2559             for (i = 0; i < ctypelen; i++) {
2560                 if (ctypes[i] == check_type) {
2561                     rv |= CERT_PKEY_CERT_TYPE;
2562                     break;
2563                 }
2564             }
2565             if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags)
2566                 goto end;
2567         } else
2568             rv |= CERT_PKEY_CERT_TYPE;
2569
2570         ca_dn = s->s3->tmp.ca_names;
2571
2572         if (!sk_X509_NAME_num(ca_dn))
2573             rv |= CERT_PKEY_ISSUER_NAME;
2574
2575         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
2576             if (ssl_check_ca_name(ca_dn, x))
2577                 rv |= CERT_PKEY_ISSUER_NAME;
2578         }
2579         if (!(rv & CERT_PKEY_ISSUER_NAME)) {
2580             for (i = 0; i < sk_X509_num(chain); i++) {
2581                 X509 *xtmp = sk_X509_value(chain, i);
2582                 if (ssl_check_ca_name(ca_dn, xtmp)) {
2583                     rv |= CERT_PKEY_ISSUER_NAME;
2584                     break;
2585                 }
2586             }
2587         }
2588         if (!check_flags && !(rv & CERT_PKEY_ISSUER_NAME))
2589             goto end;
2590     } else
2591         rv |= CERT_PKEY_ISSUER_NAME | CERT_PKEY_CERT_TYPE;
2592
2593     if (!check_flags || (rv & check_flags) == check_flags)
2594         rv |= CERT_PKEY_VALID;
2595
2596  end:
2597
2598     if (TLS1_get_version(s) >= TLS1_2_VERSION) {
2599         if (*pvalid & CERT_PKEY_EXPLICIT_SIGN)
2600             rv |= CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN;
2601         else if (s->s3->tmp.md[idx] != NULL)
2602             rv |= CERT_PKEY_SIGN;
2603     } else
2604         rv |= CERT_PKEY_SIGN | CERT_PKEY_EXPLICIT_SIGN;
2605
2606     /*
2607      * When checking a CERT_PKEY structure all flags are irrelevant if the
2608      * chain is invalid.
2609      */
2610     if (!check_flags) {
2611         if (rv & CERT_PKEY_VALID)
2612             *pvalid = rv;
2613         else {
2614             /* Preserve explicit sign flag, clear rest */
2615             *pvalid &= CERT_PKEY_EXPLICIT_SIGN;
2616             return 0;
2617         }
2618     }
2619     return rv;
2620 }
2621
2622 /* Set validity of certificates in an SSL structure */
2623 void tls1_set_cert_validity(SSL *s)
2624 {
2625     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_ENC);
2626     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_SIGN);
2627     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DSA_SIGN);
2628     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ECC);
2629     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST01);
2630     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_256);
2631     tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_512);
2632 }
2633
2634 /* User level utiity function to check a chain is suitable */
2635 int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain)
2636 {
2637     return tls1_check_chain(s, x, pk, chain, -1);
2638 }
2639
2640 #ifndef OPENSSL_NO_DH
2641 DH *ssl_get_auto_dh(SSL *s)
2642 {
2643     int dh_secbits = 80;
2644     if (s->cert->dh_tmp_auto == 2)
2645         return DH_get_1024_160();
2646     if (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aPSK)) {
2647         if (s->s3->tmp.new_cipher->strength_bits == 256)
2648             dh_secbits = 128;
2649         else
2650             dh_secbits = 80;
2651     } else {
2652         CERT_PKEY *cpk = ssl_get_server_send_pkey(s);
2653         dh_secbits = EVP_PKEY_security_bits(cpk->privatekey);
2654     }
2655
2656     if (dh_secbits >= 128) {
2657         DH *dhp = DH_new();
2658         BIGNUM *p, *g;
2659         if (dhp == NULL)
2660             return NULL;
2661         g = BN_new();
2662         if (g != NULL)
2663             BN_set_word(g, 2);
2664         if (dh_secbits >= 192)
2665             p = BN_get_rfc3526_prime_8192(NULL);
2666         else
2667             p = BN_get_rfc3526_prime_3072(NULL);
2668         if (p == NULL || g == NULL || !DH_set0_pqg(dhp, p, NULL, g)) {
2669             DH_free(dhp);
2670             BN_free(p);
2671             BN_free(g);
2672             return NULL;
2673         }
2674         return dhp;
2675     }
2676     if (dh_secbits >= 112)
2677         return DH_get_2048_224();
2678     return DH_get_1024_160();
2679 }
2680 #endif
2681
2682 static int ssl_security_cert_key(SSL *s, SSL_CTX *ctx, X509 *x, int op)
2683 {
2684     int secbits = -1;
2685     EVP_PKEY *pkey = X509_get0_pubkey(x);
2686     if (pkey) {
2687         /*
2688          * If no parameters this will return -1 and fail using the default
2689          * security callback for any non-zero security level. This will
2690          * reject keys which omit parameters but this only affects DSA and
2691          * omission of parameters is never (?) done in practice.
2692          */
2693         secbits = EVP_PKEY_security_bits(pkey);
2694     }
2695     if (s)
2696         return ssl_security(s, op, secbits, 0, x);
2697     else
2698         return ssl_ctx_security(ctx, op, secbits, 0, x);
2699 }
2700
2701 static int ssl_security_cert_sig(SSL *s, SSL_CTX *ctx, X509 *x, int op)
2702 {
2703     /* Lookup signature algorithm digest */
2704     int secbits = -1, md_nid = NID_undef, sig_nid;
2705     /* Don't check signature if self signed */
2706     if ((X509_get_extension_flags(x) & EXFLAG_SS) != 0)
2707         return 1;
2708     sig_nid = X509_get_signature_nid(x);
2709     if (sig_nid && OBJ_find_sigid_algs(sig_nid, &md_nid, NULL)) {
2710         const EVP_MD *md;
2711         if (md_nid && (md = EVP_get_digestbynid(md_nid)))
2712             secbits = EVP_MD_size(md) * 4;
2713     }
2714     if (s)
2715         return ssl_security(s, op, secbits, md_nid, x);
2716     else
2717         return ssl_ctx_security(ctx, op, secbits, md_nid, x);
2718 }
2719
2720 int ssl_security_cert(SSL *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee)
2721 {
2722     if (vfy)
2723         vfy = SSL_SECOP_PEER;
2724     if (is_ee) {
2725         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_EE_KEY | vfy))
2726             return SSL_R_EE_KEY_TOO_SMALL;
2727     } else {
2728         if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_CA_KEY | vfy))
2729             return SSL_R_CA_KEY_TOO_SMALL;
2730     }
2731     if (!ssl_security_cert_sig(s, ctx, x, SSL_SECOP_CA_MD | vfy))
2732         return SSL_R_CA_MD_TOO_WEAK;
2733     return 1;
2734 }
2735
2736 /*
2737  * Check security of a chain, if sk includes the end entity certificate then
2738  * x is NULL. If vfy is 1 then we are verifying a peer chain and not sending
2739  * one to the peer. Return values: 1 if ok otherwise error code to use
2740  */
2741
2742 int ssl_security_cert_chain(SSL *s, STACK_OF(X509) *sk, X509 *x, int vfy)
2743 {
2744     int rv, start_idx, i;
2745     if (x == NULL) {
2746         x = sk_X509_value(sk, 0);
2747         start_idx = 1;
2748     } else
2749         start_idx = 0;
2750
2751     rv = ssl_security_cert(s, NULL, x, vfy, 1);
2752     if (rv != 1)
2753         return rv;
2754
2755     for (i = start_idx; i < sk_X509_num(sk); i++) {
2756         x = sk_X509_value(sk, i);
2757         rv = ssl_security_cert(s, NULL, x, vfy, 0);
2758         if (rv != 1)
2759             return rv;
2760     }
2761     return 1;
2762 }