Move init of the WPACKET into write_state_machine()
[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, WPACKET *pkt)
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, pkt);
633
634     case TLS_ST_SW_HELLO_REQ:
635         return tls_construct_hello_request(s, pkt);
636
637     case TLS_ST_SW_SRVR_HELLO:
638         return tls_construct_server_hello(s, pkt);
639
640     case TLS_ST_SW_CERT:
641         return tls_construct_server_certificate(s, pkt);
642
643     case TLS_ST_SW_KEY_EXCH:
644         return tls_construct_server_key_exchange(s, pkt);
645
646     case TLS_ST_SW_CERT_REQ:
647         return tls_construct_certificate_request(s, pkt);
648
649     case TLS_ST_SW_SRVR_DONE:
650         return tls_construct_server_done(s, pkt);
651
652     case TLS_ST_SW_SESSION_TICKET:
653         return tls_construct_new_session_ticket(s, pkt);
654
655     case TLS_ST_SW_CERT_STATUS:
656         return tls_construct_cert_status(s, pkt);
657
658     case TLS_ST_SW_CHANGE:
659         if (SSL_IS_DTLS(s))
660             return dtls_construct_change_cipher_spec(s, pkt);
661         else
662             return tls_construct_change_cipher_spec(s, pkt);
663
664     case TLS_ST_SW_FINISHED:
665         return tls_construct_finished(s, pkt,
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, WPACKET *pkt)
833 {
834     if (!ssl_set_handshake_header(s, pkt, SSL3_MT_HELLO_REQUEST)
835             || !ssl_close_construct_packet(s, pkt)) {
836         SSLerr(SSL_F_TLS_CONSTRUCT_HELLO_REQUEST, ERR_R_INTERNAL_ERROR);
837         return 0;
838     }
839
840     return 1;
841 }
842
843 int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie,
844                                   unsigned char cookie_len)
845 {
846     /* Always use DTLS 1.0 version: see RFC 6347 */
847     if (!WPACKET_put_bytes_u16(pkt, DTLS1_VERSION)
848             || !WPACKET_sub_memcpy_u8(pkt, cookie, cookie_len))
849         return 0;
850
851     return 1;
852 }
853
854 int dtls_construct_hello_verify_request(SSL *s, WPACKET *pkt)
855 {
856     size_t msglen;
857
858     if (s->ctx->app_gen_cookie_cb == NULL ||
859         s->ctx->app_gen_cookie_cb(s, s->d1->cookie,
860                                   &(s->d1->cookie_len)) == 0 ||
861         s->d1->cookie_len > 255) {
862         SSLerr(SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST,
863                SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
864         return 0;
865     }
866
867     if (!ssl_set_handshake_header(s, pkt,
868                                          DTLS1_MT_HELLO_VERIFY_REQUEST)
869             || !dtls_raw_hello_verify_request(pkt, s->d1->cookie,
870                                               s->d1->cookie_len)
871                /*
872                 * We don't call close_construct_packet() because we don't want
873                 * to buffer this message
874                 */
875             || !WPACKET_close(pkt)
876             || !WPACKET_get_length(pkt, &msglen)
877             || !WPACKET_finish(pkt)) {
878         SSLerr(SSL_F_DTLS_CONSTRUCT_HELLO_VERIFY_REQUEST, ERR_R_INTERNAL_ERROR);
879         return 0;
880     }
881
882     /* number of bytes to write */
883     s->d1->w_msg_hdr.msg_len = msglen - DTLS1_HM_HEADER_LENGTH;
884     s->d1->w_msg_hdr.frag_len = msglen - DTLS1_HM_HEADER_LENGTH;
885     s->init_num = (int)msglen;
886     s->init_off = 0;
887
888     return 1;
889 }
890
891 MSG_PROCESS_RETURN tls_process_client_hello(SSL *s, PACKET *pkt)
892 {
893     int i, al = SSL_AD_INTERNAL_ERROR;
894     unsigned int j, complen = 0;
895     unsigned long id;
896     const SSL_CIPHER *c;
897 #ifndef OPENSSL_NO_COMP
898     SSL_COMP *comp = NULL;
899 #endif
900     STACK_OF(SSL_CIPHER) *ciphers = NULL;
901     int protverr;
902     /* |cookie| will only be initialized for DTLS. */
903     PACKET session_id, cipher_suites, compression, extensions, cookie;
904     int is_v2_record;
905     static const unsigned char null_compression = 0;
906
907     is_v2_record = RECORD_LAYER_is_sslv2_record(&s->rlayer);
908
909     PACKET_null_init(&cookie);
910     /* First lets get s->client_version set correctly */
911     if (is_v2_record) {
912         unsigned int version;
913         unsigned int mt;
914         /*-
915          * An SSLv3/TLSv1 backwards-compatible CLIENT-HELLO in an SSLv2
916          * header is sent directly on the wire, not wrapped as a TLS
917          * record. Our record layer just processes the message length and passes
918          * the rest right through. Its format is:
919          * Byte  Content
920          * 0-1   msg_length - decoded by the record layer
921          * 2     msg_type - s->init_msg points here
922          * 3-4   version
923          * 5-6   cipher_spec_length
924          * 7-8   session_id_length
925          * 9-10  challenge_length
926          * ...   ...
927          */
928
929         if (!PACKET_get_1(pkt, &mt)
930             || mt != SSL2_MT_CLIENT_HELLO) {
931             /*
932              * Should never happen. We should have tested this in the record
933              * layer in order to have determined that this is a SSLv2 record
934              * in the first place
935              */
936             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
937             goto err;
938         }
939
940         if (!PACKET_get_net_2(pkt, &version)) {
941             /* No protocol version supplied! */
942             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
943             goto err;
944         }
945         if (version == 0x0002) {
946             /* This is real SSLv2. We don't support it. */
947             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
948             goto err;
949         } else if ((version & 0xff00) == (SSL3_VERSION_MAJOR << 8)) {
950             /* SSLv3/TLS */
951             s->client_version = version;
952         } else {
953             /* No idea what protocol this is */
954             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_UNKNOWN_PROTOCOL);
955             goto err;
956         }
957     } else {
958         /*
959          * use version from inside client hello, not from record header (may
960          * differ: see RFC 2246, Appendix E, second paragraph)
961          */
962         if (!PACKET_get_net_2(pkt, (unsigned int *)&s->client_version)) {
963             al = SSL_AD_DECODE_ERROR;
964             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_TOO_SHORT);
965             goto f_err;
966         }
967     }
968
969     /*
970      * Do SSL/TLS version negotiation if applicable. For DTLS we just check
971      * versions are potentially compatible. Version negotiation comes later.
972      */
973     if (!SSL_IS_DTLS(s)) {
974         protverr = ssl_choose_server_version(s);
975     } else if (s->method->version != DTLS_ANY_VERSION &&
976                DTLS_VERSION_LT(s->client_version, s->version)) {
977         protverr = SSL_R_VERSION_TOO_LOW;
978     } else {
979         protverr = 0;
980     }
981
982     if (protverr) {
983         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, protverr);
984         if ((!s->enc_write_ctx && !s->write_hash)) {
985             /*
986              * similar to ssl3_get_record, send alert using remote version
987              * number
988              */
989             s->version = s->client_version;
990         }
991         al = SSL_AD_PROTOCOL_VERSION;
992         goto f_err;
993     }
994
995     /* Parse the message and load client random. */
996     if (is_v2_record) {
997         /*
998          * Handle an SSLv2 backwards compatible ClientHello
999          * Note, this is only for SSLv3+ using the backward compatible format.
1000          * Real SSLv2 is not supported, and is rejected above.
1001          */
1002         unsigned int cipher_len, session_id_len, challenge_len;
1003         PACKET challenge;
1004
1005         if (!PACKET_get_net_2(pkt, &cipher_len)
1006             || !PACKET_get_net_2(pkt, &session_id_len)
1007             || !PACKET_get_net_2(pkt, &challenge_len)) {
1008             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1009                    SSL_R_RECORD_LENGTH_MISMATCH);
1010             al = SSL_AD_DECODE_ERROR;
1011             goto f_err;
1012         }
1013
1014         if (session_id_len > SSL_MAX_SSL_SESSION_ID_LENGTH) {
1015             al = SSL_AD_DECODE_ERROR;
1016             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1017             goto f_err;
1018         }
1019
1020         if (!PACKET_get_sub_packet(pkt, &cipher_suites, cipher_len)
1021             || !PACKET_get_sub_packet(pkt, &session_id, session_id_len)
1022             || !PACKET_get_sub_packet(pkt, &challenge, challenge_len)
1023             /* No extensions. */
1024             || PACKET_remaining(pkt) != 0) {
1025             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1026                    SSL_R_RECORD_LENGTH_MISMATCH);
1027             al = SSL_AD_DECODE_ERROR;
1028             goto f_err;
1029         }
1030
1031         /* Load the client random and compression list. */
1032         challenge_len = challenge_len > SSL3_RANDOM_SIZE ? SSL3_RANDOM_SIZE :
1033             challenge_len;
1034         memset(s->s3->client_random, 0, SSL3_RANDOM_SIZE);
1035         if (!PACKET_copy_bytes(&challenge,
1036                                s->s3->client_random + SSL3_RANDOM_SIZE -
1037                                challenge_len, challenge_len)
1038             /* Advertise only null compression. */
1039             || !PACKET_buf_init(&compression, &null_compression, 1)) {
1040             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1041             al = SSL_AD_INTERNAL_ERROR;
1042             goto f_err;
1043         }
1044
1045         PACKET_null_init(&extensions);
1046     } else {
1047         /* Regular ClientHello. */
1048         if (!PACKET_copy_bytes(pkt, s->s3->client_random, SSL3_RANDOM_SIZE)
1049             || !PACKET_get_length_prefixed_1(pkt, &session_id)) {
1050             al = SSL_AD_DECODE_ERROR;
1051             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1052             goto f_err;
1053         }
1054
1055         if (PACKET_remaining(&session_id) > SSL_MAX_SSL_SESSION_ID_LENGTH) {
1056             al = SSL_AD_DECODE_ERROR;
1057             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1058             goto f_err;
1059         }
1060
1061         if (SSL_IS_DTLS(s)) {
1062             if (!PACKET_get_length_prefixed_1(pkt, &cookie)) {
1063                 al = SSL_AD_DECODE_ERROR;
1064                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1065                 goto f_err;
1066             }
1067             /*
1068              * If we require cookies and this ClientHello doesn't contain one,
1069              * just return since we do not want to allocate any memory yet.
1070              * So check cookie length...
1071              */
1072             if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
1073                 if (PACKET_remaining(&cookie) == 0)
1074                     return 1;
1075             }
1076         }
1077
1078         if (!PACKET_get_length_prefixed_2(pkt, &cipher_suites)
1079             || !PACKET_get_length_prefixed_1(pkt, &compression)) {
1080             al = SSL_AD_DECODE_ERROR;
1081             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_LENGTH_MISMATCH);
1082             goto f_err;
1083         }
1084         /* Could be empty. */
1085         extensions = *pkt;
1086     }
1087
1088     if (SSL_IS_DTLS(s)) {
1089         /* Empty cookie was already handled above by returning early. */
1090         if (SSL_get_options(s) & SSL_OP_COOKIE_EXCHANGE) {
1091             if (s->ctx->app_verify_cookie_cb != NULL) {
1092                 if (s->ctx->app_verify_cookie_cb(s, PACKET_data(&cookie),
1093                                                  PACKET_remaining(&cookie)) ==
1094                     0) {
1095                     al = SSL_AD_HANDSHAKE_FAILURE;
1096                     SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1097                            SSL_R_COOKIE_MISMATCH);
1098                     goto f_err;
1099                     /* else cookie verification succeeded */
1100                 }
1101                 /* default verification */
1102             } else if (!PACKET_equal(&cookie, s->d1->cookie, s->d1->cookie_len)) {
1103                 al = SSL_AD_HANDSHAKE_FAILURE;
1104                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_COOKIE_MISMATCH);
1105                 goto f_err;
1106             }
1107             s->d1->cookie_verified = 1;
1108         }
1109         if (s->method->version == DTLS_ANY_VERSION) {
1110             protverr = ssl_choose_server_version(s);
1111             if (protverr != 0) {
1112                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, protverr);
1113                 s->version = s->client_version;
1114                 al = SSL_AD_PROTOCOL_VERSION;
1115                 goto f_err;
1116             }
1117         }
1118     }
1119
1120     s->hit = 0;
1121
1122     /*
1123      * We don't allow resumption in a backwards compatible ClientHello.
1124      * TODO(openssl-team): in TLS1.1+, session_id MUST be empty.
1125      *
1126      * Versions before 0.9.7 always allow clients to resume sessions in
1127      * renegotiation. 0.9.7 and later allow this by default, but optionally
1128      * ignore resumption requests with flag
1129      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather
1130      * than a change to default behavior so that applications relying on
1131      * this for security won't even compile against older library versions).
1132      * 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to
1133      * request renegotiation but not a new session (s->new_session remains
1134      * unset): for servers, this essentially just means that the
1135      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be
1136      * ignored.
1137      */
1138     if (is_v2_record ||
1139         (s->new_session &&
1140          (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
1141         if (!ssl_get_new_session(s, 1))
1142             goto err;
1143     } else {
1144         i = ssl_get_prev_session(s, &extensions, &session_id);
1145         /*
1146          * Only resume if the session's version matches the negotiated
1147          * version.
1148          * RFC 5246 does not provide much useful advice on resumption
1149          * with a different protocol version. It doesn't forbid it but
1150          * the sanity of such behaviour would be questionable.
1151          * In practice, clients do not accept a version mismatch and
1152          * will abort the handshake with an error.
1153          */
1154         if (i == 1 && s->version == s->session->ssl_version) {
1155             /* previous session */
1156             s->hit = 1;
1157         } else if (i == -1) {
1158             goto err;
1159         } else {
1160             /* i == 0 */
1161             if (!ssl_get_new_session(s, 1))
1162                 goto err;
1163         }
1164     }
1165
1166     if (ssl_bytes_to_cipher_list(s, &cipher_suites, &(ciphers),
1167                                  is_v2_record, &al) == NULL) {
1168         goto f_err;
1169     }
1170
1171     /* If it is a hit, check that the cipher is in the list */
1172     if (s->hit) {
1173         j = 0;
1174         id = s->session->cipher->id;
1175
1176 #ifdef CIPHER_DEBUG
1177         fprintf(stderr, "client sent %d ciphers\n", sk_SSL_CIPHER_num(ciphers));
1178 #endif
1179         for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1180             c = sk_SSL_CIPHER_value(ciphers, i);
1181 #ifdef CIPHER_DEBUG
1182             fprintf(stderr, "client [%2d of %2d]:%s\n",
1183                     i, sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c));
1184 #endif
1185             if (c->id == id) {
1186                 j = 1;
1187                 break;
1188             }
1189         }
1190         if (j == 0) {
1191             /*
1192              * we need to have the cipher in the cipher list if we are asked
1193              * to reuse it
1194              */
1195             al = SSL_AD_ILLEGAL_PARAMETER;
1196             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1197                    SSL_R_REQUIRED_CIPHER_MISSING);
1198             goto f_err;
1199         }
1200     }
1201
1202     complen = PACKET_remaining(&compression);
1203     for (j = 0; j < complen; j++) {
1204         if (PACKET_data(&compression)[j] == 0)
1205             break;
1206     }
1207
1208     if (j >= complen) {
1209         /* no compress */
1210         al = SSL_AD_DECODE_ERROR;
1211         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_NO_COMPRESSION_SPECIFIED);
1212         goto f_err;
1213     }
1214
1215     /* TLS extensions */
1216     if (s->version >= SSL3_VERSION) {
1217         if (!ssl_parse_clienthello_tlsext(s, &extensions)) {
1218             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_PARSE_TLSEXT);
1219             goto err;
1220         }
1221     }
1222
1223     /*
1224      * Check if we want to use external pre-shared secret for this handshake
1225      * for not reused session only. We need to generate server_random before
1226      * calling tls_session_secret_cb in order to allow SessionTicket
1227      * processing to use it in key derivation.
1228      */
1229     {
1230         unsigned char *pos;
1231         pos = s->s3->server_random;
1232         if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE) <= 0) {
1233             goto f_err;
1234         }
1235     }
1236
1237     if (!s->hit && s->version >= TLS1_VERSION && s->tls_session_secret_cb) {
1238         const SSL_CIPHER *pref_cipher = NULL;
1239
1240         s->session->master_key_length = sizeof(s->session->master_key);
1241         if (s->tls_session_secret_cb(s, s->session->master_key,
1242                                      &s->session->master_key_length, ciphers,
1243                                      &pref_cipher,
1244                                      s->tls_session_secret_cb_arg)) {
1245             s->hit = 1;
1246             s->session->ciphers = ciphers;
1247             s->session->verify_result = X509_V_OK;
1248
1249             ciphers = NULL;
1250
1251             /* check if some cipher was preferred by call back */
1252             pref_cipher =
1253                 pref_cipher ? pref_cipher : ssl3_choose_cipher(s,
1254                                                                s->
1255                                                                session->ciphers,
1256                                                                SSL_get_ciphers
1257                                                                (s));
1258             if (pref_cipher == NULL) {
1259                 al = SSL_AD_HANDSHAKE_FAILURE;
1260                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_NO_SHARED_CIPHER);
1261                 goto f_err;
1262             }
1263
1264             s->session->cipher = pref_cipher;
1265             sk_SSL_CIPHER_free(s->cipher_list);
1266             s->cipher_list = sk_SSL_CIPHER_dup(s->session->ciphers);
1267             sk_SSL_CIPHER_free(s->cipher_list_by_id);
1268             s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->session->ciphers);
1269         }
1270     }
1271
1272     /*
1273      * Worst case, we will use the NULL compression, but if we have other
1274      * options, we will now look for them.  We have complen-1 compression
1275      * algorithms from the client, starting at q.
1276      */
1277     s->s3->tmp.new_compression = NULL;
1278 #ifndef OPENSSL_NO_COMP
1279     /* This only happens if we have a cache hit */
1280     if (s->session->compress_meth != 0) {
1281         int m, comp_id = s->session->compress_meth;
1282         unsigned int k;
1283         /* Perform sanity checks on resumed compression algorithm */
1284         /* Can't disable compression */
1285         if (!ssl_allow_compression(s)) {
1286             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1287                    SSL_R_INCONSISTENT_COMPRESSION);
1288             goto f_err;
1289         }
1290         /* Look for resumed compression method */
1291         for (m = 0; m < sk_SSL_COMP_num(s->ctx->comp_methods); m++) {
1292             comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
1293             if (comp_id == comp->id) {
1294                 s->s3->tmp.new_compression = comp;
1295                 break;
1296             }
1297         }
1298         if (s->s3->tmp.new_compression == NULL) {
1299             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1300                    SSL_R_INVALID_COMPRESSION_ALGORITHM);
1301             goto f_err;
1302         }
1303         /* Look for resumed method in compression list */
1304         for (k = 0; k < complen; k++) {
1305             if (PACKET_data(&compression)[k] == comp_id)
1306                 break;
1307         }
1308         if (k >= complen) {
1309             al = SSL_AD_ILLEGAL_PARAMETER;
1310             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO,
1311                    SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING);
1312             goto f_err;
1313         }
1314     } else if (s->hit)
1315         comp = NULL;
1316     else if (ssl_allow_compression(s) && s->ctx->comp_methods) {
1317         /* See if we have a match */
1318         int m, nn, v, done = 0;
1319         unsigned int o;
1320
1321         nn = sk_SSL_COMP_num(s->ctx->comp_methods);
1322         for (m = 0; m < nn; m++) {
1323             comp = sk_SSL_COMP_value(s->ctx->comp_methods, m);
1324             v = comp->id;
1325             for (o = 0; o < complen; o++) {
1326                 if (v == PACKET_data(&compression)[o]) {
1327                     done = 1;
1328                     break;
1329                 }
1330             }
1331             if (done)
1332                 break;
1333         }
1334         if (done)
1335             s->s3->tmp.new_compression = comp;
1336         else
1337             comp = NULL;
1338     }
1339 #else
1340     /*
1341      * If compression is disabled we'd better not try to resume a session
1342      * using compression.
1343      */
1344     if (s->session->compress_meth != 0) {
1345         SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_INCONSISTENT_COMPRESSION);
1346         goto f_err;
1347     }
1348 #endif
1349
1350     /*
1351      * Given s->session->ciphers and SSL_get_ciphers, we must pick a cipher
1352      */
1353
1354     if (!s->hit) {
1355 #ifdef OPENSSL_NO_COMP
1356         s->session->compress_meth = 0;
1357 #else
1358         s->session->compress_meth = (comp == NULL) ? 0 : comp->id;
1359 #endif
1360         sk_SSL_CIPHER_free(s->session->ciphers);
1361         s->session->ciphers = ciphers;
1362         if (ciphers == NULL) {
1363             al = SSL_AD_INTERNAL_ERROR;
1364             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
1365             goto f_err;
1366         }
1367         ciphers = NULL;
1368         if (!tls1_set_server_sigalgs(s)) {
1369             SSLerr(SSL_F_TLS_PROCESS_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
1370             goto err;
1371         }
1372     }
1373
1374     sk_SSL_CIPHER_free(ciphers);
1375     return MSG_PROCESS_CONTINUE_PROCESSING;
1376  f_err:
1377     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1378  err:
1379     ossl_statem_set_error(s);
1380
1381     sk_SSL_CIPHER_free(ciphers);
1382     return MSG_PROCESS_ERROR;
1383
1384 }
1385
1386 WORK_STATE tls_post_process_client_hello(SSL *s, WORK_STATE wst)
1387 {
1388     int al = SSL_AD_HANDSHAKE_FAILURE;
1389     const SSL_CIPHER *cipher;
1390
1391     if (wst == WORK_MORE_A) {
1392         if (!s->hit) {
1393             /* Let cert callback update server certificates if required */
1394             if (s->cert->cert_cb) {
1395                 int rv = s->cert->cert_cb(s, s->cert->cert_cb_arg);
1396                 if (rv == 0) {
1397                     al = SSL_AD_INTERNAL_ERROR;
1398                     SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1399                            SSL_R_CERT_CB_ERROR);
1400                     goto f_err;
1401                 }
1402                 if (rv < 0) {
1403                     s->rwstate = SSL_X509_LOOKUP;
1404                     return WORK_MORE_A;
1405                 }
1406                 s->rwstate = SSL_NOTHING;
1407             }
1408             cipher =
1409                 ssl3_choose_cipher(s, s->session->ciphers, SSL_get_ciphers(s));
1410
1411             if (cipher == NULL) {
1412                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1413                        SSL_R_NO_SHARED_CIPHER);
1414                 goto f_err;
1415             }
1416             s->s3->tmp.new_cipher = cipher;
1417             /* check whether we should disable session resumption */
1418             if (s->not_resumable_session_cb != NULL)
1419                 s->session->not_resumable = s->not_resumable_session_cb(s,
1420                                                                         ((cipher->algorithm_mkey & (SSL_kDHE | SSL_kECDHE)) != 0));
1421             if (s->session->not_resumable)
1422                 /* do not send a session ticket */
1423                 s->tlsext_ticket_expected = 0;
1424         } else {
1425             /* Session-id reuse */
1426             s->s3->tmp.new_cipher = s->session->cipher;
1427         }
1428
1429         if (!(s->verify_mode & SSL_VERIFY_PEER)) {
1430             if (!ssl3_digest_cached_records(s, 0)) {
1431                 al = SSL_AD_INTERNAL_ERROR;
1432                 goto f_err;
1433             }
1434         }
1435
1436         /*-
1437          * we now have the following setup.
1438          * client_random
1439          * cipher_list          - our preferred list of ciphers
1440          * ciphers              - the clients preferred list of ciphers
1441          * compression          - basically ignored right now
1442          * ssl version is set   - sslv3
1443          * s->session           - The ssl session has been setup.
1444          * s->hit               - session reuse flag
1445          * s->s3->tmp.new_cipher- the new cipher to use.
1446          */
1447
1448         /* Handles TLS extensions that we couldn't check earlier */
1449         if (s->version >= SSL3_VERSION) {
1450             if (!ssl_check_clienthello_tlsext_late(s, &al)) {
1451                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1452                        SSL_R_CLIENTHELLO_TLSEXT);
1453                 goto f_err;
1454             }
1455         }
1456
1457         wst = WORK_MORE_B;
1458     }
1459 #ifndef OPENSSL_NO_SRP
1460     if (wst == WORK_MORE_B) {
1461         int ret;
1462         if ((ret = ssl_check_srp_ext_ClientHello(s, &al)) < 0) {
1463             /*
1464              * callback indicates further work to be done
1465              */
1466             s->rwstate = SSL_X509_LOOKUP;
1467             return WORK_MORE_B;
1468         }
1469         if (ret != SSL_ERROR_NONE) {
1470             /*
1471              * This is not really an error but the only means to for
1472              * a client to detect whether srp is supported.
1473              */
1474             if (al != TLS1_AD_UNKNOWN_PSK_IDENTITY)
1475                 SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_HELLO,
1476                        SSL_R_CLIENTHELLO_TLSEXT);
1477             goto f_err;
1478         }
1479     }
1480 #endif
1481     s->renegotiate = 2;
1482
1483     return WORK_FINISHED_STOP;
1484  f_err:
1485     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1486     ossl_statem_set_error(s);
1487     return WORK_ERROR;
1488 }
1489
1490 int tls_construct_server_hello(SSL *s, WPACKET *pkt)
1491 {
1492     int sl, compm, al = SSL_AD_INTERNAL_ERROR;
1493     size_t len;
1494
1495     if (!ssl_set_handshake_header(s, pkt, SSL3_MT_SERVER_HELLO)
1496             || !WPACKET_put_bytes_u16(pkt, s->version)
1497                /*
1498                 * Random stuff. Filling of the server_random takes place in
1499                 * tls_process_client_hello()
1500                 */
1501             || !WPACKET_memcpy(pkt, s->s3->server_random, SSL3_RANDOM_SIZE)) {
1502         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1503         goto err;
1504     }
1505
1506     /*-
1507      * There are several cases for the session ID to send
1508      * back in the server hello:
1509      * - For session reuse from the session cache,
1510      *   we send back the old session ID.
1511      * - If stateless session reuse (using a session ticket)
1512      *   is successful, we send back the client's "session ID"
1513      *   (which doesn't actually identify the session).
1514      * - If it is a new session, we send back the new
1515      *   session ID.
1516      * - However, if we want the new session to be single-use,
1517      *   we send back a 0-length session ID.
1518      * s->hit is non-zero in either case of session reuse,
1519      * so the following won't overwrite an ID that we're supposed
1520      * to send back.
1521      */
1522     if (s->session->not_resumable ||
1523         (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_SERVER)
1524          && !s->hit))
1525         s->session->session_id_length = 0;
1526
1527     sl = s->session->session_id_length;
1528     if (sl > (int)sizeof(s->session->session_id)) {
1529         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1530         goto err;
1531     }
1532
1533     /* set up the compression method */
1534 #ifdef OPENSSL_NO_COMP
1535     compm = 0;
1536 #else
1537     if (s->s3->tmp.new_compression == NULL)
1538         compm = 0;
1539     else
1540         compm = s->s3->tmp.new_compression->id;
1541 #endif
1542
1543     if (!WPACKET_sub_memcpy_u8(pkt, s->session->session_id, sl)
1544             || !s->method->put_cipher_by_char(s->s3->tmp.new_cipher, pkt, &len)
1545             || !WPACKET_put_bytes_u8(pkt, compm)
1546             || !ssl_prepare_serverhello_tlsext(s)
1547             || !ssl_add_serverhello_tlsext(s, pkt, &al)
1548             || !ssl_close_construct_packet(s, pkt)) {
1549         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_HELLO, ERR_R_INTERNAL_ERROR);
1550         goto err;
1551     }
1552
1553     return 1;
1554  err:
1555     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
1556     return 0;
1557 }
1558
1559 int tls_construct_server_done(SSL *s, WPACKET *pkt)
1560 {
1561     if (!ssl_set_handshake_header(s, pkt, SSL3_MT_SERVER_DONE)
1562             || !ssl_close_construct_packet(s, pkt)) {
1563         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_DONE, ERR_R_INTERNAL_ERROR);
1564         goto err;
1565     }
1566
1567     if (!s->s3->tmp.cert_request) {
1568         if (!ssl3_digest_cached_records(s, 0))
1569             goto err;
1570     }
1571     return 1;
1572
1573  err:
1574     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
1575     return 0;
1576 }
1577
1578 int tls_construct_server_key_exchange(SSL *s, WPACKET *pkt)
1579 {
1580 #ifndef OPENSSL_NO_DH
1581     EVP_PKEY *pkdh = NULL;
1582 #endif
1583 #ifndef OPENSSL_NO_EC
1584     unsigned char *encodedPoint = NULL;
1585     int encodedlen = 0;
1586     int curve_id = 0;
1587 #endif
1588     EVP_PKEY *pkey;
1589     const EVP_MD *md = NULL;
1590     int al = SSL_AD_INTERNAL_ERROR, i;
1591     unsigned long type;
1592     const BIGNUM *r[4];
1593     EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
1594     size_t paramlen, paramoffset;
1595
1596     if (!ssl_set_handshake_header(s, pkt,
1597                                          SSL3_MT_SERVER_KEY_EXCHANGE)
1598             || !WPACKET_get_total_written(pkt, &paramoffset)) {
1599         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1600         goto f_err;
1601     }
1602
1603     if (md_ctx == NULL) {
1604         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
1605         goto f_err;
1606     }
1607
1608     type = s->s3->tmp.new_cipher->algorithm_mkey;
1609
1610     r[0] = r[1] = r[2] = r[3] = NULL;
1611 #ifndef OPENSSL_NO_PSK
1612     /* Plain PSK or RSAPSK nothing to do */
1613     if (type & (SSL_kPSK | SSL_kRSAPSK)) {
1614     } else
1615 #endif                          /* !OPENSSL_NO_PSK */
1616 #ifndef OPENSSL_NO_DH
1617     if (type & (SSL_kDHE | SSL_kDHEPSK)) {
1618         CERT *cert = s->cert;
1619
1620         EVP_PKEY *pkdhp = NULL;
1621         DH *dh;
1622
1623         if (s->cert->dh_tmp_auto) {
1624             DH *dhp = ssl_get_auto_dh(s);
1625             pkdh = EVP_PKEY_new();
1626             if (pkdh == NULL || dhp == NULL) {
1627                 DH_free(dhp);
1628                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1629                        ERR_R_INTERNAL_ERROR);
1630                 goto f_err;
1631             }
1632             EVP_PKEY_assign_DH(pkdh, dhp);
1633             pkdhp = pkdh;
1634         } else {
1635             pkdhp = cert->dh_tmp;
1636         }
1637         if ((pkdhp == NULL) && (s->cert->dh_tmp_cb != NULL)) {
1638             DH *dhp = s->cert->dh_tmp_cb(s, 0, 1024);
1639             pkdh = ssl_dh_to_pkey(dhp);
1640             if (pkdh == NULL) {
1641                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1642                        ERR_R_INTERNAL_ERROR);
1643                 goto f_err;
1644             }
1645             pkdhp = pkdh;
1646         }
1647         if (pkdhp == NULL) {
1648             al = SSL_AD_HANDSHAKE_FAILURE;
1649             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1650                    SSL_R_MISSING_TMP_DH_KEY);
1651             goto f_err;
1652         }
1653         if (!ssl_security(s, SSL_SECOP_TMP_DH,
1654                           EVP_PKEY_security_bits(pkdhp), 0, pkdhp)) {
1655             al = SSL_AD_HANDSHAKE_FAILURE;
1656             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1657                    SSL_R_DH_KEY_TOO_SMALL);
1658             goto f_err;
1659         }
1660         if (s->s3->tmp.pkey != NULL) {
1661             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1662                    ERR_R_INTERNAL_ERROR);
1663             goto err;
1664         }
1665
1666         s->s3->tmp.pkey = ssl_generate_pkey(pkdhp);
1667
1668         if (s->s3->tmp.pkey == NULL) {
1669             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_EVP_LIB);
1670             goto err;
1671         }
1672
1673         dh = EVP_PKEY_get0_DH(s->s3->tmp.pkey);
1674
1675         EVP_PKEY_free(pkdh);
1676         pkdh = NULL;
1677
1678         DH_get0_pqg(dh, &r[0], NULL, &r[1]);
1679         DH_get0_key(dh, &r[2], NULL);
1680     } else
1681 #endif
1682 #ifndef OPENSSL_NO_EC
1683     if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
1684         int nid;
1685
1686         if (s->s3->tmp.pkey != NULL) {
1687             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1688                    ERR_R_INTERNAL_ERROR);
1689             goto err;
1690         }
1691
1692         /* Get NID of appropriate shared curve */
1693         nid = tls1_shared_curve(s, -2);
1694         curve_id = tls1_ec_nid2curve_id(nid);
1695         if (curve_id == 0) {
1696             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1697                    SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
1698             goto err;
1699         }
1700         s->s3->tmp.pkey = ssl_generate_pkey_curve(curve_id);
1701         /* Generate a new key for this curve */
1702         if (s->s3->tmp.pkey == NULL) {
1703             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_EVP_LIB);
1704             goto f_err;
1705         }
1706
1707         /* Encode the public key. */
1708         encodedlen = EVP_PKEY_get1_tls_encodedpoint(s->s3->tmp.pkey,
1709                                                     &encodedPoint);
1710         if (encodedlen == 0) {
1711             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_EC_LIB);
1712             goto err;
1713         }
1714
1715         /*
1716          * We'll generate the serverKeyExchange message explicitly so we
1717          * can set these to NULLs
1718          */
1719         r[0] = NULL;
1720         r[1] = NULL;
1721         r[2] = NULL;
1722         r[3] = NULL;
1723     } else
1724 #endif                          /* !OPENSSL_NO_EC */
1725 #ifndef OPENSSL_NO_SRP
1726     if (type & SSL_kSRP) {
1727         if ((s->srp_ctx.N == NULL) ||
1728             (s->srp_ctx.g == NULL) ||
1729             (s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) {
1730             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1731                    SSL_R_MISSING_SRP_PARAM);
1732             goto err;
1733         }
1734         r[0] = s->srp_ctx.N;
1735         r[1] = s->srp_ctx.g;
1736         r[2] = s->srp_ctx.s;
1737         r[3] = s->srp_ctx.B;
1738     } else
1739 #endif
1740     {
1741         al = SSL_AD_HANDSHAKE_FAILURE;
1742         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1743                SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
1744         goto f_err;
1745     }
1746
1747     if (!(s->s3->tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP))
1748         && !(s->s3->tmp.new_cipher->algorithm_mkey & SSL_PSK)) {
1749         if ((pkey = ssl_get_sign_pkey(s, s->s3->tmp.new_cipher, &md))
1750             == NULL) {
1751             al = SSL_AD_DECODE_ERROR;
1752             goto f_err;
1753         }
1754     } else {
1755         pkey = NULL;
1756     }
1757
1758 #ifndef OPENSSL_NO_PSK
1759     if (type & SSL_PSK) {
1760         size_t len = (s->cert->psk_identity_hint == NULL)
1761                         ? 0 : strlen(s->cert->psk_identity_hint);
1762
1763         /*
1764          * It should not happen that len > PSK_MAX_IDENTITY_LEN - we already
1765          * checked this when we set the identity hint - but just in case
1766          */
1767         if (len > PSK_MAX_IDENTITY_LEN
1768                 || !WPACKET_sub_memcpy_u16(pkt, s->cert->psk_identity_hint,
1769                                            len)) {
1770             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1771                    ERR_R_INTERNAL_ERROR);
1772             goto f_err;
1773         }
1774     }
1775 #endif
1776
1777     for (i = 0; i < 4 && r[i] != NULL; i++) {
1778         unsigned char *binval;
1779         int res;
1780
1781 #ifndef OPENSSL_NO_SRP
1782         if ((i == 2) && (type & SSL_kSRP)) {
1783             res = WPACKET_start_sub_packet_u8(pkt);
1784         } else
1785 #endif
1786             res = WPACKET_start_sub_packet_u16(pkt);
1787
1788         if (!res) {
1789             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1790                    ERR_R_INTERNAL_ERROR);
1791             goto f_err;
1792         }
1793
1794 #ifndef OPENSSL_NO_DH
1795         /*-
1796          * for interoperability with some versions of the Microsoft TLS
1797          * stack, we need to zero pad the DHE pub key to the same length
1798          * as the prime
1799          */
1800         if ((i == 2) && (type & (SSL_kDHE | SSL_kDHEPSK))) {
1801             size_t len = BN_num_bytes(r[0]) - BN_num_bytes(r[2]);
1802
1803             if (len > 0) {
1804                 if (!WPACKET_allocate_bytes(pkt, len, &binval)) {
1805                     SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1806                            ERR_R_INTERNAL_ERROR);
1807                     goto f_err;
1808                 }
1809                 memset(binval, 0, len);
1810             }
1811         }
1812 #endif
1813         if (!WPACKET_allocate_bytes(pkt, BN_num_bytes(r[i]), &binval)
1814                 || !WPACKET_close(pkt)) {
1815             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1816                    ERR_R_INTERNAL_ERROR);
1817             goto f_err;
1818         }
1819
1820         BN_bn2bin(r[i], binval);
1821     }
1822
1823 #ifndef OPENSSL_NO_EC
1824     if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
1825         /*
1826          * We only support named (not generic) curves. In this situation, the
1827          * ServerKeyExchange message has: [1 byte CurveType], [2 byte CurveName]
1828          * [1 byte length of encoded point], followed by the actual encoded
1829          * point itself
1830          */
1831         if (!WPACKET_put_bytes_u8(pkt, NAMED_CURVE_TYPE)
1832                 || !WPACKET_put_bytes_u8(pkt, 0)
1833                 || !WPACKET_put_bytes_u8(pkt, curve_id)
1834                 || !WPACKET_sub_memcpy_u8(pkt, encodedPoint, encodedlen)) {
1835             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1836                    ERR_R_INTERNAL_ERROR);
1837             goto f_err;
1838         }
1839         OPENSSL_free(encodedPoint);
1840         encodedPoint = NULL;
1841     }
1842 #endif
1843
1844     /* not anonymous */
1845     if (pkey != NULL) {
1846         /*
1847          * n is the length of the params, they start at &(d[4]) and p
1848          * points to the space at the end.
1849          */
1850         if (md) {
1851             unsigned char *sigbytes1, *sigbytes2;
1852             unsigned int siglen;
1853
1854             /* Get length of the parameters we have written above */
1855             if (!WPACKET_get_length(pkt, &paramlen)) {
1856                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1857                        ERR_R_INTERNAL_ERROR);
1858                 goto f_err;
1859             }
1860             /* send signature algorithm */
1861             if (SSL_USE_SIGALGS(s)) {
1862                 if (!tls12_get_sigandhash(pkt, pkey, md)) {
1863                     /* Should never happen */
1864                     SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1865                            ERR_R_INTERNAL_ERROR);
1866                     goto f_err;
1867                 }
1868             }
1869 #ifdef SSL_DEBUG
1870             fprintf(stderr, "Using hash %s\n", EVP_MD_name(md));
1871 #endif
1872             /*
1873              * Create the signature. We don't know the actual length of the sig
1874              * until after we've created it, so we reserve enough bytes for it
1875              * up front, and then properly allocate them in the WPACKET
1876              * afterwards.
1877              */
1878             if (!WPACKET_sub_reserve_bytes_u16(pkt, EVP_PKEY_size(pkey),
1879                                                &sigbytes1)
1880                     || EVP_SignInit_ex(md_ctx, md, NULL) <= 0
1881                     || EVP_SignUpdate(md_ctx, &(s->s3->client_random[0]),
1882                                       SSL3_RANDOM_SIZE) <= 0
1883                     || EVP_SignUpdate(md_ctx, &(s->s3->server_random[0]),
1884                                       SSL3_RANDOM_SIZE) <= 0
1885                     || EVP_SignUpdate(md_ctx, s->init_buf->data + paramoffset,
1886                                       paramlen) <= 0
1887                     || EVP_SignFinal(md_ctx, sigbytes1, &siglen, pkey) <= 0
1888                     || !WPACKET_sub_allocate_bytes_u16(pkt, siglen, &sigbytes2)
1889                     || sigbytes1 != sigbytes2) {
1890                 SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1891                        ERR_R_INTERNAL_ERROR);
1892                 goto f_err;
1893             }
1894         } else {
1895             /* Is this error check actually needed? */
1896             al = SSL_AD_HANDSHAKE_FAILURE;
1897             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE,
1898                    SSL_R_UNKNOWN_PKEY_TYPE);
1899             goto f_err;
1900         }
1901     }
1902
1903     if (!ssl_close_construct_packet(s, pkt)) {
1904         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
1905         goto f_err;
1906     }
1907
1908     EVP_MD_CTX_free(md_ctx);
1909     return 1;
1910  f_err:
1911     ssl3_send_alert(s, SSL3_AL_FATAL, al);
1912  err:
1913 #ifndef OPENSSL_NO_DH
1914     EVP_PKEY_free(pkdh);
1915 #endif
1916 #ifndef OPENSSL_NO_EC
1917     OPENSSL_free(encodedPoint);
1918 #endif
1919     EVP_MD_CTX_free(md_ctx);
1920     return 0;
1921 }
1922
1923 int tls_construct_certificate_request(SSL *s, WPACKET *pkt)
1924 {
1925     int i, nl;
1926     STACK_OF(X509_NAME) *sk = NULL;
1927
1928     if (!ssl_set_handshake_header(s, pkt,
1929                                          SSL3_MT_CERTIFICATE_REQUEST)) {
1930         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
1931         goto err;
1932     }
1933
1934
1935     /* get the list of acceptable cert types */
1936     if (!WPACKET_start_sub_packet_u8(pkt)
1937             || !ssl3_get_req_cert_type(s, pkt)
1938             || !WPACKET_close(pkt)) {
1939         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
1940         goto err;
1941     }
1942
1943     if (SSL_USE_SIGALGS(s)) {
1944         const unsigned char *psigs;
1945         nl = tls12_get_psigalgs(s, &psigs);
1946         if (!WPACKET_start_sub_packet_u16(pkt)
1947                 || !tls12_copy_sigalgs(s, pkt, psigs, nl)
1948                 || !WPACKET_close(pkt)) {
1949             SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST,
1950                    ERR_R_INTERNAL_ERROR);
1951             goto err;
1952         }
1953     }
1954
1955     /* Start sub-packet for client CA list */
1956     if (!WPACKET_start_sub_packet_u16(pkt)) {
1957         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
1958         goto err;
1959     }
1960
1961     sk = SSL_get_client_CA_list(s);
1962     if (sk != NULL) {
1963         for (i = 0; i < sk_X509_NAME_num(sk); i++) {
1964             unsigned char *namebytes;
1965             X509_NAME *name = sk_X509_NAME_value(sk, i);
1966             int namelen;
1967
1968             if (name == NULL
1969                     || (namelen = i2d_X509_NAME(name, NULL)) < 0
1970                     || !WPACKET_sub_allocate_bytes_u16(pkt, namelen,
1971                                                        &namebytes)
1972                     || i2d_X509_NAME(name, &namebytes) != namelen) {
1973                 SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST,
1974                        ERR_R_INTERNAL_ERROR);
1975                 goto err;
1976             }
1977         }
1978     }
1979     /* else no CA names */
1980
1981     if (!WPACKET_close(pkt)
1982             || !ssl_close_construct_packet(s, pkt)) {
1983         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_REQUEST, ERR_R_INTERNAL_ERROR);
1984         goto err;
1985     }
1986
1987     s->s3->tmp.cert_request = 1;
1988
1989     return 1;
1990  err:
1991     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
1992     return 0;
1993 }
1994
1995 static int tls_process_cke_psk_preamble(SSL *s, PACKET *pkt, int *al)
1996 {
1997 #ifndef OPENSSL_NO_PSK
1998     unsigned char psk[PSK_MAX_PSK_LEN];
1999     size_t psklen;
2000     PACKET psk_identity;
2001
2002     if (!PACKET_get_length_prefixed_2(pkt, &psk_identity)) {
2003         *al = SSL_AD_DECODE_ERROR;
2004         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, SSL_R_LENGTH_MISMATCH);
2005         return 0;
2006     }
2007     if (PACKET_remaining(&psk_identity) > PSK_MAX_IDENTITY_LEN) {
2008         *al = SSL_AD_DECODE_ERROR;
2009         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, SSL_R_DATA_LENGTH_TOO_LONG);
2010         return 0;
2011     }
2012     if (s->psk_server_callback == NULL) {
2013         *al = SSL_AD_INTERNAL_ERROR;
2014         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, SSL_R_PSK_NO_SERVER_CB);
2015         return 0;
2016     }
2017
2018     if (!PACKET_strndup(&psk_identity, &s->session->psk_identity)) {
2019         *al = SSL_AD_INTERNAL_ERROR;
2020         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2021         return 0;
2022     }
2023
2024     psklen = s->psk_server_callback(s, s->session->psk_identity,
2025                                     psk, sizeof(psk));
2026
2027     if (psklen > PSK_MAX_PSK_LEN) {
2028         *al = SSL_AD_INTERNAL_ERROR;
2029         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2030         return 0;
2031     } else if (psklen == 0) {
2032         /*
2033          * PSK related to the given identity not found
2034          */
2035         *al = SSL_AD_UNKNOWN_PSK_IDENTITY;
2036         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE,
2037                SSL_R_PSK_IDENTITY_NOT_FOUND);
2038         return 0;
2039     }
2040
2041     OPENSSL_free(s->s3->tmp.psk);
2042     s->s3->tmp.psk = OPENSSL_memdup(psk, psklen);
2043     OPENSSL_cleanse(psk, psklen);
2044
2045     if (s->s3->tmp.psk == NULL) {
2046         *al = SSL_AD_INTERNAL_ERROR;
2047         SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_MALLOC_FAILURE);
2048         return 0;
2049     }
2050
2051     s->s3->tmp.psklen = psklen;
2052
2053     return 1;
2054 #else
2055     /* Should never happen */
2056     *al = SSL_AD_INTERNAL_ERROR;
2057     SSLerr(SSL_F_TLS_PROCESS_CKE_PSK_PREAMBLE, ERR_R_INTERNAL_ERROR);
2058     return 0;
2059 #endif
2060 }
2061
2062 static int tls_process_cke_rsa(SSL *s, PACKET *pkt, int *al)
2063 {
2064 #ifndef OPENSSL_NO_RSA
2065     unsigned char rand_premaster_secret[SSL_MAX_MASTER_KEY_LENGTH];
2066     int decrypt_len;
2067     unsigned char decrypt_good, version_good;
2068     size_t j, padding_len;
2069     PACKET enc_premaster;
2070     RSA *rsa = NULL;
2071     unsigned char *rsa_decrypt = NULL;
2072     int ret = 0;
2073
2074     rsa = EVP_PKEY_get0_RSA(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey);
2075     if (rsa == NULL) {
2076         *al = SSL_AD_HANDSHAKE_FAILURE;
2077         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, SSL_R_MISSING_RSA_CERTIFICATE);
2078         return 0;
2079     }
2080
2081     /* SSLv3 and pre-standard DTLS omit the length bytes. */
2082     if (s->version == SSL3_VERSION || s->version == DTLS1_BAD_VER) {
2083         enc_premaster = *pkt;
2084     } else {
2085         if (!PACKET_get_length_prefixed_2(pkt, &enc_premaster)
2086             || PACKET_remaining(pkt) != 0) {
2087             *al = SSL_AD_DECODE_ERROR;
2088             SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, SSL_R_LENGTH_MISMATCH);
2089             return 0;
2090         }
2091     }
2092
2093     /*
2094      * We want to be sure that the plaintext buffer size makes it safe to
2095      * iterate over the entire size of a premaster secret
2096      * (SSL_MAX_MASTER_KEY_LENGTH). Reject overly short RSA keys because
2097      * their ciphertext cannot accommodate a premaster secret anyway.
2098      */
2099     if (RSA_size(rsa) < SSL_MAX_MASTER_KEY_LENGTH) {
2100         *al = SSL_AD_INTERNAL_ERROR;
2101         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, RSA_R_KEY_SIZE_TOO_SMALL);
2102         return 0;
2103     }
2104
2105     rsa_decrypt = OPENSSL_malloc(RSA_size(rsa));
2106     if (rsa_decrypt == NULL) {
2107         *al = SSL_AD_INTERNAL_ERROR;
2108         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, ERR_R_MALLOC_FAILURE);
2109         return 0;
2110     }
2111
2112     /*
2113      * We must not leak whether a decryption failure occurs because of
2114      * Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see RFC 2246,
2115      * section 7.4.7.1). The code follows that advice of the TLS RFC and
2116      * generates a random premaster secret for the case that the decrypt
2117      * fails. See https://tools.ietf.org/html/rfc5246#section-7.4.7.1
2118      */
2119
2120     if (RAND_bytes(rand_premaster_secret, sizeof(rand_premaster_secret)) <= 0)
2121         goto err;
2122
2123     /*
2124      * Decrypt with no padding. PKCS#1 padding will be removed as part of
2125      * the timing-sensitive code below.
2126      */
2127     decrypt_len = RSA_private_decrypt(PACKET_remaining(&enc_premaster),
2128                                       PACKET_data(&enc_premaster),
2129                                       rsa_decrypt, rsa, RSA_NO_PADDING);
2130     if (decrypt_len < 0)
2131         goto err;
2132
2133     /* Check the padding. See RFC 3447, section 7.2.2. */
2134
2135     /*
2136      * The smallest padded premaster is 11 bytes of overhead. Small keys
2137      * are publicly invalid, so this may return immediately. This ensures
2138      * PS is at least 8 bytes.
2139      */
2140     if (decrypt_len < 11 + SSL_MAX_MASTER_KEY_LENGTH) {
2141         *al = SSL_AD_DECRYPT_ERROR;
2142         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, SSL_R_DECRYPTION_FAILED);
2143         goto err;
2144     }
2145
2146     padding_len = decrypt_len - SSL_MAX_MASTER_KEY_LENGTH;
2147     decrypt_good = constant_time_eq_int_8(rsa_decrypt[0], 0) &
2148         constant_time_eq_int_8(rsa_decrypt[1], 2);
2149     for (j = 2; j < padding_len - 1; j++) {
2150         decrypt_good &= ~constant_time_is_zero_8(rsa_decrypt[j]);
2151     }
2152     decrypt_good &= constant_time_is_zero_8(rsa_decrypt[padding_len - 1]);
2153
2154     /*
2155      * If the version in the decrypted pre-master secret is correct then
2156      * version_good will be 0xff, otherwise it'll be zero. The
2157      * Klima-Pokorny-Rosa extension of Bleichenbacher's attack
2158      * (http://eprint.iacr.org/2003/052/) exploits the version number
2159      * check as a "bad version oracle". Thus version checks are done in
2160      * constant time and are treated like any other decryption error.
2161      */
2162     version_good =
2163         constant_time_eq_8(rsa_decrypt[padding_len],
2164                            (unsigned)(s->client_version >> 8));
2165     version_good &=
2166         constant_time_eq_8(rsa_decrypt[padding_len + 1],
2167                            (unsigned)(s->client_version & 0xff));
2168
2169     /*
2170      * The premaster secret must contain the same version number as the
2171      * ClientHello to detect version rollback attacks (strangely, the
2172      * protocol does not offer such protection for DH ciphersuites).
2173      * However, buggy clients exist that send the negotiated protocol
2174      * version instead if the server does not support the requested
2175      * protocol version. If SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such
2176      * clients.
2177      */
2178     if (s->options & SSL_OP_TLS_ROLLBACK_BUG) {
2179         unsigned char workaround_good;
2180         workaround_good = constant_time_eq_8(rsa_decrypt[padding_len],
2181                                              (unsigned)(s->version >> 8));
2182         workaround_good &=
2183             constant_time_eq_8(rsa_decrypt[padding_len + 1],
2184                                (unsigned)(s->version & 0xff));
2185         version_good |= workaround_good;
2186     }
2187
2188     /*
2189      * Both decryption and version must be good for decrypt_good to
2190      * remain non-zero (0xff).
2191      */
2192     decrypt_good &= version_good;
2193
2194     /*
2195      * Now copy rand_premaster_secret over from p using
2196      * decrypt_good_mask. If decryption failed, then p does not
2197      * contain valid plaintext, however, a check above guarantees
2198      * it is still sufficiently large to read from.
2199      */
2200     for (j = 0; j < sizeof(rand_premaster_secret); j++) {
2201         rsa_decrypt[padding_len + j] =
2202             constant_time_select_8(decrypt_good,
2203                                    rsa_decrypt[padding_len + j],
2204                                    rand_premaster_secret[j]);
2205     }
2206
2207     if (!ssl_generate_master_secret(s, rsa_decrypt + padding_len,
2208                                     sizeof(rand_premaster_secret), 0)) {
2209         *al = SSL_AD_INTERNAL_ERROR;
2210         SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, ERR_R_INTERNAL_ERROR);
2211         goto err;
2212     }
2213
2214     ret = 1;
2215  err:
2216     OPENSSL_free(rsa_decrypt);
2217     return ret;
2218 #else
2219     /* Should never happen */
2220     *al = SSL_AD_INTERNAL_ERROR;
2221     SSLerr(SSL_F_TLS_PROCESS_CKE_RSA, ERR_R_INTERNAL_ERROR);
2222     return 0;
2223 #endif
2224 }
2225
2226 static int tls_process_cke_dhe(SSL *s, PACKET *pkt, int *al)
2227 {
2228 #ifndef OPENSSL_NO_DH
2229     EVP_PKEY *skey = NULL;
2230     DH *cdh;
2231     unsigned int i;
2232     BIGNUM *pub_key;
2233     const unsigned char *data;
2234     EVP_PKEY *ckey = NULL;
2235     int ret = 0;
2236
2237     if (!PACKET_get_net_2(pkt, &i) || PACKET_remaining(pkt) != i) {
2238         *al = SSL_AD_HANDSHAKE_FAILURE;
2239         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE,
2240                SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG);
2241         goto err;
2242     }
2243     skey = s->s3->tmp.pkey;
2244     if (skey == NULL) {
2245         *al = SSL_AD_HANDSHAKE_FAILURE;
2246         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, SSL_R_MISSING_TMP_DH_KEY);
2247         goto err;
2248     }
2249
2250     if (PACKET_remaining(pkt) == 0L) {
2251         *al = SSL_AD_HANDSHAKE_FAILURE;
2252         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, SSL_R_MISSING_TMP_DH_KEY);
2253         goto err;
2254     }
2255     if (!PACKET_get_bytes(pkt, &data, i)) {
2256         /* We already checked we have enough data */
2257         *al = SSL_AD_INTERNAL_ERROR;
2258         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, ERR_R_INTERNAL_ERROR);
2259         goto err;
2260     }
2261     ckey = EVP_PKEY_new();
2262     if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) == 0) {
2263         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, SSL_R_BN_LIB);
2264         goto err;
2265     }
2266     cdh = EVP_PKEY_get0_DH(ckey);
2267     pub_key = BN_bin2bn(data, i, NULL);
2268
2269     if (pub_key == NULL || !DH_set0_key(cdh, pub_key, NULL)) {
2270         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, ERR_R_INTERNAL_ERROR);
2271         if (pub_key != NULL)
2272             BN_free(pub_key);
2273         goto err;
2274     }
2275
2276     if (ssl_derive(s, skey, ckey) == 0) {
2277         *al = SSL_AD_INTERNAL_ERROR;
2278         SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, ERR_R_INTERNAL_ERROR);
2279         goto err;
2280     }
2281
2282     ret = 1;
2283     EVP_PKEY_free(s->s3->tmp.pkey);
2284     s->s3->tmp.pkey = NULL;
2285  err:
2286     EVP_PKEY_free(ckey);
2287     return ret;
2288 #else
2289     /* Should never happen */
2290     *al = SSL_AD_INTERNAL_ERROR;
2291     SSLerr(SSL_F_TLS_PROCESS_CKE_DHE, ERR_R_INTERNAL_ERROR);
2292     return 0;
2293 #endif
2294 }
2295
2296 static int tls_process_cke_ecdhe(SSL *s, PACKET *pkt, int *al)
2297 {
2298 #ifndef OPENSSL_NO_EC
2299     EVP_PKEY *skey = s->s3->tmp.pkey;
2300     EVP_PKEY *ckey = NULL;
2301     int ret = 0;
2302
2303     if (PACKET_remaining(pkt) == 0L) {
2304         /* We don't support ECDH client auth */
2305         *al = SSL_AD_HANDSHAKE_FAILURE;
2306         SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, SSL_R_MISSING_TMP_ECDH_KEY);
2307         goto err;
2308     } else {
2309         unsigned int i;
2310         const unsigned char *data;
2311
2312         /*
2313          * Get client's public key from encoded point in the
2314          * ClientKeyExchange message.
2315          */
2316
2317         /* Get encoded point length */
2318         if (!PACKET_get_1(pkt, &i) || !PACKET_get_bytes(pkt, &data, i)
2319             || PACKET_remaining(pkt) != 0) {
2320             *al = SSL_AD_DECODE_ERROR;
2321             SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, SSL_R_LENGTH_MISMATCH);
2322             goto err;
2323         }
2324         ckey = EVP_PKEY_new();
2325         if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) <= 0) {
2326             SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, ERR_R_EVP_LIB);
2327             goto err;
2328         }
2329         if (EVP_PKEY_set1_tls_encodedpoint(ckey, data, i) == 0) {
2330             *al = SSL_AD_HANDSHAKE_FAILURE;
2331             SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, ERR_R_EC_LIB);
2332             goto err;
2333         }
2334     }
2335
2336     if (ssl_derive(s, skey, ckey) == 0) {
2337         *al = SSL_AD_INTERNAL_ERROR;
2338         SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2339         goto err;
2340     }
2341
2342     ret = 1;
2343     EVP_PKEY_free(s->s3->tmp.pkey);
2344     s->s3->tmp.pkey = NULL;
2345  err:
2346     EVP_PKEY_free(ckey);
2347
2348     return ret;
2349 #else
2350     /* Should never happen */
2351     *al = SSL_AD_INTERNAL_ERROR;
2352     SSLerr(SSL_F_TLS_PROCESS_CKE_ECDHE, ERR_R_INTERNAL_ERROR);
2353     return 0;
2354 #endif
2355 }
2356
2357 static int tls_process_cke_srp(SSL *s, PACKET *pkt, int *al)
2358 {
2359 #ifndef OPENSSL_NO_SRP
2360     unsigned int i;
2361     const unsigned char *data;
2362
2363     if (!PACKET_get_net_2(pkt, &i)
2364         || !PACKET_get_bytes(pkt, &data, i)) {
2365         *al = SSL_AD_DECODE_ERROR;
2366         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, SSL_R_BAD_SRP_A_LENGTH);
2367         return 0;
2368     }
2369     if ((s->srp_ctx.A = BN_bin2bn(data, i, NULL)) == NULL) {
2370         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, ERR_R_BN_LIB);
2371         return 0;
2372     }
2373     if (BN_ucmp(s->srp_ctx.A, s->srp_ctx.N) >= 0 || BN_is_zero(s->srp_ctx.A)) {
2374         *al = SSL_AD_ILLEGAL_PARAMETER;
2375         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, SSL_R_BAD_SRP_PARAMETERS);
2376         return 0;
2377     }
2378     OPENSSL_free(s->session->srp_username);
2379     s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
2380     if (s->session->srp_username == NULL) {
2381         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, ERR_R_MALLOC_FAILURE);
2382         return 0;
2383     }
2384
2385     if (!srp_generate_server_master_secret(s)) {
2386         SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, ERR_R_INTERNAL_ERROR);
2387         return 0;
2388     }
2389
2390     return 1;
2391 #else
2392     /* Should never happen */
2393     *al = SSL_AD_INTERNAL_ERROR;
2394     SSLerr(SSL_F_TLS_PROCESS_CKE_SRP, ERR_R_INTERNAL_ERROR);
2395     return 0;
2396 #endif
2397 }
2398
2399 static int tls_process_cke_gost(SSL *s, PACKET *pkt, int *al)
2400 {
2401 #ifndef OPENSSL_NO_GOST
2402     EVP_PKEY_CTX *pkey_ctx;
2403     EVP_PKEY *client_pub_pkey = NULL, *pk = NULL;
2404     unsigned char premaster_secret[32];
2405     const unsigned char *start;
2406     size_t outlen = 32, inlen;
2407     unsigned long alg_a;
2408     int Ttag, Tclass;
2409     long Tlen;
2410     long sess_key_len;
2411     const unsigned char *data;
2412     int ret = 0;
2413
2414     /* Get our certificate private key */
2415     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2416     if (alg_a & SSL_aGOST12) {
2417         /*
2418          * New GOST ciphersuites have SSL_aGOST01 bit too
2419          */
2420         pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey;
2421         if (pk == NULL) {
2422             pk = s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey;
2423         }
2424         if (pk == NULL) {
2425             pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
2426         }
2427     } else if (alg_a & SSL_aGOST01) {
2428         pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
2429     }
2430
2431     pkey_ctx = EVP_PKEY_CTX_new(pk, NULL);
2432     if (pkey_ctx == NULL) {
2433         *al = SSL_AD_INTERNAL_ERROR;
2434         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_MALLOC_FAILURE);
2435         return 0;
2436     }
2437     if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) {
2438         *al = SSL_AD_INTERNAL_ERROR;
2439         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_INTERNAL_ERROR);
2440         return 0;
2441     }
2442     /*
2443      * If client certificate is present and is of the same type, maybe
2444      * use it for key exchange.  Don't mind errors from
2445      * EVP_PKEY_derive_set_peer, because it is completely valid to use a
2446      * client certificate for authorization only.
2447      */
2448     client_pub_pkey = X509_get0_pubkey(s->session->peer);
2449     if (client_pub_pkey) {
2450         if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0)
2451             ERR_clear_error();
2452     }
2453     /* Decrypt session key */
2454     sess_key_len = PACKET_remaining(pkt);
2455     if (!PACKET_get_bytes(pkt, &data, sess_key_len)) {
2456         *al = SSL_AD_INTERNAL_ERROR;
2457         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_INTERNAL_ERROR);
2458         goto err;
2459     }
2460     if (ASN1_get_object((const unsigned char **)&data, &Tlen, &Ttag,
2461                         &Tclass, sess_key_len) != V_ASN1_CONSTRUCTED
2462         || Ttag != V_ASN1_SEQUENCE || Tclass != V_ASN1_UNIVERSAL) {
2463         *al = SSL_AD_DECODE_ERROR;
2464         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, SSL_R_DECRYPTION_FAILED);
2465         goto err;
2466     }
2467     start = data;
2468     inlen = Tlen;
2469     if (EVP_PKEY_decrypt
2470         (pkey_ctx, premaster_secret, &outlen, start, inlen) <= 0) {
2471         *al = SSL_AD_DECODE_ERROR;
2472         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, SSL_R_DECRYPTION_FAILED);
2473         goto err;
2474     }
2475     /* Generate master secret */
2476     if (!ssl_generate_master_secret(s, premaster_secret,
2477                                     sizeof(premaster_secret), 0)) {
2478         *al = SSL_AD_INTERNAL_ERROR;
2479         SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_INTERNAL_ERROR);
2480         goto err;
2481     }
2482     /* Check if pubkey from client certificate was used */
2483     if (EVP_PKEY_CTX_ctrl
2484         (pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0)
2485         s->statem.no_cert_verify = 1;
2486
2487     ret = 1;
2488  err:
2489     EVP_PKEY_CTX_free(pkey_ctx);
2490     return ret;
2491 #else
2492     /* Should never happen */
2493     *al = SSL_AD_INTERNAL_ERROR;
2494     SSLerr(SSL_F_TLS_PROCESS_CKE_GOST, ERR_R_INTERNAL_ERROR);
2495     return 0;
2496 #endif
2497 }
2498
2499 MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL *s, PACKET *pkt)
2500 {
2501     int al = -1;
2502     unsigned long alg_k;
2503
2504     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2505
2506     /* For PSK parse and retrieve identity, obtain PSK key */
2507     if ((alg_k & SSL_PSK) && !tls_process_cke_psk_preamble(s, pkt, &al))
2508         goto err;
2509
2510     if (alg_k & SSL_kPSK) {
2511         /* Identity extracted earlier: should be nothing left */
2512         if (PACKET_remaining(pkt) != 0) {
2513             al = SSL_AD_HANDSHAKE_FAILURE;
2514             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2515                    SSL_R_LENGTH_MISMATCH);
2516             goto err;
2517         }
2518         /* PSK handled by ssl_generate_master_secret */
2519         if (!ssl_generate_master_secret(s, NULL, 0, 0)) {
2520             al = SSL_AD_INTERNAL_ERROR;
2521             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2522             goto err;
2523         }
2524     } else if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
2525         if (!tls_process_cke_rsa(s, pkt, &al))
2526             goto err;
2527     } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
2528         if (!tls_process_cke_dhe(s, pkt, &al))
2529             goto err;
2530     } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) {
2531         if (!tls_process_cke_ecdhe(s, pkt, &al))
2532             goto err;
2533     } else if (alg_k & SSL_kSRP) {
2534         if (!tls_process_cke_srp(s, pkt, &al))
2535             goto err;
2536     } else if (alg_k & SSL_kGOST) {
2537         if (!tls_process_cke_gost(s, pkt, &al))
2538             goto err;
2539     } else {
2540         al = SSL_AD_HANDSHAKE_FAILURE;
2541         SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2542                SSL_R_UNKNOWN_CIPHER_TYPE);
2543         goto err;
2544     }
2545
2546     return MSG_PROCESS_CONTINUE_PROCESSING;
2547  err:
2548     if (al != -1)
2549         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2550 #ifndef OPENSSL_NO_PSK
2551     OPENSSL_clear_free(s->s3->tmp.psk, s->s3->tmp.psklen);
2552     s->s3->tmp.psk = NULL;
2553 #endif
2554     ossl_statem_set_error(s);
2555     return MSG_PROCESS_ERROR;
2556 }
2557
2558 WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst)
2559 {
2560 #ifndef OPENSSL_NO_SCTP
2561     if (wst == WORK_MORE_A) {
2562         if (SSL_IS_DTLS(s)) {
2563             unsigned char sctpauthkey[64];
2564             char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
2565             /*
2566              * Add new shared key for SCTP-Auth, will be ignored if no SCTP
2567              * used.
2568              */
2569             memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
2570                    sizeof(DTLS1_SCTP_AUTH_LABEL));
2571
2572             if (SSL_export_keying_material(s, sctpauthkey,
2573                                            sizeof(sctpauthkey), labelbuffer,
2574                                            sizeof(labelbuffer), NULL, 0,
2575                                            0) <= 0) {
2576                 ossl_statem_set_error(s);
2577                 return WORK_ERROR;;
2578             }
2579
2580             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
2581                      sizeof(sctpauthkey), sctpauthkey);
2582         }
2583         wst = WORK_MORE_B;
2584     }
2585
2586     if ((wst == WORK_MORE_B)
2587         /* Is this SCTP? */
2588         && BIO_dgram_is_sctp(SSL_get_wbio(s))
2589         /* Are we renegotiating? */
2590         && s->renegotiate
2591         /* Are we going to skip the CertificateVerify? */
2592         && (s->session->peer == NULL || s->statem.no_cert_verify)
2593         && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) {
2594         s->s3->in_read_app_data = 2;
2595         s->rwstate = SSL_READING;
2596         BIO_clear_retry_flags(SSL_get_rbio(s));
2597         BIO_set_retry_read(SSL_get_rbio(s));
2598         ossl_statem_set_sctp_read_sock(s, 1);
2599         return WORK_MORE_B;
2600     } else {
2601         ossl_statem_set_sctp_read_sock(s, 0);
2602     }
2603 #endif
2604
2605     if (s->statem.no_cert_verify || !s->session->peer) {
2606         /*
2607          * No certificate verify or no peer certificate so we no longer need
2608          * the handshake_buffer
2609          */
2610         if (!ssl3_digest_cached_records(s, 0)) {
2611             ossl_statem_set_error(s);
2612             return WORK_ERROR;
2613         }
2614         return WORK_FINISHED_CONTINUE;
2615     } else {
2616         if (!s->s3->handshake_buffer) {
2617             SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE,
2618                    ERR_R_INTERNAL_ERROR);
2619             ossl_statem_set_error(s);
2620             return WORK_ERROR;
2621         }
2622         /*
2623          * For sigalgs freeze the handshake buffer. If we support
2624          * extms we've done this already so this is a no-op
2625          */
2626         if (!ssl3_digest_cached_records(s, 1)) {
2627             ossl_statem_set_error(s);
2628             return WORK_ERROR;
2629         }
2630     }
2631
2632     return WORK_FINISHED_CONTINUE;
2633 }
2634
2635 MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
2636 {
2637     EVP_PKEY *pkey = NULL;
2638     const unsigned char *sig, *data;
2639 #ifndef OPENSSL_NO_GOST
2640     unsigned char *gost_data = NULL;
2641 #endif
2642     int al, ret = MSG_PROCESS_ERROR;
2643     int type = 0, j;
2644     unsigned int len;
2645     X509 *peer;
2646     const EVP_MD *md = NULL;
2647     long hdatalen = 0;
2648     void *hdata;
2649
2650     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
2651
2652     if (mctx == NULL) {
2653         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
2654         al = SSL_AD_INTERNAL_ERROR;
2655         goto f_err;
2656     }
2657
2658     peer = s->session->peer;
2659     pkey = X509_get0_pubkey(peer);
2660     type = X509_certificate_type(peer, pkey);
2661
2662     if (!(type & EVP_PKT_SIGN)) {
2663         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY,
2664                SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
2665         al = SSL_AD_ILLEGAL_PARAMETER;
2666         goto f_err;
2667     }
2668
2669     /* Check for broken implementations of GOST ciphersuites */
2670     /*
2671      * If key is GOST and n is exactly 64, it is bare signature without
2672      * length field (CryptoPro implementations at least till CSP 4.0)
2673      */
2674 #ifndef OPENSSL_NO_GOST
2675     if (PACKET_remaining(pkt) == 64
2676         && EVP_PKEY_id(pkey) == NID_id_GostR3410_2001) {
2677         len = 64;
2678     } else
2679 #endif
2680     {
2681         if (SSL_USE_SIGALGS(s)) {
2682             int rv;
2683
2684             if (!PACKET_get_bytes(pkt, &sig, 2)) {
2685                 al = SSL_AD_DECODE_ERROR;
2686                 goto f_err;
2687             }
2688             rv = tls12_check_peer_sigalg(&md, s, sig, pkey);
2689             if (rv == -1) {
2690                 al = SSL_AD_INTERNAL_ERROR;
2691                 goto f_err;
2692             } else if (rv == 0) {
2693                 al = SSL_AD_DECODE_ERROR;
2694                 goto f_err;
2695             }
2696 #ifdef SSL_DEBUG
2697             fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
2698 #endif
2699         } else {
2700             /* Use default digest for this key type */
2701             int idx = ssl_cert_type(NULL, pkey);
2702             if (idx >= 0)
2703                 md = s->s3->tmp.md[idx];
2704             if (md == NULL) {
2705                 al = SSL_AD_INTERNAL_ERROR;
2706                 goto f_err;
2707             }
2708         }
2709
2710         if (!PACKET_get_net_2(pkt, &len)) {
2711             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
2712             al = SSL_AD_DECODE_ERROR;
2713             goto f_err;
2714         }
2715     }
2716     j = EVP_PKEY_size(pkey);
2717     if (((int)len > j) || ((int)PACKET_remaining(pkt) > j)
2718         || (PACKET_remaining(pkt) == 0)) {
2719         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_WRONG_SIGNATURE_SIZE);
2720         al = SSL_AD_DECODE_ERROR;
2721         goto f_err;
2722     }
2723     if (!PACKET_get_bytes(pkt, &data, len)) {
2724         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
2725         al = SSL_AD_DECODE_ERROR;
2726         goto f_err;
2727     }
2728
2729     hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
2730     if (hdatalen <= 0) {
2731         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
2732         al = SSL_AD_INTERNAL_ERROR;
2733         goto f_err;
2734     }
2735 #ifdef SSL_DEBUG
2736     fprintf(stderr, "Using client verify alg %s\n", EVP_MD_name(md));
2737 #endif
2738     if (!EVP_VerifyInit_ex(mctx, md, NULL)
2739         || !EVP_VerifyUpdate(mctx, hdata, hdatalen)) {
2740         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
2741         al = SSL_AD_INTERNAL_ERROR;
2742         goto f_err;
2743     }
2744 #ifndef OPENSSL_NO_GOST
2745     {
2746         int pktype = EVP_PKEY_id(pkey);
2747         if (pktype == NID_id_GostR3410_2001
2748             || pktype == NID_id_GostR3410_2012_256
2749             || pktype == NID_id_GostR3410_2012_512) {
2750             if ((gost_data = OPENSSL_malloc(len)) == NULL) {
2751                 SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
2752                 al = SSL_AD_INTERNAL_ERROR;
2753                 goto f_err;
2754             }
2755             BUF_reverse(gost_data, data, len);
2756             data = gost_data;
2757         }
2758     }
2759 #endif
2760
2761     if (s->version == SSL3_VERSION
2762         && !EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
2763                             s->session->master_key_length,
2764                             s->session->master_key)) {
2765         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
2766         al = SSL_AD_INTERNAL_ERROR;
2767         goto f_err;
2768     }
2769
2770     if (EVP_VerifyFinal(mctx, data, len, pkey) <= 0) {
2771         al = SSL_AD_DECRYPT_ERROR;
2772         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_SIGNATURE);
2773         goto f_err;
2774     }
2775
2776     ret = MSG_PROCESS_CONTINUE_PROCESSING;
2777     if (0) {
2778  f_err:
2779         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2780         ossl_statem_set_error(s);
2781     }
2782     BIO_free(s->s3->handshake_buffer);
2783     s->s3->handshake_buffer = NULL;
2784     EVP_MD_CTX_free(mctx);
2785 #ifndef OPENSSL_NO_GOST
2786     OPENSSL_free(gost_data);
2787 #endif
2788     return ret;
2789 }
2790
2791 MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt)
2792 {
2793     int i, al = SSL_AD_INTERNAL_ERROR, ret = MSG_PROCESS_ERROR;
2794     X509 *x = NULL;
2795     unsigned long l, llen;
2796     const unsigned char *certstart, *certbytes;
2797     STACK_OF(X509) *sk = NULL;
2798     PACKET spkt;
2799
2800     if ((sk = sk_X509_new_null()) == NULL) {
2801         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
2802         goto f_err;
2803     }
2804
2805     if (!PACKET_get_net_3(pkt, &llen)
2806         || !PACKET_get_sub_packet(pkt, &spkt, llen)
2807         || PACKET_remaining(pkt) != 0) {
2808         al = SSL_AD_DECODE_ERROR;
2809         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
2810         goto f_err;
2811     }
2812
2813     while (PACKET_remaining(&spkt) > 0) {
2814         if (!PACKET_get_net_3(&spkt, &l)
2815             || !PACKET_get_bytes(&spkt, &certbytes, l)) {
2816             al = SSL_AD_DECODE_ERROR;
2817             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2818                    SSL_R_CERT_LENGTH_MISMATCH);
2819             goto f_err;
2820         }
2821
2822         certstart = certbytes;
2823         x = d2i_X509(NULL, (const unsigned char **)&certbytes, l);
2824         if (x == NULL) {
2825             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_ASN1_LIB);
2826             goto f_err;
2827         }
2828         if (certbytes != (certstart + l)) {
2829             al = SSL_AD_DECODE_ERROR;
2830             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2831                    SSL_R_CERT_LENGTH_MISMATCH);
2832             goto f_err;
2833         }
2834         if (!sk_X509_push(sk, x)) {
2835             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
2836             goto f_err;
2837         }
2838         x = NULL;
2839     }
2840
2841     if (sk_X509_num(sk) <= 0) {
2842         /* TLS does not mind 0 certs returned */
2843         if (s->version == SSL3_VERSION) {
2844             al = SSL_AD_HANDSHAKE_FAILURE;
2845             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2846                    SSL_R_NO_CERTIFICATES_RETURNED);
2847             goto f_err;
2848         }
2849         /* Fail for TLS only if we required a certificate */
2850         else if ((s->verify_mode & SSL_VERIFY_PEER) &&
2851                  (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
2852             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2853                    SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
2854             al = SSL_AD_HANDSHAKE_FAILURE;
2855             goto f_err;
2856         }
2857         /* No client certificate so digest cached records */
2858         if (s->s3->handshake_buffer && !ssl3_digest_cached_records(s, 0)) {
2859             goto f_err;
2860         }
2861     } else {
2862         EVP_PKEY *pkey;
2863         i = ssl_verify_cert_chain(s, sk);
2864         if (i <= 0) {
2865             al = ssl_verify_alarm_type(s->verify_result);
2866             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2867                    SSL_R_CERTIFICATE_VERIFY_FAILED);
2868             goto f_err;
2869         }
2870         if (i > 1) {
2871             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, i);
2872             al = SSL_AD_HANDSHAKE_FAILURE;
2873             goto f_err;
2874         }
2875         pkey = X509_get0_pubkey(sk_X509_value(sk, 0));
2876         if (pkey == NULL) {
2877             al = SSL3_AD_HANDSHAKE_FAILURE;
2878             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2879                    SSL_R_UNKNOWN_CERTIFICATE_TYPE);
2880             goto f_err;
2881         }
2882     }
2883
2884     X509_free(s->session->peer);
2885     s->session->peer = sk_X509_shift(sk);
2886     s->session->verify_result = s->verify_result;
2887
2888     sk_X509_pop_free(s->session->peer_chain, X509_free);
2889     s->session->peer_chain = sk;
2890     /*
2891      * Inconsistency alert: cert_chain does *not* include the peer's own
2892      * certificate, while we do include it in statem_clnt.c
2893      */
2894     sk = NULL;
2895     ret = MSG_PROCESS_CONTINUE_READING;
2896     goto done;
2897
2898  f_err:
2899     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2900     ossl_statem_set_error(s);
2901  done:
2902     X509_free(x);
2903     sk_X509_pop_free(sk, X509_free);
2904     return ret;
2905 }
2906
2907 int tls_construct_server_certificate(SSL *s, WPACKET *pkt)
2908 {
2909     CERT_PKEY *cpk;
2910
2911     cpk = ssl_get_server_send_pkey(s);
2912     if (cpk == NULL) {
2913         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
2914         return 0;
2915     }
2916
2917     if (!ssl3_output_cert_chain(s, pkt, cpk)) {
2918         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
2919         return 0;
2920     }
2921
2922     return 1;
2923 }
2924
2925 int tls_construct_new_session_ticket(SSL *s, WPACKET *pkt)
2926 {
2927     unsigned char *senc = NULL;
2928     EVP_CIPHER_CTX *ctx = NULL;
2929     HMAC_CTX *hctx = NULL;
2930     unsigned char *p, *encdata1, *encdata2, *macdata1, *macdata2;
2931     const unsigned char *const_p;
2932     int len, slen_full, slen, lenfinal;
2933     SSL_SESSION *sess;
2934     unsigned int hlen;
2935     SSL_CTX *tctx = s->initial_ctx;
2936     unsigned char iv[EVP_MAX_IV_LENGTH];
2937     unsigned char key_name[TLSEXT_KEYNAME_LENGTH];
2938     int iv_len;
2939     size_t macoffset, macendoffset;
2940
2941     /* get session encoding length */
2942     slen_full = i2d_SSL_SESSION(s->session, NULL);
2943     /*
2944      * Some length values are 16 bits, so forget it if session is too
2945      * long
2946      */
2947     if (slen_full == 0 || slen_full > 0xFF00) {
2948         ossl_statem_set_error(s);
2949         return 0;
2950     }
2951     senc = OPENSSL_malloc(slen_full);
2952     if (senc == NULL) {
2953         ossl_statem_set_error(s);
2954         return 0;
2955     }
2956
2957     if (!ssl_set_handshake_header(s, pkt, SSL3_MT_NEWSESSION_TICKET)) {
2958         SSLerr(SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
2959         goto err;
2960     }
2961
2962     ctx = EVP_CIPHER_CTX_new();
2963     hctx = HMAC_CTX_new();
2964     if (ctx == NULL || hctx == NULL) {
2965         SSLerr(SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET, ERR_R_MALLOC_FAILURE);
2966         goto err;
2967     }
2968
2969     p = senc;
2970     if (!i2d_SSL_SESSION(s->session, &p))
2971         goto err;
2972
2973     /*
2974      * create a fresh copy (not shared with other threads) to clean up
2975      */
2976     const_p = senc;
2977     sess = d2i_SSL_SESSION(NULL, &const_p, slen_full);
2978     if (sess == NULL)
2979         goto err;
2980     sess->session_id_length = 0; /* ID is irrelevant for the ticket */
2981
2982     slen = i2d_SSL_SESSION(sess, NULL);
2983     if (slen == 0 || slen > slen_full) { /* shouldn't ever happen */
2984         SSL_SESSION_free(sess);
2985         goto err;
2986     }
2987     p = senc;
2988     if (!i2d_SSL_SESSION(sess, &p)) {
2989         SSL_SESSION_free(sess);
2990         goto err;
2991     }
2992     SSL_SESSION_free(sess);
2993
2994     /*
2995      * Initialize HMAC and cipher contexts. If callback present it does
2996      * all the work otherwise use generated values from parent ctx.
2997      */
2998     if (tctx->tlsext_ticket_key_cb) {
2999         /* if 0 is returned, write an empty ticket */
3000         int ret = tctx->tlsext_ticket_key_cb(s, key_name, iv, ctx,
3001                                              hctx, 1);
3002
3003         if (ret == 0) {
3004
3005             /* Put timeout and length */
3006             if (!WPACKET_put_bytes_u32(pkt, 0)
3007                     || !WPACKET_put_bytes_u16(pkt, 0)
3008                     || !ssl_close_construct_packet(s, pkt)) {
3009                 SSLerr(SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET,
3010                        ERR_R_INTERNAL_ERROR);
3011                 goto err;
3012             }
3013             OPENSSL_free(senc);
3014             EVP_CIPHER_CTX_free(ctx);
3015             HMAC_CTX_free(hctx);
3016             return 1;
3017         }
3018         if (ret < 0)
3019             goto err;
3020         iv_len = EVP_CIPHER_CTX_iv_length(ctx);
3021     } else {
3022         const EVP_CIPHER *cipher = EVP_aes_256_cbc();
3023
3024         iv_len = EVP_CIPHER_iv_length(cipher);
3025         if (RAND_bytes(iv, iv_len) <= 0)
3026             goto err;
3027         if (!EVP_EncryptInit_ex(ctx, cipher, NULL,
3028                                 tctx->tlsext_tick_aes_key, iv))
3029             goto err;
3030         if (!HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key,
3031                           sizeof(tctx->tlsext_tick_hmac_key),
3032                           EVP_sha256(), NULL))
3033             goto err;
3034         memcpy(key_name, tctx->tlsext_tick_key_name,
3035                sizeof(tctx->tlsext_tick_key_name));
3036     }
3037
3038     /*
3039      * Ticket lifetime hint (advisory only): We leave this unspecified
3040      * for resumed session (for simplicity), and guess that tickets for
3041      * new sessions will live as long as their sessions.
3042      */
3043     if (!WPACKET_put_bytes_u32(pkt, s->hit ? 0 : s->session->timeout)
3044                /* Now the actual ticket data */
3045             || !WPACKET_start_sub_packet_u16(pkt)
3046             || !WPACKET_get_total_written(pkt, &macoffset)
3047                /* Output key name */
3048             || !WPACKET_memcpy(pkt, key_name, sizeof(key_name))
3049                /* output IV */
3050             || !WPACKET_memcpy(pkt, iv, iv_len)
3051             || !WPACKET_reserve_bytes(pkt, slen + EVP_MAX_BLOCK_LENGTH,
3052                                       &encdata1)
3053                /* Encrypt session data */
3054             || !EVP_EncryptUpdate(ctx, encdata1, &len, senc, slen)
3055             || !WPACKET_allocate_bytes(pkt, len, &encdata2)
3056             || encdata1 != encdata2
3057             || !EVP_EncryptFinal(ctx, encdata1 + len, &lenfinal)
3058             || !WPACKET_allocate_bytes(pkt, lenfinal, &encdata2)
3059             || encdata1 + len != encdata2
3060             || len + lenfinal > slen + EVP_MAX_BLOCK_LENGTH
3061             || !WPACKET_get_total_written(pkt, &macendoffset)
3062             || !HMAC_Update(hctx,
3063                             (unsigned char *)s->init_buf->data + macoffset,
3064                             macendoffset - macoffset)
3065             || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &macdata1)
3066             || !HMAC_Final(hctx, macdata1, &hlen)
3067             || hlen > EVP_MAX_MD_SIZE
3068             || !WPACKET_allocate_bytes(pkt, hlen, &macdata2)
3069             || macdata1 != macdata2
3070             || !WPACKET_close(pkt)
3071             || !ssl_close_construct_packet(s, pkt)) {
3072         SSLerr(SSL_F_TLS_CONSTRUCT_NEW_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
3073         goto err;
3074     }
3075     EVP_CIPHER_CTX_free(ctx);
3076     HMAC_CTX_free(hctx);
3077     OPENSSL_free(senc);
3078
3079     return 1;
3080  err:
3081     OPENSSL_free(senc);
3082     EVP_CIPHER_CTX_free(ctx);
3083     HMAC_CTX_free(hctx);
3084     ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3085     return 0;
3086 }
3087
3088 int tls_construct_cert_status(SSL *s, WPACKET *pkt)
3089 {
3090     if (!ssl_set_handshake_header(s, pkt, SSL3_MT_CERTIFICATE_STATUS)
3091             || !WPACKET_put_bytes_u8(pkt, s->tlsext_status_type)
3092             || !WPACKET_sub_memcpy_u24(pkt, s->tlsext_ocsp_resp,
3093                                        s->tlsext_ocsp_resplen)
3094             || !ssl_close_construct_packet(s, pkt)) {
3095         SSLerr(SSL_F_TLS_CONSTRUCT_CERT_STATUS, ERR_R_INTERNAL_ERROR);
3096         ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
3097         return 0;
3098     }
3099
3100     return 1;
3101 }
3102
3103 #ifndef OPENSSL_NO_NEXTPROTONEG
3104 /*
3105  * tls_process_next_proto reads a Next Protocol Negotiation handshake message.
3106  * It sets the next_proto member in s if found
3107  */
3108 MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt)
3109 {
3110     PACKET next_proto, padding;
3111     size_t next_proto_len;
3112
3113     /*-
3114      * The payload looks like:
3115      *   uint8 proto_len;
3116      *   uint8 proto[proto_len];
3117      *   uint8 padding_len;
3118      *   uint8 padding[padding_len];
3119      */
3120     if (!PACKET_get_length_prefixed_1(pkt, &next_proto)
3121         || !PACKET_get_length_prefixed_1(pkt, &padding)
3122         || PACKET_remaining(pkt) > 0) {
3123         SSLerr(SSL_F_TLS_PROCESS_NEXT_PROTO, SSL_R_LENGTH_MISMATCH);
3124         goto err;
3125     }
3126
3127     if (!PACKET_memdup(&next_proto, &s->next_proto_negotiated, &next_proto_len)) {
3128         s->next_proto_negotiated_len = 0;
3129         goto err;
3130     }
3131
3132     s->next_proto_negotiated_len = (unsigned char)next_proto_len;
3133
3134     return MSG_PROCESS_CONTINUE_READING;
3135  err:
3136     ossl_statem_set_error(s);
3137     return MSG_PROCESS_ERROR;
3138 }
3139 #endif
3140
3141 #define SSLV2_CIPHER_LEN    3
3142
3143 STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,
3144                                                PACKET *cipher_suites,
3145                                                STACK_OF(SSL_CIPHER) **skp,
3146                                                int sslv2format, int *al)
3147 {
3148     const SSL_CIPHER *c;
3149     STACK_OF(SSL_CIPHER) *sk;
3150     int n;
3151     /* 3 = SSLV2_CIPHER_LEN > TLS_CIPHER_LEN = 2. */
3152     unsigned char cipher[SSLV2_CIPHER_LEN];
3153
3154     s->s3->send_connection_binding = 0;
3155
3156     n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN;
3157
3158     if (PACKET_remaining(cipher_suites) == 0) {
3159         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, SSL_R_NO_CIPHERS_SPECIFIED);
3160         *al = SSL_AD_ILLEGAL_PARAMETER;
3161         return NULL;
3162     }
3163
3164     if (PACKET_remaining(cipher_suites) % n != 0) {
3165         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3166                SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
3167         *al = SSL_AD_DECODE_ERROR;
3168         return NULL;
3169     }
3170
3171     if ((skp == NULL) || (*skp == NULL)) {
3172         sk = sk_SSL_CIPHER_new_null(); /* change perhaps later */
3173         if (sk == NULL) {
3174             SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
3175             *al = SSL_AD_INTERNAL_ERROR;
3176             return NULL;
3177         }
3178     } else {
3179         sk = *skp;
3180         sk_SSL_CIPHER_zero(sk);
3181     }
3182
3183     if (!PACKET_memdup(cipher_suites, &s->s3->tmp.ciphers_raw,
3184                        &s->s3->tmp.ciphers_rawlen)) {
3185         *al = SSL_AD_INTERNAL_ERROR;
3186         goto err;
3187     }
3188
3189     while (PACKET_copy_bytes(cipher_suites, cipher, n)) {
3190         /*
3191          * SSLv3 ciphers wrapped in an SSLv2-compatible ClientHello have the
3192          * first byte set to zero, while true SSLv2 ciphers have a non-zero
3193          * first byte. We don't support any true SSLv2 ciphers, so skip them.
3194          */
3195         if (sslv2format && cipher[0] != '\0')
3196             continue;
3197
3198         /* Check for TLS_EMPTY_RENEGOTIATION_INFO_SCSV */
3199         if ((cipher[n - 2] == ((SSL3_CK_SCSV >> 8) & 0xff)) &&
3200             (cipher[n - 1] == (SSL3_CK_SCSV & 0xff))) {
3201             /* SCSV fatal if renegotiating */
3202             if (s->renegotiate) {
3203                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3204                        SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
3205                 *al = SSL_AD_HANDSHAKE_FAILURE;
3206                 goto err;
3207             }
3208             s->s3->send_connection_binding = 1;
3209             continue;
3210         }
3211
3212         /* Check for TLS_FALLBACK_SCSV */
3213         if ((cipher[n - 2] == ((SSL3_CK_FALLBACK_SCSV >> 8) & 0xff)) &&
3214             (cipher[n - 1] == (SSL3_CK_FALLBACK_SCSV & 0xff))) {
3215             /*
3216              * The SCSV indicates that the client previously tried a higher
3217              * version. Fail if the current version is an unexpected
3218              * downgrade.
3219              */
3220             if (!ssl_check_version_downgrade(s)) {
3221                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3222                        SSL_R_INAPPROPRIATE_FALLBACK);
3223                 *al = SSL_AD_INAPPROPRIATE_FALLBACK;
3224                 goto err;
3225             }
3226             continue;
3227         }
3228
3229         /* For SSLv2-compat, ignore leading 0-byte. */
3230         c = ssl_get_cipher_by_char(s, sslv2format ? &cipher[1] : cipher);
3231         if (c != NULL) {
3232             if (!sk_SSL_CIPHER_push(sk, c)) {
3233                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
3234                 *al = SSL_AD_INTERNAL_ERROR;
3235                 goto err;
3236             }
3237         }
3238     }
3239     if (PACKET_remaining(cipher_suites) > 0) {
3240         *al = SSL_AD_INTERNAL_ERROR;
3241         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_INTERNAL_ERROR);
3242         goto err;
3243     }
3244
3245     if (skp != NULL)
3246         *skp = sk;
3247     return (sk);
3248  err:
3249     if ((skp == NULL) || (*skp == NULL))
3250         sk_SSL_CIPHER_free(sk);
3251     return NULL;
3252 }