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