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