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