Change all our uses of CRYPTO_THREAD_run_once to use RUN_ONCE instead
[openssl.git] / ssl / ssl_lib.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /* ====================================================================
11  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
12  * ECC cipher suite support in OpenSSL originally developed by
13  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
14  */
15 /* ====================================================================
16  * Copyright 2005 Nokia. All rights reserved.
17  *
18  * The portions of the attached software ("Contribution") is developed by
19  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
20  * license.
21  *
22  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
23  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
24  * support (see RFC 4279) to OpenSSL.
25  *
26  * No patent licenses or other rights except those expressly stated in
27  * the OpenSSL open source license shall be deemed granted or received
28  * expressly, by implication, estoppel, or otherwise.
29  *
30  * No assurances are provided by Nokia that the Contribution does not
31  * infringe the patent or other intellectual property rights of any third
32  * party or that the license provides you with all the necessary rights
33  * to make use of the Contribution.
34  *
35  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
36  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
37  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
38  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
39  * OTHERWISE.
40  */
41
42 #include <assert.h>
43 #include <stdio.h>
44 #include "ssl_locl.h"
45 #include <openssl/objects.h>
46 #include <openssl/lhash.h>
47 #include <openssl/x509v3.h>
48 #include <openssl/rand.h>
49 #include <openssl/ocsp.h>
50 #include <openssl/dh.h>
51 #include <openssl/engine.h>
52 #include <openssl/async.h>
53 #include <openssl/ct.h>
54
55 const char SSL_version_str[] = OPENSSL_VERSION_TEXT;
56
57 SSL3_ENC_METHOD ssl3_undef_enc_method = {
58     /*
59      * evil casts, but these functions are only called if there's a library
60      * bug
61      */
62     (int (*)(SSL *, SSL3_RECORD *, unsigned int, int))ssl_undefined_function,
63     (int (*)(SSL *, SSL3_RECORD *, unsigned char *, int))ssl_undefined_function,
64     ssl_undefined_function,
65     (int (*)(SSL *, unsigned char *, unsigned char *, int))
66         ssl_undefined_function,
67     (int (*)(SSL *, int))ssl_undefined_function,
68     (int (*)(SSL *, const char *, int, unsigned char *))
69         ssl_undefined_function,
70     0,                          /* finish_mac_length */
71     NULL,                       /* client_finished_label */
72     0,                          /* client_finished_label_len */
73     NULL,                       /* server_finished_label */
74     0,                          /* server_finished_label_len */
75     (int (*)(int))ssl_undefined_function,
76     (int (*)(SSL *, unsigned char *, size_t, const char *,
77              size_t, const unsigned char *, size_t,
78              int use_context))ssl_undefined_function,
79 };
80
81 struct ssl_async_args {
82     SSL *s;
83     void *buf;
84     int num;
85     enum { READFUNC, WRITEFUNC,  OTHERFUNC} type;
86     union {
87         int (*func_read)(SSL *, void *, int);
88         int (*func_write)(SSL *, const void *, int);
89         int (*func_other)(SSL *);
90     } f;
91 };
92
93 static const struct {
94     uint8_t mtype;
95     uint8_t ord;
96     int     nid;
97 } dane_mds[] = {
98     { DANETLS_MATCHING_FULL, 0, NID_undef },
99     { DANETLS_MATCHING_2256, 1, NID_sha256 },
100     { DANETLS_MATCHING_2512, 2, NID_sha512 },
101 };
102
103 static int dane_ctx_enable(struct dane_ctx_st *dctx)
104 {
105     const EVP_MD **mdevp;
106     uint8_t *mdord;
107     uint8_t mdmax = DANETLS_MATCHING_LAST;
108     int n = ((int) mdmax) + 1;          /* int to handle PrivMatch(255) */
109     size_t i;
110
111     if (dctx->mdevp != NULL)
112         return 1;
113
114     mdevp = OPENSSL_zalloc(n * sizeof(*mdevp));
115     mdord = OPENSSL_zalloc(n * sizeof(*mdord));
116
117     if (mdord == NULL || mdevp == NULL) {
118         OPENSSL_free(mdord);
119         OPENSSL_free(mdevp);
120         SSLerr(SSL_F_DANE_CTX_ENABLE, ERR_R_MALLOC_FAILURE);
121         return 0;
122     }
123
124     /* Install default entries */
125     for (i = 0; i < OSSL_NELEM(dane_mds); ++i) {
126         const EVP_MD *md;
127
128         if (dane_mds[i].nid == NID_undef ||
129             (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL)
130             continue;
131         mdevp[dane_mds[i].mtype] = md;
132         mdord[dane_mds[i].mtype] = dane_mds[i].ord;
133     }
134
135     dctx->mdevp = mdevp;
136     dctx->mdord = mdord;
137     dctx->mdmax = mdmax;
138
139     return 1;
140 }
141
142 static void dane_ctx_final(struct dane_ctx_st *dctx)
143 {
144     OPENSSL_free(dctx->mdevp);
145     dctx->mdevp = NULL;
146
147     OPENSSL_free(dctx->mdord);
148     dctx->mdord = NULL;
149     dctx->mdmax = 0;
150 }
151
152 static void tlsa_free(danetls_record *t)
153 {
154     if (t == NULL)
155         return;
156     OPENSSL_free(t->data);
157     EVP_PKEY_free(t->spki);
158     OPENSSL_free(t);
159 }
160
161 static void dane_final(SSL_DANE *dane)
162 {
163     sk_danetls_record_pop_free(dane->trecs, tlsa_free);
164     dane->trecs = NULL;
165
166     sk_X509_pop_free(dane->certs, X509_free);
167     dane->certs = NULL;
168
169     X509_free(dane->mcert);
170     dane->mcert = NULL;
171     dane->mtlsa = NULL;
172     dane->mdpth = -1;
173     dane->pdpth = -1;
174 }
175
176 /*
177  * dane_copy - Copy dane configuration, sans verification state.
178  */
179 static int ssl_dane_dup(SSL *to, SSL *from)
180 {
181     int num;
182     int i;
183
184     if (!DANETLS_ENABLED(&from->dane))
185         return 1;
186
187     dane_final(&to->dane);
188     to->dane.flags = from->dane.flags;
189     to->dane.dctx = &to->ctx->dane;
190     to->dane.trecs = sk_danetls_record_new_null();
191
192     if (to->dane.trecs == NULL) {
193         SSLerr(SSL_F_SSL_DANE_DUP, ERR_R_MALLOC_FAILURE);
194         return 0;
195     }
196
197     num  = sk_danetls_record_num(from->dane.trecs);
198     for (i = 0; i < num; ++i) {
199         danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);
200
201         if (SSL_dane_tlsa_add(to, t->usage, t->selector, t->mtype,
202                               t->data, t->dlen) <= 0)
203             return 0;
204     }
205     return 1;
206 }
207
208 static int dane_mtype_set(
209     struct dane_ctx_st *dctx,
210     const EVP_MD *md,
211     uint8_t mtype,
212     uint8_t ord)
213 {
214     int i;
215
216     if (mtype == DANETLS_MATCHING_FULL && md != NULL) {
217         SSLerr(SSL_F_DANE_MTYPE_SET,
218                 SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL);
219         return 0;
220     }
221
222     if (mtype > dctx->mdmax) {
223         const EVP_MD **mdevp;
224         uint8_t *mdord;
225         int n = ((int) mtype) + 1;
226
227         mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(*mdevp));
228         if (mdevp == NULL) {
229             SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);
230             return -1;
231         }
232         dctx->mdevp = mdevp;
233
234         mdord = OPENSSL_realloc(dctx->mdord, n * sizeof(*mdord));
235         if (mdord == NULL) {
236             SSLerr(SSL_F_DANE_MTYPE_SET, ERR_R_MALLOC_FAILURE);
237             return -1;
238         }
239         dctx->mdord = mdord;
240
241         /* Zero-fill any gaps */
242         for (i = dctx->mdmax+1; i < mtype; ++i) {
243             mdevp[i] = NULL;
244             mdord[i] = 0;
245         }
246
247         dctx->mdmax = mtype;
248     }
249
250     dctx->mdevp[mtype] = md;
251     /* Coerce ordinal of disabled matching types to 0 */
252     dctx->mdord[mtype] = (md == NULL) ? 0 : ord;
253
254     return 1;
255 }
256
257 static const EVP_MD *tlsa_md_get(SSL_DANE *dane, uint8_t mtype)
258 {
259     if (mtype > dane->dctx->mdmax)
260         return NULL;
261     return dane->dctx->mdevp[mtype];
262 }
263
264 static int dane_tlsa_add(
265     SSL_DANE *dane,
266     uint8_t usage,
267     uint8_t selector,
268     uint8_t mtype,
269     unsigned char *data,
270     size_t dlen)
271 {
272     danetls_record *t;
273     const EVP_MD *md = NULL;
274     int ilen = (int)dlen;
275     int i;
276     int num;
277
278     if (dane->trecs == NULL) {
279         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_NOT_ENABLED);
280         return -1;
281     }
282
283     if (ilen < 0 || dlen != (size_t)ilen) {
284         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DATA_LENGTH);
285         return 0;
286     }
287
288     if (usage > DANETLS_USAGE_LAST) {
289         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE);
290         return 0;
291     }
292
293     if (selector > DANETLS_SELECTOR_LAST) {
294         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_SELECTOR);
295         return 0;
296     }
297
298     if (mtype != DANETLS_MATCHING_FULL) {
299         md = tlsa_md_get(dane, mtype);
300         if (md == NULL) {
301             SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE);
302             return 0;
303         }
304     }
305
306     if (md != NULL && dlen != (size_t)EVP_MD_size(md)) {
307         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH);
308         return 0;
309     }
310     if (!data) {
311         SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_NULL_DATA);
312         return 0;
313     }
314
315     if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL) {
316         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
317         return -1;
318     }
319
320     t->usage = usage;
321     t->selector = selector;
322     t->mtype = mtype;
323     t->data = OPENSSL_malloc(ilen);
324     if (t->data == NULL) {
325         tlsa_free(t);
326         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
327         return -1;
328     }
329     memcpy(t->data, data, ilen);
330     t->dlen = ilen;
331
332     /* Validate and cache full certificate or public key */
333     if (mtype == DANETLS_MATCHING_FULL) {
334         const unsigned char *p = data;
335         X509 *cert = NULL;
336         EVP_PKEY *pkey = NULL;
337
338         switch (selector) {
339         case DANETLS_SELECTOR_CERT:
340             if (!d2i_X509(&cert, &p, dlen) || p < data ||
341                 dlen != (size_t)(p - data)) {
342                 tlsa_free(t);
343                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
344                 return 0;
345             }
346             if (X509_get0_pubkey(cert) == NULL) {
347                 tlsa_free(t);
348                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
349                 return 0;
350             }
351
352             if ((DANETLS_USAGE_BIT(usage) & DANETLS_TA_MASK) == 0) {
353                 X509_free(cert);
354                 break;
355             }
356
357             /*
358              * For usage DANE-TA(2), we support authentication via "2 0 0" TLSA
359              * records that contain full certificates of trust-anchors that are
360              * not present in the wire chain.  For usage PKIX-TA(0), we augment
361              * the chain with untrusted Full(0) certificates from DNS, in case
362              * they are missing from the chain.
363              */
364             if ((dane->certs == NULL &&
365                  (dane->certs = sk_X509_new_null()) == NULL) ||
366                 !sk_X509_push(dane->certs, cert)) {
367                 SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
368                 X509_free(cert);
369                 tlsa_free(t);
370                 return -1;
371             }
372             break;
373
374         case DANETLS_SELECTOR_SPKI:
375             if (!d2i_PUBKEY(&pkey, &p, dlen) || p < data ||
376                 dlen != (size_t)(p - data)) {
377                 tlsa_free(t);
378                 SSLerr(SSL_F_DANE_TLSA_ADD, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY);
379                 return 0;
380             }
381
382             /*
383              * For usage DANE-TA(2), we support authentication via "2 1 0" TLSA
384              * records that contain full bare keys of trust-anchors that are
385              * not present in the wire chain.
386              */
387             if (usage == DANETLS_USAGE_DANE_TA)
388                 t->spki = pkey;
389             else
390                 EVP_PKEY_free(pkey);
391             break;
392         }
393     }
394
395     /*-
396      * Find the right insertion point for the new record.
397      *
398      * See crypto/x509/x509_vfy.c.  We sort DANE-EE(3) records first, so that
399      * they can be processed first, as they require no chain building, and no
400      * expiration or hostname checks.  Because DANE-EE(3) is numerically
401      * largest, this is accomplished via descending sort by "usage".
402      *
403      * We also sort in descending order by matching ordinal to simplify
404      * the implementation of digest agility in the verification code.
405      *
406      * The choice of order for the selector is not significant, so we
407      * use the same descending order for consistency.
408      */
409     num = sk_danetls_record_num(dane->trecs);
410     for (i = 0; i < num; ++i) {
411         danetls_record *rec = sk_danetls_record_value(dane->trecs, i);
412
413         if (rec->usage > usage)
414             continue;
415         if (rec->usage < usage)
416             break;
417         if (rec->selector > selector)
418             continue;
419         if (rec->selector < selector)
420             break;
421         if (dane->dctx->mdord[rec->mtype] > dane->dctx->mdord[mtype])
422             continue;
423         break;
424     }
425
426     if (!sk_danetls_record_insert(dane->trecs, t, i)) {
427         tlsa_free(t);
428         SSLerr(SSL_F_DANE_TLSA_ADD, ERR_R_MALLOC_FAILURE);
429         return -1;
430     }
431     dane->umask |= DANETLS_USAGE_BIT(usage);
432
433     return 1;
434 }
435
436 static void clear_ciphers(SSL *s)
437 {
438     /* clear the current cipher */
439     ssl_clear_cipher_ctx(s);
440     ssl_clear_hash_ctx(&s->read_hash);
441     ssl_clear_hash_ctx(&s->write_hash);
442 }
443
444 int SSL_clear(SSL *s)
445 {
446     if (s->method == NULL) {
447         SSLerr(SSL_F_SSL_CLEAR, SSL_R_NO_METHOD_SPECIFIED);
448         return (0);
449     }
450
451     if (ssl_clear_bad_session(s)) {
452         SSL_SESSION_free(s->session);
453         s->session = NULL;
454     }
455
456     s->error = 0;
457     s->hit = 0;
458     s->shutdown = 0;
459
460     if (s->renegotiate) {
461         SSLerr(SSL_F_SSL_CLEAR, ERR_R_INTERNAL_ERROR);
462         return 0;
463     }
464
465     ossl_statem_clear(s);
466
467     s->version = s->method->version;
468     s->client_version = s->version;
469     s->rwstate = SSL_NOTHING;
470
471     BUF_MEM_free(s->init_buf);
472     s->init_buf = NULL;
473     clear_ciphers(s);
474     s->first_packet = 0;
475
476     /* Reset DANE verification result state */
477     s->dane.mdpth = -1;
478     s->dane.pdpth = -1;
479     X509_free(s->dane.mcert);
480     s->dane.mcert = NULL;
481     s->dane.mtlsa = NULL;
482
483     /* Clear the verification result peername */
484     X509_VERIFY_PARAM_move_peername(s->param, NULL);
485
486     /*
487      * Check to see if we were changed into a different method, if so, revert
488      * back if we are not doing session-id reuse.
489      */
490     if (!ossl_statem_get_in_handshake(s) && (s->session == NULL)
491         && (s->method != s->ctx->method)) {
492         s->method->ssl_free(s);
493         s->method = s->ctx->method;
494         if (!s->method->ssl_new(s))
495             return (0);
496     } else
497         s->method->ssl_clear(s);
498
499     RECORD_LAYER_clear(&s->rlayer);
500
501     return (1);
502 }
503
504 /** Used to change an SSL_CTXs default SSL method type */
505 int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
506 {
507     STACK_OF(SSL_CIPHER) *sk;
508
509     ctx->method = meth;
510
511     sk = ssl_create_cipher_list(ctx->method, &(ctx->cipher_list),
512                                 &(ctx->cipher_list_by_id),
513                                 SSL_DEFAULT_CIPHER_LIST, ctx->cert);
514     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) {
515         SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,
516                SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
517         return (0);
518     }
519     return (1);
520 }
521
522 SSL *SSL_new(SSL_CTX *ctx)
523 {
524     SSL *s;
525
526     if (ctx == NULL) {
527         SSLerr(SSL_F_SSL_NEW, SSL_R_NULL_SSL_CTX);
528         return (NULL);
529     }
530     if (ctx->method == NULL) {
531         SSLerr(SSL_F_SSL_NEW, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
532         return (NULL);
533     }
534
535     s = OPENSSL_zalloc(sizeof(*s));
536     if (s == NULL)
537         goto err;
538
539     s->lock = CRYPTO_THREAD_lock_new();
540     if (s->lock == NULL) {
541         SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
542         OPENSSL_free(s);
543         return NULL;
544     }
545
546     RECORD_LAYER_init(&s->rlayer, s);
547
548     s->options = ctx->options;
549     s->dane.flags = ctx->dane.flags;
550     s->min_proto_version = ctx->min_proto_version;
551     s->max_proto_version = ctx->max_proto_version;
552     s->mode = ctx->mode;
553     s->max_cert_list = ctx->max_cert_list;
554     s->references = 1;
555
556     /*
557      * Earlier library versions used to copy the pointer to the CERT, not
558      * its contents; only when setting new parameters for the per-SSL
559      * copy, ssl_cert_new would be called (and the direct reference to
560      * the per-SSL_CTX settings would be lost, but those still were
561      * indirectly accessed for various purposes, and for that reason they
562      * used to be known as s->ctx->default_cert). Now we don't look at the
563      * SSL_CTX's CERT after having duplicated it once.
564      */
565     s->cert = ssl_cert_dup(ctx->cert);
566     if (s->cert == NULL)
567         goto err;
568
569     RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
570     s->msg_callback = ctx->msg_callback;
571     s->msg_callback_arg = ctx->msg_callback_arg;
572     s->verify_mode = ctx->verify_mode;
573     s->not_resumable_session_cb = ctx->not_resumable_session_cb;
574     s->sid_ctx_length = ctx->sid_ctx_length;
575     OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
576     memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
577     s->verify_callback = ctx->default_verify_callback;
578     s->generate_session_id = ctx->generate_session_id;
579
580     s->param = X509_VERIFY_PARAM_new();
581     if (s->param == NULL)
582         goto err;
583     X509_VERIFY_PARAM_inherit(s->param, ctx->param);
584     s->quiet_shutdown = ctx->quiet_shutdown;
585     s->max_send_fragment = ctx->max_send_fragment;
586     s->split_send_fragment = ctx->split_send_fragment;
587     s->max_pipelines = ctx->max_pipelines;
588     if (s->max_pipelines > 1)
589         RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
590     if (ctx->default_read_buf_len > 0)
591         SSL_set_default_read_buffer_len(s, ctx->default_read_buf_len);
592
593     SSL_CTX_up_ref(ctx);
594     s->ctx = ctx;
595     s->tlsext_debug_cb = 0;
596     s->tlsext_debug_arg = NULL;
597     s->tlsext_ticket_expected = 0;
598     s->tlsext_status_type = ctx->tlsext_status_type;
599     s->tlsext_status_expected = 0;
600     s->tlsext_ocsp_ids = NULL;
601     s->tlsext_ocsp_exts = NULL;
602     s->tlsext_ocsp_resp = NULL;
603     s->tlsext_ocsp_resplen = -1;
604     SSL_CTX_up_ref(ctx);
605     s->initial_ctx = ctx;
606 # ifndef OPENSSL_NO_EC
607     if (ctx->tlsext_ecpointformatlist) {
608         s->tlsext_ecpointformatlist =
609             OPENSSL_memdup(ctx->tlsext_ecpointformatlist,
610                            ctx->tlsext_ecpointformatlist_length);
611         if (!s->tlsext_ecpointformatlist)
612             goto err;
613         s->tlsext_ecpointformatlist_length =
614             ctx->tlsext_ecpointformatlist_length;
615     }
616     if (ctx->tlsext_ellipticcurvelist) {
617         s->tlsext_ellipticcurvelist =
618             OPENSSL_memdup(ctx->tlsext_ellipticcurvelist,
619                            ctx->tlsext_ellipticcurvelist_length);
620         if (!s->tlsext_ellipticcurvelist)
621             goto err;
622         s->tlsext_ellipticcurvelist_length =
623             ctx->tlsext_ellipticcurvelist_length;
624     }
625 # endif
626 # ifndef OPENSSL_NO_NEXTPROTONEG
627     s->next_proto_negotiated = NULL;
628 # endif
629
630     if (s->ctx->alpn_client_proto_list) {
631         s->alpn_client_proto_list =
632             OPENSSL_malloc(s->ctx->alpn_client_proto_list_len);
633         if (s->alpn_client_proto_list == NULL)
634             goto err;
635         memcpy(s->alpn_client_proto_list, s->ctx->alpn_client_proto_list,
636                s->ctx->alpn_client_proto_list_len);
637         s->alpn_client_proto_list_len = s->ctx->alpn_client_proto_list_len;
638     }
639
640     s->verified_chain = NULL;
641     s->verify_result = X509_V_OK;
642
643     s->default_passwd_callback = ctx->default_passwd_callback;
644     s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;
645
646     s->method = ctx->method;
647
648     if (!s->method->ssl_new(s))
649         goto err;
650
651     s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
652
653     if (!SSL_clear(s))
654         goto err;
655
656     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data))
657         goto err;
658
659 #ifndef OPENSSL_NO_PSK
660     s->psk_client_callback = ctx->psk_client_callback;
661     s->psk_server_callback = ctx->psk_server_callback;
662 #endif
663
664     s->job = NULL;
665
666 #ifndef OPENSSL_NO_CT
667     if (!SSL_set_ct_validation_callback(s, ctx->ct_validation_callback,
668             ctx->ct_validation_callback_arg))
669         goto err;
670 #endif
671
672     return s;
673  err:
674     SSL_free(s);
675     SSLerr(SSL_F_SSL_NEW, ERR_R_MALLOC_FAILURE);
676     return NULL;
677 }
678
679 int SSL_is_dtls(const SSL *s)
680 {
681     return SSL_IS_DTLS(s) ? 1 : 0;
682 }
683
684 int SSL_up_ref(SSL *s)
685 {
686     int i;
687
688     if (CRYPTO_atomic_add(&s->references, 1, &i, s->lock) <= 0)
689         return 0;
690
691     REF_PRINT_COUNT("SSL", s);
692     REF_ASSERT_ISNT(i < 2);
693     return ((i > 1) ? 1 : 0);
694 }
695
696 int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
697                                    unsigned int sid_ctx_len)
698 {
699     if (sid_ctx_len > sizeof ctx->sid_ctx) {
700         SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,
701                SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
702         return 0;
703     }
704     ctx->sid_ctx_length = sid_ctx_len;
705     memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
706
707     return 1;
708 }
709
710 int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
711                                unsigned int sid_ctx_len)
712 {
713     if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
714         SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,
715                SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
716         return 0;
717     }
718     ssl->sid_ctx_length = sid_ctx_len;
719     memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
720
721     return 1;
722 }
723
724 int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
725 {
726     CRYPTO_THREAD_write_lock(ctx->lock);
727     ctx->generate_session_id = cb;
728     CRYPTO_THREAD_unlock(ctx->lock);
729     return 1;
730 }
731
732 int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
733 {
734     CRYPTO_THREAD_write_lock(ssl->lock);
735     ssl->generate_session_id = cb;
736     CRYPTO_THREAD_unlock(ssl->lock);
737     return 1;
738 }
739
740 int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
741                                 unsigned int id_len)
742 {
743     /*
744      * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
745      * we can "construct" a session to give us the desired check - ie. to
746      * find if there's a session in the hash table that would conflict with
747      * any new session built out of this id/id_len and the ssl_version in use
748      * by this SSL.
749      */
750     SSL_SESSION r, *p;
751
752     if (id_len > sizeof r.session_id)
753         return 0;
754
755     r.ssl_version = ssl->version;
756     r.session_id_length = id_len;
757     memcpy(r.session_id, id, id_len);
758
759     CRYPTO_THREAD_read_lock(ssl->session_ctx->lock);
760     p = lh_SSL_SESSION_retrieve(ssl->session_ctx->sessions, &r);
761     CRYPTO_THREAD_unlock(ssl->session_ctx->lock);
762     return (p != NULL);
763 }
764
765 int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
766 {
767     return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
768 }
769
770 int SSL_set_purpose(SSL *s, int purpose)
771 {
772     return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
773 }
774
775 int SSL_CTX_set_trust(SSL_CTX *s, int trust)
776 {
777     return X509_VERIFY_PARAM_set_trust(s->param, trust);
778 }
779
780 int SSL_set_trust(SSL *s, int trust)
781 {
782     return X509_VERIFY_PARAM_set_trust(s->param, trust);
783 }
784
785 int SSL_set1_host(SSL *s, const char *hostname)
786 {
787     return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0);
788 }
789
790 int SSL_add1_host(SSL *s, const char *hostname)
791 {
792     return X509_VERIFY_PARAM_add1_host(s->param, hostname, 0);
793 }
794
795 void SSL_set_hostflags(SSL *s, unsigned int flags)
796 {
797     X509_VERIFY_PARAM_set_hostflags(s->param, flags);
798 }
799
800 const char *SSL_get0_peername(SSL *s)
801 {
802     return X509_VERIFY_PARAM_get0_peername(s->param);
803 }
804
805 int SSL_CTX_dane_enable(SSL_CTX *ctx)
806 {
807     return dane_ctx_enable(&ctx->dane);
808 }
809
810 unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags)
811 {
812     unsigned long orig = ctx->dane.flags;
813
814     ctx->dane.flags |= flags;
815     return orig;
816 }
817
818 unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags)
819 {
820     unsigned long orig = ctx->dane.flags;
821
822     ctx->dane.flags &= ~flags;
823     return orig;
824 }
825
826 int SSL_dane_enable(SSL *s, const char *basedomain)
827 {
828     SSL_DANE *dane = &s->dane;
829
830     if (s->ctx->dane.mdmax == 0) {
831         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_CONTEXT_NOT_DANE_ENABLED);
832         return 0;
833     }
834     if (dane->trecs != NULL) {
835         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_DANE_ALREADY_ENABLED);
836         return 0;
837     }
838
839     /*
840      * Default SNI name.  This rejects empty names, while set1_host below
841      * accepts them and disables host name checks.  To avoid side-effects with
842      * invalid input, set the SNI name first.
843      */
844     if (s->tlsext_hostname == NULL) {
845         if (!SSL_set_tlsext_host_name(s, basedomain)) {
846             SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
847             return -1;
848         }
849     }
850
851     /* Primary RFC6125 reference identifier */
852     if (!X509_VERIFY_PARAM_set1_host(s->param, basedomain, 0)) {
853         SSLerr(SSL_F_SSL_DANE_ENABLE, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
854         return -1;
855     }
856
857     dane->mdpth = -1;
858     dane->pdpth = -1;
859     dane->dctx = &s->ctx->dane;
860     dane->trecs = sk_danetls_record_new_null();
861
862     if (dane->trecs == NULL) {
863         SSLerr(SSL_F_SSL_DANE_ENABLE, ERR_R_MALLOC_FAILURE);
864         return -1;
865     }
866     return 1;
867 }
868
869 unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags)
870 {
871     unsigned long orig = ssl->dane.flags;
872
873     ssl->dane.flags |= flags;
874     return orig;
875 }
876
877 unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags)
878 {
879     unsigned long orig = ssl->dane.flags;
880
881     ssl->dane.flags &= ~flags;
882     return orig;
883 }
884
885 int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki)
886 {
887     SSL_DANE *dane = &s->dane;
888
889     if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
890         return -1;
891     if (dane->mtlsa) {
892         if (mcert)
893             *mcert = dane->mcert;
894         if (mspki)
895             *mspki = (dane->mcert == NULL) ? dane->mtlsa->spki : NULL;
896     }
897     return dane->mdpth;
898 }
899
900 int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
901                        uint8_t *mtype, unsigned const char **data, size_t *dlen)
902 {
903     SSL_DANE *dane = &s->dane;
904
905     if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
906         return -1;
907     if (dane->mtlsa) {
908         if (usage)
909             *usage = dane->mtlsa->usage;
910         if (selector)
911             *selector = dane->mtlsa->selector;
912         if (mtype)
913             *mtype = dane->mtlsa->mtype;
914         if (data)
915             *data = dane->mtlsa->data;
916         if (dlen)
917             *dlen = dane->mtlsa->dlen;
918     }
919     return dane->mdpth;
920 }
921
922 SSL_DANE *SSL_get0_dane(SSL *s)
923 {
924     return &s->dane;
925 }
926
927 int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
928                       uint8_t mtype, unsigned char *data, size_t dlen)
929 {
930     return dane_tlsa_add(&s->dane, usage, selector, mtype, data, dlen);
931 }
932
933 int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, uint8_t mtype, uint8_t ord)
934 {
935     return dane_mtype_set(&ctx->dane, md, mtype, ord);
936 }
937
938 int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
939 {
940     return X509_VERIFY_PARAM_set1(ctx->param, vpm);
941 }
942
943 int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
944 {
945     return X509_VERIFY_PARAM_set1(ssl->param, vpm);
946 }
947
948 X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
949 {
950     return ctx->param;
951 }
952
953 X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
954 {
955     return ssl->param;
956 }
957
958 void SSL_certs_clear(SSL *s)
959 {
960     ssl_cert_clear_certs(s->cert);
961 }
962
963 void SSL_free(SSL *s)
964 {
965     int i;
966
967     if (s == NULL)
968         return;
969
970     CRYPTO_atomic_add(&s->references, -1, &i, s->lock);
971     REF_PRINT_COUNT("SSL", s);
972     if (i > 0)
973         return;
974     REF_ASSERT_ISNT(i < 0);
975
976     X509_VERIFY_PARAM_free(s->param);
977     dane_final(&s->dane);
978     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
979
980     if (s->bbio != NULL) {
981         /* If the buffering BIO is in place, pop it off */
982         if (s->bbio == s->wbio) {
983             s->wbio = BIO_pop(s->wbio);
984         }
985         BIO_free(s->bbio);
986         s->bbio = NULL;
987     }
988     if (s->wbio != s->rbio)
989         BIO_free_all(s->wbio);
990     BIO_free_all(s->rbio);
991
992     BUF_MEM_free(s->init_buf);
993
994     /* add extra stuff */
995     sk_SSL_CIPHER_free(s->cipher_list);
996     sk_SSL_CIPHER_free(s->cipher_list_by_id);
997
998     /* Make the next call work :-) */
999     if (s->session != NULL) {
1000         ssl_clear_bad_session(s);
1001         SSL_SESSION_free(s->session);
1002     }
1003
1004     clear_ciphers(s);
1005
1006     ssl_cert_free(s->cert);
1007     /* Free up if allocated */
1008
1009     OPENSSL_free(s->tlsext_hostname);
1010     SSL_CTX_free(s->initial_ctx);
1011 #ifndef OPENSSL_NO_EC
1012     OPENSSL_free(s->tlsext_ecpointformatlist);
1013     OPENSSL_free(s->tlsext_ellipticcurvelist);
1014 #endif                         /* OPENSSL_NO_EC */
1015     sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts, X509_EXTENSION_free);
1016 #ifndef OPENSSL_NO_OCSP
1017     sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
1018 #endif
1019 #ifndef OPENSSL_NO_CT
1020     SCT_LIST_free(s->scts);
1021     OPENSSL_free(s->tlsext_scts);
1022 #endif
1023     OPENSSL_free(s->tlsext_ocsp_resp);
1024     OPENSSL_free(s->alpn_client_proto_list);
1025
1026     sk_X509_NAME_pop_free(s->client_CA, X509_NAME_free);
1027
1028     sk_X509_pop_free(s->verified_chain, X509_free);
1029
1030     if (s->method != NULL)
1031         s->method->ssl_free(s);
1032
1033     RECORD_LAYER_release(&s->rlayer);
1034
1035     SSL_CTX_free(s->ctx);
1036
1037     ASYNC_WAIT_CTX_free(s->waitctx);
1038
1039 #if !defined(OPENSSL_NO_NEXTPROTONEG)
1040     OPENSSL_free(s->next_proto_negotiated);
1041 #endif
1042
1043 #ifndef OPENSSL_NO_SRTP
1044     sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
1045 #endif
1046
1047     CRYPTO_THREAD_lock_free(s->lock);
1048
1049     OPENSSL_free(s);
1050 }
1051
1052 void SSL_set_rbio(SSL *s, BIO *rbio)
1053 {
1054     if (s->rbio != rbio)
1055         BIO_free_all(s->rbio);
1056     s->rbio = rbio;
1057 }
1058
1059 void SSL_set_wbio(SSL *s, BIO *wbio)
1060 {
1061     /*
1062      * If the output buffering BIO is still in place, remove it
1063      */
1064     if (s->bbio != NULL) {
1065         if (s->wbio == s->bbio) {
1066             s->wbio = BIO_next(s->wbio);
1067             BIO_set_next(s->bbio, NULL);
1068         }
1069     }
1070     if (s->wbio != wbio && s->rbio != s->wbio)
1071         BIO_free_all(s->wbio);
1072     s->wbio = wbio;
1073 }
1074
1075 void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
1076 {
1077     SSL_set_wbio(s, wbio);
1078     SSL_set_rbio(s, rbio);
1079 }
1080
1081 BIO *SSL_get_rbio(const SSL *s)
1082 {
1083     return (s->rbio);
1084 }
1085
1086 BIO *SSL_get_wbio(const SSL *s)
1087 {
1088     return (s->wbio);
1089 }
1090
1091 int SSL_get_fd(const SSL *s)
1092 {
1093     return (SSL_get_rfd(s));
1094 }
1095
1096 int SSL_get_rfd(const SSL *s)
1097 {
1098     int ret = -1;
1099     BIO *b, *r;
1100
1101     b = SSL_get_rbio(s);
1102     r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1103     if (r != NULL)
1104         BIO_get_fd(r, &ret);
1105     return (ret);
1106 }
1107
1108 int SSL_get_wfd(const SSL *s)
1109 {
1110     int ret = -1;
1111     BIO *b, *r;
1112
1113     b = SSL_get_wbio(s);
1114     r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1115     if (r != NULL)
1116         BIO_get_fd(r, &ret);
1117     return (ret);
1118 }
1119
1120 #ifndef OPENSSL_NO_SOCK
1121 int SSL_set_fd(SSL *s, int fd)
1122 {
1123     int ret = 0;
1124     BIO *bio = NULL;
1125
1126     bio = BIO_new(BIO_s_socket());
1127
1128     if (bio == NULL) {
1129         SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
1130         goto err;
1131     }
1132     BIO_set_fd(bio, fd, BIO_NOCLOSE);
1133     SSL_set_bio(s, bio, bio);
1134     ret = 1;
1135  err:
1136     return (ret);
1137 }
1138
1139 int SSL_set_wfd(SSL *s, int fd)
1140 {
1141     int ret = 0;
1142     BIO *bio = NULL;
1143
1144     if ((s->rbio == NULL) || (BIO_method_type(s->rbio) != BIO_TYPE_SOCKET)
1145         || ((int)BIO_get_fd(s->rbio, NULL) != fd)) {
1146         bio = BIO_new(BIO_s_socket());
1147
1148         if (bio == NULL) {
1149             SSLerr(SSL_F_SSL_SET_WFD, ERR_R_BUF_LIB);
1150             goto err;
1151         }
1152         BIO_set_fd(bio, fd, BIO_NOCLOSE);
1153         SSL_set_bio(s, SSL_get_rbio(s), bio);
1154     } else
1155         SSL_set_bio(s, SSL_get_rbio(s), SSL_get_rbio(s));
1156     ret = 1;
1157  err:
1158     return (ret);
1159 }
1160
1161 int SSL_set_rfd(SSL *s, int fd)
1162 {
1163     int ret = 0;
1164     BIO *bio = NULL;
1165
1166     if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
1167         || ((int)BIO_get_fd(s->wbio, NULL) != fd)) {
1168         bio = BIO_new(BIO_s_socket());
1169
1170         if (bio == NULL) {
1171             SSLerr(SSL_F_SSL_SET_RFD, ERR_R_BUF_LIB);
1172             goto err;
1173         }
1174         BIO_set_fd(bio, fd, BIO_NOCLOSE);
1175         SSL_set_bio(s, bio, SSL_get_wbio(s));
1176     } else
1177         SSL_set_bio(s, SSL_get_wbio(s), SSL_get_wbio(s));
1178     ret = 1;
1179  err:
1180     return (ret);
1181 }
1182 #endif
1183
1184 /* return length of latest Finished message we sent, copy to 'buf' */
1185 size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
1186 {
1187     size_t ret = 0;
1188
1189     if (s->s3 != NULL) {
1190         ret = s->s3->tmp.finish_md_len;
1191         if (count > ret)
1192             count = ret;
1193         memcpy(buf, s->s3->tmp.finish_md, count);
1194     }
1195     return ret;
1196 }
1197
1198 /* return length of latest Finished message we expected, copy to 'buf' */
1199 size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
1200 {
1201     size_t ret = 0;
1202
1203     if (s->s3 != NULL) {
1204         ret = s->s3->tmp.peer_finish_md_len;
1205         if (count > ret)
1206             count = ret;
1207         memcpy(buf, s->s3->tmp.peer_finish_md, count);
1208     }
1209     return ret;
1210 }
1211
1212 int SSL_get_verify_mode(const SSL *s)
1213 {
1214     return (s->verify_mode);
1215 }
1216
1217 int SSL_get_verify_depth(const SSL *s)
1218 {
1219     return X509_VERIFY_PARAM_get_depth(s->param);
1220 }
1221
1222 int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
1223     return (s->verify_callback);
1224 }
1225
1226 int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
1227 {
1228     return (ctx->verify_mode);
1229 }
1230
1231 int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
1232 {
1233     return X509_VERIFY_PARAM_get_depth(ctx->param);
1234 }
1235
1236 int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
1237     return (ctx->default_verify_callback);
1238 }
1239
1240 void SSL_set_verify(SSL *s, int mode,
1241                     int (*callback) (int ok, X509_STORE_CTX *ctx))
1242 {
1243     s->verify_mode = mode;
1244     if (callback != NULL)
1245         s->verify_callback = callback;
1246 }
1247
1248 void SSL_set_verify_depth(SSL *s, int depth)
1249 {
1250     X509_VERIFY_PARAM_set_depth(s->param, depth);
1251 }
1252
1253 void SSL_set_read_ahead(SSL *s, int yes)
1254 {
1255     RECORD_LAYER_set_read_ahead(&s->rlayer, yes);
1256 }
1257
1258 int SSL_get_read_ahead(const SSL *s)
1259 {
1260     return RECORD_LAYER_get_read_ahead(&s->rlayer);
1261 }
1262
1263 int SSL_pending(const SSL *s)
1264 {
1265     /*
1266      * SSL_pending cannot work properly if read-ahead is enabled
1267      * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)), and it is
1268      * impossible to fix since SSL_pending cannot report errors that may be
1269      * observed while scanning the new data. (Note that SSL_pending() is
1270      * often used as a boolean value, so we'd better not return -1.)
1271      */
1272     return (s->method->ssl_pending(s));
1273 }
1274
1275 int SSL_has_pending(const SSL *s)
1276 {
1277     /*
1278      * Similar to SSL_pending() but returns a 1 to indicate that we have
1279      * unprocessed data available or 0 otherwise (as opposed to the number of
1280      * bytes available). Unlike SSL_pending() this will take into account
1281      * read_ahead data. A 1 return simply indicates that we have unprocessed
1282      * data. That data may not result in any application data, or we may fail
1283      * to parse the records for some reason.
1284      */
1285     if (SSL_pending(s))
1286         return 1;
1287
1288     return RECORD_LAYER_read_pending(&s->rlayer);
1289 }
1290
1291 X509 *SSL_get_peer_certificate(const SSL *s)
1292 {
1293     X509 *r;
1294
1295     if ((s == NULL) || (s->session == NULL))
1296         r = NULL;
1297     else
1298         r = s->session->peer;
1299
1300     if (r == NULL)
1301         return (r);
1302
1303     X509_up_ref(r);
1304
1305     return (r);
1306 }
1307
1308 STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
1309 {
1310     STACK_OF(X509) *r;
1311
1312     if ((s == NULL) || (s->session == NULL))
1313         r = NULL;
1314     else
1315         r = s->session->peer_chain;
1316
1317     /*
1318      * If we are a client, cert_chain includes the peer's own certificate; if
1319      * we are a server, it does not.
1320      */
1321
1322     return (r);
1323 }
1324
1325 /*
1326  * Now in theory, since the calling process own 't' it should be safe to
1327  * modify.  We need to be able to read f without being hassled
1328  */
1329 int SSL_copy_session_id(SSL *t, const SSL *f)
1330 {
1331     int i;
1332     /* Do we need to to SSL locking? */
1333     if (!SSL_set_session(t, SSL_get_session(f))) {
1334         return 0;
1335     }
1336
1337     /*
1338      * what if we are setup for one protocol version but want to talk another
1339      */
1340     if (t->method != f->method) {
1341         t->method->ssl_free(t);
1342         t->method = f->method;
1343         if (t->method->ssl_new(t) == 0)
1344             return 0;
1345     }
1346
1347     CRYPTO_atomic_add(&f->cert->references, 1, &i, f->cert->lock);
1348     ssl_cert_free(t->cert);
1349     t->cert = f->cert;
1350     if (!SSL_set_session_id_context(t, f->sid_ctx, f->sid_ctx_length)) {
1351         return 0;
1352     }
1353
1354     return 1;
1355 }
1356
1357 /* Fix this so it checks all the valid key/cert options */
1358 int SSL_CTX_check_private_key(const SSL_CTX *ctx)
1359 {
1360     if ((ctx == NULL) ||
1361         (ctx->cert->key->x509 == NULL)) {
1362         SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,
1363                SSL_R_NO_CERTIFICATE_ASSIGNED);
1364         return (0);
1365     }
1366     if (ctx->cert->key->privatekey == NULL) {
1367         SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,
1368                SSL_R_NO_PRIVATE_KEY_ASSIGNED);
1369         return (0);
1370     }
1371     return (X509_check_private_key
1372             (ctx->cert->key->x509, ctx->cert->key->privatekey));
1373 }
1374
1375 /* Fix this function so that it takes an optional type parameter */
1376 int SSL_check_private_key(const SSL *ssl)
1377 {
1378     if (ssl == NULL) {
1379         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
1380         return (0);
1381     }
1382     if (ssl->cert->key->x509 == NULL) {
1383         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_CERTIFICATE_ASSIGNED);
1384         return (0);
1385     }
1386     if (ssl->cert->key->privatekey == NULL) {
1387         SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
1388         return (0);
1389     }
1390     return (X509_check_private_key(ssl->cert->key->x509,
1391                                    ssl->cert->key->privatekey));
1392 }
1393
1394 int SSL_waiting_for_async(SSL *s)
1395 {
1396     if(s->job)
1397         return 1;
1398
1399     return 0;
1400 }
1401
1402 int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds)
1403 {
1404     ASYNC_WAIT_CTX *ctx = s->waitctx;
1405
1406     if (ctx == NULL)
1407         return 0;
1408     return ASYNC_WAIT_CTX_get_all_fds(ctx, fds, numfds);
1409 }
1410
1411 int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds,
1412                               OSSL_ASYNC_FD *delfd, size_t *numdelfds)
1413 {
1414     ASYNC_WAIT_CTX *ctx = s->waitctx;
1415
1416     if (ctx == NULL)
1417         return 0;
1418     return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd,
1419                                           numdelfds);
1420 }
1421
1422 int SSL_accept(SSL *s)
1423 {
1424     if (s->handshake_func == NULL) {
1425         /* Not properly initialized yet */
1426         SSL_set_accept_state(s);
1427     }
1428
1429     return SSL_do_handshake(s);
1430 }
1431
1432 int SSL_connect(SSL *s)
1433 {
1434     if (s->handshake_func == NULL) {
1435         /* Not properly initialized yet */
1436         SSL_set_connect_state(s);
1437     }
1438
1439     return SSL_do_handshake(s);
1440 }
1441
1442 long SSL_get_default_timeout(const SSL *s)
1443 {
1444     return (s->method->get_timeout());
1445 }
1446
1447 static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
1448                           int (*func)(void *)) {
1449     int ret;
1450     if (s->waitctx == NULL) {
1451         s->waitctx = ASYNC_WAIT_CTX_new();
1452         if (s->waitctx == NULL)
1453             return -1;
1454     }
1455     switch(ASYNC_start_job(&s->job, s->waitctx, &ret, func, args,
1456         sizeof(struct ssl_async_args))) {
1457     case ASYNC_ERR:
1458         s->rwstate = SSL_NOTHING;
1459         SSLerr(SSL_F_SSL_START_ASYNC_JOB, SSL_R_FAILED_TO_INIT_ASYNC);
1460         return -1;
1461     case ASYNC_PAUSE:
1462         s->rwstate = SSL_ASYNC_PAUSED;
1463         return -1;
1464     case ASYNC_NO_JOBS:
1465         s->rwstate = SSL_ASYNC_NO_JOBS;
1466         return -1;
1467     case ASYNC_FINISH:
1468         s->job = NULL;
1469         return ret;
1470     default:
1471         s->rwstate = SSL_NOTHING;
1472         SSLerr(SSL_F_SSL_START_ASYNC_JOB, ERR_R_INTERNAL_ERROR);
1473         /* Shouldn't happen */
1474         return -1;
1475     }
1476 }
1477
1478 static int ssl_io_intern(void *vargs)
1479 {
1480     struct ssl_async_args *args;
1481     SSL *s;
1482     void *buf;
1483     int num;
1484
1485     args = (struct ssl_async_args *)vargs;
1486     s = args->s;
1487     buf = args->buf;
1488     num = args->num;
1489     switch (args->type) {
1490     case READFUNC:
1491         return args->f.func_read(s, buf, num);
1492     case WRITEFUNC:
1493         return args->f.func_write(s, buf, num);
1494     case OTHERFUNC:
1495         return args->f.func_other(s);
1496     }
1497     return -1;
1498 }
1499
1500 int SSL_read(SSL *s, void *buf, int num)
1501 {
1502     if (s->handshake_func == NULL) {
1503         SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
1504         return -1;
1505     }
1506
1507     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1508         s->rwstate = SSL_NOTHING;
1509         return (0);
1510     }
1511
1512     if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1513         struct ssl_async_args args;
1514
1515         args.s = s;
1516         args.buf = buf;
1517         args.num = num;
1518         args.type = READFUNC;
1519         args.f.func_read = s->method->ssl_read;
1520
1521         return ssl_start_async_job(s, &args, ssl_io_intern);
1522     } else {
1523         return s->method->ssl_read(s, buf, num);
1524     }
1525 }
1526
1527 int SSL_peek(SSL *s, void *buf, int num)
1528 {
1529     if (s->handshake_func == NULL) {
1530         SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
1531         return -1;
1532     }
1533
1534     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
1535         return (0);
1536     }
1537     if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1538         struct ssl_async_args args;
1539
1540         args.s = s;
1541         args.buf = buf;
1542         args.num = num;
1543         args.type = READFUNC;
1544         args.f.func_read = s->method->ssl_peek;
1545
1546         return ssl_start_async_job(s, &args, ssl_io_intern);
1547     } else {
1548         return s->method->ssl_peek(s, buf, num);
1549     }
1550 }
1551
1552 int SSL_write(SSL *s, const void *buf, int num)
1553 {
1554     if (s->handshake_func == NULL) {
1555         SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
1556         return -1;
1557     }
1558
1559     if (s->shutdown & SSL_SENT_SHUTDOWN) {
1560         s->rwstate = SSL_NOTHING;
1561         SSLerr(SSL_F_SSL_WRITE, SSL_R_PROTOCOL_IS_SHUTDOWN);
1562         return (-1);
1563     }
1564
1565     if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1566         struct ssl_async_args args;
1567
1568         args.s = s;
1569         args.buf = (void *)buf;
1570         args.num = num;
1571         args.type = WRITEFUNC;
1572         args.f.func_write = s->method->ssl_write;
1573
1574         return ssl_start_async_job(s, &args, ssl_io_intern);
1575     } else {
1576         return s->method->ssl_write(s, buf, num);
1577     }
1578 }
1579
1580 int SSL_shutdown(SSL *s)
1581 {
1582     /*
1583      * Note that this function behaves differently from what one might
1584      * expect.  Return values are 0 for no success (yet), 1 for success; but
1585      * calling it once is usually not enough, even if blocking I/O is used
1586      * (see ssl3_shutdown).
1587      */
1588
1589     if (s->handshake_func == NULL) {
1590         SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
1591         return -1;
1592     }
1593
1594     if (!SSL_in_init(s)) {
1595         if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
1596             struct ssl_async_args args;
1597
1598             args.s = s;
1599             args.type = OTHERFUNC;
1600             args.f.func_other = s->method->ssl_shutdown;
1601
1602             return ssl_start_async_job(s, &args, ssl_io_intern);
1603         } else {
1604             return s->method->ssl_shutdown(s);
1605         }
1606     } else {
1607         SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_SHUTDOWN_WHILE_IN_INIT);
1608         return -1;
1609     }
1610 }
1611
1612 int SSL_renegotiate(SSL *s)
1613 {
1614     if (s->renegotiate == 0)
1615         s->renegotiate = 1;
1616
1617     s->new_session = 1;
1618
1619     return (s->method->ssl_renegotiate(s));
1620 }
1621
1622 int SSL_renegotiate_abbreviated(SSL *s)
1623 {
1624     if (s->renegotiate == 0)
1625         s->renegotiate = 1;
1626
1627     s->new_session = 0;
1628
1629     return (s->method->ssl_renegotiate(s));
1630 }
1631
1632 int SSL_renegotiate_pending(SSL *s)
1633 {
1634     /*
1635      * becomes true when negotiation is requested; false again once a
1636      * handshake has finished
1637      */
1638     return (s->renegotiate != 0);
1639 }
1640
1641 long SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
1642 {
1643     long l;
1644
1645     switch (cmd) {
1646     case SSL_CTRL_GET_READ_AHEAD:
1647         return (RECORD_LAYER_get_read_ahead(&s->rlayer));
1648     case SSL_CTRL_SET_READ_AHEAD:
1649         l = RECORD_LAYER_get_read_ahead(&s->rlayer);
1650         RECORD_LAYER_set_read_ahead(&s->rlayer, larg);
1651         return (l);
1652
1653     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1654         s->msg_callback_arg = parg;
1655         return 1;
1656
1657     case SSL_CTRL_MODE:
1658         return (s->mode |= larg);
1659     case SSL_CTRL_CLEAR_MODE:
1660         return (s->mode &= ~larg);
1661     case SSL_CTRL_GET_MAX_CERT_LIST:
1662         return (s->max_cert_list);
1663     case SSL_CTRL_SET_MAX_CERT_LIST:
1664         l = s->max_cert_list;
1665         s->max_cert_list = larg;
1666         return (l);
1667     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1668         if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1669             return 0;
1670         s->max_send_fragment = larg;
1671         if (s->max_send_fragment < s->split_send_fragment)
1672             s->split_send_fragment = s->max_send_fragment;
1673         return 1;
1674     case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
1675         if ((unsigned int)larg > s->max_send_fragment || larg == 0)
1676             return 0;
1677         s->split_send_fragment = larg;
1678         return 1;
1679     case SSL_CTRL_SET_MAX_PIPELINES:
1680         if (larg < 1 || larg > SSL_MAX_PIPELINES)
1681             return 0;
1682         s->max_pipelines = larg;
1683         if (larg > 1)
1684             RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
1685         return 1;
1686     case SSL_CTRL_GET_RI_SUPPORT:
1687         if (s->s3)
1688             return s->s3->send_connection_binding;
1689         else
1690             return 0;
1691     case SSL_CTRL_CERT_FLAGS:
1692         return (s->cert->cert_flags |= larg);
1693     case SSL_CTRL_CLEAR_CERT_FLAGS:
1694         return (s->cert->cert_flags &= ~larg);
1695
1696     case SSL_CTRL_GET_RAW_CIPHERLIST:
1697         if (parg) {
1698             if (s->s3->tmp.ciphers_raw == NULL)
1699                 return 0;
1700             *(unsigned char **)parg = s->s3->tmp.ciphers_raw;
1701             return (int)s->s3->tmp.ciphers_rawlen;
1702         } else {
1703             return TLS_CIPHER_LEN;
1704         }
1705     case SSL_CTRL_GET_EXTMS_SUPPORT:
1706         if (!s->session || SSL_in_init(s) || ossl_statem_get_in_handshake(s))
1707                 return -1;
1708         if (s->session->flags & SSL_SESS_FLAG_EXTMS)
1709             return 1;
1710         else
1711             return 0;
1712     case SSL_CTRL_SET_MIN_PROTO_VERSION:
1713         return ssl_set_version_bound(s->ctx->method->version, (int)larg,
1714                                      &s->min_proto_version);
1715     case SSL_CTRL_SET_MAX_PROTO_VERSION:
1716         return ssl_set_version_bound(s->ctx->method->version, (int)larg,
1717                                      &s->max_proto_version);
1718     default:
1719         return (s->method->ssl_ctrl(s, cmd, larg, parg));
1720     }
1721 }
1722
1723 long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
1724 {
1725     switch (cmd) {
1726     case SSL_CTRL_SET_MSG_CALLBACK:
1727         s->msg_callback = (void (*)
1728                            (int write_p, int version, int content_type,
1729                             const void *buf, size_t len, SSL *ssl,
1730                             void *arg))(fp);
1731         return 1;
1732
1733     default:
1734         return (s->method->ssl_callback_ctrl(s, cmd, fp));
1735     }
1736 }
1737
1738 LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
1739 {
1740     return ctx->sessions;
1741 }
1742
1743 long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
1744 {
1745     long l;
1746     /* For some cases with ctx == NULL perform syntax checks */
1747     if (ctx == NULL) {
1748         switch (cmd) {
1749 #ifndef OPENSSL_NO_EC
1750         case SSL_CTRL_SET_CURVES_LIST:
1751             return tls1_set_curves_list(NULL, NULL, parg);
1752 #endif
1753         case SSL_CTRL_SET_SIGALGS_LIST:
1754         case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
1755             return tls1_set_sigalgs_list(NULL, parg, 0);
1756         default:
1757             return 0;
1758         }
1759     }
1760
1761     switch (cmd) {
1762     case SSL_CTRL_GET_READ_AHEAD:
1763         return (ctx->read_ahead);
1764     case SSL_CTRL_SET_READ_AHEAD:
1765         l = ctx->read_ahead;
1766         ctx->read_ahead = larg;
1767         return (l);
1768
1769     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1770         ctx->msg_callback_arg = parg;
1771         return 1;
1772
1773     case SSL_CTRL_GET_MAX_CERT_LIST:
1774         return (ctx->max_cert_list);
1775     case SSL_CTRL_SET_MAX_CERT_LIST:
1776         l = ctx->max_cert_list;
1777         ctx->max_cert_list = larg;
1778         return (l);
1779
1780     case SSL_CTRL_SET_SESS_CACHE_SIZE:
1781         l = ctx->session_cache_size;
1782         ctx->session_cache_size = larg;
1783         return (l);
1784     case SSL_CTRL_GET_SESS_CACHE_SIZE:
1785         return (ctx->session_cache_size);
1786     case SSL_CTRL_SET_SESS_CACHE_MODE:
1787         l = ctx->session_cache_mode;
1788         ctx->session_cache_mode = larg;
1789         return (l);
1790     case SSL_CTRL_GET_SESS_CACHE_MODE:
1791         return (ctx->session_cache_mode);
1792
1793     case SSL_CTRL_SESS_NUMBER:
1794         return (lh_SSL_SESSION_num_items(ctx->sessions));
1795     case SSL_CTRL_SESS_CONNECT:
1796         return (ctx->stats.sess_connect);
1797     case SSL_CTRL_SESS_CONNECT_GOOD:
1798         return (ctx->stats.sess_connect_good);
1799     case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
1800         return (ctx->stats.sess_connect_renegotiate);
1801     case SSL_CTRL_SESS_ACCEPT:
1802         return (ctx->stats.sess_accept);
1803     case SSL_CTRL_SESS_ACCEPT_GOOD:
1804         return (ctx->stats.sess_accept_good);
1805     case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
1806         return (ctx->stats.sess_accept_renegotiate);
1807     case SSL_CTRL_SESS_HIT:
1808         return (ctx->stats.sess_hit);
1809     case SSL_CTRL_SESS_CB_HIT:
1810         return (ctx->stats.sess_cb_hit);
1811     case SSL_CTRL_SESS_MISSES:
1812         return (ctx->stats.sess_miss);
1813     case SSL_CTRL_SESS_TIMEOUTS:
1814         return (ctx->stats.sess_timeout);
1815     case SSL_CTRL_SESS_CACHE_FULL:
1816         return (ctx->stats.sess_cache_full);
1817     case SSL_CTRL_MODE:
1818         return (ctx->mode |= larg);
1819     case SSL_CTRL_CLEAR_MODE:
1820         return (ctx->mode &= ~larg);
1821     case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1822         if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1823             return 0;
1824         ctx->max_send_fragment = larg;
1825         if (ctx->max_send_fragment < ctx->split_send_fragment)
1826             ctx->split_send_fragment = ctx->max_send_fragment;
1827         return 1;
1828     case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
1829         if ((unsigned int)larg > ctx->max_send_fragment || larg == 0)
1830             return 0;
1831         ctx->split_send_fragment = larg;
1832         return 1;
1833     case SSL_CTRL_SET_MAX_PIPELINES:
1834         if (larg < 1 || larg > SSL_MAX_PIPELINES)
1835             return 0;
1836         ctx->max_pipelines = larg;
1837         return 1;
1838     case SSL_CTRL_CERT_FLAGS:
1839         return (ctx->cert->cert_flags |= larg);
1840     case SSL_CTRL_CLEAR_CERT_FLAGS:
1841         return (ctx->cert->cert_flags &= ~larg);
1842     case SSL_CTRL_SET_MIN_PROTO_VERSION:
1843         return ssl_set_version_bound(ctx->method->version, (int)larg,
1844                                      &ctx->min_proto_version);
1845     case SSL_CTRL_SET_MAX_PROTO_VERSION:
1846         return ssl_set_version_bound(ctx->method->version, (int)larg,
1847                                      &ctx->max_proto_version);
1848     default:
1849         return (ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg));
1850     }
1851 }
1852
1853 long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
1854 {
1855     switch (cmd) {
1856     case SSL_CTRL_SET_MSG_CALLBACK:
1857         ctx->msg_callback = (void (*)
1858                              (int write_p, int version, int content_type,
1859                               const void *buf, size_t len, SSL *ssl,
1860                               void *arg))(fp);
1861         return 1;
1862
1863     default:
1864         return (ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp));
1865     }
1866 }
1867
1868 int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
1869 {
1870     if (a->id > b->id)
1871         return 1;
1872     if (a->id < b->id)
1873         return -1;
1874     return 0;
1875 }
1876
1877 int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
1878                           const SSL_CIPHER *const *bp)
1879 {
1880     if ((*ap)->id > (*bp)->id)
1881         return 1;
1882     if ((*ap)->id < (*bp)->id)
1883         return -1;
1884     return 0;
1885 }
1886
1887 /** return a STACK of the ciphers available for the SSL and in order of
1888  * preference */
1889 STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
1890 {
1891     if (s != NULL) {
1892         if (s->cipher_list != NULL) {
1893             return (s->cipher_list);
1894         } else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) {
1895             return (s->ctx->cipher_list);
1896         }
1897     }
1898     return (NULL);
1899 }
1900
1901 STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s)
1902 {
1903     if ((s == NULL) || (s->session == NULL) || !s->server)
1904         return NULL;
1905     return s->session->ciphers;
1906 }
1907
1908 STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
1909 {
1910     STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
1911     int i;
1912     ciphers = SSL_get_ciphers(s);
1913     if (!ciphers)
1914         return NULL;
1915     ssl_set_client_disabled(s);
1916     for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
1917         const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
1918         if (!ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED)) {
1919             if (!sk)
1920                 sk = sk_SSL_CIPHER_new_null();
1921             if (!sk)
1922                 return NULL;
1923             if (!sk_SSL_CIPHER_push(sk, c)) {
1924                 sk_SSL_CIPHER_free(sk);
1925                 return NULL;
1926             }
1927         }
1928     }
1929     return sk;
1930 }
1931
1932 /** return a STACK of the ciphers available for the SSL and in order of
1933  * algorithm id */
1934 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
1935 {
1936     if (s != NULL) {
1937         if (s->cipher_list_by_id != NULL) {
1938             return (s->cipher_list_by_id);
1939         } else if ((s->ctx != NULL) && (s->ctx->cipher_list_by_id != NULL)) {
1940             return (s->ctx->cipher_list_by_id);
1941         }
1942     }
1943     return (NULL);
1944 }
1945
1946 /** The old interface to get the same thing as SSL_get_ciphers() */
1947 const char *SSL_get_cipher_list(const SSL *s, int n)
1948 {
1949     const SSL_CIPHER *c;
1950     STACK_OF(SSL_CIPHER) *sk;
1951
1952     if (s == NULL)
1953         return (NULL);
1954     sk = SSL_get_ciphers(s);
1955     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
1956         return (NULL);
1957     c = sk_SSL_CIPHER_value(sk, n);
1958     if (c == NULL)
1959         return (NULL);
1960     return (c->name);
1961 }
1962
1963 /** return a STACK of the ciphers available for the SSL_CTX and in order of
1964  * preference */
1965 STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx)
1966 {
1967     if (ctx != NULL)
1968         return ctx->cipher_list;
1969     return NULL;
1970 }
1971
1972 /** specify the ciphers to be used by default by the SSL_CTX */
1973 int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
1974 {
1975     STACK_OF(SSL_CIPHER) *sk;
1976
1977     sk = ssl_create_cipher_list(ctx->method, &ctx->cipher_list,
1978                                 &ctx->cipher_list_by_id, str, ctx->cert);
1979     /*
1980      * ssl_create_cipher_list may return an empty stack if it was unable to
1981      * find a cipher matching the given rule string (for example if the rule
1982      * string specifies a cipher which has been disabled). This is not an
1983      * error as far as ssl_create_cipher_list is concerned, and hence
1984      * ctx->cipher_list and ctx->cipher_list_by_id has been updated.
1985      */
1986     if (sk == NULL)
1987         return 0;
1988     else if (sk_SSL_CIPHER_num(sk) == 0) {
1989         SSLerr(SSL_F_SSL_CTX_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
1990         return 0;
1991     }
1992     return 1;
1993 }
1994
1995 /** specify the ciphers to be used by the SSL */
1996 int SSL_set_cipher_list(SSL *s, const char *str)
1997 {
1998     STACK_OF(SSL_CIPHER) *sk;
1999
2000     sk = ssl_create_cipher_list(s->ctx->method, &s->cipher_list,
2001                                 &s->cipher_list_by_id, str, s->cert);
2002     /* see comment in SSL_CTX_set_cipher_list */
2003     if (sk == NULL)
2004         return 0;
2005     else if (sk_SSL_CIPHER_num(sk) == 0) {
2006         SSLerr(SSL_F_SSL_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
2007         return 0;
2008     }
2009     return 1;
2010 }
2011
2012 char *SSL_get_shared_ciphers(const SSL *s, char *buf, int len)
2013 {
2014     char *p;
2015     STACK_OF(SSL_CIPHER) *sk;
2016     const SSL_CIPHER *c;
2017     int i;
2018
2019     if ((s->session == NULL) || (s->session->ciphers == NULL) || (len < 2))
2020         return (NULL);
2021
2022     p = buf;
2023     sk = s->session->ciphers;
2024
2025     if (sk_SSL_CIPHER_num(sk) == 0)
2026         return NULL;
2027
2028     for (i = 0; i < sk_SSL_CIPHER_num(sk); i++) {
2029         int n;
2030
2031         c = sk_SSL_CIPHER_value(sk, i);
2032         n = strlen(c->name);
2033         if (n + 1 > len) {
2034             if (p != buf)
2035                 --p;
2036             *p = '\0';
2037             return buf;
2038         }
2039         memcpy(p, c->name, n + 1);
2040         p += n;
2041         *(p++) = ':';
2042         len -= n + 1;
2043     }
2044     p[-1] = '\0';
2045     return (buf);
2046 }
2047
2048 /** return a servername extension value if provided in Client Hello, or NULL.
2049  * So far, only host_name types are defined (RFC 3546).
2050  */
2051
2052 const char *SSL_get_servername(const SSL *s, const int type)
2053 {
2054     if (type != TLSEXT_NAMETYPE_host_name)
2055         return NULL;
2056
2057     return s->session && !s->tlsext_hostname ?
2058         s->session->tlsext_hostname : s->tlsext_hostname;
2059 }
2060
2061 int SSL_get_servername_type(const SSL *s)
2062 {
2063     if (s->session
2064         && (!s->tlsext_hostname ? s->session->
2065             tlsext_hostname : s->tlsext_hostname))
2066         return TLSEXT_NAMETYPE_host_name;
2067     return -1;
2068 }
2069
2070 /*
2071  * SSL_select_next_proto implements the standard protocol selection. It is
2072  * expected that this function is called from the callback set by
2073  * SSL_CTX_set_next_proto_select_cb. The protocol data is assumed to be a
2074  * vector of 8-bit, length prefixed byte strings. The length byte itself is
2075  * not included in the length. A byte string of length 0 is invalid. No byte
2076  * string may be truncated. The current, but experimental algorithm for
2077  * selecting the protocol is: 1) If the server doesn't support NPN then this
2078  * is indicated to the callback. In this case, the client application has to
2079  * abort the connection or have a default application level protocol. 2) If
2080  * the server supports NPN, but advertises an empty list then the client
2081  * selects the first protocol in its list, but indicates via the API that this
2082  * fallback case was enacted. 3) Otherwise, the client finds the first
2083  * protocol in the server's list that it supports and selects this protocol.
2084  * This is because it's assumed that the server has better information about
2085  * which protocol a client should use. 4) If the client doesn't support any
2086  * of the server's advertised protocols, then this is treated the same as
2087  * case 2. It returns either OPENSSL_NPN_NEGOTIATED if a common protocol was
2088  * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
2089  */
2090 int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
2091                           const unsigned char *server,
2092                           unsigned int server_len,
2093                           const unsigned char *client,
2094                           unsigned int client_len)
2095 {
2096     unsigned int i, j;
2097     const unsigned char *result;
2098     int status = OPENSSL_NPN_UNSUPPORTED;
2099
2100     /*
2101      * For each protocol in server preference order, see if we support it.
2102      */
2103     for (i = 0; i < server_len;) {
2104         for (j = 0; j < client_len;) {
2105             if (server[i] == client[j] &&
2106                 memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) {
2107                 /* We found a match */
2108                 result = &server[i];
2109                 status = OPENSSL_NPN_NEGOTIATED;
2110                 goto found;
2111             }
2112             j += client[j];
2113             j++;
2114         }
2115         i += server[i];
2116         i++;
2117     }
2118
2119     /* There's no overlap between our protocols and the server's list. */
2120     result = client;
2121     status = OPENSSL_NPN_NO_OVERLAP;
2122
2123  found:
2124     *out = (unsigned char *)result + 1;
2125     *outlen = result[0];
2126     return status;
2127 }
2128
2129 #ifndef OPENSSL_NO_NEXTPROTONEG
2130 /*
2131  * SSL_get0_next_proto_negotiated sets *data and *len to point to the
2132  * client's requested protocol for this connection and returns 0. If the
2133  * client didn't request any protocol, then *data is set to NULL. Note that
2134  * the client can request any protocol it chooses. The value returned from
2135  * this function need not be a member of the list of supported protocols
2136  * provided by the callback.
2137  */
2138 void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
2139                                     unsigned *len)
2140 {
2141     *data = s->next_proto_negotiated;
2142     if (!*data) {
2143         *len = 0;
2144     } else {
2145         *len = s->next_proto_negotiated_len;
2146     }
2147 }
2148
2149 /*
2150  * SSL_CTX_set_next_protos_advertised_cb sets a callback that is called when
2151  * a TLS server needs a list of supported protocols for Next Protocol
2152  * Negotiation. The returned list must be in wire format.  The list is
2153  * returned by setting |out| to point to it and |outlen| to its length. This
2154  * memory will not be modified, but one should assume that the SSL* keeps a
2155  * reference to it. The callback should return SSL_TLSEXT_ERR_OK if it
2156  * wishes to advertise. Otherwise, no such extension will be included in the
2157  * ServerHello.
2158  */
2159 void SSL_CTX_set_next_protos_advertised_cb(SSL_CTX *ctx,
2160                                            int (*cb) (SSL *ssl,
2161                                                       const unsigned char
2162                                                       **out,
2163                                                       unsigned int *outlen,
2164                                                       void *arg), void *arg)
2165 {
2166     ctx->next_protos_advertised_cb = cb;
2167     ctx->next_protos_advertised_cb_arg = arg;
2168 }
2169
2170 /*
2171  * SSL_CTX_set_next_proto_select_cb sets a callback that is called when a
2172  * client needs to select a protocol from the server's provided list. |out|
2173  * must be set to point to the selected protocol (which may be within |in|).
2174  * The length of the protocol name must be written into |outlen|. The
2175  * server's advertised protocols are provided in |in| and |inlen|. The
2176  * callback can assume that |in| is syntactically valid. The client must
2177  * select a protocol. It is fatal to the connection if this callback returns
2178  * a value other than SSL_TLSEXT_ERR_OK.
2179  */
2180 void SSL_CTX_set_next_proto_select_cb(SSL_CTX *ctx,
2181                                       int (*cb) (SSL *s, unsigned char **out,
2182                                                  unsigned char *outlen,
2183                                                  const unsigned char *in,
2184                                                  unsigned int inlen,
2185                                                  void *arg), void *arg)
2186 {
2187     ctx->next_proto_select_cb = cb;
2188     ctx->next_proto_select_cb_arg = arg;
2189 }
2190 #endif
2191
2192 /*
2193  * SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|.
2194  * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
2195  * length-prefixed strings). Returns 0 on success.
2196  */
2197 int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
2198                             unsigned int protos_len)
2199 {
2200     OPENSSL_free(ctx->alpn_client_proto_list);
2201     ctx->alpn_client_proto_list = OPENSSL_memdup(protos, protos_len);
2202     if (ctx->alpn_client_proto_list == NULL) {
2203         SSLerr(SSL_F_SSL_CTX_SET_ALPN_PROTOS, ERR_R_MALLOC_FAILURE);
2204         return 1;
2205     }
2206     ctx->alpn_client_proto_list_len = protos_len;
2207
2208     return 0;
2209 }
2210
2211 /*
2212  * SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|.
2213  * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
2214  * length-prefixed strings). Returns 0 on success.
2215  */
2216 int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
2217                         unsigned int protos_len)
2218 {
2219     OPENSSL_free(ssl->alpn_client_proto_list);
2220     ssl->alpn_client_proto_list = OPENSSL_memdup(protos, protos_len);
2221     if (ssl->alpn_client_proto_list == NULL) {
2222         SSLerr(SSL_F_SSL_SET_ALPN_PROTOS, ERR_R_MALLOC_FAILURE);
2223         return 1;
2224     }
2225     ssl->alpn_client_proto_list_len = protos_len;
2226
2227     return 0;
2228 }
2229
2230 /*
2231  * SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is
2232  * called during ClientHello processing in order to select an ALPN protocol
2233  * from the client's list of offered protocols.
2234  */
2235 void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
2236                                 int (*cb) (SSL *ssl,
2237                                            const unsigned char **out,
2238                                            unsigned char *outlen,
2239                                            const unsigned char *in,
2240                                            unsigned int inlen,
2241                                            void *arg), void *arg)
2242 {
2243     ctx->alpn_select_cb = cb;
2244     ctx->alpn_select_cb_arg = arg;
2245 }
2246
2247 /*
2248  * SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from
2249  * |ssl|. On return it sets |*data| to point to |*len| bytes of protocol name
2250  * (not including the leading length-prefix byte). If the server didn't
2251  * respond with a negotiated protocol then |*len| will be zero.
2252  */
2253 void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
2254                             unsigned int *len)
2255 {
2256     *data = NULL;
2257     if (ssl->s3)
2258         *data = ssl->s3->alpn_selected;
2259     if (*data == NULL)
2260         *len = 0;
2261     else
2262         *len = ssl->s3->alpn_selected_len;
2263 }
2264
2265
2266 int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
2267                                const char *label, size_t llen,
2268                                const unsigned char *p, size_t plen,
2269                                int use_context)
2270 {
2271     if (s->version < TLS1_VERSION)
2272         return -1;
2273
2274     return s->method->ssl3_enc->export_keying_material(s, out, olen, label,
2275                                                        llen, p, plen,
2276                                                        use_context);
2277 }
2278
2279 static unsigned long ssl_session_hash(const SSL_SESSION *a)
2280 {
2281     unsigned long l;
2282
2283     l = (unsigned long)
2284         ((unsigned int)a->session_id[0]) |
2285         ((unsigned int)a->session_id[1] << 8L) |
2286         ((unsigned long)a->session_id[2] << 16L) |
2287         ((unsigned long)a->session_id[3] << 24L);
2288     return (l);
2289 }
2290
2291 /*
2292  * NB: If this function (or indeed the hash function which uses a sort of
2293  * coarser function than this one) is changed, ensure
2294  * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on
2295  * being able to construct an SSL_SESSION that will collide with any existing
2296  * session with a matching session ID.
2297  */
2298 static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b)
2299 {
2300     if (a->ssl_version != b->ssl_version)
2301         return (1);
2302     if (a->session_id_length != b->session_id_length)
2303         return (1);
2304     return (memcmp(a->session_id, b->session_id, a->session_id_length));
2305 }
2306
2307 /*
2308  * These wrapper functions should remain rather than redeclaring
2309  * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
2310  * variable. The reason is that the functions aren't static, they're exposed
2311  * via ssl.h.
2312  */
2313
2314 SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
2315 {
2316     SSL_CTX *ret = NULL;
2317
2318     if (meth == NULL) {
2319         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_NULL_SSL_METHOD_PASSED);
2320         return (NULL);
2321     }
2322
2323     if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
2324         return NULL;
2325
2326     if (FIPS_mode() && (meth->version < TLS1_VERSION)) {
2327         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE);
2328         return NULL;
2329     }
2330
2331     if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
2332         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
2333         goto err;
2334     }
2335     ret = OPENSSL_zalloc(sizeof(*ret));
2336     if (ret == NULL)
2337         goto err;
2338
2339     ret->method = meth;
2340     ret->min_proto_version = 0;
2341     ret->max_proto_version = 0;
2342     ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
2343     ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
2344     /* We take the system default. */
2345     ret->session_timeout = meth->get_timeout();
2346     ret->references = 1;
2347     ret->lock = CRYPTO_THREAD_lock_new();
2348     if (ret->lock == NULL) {
2349         SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2350         OPENSSL_free(ret);
2351         return NULL;
2352     }
2353     ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
2354     ret->verify_mode = SSL_VERIFY_NONE;
2355     if ((ret->cert = ssl_cert_new()) == NULL)
2356         goto err;
2357
2358     ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
2359     if (ret->sessions == NULL)
2360         goto err;
2361     ret->cert_store = X509_STORE_new();
2362     if (ret->cert_store == NULL)
2363         goto err;
2364 #ifndef OPENSSL_NO_CT
2365     ret->ctlog_store = CTLOG_STORE_new();
2366     if (ret->ctlog_store == NULL)
2367         goto err;
2368 #endif
2369     if (!ssl_create_cipher_list(ret->method,
2370                            &ret->cipher_list, &ret->cipher_list_by_id,
2371                            SSL_DEFAULT_CIPHER_LIST, ret->cert)
2372        || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
2373         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_LIBRARY_HAS_NO_CIPHERS);
2374         goto err2;
2375     }
2376
2377     ret->param = X509_VERIFY_PARAM_new();
2378     if (ret->param == NULL)
2379         goto err;
2380
2381     if ((ret->md5 = EVP_get_digestbyname("ssl3-md5")) == NULL) {
2382         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
2383         goto err2;
2384     }
2385     if ((ret->sha1 = EVP_get_digestbyname("ssl3-sha1")) == NULL) {
2386         SSLerr(SSL_F_SSL_CTX_NEW, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
2387         goto err2;
2388     }
2389
2390     if ((ret->client_CA = sk_X509_NAME_new_null()) == NULL)
2391         goto err;
2392
2393     if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data))
2394         goto err;
2395
2396     /* No compression for DTLS */
2397     if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
2398         ret->comp_methods = SSL_COMP_get_compression_methods();
2399
2400     ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
2401     ret->split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
2402
2403     /* Setup RFC5077 ticket keys */
2404     if ((RAND_bytes(ret->tlsext_tick_key_name, sizeof(ret->tlsext_tick_key_name)) <= 0)
2405         || (RAND_bytes(ret->tlsext_tick_hmac_key, sizeof(ret->tlsext_tick_hmac_key)) <= 0)
2406         || (RAND_bytes(ret->tlsext_tick_aes_key, sizeof(ret->tlsext_tick_aes_key)) <= 0))
2407         ret->options |= SSL_OP_NO_TICKET;
2408
2409 #ifndef OPENSSL_NO_SRP
2410     if (!SSL_CTX_SRP_CTX_init(ret))
2411         goto err;
2412 #endif
2413 #ifndef OPENSSL_NO_ENGINE
2414 # ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
2415 #  define eng_strx(x)     #x
2416 #  define eng_str(x)      eng_strx(x)
2417     /* Use specific client engine automatically... ignore errors */
2418     {
2419         ENGINE *eng;
2420         eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
2421         if (!eng) {
2422             ERR_clear_error();
2423             ENGINE_load_builtin_engines();
2424             eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
2425         }
2426         if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
2427             ERR_clear_error();
2428     }
2429 # endif
2430 #endif
2431     /*
2432      * Default is to connect to non-RI servers. When RI is more widely
2433      * deployed might change this.
2434      */
2435     ret->options |= SSL_OP_LEGACY_SERVER_CONNECT;
2436     /*
2437      * Disable compression by default to prevent CRIME. Applications can
2438      * re-enable compression by configuring
2439      * SSL_CTX_clear_options(ctx, SSL_OP_NO_COMPRESSION);
2440      * or by using the SSL_CONF library.
2441      */
2442     ret->options |= SSL_OP_NO_COMPRESSION;
2443
2444     ret->tlsext_status_type = -1;
2445
2446     return ret;
2447  err:
2448     SSLerr(SSL_F_SSL_CTX_NEW, ERR_R_MALLOC_FAILURE);
2449  err2:
2450     SSL_CTX_free(ret);
2451     return NULL;
2452 }
2453
2454 int SSL_CTX_up_ref(SSL_CTX *ctx)
2455 {
2456     int i;
2457
2458     if (CRYPTO_atomic_add(&ctx->references, 1, &i, ctx->lock) <= 0)
2459         return 0;
2460
2461     REF_PRINT_COUNT("SSL_CTX", ctx);
2462     REF_ASSERT_ISNT(i < 2);
2463     return ((i > 1) ? 1 : 0);
2464 }
2465
2466 void SSL_CTX_free(SSL_CTX *a)
2467 {
2468     int i;
2469
2470     if (a == NULL)
2471         return;
2472
2473     CRYPTO_atomic_add(&a->references, -1, &i, a->lock);
2474     REF_PRINT_COUNT("SSL_CTX", a);
2475     if (i > 0)
2476         return;
2477     REF_ASSERT_ISNT(i < 0);
2478
2479     X509_VERIFY_PARAM_free(a->param);
2480     dane_ctx_final(&a->dane);
2481
2482     /*
2483      * Free internal session cache. However: the remove_cb() may reference
2484      * the ex_data of SSL_CTX, thus the ex_data store can only be removed
2485      * after the sessions were flushed.
2486      * As the ex_data handling routines might also touch the session cache,
2487      * the most secure solution seems to be: empty (flush) the cache, then
2488      * free ex_data, then finally free the cache.
2489      * (See ticket [openssl.org #212].)
2490      */
2491     if (a->sessions != NULL)
2492         SSL_CTX_flush_sessions(a, 0);
2493
2494     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
2495     lh_SSL_SESSION_free(a->sessions);
2496     X509_STORE_free(a->cert_store);
2497 #ifndef OPENSSL_NO_CT
2498     CTLOG_STORE_free(a->ctlog_store);
2499 #endif
2500     sk_SSL_CIPHER_free(a->cipher_list);
2501     sk_SSL_CIPHER_free(a->cipher_list_by_id);
2502     ssl_cert_free(a->cert);
2503     sk_X509_NAME_pop_free(a->client_CA, X509_NAME_free);
2504     sk_X509_pop_free(a->extra_certs, X509_free);
2505     a->comp_methods = NULL;
2506 #ifndef OPENSSL_NO_SRTP
2507     sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles);
2508 #endif
2509 #ifndef OPENSSL_NO_SRP
2510     SSL_CTX_SRP_CTX_free(a);
2511 #endif
2512 #ifndef OPENSSL_NO_ENGINE
2513     ENGINE_finish(a->client_cert_engine);
2514 #endif
2515
2516 #ifndef OPENSSL_NO_EC
2517     OPENSSL_free(a->tlsext_ecpointformatlist);
2518     OPENSSL_free(a->tlsext_ellipticcurvelist);
2519 #endif
2520     OPENSSL_free(a->alpn_client_proto_list);
2521
2522     CRYPTO_THREAD_lock_free(a->lock);
2523
2524     OPENSSL_free(a);
2525 }
2526
2527 void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
2528 {
2529     ctx->default_passwd_callback = cb;
2530 }
2531
2532 void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
2533 {
2534     ctx->default_passwd_callback_userdata = u;
2535 }
2536
2537 pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)
2538 {
2539     return ctx->default_passwd_callback;
2540 }
2541
2542 void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx)
2543 {
2544     return ctx->default_passwd_callback_userdata;
2545 }
2546
2547 void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb)
2548 {
2549     s->default_passwd_callback = cb;
2550 }
2551
2552 void SSL_set_default_passwd_cb_userdata(SSL *s, void *u)
2553 {
2554     s->default_passwd_callback_userdata = u;
2555 }
2556
2557 pem_password_cb *SSL_get_default_passwd_cb(SSL *s)
2558 {
2559     return s->default_passwd_callback;
2560 }
2561
2562 void *SSL_get_default_passwd_cb_userdata(SSL *s)
2563 {
2564     return s->default_passwd_callback_userdata;
2565 }
2566
2567 void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
2568                                       int (*cb) (X509_STORE_CTX *, void *),
2569                                       void *arg)
2570 {
2571     ctx->app_verify_callback = cb;
2572     ctx->app_verify_arg = arg;
2573 }
2574
2575 void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
2576                         int (*cb) (int, X509_STORE_CTX *))
2577 {
2578     ctx->verify_mode = mode;
2579     ctx->default_verify_callback = cb;
2580 }
2581
2582 void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
2583 {
2584     X509_VERIFY_PARAM_set_depth(ctx->param, depth);
2585 }
2586
2587 void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg),
2588                          void *arg)
2589 {
2590     ssl_cert_set_cert_cb(c->cert, cb, arg);
2591 }
2592
2593 void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
2594 {
2595     ssl_cert_set_cert_cb(s->cert, cb, arg);
2596 }
2597
2598 void ssl_set_masks(SSL *s)
2599 {
2600 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_GOST)
2601     CERT_PKEY *cpk;
2602 #endif
2603     CERT *c = s->cert;
2604     uint32_t *pvalid = s->s3->tmp.valid_flags;
2605     int rsa_enc, rsa_sign, dh_tmp, dsa_sign;
2606     unsigned long mask_k, mask_a;
2607 #ifndef OPENSSL_NO_EC
2608     int have_ecc_cert, ecdsa_ok;
2609     X509 *x = NULL;
2610 #endif
2611     if (c == NULL)
2612         return;
2613
2614 #ifndef OPENSSL_NO_DH
2615     dh_tmp = (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto);
2616 #else
2617     dh_tmp = 0;
2618 #endif
2619
2620     rsa_enc = pvalid[SSL_PKEY_RSA_ENC] & CERT_PKEY_VALID;
2621     rsa_sign = pvalid[SSL_PKEY_RSA_SIGN] & CERT_PKEY_SIGN;
2622     dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_SIGN;
2623 #ifndef OPENSSL_NO_EC
2624     have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID;
2625 #endif
2626     mask_k = 0;
2627     mask_a = 0;
2628
2629 #ifdef CIPHER_DEBUG
2630     fprintf(stderr, "dht=%d re=%d rs=%d ds=%d\n",
2631             dh_tmp, rsa_enc, rsa_sign, dsa_sign);
2632 #endif
2633
2634 #ifndef OPENSSL_NO_GOST
2635     cpk = &(c->pkeys[SSL_PKEY_GOST12_512]);
2636     if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2637         mask_k |= SSL_kGOST;
2638         mask_a |= SSL_aGOST12;
2639     }
2640     cpk = &(c->pkeys[SSL_PKEY_GOST12_256]);
2641     if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2642         mask_k |= SSL_kGOST;
2643         mask_a |= SSL_aGOST12;
2644     }
2645     cpk = &(c->pkeys[SSL_PKEY_GOST01]);
2646     if (cpk->x509 != NULL && cpk->privatekey != NULL) {
2647         mask_k |= SSL_kGOST;
2648         mask_a |= SSL_aGOST01;
2649     }
2650 #endif
2651
2652     if (rsa_enc)
2653         mask_k |= SSL_kRSA;
2654
2655     if (dh_tmp)
2656         mask_k |= SSL_kDHE;
2657
2658     if (rsa_enc || rsa_sign) {
2659         mask_a |= SSL_aRSA;
2660     }
2661
2662     if (dsa_sign) {
2663         mask_a |= SSL_aDSS;
2664     }
2665
2666     mask_a |= SSL_aNULL;
2667
2668     /*
2669      * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites
2670      * depending on the key usage extension.
2671      */
2672 #ifndef OPENSSL_NO_EC
2673     if (have_ecc_cert) {
2674         uint32_t ex_kusage;
2675         cpk = &c->pkeys[SSL_PKEY_ECC];
2676         x = cpk->x509;
2677         ex_kusage = X509_get_key_usage(x);
2678         ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE;
2679         if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN))
2680             ecdsa_ok = 0;
2681         if (ecdsa_ok)
2682             mask_a |= SSL_aECDSA;
2683     }
2684 #endif
2685
2686 #ifndef OPENSSL_NO_EC
2687     mask_k |= SSL_kECDHE;
2688 #endif
2689
2690 #ifndef OPENSSL_NO_PSK
2691     mask_k |= SSL_kPSK;
2692     mask_a |= SSL_aPSK;
2693     if (mask_k & SSL_kRSA)
2694         mask_k |= SSL_kRSAPSK;
2695     if (mask_k & SSL_kDHE)
2696         mask_k |= SSL_kDHEPSK;
2697     if (mask_k & SSL_kECDHE)
2698         mask_k |= SSL_kECDHEPSK;
2699 #endif
2700
2701     s->s3->tmp.mask_k = mask_k;
2702     s->s3->tmp.mask_a = mask_a;
2703 }
2704
2705 #ifndef OPENSSL_NO_EC
2706
2707 int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL *s)
2708 {
2709     if (s->s3->tmp.new_cipher->algorithm_auth & SSL_aECDSA) {
2710         /* key usage, if present, must allow signing */
2711         if (!(X509_get_key_usage(x) & X509v3_KU_DIGITAL_SIGNATURE)) {
2712             SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG,
2713                    SSL_R_ECC_CERT_NOT_FOR_SIGNING);
2714             return 0;
2715         }
2716     }
2717     return 1;                   /* all checks are ok */
2718 }
2719
2720 #endif
2721
2722 static int ssl_get_server_cert_index(const SSL *s)
2723 {
2724     int idx;
2725     idx = ssl_cipher_get_cert_index(s->s3->tmp.new_cipher);
2726     if (idx == SSL_PKEY_RSA_ENC && !s->cert->pkeys[SSL_PKEY_RSA_ENC].x509)
2727         idx = SSL_PKEY_RSA_SIGN;
2728     if (idx == SSL_PKEY_GOST_EC) {
2729         if (s->cert->pkeys[SSL_PKEY_GOST12_512].x509)
2730             idx = SSL_PKEY_GOST12_512;
2731         else if (s->cert->pkeys[SSL_PKEY_GOST12_256].x509)
2732             idx = SSL_PKEY_GOST12_256;
2733         else if (s->cert->pkeys[SSL_PKEY_GOST01].x509)
2734             idx = SSL_PKEY_GOST01;
2735         else
2736             idx = -1;
2737     }
2738     if (idx == -1)
2739         SSLerr(SSL_F_SSL_GET_SERVER_CERT_INDEX, ERR_R_INTERNAL_ERROR);
2740     return idx;
2741 }
2742
2743 CERT_PKEY *ssl_get_server_send_pkey(SSL *s)
2744 {
2745     CERT *c;
2746     int i;
2747
2748     c = s->cert;
2749     if (!s->s3 || !s->s3->tmp.new_cipher)
2750         return NULL;
2751     ssl_set_masks(s);
2752
2753     i = ssl_get_server_cert_index(s);
2754
2755     /* This may or may not be an error. */
2756     if (i < 0)
2757         return NULL;
2758
2759     /* May be NULL. */
2760     return &c->pkeys[i];
2761 }
2762
2763 EVP_PKEY *ssl_get_sign_pkey(SSL *s, const SSL_CIPHER *cipher,
2764                             const EVP_MD **pmd)
2765 {
2766     unsigned long alg_a;
2767     CERT *c;
2768     int idx = -1;
2769
2770     alg_a = cipher->algorithm_auth;
2771     c = s->cert;
2772
2773     if ((alg_a & SSL_aDSS) &&
2774             (c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
2775         idx = SSL_PKEY_DSA_SIGN;
2776     else if (alg_a & SSL_aRSA) {
2777         if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
2778             idx = SSL_PKEY_RSA_SIGN;
2779         else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
2780             idx = SSL_PKEY_RSA_ENC;
2781     } else if ((alg_a & SSL_aECDSA) &&
2782                (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
2783         idx = SSL_PKEY_ECC;
2784     if (idx == -1) {
2785         SSLerr(SSL_F_SSL_GET_SIGN_PKEY, ERR_R_INTERNAL_ERROR);
2786         return (NULL);
2787     }
2788     if (pmd)
2789         *pmd = s->s3->tmp.md[idx];
2790     return c->pkeys[idx].privatekey;
2791 }
2792
2793 int ssl_get_server_cert_serverinfo(SSL *s, const unsigned char **serverinfo,
2794                                    size_t *serverinfo_length)
2795 {
2796     CERT *c = NULL;
2797     int i = 0;
2798     *serverinfo_length = 0;
2799
2800     c = s->cert;
2801     i = ssl_get_server_cert_index(s);
2802
2803     if (i == -1)
2804         return 0;
2805     if (c->pkeys[i].serverinfo == NULL)
2806         return 0;
2807
2808     *serverinfo = c->pkeys[i].serverinfo;
2809     *serverinfo_length = c->pkeys[i].serverinfo_length;
2810     return 1;
2811 }
2812
2813 void ssl_update_cache(SSL *s, int mode)
2814 {
2815     int i;
2816
2817     /*
2818      * If the session_id_length is 0, we are not supposed to cache it, and it
2819      * would be rather hard to do anyway :-)
2820      */
2821     if (s->session->session_id_length == 0)
2822         return;
2823
2824     i = s->session_ctx->session_cache_mode;
2825     if ((i & mode) && (!s->hit)
2826         && ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
2827             || SSL_CTX_add_session(s->session_ctx, s->session))
2828         && (s->session_ctx->new_session_cb != NULL)) {
2829         SSL_SESSION_up_ref(s->session);
2830         if (!s->session_ctx->new_session_cb(s, s->session))
2831             SSL_SESSION_free(s->session);
2832     }
2833
2834     /* auto flush every 255 connections */
2835     if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) {
2836         if ((((mode & SSL_SESS_CACHE_CLIENT)
2837               ? s->session_ctx->stats.sess_connect_good
2838               : s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff) {
2839             SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL));
2840         }
2841     }
2842 }
2843
2844 const SSL_METHOD *SSL_CTX_get_ssl_method(SSL_CTX *ctx)
2845 {
2846     return ctx->method;
2847 }
2848
2849 const SSL_METHOD *SSL_get_ssl_method(SSL *s)
2850 {
2851     return (s->method);
2852 }
2853
2854 int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
2855 {
2856     int ret = 1;
2857
2858     if (s->method != meth) {
2859         const SSL_METHOD *sm = s->method;
2860         int (*hf)(SSL *) = s->handshake_func;
2861
2862         if (sm->version == meth->version)
2863             s->method = meth;
2864         else {
2865             sm->ssl_free(s);
2866             s->method = meth;
2867             ret = s->method->ssl_new(s);
2868         }
2869
2870         if (hf == sm->ssl_connect)
2871             s->handshake_func = meth->ssl_connect;
2872         else if (hf == sm->ssl_accept)
2873             s->handshake_func = meth->ssl_accept;
2874     }
2875     return (ret);
2876 }
2877
2878 int SSL_get_error(const SSL *s, int i)
2879 {
2880     int reason;
2881     unsigned long l;
2882     BIO *bio;
2883
2884     if (i > 0)
2885         return (SSL_ERROR_NONE);
2886
2887     /*
2888      * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
2889      * where we do encode the error
2890      */
2891     if ((l = ERR_peek_error()) != 0) {
2892         if (ERR_GET_LIB(l) == ERR_LIB_SYS)
2893             return (SSL_ERROR_SYSCALL);
2894         else
2895             return (SSL_ERROR_SSL);
2896     }
2897
2898     if (i < 0) {
2899         if (SSL_want_read(s)) {
2900             bio = SSL_get_rbio(s);
2901             if (BIO_should_read(bio))
2902                 return (SSL_ERROR_WANT_READ);
2903             else if (BIO_should_write(bio))
2904                 /*
2905                  * This one doesn't make too much sense ... We never try to write
2906                  * to the rbio, and an application program where rbio and wbio
2907                  * are separate couldn't even know what it should wait for.
2908                  * However if we ever set s->rwstate incorrectly (so that we have
2909                  * SSL_want_read(s) instead of SSL_want_write(s)) and rbio and
2910                  * wbio *are* the same, this test works around that bug; so it
2911                  * might be safer to keep it.
2912                  */
2913                 return (SSL_ERROR_WANT_WRITE);
2914             else if (BIO_should_io_special(bio)) {
2915                 reason = BIO_get_retry_reason(bio);
2916                 if (reason == BIO_RR_CONNECT)
2917                     return (SSL_ERROR_WANT_CONNECT);
2918                 else if (reason == BIO_RR_ACCEPT)
2919                     return (SSL_ERROR_WANT_ACCEPT);
2920                 else
2921                     return (SSL_ERROR_SYSCALL); /* unknown */
2922             }
2923         }
2924
2925         if (SSL_want_write(s)) {
2926             bio = SSL_get_wbio(s);
2927             if (BIO_should_write(bio))
2928                 return (SSL_ERROR_WANT_WRITE);
2929             else if (BIO_should_read(bio))
2930                 /*
2931                  * See above (SSL_want_read(s) with BIO_should_write(bio))
2932                  */
2933                 return (SSL_ERROR_WANT_READ);
2934             else if (BIO_should_io_special(bio)) {
2935                 reason = BIO_get_retry_reason(bio);
2936                 if (reason == BIO_RR_CONNECT)
2937                     return (SSL_ERROR_WANT_CONNECT);
2938                 else if (reason == BIO_RR_ACCEPT)
2939                     return (SSL_ERROR_WANT_ACCEPT);
2940                 else
2941                     return (SSL_ERROR_SYSCALL);
2942             }
2943         }
2944         if (SSL_want_x509_lookup(s)) {
2945             return (SSL_ERROR_WANT_X509_LOOKUP);
2946         }
2947         if (SSL_want_async(s)) {
2948             return SSL_ERROR_WANT_ASYNC;
2949         }
2950         if (SSL_want_async_job(s)) {
2951             return SSL_ERROR_WANT_ASYNC_JOB;
2952         }
2953     }
2954
2955     if (i == 0) {
2956         if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2957             (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
2958             return (SSL_ERROR_ZERO_RETURN);
2959     }
2960     return (SSL_ERROR_SYSCALL);
2961 }
2962
2963 static int ssl_do_handshake_intern(void *vargs)
2964 {
2965     struct ssl_async_args *args;
2966     SSL *s;
2967
2968     args = (struct ssl_async_args *)vargs;
2969     s = args->s;
2970
2971     return s->handshake_func(s);
2972 }
2973
2974 int SSL_do_handshake(SSL *s)
2975 {
2976     int ret = 1;
2977
2978     if (s->handshake_func == NULL) {
2979         SSLerr(SSL_F_SSL_DO_HANDSHAKE, SSL_R_CONNECTION_TYPE_NOT_SET);
2980         return -1;
2981     }
2982
2983     s->method->ssl_renegotiate_check(s);
2984
2985     if (SSL_in_init(s) || SSL_in_before(s)) {
2986         if((s->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
2987             struct ssl_async_args args;
2988
2989             args.s = s;
2990
2991             ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern);
2992         } else {
2993             ret = s->handshake_func(s);
2994         }
2995     }
2996     return ret;
2997 }
2998
2999 void SSL_set_accept_state(SSL *s)
3000 {
3001     s->server = 1;
3002     s->shutdown = 0;
3003     ossl_statem_clear(s);
3004     s->handshake_func = s->method->ssl_accept;
3005     clear_ciphers(s);
3006 }
3007
3008 void SSL_set_connect_state(SSL *s)
3009 {
3010     s->server = 0;
3011     s->shutdown = 0;
3012     ossl_statem_clear(s);
3013     s->handshake_func = s->method->ssl_connect;
3014     clear_ciphers(s);
3015 }
3016
3017 int ssl_undefined_function(SSL *s)
3018 {
3019     SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3020     return (0);
3021 }
3022
3023 int ssl_undefined_void_function(void)
3024 {
3025     SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,
3026            ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3027     return (0);
3028 }
3029
3030 int ssl_undefined_const_function(const SSL *s)
3031 {
3032     return (0);
3033 }
3034
3035 const SSL_METHOD *ssl_bad_method(int ver)
3036 {
3037     SSLerr(SSL_F_SSL_BAD_METHOD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
3038     return (NULL);
3039 }
3040
3041 const char *ssl_protocol_to_string(int version)
3042 {
3043     if (version == TLS1_2_VERSION)
3044         return "TLSv1.2";
3045     else if (version == TLS1_1_VERSION)
3046         return "TLSv1.1";
3047     else if (version == TLS1_VERSION)
3048         return "TLSv1";
3049     else if (version == SSL3_VERSION)
3050         return "SSLv3";
3051     else if (version == DTLS1_BAD_VER)
3052         return "DTLSv0.9";
3053     else if (version == DTLS1_VERSION)
3054         return "DTLSv1";
3055     else if (version == DTLS1_2_VERSION)
3056         return "DTLSv1.2";
3057     else
3058         return ("unknown");
3059 }
3060
3061 const char *SSL_get_version(const SSL *s)
3062 {
3063     return ssl_protocol_to_string(s->version);
3064 }
3065
3066 SSL *SSL_dup(SSL *s)
3067 {
3068     STACK_OF(X509_NAME) *sk;
3069     X509_NAME *xn;
3070     SSL *ret;
3071     int i;
3072
3073     /* If we're not quiescent, just up_ref! */
3074     if (!SSL_in_init(s) || !SSL_in_before(s)) {
3075         CRYPTO_atomic_add(&s->references, 1, &i, s->lock);
3076         return s;
3077     }
3078
3079     /*
3080      * Otherwise, copy configuration state, and session if set.
3081      */
3082     if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
3083         return (NULL);
3084
3085     if (s->session != NULL) {
3086         /*
3087          * Arranges to share the same session via up_ref.  This "copies"
3088          * session-id, SSL_METHOD, sid_ctx, and 'cert'
3089          */
3090         if (!SSL_copy_session_id(ret, s))
3091             goto err;
3092     } else {
3093         /*
3094          * No session has been established yet, so we have to expect that
3095          * s->cert or ret->cert will be changed later -- they should not both
3096          * point to the same object, and thus we can't use
3097          * SSL_copy_session_id.
3098          */
3099         if (!SSL_set_ssl_method(ret, s->method))
3100             goto err;
3101
3102         if (s->cert != NULL) {
3103             ssl_cert_free(ret->cert);
3104             ret->cert = ssl_cert_dup(s->cert);
3105             if (ret->cert == NULL)
3106                 goto err;
3107         }
3108
3109         if (!SSL_set_session_id_context(ret, s->sid_ctx, s->sid_ctx_length))
3110             goto err;
3111     }
3112
3113     if (!ssl_dane_dup(ret, s))
3114         goto err;
3115     ret->version = s->version;
3116     ret->options = s->options;
3117     ret->mode = s->mode;
3118     SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
3119     SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
3120     ret->msg_callback = s->msg_callback;
3121     ret->msg_callback_arg = s->msg_callback_arg;
3122     SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
3123     SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
3124     ret->generate_session_id = s->generate_session_id;
3125
3126     SSL_set_info_callback(ret, SSL_get_info_callback(s));
3127
3128     /* copy app data, a little dangerous perhaps */
3129     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
3130         goto err;
3131
3132     /* setup rbio, and wbio */
3133     if (s->rbio != NULL) {
3134         if (!BIO_dup_state(s->rbio, (char *)&ret->rbio))
3135             goto err;
3136     }
3137     if (s->wbio != NULL) {
3138         if (s->wbio != s->rbio) {
3139             if (!BIO_dup_state(s->wbio, (char *)&ret->wbio))
3140                 goto err;
3141         } else
3142             ret->wbio = ret->rbio;
3143     }
3144
3145     ret->server = s->server;
3146     if (s->handshake_func) {
3147         if (s->server)
3148             SSL_set_accept_state(ret);
3149         else
3150             SSL_set_connect_state(ret);
3151     }
3152     ret->shutdown = s->shutdown;
3153     ret->hit = s->hit;
3154
3155     ret->default_passwd_callback = s->default_passwd_callback;
3156     ret->default_passwd_callback_userdata = s->default_passwd_callback_userdata;
3157
3158     X509_VERIFY_PARAM_inherit(ret->param, s->param);
3159
3160     /* dup the cipher_list and cipher_list_by_id stacks */
3161     if (s->cipher_list != NULL) {
3162         if ((ret->cipher_list = sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
3163             goto err;
3164     }
3165     if (s->cipher_list_by_id != NULL)
3166         if ((ret->cipher_list_by_id = sk_SSL_CIPHER_dup(s->cipher_list_by_id))
3167             == NULL)
3168             goto err;
3169
3170     /* Dup the client_CA list */
3171     if (s->client_CA != NULL) {
3172         if ((sk = sk_X509_NAME_dup(s->client_CA)) == NULL)
3173             goto err;
3174         ret->client_CA = sk;
3175         for (i = 0; i < sk_X509_NAME_num(sk); i++) {
3176             xn = sk_X509_NAME_value(sk, i);
3177             if (sk_X509_NAME_set(sk, i, X509_NAME_dup(xn)) == NULL) {
3178                 X509_NAME_free(xn);
3179                 goto err;
3180             }
3181         }
3182     }
3183     return ret;
3184
3185  err:
3186     SSL_free(ret);
3187     return NULL;
3188 }
3189
3190 void ssl_clear_cipher_ctx(SSL *s)
3191 {
3192     if (s->enc_read_ctx != NULL) {
3193         EVP_CIPHER_CTX_free(s->enc_read_ctx);
3194         s->enc_read_ctx = NULL;
3195     }
3196     if (s->enc_write_ctx != NULL) {
3197         EVP_CIPHER_CTX_free(s->enc_write_ctx);
3198         s->enc_write_ctx = NULL;
3199     }
3200 #ifndef OPENSSL_NO_COMP
3201     COMP_CTX_free(s->expand);
3202     s->expand = NULL;
3203     COMP_CTX_free(s->compress);
3204     s->compress = NULL;
3205 #endif
3206 }
3207
3208 X509 *SSL_get_certificate(const SSL *s)
3209 {
3210     if (s->cert != NULL)
3211         return (s->cert->key->x509);
3212     else
3213         return (NULL);
3214 }
3215
3216 EVP_PKEY *SSL_get_privatekey(const SSL *s)
3217 {
3218     if (s->cert != NULL)
3219         return (s->cert->key->privatekey);
3220     else
3221         return (NULL);
3222 }
3223
3224 X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
3225 {
3226     if (ctx->cert != NULL)
3227         return ctx->cert->key->x509;
3228     else
3229         return NULL;
3230 }
3231
3232 EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
3233 {
3234     if (ctx->cert != NULL)
3235         return ctx->cert->key->privatekey;
3236     else
3237         return NULL;
3238 }
3239
3240 const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
3241 {
3242     if ((s->session != NULL) && (s->session->cipher != NULL))
3243         return (s->session->cipher);
3244     return (NULL);
3245 }
3246
3247 const COMP_METHOD *SSL_get_current_compression(SSL *s)
3248 {
3249 #ifndef OPENSSL_NO_COMP
3250     return s->compress ? COMP_CTX_get_method(s->compress) : NULL;
3251 #else
3252     return NULL;
3253 #endif
3254 }
3255
3256 const COMP_METHOD *SSL_get_current_expansion(SSL *s)
3257 {
3258 #ifndef OPENSSL_NO_COMP
3259     return s->expand ? COMP_CTX_get_method(s->expand) : NULL;
3260 #else
3261     return NULL;
3262 #endif
3263 }
3264
3265 int ssl_init_wbio_buffer(SSL *s)
3266 {
3267     BIO *bbio;
3268
3269     if (s->bbio == NULL) {
3270         bbio = BIO_new(BIO_f_buffer());
3271         if (bbio == NULL)
3272             return 0;
3273         s->bbio = bbio;
3274         s->wbio = BIO_push(bbio, s->wbio);
3275     } else {
3276         bbio = s->bbio;
3277         (void)BIO_reset(bbio);
3278     }
3279
3280     if (!BIO_set_read_buffer_size(bbio, 1)) {
3281         SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER, ERR_R_BUF_LIB);
3282         return 0;
3283     }
3284
3285     return 1;
3286 }
3287
3288 void ssl_free_wbio_buffer(SSL *s)
3289 {
3290     /* callers ensure s is never null */
3291     if (s->bbio == NULL)
3292         return;
3293
3294     if (s->bbio == s->wbio) {
3295         /* remove buffering */
3296         s->wbio = BIO_pop(s->wbio);
3297         assert(s->wbio != NULL);
3298     }
3299     BIO_free(s->bbio);
3300     s->bbio = NULL;
3301 }
3302
3303 void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
3304 {
3305     ctx->quiet_shutdown = mode;
3306 }
3307
3308 int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
3309 {
3310     return (ctx->quiet_shutdown);
3311 }
3312
3313 void SSL_set_quiet_shutdown(SSL *s, int mode)
3314 {
3315     s->quiet_shutdown = mode;
3316 }
3317
3318 int SSL_get_quiet_shutdown(const SSL *s)
3319 {
3320     return (s->quiet_shutdown);
3321 }
3322
3323 void SSL_set_shutdown(SSL *s, int mode)
3324 {
3325     s->shutdown = mode;
3326 }
3327
3328 int SSL_get_shutdown(const SSL *s)
3329 {
3330     return s->shutdown;
3331 }
3332
3333 int SSL_version(const SSL *s)
3334 {
3335     return s->version;
3336 }
3337
3338 int SSL_client_version(const SSL *s)
3339 {
3340     return s->client_version;
3341 }
3342
3343 SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
3344 {
3345     return ssl->ctx;
3346 }
3347
3348 SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
3349 {
3350     CERT *new_cert;
3351     if (ssl->ctx == ctx)
3352         return ssl->ctx;
3353     if (ctx == NULL)
3354         ctx = ssl->initial_ctx;
3355     new_cert = ssl_cert_dup(ctx->cert);
3356     if (new_cert == NULL) {
3357         return NULL;
3358     }
3359     ssl_cert_free(ssl->cert);
3360     ssl->cert = new_cert;
3361
3362     /*
3363      * Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
3364      * so setter APIs must prevent invalid lengths from entering the system.
3365      */
3366     OPENSSL_assert(ssl->sid_ctx_length <= sizeof(ssl->sid_ctx));
3367
3368     /*
3369      * If the session ID context matches that of the parent SSL_CTX,
3370      * inherit it from the new SSL_CTX as well. If however the context does
3371      * not match (i.e., it was set per-ssl with SSL_set_session_id_context),
3372      * leave it unchanged.
3373      */
3374     if ((ssl->ctx != NULL) &&
3375         (ssl->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
3376         (memcmp(ssl->sid_ctx, ssl->ctx->sid_ctx, ssl->sid_ctx_length) == 0)) {
3377         ssl->sid_ctx_length = ctx->sid_ctx_length;
3378         memcpy(&ssl->sid_ctx, &ctx->sid_ctx, sizeof(ssl->sid_ctx));
3379     }
3380
3381     SSL_CTX_up_ref(ctx);
3382     SSL_CTX_free(ssl->ctx); /* decrement reference count */
3383     ssl->ctx = ctx;
3384
3385     return ssl->ctx;
3386 }
3387
3388 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
3389 {
3390     return (X509_STORE_set_default_paths(ctx->cert_store));
3391 }
3392
3393 int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx)
3394 {
3395     X509_LOOKUP *lookup;
3396
3397     lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_hash_dir());
3398     if (lookup == NULL)
3399         return 0;
3400     X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
3401
3402     /* Clear any errors if the default directory does not exist */
3403     ERR_clear_error();
3404
3405     return 1;
3406 }
3407
3408 int SSL_CTX_set_default_verify_file(SSL_CTX *ctx)
3409 {
3410     X509_LOOKUP *lookup;
3411
3412     lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_file());
3413     if (lookup == NULL)
3414         return 0;
3415
3416     X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
3417
3418     /* Clear any errors if the default file does not exist */
3419     ERR_clear_error();
3420
3421     return 1;
3422 }
3423
3424 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
3425                                   const char *CApath)
3426 {
3427     return (X509_STORE_load_locations(ctx->cert_store, CAfile, CApath));
3428 }
3429
3430 void SSL_set_info_callback(SSL *ssl,
3431                            void (*cb) (const SSL *ssl, int type, int val))
3432 {
3433     ssl->info_callback = cb;
3434 }
3435
3436 /*
3437  * One compiler (Diab DCC) doesn't like argument names in returned function
3438  * pointer.
3439  */
3440 void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
3441                                                int /* type */ ,
3442                                                int /* val */ ) {
3443     return ssl->info_callback;
3444 }
3445
3446 void SSL_set_verify_result(SSL *ssl, long arg)
3447 {
3448     ssl->verify_result = arg;
3449 }
3450
3451 long SSL_get_verify_result(const SSL *ssl)
3452 {
3453     return (ssl->verify_result);
3454 }
3455
3456 size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
3457 {
3458     if (outlen == 0)
3459         return sizeof(ssl->s3->client_random);
3460     if (outlen > sizeof(ssl->s3->client_random))
3461         outlen = sizeof(ssl->s3->client_random);
3462     memcpy(out, ssl->s3->client_random, outlen);
3463     return outlen;
3464 }
3465
3466 size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
3467 {
3468     if (outlen == 0)
3469         return sizeof(ssl->s3->server_random);
3470     if (outlen > sizeof(ssl->s3->server_random))
3471         outlen = sizeof(ssl->s3->server_random);
3472     memcpy(out, ssl->s3->server_random, outlen);
3473     return outlen;
3474 }
3475
3476 size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
3477                                unsigned char *out, size_t outlen)
3478 {
3479     if (session->master_key_length < 0) {
3480         /* Should never happen */
3481         return 0;
3482     }
3483     if (outlen == 0)
3484         return session->master_key_length;
3485     if (outlen > (size_t)session->master_key_length)
3486         outlen = session->master_key_length;
3487     memcpy(out, session->master_key, outlen);
3488     return outlen;
3489 }
3490
3491 int SSL_set_ex_data(SSL *s, int idx, void *arg)
3492 {
3493     return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
3494 }
3495
3496 void *SSL_get_ex_data(const SSL *s, int idx)
3497 {
3498     return (CRYPTO_get_ex_data(&s->ex_data, idx));
3499 }
3500
3501 int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
3502 {
3503     return (CRYPTO_set_ex_data(&s->ex_data, idx, arg));
3504 }
3505
3506 void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
3507 {
3508     return (CRYPTO_get_ex_data(&s->ex_data, idx));
3509 }
3510
3511 int ssl_ok(SSL *s)
3512 {
3513     return (1);
3514 }
3515
3516 X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
3517 {
3518     return (ctx->cert_store);
3519 }
3520
3521 void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
3522 {
3523     X509_STORE_free(ctx->cert_store);
3524     ctx->cert_store = store;
3525 }
3526
3527 int SSL_want(const SSL *s)
3528 {
3529     return (s->rwstate);
3530 }
3531
3532 /**
3533  * \brief Set the callback for generating temporary DH keys.
3534  * \param ctx the SSL context.
3535  * \param dh the callback
3536  */
3537
3538 #ifndef OPENSSL_NO_DH
3539 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
3540                                  DH *(*dh) (SSL *ssl, int is_export,
3541                                             int keylength))
3542 {
3543     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
3544 }
3545
3546 void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export,
3547                                                   int keylength))
3548 {
3549     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
3550 }
3551 #endif
3552
3553 #ifndef OPENSSL_NO_PSK
3554 int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
3555 {
3556     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3557         SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT,
3558                SSL_R_DATA_LENGTH_TOO_LONG);
3559         return 0;
3560     }
3561     OPENSSL_free(ctx->cert->psk_identity_hint);
3562     if (identity_hint != NULL) {
3563         ctx->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
3564         if (ctx->cert->psk_identity_hint == NULL)
3565             return 0;
3566     } else
3567         ctx->cert->psk_identity_hint = NULL;
3568     return 1;
3569 }
3570
3571 int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
3572 {
3573     if (s == NULL)
3574         return 0;
3575
3576     if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
3577         SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
3578         return 0;
3579     }
3580     OPENSSL_free(s->cert->psk_identity_hint);
3581     if (identity_hint != NULL) {
3582         s->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
3583         if (s->cert->psk_identity_hint == NULL)
3584             return 0;
3585     } else
3586         s->cert->psk_identity_hint = NULL;
3587     return 1;
3588 }
3589
3590 const char *SSL_get_psk_identity_hint(const SSL *s)
3591 {
3592     if (s == NULL || s->session == NULL)
3593         return NULL;
3594     return (s->session->psk_identity_hint);
3595 }
3596
3597 const char *SSL_get_psk_identity(const SSL *s)
3598 {
3599     if (s == NULL || s->session == NULL)
3600         return NULL;
3601     return (s->session->psk_identity);
3602 }
3603
3604 void SSL_set_psk_client_callback(SSL *s,
3605                                  unsigned int (*cb) (SSL *ssl,
3606                                                      const char *hint,
3607                                                      char *identity,
3608                                                      unsigned int
3609                                                      max_identity_len,
3610                                                      unsigned char *psk,
3611                                                      unsigned int
3612                                                      max_psk_len))
3613 {
3614     s->psk_client_callback = cb;
3615 }
3616
3617 void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
3618                                      unsigned int (*cb) (SSL *ssl,
3619                                                          const char *hint,
3620                                                          char *identity,
3621                                                          unsigned int
3622                                                          max_identity_len,
3623                                                          unsigned char *psk,
3624                                                          unsigned int
3625                                                          max_psk_len))
3626 {
3627     ctx->psk_client_callback = cb;
3628 }
3629
3630 void SSL_set_psk_server_callback(SSL *s,
3631                                  unsigned int (*cb) (SSL *ssl,
3632                                                      const char *identity,
3633                                                      unsigned char *psk,
3634                                                      unsigned int
3635                                                      max_psk_len))
3636 {
3637     s->psk_server_callback = cb;
3638 }
3639
3640 void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
3641                                      unsigned int (*cb) (SSL *ssl,
3642                                                          const char *identity,
3643                                                          unsigned char *psk,
3644                                                          unsigned int
3645                                                          max_psk_len))
3646 {
3647     ctx->psk_server_callback = cb;
3648 }
3649 #endif
3650
3651 void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
3652                               void (*cb) (int write_p, int version,
3653                                           int content_type, const void *buf,
3654                                           size_t len, SSL *ssl, void *arg))
3655 {
3656     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3657 }
3658
3659 void SSL_set_msg_callback(SSL *ssl,
3660                           void (*cb) (int write_p, int version,
3661                                       int content_type, const void *buf,
3662                                       size_t len, SSL *ssl, void *arg))
3663 {
3664     SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3665 }
3666
3667 void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
3668                                                 int (*cb) (SSL *ssl,
3669                                                            int
3670                                                            is_forward_secure))
3671 {
3672     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3673                           (void (*)(void))cb);
3674 }
3675
3676 void SSL_set_not_resumable_session_callback(SSL *ssl,
3677                                             int (*cb) (SSL *ssl,
3678                                                        int is_forward_secure))
3679 {
3680     SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
3681                       (void (*)(void))cb);
3682 }
3683
3684 /*
3685  * Allocates new EVP_MD_CTX and sets pointer to it into given pointer
3686  * variable, freeing EVP_MD_CTX previously stored in that variable, if any.
3687  * If EVP_MD pointer is passed, initializes ctx with this md Returns newly
3688  * allocated ctx;
3689  */
3690
3691 EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash, const EVP_MD *md)
3692 {
3693     ssl_clear_hash_ctx(hash);
3694     *hash = EVP_MD_CTX_new();
3695     if (*hash == NULL || (md && EVP_DigestInit_ex(*hash, md, NULL) <= 0)) {
3696         EVP_MD_CTX_free(*hash);
3697         *hash = NULL;
3698         return NULL;
3699     }
3700     return *hash;
3701 }
3702
3703 void ssl_clear_hash_ctx(EVP_MD_CTX **hash)
3704 {
3705
3706     if (*hash)
3707         EVP_MD_CTX_free(*hash);
3708     *hash = NULL;
3709 }
3710
3711 /* Retrieve handshake hashes */
3712 int ssl_handshake_hash(SSL *s, unsigned char *out, int outlen)
3713 {
3714     EVP_MD_CTX *ctx = NULL;
3715     EVP_MD_CTX *hdgst = s->s3->handshake_dgst;
3716     int ret = EVP_MD_CTX_size(hdgst);
3717     if (ret < 0 || ret > outlen) {
3718         ret = 0;
3719         goto err;
3720     }
3721     ctx = EVP_MD_CTX_new();
3722     if (ctx == NULL) {
3723         ret = 0;
3724         goto err;
3725     }
3726     if (!EVP_MD_CTX_copy_ex(ctx, hdgst)
3727         || EVP_DigestFinal_ex(ctx, out, NULL) <= 0)
3728         ret = 0;
3729  err:
3730     EVP_MD_CTX_free(ctx);
3731     return ret;
3732 }
3733
3734 int SSL_session_reused(SSL *s)
3735 {
3736     return s->hit;
3737 }
3738
3739 int SSL_is_server(SSL *s)
3740 {
3741     return s->server;
3742 }
3743
3744 #if OPENSSL_API_COMPAT < 0x10100000L
3745 void SSL_set_debug(SSL *s, int debug)
3746 {
3747     /* Old function was do-nothing anyway... */
3748     (void)s;
3749     (void)debug;
3750 }
3751 #endif
3752
3753
3754 void SSL_set_security_level(SSL *s, int level)
3755 {
3756     s->cert->sec_level = level;
3757 }
3758
3759 int SSL_get_security_level(const SSL *s)
3760 {
3761     return s->cert->sec_level;
3762 }
3763
3764 void SSL_set_security_callback(SSL *s,
3765                                int (*cb) (const SSL *s, const SSL_CTX *ctx, int op,
3766                                           int bits, int nid, void *other,
3767                                           void *ex))
3768 {
3769     s->cert->sec_cb = cb;
3770 }
3771
3772 int (*SSL_get_security_callback(const SSL *s)) (const SSL *s, const SSL_CTX *ctx, int op,
3773                                                 int bits, int nid,
3774                                                 void *other, void *ex) {
3775     return s->cert->sec_cb;
3776 }
3777
3778 void SSL_set0_security_ex_data(SSL *s, void *ex)
3779 {
3780     s->cert->sec_ex = ex;
3781 }
3782
3783 void *SSL_get0_security_ex_data(const SSL *s)
3784 {
3785     return s->cert->sec_ex;
3786 }
3787
3788 void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
3789 {
3790     ctx->cert->sec_level = level;
3791 }
3792
3793 int SSL_CTX_get_security_level(const SSL_CTX *ctx)
3794 {
3795     return ctx->cert->sec_level;
3796 }
3797
3798 void SSL_CTX_set_security_callback(SSL_CTX *ctx,
3799                                    int (*cb) (const SSL *s, const SSL_CTX *ctx, int op,
3800                                               int bits, int nid, void *other,
3801                                               void *ex))
3802 {
3803     ctx->cert->sec_cb = cb;
3804 }
3805
3806 int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
3807                                                           const SSL_CTX *ctx,
3808                                                           int op, int bits,
3809                                                           int nid,
3810                                                           void *other,
3811                                                           void *ex) {
3812     return ctx->cert->sec_cb;
3813 }
3814
3815 void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
3816 {
3817     ctx->cert->sec_ex = ex;
3818 }
3819
3820 void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
3821 {
3822     return ctx->cert->sec_ex;
3823 }
3824
3825
3826 /*
3827  * Get/Set/Clear options in SSL_CTX or SSL, formerly macros, now functions that
3828  * can return unsigned long, instead of the generic long return value from the
3829  * control interface.
3830  */
3831 unsigned long SSL_CTX_get_options(const SSL_CTX *ctx)
3832 {
3833     return ctx->options;
3834 }
3835 unsigned long SSL_get_options(const SSL* s)
3836 {
3837     return s->options;
3838 }
3839 unsigned long SSL_CTX_set_options(SSL_CTX *ctx, unsigned long op)
3840 {
3841     return ctx->options |= op;
3842 }
3843 unsigned long SSL_set_options(SSL *s, unsigned long op)
3844 {
3845     return s->options |= op;
3846 }
3847 unsigned long SSL_CTX_clear_options(SSL_CTX *ctx, unsigned long op)
3848 {
3849     return ctx->options &= ~op;
3850 }
3851 unsigned long SSL_clear_options(SSL *s, unsigned long op)
3852 {
3853     return s->options &= ~op;
3854 }
3855
3856 STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s)
3857 {
3858     return s->verified_chain;
3859 }
3860