c744bf64eb032ac4bb6909543e300905eddedb75
[openssl.git] / ssl / statem / statem_srvr.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 Apache License 2.0 (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 "../ssl_local.h"
14 #include "statem_local.h"
15 #include "internal/constant_time.h"
16 #include "internal/cryptlib.h"
17 #include <openssl/buffer.h>
18 #include <openssl/rand.h>
19 #include <openssl/objects.h>
20 #include <openssl/evp.h>
21 #include <openssl/hmac.h>
22 #include <openssl/x509.h>
23 #include <openssl/dh.h>
24 #include <openssl/bn.h>
25 #include <openssl/md5.h>
26 #include <openssl/trace.h>
27 #include <openssl/core_names.h>
28 #include <openssl/asn1t.h>
29
30 #define TICKET_NONCE_SIZE       8
31
32 typedef struct {
33   ASN1_TYPE *kxBlob;
34   ASN1_TYPE *opaqueBlob;
35 } GOST_KX_MESSAGE;
36
37 DECLARE_ASN1_FUNCTIONS(GOST_KX_MESSAGE)
38
39 ASN1_SEQUENCE(GOST_KX_MESSAGE) = {
40   ASN1_SIMPLE(GOST_KX_MESSAGE,  kxBlob, ASN1_ANY),
41   ASN1_OPT(GOST_KX_MESSAGE, opaqueBlob, ASN1_ANY),
42 } ASN1_SEQUENCE_END(GOST_KX_MESSAGE)
43
44 IMPLEMENT_ASN1_FUNCTIONS(GOST_KX_MESSAGE)
45
46 static int tls_construct_encrypted_extensions(SSL *s, WPACKET *pkt);
47
48 /*
49  * ossl_statem_server13_read_transition() encapsulates the logic for the allowed
50  * handshake state transitions when a TLSv1.3 server is reading messages from
51  * the client. The message type that the client has sent is provided in |mt|.
52  * The current state is in |s->statem.hand_state|.
53  *
54  * Return values are 1 for success (transition allowed) and  0 on error
55  * (transition not allowed)
56  */
57 static int ossl_statem_server13_read_transition(SSL *s, int mt)
58 {
59     OSSL_STATEM *st = &s->statem;
60
61     /*
62      * Note: There is no case for TLS_ST_BEFORE because at that stage we have
63      * not negotiated TLSv1.3 yet, so that case is handled by
64      * ossl_statem_server_read_transition()
65      */
66     switch (st->hand_state) {
67     default:
68         break;
69
70     case TLS_ST_EARLY_DATA:
71         if (s->hello_retry_request == SSL_HRR_PENDING) {
72             if (mt == SSL3_MT_CLIENT_HELLO) {
73                 st->hand_state = TLS_ST_SR_CLNT_HELLO;
74                 return 1;
75             }
76             break;
77         } else if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) {
78             if (mt == SSL3_MT_END_OF_EARLY_DATA) {
79                 st->hand_state = TLS_ST_SR_END_OF_EARLY_DATA;
80                 return 1;
81             }
82             break;
83         }
84         /* Fall through */
85
86     case TLS_ST_SR_END_OF_EARLY_DATA:
87     case TLS_ST_SW_FINISHED:
88         if (s->s3.tmp.cert_request) {
89             if (mt == SSL3_MT_CERTIFICATE) {
90                 st->hand_state = TLS_ST_SR_CERT;
91                 return 1;
92             }
93         } else {
94             if (mt == SSL3_MT_FINISHED) {
95                 st->hand_state = TLS_ST_SR_FINISHED;
96                 return 1;
97             }
98         }
99         break;
100
101     case TLS_ST_SR_CERT:
102         if (s->session->peer == NULL) {
103             if (mt == SSL3_MT_FINISHED) {
104                 st->hand_state = TLS_ST_SR_FINISHED;
105                 return 1;
106             }
107         } else {
108             if (mt == SSL3_MT_CERTIFICATE_VERIFY) {
109                 st->hand_state = TLS_ST_SR_CERT_VRFY;
110                 return 1;
111             }
112         }
113         break;
114
115     case TLS_ST_SR_CERT_VRFY:
116         if (mt == SSL3_MT_FINISHED) {
117             st->hand_state = TLS_ST_SR_FINISHED;
118             return 1;
119         }
120         break;
121
122     case TLS_ST_OK:
123         /*
124          * Its never ok to start processing handshake messages in the middle of
125          * early data (i.e. before we've received the end of early data alert)
126          */
127         if (s->early_data_state == SSL_EARLY_DATA_READING)
128             break;
129
130         if (mt == SSL3_MT_CERTIFICATE
131                 && s->post_handshake_auth == SSL_PHA_REQUESTED) {
132             st->hand_state = TLS_ST_SR_CERT;
133             return 1;
134         }
135
136         if (mt == SSL3_MT_KEY_UPDATE) {
137             st->hand_state = TLS_ST_SR_KEY_UPDATE;
138             return 1;
139         }
140         break;
141     }
142
143     /* No valid transition found */
144     return 0;
145 }
146
147 /*
148  * ossl_statem_server_read_transition() encapsulates the logic for the allowed
149  * handshake state transitions when the server is reading messages from the
150  * client. The message type that the client has sent is provided in |mt|. The
151  * current state is in |s->statem.hand_state|.
152  *
153  * Return values are 1 for success (transition allowed) and  0 on error
154  * (transition not allowed)
155  */
156 int ossl_statem_server_read_transition(SSL *s, int mt)
157 {
158     OSSL_STATEM *st = &s->statem;
159
160     if (SSL_IS_TLS13(s)) {
161         if (!ossl_statem_server13_read_transition(s, mt))
162             goto err;
163         return 1;
164     }
165
166     switch (st->hand_state) {
167     default:
168         break;
169
170     case TLS_ST_BEFORE:
171     case TLS_ST_OK:
172     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
173         if (mt == SSL3_MT_CLIENT_HELLO) {
174             st->hand_state = TLS_ST_SR_CLNT_HELLO;
175             return 1;
176         }
177         break;
178
179     case TLS_ST_SW_SRVR_DONE:
180         /*
181          * If we get a CKE message after a ServerDone then either
182          * 1) We didn't request a Certificate
183          * OR
184          * 2) If we did request one then
185          *      a) We allow no Certificate to be returned
186          *      AND
187          *      b) We are running SSL3 (in TLS1.0+ the client must return a 0
188          *         list if we requested a certificate)
189          */
190         if (mt == SSL3_MT_CLIENT_KEY_EXCHANGE) {
191             if (s->s3.tmp.cert_request) {
192                 if (s->version == SSL3_VERSION) {
193                     if ((s->verify_mode & SSL_VERIFY_PEER)
194                         && (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
195                         /*
196                          * This isn't an unexpected message as such - we're just
197                          * not going to accept it because we require a client
198                          * cert.
199                          */
200                         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
201                                  SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION,
202                                  SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
203                         return 0;
204                     }
205                     st->hand_state = TLS_ST_SR_KEY_EXCH;
206                     return 1;
207                 }
208             } else {
209                 st->hand_state = TLS_ST_SR_KEY_EXCH;
210                 return 1;
211             }
212         } else if (s->s3.tmp.cert_request) {
213             if (mt == SSL3_MT_CERTIFICATE) {
214                 st->hand_state = TLS_ST_SR_CERT;
215                 return 1;
216             }
217         }
218         break;
219
220     case TLS_ST_SR_CERT:
221         if (mt == SSL3_MT_CLIENT_KEY_EXCHANGE) {
222             st->hand_state = TLS_ST_SR_KEY_EXCH;
223             return 1;
224         }
225         break;
226
227     case TLS_ST_SR_KEY_EXCH:
228         /*
229          * We should only process a CertificateVerify message if we have
230          * received a Certificate from the client. If so then |s->session->peer|
231          * will be non NULL. In some instances a CertificateVerify message is
232          * not required even if the peer has sent a Certificate (e.g. such as in
233          * the case of static DH). In that case |st->no_cert_verify| should be
234          * set.
235          */
236         if (s->session->peer == NULL || st->no_cert_verify) {
237             if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
238                 /*
239                  * For the ECDH ciphersuites when the client sends its ECDH
240                  * pub key in a certificate, the CertificateVerify message is
241                  * not sent. Also for GOST ciphersuites when the client uses
242                  * its key from the certificate for key exchange.
243                  */
244                 st->hand_state = TLS_ST_SR_CHANGE;
245                 return 1;
246             }
247         } else {
248             if (mt == SSL3_MT_CERTIFICATE_VERIFY) {
249                 st->hand_state = TLS_ST_SR_CERT_VRFY;
250                 return 1;
251             }
252         }
253         break;
254
255     case TLS_ST_SR_CERT_VRFY:
256         if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
257             st->hand_state = TLS_ST_SR_CHANGE;
258             return 1;
259         }
260         break;
261
262     case TLS_ST_SR_CHANGE:
263 #ifndef OPENSSL_NO_NEXTPROTONEG
264         if (s->s3.npn_seen) {
265             if (mt == SSL3_MT_NEXT_PROTO) {
266                 st->hand_state = TLS_ST_SR_NEXT_PROTO;
267                 return 1;
268             }
269         } else {
270 #endif
271             if (mt == SSL3_MT_FINISHED) {
272                 st->hand_state = TLS_ST_SR_FINISHED;
273                 return 1;
274             }
275 #ifndef OPENSSL_NO_NEXTPROTONEG
276         }
277 #endif
278         break;
279
280 #ifndef OPENSSL_NO_NEXTPROTONEG
281     case TLS_ST_SR_NEXT_PROTO:
282         if (mt == SSL3_MT_FINISHED) {
283             st->hand_state = TLS_ST_SR_FINISHED;
284             return 1;
285         }
286         break;
287 #endif
288
289     case TLS_ST_SW_FINISHED:
290         if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
291             st->hand_state = TLS_ST_SR_CHANGE;
292             return 1;
293         }
294         break;
295     }
296
297  err:
298     /* No valid transition found */
299     if (SSL_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
300         BIO *rbio;
301
302         /*
303          * CCS messages don't have a message sequence number so this is probably
304          * because of an out-of-order CCS. We'll just drop it.
305          */
306         s->init_num = 0;
307         s->rwstate = SSL_READING;
308         rbio = SSL_get_rbio(s);
309         BIO_clear_retry_flags(rbio);
310         BIO_set_retry_read(rbio);
311         return 0;
312     }
313     SSLfatal(s, SSL3_AD_UNEXPECTED_MESSAGE,
314              SSL_F_OSSL_STATEM_SERVER_READ_TRANSITION,
315              SSL_R_UNEXPECTED_MESSAGE);
316     return 0;
317 }
318
319 /*
320  * Should we send a ServerKeyExchange message?
321  *
322  * Valid return values are:
323  *   1: Yes
324  *   0: No
325  */
326 static int send_server_key_exchange(SSL *s)
327 {
328     unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
329
330     /*
331      * only send a ServerKeyExchange if DH or fortezza but we have a
332      * sign only certificate PSK: may send PSK identity hints For
333      * ECC ciphersuites, we send a serverKeyExchange message only if
334      * the cipher suite is either ECDH-anon or ECDHE. In other cases,
335      * the server certificate contains the server's public key for
336      * key exchange.
337      */
338     if (alg_k & (SSL_kDHE | SSL_kECDHE)
339         /*
340          * PSK: send ServerKeyExchange if PSK identity hint if
341          * provided
342          */
343 #ifndef OPENSSL_NO_PSK
344         /* Only send SKE if we have identity hint for plain PSK */
345         || ((alg_k & (SSL_kPSK | SSL_kRSAPSK))
346             && s->cert->psk_identity_hint)
347         /* For other PSK always send SKE */
348         || (alg_k & (SSL_PSK & (SSL_kDHEPSK | SSL_kECDHEPSK)))
349 #endif
350 #ifndef OPENSSL_NO_SRP
351         /* SRP: send ServerKeyExchange */
352         || (alg_k & SSL_kSRP)
353 #endif
354         ) {
355         return 1;
356     }
357
358     return 0;
359 }
360
361 /*
362  * Should we send a CertificateRequest message?
363  *
364  * Valid return values are:
365  *   1: Yes
366  *   0: No
367  */
368 int send_certificate_request(SSL *s)
369 {
370     if (
371            /* don't request cert unless asked for it: */
372            s->verify_mode & SSL_VERIFY_PEER
373            /*
374             * don't request if post-handshake-only unless doing
375             * post-handshake in TLSv1.3:
376             */
377            && (!SSL_IS_TLS13(s) || !(s->verify_mode & SSL_VERIFY_POST_HANDSHAKE)
378                || s->post_handshake_auth == SSL_PHA_REQUEST_PENDING)
379            /*
380             * if SSL_VERIFY_CLIENT_ONCE is set, don't request cert
381             * a second time:
382             */
383            && (s->certreqs_sent < 1 ||
384                !(s->verify_mode & SSL_VERIFY_CLIENT_ONCE))
385            /*
386             * never request cert in anonymous ciphersuites (see
387             * section "Certificate request" in SSL 3 drafts and in
388             * RFC 2246):
389             */
390            && (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL)
391                /*
392                 * ... except when the application insists on
393                 * verification (against the specs, but statem_clnt.c accepts
394                 * this for SSL 3)
395                 */
396                || (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
397            /* don't request certificate for SRP auth */
398            && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aSRP)
399            /*
400             * With normal PSK Certificates and Certificate Requests
401             * are omitted
402             */
403            && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aPSK)) {
404         return 1;
405     }
406
407     return 0;
408 }
409
410 /*
411  * ossl_statem_server13_write_transition() works out what handshake state to
412  * move to next when a TLSv1.3 server is writing messages to be sent to the
413  * client.
414  */
415 static WRITE_TRAN ossl_statem_server13_write_transition(SSL *s)
416 {
417     OSSL_STATEM *st = &s->statem;
418
419     /*
420      * No case for TLS_ST_BEFORE, because at that stage we have not negotiated
421      * TLSv1.3 yet, so that is handled by ossl_statem_server_write_transition()
422      */
423
424     switch (st->hand_state) {
425     default:
426         /* Shouldn't happen */
427         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
428                  SSL_F_OSSL_STATEM_SERVER13_WRITE_TRANSITION,
429                  ERR_R_INTERNAL_ERROR);
430         return WRITE_TRAN_ERROR;
431
432     case TLS_ST_OK:
433         if (s->key_update != SSL_KEY_UPDATE_NONE) {
434             st->hand_state = TLS_ST_SW_KEY_UPDATE;
435             return WRITE_TRAN_CONTINUE;
436         }
437         if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) {
438             st->hand_state = TLS_ST_SW_CERT_REQ;
439             return WRITE_TRAN_CONTINUE;
440         }
441         /* Try to read from the client instead */
442         return WRITE_TRAN_FINISHED;
443
444     case TLS_ST_SR_CLNT_HELLO:
445         st->hand_state = TLS_ST_SW_SRVR_HELLO;
446         return WRITE_TRAN_CONTINUE;
447
448     case TLS_ST_SW_SRVR_HELLO:
449         if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0
450                 && s->hello_retry_request != SSL_HRR_COMPLETE)
451             st->hand_state = TLS_ST_SW_CHANGE;
452         else if (s->hello_retry_request == SSL_HRR_PENDING)
453             st->hand_state = TLS_ST_EARLY_DATA;
454         else
455             st->hand_state = TLS_ST_SW_ENCRYPTED_EXTENSIONS;
456         return WRITE_TRAN_CONTINUE;
457
458     case TLS_ST_SW_CHANGE:
459         if (s->hello_retry_request == SSL_HRR_PENDING)
460             st->hand_state = TLS_ST_EARLY_DATA;
461         else
462             st->hand_state = TLS_ST_SW_ENCRYPTED_EXTENSIONS;
463         return WRITE_TRAN_CONTINUE;
464
465     case TLS_ST_SW_ENCRYPTED_EXTENSIONS:
466         if (s->hit)
467             st->hand_state = TLS_ST_SW_FINISHED;
468         else if (send_certificate_request(s))
469             st->hand_state = TLS_ST_SW_CERT_REQ;
470         else
471             st->hand_state = TLS_ST_SW_CERT;
472
473         return WRITE_TRAN_CONTINUE;
474
475     case TLS_ST_SW_CERT_REQ:
476         if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) {
477             s->post_handshake_auth = SSL_PHA_REQUESTED;
478             st->hand_state = TLS_ST_OK;
479         } else {
480             st->hand_state = TLS_ST_SW_CERT;
481         }
482         return WRITE_TRAN_CONTINUE;
483
484     case TLS_ST_SW_CERT:
485         st->hand_state = TLS_ST_SW_CERT_VRFY;
486         return WRITE_TRAN_CONTINUE;
487
488     case TLS_ST_SW_CERT_VRFY:
489         st->hand_state = TLS_ST_SW_FINISHED;
490         return WRITE_TRAN_CONTINUE;
491
492     case TLS_ST_SW_FINISHED:
493         st->hand_state = TLS_ST_EARLY_DATA;
494         return WRITE_TRAN_CONTINUE;
495
496     case TLS_ST_EARLY_DATA:
497         return WRITE_TRAN_FINISHED;
498
499     case TLS_ST_SR_FINISHED:
500         /*
501          * Technically we have finished the handshake at this point, but we're
502          * going to remain "in_init" for now and write out any session tickets
503          * immediately.
504          */
505         if (s->post_handshake_auth == SSL_PHA_REQUESTED) {
506             s->post_handshake_auth = SSL_PHA_EXT_RECEIVED;
507         } else if (!s->ext.ticket_expected) {
508             /*
509              * If we're not going to renew the ticket then we just finish the
510              * handshake at this point.
511              */
512             st->hand_state = TLS_ST_OK;
513             return WRITE_TRAN_CONTINUE;
514         }
515         if (s->num_tickets > s->sent_tickets)
516             st->hand_state = TLS_ST_SW_SESSION_TICKET;
517         else
518             st->hand_state = TLS_ST_OK;
519         return WRITE_TRAN_CONTINUE;
520
521     case TLS_ST_SR_KEY_UPDATE:
522     case TLS_ST_SW_KEY_UPDATE:
523         st->hand_state = TLS_ST_OK;
524         return WRITE_TRAN_CONTINUE;
525
526     case TLS_ST_SW_SESSION_TICKET:
527         /* In a resumption we only ever send a maximum of one new ticket.
528          * Following an initial handshake we send the number of tickets we have
529          * been configured for.
530          */
531         if (s->hit || s->num_tickets <= s->sent_tickets) {
532             /* We've written enough tickets out. */
533             st->hand_state = TLS_ST_OK;
534         }
535         return WRITE_TRAN_CONTINUE;
536     }
537 }
538
539 /*
540  * ossl_statem_server_write_transition() works out what handshake state to move
541  * to next when the server is writing messages to be sent to the client.
542  */
543 WRITE_TRAN ossl_statem_server_write_transition(SSL *s)
544 {
545     OSSL_STATEM *st = &s->statem;
546
547     /*
548      * Note that before the ClientHello we don't know what version we are going
549      * to negotiate yet, so we don't take this branch until later
550      */
551
552     if (SSL_IS_TLS13(s))
553         return ossl_statem_server13_write_transition(s);
554
555     switch (st->hand_state) {
556     default:
557         /* Shouldn't happen */
558         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
559                  SSL_F_OSSL_STATEM_SERVER_WRITE_TRANSITION,
560                  ERR_R_INTERNAL_ERROR);
561         return WRITE_TRAN_ERROR;
562
563     case TLS_ST_OK:
564         if (st->request_state == TLS_ST_SW_HELLO_REQ) {
565             /* We must be trying to renegotiate */
566             st->hand_state = TLS_ST_SW_HELLO_REQ;
567             st->request_state = TLS_ST_BEFORE;
568             return WRITE_TRAN_CONTINUE;
569         }
570         /* Must be an incoming ClientHello */
571         if (!tls_setup_handshake(s)) {
572             /* SSLfatal() already called */
573             return WRITE_TRAN_ERROR;
574         }
575         /* Fall through */
576
577     case TLS_ST_BEFORE:
578         /* Just go straight to trying to read from the client */
579         return WRITE_TRAN_FINISHED;
580
581     case TLS_ST_SW_HELLO_REQ:
582         st->hand_state = TLS_ST_OK;
583         return WRITE_TRAN_CONTINUE;
584
585     case TLS_ST_SR_CLNT_HELLO:
586         if (SSL_IS_DTLS(s) && !s->d1->cookie_verified
587             && (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE)) {
588             st->hand_state = DTLS_ST_SW_HELLO_VERIFY_REQUEST;
589         } else if (s->renegotiate == 0 && !SSL_IS_FIRST_HANDSHAKE(s)) {
590             /* We must have rejected the renegotiation */
591             st->hand_state = TLS_ST_OK;
592             return WRITE_TRAN_CONTINUE;
593         } else {
594             st->hand_state = TLS_ST_SW_SRVR_HELLO;
595         }
596         return WRITE_TRAN_CONTINUE;
597
598     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
599         return WRITE_TRAN_FINISHED;
600
601     case TLS_ST_SW_SRVR_HELLO:
602         if (s->hit) {
603             if (s->ext.ticket_expected)
604                 st->hand_state = TLS_ST_SW_SESSION_TICKET;
605             else
606                 st->hand_state = TLS_ST_SW_CHANGE;
607         } else {
608             /* Check if it is anon DH or anon ECDH, */
609             /* normal PSK or SRP */
610             if (!(s->s3.tmp.new_cipher->algorithm_auth &
611                   (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
612                 st->hand_state = TLS_ST_SW_CERT;
613             } else if (send_server_key_exchange(s)) {
614                 st->hand_state = TLS_ST_SW_KEY_EXCH;
615             } else if (send_certificate_request(s)) {
616                 st->hand_state = TLS_ST_SW_CERT_REQ;
617             } else {
618                 st->hand_state = TLS_ST_SW_SRVR_DONE;
619             }
620         }
621         return WRITE_TRAN_CONTINUE;
622
623     case TLS_ST_SW_CERT:
624         if (s->ext.status_expected) {
625             st->hand_state = TLS_ST_SW_CERT_STATUS;
626             return WRITE_TRAN_CONTINUE;
627         }
628         /* Fall through */
629
630     case TLS_ST_SW_CERT_STATUS:
631         if (send_server_key_exchange(s)) {
632             st->hand_state = TLS_ST_SW_KEY_EXCH;
633             return WRITE_TRAN_CONTINUE;
634         }
635         /* Fall through */
636
637     case TLS_ST_SW_KEY_EXCH:
638         if (send_certificate_request(s)) {
639             st->hand_state = TLS_ST_SW_CERT_REQ;
640             return WRITE_TRAN_CONTINUE;
641         }
642         /* Fall through */
643
644     case TLS_ST_SW_CERT_REQ:
645         st->hand_state = TLS_ST_SW_SRVR_DONE;
646         return WRITE_TRAN_CONTINUE;
647
648     case TLS_ST_SW_SRVR_DONE:
649         return WRITE_TRAN_FINISHED;
650
651     case TLS_ST_SR_FINISHED:
652         if (s->hit) {
653             st->hand_state = TLS_ST_OK;
654             return WRITE_TRAN_CONTINUE;
655         } else if (s->ext.ticket_expected) {
656             st->hand_state = TLS_ST_SW_SESSION_TICKET;
657         } else {
658             st->hand_state = TLS_ST_SW_CHANGE;
659         }
660         return WRITE_TRAN_CONTINUE;
661
662     case TLS_ST_SW_SESSION_TICKET:
663         st->hand_state = TLS_ST_SW_CHANGE;
664         return WRITE_TRAN_CONTINUE;
665
666     case TLS_ST_SW_CHANGE:
667         st->hand_state = TLS_ST_SW_FINISHED;
668         return WRITE_TRAN_CONTINUE;
669
670     case TLS_ST_SW_FINISHED:
671         if (s->hit) {
672             return WRITE_TRAN_FINISHED;
673         }
674         st->hand_state = TLS_ST_OK;
675         return WRITE_TRAN_CONTINUE;
676     }
677 }
678
679 /*
680  * Perform any pre work that needs to be done prior to sending a message from
681  * the server to the client.
682  */
683 WORK_STATE ossl_statem_server_pre_work(SSL *s, WORK_STATE wst)
684 {
685     OSSL_STATEM *st = &s->statem;
686
687     switch (st->hand_state) {
688     default:
689         /* No pre work to be done */
690         break;
691
692     case TLS_ST_SW_HELLO_REQ:
693         s->shutdown = 0;
694         if (SSL_IS_DTLS(s))
695             dtls1_clear_sent_buffer(s);
696         break;
697
698     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
699         s->shutdown = 0;
700         if (SSL_IS_DTLS(s)) {
701             dtls1_clear_sent_buffer(s);
702             /* We don't buffer this message so don't use the timer */
703             st->use_timer = 0;
704         }
705         break;
706
707     case TLS_ST_SW_SRVR_HELLO:
708         if (SSL_IS_DTLS(s)) {
709             /*
710              * Messages we write from now on should be buffered and
711              * retransmitted if necessary, so we need to use the timer now
712              */
713             st->use_timer = 1;
714         }
715         break;
716
717     case TLS_ST_SW_SRVR_DONE:
718 #ifndef OPENSSL_NO_SCTP
719         if (SSL_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(s))) {
720             /* Calls SSLfatal() as required */
721             return dtls_wait_for_dry(s);
722         }
723 #endif
724         return WORK_FINISHED_CONTINUE;
725
726     case TLS_ST_SW_SESSION_TICKET:
727         if (SSL_IS_TLS13(s) && s->sent_tickets == 0) {
728             /*
729              * Actually this is the end of the handshake, but we're going
730              * straight into writing the session ticket out. So we finish off
731              * the handshake, but keep the various buffers active.
732              *
733              * Calls SSLfatal as required.
734              */
735             return tls_finish_handshake(s, wst, 0, 0);
736         } if (SSL_IS_DTLS(s)) {
737             /*
738              * We're into the last flight. We don't retransmit the last flight
739              * unless we need to, so we don't use the timer
740              */
741             st->use_timer = 0;
742         }
743         break;
744
745     case TLS_ST_SW_CHANGE:
746         if (SSL_IS_TLS13(s))
747             break;
748         s->session->cipher = s->s3.tmp.new_cipher;
749         if (!s->method->ssl3_enc->setup_key_block(s)) {
750             /* SSLfatal() already called */
751             return WORK_ERROR;
752         }
753         if (SSL_IS_DTLS(s)) {
754             /*
755              * We're into the last flight. We don't retransmit the last flight
756              * unless we need to, so we don't use the timer. This might have
757              * already been set to 0 if we sent a NewSessionTicket message,
758              * but we'll set it again here in case we didn't.
759              */
760             st->use_timer = 0;
761         }
762         return WORK_FINISHED_CONTINUE;
763
764     case TLS_ST_EARLY_DATA:
765         if (s->early_data_state != SSL_EARLY_DATA_ACCEPTING
766                 && (s->s3.flags & TLS1_FLAGS_STATELESS) == 0)
767             return WORK_FINISHED_CONTINUE;
768         /* Fall through */
769
770     case TLS_ST_OK:
771         /* Calls SSLfatal() as required */
772         return tls_finish_handshake(s, wst, 1, 1);
773     }
774
775     return WORK_FINISHED_CONTINUE;
776 }
777
778 static ossl_inline int conn_is_closed(void)
779 {
780     switch (get_last_sys_error()) {
781 #if defined(EPIPE)
782     case EPIPE:
783         return 1;
784 #endif
785 #if defined(ECONNRESET)
786     case ECONNRESET:
787         return 1;
788 #endif
789 #if defined(WSAECONNRESET)
790     case WSAECONNRESET:
791         return 1;
792 #endif
793     default:
794         return 0;
795     }
796 }
797
798 /*
799  * Perform any work that needs to be done after sending a message from the
800  * server to the client.
801  */
802 WORK_STATE ossl_statem_server_post_work(SSL *s, WORK_STATE wst)
803 {
804     OSSL_STATEM *st = &s->statem;
805
806     s->init_num = 0;
807
808     switch (st->hand_state) {
809     default:
810         /* No post work to be done */
811         break;
812
813     case TLS_ST_SW_HELLO_REQ:
814         if (statem_flush(s) != 1)
815             return WORK_MORE_A;
816         if (!ssl3_init_finished_mac(s)) {
817             /* SSLfatal() already called */
818             return WORK_ERROR;
819         }
820         break;
821
822     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
823         if (statem_flush(s) != 1)
824             return WORK_MORE_A;
825         /* HelloVerifyRequest resets Finished MAC */
826         if (s->version != DTLS1_BAD_VER && !ssl3_init_finished_mac(s)) {
827             /* SSLfatal() already called */
828             return WORK_ERROR;
829         }
830         /*
831          * The next message should be another ClientHello which we need to
832          * treat like it was the first packet
833          */
834         s->first_packet = 1;
835         break;
836
837     case TLS_ST_SW_SRVR_HELLO:
838         if (SSL_IS_TLS13(s) && s->hello_retry_request == SSL_HRR_PENDING) {
839             if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0
840                     && statem_flush(s) != 1)
841                 return WORK_MORE_A;
842             break;
843         }
844 #ifndef OPENSSL_NO_SCTP
845         if (SSL_IS_DTLS(s) && s->hit) {
846             unsigned char sctpauthkey[64];
847             char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
848             size_t labellen;
849
850             /*
851              * Add new shared key for SCTP-Auth, will be ignored if no
852              * SCTP used.
853              */
854             memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
855                    sizeof(DTLS1_SCTP_AUTH_LABEL));
856
857             /* Don't include the terminating zero. */
858             labellen = sizeof(labelbuffer) - 1;
859             if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG)
860                 labellen += 1;
861
862             if (SSL_export_keying_material(s, sctpauthkey,
863                                            sizeof(sctpauthkey), labelbuffer,
864                                            labellen, NULL, 0,
865                                            0) <= 0) {
866                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
867                          SSL_F_OSSL_STATEM_SERVER_POST_WORK,
868                          ERR_R_INTERNAL_ERROR);
869                 return WORK_ERROR;
870             }
871
872             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
873                      sizeof(sctpauthkey), sctpauthkey);
874         }
875 #endif
876         if (!SSL_IS_TLS13(s)
877                 || ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0
878                     && s->hello_retry_request != SSL_HRR_COMPLETE))
879             break;
880         /* Fall through */
881
882     case TLS_ST_SW_CHANGE:
883         if (s->hello_retry_request == SSL_HRR_PENDING) {
884             if (!statem_flush(s))
885                 return WORK_MORE_A;
886             break;
887         }
888
889         if (SSL_IS_TLS13(s)) {
890             if (!s->method->ssl3_enc->setup_key_block(s)
891                 || !s->method->ssl3_enc->change_cipher_state(s,
892                         SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_WRITE)) {
893                 /* SSLfatal() already called */
894                 return WORK_ERROR;
895             }
896
897             if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED
898                 && !s->method->ssl3_enc->change_cipher_state(s,
899                         SSL3_CC_HANDSHAKE |SSL3_CHANGE_CIPHER_SERVER_READ)) {
900                 /* SSLfatal() already called */
901                 return WORK_ERROR;
902             }
903             /*
904              * We don't yet know whether the next record we are going to receive
905              * is an unencrypted alert, an encrypted alert, or an encrypted
906              * handshake message. We temporarily tolerate unencrypted alerts.
907              */
908             s->statem.enc_read_state = ENC_READ_STATE_ALLOW_PLAIN_ALERTS;
909             break;
910         }
911
912 #ifndef OPENSSL_NO_SCTP
913         if (SSL_IS_DTLS(s) && !s->hit) {
914             /*
915              * Change to new shared key of SCTP-Auth, will be ignored if
916              * no SCTP used.
917              */
918             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
919                      0, NULL);
920         }
921 #endif
922         if (!s->method->ssl3_enc->change_cipher_state(s,
923                                                       SSL3_CHANGE_CIPHER_SERVER_WRITE))
924         {
925             /* SSLfatal() already called */
926             return WORK_ERROR;
927         }
928
929         if (SSL_IS_DTLS(s))
930             dtls1_reset_seq_numbers(s, SSL3_CC_WRITE);
931         break;
932
933     case TLS_ST_SW_SRVR_DONE:
934         if (statem_flush(s) != 1)
935             return WORK_MORE_A;
936         break;
937
938     case TLS_ST_SW_FINISHED:
939         if (statem_flush(s) != 1)
940             return WORK_MORE_A;
941 #ifndef OPENSSL_NO_SCTP
942         if (SSL_IS_DTLS(s) && s->hit) {
943             /*
944              * Change to new shared key of SCTP-Auth, will be ignored if
945              * no SCTP used.
946              */
947             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
948                      0, NULL);
949         }
950 #endif
951         if (SSL_IS_TLS13(s)) {
952             if (!s->method->ssl3_enc->generate_master_secret(s,
953                         s->master_secret, s->handshake_secret, 0,
954                         &s->session->master_key_length)
955                 || !s->method->ssl3_enc->change_cipher_state(s,
956                         SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_WRITE))
957             /* SSLfatal() already called */
958             return WORK_ERROR;
959         }
960         break;
961
962     case TLS_ST_SW_CERT_REQ:
963         if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) {
964             if (statem_flush(s) != 1)
965                 return WORK_MORE_A;
966         }
967         break;
968
969     case TLS_ST_SW_KEY_UPDATE:
970         if (statem_flush(s) != 1)
971             return WORK_MORE_A;
972         if (!tls13_update_key(s, 1)) {
973             /* SSLfatal() already called */
974             return WORK_ERROR;
975         }
976         break;
977
978     case TLS_ST_SW_SESSION_TICKET:
979         clear_sys_error();
980         if (SSL_IS_TLS13(s) && statem_flush(s) != 1) {
981             if (SSL_get_error(s, 0) == SSL_ERROR_SYSCALL
982                     && conn_is_closed()) {
983                 /*
984                  * We ignore connection closed errors in TLSv1.3 when sending a
985                  * NewSessionTicket and behave as if we were successful. This is
986                  * so that we are still able to read data sent to us by a client
987                  * that closes soon after the end of the handshake without
988                  * waiting to read our post-handshake NewSessionTickets.
989                  */
990                 s->rwstate = SSL_NOTHING;
991                 break;
992             }
993
994             return WORK_MORE_A;
995         }
996         break;
997     }
998
999     return WORK_FINISHED_CONTINUE;
1000 }
1001
1002 /*
1003  * Get the message construction function and message type for sending from the
1004  * server
1005  *
1006  * Valid return values are:
1007  *   1: Success
1008  *   0: Error
1009  */
1010 int ossl_statem_server_construct_message(SSL *s, WPACKET *pkt,
1011                                          confunc_f *confunc, int *mt)
1012 {
1013     OSSL_STATEM *st = &s->statem;
1014
1015     switch (st->hand_state) {
1016     default:
1017         /* Shouldn't happen */
1018         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1019                  SSL_F_OSSL_STATEM_SERVER_CONSTRUCT_MESSAGE,
1020                  SSL_R_BAD_HANDSHAKE_STATE);
1021         return 0;
1022
1023     case TLS_ST_SW_CHANGE:
1024         if (SSL_IS_DTLS(s))
1025             *confunc = dtls_construct_change_cipher_spec;
1026         else
1027             *confunc = tls_construct_change_cipher_spec;
1028         *mt = SSL3_MT_CHANGE_CIPHER_SPEC;
1029         break;
1030
1031     case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
1032         *confunc = dtls_construct_hello_verify_request;
1033         *mt = DTLS1_MT_HELLO_VERIFY_REQUEST;
1034         break;
1035
1036     case TLS_ST_SW_HELLO_REQ:
1037         /* No construction function needed */
1038         *confunc = NULL;
1039         *mt = SSL3_MT_HELLO_REQUEST;
1040         break;
1041
1042     case TLS_ST_SW_SRVR_HELLO:
1043         *confunc = tls_construct_server_hello;
1044         *mt = SSL3_MT_SERVER_HELLO;
1045         break;
1046
1047     case TLS_ST_SW_CERT:
1048         *confunc = tls_construct_server_certificate;
1049         *mt = SSL3_MT_CERTIFICATE;
1050         break;
1051
1052     case TLS_ST_SW_CERT_VRFY:
1053         *confunc = tls_construct_cert_verify;
1054         *mt = SSL3_MT_CERTIFICATE_VERIFY;
1055         break;
1056
1057
1058     case TLS_ST_SW_KEY_EXCH:
1059         *confunc = tls_construct_server_key_exchange;
1060         *mt = SSL3_MT_SERVER_KEY_EXCHANGE;
1061         break;
1062
1063     case TLS_ST_SW_CERT_REQ:
1064         *confunc = tls_construct_certificate_request;
1065         *mt = SSL3_MT_CERTIFICATE_REQUEST;
1066         break;
1067
1068     case TLS_ST_SW_SRVR_DONE:
1069         *confunc = tls_construct_server_done;
1070         *mt = SSL3_MT_SERVER_DONE;
1071         break;
1072
1073     case TLS_ST_SW_SESSION_TICKET:
1074         *confunc = tls_construct_new_session_ticket;
1075         *mt = SSL3_MT_NEWSESSION_TICKET;
1076         break;
1077
1078     case TLS_ST_SW_CERT_STATUS:
1079         *confunc = tls_construct_cert_status;
1080         *mt = SSL3_MT_CERTIFICATE_STATUS;
1081         break;
1082
1083     case TLS_ST_SW_FINISHED:
1084         *confunc = tls_construct_finished;
1085         *mt = SSL3_MT_FINISHED;
1086         break;
1087
1088     case TLS_ST_EARLY_DATA:
1089         *confunc = NULL;
1090         *mt = SSL3_MT_DUMMY;
1091         break;
1092
1093     case TLS_ST_SW_ENCRYPTED_EXTENSIONS:
1094         *confunc = tls_construct_encrypted_extensions;
1095         *mt = SSL3_MT_ENCRYPTED_EXTENSIONS;
1096         break;
1097
1098     case TLS_ST_SW_KEY_UPDATE:
1099         *confunc = tls_construct_key_update;
1100         *mt = SSL3_MT_KEY_UPDATE;
1101         break;
1102     }
1103
1104     return 1;
1105 }
1106
1107 /*
1108  * Maximum size (excluding the Handshake header) of a ClientHello message,
1109  * calculated as follows:
1110  *
1111  *  2 + # client_version
1112  *  32 + # only valid length for random
1113  *  1 + # length of session_id
1114  *  32 + # maximum size for session_id
1115  *  2 + # length of cipher suites
1116  *  2^16-2 + # maximum length of cipher suites array
1117  *  1 + # length of compression_methods
1118  *  2^8-1 + # maximum length of compression methods
1119  *  2 + # length of extensions
1120  *  2^16-1 # maximum length of extensions
1121  */
1122 #define CLIENT_HELLO_MAX_LENGTH         131396
1123
1124 #define CLIENT_KEY_EXCH_MAX_LENGTH      2048
1125 #define NEXT_PROTO_MAX_LENGTH           514
1126
1127 /*
1128  * Returns the maximum allowed length for the current message that we are
1129  * reading. Excludes the message header.
1130  */
1131 size_t ossl_statem_server_max_message_size(SSL *s)
1132 {
1133     OSSL_STATEM *st = &s->statem;
1134
1135     switch (st->hand_state) {
1136     default:
1137         /* Shouldn't happen */
1138         return 0;
1139
1140     case TLS_ST_SR_CLNT_HELLO:
1141         return CLIENT_HELLO_MAX_LENGTH;
1142
1143     case TLS_ST_SR_END_OF_EARLY_DATA:
1144         return END_OF_EARLY_DATA_MAX_LENGTH;
1145
1146     case TLS_ST_SR_CERT:
1147         return s->max_cert_list;
1148
1149     case TLS_ST_SR_KEY_EXCH:
1150         return CLIENT_KEY_EXCH_MAX_LENGTH;
1151
1152     case TLS_ST_SR_CERT_VRFY:
1153         return SSL3_RT_MAX_PLAIN_LENGTH;
1154
1155 #ifndef OPENSSL_NO_NEXTPROTONEG
1156     case TLS_ST_SR_NEXT_PROTO:
1157         return NEXT_PROTO_MAX_LENGTH;
1158 #endif
1159
1160     case TLS_ST_SR_CHANGE:
1161         return CCS_MAX_LENGTH;
1162
1163     case TLS_ST_SR_FINISHED:
1164         return FINISHED_MAX_LENGTH;
1165
1166     case TLS_ST_SR_KEY_UPDATE:
1167         return KEY_UPDATE_MAX_LENGTH;
1168     }
1169 }
1170
1171 /*
1172  * Process a message that the server has received from the client.
1173  */
1174 MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL *s, PACKET *pkt)
1175 {
1176     OSSL_STATEM *st = &s->statem;
1177
1178     switch (st->hand_state) {
1179     default:
1180         /* Shouldn't happen */
1181         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1182                  SSL_F_OSSL_STATEM_SERVER_PROCESS_MESSAGE,
1183                  ERR_R_INTERNAL_ERROR);
1184         return MSG_PROCESS_ERROR;
1185
1186     case TLS_ST_SR_CLNT_HELLO:
1187         return tls_process_client_hello(s, pkt);
1188
1189     case TLS_ST_SR_END_OF_EARLY_DATA:
1190         return tls_process_end_of_early_data(s, pkt);
1191
1192     case TLS_ST_SR_CERT:
1193         return tls_process_client_certificate(s, pkt);
1194
1195     case TLS_ST_SR_KEY_EXCH:
1196         return tls_process_client_key_exchange(s, pkt);
1197
1198     case TLS_ST_SR_CERT_VRFY:
1199         return tls_process_cert_verify(s, pkt);
1200
1201 #ifndef OPENSSL_NO_NEXTPROTONEG
1202     case TLS_ST_SR_NEXT_PROTO:
1203         return tls_process_next_proto(s, pkt);
1204 #endif
1205
1206     case TLS_ST_SR_CHANGE:
1207         return tls_process_change_cipher_spec(s, pkt);
1208
1209     case TLS_ST_SR_FINISHED:
1210         return tls_process_finished(s, pkt);
1211
1212     case TLS_ST_SR_KEY_UPDATE:
1213         return tls_process_key_update(s, pkt);
1214
1215     }
1216 }
1217
1218 /*
1219  * Perform any further processing required following the receipt of a message
1220  * from the client
1221  */
1222 WORK_STATE ossl_statem_server_post_process_message(SSL *s, WORK_STATE wst)
1223 {
1224     OSSL_STATEM *st = &s->statem;
1225
1226     switch (st->hand_state) {
1227     default:
1228         /* Shouldn't happen */
1229         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1230                  SSL_F_OSSL_STATEM_SERVER_POST_PROCESS_MESSAGE,
1231                  ERR_R_INTERNAL_ERROR);
1232         return WORK_ERROR;
1233
1234     case TLS_ST_SR_CLNT_HELLO:
1235         return tls_post_process_client_hello(s, wst);
1236
1237     case TLS_ST_SR_KEY_EXCH:
1238         return tls_post_process_client_key_exchange(s, wst);
1239     }
1240 }
1241
1242 #ifndef OPENSSL_NO_SRP
1243 /* Returns 1 on success, 0 for retryable error, -1 for fatal error */
1244 static int ssl_check_srp_ext_ClientHello(SSL *s)
1245 {
1246     int ret;
1247     int al = SSL_AD_UNRECOGNIZED_NAME;
1248
1249     if ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
1250         (s->srp_ctx.TLS_ext_srp_username_callback != NULL)) {
1251         if (s->srp_ctx.login == NULL) {
1252             /*
1253              * RFC 5054 says SHOULD reject, we do so if There is no srp
1254              * login name
1255              */
1256             SSLfatal(s, SSL_AD_UNKNOWN_PSK_IDENTITY,
1257                      SSL_F_SSL_CHECK_SRP_EXT_CLIENTHELLO,
1258                      SSL_R_PSK_IDENTITY_NOT_FOUND);
1259             return -1;
1260         } else {
1261             ret = SSL_srp_server_param_with_username(s, &al);
1262             if (ret < 0)
1263                 return 0;
1264             if (ret == SSL3_AL_FATAL) {
1265                 SSLfatal(s, al, SSL_F_SSL_CHECK_SRP_EXT_CLIENTHELLO,
1266                          al == SSL_AD_UNKNOWN_PSK_IDENTITY
1267                          ? SSL_R_PSK_IDENTITY_NOT_FOUND
1268                          : SSL_R_CLIENTHELLO_TLSEXT);
1269                 return -1;
1270             }
1271         }
1272     }
1273     return 1;
1274 }
1275 #endif
1276
1277 int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie,
1278                                   size_t cookie_len)
1279 {
1280     /* Always use DTLS 1.0 version: see RFC 6347 */
1281     if (!WPACKET_put_bytes_u16(pkt, DTLS1_VERSION)
1282             || !WPACKET_sub_memcpy_u8(pkt, cookie, cookie_len))
1283         return 0;
1284
1285     return 1;
1286 }
1287
1288 int dtls_construct_hello_verify_request(SSL *s, WPACKET *pkt)
1289 {
1290     unsigned int cookie_leni;
1291     if (s->ctx->app_gen_cookie_cb == NULL ||
1292         s->ctx->app_gen_cookie_cb(s, s->d1->cookie,
1293                                   &cookie_leni) == 0 ||
1294         cookie_leni > 255) {
1295         SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST,
1296                  SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
1297         return 0;
1298     }
1299     s->d1->cookie_len = cookie_leni;
1300
1301     if (!dtls_raw_hello_verify_request(pkt, s->d1->cookie,
1302                                               s->d1->cookie_len)) {
1303         SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST,
1304                  ERR_R_INTERNAL_ERROR);
1305         return 0;
1306     }
1307
1308     return 1;
1309 }
1310
1311 #ifndef OPENSSL_NO_EC
1312 /*-
1313  * ssl_check_for_safari attempts to fingerprint Safari using OS X
1314  * SecureTransport using the TLS extension block in |hello|.
1315  * Safari, since 10.6, sends exactly these extensions, in this order:
1316  *   SNI,
1317  *   elliptic_curves
1318  *   ec_point_formats
1319  *   signature_algorithms (for TLSv1.2 only)
1320  *
1321  * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8,
1322  * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them.
1323  * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from
1324  * 10.8..10.8.3 (which don't work).
1325  */
1326 static void ssl_check_for_safari(SSL *s, const CLIENTHELLO_MSG *hello)
1327 {
1328     static const unsigned char kSafariExtensionsBlock[] = {
1329         0x00, 0x0a,             /* elliptic_curves extension */
1330         0x00, 0x08,             /* 8 bytes */
1331         0x00, 0x06,             /* 6 bytes of curve ids */
1332         0x00, 0x17,             /* P-256 */
1333         0x00, 0x18,             /* P-384 */
1334         0x00, 0x19,             /* P-521 */
1335
1336         0x00, 0x0b,             /* ec_point_formats */
1337         0x00, 0x02,             /* 2 bytes */
1338         0x01,                   /* 1 point format */
1339         0x00,                   /* uncompressed */
1340         /* The following is only present in TLS 1.2 */
1341         0x00, 0x0d,             /* signature_algorithms */
1342         0x00, 0x0c,             /* 12 bytes */
1343         0x00, 0x0a,             /* 10 bytes */
1344         0x05, 0x01,             /* SHA-384/RSA */
1345         0x04, 0x01,             /* SHA-256/RSA */
1346         0x02, 0x01,             /* SHA-1/RSA */
1347         0x04, 0x03,             /* SHA-256/ECDSA */
1348         0x02, 0x03,             /* SHA-1/ECDSA */
1349     };
1350     /* Length of the common prefix (first two extensions). */
1351     static const size_t kSafariCommonExtensionsLength = 18;
1352     unsigned int type;
1353     PACKET sni, tmppkt;
1354     size_t ext_len;
1355
1356     tmppkt = hello->extensions;
1357
1358     if (!PACKET_forward(&tmppkt, 2)
1359         || !PACKET_get_net_2(&tmppkt, &type)
1360         || !PACKET_get_length_prefixed_2(&tmppkt, &sni)) {
1361         return;
1362     }
1363
1364     if (type != TLSEXT_TYPE_server_name)
1365         return;
1366
1367     ext_len = TLS1_get_client_version(s) >= TLS1_2_VERSION ?
1368         sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength;
1369
1370     s->s3.is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock,
1371                                              ext_len);
1372 }
1373 #endif                          /* !OPENSSL_NO_EC */
1374
1375 MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt)
1376 {
1377     /* |cookie| will only be initialized for DTLS. */
1378     PACKET session_id, compression, extensions, cookie;
1379     static const unsigned char null_compression = 0;
1380     CLIENTHELLO_MSG *clienthello = NULL;
1381
1382     /* Check if this is actually an unexpected renegotiation ClientHello */
1383     if (s->renegotiate == 0 && !SSL_IS_FIRST_HANDSHAKE(s)) {
1384         if (!ossl_assert(!SSL_IS_TLS13(s))) {
1385             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1386                      ERR_R_INTERNAL_ERROR);
1387             goto err;
1388         }
1389         if ((s->options & SSL_OP_NO_RENEGOTIATION) != 0
1390                 || (!s->s3.send_connection_binding
1391                     && (s->options
1392                         & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) == 0)) {
1393             ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION);
1394             return MSG_PROCESS_FINISHED_READING;
1395         }
1396         s->renegotiate = 1;
1397         s->new_session = 1;
1398     }
1399
1400     clienthello = OPENSSL_zalloc(sizeof(*clienthello));
1401     if (clienthello == NULL) {
1402         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1403                  ERR_R_INTERNAL_ERROR);
1404         goto err;
1405     }
1406
1407     /*
1408      * First, parse the raw ClientHello data into the CLIENTHELLO_MSG structure.
1409      */
1410     clienthello->isv2 = RECORD_LAYER_is_sslv2_record(&s->rlayer);
1411     PACKET_null_init(&cookie);
1412
1413     if (clienthello->isv2) {
1414         unsigned int mt;
1415
1416         if (!SSL_IS_FIRST_HANDSHAKE(s)
1417                 || s->hello_retry_request != SSL_HRR_NONE) {
1418             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
1419                      SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNEXPECTED_MESSAGE);
1420             goto err;
1421         }
1422
1423         /*-
1424          * An SSLv3/TLSv1 backwards-compatible CLIENT-HELLO in an SSLv2
1425          * header is sent directly on the wire, not wrapped as a TLS
1426          * record. Our record layer just processes the message length and passes
1427          * the rest right through. Its format is:
1428          * Byte  Content
1429          * 0-1   msg_length - decoded by the record layer
1430          * 2     msg_type - s->init_msg points here
1431          * 3-4   version
1432          * 5-6   cipher_spec_length
1433          * 7-8   session_id_length
1434          * 9-10  challenge_length
1435          * ...   ...
1436          */
1437
1438         if (!PACKET_get_1(pkt, &mt)
1439             || mt != SSL2_MT_CLIENT_HELLO) {
1440             /*
1441              * Should never happen. We should have tested this in the record
1442              * layer in order to have determined that this is a SSLv2 record
1443              * in the first place
1444              */
1445             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1446                      ERR_R_INTERNAL_ERROR);
1447             goto err;
1448         }
1449     }
1450
1451     if (!PACKET_get_net_2(pkt, &clienthello->legacy_version)) {
1452         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1453                  SSL_R_LENGTH_TOO_SHORT);
1454         goto err;
1455     }
1456
1457     /* Parse the message and load client random. */
1458     if (clienthello->isv2) {
1459         /*
1460          * Handle an SSLv2 backwards compatible ClientHello
1461          * Note, this is only for SSLv3+ using the backward compatible format.
1462          * Real SSLv2 is not supported, and is rejected below.
1463          */
1464         unsigned int ciphersuite_len, session_id_len, challenge_len;
1465         PACKET challenge;
1466
1467         if (!PACKET_get_net_2(pkt, &ciphersuite_len)
1468             || !PACKET_get_net_2(pkt, &session_id_len)
1469             || !PACKET_get_net_2(pkt, &challenge_len)) {
1470             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1471                      SSL_R_RECORD_LENGTH_MISMATCH);
1472             goto err;
1473         }
1474
1475         if (session_id_len > SSL_MAX_SSL_SESSION_ID_LENGTH) {
1476             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1477                      SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1478             goto err;
1479         }
1480
1481         if (!PACKET_get_sub_packet(pkt, &clienthello->ciphersuites,
1482                                    ciphersuite_len)
1483             || !PACKET_copy_bytes(pkt, clienthello->session_id, session_id_len)
1484             || !PACKET_get_sub_packet(pkt, &challenge, challenge_len)
1485             /* No extensions. */
1486             || PACKET_remaining(pkt) != 0) {
1487             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1488                      SSL_R_RECORD_LENGTH_MISMATCH);
1489             goto err;
1490         }
1491         clienthello->session_id_len = session_id_len;
1492
1493         /* Load the client random and compression list. We use SSL3_RANDOM_SIZE
1494          * here rather than sizeof(clienthello->random) because that is the limit
1495          * for SSLv3 and it is fixed. It won't change even if
1496          * sizeof(clienthello->random) does.
1497          */
1498         challenge_len = challenge_len > SSL3_RANDOM_SIZE
1499                         ? SSL3_RANDOM_SIZE : challenge_len;
1500         memset(clienthello->random, 0, SSL3_RANDOM_SIZE);
1501         if (!PACKET_copy_bytes(&challenge,
1502                                clienthello->random + SSL3_RANDOM_SIZE -
1503                                challenge_len, challenge_len)
1504             /* Advertise only null compression. */
1505             || !PACKET_buf_init(&compression, &null_compression, 1)) {
1506             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1507                      ERR_R_INTERNAL_ERROR);
1508             goto err;
1509         }
1510
1511         PACKET_null_init(&clienthello->extensions);
1512     } else {
1513         /* Regular ClientHello. */
1514         if (!PACKET_copy_bytes(pkt, clienthello->random, SSL3_RANDOM_SIZE)
1515             || !PACKET_get_length_prefixed_1(pkt, &session_id)
1516             || !PACKET_copy_all(&session_id, clienthello->session_id,
1517                     SSL_MAX_SSL_SESSION_ID_LENGTH,
1518                     &clienthello->session_id_len)) {
1519             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1520                      SSL_R_LENGTH_MISMATCH);
1521             goto err;
1522         }
1523
1524         if (SSL_IS_DTLS(s)) {
1525             if (!PACKET_get_length_prefixed_1(pkt, &cookie)) {
1526                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1527                          SSL_R_LENGTH_MISMATCH);
1528                 goto err;
1529             }
1530             if (!PACKET_copy_all(&cookie, clienthello->dtls_cookie,
1531                                  DTLS1_COOKIE_LENGTH,
1532                                  &clienthello->dtls_cookie_len)) {
1533                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1534                          SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1535                 goto err;
1536             }
1537             /*
1538              * If we require cookies and this ClientHello doesn't contain one,
1539              * just return since we do not want to allocate any memory yet.
1540              * So check cookie length...
1541              */
1542             if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
1543                 if (clienthello->dtls_cookie_len == 0) {
1544                     OPENSSL_free(clienthello);
1545                     return MSG_PROCESS_FINISHED_READING;
1546                 }
1547             }
1548         }
1549
1550         if (!PACKET_get_length_prefixed_2(pkt, &clienthello->ciphersuites)) {
1551             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1552                      SSL_R_LENGTH_MISMATCH);
1553             goto err;
1554         }
1555
1556         if (!PACKET_get_length_prefixed_1(pkt, &compression)) {
1557             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1558                      SSL_R_LENGTH_MISMATCH);
1559             goto err;
1560         }
1561
1562         /* Could be empty. */
1563         if (PACKET_remaining(pkt) == 0) {
1564             PACKET_null_init(&clienthello->extensions);
1565         } else {
1566             if (!PACKET_get_length_prefixed_2(pkt, &clienthello->extensions)
1567                     || PACKET_remaining(pkt) != 0) {
1568                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1569                          SSL_R_LENGTH_MISMATCH);
1570                 goto err;
1571             }
1572         }
1573     }
1574
1575     if (!PACKET_copy_all(&compression, clienthello->compressions,
1576                          MAX_COMPRESSIONS_SIZE,
1577                          &clienthello->compressions_len)) {
1578         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CLIENT_HELLO,
1579                  ERR_R_INTERNAL_ERROR);
1580         goto err;
1581     }
1582
1583     /* Preserve the raw extensions PACKET for later use */
1584     extensions = clienthello->extensions;
1585     if (!tls_collect_extensions(s, &extensions, SSL_EXT_CLIENT_HELLO,
1586                                 &clienthello->pre_proc_exts,
1587                                 &clienthello->pre_proc_exts_len, 1)) {
1588         /* SSLfatal already been called */
1589         goto err;
1590     }
1591     s->clienthello = clienthello;
1592
1593     return MSG_PROCESS_CONTINUE_PROCESSING;
1594
1595  err:
1596     if (clienthello != NULL)
1597         OPENSSL_free(clienthello->pre_proc_exts);
1598     OPENSSL_free(clienthello);
1599
1600     return MSG_PROCESS_ERROR;
1601 }
1602
1603 static int tls_early_post_process_client_hello(SSL *s)
1604 {
1605     unsigned int j;
1606     int i, al = SSL_AD_INTERNAL_ERROR;
1607     int protverr;
1608     size_t loop;
1609     unsigned long id;
1610 #ifndef OPENSSL_NO_COMP
1611     SSL_COMP *comp = NULL;
1612 #endif
1613     const SSL_CIPHER *c;
1614     STACK_OF(SSL_CIPHER) *ciphers = NULL;
1615     STACK_OF(SSL_CIPHER) *scsvs = NULL;
1616     CLIENTHELLO_MSG *clienthello = s->clienthello;
1617     DOWNGRADE dgrd = DOWNGRADE_NONE;
1618
1619     /* Finished parsing the ClientHello, now we can start processing it */
1620     /* Give the ClientHello callback a crack at things */
1621     if (s->ctx->client_hello_cb != NULL) {
1622         /* A failure in the ClientHello callback terminates the connection. */
1623         switch (s->ctx->client_hello_cb(s, &al, s->ctx->client_hello_cb_arg)) {
1624         case SSL_CLIENT_HELLO_SUCCESS:
1625             break;
1626         case SSL_CLIENT_HELLO_RETRY:
1627             s->rwstate = SSL_CLIENT_HELLO_CB;
1628             return -1;
1629         case SSL_CLIENT_HELLO_ERROR:
1630         default:
1631             SSLfatal(s, al,
1632                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1633                      SSL_R_CALLBACK_FAILED);
1634             goto err;
1635         }
1636     }
1637
1638     /* Set up the client_random */
1639     memcpy(s->s3.client_random, clienthello->random, SSL3_RANDOM_SIZE);
1640
1641     /* Choose the version */
1642
1643     if (clienthello->isv2) {
1644         if (clienthello->legacy_version == SSL2_VERSION
1645                 || (clienthello->legacy_version & 0xff00)
1646                    != (SSL3_VERSION_MAJOR << 8)) {
1647             /*
1648              * This is real SSLv2 or something completely unknown. We don't
1649              * support it.
1650              */
1651             SSLfatal(s, SSL_AD_PROTOCOL_VERSION,
1652                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1653                      SSL_R_UNKNOWN_PROTOCOL);
1654             goto err;
1655         }
1656         /* SSLv3/TLS */
1657         s->client_version = clienthello->legacy_version;
1658     }
1659     /*
1660      * Do SSL/TLS version negotiation if applicable. For DTLS we just check
1661      * versions are potentially compatible. Version negotiation comes later.
1662      */
1663     if (!SSL_IS_DTLS(s)) {
1664         protverr = ssl_choose_server_version(s, clienthello, &dgrd);
1665     } else if (s->method->version != DTLS_ANY_VERSION &&
1666                DTLS_VERSION_LT((int)clienthello->legacy_version, s->version)) {
1667         protverr = SSL_R_VERSION_TOO_LOW;
1668     } else {
1669         protverr = 0;
1670     }
1671
1672     if (protverr) {
1673         if (SSL_IS_FIRST_HANDSHAKE(s)) {
1674             /* like ssl3_get_record, send alert using remote version number */
1675             s->version = s->client_version = clienthello->legacy_version;
1676         }
1677         SSLfatal(s, SSL_AD_PROTOCOL_VERSION,
1678                  SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO, protverr);
1679         goto err;
1680     }
1681
1682     /* TLSv1.3 specifies that a ClientHello must end on a record boundary */
1683     if (SSL_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) {
1684         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
1685                  SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1686                  SSL_R_NOT_ON_RECORD_BOUNDARY);
1687         goto err;
1688     }
1689
1690     if (SSL_IS_DTLS(s)) {
1691         /* Empty cookie was already handled above by returning early. */
1692         if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
1693             if (s->ctx->app_verify_cookie_cb != NULL) {
1694                 if (s->ctx->app_verify_cookie_cb(s, clienthello->dtls_cookie,
1695                         clienthello->dtls_cookie_len) == 0) {
1696                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1697                              SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1698                              SSL_R_COOKIE_MISMATCH);
1699                     goto err;
1700                     /* else cookie verification succeeded */
1701                 }
1702                 /* default verification */
1703             } else if (s->d1->cookie_len != clienthello->dtls_cookie_len
1704                     || memcmp(clienthello->dtls_cookie, s->d1->cookie,
1705                               s->d1->cookie_len) != 0) {
1706                 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1707                          SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1708                          SSL_R_COOKIE_MISMATCH);
1709                 goto err;
1710             }
1711             s->d1->cookie_verified = 1;
1712         }
1713         if (s->method->version == DTLS_ANY_VERSION) {
1714             protverr = ssl_choose_server_version(s, clienthello, &dgrd);
1715             if (protverr != 0) {
1716                 s->version = s->client_version;
1717                 SSLfatal(s, SSL_AD_PROTOCOL_VERSION,
1718                          SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO, protverr);
1719                 goto err;
1720             }
1721         }
1722     }
1723
1724     s->hit = 0;
1725
1726     if (!ssl_cache_cipherlist(s, &clienthello->ciphersuites,
1727                               clienthello->isv2) ||
1728         !bytes_to_cipher_list(s, &clienthello->ciphersuites, &ciphers, &scsvs,
1729                               clienthello->isv2, 1)) {
1730         /* SSLfatal() already called */
1731         goto err;
1732     }
1733
1734     s->s3.send_connection_binding = 0;
1735     /* Check what signalling cipher-suite values were received. */
1736     if (scsvs != NULL) {
1737         for(i = 0; i < sk_SSL_CIPHER_num(scsvs); i++) {
1738             c = sk_SSL_CIPHER_value(scsvs, i);
1739             if (SSL_CIPHER_get_id(c) == SSL3_CK_SCSV) {
1740                 if (s->renegotiate) {
1741                     /* SCSV is fatal if renegotiating */
1742                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1743                              SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1744                              SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
1745                     goto err;
1746                 }
1747                 s->s3.send_connection_binding = 1;
1748             } else if (SSL_CIPHER_get_id(c) == SSL3_CK_FALLBACK_SCSV &&
1749                        !ssl_check_version_downgrade(s)) {
1750                 /*
1751                  * This SCSV indicates that the client previously tried
1752                  * a higher version.  We should fail if the current version
1753                  * is an unexpected downgrade, as that indicates that the first
1754                  * connection may have been tampered with in order to trigger
1755                  * an insecure downgrade.
1756                  */
1757                 SSLfatal(s, SSL_AD_INAPPROPRIATE_FALLBACK,
1758                          SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1759                          SSL_R_INAPPROPRIATE_FALLBACK);
1760                 goto err;
1761             }
1762         }
1763     }
1764
1765     /* For TLSv1.3 we must select the ciphersuite *before* session resumption */
1766     if (SSL_IS_TLS13(s)) {
1767         const SSL_CIPHER *cipher =
1768             ssl3_choose_cipher(s, ciphers, SSL_get_ciphers(s));
1769
1770         if (cipher == NULL) {
1771             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1772                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1773                      SSL_R_NO_SHARED_CIPHER);
1774             goto err;
1775         }
1776         if (s->hello_retry_request == SSL_HRR_PENDING
1777                 && (s->s3.tmp.new_cipher == NULL
1778                     || s->s3.tmp.new_cipher->id != cipher->id)) {
1779             /*
1780              * A previous HRR picked a different ciphersuite to the one we
1781              * just selected. Something must have changed.
1782              */
1783             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1784                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1785                      SSL_R_BAD_CIPHER);
1786             goto err;
1787         }
1788         s->s3.tmp.new_cipher = cipher;
1789     }
1790
1791     /* We need to do this before getting the session */
1792     if (!tls_parse_extension(s, TLSEXT_IDX_extended_master_secret,
1793                              SSL_EXT_CLIENT_HELLO,
1794                              clienthello->pre_proc_exts, NULL, 0)) {
1795         /* SSLfatal() already called */
1796         goto err;
1797     }
1798
1799     /*
1800      * We don't allow resumption in a backwards compatible ClientHello.
1801      * TODO(openssl-team): in TLS1.1+, session_id MUST be empty.
1802      *
1803      * Versions before 0.9.7 always allow clients to resume sessions in
1804      * renegotiation. 0.9.7 and later allow this by default, but optionally
1805      * ignore resumption requests with flag
1806      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather
1807      * than a change to default behavior so that applications relying on
1808      * this for security won't even compile against older library versions).
1809      * 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to
1810      * request renegotiation but not a new session (s->new_session remains
1811      * unset): for servers, this essentially just means that the
1812      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be
1813      * ignored.
1814      */
1815     if (clienthello->isv2 ||
1816         (s->new_session &&
1817          (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
1818         if (!ssl_get_new_session(s, 1)) {
1819             /* SSLfatal() already called */
1820             goto err;
1821         }
1822     } else {
1823         i = ssl_get_prev_session(s, clienthello);
1824         if (i == 1) {
1825             /* previous session */
1826             s->hit = 1;
1827         } else if (i == -1) {
1828             /* SSLfatal() already called */
1829             goto err;
1830         } else {
1831             /* i == 0 */
1832             if (!ssl_get_new_session(s, 1)) {
1833                 /* SSLfatal() already called */
1834                 goto err;
1835             }
1836         }
1837     }
1838
1839     if (SSL_IS_TLS13(s)) {
1840         memcpy(s->tmp_session_id, s->clienthello->session_id,
1841                s->clienthello->session_id_len);
1842         s->tmp_session_id_len = s->clienthello->session_id_len;
1843     }
1844
1845     /*
1846      * If it is a hit, check that the cipher is in the list. In TLSv1.3 we check
1847      * ciphersuite compatibility with the session as part of resumption.
1848      */
1849     if (!SSL_IS_TLS13(s) && s->hit) {
1850         j = 0;
1851         id = s->session->cipher->id;
1852
1853         OSSL_TRACE_BEGIN(TLS_CIPHER) {
1854             BIO_printf(trc_out, "client sent %d ciphers\n",
1855                        sk_SSL_CIPHER_num(ciphers));
1856         }
1857         for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1858             c = sk_SSL_CIPHER_value(ciphers, i);
1859             if (trc_out != NULL)
1860                 BIO_printf(trc_out, "client [%2d of %2d]:%s\n", i,
1861                            sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c));
1862             if (c->id == id) {
1863                 j = 1;
1864                 break;
1865             }
1866         }
1867         if (j == 0) {
1868             /*
1869              * we need to have the cipher in the cipher list if we are asked
1870              * to reuse it
1871              */
1872             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1873                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1874                      SSL_R_REQUIRED_CIPHER_MISSING);
1875             OSSL_TRACE_CANCEL(TLS_CIPHER);
1876             goto err;
1877         }
1878         OSSL_TRACE_END(TLS_CIPHER);
1879     }
1880
1881     for (loop = 0; loop < clienthello->compressions_len; loop++) {
1882         if (clienthello->compressions[loop] == 0)
1883             break;
1884     }
1885
1886     if (loop >= clienthello->compressions_len) {
1887         /* no compress */
1888         SSLfatal(s, SSL_AD_DECODE_ERROR,
1889                  SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1890                  SSL_R_NO_COMPRESSION_SPECIFIED);
1891         goto err;
1892     }
1893
1894 #ifndef OPENSSL_NO_EC
1895     if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG)
1896         ssl_check_for_safari(s, clienthello);
1897 #endif                          /* !OPENSSL_NO_EC */
1898
1899     /* TLS extensions */
1900     if (!tls_parse_all_extensions(s, SSL_EXT_CLIENT_HELLO,
1901                                   clienthello->pre_proc_exts, NULL, 0, 1)) {
1902         /* SSLfatal() already called */
1903         goto err;
1904     }
1905
1906     /*
1907      * Check if we want to use external pre-shared secret for this handshake
1908      * for not reused session only. We need to generate server_random before
1909      * calling tls_session_secret_cb in order to allow SessionTicket
1910      * processing to use it in key derivation.
1911      */
1912     {
1913         unsigned char *pos;
1914         pos = s->s3.server_random;
1915         if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE, dgrd) <= 0) {
1916             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1917                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1918                      ERR_R_INTERNAL_ERROR);
1919             goto err;
1920         }
1921     }
1922
1923     if (!s->hit
1924             && s->version >= TLS1_VERSION
1925             && !SSL_IS_TLS13(s)
1926             && !SSL_IS_DTLS(s)
1927             && s->ext.session_secret_cb) {
1928         const SSL_CIPHER *pref_cipher = NULL;
1929         /*
1930          * s->session->master_key_length is a size_t, but this is an int for
1931          * backwards compat reasons
1932          */
1933         int master_key_length;
1934
1935         master_key_length = sizeof(s->session->master_key);
1936         if (s->ext.session_secret_cb(s, s->session->master_key,
1937                                      &master_key_length, ciphers,
1938                                      &pref_cipher,
1939                                      s->ext.session_secret_cb_arg)
1940                 && master_key_length > 0) {
1941             s->session->master_key_length = master_key_length;
1942             s->hit = 1;
1943             s->peer_ciphers = ciphers;
1944             s->session->verify_result = X509_V_OK;
1945
1946             ciphers = NULL;
1947
1948             /* check if some cipher was preferred by call back */
1949             if (pref_cipher == NULL)
1950                 pref_cipher = ssl3_choose_cipher(s, s->peer_ciphers,
1951                                                  SSL_get_ciphers(s));
1952             if (pref_cipher == NULL) {
1953                 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1954                          SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1955                          SSL_R_NO_SHARED_CIPHER);
1956                 goto err;
1957             }
1958
1959             s->session->cipher = pref_cipher;
1960             sk_SSL_CIPHER_free(s->cipher_list);
1961             s->cipher_list = sk_SSL_CIPHER_dup(s->peer_ciphers);
1962             sk_SSL_CIPHER_free(s->cipher_list_by_id);
1963             s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->peer_ciphers);
1964         }
1965     }
1966
1967     /*
1968      * Worst case, we will use the NULL compression, but if we have other
1969      * options, we will now look for them.  We have complen-1 compression
1970      * algorithms from the client, starting at q.
1971      */
1972     s->s3.tmp.new_compression = NULL;
1973     if (SSL_IS_TLS13(s)) {
1974         /*
1975          * We already checked above that the NULL compression method appears in
1976          * the list. Now we check there aren't any others (which is illegal in
1977          * a TLSv1.3 ClientHello.
1978          */
1979         if (clienthello->compressions_len != 1) {
1980             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1981                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1982                      SSL_R_INVALID_COMPRESSION_ALGORITHM);
1983             goto err;
1984         }
1985     }
1986 #ifndef OPENSSL_NO_COMP
1987     /* This only happens if we have a cache hit */
1988     else if (s->session->compress_meth != 0) {
1989         int m, comp_id = s->session->compress_meth;
1990         unsigned int k;
1991         /* Perform sanity checks on resumed compression algorithm */
1992         /* Can't disable compression */
1993         if (!ssl_allow_compression(s)) {
1994             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1995                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
1996                      SSL_R_INCONSISTENT_COMPRESSION);
1997             goto err;
1998         }
1999         /* Look for resumed compression method */
2000         for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++) {
2001             comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
2002             if (comp_id == comp->id) {
2003                 s->s3.tmp.new_compression = comp;
2004                 break;
2005             }
2006         }
2007         if (s->s3.tmp.new_compression == NULL) {
2008             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
2009                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
2010                      SSL_R_INVALID_COMPRESSION_ALGORITHM);
2011             goto err;
2012         }
2013         /* Look for resumed method in compression list */
2014         for (k = 0; k < clienthello->compressions_len; k++) {
2015             if (clienthello->compressions[k] == comp_id)
2016                 break;
2017         }
2018         if (k >= clienthello->compressions_len) {
2019             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
2020                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
2021                      SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING);
2022             goto err;
2023         }
2024     } else if (s->hit) {
2025         comp = NULL;
2026     } else if (ssl_allow_compression(s) && s->ctx->comp_methods) {
2027         /* See if we have a match */
2028         int m, nn, v, done = 0;
2029         unsigned int o;
2030
2031         nn = sk_SSL_COMP_num(s->ctx->comp_methods);
2032         for (m = 0; m < nn; m++) {
2033             comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
2034             v = comp->id;
2035             for (o = 0; o < clienthello->compressions_len; o++) {
2036                 if (v == clienthello->compressions[o]) {
2037                     done = 1;
2038                     break;
2039                 }
2040             }
2041             if (done)
2042                 break;
2043         }
2044         if (done)
2045             s->s3.tmp.new_compression = comp;
2046         else
2047             comp = NULL;
2048     }
2049 #else
2050     /*
2051      * If compression is disabled we'd better not try to resume a session
2052      * using compression.
2053      */
2054     if (s->session->compress_meth != 0) {
2055         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
2056                  SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
2057                  SSL_R_INCONSISTENT_COMPRESSION);
2058         goto err;
2059     }
2060 #endif
2061
2062     /*
2063      * Given s->peer_ciphers and SSL_get_ciphers, we must pick a cipher
2064      */
2065
2066     if (!s->hit || SSL_IS_TLS13(s)) {
2067         sk_SSL_CIPHER_free(s->peer_ciphers);
2068         s->peer_ciphers = ciphers;
2069         if (ciphers == NULL) {
2070             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2071                      SSL_F_TLS_EARLY_POST_PROCESS_CLIENT_HELLO,
2072                      ERR_R_INTERNAL_ERROR);
2073             goto err;
2074         }
2075         ciphers = NULL;
2076     }
2077
2078     if (!s->hit) {
2079 #ifdef OPENSSL_NO_COMP
2080         s->session->compress_meth = 0;
2081 #else
2082         s->session->compress_meth = (comp == NULL) ? 0 : comp->id;
2083 #endif
2084         if (!tls1_set_server_sigalgs(s)) {
2085             /* SSLfatal() already called */
2086             goto err;
2087         }
2088     }
2089
2090     sk_SSL_CIPHER_free(ciphers);
2091     sk_SSL_CIPHER_free(scsvs);
2092     OPENSSL_free(clienthello->pre_proc_exts);
2093     OPENSSL_free(s->clienthello);
2094     s->clienthello = NULL;
2095     return 1;
2096  err:
2097     sk_SSL_CIPHER_free(ciphers);
2098     sk_SSL_CIPHER_free(scsvs);
2099     OPENSSL_free(clienthello->pre_proc_exts);
2100     OPENSSL_free(s->clienthello);
2101     s->clienthello = NULL;
2102
2103     return 0;
2104 }
2105
2106 /*
2107  * Call the status request callback if needed. Upon success, returns 1.
2108  * Upon failure, returns 0.
2109  */
2110 static int tls_handle_status_request(SSL *s)
2111 {
2112     s->ext.status_expected = 0;
2113
2114     /*
2115      * If status request then ask callback what to do. Note: this must be
2116      * called after servername callbacks in case the certificate has changed,
2117      * and must be called after the cipher has been chosen because this may
2118      * influence which certificate is sent
2119      */
2120     if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing && s->ctx != NULL
2121             && s->ctx->ext.status_cb != NULL) {
2122         int ret;
2123
2124         /* If no certificate can't return certificate status */
2125         if (s->s3.tmp.cert != NULL) {
2126             /*
2127              * Set current certificate to one we will use so SSL_get_certificate
2128              * et al can pick it up.
2129              */
2130             s->cert->key = s->s3.tmp.cert;
2131             ret = s->ctx->ext.status_cb(s, s->ctx->ext.status_arg);
2132             switch (ret) {
2133                 /* We don't want to send a status request response */
2134             case SSL_TLSEXT_ERR_NOACK:
2135                 s->ext.status_expected = 0;
2136                 break;
2137                 /* status request response should be sent */
2138             case SSL_TLSEXT_ERR_OK:
2139                 if (s->ext.ocsp.resp)
2140                     s->ext.status_expected = 1;
2141                 break;
2142                 /* something bad happened */
2143             case SSL_TLSEXT_ERR_ALERT_FATAL:
2144             default:
2145                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2146                          SSL_F_TLS_HANDLE_STATUS_REQUEST,
2147                          SSL_R_CLIENTHELLO_TLSEXT);
2148                 return 0;
2149             }
2150         }
2151     }
2152
2153     return 1;
2154 }
2155
2156 /*
2157  * Call the alpn_select callback if needed. Upon success, returns 1.
2158  * Upon failure, returns 0.
2159  */
2160 int tls_handle_alpn(SSL *s)
2161 {
2162     const unsigned char *selected = NULL;
2163     unsigned char selected_len = 0;
2164
2165     if (s->ctx->ext.alpn_select_cb != NULL && s->s3.alpn_proposed != NULL) {
2166         int r = s->ctx->ext.alpn_select_cb(s, &selected, &selected_len,
2167                                            s->s3.alpn_proposed,
2168                                            (unsigned int)s->s3.alpn_proposed_len,
2169                                            s->ctx->ext.alpn_select_cb_arg);
2170
2171         if (r == SSL_TLSEXT_ERR_OK) {
2172             OPENSSL_free(s->s3.alpn_selected);
2173             s->s3.alpn_selected = OPENSSL_memdup(selected, selected_len);
2174             if (s->s3.alpn_selected == NULL) {
2175                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_HANDLE_ALPN,
2176                          ERR_R_INTERNAL_ERROR);
2177                 return 0;
2178             }
2179             s->s3.alpn_selected_len = selected_len;
2180 #ifndef OPENSSL_NO_NEXTPROTONEG
2181             /* ALPN takes precedence over NPN. */
2182             s->s3.npn_seen = 0;
2183 #endif
2184
2185             /* Check ALPN is consistent with session */
2186             if (s->session->ext.alpn_selected == NULL
2187                         || selected_len != s->session->ext.alpn_selected_len
2188                         || memcmp(selected, s->session->ext.alpn_selected,
2189                                   selected_len) != 0) {
2190                 /* Not consistent so can't be used for early_data */
2191                 s->ext.early_data_ok = 0;
2192
2193                 if (!s->hit) {
2194                     /*
2195                      * This is a new session and so alpn_selected should have
2196                      * been initialised to NULL. We should update it with the
2197                      * selected ALPN.
2198                      */
2199                     if (!ossl_assert(s->session->ext.alpn_selected == NULL)) {
2200                         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2201                                  SSL_F_TLS_HANDLE_ALPN,
2202                                  ERR_R_INTERNAL_ERROR);
2203                         return 0;
2204                     }
2205                     s->session->ext.alpn_selected = OPENSSL_memdup(selected,
2206                                                                    selected_len);
2207                     if (s->session->ext.alpn_selected == NULL) {
2208                         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2209                                  SSL_F_TLS_HANDLE_ALPN,
2210                                  ERR_R_INTERNAL_ERROR);
2211                         return 0;
2212                     }
2213                     s->session->ext.alpn_selected_len = selected_len;
2214                 }
2215             }
2216
2217             return 1;
2218         } else if (r != SSL_TLSEXT_ERR_NOACK) {
2219             SSLfatal(s, SSL_AD_NO_APPLICATION_PROTOCOL, SSL_F_TLS_HANDLE_ALPN,
2220                      SSL_R_NO_APPLICATION_PROTOCOL);
2221             return 0;
2222         }
2223         /*
2224          * If r == SSL_TLSEXT_ERR_NOACK then behave as if no callback was
2225          * present.
2226          */
2227     }
2228
2229     /* Check ALPN is consistent with session */
2230     if (s->session->ext.alpn_selected != NULL) {
2231         /* Not consistent so can't be used for early_data */
2232         s->ext.early_data_ok = 0;
2233     }
2234
2235     return 1;
2236 }
2237
2238 WORK_STATE tls_post_process_client_hello(SSL *s, WORK_STATE wst)
2239 {
2240     const SSL_CIPHER *cipher;
2241
2242     if (wst == WORK_MORE_A) {
2243         int rv = tls_early_post_process_client_hello(s);
2244         if (rv == 0) {
2245             /* SSLfatal() was already called */
2246             goto err;
2247         }
2248         if (rv < 0)
2249             return WORK_MORE_A;
2250         wst = WORK_MORE_B;
2251     }
2252     if (wst == WORK_MORE_B) {
2253         if (!s->hit || SSL_IS_TLS13(s)) {
2254             /* Let cert callback update server certificates if required */
2255             if (!s->hit && s->cert->cert_cb != NULL) {
2256                 int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
2257                 if (rv == 0) {
2258                     SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2259                              SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
2260                              SSL_R_CERT_CB_ERROR);
2261                     goto err;
2262                 }
2263                 if (rv < 0) {
2264                     s->rwstate = SSL_X509_LOOKUP;
2265                     return WORK_MORE_B;
2266                 }
2267                 s->rwstate = SSL_NOTHING;
2268             }
2269
2270             /* In TLSv1.3 we selected the ciphersuite before resumption */
2271             if (!SSL_IS_TLS13(s)) {
2272                 cipher =
2273                     ssl3_choose_cipher(s, s->peer_ciphers, SSL_get_ciphers(s));
2274
2275                 if (cipher == NULL) {
2276                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
2277                              SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
2278                              SSL_R_NO_SHARED_CIPHER);
2279                     goto err;
2280                 }
2281                 s->s3.tmp.new_cipher = cipher;
2282             }
2283             if (!s->hit) {
2284                 if (!tls_choose_sigalg(s, 1)) {
2285                     /* SSLfatal already called */
2286                     goto err;
2287                 }
2288                 /* check whether we should disable session resumption */
2289                 if (s->not_resumable_session_cb != NULL)
2290                     s->session->not_resumable =
2291                         s->not_resumable_session_cb(s,
2292                             ((s->s3.tmp.new_cipher->algorithm_mkey
2293                               & (SSL_kDHE | SSL_kECDHE)) != 0));
2294                 if (s->session->not_resumable)
2295                     /* do not send a session ticket */
2296                     s->ext.ticket_expected = 0;
2297             }
2298         } else {
2299             /* Session-id reuse */
2300             s->s3.tmp.new_cipher = s->session->cipher;
2301         }
2302
2303         /*-
2304          * we now have the following setup.
2305          * client_random
2306          * cipher_list          - our preferred list of ciphers
2307          * ciphers              - the clients preferred list of ciphers
2308          * compression          - basically ignored right now
2309          * ssl version is set   - sslv3
2310          * s->session           - The ssl session has been setup.
2311          * s->hit               - session reuse flag
2312          * s->s3.tmp.new_cipher - the new cipher to use.
2313          */
2314
2315         /*
2316          * Call status_request callback if needed. Has to be done after the
2317          * certificate callbacks etc above.
2318          */
2319         if (!tls_handle_status_request(s)) {
2320             /* SSLfatal() already called */
2321             goto err;
2322         }
2323         /*
2324          * Call alpn_select callback if needed.  Has to be done after SNI and
2325          * cipher negotiation (HTTP/2 restricts permitted ciphers). In TLSv1.3
2326          * we already did this because cipher negotiation happens earlier, and
2327          * we must handle ALPN before we decide whether to accept early_data.
2328          */
2329         if (!SSL_IS_TLS13(s) && !tls_handle_alpn(s)) {
2330             /* SSLfatal() already called */
2331             goto err;
2332         }
2333
2334         wst = WORK_MORE_C;
2335     }
2336 #ifndef OPENSSL_NO_SRP
2337     if (wst == WORK_MORE_C) {
2338         int ret;
2339         if ((ret = ssl_check_srp_ext_ClientHello(s)) == 0) {
2340             /*
2341              * callback indicates further work to be done
2342              */
2343             s->rwstate = SSL_X509_LOOKUP;
2344             return WORK_MORE_C;
2345         }
2346         if (ret < 0) {
2347             /* SSLfatal() already called */
2348             goto err;
2349         }
2350     }
2351 #endif
2352
2353     return WORK_FINISHED_STOP;
2354  err:
2355     return WORK_ERROR;
2356 }
2357
2358 int tls_construct_server_hello(SSL *s, WPACKET *pkt)
2359 {
2360     int compm;
2361     size_t sl, len;
2362     int version;
2363     unsigned char *session_id;
2364     int usetls13 = SSL_IS_TLS13(s) || s->hello_retry_request == SSL_HRR_PENDING;
2365
2366     version = usetls13 ? TLS1_2_VERSION : s->version;
2367     if (!WPACKET_put_bytes_u16(pkt, version)
2368                /*
2369                 * Random stuff. Filling of the server_random takes place in
2370                 * tls_process_client_hello()
2371                 */
2372             || !WPACKET_memcpy(pkt,
2373                                s->hello_retry_request == SSL_HRR_PENDING
2374                                    ? hrrrandom : s->s3.server_random,
2375                                SSL3_RANDOM_SIZE)) {
2376         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_SERVER_HELLO,
2377                  ERR_R_INTERNAL_ERROR);
2378         return 0;
2379     }
2380
2381     /*-
2382      * There are several cases for the session ID to send
2383      * back in the server hello:
2384      * - For session reuse from the session cache,
2385      *   we send back the old session ID.
2386      * - If stateless session reuse (using a session ticket)
2387      *   is successful, we send back the client's "session ID"
2388      *   (which doesn't actually identify the session).
2389      * - If it is a new session, we send back the new
2390      *   session ID.
2391      * - However, if we want the new session to be single-use,
2392      *   we send back a 0-length session ID.
2393      * - In TLSv1.3 we echo back the session id sent to us by the client
2394      *   regardless
2395      * s->hit is non-zero in either case of session reuse,
2396      * so the following won't overwrite an ID that we're supposed
2397      * to send back.
2398      */
2399     if (s->session->not_resumable ||
2400         (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
2401          && !s->hit))
2402         s->session->session_id_length = 0;
2403
2404     if (usetls13) {
2405         sl = s->tmp_session_id_len;
2406         session_id = s->tmp_session_id;
2407     } else {
2408         sl = s->session->session_id_length;
2409         session_id = s->session->session_id;
2410     }
2411
2412     if (sl > sizeof(s->session->session_id)) {
2413         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_SERVER_HELLO,
2414                  ERR_R_INTERNAL_ERROR);
2415         return 0;
2416     }
2417
2418     /* set up the compression method */
2419 #ifdef OPENSSL_NO_COMP
2420     compm = 0;
2421 #else
2422     if (usetls13 || s->s3.tmp.new_compression == NULL)
2423         compm = 0;
2424     else
2425         compm = s->s3.tmp.new_compression->id;
2426 #endif
2427
2428     if (!WPACKET_sub_memcpy_u8(pkt, session_id, sl)
2429             || !s->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt, &len)
2430             || !WPACKET_put_bytes_u8(pkt, compm)) {
2431         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_SERVER_HELLO,
2432                  ERR_R_INTERNAL_ERROR);
2433         return 0;
2434     }
2435
2436     if (!tls_construct_extensions(s, pkt,
2437                                   s->hello_retry_request == SSL_HRR_PENDING
2438                                       ? SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST
2439                                       : (SSL_IS_TLS13(s)
2440                                           ? SSL_EXT_TLS1_3_SERVER_HELLO
2441                                           : SSL_EXT_TLS1_2_SERVER_HELLO),
2442                                   NULL, 0)) {
2443         /* SSLfatal() already called */
2444         return 0;
2445     }
2446
2447     if (s->hello_retry_request == SSL_HRR_PENDING) {
2448         /* Ditch the session. We'll create a new one next time around */
2449         SSL_SESSION_free(s->session);
2450         s->session = NULL;
2451         s->hit = 0;
2452
2453         /*
2454          * Re-initialise the Transcript Hash. We're going to prepopulate it with
2455          * a synthetic message_hash in place of ClientHello1.
2456          */
2457         if (!create_synthetic_message_hash(s, NULL, 0, NULL, 0)) {
2458             /* SSLfatal() already called */
2459             return 0;
2460         }
2461     } else if (!(s->verify_mode & SSL_VERIFY_PEER)
2462                 && !ssl3_digest_cached_records(s, 0)) {
2463         /* SSLfatal() already called */;
2464         return 0;
2465     }
2466
2467     return 1;
2468 }
2469
2470 int tls_construct_server_done(SSL *s, WPACKET *pkt)
2471 {
2472     if (!s->s3.tmp.cert_request) {
2473         if (!ssl3_digest_cached_records(s, 0)) {
2474             /* SSLfatal() already called */
2475             return 0;
2476         }
2477     }
2478     return 1;
2479 }
2480
2481 int tls_construct_server_key_exchange(SSL *s, WPACKET *pkt)
2482 {
2483 #ifndef OPENSSL_NO_DH
2484     EVP_PKEY *pkdh = NULL;
2485 #endif
2486 #ifndef OPENSSL_NO_EC
2487     unsigned char *encodedPoint = NULL;
2488     size_t encodedlen = 0;
2489     int curve_id = 0;
2490 #endif
2491     const SIGALG_LOOKUP *lu = s->s3.tmp.sigalg;
2492     int i;
2493     unsigned long type;
2494     const BIGNUM *r[4];
2495     EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
2496     EVP_PKEY_CTX *pctx = NULL;
2497     size_t paramlen, paramoffset;
2498
2499     if (!WPACKET_get_total_written(pkt, &paramoffset)) {
2500         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2501                  SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2502         goto err;
2503     }
2504
2505     if (md_ctx == NULL) {
2506         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2507                  SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2508         goto err;
2509     }
2510
2511     type = s->s3.tmp.new_cipher->algorithm_mkey;
2512
2513     r[0] = r[1] = r[2] = r[3] = NULL;
2514 #ifndef OPENSSL_NO_PSK
2515     /* Plain PSK or RSAPSK nothing to do */
2516     if (type & (SSL_kPSK | SSL_kRSAPSK)) {
2517     } else
2518 #endif                          /* !OPENSSL_NO_PSK */
2519 #ifndef OPENSSL_NO_DH
2520     if (type & (SSL_kDHE | SSL_kDHEPSK)) {
2521         CERT *cert = s->cert;
2522
2523         EVP_PKEY *pkdhp = NULL;
2524         DH *dh;
2525
2526         if (s->cert->dh_tmp_auto) {
2527             DH *dhp = ssl_get_auto_dh(s);
2528             pkdh = EVP_PKEY_new();
2529             if (pkdh == NULL || dhp == NULL) {
2530                 DH_free(dhp);
2531                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2532                          SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2533                          ERR_R_INTERNAL_ERROR);
2534                 goto err;
2535             }
2536             EVP_PKEY_assign_DH(pkdh, dhp);
2537             pkdhp = pkdh;
2538         } else {
2539             pkdhp = cert->dh_tmp;
2540         }
2541         if ((pkdhp == NULL) && (s->cert->dh_tmp_cb != NULL)) {
2542             DH *dhp = s->cert->dh_tmp_cb(s, 0, 1024);
2543             pkdh = ssl_dh_to_pkey(dhp);
2544             if (pkdh == NULL) {
2545                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2546                          SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2547                          ERR_R_INTERNAL_ERROR);
2548                 goto err;
2549             }
2550             pkdhp = pkdh;
2551         }
2552         if (pkdhp == NULL) {
2553             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2554                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2555                      SSL_R_MISSING_TMP_DH_KEY);
2556             goto err;
2557         }
2558         if (!ssl_security(s, SSL_SECOP_TMP_DH,
2559                           EVP_PKEY_security_bits(pkdhp), 0, pkdhp)) {
2560             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
2561                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2562                      SSL_R_DH_KEY_TOO_SMALL);
2563             goto err;
2564         }
2565         if (s->s3.tmp.pkey != NULL) {
2566             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2567                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2568                      ERR_R_INTERNAL_ERROR);
2569             goto err;
2570         }
2571
2572         s->s3.tmp.pkey = ssl_generate_pkey(pkdhp);
2573         if (s->s3.tmp.pkey == NULL) {
2574             /* SSLfatal() already called */
2575             goto err;
2576         }
2577
2578         dh = EVP_PKEY_get0_DH(s->s3.tmp.pkey);
2579         if (dh == NULL) {
2580             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2581                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2582                      ERR_R_INTERNAL_ERROR);
2583             goto err;
2584         }
2585
2586         EVP_PKEY_free(pkdh);
2587         pkdh = NULL;
2588
2589         DH_get0_pqg(dh, &r[0], NULL, &r[1]);
2590         DH_get0_key(dh, &r[2], NULL);
2591     } else
2592 #endif
2593 #ifndef OPENSSL_NO_EC
2594     if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
2595
2596         if (s->s3.tmp.pkey != NULL) {
2597             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2598                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2599                      ERR_R_INTERNAL_ERROR);
2600             goto err;
2601         }
2602
2603         /* Get NID of appropriate shared curve */
2604         curve_id = tls1_shared_group(s, -2);
2605         if (curve_id == 0) {
2606             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
2607                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2608                      SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
2609             goto err;
2610         }
2611         s->s3.tmp.pkey = ssl_generate_pkey_group(s, curve_id);
2612         /* Generate a new key for this curve */
2613         if (s->s3.tmp.pkey == NULL) {
2614             /* SSLfatal() already called */
2615             goto err;
2616         }
2617
2618         /* Encode the public key. */
2619         encodedlen = EVP_PKEY_get1_tls_encodedpoint(s->s3.tmp.pkey,
2620                                                     &encodedPoint);
2621         if (encodedlen == 0) {
2622             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2623                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_EC_LIB);
2624             goto err;
2625         }
2626
2627         /*
2628          * We'll generate the serverKeyExchange message explicitly so we
2629          * can set these to NULLs
2630          */
2631         r[0] = NULL;
2632         r[1] = NULL;
2633         r[2] = NULL;
2634         r[3] = NULL;
2635     } else
2636 #endif                          /* !OPENSSL_NO_EC */
2637 #ifndef OPENSSL_NO_SRP
2638     if (type & SSL_kSRP) {
2639         if ((s->srp_ctx.N == NULL) ||
2640             (s->srp_ctx.g == NULL) ||
2641             (s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) {
2642             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2643                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2644                      SSL_R_MISSING_SRP_PARAM);
2645             goto err;
2646         }
2647         r[0] = s->srp_ctx.N;
2648         r[1] = s->srp_ctx.g;
2649         r[2] = s->srp_ctx.s;
2650         r[3] = s->srp_ctx.B;
2651     } else
2652 #endif
2653     {
2654         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2655                  SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2656                  SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
2657         goto err;
2658     }
2659
2660     if (((s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP)) != 0)
2661         || ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK)) != 0) {
2662         lu = NULL;
2663     } else if (lu == NULL) {
2664         SSLfatal(s, SSL_AD_DECODE_ERROR,
2665                  SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2666         goto err;
2667     }
2668
2669 #ifndef OPENSSL_NO_PSK
2670     if (type & SSL_PSK) {
2671         size_t len = (s->cert->psk_identity_hint == NULL)
2672                         ? 0 : strlen(s->cert->psk_identity_hint);
2673
2674         /*
2675          * It should not happen that len > PSK_MAX_IDENTITY_LEN - we already
2676          * checked this when we set the identity hint - but just in case
2677          */
2678         if (len > PSK_MAX_IDENTITY_LEN
2679                 || !WPACKET_sub_memcpy_u16(pkt, s->cert->psk_identity_hint,
2680                                            len)) {
2681             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2682                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2683                      ERR_R_INTERNAL_ERROR);
2684             goto err;
2685         }
2686     }
2687 #endif
2688
2689     for (i = 0; i < 4 && r[i] != NULL; i++) {
2690         unsigned char *binval;
2691         int res;
2692
2693 #ifndef OPENSSL_NO_SRP
2694         if ((i == 2) && (type & SSL_kSRP)) {
2695             res = WPACKET_start_sub_packet_u8(pkt);
2696         } else
2697 #endif
2698             res = WPACKET_start_sub_packet_u16(pkt);
2699
2700         if (!res) {
2701             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2702                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2703                      ERR_R_INTERNAL_ERROR);
2704             goto err;
2705         }
2706
2707 #ifndef OPENSSL_NO_DH
2708         /*-
2709          * for interoperability with some versions of the Microsoft TLS
2710          * stack, we need to zero pad the DHE pub key to the same length
2711          * as the prime
2712          */
2713         if ((i == 2) && (type & (SSL_kDHE | SSL_kDHEPSK))) {
2714             size_t len = BN_num_bytes(r[0]) - BN_num_bytes(r[2]);
2715
2716             if (len > 0) {
2717                 if (!WPACKET_allocate_bytes(pkt, len, &binval)) {
2718                     SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2719                              SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2720                              ERR_R_INTERNAL_ERROR);
2721                     goto err;
2722                 }
2723                 memset(binval, 0, len);
2724             }
2725         }
2726 #endif
2727         if (!WPACKET_allocate_bytes(pkt, BN_num_bytes(r[i]), &binval)
2728                 || !WPACKET_close(pkt)) {
2729             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2730                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2731                      ERR_R_INTERNAL_ERROR);
2732             goto err;
2733         }
2734
2735         BN_bn2bin(r[i], binval);
2736     }
2737
2738 #ifndef OPENSSL_NO_EC
2739     if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
2740         /*
2741          * We only support named (not generic) curves. In this situation, the
2742          * ServerKeyExchange message has: [1 byte CurveType], [2 byte CurveName]
2743          * [1 byte length of encoded point], followed by the actual encoded
2744          * point itself
2745          */
2746         if (!WPACKET_put_bytes_u8(pkt, NAMED_CURVE_TYPE)
2747                 || !WPACKET_put_bytes_u8(pkt, 0)
2748                 || !WPACKET_put_bytes_u8(pkt, curve_id)
2749                 || !WPACKET_sub_memcpy_u8(pkt, encodedPoint, encodedlen)) {
2750             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2751                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2752                      ERR_R_INTERNAL_ERROR);
2753             goto err;
2754         }
2755         OPENSSL_free(encodedPoint);
2756         encodedPoint = NULL;
2757     }
2758 #endif
2759
2760     /* not anonymous */
2761     if (lu != NULL) {
2762         EVP_PKEY *pkey = s->s3.tmp.cert->privatekey;
2763         const EVP_MD *md;
2764         unsigned char *sigbytes1, *sigbytes2, *tbs;
2765         size_t siglen = 0, tbslen;
2766
2767         if (pkey == NULL || !tls1_lookup_md(lu, &md)) {
2768             /* Should never happen */
2769             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2770                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2771                      ERR_R_INTERNAL_ERROR);
2772             goto err;
2773         }
2774         /* Get length of the parameters we have written above */
2775         if (!WPACKET_get_length(pkt, &paramlen)) {
2776             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2777                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2778                      ERR_R_INTERNAL_ERROR);
2779             goto err;
2780         }
2781         /* send signature algorithm */
2782         if (SSL_USE_SIGALGS(s) && !WPACKET_put_bytes_u16(pkt, lu->sigalg)) {
2783             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2784                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2785                      ERR_R_INTERNAL_ERROR);
2786             goto err;
2787         }
2788
2789         if (EVP_DigestSignInit(md_ctx, &pctx, md, NULL, pkey) <= 0) {
2790             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2791                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2792                      ERR_R_INTERNAL_ERROR);
2793             goto err;
2794         }
2795         if (lu->sig == EVP_PKEY_RSA_PSS) {
2796             if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
2797                 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) {
2798                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2799                          SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2800                         ERR_R_EVP_LIB);
2801                 goto err;
2802             }
2803         }
2804         tbslen = construct_key_exchange_tbs(s, &tbs,
2805                                             s->init_buf->data + paramoffset,
2806                                             paramlen);
2807         if (tbslen == 0) {
2808             /* SSLfatal() already called */
2809             goto err;
2810         }
2811
2812         if (EVP_DigestSign(md_ctx, NULL, &siglen, tbs, tbslen) <=0
2813                 || !WPACKET_sub_reserve_bytes_u16(pkt, siglen, &sigbytes1)
2814                 || EVP_DigestSign(md_ctx, sigbytes1, &siglen, tbs, tbslen) <= 0
2815                 || !WPACKET_sub_allocate_bytes_u16(pkt, siglen, &sigbytes2)
2816                 || sigbytes1 != sigbytes2) {
2817             OPENSSL_free(tbs);
2818             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2819                      SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
2820                      ERR_R_INTERNAL_ERROR);
2821             goto err;
2822         }
2823         OPENSSL_free(tbs);
2824     }
2825
2826     EVP_MD_CTX_free(md_ctx);
2827     return 1;
2828  err:
2829 #ifndef OPENSSL_NO_DH
2830     EVP_PKEY_free(pkdh);
2831 #endif
2832 #ifndef OPENSSL_NO_EC
2833     OPENSSL_free(encodedPoint);
2834 #endif
2835     EVP_MD_CTX_free(md_ctx);
2836     return 0;
2837 }
2838
2839 int tls_construct_certificate_request(SSL *s, WPACKET *pkt)
2840 {
2841     if (SSL_IS_TLS13(s)) {
2842         /* Send random context when doing post-handshake auth */
2843         if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) {
2844             OPENSSL_free(s->pha_context);
2845             s->pha_context_len = 32;
2846             if ((s->pha_context = OPENSSL_malloc(s->pha_context_len)) == NULL
2847                     || RAND_bytes(s->pha_context, s->pha_context_len) <= 0
2848                     || !WPACKET_sub_memcpy_u8(pkt, s->pha_context, s->pha_context_len)) {
2849                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2850                          SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST,
2851                          ERR_R_INTERNAL_ERROR);
2852                 return 0;
2853             }
2854             /* reset the handshake hash back to just after the ClientFinished */
2855             if (!tls13_restore_handshake_digest_for_pha(s)) {
2856                 /* SSLfatal() already called */
2857                 return 0;
2858             }
2859         } else {
2860             if (!WPACKET_put_bytes_u8(pkt, 0)) {
2861                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2862                          SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST,
2863                          ERR_R_INTERNAL_ERROR);
2864                 return 0;
2865             }
2866         }
2867
2868         if (!tls_construct_extensions(s, pkt,
2869                                       SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, NULL,
2870                                       0)) {
2871             /* SSLfatal() already called */
2872             return 0;
2873         }
2874         goto done;
2875     }
2876
2877     /* get the list of acceptable cert types */
2878     if (!WPACKET_start_sub_packet_u8(pkt)
2879         || !ssl3_get_req_cert_type(s, pkt) || !WPACKET_close(pkt)) {
2880         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2881                  SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
2882         return 0;
2883     }
2884
2885     if (SSL_USE_SIGALGS(s)) {
2886         const uint16_t *psigs;
2887         size_t nl = tls12_get_psigalgs(s, 1, &psigs);
2888
2889         if (!WPACKET_start_sub_packet_u16(pkt)
2890                 || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
2891                 || !tls12_copy_sigalgs(s, pkt, psigs, nl)
2892                 || !WPACKET_close(pkt)) {
2893             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2894                      SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST,
2895                      ERR_R_INTERNAL_ERROR);
2896             return 0;
2897         }
2898     }
2899
2900     if (!construct_ca_names(s, get_ca_names(s), pkt)) {
2901         /* SSLfatal() already called */
2902         return 0;
2903     }
2904
2905  done:
2906     s->certreqs_sent++;
2907     s->s3.tmp.cert_request = 1;
2908     return 1;
2909 }
2910
2911 static int tls_process_cke_psk_preamble(SSL *s, PACKET *pkt)
2912 {
2913 #ifndef OPENSSL_NO_PSK
2914     unsigned char psk[PSK_MAX_PSK_LEN];
2915     size_t psklen;
2916     PACKET psk_identity;
2917
2918     if (!PACKET_get_length_prefixed_2(pkt, &psk_identity)) {
2919         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2920                  SSL_R_LENGTH_MISMATCH);
2921         return 0;
2922     }
2923     if (PACKET_remaining(&psk_identity) > PSK_MAX_IDENTITY_LEN) {
2924         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2925                  SSL_R_DATA_LENGTH_TOO_LONG);
2926         return 0;
2927     }
2928     if (s->psk_server_callback == NULL) {
2929         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2930                  SSL_R_PSK_NO_SERVER_CB);
2931         return 0;
2932     }
2933
2934     if (!PACKET_strndup(&psk_identity, &s->session->psk_identity)) {
2935         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2936                  ERR_R_INTERNAL_ERROR);
2937         return 0;
2938     }
2939
2940     psklen = s->psk_server_callback(s, s->session->psk_identity,
2941                                     psk, sizeof(psk));
2942
2943     if (psklen > PSK_MAX_PSK_LEN) {
2944         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2945                  ERR_R_INTERNAL_ERROR);
2946         return 0;
2947     } else if (psklen == 0) {
2948         /*
2949          * PSK related to the given identity not found
2950          */
2951         SSLfatal(s, SSL_AD_UNKNOWN_PSK_IDENTITY,
2952                  SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2953                  SSL_R_PSK_IDENTITY_NOT_FOUND);
2954         return 0;
2955     }
2956
2957     OPENSSL_free(s->s3.tmp.psk);
2958     s->s3.tmp.psk = OPENSSL_memdup(psk, psklen);
2959     OPENSSL_cleanse(psk, psklen);
2960
2961     if (s->s3.tmp.psk == NULL) {
2962         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
2963                  SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_MALLOC_FAILURE);
2964         return 0;
2965     }
2966
2967     s->s3.tmp.psklen = psklen;
2968
2969     return 1;
2970 #else
2971     /* Should never happen */
2972     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2973              ERR_R_INTERNAL_ERROR);
2974     return 0;
2975 #endif
2976 }
2977
2978 static int tls_process_cke_rsa(SSL *s, PACKET *pkt)
2979 {
2980 #ifndef OPENSSL_NO_RSA
2981     size_t outlen;
2982     PACKET enc_premaster;
2983     EVP_PKEY *rsa = NULL;
2984     unsigned char *rsa_decrypt = NULL;
2985     int ret = 0;
2986     EVP_PKEY_CTX *ctx = NULL;
2987     OSSL_PARAM params[3], *p = params;
2988
2989     rsa = s->cert->pkeys[SSL_PKEY_RSA].privatekey;
2990     if (rsa == NULL) {
2991         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_RSA,
2992                  SSL_R_MISSING_RSA_CERTIFICATE);
2993         return 0;
2994     }
2995
2996     /* SSLv3 and pre-standard DTLS omit the length bytes. */
2997     if (s->version == SSL3_VERSION || s->version == DTLS1_BAD_VER) {
2998         enc_premaster = *pkt;
2999     } else {
3000         if (!PACKET_get_length_prefixed_2(pkt, &enc_premaster)
3001             || PACKET_remaining(pkt) != 0) {
3002             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_RSA,
3003                      SSL_R_LENGTH_MISMATCH);
3004             return 0;
3005         }
3006     }
3007
3008     outlen = SSL_MAX_MASTER_KEY_LENGTH;
3009     rsa_decrypt = OPENSSL_malloc(outlen);
3010     if (rsa_decrypt == NULL) {
3011         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_RSA,
3012                  ERR_R_MALLOC_FAILURE);
3013         return 0;
3014     }
3015
3016     ctx = EVP_PKEY_CTX_new(rsa, NULL);
3017     if (ctx == NULL) {
3018         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_RSA,
3019                  ERR_R_MALLOC_FAILURE);
3020         goto err;
3021     }
3022
3023     /*
3024      * We must not leak whether a decryption failure occurs because of
3025      * Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see RFC 2246,
3026      * section 7.4.7.1). We use the special padding type
3027      * RSA_PKCS1_WITH_TLS_PADDING to do that. It will automaticaly decrypt the
3028      * RSA, check the padding and check that the client version is as expected
3029      * in the premaster secret. If any of that fails then the function appears
3030      * to return successfully but with a random result. The call below could
3031      * still fail if the input is publicly invalid.
3032      * See https://tools.ietf.org/html/rfc5246#section-7.4.7.1
3033      */
3034     if (EVP_PKEY_decrypt_init(ctx) <= 0
3035             || EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_WITH_TLS_PADDING) <= 0) {
3036         SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_F_TLS_PROCESS_CKE_RSA,
3037                  SSL_R_DECRYPTION_FAILED);
3038         goto err;
3039     }
3040
3041     *p++ = OSSL_PARAM_construct_uint(OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION,
3042                                      (unsigned int *)&s->client_version);
3043    if ((s->options & SSL_OP_TLS_ROLLBACK_BUG) != 0)
3044         *p++ = OSSL_PARAM_construct_uint(
3045             OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION,
3046             (unsigned int *)&s->version);
3047     *p++ = OSSL_PARAM_construct_end();
3048
3049     if (!EVP_PKEY_CTX_set_params(ctx, params)
3050             || EVP_PKEY_decrypt(ctx, rsa_decrypt, &outlen,
3051                                 PACKET_data(&enc_premaster),
3052                                 PACKET_remaining(&enc_premaster)) <= 0) {
3053         SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_F_TLS_PROCESS_CKE_RSA,
3054                  SSL_R_DECRYPTION_FAILED);
3055         goto err;
3056     }
3057
3058     /*
3059      * This test should never fail (otherwise we should have failed above) but
3060      * we double check anyway.
3061      */
3062     if (outlen != SSL_MAX_MASTER_KEY_LENGTH) {
3063         OPENSSL_cleanse(rsa_decrypt, SSL_MAX_MASTER_KEY_LENGTH);
3064         SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_F_TLS_PROCESS_CKE_RSA,
3065                  SSL_R_DECRYPTION_FAILED);
3066         goto err;
3067     }
3068
3069     /* Also cleanses rsa_decrypt (on success or failure) */
3070     if (!ssl_generate_master_secret(s, rsa_decrypt,
3071                                     SSL_MAX_MASTER_KEY_LENGTH, 0)) {
3072         /* SSLfatal() already called */
3073         goto err;
3074     }
3075
3076     ret = 1;
3077  err:
3078     OPENSSL_free(rsa_decrypt);
3079     EVP_PKEY_CTX_free(ctx);
3080     return ret;
3081 #else
3082     /* Should never happen */
3083     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_RSA,
3084              ERR_R_INTERNAL_ERROR);
3085     return 0;
3086 #endif
3087 }
3088
3089 static int tls_process_cke_dhe(SSL *s, PACKET *pkt)
3090 {
3091 #ifndef OPENSSL_NO_DH
3092     EVP_PKEY *skey = NULL;
3093     DH *cdh;
3094     unsigned int i;
3095     BIGNUM *pub_key;
3096     const unsigned char *data;
3097     EVP_PKEY *ckey = NULL;
3098     int ret = 0;
3099
3100     if (!PACKET_get_net_2(pkt, &i) || PACKET_remaining(pkt) != i) {
3101         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_DHE,
3102                SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG);
3103         goto err;
3104     }
3105     skey = s->s3.tmp.pkey;
3106     if (skey == NULL) {
3107         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_DHE,
3108                  SSL_R_MISSING_TMP_DH_KEY);
3109         goto err;
3110     }
3111
3112     if (PACKET_remaining(pkt) == 0L) {
3113         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_DHE,
3114                  SSL_R_MISSING_TMP_DH_KEY);
3115         goto err;
3116     }
3117     if (!PACKET_get_bytes(pkt, &data, i)) {
3118         /* We already checked we have enough data */
3119         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_DHE,
3120                  ERR_R_INTERNAL_ERROR);
3121         goto err;
3122     }
3123     ckey = EVP_PKEY_new();
3124     if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) == 0) {
3125         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_DHE,
3126                  SSL_R_BN_LIB);
3127         goto err;
3128     }
3129
3130     cdh = EVP_PKEY_get0_DH(ckey);
3131     pub_key = BN_bin2bn(data, i, NULL);
3132     if (pub_key == NULL || cdh == NULL || !DH_set0_key(cdh, pub_key, NULL)) {
3133         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_DHE,
3134                  ERR_R_INTERNAL_ERROR);
3135         BN_free(pub_key);
3136         goto err;
3137     }
3138
3139     if (ssl_derive(s, skey, ckey, 1) == 0) {
3140         /* SSLfatal() already called */
3141         goto err;
3142     }
3143
3144     ret = 1;
3145     EVP_PKEY_free(s->s3.tmp.pkey);
3146     s->s3.tmp.pkey = NULL;
3147  err:
3148     EVP_PKEY_free(ckey);
3149     return ret;
3150 #else
3151     /* Should never happen */
3152     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_DHE,
3153              ERR_R_INTERNAL_ERROR);
3154     return 0;
3155 #endif
3156 }
3157
3158 static int tls_process_cke_ecdhe(SSL *s, PACKET *pkt)
3159 {
3160 #ifndef OPENSSL_NO_EC
3161     EVP_PKEY *skey = s->s3.tmp.pkey;
3162     EVP_PKEY *ckey = NULL;
3163     int ret = 0;
3164
3165     if (PACKET_remaining(pkt) == 0L) {
3166         /* We don't support ECDH client auth */
3167         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_TLS_PROCESS_CKE_ECDHE,
3168                  SSL_R_MISSING_TMP_ECDH_KEY);
3169         goto err;
3170     } else {
3171         unsigned int i;
3172         const unsigned char *data;
3173
3174         /*
3175          * Get client's public key from encoded point in the
3176          * ClientKeyExchange message.
3177          */
3178
3179         /* Get encoded point length */
3180         if (!PACKET_get_1(pkt, &i) || !PACKET_get_bytes(pkt, &data, i)
3181             || PACKET_remaining(pkt) != 0) {
3182             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_ECDHE,
3183                      SSL_R_LENGTH_MISMATCH);
3184             goto err;
3185         }
3186         if (skey == NULL) {
3187             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_ECDHE,
3188                      SSL_R_MISSING_TMP_ECDH_KEY);
3189             goto err;
3190         }
3191
3192         ckey = EVP_PKEY_new();
3193         if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) <= 0) {
3194             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_ECDHE,
3195                      ERR_R_EVP_LIB);
3196             goto err;
3197         }
3198         if (EVP_PKEY_set1_tls_encodedpoint(ckey, data, i) == 0) {
3199             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_ECDHE,
3200                      ERR_R_EC_LIB);
3201             goto err;
3202         }
3203     }
3204
3205     if (ssl_derive(s, skey, ckey, 1) == 0) {
3206         /* SSLfatal() already called */
3207         goto err;
3208     }
3209
3210     ret = 1;
3211     EVP_PKEY_free(s->s3.tmp.pkey);
3212     s->s3.tmp.pkey = NULL;
3213  err:
3214     EVP_PKEY_free(ckey);
3215
3216     return ret;
3217 #else
3218     /* Should never happen */
3219     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_ECDHE,
3220              ERR_R_INTERNAL_ERROR);
3221     return 0;
3222 #endif
3223 }
3224
3225 static int tls_process_cke_srp(SSL *s, PACKET *pkt)
3226 {
3227 #ifndef OPENSSL_NO_SRP
3228     unsigned int i;
3229     const unsigned char *data;
3230
3231     if (!PACKET_get_net_2(pkt, &i)
3232         || !PACKET_get_bytes(pkt, &data, i)) {
3233         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_SRP,
3234                  SSL_R_BAD_SRP_A_LENGTH);
3235         return 0;
3236     }
3237     if ((s->srp_ctx.A = BN_bin2bn(data, i, NULL)) == NULL) {
3238         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_SRP,
3239                  ERR_R_BN_LIB);
3240         return 0;
3241     }
3242     if (BN_ucmp(s->srp_ctx.A, s->srp_ctx.N) >= 0 || BN_is_zero(s->srp_ctx.A)) {
3243         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PROCESS_CKE_SRP,
3244                  SSL_R_BAD_SRP_PARAMETERS);
3245         return 0;
3246     }
3247     OPENSSL_free(s->session->srp_username);
3248     s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
3249     if (s->session->srp_username == NULL) {
3250         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_SRP,
3251                  ERR_R_MALLOC_FAILURE);
3252         return 0;
3253     }
3254
3255     if (!srp_generate_server_master_secret(s)) {
3256         /* SSLfatal() already called */
3257         return 0;
3258     }
3259
3260     return 1;
3261 #else
3262     /* Should never happen */
3263     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_SRP,
3264              ERR_R_INTERNAL_ERROR);
3265     return 0;
3266 #endif
3267 }
3268
3269 static int tls_process_cke_gost(SSL *s, PACKET *pkt)
3270 {
3271 #ifndef OPENSSL_NO_GOST
3272     EVP_PKEY_CTX *pkey_ctx;
3273     EVP_PKEY *client_pub_pkey = NULL, *pk = NULL;
3274     unsigned char premaster_secret[32];
3275     const unsigned char *start;
3276     size_t outlen = 32, inlen;
3277     unsigned long alg_a;
3278     GOST_KX_MESSAGE *pKX = NULL;
3279     const unsigned char *ptr;
3280     int ret = 0;
3281
3282     /* Get our certificate private key */
3283     alg_a = s->s3.tmp.new_cipher->algorithm_auth;
3284     if (alg_a & SSL_aGOST12) {
3285         /*
3286          * New GOST ciphersuites have SSL_aGOST01 bit too
3287          */
3288         pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey;
3289         if (pk == NULL) {
3290             pk = s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey;
3291         }
3292         if (pk == NULL) {
3293             pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
3294         }
3295     } else if (alg_a & SSL_aGOST01) {
3296         pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
3297     }
3298
3299     pkey_ctx = EVP_PKEY_CTX_new(pk, NULL);
3300     if (pkey_ctx == NULL) {
3301         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_GOST,
3302                  ERR_R_MALLOC_FAILURE);
3303         return 0;
3304     }
3305     if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) {
3306         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_GOST,
3307                  ERR_R_INTERNAL_ERROR);
3308         return 0;
3309     }
3310     /*
3311      * If client certificate is present and is of the same type, maybe
3312      * use it for key exchange.  Don't mind errors from
3313      * EVP_PKEY_derive_set_peer, because it is completely valid to use a
3314      * client certificate for authorization only.
3315      */
3316     client_pub_pkey = X509_get0_pubkey(s->session->peer);
3317     if (client_pub_pkey) {
3318         if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0)
3319             ERR_clear_error();
3320     }
3321
3322     ptr = PACKET_data(pkt);
3323     /* Some implementations provide extra data in the opaqueBlob
3324      * We have nothing to do with this blob so we just skip it */
3325     pKX = d2i_GOST_KX_MESSAGE(NULL, &ptr, PACKET_remaining(pkt));
3326     if (pKX == NULL
3327        || pKX->kxBlob == NULL
3328        || ASN1_TYPE_get(pKX->kxBlob) != V_ASN1_SEQUENCE) {
3329          SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_GOST,
3330                   SSL_R_DECRYPTION_FAILED);
3331          goto err;
3332     }
3333
3334     if (!PACKET_forward(pkt, ptr - PACKET_data(pkt))) {
3335         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_GOST,
3336                  SSL_R_DECRYPTION_FAILED);
3337         goto err;
3338     }
3339
3340     if (PACKET_remaining(pkt) != 0) {
3341         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_GOST,
3342                  SSL_R_DECRYPTION_FAILED);
3343         goto err;
3344     }
3345
3346     inlen = pKX->kxBlob->value.sequence->length;
3347     start = pKX->kxBlob->value.sequence->data;
3348
3349     if (EVP_PKEY_decrypt(pkey_ctx, premaster_secret, &outlen, start,
3350                          inlen) <= 0) {
3351         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CKE_GOST,
3352                  SSL_R_DECRYPTION_FAILED);
3353         goto err;
3354     }
3355     /* Generate master secret */
3356     if (!ssl_generate_master_secret(s, premaster_secret,
3357                                     sizeof(premaster_secret), 0)) {
3358         /* SSLfatal() already called */
3359         goto err;
3360     }
3361     /* Check if pubkey from client certificate was used */
3362     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2,
3363                           NULL) > 0)
3364         s->statem.no_cert_verify = 1;
3365
3366     ret = 1;
3367  err:
3368     EVP_PKEY_CTX_free(pkey_ctx);
3369     GOST_KX_MESSAGE_free(pKX);
3370     return ret;
3371 #else
3372     /* Should never happen */
3373     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CKE_GOST,
3374              ERR_R_INTERNAL_ERROR);
3375     return 0;
3376 #endif
3377 }
3378
3379 MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt)
3380 {
3381     unsigned long alg_k;
3382
3383     alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
3384
3385     /* For PSK parse and retrieve identity, obtain PSK key */
3386     if ((alg_k & SSL_PSK) && !tls_process_cke_psk_preamble(s, pkt)) {
3387         /* SSLfatal() already called */
3388         goto err;
3389     }
3390
3391     if (alg_k & SSL_kPSK) {
3392         /* Identity extracted earlier: should be nothing left */
3393         if (PACKET_remaining(pkt) != 0) {
3394             SSLfatal(s, SSL_AD_DECODE_ERROR,
3395                      SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
3396                      SSL_R_LENGTH_MISMATCH);
3397             goto err;
3398         }
3399         /* PSK handled by ssl_generate_master_secret */
3400         if (!ssl_generate_master_secret(s, NULL, 0, 0)) {
3401             /* SSLfatal() already called */
3402             goto err;
3403         }
3404     } else if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
3405         if (!tls_process_cke_rsa(s, pkt)) {
3406             /* SSLfatal() already called */
3407             goto err;
3408         }
3409     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
3410         if (!tls_process_cke_dhe(s, pkt)) {
3411             /* SSLfatal() already called */
3412             goto err;
3413         }
3414     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
3415         if (!tls_process_cke_ecdhe(s, pkt)) {
3416             /* SSLfatal() already called */
3417             goto err;
3418         }
3419     } else if (alg_k & SSL_kSRP) {
3420         if (!tls_process_cke_srp(s, pkt)) {
3421             /* SSLfatal() already called */
3422             goto err;
3423         }
3424     } else if (alg_k & SSL_kGOST) {
3425         if (!tls_process_cke_gost(s, pkt)) {
3426             /* SSLfatal() already called */
3427             goto err;
3428         }
3429     } else {
3430         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3431                  SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
3432                  SSL_R_UNKNOWN_CIPHER_TYPE);
3433         goto err;
3434     }
3435
3436     return MSG_PROCESS_CONTINUE_PROCESSING;
3437  err:
3438 #ifndef OPENSSL_NO_PSK
3439     OPENSSL_clear_free(s->s3.tmp.psk, s->s3.tmp.psklen);
3440     s->s3.tmp.psk = NULL;
3441 #endif
3442     return MSG_PROCESS_ERROR;
3443 }
3444
3445 WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst)
3446 {
3447 #ifndef OPENSSL_NO_SCTP
3448     if (wst == WORK_MORE_A) {
3449         if (SSL_IS_DTLS(s)) {
3450             unsigned char sctpauthkey[64];
3451             char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
3452             size_t labellen;
3453             /*
3454              * Add new shared key for SCTP-Auth, will be ignored if no SCTP
3455              * used.
3456              */
3457             memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
3458                    sizeof(DTLS1_SCTP_AUTH_LABEL));
3459
3460             /* Don't include the terminating zero. */
3461             labellen = sizeof(labelbuffer) - 1;
3462             if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG)
3463                 labellen += 1;
3464
3465             if (SSL_export_keying_material(s, sctpauthkey,
3466                                            sizeof(sctpauthkey), labelbuffer,
3467                                            labellen, NULL, 0,
3468                                            0) <= 0) {
3469                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3470                          SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE,
3471                          ERR_R_INTERNAL_ERROR);
3472                 return WORK_ERROR;
3473             }
3474
3475             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
3476                      sizeof(sctpauthkey), sctpauthkey);
3477         }
3478     }
3479 #endif
3480
3481     if (s->statem.no_cert_verify || !s->session->peer) {
3482         /*
3483          * No certificate verify or no peer certificate so we no longer need
3484          * the handshake_buffer
3485          */
3486         if (!ssl3_digest_cached_records(s, 0)) {
3487             /* SSLfatal() already called */
3488             return WORK_ERROR;
3489         }
3490         return WORK_FINISHED_CONTINUE;
3491     } else {
3492         if (!s->s3.handshake_buffer) {
3493             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3494                      SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE,
3495                      ERR_R_INTERNAL_ERROR);
3496             return WORK_ERROR;
3497         }
3498         /*
3499          * For sigalgs freeze the handshake buffer. If we support
3500          * extms we've done this already so this is a no-op
3501          */
3502         if (!ssl3_digest_cached_records(s, 1)) {
3503             /* SSLfatal() already called */
3504             return WORK_ERROR;
3505         }
3506     }
3507
3508     return WORK_FINISHED_CONTINUE;
3509 }
3510
3511 MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt)
3512 {
3513     int i;
3514     MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR;
3515     X509 *x = NULL;
3516     unsigned long l;
3517     const unsigned char *certstart, *certbytes;
3518     STACK_OF(X509) *sk = NULL;
3519     PACKET spkt, context;
3520     size_t chainidx;
3521     SSL_SESSION *new_sess = NULL;
3522
3523     /*
3524      * To get this far we must have read encrypted data from the client. We no
3525      * longer tolerate unencrypted alerts. This value is ignored if less than
3526      * TLSv1.3
3527      */
3528     s->statem.enc_read_state = ENC_READ_STATE_VALID;
3529
3530     if ((sk = sk_X509_new_null()) == NULL) {
3531         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3532                  ERR_R_MALLOC_FAILURE);
3533         goto err;
3534     }
3535
3536     if (SSL_IS_TLS13(s) && (!PACKET_get_length_prefixed_1(pkt, &context)
3537                             || (s->pha_context == NULL && PACKET_remaining(&context) != 0)
3538                             || (s->pha_context != NULL &&
3539                                 !PACKET_equal(&context, s->pha_context, s->pha_context_len)))) {
3540         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3541                  SSL_R_INVALID_CONTEXT);
3542         goto err;
3543     }
3544
3545     if (!PACKET_get_length_prefixed_3(pkt, &spkt)
3546             || PACKET_remaining(pkt) != 0) {
3547         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3548                  SSL_R_LENGTH_MISMATCH);
3549         goto err;
3550     }
3551
3552     for (chainidx = 0; PACKET_remaining(&spkt) > 0; chainidx++) {
3553         if (!PACKET_get_net_3(&spkt, &l)
3554             || !PACKET_get_bytes(&spkt, &certbytes, l)) {
3555             SSLfatal(s, SSL_AD_DECODE_ERROR,
3556                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3557                      SSL_R_CERT_LENGTH_MISMATCH);
3558             goto err;
3559         }
3560
3561         certstart = certbytes;
3562         x = d2i_X509(NULL, (const unsigned char **)&certbytes, l);
3563         if (x == NULL) {
3564             SSLfatal(s, SSL_AD_DECODE_ERROR,
3565                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_ASN1_LIB);
3566             goto err;
3567         }
3568         if (certbytes != (certstart + l)) {
3569             SSLfatal(s, SSL_AD_DECODE_ERROR,
3570                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3571                      SSL_R_CERT_LENGTH_MISMATCH);
3572             goto err;
3573         }
3574
3575         if (SSL_IS_TLS13(s)) {
3576             RAW_EXTENSION *rawexts = NULL;
3577             PACKET extensions;
3578
3579             if (!PACKET_get_length_prefixed_2(&spkt, &extensions)) {
3580                 SSLfatal(s, SSL_AD_DECODE_ERROR,
3581                          SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3582                          SSL_R_BAD_LENGTH);
3583                 goto err;
3584             }
3585             if (!tls_collect_extensions(s, &extensions,
3586                                         SSL_EXT_TLS1_3_CERTIFICATE, &rawexts,
3587                                         NULL, chainidx == 0)
3588                 || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE,
3589                                              rawexts, x, chainidx,
3590                                              PACKET_remaining(&spkt) == 0)) {
3591                 OPENSSL_free(rawexts);
3592                 goto err;
3593             }
3594             OPENSSL_free(rawexts);
3595         }
3596
3597         if (!sk_X509_push(sk, x)) {
3598             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3599                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3600                      ERR_R_MALLOC_FAILURE);
3601             goto err;
3602         }
3603         x = NULL;
3604     }
3605
3606     if (sk_X509_num(sk) <= 0) {
3607         /* TLS does not mind 0 certs returned */
3608         if (s->version == SSL3_VERSION) {
3609             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3610                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3611                      SSL_R_NO_CERTIFICATES_RETURNED);
3612             goto err;
3613         }
3614         /* Fail for TLS only if we required a certificate */
3615         else if ((s->verify_mode & SSL_VERIFY_PEER) &&
3616                  (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
3617             SSLfatal(s, SSL_AD_CERTIFICATE_REQUIRED,
3618                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3619                      SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
3620             goto err;
3621         }
3622         /* No client certificate so digest cached records */
3623         if (s->s3.handshake_buffer && !ssl3_digest_cached_records(s, 0)) {
3624             /* SSLfatal() already called */
3625             goto err;
3626         }
3627     } else {
3628         EVP_PKEY *pkey;
3629         i = ssl_verify_cert_chain(s, sk);
3630         if (i <= 0) {
3631             SSLfatal(s, ssl_x509err2alert(s->verify_result),
3632                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3633                      SSL_R_CERTIFICATE_VERIFY_FAILED);
3634             goto err;
3635         }
3636         if (i > 1) {
3637             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3638                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, i);
3639             goto err;
3640         }
3641         pkey = X509_get0_pubkey(sk_X509_value(sk, 0));
3642         if (pkey == NULL) {
3643             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
3644                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3645                      SSL_R_UNKNOWN_CERTIFICATE_TYPE);
3646             goto err;
3647         }
3648     }
3649
3650     /*
3651      * Sessions must be immutable once they go into the session cache. Otherwise
3652      * we can get multi-thread problems. Therefore we don't "update" sessions,
3653      * we replace them with a duplicate. Here, we need to do this every time
3654      * a new certificate is received via post-handshake authentication, as the
3655      * session may have already gone into the session cache.
3656      */
3657
3658     if (s->post_handshake_auth == SSL_PHA_REQUESTED) {
3659         if ((new_sess = ssl_session_dup(s->session, 0)) == 0) {
3660             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3661                      SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
3662                      ERR_R_MALLOC_FAILURE);
3663             goto err;
3664         }
3665
3666         SSL_SESSION_free(s->session);
3667         s->session = new_sess;
3668     }
3669
3670     X509_free(s->session->peer);
3671     s->session->peer = sk_X509_shift(sk);
3672     s->session->verify_result = s->verify_result;
3673
3674     sk_X509_pop_free(s->session->peer_chain, X509_free);
3675     s->session->peer_chain = sk;
3676
3677     /*
3678      * Freeze the handshake buffer. For <TLS1.3 we do this after the CKE
3679      * message
3680      */
3681     if (SSL_IS_TLS13(s) && !ssl3_digest_cached_records(s, 1)) {
3682         /* SSLfatal() already called */
3683         goto err;
3684     }
3685
3686     /*
3687      * Inconsistency alert: cert_chain does *not* include the peer's own
3688      * certificate, while we do include it in statem_clnt.c
3689      */
3690     sk = NULL;
3691
3692     /* Save the current hash state for when we receive the CertificateVerify */
3693     if (SSL_IS_TLS13(s)) {
3694         if (!ssl_handshake_hash(s, s->cert_verify_hash,
3695                                 sizeof(s->cert_verify_hash),
3696                                 &s->cert_verify_hash_len)) {
3697             /* SSLfatal() already called */
3698             goto err;
3699         }
3700
3701         /* Resend session tickets */
3702         s->sent_tickets = 0;
3703     }
3704
3705     ret = MSG_PROCESS_CONTINUE_READING;
3706
3707  err:
3708     X509_free(x);
3709     sk_X509_pop_free(sk, X509_free);
3710     return ret;
3711 }
3712
3713 int tls_construct_server_certificate(SSL *s, WPACKET *pkt)
3714 {
3715     CERT_PKEY *cpk = s->s3.tmp.cert;
3716
3717     if (cpk == NULL) {
3718         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3719                  SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3720         return 0;
3721     }
3722
3723     /*
3724      * In TLSv1.3 the certificate chain is always preceded by a 0 length context
3725      * for the server Certificate message
3726      */
3727     if (SSL_IS_TLS13(s) && !WPACKET_put_bytes_u8(pkt, 0)) {
3728         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3729                  SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
3730         return 0;
3731     }
3732     if (!ssl3_output_cert_chain(s, pkt, cpk)) {
3733         /* SSLfatal() already called */
3734         return 0;
3735     }
3736
3737     return 1;
3738 }
3739
3740 static int create_ticket_prequel(SSL *s, WPACKET *pkt, uint32_t age_add,
3741                                  unsigned char *tick_nonce)
3742 {
3743     /*
3744      * Ticket lifetime hint: For TLSv1.2 this is advisory only and we leave this
3745      * unspecified for resumed session (for simplicity).
3746      * In TLSv1.3 we reset the "time" field above, and always specify the
3747      * timeout.
3748      */
3749     if (!WPACKET_put_bytes_u32(pkt,
3750                                (s->hit && !SSL_IS_TLS13(s))
3751                                ? 0 : s->session->timeout)) {
3752         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CREATE_TICKET_PREQUEL,
3753                  ERR_R_INTERNAL_ERROR);
3754         return 0;
3755     }
3756
3757     if (SSL_IS_TLS13(s)) {
3758         if (!WPACKET_put_bytes_u32(pkt, age_add)
3759                 || !WPACKET_sub_memcpy_u8(pkt, tick_nonce, TICKET_NONCE_SIZE)) {
3760             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CREATE_TICKET_PREQUEL,
3761                      ERR_R_INTERNAL_ERROR);
3762             return 0;
3763         }
3764     }
3765
3766     /* Start the sub-packet for the actual ticket data */
3767     if (!WPACKET_start_sub_packet_u16(pkt)) {
3768         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CREATE_TICKET_PREQUEL,
3769                  ERR_R_INTERNAL_ERROR);
3770         return 0;
3771     }
3772
3773     return 1;
3774 }
3775
3776 static int construct_stateless_ticket(SSL *s, WPACKET *pkt, uint32_t age_add,
3777                                       unsigned char *tick_nonce)
3778 {
3779     unsigned char *senc = NULL;
3780     EVP_CIPHER_CTX *ctx = NULL;
3781     HMAC_CTX *hctx = NULL;
3782     unsigned char *p, *encdata1, *encdata2, *macdata1, *macdata2;
3783     const unsigned char *const_p;
3784     int len, slen_full, slen, lenfinal;
3785     SSL_SESSION *sess;
3786     unsigned int hlen;
3787     SSL_CTX *tctx = s->session_ctx;
3788     unsigned char iv[EVP_MAX_IV_LENGTH];
3789     unsigned char key_name[TLSEXT_KEYNAME_LENGTH];
3790     int iv_len, ok = 0;
3791     size_t macoffset, macendoffset;
3792
3793     /* get session encoding length */
3794     slen_full = i2d_SSL_SESSION(s->session, NULL);
3795     /*
3796      * Some length values are 16 bits, so forget it if session is too
3797      * long
3798      */
3799     if (slen_full == 0 || slen_full > 0xFF00) {
3800         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3801                  ERR_R_INTERNAL_ERROR);
3802         goto err;
3803     }
3804     senc = OPENSSL_malloc(slen_full);
3805     if (senc == NULL) {
3806         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3807                  SSL_F_CONSTRUCT_STATELESS_TICKET, ERR_R_MALLOC_FAILURE);
3808         goto err;
3809     }
3810
3811     ctx = EVP_CIPHER_CTX_new();
3812     hctx = HMAC_CTX_new();
3813     if (ctx == NULL || hctx == NULL) {
3814         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3815                  ERR_R_MALLOC_FAILURE);
3816         goto err;
3817     }
3818
3819     p = senc;
3820     if (!i2d_SSL_SESSION(s->session, &p)) {
3821         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3822                  ERR_R_INTERNAL_ERROR);
3823         goto err;
3824     }
3825
3826     /*
3827      * create a fresh copy (not shared with other threads) to clean up
3828      */
3829     const_p = senc;
3830     sess = d2i_SSL_SESSION(NULL, &const_p, slen_full);
3831     if (sess == NULL) {
3832         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3833                  ERR_R_INTERNAL_ERROR);
3834         goto err;
3835     }
3836
3837     slen = i2d_SSL_SESSION(sess, NULL);
3838     if (slen == 0 || slen > slen_full) {
3839         /* shouldn't ever happen */
3840         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3841                  ERR_R_INTERNAL_ERROR);
3842         SSL_SESSION_free(sess);
3843         goto err;
3844     }
3845     p = senc;
3846     if (!i2d_SSL_SESSION(sess, &p)) {
3847         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3848                  ERR_R_INTERNAL_ERROR);
3849         SSL_SESSION_free(sess);
3850         goto err;
3851     }
3852     SSL_SESSION_free(sess);
3853
3854     /*
3855      * Initialize HMAC and cipher contexts. If callback present it does
3856      * all the work otherwise use generated values from parent ctx.
3857      */
3858     if (tctx->ext.ticket_key_cb) {
3859         /* if 0 is returned, write an empty ticket */
3860         int ret = tctx->ext.ticket_key_cb(s, key_name, iv, ctx,
3861                                              hctx, 1);
3862
3863         if (ret == 0) {
3864
3865             /* Put timeout and length */
3866             if (!WPACKET_put_bytes_u32(pkt, 0)
3867                     || !WPACKET_put_bytes_u16(pkt, 0)) {
3868                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3869                          SSL_F_CONSTRUCT_STATELESS_TICKET,
3870                          ERR_R_INTERNAL_ERROR);
3871                 goto err;
3872             }
3873             OPENSSL_free(senc);
3874             EVP_CIPHER_CTX_free(ctx);
3875             HMAC_CTX_free(hctx);
3876             return 1;
3877         }
3878         if (ret < 0) {
3879             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3880                      SSL_R_CALLBACK_FAILED);
3881             goto err;
3882         }
3883         iv_len = EVP_CIPHER_CTX_iv_length(ctx);
3884     } else {
3885         const EVP_CIPHER *cipher = EVP_aes_256_cbc();
3886
3887         iv_len = EVP_CIPHER_iv_length(cipher);
3888         if (RAND_bytes(iv, iv_len) <= 0
3889                 || !EVP_EncryptInit_ex(ctx, cipher, NULL,
3890                                        tctx->ext.secure->tick_aes_key, iv)
3891                 || !HMAC_Init_ex(hctx, tctx->ext.secure->tick_hmac_key,
3892                                  sizeof(tctx->ext.secure->tick_hmac_key),
3893                                  EVP_sha256(), NULL)) {
3894             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3895                      ERR_R_INTERNAL_ERROR);
3896             goto err;
3897         }
3898         memcpy(key_name, tctx->ext.tick_key_name,
3899                sizeof(tctx->ext.tick_key_name));
3900     }
3901
3902     if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) {
3903         /* SSLfatal() already called */
3904         goto err;
3905     }
3906
3907     if (!WPACKET_get_total_written(pkt, &macoffset)
3908                /* Output key name */
3909             || !WPACKET_memcpy(pkt, key_name, sizeof(key_name))
3910                /* output IV */
3911             || !WPACKET_memcpy(pkt, iv, iv_len)
3912             || !WPACKET_reserve_bytes(pkt, slen + EVP_MAX_BLOCK_LENGTH,
3913                                       &encdata1)
3914                /* Encrypt session data */
3915             || !EVP_EncryptUpdate(ctx, encdata1, &len, senc, slen)
3916             || !WPACKET_allocate_bytes(pkt, len, &encdata2)
3917             || encdata1 != encdata2
3918             || !EVP_EncryptFinal(ctx, encdata1 + len, &lenfinal)
3919             || !WPACKET_allocate_bytes(pkt, lenfinal, &encdata2)
3920             || encdata1 + len != encdata2
3921             || len + lenfinal > slen + EVP_MAX_BLOCK_LENGTH
3922             || !WPACKET_get_total_written(pkt, &macendoffset)
3923             || !HMAC_Update(hctx,
3924                             (unsigned char *)s->init_buf->data + macoffset,
3925                             macendoffset - macoffset)
3926             || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &macdata1)
3927             || !HMAC_Final(hctx, macdata1, &hlen)
3928             || hlen > EVP_MAX_MD_SIZE
3929             || !WPACKET_allocate_bytes(pkt, hlen, &macdata2)
3930             || macdata1 != macdata2) {
3931         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3932                  SSL_F_CONSTRUCT_STATELESS_TICKET, ERR_R_INTERNAL_ERROR);
3933         goto err;
3934     }
3935
3936     /* Close the sub-packet created by create_ticket_prequel() */
3937     if (!WPACKET_close(pkt)) {
3938         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATELESS_TICKET,
3939                  ERR_R_INTERNAL_ERROR);
3940         goto err;
3941     }
3942
3943     ok = 1;
3944  err:
3945     OPENSSL_free(senc);
3946     EVP_CIPHER_CTX_free(ctx);
3947     HMAC_CTX_free(hctx);
3948     return ok;
3949 }
3950
3951 static int construct_stateful_ticket(SSL *s, WPACKET *pkt, uint32_t age_add,
3952                                      unsigned char *tick_nonce)
3953 {
3954     if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) {
3955         /* SSLfatal() already called */
3956         return 0;
3957     }
3958
3959     if (!WPACKET_memcpy(pkt, s->session->session_id,
3960                         s->session->session_id_length)
3961             || !WPACKET_close(pkt)) {
3962         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_CONSTRUCT_STATEFUL_TICKET,
3963                  ERR_R_INTERNAL_ERROR);
3964         return 0;
3965     }
3966
3967     return 1;
3968 }
3969
3970 int tls_construct_new_session_ticket(SSL *s, WPACKET *pkt)
3971 {
3972     SSL_CTX *tctx = s->session_ctx;
3973     unsigned char tick_nonce[TICKET_NONCE_SIZE];
3974     union {
3975         unsigned char age_add_c[sizeof(uint32_t)];
3976         uint32_t age_add;
3977     } age_add_u;
3978
3979     age_add_u.age_add = 0;
3980
3981     if (SSL_IS_TLS13(s)) {
3982         size_t i, hashlen;
3983         uint64_t nonce;
3984         static const unsigned char nonce_label[] = "resumption";
3985         const EVP_MD *md = ssl_handshake_md(s);
3986         int hashleni = EVP_MD_size(md);
3987
3988         /* Ensure cast to size_t is safe */
3989         if (!ossl_assert(hashleni >= 0)) {
3990             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
3991                      SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET,
3992                      ERR_R_INTERNAL_ERROR);
3993             goto err;
3994         }
3995         hashlen = (size_t)hashleni;
3996
3997         /*
3998          * If we already sent one NewSessionTicket, or we resumed then
3999          * s->session may already be in a cache and so we must not modify it.
4000          * Instead we need to take a copy of it and modify that.
4001          */
4002         if (s->sent_tickets != 0 || s->hit) {
4003             SSL_SESSION *new_sess = ssl_session_dup(s->session, 0);
4004
4005             if (new_sess == NULL) {
4006                 /* SSLfatal already called */
4007                 goto err;
4008             }
4009