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