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