Send an illegal parameter alert if the update type in a KeyUpdate is wrong
[openssl.git] / ssl / statem / statem_lib.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /* ====================================================================
11  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
12  * ECC cipher suite support in OpenSSL originally developed by
13  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
14  */
15
16 #include <limits.h>
17 #include <string.h>
18 #include <stdio.h>
19 #include "../ssl_locl.h"
20 #include "statem_locl.h"
21 #include <openssl/buffer.h>
22 #include <openssl/objects.h>
23 #include <openssl/evp.h>
24 #include <openssl/x509.h>
25
26 /*
27  * send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or
28  * SSL3_RT_CHANGE_CIPHER_SPEC)
29  */
30 int ssl3_do_write(SSL *s, int type)
31 {
32     int ret;
33     size_t written = 0;
34
35     ret = ssl3_write_bytes(s, type, &s->init_buf->data[s->init_off],
36                            s->init_num, &written);
37     if (ret < 0)
38         return (-1);
39     if (type == SSL3_RT_HANDSHAKE)
40         /*
41          * should not be done for 'Hello Request's, but in that case we'll
42          * ignore the result anyway
43          */
44         if (!ssl3_finish_mac(s,
45                              (unsigned char *)&s->init_buf->data[s->init_off],
46                              written))
47             return -1;
48
49     if (written == s->init_num) {
50         if (s->msg_callback)
51             s->msg_callback(1, s->version, type, s->init_buf->data,
52                             (size_t)(s->init_off + s->init_num), s,
53                             s->msg_callback_arg);
54         return (1);
55     }
56     s->init_off += written;
57     s->init_num -= written;
58     return (0);
59 }
60
61 int tls_close_construct_packet(SSL *s, WPACKET *pkt, int htype)
62 {
63     size_t msglen;
64
65     if ((htype != SSL3_MT_CHANGE_CIPHER_SPEC && !WPACKET_close(pkt))
66             || !WPACKET_get_length(pkt, &msglen)
67             || msglen > INT_MAX)
68         return 0;
69     s->init_num = (int)msglen;
70     s->init_off = 0;
71
72     return 1;
73 }
74
75 int tls_setup_handshake(SSL *s)
76 {
77     if (!ssl3_init_finished_mac(s))
78         return 0;
79
80     if (s->server) {
81         STACK_OF(SSL_CIPHER) *ciphers = SSL_get_ciphers(s);
82         int i, ver_min, ver_max, ok = 0;
83
84         /*
85          * Sanity check that the maximum version we accept has ciphers
86          * enabled. For clients we do this check during construction of the
87          * ClientHello.
88          */
89         if (ssl_get_min_max_version(s, &ver_min, &ver_max) != 0) {
90             SSLerr(SSL_F_TLS_SETUP_HANDSHAKE, ERR_R_INTERNAL_ERROR);
91             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
92             return 0;
93         }
94         for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
95             const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
96
97             if (SSL_IS_DTLS(s)) {
98                 if (DTLS_VERSION_GE(ver_max, c->min_dtls) &&
99                         DTLS_VERSION_LE(ver_max, c->max_dtls))
100                     ok = 1;
101             } else if (ver_max >= c->min_tls && ver_max <= c->max_tls) {
102                 ok = 1;
103             }
104             if (ok)
105                 break;
106         }
107         if (!ok) {
108             SSLerr(SSL_F_TLS_SETUP_HANDSHAKE, SSL_R_NO_CIPHERS_AVAILABLE);
109             ERR_add_error_data(1, "No ciphers enabled for max supported "
110                                   "SSL/TLS version");
111             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
112             return 0;
113         }
114         if (SSL_IS_FIRST_HANDSHAKE(s)) {
115             s->ctx->stats.sess_accept++;
116         } else if (!s->s3->send_connection_binding &&
117                    !(s->options &
118                      SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)) {
119             /*
120              * Server attempting to renegotiate with client that doesn't
121              * support secure renegotiation.
122              */
123             SSLerr(SSL_F_TLS_SETUP_HANDSHAKE,
124                    SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
125             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
126             return 0;
127         } else {
128             s->ctx->stats.sess_accept_renegotiate++;
129
130             s->s3->tmp.cert_request = 0;
131         }
132     } else {
133         if (SSL_IS_FIRST_HANDSHAKE(s))
134             s->ctx->stats.sess_connect++;
135         else
136             s->ctx->stats.sess_connect_renegotiate++;
137
138         /* mark client_random uninitialized */
139         memset(s->s3->client_random, 0, sizeof(s->s3->client_random));
140         s->hit = 0;
141
142         s->s3->tmp.cert_req = 0;
143
144         if (SSL_IS_DTLS(s))
145             s->statem.use_timer = 1;
146     }
147
148     return 1;
149 }
150
151 /*
152  * Size of the to-be-signed TLS13 data, without the hash size itself:
153  * 64 bytes of value 32, 33 context bytes, 1 byte separator
154  */
155 #define TLS13_TBS_START_SIZE            64
156 #define TLS13_TBS_PREAMBLE_SIZE         (TLS13_TBS_START_SIZE + 33 + 1)
157
158 static int get_cert_verify_tbs_data(SSL *s, unsigned char *tls13tbs,
159                                     void **hdata, size_t *hdatalen)
160 {
161     static const char *servercontext = "TLS 1.3, server CertificateVerify";
162     static const char *clientcontext = "TLS 1.3, client CertificateVerify";
163
164     if (SSL_IS_TLS13(s)) {
165         size_t hashlen;
166
167         /* Set the first 64 bytes of to-be-signed data to octet 32 */
168         memset(tls13tbs, 32, TLS13_TBS_START_SIZE);
169         /* This copies the 33 bytes of context plus the 0 separator byte */
170         if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY
171                  || s->statem.hand_state == TLS_ST_SW_CERT_VRFY)
172             strcpy((char *)tls13tbs + TLS13_TBS_START_SIZE, servercontext);
173         else
174             strcpy((char *)tls13tbs + TLS13_TBS_START_SIZE, clientcontext);
175
176         /*
177          * If we're currently reading then we need to use the saved handshake
178          * hash value. We can't use the current handshake hash state because
179          * that includes the CertVerify itself.
180          */
181         if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY
182                 || s->statem.hand_state == TLS_ST_SR_CERT_VRFY) {
183             memcpy(tls13tbs + TLS13_TBS_PREAMBLE_SIZE, s->cert_verify_hash,
184                    s->cert_verify_hash_len);
185             hashlen = s->cert_verify_hash_len;
186         } else if (!ssl_handshake_hash(s, tls13tbs + TLS13_TBS_PREAMBLE_SIZE,
187                                        EVP_MAX_MD_SIZE, &hashlen)) {
188             return 0;
189         }
190
191         *hdata = tls13tbs;
192         *hdatalen = TLS13_TBS_PREAMBLE_SIZE + hashlen;
193     } else {
194         size_t retlen;
195
196         retlen = BIO_get_mem_data(s->s3->handshake_buffer, hdata);
197         if (retlen <= 0)
198             return 0;
199         *hdatalen = retlen;
200     }
201
202     return 1;
203 }
204
205 int tls_construct_cert_verify(SSL *s, WPACKET *pkt)
206 {
207     EVP_PKEY *pkey = NULL;
208     const EVP_MD *md = NULL;
209     EVP_MD_CTX *mctx = NULL;
210     EVP_PKEY_CTX *pctx = NULL;
211     size_t hdatalen = 0, siglen = 0;
212     void *hdata;
213     unsigned char *sig = NULL;
214     unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE];
215     const SIGALG_LOOKUP *lu = s->s3->tmp.sigalg;
216
217     if (lu == NULL || s->s3->tmp.cert == NULL) {
218         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
219         goto err;
220     }
221     pkey = s->s3->tmp.cert->privatekey;
222     md = ssl_md(lu->hash_idx);
223
224     if (pkey == NULL || md == NULL) {
225         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
226         goto err;
227     }
228
229     mctx = EVP_MD_CTX_new();
230     if (mctx == NULL) {
231         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
232         goto err;
233     }
234
235     /* Get the data to be signed */
236     if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) {
237         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
238         goto err;
239     }
240
241     if (SSL_USE_SIGALGS(s) && !WPACKET_put_bytes_u16(pkt, lu->sigalg)) {
242         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
243         goto err;
244     }
245     siglen = EVP_PKEY_size(pkey);
246     sig = OPENSSL_malloc(siglen);
247     if (sig == NULL) {
248         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
249         goto err;
250     }
251
252     if (EVP_DigestSignInit(mctx, &pctx, md, NULL, pkey) <= 0) {
253         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_EVP_LIB);
254         goto err;
255     }
256
257     if (lu->sig == EVP_PKEY_RSA_PSS) {
258         if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
259             || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
260                                                 RSA_PSS_SALTLEN_DIGEST) <= 0) {
261             SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_EVP_LIB);
262             goto err;
263         }
264     } else if (s->version == SSL3_VERSION) {
265         if (!EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
266                              (int)s->session->master_key_length,
267                              s->session->master_key)) {
268             SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_EVP_LIB);
269             goto err;
270         }
271     }
272
273     if (EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen) <= 0) {
274         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_EVP_LIB);
275         goto err;
276     }
277
278 #ifndef OPENSSL_NO_GOST
279     {
280         int pktype = lu->sig;
281
282         if (pktype == NID_id_GostR3410_2001
283             || pktype == NID_id_GostR3410_2012_256
284             || pktype == NID_id_GostR3410_2012_512)
285             BUF_reverse(sig, NULL, siglen);
286     }
287 #endif
288
289     if (!WPACKET_sub_memcpy_u16(pkt, sig, siglen)) {
290         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
291         goto err;
292     }
293
294     /* Digest cached records and discard handshake buffer */
295     if (!ssl3_digest_cached_records(s, 0))
296         goto err;
297
298     OPENSSL_free(sig);
299     EVP_MD_CTX_free(mctx);
300     return 1;
301  err:
302     OPENSSL_free(sig);
303     EVP_MD_CTX_free(mctx);
304     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
305     return 0;
306 }
307
308 MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
309 {
310     EVP_PKEY *pkey = NULL;
311     const unsigned char *data;
312 #ifndef OPENSSL_NO_GOST
313     unsigned char *gost_data = NULL;
314 #endif
315     int al = SSL_AD_INTERNAL_ERROR, ret = MSG_PROCESS_ERROR;
316     int type = 0, j;
317     unsigned int len;
318     X509 *peer;
319     const EVP_MD *md = NULL;
320     size_t hdatalen = 0;
321     void *hdata;
322     unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE];
323     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
324     EVP_PKEY_CTX *pctx = NULL;
325
326     if (mctx == NULL) {
327         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
328         goto f_err;
329     }
330
331     peer = s->session->peer;
332     pkey = X509_get0_pubkey(peer);
333     if (pkey == NULL) {
334         al = SSL_AD_INTERNAL_ERROR;
335         goto f_err;
336     }
337
338     type = X509_certificate_type(peer, pkey);
339
340     if (!(type & EVP_PKT_SIGN)) {
341         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY,
342                SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
343         al = SSL_AD_ILLEGAL_PARAMETER;
344         goto f_err;
345     }
346
347     /* Check for broken implementations of GOST ciphersuites */
348     /*
349      * If key is GOST and n is exactly 64, it is bare signature without
350      * length field (CryptoPro implementations at least till CSP 4.0)
351      */
352 #ifndef OPENSSL_NO_GOST
353     if (PACKET_remaining(pkt) == 64
354         && EVP_PKEY_id(pkey) == NID_id_GostR3410_2001) {
355         len = 64;
356     } else
357 #endif
358     {
359         if (SSL_USE_SIGALGS(s)) {
360             int rv;
361             unsigned int sigalg;
362
363             if (!PACKET_get_net_2(pkt, &sigalg)) {
364                 al = SSL_AD_DECODE_ERROR;
365                 goto f_err;
366             }
367             rv = tls12_check_peer_sigalg(s, sigalg, pkey);
368             if (rv == -1) {
369                 goto f_err;
370             } else if (rv == 0) {
371                 al = SSL_AD_DECODE_ERROR;
372                 goto f_err;
373             }
374 #ifdef SSL_DEBUG
375             fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
376 #endif
377         } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) {
378                 al = SSL_AD_INTERNAL_ERROR;
379                 goto f_err;
380         }
381
382         md = ssl_md(s->s3->tmp.peer_sigalg->hash_idx);
383
384         if (!PACKET_get_net_2(pkt, &len)) {
385             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
386             al = SSL_AD_DECODE_ERROR;
387             goto f_err;
388         }
389     }
390     j = EVP_PKEY_size(pkey);
391     if (((int)len > j) || ((int)PACKET_remaining(pkt) > j)
392         || (PACKET_remaining(pkt) == 0)) {
393         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_WRONG_SIGNATURE_SIZE);
394         al = SSL_AD_DECODE_ERROR;
395         goto f_err;
396     }
397     if (!PACKET_get_bytes(pkt, &data, len)) {
398         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
399         al = SSL_AD_DECODE_ERROR;
400         goto f_err;
401     }
402
403     if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) {
404         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
405         goto f_err;
406     }
407
408 #ifdef SSL_DEBUG
409     fprintf(stderr, "Using client verify alg %s\n", EVP_MD_name(md));
410 #endif
411     if (EVP_DigestVerifyInit(mctx, &pctx, md, NULL, pkey) <= 0) {
412         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
413         goto f_err;
414     }
415 #ifndef OPENSSL_NO_GOST
416     {
417         int pktype = EVP_PKEY_id(pkey);
418         if (pktype == NID_id_GostR3410_2001
419             || pktype == NID_id_GostR3410_2012_256
420             || pktype == NID_id_GostR3410_2012_512) {
421             if ((gost_data = OPENSSL_malloc(len)) == NULL) {
422                 SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
423                 goto f_err;
424             }
425             BUF_reverse(gost_data, data, len);
426             data = gost_data;
427         }
428     }
429 #endif
430
431     if (SSL_USE_PSS(s)) {
432         if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
433             || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
434                                                 RSA_PSS_SALTLEN_DIGEST) <= 0) {
435             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
436             goto f_err;
437         }
438     } else if (s->version == SSL3_VERSION
439         && !EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
440                             (int)s->session->master_key_length,
441                             s->session->master_key)) {
442         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
443         goto f_err;
444     }
445
446     j = EVP_DigestVerify(mctx, data, len, hdata, hdatalen);
447
448     if (j < 0) {
449         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
450         goto f_err;
451     } else if (j == 0) {
452         al = SSL_AD_DECRYPT_ERROR;
453         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_SIGNATURE);
454         goto f_err;
455     }
456
457     ret = MSG_PROCESS_CONTINUE_READING;
458     if (0) {
459  f_err:
460         ssl3_send_alert(s, SSL3_AL_FATAL, al);
461         ossl_statem_set_error(s);
462     }
463     BIO_free(s->s3->handshake_buffer);
464     s->s3->handshake_buffer = NULL;
465     EVP_MD_CTX_free(mctx);
466 #ifndef OPENSSL_NO_GOST
467     OPENSSL_free(gost_data);
468 #endif
469     return ret;
470 }
471
472 int tls_construct_finished(SSL *s, WPACKET *pkt)
473 {
474     size_t finish_md_len;
475     const char *sender;
476     size_t slen;
477
478     /* This is a real handshake so make sure we clean it up at the end */
479     if (!s->server)
480         s->statem.cleanuphand = 1;
481
482     /*
483      * We only change the keys if we didn't already do this when we sent the
484      * client certificate
485      */
486     if (SSL_IS_TLS13(s)
487             && !s->server
488             && s->s3->tmp.cert_req == 0
489             && (!s->method->ssl3_enc->change_cipher_state(s,
490                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
491         SSLerr(SSL_F_TLS_CONSTRUCT_FINISHED, SSL_R_CANNOT_CHANGE_CIPHER);
492         goto err;
493     }
494
495     if (s->server) {
496         sender = s->method->ssl3_enc->server_finished_label;
497         slen = s->method->ssl3_enc->server_finished_label_len;
498     } else {
499         sender = s->method->ssl3_enc->client_finished_label;
500         slen = s->method->ssl3_enc->client_finished_label_len;
501     }
502
503     finish_md_len = s->method->ssl3_enc->final_finish_mac(s,
504                                                           sender, slen,
505                                                           s->s3->tmp.finish_md);
506     if (finish_md_len == 0) {
507         SSLerr(SSL_F_TLS_CONSTRUCT_FINISHED, ERR_R_INTERNAL_ERROR);
508         goto err;
509     }
510
511     s->s3->tmp.finish_md_len = finish_md_len;
512
513     if (!WPACKET_memcpy(pkt, s->s3->tmp.finish_md, finish_md_len)) {
514         SSLerr(SSL_F_TLS_CONSTRUCT_FINISHED, ERR_R_INTERNAL_ERROR);
515         goto err;
516     }
517
518     /*
519      * Log the master secret, if logging is enabled. We don't log it for
520      * TLSv1.3: there's a different key schedule for that.
521      */
522     if (!SSL_IS_TLS13(s) && !ssl_log_secret(s, MASTER_SECRET_LABEL,
523                                             s->session->master_key,
524                                             s->session->master_key_length))
525         return 0;
526
527     /*
528      * Copy the finished so we can use it for renegotiation checks
529      */
530     if (!s->server) {
531         OPENSSL_assert(finish_md_len <= EVP_MAX_MD_SIZE);
532         memcpy(s->s3->previous_client_finished, s->s3->tmp.finish_md,
533                finish_md_len);
534         s->s3->previous_client_finished_len = finish_md_len;
535     } else {
536         OPENSSL_assert(finish_md_len <= EVP_MAX_MD_SIZE);
537         memcpy(s->s3->previous_server_finished, s->s3->tmp.finish_md,
538                finish_md_len);
539         s->s3->previous_server_finished_len = finish_md_len;
540     }
541
542     return 1;
543  err:
544     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
545     return 0;
546 }
547
548 int tls_construct_key_update(SSL *s, WPACKET *pkt)
549 {
550     if (!WPACKET_put_bytes_u8(pkt, s->key_update)) {
551         SSLerr(SSL_F_TLS_CONSTRUCT_KEY_UPDATE, ERR_R_INTERNAL_ERROR);
552         goto err;
553     }
554
555     s->key_update = SSL_KEY_UPDATE_NONE;
556     return 1;
557
558  err:
559     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
560     return 0;
561 }
562
563 MSG_PROCESS_RETURN tls_process_key_update(SSL *s, PACKET *pkt)
564 {
565     int al;
566     unsigned int updatetype;
567
568     s->key_update_count++;
569     if (s->key_update_count > MAX_KEY_UPDATE_MESSAGES) {
570         al = SSL_AD_ILLEGAL_PARAMETER;
571         SSLerr(SSL_F_TLS_PROCESS_KEY_UPDATE, SSL_R_TOO_MANY_KEY_UPDATES);
572         goto err;
573     }
574
575     /*
576      * A KeyUpdate message signals a key change so the end of the message must
577      * be on a record boundary.
578      */
579     if (RECORD_LAYER_processed_read_pending(&s->rlayer)) {
580         al = SSL_AD_UNEXPECTED_MESSAGE;
581         SSLerr(SSL_F_TLS_PROCESS_KEY_UPDATE, SSL_R_NOT_ON_RECORD_BOUNDARY);
582         goto err;
583     }
584
585     if (!PACKET_get_1(pkt, &updatetype)
586             || PACKET_remaining(pkt) != 0) {
587         al = SSL_AD_DECODE_ERROR;
588         SSLerr(SSL_F_TLS_PROCESS_KEY_UPDATE, SSL_R_BAD_KEY_UPDATE);
589         goto err;
590     }
591
592     if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED
593             && updatetype != SSL_KEY_UPDATE_REQUESTED) {
594         al = SSL_AD_ILLEGAL_PARAMETER;
595         SSLerr(SSL_F_TLS_PROCESS_KEY_UPDATE, SSL_R_BAD_KEY_UPDATE);
596         goto err;
597     }
598
599     /*
600      * If we get a request for us to update our sending keys too then, we need
601      * to additionally send a KeyUpdate message. However that message should
602      * not also request an update (otherwise we get into an infinite loop).
603      */
604     if (updatetype == SSL_KEY_UPDATE_REQUESTED)
605         s->key_update = SSL_KEY_UPDATE_NOT_REQUESTED;
606
607     if (!tls13_update_key(s, 0)) {
608         al = SSL_AD_INTERNAL_ERROR;
609         SSLerr(SSL_F_TLS_PROCESS_KEY_UPDATE, ERR_R_INTERNAL_ERROR);
610         goto err;
611     }
612
613     return MSG_PROCESS_FINISHED_READING;
614  err:
615     ssl3_send_alert(s, SSL3_AL_FATAL, al);
616     ossl_statem_set_error(s);
617     return MSG_PROCESS_ERROR;
618 }
619
620 #ifndef OPENSSL_NO_NEXTPROTONEG
621 /*
622  * ssl3_take_mac calculates the Finished MAC for the handshakes messages seen
623  * to far.
624  */
625 static void ssl3_take_mac(SSL *s)
626 {
627     const char *sender;
628     size_t slen;
629     /*
630      * If no new cipher setup return immediately: other functions will set
631      * the appropriate error.
632      */
633     if (s->s3->tmp.new_cipher == NULL)
634         return;
635     if (!s->server) {
636         sender = s->method->ssl3_enc->server_finished_label;
637         slen = s->method->ssl3_enc->server_finished_label_len;
638     } else {
639         sender = s->method->ssl3_enc->client_finished_label;
640         slen = s->method->ssl3_enc->client_finished_label_len;
641     }
642
643     s->s3->tmp.peer_finish_md_len = s->method->ssl3_enc->final_finish_mac(s,
644                                                                           sender,
645                                                                           slen,
646                                                                           s->s3->tmp.peer_finish_md);
647 }
648 #endif
649
650 MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL *s, PACKET *pkt)
651 {
652     int al;
653     size_t remain;
654
655     remain = PACKET_remaining(pkt);
656     /*
657      * 'Change Cipher Spec' is just a single byte, which should already have
658      * been consumed by ssl_get_message() so there should be no bytes left,
659      * unless we're using DTLS1_BAD_VER, which has an extra 2 bytes
660      */
661     if (SSL_IS_DTLS(s)) {
662         if ((s->version == DTLS1_BAD_VER
663              && remain != DTLS1_CCS_HEADER_LENGTH + 1)
664             || (s->version != DTLS1_BAD_VER
665                 && remain != DTLS1_CCS_HEADER_LENGTH - 1)) {
666             al = SSL_AD_ILLEGAL_PARAMETER;
667             SSLerr(SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC,
668                    SSL_R_BAD_CHANGE_CIPHER_SPEC);
669             goto f_err;
670         }
671     } else {
672         if (remain != 0) {
673             al = SSL_AD_ILLEGAL_PARAMETER;
674             SSLerr(SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC,
675                    SSL_R_BAD_CHANGE_CIPHER_SPEC);
676             goto f_err;
677         }
678     }
679
680     /* Check we have a cipher to change to */
681     if (s->s3->tmp.new_cipher == NULL) {
682         al = SSL_AD_UNEXPECTED_MESSAGE;
683         SSLerr(SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC, SSL_R_CCS_RECEIVED_EARLY);
684         goto f_err;
685     }
686
687     s->s3->change_cipher_spec = 1;
688     if (!ssl3_do_change_cipher_spec(s)) {
689         al = SSL_AD_INTERNAL_ERROR;
690         SSLerr(SSL_F_TLS_PROCESS_CHANGE_CIPHER_SPEC, ERR_R_INTERNAL_ERROR);
691         goto f_err;
692     }
693
694     if (SSL_IS_DTLS(s)) {
695         dtls1_reset_seq_numbers(s, SSL3_CC_READ);
696
697         if (s->version == DTLS1_BAD_VER)
698             s->d1->handshake_read_seq++;
699
700 #ifndef OPENSSL_NO_SCTP
701         /*
702          * Remember that a CCS has been received, so that an old key of
703          * SCTP-Auth can be deleted when a CCS is sent. Will be ignored if no
704          * SCTP is used
705          */
706         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL);
707 #endif
708     }
709
710     return MSG_PROCESS_CONTINUE_READING;
711  f_err:
712     ssl3_send_alert(s, SSL3_AL_FATAL, al);
713     ossl_statem_set_error(s);
714     return MSG_PROCESS_ERROR;
715 }
716
717 MSG_PROCESS_RETURN tls_process_finished(SSL *s, PACKET *pkt)
718 {
719     int al = SSL_AD_INTERNAL_ERROR;
720     size_t md_len;
721
722
723     /* This is a real handshake so make sure we clean it up at the end */
724     if (s->server)
725         s->statem.cleanuphand = 1;
726
727     /*
728      * In TLSv1.3 a Finished message signals a key change so the end of the
729      * message must be on a record boundary.
730      */
731     if (SSL_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
732         al = SSL_AD_UNEXPECTED_MESSAGE;
733         SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_NOT_ON_RECORD_BOUNDARY);
734         goto f_err;
735     }
736
737     /* If this occurs, we have missed a message */
738     if (!SSL_IS_TLS13(s) && !s->s3->change_cipher_spec) {
739         al = SSL_AD_UNEXPECTED_MESSAGE;
740         SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_GOT_A_FIN_BEFORE_A_CCS);
741         goto f_err;
742     }
743     s->s3->change_cipher_spec = 0;
744
745     md_len = s->s3->tmp.peer_finish_md_len;
746
747     if (md_len != PACKET_remaining(pkt)) {
748         al = SSL_AD_DECODE_ERROR;
749         SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_BAD_DIGEST_LENGTH);
750         goto f_err;
751     }
752
753     if (CRYPTO_memcmp(PACKET_data(pkt), s->s3->tmp.peer_finish_md,
754                       md_len) != 0) {
755         al = SSL_AD_DECRYPT_ERROR;
756         SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_DIGEST_CHECK_FAILED);
757         goto f_err;
758     }
759
760     /*
761      * Copy the finished so we can use it for renegotiation checks
762      */
763     if (s->server) {
764         OPENSSL_assert(md_len <= EVP_MAX_MD_SIZE);
765         memcpy(s->s3->previous_client_finished, s->s3->tmp.peer_finish_md,
766                md_len);
767         s->s3->previous_client_finished_len = md_len;
768     } else {
769         OPENSSL_assert(md_len <= EVP_MAX_MD_SIZE);
770         memcpy(s->s3->previous_server_finished, s->s3->tmp.peer_finish_md,
771                md_len);
772         s->s3->previous_server_finished_len = md_len;
773     }
774
775     /*
776      * In TLS1.3 we also have to change cipher state and do any final processing
777      * of the initial server flight (if we are a client)
778      */
779     if (SSL_IS_TLS13(s)) {
780         if (s->server) {
781             if (!s->method->ssl3_enc->change_cipher_state(s,
782                     SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_READ)) {
783                 SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_CANNOT_CHANGE_CIPHER);
784                 goto f_err;
785             }
786         } else {
787             if (!s->method->ssl3_enc->generate_master_secret(s,
788                     s->master_secret, s->handshake_secret, 0,
789                     &s->session->master_key_length)) {
790                 SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_CANNOT_CHANGE_CIPHER);
791                 goto f_err;
792             }
793             if (!s->method->ssl3_enc->change_cipher_state(s,
794                     SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
795                 SSLerr(SSL_F_TLS_PROCESS_FINISHED, SSL_R_CANNOT_CHANGE_CIPHER);
796                 goto f_err;
797             }
798             if (!tls_process_initial_server_flight(s, &al))
799                 goto f_err;
800         }
801     }
802
803     return MSG_PROCESS_FINISHED_READING;
804  f_err:
805     ssl3_send_alert(s, SSL3_AL_FATAL, al);
806     ossl_statem_set_error(s);
807     return MSG_PROCESS_ERROR;
808 }
809
810 int tls_construct_change_cipher_spec(SSL *s, WPACKET *pkt)
811 {
812     if (!WPACKET_put_bytes_u8(pkt, SSL3_MT_CCS)) {
813         SSLerr(SSL_F_TLS_CONSTRUCT_CHANGE_CIPHER_SPEC, ERR_R_INTERNAL_ERROR);
814         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
815         return 0;
816     }
817
818     return 1;
819 }
820
821 /* Add a certificate to the WPACKET */
822 static int ssl_add_cert_to_wpacket(SSL *s, WPACKET *pkt, X509 *x, int chain,
823                                    int *al)
824 {
825     int len;
826     unsigned char *outbytes;
827
828     len = i2d_X509(x, NULL);
829     if (len < 0) {
830         SSLerr(SSL_F_SSL_ADD_CERT_TO_WPACKET, ERR_R_BUF_LIB);
831         *al = SSL_AD_INTERNAL_ERROR;
832         return 0;
833     }
834     if (!WPACKET_sub_allocate_bytes_u24(pkt, len, &outbytes)
835             || i2d_X509(x, &outbytes) != len) {
836         SSLerr(SSL_F_SSL_ADD_CERT_TO_WPACKET, ERR_R_INTERNAL_ERROR);
837         *al = SSL_AD_INTERNAL_ERROR;
838         return 0;
839     }
840
841     if (SSL_IS_TLS13(s)
842             && !tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_CERTIFICATE, x,
843                                          chain, al))
844         return 0;
845
846     return 1;
847 }
848
849 /* Add certificate chain to provided WPACKET */
850 static int ssl_add_cert_chain(SSL *s, WPACKET *pkt, CERT_PKEY *cpk, int *al)
851 {
852     int i, chain_count;
853     X509 *x;
854     STACK_OF(X509) *extra_certs;
855     STACK_OF(X509) *chain = NULL;
856     X509_STORE *chain_store;
857     int tmpal = SSL_AD_INTERNAL_ERROR;
858
859     if (cpk == NULL || cpk->x509 == NULL)
860         return 1;
861
862     x = cpk->x509;
863
864     /*
865      * If we have a certificate specific chain use it, else use parent ctx.
866      */
867     if (cpk->chain != NULL)
868         extra_certs = cpk->chain;
869     else
870         extra_certs = s->ctx->extra_certs;
871
872     if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs)
873         chain_store = NULL;
874     else if (s->cert->chain_store)
875         chain_store = s->cert->chain_store;
876     else
877         chain_store = s->ctx->cert_store;
878
879     if (chain_store != NULL) {
880         X509_STORE_CTX *xs_ctx = X509_STORE_CTX_new();
881
882         if (xs_ctx == NULL) {
883             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_MALLOC_FAILURE);
884             goto err;
885         }
886         if (!X509_STORE_CTX_init(xs_ctx, chain_store, x, NULL)) {
887             X509_STORE_CTX_free(xs_ctx);
888             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, ERR_R_X509_LIB);
889             goto err;
890         }
891         /*
892          * It is valid for the chain not to be complete (because normally we
893          * don't include the root cert in the chain). Therefore we deliberately
894          * ignore the error return from this call. We're not actually verifying
895          * the cert - we're just building as much of the chain as we can
896          */
897         (void)X509_verify_cert(xs_ctx);
898         /* Don't leave errors in the queue */
899         ERR_clear_error();
900         chain = X509_STORE_CTX_get0_chain(xs_ctx);
901         i = ssl_security_cert_chain(s, chain, NULL, 0);
902         if (i != 1) {
903 #if 0
904             /* Dummy error calls so mkerr generates them */
905             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, SSL_R_EE_KEY_TOO_SMALL);
906             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, SSL_R_CA_KEY_TOO_SMALL);
907             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, SSL_R_CA_MD_TOO_WEAK);
908 #endif
909             X509_STORE_CTX_free(xs_ctx);
910             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, i);
911             goto err;
912         }
913         chain_count = sk_X509_num(chain);
914         for (i = 0; i < chain_count; i++) {
915             x = sk_X509_value(chain, i);
916
917             if (!ssl_add_cert_to_wpacket(s, pkt, x, i, &tmpal)) {
918                 X509_STORE_CTX_free(xs_ctx);
919                 goto err;
920             }
921         }
922         X509_STORE_CTX_free(xs_ctx);
923     } else {
924         i = ssl_security_cert_chain(s, extra_certs, x, 0);
925         if (i != 1) {
926             SSLerr(SSL_F_SSL_ADD_CERT_CHAIN, i);
927             goto err;
928         }
929         if (!ssl_add_cert_to_wpacket(s, pkt, x, 0, &tmpal))
930             goto err;
931         for (i = 0; i < sk_X509_num(extra_certs); i++) {
932             x = sk_X509_value(extra_certs, i);
933             if (!ssl_add_cert_to_wpacket(s, pkt, x, i + 1, &tmpal))
934                 goto err;
935         }
936     }
937     return 1;
938
939  err:
940     *al = tmpal;
941     return 0;
942 }
943
944 unsigned long ssl3_output_cert_chain(SSL *s, WPACKET *pkt, CERT_PKEY *cpk,
945                                      int *al)
946 {
947     int tmpal = SSL_AD_INTERNAL_ERROR;
948
949     if (!WPACKET_start_sub_packet_u24(pkt)
950             || !ssl_add_cert_chain(s, pkt, cpk, &tmpal)
951             || !WPACKET_close(pkt)) {
952         SSLerr(SSL_F_SSL3_OUTPUT_CERT_CHAIN, ERR_R_INTERNAL_ERROR);
953         *al = tmpal;
954         return 0;
955     }
956     return 1;
957 }
958
959 /*
960  * Tidy up after the end of a handshake. In the case of SCTP this may result
961  * in NBIO events. If |clearbufs| is set then init_buf and the wbio buffer is
962  * freed up as well.
963  */
964 WORK_STATE tls_finish_handshake(SSL *s, WORK_STATE wst, int clearbufs)
965 {
966     void (*cb) (const SSL *ssl, int type, int val) = NULL;
967
968 #ifndef OPENSSL_NO_SCTP
969     if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
970         WORK_STATE ret;
971         ret = dtls_wait_for_dry(s);
972         if (ret != WORK_FINISHED_CONTINUE)
973             return ret;
974     }
975 #endif
976
977     if (clearbufs) {
978         if (!SSL_IS_DTLS(s)) {
979             /*
980              * We don't do this in DTLS because we may still need the init_buf
981              * in case there are any unexpected retransmits
982              */
983             BUF_MEM_free(s->init_buf);
984             s->init_buf = NULL;
985         }
986         ssl_free_wbio_buffer(s);
987         s->init_num = 0;
988     }
989
990     if (s->statem.cleanuphand) {
991         /* skipped if we just sent a HelloRequest */
992         s->renegotiate = 0;
993         s->new_session = 0;
994         s->statem.cleanuphand = 0;
995
996         ssl3_cleanup_key_block(s);
997
998         if (s->server) {
999             ssl_update_cache(s, SSL_SESS_CACHE_SERVER);
1000
1001             s->ctx->stats.sess_accept_good++;
1002             s->handshake_func = ossl_statem_accept;
1003         } else {
1004             ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
1005             if (s->hit)
1006                 s->ctx->stats.sess_hit++;
1007
1008             s->handshake_func = ossl_statem_connect;
1009             s->ctx->stats.sess_connect_good++;
1010         }
1011
1012         if (s->info_callback != NULL)
1013             cb = s->info_callback;
1014         else if (s->ctx->info_callback != NULL)
1015             cb = s->ctx->info_callback;
1016
1017         if (cb != NULL)
1018             cb(s, SSL_CB_HANDSHAKE_DONE, 1);
1019
1020         if (SSL_IS_DTLS(s)) {
1021             /* done with handshaking */
1022             s->d1->handshake_read_seq = 0;
1023             s->d1->handshake_write_seq = 0;
1024             s->d1->next_handshake_write_seq = 0;
1025             dtls1_clear_received_buffer(s);
1026         }
1027     }
1028
1029     /*
1030      * If we've not cleared the buffers its because we've got more work to do,
1031      * so continue.
1032      */
1033     if (!clearbufs)
1034         return WORK_FINISHED_CONTINUE;
1035
1036     ossl_statem_set_in_init(s, 0);
1037     return WORK_FINISHED_STOP;
1038 }
1039
1040 int tls_get_message_header(SSL *s, int *mt)
1041 {
1042     /* s->init_num < SSL3_HM_HEADER_LENGTH */
1043     int skip_message, i, recvd_type, al;
1044     unsigned char *p;
1045     size_t l, readbytes;
1046
1047     p = (unsigned char *)s->init_buf->data;
1048
1049     do {
1050         while (s->init_num < SSL3_HM_HEADER_LENGTH) {
1051             i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, &recvd_type,
1052                                           &p[s->init_num],
1053                                           SSL3_HM_HEADER_LENGTH - s->init_num,
1054                                           0, &readbytes);
1055             if (i <= 0) {
1056                 s->rwstate = SSL_READING;
1057                 return 0;
1058             }
1059             if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) {
1060                 /*
1061                  * A ChangeCipherSpec must be a single byte and may not occur
1062                  * in the middle of a handshake message.
1063                  */
1064                 if (s->init_num != 0 || readbytes != 1 || p[0] != SSL3_MT_CCS) {
1065                     al = SSL_AD_UNEXPECTED_MESSAGE;
1066                     SSLerr(SSL_F_TLS_GET_MESSAGE_HEADER,
1067                            SSL_R_BAD_CHANGE_CIPHER_SPEC);
1068                     goto f_err;
1069                 }
1070                 s->s3->tmp.message_type = *mt = SSL3_MT_CHANGE_CIPHER_SPEC;
1071                 s->init_num = readbytes - 1;
1072                 s->init_msg = s->init_buf->data;
1073                 s->s3->tmp.message_size = readbytes;
1074                 return 1;
1075             } else if (recvd_type != SSL3_RT_HANDSHAKE) {
1076                 al = SSL_AD_UNEXPECTED_MESSAGE;
1077                 SSLerr(SSL_F_TLS_GET_MESSAGE_HEADER, SSL_R_CCS_RECEIVED_EARLY);
1078                 goto f_err;
1079             }
1080             s->init_num += readbytes;
1081         }
1082
1083         skip_message = 0;
1084         if (!s->server)
1085             if (s->statem.hand_state != TLS_ST_OK
1086                     && p[0] == SSL3_MT_HELLO_REQUEST)
1087                 /*
1088                  * The server may always send 'Hello Request' messages --
1089                  * we are doing a handshake anyway now, so ignore them if
1090                  * their format is correct. Does not count for 'Finished'
1091                  * MAC.
1092                  */
1093                 if (p[1] == 0 && p[2] == 0 && p[3] == 0) {
1094                     s->init_num = 0;
1095                     skip_message = 1;
1096
1097                     if (s->msg_callback)
1098                         s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
1099                                         p, SSL3_HM_HEADER_LENGTH, s,
1100                                         s->msg_callback_arg);
1101                 }
1102     } while (skip_message);
1103     /* s->init_num == SSL3_HM_HEADER_LENGTH */
1104
1105     *mt = *p;
1106     s->s3->tmp.message_type = *(p++);
1107
1108     if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) {
1109         /*
1110          * Only happens with SSLv3+ in an SSLv2 backward compatible
1111          * ClientHello
1112          *
1113          * Total message size is the remaining record bytes to read
1114          * plus the SSL3_HM_HEADER_LENGTH bytes that we already read
1115          */
1116         l = RECORD_LAYER_get_rrec_length(&s->rlayer)
1117             + SSL3_HM_HEADER_LENGTH;
1118         s->s3->tmp.message_size = l;
1119
1120         s->init_msg = s->init_buf->data;
1121         s->init_num = SSL3_HM_HEADER_LENGTH;
1122     } else {
1123         n2l3(p, l);
1124         /* BUF_MEM_grow takes an 'int' parameter */
1125         if (l > (INT_MAX - SSL3_HM_HEADER_LENGTH)) {
1126             al = SSL_AD_ILLEGAL_PARAMETER;
1127             SSLerr(SSL_F_TLS_GET_MESSAGE_HEADER, SSL_R_EXCESSIVE_MESSAGE_SIZE);
1128             goto f_err;
1129         }
1130         s->s3->tmp.message_size = l;
1131
1132         s->init_msg = s->init_buf->data + SSL3_HM_HEADER_LENGTH;
1133         s->init_num = 0;
1134     }
1135
1136     return 1;
1137  f_err:
1138     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1139     return 0;
1140 }
1141
1142 int tls_get_message_body(SSL *s, size_t *len)
1143 {
1144     size_t n, readbytes;
1145     unsigned char *p;
1146     int i;
1147
1148     if (s->s3->tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC) {
1149         /* We've already read everything in */
1150         *len = (unsigned long)s->init_num;
1151         return 1;
1152     }
1153
1154     p = s->init_msg;
1155     n = s->s3->tmp.message_size - s->init_num;
1156     while (n > 0) {
1157         i = s->method->ssl_read_bytes(s, SSL3_RT_HANDSHAKE, NULL,
1158                                       &p[s->init_num], n, 0, &readbytes);
1159         if (i <= 0) {
1160             s->rwstate = SSL_READING;
1161             *len = 0;
1162             return 0;
1163         }
1164         s->init_num += readbytes;
1165         n -= readbytes;
1166     }
1167
1168 #ifndef OPENSSL_NO_NEXTPROTONEG
1169     /*
1170      * If receiving Finished, record MAC of prior handshake messages for
1171      * Finished verification.
1172      */
1173     if (*s->init_buf->data == SSL3_MT_FINISHED)
1174         ssl3_take_mac(s);
1175 #endif
1176
1177     /* Feed this message into MAC computation. */
1178     if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) {
1179         if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
1180                              s->init_num)) {
1181             SSLerr(SSL_F_TLS_GET_MESSAGE_BODY, ERR_R_EVP_LIB);
1182             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
1183             *len = 0;
1184             return 0;
1185         }
1186         if (s->msg_callback)
1187             s->msg_callback(0, SSL2_VERSION, 0, s->init_buf->data,
1188                             (size_t)s->init_num, s, s->msg_callback_arg);
1189     } else {
1190         /*
1191          * We defer feeding in the HRR until later. We'll do it as part of
1192          * processing the message
1193          */
1194         if (s->s3->tmp.message_type != SSL3_MT_HELLO_RETRY_REQUEST
1195                 && !ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
1196                                     s->init_num + SSL3_HM_HEADER_LENGTH)) {
1197             SSLerr(SSL_F_TLS_GET_MESSAGE_BODY, ERR_R_EVP_LIB);
1198             ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
1199             *len = 0;
1200             return 0;
1201         }
1202         if (s->msg_callback)
1203             s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data,
1204                             (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, s,
1205                             s->msg_callback_arg);
1206     }
1207
1208     *len = s->init_num;
1209     return 1;
1210 }
1211
1212 int ssl_cert_type(const X509 *x, const EVP_PKEY *pk)
1213 {
1214     if (pk == NULL && (pk = X509_get0_pubkey(x)) == NULL)
1215         return -1;
1216
1217     switch (EVP_PKEY_id(pk)) {
1218     default:
1219         return -1;
1220     case EVP_PKEY_RSA:
1221         return SSL_PKEY_RSA;
1222     case EVP_PKEY_DSA:
1223         return SSL_PKEY_DSA_SIGN;
1224 #ifndef OPENSSL_NO_EC
1225     case EVP_PKEY_EC:
1226         return SSL_PKEY_ECC;
1227 #endif
1228 #ifndef OPENSSL_NO_GOST
1229     case NID_id_GostR3410_2001:
1230         return SSL_PKEY_GOST01;
1231     case NID_id_GostR3410_2012_256:
1232         return SSL_PKEY_GOST12_256;
1233     case NID_id_GostR3410_2012_512:
1234         return SSL_PKEY_GOST12_512;
1235 #endif
1236     }
1237 }
1238
1239 int ssl_verify_alarm_type(long type)
1240 {
1241     int al;
1242
1243     switch (type) {
1244     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT:
1245     case X509_V_ERR_UNABLE_TO_GET_CRL:
1246     case X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER:
1247         al = SSL_AD_UNKNOWN_CA;
1248         break;
1249     case X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE:
1250     case X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE:
1251     case X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
1252     case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD:
1253     case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD:
1254     case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD:
1255     case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD:
1256     case X509_V_ERR_CERT_NOT_YET_VALID:
1257     case X509_V_ERR_CRL_NOT_YET_VALID:
1258     case X509_V_ERR_CERT_UNTRUSTED:
1259     case X509_V_ERR_CERT_REJECTED:
1260     case X509_V_ERR_HOSTNAME_MISMATCH:
1261     case X509_V_ERR_EMAIL_MISMATCH:
1262     case X509_V_ERR_IP_ADDRESS_MISMATCH:
1263     case X509_V_ERR_DANE_NO_MATCH:
1264     case X509_V_ERR_EE_KEY_TOO_SMALL:
1265     case X509_V_ERR_CA_KEY_TOO_SMALL:
1266     case X509_V_ERR_CA_MD_TOO_WEAK:
1267         al = SSL_AD_BAD_CERTIFICATE;
1268         break;
1269     case X509_V_ERR_CERT_SIGNATURE_FAILURE:
1270     case X509_V_ERR_CRL_SIGNATURE_FAILURE:
1271         al = SSL_AD_DECRYPT_ERROR;
1272         break;
1273     case X509_V_ERR_CERT_HAS_EXPIRED:
1274     case X509_V_ERR_CRL_HAS_EXPIRED:
1275         al = SSL_AD_CERTIFICATE_EXPIRED;
1276         break;
1277     case X509_V_ERR_CERT_REVOKED:
1278         al = SSL_AD_CERTIFICATE_REVOKED;
1279         break;
1280     case X509_V_ERR_UNSPECIFIED:
1281     case X509_V_ERR_OUT_OF_MEM:
1282     case X509_V_ERR_INVALID_CALL:
1283     case X509_V_ERR_STORE_LOOKUP:
1284         al = SSL_AD_INTERNAL_ERROR;
1285         break;
1286     case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
1287     case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
1288     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
1289     case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
1290     case X509_V_ERR_CERT_CHAIN_TOO_LONG:
1291     case X509_V_ERR_PATH_LENGTH_EXCEEDED:
1292     case X509_V_ERR_INVALID_CA:
1293         al = SSL_AD_UNKNOWN_CA;
1294         break;
1295     case X509_V_ERR_APPLICATION_VERIFICATION:
1296         al = SSL_AD_HANDSHAKE_FAILURE;
1297         break;
1298     case X509_V_ERR_INVALID_PURPOSE:
1299         al = SSL_AD_UNSUPPORTED_CERTIFICATE;
1300         break;
1301     default:
1302         al = SSL_AD_CERTIFICATE_UNKNOWN;
1303         break;
1304     }
1305     return (al);
1306 }
1307
1308 int ssl_allow_compression(SSL *s)
1309 {
1310     if (s->options & SSL_OP_NO_COMPRESSION)
1311         return 0;
1312     return ssl_security(s, SSL_SECOP_COMPRESSION, 0, 0, NULL);
1313 }
1314
1315 static int version_cmp(const SSL *s, int a, int b)
1316 {
1317     int dtls = SSL_IS_DTLS(s);
1318
1319     if (a == b)
1320         return 0;
1321     if (!dtls)
1322         return a < b ? -1 : 1;
1323     return DTLS_VERSION_LT(a, b) ? -1 : 1;
1324 }
1325
1326 typedef struct {
1327     int version;
1328     const SSL_METHOD *(*cmeth) (void);
1329     const SSL_METHOD *(*smeth) (void);
1330 } version_info;
1331
1332 #if TLS_MAX_VERSION != TLS1_3_VERSION
1333 # error Code needs update for TLS_method() support beyond TLS1_3_VERSION.
1334 #endif
1335
1336 /* Must be in order high to low */
1337 static const version_info tls_version_table[] = {
1338 #ifndef OPENSSL_NO_TLS1_3
1339     {TLS1_3_VERSION, tlsv1_3_client_method, tlsv1_3_server_method},
1340 #else
1341     {TLS1_3_VERSION, NULL, NULL},
1342 #endif
1343 #ifndef OPENSSL_NO_TLS1_2
1344     {TLS1_2_VERSION, tlsv1_2_client_method, tlsv1_2_server_method},
1345 #else
1346     {TLS1_2_VERSION, NULL, NULL},
1347 #endif
1348 #ifndef OPENSSL_NO_TLS1_1
1349     {TLS1_1_VERSION, tlsv1_1_client_method, tlsv1_1_server_method},
1350 #else
1351     {TLS1_1_VERSION, NULL, NULL},
1352 #endif
1353 #ifndef OPENSSL_NO_TLS1
1354     {TLS1_VERSION, tlsv1_client_method, tlsv1_server_method},
1355 #else
1356     {TLS1_VERSION, NULL, NULL},
1357 #endif
1358 #ifndef OPENSSL_NO_SSL3
1359     {SSL3_VERSION, sslv3_client_method, sslv3_server_method},
1360 #else
1361     {SSL3_VERSION, NULL, NULL},
1362 #endif
1363     {0, NULL, NULL},
1364 };
1365
1366 #if DTLS_MAX_VERSION != DTLS1_2_VERSION
1367 # error Code needs update for DTLS_method() support beyond DTLS1_2_VERSION.
1368 #endif
1369
1370 /* Must be in order high to low */
1371 static const version_info dtls_version_table[] = {
1372 #ifndef OPENSSL_NO_DTLS1_2
1373     {DTLS1_2_VERSION, dtlsv1_2_client_method, dtlsv1_2_server_method},
1374 #else
1375     {DTLS1_2_VERSION, NULL, NULL},
1376 #endif
1377 #ifndef OPENSSL_NO_DTLS1
1378     {DTLS1_VERSION, dtlsv1_client_method, dtlsv1_server_method},
1379     {DTLS1_BAD_VER, dtls_bad_ver_client_method, NULL},
1380 #else
1381     {DTLS1_VERSION, NULL, NULL},
1382     {DTLS1_BAD_VER, NULL, NULL},
1383 #endif
1384     {0, NULL, NULL},
1385 };
1386
1387 /*
1388  * ssl_method_error - Check whether an SSL_METHOD is enabled.
1389  *
1390  * @s: The SSL handle for the candidate method
1391  * @method: the intended method.
1392  *
1393  * Returns 0 on success, or an SSL error reason on failure.
1394  */
1395 static int ssl_method_error(const SSL *s, const SSL_METHOD *method)
1396 {
1397     int version = method->version;
1398
1399     if ((s->min_proto_version != 0 &&
1400          version_cmp(s, version, s->min_proto_version) < 0) ||
1401         ssl_security(s, SSL_SECOP_VERSION, 0, version, NULL) == 0)
1402         return SSL_R_VERSION_TOO_LOW;
1403
1404     if (s->max_proto_version != 0 &&
1405         version_cmp(s, version, s->max_proto_version) > 0)
1406         return SSL_R_VERSION_TOO_HIGH;
1407
1408     if ((s->options & method->mask) != 0)
1409         return SSL_R_UNSUPPORTED_PROTOCOL;
1410     if ((method->flags & SSL_METHOD_NO_SUITEB) != 0 && tls1_suiteb(s))
1411         return SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE;
1412
1413     return 0;
1414 }
1415
1416 /*
1417  * ssl_version_supported - Check that the specified `version` is supported by
1418  * `SSL *` instance
1419  *
1420  * @s: The SSL handle for the candidate method
1421  * @version: Protocol version to test against
1422  *
1423  * Returns 1 when supported, otherwise 0
1424  */
1425 int ssl_version_supported(const SSL *s, int version)
1426 {
1427     const version_info *vent;
1428     const version_info *table;
1429
1430     switch (s->method->version) {
1431     default:
1432         /* Version should match method version for non-ANY method */
1433         return version_cmp(s, version, s->version) == 0;
1434     case TLS_ANY_VERSION:
1435         table = tls_version_table;
1436         break;
1437     case DTLS_ANY_VERSION:
1438         table = dtls_version_table;
1439         break;
1440     }
1441
1442     for (vent = table;
1443          vent->version != 0 && version_cmp(s, version, vent->version) <= 0;
1444          ++vent) {
1445         if (vent->cmeth != NULL &&
1446             version_cmp(s, version, vent->version) == 0 &&
1447             ssl_method_error(s, vent->cmeth()) == 0) {
1448             return 1;
1449         }
1450     }
1451     return 0;
1452 }
1453
1454 /*
1455  * ssl_check_version_downgrade - In response to RFC7507 SCSV version
1456  * fallback indication from a client check whether we're using the highest
1457  * supported protocol version.
1458  *
1459  * @s server SSL handle.
1460  *
1461  * Returns 1 when using the highest enabled version, 0 otherwise.
1462  */
1463 int ssl_check_version_downgrade(SSL *s)
1464 {
1465     const version_info *vent;
1466     const version_info *table;
1467
1468     /*
1469      * Check that the current protocol is the highest enabled version
1470      * (according to s->ctx->method, as version negotiation may have changed
1471      * s->method).
1472      */
1473     if (s->version == s->ctx->method->version)
1474         return 1;
1475
1476     /*
1477      * Apparently we're using a version-flexible SSL_METHOD (not at its
1478      * highest protocol version).
1479      */
1480     if (s->ctx->method->version == TLS_method()->version)
1481         table = tls_version_table;
1482     else if (s->ctx->method->version == DTLS_method()->version)
1483         table = dtls_version_table;
1484     else {
1485         /* Unexpected state; fail closed. */
1486         return 0;
1487     }
1488
1489     for (vent = table; vent->version != 0; ++vent) {
1490         if (vent->smeth != NULL && ssl_method_error(s, vent->smeth()) == 0)
1491             return s->version == vent->version;
1492     }
1493     return 0;
1494 }
1495
1496 /*
1497  * ssl_set_version_bound - set an upper or lower bound on the supported (D)TLS
1498  * protocols, provided the initial (D)TLS method is version-flexible.  This
1499  * function sanity-checks the proposed value and makes sure the method is
1500  * version-flexible, then sets the limit if all is well.
1501  *
1502  * @method_version: The version of the current SSL_METHOD.
1503  * @version: the intended limit.
1504  * @bound: pointer to limit to be updated.
1505  *
1506  * Returns 1 on success, 0 on failure.
1507  */
1508 int ssl_set_version_bound(int method_version, int version, int *bound)
1509 {
1510     if (version == 0) {
1511         *bound = version;
1512         return 1;
1513     }
1514
1515     /*-
1516      * Restrict TLS methods to TLS protocol versions.
1517      * Restrict DTLS methods to DTLS protocol versions.
1518      * Note, DTLS version numbers are decreasing, use comparison macros.
1519      *
1520      * Note that for both lower-bounds we use explicit versions, not
1521      * (D)TLS_MIN_VERSION.  This is because we don't want to break user
1522      * configurations.  If the MIN (supported) version ever rises, the user's
1523      * "floor" remains valid even if no longer available.  We don't expect the
1524      * MAX ceiling to ever get lower, so making that variable makes sense.
1525      */
1526     switch (method_version) {
1527     default:
1528         /*
1529          * XXX For fixed version methods, should we always fail and not set any
1530          * bounds, always succeed and not set any bounds, or set the bounds and
1531          * arrange to fail later if they are not met?  At present fixed-version
1532          * methods are not subject to controls that disable individual protocol
1533          * versions.
1534          */
1535         return 0;
1536
1537     case TLS_ANY_VERSION:
1538         if (version < SSL3_VERSION || version > TLS_MAX_VERSION)
1539             return 0;
1540         break;
1541
1542     case DTLS_ANY_VERSION:
1543         if (DTLS_VERSION_GT(version, DTLS_MAX_VERSION) ||
1544             DTLS_VERSION_LT(version, DTLS1_BAD_VER))
1545             return 0;
1546         break;
1547     }
1548
1549     *bound = version;
1550     return 1;
1551 }
1552
1553 static void check_for_downgrade(SSL *s, int vers, DOWNGRADE *dgrd)
1554 {
1555     if (vers == TLS1_2_VERSION
1556             && ssl_version_supported(s, TLS1_3_VERSION)) {
1557         *dgrd = DOWNGRADE_TO_1_2;
1558     } else if (!SSL_IS_DTLS(s) && vers < TLS1_2_VERSION
1559             && (ssl_version_supported(s, TLS1_2_VERSION)
1560                 || ssl_version_supported(s, TLS1_3_VERSION))) {
1561         *dgrd = DOWNGRADE_TO_1_1;
1562     } else {
1563         *dgrd = DOWNGRADE_NONE;
1564     }
1565 }
1566
1567 /*
1568  * ssl_choose_server_version - Choose server (D)TLS version.  Called when the
1569  * client HELLO is received to select the final server protocol version and
1570  * the version specific method.
1571  *
1572  * @s: server SSL handle.
1573  *
1574  * Returns 0 on success or an SSL error reason number on failure.
1575  */
1576 int ssl_choose_server_version(SSL *s, CLIENTHELLO_MSG *hello, DOWNGRADE *dgrd)
1577 {
1578     /*-
1579      * With version-flexible methods we have an initial state with:
1580      *
1581      *   s->method->version == (D)TLS_ANY_VERSION,
1582      *   s->version == (D)TLS_MAX_VERSION.
1583      *
1584      * So we detect version-flexible methods via the method version, not the
1585      * handle version.
1586      */
1587     int server_version = s->method->version;
1588     int client_version = hello->legacy_version;
1589     const version_info *vent;
1590     const version_info *table;
1591     int disabled = 0;
1592     RAW_EXTENSION *suppversions;
1593
1594     s->client_version = client_version;
1595
1596     switch (server_version) {
1597     default:
1598         if (!SSL_IS_TLS13(s)) {
1599             if (version_cmp(s, client_version, s->version) < 0)
1600                 return SSL_R_WRONG_SSL_VERSION;
1601             *dgrd = DOWNGRADE_NONE;
1602             /*
1603              * If this SSL handle is not from a version flexible method we don't
1604              * (and never did) check min/max FIPS or Suite B constraints.  Hope
1605              * that's OK.  It is up to the caller to not choose fixed protocol
1606              * versions they don't want.  If not, then easy to fix, just return
1607              * ssl_method_error(s, s->method)
1608              */
1609             return 0;
1610         }
1611         /*
1612          * Fall through if we are TLSv1.3 already (this means we must be after
1613          * a HelloRetryRequest
1614          */
1615     case TLS_ANY_VERSION:
1616         table = tls_version_table;
1617         break;
1618     case DTLS_ANY_VERSION:
1619         table = dtls_version_table;
1620         break;
1621     }
1622
1623     suppversions = &hello->pre_proc_exts[TLSEXT_IDX_supported_versions];
1624
1625     if (suppversions->present && !SSL_IS_DTLS(s)) {
1626         unsigned int candidate_vers = 0;
1627         unsigned int best_vers = 0;
1628         const SSL_METHOD *best_method = NULL;
1629         PACKET versionslist;
1630
1631         suppversions->parsed = 1;
1632
1633         if (!PACKET_as_length_prefixed_1(&suppversions->data, &versionslist)) {
1634             /* Trailing or invalid data? */
1635             return SSL_R_LENGTH_MISMATCH;
1636         }
1637
1638         while (PACKET_get_net_2(&versionslist, &candidate_vers)) {
1639             /* TODO(TLS1.3): Remove this before release */
1640             if (candidate_vers == TLS1_3_VERSION_DRAFT)
1641                 candidate_vers = TLS1_3_VERSION;
1642             /*
1643              * TODO(TLS1.3): There is some discussion on the TLS list about
1644              * whether to ignore versions <TLS1.2 in supported_versions. At the
1645              * moment we honour them if present. To be reviewed later
1646              */
1647             if (version_cmp(s, candidate_vers, best_vers) <= 0)
1648                 continue;
1649             for (vent = table;
1650                  vent->version != 0 && vent->version != (int)candidate_vers;
1651                  ++vent)
1652                 continue;
1653             if (vent->version != 0 && vent->smeth != NULL) {
1654                 const SSL_METHOD *method;
1655
1656                 method = vent->smeth();
1657                 if (ssl_method_error(s, method) == 0) {
1658                     best_vers = candidate_vers;
1659                     best_method = method;
1660                 }
1661             }
1662         }
1663         if (PACKET_remaining(&versionslist) != 0) {
1664             /* Trailing data? */
1665             return SSL_R_LENGTH_MISMATCH;
1666         }
1667
1668         if (best_vers > 0) {
1669             if (SSL_IS_TLS13(s)) {
1670                 /*
1671                  * We get here if this is after a HelloRetryRequest. In this
1672                  * case we just check that we still negotiated TLSv1.3
1673                  */
1674                 if (best_vers != TLS1_3_VERSION)
1675                     return SSL_R_UNSUPPORTED_PROTOCOL;
1676                 return 0;
1677             }
1678             check_for_downgrade(s, best_vers, dgrd);
1679             s->version = best_vers;
1680             s->method = best_method;
1681             return 0;
1682         }
1683         return SSL_R_UNSUPPORTED_PROTOCOL;
1684     }
1685
1686     /*
1687      * If the supported versions extension isn't present, then the highest
1688      * version we can negotiate is TLSv1.2
1689      */
1690     if (version_cmp(s, client_version, TLS1_3_VERSION) >= 0)
1691         client_version = TLS1_2_VERSION;
1692
1693     /*
1694      * No supported versions extension, so we just use the version supplied in
1695      * the ClientHello.
1696      */
1697     for (vent = table; vent->version != 0; ++vent) {
1698         const SSL_METHOD *method;
1699
1700         if (vent->smeth == NULL ||
1701             version_cmp(s, client_version, vent->version) < 0)
1702             continue;
1703         method = vent->smeth();
1704         if (ssl_method_error(s, method) == 0) {
1705             check_for_downgrade(s, vent->version, dgrd);
1706             s->version = vent->version;
1707             s->method = method;
1708             return 0;
1709         }
1710         disabled = 1;
1711     }
1712     return disabled ? SSL_R_UNSUPPORTED_PROTOCOL : SSL_R_VERSION_TOO_LOW;
1713 }
1714
1715 /*
1716  * ssl_choose_client_version - Choose client (D)TLS version.  Called when the
1717  * server HELLO is received to select the final client protocol version and
1718  * the version specific method.
1719  *
1720  * @s: client SSL handle.
1721  * @version: The proposed version from the server's HELLO.
1722  * @checkdgrd: Whether to check the downgrade sentinels in the server_random
1723  * @al: Where to store any alert value that may be generated
1724  *
1725  * Returns 0 on success or an SSL error reason number on failure.
1726  */
1727 int ssl_choose_client_version(SSL *s, int version, int checkdgrd, int *al)
1728 {
1729     const version_info *vent;
1730     const version_info *table;
1731     int highver = 0;
1732
1733     /* TODO(TLS1.3): Remove this before release */
1734     if (version == TLS1_3_VERSION_DRAFT)
1735         version = TLS1_3_VERSION;
1736
1737     if (s->hello_retry_request && version != TLS1_3_VERSION) {
1738         *al = SSL_AD_PROTOCOL_VERSION;
1739         return SSL_R_WRONG_SSL_VERSION;
1740     }
1741
1742     switch (s->method->version) {
1743     default:
1744         if (version != s->version) {
1745             *al = SSL_AD_PROTOCOL_VERSION;
1746             return SSL_R_WRONG_SSL_VERSION;
1747         }
1748         /*
1749          * If this SSL handle is not from a version flexible method we don't
1750          * (and never did) check min/max, FIPS or Suite B constraints.  Hope
1751          * that's OK.  It is up to the caller to not choose fixed protocol
1752          * versions they don't want.  If not, then easy to fix, just return
1753          * ssl_method_error(s, s->method)
1754          */
1755         return 0;
1756     case TLS_ANY_VERSION:
1757         table = tls_version_table;
1758         break;
1759     case DTLS_ANY_VERSION:
1760         table = dtls_version_table;
1761         break;
1762     }
1763
1764     for (vent = table; vent->version != 0; ++vent) {
1765         const SSL_METHOD *method;
1766         int err;
1767
1768         if (vent->cmeth == NULL)
1769             continue;
1770
1771         if (highver != 0 && version != vent->version)
1772             continue;
1773
1774         method = vent->cmeth();
1775         err = ssl_method_error(s, method);
1776         if (err != 0) {
1777             if (version == vent->version) {
1778                 *al = SSL_AD_PROTOCOL_VERSION;
1779                 return err;
1780             }
1781
1782             continue;
1783         }
1784         if (highver == 0)
1785             highver = vent->version;
1786
1787         if (version != vent->version)
1788             continue;
1789
1790 #ifndef OPENSSL_NO_TLS13DOWNGRADE
1791         /* Check for downgrades */
1792         if (checkdgrd) {
1793             if (version == TLS1_2_VERSION && highver > version) {
1794                 if (memcmp(tls12downgrade,
1795                            s->s3->server_random + SSL3_RANDOM_SIZE
1796                                                 - sizeof(tls12downgrade),
1797                            sizeof(tls12downgrade)) == 0) {
1798                     *al = SSL_AD_ILLEGAL_PARAMETER;
1799                     return SSL_R_INAPPROPRIATE_FALLBACK;
1800                 }
1801             } else if (!SSL_IS_DTLS(s)
1802                        && version < TLS1_2_VERSION
1803                        && highver > version) {
1804                 if (memcmp(tls11downgrade,
1805                            s->s3->server_random + SSL3_RANDOM_SIZE
1806                                                 - sizeof(tls11downgrade),
1807                            sizeof(tls11downgrade)) == 0) {
1808                     *al = SSL_AD_ILLEGAL_PARAMETER;
1809                     return SSL_R_INAPPROPRIATE_FALLBACK;
1810                 }
1811             }
1812         }
1813 #endif
1814
1815         s->method = method;
1816         s->version = version;
1817         return 0;
1818     }
1819
1820     *al = SSL_AD_PROTOCOL_VERSION;
1821     return SSL_R_UNSUPPORTED_PROTOCOL;
1822 }
1823
1824 /*
1825  * ssl_get_min_max_version - get minimum and maximum protocol version
1826  * @s: The SSL connection
1827  * @min_version: The minimum supported version
1828  * @max_version: The maximum supported version
1829  *
1830  * Work out what version we should be using for the initial ClientHello if the
1831  * version is initially (D)TLS_ANY_VERSION.  We apply any explicit SSL_OP_NO_xxx
1832  * options, the MinProtocol and MaxProtocol configuration commands, any Suite B
1833  * constraints and any floor imposed by the security level here,
1834  * so we don't advertise the wrong protocol version to only reject the outcome later.
1835  *
1836  * Computing the right floor matters.  If, e.g., TLS 1.0 and 1.2 are enabled,
1837  * TLS 1.1 is disabled, but the security level, Suite-B  and/or MinProtocol
1838  * only allow TLS 1.2, we want to advertise TLS1.2, *not* TLS1.
1839  *
1840  * Returns 0 on success or an SSL error reason number on failure.  On failure
1841  * min_version and max_version will also be set to 0.
1842  */
1843 int ssl_get_min_max_version(const SSL *s, int *min_version, int *max_version)
1844 {
1845     int version;
1846     int hole;
1847     const SSL_METHOD *single = NULL;
1848     const SSL_METHOD *method;
1849     const version_info *table;
1850     const version_info *vent;
1851
1852     switch (s->method->version) {
1853     default:
1854         /*
1855          * If this SSL handle is not from a version flexible method we don't
1856          * (and never did) check min/max FIPS or Suite B constraints.  Hope
1857          * that's OK.  It is up to the caller to not choose fixed protocol
1858          * versions they don't want.  If not, then easy to fix, just return
1859          * ssl_method_error(s, s->method)
1860          */
1861         *min_version = *max_version = s->version;
1862         return 0;
1863     case TLS_ANY_VERSION:
1864         table = tls_version_table;
1865         break;
1866     case DTLS_ANY_VERSION:
1867         table = dtls_version_table;
1868         break;
1869     }
1870
1871     /*
1872      * SSL_OP_NO_X disables all protocols above X *if* there are some protocols
1873      * below X enabled. This is required in order to maintain the "version
1874      * capability" vector contiguous. Any versions with a NULL client method
1875      * (protocol version client is disabled at compile-time) is also a "hole".
1876      *
1877      * Our initial state is hole == 1, version == 0.  That is, versions above
1878      * the first version in the method table are disabled (a "hole" above
1879      * the valid protocol entries) and we don't have a selected version yet.
1880      *
1881      * Whenever "hole == 1", and we hit an enabled method, its version becomes
1882      * the selected version, and the method becomes a candidate "single"
1883      * method.  We're no longer in a hole, so "hole" becomes 0.
1884      *
1885      * If "hole == 0" and we hit an enabled method, then "single" is cleared,
1886      * as we support a contiguous range of at least two methods.  If we hit
1887      * a disabled method, then hole becomes true again, but nothing else
1888      * changes yet, because all the remaining methods may be disabled too.
1889      * If we again hit an enabled method after the new hole, it becomes
1890      * selected, as we start from scratch.
1891      */
1892     *min_version = version = 0;
1893     hole = 1;
1894     for (vent = table; vent->version != 0; ++vent) {
1895         /*
1896          * A table entry with a NULL client method is still a hole in the
1897          * "version capability" vector.
1898          */
1899         if (vent->cmeth == NULL) {
1900             hole = 1;
1901             continue;
1902         }
1903         method = vent->cmeth();
1904         if (ssl_method_error(s, method) != 0) {
1905             hole = 1;
1906         } else if (!hole) {
1907             single = NULL;
1908             *min_version = method->version;
1909         } else {
1910             version = (single = method)->version;
1911             *min_version = version;
1912             hole = 0;
1913         }
1914     }
1915
1916     *max_version = version;
1917
1918     /* Fail if everything is disabled */
1919     if (version == 0)
1920         return SSL_R_NO_PROTOCOLS_AVAILABLE;
1921
1922     return 0;
1923 }
1924
1925 /*
1926  * ssl_set_client_hello_version - Work out what version we should be using for
1927  * the initial ClientHello.legacy_version field.
1928  *
1929  * @s: client SSL handle.
1930  *
1931  * Returns 0 on success or an SSL error reason number on failure.
1932  */
1933 int ssl_set_client_hello_version(SSL *s)
1934 {
1935     int ver_min, ver_max, ret;
1936
1937     ret = ssl_get_min_max_version(s, &ver_min, &ver_max);
1938
1939     if (ret != 0)
1940         return ret;
1941
1942     s->version = ver_max;
1943
1944     /* TLS1.3 always uses TLS1.2 in the legacy_version field */
1945     if (!SSL_IS_DTLS(s) && ver_max > TLS1_2_VERSION)
1946         ver_max = TLS1_2_VERSION;
1947
1948     s->client_version = ver_max;
1949     return 0;
1950 }
1951
1952 /*
1953  * Checks a list of |groups| to determine if the |group_id| is in it. If it is
1954  * and |checkallow| is 1 then additionally check if the group is allowed to be
1955  * used. Returns 1 if the group is in the list (and allowed if |checkallow| is
1956  * 1) or 0 otherwise.
1957  */
1958 #ifndef OPENSSL_NO_EC
1959 int check_in_list(SSL *s, unsigned int group_id, const unsigned char *groups,
1960                   size_t num_groups, int checkallow)
1961 {
1962     size_t i;
1963
1964     if (groups == NULL || num_groups == 0)
1965         return 0;
1966
1967     for (i = 0; i < num_groups; i++, groups += 2) {
1968         if (group_id == GET_GROUP_ID(groups, 0)
1969                 && (!checkallow
1970                     || tls_curve_allowed(s, groups, SSL_SECOP_CURVE_CHECK))) {
1971             return 1;
1972         }
1973     }
1974
1975     return 0;
1976 }
1977 #endif
1978
1979 /* Replace ClientHello1 in the transcript hash with a synthetic message */
1980 int create_synthetic_message_hash(SSL *s)
1981 {
1982     unsigned char hashval[EVP_MAX_MD_SIZE];
1983     size_t hashlen = 0;
1984     unsigned char msghdr[SSL3_HM_HEADER_LENGTH];
1985
1986     memset(msghdr, 0, sizeof(msghdr));
1987
1988     /* Get the hash of the initial ClientHello */
1989     if (!ssl3_digest_cached_records(s, 0)
1990             || !ssl_handshake_hash(s, hashval, sizeof(hashval), &hashlen)) {
1991         SSLerr(SSL_F_CREATE_SYNTHETIC_MESSAGE_HASH, ERR_R_INTERNAL_ERROR);
1992         return 0;
1993     }
1994
1995     /* Reinitialise the transcript hash */
1996     if (!ssl3_init_finished_mac(s))
1997         return 0;
1998
1999     /* Inject the synthetic message_hash message */
2000     msghdr[0] = SSL3_MT_MESSAGE_HASH;
2001     msghdr[SSL3_HM_HEADER_LENGTH - 1] = hashlen;
2002     if (!ssl3_finish_mac(s, msghdr, SSL3_HM_HEADER_LENGTH)
2003             || !ssl3_finish_mac(s, hashval, hashlen)) {
2004         SSLerr(SSL_F_CREATE_SYNTHETIC_MESSAGE_HASH, ERR_R_INTERNAL_ERROR);
2005         return 0;
2006     }
2007
2008     return 1;
2009 }
2010
2011 static int ca_dn_cmp(const X509_NAME *const *a, const X509_NAME *const *b)
2012 {
2013     return X509_NAME_cmp(*a, *b);
2014 }
2015
2016 int parse_ca_names(SSL *s, PACKET *pkt, int *al)
2017 {
2018     STACK_OF(X509_NAME) *ca_sk = sk_X509_NAME_new(ca_dn_cmp);
2019     X509_NAME *xn = NULL;
2020     PACKET cadns;
2021
2022     if (ca_sk == NULL) {
2023         SSLerr(SSL_F_PARSE_CA_NAMES, ERR_R_MALLOC_FAILURE);
2024         goto decerr;
2025     }
2026     /* get the CA RDNs */
2027     if (!PACKET_get_length_prefixed_2(pkt, &cadns)) {
2028         *al = SSL_AD_DECODE_ERROR;
2029         SSLerr(SSL_F_PARSE_CA_NAMES, SSL_R_LENGTH_MISMATCH);
2030         goto decerr;
2031     }
2032
2033     while (PACKET_remaining(&cadns)) {
2034         const unsigned char *namestart, *namebytes;
2035         unsigned int name_len;
2036
2037         if (!PACKET_get_net_2(&cadns, &name_len)
2038             || !PACKET_get_bytes(&cadns, &namebytes, name_len)) {
2039             SSLerr(SSL_F_PARSE_CA_NAMES, SSL_R_LENGTH_MISMATCH);
2040             goto decerr;
2041         }
2042
2043         namestart = namebytes;
2044         if ((xn = d2i_X509_NAME(NULL, &namebytes, name_len)) == NULL) {
2045             SSLerr(SSL_F_PARSE_CA_NAMES, ERR_R_ASN1_LIB);
2046             goto decerr;
2047         }
2048         if (namebytes != (namestart + name_len)) {
2049             SSLerr(SSL_F_PARSE_CA_NAMES, SSL_R_CA_DN_LENGTH_MISMATCH);
2050             goto decerr;
2051         }
2052
2053         if (!sk_X509_NAME_push(ca_sk, xn)) {
2054             SSLerr(SSL_F_PARSE_CA_NAMES, ERR_R_MALLOC_FAILURE);
2055             *al = SSL_AD_INTERNAL_ERROR;
2056             goto err;
2057         }
2058         xn = NULL;
2059     }
2060
2061     sk_X509_NAME_pop_free(s->s3->tmp.peer_ca_names, X509_NAME_free);
2062     s->s3->tmp.peer_ca_names = ca_sk;
2063
2064     return 1;
2065
2066  decerr:
2067     *al = SSL_AD_DECODE_ERROR;
2068  err:
2069     sk_X509_NAME_pop_free(ca_sk, X509_NAME_free);
2070     X509_NAME_free(xn);
2071     return 0;
2072 }
2073
2074 int construct_ca_names(SSL *s, WPACKET *pkt)
2075 {
2076     const STACK_OF(X509_NAME) *ca_sk = SSL_get0_CA_list(s);
2077
2078     /* Start sub-packet for client CA list */
2079     if (!WPACKET_start_sub_packet_u16(pkt))
2080         return 0;
2081
2082     if (ca_sk != NULL) {
2083         int i;
2084
2085         for (i = 0; i < sk_X509_NAME_num(ca_sk); i++) {
2086             unsigned char *namebytes;
2087             X509_NAME *name = sk_X509_NAME_value(ca_sk, i);
2088             int namelen;
2089
2090             if (name == NULL
2091                     || (namelen = i2d_X509_NAME(name, NULL)) < 0
2092                     || !WPACKET_sub_allocate_bytes_u16(pkt, namelen,
2093                                                        &namebytes)
2094                     || i2d_X509_NAME(name, &namebytes) != namelen) {
2095                 return 0;
2096             }
2097         }
2098     }
2099
2100     if (!WPACKET_close(pkt))
2101         return 0;
2102
2103     return 1;
2104 }