Fix no-gost no-srp no-ec no-dh.
[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     unsigned char *rsa_decrypt = NULL;
2083
2084     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2085
2086 #ifndef OPENSSL_NO_PSK
2087     /* For PSK parse and retrieve identity, obtain PSK key */
2088     if (alg_k & SSL_PSK) {
2089         unsigned char psk[PSK_MAX_PSK_LEN];
2090         size_t psklen;
2091         PACKET psk_identity;
2092
2093         if (!PACKET_get_length_prefixed_2(pkt, &psk_identity)) {
2094             al = SSL_AD_DECODE_ERROR;
2095             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
2096             goto f_err;
2097         }
2098         if (PACKET_remaining(&psk_identity) > PSK_MAX_IDENTITY_LEN) {
2099             al = SSL_AD_DECODE_ERROR;
2100             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2101                    SSL_R_DATA_LENGTH_TOO_LONG);
2102             goto f_err;
2103         }
2104         if (s->psk_server_callback == NULL) {
2105             al = SSL_AD_INTERNAL_ERROR;
2106             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2107                    SSL_R_PSK_NO_SERVER_CB);
2108             goto f_err;
2109         }
2110
2111         if (!PACKET_strndup(&psk_identity, &s->session->psk_identity)) {
2112             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2113             al = SSL_AD_INTERNAL_ERROR;
2114             goto f_err;
2115         }
2116
2117         psklen = s->psk_server_callback(s, s->session->psk_identity,
2118                                          psk, sizeof(psk));
2119
2120         if (psklen > PSK_MAX_PSK_LEN) {
2121             al = SSL_AD_INTERNAL_ERROR;
2122             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2123             goto f_err;
2124         } else if (psklen == 0) {
2125             /*
2126              * PSK related to the given identity not found
2127              */
2128             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2129                    SSL_R_PSK_IDENTITY_NOT_FOUND);
2130             al = SSL_AD_UNKNOWN_PSK_IDENTITY;
2131             goto f_err;
2132         }
2133
2134         OPENSSL_free(s->s3->tmp.psk);
2135         s->s3->tmp.psk = OPENSSL_memdup(psk, psklen);
2136         OPENSSL_cleanse(psk, psklen);
2137
2138         if (s->s3->tmp.psk == NULL) {
2139             al = SSL_AD_INTERNAL_ERROR;
2140             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2141             goto f_err;
2142         }
2143
2144         s->s3->tmp.psklen = psklen;
2145     }
2146     if (alg_k & SSL_kPSK) {
2147         /* Identity extracted earlier: should be nothing left */
2148         if (PACKET_remaining(pkt) != 0) {
2149             al = SSL_AD_HANDSHAKE_FAILURE;
2150             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_LENGTH_MISMATCH);
2151             goto f_err;
2152         }
2153         /* PSK handled by ssl_generate_master_secret */
2154         if (!ssl_generate_master_secret(s, NULL, 0, 0)) {
2155             al = SSL_AD_INTERNAL_ERROR;
2156             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2157             goto f_err;
2158         }
2159     } else
2160 #endif
2161 #ifndef OPENSSL_NO_RSA
2162     if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) {
2163         unsigned char rand_premaster_secret[SSL_MAX_MASTER_KEY_LENGTH];
2164         int decrypt_len;
2165         unsigned char decrypt_good, version_good;
2166         size_t j;
2167
2168         /* FIX THIS UP EAY EAY EAY EAY */
2169         rsa = EVP_PKEY_get0_RSA(s->cert->pkeys[SSL_PKEY_RSA_ENC].privatekey);
2170         if (rsa == NULL) {
2171             al = SSL_AD_HANDSHAKE_FAILURE;
2172             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2173                    SSL_R_MISSING_RSA_CERTIFICATE);
2174             goto f_err;
2175         }
2176
2177         /* SSLv3 and pre-standard DTLS omit the length bytes. */
2178         if (s->version == SSL3_VERSION || s->version == DTLS1_BAD_VER) {
2179             enc_premaster = *pkt;
2180         } else {
2181             if (!PACKET_get_length_prefixed_2(pkt, &enc_premaster)
2182                 || PACKET_remaining(pkt) != 0) {
2183                 al = SSL_AD_DECODE_ERROR;
2184                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2185                        SSL_R_LENGTH_MISMATCH);
2186                 goto f_err;
2187             }
2188         }
2189
2190         /*
2191          * We want to be sure that the plaintext buffer size makes it safe to
2192          * iterate over the entire size of a premaster secret
2193          * (SSL_MAX_MASTER_KEY_LENGTH). Reject overly short RSA keys because
2194          * their ciphertext cannot accommodate a premaster secret anyway.
2195          */
2196         if (RSA_size(rsa) < SSL_MAX_MASTER_KEY_LENGTH) {
2197             al = SSL_AD_INTERNAL_ERROR;
2198             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2199                    RSA_R_KEY_SIZE_TOO_SMALL);
2200             goto f_err;
2201         }
2202
2203         rsa_decrypt = OPENSSL_malloc(RSA_size(rsa));
2204         if (rsa_decrypt == NULL) {
2205             al = SSL_AD_INTERNAL_ERROR;
2206             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2207             goto f_err;
2208         }
2209
2210         /*
2211          * We must not leak whether a decryption failure occurs because of
2212          * Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see RFC 2246,
2213          * section 7.4.7.1). The code follows that advice of the TLS RFC and
2214          * generates a random premaster secret for the case that the decrypt
2215          * fails. See https://tools.ietf.org/html/rfc5246#section-7.4.7.1
2216          */
2217
2218         if (RAND_bytes(rand_premaster_secret,
2219                        sizeof(rand_premaster_secret)) <= 0) {
2220             goto err;
2221         }
2222
2223         decrypt_len = RSA_private_decrypt(PACKET_remaining(&enc_premaster),
2224                                           PACKET_data(&enc_premaster),
2225                                           rsa_decrypt, rsa, RSA_PKCS1_PADDING);
2226         ERR_clear_error();
2227
2228         /*
2229          * decrypt_len should be SSL_MAX_MASTER_KEY_LENGTH. decrypt_good will
2230          * be 0xff if so and zero otherwise.
2231          */
2232         decrypt_good =
2233             constant_time_eq_int_8(decrypt_len, SSL_MAX_MASTER_KEY_LENGTH);
2234
2235         /*
2236          * If the version in the decrypted pre-master secret is correct then
2237          * version_good will be 0xff, otherwise it'll be zero. The
2238          * Klima-Pokorny-Rosa extension of Bleichenbacher's attack
2239          * (http://eprint.iacr.org/2003/052/) exploits the version number
2240          * check as a "bad version oracle". Thus version checks are done in
2241          * constant time and are treated like any other decryption error.
2242          */
2243         version_good =
2244             constant_time_eq_8(rsa_decrypt[0],
2245                                (unsigned)(s->client_version >> 8));
2246         version_good &=
2247             constant_time_eq_8(rsa_decrypt[1],
2248                                (unsigned)(s->client_version & 0xff));
2249
2250         /*
2251          * The premaster secret must contain the same version number as the
2252          * ClientHello to detect version rollback attacks (strangely, the
2253          * protocol does not offer such protection for DH ciphersuites).
2254          * However, buggy clients exist that send the negotiated protocol
2255          * version instead if the server does not support the requested
2256          * protocol version. If SSL_OP_TLS_ROLLBACK_BUG is set, tolerate such
2257          * clients.
2258          */
2259         if (s->options & SSL_OP_TLS_ROLLBACK_BUG) {
2260             unsigned char workaround_good;
2261             workaround_good =
2262                 constant_time_eq_8(rsa_decrypt[0], (unsigned)(s->version >> 8));
2263             workaround_good &=
2264                 constant_time_eq_8(rsa_decrypt[1],
2265                                    (unsigned)(s->version & 0xff));
2266             version_good |= workaround_good;
2267         }
2268
2269         /*
2270          * Both decryption and version must be good for decrypt_good to
2271          * remain non-zero (0xff).
2272          */
2273         decrypt_good &= version_good;
2274
2275         /*
2276          * Now copy rand_premaster_secret over from p using
2277          * decrypt_good_mask. If decryption failed, then p does not
2278          * contain valid plaintext, however, a check above guarantees
2279          * it is still sufficiently large to read from.
2280          */
2281         for (j = 0; j < sizeof(rand_premaster_secret); j++) {
2282             rsa_decrypt[j] =
2283                 constant_time_select_8(decrypt_good, rsa_decrypt[j],
2284                                        rand_premaster_secret[j]);
2285         }
2286
2287         if (!ssl_generate_master_secret(s, rsa_decrypt,
2288                                         sizeof(rand_premaster_secret), 0)) {
2289             al = SSL_AD_INTERNAL_ERROR;
2290             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2291             goto f_err;
2292         }
2293         OPENSSL_free(rsa_decrypt);
2294         rsa_decrypt = NULL;
2295     } else
2296 #endif
2297 #ifndef OPENSSL_NO_DH
2298     if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) {
2299         EVP_PKEY *skey = NULL;
2300         DH *cdh;
2301         unsigned int i;
2302         BIGNUM *pub_key;
2303         const unsigned char *data;
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             const unsigned char *data;
2382
2383             /*
2384              * Get client's public key from encoded point in the
2385              * ClientKeyExchange message.
2386              */
2387
2388             /* Get encoded point length */
2389             if (!PACKET_get_1(pkt, &i)) {
2390                 al = SSL_AD_DECODE_ERROR;
2391                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2392                        SSL_R_LENGTH_MISMATCH);
2393                 goto f_err;
2394             }
2395             if (!PACKET_get_bytes(pkt, &data, i)
2396                     || PACKET_remaining(pkt) != 0) {
2397                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_EC_LIB);
2398                 goto err;
2399             }
2400             ckey = EVP_PKEY_new();
2401             if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) <= 0) {
2402                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_EVP_LIB);
2403                 goto err;
2404             }
2405             if (EC_KEY_oct2key(EVP_PKEY_get0_EC_KEY(ckey), data, i,
2406                                NULL) == 0) {
2407                 SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_EC_LIB);
2408                 goto err;
2409             }
2410         }
2411
2412         if (ssl_derive(s, skey, ckey) == 0) {
2413             al = SSL_AD_INTERNAL_ERROR;
2414             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2415             goto f_err;
2416         }
2417
2418         EVP_PKEY_free(ckey);
2419         ckey = NULL;
2420         EVP_PKEY_free(s->s3->tmp.pkey);
2421         s->s3->tmp.pkey = NULL;
2422
2423         return MSG_PROCESS_CONTINUE_PROCESSING;
2424     } else
2425 #endif
2426 #ifndef OPENSSL_NO_SRP
2427     if (alg_k & SSL_kSRP) {
2428         unsigned int i;
2429         const unsigned char *data;
2430
2431         if (!PACKET_get_net_2(pkt, &i)
2432                 || !PACKET_get_bytes(pkt, &data, i)) {
2433             al = SSL_AD_DECODE_ERROR;
2434             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_BAD_SRP_A_LENGTH);
2435             goto f_err;
2436         }
2437         if ((s->srp_ctx.A = BN_bin2bn(data, i, NULL)) == NULL) {
2438             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_BN_LIB);
2439             goto err;
2440         }
2441         if (BN_ucmp(s->srp_ctx.A, s->srp_ctx.N) >= 0
2442             || BN_is_zero(s->srp_ctx.A)) {
2443             al = SSL_AD_ILLEGAL_PARAMETER;
2444             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2445                    SSL_R_BAD_SRP_PARAMETERS);
2446             goto f_err;
2447         }
2448         OPENSSL_free(s->session->srp_username);
2449         s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login);
2450         if (s->session->srp_username == NULL) {
2451             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2452             goto err;
2453         }
2454
2455         if (!srp_generate_server_master_secret(s)) {
2456             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2457             goto err;
2458         }
2459     } else
2460 #endif                          /* OPENSSL_NO_SRP */
2461 #ifndef OPENSSL_NO_GOST
2462     if (alg_k & SSL_kGOST) {
2463         EVP_PKEY_CTX *pkey_ctx;
2464         EVP_PKEY *client_pub_pkey = NULL, *pk = NULL;
2465         unsigned char premaster_secret[32];
2466         const unsigned char *start;
2467         size_t outlen = 32, inlen;
2468         unsigned long alg_a;
2469         int Ttag, Tclass;
2470         long Tlen;
2471         long sess_key_len;
2472         const unsigned char *data;
2473
2474         /* Get our certificate private key */
2475         alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2476         if (alg_a & SSL_aGOST12) {
2477             /*
2478              * New GOST ciphersuites have SSL_aGOST01 bit too
2479              */
2480             pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey;
2481             if (pk == NULL) {
2482                 pk = s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey;
2483             }
2484             if (pk == NULL) {
2485                 pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
2486             }
2487         } else if (alg_a & SSL_aGOST01) {
2488             pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey;
2489         }
2490
2491         pkey_ctx = EVP_PKEY_CTX_new(pk, NULL);
2492         if (pkey_ctx == NULL) {
2493             al = SSL_AD_INTERNAL_ERROR;
2494             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_MALLOC_FAILURE);
2495             goto f_err;
2496         }
2497         if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) {
2498             al = SSL_AD_INTERNAL_ERROR;
2499             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2500             goto f_err;
2501         }
2502         /*
2503          * If client certificate is present and is of the same type, maybe
2504          * use it for key exchange.  Don't mind errors from
2505          * EVP_PKEY_derive_set_peer, because it is completely valid to use a
2506          * client certificate for authorization only.
2507          */
2508         client_pub_pkey = X509_get0_pubkey(s->session->peer);
2509         if (client_pub_pkey) {
2510             if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0)
2511                 ERR_clear_error();
2512         }
2513         /* Decrypt session key */
2514         sess_key_len = PACKET_remaining(pkt);
2515         if (!PACKET_get_bytes(pkt, &data, sess_key_len)) {
2516             al = SSL_AD_INTERNAL_ERROR;
2517             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2518             goto gerr;
2519         }
2520         if (ASN1_get_object ((const unsigned char **)&data, &Tlen, &Ttag,
2521                              &Tclass, sess_key_len) != V_ASN1_CONSTRUCTED
2522             || Ttag != V_ASN1_SEQUENCE
2523             || Tclass != V_ASN1_UNIVERSAL) {
2524             al = SSL_AD_DECODE_ERROR;
2525             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2526                    SSL_R_DECRYPTION_FAILED);
2527             goto gerr;
2528         }
2529         start = data;
2530         inlen = Tlen;
2531         if (EVP_PKEY_decrypt
2532             (pkey_ctx, premaster_secret, &outlen, start, inlen) <= 0) {
2533             al = SSL_AD_DECODE_ERROR;
2534             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE,
2535                    SSL_R_DECRYPTION_FAILED);
2536             goto gerr;
2537         }
2538         /* Generate master secret */
2539         if (!ssl_generate_master_secret(s, premaster_secret,
2540                                         sizeof(premaster_secret), 0)) {
2541             al = SSL_AD_INTERNAL_ERROR;
2542             SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, ERR_R_INTERNAL_ERROR);
2543             goto gerr;
2544         }
2545         /* Check if pubkey from client certificate was used */
2546         if (EVP_PKEY_CTX_ctrl
2547             (pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0)
2548             s->statem.no_cert_verify = 1;
2549
2550         EVP_PKEY_CTX_free(pkey_ctx);
2551         return MSG_PROCESS_CONTINUE_PROCESSING;
2552  gerr:
2553         EVP_PKEY_CTX_free(pkey_ctx);
2554         goto f_err;
2555     } else
2556 #endif
2557     {
2558         al = SSL_AD_HANDSHAKE_FAILURE;
2559         SSLerr(SSL_F_TLS_PROCESS_CLIENT_KEY_EXCHANGE, SSL_R_UNKNOWN_CIPHER_TYPE);
2560         goto f_err;
2561     }
2562
2563     return MSG_PROCESS_CONTINUE_PROCESSING;
2564  f_err:
2565     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2566 #if !defined(OPENSSL_NO_DH) || !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_EC) || defined(OPENSSL_NO_SRP)
2567  err:
2568 #endif
2569 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DH)
2570     EVP_PKEY_free(ckey);
2571 #endif
2572     OPENSSL_free(rsa_decrypt);
2573 #ifndef OPENSSL_NO_PSK
2574     OPENSSL_clear_free(s->s3->tmp.psk, s->s3->tmp.psklen);
2575     s->s3->tmp.psk = NULL;
2576 #endif
2577     ossl_statem_set_error(s);
2578     return MSG_PROCESS_ERROR;
2579 }
2580
2581 WORK_STATE tls_post_process_client_key_exchange(SSL *s, WORK_STATE wst)
2582 {
2583 #ifndef OPENSSL_NO_SCTP
2584     if (wst == WORK_MORE_A) {
2585         if (SSL_IS_DTLS(s)) {
2586             unsigned char sctpauthkey[64];
2587             char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)];
2588             /*
2589              * Add new shared key for SCTP-Auth, will be ignored if no SCTP
2590              * used.
2591              */
2592             memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
2593                    sizeof(DTLS1_SCTP_AUTH_LABEL));
2594
2595             if (SSL_export_keying_material(s, sctpauthkey,
2596                                        sizeof(sctpauthkey), labelbuffer,
2597                                        sizeof(labelbuffer), NULL, 0, 0) <= 0) {
2598                 ossl_statem_set_error(s);
2599                 return WORK_ERROR;;
2600             }
2601
2602             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
2603                      sizeof(sctpauthkey), sctpauthkey);
2604         }
2605         wst = WORK_MORE_B;
2606     }
2607
2608     if ((wst == WORK_MORE_B)
2609             /* Is this SCTP? */
2610             && BIO_dgram_is_sctp(SSL_get_wbio(s))
2611             /* Are we renegotiating? */
2612             && s->renegotiate
2613             /* Are we going to skip the CertificateVerify? */
2614             && (s->session->peer == NULL || s->statem.no_cert_verify)
2615             && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s))) {
2616         s->s3->in_read_app_data = 2;
2617         s->rwstate = SSL_READING;
2618         BIO_clear_retry_flags(SSL_get_rbio(s));
2619         BIO_set_retry_read(SSL_get_rbio(s));
2620         ossl_statem_set_sctp_read_sock(s, 1);
2621         return WORK_MORE_B;
2622     } else {
2623         ossl_statem_set_sctp_read_sock(s, 0);
2624     }
2625 #endif
2626
2627     if (s->statem.no_cert_verify) {
2628         /* No certificate verify so we no longer need the handshake_buffer */
2629         BIO_free(s->s3->handshake_buffer);
2630         s->s3->handshake_buffer = NULL;
2631         return WORK_FINISHED_CONTINUE;
2632     } else {
2633         if (!s->session->peer) {
2634             /* No peer certificate so we no longer need the handshake_buffer */
2635             BIO_free(s->s3->handshake_buffer);
2636             return WORK_FINISHED_CONTINUE;
2637         }
2638         if (!s->s3->handshake_buffer) {
2639             SSLerr(SSL_F_TLS_POST_PROCESS_CLIENT_KEY_EXCHANGE,
2640                    ERR_R_INTERNAL_ERROR);
2641             ossl_statem_set_error(s);
2642             return WORK_ERROR;
2643         }
2644         /*
2645          * For sigalgs freeze the handshake buffer. If we support
2646          * extms we've done this already so this is a no-op
2647          */
2648         if (!ssl3_digest_cached_records(s, 1)) {
2649             ossl_statem_set_error(s);
2650             return WORK_ERROR;
2651         }
2652     }
2653
2654     return WORK_FINISHED_CONTINUE;
2655 }
2656
2657 MSG_PROCESS_RETURN tls_process_cert_verify(SSL *s, PACKET *pkt)
2658 {
2659     EVP_PKEY *pkey = NULL;
2660     const unsigned char *sig, *data;
2661 #ifndef OPENSSL_NO_GOST
2662     unsigned char *gost_data = NULL;
2663 #endif
2664     int al, ret = MSG_PROCESS_ERROR;
2665     int type = 0, j;
2666     unsigned int len;
2667     X509 *peer;
2668     const EVP_MD *md = NULL;
2669     long hdatalen = 0;
2670     void *hdata;
2671
2672     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
2673
2674     if (mctx == NULL) {
2675         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
2676         al = SSL_AD_INTERNAL_ERROR;
2677         goto f_err;
2678     }
2679
2680     peer = s->session->peer;
2681     pkey = X509_get0_pubkey(peer);
2682     type = X509_certificate_type(peer, pkey);
2683
2684     if (!(type & EVP_PKT_SIGN)) {
2685         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY,
2686                SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
2687         al = SSL_AD_ILLEGAL_PARAMETER;
2688         goto f_err;
2689     }
2690
2691     /* Check for broken implementations of GOST ciphersuites */
2692     /*
2693      * If key is GOST and n is exactly 64, it is bare signature without
2694      * length field (CryptoPro implementations at least till CSP 4.0)
2695      */
2696 #ifndef OPENSSL_NO_GOST
2697     if (PACKET_remaining(pkt) == 64
2698         && EVP_PKEY_id(pkey) == NID_id_GostR3410_2001) {
2699         len = 64;
2700     } else
2701 #endif
2702     {
2703         if (SSL_USE_SIGALGS(s)) {
2704             int rv;
2705
2706             if (!PACKET_get_bytes(pkt, &sig, 2)) {
2707                 al = SSL_AD_DECODE_ERROR;
2708                 goto f_err;
2709             }
2710             rv = tls12_check_peer_sigalg(&md, s, sig, pkey);
2711             if (rv == -1) {
2712                 al = SSL_AD_INTERNAL_ERROR;
2713                 goto f_err;
2714             } else if (rv == 0) {
2715                 al = SSL_AD_DECODE_ERROR;
2716                 goto f_err;
2717             }
2718 #ifdef SSL_DEBUG
2719             fprintf(stderr, "USING TLSv1.2 HASH %s\n", EVP_MD_name(md));
2720 #endif
2721         } else {
2722             /* Use default digest for this key type */
2723             int idx = ssl_cert_type(NULL, pkey);
2724             if (idx >= 0)
2725                 md = s->s3->tmp.md[idx];
2726             if (md == NULL) {
2727                 al = SSL_AD_INTERNAL_ERROR;
2728                 goto f_err;
2729             }
2730         }
2731
2732         if (!PACKET_get_net_2(pkt, &len)) {
2733             SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
2734             al = SSL_AD_DECODE_ERROR;
2735             goto f_err;
2736         }
2737     }
2738     j = EVP_PKEY_size(pkey);
2739     if (((int)len > j) || ((int)PACKET_remaining(pkt) > j)
2740             || (PACKET_remaining(pkt) == 0)) {
2741         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_WRONG_SIGNATURE_SIZE);
2742         al = SSL_AD_DECODE_ERROR;
2743         goto f_err;
2744     }
2745     if (!PACKET_get_bytes(pkt, &data, len)) {
2746         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_LENGTH_MISMATCH);
2747         al = SSL_AD_DECODE_ERROR;
2748         goto f_err;
2749     }
2750
2751     hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
2752     if (hdatalen <= 0) {
2753         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_INTERNAL_ERROR);
2754         al = SSL_AD_INTERNAL_ERROR;
2755         goto f_err;
2756     }
2757 #ifdef SSL_DEBUG
2758     fprintf(stderr, "Using client verify alg %s\n", EVP_MD_name(md));
2759 #endif
2760     if (!EVP_VerifyInit_ex(mctx, md, NULL)
2761         || !EVP_VerifyUpdate(mctx, hdata, hdatalen)) {
2762         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
2763         al = SSL_AD_INTERNAL_ERROR;
2764         goto f_err;
2765     }
2766
2767 #ifndef OPENSSL_NO_GOST
2768     {
2769         int pktype = EVP_PKEY_id(pkey);
2770         if (pktype == NID_id_GostR3410_2001
2771             || pktype == NID_id_GostR3410_2012_256
2772             || pktype == NID_id_GostR3410_2012_512) {
2773             if ((gost_data = OPENSSL_malloc(len)) == NULL) {
2774                 SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_MALLOC_FAILURE);
2775                 al = SSL_AD_INTERNAL_ERROR;
2776                 goto f_err;
2777             }
2778             BUF_reverse(gost_data, data, len);
2779             data = gost_data;
2780         }
2781     }
2782 #endif
2783
2784     if (s->version == SSL3_VERSION
2785         && !EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
2786                             s->session->master_key_length,
2787                             s->session->master_key)) {
2788         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, ERR_R_EVP_LIB);
2789         al = SSL_AD_INTERNAL_ERROR;
2790         goto f_err;
2791     }
2792
2793     if (EVP_VerifyFinal(mctx, data, len, pkey) <= 0) {
2794         al = SSL_AD_DECRYPT_ERROR;
2795         SSLerr(SSL_F_TLS_PROCESS_CERT_VERIFY, SSL_R_BAD_SIGNATURE);
2796         goto f_err;
2797     }
2798
2799     ret = MSG_PROCESS_CONTINUE_PROCESSING;
2800     if (0) {
2801  f_err:
2802         ssl3_send_alert(s, SSL3_AL_FATAL, al);
2803         ossl_statem_set_error(s);
2804     }
2805     BIO_free(s->s3->handshake_buffer);
2806     s->s3->handshake_buffer = NULL;
2807     EVP_MD_CTX_free(mctx);
2808 #ifndef OPENSSL_NO_GOST
2809     OPENSSL_free(gost_data);
2810 #endif
2811     return ret;
2812 }
2813
2814 MSG_PROCESS_RETURN tls_process_client_certificate(SSL *s, PACKET *pkt)
2815 {
2816     int i, al = SSL_AD_INTERNAL_ERROR, ret = MSG_PROCESS_ERROR;
2817     X509 *x = NULL;
2818     unsigned long l, llen;
2819     const unsigned char *certstart, *certbytes;
2820     STACK_OF(X509) *sk = NULL;
2821     PACKET spkt;
2822
2823     if ((sk = sk_X509_new_null()) == NULL) {
2824         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
2825         goto f_err;
2826     }
2827
2828     if (!PACKET_get_net_3(pkt, &llen)
2829             || !PACKET_get_sub_packet(pkt, &spkt, llen)
2830             || PACKET_remaining(pkt) != 0) {
2831         al = SSL_AD_DECODE_ERROR;
2832         SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, SSL_R_LENGTH_MISMATCH);
2833         goto f_err;
2834     }
2835
2836     while (PACKET_remaining(&spkt) > 0) {
2837         if (!PACKET_get_net_3(&spkt, &l)
2838                 || !PACKET_get_bytes(&spkt, &certbytes, l)) {
2839             al = SSL_AD_DECODE_ERROR;
2840             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2841                    SSL_R_CERT_LENGTH_MISMATCH);
2842             goto f_err;
2843         }
2844
2845         certstart = certbytes;
2846         x = d2i_X509(NULL, (const unsigned char **)&certbytes, l);
2847         if (x == NULL) {
2848             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_ASN1_LIB);
2849             goto f_err;
2850         }
2851         if (certbytes != (certstart + l)) {
2852             al = SSL_AD_DECODE_ERROR;
2853             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2854                    SSL_R_CERT_LENGTH_MISMATCH);
2855             goto f_err;
2856         }
2857         if (!sk_X509_push(sk, x)) {
2858             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, ERR_R_MALLOC_FAILURE);
2859             goto f_err;
2860         }
2861         x = NULL;
2862     }
2863
2864     if (sk_X509_num(sk) <= 0) {
2865         /* TLS does not mind 0 certs returned */
2866         if (s->version == SSL3_VERSION) {
2867             al = SSL_AD_HANDSHAKE_FAILURE;
2868             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2869                    SSL_R_NO_CERTIFICATES_RETURNED);
2870             goto f_err;
2871         }
2872         /* Fail for TLS only if we required a certificate */
2873         else if ((s->verify_mode & SSL_VERIFY_PEER) &&
2874                  (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
2875             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2876                    SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
2877             al = SSL_AD_HANDSHAKE_FAILURE;
2878             goto f_err;
2879         }
2880         /* No client certificate so digest cached records */
2881         if (s->s3->handshake_buffer && !ssl3_digest_cached_records(s, 0)) {
2882             goto f_err;
2883         }
2884     } else {
2885         EVP_PKEY *pkey;
2886         i = ssl_verify_cert_chain(s, sk);
2887         if (i <= 0) {
2888             al = ssl_verify_alarm_type(s->verify_result);
2889             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2890                    SSL_R_CERTIFICATE_VERIFY_FAILED);
2891             goto f_err;
2892         }
2893         if (i > 1) {
2894             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE, i);
2895             al = SSL_AD_HANDSHAKE_FAILURE;
2896             goto f_err;
2897         }
2898         pkey = X509_get0_pubkey(sk_X509_value(sk, 0));
2899         if (pkey == NULL) {
2900             al = SSL3_AD_HANDSHAKE_FAILURE;
2901             SSLerr(SSL_F_TLS_PROCESS_CLIENT_CERTIFICATE,
2902                    SSL_R_UNKNOWN_CERTIFICATE_TYPE);
2903             goto f_err;
2904         }
2905     }
2906
2907     X509_free(s->session->peer);
2908     s->session->peer = sk_X509_shift(sk);
2909     s->session->verify_result = s->verify_result;
2910
2911     sk_X509_pop_free(s->session->peer_chain, X509_free);
2912     s->session->peer_chain = sk;
2913     /*
2914      * Inconsistency alert: cert_chain does *not* include the peer's own
2915      * certificate, while we do include it in s3_clnt.c
2916      */
2917     sk = NULL;
2918     ret = MSG_PROCESS_CONTINUE_READING;
2919     goto done;
2920
2921  f_err:
2922     ssl3_send_alert(s, SSL3_AL_FATAL, al);
2923     ossl_statem_set_error(s);
2924  done:
2925     X509_free(x);
2926     sk_X509_pop_free(sk, X509_free);
2927     return ret;
2928 }
2929
2930 int tls_construct_server_certificate(SSL *s)
2931 {
2932     CERT_PKEY *cpk;
2933
2934     cpk = ssl_get_server_send_pkey(s);
2935     if (cpk == NULL) {
2936         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
2937         ossl_statem_set_error(s);
2938         return 0;
2939     }
2940
2941     if (!ssl3_output_cert_chain(s, cpk)) {
2942         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CERTIFICATE, ERR_R_INTERNAL_ERROR);
2943         ossl_statem_set_error(s);
2944         return 0;
2945     }
2946
2947     return 1;
2948 }
2949
2950 int tls_construct_new_session_ticket(SSL *s)
2951 {
2952     unsigned char *senc = NULL;
2953     EVP_CIPHER_CTX *ctx;
2954     HMAC_CTX *hctx = NULL;
2955     unsigned char *p, *macstart;
2956     const unsigned char *const_p;
2957     int len, slen_full, slen;
2958     SSL_SESSION *sess;
2959     unsigned int hlen;
2960     SSL_CTX *tctx = s->initial_ctx;
2961     unsigned char iv[EVP_MAX_IV_LENGTH];
2962     unsigned char key_name[16];
2963
2964     /* get session encoding length */
2965     slen_full = i2d_SSL_SESSION(s->session, NULL);
2966     /*
2967      * Some length values are 16 bits, so forget it if session is too
2968      * long
2969      */
2970     if (slen_full == 0 || slen_full > 0xFF00) {
2971         ossl_statem_set_error(s);
2972         return 0;
2973     }
2974     senc = OPENSSL_malloc(slen_full);
2975     if (senc == NULL) {
2976         ossl_statem_set_error(s);
2977         return 0;
2978     }
2979
2980     ctx = EVP_CIPHER_CTX_new();
2981     hctx = HMAC_CTX_new();
2982
2983     p = senc;
2984     if (!i2d_SSL_SESSION(s->session, &p))
2985         goto err;
2986
2987     /*
2988      * create a fresh copy (not shared with other threads) to clean up
2989      */
2990     const_p = senc;
2991     sess = d2i_SSL_SESSION(NULL, &const_p, slen_full);
2992     if (sess == NULL)
2993         goto err;
2994     sess->session_id_length = 0; /* ID is irrelevant for the ticket */
2995
2996     slen = i2d_SSL_SESSION(sess, NULL);
2997     if (slen == 0 || slen > slen_full) { /* shouldn't ever happen */
2998         SSL_SESSION_free(sess);
2999         goto err;
3000     }
3001     p = senc;
3002     if (!i2d_SSL_SESSION(sess, &p)) {
3003         SSL_SESSION_free(sess);
3004         goto err;
3005     }
3006     SSL_SESSION_free(sess);
3007
3008     /*-
3009      * Grow buffer if need be: the length calculation is as
3010      * follows handshake_header_length +
3011      * 4 (ticket lifetime hint) + 2 (ticket length) +
3012      * 16 (key name) + max_iv_len (iv length) +
3013      * session_length + max_enc_block_size (max encrypted session
3014      * length) + max_md_size (HMAC).
3015      */
3016     if (!BUF_MEM_grow(s->init_buf,
3017                       SSL_HM_HEADER_LENGTH(s) + 22 + EVP_MAX_IV_LENGTH +
3018                       EVP_MAX_BLOCK_LENGTH + EVP_MAX_MD_SIZE + slen))
3019         goto err;
3020
3021     p = ssl_handshake_start(s);
3022     /*
3023      * Initialize HMAC and cipher contexts. If callback present it does
3024      * all the work otherwise use generated values from parent ctx.
3025      */
3026     if (tctx->tlsext_ticket_key_cb) {
3027         if (tctx->tlsext_ticket_key_cb(s, key_name, iv, ctx, hctx, 1) < 0)
3028             goto err;
3029     } else {
3030         if (RAND_bytes(iv, 16) <= 0)
3031             goto err;
3032         if (!EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL,
3033                                 tctx->tlsext_tick_aes_key, iv))
3034             goto err;
3035         if (!HMAC_Init_ex(hctx, tctx->tlsext_tick_hmac_key, 16,
3036                           EVP_sha256(), NULL))
3037             goto err;
3038         memcpy(key_name, tctx->tlsext_tick_key_name, 16);
3039     }
3040
3041     /*
3042      * Ticket lifetime hint (advisory only): We leave this unspecified
3043      * for resumed session (for simplicity), and guess that tickets for
3044      * new sessions will live as long as their sessions.
3045      */
3046     l2n(s->hit ? 0 : s->session->timeout, p);
3047
3048     /* Skip ticket length for now */
3049     p += 2;
3050     /* Output key name */
3051     macstart = p;
3052     memcpy(p, key_name, 16);
3053     p += 16;
3054     /* output IV */
3055     memcpy(p, iv, EVP_CIPHER_CTX_iv_length(ctx));
3056     p += EVP_CIPHER_CTX_iv_length(ctx);
3057     /* Encrypt session data */
3058     if (!EVP_EncryptUpdate(ctx, p, &len, senc, slen))
3059         goto err;
3060     p += len;
3061     if (!EVP_EncryptFinal(ctx, p, &len))
3062         goto err;
3063     p += len;
3064
3065     if (!HMAC_Update(hctx, macstart, p - macstart))
3066         goto err;
3067     if (!HMAC_Final(hctx, p, &hlen))
3068         goto err;
3069
3070     EVP_CIPHER_CTX_free(ctx);
3071     HMAC_CTX_free(hctx);
3072     ctx = NULL;
3073     hctx = NULL;
3074
3075     p += hlen;
3076     /* Now write out lengths: p points to end of data written */
3077     /* Total length */
3078     len = p - ssl_handshake_start(s);
3079     /* Skip ticket lifetime hint */
3080     p = ssl_handshake_start(s) + 4;
3081     s2n(len - 6, p);
3082     if (!ssl_set_handshake_header(s, SSL3_MT_NEWSESSION_TICKET, len))
3083         goto err;
3084     OPENSSL_free(senc);
3085
3086     return 1;
3087  err:
3088     OPENSSL_free(senc);
3089     EVP_CIPHER_CTX_free(ctx);
3090     HMAC_CTX_free(hctx);
3091     ossl_statem_set_error(s);
3092     return 0;
3093 }
3094
3095 int tls_construct_cert_status(SSL *s)
3096 {
3097     unsigned char *p;
3098     /*-
3099      * Grow buffer if need be: the length calculation is as
3100      * follows 1 (message type) + 3 (message length) +
3101      * 1 (ocsp response type) + 3 (ocsp response length)
3102      * + (ocsp response)
3103      */
3104     if (!BUF_MEM_grow(s->init_buf, 8 + s->tlsext_ocsp_resplen)) {
3105         ossl_statem_set_error(s);
3106         return 0;
3107     }
3108
3109     p = (unsigned char *)s->init_buf->data;
3110
3111     /* do the header */
3112     *(p++) = SSL3_MT_CERTIFICATE_STATUS;
3113     /* message length */
3114     l2n3(s->tlsext_ocsp_resplen + 4, p);
3115     /* status type */
3116     *(p++) = s->tlsext_status_type;
3117     /* length of OCSP response */
3118     l2n3(s->tlsext_ocsp_resplen, p);
3119     /* actual response */
3120     memcpy(p, s->tlsext_ocsp_resp, s->tlsext_ocsp_resplen);
3121     /* number of bytes to write */
3122     s->init_num = 8 + s->tlsext_ocsp_resplen;
3123     s->init_off = 0;
3124
3125     return 1;
3126 }
3127
3128 #ifndef OPENSSL_NO_NEXTPROTONEG
3129 /*
3130  * tls_process_next_proto reads a Next Protocol Negotiation handshake message.
3131  * It sets the next_proto member in s if found
3132  */
3133 MSG_PROCESS_RETURN tls_process_next_proto(SSL *s, PACKET *pkt)
3134 {
3135     PACKET next_proto, padding;
3136     size_t next_proto_len;
3137
3138     /*-
3139      * The payload looks like:
3140      *   uint8 proto_len;
3141      *   uint8 proto[proto_len];
3142      *   uint8 padding_len;
3143      *   uint8 padding[padding_len];
3144      */
3145     if (!PACKET_get_length_prefixed_1(pkt, &next_proto)
3146         || !PACKET_get_length_prefixed_1(pkt, &padding)
3147         || PACKET_remaining(pkt) > 0) {
3148         SSLerr(SSL_F_TLS_PROCESS_NEXT_PROTO, SSL_R_LENGTH_MISMATCH);
3149         goto err;
3150     }
3151
3152     if (!PACKET_memdup(&next_proto, &s->next_proto_negotiated,
3153                        &next_proto_len)) {
3154         s->next_proto_negotiated_len = 0;
3155         goto err;
3156     }
3157
3158     s->next_proto_negotiated_len = (unsigned char)next_proto_len;
3159
3160     return MSG_PROCESS_CONTINUE_READING;
3161 err:
3162     ossl_statem_set_error(s);
3163     return MSG_PROCESS_ERROR;
3164 }
3165 #endif
3166
3167 #define SSLV2_CIPHER_LEN    3
3168
3169 STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,
3170                                                PACKET *cipher_suites,
3171                                                STACK_OF(SSL_CIPHER) **skp,
3172                                                int sslv2format, int *al
3173                                                )
3174 {
3175     const SSL_CIPHER *c;
3176     STACK_OF(SSL_CIPHER) *sk;
3177     int n;
3178     /* 3 = SSLV2_CIPHER_LEN > TLS_CIPHER_LEN = 2. */
3179     unsigned char cipher[SSLV2_CIPHER_LEN];
3180
3181     s->s3->send_connection_binding = 0;
3182
3183     n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN;
3184
3185     if (PACKET_remaining(cipher_suites) == 0) {
3186         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, SSL_R_NO_CIPHERS_SPECIFIED);
3187         *al = SSL_AD_ILLEGAL_PARAMETER;
3188         return NULL;
3189     }
3190
3191     if (PACKET_remaining(cipher_suites) % n != 0) {
3192         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3193                SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
3194         *al = SSL_AD_DECODE_ERROR;
3195         return NULL;
3196     }
3197
3198     if ((skp == NULL) || (*skp == NULL)) {
3199         sk = sk_SSL_CIPHER_new_null(); /* change perhaps later */
3200         if(sk == NULL) {
3201             SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
3202             *al = SSL_AD_INTERNAL_ERROR;
3203             return NULL;
3204         }
3205     } else {
3206         sk = *skp;
3207         sk_SSL_CIPHER_zero(sk);
3208     }
3209
3210     if (!PACKET_memdup(cipher_suites, &s->s3->tmp.ciphers_raw,
3211                        &s->s3->tmp.ciphers_rawlen)) {
3212         *al = SSL_AD_INTERNAL_ERROR;
3213         goto err;
3214     }
3215
3216     while (PACKET_copy_bytes(cipher_suites, cipher, n)) {
3217         /*
3218          * SSLv3 ciphers wrapped in an SSLv2-compatible ClientHello have the
3219          * first byte set to zero, while true SSLv2 ciphers have a non-zero
3220          * first byte. We don't support any true SSLv2 ciphers, so skip them.
3221          */
3222         if (sslv2format && cipher[0] != '\0')
3223                 continue;
3224
3225         /* Check for TLS_EMPTY_RENEGOTIATION_INFO_SCSV */
3226         if ((cipher[n - 2] == ((SSL3_CK_SCSV >> 8) & 0xff)) &&
3227             (cipher[n - 1] == (SSL3_CK_SCSV & 0xff))) {
3228             /* SCSV fatal if renegotiating */
3229             if (s->renegotiate) {
3230                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3231                        SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
3232                 *al = SSL_AD_HANDSHAKE_FAILURE;
3233                 goto err;
3234             }
3235             s->s3->send_connection_binding = 1;
3236             continue;
3237         }
3238
3239         /* Check for TLS_FALLBACK_SCSV */
3240         if ((cipher[n - 2] == ((SSL3_CK_FALLBACK_SCSV >> 8) & 0xff)) &&
3241             (cipher[n - 1] == (SSL3_CK_FALLBACK_SCSV & 0xff))) {
3242             /*
3243              * The SCSV indicates that the client previously tried a higher
3244              * version. Fail if the current version is an unexpected
3245              * downgrade.
3246              */
3247             if (!ssl_check_version_downgrade(s)) {
3248                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,
3249                        SSL_R_INAPPROPRIATE_FALLBACK);
3250                 *al = SSL_AD_INAPPROPRIATE_FALLBACK;
3251                 goto err;
3252             }
3253             continue;
3254         }
3255
3256         /* For SSLv2-compat, ignore leading 0-byte. */
3257         c = ssl_get_cipher_by_char(s, sslv2format ? &cipher[1] : cipher);
3258         if (c != NULL) {
3259             if (!sk_SSL_CIPHER_push(sk, c)) {
3260                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_MALLOC_FAILURE);
3261                 *al = SSL_AD_INTERNAL_ERROR;
3262                 goto err;
3263             }
3264         }
3265     }
3266     if (PACKET_remaining(cipher_suites) > 0) {
3267         *al = SSL_AD_INTERNAL_ERROR;
3268         SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST, ERR_R_INTERNAL_ERROR);
3269         goto err;
3270     }
3271
3272     if (skp != NULL)
3273         *skp = sk;
3274     return (sk);
3275  err:
3276     if ((skp == NULL) || (*skp == NULL))
3277         sk_SSL_CIPHER_free(sk);
3278     return NULL;
3279 }