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