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