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