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