Have 'make clean' clean away the log files.
[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
290     /*
291      * Earlier library versions used to copy the pointer to the CERT, not
292      * its contents; only when setting new parameters for the per-SSL
293      * copy, ssl_cert_new would be called (and the direct reference to
294      * the per-SSL_CTX settings would be lost, but those still were
295      * indirectly accessed for various purposes, and for that reason they
296      * used to be known as s->ctx->default_cert). Now we don't look at the
297      * SSL_CTX's CERT after having duplicated it once.
298      */
299     s->cert = ssl_cert_dup(ctx->cert);
300     if (s->cert == NULL)
301         goto err;
302
303     RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
304     s->msg_callback = ctx->msg_callback;
305     s->msg_callback_arg = ctx->msg_callback_arg;
306     s->verify_mode = ctx->verify_mode;
307     s->not_resumable_session_cb = ctx->not_resumable_session_cb;
308     s->sid_ctx_length = ctx->sid_ctx_length;
309     OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
310     memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
311     s->verify_callback = ctx->default_verify_callback;
312     s->generate_session_id = ctx->generate_session_id;
313
314     s->param = X509_VERIFY_PARAM_new();
315     if (!s->param)
316         goto err;
317     X509_VERIFY_PARAM_inherit(s->param, ctx->param);
318     s->quiet_shutdown = ctx->quiet_shutdown;
319     s->max_send_fragment = ctx->max_send_fragment;
320
321     CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
322     s->ctx = ctx;
323     s->tlsext_debug_cb = 0;
324     s->tlsext_debug_arg = NULL;
325     s->tlsext_ticket_expected = 0;
326     s->tlsext_status_type = -1;
327     s->tlsext_status_expected = 0;
328     s->tlsext_ocsp_ids = NULL;
329     s->tlsext_ocsp_exts = NULL;
330     s->tlsext_ocsp_resp = NULL;
331     s->tlsext_ocsp_resplen = -1;
332     CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
333     s->initial_ctx = ctx;
334 # ifndef OPENSSL_NO_EC
335     if (ctx->tlsext_ecpointformatlist) {
336         s->tlsext_ecpointformatlist =
337             BUF_memdup(ctx->tlsext_ecpointformatlist,
338                        ctx->tlsext_ecpointformatlist_length);
339         if (!s->tlsext_ecpointformatlist)
340             goto err;
341         s->tlsext_ecpointformatlist_length =
342             ctx->tlsext_ecpointformatlist_length;
343     }
344     if (ctx->tlsext_ellipticcurvelist) {
345         s->tlsext_ellipticcurvelist =
346             BUF_memdup(ctx->tlsext_ellipticcurvelist,
347                        ctx->tlsext_ellipticcurvelist_length);
348         if (!s->tlsext_ellipticcurvelist)
349             goto err;
350         s->tlsext_ellipticcurvelist_length =
351             ctx->tlsext_ellipticcurvelist_length;
352     }
353 # endif
354 # ifndef OPENSSL_NO_NEXTPROTONEG
355     s->next_proto_negotiated = NULL;
356 # endif
357
358     if (s->ctx->alpn_client_proto_list) {
359         s->alpn_client_proto_list =
360             OPENSSL_malloc(s->ctx->alpn_client_proto_list_len);
361         if (s->alpn_client_proto_list == NULL)
362             goto err;
363         memcpy(s->alpn_client_proto_list, s->ctx->alpn_client_proto_list,
364                s->ctx->alpn_client_proto_list_len);
365         s->alpn_client_proto_list_len = s->ctx->alpn_client_proto_list_len;
366     }
367
368     s->verify_result = X509_V_OK;
369
370     s->method = ctx->method;
371
372     if (!s->method->ssl_new(s))
373         goto err;
374
375     s->references = 1;
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_PSK
1829     OPENSSL_free(a->psk_identity_hint);
1830 #endif
1831 #ifndef OPENSSL_NO_SRP
1832     SSL_CTX_SRP_CTX_free(a);
1833 #endif
1834 #ifndef OPENSSL_NO_ENGINE
1835     if (a->client_cert_engine)
1836         ENGINE_finish(a->client_cert_engine);
1837 #endif
1838
1839 #ifndef OPENSSL_NO_EC
1840     OPENSSL_free(a->tlsext_ecpointformatlist);
1841     OPENSSL_free(a->tlsext_ellipticcurvelist);
1842 #endif
1843     OPENSSL_free(a->alpn_client_proto_list);
1844
1845     OPENSSL_free(a);
1846 }
1847
1848 void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
1849 {
1850     ctx->default_passwd_callback = cb;
1851 }
1852
1853 void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
1854 {
1855     ctx->default_passwd_callback_userdata = u;
1856 }
1857
1858 void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
1859                                       int (*cb) (X509_STORE_CTX *, void *),
1860                                       void *arg)
1861 {
1862     ctx->app_verify_callback = cb;
1863     ctx->app_verify_arg = arg;
1864 }
1865
1866 void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
1867                         int (*cb) (int, X509_STORE_CTX *))
1868 {
1869     ctx->verify_mode = mode;
1870     ctx->default_verify_callback = cb;
1871 }
1872
1873 void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
1874 {
1875     X509_VERIFY_PARAM_set_depth(ctx->param, depth);
1876 }
1877
1878 void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
1879                          void *arg)
1880 {
1881     ssl_cert_set_cert_cb(c->cert, cb, arg);
1882 }
1883
1884 void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
1885 {
1886     ssl_cert_set_cert_cb(s->cert, cb, arg);
1887 }
1888
1889 void ssl_set_masks(SSL *s, const SSL_CIPHER *cipher)
1890 {
1891     CERT_PKEY *cpk;
1892     CERT *c = s->cert;
1893     uint32_t *pvalid = s->s3->tmp.valid_flags;
1894     int rsa_enc, rsa_tmp, rsa_sign, dh_tmp, dh_rsa, dh_dsa, dsa_sign;
1895     int rsa_enc_export, dh_rsa_export, dh_dsa_export;
1896     int rsa_tmp_export, dh_tmp_export, kl;
1897     unsigned long mask_k, mask_a, emask_k, emask_a;
1898 #ifndef OPENSSL_NO_EC
1899     int have_ecc_cert, ecdsa_ok, ecc_pkey_size;
1900     int have_ecdh_tmp, ecdh_ok;
1901     X509 *x = NULL;
1902     EVP_PKEY *ecc_pkey = NULL;
1903     int pk_nid = 0, md_nid = 0;
1904 #endif
1905     if (c == NULL)
1906         return;
1907
1908     kl = SSL_C_EXPORT_PKEYLENGTH(cipher);
1909
1910 #ifndef OPENSSL_NO_RSA
1911     rsa_tmp = (c->rsa_tmp != NULL || c->rsa_tmp_cb != NULL);
1912     rsa_tmp_export = (c->rsa_tmp_cb != NULL ||
1913                       (rsa_tmp && RSA_size(c->rsa_tmp) * 8 <= kl));
1914 #else
1915     rsa_tmp = rsa_tmp_export = 0;
1916 #endif
1917 #ifndef OPENSSL_NO_DH
1918     dh_tmp = (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto);
1919     dh_tmp_export = !c->dh_tmp_auto && (c->dh_tmp_cb != NULL ||
1920                                         (dh_tmp
1921                                          && DH_size(c->dh_tmp) * 8 <= kl));
1922 #else
1923     dh_tmp = dh_tmp_export = 0;
1924 #endif
1925
1926 #ifndef OPENSSL_NO_EC
1927     have_ecdh_tmp = (c->ecdh_tmp || c->ecdh_tmp_cb || c->ecdh_tmp_auto);
1928 #endif
1929     cpk = &(c->pkeys[SSL_PKEY_RSA_ENC]);
1930     rsa_enc = pvalid[SSL_PKEY_RSA_ENC] & CERT_PKEY_VALID;
1931     rsa_enc_export = (rsa_enc && EVP_PKEY_size(cpk->privatekey) * 8 <= kl);
1932     cpk = &(c->pkeys[SSL_PKEY_RSA_SIGN]);
1933     rsa_sign = pvalid[SSL_PKEY_RSA_SIGN] & CERT_PKEY_SIGN;
1934     cpk = &(c->pkeys[SSL_PKEY_DSA_SIGN]);
1935     dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_SIGN;
1936     cpk = &(c->pkeys[SSL_PKEY_DH_RSA]);
1937     dh_rsa = pvalid[SSL_PKEY_DH_RSA] & CERT_PKEY_VALID;
1938     dh_rsa_export = (dh_rsa && EVP_PKEY_size(cpk->privatekey) * 8 <= kl);
1939     cpk = &(c->pkeys[SSL_PKEY_DH_DSA]);
1940     dh_dsa = pvalid[SSL_PKEY_DH_DSA] & CERT_PKEY_VALID;
1941     dh_dsa_export = (dh_dsa && EVP_PKEY_size(cpk->privatekey) * 8 <= kl);
1942     cpk = &(c->pkeys[SSL_PKEY_ECC]);
1943 #ifndef OPENSSL_NO_EC
1944     have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID;
1945 #endif
1946     mask_k = 0;
1947     mask_a = 0;
1948     emask_k = 0;
1949     emask_a = 0;
1950
1951 #ifdef CIPHER_DEBUG
1952     fprintf(stderr,
1953             "rt=%d rte=%d dht=%d ecdht=%d re=%d ree=%d rs=%d ds=%d dhr=%d dhd=%d\n",
1954             rsa_tmp, rsa_tmp_export, dh_tmp, have_ecdh_tmp, rsa_enc,
1955             rsa_enc_export, rsa_sign, dsa_sign, dh_rsa, dh_dsa);
1956 #endif
1957
1958     cpk = &(c->pkeys[SSL_PKEY_GOST01]);
1959     if (cpk->x509 != NULL && cpk->privatekey != NULL) {
1960         mask_k |= SSL_kGOST;
1961         mask_a |= SSL_aGOST01;
1962     }
1963
1964     if (rsa_enc || (rsa_tmp && rsa_sign))
1965         mask_k |= SSL_kRSA;
1966     if (rsa_enc_export || (rsa_tmp_export && (rsa_sign || rsa_enc)))
1967         emask_k |= SSL_kRSA;
1968
1969     if (dh_tmp_export)
1970         emask_k |= SSL_kDHE;
1971
1972     if (dh_tmp)
1973         mask_k |= SSL_kDHE;
1974
1975     if (dh_rsa)
1976         mask_k |= SSL_kDHr;
1977     if (dh_rsa_export)
1978         emask_k |= SSL_kDHr;
1979
1980     if (dh_dsa)
1981         mask_k |= SSL_kDHd;
1982     if (dh_dsa_export)
1983         emask_k |= SSL_kDHd;
1984
1985     if (mask_k & (SSL_kDHr | SSL_kDHd))
1986         mask_a |= SSL_aDH;
1987
1988     if (rsa_enc || rsa_sign) {
1989         mask_a |= SSL_aRSA;
1990         emask_a |= SSL_aRSA;
1991     }
1992
1993     if (dsa_sign) {
1994         mask_a |= SSL_aDSS;
1995         emask_a |= SSL_aDSS;
1996     }
1997
1998     mask_a |= SSL_aNULL;
1999     emask_a |= SSL_aNULL;
2000
2001     /*
2002      * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites
2003      * depending on the key usage extension.
2004      */
2005 #ifndef OPENSSL_NO_EC
2006     if (have_ecc_cert) {
2007         uint32_t ex_kusage;
2008         cpk = &c->pkeys[SSL_PKEY_ECC];
2009         x = cpk->x509;
2010         ex_kusage = X509_get_key_usage(x);
2011         ecdh_ok = ex_kusage & X509v3_KU_KEY_AGREEMENT;
2012         ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE;
2013         if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN))
2014             ecdsa_ok = 0;
2015         ecc_pkey = X509_get_pubkey(x);
2016         ecc_pkey_size = (ecc_pkey != NULL) ? EVP_PKEY_bits(ecc_pkey) : 0;
2017         EVP_PKEY_free(ecc_pkey);
2018         OBJ_find_sigid_algs(X509_get_signature_nid(x), &md_nid, &pk_nid);
2019         if (ecdh_ok) {
2020
2021             if (pk_nid == NID_rsaEncryption || pk_nid == NID_rsa) {
2022                 mask_k |= SSL_kECDHr;
2023                 mask_a |= SSL_aECDH;
2024                 if (ecc_pkey_size <= 163) {
2025                     emask_k |= SSL_kECDHr;
2026                     emask_a |= SSL_aECDH;
2027                 }
2028             }
2029
2030             if (pk_nid == NID_X9_62_id_ecPublicKey) {
2031                 mask_k |= SSL_kECDHe;
2032                 mask_a |= SSL_aECDH;
2033                 if (ecc_pkey_size <= 163) {
2034                     emask_k |= SSL_kECDHe;
2035                     emask_a |= SSL_aECDH;
2036                 }
2037             }
2038         }
2039         if (ecdsa_ok) {
2040             mask_a |= SSL_aECDSA;
2041             emask_a |= SSL_aECDSA;
2042         }
2043     }
2044 #endif
2045
2046 #ifndef OPENSSL_NO_EC
2047     if (have_ecdh_tmp) {
2048         mask_k |= SSL_kECDHE;
2049         emask_k |= SSL_kECDHE;
2050     }
2051 #endif
2052
2053 #ifndef OPENSSL_NO_PSK
2054     mask_k |= SSL_kPSK;
2055     mask_a |= SSL_aPSK;
2056     emask_k |= SSL_kPSK;
2057     emask_a |= SSL_aPSK;
2058     if (mask_k & SSL_kRSA)
2059         mask_k |= SSL_kRSAPSK;
2060     if (mask_k & SSL_kDHE)
2061         mask_k |= SSL_kDHEPSK;
2062     if (mask_k & SSL_kECDHE)
2063         mask_k |= SSL_kECDHEPSK;
2064 #endif
2065
2066     s->s3->tmp.mask_k = mask_k;
2067     s->s3->tmp.mask_a = mask_a;
2068     s->s3->tmp.export_mask_k = emask_k;
2069     s->s3->tmp.export_mask_a = emask_a;
2070 }
2071
2072 #ifndef OPENSSL_NO_EC
2073
2074 int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
2075 {
2076     unsigned long alg_k, alg_a;
2077     EVP_PKEY *pkey = NULL;
2078     int keysize = 0;
2079     int md_nid = 0, pk_nid = 0;
2080     const SSL_CIPHER *cs = s->s3->tmp.new_cipher;
2081     uint32_t ex_kusage = X509_get_key_usage(x);
2082
2083     alg_k = cs->algorithm_mkey;
2084     alg_a = cs->algorithm_auth;
2085
2086     if (SSL_C_IS_EXPORT(cs)) {
2087         /* ECDH key length in export ciphers must be <= 163 bits */
2088         pkey = X509_get_pubkey(x);
2089         if (pkey == NULL)
2090             return 0;
2091         keysize = EVP_PKEY_bits(pkey);
2092         EVP_PKEY_free(pkey);
2093         if (keysize > 163)
2094             return 0;
2095     }
2096
2097     OBJ_find_sigid_algs(X509_get_signature_nid(x), &md_nid, &pk_nid);
2098
2099     if (alg_k & SSL_kECDHe || alg_k & SSL_kECDHr) {
2100         /* key usage, if present, must allow key agreement */
2101         if (!(ex_kusage & X509v3_KU_KEY_AGREEMENT)) {
2102             SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2103                    SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT);
2104             return 0;
2105         }
2106         if ((alg_k & SSL_kECDHe) && TLS1_get_version(s) < TLS1_2_VERSION) {
2107             /* signature alg must be ECDSA */
2108             if (pk_nid != NID_X9_62_id_ecPublicKey) {
2109                 SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2110                        SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE);
2111                 return 0;
2112             }
2113         }
2114         if ((alg_k & SSL_kECDHr) && TLS1_get_version(s) < TLS1_2_VERSION) {
2115             /* signature alg must be RSA */
2116
2117             if (pk_nid != NID_rsaEncryption && pk_nid != NID_rsa) {
2118                 SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2119                        SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE);
2120                 return 0;
2121             }
2122         }
2123     }
2124     if (alg_a & SSL_aECDSA) {
2125         /* key usage, if present, must allow signing */
2126         if (!(ex_kusage & X509v3_KU_DIGITAL_SIGNATURE)) {
2127             SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2128                    SSL_R_ECC_CERT_NOT_FOR_SIGNING);
2129             return 0;
2130         }
2131     }
2132
2133     return 1;                   /* all checks are ok */
2134 }
2135
2136 #endif
2137
2138 static int ssl_get_server_cert_index(const SSL *s)
2139 {
2140     int idx;
2141     idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
2142     if (idx == SSL_PKEY_RSA_ENC && !s->cert->pkeys[SSL_PKEY_RSA_ENC].x509)
2143         idx = SSL_PKEY_RSA_SIGN;
2144     if (idx == -1)
2145         SSLerr(SSL_F_SSL_GET_SERVER_CERT_INDEX, ERR_R_INTERNAL_ERROR);
2146     return idx;
2147 }
2148
2149 CERT_PKEY *ssl_get_server_send_pkey(SSL *s)
2150 {
2151     CERT *c;
2152     int i;
2153
2154     c = s->cert;
2155     if (!s->s3 || !s->s3->tmp.new_cipher)
2156         return NULL;
2157     ssl_set_masks(s, s->s3->tmp.new_cipher);
2158
2159 #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
2160     /*
2161      * Broken protocol test: return last used certificate: which may mismatch
2162      * the one expected.
2163      */
2164     if (c->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
2165         return c->key;
2166 #endif
2167
2168     i = ssl_get_server_cert_index(s);
2169
2170     /* This may or may not be an error. */
2171     if (i < 0)
2172         return NULL;
2173
2174     /* May be NULL. */
2175     return &c->pkeys[i];
2176 }
2177
2178 EVP_PKEY *ssl_get_sign_pkey(SSL *s, const SSL_CIPHER *cipher,
2179                             const EVP_MD **pmd)
2180 {
2181     unsigned long alg_a;
2182     CERT *c;
2183     int idx = -1;
2184
2185     alg_a = cipher->algorithm_auth;
2186     c = s->cert;
2187
2188 #ifdef OPENSSL_SSL_DEBUG_BROKEN_PROTOCOL
2189     /*
2190      * Broken protocol test: use last key: which may mismatch the one
2191      * expected.
2192      */
2193     if (c->cert_flags & SSL_CERT_FLAG_BROKEN_PROTOCOL)
2194         idx = c->key - c->pkeys;
2195     else
2196 #endif
2197
2198     if ((alg_a & SSL_aDSS) &&
2199             (c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
2200         idx = SSL_PKEY_DSA_SIGN;
2201     else if (alg_a & SSL_aRSA) {
2202         if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
2203             idx = SSL_PKEY_RSA_SIGN;
2204         else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
2205             idx = SSL_PKEY_RSA_ENC;
2206     } else if ((alg_a & SSL_aECDSA) &&
2207                (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
2208         idx = SSL_PKEY_ECC;
2209     if (idx == -1) {
2210         SSLerr(SSL_F_SSL_GET_SIGN_PKEY, ERR_R_INTERNAL_ERROR);
2211         return (NULL);
2212     }
2213     if (pmd)
2214         *pmd = s->s3->tmp.md[idx];
2215     return c->pkeys[idx].privatekey;
2216 }
2217
2218 int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
2219                                    size_t *serverinfo_length)
2220 {
2221     CERT *c = NULL;
2222     int i = 0;
2223     *serverinfo_length = 0;
2224
2225     c = s->cert;
2226     i = ssl_get_server_cert_index(s);
2227
2228     if (i == -1)
2229         return 0;
2230     if (c->pkeys[i].serverinfo == NULL)
2231         return 0;
2232
2233     *serverinfo = c->pkeys[i].serverinfo;
2234     *serverinfo_length = c->pkeys[i].serverinfo_length;
2235     return 1;
2236 }
2237
2238 void ssl_update_cache(SSL *s, int mode)
2239 {
2240     int i;
2241
2242     /*
2243      * If the session_id_length is 0, we are not supposed to cache it, and it
2244      * would be rather hard to do anyway :-)
2245      */
2246     if (s->session->session_id_length == 0)
2247         return;
2248
2249     i = s->session_ctx->session_cache_mode;
2250     if ((i & mode) && (!s->hit)
2251         && ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
2252             || SSL_CTX_add_session(s->session_ctx, s->session))
2253         && (s->session_ctx->new_session_cb != NULL)) {
2254         CRYPTO_add(&s->session->references, 1, CRYPTO_LOCK_SSL_SESSION);
2255         if (!s->session_ctx->new_session_cb(s, s->session))
2256             SSL_SESSION_free(s->session);
2257     }
2258
2259     /* auto flush every 255 connections */
2260     if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) {
2261         if ((((mode & SSL_SESS_CACHE_CLIENT)
2262               ? s->session_ctx->stats.sess_connect_good
2263               : s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff) {
2264             SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL));
2265         }
2266     }
2267 }
2268
2269 const SSL_METHOD *SSL_CTX_get_ssl_method(SSL_CTX *ctx)
2270 {
2271     return ctx->method;
2272 }
2273
2274 const SSL_METHOD *SSL_get_ssl_method(SSL *s)
2275 {
2276     return (s->method);
2277 }
2278
2279 int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
2280 {
2281     int conn = -1;
2282     int ret = 1;
2283
2284     if (s->method != meth) {
2285         if (s->handshake_func != NULL)
2286             conn = (s->handshake_func == s->method->ssl_connect);
2287
2288         if (s->method->version == meth->version)
2289             s->method = meth;
2290         else {
2291             s->method->ssl_free(s);
2292             s->method = meth;
2293             ret = s->method->ssl_new(s);
2294         }
2295
2296         if (conn == 1)
2297             s->handshake_func = meth->ssl_connect;
2298         else if (conn == 0)
2299             s->handshake_func = meth->ssl_accept;
2300     }
2301     return (ret);
2302 }
2303
2304 int SSL_get_error(const SSL *s, int i)
2305 {
2306     int reason;
2307     unsigned long l;
2308     BIO *bio;
2309
2310     if (i > 0)
2311         return (SSL_ERROR_NONE);
2312
2313     /*
2314      * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
2315      * where we do encode the error
2316      */
2317     if ((l = ERR_peek_error()) != 0) {
2318         if (ERR_GET_LIB(l) == ERR_LIB_SYS)
2319             return (SSL_ERROR_SYSCALL);
2320         else
2321             return (SSL_ERROR_SSL);
2322     }
2323
2324     if ((i < 0) && SSL_want_read(s)) {
2325         bio = SSL_get_rbio(s);
2326         if (BIO_should_read(bio))
2327             return (SSL_ERROR_WANT_READ);
2328         else if (BIO_should_write(bio))
2329             /*
2330              * This one doesn't make too much sense ... We never try to write
2331              * to the rbio, and an application program where rbio and wbio
2332              * are separate couldn't even know what it should wait for.
2333              * However if we ever set s->rwstate incorrectly (so that we have
2334              * SSL_want_read(s) instead of SSL_want_write(s)) and rbio and
2335              * wbio *are* the same, this test works around that bug; so it
2336              * might be safer to keep it.
2337              */
2338             return (SSL_ERROR_WANT_WRITE);
2339         else if (BIO_should_io_special(bio)) {
2340             reason = BIO_get_retry_reason(bio);
2341             if (reason == BIO_RR_CONNECT)
2342                 return (SSL_ERROR_WANT_CONNECT);
2343             else if (reason == BIO_RR_ACCEPT)
2344                 return (SSL_ERROR_WANT_ACCEPT);
2345             else
2346                 return (SSL_ERROR_SYSCALL); /* unknown */
2347         }
2348     }
2349
2350     if ((i < 0) && SSL_want_write(s)) {
2351         bio = SSL_get_wbio(s);
2352         if (BIO_should_write(bio))
2353             return (SSL_ERROR_WANT_WRITE);
2354         else if (BIO_should_read(bio))
2355             /*
2356              * See above (SSL_want_read(s) with BIO_should_write(bio))
2357              */
2358             return (SSL_ERROR_WANT_READ);
2359         else if (BIO_should_io_special(bio)) {
2360             reason = BIO_get_retry_reason(bio);
2361             if (reason == BIO_RR_CONNECT)
2362                 return (SSL_ERROR_WANT_CONNECT);
2363             else if (reason == BIO_RR_ACCEPT)
2364                 return (SSL_ERROR_WANT_ACCEPT);
2365             else
2366                 return (SSL_ERROR_SYSCALL);
2367         }
2368     }
2369     if ((i < 0) && SSL_want_x509_lookup(s)) {
2370         return (SSL_ERROR_WANT_X509_LOOKUP);
2371     }
2372
2373     if (i == 0) {
2374         if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2375             (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
2376             return (SSL_ERROR_ZERO_RETURN);
2377     }
2378     return (SSL_ERROR_SYSCALL);
2379 }
2380
2381 int SSL_do_handshake(SSL *s)
2382 {
2383     int ret = 1;
2384
2385     if (s->handshake_func == NULL) {
2386         SSLerr(SSL_F_SSL_DO_HANDSHAKE, SSL_R_CONNECTION_TYPE_NOT_SET);
2387         return (-1);
2388     }
2389
2390     s->method->ssl_renegotiate_check(s);
2391
2392     if (SSL_in_init(s) || SSL_in_before(s)) {
2393         ret = s->handshake_func(s);
2394     }
2395     return (ret);
2396 }
2397
2398 void SSL_set_accept_state(SSL *s)
2399 {
2400     s->server = 1;
2401     s->shutdown = 0;
2402     s->state = SSL_ST_ACCEPT | SSL_ST_BEFORE;
2403     s->handshake_func = s->method->ssl_accept;
2404     clear_ciphers(s);
2405 }
2406
2407 void SSL_set_connect_state(SSL *s)
2408 {
2409     s->server = 0;
2410     s->shutdown = 0;
2411     s->state = SSL_ST_CONNECT | SSL_ST_BEFORE;
2412     s->handshake_func = s->method->ssl_connect;
2413     clear_ciphers(s);
2414 }
2415
2416 int ssl_undefined_function(SSL *s)
2417 {
2418     SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2419     return (0);
2420 }
2421
2422 int ssl_undefined_void_function(void)
2423 {
2424     SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,
2425            ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2426     return (0);
2427 }
2428
2429 int ssl_undefined_const_function(const SSL *s)
2430 {
2431     SSLerr(SSL_F_SSL_UNDEFINED_CONST_FUNCTION,
2432            ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2433     return (0);
2434 }
2435
2436 SSL_METHOD *ssl_bad_method(int ver)
2437 {
2438     SSLerr(SSL_F_SSL_BAD_METHOD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2439     return (NULL);
2440 }
2441
2442 const char *SSL_get_version(const SSL *s)
2443 {
2444     if (s->version == TLS1_2_VERSION)
2445         return ("TLSv1.2");
2446     else if (s->version == TLS1_1_VERSION)
2447         return ("TLSv1.1");
2448     else if (s->version == TLS1_VERSION)
2449         return ("TLSv1");
2450     else if (s->version == SSL3_VERSION)
2451         return ("SSLv3");
2452     else if (s->version == DTLS1_BAD_VER)
2453         return ("DTLSv0.9");
2454     else if (s->version == DTLS1_VERSION)
2455         return ("DTLSv1");
2456     else if (s->version == DTLS1_2_VERSION)
2457         return ("DTLSv1.2");
2458     else
2459         return ("unknown");
2460 }
2461
2462 SSL *SSL_dup(SSL *s)
2463 {
2464     STACK_OF(X509_NAME) *sk;
2465     X509_NAME *xn;
2466     SSL *ret;
2467     int i;
2468
2469     if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
2470         return (NULL);
2471
2472     ret->version = s->version;
2473     ret->type = s->type;
2474     ret->method = s->method;
2475
2476     if (s->session != NULL) {
2477         /* This copies session-id, SSL_METHOD, sid_ctx, and 'cert' */
2478         if (!SSL_copy_session_id(ret, s))
2479             goto err;
2480     } else {
2481         /*
2482          * No session has been established yet, so we have to expect that
2483          * s->cert or ret->cert will be changed later -- they should not both
2484          * point to the same object, and thus we can't use
2485          * SSL_copy_session_id.
2486          */
2487
2488         ret->method->ssl_free(ret);
2489         ret->method = s->method;
2490         ret->method->ssl_new(ret);
2491
2492         if (s->cert != NULL) {
2493             ssl_cert_free(ret->cert);
2494             ret->cert = ssl_cert_dup(s->cert);
2495             if (ret->cert == NULL)
2496                 goto err;
2497         }
2498
2499         if (!SSL_set_session_id_context(ret, s->sid_ctx, s->sid_ctx_length))
2500             goto err;
2501     }
2502
2503     ret->options = s->options;
2504     ret->mode = s->mode;
2505     SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
2506     SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
2507     ret->msg_callback = s->msg_callback;
2508     ret->msg_callback_arg = s->msg_callback_arg;
2509     SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
2510     SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
2511     ret->generate_session_id = s->generate_session_id;
2512
2513     SSL_set_info_callback(ret, SSL_get_info_callback(s));
2514
2515     ret->debug = s->debug;
2516
2517     /* copy app data, a little dangerous perhaps */
2518     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
2519         goto err;
2520
2521     /* setup rbio, and wbio */
2522     if (s->rbio != NULL) {
2523         if (!BIO_dup_state(s->rbio, (char *)&ret->rbio))
2524             goto err;
2525     }
2526     if (s->wbio != NULL) {
2527         if (s->wbio != s->rbio) {
2528             if (!BIO_dup_state(s->wbio, (char *)&ret->wbio))
2529                 goto err;
2530         } else
2531             ret->wbio = ret->rbio;
2532     }
2533     ret->rwstate = s->rwstate;
2534     ret->in_handshake = s->in_handshake;
2535     ret->handshake_func = s->handshake_func;
2536     ret->server = s->server;
2537     ret->renegotiate = s->renegotiate;
2538     ret->new_session = s->new_session;
2539     ret->quiet_shutdown = s->quiet_shutdown;
2540     ret->shutdown = s->shutdown;
2541     ret->state = s->state;      /* SSL_dup does not really work at any state,
2542                                  * though */
2543     RECORD_LAYER_dup(&ret->rlayer, &s->rlayer);
2544     ret->init_num = 0;          /* would have to copy ret->init_buf,
2545                                  * ret->init_msg, ret->init_num,
2546                                  * ret->init_off */
2547     ret->hit = s->hit;
2548
2549     X509_VERIFY_PARAM_inherit(ret->param, s->param);
2550
2551     /* dup the cipher_list and cipher_list_by_id stacks */
2552     if (s->cipher_list != NULL) {
2553         if ((ret->cipher_list = sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
2554             goto err;
2555     }
2556     if (s->cipher_list_by_id != NULL)
2557         if ((ret->cipher_list_by_id = sk_SSL_CIPHER_dup(s->cipher_list_by_id))
2558             == NULL)
2559             goto err;
2560
2561     /* Dup the client_CA list */
2562     if (s->client_CA != NULL) {
2563         if ((sk = sk_X509_NAME_dup(s->client_CA)) == NULL)
2564             goto err;
2565         ret->client_CA = sk;
2566         for (i = 0; i < sk_X509_NAME_num(sk); i++) {
2567             xn = sk_X509_NAME_value(sk, i);
2568             if (sk_X509_NAME_set(sk, i, X509_NAME_dup(xn)) == NULL) {
2569                 X509_NAME_free(xn);
2570                 goto err;
2571             }
2572         }
2573     }
2574     return ret;
2575
2576  err:
2577     SSL_free(ret);
2578     return NULL;
2579 }
2580
2581 void ssl_clear_cipher_ctx(SSL *s)
2582 {
2583     if (s->enc_read_ctx != NULL) {
2584         EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
2585         OPENSSL_free(s->enc_read_ctx);
2586         s->enc_read_ctx = NULL;
2587     }
2588     if (s->enc_write_ctx != NULL) {
2589         EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
2590         OPENSSL_free(s->enc_write_ctx);
2591         s->enc_write_ctx = NULL;
2592     }
2593 #ifndef OPENSSL_NO_COMP
2594     COMP_CTX_free(s->expand);
2595     s->expand = NULL;
2596     COMP_CTX_free(s->compress);
2597     s->compress = NULL;
2598 #endif
2599 }
2600
2601 X509 *SSL_get_certificate(const SSL *s)
2602 {
2603     if (s->cert != NULL)
2604         return (s->cert->key->x509);
2605     else
2606         return (NULL);
2607 }
2608
2609 EVP_PKEY *SSL_get_privatekey(const SSL *s)
2610 {
2611     if (s->cert != NULL)
2612         return (s->cert->key->privatekey);
2613     else
2614         return (NULL);
2615 }
2616
2617 X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
2618 {
2619     if (ctx->cert != NULL)
2620         return ctx->cert->key->x509;
2621     else
2622         return NULL;
2623 }
2624
2625 EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
2626 {
2627     if (ctx->cert != NULL)
2628         return ctx->cert->key->privatekey;
2629     else
2630         return NULL;
2631 }
2632
2633 const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
2634 {
2635     if ((s->session != NULL) && (s->session->cipher != NULL))
2636         return (s->session->cipher);
2637     return (NULL);
2638 }
2639
2640 const COMP_METHOD *SSL_get_current_compression(SSL *s)
2641 {
2642 #ifndef OPENSSL_NO_COMP
2643     return s->compress ? COMP_CTX_get_method(s->compress) : NULL;
2644 #else
2645     return NULL;
2646 #endif
2647 }
2648
2649 const COMP_METHOD *SSL_get_current_expansion(SSL *s)
2650 {
2651 #ifndef OPENSSL_NO_COMP
2652     return s->expand ? COMP_CTX_get_method(s->expand) : NULL;
2653 #else
2654     return NULL;
2655 #endif
2656 }
2657
2658 int ssl_init_wbio_buffer(SSL *s, int push)
2659 {
2660     BIO *bbio;
2661
2662     if (s->bbio == NULL) {
2663         bbio = BIO_new(BIO_f_buffer());
2664         if (bbio == NULL)
2665             return (0);
2666         s->bbio = bbio;
2667     } else {
2668         bbio = s->bbio;
2669         if (s->bbio == s->wbio)
2670             s->wbio = BIO_pop(s->wbio);
2671     }
2672     (void)BIO_reset(bbio);
2673 /*      if (!BIO_set_write_buffer_size(bbio,16*1024)) */
2674     if (!BIO_set_read_buffer_size(bbio, 1)) {
2675         SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER, ERR_R_BUF_LIB);
2676         return (0);
2677     }
2678     if (push) {
2679         if (s->wbio != bbio)
2680             s->wbio = BIO_push(bbio, s->wbio);
2681     } else {
2682         if (s->wbio == bbio)
2683             s->wbio = BIO_pop(bbio);
2684     }
2685     return (1);
2686 }
2687
2688 void ssl_free_wbio_buffer(SSL *s)
2689 {
2690     /* callers ensure s is never null */
2691     if (s->bbio == NULL)
2692         return;
2693
2694     if (s->bbio == s->wbio) {
2695         /* remove buffering */
2696         s->wbio = BIO_pop(s->wbio);
2697 #ifdef REF_CHECK                /* not the usual REF_CHECK, but this avoids
2698                                  * adding one more preprocessor symbol */
2699         assert(s->wbio != NULL);
2700 #endif
2701     }
2702     BIO_free(s->bbio);
2703     s->bbio = NULL;
2704 }
2705
2706 void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
2707 {
2708     ctx->quiet_shutdown = mode;
2709 }
2710
2711 int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
2712 {
2713     return (ctx->quiet_shutdown);
2714 }
2715
2716 void SSL_set_quiet_shutdown(SSL *s, int mode)
2717 {
2718     s->quiet_shutdown = mode;
2719 }
2720
2721 int SSL_get_quiet_shutdown(const SSL *s)
2722 {
2723     return (s->quiet_shutdown);
2724 }
2725
2726 void SSL_set_shutdown(SSL *s, int mode)
2727 {
2728     s->shutdown = mode;
2729 }
2730
2731 int SSL_get_shutdown(const SSL *s)
2732 {
2733     return (s->shutdown);
2734 }
2735
2736 int SSL_version(const SSL *s)
2737 {
2738     return (s->version);
2739 }
2740
2741 SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
2742 {
2743     return (ssl->ctx);
2744 }
2745
2746 SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
2747 {
2748     CERT *new_cert;
2749     if (ssl->ctx == ctx)
2750         return ssl->ctx;
2751     if (ctx == NULL)
2752         ctx = ssl->initial_ctx;
2753     new_cert = ssl_cert_dup(ctx->cert);
2754     if (new_cert == NULL) {
2755         return NULL;
2756     }
2757     ssl_cert_free(ssl->cert);
2758     ssl->cert = new_cert;
2759
2760     /*
2761      * Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
2762      * so setter APIs must prevent invalid lengths from entering the system.
2763      */
2764     OPENSSL_assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx));
2765
2766     /*
2767      * If the session ID context matches that of the parent SSL_CTX,
2768      * inherit it from the new SSL_CTX as well. If however the context does
2769      * not match (i.e., it was set per-ssl with SSL_set_session_id_context),
2770      * leave it unchanged.
2771      */
2772     if ((ssl->ctx != NULL) &&
2773         (ssl->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
2774         (memcmp(ssl->sid_ctx, ssl->ctx->sid_ctx, ssl->sid_ctx_length) == 0)) {
2775         ssl->sid_ctx_length = ctx->sid_ctx_length;
2776         memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
2777     }
2778
2779     CRYPTO_add(&ctx->references, 1, CRYPTO_LOCK_SSL_CTX);
2780     SSL_CTX_free(ssl->ctx); /* decrement reference count */
2781     ssl->ctx = ctx;
2782
2783     return (ssl->ctx);
2784 }
2785
2786 #ifndef OPENSSL_NO_STDIO
2787 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
2788 {
2789     return (X509_STORE_set_default_paths(ctx->cert_store));
2790 }
2791
2792 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
2793                                   const char *CApath)
2794 {
2795     return (X509_STORE_load_locations(ctx->cert_store, CAfile, CApath));
2796 }
2797 #endif
2798
2799 void SSL_set_info_callback(SSL *ssl,
2800                            void (*cb) (const SSL *ssl, int type, int val))
2801 {
2802     ssl->info_callback = cb;
2803 }
2804
2805 /*
2806  * One compiler (Diab DCC) doesn't like argument names in returned function
2807  * pointer.
2808  */
2809 void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
2810                                                int /* type */ ,
2811                                                int /* val */ ) {
2812     return ssl->info_callback;
2813 }
2814
2815 int SSL_state(const SSL *ssl)
2816 {
2817     return (ssl->state);
2818 }
2819
2820 void SSL_set_state(SSL *ssl, int state)
2821 {
2822     ssl->state = state;
2823 }
2824
2825 void SSL_set_verify_result(SSL *ssl, long arg)
2826 {
2827     ssl->verify_result = arg;
2828 }
2829
2830 long SSL_get_verify_result(const SSL *ssl)
2831 {
2832     return (ssl->verify_result);
2833 }
2834
2835 size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
2836 {
2837     if (outlen == 0)
2838         return sizeof(ssl->s3->client_random);
2839     if (outlen > sizeof(ssl->s3->client_random))
2840         outlen = sizeof(ssl->s3->client_random);
2841     memcpy(out, ssl->s3->client_random, outlen);
2842     return outlen;
2843 }
2844
2845 size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
2846 {
2847     if (outlen == 0)
2848         return sizeof(ssl->s3->server_random);
2849     if (outlen > sizeof(ssl->s3->server_random))
2850         outlen = sizeof(ssl->s3->server_random);
2851     memcpy(out, ssl->s3->server_random, outlen);
2852     return outlen;
2853 }
2854
2855 size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
2856                                unsigned char *out, size_t outlen)
2857 {
2858     if (session->master_key_length < 0) {
2859         /* Should never happen */
2860         return 0;
2861     }
2862     if (outlen == 0)
2863         return session->master_key_length;
2864     if (outlen > (size_t)session->master_key_length)
2865         outlen = session->master_key_length;
2866     memcpy(out, session->master_key, outlen);
2867     return outlen;
2868 }
2869
2870 int SSL_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
2871                          CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
2872 {
2873     return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp,
2874                                    new_func, dup_func, free_func);
2875 }
2876
2877 int SSL_set_ex_data(SSL *s, int idx, void *arg)
2878 {
2879     return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
2880 }
2881
2882 void *SSL_get_ex_data(const SSL *s, int idx)
2883 {
2884     return (CRYPTO_get_ex_data(&s->ex_data, idx));
2885 }
2886
2887 int SSL_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
2888                              CRYPTO_EX_dup *dup_func,
2889                              CRYPTO_EX_free *free_func)
2890 {
2891     return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp,
2892                                    new_func, dup_func, free_func);
2893 }
2894
2895 int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
2896 {
2897     return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
2898 }
2899
2900 void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
2901 {
2902     return (CRYPTO_get_ex_data(&s->ex_data, idx));
2903 }
2904
2905 int ssl_ok(SSL *s)
2906 {
2907     return (1);
2908 }
2909
2910 X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
2911 {
2912     return (ctx->cert_store);
2913 }
2914
2915 void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
2916 {
2917     X509_STORE_free(ctx->cert_store);
2918     ctx->cert_store = store;
2919 }
2920
2921 int SSL_want(const SSL *s)
2922 {
2923     return (s->rwstate);
2924 }
2925
2926 /**
2927  * \brief Set the callback for generating temporary RSA keys.
2928  * \param ctx the SSL context.
2929  * \param cb the callback
2930  */
2931
2932 #ifndef OPENSSL_NO_RSA
2933 void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, RSA *(*cb) (SSL *ssl,
2934                                                             int is_export,
2935                                                             int keylength))
2936 {
2937     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_RSA_CB, (void (*)(void))cb);
2938 }
2939
2940 void SSL_set_tmp_rsa_callback(SSL *ssl, RSA *(*cb) (SSL *ssl,
2941                                                     int is_export,
2942                                                     int keylength))
2943 {
2944     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_RSA_CB, (void (*)(void))cb);
2945 }
2946 #endif
2947
2948 #ifdef DOXYGEN
2949 /**
2950  * \brief The RSA temporary key callback function.
2951  * \param ssl the SSL session.
2952  * \param is_export \c TRUE if the temp RSA key is for an export ciphersuite.
2953  * \param keylength if \c is_export is \c TRUE, then \c keylength is the size
2954  * of the required key in bits.
2955  * \return the temporary RSA key.
2956  * \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
2957  */
2958
2959 RSA *cb(SSL *ssl, int is_export, int keylength)
2960 {
2961 }
2962 #endif
2963
2964 /**
2965  * \brief Set the callback for generating temporary DH keys.
2966  * \param ctx the SSL context.
2967  * \param dh the callback
2968  */
2969
2970 #ifndef OPENSSL_NO_DH
2971 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
2972                                  DH *(*dh) (SSL *ssl, int is_export,
2973                                             int keylength))
2974 {
2975     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
2976 }
2977
2978 void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export,
2979                                                   int keylength))
2980 {
2981     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
2982 }
2983 #endif
2984
2985 #ifndef OPENSSL_NO_EC
2986 void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx,
2987                                    EC_KEY *(*ecdh) (SSL *ssl, int is_export,
2988                                                     int keylength))
2989 {
2990     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_ECDH_CB,
2991                           (void (*)(void))ecdh);
2992 }
2993
2994 void SSL_set_tmp_ecdh_callback(SSL *ssl,
2995                                EC_KEY *(*ecdh) (SSL *ssl, int is_export,
2996                                                 int keylength))
2997 {
2998     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_ECDH_CB, (void (*)(void))ecdh);
2999 }
3000 #endif
3001
3002 #ifndef OPENSSL_NO_PSK
3003 int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
3004 {
3005     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3006         SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT,
3007                SSL_R_DATA_LENGTH_TOO_LONG);
3008         return 0;
3009     }
3010     OPENSSL_free(ctx->psk_identity_hint);
3011     if (identity_hint != NULL) {
3012         ctx->psk_identity_hint = BUF_strdup(identity_hint);
3013         if (ctx->psk_identity_hint == NULL)
3014             return 0;
3015     } else
3016         ctx->psk_identity_hint = NULL;
3017     return 1;
3018 }
3019
3020 int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
3021 {
3022     if (s == NULL)
3023         return 0;
3024
3025     if (s->session == NULL)
3026         return 1;               /* session not created yet, ignored */
3027
3028     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3029         SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
3030         return 0;
3031     }
3032     OPENSSL_free(s->session->psk_identity_hint);
3033     if (identity_hint != NULL) {
3034         s->session->psk_identity_hint = BUF_strdup(identity_hint);
3035         if (s->session->psk_identity_hint == NULL)
3036             return 0;
3037     } else
3038         s->session->psk_identity_hint = NULL;
3039     return 1;
3040 }
3041
3042 const char *SSL_get_psk_identity_hint(const SSL *s)
3043 {
3044     if (s == NULL || s->session == NULL)
3045         return NULL;
3046     return (s->session->psk_identity_hint);
3047 }
3048
3049 const char *SSL_get_psk_identity(const SSL *s)
3050 {
3051     if (s == NULL || s->session == NULL)
3052         return NULL;
3053     return (s->session->psk_identity);
3054 }
3055
3056 void SSL_set_psk_client_callback(SSL *s,
3057                                  unsigned int (*cb) (SSL *ssl,
3058                                                      const char *hint,
3059                                                      char *identity,
3060                                                      unsigned int
3061                                                      max_identity_len,
3062                                                      unsigned char *psk,
3063                                                      unsigned int
3064                                                      max_psk_len))
3065 {
3066     s->psk_client_callback = cb;
3067 }
3068
3069 void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
3070                                      unsigned int (*cb) (SSL *ssl,
3071                                                          const char *hint,
3072                                                          char *identity,
3073                                                          unsigned int
3074                                                          max_identity_len,
3075                                                          unsigned char *psk,
3076                                                          unsigned int
3077                                                          max_psk_len))
3078 {
3079     ctx->psk_client_callback = cb;
3080 }
3081
3082 void SSL_set_psk_server_callback(SSL *s,
3083                                  unsigned int (*cb) (SSL *ssl,
3084                                                      const char *identity,
3085                                                      unsigned char *psk,
3086                                                      unsigned int
3087                                                      max_psk_len))
3088 {
3089     s->psk_server_callback = cb;
3090 }
3091
3092 void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
3093                                      unsigned int (*cb) (SSL *ssl,
3094                                                          const char *identity,
3095                                                          unsigned char *psk,
3096                                                          unsigned int
3097                                                          max_psk_len))
3098 {
3099     ctx->psk_server_callback = cb;
3100 }
3101 #endif
3102
3103 void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
3104                               void (*cb) (int write_p, int version,
3105                                           int content_type, const void *buf,
3106                                           size_t len, SSL *ssl, void *arg))
3107 {
3108     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3109 }
3110
3111 void SSL_set_msg_callback(SSL *ssl,
3112                           void (*cb) (int write_p, int version,
3113                                       int content_type, const void *buf,
3114                                       size_t len, SSL *ssl, void *arg))
3115 {
3116     SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3117 }
3118
3119 void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
3120                                                 int (*cb) (SSL *ssl,
3121                                                            int
3122                                                            is_forward_secure))
3123 {
3124     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3125                           (void (*)(void))cb);
3126 }
3127
3128 void SSL_set_not_resumable_session_callback(SSL *ssl,
3129                                             int (*cb) (SSL *ssl,
3130                                                        int is_forward_secure))
3131 {
3132     SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3133                       (void (*)(void))cb);
3134 }
3135
3136 /*
3137  * Allocates new EVP_MD_CTX and sets pointer to it into given pointer
3138  * vairable, freeing EVP_MD_CTX previously stored in that variable, if any.
3139  * If EVP_MD pointer is passed, initializes ctx with this md Returns newly
3140  * allocated ctx;
3141  */
3142
3143 EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md)
3144 {
3145     ssl_clear_hash_ctx(hash);
3146     *hash = EVP_MD_CTX_create();
3147     if (md)
3148         EVP_DigestInit_ex(*hash, md, NULL);
3149     return *hash;
3150 }
3151
3152 void ssl_clear_hash_ctx(EVP_MD_CTX **hash)
3153 {
3154
3155     if (*hash)
3156         EVP_MD_CTX_destroy(*hash);
3157     *hash = NULL;
3158 }
3159
3160 /* Retrieve handshake hashes */
3161 int ssl_handshake_hash(SSL *s, unsigned char *out, int outlen)
3162 {
3163     unsigned char *p = out;
3164     int idx, ret = 0;
3165     long mask;
3166     EVP_MD_CTX ctx;
3167     const EVP_MD *md;
3168     EVP_MD_CTX_init(&ctx);
3169     for (idx = 0; ssl_get_handshake_digest(idx, &mask, &md); idx++) {
3170         if (mask & ssl_get_algorithm2(s)) {
3171             int hashsize = EVP_MD_size(md);
3172             EVP_MD_CTX *hdgst = s->s3->handshake_dgst[idx];
3173             if (!hdgst || hashsize < 0 || hashsize > outlen)
3174                 goto err;
3175             if (!EVP_MD_CTX_copy_ex(&ctx, hdgst))
3176                 goto err;
3177             if (!EVP_DigestFinal_ex(&ctx, p, NULL))
3178                 goto err;
3179             p += hashsize;
3180             outlen -= hashsize;
3181         }
3182     }
3183     ret = p - out;
3184  err:
3185     EVP_MD_CTX_cleanup(&ctx);
3186     return ret;
3187 }
3188
3189 void SSL_set_debug(SSL *s, int debug)
3190 {
3191     s->debug = debug;
3192 }
3193
3194 int SSL_cache_hit(SSL *s)
3195 {
3196     return s->hit;
3197 }
3198
3199 int SSL_is_server(SSL *s)
3200 {
3201     return s->server;
3202 }
3203
3204 void SSL_set_security_level(SSL *s, int level)
3205 {
3206     s->cert->sec_level = level;
3207 }
3208
3209 int SSL_get_security_level(const SSL *s)
3210 {
3211     return s->cert->sec_level;
3212 }
3213
3214 void SSL_set_security_callback(SSL *s,
3215                                int (*cb) (SSL *s, SSL_CTX *ctx, int op,
3216                                           int bits, int nid, void *other,
3217                                           void *ex))
3218 {
3219     s->cert->sec_cb = cb;
3220 }
3221
3222 int (*SSL_get_security_callback(const SSL *s)) (SSL *s, SSL_CTX *ctx, int op,
3223                                                 int bits, int nid,
3224                                                 void *other, void *ex) {
3225     return s->cert->sec_cb;
3226 }
3227
3228 void SSL_set0_security_ex_data(SSL *s, void *ex)
3229 {
3230     s->cert->sec_ex = ex;
3231 }
3232
3233 void *SSL_get0_security_ex_data(const SSL *s)
3234 {
3235     return s->cert->sec_ex;
3236 }
3237
3238 void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
3239 {
3240     ctx->cert->sec_level = level;
3241 }
3242
3243 int SSL_CTX_get_security_level(const SSL_CTX *ctx)
3244 {
3245     return ctx->cert->sec_level;
3246 }
3247
3248 void SSL_CTX_set_security_callback(SSL_CTX *ctx,
3249                                    int (*cb) (SSL *s, SSL_CTX *ctx, int op,
3250                                               int bits, int nid, void *other,
3251                                               void *ex))
3252 {
3253     ctx->cert->sec_cb = cb;
3254 }
3255
3256 int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (SSL *s,
3257                                                           SSL_CTX *ctx,
3258                                                           int op, int bits,
3259                                                           int nid,
3260                                                           void *other,
3261                                                           void *ex) {
3262     return ctx->cert->sec_cb;
3263 }
3264
3265 void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
3266 {
3267     ctx->cert->sec_ex = ex;
3268 }
3269
3270 void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
3271 {
3272     return ctx->cert->sec_ex;
3273 }
3274
3275 IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);