6bff9d47d32d5ad50680c9d9011a7c16f9de539c
[openssl.git] / ssl / statem / statem_clnt.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  *
13  * Portions of the attached software ("Contribution") are developed by
14  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
15  *
16  * The Contribution is licensed pursuant to the OpenSSL open source
17  * license provided above.
18  *
19  * ECC cipher suite support in OpenSSL originally written by
20  * Vipul Gupta and Sumit Gupta of Sun Microsystems Laboratories.
21  *
22  */
23 /* ====================================================================
24  * Copyright 2005 Nokia. All rights reserved.
25  *
26  * The portions of the attached software ("Contribution") is developed by
27  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
28  * license.
29  *
30  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
31  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
32  * support (see RFC 4279) to OpenSSL.
33  *
34  * No patent licenses or other rights except those expressly stated in
35  * the OpenSSL open source license shall be deemed granted or received
36  * expressly, by implication, estoppel, or otherwise.
37  *
38  * No assurances are provided by Nokia that the Contribution does not
39  * infringe the patent or other intellectual property rights of any third
40  * party or that the license provides you with all the necessary rights
41  * to make use of the Contribution.
42  *
43  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
44  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
45  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
46  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
47  * OTHERWISE.
48  */
49
50 #include <stdio.h>
51 #include <time.h>
52 #include "../ssl_locl.h"
53 #include "statem_locl.h"
54 #include <openssl/buffer.h>
55 #include <openssl/rand.h>
56 #include <openssl/objects.h>
57 #include <openssl/evp.h>
58 #include <openssl/md5.h>
59 #include <openssl/dh.h>
60 #include <openssl/bn.h>
61 #include <openssl/engine.h>
62
63 static MSG_PROCESS_RETURN tls_process_hello_retry_request(SSL *s, PACKET *pkt);
64 static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL *s, PACKET *pkt);
65
66 static ossl_inline int cert_req_allowed(SSL *s);
67 static int key_exchange_expected(SSL *s);
68 static int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk,
69                                     WPACKET *pkt);
70
71 /*
72  * Is a CertificateRequest message allowed at the moment or not?
73  *
74  *  Return values are:
75  *  1: Yes
76  *  0: No
77  */
78 static ossl_inline int cert_req_allowed(SSL *s)
79 {
80     /* TLS does not like anon-DH with client cert */
81     if ((s->version > SSL3_VERSION
82          && (s->s3->tmp.new_cipher->algorithm_auth & SSL_aNULL))
83         || (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aSRP | SSL_aPSK)))
84         return 0;
85
86     return 1;
87 }
88
89 /*
90  * Should we expect the ServerKeyExchange message or not?
91  *
92  *  Return values are:
93  *  1: Yes
94  *  0: No
95  */
96 static int key_exchange_expected(SSL *s)
97 {
98     long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
99
100     /*
101      * Can't skip server key exchange if this is an ephemeral
102      * ciphersuite or for SRP
103      */
104     if (alg_k & (SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK
105                  | SSL_kSRP)) {
106         return 1;
107     }
108
109     return 0;
110 }
111
112 /*
113  * ossl_statem_client_read_transition() encapsulates the logic for the allowed
114  * handshake state transitions when a TLS1.3 client is reading messages from the
115  * server. The message type that the server has sent is provided in |mt|. The
116  * current state is in |s->statem.hand_state|.
117  *
118  * Return values are 1 for success (transition allowed) and  0 on error
119  * (transition not allowed)
120  */
121 static int ossl_statem_client13_read_transition(SSL *s, int mt)
122 {
123     OSSL_STATEM *st = &s->statem;
124
125     /*
126      * Note: There is no case for TLS_ST_CW_CLNT_HELLO, because we haven't
127      * yet negotiated TLSv1.3 at that point so that is handled by
128      * ossl_statem_client_read_transition()
129      */
130
131     switch (st->hand_state) {
132     default:
133         break;
134
135     case TLS_ST_CW_CLNT_HELLO:
136         /*
137          * This must a ClientHello following a HelloRetryRequest, so the only
138          * thing we can get now is a ServerHello.
139          */
140         if (mt == SSL3_MT_SERVER_HELLO) {
141             st->hand_state = TLS_ST_CR_SRVR_HELLO;
142             return 1;
143         }
144         break;
145
146     case TLS_ST_CR_SRVR_HELLO:
147         if (mt == SSL3_MT_ENCRYPTED_EXTENSIONS) {
148             st->hand_state = TLS_ST_CR_ENCRYPTED_EXTENSIONS;
149             return 1;
150         }
151         break;
152
153     case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
154         if (s->hit) {
155             if (mt == SSL3_MT_FINISHED) {
156                 st->hand_state = TLS_ST_CR_FINISHED;
157                 return 1;
158             }
159         } else {
160             if (mt == SSL3_MT_CERTIFICATE_REQUEST) {
161                 st->hand_state = TLS_ST_CR_CERT_REQ;
162                 return 1;
163             }
164             if (mt == SSL3_MT_CERTIFICATE) {
165                 st->hand_state = TLS_ST_CR_CERT;
166                 return 1;
167             }
168         }
169         break;
170
171     case TLS_ST_CR_CERT_REQ:
172         if (mt == SSL3_MT_CERTIFICATE) {
173             st->hand_state = TLS_ST_CR_CERT;
174             return 1;
175         }
176         break;
177
178     case TLS_ST_CR_CERT:
179         if (mt == SSL3_MT_CERTIFICATE_VERIFY) {
180             st->hand_state = TLS_ST_CR_CERT_VRFY;
181             return 1;
182         }
183         break;
184
185     case TLS_ST_CR_CERT_VRFY:
186         if (mt == SSL3_MT_FINISHED) {
187             st->hand_state = TLS_ST_CR_FINISHED;
188             return 1;
189         }
190         break;
191
192     case TLS_ST_OK:
193         if (mt == SSL3_MT_NEWSESSION_TICKET) {
194             st->hand_state = TLS_ST_CR_SESSION_TICKET;
195             return 1;
196         }
197         if (mt == SSL3_MT_KEY_UPDATE) {
198             st->hand_state = TLS_ST_CR_KEY_UPDATE;
199             return 1;
200         }
201         break;
202     }
203
204     /* No valid transition found */
205     return 0;
206 }
207
208 /*
209  * ossl_statem_client_read_transition() encapsulates the logic for the allowed
210  * handshake state transitions when the client is reading messages from the
211  * server. The message type that the server has sent is provided in |mt|. The
212  * current state is in |s->statem.hand_state|.
213  *
214  * Return values are 1 for success (transition allowed) and  0 on error
215  * (transition not allowed)
216  */
217 int ossl_statem_client_read_transition(SSL *s, int mt)
218 {
219     OSSL_STATEM *st = &s->statem;
220     int ske_expected;
221
222     /*
223      * Note that after writing the first ClientHello we don't know what version
224      * we are going to negotiate yet, so we don't take this branch until later.
225      */
226     if (SSL_IS_TLS13(s)) {
227         if (!ossl_statem_client13_read_transition(s, mt))
228             goto err;
229         return 1;
230     }
231
232     switch (st->hand_state) {
233     default:
234         break;
235
236     case TLS_ST_CW_CLNT_HELLO:
237         if (mt == SSL3_MT_SERVER_HELLO) {
238             st->hand_state = TLS_ST_CR_SRVR_HELLO;
239             return 1;
240         }
241
242         if (SSL_IS_DTLS(s)) {
243             if (mt == DTLS1_MT_HELLO_VERIFY_REQUEST) {
244                 st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST;
245                 return 1;
246             }
247         } else {
248             if (mt == SSL3_MT_HELLO_RETRY_REQUEST) {
249                 st->hand_state = TLS_ST_CR_HELLO_RETRY_REQUEST;
250                 return 1;
251             }
252         }
253         break;
254
255     case TLS_ST_EARLY_DATA:
256         /*
257          * We've not actually selected TLSv1.3 yet, but we have sent early
258          * data. The only thing allowed now is a ServerHello or a
259          * HelloRetryRequest.
260          */
261         if (mt == SSL3_MT_SERVER_HELLO) {
262             st->hand_state = TLS_ST_CR_SRVR_HELLO;
263             return 1;
264         }
265         if (mt == SSL3_MT_HELLO_RETRY_REQUEST) {
266             st->hand_state = TLS_ST_CR_HELLO_RETRY_REQUEST;
267             return 1;
268         }
269         break;
270
271     case TLS_ST_CR_SRVR_HELLO:
272         if (s->hit) {
273             if (s->ext.ticket_expected) {
274                 if (mt == SSL3_MT_NEWSESSION_TICKET) {
275                     st->hand_state = TLS_ST_CR_SESSION_TICKET;
276                     return 1;
277                 }
278             } else if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
279                 st->hand_state = TLS_ST_CR_CHANGE;
280                 return 1;
281             }
282         } else {
283             if (SSL_IS_DTLS(s) && mt == DTLS1_MT_HELLO_VERIFY_REQUEST) {
284                 st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST;
285                 return 1;
286             } else if (s->version >= TLS1_VERSION
287                        && s->ext.session_secret_cb != NULL
288                        && s->session->ext.tick != NULL
289                        && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
290                 /*
291                  * Normally, we can tell if the server is resuming the session
292                  * from the session ID. EAP-FAST (RFC 4851), however, relies on
293                  * the next server message after the ServerHello to determine if
294                  * the server is resuming.
295                  */
296                 s->hit = 1;
297                 st->hand_state = TLS_ST_CR_CHANGE;
298                 return 1;
299             } else if (!(s->s3->tmp.new_cipher->algorithm_auth
300                          & (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
301                 if (mt == SSL3_MT_CERTIFICATE) {
302                     st->hand_state = TLS_ST_CR_CERT;
303                     return 1;
304                 }
305             } else {
306                 ske_expected = key_exchange_expected(s);
307                 /* SKE is optional for some PSK ciphersuites */
308                 if (ske_expected
309                     || ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_PSK)
310                         && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) {
311                     if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) {
312                         st->hand_state = TLS_ST_CR_KEY_EXCH;
313                         return 1;
314                     }
315                 } else if (mt == SSL3_MT_CERTIFICATE_REQUEST
316                            && cert_req_allowed(s)) {
317                     st->hand_state = TLS_ST_CR_CERT_REQ;
318                     return 1;
319                 } else if (mt == SSL3_MT_SERVER_DONE) {
320                     st->hand_state = TLS_ST_CR_SRVR_DONE;
321                     return 1;
322                 }
323             }
324         }
325         break;
326
327     case TLS_ST_CR_CERT:
328         /*
329          * The CertificateStatus message is optional even if
330          * |ext.status_expected| is set
331          */
332         if (s->ext.status_expected && mt == SSL3_MT_CERTIFICATE_STATUS) {
333             st->hand_state = TLS_ST_CR_CERT_STATUS;
334             return 1;
335         }
336         /* Fall through */
337
338     case TLS_ST_CR_CERT_STATUS:
339         ske_expected = key_exchange_expected(s);
340         /* SKE is optional for some PSK ciphersuites */
341         if (ske_expected || ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_PSK)
342                              && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) {
343             if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) {
344                 st->hand_state = TLS_ST_CR_KEY_EXCH;
345                 return 1;
346             }
347             goto err;
348         }
349         /* Fall through */
350
351     case TLS_ST_CR_KEY_EXCH:
352         if (mt == SSL3_MT_CERTIFICATE_REQUEST) {
353             if (cert_req_allowed(s)) {
354                 st->hand_state = TLS_ST_CR_CERT_REQ;
355                 return 1;
356             }
357             goto err;
358         }
359         /* Fall through */
360
361     case TLS_ST_CR_CERT_REQ:
362         if (mt == SSL3_MT_SERVER_DONE) {
363             st->hand_state = TLS_ST_CR_SRVR_DONE;
364             return 1;
365         }
366         break;
367
368     case TLS_ST_CW_FINISHED:
369         if (s->ext.ticket_expected) {
370             if (mt == SSL3_MT_NEWSESSION_TICKET) {
371                 st->hand_state = TLS_ST_CR_SESSION_TICKET;
372                 return 1;
373             }
374         } else if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
375             st->hand_state = TLS_ST_CR_CHANGE;
376             return 1;
377         }
378         break;
379
380     case TLS_ST_CR_SESSION_TICKET:
381         if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
382             st->hand_state = TLS_ST_CR_CHANGE;
383             return 1;
384         }
385         break;
386
387     case TLS_ST_CR_CHANGE:
388         if (mt == SSL3_MT_FINISHED) {
389             st->hand_state = TLS_ST_CR_FINISHED;
390             return 1;
391         }
392         break;
393
394     case TLS_ST_OK:
395         if (mt == SSL3_MT_HELLO_REQUEST) {
396             st->hand_state = TLS_ST_CR_HELLO_REQ;
397             return 1;
398         }
399         break;
400     }
401
402  err:
403     /* No valid transition found */
404     ssl3_send_alert(s, SSL3_AL_FATAL, SSL3_AD_UNEXPECTED_MESSAGE);
405     SSLerr(SSL_F_OSSL_STATEM_CLIENT_READ_TRANSITION, SSL_R_UNEXPECTED_MESSAGE);
406     return 0;
407 }
408
409 /*
410  * ossl_statem_client13_write_transition() works out what handshake state to
411  * move to next when the TLSv1.3 client is writing messages to be sent to the
412  * server.
413  */
414 static WRITE_TRAN ossl_statem_client13_write_transition(SSL *s)
415 {
416     OSSL_STATEM *st = &s->statem;
417
418     /*
419      * Note: There are no cases for TLS_ST_BEFORE because we haven't negotiated
420      * TLSv1.3 yet at that point. They are handled by
421      * ossl_statem_client_write_transition().
422      */
423     switch (st->hand_state) {
424     default:
425         /* Shouldn't happen */
426         return WRITE_TRAN_ERROR;
427
428     case TLS_ST_CW_CLNT_HELLO:
429         /* We only hit this in the case of HelloRetryRequest */
430         return WRITE_TRAN_FINISHED;
431
432     case TLS_ST_CR_HELLO_RETRY_REQUEST:
433         st->hand_state = TLS_ST_CW_CLNT_HELLO;
434         return WRITE_TRAN_CONTINUE;
435
436     case TLS_ST_CR_FINISHED:
437         if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY
438                 || s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING)
439             st->hand_state = TLS_ST_PENDING_EARLY_DATA_END;
440         else
441             st->hand_state = (s->s3->tmp.cert_req != 0) ? TLS_ST_CW_CERT
442                                                         : TLS_ST_CW_FINISHED;
443         return WRITE_TRAN_CONTINUE;
444
445     case TLS_ST_PENDING_EARLY_DATA_END:
446         if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) {
447             st->hand_state = TLS_ST_CW_END_OF_EARLY_DATA;
448             return WRITE_TRAN_CONTINUE;
449         }
450         /* Fall through */
451
452     case TLS_ST_CW_END_OF_EARLY_DATA:
453         st->hand_state = (s->s3->tmp.cert_req != 0) ? TLS_ST_CW_CERT
454                                                     : TLS_ST_CW_FINISHED;
455         return WRITE_TRAN_CONTINUE;
456
457     case TLS_ST_CW_CERT:
458         /* If a non-empty Certificate we also send CertificateVerify */
459         st->hand_state = (s->s3->tmp.cert_req == 1) ? TLS_ST_CW_CERT_VRFY
460                                                     : TLS_ST_CW_FINISHED;
461         return WRITE_TRAN_CONTINUE;
462
463     case TLS_ST_CW_CERT_VRFY:
464         st->hand_state = TLS_ST_CW_FINISHED;
465         return WRITE_TRAN_CONTINUE;
466
467     case TLS_ST_CR_KEY_UPDATE:
468         if (s->key_update != SSL_KEY_UPDATE_NONE) {
469             st->hand_state = TLS_ST_CW_KEY_UPDATE;
470             return WRITE_TRAN_CONTINUE;
471         }
472         /* Fall through */
473
474     case TLS_ST_CW_KEY_UPDATE:
475     case TLS_ST_CR_SESSION_TICKET:
476     case TLS_ST_CW_FINISHED:
477         st->hand_state = TLS_ST_OK;
478         return WRITE_TRAN_CONTINUE;
479
480     case TLS_ST_OK:
481         if (s->key_update != SSL_KEY_UPDATE_NONE) {
482             st->hand_state = TLS_ST_CW_KEY_UPDATE;
483             return WRITE_TRAN_CONTINUE;
484         }
485
486         /* Try to read from the server instead */
487         return WRITE_TRAN_FINISHED;
488     }
489 }
490
491 /*
492  * ossl_statem_client_write_transition() works out what handshake state to
493  * move to next when the client is writing messages to be sent to the server.
494  */
495 WRITE_TRAN ossl_statem_client_write_transition(SSL *s)
496 {
497     OSSL_STATEM *st = &s->statem;
498
499     /*
500      * Note that immediately before/after a ClientHello we don't know what
501      * version we are going to negotiate yet, so we don't take this branch until
502      * later
503      */
504     if (SSL_IS_TLS13(s))
505         return ossl_statem_client13_write_transition(s);
506
507     switch (st->hand_state) {
508     default:
509         /* Shouldn't happen */
510         return WRITE_TRAN_ERROR;
511
512     case TLS_ST_OK:
513         if (!s->renegotiate) {
514             /*
515              * We haven't requested a renegotiation ourselves so we must have
516              * received a message from the server. Better read it.
517              */
518             return WRITE_TRAN_FINISHED;
519         }
520         /* Renegotiation - fall through */
521     case TLS_ST_BEFORE:
522         st->hand_state = TLS_ST_CW_CLNT_HELLO;
523         return WRITE_TRAN_CONTINUE;
524
525     case TLS_ST_CW_CLNT_HELLO:
526         if (s->early_data_state == SSL_EARLY_DATA_CONNECTING) {
527             /*
528              * We are assuming this is a TLSv1.3 connection, although we haven't
529              * actually selected a version yet.
530              */
531             st->hand_state = TLS_ST_EARLY_DATA;
532             return WRITE_TRAN_CONTINUE;
533         }
534         /*
535          * No transition at the end of writing because we don't know what
536          * we will be sent
537          */
538         return WRITE_TRAN_FINISHED;
539
540     case TLS_ST_EARLY_DATA:
541         return WRITE_TRAN_FINISHED;
542
543     case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
544         st->hand_state = TLS_ST_CW_CLNT_HELLO;
545         return WRITE_TRAN_CONTINUE;
546
547     case TLS_ST_CR_SRVR_DONE:
548         if (s->s3->tmp.cert_req)
549             st->hand_state = TLS_ST_CW_CERT;
550         else
551             st->hand_state = TLS_ST_CW_KEY_EXCH;
552         return WRITE_TRAN_CONTINUE;
553
554     case TLS_ST_CW_CERT:
555         st->hand_state = TLS_ST_CW_KEY_EXCH;
556         return WRITE_TRAN_CONTINUE;
557
558     case TLS_ST_CW_KEY_EXCH:
559         /*
560          * For TLS, cert_req is set to 2, so a cert chain of nothing is
561          * sent, but no verify packet is sent
562          */
563         /*
564          * XXX: For now, we do not support client authentication in ECDH
565          * cipher suites with ECDH (rather than ECDSA) certificates. We
566          * need to skip the certificate verify message when client's
567          * ECDH public key is sent inside the client certificate.
568          */
569         if (s->s3->tmp.cert_req == 1) {
570             st->hand_state = TLS_ST_CW_CERT_VRFY;
571         } else {
572             st->hand_state = TLS_ST_CW_CHANGE;
573         }
574         if (s->s3->flags & TLS1_FLAGS_SKIP_CERT_VERIFY) {
575             st->hand_state = TLS_ST_CW_CHANGE;
576         }
577         return WRITE_TRAN_CONTINUE;
578
579     case TLS_ST_CW_CERT_VRFY:
580         st->hand_state = TLS_ST_CW_CHANGE;
581         return WRITE_TRAN_CONTINUE;
582
583     case TLS_ST_CW_CHANGE:
584 #if defined(OPENSSL_NO_NEXTPROTONEG)
585         st->
586         hand_state = TLS_ST_CW_FINISHED;
587 #else
588         if (!SSL_IS_DTLS(s) && s->s3->npn_seen)
589             st->hand_state = TLS_ST_CW_NEXT_PROTO;
590         else
591             st->hand_state = TLS_ST_CW_FINISHED;
592 #endif
593         return WRITE_TRAN_CONTINUE;
594
595 #if !defined(OPENSSL_NO_NEXTPROTONEG)
596     case TLS_ST_CW_NEXT_PROTO:
597         st->hand_state = TLS_ST_CW_FINISHED;
598         return WRITE_TRAN_CONTINUE;
599 #endif
600
601     case TLS_ST_CW_FINISHED:
602         if (s->hit) {
603             st->hand_state = TLS_ST_OK;
604             return WRITE_TRAN_CONTINUE;
605         } else {
606             return WRITE_TRAN_FINISHED;
607         }
608
609     case TLS_ST_CR_FINISHED:
610         if (s->hit) {
611             st->hand_state = TLS_ST_CW_CHANGE;
612             return WRITE_TRAN_CONTINUE;
613         } else {
614             st->hand_state = TLS_ST_OK;
615             return WRITE_TRAN_CONTINUE;
616         }
617
618     case TLS_ST_CR_HELLO_REQ:
619         /*
620          * If we can renegotiate now then do so, otherwise wait for a more
621          * convenient time.
622          */
623         if (ssl3_renegotiate_check(s, 1)) {
624             if (!tls_setup_handshake(s)) {
625                 ossl_statem_set_error(s);
626                 return WRITE_TRAN_ERROR;
627             }
628             st->hand_state = TLS_ST_CW_CLNT_HELLO;
629             return WRITE_TRAN_CONTINUE;
630         }
631         st->hand_state = TLS_ST_OK;
632         return WRITE_TRAN_CONTINUE;
633     }
634 }
635
636 /*
637  * Perform any pre work that needs to be done prior to sending a message from
638  * the client to the server.
639  */
640 WORK_STATE ossl_statem_client_pre_work(SSL *s, WORK_STATE wst)
641 {
642     OSSL_STATEM *st = &s->statem;
643
644     switch (st->hand_state) {
645     default:
646         /* No pre work to be done */
647         break;
648
649     case TLS_ST_CW_CLNT_HELLO:
650         s->shutdown = 0;
651         if (SSL_IS_DTLS(s)) {
652             /* every DTLS ClientHello resets Finished MAC */
653             if (!ssl3_init_finished_mac(s)) {
654                 ossl_statem_set_error(s);
655                 return WORK_ERROR;
656             }
657         }
658         break;
659
660     case TLS_ST_CW_CHANGE:
661         if (SSL_IS_DTLS(s)) {
662             if (s->hit) {
663                 /*
664                  * We're into the last flight so we don't retransmit these
665                  * messages unless we need to.
666                  */
667                 st->use_timer = 0;
668             }
669 #ifndef OPENSSL_NO_SCTP
670             if (BIO_dgram_is_sctp(SSL_get_wbio(s)))
671                 return dtls_wait_for_dry(s);
672 #endif
673         }
674         break;
675
676     case TLS_ST_PENDING_EARLY_DATA_END:
677         /*
678          * If we've been called by SSL_do_handshake()/SSL_write(), or we did not
679          * attempt to write early data before calling SSL_read() then we press
680          * on with the handshake. Otherwise we pause here.
681          */
682         if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING
683                 || s->early_data_state == SSL_EARLY_DATA_NONE)
684             return WORK_FINISHED_CONTINUE;
685         /* Fall through */
686
687     case TLS_ST_EARLY_DATA:
688     case TLS_ST_OK:
689         return tls_finish_handshake(s, wst, 1);
690     }
691
692     return WORK_FINISHED_CONTINUE;
693 }
694
695 /*
696  * Perform any work that needs to be done after sending a message from the
697  * client to the server.
698  */
699 WORK_STATE ossl_statem_client_post_work(SSL *s, WORK_STATE wst)
700 {
701     OSSL_STATEM *st = &s->statem;
702
703     s->init_num = 0;
704
705     switch (st->hand_state) {
706     default:
707         /* No post work to be done */
708         break;
709
710     case TLS_ST_CW_CLNT_HELLO:
711         if (wst == WORK_MORE_A && statem_flush(s) != 1)
712             return WORK_MORE_A;
713
714         if (SSL_IS_DTLS(s)) {
715             /* Treat the next message as the first packet */
716             s->first_packet = 1;
717         }
718
719         if (s->early_data_state == SSL_EARLY_DATA_CONNECTING
720                 && s->max_early_data > 0) {
721             /*
722              * We haven't selected TLSv1.3 yet so we don't call the change
723              * cipher state function associated with the SSL_METHOD. Instead
724              * we call tls13_change_cipher_state() directly.
725              */
726             if (!tls13_change_cipher_state(s,
727                         SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_CLIENT_WRITE))
728                 return WORK_ERROR;
729         }
730         break;
731
732     case TLS_ST_CW_END_OF_EARLY_DATA:
733         /*
734          * We set the enc_write_ctx back to NULL because we may end up writing
735          * in cleartext again if we get a HelloRetryRequest from the server.
736          */
737         EVP_CIPHER_CTX_free(s->enc_write_ctx);
738         s->enc_write_ctx = NULL;
739         break;
740
741     case TLS_ST_CW_KEY_EXCH:
742         if (tls_client_key_exchange_post_work(s) == 0)
743             return WORK_ERROR;
744         break;
745
746     case TLS_ST_CW_CHANGE:
747         s->session->cipher = s->s3->tmp.new_cipher;
748 #ifdef OPENSSL_NO_COMP
749         s->session->compress_meth = 0;
750 #else
751         if (s->s3->tmp.new_compression == NULL)
752             s->session->compress_meth = 0;
753         else
754             s->session->compress_meth = s->s3->tmp.new_compression->id;
755 #endif
756         if (!s->method->ssl3_enc->setup_key_block(s))
757             return WORK_ERROR;
758
759         if (!s->method->ssl3_enc->change_cipher_state(s,
760                                                       SSL3_CHANGE_CIPHER_CLIENT_WRITE))
761             return WORK_ERROR;
762
763         if (SSL_IS_DTLS(s)) {
764 #ifndef OPENSSL_NO_SCTP
765             if (s->hit) {
766                 /*
767                  * Change to new shared key of SCTP-Auth, will be ignored if
768                  * no SCTP used.
769                  */
770                 BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
771                          0, NULL);
772             }
773 #endif
774
775             dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);
776         }
777         break;
778
779     case TLS_ST_CW_FINISHED:
780 #ifndef OPENSSL_NO_SCTP
781         if (wst == WORK_MORE_A && SSL_IS_DTLS(s) && s->hit == 0) {
782             /*
783              * Change to new shared key of SCTP-Auth, will be ignored if
784              * no SCTP used.
785              */
786             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
787                      0, NULL);
788         }
789 #endif
790         if (statem_flush(s) != 1)
791             return WORK_MORE_B;
792
793         if (SSL_IS_TLS13(s)) {
794             if (!s->method->ssl3_enc->change_cipher_state(s,
795                         SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_WRITE))
796             return WORK_ERROR;
797         }
798         break;
799
800     case TLS_ST_CW_KEY_UPDATE:
801         if (statem_flush(s) != 1)
802             return WORK_MORE_A;
803         if (!tls13_update_key(s, 1))
804             return WORK_ERROR;
805         break;
806     }
807
808     return WORK_FINISHED_CONTINUE;
809 }
810
811 /*
812  * Get the message construction function and message type for sending from the
813  * client
814  *
815  * Valid return values are:
816  *   1: Success
817  *   0: Error
818  */
819 int ossl_statem_client_construct_message(SSL *s, WPACKET *pkt,
820                                          confunc_f *confunc, int *mt)
821 {
822     OSSL_STATEM *st = &s->statem;
823
824     switch (st->hand_state) {
825     default:
826         /* Shouldn't happen */
827         return 0;
828
829     case TLS_ST_CW_CHANGE:
830         if (SSL_IS_DTLS(s))
831             *confunc = dtls_construct_change_cipher_spec;
832         else
833             *confunc = tls_construct_change_cipher_spec;
834         *mt = SSL3_MT_CHANGE_CIPHER_SPEC;
835         break;
836
837     case TLS_ST_CW_CLNT_HELLO:
838         *confunc = tls_construct_client_hello;
839         *mt = SSL3_MT_CLIENT_HELLO;
840         break;
841
842     case TLS_ST_CW_END_OF_EARLY_DATA:
843         *confunc = tls_construct_end_of_early_data;
844         *mt = SSL3_MT_END_OF_EARLY_DATA;
845         break;
846
847     case TLS_ST_PENDING_EARLY_DATA_END:
848         *confunc = NULL;
849         *mt = SSL3_MT_DUMMY;
850         break;
851
852     case TLS_ST_CW_CERT:
853         *confunc = tls_construct_client_certificate;
854         *mt = SSL3_MT_CERTIFICATE;
855         break;
856
857     case TLS_ST_CW_KEY_EXCH:
858         *confunc = tls_construct_client_key_exchange;
859         *mt = SSL3_MT_CLIENT_KEY_EXCHANGE;
860         break;
861
862     case TLS_ST_CW_CERT_VRFY:
863         *confunc = tls_construct_cert_verify;
864         *mt = SSL3_MT_CERTIFICATE_VERIFY;
865         break;
866
867 #if !defined(OPENSSL_NO_NEXTPROTONEG)
868     case TLS_ST_CW_NEXT_PROTO:
869         *confunc = tls_construct_next_proto;
870         *mt = SSL3_MT_NEXT_PROTO;
871         break;
872 #endif
873     case TLS_ST_CW_FINISHED:
874         *confunc = tls_construct_finished;
875         *mt = SSL3_MT_FINISHED;
876         break;
877
878     case TLS_ST_CW_KEY_UPDATE:
879         *confunc = tls_construct_key_update;
880         *mt = SSL3_MT_KEY_UPDATE;
881         break;
882     }
883
884     return 1;
885 }
886
887 /*
888  * Returns the maximum allowed length for the current message that we are
889  * reading. Excludes the message header.
890  */
891 size_t ossl_statem_client_max_message_size(SSL *s)
892 {
893     OSSL_STATEM *st = &s->statem;
894
895     switch (st->hand_state) {
896     default:
897         /* Shouldn't happen */
898         return 0;
899
900     case TLS_ST_CR_SRVR_HELLO:
901         return SERVER_HELLO_MAX_LENGTH;
902
903     case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
904         return HELLO_VERIFY_REQUEST_MAX_LENGTH;
905
906     case TLS_ST_CR_HELLO_RETRY_REQUEST:
907         return HELLO_RETRY_REQUEST_MAX_LENGTH;
908
909     case TLS_ST_CR_CERT:
910         return s->max_cert_list;
911
912     case TLS_ST_CR_CERT_VRFY:
913         return SSL3_RT_MAX_PLAIN_LENGTH;
914
915     case TLS_ST_CR_CERT_STATUS:
916         return SSL3_RT_MAX_PLAIN_LENGTH;
917
918     case TLS_ST_CR_KEY_EXCH:
919         return SERVER_KEY_EXCH_MAX_LENGTH;
920
921     case TLS_ST_CR_CERT_REQ:
922         /*
923          * Set to s->max_cert_list for compatibility with previous releases. In
924          * practice these messages can get quite long if servers are configured
925          * to provide a long list of acceptable CAs
926          */
927         return s->max_cert_list;
928
929     case TLS_ST_CR_SRVR_DONE:
930         return SERVER_HELLO_DONE_MAX_LENGTH;
931
932     case TLS_ST_CR_CHANGE:
933         if (s->version == DTLS1_BAD_VER)
934             return 3;
935         return CCS_MAX_LENGTH;
936
937     case TLS_ST_CR_SESSION_TICKET:
938         return SSL3_RT_MAX_PLAIN_LENGTH;
939
940     case TLS_ST_CR_FINISHED:
941         return FINISHED_MAX_LENGTH;
942
943     case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
944         return ENCRYPTED_EXTENSIONS_MAX_LENGTH;
945
946     case TLS_ST_CR_KEY_UPDATE:
947         return KEY_UPDATE_MAX_LENGTH;
948     }
949 }
950
951 /*
952  * Process a message that the client has been received from the server.
953  */
954 MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL *s, PACKET *pkt)
955 {
956     OSSL_STATEM *st = &s->statem;
957
958     switch (st->hand_state) {
959     default:
960         /* Shouldn't happen */
961         return MSG_PROCESS_ERROR;
962
963     case TLS_ST_CR_SRVR_HELLO:
964         return tls_process_server_hello(s, pkt);
965
966     case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
967         return dtls_process_hello_verify(s, pkt);
968
969     case TLS_ST_CR_HELLO_RETRY_REQUEST:
970         return tls_process_hello_retry_request(s, pkt);
971
972     case TLS_ST_CR_CERT:
973         return tls_process_server_certificate(s, pkt);
974
975     case TLS_ST_CR_CERT_VRFY:
976         return tls_process_cert_verify(s, pkt);
977
978     case TLS_ST_CR_CERT_STATUS:
979         return tls_process_cert_status(s, pkt);
980
981     case TLS_ST_CR_KEY_EXCH:
982         return tls_process_key_exchange(s, pkt);
983
984     case TLS_ST_CR_CERT_REQ:
985         return tls_process_certificate_request(s, pkt);
986
987     case TLS_ST_CR_SRVR_DONE:
988         return tls_process_server_done(s, pkt);
989
990     case TLS_ST_CR_CHANGE:
991         return tls_process_change_cipher_spec(s, pkt);
992
993     case TLS_ST_CR_SESSION_TICKET:
994         return tls_process_new_session_ticket(s, pkt);
995
996     case TLS_ST_CR_FINISHED:
997         return tls_process_finished(s, pkt);
998
999     case TLS_ST_CR_HELLO_REQ:
1000         return tls_process_hello_req(s, pkt);
1001
1002     case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
1003         return tls_process_encrypted_extensions(s, pkt);
1004
1005     case TLS_ST_CR_KEY_UPDATE:
1006         return tls_process_key_update(s, pkt);
1007     }
1008 }
1009
1010 /*
1011  * Perform any further processing required following the receipt of a message
1012  * from the server
1013  */
1014 WORK_STATE ossl_statem_client_post_process_message(SSL *s, WORK_STATE wst)
1015 {
1016     OSSL_STATEM *st = &s->statem;
1017
1018     switch (st->hand_state) {
1019     default:
1020         /* Shouldn't happen */
1021         return WORK_ERROR;
1022
1023     case TLS_ST_CR_CERT_REQ:
1024         return tls_prepare_client_certificate(s, wst);
1025     }
1026 }
1027
1028 int tls_construct_client_hello(SSL *s, WPACKET *pkt)
1029 {
1030     unsigned char *p;
1031     size_t sess_id_len;
1032     int i, protverr;
1033     int al = SSL_AD_HANDSHAKE_FAILURE;
1034 #ifndef OPENSSL_NO_COMP
1035     SSL_COMP *comp;
1036 #endif
1037     SSL_SESSION *sess = s->session;
1038
1039     if (!WPACKET_set_max_size(pkt, SSL3_RT_MAX_PLAIN_LENGTH)) {
1040         /* Should not happen */
1041         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1042         return 0;
1043     }
1044
1045     /* Work out what SSL/TLS/DTLS version to use */
1046     protverr = ssl_set_client_hello_version(s);
1047     if (protverr != 0) {
1048         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, protverr);
1049         return 0;
1050     }
1051
1052     if (sess == NULL
1053             || !ssl_version_supported(s, sess->ssl_version)
1054             || !SSL_SESSION_is_resumable(sess)) {
1055         if (!ssl_get_new_session(s, 0))
1056             return 0;
1057     }
1058     /* else use the pre-loaded session */
1059
1060     p = s->s3->client_random;
1061
1062     /*
1063      * for DTLS if client_random is initialized, reuse it, we are
1064      * required to use same upon reply to HelloVerify
1065      */
1066     if (SSL_IS_DTLS(s)) {
1067         size_t idx;
1068         i = 1;
1069         for (idx = 0; idx < sizeof(s->s3->client_random); idx++) {
1070             if (p[idx]) {
1071                 i = 0;
1072                 break;
1073             }
1074         }
1075     } else
1076         i = 1;
1077
1078     if (i && ssl_fill_hello_random(s, 0, p, sizeof(s->s3->client_random),
1079                                    DOWNGRADE_NONE) <= 0)
1080         return 0;
1081
1082     /*-
1083      * version indicates the negotiated version: for example from
1084      * an SSLv2/v3 compatible client hello). The client_version
1085      * field is the maximum version we permit and it is also
1086      * used in RSA encrypted premaster secrets. Some servers can
1087      * choke if we initially report a higher version then
1088      * renegotiate to a lower one in the premaster secret. This
1089      * didn't happen with TLS 1.0 as most servers supported it
1090      * but it can with TLS 1.1 or later if the server only supports
1091      * 1.0.
1092      *
1093      * Possible scenario with previous logic:
1094      *      1. Client hello indicates TLS 1.2
1095      *      2. Server hello says TLS 1.0
1096      *      3. RSA encrypted premaster secret uses 1.2.
1097      *      4. Handshake proceeds using TLS 1.0.
1098      *      5. Server sends hello request to renegotiate.
1099      *      6. Client hello indicates TLS v1.0 as we now
1100      *         know that is maximum server supports.
1101      *      7. Server chokes on RSA encrypted premaster secret
1102      *         containing version 1.0.
1103      *
1104      * For interoperability it should be OK to always use the
1105      * maximum version we support in client hello and then rely
1106      * on the checking of version to ensure the servers isn't
1107      * being inconsistent: for example initially negotiating with
1108      * TLS 1.0 and renegotiating with TLS 1.2. We do this by using
1109      * client_version in client hello and not resetting it to
1110      * the negotiated version.
1111      *
1112      * For TLS 1.3 we always set the ClientHello version to 1.2 and rely on the
1113      * supported_versions extension for the real supported versions.
1114      */
1115     if (!WPACKET_put_bytes_u16(pkt, s->client_version)
1116             || !WPACKET_memcpy(pkt, s->s3->client_random, SSL3_RANDOM_SIZE)) {
1117         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1118         return 0;
1119     }
1120
1121     /* Session ID */
1122     if (s->new_session || s->session->ssl_version == TLS1_3_VERSION)
1123         sess_id_len = 0;
1124     else
1125         sess_id_len = s->session->session_id_length;
1126     if (sess_id_len > sizeof(s->session->session_id)
1127             || !WPACKET_start_sub_packet_u8(pkt)
1128             || (sess_id_len != 0 && !WPACKET_memcpy(pkt, s->session->session_id,
1129                                                     sess_id_len))
1130             || !WPACKET_close(pkt)) {
1131         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1132         return 0;
1133     }
1134
1135     /* cookie stuff for DTLS */
1136     if (SSL_IS_DTLS(s)) {
1137         if (s->d1->cookie_len > sizeof(s->d1->cookie)
1138                 || !WPACKET_sub_memcpy_u8(pkt, s->d1->cookie,
1139                                           s->d1->cookie_len)) {
1140             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1141             return 0;
1142         }
1143     }
1144
1145     /* Ciphers supported */
1146     if (!WPACKET_start_sub_packet_u16(pkt)) {
1147         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1148         return 0;
1149     }
1150     /* ssl_cipher_list_to_bytes() raises SSLerr if appropriate */
1151     if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), pkt))
1152         return 0;
1153     if (!WPACKET_close(pkt)) {
1154         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1155         return 0;
1156     }
1157
1158     /* COMPRESSION */
1159     if (!WPACKET_start_sub_packet_u8(pkt)) {
1160         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1161         return 0;
1162     }
1163 #ifndef OPENSSL_NO_COMP
1164     if (ssl_allow_compression(s)
1165             && s->ctx->comp_methods
1166             && (SSL_IS_DTLS(s) || s->s3->tmp.max_ver < TLS1_3_VERSION)) {
1167         int compnum = sk_SSL_COMP_num(s->ctx->comp_methods);
1168         for (i = 0; i < compnum; i++) {
1169             comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
1170             if (!WPACKET_put_bytes_u8(pkt, comp->id)) {
1171                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1172                 return 0;
1173             }
1174         }
1175     }
1176 #endif
1177     /* Add the NULL method */
1178     if (!WPACKET_put_bytes_u8(pkt, 0) || !WPACKET_close(pkt)) {
1179         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1180         return 0;
1181     }
1182
1183     /* TLS extensions */
1184     if (!tls_construct_extensions(s, pkt, SSL_EXT_CLIENT_HELLO, NULL, 0, &al)) {
1185         ssl3_send_alert(s, SSL3_AL_FATAL, al);
1186         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1187         return 0;
1188     }
1189
1190     return 1;
1191 }
1192
1193 MSG_PROCESS_RETURN dtls_process_hello_verify(SSL *s, PACKET *pkt)
1194 {
1195     int al;
1196     size_t cookie_len;
1197     PACKET cookiepkt;
1198
1199     if (!PACKET_forward(pkt, 2)
1200         || !PACKET_get_length_prefixed_1(pkt, &cookiepkt)) {
1201         al = SSL_AD_DECODE_ERROR;
1202         SSLerr(SSL_F_DTLS_PROCESS_HELLO_VERIFY, SSL_R_LENGTH_MISMATCH);
1203         goto f_err;
1204     }
1205
1206     cookie_len = PACKET_remaining(&cookiepkt);
1207     if (cookie_len > sizeof(s->d1->cookie)) {
1208         al = SSL_AD_ILLEGAL_PARAMETER;
1209         SSLerr(SSL_F_DTLS_PROCESS_HELLO_VERIFY, SSL_R_LENGTH_TOO_LONG);
1210         goto f_err;
1211     }
1212
1213     if (!PACKET_copy_bytes(&cookiepkt, s->d1->cookie, cookie_len)) {
1214         al = SSL_AD_DECODE_ERROR;
1215         SSLerr(SSL_F_DTLS_PROCESS_HELLO_VERIFY, SSL_R_LENGTH_MISMATCH);
1216         goto f_err;
1217     }
1218     s->d1->cookie_len = cookie_len;
1219
1220     return MSG_PROCESS_FINISHED_READING;
1221  f_err:
1222     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1223     ossl_statem_set_error(s);
1224     return MSG_PROCESS_ERROR;
1225 }
1226
1227 static int set_client_ciphersuite(SSL *s, const unsigned char *cipherchars)
1228 {
1229     STACK_OF(SSL_CIPHER) *sk;
1230     const SSL_CIPHER *c;
1231     int i;
1232
1233     c = ssl_get_cipher_by_char(s, cipherchars, 0);
1234     if (c == NULL) {
1235         /* unknown cipher */
1236         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE, SSL_R_UNKNOWN_CIPHER_RETURNED);
1237         return 0;
1238     }
1239     /*
1240      * If it is a disabled cipher we either didn't send it in client hello,
1241      * or it's not allowed for the selected protocol. So we return an error.
1242      */
1243     if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_CHECK, 1)) {
1244         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE, SSL_R_WRONG_CIPHER_RETURNED);
1245         return 0;
1246     }
1247
1248     sk = ssl_get_ciphers_by_id(s);
1249     i = sk_SSL_CIPHER_find(sk, c);
1250     if (i < 0) {
1251         /* we did not say we would use this cipher */
1252         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE, SSL_R_WRONG_CIPHER_RETURNED);
1253         return 0;
1254     }
1255
1256     if (SSL_IS_TLS13(s) && s->s3->tmp.new_cipher != NULL
1257             && s->s3->tmp.new_cipher->id != c->id) {
1258         /* ServerHello selected a different ciphersuite to that in the HRR */
1259         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE, SSL_R_WRONG_CIPHER_RETURNED);
1260         return 0;
1261     }
1262
1263     /*
1264      * Depending on the session caching (internal/external), the cipher
1265      * and/or cipher_id values may not be set. Make sure that cipher_id is
1266      * set and use it for comparison.
1267      */
1268     if (s->session->cipher != NULL)
1269         s->session->cipher_id = s->session->cipher->id;
1270     if (s->hit && (s->session->cipher_id != c->id)) {
1271         SSLerr(SSL_F_SET_CLIENT_CIPHERSUITE,
1272                SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED);
1273         return 0;
1274     }
1275     s->s3->tmp.new_cipher = c;
1276
1277     return 1;
1278 }
1279
1280 MSG_PROCESS_RETURN tls_process_server_hello(SSL *s, PACKET *pkt)
1281 {
1282     PACKET session_id, extpkt;
1283     size_t session_id_len;
1284     const unsigned char *cipherchars;
1285     int al = SSL_AD_INTERNAL_ERROR;
1286     unsigned int compression;
1287     unsigned int sversion;
1288     unsigned int context;
1289     int protverr;
1290     RAW_EXTENSION *extensions = NULL;
1291 #ifndef OPENSSL_NO_COMP
1292     SSL_COMP *comp;
1293 #endif
1294
1295     if (!PACKET_get_net_2(pkt, &sversion)) {
1296         al = SSL_AD_DECODE_ERROR;
1297         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1298         goto f_err;
1299     }
1300
1301     /* load the server random */
1302     if (!PACKET_copy_bytes(pkt, s->s3->server_random, SSL3_RANDOM_SIZE)) {
1303         al = SSL_AD_DECODE_ERROR;
1304         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1305         goto f_err;
1306     }
1307
1308     /*
1309      * We do this immediately so we know what format the ServerHello is in.
1310      * Must be done after reading the random data so we can check for the
1311      * TLSv1.3 downgrade sentinels
1312      */
1313     protverr = ssl_choose_client_version(s, sversion, 1, &al);
1314     if (protverr != 0) {
1315         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, protverr);
1316         goto f_err;
1317     }
1318
1319     /*
1320      * In TLSv1.3 a ServerHello message signals a key change so the end of the
1321      * message must be on a record boundary.
1322      */
1323     if (SSL_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
1324         al = SSL_AD_UNEXPECTED_MESSAGE;
1325         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_NOT_ON_RECORD_BOUNDARY);
1326         goto f_err;
1327     }
1328
1329     /* Get the session-id. */
1330     if (!SSL_IS_TLS13(s)) {
1331         if (!PACKET_get_length_prefixed_1(pkt, &session_id)) {
1332             al = SSL_AD_DECODE_ERROR;
1333             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1334             goto f_err;
1335         }
1336         session_id_len = PACKET_remaining(&session_id);
1337         if (session_id_len > sizeof s->session->session_id
1338             || session_id_len > SSL3_SESSION_ID_SIZE) {
1339             al = SSL_AD_ILLEGAL_PARAMETER;
1340             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1341                    SSL_R_SSL3_SESSION_ID_TOO_LONG);
1342             goto f_err;
1343         }
1344     } else {
1345         PACKET_null_init(&session_id);
1346         session_id_len = 0;
1347     }
1348
1349     if (!PACKET_get_bytes(pkt, &cipherchars, TLS_CIPHER_LEN)) {
1350         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1351         al = SSL_AD_DECODE_ERROR;
1352         goto f_err;
1353     }
1354
1355     if (!SSL_IS_TLS13(s)) {
1356         if (!PACKET_get_1(pkt, &compression)) {
1357             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_LENGTH_MISMATCH);
1358             al = SSL_AD_DECODE_ERROR;
1359             goto f_err;
1360         }
1361     } else {
1362         compression = 0;
1363     }
1364
1365     /* TLS extensions */
1366     if (PACKET_remaining(pkt) == 0) {
1367         PACKET_null_init(&extpkt);
1368     } else if (!PACKET_as_length_prefixed_2(pkt, &extpkt)) {
1369         al = SSL_AD_DECODE_ERROR;
1370         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_BAD_LENGTH);
1371         goto f_err;
1372     }
1373
1374     context = SSL_IS_TLS13(s) ? SSL_EXT_TLS1_3_SERVER_HELLO
1375                               : SSL_EXT_TLS1_2_SERVER_HELLO;
1376     if (!tls_collect_extensions(s, &extpkt, context, &extensions, &al, NULL, 1))
1377         goto f_err;
1378
1379     s->hit = 0;
1380
1381     if (SSL_IS_TLS13(s)) {
1382         /* This will set s->hit if we are resuming */
1383         if (!tls_parse_extension(s, TLSEXT_IDX_psk,
1384                                  SSL_EXT_TLS1_3_SERVER_HELLO,
1385                                  extensions, NULL, 0, &al))
1386             goto f_err;
1387     } else {
1388         /*
1389          * Check if we can resume the session based on external pre-shared
1390          * secret. EAP-FAST (RFC 4851) supports two types of session resumption.
1391          * Resumption based on server-side state works with session IDs.
1392          * Resumption based on pre-shared Protected Access Credentials (PACs)
1393          * works by overriding the SessionTicket extension at the application
1394          * layer, and does not send a session ID. (We do not know whether
1395          * EAP-FAST servers would honour the session ID.) Therefore, the session
1396          * ID alone is not a reliable indicator of session resumption, so we
1397          * first check if we can resume, and later peek at the next handshake
1398          * message to see if the server wants to resume.
1399          */
1400         if (s->version >= TLS1_VERSION
1401                 && s->ext.session_secret_cb != NULL && s->session->ext.tick) {
1402             const SSL_CIPHER *pref_cipher = NULL;
1403             /*
1404              * s->session->master_key_length is a size_t, but this is an int for
1405              * backwards compat reasons
1406              */
1407             int master_key_length;
1408             master_key_length = sizeof(s->session->master_key);
1409             if (s->ext.session_secret_cb(s, s->session->master_key,
1410                                          &master_key_length,
1411                                          NULL, &pref_cipher,
1412                                          s->ext.session_secret_cb_arg)
1413                      && master_key_length > 0) {
1414                 s->session->master_key_length = master_key_length;
1415                 s->session->cipher = pref_cipher ?
1416                     pref_cipher : ssl_get_cipher_by_char(s, cipherchars, 0);
1417             } else {
1418                 SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1419                 al = SSL_AD_INTERNAL_ERROR;
1420                 goto f_err;
1421             }
1422         }
1423
1424         if (session_id_len != 0
1425                 && session_id_len == s->session->session_id_length
1426                 && memcmp(PACKET_data(&session_id), s->session->session_id,
1427                           session_id_len) == 0)
1428             s->hit = 1;
1429     }
1430
1431     if (s->hit) {
1432         if (s->sid_ctx_length != s->session->sid_ctx_length
1433                 || memcmp(s->session->sid_ctx, s->sid_ctx, s->sid_ctx_length)) {
1434             /* actually a client application bug */
1435             al = SSL_AD_ILLEGAL_PARAMETER;
1436             SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1437                    SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
1438             goto f_err;
1439         }
1440     } else {
1441         /*
1442          * If we were trying for session-id reuse but the server
1443          * didn't resume, make a new SSL_SESSION.
1444          * In the case of EAP-FAST and PAC, we do not send a session ID,
1445          * so the PAC-based session secret is always preserved. It'll be
1446          * overwritten if the server refuses resumption.
1447          */
1448         if (s->session->session_id_length > 0
1449                 || (SSL_IS_TLS13(s)
1450                     && s->session->ext.tick_identity
1451                        != TLSEXT_PSK_BAD_IDENTITY)) {
1452             s->ctx->stats.sess_miss++;
1453             if (!ssl_get_new_session(s, 0)) {
1454                 goto f_err;
1455             }
1456         }
1457
1458         s->session->ssl_version = s->version;
1459         s->session->session_id_length = session_id_len;
1460         /* session_id_len could be 0 */
1461         if (session_id_len > 0)
1462             memcpy(s->session->session_id, PACKET_data(&session_id),
1463                    session_id_len);
1464     }
1465
1466     /* Session version and negotiated protocol version should match */
1467     if (s->version != s->session->ssl_version) {
1468         al = SSL_AD_PROTOCOL_VERSION;
1469
1470         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1471                SSL_R_SSL_SESSION_VERSION_MISMATCH);
1472         goto f_err;
1473     }
1474     /*
1475      * Now that we know the version, update the check to see if it's an allowed
1476      * version.
1477      */
1478     s->s3->tmp.min_ver = s->version;
1479     s->s3->tmp.max_ver = s->version;
1480
1481     if (!set_client_ciphersuite(s, cipherchars)) {
1482         al = SSL_AD_ILLEGAL_PARAMETER;
1483         goto f_err;
1484     }
1485
1486 #ifdef OPENSSL_NO_COMP
1487     if (compression != 0) {
1488         al = SSL_AD_ILLEGAL_PARAMETER;
1489         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1490                SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
1491         goto f_err;
1492     }
1493     /*
1494      * If compression is disabled we'd better not try to resume a session
1495      * using compression.
1496      */
1497     if (s->session->compress_meth != 0) {
1498         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_INCONSISTENT_COMPRESSION);
1499         goto f_err;
1500     }
1501 #else
1502     if (s->hit && compression != s->session->compress_meth) {
1503         al = SSL_AD_ILLEGAL_PARAMETER;
1504         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1505                SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED);
1506         goto f_err;
1507     }
1508     if (compression == 0)
1509         comp = NULL;
1510     else if (!ssl_allow_compression(s)) {
1511         al = SSL_AD_ILLEGAL_PARAMETER;
1512         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_COMPRESSION_DISABLED);
1513         goto f_err;
1514     } else {
1515         comp = ssl3_comp_find(s->ctx->comp_methods, compression);
1516     }
1517
1518     if (compression != 0 && comp == NULL) {
1519         al = SSL_AD_ILLEGAL_PARAMETER;
1520         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO,
1521                SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
1522         goto f_err;
1523     } else {
1524         s->s3->tmp.new_compression = comp;
1525     }
1526 #endif
1527
1528     if (!tls_parse_all_extensions(s, context, extensions, NULL, 0, &al, 1))
1529         goto f_err;
1530
1531 #ifndef OPENSSL_NO_SCTP
1532     if (SSL_IS_DTLS(s) && s->hit) {
1533         unsigned char sctpauthkey[64];
1534         char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
1535
1536         /*
1537          * Add new shared key for SCTP-Auth, will be ignored if
1538          * no SCTP used.
1539          */
1540         memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
1541                sizeof(DTLS1_SCTP_AUTH_LABEL));
1542
1543         if (SSL_export_keying_material(s, sctpauthkey,
1544                                        sizeof(sctpauthkey),
1545                                        labelbuffer,
1546                                        sizeof(labelbuffer), NULL, 0, 0) <= 0)
1547             goto f_err;
1548
1549         BIO_ctrl(SSL_get_wbio(s),
1550                  BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
1551                  sizeof(sctpauthkey), sctpauthkey);
1552     }
1553 #endif
1554
1555     /*
1556      * In TLSv1.3 we have some post-processing to change cipher state, otherwise
1557      * we're done with this message
1558      */
1559     if (SSL_IS_TLS13(s)
1560             && (!s->method->ssl3_enc->setup_key_block(s)
1561                 || !s->method->ssl3_enc->change_cipher_state(s,
1562                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_READ))) {
1563         al = SSL_AD_INTERNAL_ERROR;
1564         SSLerr(SSL_F_TLS_PROCESS_SERVER_HELLO, SSL_R_CANNOT_CHANGE_CIPHER);
1565         goto f_err;
1566     }
1567
1568     OPENSSL_free(extensions);
1569     return MSG_PROCESS_CONTINUE_READING;
1570  f_err:
1571     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1572     ossl_statem_set_error(s);
1573     OPENSSL_free(extensions);
1574     return MSG_PROCESS_ERROR;
1575 }
1576
1577 static MSG_PROCESS_RETURN tls_process_hello_retry_request(SSL *s, PACKET *pkt)
1578 {
1579     unsigned int sversion;
1580     int errorcode;
1581     const unsigned char *cipherchars;
1582     RAW_EXTENSION *extensions = NULL;
1583     int al;
1584     PACKET extpkt;
1585
1586     if (!PACKET_get_net_2(pkt, &sversion)) {
1587         al = SSL_AD_DECODE_ERROR;
1588         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, SSL_R_LENGTH_MISMATCH);
1589         goto f_err;
1590     }
1591
1592     s->hello_retry_request = 1;
1593
1594     /* This will fail if it doesn't choose TLSv1.3+ */
1595     errorcode = ssl_choose_client_version(s, sversion, 0, &al);
1596     if (errorcode != 0) {
1597         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, errorcode);
1598         goto f_err;
1599     }
1600
1601     if (!PACKET_get_bytes(pkt, &cipherchars, TLS_CIPHER_LEN)) {
1602         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, SSL_R_LENGTH_MISMATCH);
1603         al = SSL_AD_DECODE_ERROR;
1604         goto f_err;
1605     }
1606
1607     if (!set_client_ciphersuite(s, cipherchars)) {
1608         al = SSL_AD_ILLEGAL_PARAMETER;
1609         goto f_err;
1610     }
1611
1612     if (!PACKET_as_length_prefixed_2(pkt, &extpkt)
1613                /* Must have a non-empty extensions block */
1614             || PACKET_remaining(&extpkt) == 0
1615                /* Must be no trailing data after extensions */
1616             || PACKET_remaining(pkt) != 0) {
1617         al = SSL_AD_DECODE_ERROR;
1618         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, SSL_R_BAD_LENGTH);
1619         goto f_err;
1620     }
1621
1622     if (!tls_collect_extensions(s, &extpkt, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
1623                                 &extensions, &al, NULL, 1)
1624             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
1625                                          extensions, NULL, 0, &al, 1))
1626         goto f_err;
1627
1628     OPENSSL_free(extensions);
1629     extensions = NULL;
1630
1631     if (s->ext.tls13_cookie_len == 0 && s->s3->tmp.pkey != NULL) {
1632         /*
1633          * We didn't receive a cookie or a new key_share so the next
1634          * ClientHello will not change
1635          */
1636         al = SSL_AD_ILLEGAL_PARAMETER;
1637         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST,
1638                SSL_R_NO_CHANGE_FOLLOWING_HRR);
1639         goto f_err;
1640     }
1641
1642     /*
1643      * Re-initialise the Transcript Hash. We're going to prepopulate it with
1644      * a synthetic message_hash in place of ClientHello1.
1645      */
1646     if (!create_synthetic_message_hash(s)) {
1647         al = SSL_AD_INTERNAL_ERROR;
1648         goto f_err;
1649     }
1650
1651     /*
1652      * Add this message to the Transcript Hash. Normally this is done
1653      * automatically prior to the message processing stage. However due to the
1654      * need to create the synthetic message hash, we defer that step until now
1655      * for HRR messages.
1656      */
1657     if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
1658                                 s->init_num + SSL3_HM_HEADER_LENGTH)) {
1659         al = SSL_AD_INTERNAL_ERROR;
1660         SSLerr(SSL_F_TLS_PROCESS_HELLO_RETRY_REQUEST, ERR_R_INTERNAL_ERROR);
1661         goto f_err;
1662     }
1663
1664     return MSG_PROCESS_FINISHED_READING;
1665  f_err:
1666     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1667     ossl_statem_set_error(s);
1668     OPENSSL_free(extensions);
1669     return MSG_PROCESS_ERROR;
1670 }
1671
1672 MSG_PROCESS_RETURN tls_process_server_certificate(SSL *s, PACKET *pkt)
1673 {
1674     int al, i, ret = MSG_PROCESS_ERROR, exp_idx;
1675     unsigned long cert_list_len, cert_len;
1676     X509 *x = NULL;
1677     const unsigned char *certstart, *certbytes;
1678     STACK_OF(X509) *sk = NULL;
1679     EVP_PKEY *pkey = NULL;
1680     size_t chainidx;
1681     unsigned int context = 0;
1682
1683     if ((sk = sk_X509_new_null()) == NULL) {
1684         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_MALLOC_FAILURE);
1685         goto err;
1686     }
1687
1688     if ((SSL_IS_TLS13(s) && !PACKET_get_1(pkt, &context))
1689             || context != 0
1690             || !PACKET_get_net_3(pkt, &cert_list_len)
1691             || PACKET_remaining(pkt) != cert_list_len) {
1692         al = SSL_AD_DECODE_ERROR;
1693         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
1694         goto f_err;
1695     }
1696     for (chainidx = 0; PACKET_remaining(pkt); chainidx++) {
1697         if (!PACKET_get_net_3(pkt, &cert_len)
1698             || !PACKET_get_bytes(pkt, &certbytes, cert_len)) {
1699             al = SSL_AD_DECODE_ERROR;
1700             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1701                    SSL_R_CERT_LENGTH_MISMATCH);
1702             goto f_err;
1703         }
1704
1705         certstart = certbytes;
1706         x = d2i_X509(NULL, (const unsigned char **)&certbytes, cert_len);
1707         if (x == NULL) {
1708             al = SSL_AD_BAD_CERTIFICATE;
1709             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_ASN1_LIB);
1710             goto f_err;
1711         }
1712         if (certbytes != (certstart + cert_len)) {
1713             al = SSL_AD_DECODE_ERROR;
1714             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1715                    SSL_R_CERT_LENGTH_MISMATCH);
1716             goto f_err;
1717         }
1718
1719         if (SSL_IS_TLS13(s)) {
1720             RAW_EXTENSION *rawexts = NULL;
1721             PACKET extensions;
1722
1723             if (!PACKET_get_length_prefixed_2(pkt, &extensions)) {
1724                 al = SSL_AD_DECODE_ERROR;
1725                 SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, SSL_R_BAD_LENGTH);
1726                 goto f_err;
1727             }
1728             if (!tls_collect_extensions(s, &extensions,
1729                                         SSL_EXT_TLS1_3_CERTIFICATE, &rawexts,
1730                                         &al, NULL, chainidx == 0)
1731                 || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE,
1732                                              rawexts, x, chainidx, &al,
1733                                              PACKET_remaining(pkt) == 0)) {
1734                 OPENSSL_free(rawexts);
1735                 goto f_err;
1736             }
1737             OPENSSL_free(rawexts);
1738         }
1739
1740         if (!sk_X509_push(sk, x)) {
1741             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_MALLOC_FAILURE);
1742             goto err;
1743         }
1744         x = NULL;
1745     }
1746
1747     i = ssl_verify_cert_chain(s, sk);
1748     /*
1749      * The documented interface is that SSL_VERIFY_PEER should be set in order
1750      * for client side verification of the server certificate to take place.
1751      * However, historically the code has only checked that *any* flag is set
1752      * to cause server verification to take place. Use of the other flags makes
1753      * no sense in client mode. An attempt to clean up the semantics was
1754      * reverted because at least one application *only* set
1755      * SSL_VERIFY_FAIL_IF_NO_PEER_CERT. Prior to the clean up this still caused
1756      * server verification to take place, after the clean up it silently did
1757      * nothing. SSL_CTX_set_verify()/SSL_set_verify() cannot validate the flags
1758      * sent to them because they are void functions. Therefore, we now use the
1759      * (less clean) historic behaviour of performing validation if any flag is
1760      * set. The *documented* interface remains the same.
1761      */
1762     if (s->verify_mode != SSL_VERIFY_NONE && i <= 0) {
1763         al = ssl_verify_alarm_type(s->verify_result);
1764         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1765                SSL_R_CERTIFICATE_VERIFY_FAILED);
1766         goto f_err;
1767     }
1768     ERR_clear_error();          /* but we keep s->verify_result */
1769     if (i > 1) {
1770         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, i);
1771         al = SSL_AD_HANDSHAKE_FAILURE;
1772         goto f_err;
1773     }
1774
1775     s->session->peer_chain = sk;
1776     /*
1777      * Inconsistency alert: cert_chain does include the peer's certificate,
1778      * which we don't include in statem_srvr.c
1779      */
1780     x = sk_X509_value(sk, 0);
1781     sk = NULL;
1782     /*
1783      * VRS 19990621: possible memory leak; sk=null ==> !sk_pop_free() @end
1784      */
1785
1786     pkey = X509_get0_pubkey(x);
1787
1788     if (pkey == NULL || EVP_PKEY_missing_parameters(pkey)) {
1789         x = NULL;
1790         al = SSL3_AL_FATAL;
1791         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1792                SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
1793         goto f_err;
1794     }
1795
1796     i = ssl_cert_type(x, pkey);
1797     if (i < 0) {
1798         x = NULL;
1799         al = SSL3_AL_FATAL;
1800         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1801                SSL_R_UNKNOWN_CERTIFICATE_TYPE);
1802         goto f_err;
1803     }
1804     /*
1805      * Check certificate type is consistent with ciphersuite. For TLS 1.3
1806      * skip check since TLS 1.3 ciphersuites can be used with any certificate
1807      * type.
1808      */
1809     if (!SSL_IS_TLS13(s)) {
1810         exp_idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
1811         if (exp_idx >= 0 && i != exp_idx
1812             && (exp_idx != SSL_PKEY_GOST_EC ||
1813                 (i != SSL_PKEY_GOST12_512 && i != SSL_PKEY_GOST12_256
1814                  && i != SSL_PKEY_GOST01))) {
1815             x = NULL;
1816             al = SSL_AD_ILLEGAL_PARAMETER;
1817             SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE,
1818                    SSL_R_WRONG_CERTIFICATE_TYPE);
1819             goto f_err;
1820         }
1821     }
1822     s->session->peer_type = i;
1823
1824     X509_free(s->session->peer);
1825     X509_up_ref(x);
1826     s->session->peer = x;
1827     s->session->verify_result = s->verify_result;
1828     x = NULL;
1829
1830     /* Save the current hash state for when we receive the CertificateVerify */
1831     if (SSL_IS_TLS13(s)
1832             && !ssl_handshake_hash(s, s->cert_verify_hash,
1833                                    sizeof(s->cert_verify_hash),
1834                                    &s->cert_verify_hash_len)) {
1835         al = SSL_AD_INTERNAL_ERROR;
1836         SSLerr(SSL_F_TLS_PROCESS_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
1837         goto f_err;
1838     }
1839
1840     ret = MSG_PROCESS_CONTINUE_READING;
1841     goto done;
1842
1843  f_err:
1844     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1845  err:
1846     ossl_statem_set_error(s);
1847  done:
1848     X509_free(x);
1849     sk_X509_pop_free(sk, X509_free);
1850     return ret;
1851 }
1852
1853 static int tls_process_ske_psk_preamble(SSL *s, PACKET *pkt, int *al)
1854 {
1855 #ifndef OPENSSL_NO_PSK
1856     PACKET psk_identity_hint;
1857
1858     /* PSK ciphersuites are preceded by an identity hint */
1859
1860     if (!PACKET_get_length_prefixed_2(pkt, &psk_identity_hint)) {
1861         *al = SSL_AD_DECODE_ERROR;
1862         SSLerr(SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE, SSL_R_LENGTH_MISMATCH);
1863         return 0;
1864     }
1865
1866     /*
1867      * Store PSK identity hint for later use, hint is used in
1868      * tls_construct_client_key_exchange.  Assume that the maximum length of
1869      * a PSK identity hint can be as long as the maximum length of a PSK
1870      * identity.
1871      */
1872     if (PACKET_remaining(&psk_identity_hint) > PSK_MAX_IDENTITY_LEN) {
1873         *al = SSL_AD_HANDSHAKE_FAILURE;
1874         SSLerr(SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE, SSL_R_DATA_LENGTH_TOO_LONG);
1875         return 0;
1876     }
1877
1878     if (PACKET_remaining(&psk_identity_hint) == 0) {
1879         OPENSSL_free(s->session->psk_identity_hint);
1880         s->session->psk_identity_hint = NULL;
1881     } else if (!PACKET_strndup(&psk_identity_hint,
1882                                &s->session->psk_identity_hint)) {
1883         *al = SSL_AD_INTERNAL_ERROR;
1884         return 0;
1885     }
1886
1887     return 1;
1888 #else
1889     SSLerr(SSL_F_TLS_PROCESS_SKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
1890     *al = SSL_AD_INTERNAL_ERROR;
1891     return 0;
1892 #endif
1893 }
1894
1895 static int tls_process_ske_srp(SSL *s, PACKET *pkt, EVP_PKEY **pkey, int *al)
1896 {
1897 #ifndef OPENSSL_NO_SRP
1898     PACKET prime, generator, salt, server_pub;
1899
1900     if (!PACKET_get_length_prefixed_2(pkt, &prime)
1901         || !PACKET_get_length_prefixed_2(pkt, &generator)
1902         || !PACKET_get_length_prefixed_1(pkt, &salt)
1903         || !PACKET_get_length_prefixed_2(pkt, &server_pub)) {
1904         *al = SSL_AD_DECODE_ERROR;
1905         SSLerr(SSL_F_TLS_PROCESS_SKE_SRP, SSL_R_LENGTH_MISMATCH);
1906         return 0;
1907     }
1908
1909     /* TODO(size_t): Convert BN_bin2bn() calls */
1910     if ((s->srp_ctx.N =
1911          BN_bin2bn(PACKET_data(&prime),
1912                    (int)PACKET_remaining(&prime), NULL)) == NULL
1913         || (s->srp_ctx.g =
1914             BN_bin2bn(PACKET_data(&generator),
1915                       (int)PACKET_remaining(&generator), NULL)) == NULL
1916         || (s->srp_ctx.s =
1917             BN_bin2bn(PACKET_data(&salt),
1918                       (int)PACKET_remaining(&salt), NULL)) == NULL
1919         || (s->srp_ctx.B =
1920             BN_bin2bn(PACKET_data(&server_pub),
1921                       (int)PACKET_remaining(&server_pub), NULL)) == NULL) {
1922         *al = SSL_AD_INTERNAL_ERROR;
1923         SSLerr(SSL_F_TLS_PROCESS_SKE_SRP, ERR_R_BN_LIB);
1924         return 0;
1925     }
1926
1927     if (!srp_verify_server_param(s, al)) {
1928         *al = SSL_AD_DECODE_ERROR;
1929         SSLerr(SSL_F_TLS_PROCESS_SKE_SRP, SSL_R_BAD_SRP_PARAMETERS);
1930         return 0;
1931     }
1932
1933     /* We must check if there is a certificate */
1934     if (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aRSA | SSL_aDSS))
1935         *pkey = X509_get0_pubkey(s->session->peer);
1936
1937     return 1;
1938 #else
1939     SSLerr(SSL_F_TLS_PROCESS_SKE_SRP, ERR_R_INTERNAL_ERROR);
1940     *al = SSL_AD_INTERNAL_ERROR;
1941     return 0;
1942 #endif
1943 }
1944
1945 static int tls_process_ske_dhe(SSL *s, PACKET *pkt, EVP_PKEY **pkey, int *al)
1946 {
1947 #ifndef OPENSSL_NO_DH
1948     PACKET prime, generator, pub_key;
1949     EVP_PKEY *peer_tmp = NULL;
1950
1951     DH *dh = NULL;
1952     BIGNUM *p = NULL, *g = NULL, *bnpub_key = NULL;
1953
1954     int check_bits = 0;
1955
1956     if (!PACKET_get_length_prefixed_2(pkt, &prime)
1957         || !PACKET_get_length_prefixed_2(pkt, &generator)
1958         || !PACKET_get_length_prefixed_2(pkt, &pub_key)) {
1959         *al = SSL_AD_DECODE_ERROR;
1960         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, SSL_R_LENGTH_MISMATCH);
1961         return 0;
1962     }
1963
1964     peer_tmp = EVP_PKEY_new();
1965     dh = DH_new();
1966
1967     if (peer_tmp == NULL || dh == NULL) {
1968         *al = SSL_AD_INTERNAL_ERROR;
1969         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_MALLOC_FAILURE);
1970         goto err;
1971     }
1972
1973     /* TODO(size_t): Convert these calls */
1974     p = BN_bin2bn(PACKET_data(&prime), (int)PACKET_remaining(&prime), NULL);
1975     g = BN_bin2bn(PACKET_data(&generator), (int)PACKET_remaining(&generator),
1976                   NULL);
1977     bnpub_key = BN_bin2bn(PACKET_data(&pub_key),
1978                           (int)PACKET_remaining(&pub_key), NULL);
1979     if (p == NULL || g == NULL || bnpub_key == NULL) {
1980         *al = SSL_AD_INTERNAL_ERROR;
1981         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_BN_LIB);
1982         goto err;
1983     }
1984
1985     /* test non-zero pubkey */
1986     if (BN_is_zero(bnpub_key)) {
1987         *al = SSL_AD_DECODE_ERROR;
1988         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, SSL_R_BAD_DH_VALUE);
1989         goto err;
1990     }
1991
1992     if (!DH_set0_pqg(dh, p, NULL, g)) {
1993         *al = SSL_AD_INTERNAL_ERROR;
1994         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_BN_LIB);
1995         goto err;
1996     }
1997     p = g = NULL;
1998
1999     if (DH_check_params(dh, &check_bits) == 0 || check_bits != 0) {
2000         *al = SSL_AD_DECODE_ERROR;
2001         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, SSL_R_BAD_DH_VALUE);
2002         goto err;
2003     }
2004
2005     if (!DH_set0_key(dh, bnpub_key, NULL)) {
2006         *al = SSL_AD_INTERNAL_ERROR;
2007         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_BN_LIB);
2008         goto err;
2009     }
2010     bnpub_key = NULL;
2011
2012     if (!ssl_security(s, SSL_SECOP_TMP_DH, DH_security_bits(dh), 0, dh)) {
2013         *al = SSL_AD_HANDSHAKE_FAILURE;
2014         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, SSL_R_DH_KEY_TOO_SMALL);
2015         goto err;
2016     }
2017
2018     if (EVP_PKEY_assign_DH(peer_tmp, dh) == 0) {
2019         *al = SSL_AD_INTERNAL_ERROR;
2020         SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_EVP_LIB);
2021         goto err;
2022     }
2023
2024     s->s3->peer_tmp = peer_tmp;
2025
2026     /*
2027      * FIXME: This makes assumptions about which ciphersuites come with
2028      * public keys. We should have a less ad-hoc way of doing this
2029      */
2030     if (s->s3->tmp.new_cipher->algorithm_auth & (SSL_aRSA | SSL_aDSS))
2031         *pkey = X509_get0_pubkey(s->session->peer);
2032     /* else anonymous DH, so no certificate or pkey. */
2033
2034     return 1;
2035
2036  err:
2037     BN_free(p);
2038     BN_free(g);
2039     BN_free(bnpub_key);
2040     DH_free(dh);
2041     EVP_PKEY_free(peer_tmp);
2042
2043     return 0;
2044 #else
2045     SSLerr(SSL_F_TLS_PROCESS_SKE_DHE, ERR_R_INTERNAL_ERROR);
2046     *al = SSL_AD_INTERNAL_ERROR;
2047     return 0;
2048 #endif
2049 }
2050
2051 static int tls_process_ske_ecdhe(SSL *s, PACKET *pkt, EVP_PKEY **pkey, int *al)
2052 {
2053 #ifndef OPENSSL_NO_EC
2054     PACKET encoded_pt;
2055     const unsigned char *ecparams;
2056     int curve_nid;
2057     unsigned int curve_flags;
2058     EVP_PKEY_CTX *pctx = NULL;
2059
2060     /*
2061      * Extract elliptic curve parameters and the server's ephemeral ECDH
2062      * public key. For now we only support named (not generic) curves and
2063      * ECParameters in this case is just three bytes.
2064      */
2065     if (!PACKET_get_bytes(pkt, &ecparams, 3)) {
2066         *al = SSL_AD_DECODE_ERROR;
2067         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, SSL_R_LENGTH_TOO_SHORT);
2068         return 0;
2069     }
2070     /*
2071      * Check curve is one of our preferences, if not server has sent an
2072      * invalid curve. ECParameters is 3 bytes.
2073      */
2074     if (!tls1_check_curve(s, ecparams, 3)) {
2075         *al = SSL_AD_DECODE_ERROR;
2076         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, SSL_R_WRONG_CURVE);
2077         return 0;
2078     }
2079
2080     curve_nid = tls1_ec_curve_id2nid(*(ecparams + 2), &curve_flags);
2081
2082     if (curve_nid == 0) {
2083         *al = SSL_AD_INTERNAL_ERROR;
2084         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE,
2085                SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
2086         return 0;
2087     }
2088
2089     if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
2090         EVP_PKEY *key = EVP_PKEY_new();
2091
2092         if (key == NULL || !EVP_PKEY_set_type(key, curve_nid)) {
2093             *al = SSL_AD_INTERNAL_ERROR;
2094             SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, ERR_R_EVP_LIB);
2095             EVP_PKEY_free(key);
2096             return 0;
2097         }
2098         s->s3->peer_tmp = key;
2099     } else {
2100         /* Set up EVP_PKEY with named curve as parameters */
2101         pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
2102         if (pctx == NULL
2103             || EVP_PKEY_paramgen_init(pctx) <= 0
2104             || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, curve_nid) <= 0
2105             || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
2106             *al = SSL_AD_INTERNAL_ERROR;
2107             SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, ERR_R_EVP_LIB);
2108             EVP_PKEY_CTX_free(pctx);
2109             return 0;
2110         }
2111         EVP_PKEY_CTX_free(pctx);
2112         pctx = NULL;
2113     }
2114
2115     if (!PACKET_get_length_prefixed_1(pkt, &encoded_pt)) {
2116         *al = SSL_AD_DECODE_ERROR;
2117         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, SSL_R_LENGTH_MISMATCH);
2118         return 0;
2119     }
2120
2121     if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
2122                                         PACKET_data(&encoded_pt),
2123                                         PACKET_remaining(&encoded_pt))) {
2124         *al = SSL_AD_DECODE_ERROR;
2125         SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, SSL_R_BAD_ECPOINT);
2126         return 0;
2127     }
2128
2129     /*
2130      * The ECC/TLS specification does not mention the use of DSA to sign
2131      * ECParameters in the server key exchange message. We do support RSA
2132      * and ECDSA.
2133      */
2134     if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aECDSA)
2135         *pkey = X509_get0_pubkey(s->session->peer);
2136     else if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aRSA)
2137         *pkey = X509_get0_pubkey(s->session->peer);
2138     /* else anonymous ECDH, so no certificate or pkey. */
2139
2140     return 1;
2141 #else
2142     SSLerr(SSL_F_TLS_PROCESS_SKE_ECDHE, ERR_R_INTERNAL_ERROR);
2143     *al = SSL_AD_INTERNAL_ERROR;
2144     return 0;
2145 #endif
2146 }
2147
2148 MSG_PROCESS_RETURN tls_process_key_exchange(SSL *s, PACKET *pkt)
2149 {
2150     int al = -1;
2151     long alg_k;
2152     EVP_PKEY *pkey = NULL;
2153     EVP_MD_CTX *md_ctx = NULL;
2154     EVP_PKEY_CTX *pctx = NULL;
2155     PACKET save_param_start, signature;
2156
2157     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2158
2159     save_param_start = *pkt;
2160
2161 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DH)
2162     EVP_PKEY_free(s->s3->peer_tmp);
2163     s->s3->peer_tmp = NULL;
2164 #endif
2165
2166     if (alg_k & SSL_PSK) {
2167         if (!tls_process_ske_psk_preamble(s, pkt, &al))
2168             goto err;
2169     }
2170
2171     /* Nothing else to do for plain PSK or RSAPSK */
2172     if (alg_k & (SSL_kPSK | SSL_kRSAPSK)) {
2173     } else if (alg_k & SSL_kSRP) {
2174         if (!tls_process_ske_srp(s, pkt, &pkey, &al))
2175             goto err;
2176     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
2177         if (!tls_process_ske_dhe(s, pkt, &pkey, &al))
2178             goto err;
2179     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
2180         if (!tls_process_ske_ecdhe(s, pkt, &pkey, &al))
2181             goto err;
2182     } else if (alg_k) {
2183         al = SSL_AD_UNEXPECTED_MESSAGE;
2184         SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_UNEXPECTED_MESSAGE);
2185         goto err;
2186     }
2187
2188     /* if it was signed, check the signature */
2189     if (pkey != NULL) {
2190         PACKET params;
2191         int maxsig;
2192         const EVP_MD *md = NULL;
2193
2194         /*
2195          * |pkt| now points to the beginning of the signature, so the difference
2196          * equals the length of the parameters.
2197          */
2198         if (!PACKET_get_sub_packet(&save_param_start, &params,
2199                                    PACKET_remaining(&save_param_start) -
2200                                    PACKET_remaining(pkt))) {
2201             al = SSL_AD_INTERNAL_ERROR;
2202             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2203             goto err;
2204         }
2205
2206         if (SSL_USE_SIGALGS(s)) {
2207             unsigned int sigalg;
2208             int rv;
2209
2210             if (!PACKET_get_net_2(pkt, &sigalg)) {
2211                 al = SSL_AD_DECODE_ERROR;
2212                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_LENGTH_TOO_SHORT);
2213                 goto err;
2214             }
2215             rv = tls12_check_peer_sigalg(s, sigalg, pkey);
2216             if (rv == -1) {
2217                 al = SSL_AD_INTERNAL_ERROR;
2218                 goto err;
2219             } else if (rv == 0) {
2220                 al = SSL_AD_DECODE_ERROR;
2221                 goto err;
2222             }
2223 #ifdef SSL_DEBUG
2224             fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
2225 #endif
2226         } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) {
2227             al = SSL_AD_INTERNAL_ERROR;
2228             goto err;
2229         }
2230
2231         md = ssl_md(s->s3->tmp.peer_sigalg->hash_idx);
2232
2233         if (!PACKET_get_length_prefixed_2(pkt, &signature)
2234             || PACKET_remaining(pkt) != 0) {
2235             al = SSL_AD_DECODE_ERROR;
2236             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
2237             goto err;
2238         }
2239         maxsig = EVP_PKEY_size(pkey);
2240         if (maxsig < 0) {
2241             al = SSL_AD_INTERNAL_ERROR;
2242             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2243             goto err;
2244         }
2245
2246         /*
2247          * Check signature length
2248          */
2249         if (PACKET_remaining(&signature) > (size_t)maxsig) {
2250             /* wrong packet length */
2251             al = SSL_AD_DECODE_ERROR;
2252             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE,
2253                    SSL_R_WRONG_SIGNATURE_LENGTH);
2254             goto err;
2255         }
2256
2257         md_ctx = EVP_MD_CTX_new();
2258         if (md_ctx == NULL) {
2259             al = SSL_AD_INTERNAL_ERROR;
2260             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2261             goto err;
2262         }
2263
2264         if (EVP_DigestVerifyInit(md_ctx, &pctx, md, NULL, pkey) <= 0) {
2265             al = SSL_AD_INTERNAL_ERROR;
2266             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_EVP_LIB);
2267             goto err;
2268         }
2269         if (SSL_USE_PSS(s)) {
2270             if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
2271                 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
2272                                                 RSA_PSS_SALTLEN_DIGEST) <= 0) {
2273                 al = SSL_AD_INTERNAL_ERROR;
2274                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_EVP_LIB);
2275                 goto err;
2276             }
2277         }
2278         if (EVP_DigestVerifyUpdate(md_ctx, &(s->s3->client_random[0]),
2279                                    SSL3_RANDOM_SIZE) <= 0
2280                 || EVP_DigestVerifyUpdate(md_ctx, &(s->s3->server_random[0]),
2281                                           SSL3_RANDOM_SIZE) <= 0
2282                 || EVP_DigestVerifyUpdate(md_ctx, PACKET_data(&params),
2283                                           PACKET_remaining(&params)) <= 0) {
2284             al = SSL_AD_INTERNAL_ERROR;
2285             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_EVP_LIB);
2286             goto err;
2287         }
2288         if (EVP_DigestVerifyFinal(md_ctx, PACKET_data(&signature),
2289                                   PACKET_remaining(&signature)) <= 0) {
2290             /* bad signature */
2291             al = SSL_AD_DECRYPT_ERROR;
2292             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_BAD_SIGNATURE);
2293             goto err;
2294         }
2295         EVP_MD_CTX_free(md_ctx);
2296         md_ctx = NULL;
2297     } else {
2298         /* aNULL, aSRP or PSK do not need public keys */
2299         if (!(s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
2300             && !(alg_k & SSL_PSK)) {
2301             /* Might be wrong key type, check it */
2302             if (ssl3_check_cert_and_algorithm(s)) {
2303                 /* Otherwise this shouldn't happen */
2304                 al = SSL_AD_INTERNAL_ERROR;
2305                 SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2306             } else {
2307                 al = SSL_AD_DECODE_ERROR;
2308             }
2309             goto err;
2310         }
2311         /* still data left over */
2312         if (PACKET_remaining(pkt) != 0) {
2313             al = SSL_AD_DECODE_ERROR;
2314             SSLerr(SSL_F_TLS_PROCESS_KEY_EXCHANGE, SSL_R_EXTRA_DATA_IN_MESSAGE);
2315             goto err;
2316         }
2317     }
2318
2319     return MSG_PROCESS_CONTINUE_READING;
2320  err:
2321     if (al != -1)
2322         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2323     ossl_statem_set_error(s);
2324     EVP_MD_CTX_free(md_ctx);
2325     return MSG_PROCESS_ERROR;
2326 }
2327
2328 MSG_PROCESS_RETURN tls_process_certificate_request(SSL *s, PACKET *pkt)
2329 {
2330     int ret = MSG_PROCESS_ERROR;
2331     int al = SSL_AD_DECODE_ERROR;
2332     size_t i;
2333
2334     /* Clear certificate validity flags */
2335     for (i = 0; i < SSL_PKEY_NUM; i++)
2336         s->s3->tmp.valid_flags[i] = 0;
2337
2338     if (SSL_IS_TLS13(s)) {
2339         PACKET reqctx, extensions;
2340         RAW_EXTENSION *rawexts = NULL;
2341
2342         /* Free and zero certificate types: it is not present in TLS 1.3 */
2343         OPENSSL_free(s->s3->tmp.ctype);
2344         s->s3->tmp.ctype = NULL;
2345         s->s3->tmp.ctype_len = 0;
2346
2347         /* TODO(TLS1.3) need to process request context, for now ignore */
2348         if (!PACKET_get_length_prefixed_1(pkt, &reqctx)) {
2349             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2350                    SSL_R_LENGTH_MISMATCH);
2351             goto err;
2352         }
2353
2354         if (!PACKET_get_length_prefixed_2(pkt, &extensions)) {
2355                 SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, SSL_R_BAD_LENGTH);
2356                 goto err;
2357         }
2358         if (!tls_collect_extensions(s, &extensions,
2359                                     SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
2360                                     &rawexts, &al, NULL, 1)
2361             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
2362                                          rawexts, NULL, 0, &al, 1)) {
2363             OPENSSL_free(rawexts);
2364             goto err;
2365         }
2366         OPENSSL_free(rawexts);
2367         if (!tls1_process_sigalgs(s)) {
2368             al = SSL_AD_INTERNAL_ERROR;
2369             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_MALLOC_FAILURE);
2370             goto err;
2371         }
2372     } else {
2373         PACKET ctypes;
2374
2375         /* get the certificate types */
2376         if (!PACKET_get_length_prefixed_1(pkt, &ctypes)) {
2377             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2378                    SSL_R_LENGTH_MISMATCH);
2379             goto err;
2380         }
2381
2382         if (!PACKET_memdup(&ctypes, &s->s3->tmp.ctype, &s->s3->tmp.ctype_len)) {
2383             al = SSL_AD_INTERNAL_ERROR;
2384             SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
2385             goto err;
2386         }
2387
2388         if (SSL_USE_SIGALGS(s)) {
2389             PACKET sigalgs;
2390
2391             if (!PACKET_get_length_prefixed_2(pkt, &sigalgs)) {
2392                 SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2393                        SSL_R_LENGTH_MISMATCH);
2394                 goto err;
2395             }
2396
2397             if (!tls1_save_sigalgs(s, &sigalgs)) {
2398                 SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2399                        SSL_R_SIGNATURE_ALGORITHMS_ERROR);
2400                 goto err;
2401             }
2402             if (!tls1_process_sigalgs(s)) {
2403                 al = SSL_AD_INTERNAL_ERROR;
2404                 SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST,
2405                        ERR_R_MALLOC_FAILURE);
2406                 goto err;
2407             }
2408         }
2409
2410         /* get the CA RDNs */
2411         if (!parse_ca_names(s, pkt, &al))
2412             goto err;
2413     }
2414
2415     if (PACKET_remaining(pkt) != 0) {
2416         SSLerr(SSL_F_TLS_PROCESS_CERTIFICATE_REQUEST, SSL_R_LENGTH_MISMATCH);
2417         goto err;
2418     }
2419
2420     /* we should setup a certificate to return.... */
2421     s->s3->tmp.cert_req = 1;
2422
2423     ret = MSG_PROCESS_CONTINUE_PROCESSING;
2424     goto done;
2425  err:
2426     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2427     ossl_statem_set_error(s);
2428  done:
2429     return ret;
2430 }
2431
2432 MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL *s, PACKET *pkt)
2433 {
2434     int al = SSL_AD_DECODE_ERROR;
2435     unsigned int ticklen;
2436     unsigned long ticket_lifetime_hint, age_add = 0;
2437     unsigned int sess_len;
2438     RAW_EXTENSION *exts = NULL;
2439
2440     if (!PACKET_get_net_4(pkt, &ticket_lifetime_hint)
2441         || (SSL_IS_TLS13(s) && !PACKET_get_net_4(pkt, &age_add))
2442         || !PACKET_get_net_2(pkt, &ticklen)
2443         || (!SSL_IS_TLS13(s) && PACKET_remaining(pkt) != ticklen)
2444         || (SSL_IS_TLS13(s)
2445             && (ticklen == 0 || PACKET_remaining(pkt) < ticklen))) {
2446         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, SSL_R_LENGTH_MISMATCH);
2447         goto f_err;
2448     }
2449
2450     /*
2451      * Server is allowed to change its mind (in <=TLSv1.2) and send an empty
2452      * ticket. We already checked this TLSv1.3 case above, so it should never
2453      * be 0 here in that instance
2454      */
2455     if (ticklen == 0)
2456         return MSG_PROCESS_CONTINUE_READING;
2457
2458     /*
2459      * Sessions must be immutable once they go into the session cache. Otherwise
2460      * we can get multi-thread problems. Therefore we don't "update" sessions,
2461      * we replace them with a duplicate. In TLSv1.3 we need to do this every
2462      * time a NewSessionTicket arrives because those messages arrive
2463      * post-handshake and the session may have already gone into the session
2464      * cache.
2465      */
2466     if (SSL_IS_TLS13(s) || s->session->session_id_length > 0) {
2467         int i = s->session_ctx->session_cache_mode;
2468         SSL_SESSION *new_sess;
2469         /*
2470          * We reused an existing session, so we need to replace it with a new
2471          * one
2472          */
2473         if (i & SSL_SESS_CACHE_CLIENT) {
2474             /*
2475              * Remove the old session from the cache. We carry on if this fails
2476              */
2477             SSL_CTX_remove_session(s->session_ctx, s->session);
2478         }
2479
2480         if ((new_sess = ssl_session_dup(s->session, 0)) == 0) {
2481             al = SSL_AD_INTERNAL_ERROR;
2482             SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_MALLOC_FAILURE);
2483             goto f_err;
2484         }
2485
2486         SSL_SESSION_free(s->session);
2487         s->session = new_sess;
2488     }
2489
2490     /*
2491      * Technically the cast to long here is not guaranteed by the C standard -
2492      * but we use it elsewhere, so this should be ok.
2493      */
2494     s->session->time = (long)time(NULL);
2495
2496     OPENSSL_free(s->session->ext.tick);
2497     s->session->ext.tick = NULL;
2498     s->session->ext.ticklen = 0;
2499
2500     s->session->ext.tick = OPENSSL_malloc(ticklen);
2501     if (s->session->ext.tick == NULL) {
2502         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_MALLOC_FAILURE);
2503         goto err;
2504     }
2505     if (!PACKET_copy_bytes(pkt, s->session->ext.tick, ticklen)) {
2506         al = SSL_AD_DECODE_ERROR;
2507         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, SSL_R_LENGTH_MISMATCH);
2508         goto f_err;
2509     }
2510
2511     s->session->ext.tick_lifetime_hint = ticket_lifetime_hint;
2512     s->session->ext.tick_age_add = age_add;
2513     s->session->ext.ticklen = ticklen;
2514
2515     if (SSL_IS_TLS13(s)) {
2516         PACKET extpkt;
2517
2518         if (!PACKET_as_length_prefixed_2(pkt, &extpkt)
2519                 || !tls_collect_extensions(s, &extpkt,
2520                                            SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
2521                                            &exts, &al, NULL, 1)
2522                 || !tls_parse_all_extensions(s,
2523                                              SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
2524                                              exts, NULL, 0, &al, 1)) {
2525             SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, SSL_R_BAD_EXTENSION);
2526             goto f_err;
2527         }
2528     }
2529
2530     /*
2531      * There are two ways to detect a resumed ticket session. One is to set
2532      * an appropriate session ID and then the server must return a match in
2533      * ServerHello. This allows the normal client session ID matching to work
2534      * and we know much earlier that the ticket has been accepted. The
2535      * other way is to set zero length session ID when the ticket is
2536      * presented and rely on the handshake to determine session resumption.
2537      * We choose the former approach because this fits in with assumptions
2538      * elsewhere in OpenSSL. The session ID is set to the SHA256 (or SHA1 is
2539      * SHA256 is disabled) hash of the ticket.
2540      */
2541     /*
2542      * TODO(size_t): we use sess_len here because EVP_Digest expects an int
2543      * but s->session->session_id_length is a size_t
2544      */
2545     if (!EVP_Digest(s->session->ext.tick, ticklen,
2546                     s->session->session_id, &sess_len,
2547                     EVP_sha256(), NULL)) {
2548         SSLerr(SSL_F_TLS_PROCESS_NEW_SESSION_TICKET, ERR_R_EVP_LIB);
2549         goto err;
2550     }
2551     s->session->session_id_length = sess_len;
2552
2553     /* This is a standalone message in TLSv1.3, so there is no more to read */
2554     if (SSL_IS_TLS13(s)) {
2555         OPENSSL_free(exts);
2556         ssl_update_cache(s, SSL_SESS_CACHE_CLIENT);
2557         return MSG_PROCESS_FINISHED_READING;
2558     }
2559
2560     return MSG_PROCESS_CONTINUE_READING;
2561  f_err:
2562     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2563  err:
2564     ossl_statem_set_error(s);
2565     OPENSSL_free(exts);
2566     return MSG_PROCESS_ERROR;
2567 }
2568
2569 /*
2570  * In TLSv1.3 this is called from the extensions code, otherwise it is used to
2571  * parse a separate message. Returns 1 on success or 0 on failure. On failure
2572  * |*al| is populated with a suitable alert code.
2573  */
2574 int tls_process_cert_status_body(SSL *s, PACKET *pkt, int *al)
2575 {
2576     size_t resplen;
2577     unsigned int type;
2578
2579     if (!PACKET_get_1(pkt, &type)
2580         || type != TLSEXT_STATUSTYPE_ocsp) {
2581         *al = SSL_AD_DECODE_ERROR;
2582         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS_BODY,
2583                SSL_R_UNSUPPORTED_STATUS_TYPE);
2584         return 0;
2585     }
2586     if (!PACKET_get_net_3_len(pkt, &resplen)
2587         || PACKET_remaining(pkt) != resplen) {
2588         *al = SSL_AD_DECODE_ERROR;
2589         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS_BODY, SSL_R_LENGTH_MISMATCH);
2590         return 0;
2591     }
2592     s->ext.ocsp.resp = OPENSSL_malloc(resplen);
2593     if (s->ext.ocsp.resp == NULL) {
2594         *al = SSL_AD_INTERNAL_ERROR;
2595         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS_BODY, ERR_R_MALLOC_FAILURE);
2596         return 0;
2597     }
2598     if (!PACKET_copy_bytes(pkt, s->ext.ocsp.resp, resplen)) {
2599         *al = SSL_AD_DECODE_ERROR;
2600         SSLerr(SSL_F_TLS_PROCESS_CERT_STATUS_BODY, SSL_R_LENGTH_MISMATCH);
2601         return 0;
2602     }
2603     s->ext.ocsp.resp_len = resplen;
2604
2605     return 1;
2606 }
2607
2608
2609 MSG_PROCESS_RETURN tls_process_cert_status(SSL *s, PACKET *pkt)
2610 {
2611     int al;
2612
2613     if (!tls_process_cert_status_body(s, pkt, &al)) {
2614         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2615         ossl_statem_set_error(s);
2616         return MSG_PROCESS_ERROR;
2617     }
2618
2619     return MSG_PROCESS_CONTINUE_READING;
2620 }
2621
2622 /*
2623  * Perform miscellaneous checks and processing after we have received the
2624  * server's initial flight. In TLS1.3 this is after the Server Finished message.
2625  * In <=TLS1.2 this is after the ServerDone message. Returns 1 on success or 0
2626  * on failure.
2627  */
2628 int tls_process_initial_server_flight(SSL *s, int *al)
2629 {
2630     /*
2631      * at this point we check that we have the required stuff from
2632      * the server
2633      */
2634     if (!ssl3_check_cert_and_algorithm(s)) {
2635         *al = SSL_AD_HANDSHAKE_FAILURE;
2636         return 0;
2637     }
2638
2639     /*
2640      * Call the ocsp status callback if needed. The |ext.ocsp.resp| and
2641      * |ext.ocsp.resp_len| values will be set if we actually received a status
2642      * message, or NULL and -1 otherwise
2643      */
2644     if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing
2645             && s->ctx->ext.status_cb != NULL) {
2646         int ret = s->ctx->ext.status_cb(s, s->ctx->ext.status_arg);
2647
2648         if (ret == 0) {
2649             *al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
2650             SSLerr(SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT,
2651                    SSL_R_INVALID_STATUS_RESPONSE);
2652             return 0;
2653         }
2654         if (ret < 0) {
2655             *al = SSL_AD_INTERNAL_ERROR;
2656             SSLerr(SSL_F_TLS_PROCESS_INITIAL_SERVER_FLIGHT,
2657                    ERR_R_MALLOC_FAILURE);
2658             return 0;
2659         }
2660     }
2661 #ifndef OPENSSL_NO_CT
2662     if (s->ct_validation_callback != NULL) {
2663         /* Note we validate the SCTs whether or not we abort on error */
2664         if (!ssl_validate_ct(s) && (s->verify_mode & SSL_VERIFY_PEER)) {
2665             *al = SSL_AD_HANDSHAKE_FAILURE;
2666             return 0;
2667         }
2668     }
2669 #endif
2670
2671     return 1;
2672 }
2673
2674 MSG_PROCESS_RETURN tls_process_server_done(SSL *s, PACKET *pkt)
2675 {
2676     int al = SSL_AD_INTERNAL_ERROR;
2677
2678     if (PACKET_remaining(pkt) > 0) {
2679         /* should contain no data */
2680         al = SSL_AD_DECODE_ERROR;
2681         SSLerr(SSL_F_TLS_PROCESS_SERVER_DONE, SSL_R_LENGTH_MISMATCH);
2682         goto err;
2683     }
2684 #ifndef OPENSSL_NO_SRP
2685     if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
2686         if (SRP_Calc_A_param(s) <= 0) {
2687             SSLerr(SSL_F_TLS_PROCESS_SERVER_DONE, SSL_R_SRP_A_CALC);
2688             goto err;
2689         }
2690     }
2691 #endif
2692
2693     /*
2694      * Error queue messages are generated directly by this function
2695      */
2696     if (!tls_process_initial_server_flight(s, &al))
2697         goto err;
2698
2699     return MSG_PROCESS_FINISHED_READING;
2700
2701  err:
2702     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2703     ossl_statem_set_error(s);
2704     return MSG_PROCESS_ERROR;
2705 }
2706
2707 static int tls_construct_cke_psk_preamble(SSL *s, WPACKET *pkt, int *al)
2708 {
2709 #ifndef OPENSSL_NO_PSK
2710     int ret = 0;
2711     /*
2712      * The callback needs PSK_MAX_IDENTITY_LEN + 1 bytes to return a
2713      * \0-terminated identity. The last byte is for us for simulating
2714      * strnlen.
2715      */
2716     char identity[PSK_MAX_IDENTITY_LEN + 1];
2717     size_t identitylen = 0;
2718     unsigned char psk[PSK_MAX_PSK_LEN];
2719     unsigned char *tmppsk = NULL;
2720     char *tmpidentity = NULL;
2721     size_t psklen = 0;
2722
2723     if (s->psk_client_callback == NULL) {
2724         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, SSL_R_PSK_NO_CLIENT_CB);
2725         *al = SSL_AD_INTERNAL_ERROR;
2726         goto err;
2727     }
2728
2729     memset(identity, 0, sizeof(identity));
2730
2731     psklen = s->psk_client_callback(s, s->session->psk_identity_hint,
2732                                     identity, sizeof(identity) - 1,
2733                                     psk, sizeof(psk));
2734
2735     if (psklen > PSK_MAX_PSK_LEN) {
2736         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2737         *al = SSL_AD_HANDSHAKE_FAILURE;
2738         goto err;
2739     } else if (psklen == 0) {
2740         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE,
2741                SSL_R_PSK_IDENTITY_NOT_FOUND);
2742         *al = SSL_AD_HANDSHAKE_FAILURE;
2743         goto err;
2744     }
2745
2746     identitylen = strlen(identity);
2747     if (identitylen > PSK_MAX_IDENTITY_LEN) {
2748         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2749         *al = SSL_AD_HANDSHAKE_FAILURE;
2750         goto err;
2751     }
2752
2753     tmppsk = OPENSSL_memdup(psk, psklen);
2754     tmpidentity = OPENSSL_strdup(identity);
2755     if (tmppsk == NULL || tmpidentity == NULL) {
2756         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_MALLOC_FAILURE);
2757         *al = SSL_AD_INTERNAL_ERROR;
2758         goto err;
2759     }
2760
2761     OPENSSL_free(s->s3->tmp.psk);
2762     s->s3->tmp.psk = tmppsk;
2763     s->s3->tmp.psklen = psklen;
2764     tmppsk = NULL;
2765     OPENSSL_free(s->session->psk_identity);
2766     s->session->psk_identity = tmpidentity;
2767     tmpidentity = NULL;
2768
2769     if (!WPACKET_sub_memcpy_u16(pkt, identity, identitylen))  {
2770         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2771         *al = SSL_AD_INTERNAL_ERROR;
2772         goto err;
2773     }
2774
2775     ret = 1;
2776
2777  err:
2778     OPENSSL_cleanse(psk, psklen);
2779     OPENSSL_cleanse(identity, sizeof(identity));
2780     OPENSSL_clear_free(tmppsk, psklen);
2781     OPENSSL_clear_free(tmpidentity, identitylen);
2782
2783     return ret;
2784 #else
2785     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2786     *al = SSL_AD_INTERNAL_ERROR;
2787     return 0;
2788 #endif
2789 }
2790
2791 static int tls_construct_cke_rsa(SSL *s, WPACKET *pkt, int *al)
2792 {
2793 #ifndef OPENSSL_NO_RSA
2794     unsigned char *encdata = NULL;
2795     EVP_PKEY *pkey = NULL;
2796     EVP_PKEY_CTX *pctx = NULL;
2797     size_t enclen;
2798     unsigned char *pms = NULL;
2799     size_t pmslen = 0;
2800
2801     if (s->session->peer == NULL) {
2802         /*
2803          * We should always have a server certificate with SSL_kRSA.
2804          */
2805         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2806         return 0;
2807     }
2808
2809     pkey = X509_get0_pubkey(s->session->peer);
2810     if (EVP_PKEY_get0_RSA(pkey) == NULL) {
2811         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2812         return 0;
2813     }
2814
2815     pmslen = SSL_MAX_MASTER_KEY_LENGTH;
2816     pms = OPENSSL_malloc(pmslen);
2817     if (pms == NULL) {
2818         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_MALLOC_FAILURE);
2819         *al = SSL_AD_INTERNAL_ERROR;
2820         return 0;
2821     }
2822
2823     pms[0] = s->client_version >> 8;
2824     pms[1] = s->client_version & 0xff;
2825     /* TODO(size_t): Convert this function */
2826     if (RAND_bytes(pms + 2, (int)(pmslen - 2)) <= 0) {
2827         goto err;
2828     }
2829
2830     /* Fix buf for TLS and beyond */
2831     if (s->version > SSL3_VERSION && !WPACKET_start_sub_packet_u16(pkt)) {
2832         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2833         goto err;
2834     }
2835     pctx = EVP_PKEY_CTX_new(pkey, NULL);
2836     if (pctx == NULL || EVP_PKEY_encrypt_init(pctx) <= 0
2837         || EVP_PKEY_encrypt(pctx, NULL, &enclen, pms, pmslen) <= 0) {
2838         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_EVP_LIB);
2839         goto err;
2840     }
2841     if (!WPACKET_allocate_bytes(pkt, enclen, &encdata)
2842             || EVP_PKEY_encrypt(pctx, encdata, &enclen, pms, pmslen) <= 0) {
2843         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, SSL_R_BAD_RSA_ENCRYPT);
2844         goto err;
2845     }
2846     EVP_PKEY_CTX_free(pctx);
2847     pctx = NULL;
2848
2849     /* Fix buf for TLS and beyond */
2850     if (s->version > SSL3_VERSION && !WPACKET_close(pkt)) {
2851         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2852         goto err;
2853     }
2854
2855     /* Log the premaster secret, if logging is enabled. */
2856     if (!ssl_log_rsa_client_key_exchange(s, encdata, enclen, pms, pmslen))
2857         goto err;
2858
2859     s->s3->tmp.pms = pms;
2860     s->s3->tmp.pmslen = pmslen;
2861
2862     return 1;
2863  err:
2864     OPENSSL_clear_free(pms, pmslen);
2865     EVP_PKEY_CTX_free(pctx);
2866
2867     return 0;
2868 #else
2869     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_RSA, ERR_R_INTERNAL_ERROR);
2870     *al = SSL_AD_INTERNAL_ERROR;
2871     return 0;
2872 #endif
2873 }
2874
2875 static int tls_construct_cke_dhe(SSL *s, WPACKET *pkt, int *al)
2876 {
2877 #ifndef OPENSSL_NO_DH
2878     DH *dh_clnt = NULL;
2879     const BIGNUM *pub_key;
2880     EVP_PKEY *ckey = NULL, *skey = NULL;
2881     unsigned char *keybytes = NULL;
2882
2883     skey = s->s3->peer_tmp;
2884     if (skey == NULL)
2885         goto err;
2886
2887     ckey = ssl_generate_pkey(skey);
2888     if (ckey == NULL)
2889         goto err;
2890
2891     dh_clnt = EVP_PKEY_get0_DH(ckey);
2892
2893     if (dh_clnt == NULL || ssl_derive(s, ckey, skey, 0) == 0)
2894         goto err;
2895
2896     /* send off the data */
2897     DH_get0_key(dh_clnt, &pub_key, NULL);
2898     if (!WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(pub_key), &keybytes))
2899         goto err;
2900
2901     BN_bn2bin(pub_key, keybytes);
2902     EVP_PKEY_free(ckey);
2903
2904     return 1;
2905  err:
2906     EVP_PKEY_free(ckey);
2907 #endif
2908     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_DHE, ERR_R_INTERNAL_ERROR);
2909     *al = SSL_AD_INTERNAL_ERROR;
2910     return 0;
2911 }
2912
2913 static int tls_construct_cke_ecdhe(SSL *s, WPACKET *pkt, int *al)
2914 {
2915 #ifndef OPENSSL_NO_EC
2916     unsigned char *encodedPoint = NULL;
2917     size_t encoded_pt_len = 0;
2918     EVP_PKEY *ckey = NULL, *skey = NULL;
2919     int ret = 0;
2920
2921     skey = s->s3->peer_tmp;
2922     if (skey == NULL) {
2923         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2924         return 0;
2925     }
2926
2927     ckey = ssl_generate_pkey(skey);
2928     if (ckey == NULL) {
2929         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_MALLOC_FAILURE);
2930         goto err;
2931     }
2932
2933     if (ssl_derive(s, ckey, skey, 0) == 0) {
2934         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_EVP_LIB);
2935         goto err;
2936     }
2937
2938     /* Generate encoding of client key */
2939     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(ckey, &encodedPoint);
2940
2941     if (encoded_pt_len == 0) {
2942         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_EC_LIB);
2943         goto err;
2944     }
2945
2946     if (!WPACKET_sub_memcpy_u8(pkt, encodedPoint, encoded_pt_len)) {
2947         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2948         goto err;
2949     }
2950
2951     ret = 1;
2952  err:
2953     OPENSSL_free(encodedPoint);
2954     EVP_PKEY_free(ckey);
2955     return ret;
2956 #else
2957     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2958     *al = SSL_AD_INTERNAL_ERROR;
2959     return 0;
2960 #endif
2961 }
2962
2963 static int tls_construct_cke_gost(SSL *s, WPACKET *pkt, int *al)
2964 {
2965 #ifndef OPENSSL_NO_GOST
2966     /* GOST key exchange message creation */
2967     EVP_PKEY_CTX *pkey_ctx = NULL;
2968     X509 *peer_cert;
2969     size_t msglen;
2970     unsigned int md_len;
2971     unsigned char shared_ukm[32], tmp[256];
2972     EVP_MD_CTX *ukm_hash = NULL;
2973     int dgst_nid = NID_id_GostR3411_94;
2974     unsigned char *pms = NULL;
2975     size_t pmslen = 0;
2976
2977     if ((s->s3->tmp.new_cipher->algorithm_auth & SSL_aGOST12) != 0)
2978         dgst_nid = NID_id_GostR3411_2012_256;
2979
2980     /*
2981      * Get server certificate PKEY and create ctx from it
2982      */
2983     peer_cert = s->session->peer;
2984     if (!peer_cert) {
2985         *al = SSL_AD_HANDSHAKE_FAILURE;
2986         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST,
2987                SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
2988         return 0;
2989     }
2990
2991     pkey_ctx = EVP_PKEY_CTX_new(X509_get0_pubkey(peer_cert), NULL);
2992     if (pkey_ctx == NULL) {
2993         *al = SSL_AD_INTERNAL_ERROR;
2994         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_MALLOC_FAILURE);
2995         return 0;
2996     }
2997     /*
2998      * If we have send a certificate, and certificate key
2999      * parameters match those of server certificate, use
3000      * certificate key for key exchange
3001      */
3002
3003     /* Otherwise, generate ephemeral key pair */
3004     pmslen = 32;
3005     pms = OPENSSL_malloc(pmslen);
3006     if (pms == NULL) {
3007         *al = SSL_AD_INTERNAL_ERROR;
3008         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_MALLOC_FAILURE);
3009         goto err;
3010     }
3011
3012     if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0
3013         /* Generate session key
3014          * TODO(size_t): Convert this function
3015          */
3016         || RAND_bytes(pms, (int)pmslen) <= 0) {
3017         *al = SSL_AD_INTERNAL_ERROR;
3018         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_INTERNAL_ERROR);
3019         goto err;
3020     };
3021     /*
3022      * Compute shared IV and store it in algorithm-specific context
3023      * data
3024      */
3025     ukm_hash = EVP_MD_CTX_new();
3026     if (ukm_hash == NULL
3027         || EVP_DigestInit(ukm_hash, EVP_get_digestbynid(dgst_nid)) <= 0
3028         || EVP_DigestUpdate(ukm_hash, s->s3->client_random,
3029                             SSL3_RANDOM_SIZE) <= 0
3030         || EVP_DigestUpdate(ukm_hash, s->s3->server_random,
3031                             SSL3_RANDOM_SIZE) <= 0
3032         || EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len) <= 0) {
3033         *al = SSL_AD_INTERNAL_ERROR;
3034         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_INTERNAL_ERROR);
3035         goto err;
3036     }
3037     EVP_MD_CTX_free(ukm_hash);
3038     ukm_hash = NULL;
3039     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
3040                           EVP_PKEY_CTRL_SET_IV, 8, shared_ukm) < 0) {
3041         *al = SSL_AD_INTERNAL_ERROR;
3042         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, SSL_R_LIBRARY_BUG);
3043         goto err;
3044     }
3045     /* Make GOST keytransport blob message */
3046     /*
3047      * Encapsulate it into sequence
3048      */
3049     msglen = 255;
3050     if (EVP_PKEY_encrypt(pkey_ctx, tmp, &msglen, pms, pmslen) <= 0) {
3051         *al = SSL_AD_INTERNAL_ERROR;
3052         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, SSL_R_LIBRARY_BUG);
3053         goto err;
3054     }
3055
3056     if (!WPACKET_put_bytes_u8(pkt, V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED)
3057             || (msglen >= 0x80 && !WPACKET_put_bytes_u8(pkt, 0x81))
3058             || !WPACKET_sub_memcpy_u8(pkt, tmp, msglen)) {
3059         *al = SSL_AD_INTERNAL_ERROR;
3060         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_INTERNAL_ERROR);
3061         goto err;
3062     }
3063
3064     EVP_PKEY_CTX_free(pkey_ctx);
3065     s->s3->tmp.pms = pms;
3066     s->s3->tmp.pmslen = pmslen;
3067
3068     return 1;
3069  err:
3070     EVP_PKEY_CTX_free(pkey_ctx);
3071     OPENSSL_clear_free(pms, pmslen);
3072     EVP_MD_CTX_free(ukm_hash);
3073     return 0;
3074 #else
3075     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_GOST, ERR_R_INTERNAL_ERROR);
3076     *al = SSL_AD_INTERNAL_ERROR;
3077     return 0;
3078 #endif
3079 }
3080
3081 static int tls_construct_cke_srp(SSL *s, WPACKET *pkt, int *al)
3082 {
3083 #ifndef OPENSSL_NO_SRP
3084     unsigned char *abytes = NULL;
3085
3086     if (s->srp_ctx.A == NULL
3087             || !WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(s->srp_ctx.A),
3088                                                &abytes)) {
3089         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_SRP, ERR_R_INTERNAL_ERROR);
3090         return 0;
3091     }
3092     BN_bn2bin(s->srp_ctx.A, abytes);
3093
3094     OPENSSL_free(s->session->srp_username);
3095     s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
3096     if (s->session->srp_username == NULL) {
3097         SSLerr(SSL_F_TLS_CONSTRUCT_CKE_SRP, ERR_R_MALLOC_FAILURE);
3098         return 0;
3099     }
3100
3101     return 1;
3102 #else
3103     SSLerr(SSL_F_TLS_CONSTRUCT_CKE_SRP, ERR_R_INTERNAL_ERROR);
3104     *al = SSL_AD_INTERNAL_ERROR;
3105     return 0;
3106 #endif
3107 }
3108
3109 int tls_construct_client_key_exchange(SSL *s, WPACKET *pkt)
3110 {
3111     unsigned long alg_k;
3112     int al = -1;
3113
3114     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3115
3116     if ((alg_k & SSL_PSK)
3117         && !tls_construct_cke_psk_preamble(s, pkt, &al))
3118         goto err;
3119
3120     if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
3121         if (!tls_construct_cke_rsa(s, pkt, &al))
3122             goto err;
3123     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
3124         if (!tls_construct_cke_dhe(s, pkt, &al))
3125             goto err;
3126     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
3127         if (!tls_construct_cke_ecdhe(s, pkt, &al))
3128             goto err;
3129     } else if (alg_k & SSL_kGOST) {
3130         if (!tls_construct_cke_gost(s, pkt, &al))
3131             goto err;
3132     } else if (alg_k & SSL_kSRP) {
3133         if (!tls_construct_cke_srp(s, pkt, &al))
3134             goto err;
3135     } else if (!(alg_k & SSL_kPSK)) {
3136         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
3137         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
3138         goto err;
3139     }
3140
3141     return 1;
3142  err:
3143     if (al != -1)
3144         ssl3_send_alert(s, SSL3_AL_FATAL, al);
3145     OPENSSL_clear_free(s->s3->tmp.pms, s->s3->tmp.pmslen);
3146     s->s3->tmp.pms = NULL;
3147 #ifndef OPENSSL_NO_PSK
3148     OPENSSL_clear_free(s->s3->tmp.psk, s->s3->tmp.psklen);
3149     s->s3->tmp.psk = NULL;
3150 #endif
3151     return 0;
3152 }
3153
3154 int tls_client_key_exchange_post_work(SSL *s)
3155 {
3156     unsigned char *pms = NULL;
3157     size_t pmslen = 0;
3158
3159     pms = s->s3->tmp.pms;
3160     pmslen = s->s3->tmp.pmslen;
3161
3162 #ifndef OPENSSL_NO_SRP
3163     /* Check for SRP */
3164     if (s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) {
3165         if (!srp_generate_client_master_secret(s)) {
3166             SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK,
3167                    ERR_R_INTERNAL_ERROR);
3168             goto err;
3169         }
3170         return 1;
3171     }
3172 #endif
3173
3174     if (pms == NULL && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_kPSK)) {
3175         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3176         SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK, ERR_R_MALLOC_FAILURE);
3177         goto err;
3178     }
3179     if (!ssl_generate_master_secret(s, pms, pmslen, 1)) {
3180         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3181         SSLerr(SSL_F_TLS_CLIENT_KEY_EXCHANGE_POST_WORK, ERR_R_INTERNAL_ERROR);
3182         /* ssl_generate_master_secret frees the pms even on error */
3183         pms = NULL;
3184         pmslen = 0;
3185         goto err;
3186     }
3187     pms = NULL;
3188     pmslen = 0;
3189
3190 #ifndef OPENSSL_NO_SCTP
3191     if (SSL_IS_DTLS(s)) {
3192         unsigned char sctpauthkey[64];
3193         char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
3194
3195         /*
3196          * Add new shared key for SCTP-Auth, will be ignored if no SCTP
3197          * used.
3198          */
3199         memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
3200                sizeof(DTLS1_SCTP_AUTH_LABEL));
3201
3202         if (SSL_export_keying_material(s, sctpauthkey,
3203                                        sizeof(sctpauthkey), labelbuffer,
3204                                        sizeof(labelbuffer), NULL, 0, 0) <= 0)
3205             goto err;
3206
3207         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
3208                  sizeof(sctpauthkey), sctpauthkey);
3209     }
3210 #endif
3211
3212     return 1;
3213  err:
3214     OPENSSL_clear_free(pms, pmslen);
3215     s->s3->tmp.pms = NULL;
3216     return 0;
3217 }
3218
3219 /*
3220  * Check a certificate can be used for client authentication. Currently check
3221  * cert exists, if we have a suitable digest for TLS 1.2 if static DH client
3222  * certificates can be used and optionally checks suitability for Suite B.
3223  */
3224 static int ssl3_check_client_certificate(SSL *s)
3225 {
3226     /* If no suitable signature algorithm can't use certificate */
3227     if (!tls_choose_sigalg(s, NULL) || s->s3->tmp.sigalg == NULL)
3228         return 0;
3229     /*
3230      * If strict mode check suitability of chain before using it. This also
3231      * adjusts suite B digest if necessary.
3232      */
3233     if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
3234         !tls1_check_chain(s, NULL, NULL, NULL, -2))
3235         return 0;
3236     return 1;
3237 }
3238
3239 WORK_STATE tls_prepare_client_certificate(SSL *s, WORK_STATE wst)
3240 {
3241     X509 *x509 = NULL;
3242     EVP_PKEY *pkey = NULL;
3243     int i;
3244
3245     if (wst == WORK_MORE_A) {
3246         /* Let cert callback update client certificates if required */
3247         if (s->cert->cert_cb) {
3248             i = s->cert->cert_cb(s, s->cert->cert_cb_arg);
3249             if (i < 0) {
3250                 s->rwstate = SSL_X509_LOOKUP;
3251                 return WORK_MORE_A;
3252             }
3253             if (i == 0) {
3254                 ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3255                 ossl_statem_set_error(s);
3256                 return 0;
3257             }
3258             s->rwstate = SSL_NOTHING;
3259         }
3260         if (ssl3_check_client_certificate(s))
3261             return WORK_FINISHED_CONTINUE;
3262
3263         /* Fall through to WORK_MORE_B */
3264         wst = WORK_MORE_B;
3265     }
3266
3267     /* We need to get a client cert */
3268     if (wst == WORK_MORE_B) {
3269         /*
3270          * If we get an error, we need to ssl->rwstate=SSL_X509_LOOKUP;
3271          * return(-1); We then get retied later
3272          */
3273         i = ssl_do_client_cert_cb(s, &x509, &pkey);
3274         if (i < 0) {
3275             s->rwstate = SSL_X509_LOOKUP;
3276             return WORK_MORE_B;
3277         }
3278         s->rwstate = SSL_NOTHING;
3279         if ((i == 1) && (pkey != NULL) && (x509 != NULL)) {
3280             if (!SSL_use_certificate(s, x509) || !SSL_use_PrivateKey(s, pkey))
3281                 i = 0;
3282         } else if (i == 1) {
3283             i = 0;
3284             SSLerr(SSL_F_TLS_PREPARE_CLIENT_CERTIFICATE,
3285                    SSL_R_BAD_DATA_RETURNED_BY_CALLBACK);
3286         }
3287
3288         X509_free(x509);
3289         EVP_PKEY_free(pkey);
3290         if (i && !ssl3_check_client_certificate(s))
3291             i = 0;
3292         if (i == 0) {
3293             if (s->version == SSL3_VERSION) {
3294                 s->s3->tmp.cert_req = 0;
3295                 ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_CERTIFICATE);
3296                 return WORK_FINISHED_CONTINUE;
3297             } else {
3298                 s->s3->tmp.cert_req = 2;
3299                 if (!ssl3_digest_cached_records(s, 0)) {
3300                     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3301                     ossl_statem_set_error(s);
3302                     return 0;
3303                 }
3304             }
3305         }
3306
3307         return WORK_FINISHED_CONTINUE;
3308     }
3309
3310     /* Shouldn't ever get here */
3311     return WORK_ERROR;
3312 }
3313
3314 int tls_construct_client_certificate(SSL *s, WPACKET *pkt)
3315 {
3316     int al = SSL_AD_INTERNAL_ERROR;
3317
3318     /*
3319      * TODO(TLS1.3): For now we must put an empty context. Needs to be filled in
3320      * later
3321      */
3322     if ((SSL_IS_TLS13(s) && !WPACKET_put_bytes_u8(pkt, 0))
3323             || !ssl3_output_cert_chain(s, pkt,
3324                                (s->s3->tmp.cert_req == 2) ? NULL
3325                                                           : s->cert->key,
3326                                 &al)) {
3327         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3328         goto err;
3329     }
3330
3331     if (SSL_IS_TLS13(s)
3332             && SSL_IS_FIRST_HANDSHAKE(s)
3333             && (!s->method->ssl3_enc->change_cipher_state(s,
3334                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
3335         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_CERTIFICATE,
3336                SSL_R_CANNOT_CHANGE_CIPHER);
3337         goto err;
3338     }
3339
3340     return 1;
3341  err:
3342     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3343     return 0;
3344 }
3345
3346 #define has_bits(i,m)   (((i)&(m)) == (m))
3347
3348 int ssl3_check_cert_and_algorithm(SSL *s)
3349 {
3350     int i;
3351 #ifndef OPENSSL_NO_EC
3352     int idx;
3353 #endif
3354     long alg_k, alg_a;
3355     EVP_PKEY *pkey = NULL;
3356     int al = SSL_AD_HANDSHAKE_FAILURE;
3357
3358     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
3359     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
3360
3361     /* we don't have a certificate */
3362     if ((alg_a & SSL_aNULL) || (alg_k & SSL_kPSK))
3363         return (1);
3364
3365     /* This is the passed certificate */
3366
3367 #ifndef OPENSSL_NO_EC
3368     idx = s->session->peer_type;
3369     if (idx == SSL_PKEY_ECC) {
3370         if (ssl_check_srvr_ecc_cert_and_alg(s->session->peer, s) == 0) {
3371             /* check failed */
3372             SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, SSL_R_BAD_ECC_CERT);
3373             goto f_err;
3374         } else {
3375             return 1;
3376         }
3377     } else if (alg_a & SSL_aECDSA) {
3378         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3379                SSL_R_MISSING_ECDSA_SIGNING_CERT);
3380         goto f_err;
3381     }
3382 #endif
3383     pkey = X509_get0_pubkey(s->session->peer);
3384     i = X509_certificate_type(s->session->peer, pkey);
3385
3386     /* Check that we have a certificate if we require one */
3387     if ((alg_a & SSL_aRSA) && !has_bits(i, EVP_PK_RSA | EVP_PKT_SIGN)) {
3388         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3389                SSL_R_MISSING_RSA_SIGNING_CERT);
3390         goto f_err;
3391     }
3392 #ifndef OPENSSL_NO_DSA
3393     else if ((alg_a & SSL_aDSS) && !has_bits(i, EVP_PK_DSA | EVP_PKT_SIGN)) {
3394         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3395                SSL_R_MISSING_DSA_SIGNING_CERT);
3396         goto f_err;
3397     }
3398 #endif
3399 #ifndef OPENSSL_NO_RSA
3400     if (alg_k & (SSL_kRSA | SSL_kRSAPSK) &&
3401         !has_bits(i, EVP_PK_RSA | EVP_PKT_ENC)) {
3402         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM,
3403                SSL_R_MISSING_RSA_ENCRYPTING_CERT);
3404         goto f_err;
3405     }
3406 #endif
3407 #ifndef OPENSSL_NO_DH
3408     if ((alg_k & SSL_kDHE) && (s->s3->peer_tmp == NULL)) {
3409         al = SSL_AD_INTERNAL_ERROR;
3410         SSLerr(SSL_F_SSL3_CHECK_CERT_AND_ALGORITHM, ERR_R_INTERNAL_ERROR);
3411         goto f_err;
3412     }
3413 #endif
3414
3415     return (1);
3416  f_err:
3417     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3418     return (0);
3419 }
3420
3421 #ifndef OPENSSL_NO_NEXTPROTONEG
3422 int tls_construct_next_proto(SSL *s, WPACKET *pkt)
3423 {
3424     size_t len, padding_len;
3425     unsigned char *padding = NULL;
3426
3427     len = s->ext.npn_len;
3428     padding_len = 32 - ((len + 2) % 32);
3429
3430     if (!WPACKET_sub_memcpy_u8(pkt, s->ext.npn, len)
3431             || !WPACKET_sub_allocate_bytes_u8(pkt, padding_len, &padding)) {
3432         SSLerr(SSL_F_TLS_CONSTRUCT_NEXT_PROTO, ERR_R_INTERNAL_ERROR);
3433         goto err;
3434     }
3435
3436     memset(padding, 0, padding_len);
3437
3438     return 1;
3439  err:
3440     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3441     return 0;
3442 }
3443 #endif
3444
3445 MSG_PROCESS_RETURN tls_process_hello_req(SSL *s, PACKET *pkt)
3446 {
3447     if (PACKET_remaining(pkt) > 0) {
3448         /* should contain no data */
3449         SSLerr(SSL_F_TLS_PROCESS_HELLO_REQ, SSL_R_LENGTH_MISMATCH);
3450         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_DECODE_ERROR);
3451         ossl_statem_set_error(s);
3452         return MSG_PROCESS_ERROR;
3453     }
3454
3455     /*
3456      * This is a historical discrepancy (not in the RFC) maintained for
3457      * compatibility reasons. If a TLS client receives a HelloRequest it will
3458      * attempt an abbreviated handshake. However if a DTLS client receives a
3459      * HelloRequest it will do a full handshake. Either behaviour is reasonable
3460      * but doing one for TLS and another for DTLS is odd.
3461      */
3462     if (SSL_IS_DTLS(s))
3463         SSL_renegotiate(s);
3464     else
3465         SSL_renegotiate_abbreviated(s);
3466
3467     return MSG_PROCESS_FINISHED_READING;
3468 }
3469
3470 static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL *s, PACKET *pkt)
3471 {
3472     int al = SSL_AD_INTERNAL_ERROR;
3473     PACKET extensions;
3474     RAW_EXTENSION *rawexts = NULL;
3475
3476     if (!PACKET_as_length_prefixed_2(pkt, &extensions)) {
3477         al = SSL_AD_DECODE_ERROR;
3478         SSLerr(SSL_F_TLS_PROCESS_ENCRYPTED_EXTENSIONS, SSL_R_LENGTH_MISMATCH);
3479         goto err;
3480     }
3481
3482     if (!tls_collect_extensions(s, &extensions,
3483                                 SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, &rawexts,
3484                                 &al, NULL, 1)
3485             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
3486                                          rawexts, NULL, 0, &al, 1))
3487         goto err;
3488
3489     OPENSSL_free(rawexts);
3490     return MSG_PROCESS_CONTINUE_READING;
3491
3492  err:
3493     ssl3_send_alert(s, SSL3_AL_FATAL, al);
3494     ossl_statem_set_error(s);
3495     OPENSSL_free(rawexts);
3496     return MSG_PROCESS_ERROR;
3497 }
3498
3499 int ssl_do_client_cert_cb(SSL *s, X509 **px509, EVP_PKEY **ppkey)
3500 {
3501     int i = 0;
3502 #ifndef OPENSSL_NO_ENGINE
3503     if (s->ctx->client_cert_engine) {
3504         i = ENGINE_load_ssl_client_cert(s->ctx->client_cert_engine, s,
3505                                         SSL_get_client_CA_list(s),
3506                                         px509, ppkey, NULL, NULL, NULL);
3507         if (i != 0)
3508             return i;
3509     }
3510 #endif
3511     if (s->ctx->client_cert_cb)
3512         i = s->ctx->client_cert_cb(s, px509, ppkey);
3513     return i;
3514 }
3515
3516 int ssl_cipher_list_to_bytes(SSL *s, STACK_OF(SSL_CIPHER) *sk, WPACKET *pkt)
3517 {
3518     int i;
3519     size_t totlen = 0, len, maxlen, maxverok = 0;
3520     int empty_reneg_info_scsv = !s->renegotiate;
3521     /* Set disabled masks for this session */
3522     ssl_set_client_disabled(s);
3523
3524     if (sk == NULL)
3525         return (0);
3526
3527 #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
3528 # if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6
3529 #  error Max cipher length too short
3530 # endif
3531     /*
3532      * Some servers hang if client hello > 256 bytes as hack workaround
3533      * chop number of supported ciphers to keep it well below this if we
3534      * use TLS v1.2
3535      */
3536     if (TLS1_get_version(s) >= TLS1_2_VERSION)
3537         maxlen = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1;
3538     else
3539 #endif
3540         /* Maximum length that can be stored in 2 bytes. Length must be even */
3541         maxlen = 0xfffe;
3542
3543     if (empty_reneg_info_scsv)
3544         maxlen -= 2;
3545     if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV)
3546         maxlen -= 2;
3547
3548     for (i = 0; i < sk_SSL_CIPHER_num(sk) && totlen < maxlen; i++) {
3549         const SSL_CIPHER *c;
3550
3551         c = sk_SSL_CIPHER_value(sk, i);
3552         /* Skip disabled ciphers */
3553         if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0))
3554             continue;
3555
3556         if (!s->method->put_cipher_by_char(c, pkt, &len)) {
3557             SSLerr(SSL_F_SSL_CIPHER_LIST_TO_BYTES, ERR_R_INTERNAL_ERROR);
3558             return 0;
3559         }
3560
3561         /* Sanity check that the maximum version we offer has ciphers enabled */
3562         if (!maxverok) {
3563             if (SSL_IS_DTLS(s)) {
3564                 if (DTLS_VERSION_GE(c->max_dtls, s->s3->tmp.max_ver)
3565                         && DTLS_VERSION_LE(c->min_dtls, s->s3->tmp.max_ver))
3566                     maxverok = 1;
3567             } else {
3568                 if (c->max_tls >= s->s3->tmp.max_ver
3569                         && c->min_tls <= s->s3->tmp.max_ver)
3570                     maxverok = 1;
3571             }
3572         }
3573
3574         totlen += len;
3575     }
3576
3577     if (totlen == 0 || !maxverok) {
3578         SSLerr(SSL_F_SSL_CIPHER_LIST_TO_BYTES, SSL_R_NO_CIPHERS_AVAILABLE);
3579
3580         if (!maxverok)
3581             ERR_add_error_data(1, "No ciphers enabled for max supported "
3582                                   "SSL/TLS version");
3583
3584         return 0;
3585     }
3586
3587     if (totlen != 0) {
3588         if (empty_reneg_info_scsv) {
3589             static SSL_CIPHER scsv = {
3590                 0, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
3591             };
3592             if (!s->method->put_cipher_by_char(&scsv, pkt, &len)) {
3593                 SSLerr(SSL_F_SSL_CIPHER_LIST_TO_BYTES, ERR_R_INTERNAL_ERROR);
3594                 return 0;
3595             }
3596         }
3597         if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) {
3598             static SSL_CIPHER scsv = {
3599                 0, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
3600             };
3601             if (!s->method->put_cipher_by_char(&scsv, pkt, &len)) {
3602                 SSLerr(SSL_F_SSL_CIPHER_LIST_TO_BYTES, ERR_R_INTERNAL_ERROR);
3603                 return 0;
3604             }
3605         }
3606     }
3607
3608     return 1;
3609 }
3610
3611 int tls_construct_end_of_early_data(SSL *s, WPACKET *pkt)
3612 {
3613     if (s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY
3614             && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) {
3615         SSLerr(SSL_F_TLS_CONSTRUCT_END_OF_EARLY_DATA,
3616                ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3617         return 0;
3618     }
3619
3620     s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING;
3621     return 1;
3622 }