e794d820585bb11b7d1f3bd065d41b9192ed0a38
[openssl.git] / ssl / ssl_lib.c
1 /*
2  * ! \file ssl/ssl_lib.c \brief Version independent SSL functions.
3  */
4 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
5  * All rights reserved.
6  *
7  * This package is an SSL implementation written
8  * by Eric Young (eay@cryptsoft.com).
9  * The implementation was written so as to conform with Netscapes SSL.
10  *
11  * This library is free for commercial and non-commercial use as long as
12  * the following conditions are aheared to.  The following conditions
13  * apply to all code found in this distribution, be it the RC4, RSA,
14  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
15  * included with this distribution is covered by the same copyright terms
16  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
17  *
18  * Copyright remains Eric Young's, and as such any Copyright notices in
19  * the code are not to be removed.
20  * If this package is used in a product, Eric Young should be given attribution
21  * as the author of the parts of the library used.
22  * This can be in the form of a textual message at program startup or
23  * in documentation (online or textual) provided with the package.
24  *
25  * Redistribution and use in source and binary forms, with or without
26  * modification, are permitted provided that the following conditions
27  * are met:
28  * 1. Redistributions of source code must retain the copyright
29  *    notice, this list of conditions and the following disclaimer.
30  * 2. Redistributions in binary form must reproduce the above copyright
31  *    notice, this list of conditions and the following disclaimer in the
32  *    documentation and/or other materials provided with the distribution.
33  * 3. All advertising materials mentioning features or use of this software
34  *    must display the following acknowledgement:
35  *    "This product includes cryptographic software written by
36  *     Eric Young (eay@cryptsoft.com)"
37  *    The word 'cryptographic' can be left out if the rouines from the library
38  *    being used are not cryptographic related :-).
39  * 4. If you include any Windows specific code (or a derivative thereof) from
40  *    the apps directory (application code) you must include an acknowledgement:
41  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
42  *
43  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53  * SUCH DAMAGE.
54  *
55  * The licence and distribution terms for any publically available version or
56  * derivative of this code cannot be changed.  i.e. this code cannot simply be
57  * copied and put under another distribution licence
58  * [including the GNU Public Licence.]
59  */
60 /* ====================================================================
61  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
62  *
63  * Redistribution and use in source and binary forms, with or without
64  * modification, are permitted provided that the following conditions
65  * are met:
66  *
67  * 1. Redistributions of source code must retain the above copyright
68  *    notice, this list of conditions and the following disclaimer.
69  *
70  * 2. Redistributions in binary form must reproduce the above copyright
71  *    notice, this list of conditions and the following disclaimer in
72  *    the documentation and/or other materials provided with the
73  *    distribution.
74  *
75  * 3. All advertising materials mentioning features or use of this
76  *    software must display the following acknowledgment:
77  *    "This product includes software developed by the OpenSSL Project
78  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
79  *
80  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
81  *    endorse or promote products derived from this software without
82  *    prior written permission. For written permission, please contact
83  *    openssl-core@openssl.org.
84  *
85  * 5. Products derived from this software may not be called "OpenSSL"
86  *    nor may "OpenSSL" appear in their names without prior written
87  *    permission of the OpenSSL Project.
88  *
89  * 6. Redistributions of any form whatsoever must retain the following
90  *    acknowledgment:
91  *    "This product includes software developed by the OpenSSL Project
92  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
93  *
94  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
95  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
96  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
97  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
98  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
99  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
100  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
101  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
102  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
103  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
104  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
105  * OF THE POSSIBILITY OF SUCH DAMAGE.
106  * ====================================================================
107  *
108  * This product includes cryptographic software written by Eric Young
109  * (eay@cryptsoft.com).  This product includes software written by Tim
110  * Hudson (tjh@cryptsoft.com).
111  *
112  */
113 /* ====================================================================
114  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
115  * ECC cipher suite support in OpenSSL originally developed by
116  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
117  */
118 /* ====================================================================
119  * Copyright 2005 Nokia. All rights reserved.
120  *
121  * The portions of the attached software ("Contribution") is developed by
122  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
123  * license.
124  *
125  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
126  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
127  * support (see RFC 4279) to OpenSSL.
128  *
129  * No patent licenses or other rights except those expressly stated in
130  * the OpenSSL open source license shall be deemed granted or received
131  * expressly, by implication, estoppel, or otherwise.
132  *
133  * No assurances are provided by Nokia that the Contribution does not
134  * infringe the patent or other intellectual property rights of any third
135  * party or that the license provides you with all the necessary rights
136  * to make use of the Contribution.
137  *
138  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
139  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
140  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
141  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
142  * OTHERWISE.
143  */
144
145 #ifdef REF_CHECK
146 # include <assert.h>
147 #endif
148 #include <stdio.h>
149 #include "ssl_locl.h"
150 #include <openssl/objects.h>
151 #include <openssl/lhash.h>
152 #include <openssl/x509v3.h>
153 #include <openssl/rand.h>
154 #include <openssl/ocsp.h>
155 #ifndef OPENSSL_NO_DH
156 # include <openssl/dh.h>
157 #endif
158 #ifndef OPENSSL_NO_ENGINE
159 # include <openssl/engine.h>
160 #endif
161
162 const char SSL_version_str[] = OPENSSL_VERSION_TEXT;
163
164 SSL3_ENC_METHOD ssl3_undef_enc_method = {
165     /*
166      * evil casts, but these functions are only called if there's a library
167      * bug
168      */
169     (int (*)(SSL *, int))ssl_undefined_function,
170     (int (*)(SSL *, unsigned char *, int))ssl_undefined_function,
171     ssl_undefined_function,
172     (int (*)(SSL *, unsigned char *, unsigned char *, int))
173         ssl_undefined_function,
174     (int (*)(SSL *, int))ssl_undefined_function,
175     (int (*)(SSL *, const char *, int, unsigned char *))
176         ssl_undefined_function,
177     0,                          /* finish_mac_length */
178     (int (*)(SSL *, int, unsigned char *))ssl_undefined_function,
179     NULL,                       /* client_finished_label */
180     0,                          /* client_finished_label_len */
181     NULL,                       /* server_finished_label */
182     0,                          /* server_finished_label_len */
183     (int (*)(int))ssl_undefined_function,
184     (int (*)(SSL *, unsigned char *, size_t, const char *,
185              size_t, const unsigned char *, size_t,
186              int use_context))ssl_undefined_function,
187 };
188
189 static void clear_ciphers(SSL *s)
190 {
191     /* clear the current cipher */
192     ssl_clear_cipher_ctx(s);
193     ssl_clear_hash_ctx(&s->read_hash);
194     ssl_clear_hash_ctx(&s->write_hash);
195 }
196
197 int SSL_clear(SSL *s)
198 {
199     if (s->method == NULL) {
200         SSLerr(SSL_F_SSL_CLEAR, SSL_R_NO_METHOD_SPECIFIED);
201         return (0);
202     }
203
204     if (ssl_clear_bad_session(s)) {
205         SSL_SESSION_free(s->session);
206         s->session = NULL;
207     }
208
209     s->error = 0;
210     s->hit = 0;
211     s->shutdown = 0;
212
213     if (s->renegotiate) {
214         SSLerr(SSL_F_SSL_CLEAR, ERR_R_INTERNAL_ERROR);
215         return 0;
216     }
217
218     s->type = 0;
219
220     s->state = SSL_ST_BEFORE | ((s->server) ? SSL_ST_ACCEPT : SSL_ST_CONNECT);
221
222     s->version = s->method->version;
223     s->client_version = s->version;
224     s->rwstate = SSL_NOTHING;
225
226     BUF_MEM_free(s->init_buf);
227     s->init_buf = NULL;
228     clear_ciphers(s);
229     s->first_packet = 0;
230
231     /*
232      * Check to see if we were changed into a different method, if so, revert
233      * back if we are not doing session-id reuse.
234      */
235     if (!s->in_handshake && (s->session == NULL)
236         && (s->method != s->ctx->method)) {
237         s->method->ssl_free(s);
238         s->method = s->ctx->method;
239         if (!s->method->ssl_new(s))
240             return (0);
241     } else
242         s->method->ssl_clear(s);
243
244     RECORD_LAYER_clear(&s->rlayer);
245
246     return (1);
247 }
248
249 /** Used to change an SSL_CTXs default SSL method type */
250 int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
251 {
252     STACK_OF(SSL_CIPHER) *sk;
253
254     ctx->method = meth;
255
256     sk = ssl_create_cipher_list(ctx->method, &(ctx->cipher_list),
257                                 &(ctx->cipher_list_by_id),
258                                 SSL_DEFAULT_CIPHER_LIST, ctx->cert);
259     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) {
260         SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,
261                SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
262         return (0);
263     }
264     return (1);
265 }
266
267 SSL *SSL_new(SSL_CTX *ctx)
268 {
269     SSL *s;
270
271     if (ctx == NULL) {
272         SSLerr(SSL_F_SSL_NEW, SSL_R_NULL_SSL_CTX);
273         return (NULL);
274     }
275     if (ctx->method == NULL) {
276         SSLerr(SSL_F_SSL_NEW, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
277         return (NULL);
278     }
279
280     s = OPENSSL_zalloc(sizeof(*s));
281     if (s == NULL)
282         goto err;
283
284     RECORD_LAYER_init(&s->rlayer, s);
285
286     s->options = ctx->options;
287     s->mode = ctx->mode;
288     s->max_cert_list = ctx->max_cert_list;
289     s->references = 1;
290
291     /*
292      * Earlier library versions used to copy the pointer to the CERT, not
293      * its contents; only when setting new parameters for the per-SSL
294      * copy, ssl_cert_new would be called (and the direct reference to
295      * the per-SSL_CTX settings would be lost, but those still were
296      * indirectly accessed for various purposes, and for that reason they
297      * used to be known as s->ctx->default_cert). Now we don't look at the
298      * SSL_CTX's CERT after having duplicated it once.
299      */
300     s->cert = ssl_cert_dup(ctx->cert);
301     if (s->cert == NULL)
302         goto err;
303
304     RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
305     s->msg_callback = ctx->msg_callback;
306     s->msg_callback_arg = ctx->msg_callback_arg;
307     s->verify_mode = ctx->verify_mode;
308     s->not_resumable_session_cb = ctx->not_resumable_session_cb;
309     s->sid_ctx_length = ctx->sid_ctx_length;
310     OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
311     memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
312     s->verify_callback = ctx->default_verify_callback;
313     s->generate_session_id = ctx->generate_session_id;
314
315     s->param = X509_VERIFY_PARAM_new();
316     if (!s->param)
317         goto err;
318     X509_VERIFY_PARAM_inherit(s->param, ctx->param);
319     s->quiet_shutdown = ctx->quiet_shutdown;
320     s->max_send_fragment = ctx->max_send_fragment;
321
322     CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
323     s->ctx = ctx;
324     s->tlsext_debug_cb = 0;
325     s->tlsext_debug_arg = NULL;
326     s->tlsext_ticket_expected = 0;
327     s->tlsext_status_type = -1;
328     s->tlsext_status_expected = 0;
329     s->tlsext_ocsp_ids = NULL;
330     s->tlsext_ocsp_exts = NULL;
331     s->tlsext_ocsp_resp = NULL;
332     s->tlsext_ocsp_resplen = -1;
333     CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
334     s->initial_ctx = ctx;
335 # ifndef OPENSSL_NO_EC
336     if (ctx->tlsext_ecpointformatlist) {
337         s->tlsext_ecpointformatlist =
338             BUF_memdup(ctx->tlsext_ecpointformatlist,
339                        ctx->tlsext_ecpointformatlist_length);
340         if (!s->tlsext_ecpointformatlist)
341             goto err;
342         s->tlsext_ecpointformatlist_length =
343             ctx->tlsext_ecpointformatlist_length;
344     }
345     if (ctx->tlsext_ellipticcurvelist) {
346         s->tlsext_ellipticcurvelist =
347             BUF_memdup(ctx->tlsext_ellipticcurvelist,
348                        ctx->tlsext_ellipticcurvelist_length);
349         if (!s->tlsext_ellipticcurvelist)
350             goto err;
351         s->tlsext_ellipticcurvelist_length =
352             ctx->tlsext_ellipticcurvelist_length;
353     }
354 # endif
355 # ifndef OPENSSL_NO_NEXTPROTONEG
356     s->next_proto_negotiated = NULL;
357 # endif
358
359     if (s->ctx->alpn_client_proto_list) {
360         s->alpn_client_proto_list =
361             OPENSSL_malloc(s->ctx->alpn_client_proto_list_len);
362         if (s->alpn_client_proto_list == NULL)
363             goto err;
364         memcpy(s->alpn_client_proto_list, s->ctx->alpn_client_proto_list,
365                s->ctx->alpn_client_proto_list_len);
366         s->alpn_client_proto_list_len = s->ctx->alpn_client_proto_list_len;
367     }
368
369     s->verify_result = X509_V_OK;
370
371     s->method = ctx->method;
372
373     if (!s->method->ssl_new(s))
374         goto err;
375
376     s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
377
378     if (!SSL_clear(s))
379         goto err;
380
381     CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
382
383 #ifndef OPENSSL_NO_PSK
384     s->psk_client_callback = ctx->psk_client_callback;
385     s->psk_server_callback = ctx->psk_server_callback;
386 #endif
387
388     return (s);
389  err:
390     SSL_free(s);
391     SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
392     return (NULL);
393 }
394
395 int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
396                                    unsigned int sid_ctx_len)
397 {
398     if (sid_ctx_len > sizeof ctx->sid_ctx) {
399         SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,
400                SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
401         return 0;
402     }
403     ctx->sid_ctx_length = sid_ctx_len;
404     memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
405
406     return 1;
407 }
408
409 int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
410                                unsigned int sid_ctx_len)
411 {
412     if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
413         SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,
414                SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
415         return 0;
416     }
417     ssl->sid_ctx_length = sid_ctx_len;
418     memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
419
420     return 1;
421 }
422
423 int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
424 {
425     CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
426     ctx->generate_session_id = cb;
427     CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
428     return 1;
429 }
430
431 int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
432 {
433     CRYPTO_w_lock(CRYPTO_LOCK_SSL);
434     ssl->generate_session_id = cb;
435     CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
436     return 1;
437 }
438
439 int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
440                                 unsigned int id_len)
441 {
442     /*
443      * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
444      * we can "construct" a session to give us the desired check - ie. to
445      * find if there's a session in the hash table that would conflict with
446      * any new session built out of this id/id_len and the ssl_version in use
447      * by this SSL.
448      */
449     SSL_SESSION r, *p;
450
451     if (id_len > sizeof r.session_id)
452         return 0;
453
454     r.ssl_version = ssl->version;
455     r.session_id_length = id_len;
456     memcpy(r.session_id, id, id_len);
457
458     CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
459     p = lh_SSL_SESSION_retrieve(ssl->ctx->sessions, &r);
460     CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
461     return (p != NULL);
462 }
463
464 int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
465 {
466     return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
467 }
468
469 int SSL_set_purpose(SSL *s, int purpose)
470 {
471     return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
472 }
473
474 int SSL_CTX_set_trust(SSL_CTX *s, int trust)
475 {
476     return X509_VERIFY_PARAM_set_trust(s->param, trust);
477 }
478
479 int SSL_set_trust(SSL *s, int trust)
480 {
481     return X509_VERIFY_PARAM_set_trust(s->param, trust);
482 }
483
484 int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
485 {
486     return X509_VERIFY_PARAM_set1(ctx->param, vpm);
487 }
488
489 int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
490 {
491     return X509_VERIFY_PARAM_set1(ssl->param, vpm);
492 }
493
494 X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
495 {
496     return ctx->param;
497 }
498
499 X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
500 {
501     return ssl->param;
502 }
503
504 void SSL_certs_clear(SSL *s)
505 {
506     ssl_cert_clear_certs(s->cert);
507 }
508
509 void SSL_free(SSL *s)
510 {
511     int i;
512
513     if (s == NULL)
514         return;
515
516     i = CRYPTO_add(&s->references, -1, CRYPTO_LOCK_SSL);
517 #ifdef REF_PRINT
518     REF_PRINT("SSL", s);
519 #endif
520     if (i > 0)
521         return;
522 #ifdef REF_CHECK
523     if (i < 0) {
524         fprintf(stderr, "SSL_free, bad reference count\n");
525         abort();                /* ok */
526     }
527 #endif
528
529     X509_VERIFY_PARAM_free(s->param);
530     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
531
532     if (s->bbio != NULL) {
533         /* If the buffering BIO is in place, pop it off */
534         if (s->bbio == s->wbio) {
535             s->wbio = BIO_pop(s->wbio);
536         }
537         BIO_free(s->bbio);
538         s->bbio = NULL;
539     }
540     BIO_free_all(s->rbio);
541     if (s->wbio != s->rbio)
542         BIO_free_all(s->wbio);
543
544     BUF_MEM_free(s->init_buf);
545
546     /* add extra stuff */
547     sk_SSL_CIPHER_free(s->cipher_list);
548     sk_SSL_CIPHER_free(s->cipher_list_by_id);
549
550     /* Make the next call work :-) */
551     if (s->session != NULL) {
552         ssl_clear_bad_session(s);
553         SSL_SESSION_free(s->session);
554     }
555
556     clear_ciphers(s);
557
558     ssl_cert_free(s->cert);
559     /* Free up if allocated */
560
561     OPENSSL_free(s->tlsext_hostname);
562     SSL_CTX_free(s->initial_ctx);
563 #ifndef OPENSSL_NO_EC
564     OPENSSL_free(s->tlsext_ecpointformatlist);
565     OPENSSL_free(s->tlsext_ellipticcurvelist);
566 #endif                         /* OPENSSL_NO_EC */
567     sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts, X509_EXTENSION_free);
568     sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
569     OPENSSL_free(s->tlsext_ocsp_resp);
570     OPENSSL_free(s->alpn_client_proto_list);
571
572     sk_X509_NAME_pop_free(s->client_CA, X509_NAME_free);
573
574     if (s->method != NULL)
575         s->method->ssl_free(s);
576
577     RECORD_LAYER_release(&s->rlayer);
578
579     SSL_CTX_free(s->ctx);
580
581 #if !defined(OPENSSL_NO_NEXTPROTONEG)
582     OPENSSL_free(s->next_proto_negotiated);
583 #endif
584
585 #ifndef OPENSSL_NO_SRTP
586     sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
587 #endif
588
589     OPENSSL_free(s);
590 }
591
592 void SSL_set_rbio(SSL *s, BIO *rbio)
593 {
594     if (s->rbio != rbio)
595         BIO_free_all(s->rbio);
596     s->rbio = rbio;
597 }
598
599 void SSL_set_wbio(SSL *s, BIO *wbio)
600 {
601     /*
602      * If the output buffering BIO is still in place, remove it
603      */
604     if (s->bbio != NULL) {
605         if (s->wbio == s->bbio) {
606             s->wbio = s->wbio->next_bio;
607             s->bbio->next_bio = NULL;
608         }
609     }
610     if (s->wbio != wbio && s->rbio != s->wbio)
611         BIO_free_all(s->wbio);
612     s->wbio = wbio;
613 }
614
615 void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
616 {
617     SSL_set_wbio(s, wbio);
618     SSL_set_rbio(s, rbio);
619 }
620
621 BIO *SSL_get_rbio(const SSL *s)
622 {
623     return (s->rbio);
624 }
625
626 BIO *SSL_get_wbio(const SSL *s)
627 {
628     return (s->wbio);
629 }
630
631 int SSL_get_fd(const SSL *s)
632 {
633     return (SSL_get_rfd(s));
634 }
635
636 int SSL_get_rfd(const SSL *s)
637 {
638     int ret = -1;
639     BIO *b, *r;
640
641     b = SSL_get_rbio(s);
642     r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
643     if (r != NULL)
644         BIO_get_fd(r, &ret);
645     return (ret);
646 }
647
648 int SSL_get_wfd(const SSL *s)
649 {
650     int ret = -1;
651     BIO *b, *r;
652
653     b = SSL_get_wbio(s);
654     r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
655     if (r != NULL)
656         BIO_get_fd(r, &ret);
657     return (ret);
658 }
659
660 #ifndef OPENSSL_NO_SOCK
661 int SSL_set_fd(SSL *s, int fd)
662 {
663     int ret = 0;
664     BIO *bio = NULL;
665
666     bio = BIO_new(BIO_s_socket());
667
668     if (bio == NULL) {
669         SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
670         goto err;
671     }
672     BIO_set_fd(bio, fd, BIO_NOCLOSE);
673     SSL_set_bio(s, bio, bio);
674     ret = 1;
675  err:
676     return (ret);
677 }
678
679 int SSL_set_wfd(SSL *s, int fd)
680 {
681     int ret = 0;
682     BIO *bio = NULL;
683
684     if ((s->rbio == NULL) || (BIO_method_type(s->rbio) != BIO_TYPE_SOCKET)
685         || ((int)BIO_get_fd(s->rbio, NULL) != fd)) {
686         bio = BIO_new(BIO_s_socket());
687
688         if (bio == NULL) {
689             SSLerr(SSL_F_SSL_SET_WFD, ERR_R_BUF_LIB);
690             goto err;
691         }
692         BIO_set_fd(bio, fd, BIO_NOCLOSE);
693         SSL_set_bio(s, SSL_get_rbio(s), bio);
694     } else
695         SSL_set_bio(s, SSL_get_rbio(s), SSL_get_rbio(s));
696     ret = 1;
697  err:
698     return (ret);
699 }
700
701 int SSL_set_rfd(SSL *s, int fd)
702 {
703     int ret = 0;
704     BIO *bio = NULL;
705
706     if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
707         || ((int)BIO_get_fd(s->wbio, NULL) != fd)) {
708         bio = BIO_new(BIO_s_socket());
709
710         if (bio == NULL) {
711             SSLerr(SSL_F_SSL_SET_RFD, ERR_R_BUF_LIB);
712             goto err;
713         }
714         BIO_set_fd(bio, fd, BIO_NOCLOSE);
715         SSL_set_bio(s, bio, SSL_get_wbio(s));
716     } else
717         SSL_set_bio(s, SSL_get_wbio(s), SSL_get_wbio(s));
718     ret = 1;
719  err:
720     return (ret);
721 }
722 #endif
723
724 /* return length of latest Finished message we sent, copy to 'buf' */
725 size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
726 {
727     size_t ret = 0;
728
729     if (s->s3 != NULL) {
730         ret = s->s3->tmp.finish_md_len;
731         if (count > ret)
732             count = ret;
733         memcpy(buf, s->s3->tmp.finish_md, count);
734     }
735     return ret;
736 }
737
738 /* return length of latest Finished message we expected, copy to 'buf' */
739 size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
740 {
741     size_t ret = 0;
742
743     if (s->s3 != NULL) {
744         ret = s->s3->tmp.peer_finish_md_len;
745         if (count > ret)
746             count = ret;
747         memcpy(buf, s->s3->tmp.peer_finish_md, count);
748     }
749     return ret;
750 }
751
752 int SSL_get_verify_mode(const SSL *s)
753 {
754     return (s->verify_mode);
755 }
756
757 int SSL_get_verify_depth(const SSL *s)
758 {
759     return X509_VERIFY_PARAM_get_depth(s->param);
760 }
761
762 int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
763     return (s->verify_callback);
764 }
765
766 int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
767 {
768     return (ctx->verify_mode);
769 }
770
771 int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
772 {
773     return X509_VERIFY_PARAM_get_depth(ctx->param);
774 }
775
776 int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
777     return (ctx->default_verify_callback);
778 }
779
780 void SSL_set_verify(SSL *s, int mode,
781                     int (*callback) (int ok, X509_STORE_CTX *ctx))
782 {
783     s->verify_mode = mode;
784     if (callback != NULL)
785         s->verify_callback = callback;
786 }
787
788 void SSL_set_verify_depth(SSL *s, int depth)
789 {
790     X509_VERIFY_PARAM_set_depth(s->param, depth);
791 }
792
793 void SSL_set_read_ahead(SSL *s, int yes)
794 {
795     RECORD_LAYER_set_read_ahead(&s->rlayer, yes);
796 }
797
798 int SSL_get_read_ahead(const SSL *s)
799 {
800     return RECORD_LAYER_get_read_ahead(&s->rlayer);
801 }
802
803 int SSL_pending(const SSL *s)
804 {
805     /*
806      * SSL_pending cannot work properly if read-ahead is enabled
807      * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)), and it is
808      * impossible to fix since SSL_pending cannot report errors that may be
809      * observed while scanning the new data. (Note that SSL_pending() is
810      * often used as a boolean value, so we'd better not return -1.)
811      */
812     return (s->method->ssl_pending(s));
813 }
814
815 X509 *SSL_get_peer_certificate(const SSL *s)
816 {
817     X509 *r;
818
819     if ((s == NULL) || (s->session == NULL))
820         r = NULL;
821     else
822         r = s->session->peer;
823
824     if (r == NULL)
825         return (r);
826
827     X509_up_ref(r);
828
829     return (r);
830 }
831
832 STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
833 {
834     STACK_OF(X509) *r;
835
836     if ((s == NULL) || (s->session == NULL))
837         r = NULL;
838     else
839         r = s->session->peer_chain;
840
841     /*
842      * If we are a client, cert_chain includes the peer's own certificate; if
843      * we are a server, it does not.
844      */
845
846     return (r);
847 }
848
849 /*
850  * Now in theory, since the calling process own 't' it should be safe to
851  * modify.  We need to be able to read f without being hassled
852  */
853 int SSL_copy_session_id(SSL *t, const SSL *f)
854 {
855     /* Do we need to to SSL locking? */
856     if (!SSL_set_session(t, SSL_get_session(f))) {
857         return 0;
858     }
859
860     /*
861      * what if we are setup as SSLv2 but want to talk SSLv3 or vice-versa
862      */
863     if (t->method != f->method) {
864         t->method->ssl_free(t); /* cleanup current */
865         t->method = f->method;  /* change method */
866         t->method->ssl_new(t);  /* setup new */
867     }
868
869     CRYPTO_add(&f->cert->references, 1, CRYPTO_LOCK_SSL_CERT);
870     ssl_cert_free(t->cert);
871     t->cert = f->cert;
872     if (!SSL_set_session_id_context(t, f->sid_ctx, f->sid_ctx_length)) {
873         return 0;
874     }
875
876     return 1;
877 }
878
879 /* Fix this so it checks all the valid key/cert options */
880 int SSL_CTX_check_private_key(const SSL_CTX *ctx)
881 {
882     if ((ctx == NULL) ||
883         (ctx->cert->key->x509 == NULL)) {
884         SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,
885                SSL_R_NO_CERTIFICATE_ASSIGNED);
886         return (0);
887     }
888     if (ctx->cert->key->privatekey == NULL) {
889         SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,
890                SSL_R_NO_PRIVATE_KEY_ASSIGNED);
891         return (0);
892     }
893     return (X509_check_private_key
894             (ctx->cert->key->x509, ctx->cert->key->privatekey));
895 }
896
897 /* Fix this function so that it takes an optional type parameter */
898 int SSL_check_private_key(const SSL *ssl)
899 {
900     if (ssl == NULL) {
901         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
902         return (0);
903     }
904     if (ssl->cert->key->x509 == NULL) {
905         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_CERTIFICATE_ASSIGNED);
906         return (0);
907     }
908     if (ssl->cert->key->privatekey == NULL) {
909         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
910         return (0);
911     }
912     return (X509_check_private_key(ssl->cert->key->x509,
913                                    ssl->cert->key->privatekey));
914 }
915
916 int SSL_accept(SSL *s)
917 {
918     if (s->handshake_func == 0)
919         /* Not properly initialized yet */
920         SSL_set_accept_state(s);
921
922     return (s->method->ssl_accept(s));
923 }
924
925 int SSL_connect(SSL *s)
926 {
927     if (s->handshake_func == 0)
928         /* Not properly initialized yet */
929         SSL_set_connect_state(s);
930
931     return (s->method->ssl_connect(s));
932 }
933
934 long SSL_get_default_timeout(const SSL *s)
935 {
936     return (s->method->get_timeout());
937 }
938
939 int SSL_read(SSL *s, void *buf, int num)
940 {
941     if (s->handshake_func == 0) {
942         SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
943         return -1;
944     }
945
946     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
947         s->rwstate = SSL_NOTHING;
948         return (0);
949     }
950     return (s->method->ssl_read(s, buf, num));
951 }
952
953 int SSL_peek(SSL *s, void *buf, int num)
954 {
955     if (s->handshake_func == 0) {
956         SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
957         return -1;
958     }
959
960     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
961         return (0);
962     }
963     return (s->method->ssl_peek(s, buf, num));
964 }
965
966 int SSL_write(SSL *s, const void *buf, int num)
967 {
968     if (s->handshake_func == 0) {
969         SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
970         return -1;
971     }
972
973     if (s->shutdown & SSL_SENT_SHUTDOWN) {
974         s->rwstate = SSL_NOTHING;
975         SSLerr(SSL_F_SSL_WRITE, SSL_R_PROTOCOL_IS_SHUTDOWN);
976         return (-1);
977     }
978     return (s->method->ssl_write(s, buf, num));
979 }
980
981 int SSL_shutdown(SSL *s)
982 {
983     /*
984      * Note that this function behaves differently from what one might
985      * expect.  Return values are 0 for no success (yet), 1 for success; but
986      * calling it once is usually not enough, even if blocking I/O is used
987      * (see ssl3_shutdown).
988      */
989
990     if (s->handshake_func == 0) {
991         SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
992         return -1;
993     }
994
995     if ((s != NULL) && !SSL_in_init(s))
996         return (s->method->ssl_shutdown(s));
997     else
998         return (1);
999 }
1000
1001 int SSL_renegotiate(SSL *s)
1002 {
1003     if (s->renegotiate == 0)
1004         s->renegotiate = 1;
1005
1006     s->new_session = 1;
1007
1008     return (s->method->ssl_renegotiate(s));
1009 }
1010
1011 int SSL_renegotiate_abbreviated(SSL *s)
1012 {
1013     if (s->renegotiate == 0)
1014         s->renegotiate = 1;
1015
1016     s->new_session = 0;
1017
1018     return (s->method->ssl_renegotiate(s));
1019 }
1020
1021 int SSL_renegotiate_pending(SSL *s)
1022 {
1023     /*
1024      * becomes true when negotiation is requested; false again once a
1025      * handshake has finished
1026      */
1027     return (s->renegotiate != 0);
1028 }
1029
1030 long SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
1031 {
1032     long l;
1033
1034     switch (cmd) {
1035     case SSL_CTRL_GET_READ_AHEAD:
1036         return (RECORD_LAYER_get_read_ahead(&s->rlayer));
1037     case SSL_CTRL_SET_READ_AHEAD:
1038         l = RECORD_LAYER_get_read_ahead(&s->rlayer);
1039         RECORD_LAYER_set_read_ahead(&s->rlayer, larg);
1040         return (l);
1041
1042     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1043         s->msg_callback_arg = parg;
1044         return 1;
1045
1046     case SSL_CTRL_OPTIONS:
1047         return (s->options |= larg);
1048     case SSL_CTRL_CLEAR_OPTIONS:
1049         return (s->options &= ~larg);
1050     case SSL_CTRL_MODE:
1051         return (s->mode |= larg);
1052     case SSL_CTRL_CLEAR_MODE:
1053         return (s->mode &= ~larg);
1054     case SSL_CTRL_GET_MAX_CERT_LIST:
1055         return (s->max_cert_list);
1056     case SSL_CTRL_SET_MAX_CERT_LIST:
1057         l = s->max_cert_list;
1058         s->max_cert_list = larg;
1059         return (l);
1060     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1061         if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1062             return 0;
1063         s->max_send_fragment = larg;
1064         return 1;
1065     case SSL_CTRL_GET_RI_SUPPORT:
1066         if (s->s3)
1067             return s->s3->send_connection_binding;
1068         else
1069             return 0;
1070     case SSL_CTRL_CERT_FLAGS:
1071         return (s->cert->cert_flags |= larg);
1072     case SSL_CTRL_CLEAR_CERT_FLAGS:
1073         return (s->cert->cert_flags &= ~larg);
1074
1075     case SSL_CTRL_GET_RAW_CIPHERLIST:
1076         if (parg) {
1077             if (s->s3->tmp.ciphers_raw == NULL)
1078                 return 0;
1079             *(unsigned char **)parg = s->s3->tmp.ciphers_raw;
1080             return (int)s->s3->tmp.ciphers_rawlen;
1081         } else
1082             return ssl_put_cipher_by_char(s, NULL, NULL);
1083     case SSL_CTRL_GET_EXTMS_SUPPORT:
1084         if (!s->session || SSL_in_init(s) || s->in_handshake)
1085                 return -1;
1086         if (s->session->flags & SSL_SESS_FLAG_EXTMS)
1087             return 1;
1088         else
1089             return 0;
1090     default:
1091         return (s->method->ssl_ctrl(s, cmd, larg, parg));
1092     }
1093 }
1094
1095 long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
1096 {
1097     switch (cmd) {
1098     case SSL_CTRL_SET_MSG_CALLBACK:
1099         s->msg_callback = (void (*)
1100                            (int write_p, int version, int content_type,
1101                             const void *buf, size_t len, SSL *ssl,
1102                             void *arg))(fp);
1103         return 1;
1104
1105     default:
1106         return (s->method->ssl_callback_ctrl(s, cmd, fp));
1107     }
1108 }
1109
1110 LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
1111 {
1112     return ctx->sessions;
1113 }
1114
1115 long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
1116 {
1117     long l;
1118     /* For some cases with ctx == NULL perform syntax checks */
1119     if (ctx == NULL) {
1120         switch (cmd) {
1121 #ifndef OPENSSL_NO_EC
1122         case SSL_CTRL_SET_CURVES_LIST:
1123             return tls1_set_curves_list(NULL, NULL, parg);
1124 #endif
1125         case SSL_CTRL_SET_SIGALGS_LIST:
1126         case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
1127             return tls1_set_sigalgs_list(NULL, parg, 0);
1128         default:
1129             return 0;
1130         }
1131     }
1132
1133     switch (cmd) {
1134     case SSL_CTRL_GET_READ_AHEAD:
1135         return (ctx->read_ahead);
1136     case SSL_CTRL_SET_READ_AHEAD:
1137         l = ctx->read_ahead;
1138         ctx->read_ahead = larg;
1139         return (l);
1140
1141     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1142         ctx->msg_callback_arg = parg;
1143         return 1;
1144
1145     case SSL_CTRL_GET_MAX_CERT_LIST:
1146         return (ctx->max_cert_list);
1147     case SSL_CTRL_SET_MAX_CERT_LIST:
1148         l = ctx->max_cert_list;
1149         ctx->max_cert_list = larg;
1150         return (l);
1151
1152     case SSL_CTRL_SET_SESS_CACHE_SIZE:
1153         l = ctx->session_cache_size;
1154         ctx->session_cache_size = larg;
1155         return (l);
1156     case SSL_CTRL_GET_SESS_CACHE_SIZE:
1157         return (ctx->session_cache_size);
1158     case SSL_CTRL_SET_SESS_CACHE_MODE:
1159         l = ctx->session_cache_mode;
1160         ctx->session_cache_mode = larg;
1161         return (l);
1162     case SSL_CTRL_GET_SESS_CACHE_MODE:
1163         return (ctx->session_cache_mode);
1164
1165     case SSL_CTRL_SESS_NUMBER:
1166         return (lh_SSL_SESSION_num_items(ctx->sessions));
1167     case SSL_CTRL_SESS_CONNECT:
1168         return (ctx->stats.sess_connect);
1169     case SSL_CTRL_SESS_CONNECT_GOOD:
1170         return (ctx->stats.sess_connect_good);
1171     case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
1172         return (ctx->stats.sess_connect_renegotiate);
1173     case SSL_CTRL_SESS_ACCEPT:
1174         return (ctx->stats.sess_accept);
1175     case SSL_CTRL_SESS_ACCEPT_GOOD:
1176         return (ctx->stats.sess_accept_good);
1177     case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
1178         return (ctx->stats.sess_accept_renegotiate);
1179     case SSL_CTRL_SESS_HIT:
1180         return (ctx->stats.sess_hit);
1181     case SSL_CTRL_SESS_CB_HIT:
1182         return (ctx->stats.sess_cb_hit);
1183     case SSL_CTRL_SESS_MISSES:
1184         return (ctx->stats.sess_miss);
1185     case SSL_CTRL_SESS_TIMEOUTS:
1186         return (ctx->stats.sess_timeout);
1187     case SSL_CTRL_SESS_CACHE_FULL:
1188         return (ctx->stats.sess_cache_full);
1189     case SSL_CTRL_OPTIONS:
1190         return (ctx->options |= larg);
1191     case SSL_CTRL_CLEAR_OPTIONS:
1192         return (ctx->options &= ~larg);
1193     case SSL_CTRL_MODE:
1194         return (ctx->mode |= larg);
1195     case SSL_CTRL_CLEAR_MODE:
1196         return (ctx->mode &= ~larg);
1197     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1198         if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1199             return 0;
1200         ctx->max_send_fragment = larg;
1201         return 1;
1202     case SSL_CTRL_CERT_FLAGS:
1203         return (ctx->cert->cert_flags |= larg);
1204     case SSL_CTRL_CLEAR_CERT_FLAGS:
1205         return (ctx->cert->cert_flags &= ~larg);
1206     default:
1207         return (ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg));
1208     }
1209 }
1210
1211 long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
1212 {
1213     switch (cmd) {
1214     case SSL_CTRL_SET_MSG_CALLBACK:
1215         ctx->msg_callback = (void (*)
1216                              (int write_p, int version, int content_type,
1217                               const void *buf, size_t len, SSL *ssl,
1218                               void *arg))(fp);
1219         return 1;
1220
1221     default:
1222         return (ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp));
1223     }
1224 }
1225
1226 int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
1227 {
1228     long l;
1229
1230     l = a->id - b->id;
1231     if (l == 0L)
1232         return (0);
1233     else
1234         return ((l > 0) ? 1 : -1);
1235 }
1236
1237 int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
1238                           const SSL_CIPHER *const *bp)
1239 {
1240     long l;
1241
1242     l = (*ap)->id - (*bp)->id;
1243     if (l == 0L)
1244         return (0);
1245     else
1246         return ((l > 0) ? 1 : -1);
1247 }
1248
1249 /** return a STACK of the ciphers available for the SSL and in order of
1250  * preference */
1251 STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
1252 {
1253     if (s != NULL) {
1254         if (s->cipher_list != NULL) {
1255             return (s->cipher_list);
1256         } else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) {
1257             return (s->ctx->cipher_list);
1258         }
1259     }
1260     return (NULL);
1261 }
1262
1263 STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s)
1264 {
1265     if ((s == NULL) || (s->session == NULL) || !s->server)
1266         return NULL;
1267     return s->session->ciphers;
1268 }
1269
1270 STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
1271 {
1272     STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
1273     int i;
1274     ciphers = SSL_get_ciphers(s);
1275     if (!ciphers)
1276         return NULL;
1277     ssl_set_client_disabled(s);
1278     for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1279         const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
1280         if (!ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED)) {
1281             if (!sk)
1282                 sk = sk_SSL_CIPHER_new_null();
1283             if (!sk)
1284                 return NULL;
1285             if (!sk_SSL_CIPHER_push(sk, c)) {
1286                 sk_SSL_CIPHER_free(sk);
1287                 return NULL;
1288             }
1289         }
1290     }
1291     return sk;
1292 }
1293
1294 /** return a STACK of the ciphers available for the SSL and in order of
1295  * algorithm id */
1296 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
1297 {
1298     if (s != NULL) {
1299         if (s->cipher_list_by_id != NULL) {
1300             return (s->cipher_list_by_id);
1301         } else if ((s->ctx != NULL) && (s->ctx->cipher_list_by_id != NULL)) {
1302             return (s->ctx->cipher_list_by_id);
1303         }
1304     }
1305     return (NULL);
1306 }
1307
1308 /** The old interface to get the same thing as SSL_get_ciphers() */
1309 const char *SSL_get_cipher_list(const SSL *s, int n)
1310 {
1311     SSL_CIPHER *c;
1312     STACK_OF(SSL_CIPHER) *sk;
1313
1314     if (s == NULL)
1315         return (NULL);
1316     sk = SSL_get_ciphers(s);
1317     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
1318         return (NULL);
1319     c = sk_SSL_CIPHER_value(sk, n);
1320     if (c == NULL)
1321         return (NULL);
1322     return (c->name);
1323 }
1324
1325 /** specify the ciphers to be used by default by the SSL_CTX */
1326 int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
1327 {
1328     STACK_OF(SSL_CIPHER) *sk;
1329
1330     sk = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
1331                                 &ctx->cipher_list_by_id, str, ctx->cert);
1332     /*
1333      * ssl_create_cipher_list may return an empty stack if it was unable to
1334      * find a cipher matching the given rule string (for example if the rule
1335      * string specifies a cipher which has been disabled). This is not an
1336      * error as far as ssl_create_cipher_list is concerned, and hence
1337      * ctx->cipher_list and ctx->cipher_list_by_id has been updated.
1338      */
1339     if (sk == NULL)
1340         return 0;
1341     else if (sk_SSL_CIPHER_num(sk) == 0) {
1342         SSLerr(SSL_F_SSL_CTX_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
1343         return 0;
1344     }
1345     return 1;
1346 }
1347
1348 /** specify the ciphers to be used by the SSL */
1349 int SSL_set_cipher_list(SSL *s, const char *str)
1350 {
1351     STACK_OF(SSL_CIPHER) *sk;
1352
1353     sk = ssl_create_cipher_list(s->ctx->method, &s->cipher_list,
1354                                 &s->cipher_list_by_id, str, s->cert);
1355     /* see comment in SSL_CTX_set_cipher_list */
1356     if (sk == NULL)
1357         return 0;
1358     else if (sk_SSL_CIPHER_num(sk) == 0) {
1359         SSLerr(SSL_F_SSL_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
1360         return 0;
1361     }
1362     return 1;
1363 }
1364
1365 /* works well for SSLv2, not so good for SSLv3 */
1366 char *SSL_get_shared_ciphers(const SSL *s, char *buf, int len)
1367 {
1368     char *p;
1369     STACK_OF(SSL_CIPHER) *sk;
1370     SSL_CIPHER *c;
1371     int i;
1372
1373     if ((s->session == NULL) || (s->session->ciphers == NULL) || (len < 2))
1374         return (NULL);
1375
1376     p = buf;
1377     sk = s->session->ciphers;
1378
1379     if (sk_SSL_CIPHER_num(sk) == 0)
1380         return NULL;
1381
1382     for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
1383         int n;
1384
1385         c = sk_SSL_CIPHER_value(sk, i);
1386         n = strlen(c->name);
1387         if (n + 1 > len) {
1388             if (p != buf)
1389                 --p;
1390             *p = '\0';
1391             return buf;
1392         }
1393         strcpy(p, c->name);
1394         p += n;
1395         *(p++) = ':';
1396         len -= n + 1;
1397     }
1398     p[-1] = '\0';
1399     return (buf);
1400 }
1401
1402 /** return a servername extension value if provided in Client Hello, or NULL.
1403  * So far, only host_name types are defined (RFC 3546).
1404  */
1405
1406 const char *SSL_get_servername(const SSL *s, const int type)
1407 {
1408     if (type != TLSEXT_NAMETYPE_host_name)
1409         return NULL;
1410
1411     return s->session && !s->tlsext_hostname ?
1412         s->session->tlsext_hostname : s->tlsext_hostname;
1413 }
1414
1415 int SSL_get_servername_type(const SSL *s)
1416 {
1417     if (s->session
1418         && (!s->tlsext_hostname ? s->session->
1419             tlsext_hostname : s->tlsext_hostname))
1420         return TLSEXT_NAMETYPE_host_name;
1421     return -1;
1422 }
1423
1424 /*
1425  * SSL_select_next_proto implements the standard protocol selection. It is
1426  * expected that this function is called from the callback set by
1427  * SSL_CTX_set_next_proto_select_cb. The protocol data is assumed to be a
1428  * vector of 8-bit, length prefixed byte strings. The length byte itself is
1429  * not included in the length. A byte string of length 0 is invalid. No byte
1430  * string may be truncated. The current, but experimental algorithm for
1431  * selecting the protocol is: 1) If the server doesn't support NPN then this
1432  * is indicated to the callback. In this case, the client application has to
1433  * abort the connection or have a default application level protocol. 2) If
1434  * the server supports NPN, but advertises an empty list then the client
1435  * selects the first protcol in its list, but indicates via the API that this
1436  * fallback case was enacted. 3) Otherwise, the client finds the first
1437  * protocol in the server's list that it supports and selects this protocol.
1438  * This is because it's assumed that the server has better information about
1439  * which protocol a client should use. 4) If the client doesn't support any
1440  * of the server's advertised protocols, then this is treated the same as
1441  * case 2. It returns either OPENSSL_NPN_NEGOTIATED if a common protocol was
1442  * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
1443  */
1444 int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
1445                           const unsigned char *server,
1446                           unsigned int server_len,
1447                           const unsigned char *client,
1448                           unsigned int client_len)
1449 {
1450     unsigned int i, j;
1451     const unsigned char *result;
1452     int status = OPENSSL_NPN_UNSUPPORTED;
1453
1454     /*
1455      * For each protocol in server preference order, see if we support it.
1456      */
1457     for (i = 0; i < server_len;) {
1458         for (j = 0; j < client_len;) {
1459             if (server[i] == client[j] &&
1460                 memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) {
1461                 /* We found a match */
1462                 result = &server[i];
1463                 status = OPENSSL_NPN_NEGOTIATED;
1464                 goto found;
1465             }
1466             j += client[j];
1467             j++;
1468         }
1469         i += server[i];
1470         i++;
1471     }
1472
1473     /* There's no overlap between our protocols and the server's list. */
1474     result = client;
1475     status = OPENSSL_NPN_NO_OVERLAP;
1476
1477  found:
1478     *out = (unsigned char *)result + 1;
1479     *outlen = result[0];
1480     return status;
1481 }
1482
1483 #ifndef OPENSSL_NO_NEXTPROTONEG
1484 /*
1485  * SSL_get0_next_proto_negotiated sets *data and *len to point to the
1486  * client's requested protocol for this connection and returns 0. If the
1487  * client didn't request any protocol, then *data is set to NULL. Note that
1488  * the client can request any protocol it chooses. The value returned from
1489  * this function need not be a member of the list of supported protocols
1490  * provided by the callback.
1491  */
1492 void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
1493                                     unsigned *len)
1494 {
1495     *data = s->next_proto_negotiated;
1496     if (!*data) {
1497         *len = 0;
1498     } else {
1499         *len = s->next_proto_negotiated_len;
1500     }
1501 }
1502
1503 /*
1504  * SSL_CTX_set_next_protos_advertised_cb sets a callback that is called when
1505  * a TLS server needs a list of supported protocols for Next Protocol
1506  * Negotiation. The returned list must be in wire format.  The list is
1507  * returned by setting |out| to point to it and |outlen| to its length. This
1508  * memory will not be modified, but one should assume that the SSL* keeps a
1509  * reference to it. The callback should return SSL_TLSEXT_ERR_OK if it
1510  * wishes to advertise. Otherwise, no such extension will be included in the
1511  * ServerHello.
1512  */
1513 void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *ctx,
1514                                            int (*cb) (SSL *ssl,
1515                                                       const unsigned char
1516                                                       **out,
1517                                                       unsigned int *outlen,
1518                                                       void *arg), void *arg)
1519 {
1520     ctx->next_protos_advertised_cb = cb;
1521     ctx->next_protos_advertised_cb_arg = arg;
1522 }
1523
1524 /*
1525  * SSL_CTX_set_next_proto_select_cb sets a callback that is called when a
1526  * client needs to select a protocol from the server's provided list. |out|
1527  * must be set to point to the selected protocol (which may be within |in|).
1528  * The length of the protocol name must be written into |outlen|. The
1529  * server's advertised protocols are provided in |in| and |inlen|. The
1530  * callback can assume that |in| is syntactically valid. The client must
1531  * select a protocol. It is fatal to the connection if this callback returns
1532  * a value other than SSL_TLSEXT_ERR_OK.
1533  */
1534 void SSL_CTX_set_next_proto_select_cb(SSL_CTX *ctx,
1535                                       int (*cb) (SSL *s, unsigned char **out,
1536                                                  unsigned char *outlen,
1537                                                  const unsigned char *in,
1538                                                  unsigned int inlen,
1539                                                  void *arg), void *arg)
1540 {
1541     ctx->next_proto_select_cb = cb;
1542     ctx->next_proto_select_cb_arg = arg;
1543 }
1544 #endif
1545
1546 /*
1547  * SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|.
1548  * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
1549  * length-prefixed strings). Returns 0 on success.
1550  */
1551 int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
1552                             unsigned protos_len)
1553 {
1554     OPENSSL_free(ctx->alpn_client_proto_list);
1555     ctx->alpn_client_proto_list = OPENSSL_malloc(protos_len);
1556     if (!ctx->alpn_client_proto_list)
1557         return 1;
1558     memcpy(ctx->alpn_client_proto_list, protos, protos_len);
1559     ctx->alpn_client_proto_list_len = protos_len;
1560
1561     return 0;
1562 }
1563
1564 /*
1565  * SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|.
1566  * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
1567  * length-prefixed strings). Returns 0 on success.
1568  */
1569 int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
1570                         unsigned protos_len)
1571 {
1572     OPENSSL_free(ssl->alpn_client_proto_list);
1573     ssl->alpn_client_proto_list = OPENSSL_malloc(protos_len);
1574     if (!ssl->alpn_client_proto_list)
1575         return 1;
1576     memcpy(ssl->alpn_client_proto_list, protos, protos_len);
1577     ssl->alpn_client_proto_list_len = protos_len;
1578
1579     return 0;
1580 }
1581
1582 /*
1583  * SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is
1584  * called during ClientHello processing in order to select an ALPN protocol
1585  * from the client's list of offered protocols.
1586  */
1587 void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
1588                                 int (*cb) (SSL *ssl,
1589                                            const unsigned char **out,
1590                                            unsigned char *outlen,
1591                                            const unsigned char *in,
1592                                            unsigned int inlen,
1593                                            void *arg), void *arg)
1594 {
1595     ctx->alpn_select_cb = cb;
1596     ctx->alpn_select_cb_arg = arg;
1597 }
1598
1599 /*
1600  * SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from
1601  * |ssl|. On return it sets |*data| to point to |*len| bytes of protocol name
1602  * (not including the leading length-prefix byte). If the server didn't
1603  * respond with a negotiated protocol then |*len| will be zero.
1604  */
1605 void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
1606                             unsigned *len)
1607 {
1608     *data = NULL;
1609     if (ssl->s3)
1610         *data = ssl->s3->alpn_selected;
1611     if (*data == NULL)
1612         *len = 0;
1613     else
1614         *len = ssl->s3->alpn_selected_len;
1615 }
1616
1617
1618 int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
1619                                const char *label, size_t llen,
1620                                const unsigned char *p, size_t plen,
1621                                int use_context)
1622 {
1623     if (s->version < TLS1_VERSION)
1624         return -1;
1625
1626     return s->method->ssl3_enc->export_keying_material(s, out, olen, label,
1627                                                        llen, p, plen,
1628                                                        use_context);
1629 }
1630
1631 static unsigned long ssl_session_hash(const SSL_SESSION *a)
1632 {
1633     unsigned long l;
1634
1635     l = (unsigned long)
1636         ((unsigned int)a->session_id[0]) |
1637         ((unsigned int)a->session_id[1] << 8L) |
1638         ((unsigned long)a->session_id[2] << 16L) |
1639         ((unsigned long)a->session_id[3] << 24L);
1640     return (l);
1641 }
1642
1643 /*
1644  * NB: If this function (or indeed the hash function which uses a sort of
1645  * coarser function than this one) is changed, ensure
1646  * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on
1647  * being able to construct an SSL_SESSION that will collide with any existing
1648  * session with a matching session ID.
1649  */
1650 static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b)
1651 {
1652     if (a->ssl_version != b->ssl_version)
1653         return (1);
1654     if (a->session_id_length != b->session_id_length)
1655         return (1);
1656     return (memcmp(a->session_id, b->session_id, a->session_id_length));
1657 }
1658
1659 /*
1660  * These wrapper functions should remain rather than redeclaring
1661  * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
1662  * variable. The reason is that the functions aren't static, they're exposed
1663  * via ssl.h.
1664  */
1665 static IMPLEMENT_LHASH_HASH_FN(ssl_session, SSL_SESSION)
1666 static IMPLEMENT_LHASH_COMP_FN(ssl_session, SSL_SESSION)
1667
1668 SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
1669 {
1670     SSL_CTX *ret = NULL;
1671
1672     if (meth == NULL) {
1673         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);
1674         return (NULL);
1675     }
1676
1677     if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
1678         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_ONLY_TLS_ALLOWED_IN_FIPS_MODE);
1679         return NULL;
1680     }
1681
1682     if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
1683         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
1684         goto err;
1685     }
1686     ret = OPENSSL_zalloc(sizeof(*ret));
1687     if (ret == NULL)
1688         goto err;
1689
1690     ret->method = meth;
1691     ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
1692     ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
1693     /* We take the system default. */
1694     ret->session_timeout = meth->get_timeout();
1695     ret->references = 1;
1696     ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
1697     ret->verify_mode = SSL_VERIFY_NONE;
1698     if ((ret->cert = ssl_cert_new()) == NULL)
1699         goto err;
1700
1701     ret->sessions = lh_SSL_SESSION_new();
1702     if (ret->sessions == NULL)
1703         goto err;
1704     ret->cert_store = X509_STORE_new();
1705     if (ret->cert_store == NULL)
1706         goto err;
1707
1708     if (!ssl_create_cipher_list(ret->method,
1709                            &ret->cipher_list, &ret->cipher_list_by_id,
1710                            SSL_DEFAULT_CIPHER_LIST, ret->cert)
1711        || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
1712         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_LIBRARY_HAS_NO_CIPHERS);
1713         goto err2;
1714     }
1715
1716     ret->param = X509_VERIFY_PARAM_new();
1717     if (!ret->param)
1718         goto err;
1719
1720     if ((ret->md5 = EVP_get_digestbyname("ssl3-md5")) == NULL) {
1721         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
1722         goto err2;
1723     }
1724     if ((ret->sha1 = EVP_get_digestbyname("ssl3-sha1")) == NULL) {
1725         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
1726         goto err2;
1727     }
1728
1729     if ((ret->client_CA = sk_X509_NAME_new_null()) == NULL)
1730         goto err;
1731
1732     CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
1733
1734     /* No compression for DTLS */
1735     if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
1736         ret->comp_methods = SSL_COMP_get_compression_methods();
1737
1738     ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
1739
1740     /* Setup RFC4507 ticket keys */
1741     if ((RAND_bytes(ret->tlsext_tick_key_name, 16) <= 0)
1742         || (RAND_bytes(ret->tlsext_tick_hmac_key, 16) <= 0)
1743         || (RAND_bytes(ret->tlsext_tick_aes_key, 16) <= 0))
1744         ret->options |= SSL_OP_NO_TICKET;
1745
1746 #ifndef OPENSSL_NO_SRP
1747     if (!SSL_CTX_SRP_CTX_init(ret))
1748         goto err;
1749 #endif
1750 #ifndef OPENSSL_NO_ENGINE
1751 # ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
1752 #  define eng_strx(x)     #x
1753 #  define eng_str(x)      eng_strx(x)
1754     /* Use specific client engine automatically... ignore errors */
1755     {
1756         ENGINE *eng;
1757         eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
1758         if (!eng) {
1759             ERR_clear_error();
1760             ENGINE_load_builtin_engines();
1761             eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
1762         }
1763         if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
1764             ERR_clear_error();
1765     }
1766 # endif
1767 #endif
1768     /*
1769      * Default is to connect to non-RI servers. When RI is more widely
1770      * deployed might change this.
1771      */
1772     ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
1773
1774     return (ret);
1775  err:
1776     SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
1777  err2:
1778     SSL_CTX_free(ret);
1779     return (NULL);
1780 }
1781
1782 void SSL_CTX_free(SSL_CTX *a)
1783 {
1784     int i;
1785
1786     if (a == NULL)
1787         return;
1788
1789     i = CRYPTO_add(&a->references, -1, CRYPTO_LOCK_SSL_CTX);
1790 #ifdef REF_PRINT
1791     REF_PRINT("SSL_CTX", a);
1792 #endif
1793     if (i > 0)
1794         return;
1795 #ifdef REF_CHECK
1796     if (i < 0) {
1797         fprintf(stderr, "SSL_CTX_free, bad reference count\n");
1798         abort();                /* ok */
1799     }
1800 #endif
1801
1802     X509_VERIFY_PARAM_free(a->param);
1803
1804     /*
1805      * Free internal session cache. However: the remove_cb() may reference
1806      * the ex_data of SSL_CTX, thus the ex_data store can only be removed
1807      * after the sessions were flushed.
1808      * As the ex_data handling routines might also touch the session cache,
1809      * the most secure solution seems to be: empty (flush) the cache, then
1810      * free ex_data, then finally free the cache.
1811      * (See ticket [openssl.org #212].)
1812      */
1813     if (a->sessions != NULL)
1814         SSL_CTX_flush_sessions(a, 0);
1815
1816     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
1817     lh_SSL_SESSION_free(a->sessions);
1818     X509_STORE_free(a->cert_store);
1819     sk_SSL_CIPHER_free(a->cipher_list);
1820     sk_SSL_CIPHER_free(a->cipher_list_by_id);
1821     ssl_cert_free(a->cert);
1822     sk_X509_NAME_pop_free(a->client_CA, X509_NAME_free);
1823     sk_X509_pop_free(a->extra_certs, X509_free);
1824     a->comp_methods = NULL;
1825 #ifndef OPENSSL_NO_SRTP
1826     sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles);
1827 #endif
1828 #ifndef OPENSSL_NO_SRP
1829     SSL_CTX_SRP_CTX_free(a);
1830 #endif
1831 #ifndef OPENSSL_NO_ENGINE
1832     if (a->client_cert_engine)
1833         ENGINE_finish(a->client_cert_engine);
1834 #endif
1835
1836 #ifndef OPENSSL_NO_EC
1837     OPENSSL_free(a->tlsext_ecpointformatlist);
1838     OPENSSL_free(a->tlsext_ellipticcurvelist);
1839 #endif
1840     OPENSSL_free(a->alpn_client_proto_list);
1841
1842     OPENSSL_free(a);
1843 }
1844
1845 void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
1846 {
1847     ctx->default_passwd_callback = cb;
1848 }
1849
1850 void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
1851 {
1852     ctx->default_passwd_callback_userdata = u;
1853 }
1854
1855 void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
1856                                       int (*cb) (X509_STORE_CTX *, void *),
1857                                       void *arg)
1858 {
1859     ctx->app_verify_callback = cb;
1860     ctx->app_verify_arg = arg;
1861 }
1862
1863 void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
1864                         int (*cb) (int, X509_STORE_CTX *))
1865 {
1866     ctx->verify_mode = mode;
1867     ctx->default_verify_callback = cb;
1868 }
1869
1870 void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
1871 {
1872     X509_VERIFY_PARAM_set_depth(ctx->param, depth);
1873 }
1874
1875 void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
1876                          void *arg)
1877 {
1878     ssl_cert_set_cert_cb(c->cert, cb, arg);
1879 }
1880
1881 void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
1882 {
1883     ssl_cert_set_cert_cb(s->cert, cb, arg);
1884 }
1885
1886 void ssl_set_masks(SSL *s, const SSL_CIPHER *cipher)
1887 {
1888     CERT_PKEY *cpk;
1889     CERT *c = s->cert;
1890     uint32_t *pvalid = s->s3->tmp.valid_flags;
1891     int rsa_enc, rsa_tmp, rsa_sign, dh_tmp, dh_rsa, dh_dsa, dsa_sign;
1892     int rsa_enc_export, dh_rsa_export, dh_dsa_export;
1893     int rsa_tmp_export, dh_tmp_export, kl;
1894     unsigned long mask_k, mask_a, emask_k, emask_a;
1895 #ifndef OPENSSL_NO_EC
1896     int have_ecc_cert, ecdsa_ok, ecc_pkey_size;
1897     int have_ecdh_tmp, ecdh_ok;
1898     X509 *x = NULL;
1899     EVP_PKEY *ecc_pkey = NULL;
1900     int pk_nid = 0, md_nid = 0;
1901 #endif
1902     if (c == NULL)
1903         return;
1904
1905     kl = SSL_C_EXPORT_PKEYLENGTH(cipher);
1906
1907 #ifndef OPENSSL_NO_RSA
1908     rsa_tmp = (c->rsa_tmp != NULL || c->rsa_tmp_cb != NULL);
1909     rsa_tmp_export = (c->rsa_tmp_cb != NULL ||
1910                       (rsa_tmp && RSA_size(c->rsa_tmp) * 8 <= kl));
1911 #else
1912     rsa_tmp = rsa_tmp_export = 0;
1913 #endif
1914 #ifndef OPENSSL_NO_DH
1915     dh_tmp = (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto);
1916     dh_tmp_export = !c->dh_tmp_auto && (c->dh_tmp_cb != NULL ||
1917                                         (dh_tmp
1918                                          && DH_size(c->dh_tmp) * 8 <= kl));
1919 #else
1920     dh_tmp = dh_tmp_export = 0;
1921 #endif
1922
1923 #ifndef OPENSSL_NO_EC
1924     have_ecdh_tmp = (c->ecdh_tmp || c->ecdh_tmp_cb || c->ecdh_tmp_auto);
1925 #endif
1926     cpk = &(c->pkeys[SSL_PKEY_RSA_ENC]);
1927     rsa_enc = pvalid[SSL_PKEY_RSA_ENC] & CERT_PKEY_VALID;
1928     rsa_enc_export = (rsa_enc && EVP_PKEY_size(cpk->privatekey) * 8 <= kl);
1929     cpk = &(c->pkeys[SSL_PKEY_RSA_SIGN]);
1930     rsa_sign = pvalid[SSL_PKEY_RSA_SIGN] & CERT_PKEY_SIGN;
1931     cpk = &(c->pkeys[SSL_PKEY_DSA_SIGN]);
1932     dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_SIGN;
1933     cpk = &(c->pkeys[SSL_PKEY_DH_RSA]);
1934     dh_rsa = pvalid[SSL_PKEY_DH_RSA] & CERT_PKEY_VALID;
1935     dh_rsa_export = (dh_rsa && EVP_PKEY_size(cpk->privatekey) * 8 <= kl);
1936     cpk = &(c->pkeys[SSL_PKEY_DH_DSA]);
1937     dh_dsa = pvalid[SSL_PKEY_DH_DSA] & CERT_PKEY_VALID;
1938     dh_dsa_export = (dh_dsa && EVP_PKEY_size(cpk->privatekey) * 8 <= kl);
1939     cpk = &(c->pkeys[SSL_PKEY_ECC]);
1940 #ifndef OPENSSL_NO_EC
1941     have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID;
1942 #endif
1943     mask_k = 0;
1944     mask_a = 0;
1945     emask_k = 0;
1946     emask_a = 0;
1947
1948 #ifdef CIPHER_DEBUG
1949     fprintf(stderr,
1950             "rt=%d rte=%d dht=%d ecdht=%d re=%d ree=%d rs=%d ds=%d dhr=%d dhd=%d\n",
1951             rsa_tmp, rsa_tmp_export, dh_tmp, have_ecdh_tmp, rsa_enc,
1952             rsa_enc_export, rsa_sign, dsa_sign, dh_rsa, dh_dsa);
1953 #endif
1954
1955     cpk = &(c->pkeys[SSL_PKEY_GOST01]);
1956     if (cpk->x509 != NULL && cpk->privatekey != NULL) {
1957         mask_k |= SSL_kGOST;
1958         mask_a |= SSL_aGOST01;
1959     }
1960
1961     if (rsa_enc || (rsa_tmp && rsa_sign))
1962         mask_k |= SSL_kRSA;
1963     if (rsa_enc_export || (rsa_tmp_export && (rsa_sign || rsa_enc)))
1964         emask_k |= SSL_kRSA;
1965
1966     if (dh_tmp_export)
1967         emask_k |= SSL_kDHE;
1968
1969     if (dh_tmp)
1970         mask_k |= SSL_kDHE;
1971
1972     if (dh_rsa)
1973         mask_k |= SSL_kDHr;
1974     if (dh_rsa_export)
1975         emask_k |= SSL_kDHr;
1976
1977     if (dh_dsa)
1978         mask_k |= SSL_kDHd;
1979     if (dh_dsa_export)
1980         emask_k |= SSL_kDHd;
1981
1982     if (mask_k & (SSL_kDHr | SSL_kDHd))
1983         mask_a |= SSL_aDH;
1984
1985     if (rsa_enc || rsa_sign) {
1986         mask_a |= SSL_aRSA;
1987         emask_a |= SSL_aRSA;
1988     }
1989
1990     if (dsa_sign) {
1991         mask_a |= SSL_aDSS;
1992         emask_a |= SSL_aDSS;
1993     }
1994
1995     mask_a |= SSL_aNULL;
1996     emask_a |= SSL_aNULL;
1997
1998     /*
1999      * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites
2000      * depending on the key usage extension.
2001      */
2002 #ifndef OPENSSL_NO_EC
2003     if (have_ecc_cert) {
2004         uint32_t ex_kusage;
2005         cpk = &c->pkeys[SSL_PKEY_ECC];
2006         x = cpk->x509;
2007         ex_kusage = X509_get_key_usage(x);
2008         ecdh_ok = ex_kusage & X509v3_KU_KEY_AGREEMENT;
2009         ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE;
2010         if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN))
2011             ecdsa_ok = 0;
2012         ecc_pkey = X509_get_pubkey(x);
2013         ecc_pkey_size = (ecc_pkey != NULL) ? EVP_PKEY_bits(ecc_pkey) : 0;
2014         EVP_PKEY_free(ecc_pkey);
2015         OBJ_find_sigid_algs(X509_get_signature_nid(x), &md_nid, &pk_nid);
2016         if (ecdh_ok) {
2017
2018             if (pk_nid == NID_rsaEncryption || pk_nid == NID_rsa) {
2019                 mask_k |= SSL_kECDHr;
2020                 mask_a |= SSL_aECDH;
2021                 if (ecc_pkey_size <= 163) {
2022                     emask_k |= SSL_kECDHr;
2023                     emask_a |= SSL_aECDH;
2024                 }
2025             }
2026
2027             if (pk_nid == NID_X9_62_id_ecPublicKey) {
2028                 mask_k |= SSL_kECDHe;
2029                 mask_a |= SSL_aECDH;
2030                 if (ecc_pkey_size <= 163) {
2031                     emask_k |= SSL_kECDHe;
2032                     emask_a |= SSL_aECDH;
2033                 }
2034             }
2035         }
2036         if (ecdsa_ok) {
2037             mask_a |= SSL_aECDSA;
2038             emask_a |= SSL_aECDSA;
2039         }
2040     }
2041 #endif
2042
2043 #ifndef OPENSSL_NO_EC
2044     if (have_ecdh_tmp) {
2045         mask_k |= SSL_kECDHE;
2046         emask_k |= SSL_kECDHE;
2047     }
2048 #endif
2049
2050 #ifndef OPENSSL_NO_PSK
2051     mask_k |= SSL_kPSK;
2052     mask_a |= SSL_aPSK;
2053     emask_k |= SSL_kPSK;
2054     emask_a |= SSL_aPSK;
2055     if (mask_k & SSL_kRSA)
2056         mask_k |= SSL_kRSAPSK;
2057     if (mask_k & SSL_kDHE)
2058         mask_k |= SSL_kDHEPSK;
2059     if (mask_k & SSL_kECDHE)
2060         mask_k |= SSL_kECDHEPSK;
2061 #endif
2062
2063     s->s3->tmp.mask_k = mask_k;
2064     s->s3->tmp.mask_a = mask_a;
2065     s->s3->tmp.export_mask_k = emask_k;
2066     s->s3->tmp.export_mask_a = emask_a;
2067 }
2068
2069 #ifndef OPENSSL_NO_EC
2070
2071 int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
2072 {
2073     unsigned long alg_k, alg_a;
2074     EVP_PKEY *pkey = NULL;
2075     int keysize = 0;
2076     int md_nid = 0, pk_nid = 0;
2077     const SSL_CIPHER *cs = s->s3->tmp.new_cipher;
2078     uint32_t ex_kusage = X509_get_key_usage(x);
2079
2080     alg_k = cs->algorithm_mkey;
2081     alg_a = cs->algorithm_auth;
2082
2083     if (SSL_C_IS_EXPORT(cs)) {
2084         /* ECDH key length in export ciphers must be <= 163 bits */
2085         pkey = X509_get_pubkey(x);
2086         if (pkey == NULL)
2087             return 0;
2088         keysize = EVP_PKEY_bits(pkey);
2089         EVP_PKEY_free(pkey);
2090         if (keysize > 163)
2091             return 0;
2092     }
2093
2094     OBJ_find_sigid_algs(X509_get_signature_nid(x), &md_nid, &pk_nid);
2095
2096     if (alg_k & SSL_kECDHe || alg_k & SSL_kECDHr) {
2097         /* key usage, if present, must allow key agreement */
2098         if (!(ex_kusage & X509v3_KU_KEY_AGREEMENT)) {
2099             SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2100                    SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT);
2101             return 0;
2102         }
2103         if ((alg_k & SSL_kECDHe) && TLS1_get_version(s) < TLS1_2_VERSION) {
2104             /* signature alg must be ECDSA */
2105             if (pk_nid != NID_X9_62_id_ecPublicKey) {
2106                 SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2107                        SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE);
2108                 return 0;
2109             }
2110         }
2111         if ((alg_k & SSL_kECDHr) && TLS1_get_version(s) < TLS1_2_VERSION) {
2112             /* signature alg must be RSA */
2113
2114             if (pk_nid != NID_rsaEncryption && pk_nid != NID_rsa) {
2115                 SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2116                        SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE);
2117                 return 0;
2118             }
2119         }
2120     }
2121     if (alg_a & SSL_aECDSA) {
2122         /* key usage, if present, must allow signing */
2123         if (!(ex_kusage & X509v3_KU_DIGITAL_SIGNATURE)) {
2124             SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2125                    SSL_R_ECC_CERT_NOT_FOR_SIGNING);
2126             return 0;
2127         }
2128     }
2129
2130     return 1;                   /* all checks are ok */
2131 }
2132
2133 #endif
2134
2135 static int ssl_get_server_cert_index(const SSL *s)
2136 {
2137     int idx;
2138     idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
2139     if (idx == SSL_PKEY_RSA_ENC && !s->cert->pkeys[SSL_PKEY_RSA_ENC].x509)
2140         idx = SSL_PKEY_RSA_SIGN;
2141     if (idx == -1)
2142         SSLerr(SSL_F_SSL_GET_SERVER_CERT_INDEX, ERR_R_INTERNAL_ERROR);
2143     return idx;
2144 }
2145
2146 CERT_PKEY *ssl_get_server_send_pkey(SSL *s)
2147 {
2148     CERT *c;
2149     int i;
2150
2151     c = s->cert;
2152     if (!s->s3 || !s->s3->tmp.new_cipher)
2153         return NULL;
2154     ssl_set_masks(s, s->s3->tmp.new_cipher);
2155
2156 #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
2157     /*
2158      * Broken protocol test: return last used certificate: which may mismatch
2159      * the one expected.
2160      */
2161     if (c->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
2162         return c->key;
2163 #endif
2164
2165     i = ssl_get_server_cert_index(s);
2166
2167     /* This may or may not be an error. */
2168     if (i < 0)
2169         return NULL;
2170
2171     /* May be NULL. */
2172     return &c->pkeys[i];
2173 }
2174
2175 EVP_PKEY *ssl_get_sign_pkey(SSL *s, const SSL_CIPHER *cipher,
2176                             const EVP_MD **pmd)
2177 {
2178     unsigned long alg_a;
2179     CERT *c;
2180     int idx = -1;
2181
2182     alg_a = cipher->algorithm_auth;
2183     c = s->cert;
2184
2185 #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
2186     /*
2187      * Broken protocol test: use last key: which may mismatch the one
2188      * expected.
2189      */
2190     if (c->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
2191         idx = c->key - c->pkeys;
2192     else
2193 #endif
2194
2195     if ((alg_a & SSL_aDSS) &&
2196             (c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
2197         idx = SSL_PKEY_DSA_SIGN;
2198     else if (alg_a & SSL_aRSA) {
2199         if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
2200             idx = SSL_PKEY_RSA_SIGN;
2201         else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
2202             idx = SSL_PKEY_RSA_ENC;
2203     } else if ((alg_a & SSL_aECDSA) &&
2204                (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
2205         idx = SSL_PKEY_ECC;
2206     if (idx == -1) {
2207         SSLerr(SSL_F_SSL_GET_SIGN_PKEY, ERR_R_INTERNAL_ERROR);
2208         return (NULL);
2209     }
2210     if (pmd)
2211         *pmd = s->s3->tmp.md[idx];
2212     return c->pkeys[idx].privatekey;
2213 }
2214
2215 int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
2216                                    size_t *serverinfo_length)
2217 {
2218     CERT *c = NULL;
2219     int i = 0;
2220     *serverinfo_length = 0;
2221
2222     c = s->cert;
2223     i = ssl_get_server_cert_index(s);
2224
2225     if (i == -1)
2226         return 0;
2227     if (c->pkeys[i].serverinfo == NULL)
2228         return 0;
2229
2230     *serverinfo = c->pkeys[i].serverinfo;
2231     *serverinfo_length = c->pkeys[i].serverinfo_length;
2232     return 1;
2233 }
2234
2235 void ssl_update_cache(SSL *s, int mode)
2236 {
2237     int i;
2238
2239     /*
2240      * If the session_id_length is 0, we are not supposed to cache it, and it
2241      * would be rather hard to do anyway :-)
2242      */
2243     if (s->session->session_id_length == 0)
2244         return;
2245
2246     i = s->session_ctx->session_cache_mode;
2247     if ((i & mode) && (!s->hit)
2248         && ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
2249             || SSL_CTX_add_session(s->session_ctx, s->session))
2250         && (s->session_ctx->new_session_cb != NULL)) {
2251         CRYPTO_add(&s->session->references, 1, CRYPTO_LOCK_SSL_SESSION);
2252         if (!s->session_ctx->new_session_cb(s, s->session))
2253             SSL_SESSION_free(s->session);
2254     }
2255
2256     /* auto flush every 255 connections */
2257     if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) {
2258         if ((((mode & SSL_SESS_CACHE_CLIENT)
2259               ? s->session_ctx->stats.sess_connect_good
2260               : s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff) {
2261             SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL));
2262         }
2263     }
2264 }
2265
2266 const SSL_METHOD *SSL_CTX_get_ssl_method(SSL_CTX *ctx)
2267 {
2268     return ctx->method;
2269 }
2270
2271 const SSL_METHOD *SSL_get_ssl_method(SSL *s)
2272 {
2273     return (s->method);
2274 }
2275
2276 int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
2277 {
2278     int conn = -1;
2279     int ret = 1;
2280
2281     if (s->method != meth) {
2282         if (s->handshake_func != NULL)
2283             conn = (s->handshake_func == s->method->ssl_connect);
2284
2285         if (s->method->version == meth->version)
2286             s->method = meth;
2287         else {
2288             s->method->ssl_free(s);
2289             s->method = meth;
2290             ret = s->method->ssl_new(s);
2291         }
2292
2293         if (conn == 1)
2294             s->handshake_func = meth->ssl_connect;
2295         else if (conn == 0)
2296             s->handshake_func = meth->ssl_accept;
2297     }
2298     return (ret);
2299 }
2300
2301 int SSL_get_error(const SSL *s, int i)
2302 {
2303     int reason;
2304     unsigned long l;
2305     BIO *bio;
2306
2307     if (i > 0)
2308         return (SSL_ERROR_NONE);
2309
2310     /*
2311      * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
2312      * where we do encode the error
2313      */
2314     if ((l = ERR_peek_error()) != 0) {
2315         if (ERR_GET_LIB(l) == ERR_LIB_SYS)
2316             return (SSL_ERROR_SYSCALL);
2317         else
2318             return (SSL_ERROR_SSL);
2319     }
2320
2321     if ((i < 0) && SSL_want_read(s)) {
2322         bio = SSL_get_rbio(s);
2323         if (BIO_should_read(bio))
2324             return (SSL_ERROR_WANT_READ);
2325         else if (BIO_should_write(bio))
2326             /*
2327              * This one doesn't make too much sense ... We never try to write
2328              * to the rbio, and an application program where rbio and wbio
2329              * are separate couldn't even know what it should wait for.
2330              * However if we ever set s->rwstate incorrectly (so that we have
2331              * SSL_want_read(s) instead of SSL_want_write(s)) and rbio and
2332              * wbio *are* the same, this test works around that bug; so it
2333              * might be safer to keep it.
2334              */
2335             return (SSL_ERROR_WANT_WRITE);
2336         else if (BIO_should_io_special(bio)) {
2337             reason = BIO_get_retry_reason(bio);
2338             if (reason == BIO_RR_CONNECT)
2339                 return (SSL_ERROR_WANT_CONNECT);
2340             else if (reason == BIO_RR_ACCEPT)
2341                 return (SSL_ERROR_WANT_ACCEPT);
2342             else
2343                 return (SSL_ERROR_SYSCALL); /* unknown */
2344         }
2345     }
2346
2347     if ((i < 0) && SSL_want_write(s)) {
2348         bio = SSL_get_wbio(s);
2349         if (BIO_should_write(bio))
2350             return (SSL_ERROR_WANT_WRITE);
2351         else if (BIO_should_read(bio))
2352             /*
2353              * See above (SSL_want_read(s) with BIO_should_write(bio))
2354              */
2355             return (SSL_ERROR_WANT_READ);
2356         else if (BIO_should_io_special(bio)) {
2357             reason = BIO_get_retry_reason(bio);
2358             if (reason == BIO_RR_CONNECT)
2359                 return (SSL_ERROR_WANT_CONNECT);
2360             else if (reason == BIO_RR_ACCEPT)
2361                 return (SSL_ERROR_WANT_ACCEPT);
2362             else
2363                 return (SSL_ERROR_SYSCALL);
2364         }
2365     }
2366     if ((i < 0) && SSL_want_x509_lookup(s)) {
2367         return (SSL_ERROR_WANT_X509_LOOKUP);
2368     }
2369
2370     if (i == 0) {
2371         if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2372             (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
2373             return (SSL_ERROR_ZERO_RETURN);
2374     }
2375     return (SSL_ERROR_SYSCALL);
2376 }
2377
2378 int SSL_do_handshake(SSL *s)
2379 {
2380     int ret = 1;
2381
2382     if (s->handshake_func == NULL) {
2383         SSLerr(SSL_F_SSL_DO_HANDSHAKE, SSL_R_CONNECTION_TYPE_NOT_SET);
2384         return (-1);
2385     }
2386
2387     s->method->ssl_renegotiate_check(s);
2388
2389     if (SSL_in_init(s) || SSL_in_before(s)) {
2390         ret = s->handshake_func(s);
2391     }
2392     return (ret);
2393 }
2394
2395 void SSL_set_accept_state(SSL *s)
2396 {
2397     s->server = 1;
2398     s->shutdown = 0;
2399     s->state = SSL_ST_ACCEPT | SSL_ST_BEFORE;
2400     s->handshake_func = s->method->ssl_accept;
2401     clear_ciphers(s);
2402 }
2403
2404 void SSL_set_connect_state(SSL *s)
2405 {
2406     s->server = 0;
2407     s->shutdown = 0;
2408     s->state = SSL_ST_CONNECT | SSL_ST_BEFORE;
2409     s->handshake_func = s->method->ssl_connect;
2410     clear_ciphers(s);
2411 }
2412
2413 int ssl_undefined_function(SSL *s)
2414 {
2415     SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2416     return (0);
2417 }
2418
2419 int ssl_undefined_void_function(void)
2420 {
2421     SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,
2422            ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2423     return (0);
2424 }
2425
2426 int ssl_undefined_const_function(const SSL *s)
2427 {
2428     SSLerr(SSL_F_SSL_UNDEFINED_CONST_FUNCTION,
2429            ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2430     return (0);
2431 }
2432
2433 SSL_METHOD *ssl_bad_method(int ver)
2434 {
2435     SSLerr(SSL_F_SSL_BAD_METHOD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2436     return (NULL);
2437 }
2438
2439 const char *SSL_get_version(const SSL *s)
2440 {
2441     if (s->version == TLS1_2_VERSION)
2442         return ("TLSv1.2");
2443     else if (s->version == TLS1_1_VERSION)
2444         return ("TLSv1.1");
2445     else if (s->version == TLS1_VERSION)
2446         return ("TLSv1");
2447     else if (s->version == SSL3_VERSION)
2448         return ("SSLv3");
2449     else if (s->version == DTLS1_BAD_VER)
2450         return ("DTLSv0.9");
2451     else if (s->version == DTLS1_VERSION)
2452         return ("DTLSv1");
2453     else if (s->version == DTLS1_2_VERSION)
2454         return ("DTLSv1.2");
2455     else
2456         return ("unknown");
2457 }
2458
2459 SSL *SSL_dup(SSL *s)
2460 {
2461     STACK_OF(X509_NAME) *sk;
2462     X509_NAME *xn;
2463     SSL *ret;
2464     int i;
2465
2466     if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
2467         return (NULL);
2468
2469     ret->version = s->version;
2470     ret->type = s->type;
2471     ret->method = s->method;
2472
2473     if (s->session != NULL) {
2474         /* This copies session-id, SSL_METHOD, sid_ctx, and 'cert' */
2475         if (!SSL_copy_session_id(ret, s))
2476             goto err;
2477     } else {
2478         /*
2479          * No session has been established yet, so we have to expect that
2480          * s->cert or ret->cert will be changed later -- they should not both
2481          * point to the same object, and thus we can't use
2482          * SSL_copy_session_id.
2483          */
2484
2485         ret->method->ssl_free(ret);
2486         ret->method = s->method;
2487         ret->method->ssl_new(ret);
2488
2489         if (s->cert != NULL) {
2490             ssl_cert_free(ret->cert);
2491             ret->cert = ssl_cert_dup(s->cert);
2492             if (ret->cert == NULL)
2493                 goto err;
2494         }
2495
2496         if (!SSL_set_session_id_context(ret, s->sid_ctx, s->sid_ctx_length))
2497             goto err;
2498     }
2499
2500     ret->options = s->options;
2501     ret->mode = s->mode;
2502     SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
2503     SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
2504     ret->msg_callback = s->msg_callback;
2505     ret->msg_callback_arg = s->msg_callback_arg;
2506     SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
2507     SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
2508     ret->generate_session_id = s->generate_session_id;
2509
2510     SSL_set_info_callback(ret, SSL_get_info_callback(s));
2511
2512     ret->debug = s->debug;
2513
2514     /* copy app data, a little dangerous perhaps */
2515     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
2516         goto err;
2517
2518     /* setup rbio, and wbio */
2519     if (s->rbio != NULL) {
2520         if (!BIO_dup_state(s->rbio, (char *)&ret->rbio))
2521             goto err;
2522     }
2523     if (s->wbio != NULL) {
2524         if (s->wbio != s->rbio) {
2525             if (!BIO_dup_state(s->wbio, (char *)&ret->wbio))
2526                 goto err;
2527         } else
2528             ret->wbio = ret->rbio;
2529     }
2530     ret->rwstate = s->rwstate;
2531     ret->in_handshake = s->in_handshake;
2532     ret->handshake_func = s->handshake_func;
2533     ret->server = s->server;
2534     ret->renegotiate = s->renegotiate;
2535     ret->new_session = s->new_session;
2536     ret->quiet_shutdown = s->quiet_shutdown;
2537     ret->shutdown = s->shutdown;
2538     ret->state = s->state;      /* SSL_dup does not really work at any state,
2539                                  * though */
2540     RECORD_LAYER_dup(&ret->rlayer, &s->rlayer);
2541     ret->init_num = 0;          /* would have to copy ret->init_buf,
2542                                  * ret->init_msg, ret->init_num,
2543                                  * ret->init_off */
2544     ret->hit = s->hit;
2545
2546     X509_VERIFY_PARAM_inherit(ret->param, s->param);
2547
2548     /* dup the cipher_list and cipher_list_by_id stacks */
2549     if (s->cipher_list != NULL) {
2550         if ((ret->cipher_list = sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
2551             goto err;
2552     }
2553     if (s->cipher_list_by_id != NULL)
2554         if ((ret->cipher_list_by_id = sk_SSL_CIPHER_dup(s->cipher_list_by_id))
2555             == NULL)
2556             goto err;
2557
2558     /* Dup the client_CA list */
2559     if (s->client_CA != NULL) {
2560         if ((sk = sk_X509_NAME_dup(s->client_CA)) == NULL)
2561             goto err;
2562         ret->client_CA = sk;
2563         for (i = 0; i < sk_X509_NAME_num(sk); i++) {
2564             xn = sk_X509_NAME_value(sk, i);
2565             if (sk_X509_NAME_set(sk, i, X509_NAME_dup(xn)) == NULL) {
2566                 X509_NAME_free(xn);
2567                 goto err;
2568             }
2569         }
2570     }
2571     return ret;
2572
2573  err:
2574     SSL_free(ret);
2575     return NULL;
2576 }
2577
2578 void ssl_clear_cipher_ctx(SSL *s)
2579 {
2580     if (s->enc_read_ctx != NULL) {
2581         EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
2582         OPENSSL_free(s->enc_read_ctx);
2583         s->enc_read_ctx = NULL;
2584     }
2585     if (s->enc_write_ctx != NULL) {
2586         EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
2587         OPENSSL_free(s->enc_write_ctx);
2588         s->enc_write_ctx = NULL;
2589     }
2590 #ifndef OPENSSL_NO_COMP
2591     COMP_CTX_free(s->expand);
2592     s->expand = NULL;
2593     COMP_CTX_free(s->compress);
2594     s->compress = NULL;
2595 #endif
2596 }
2597
2598 X509 *SSL_get_certificate(const SSL *s)
2599 {
2600     if (s->cert != NULL)
2601         return (s->cert->key->x509);
2602     else
2603         return (NULL);
2604 }
2605
2606 EVP_PKEY *SSL_get_privatekey(const SSL *s)
2607 {
2608     if (s->cert != NULL)
2609         return (s->cert->key->privatekey);
2610     else
2611         return (NULL);
2612 }
2613
2614 X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
2615 {
2616     if (ctx->cert != NULL)
2617         return ctx->cert->key->x509;
2618     else
2619         return NULL;
2620 }
2621
2622 EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
2623 {
2624     if (ctx->cert != NULL)
2625         return ctx->cert->key->privatekey;
2626     else
2627         return NULL;
2628 }
2629
2630 const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
2631 {
2632     if ((s->session != NULL) && (s->session->cipher != NULL))
2633         return (s->session->cipher);
2634     return (NULL);
2635 }
2636
2637 const COMP_METHOD *SSL_get_current_compression(SSL *s)
2638 {
2639 #ifndef OPENSSL_NO_COMP
2640     return s->compress ? COMP_CTX_get_method(s->compress) : NULL;
2641 #else
2642     return NULL;
2643 #endif
2644 }
2645
2646 const COMP_METHOD *SSL_get_current_expansion(SSL *s)
2647 {
2648 #ifndef OPENSSL_NO_COMP
2649     return s->expand ? COMP_CTX_get_method(s->expand) : NULL;
2650 #else
2651     return NULL;
2652 #endif
2653 }
2654
2655 int ssl_init_wbio_buffer(SSL *s, int push)
2656 {
2657     BIO *bbio;
2658
2659     if (s->bbio == NULL) {
2660         bbio = BIO_new(BIO_f_buffer());
2661         if (bbio == NULL)
2662             return (0);
2663         s->bbio = bbio;
2664     } else {
2665         bbio = s->bbio;
2666         if (s->bbio == s->wbio)
2667             s->wbio = BIO_pop(s->wbio);
2668     }
2669     (void)BIO_reset(bbio);
2670 /*      if (!BIO_set_write_buffer_size(bbio,16*1024)) */
2671     if (!BIO_set_read_buffer_size(bbio, 1)) {
2672         SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER, ERR_R_BUF_LIB);
2673         return (0);
2674     }
2675     if (push) {
2676         if (s->wbio != bbio)
2677             s->wbio = BIO_push(bbio, s->wbio);
2678     } else {
2679         if (s->wbio == bbio)
2680             s->wbio = BIO_pop(bbio);
2681     }
2682     return (1);
2683 }
2684
2685 void ssl_free_wbio_buffer(SSL *s)
2686 {
2687     /* callers ensure s is never null */
2688     if (s->bbio == NULL)
2689         return;
2690
2691     if (s->bbio == s->wbio) {
2692         /* remove buffering */
2693         s->wbio = BIO_pop(s->wbio);
2694 #ifdef REF_CHECK                /* not the usual REF_CHECK, but this avoids
2695                                  * adding one more preprocessor symbol */
2696         assert(s->wbio != NULL);
2697 #endif
2698     }
2699     BIO_free(s->bbio);
2700     s->bbio = NULL;
2701 }
2702
2703 void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
2704 {
2705     ctx->quiet_shutdown = mode;
2706 }
2707
2708 int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
2709 {
2710     return (ctx->quiet_shutdown);
2711 }
2712
2713 void SSL_set_quiet_shutdown(SSL *s, int mode)
2714 {
2715     s->quiet_shutdown = mode;
2716 }
2717
2718 int SSL_get_quiet_shutdown(const SSL *s)
2719 {
2720     return (s->quiet_shutdown);
2721 }
2722
2723 void SSL_set_shutdown(SSL *s, int mode)
2724 {
2725     s->shutdown = mode;
2726 }
2727
2728 int SSL_get_shutdown(const SSL *s)
2729 {
2730     return (s->shutdown);
2731 }
2732
2733 int SSL_version(const SSL *s)
2734 {
2735     return (s->version);
2736 }
2737
2738 SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
2739 {
2740     return (ssl->ctx);
2741 }
2742
2743 SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
2744 {
2745     CERT *new_cert;
2746     if (ssl->ctx == ctx)
2747         return ssl->ctx;
2748     if (ctx == NULL)
2749         ctx = ssl->initial_ctx;
2750     new_cert = ssl_cert_dup(ctx->cert);
2751     if (new_cert == NULL) {
2752         return NULL;
2753     }
2754     ssl_cert_free(ssl->cert);
2755     ssl->cert = new_cert;
2756
2757     /*
2758      * Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
2759      * so setter APIs must prevent invalid lengths from entering the system.
2760      */
2761     OPENSSL_assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx));
2762
2763     /*
2764      * If the session ID context matches that of the parent SSL_CTX,
2765      * inherit it from the new SSL_CTX as well. If however the context does
2766      * not match (i.e., it was set per-ssl with SSL_set_session_id_context),
2767      * leave it unchanged.
2768      */
2769     if ((ssl->ctx != NULL) &&
2770         (ssl->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
2771         (memcmp(ssl->sid_ctx, ssl->ctx->sid_ctx, ssl->sid_ctx_length) == 0)) {
2772         ssl->sid_ctx_length = ctx->sid_ctx_length;
2773         memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
2774     }
2775
2776     CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
2777     SSL_CTX_free(ssl->ctx); /* decrement reference count */
2778     ssl->ctx = ctx;
2779
2780     return (ssl->ctx);
2781 }
2782
2783 #ifndef OPENSSL_NO_STDIO
2784 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
2785 {
2786     return (X509_STORE_set_default_paths(ctx->cert_store));
2787 }
2788
2789 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
2790                                   const char *CApath)
2791 {
2792     return (X509_STORE_load_locations(ctx->cert_store, CAfile, CApath));
2793 }
2794 #endif
2795
2796 void SSL_set_info_callback(SSL *ssl,
2797                            void (*cb) (const SSL *ssl, int type, int val))
2798 {
2799     ssl->info_callback = cb;
2800 }
2801
2802 /*
2803  * One compiler (Diab DCC) doesn't like argument names in returned function
2804  * pointer.
2805  */
2806 void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
2807                                                int /* type */ ,
2808                                                int /* val */ ) {
2809     return ssl->info_callback;
2810 }
2811
2812 int SSL_state(const SSL *ssl)
2813 {
2814     return (ssl->state);
2815 }
2816
2817 void SSL_set_state(SSL *ssl, int state)
2818 {
2819     ssl->state = state;
2820 }
2821
2822 void SSL_set_verify_result(SSL *ssl, long arg)
2823 {
2824     ssl->verify_result = arg;
2825 }
2826
2827 long SSL_get_verify_result(const SSL *ssl)
2828 {
2829     return (ssl->verify_result);
2830 }
2831
2832 size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
2833 {
2834     if (outlen == 0)
2835         return sizeof(ssl->s3->client_random);
2836     if (outlen > sizeof(ssl->s3->client_random))
2837         outlen = sizeof(ssl->s3->client_random);
2838     memcpy(out, ssl->s3->client_random, outlen);
2839     return outlen;
2840 }
2841
2842 size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
2843 {
2844     if (outlen == 0)
2845         return sizeof(ssl->s3->server_random);
2846     if (outlen > sizeof(ssl->s3->server_random))
2847         outlen = sizeof(ssl->s3->server_random);
2848     memcpy(out, ssl->s3->server_random, outlen);
2849     return outlen;
2850 }
2851
2852 size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
2853                                unsigned char *out, size_t outlen)
2854 {
2855     if (session->master_key_length < 0) {
2856         /* Should never happen */
2857         return 0;
2858     }
2859     if (outlen == 0)
2860         return session->master_key_length;
2861     if (outlen > (size_t)session->master_key_length)
2862         outlen = session->master_key_length;
2863     memcpy(out, session->master_key, outlen);
2864     return outlen;
2865 }
2866
2867 int SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
2868                          CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
2869 {
2870     return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp,
2871                                    new_func, dup_func, free_func);
2872 }
2873
2874 int SSL_set_ex_data(SSL *s, int idx, void *arg)
2875 {
2876     return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
2877 }
2878
2879 void *SSL_get_ex_data(const SSL *s, int idx)
2880 {
2881     return (CRYPTO_get_ex_data(&s->ex_data, idx));
2882 }
2883
2884 int SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
2885                              CRYPTO_EX_dup *dup_func,
2886                              CRYPTO_EX_free *free_func)
2887 {
2888     return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp,
2889                                    new_func, dup_func, free_func);
2890 }
2891
2892 int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
2893 {
2894     return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
2895 }
2896
2897 void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
2898 {
2899     return (CRYPTO_get_ex_data(&s->ex_data, idx));
2900 }
2901
2902 int ssl_ok(SSL *s)
2903 {
2904     return (1);
2905 }
2906
2907 X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
2908 {
2909     return (ctx->cert_store);
2910 }
2911
2912 void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
2913 {
2914     X509_STORE_free(ctx->cert_store);
2915     ctx->cert_store = store;
2916 }
2917
2918 int SSL_want(const SSL *s)
2919 {
2920     return (s->rwstate);
2921 }
2922
2923 /**
2924  * \brief Set the callback for generating temporary RSA keys.
2925  * \param ctx the SSL context.
2926  * \param cb the callback
2927  */
2928
2929 #ifndef OPENSSL_NO_RSA
2930 void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, RSA *(*cb) (SSL *ssl,
2931                                                             int is_export,
2932                                                             int keylength))
2933 {
2934     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_RSA_CB, (void (*)(void))cb);
2935 }
2936
2937 void SSL_set_tmp_rsa_callback(SSL *ssl, RSA *(*cb) (SSL *ssl,
2938                                                     int is_export,
2939                                                     int keylength))
2940 {
2941     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_RSA_CB, (void (*)(void))cb);
2942 }
2943 #endif
2944
2945 #ifdef DOXYGEN
2946 /**
2947  * \brief The RSA temporary key callback function.
2948  * \param ssl the SSL session.
2949  * \param is_export \c TRUE if the temp RSA key is for an export ciphersuite.
2950  * \param keylength if \c is_export is \c TRUE, then \c keylength is the size
2951  * of the required key in bits.
2952  * \return the temporary RSA key.
2953  * \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
2954  */
2955
2956 RSA *cb(SSL *ssl, int is_export, int keylength)
2957 {
2958 }
2959 #endif
2960
2961 /**
2962  * \brief Set the callback for generating temporary DH keys.
2963  * \param ctx the SSL context.
2964  * \param dh the callback
2965  */
2966
2967 #ifndef OPENSSL_NO_DH
2968 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
2969                                  DH *(*dh) (SSL *ssl, int is_export,
2970                                             int keylength))
2971 {
2972     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
2973 }
2974
2975 void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export,
2976                                                   int keylength))
2977 {
2978     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
2979 }
2980 #endif
2981
2982 #ifndef OPENSSL_NO_EC
2983 void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx,
2984                                    EC_KEY *(*ecdh) (SSL *ssl, int is_export,
2985                                                     int keylength))
2986 {
2987     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_ECDH_CB,
2988                           (void (*)(void))ecdh);
2989 }
2990
2991 void SSL_set_tmp_ecdh_callback(SSL *ssl,
2992                                EC_KEY *(*ecdh) (SSL *ssl, int is_export,
2993                                                 int keylength))
2994 {
2995     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_ECDH_CB, (void (*)(void))ecdh);
2996 }
2997 #endif
2998
2999 #ifndef OPENSSL_NO_PSK
3000 int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
3001 {
3002     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3003         SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT,
3004                SSL_R_DATA_LENGTH_TOO_LONG);
3005         return 0;
3006     }
3007     OPENSSL_free(ctx->cert->psk_identity_hint);
3008     if (identity_hint != NULL) {
3009         ctx->cert->psk_identity_hint = BUF_strdup(identity_hint);
3010         if (ctx->cert->psk_identity_hint == NULL)
3011             return 0;
3012     } else
3013         ctx->cert->psk_identity_hint = NULL;
3014     return 1;
3015 }
3016
3017 int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
3018 {
3019     if (s == NULL)
3020         return 0;
3021
3022     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3023         SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
3024         return 0;
3025     }
3026     OPENSSL_free(s->cert->psk_identity_hint);
3027     if (identity_hint != NULL) {
3028         s->cert->psk_identity_hint = BUF_strdup(identity_hint);
3029         if (s->cert->psk_identity_hint == NULL)
3030             return 0;
3031     } else
3032         s->cert->psk_identity_hint = NULL;
3033     return 1;
3034 }
3035
3036 const char *SSL_get_psk_identity_hint(const SSL *s)
3037 {
3038     if (s == NULL || s->session == NULL)
3039         return NULL;
3040     return (s->session->psk_identity_hint);
3041 }
3042
3043 const char *SSL_get_psk_identity(const SSL *s)
3044 {
3045     if (s == NULL || s->session == NULL)
3046         return NULL;
3047     return (s->session->psk_identity);
3048 }
3049
3050 void SSL_set_psk_client_callback(SSL *s,
3051                                  unsigned int (*cb) (SSL *ssl,
3052                                                      const char *hint,
3053                                                      char *identity,
3054                                                      unsigned int
3055                                                      max_identity_len,
3056                                                      unsigned char *psk,
3057                                                      unsigned int
3058                                                      max_psk_len))
3059 {
3060     s->psk_client_callback = cb;
3061 }
3062
3063 void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
3064                                      unsigned int (*cb) (SSL *ssl,
3065                                                          const char *hint,
3066                                                          char *identity,
3067                                                          unsigned int
3068                                                          max_identity_len,
3069                                                          unsigned char *psk,
3070                                                          unsigned int
3071                                                          max_psk_len))
3072 {
3073     ctx->psk_client_callback = cb;
3074 }
3075
3076 void SSL_set_psk_server_callback(SSL *s,
3077                                  unsigned int (*cb) (SSL *ssl,
3078                                                      const char *identity,
3079                                                      unsigned char *psk,
3080                                                      unsigned int
3081                                                      max_psk_len))
3082 {
3083     s->psk_server_callback = cb;
3084 }
3085
3086 void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
3087                                      unsigned int (*cb) (SSL *ssl,
3088                                                          const char *identity,
3089                                                          unsigned char *psk,
3090                                                          unsigned int
3091                                                          max_psk_len))
3092 {
3093     ctx->psk_server_callback = cb;
3094 }
3095 #endif
3096
3097 void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
3098                               void (*cb) (int write_p, int version,
3099                                           int content_type, const void *buf,
3100                                           size_t len, SSL *ssl, void *arg))
3101 {
3102     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3103 }
3104
3105 void SSL_set_msg_callback(SSL *ssl,
3106                           void (*cb) (int write_p, int version,
3107                                       int content_type, const void *buf,
3108                                       size_t len, SSL *ssl, void *arg))
3109 {
3110     SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3111 }
3112
3113 void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
3114                                                 int (*cb) (SSL *ssl,
3115                                                            int
3116                                                            is_forward_secure))
3117 {
3118     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3119                           (void (*)(void))cb);
3120 }
3121
3122 void SSL_set_not_resumable_session_callback(SSL *ssl,
3123                                             int (*cb) (SSL *ssl,
3124                                                        int is_forward_secure))
3125 {
3126     SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3127                       (void (*)(void))cb);
3128 }
3129
3130 /*
3131  * Allocates new EVP_MD_CTX and sets pointer to it into given pointer
3132  * vairable, freeing EVP_MD_CTX previously stored in that variable, if any.
3133  * If EVP_MD pointer is passed, initializes ctx with this md Returns newly
3134  * allocated ctx;
3135  */
3136
3137 EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md)
3138 {
3139     ssl_clear_hash_ctx(hash);
3140     *hash = EVP_MD_CTX_create();
3141     if (md)
3142         EVP_DigestInit_ex(*hash, md, NULL);
3143     return *hash;
3144 }
3145
3146 void ssl_clear_hash_ctx(EVP_MD_CTX **hash)
3147 {
3148
3149     if (*hash)
3150         EVP_MD_CTX_destroy(*hash);
3151     *hash = NULL;
3152 }
3153
3154 /* Retrieve handshake hashes */
3155 int ssl_handshake_hash(SSL *s, unsigned char *out, int outlen)
3156 {
3157     unsigned char *p = out;
3158     int idx, ret = 0;
3159     long mask;
3160     EVP_MD_CTX ctx;
3161     const EVP_MD *md;
3162     EVP_MD_CTX_init(&ctx);
3163     for (idx = 0; ssl_get_handshake_digest(idx, &mask, &md); idx++) {
3164         if (mask & ssl_get_algorithm2(s)) {
3165             int hashsize = EVP_MD_size(md);
3166             EVP_MD_CTX *hdgst = s->s3->handshake_dgst[idx];
3167             if (!hdgst || hashsize < 0 || hashsize > outlen)
3168                 goto err;
3169             if (!EVP_MD_CTX_copy_ex(&ctx, hdgst))
3170                 goto err;
3171             if (!EVP_DigestFinal_ex(&ctx, p, NULL))
3172                 goto err;
3173             p += hashsize;
3174             outlen -= hashsize;
3175         }
3176     }
3177     ret = p - out;
3178  err:
3179     EVP_MD_CTX_cleanup(&ctx);
3180     return ret;
3181 }
3182
3183 void SSL_set_debug(SSL *s, int debug)
3184 {
3185     s->debug = debug;
3186 }
3187
3188 int SSL_cache_hit(SSL *s)
3189 {
3190     return s->hit;
3191 }
3192
3193 int SSL_is_server(SSL *s)
3194 {
3195     return s->server;
3196 }
3197
3198 void SSL_set_security_level(SSL *s, int level)
3199 {
3200     s->cert->sec_level = level;
3201 }
3202
3203 int SSL_get_security_level(const SSL *s)
3204 {
3205     return s->cert->sec_level;
3206 }
3207
3208 void SSL_set_security_callback(SSL *s,
3209                                int (*cb) (SSL *s, SSL_CTX *ctx, int op,
3210                                           int bits, int nid, void *other,
3211                                           void *ex))
3212 {
3213     s->cert->sec_cb = cb;
3214 }
3215
3216 int (*SSL_get_security_callback(const SSL *s)) (SSL *s, SSL_CTX *ctx, int op,
3217                                                 int bits, int nid,
3218                                                 void *other, void *ex) {
3219     return s->cert->sec_cb;
3220 }
3221
3222 void SSL_set0_security_ex_data(SSL *s, void *ex)
3223 {
3224     s->cert->sec_ex = ex;
3225 }
3226
3227 void *SSL_get0_security_ex_data(const SSL *s)
3228 {
3229     return s->cert->sec_ex;
3230 }
3231
3232 void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
3233 {
3234     ctx->cert->sec_level = level;
3235 }
3236
3237 int SSL_CTX_get_security_level(const SSL_CTX *ctx)
3238 {
3239     return ctx->cert->sec_level;
3240 }
3241
3242 void SSL_CTX_set_security_callback(SSL_CTX *ctx,
3243                                    int (*cb) (SSL *s, SSL_CTX *ctx, int op,
3244                                               int bits, int nid, void *other,
3245                                               void *ex))
3246 {
3247     ctx->cert->sec_cb = cb;
3248 }
3249
3250 int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (SSL *s,
3251                                                           SSL_CTX *ctx,
3252                                                           int op, int bits,
3253                                                           int nid,
3254                                                           void *other,
3255                                                           void *ex) {
3256     return ctx->cert->sec_cb;
3257 }
3258
3259 void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
3260 {
3261     ctx->cert->sec_ex = ex;
3262 }
3263
3264 void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
3265 {
3266     return ctx->cert->sec_ex;
3267 }
3268
3269 IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);