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