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