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