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