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