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