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