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