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