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