]> git.ipfire.org Git - thirdparty/openssl.git/blame - ssl/ssl_lib.c
projects / thirdparty / openssl.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
QUIC: Forbid NPN
[thirdparty/openssl.git] / ssl / ssl_lib.c
CommitLineData
0f113f3e 1/*
3c95ef22 2 * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
aa8f3d76 3 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
c80149d9 4 * Copyright 2005 Nokia. All rights reserved.
bf21446a 5 *
2c18d164 6 * Licensed under the Apache License 2.0 (the "License"). You may not use
846e33c7
RS		 7 * this file except in compliance with the License. You can obtain a copy
8 * in the file LICENSE in the source distribution or at
9 * https://www.openssl.org/source/license.html
bf21446a 10 */
846e33c7 11
d02b48c6 12#include <stdio.h>
706457b7 13#include "ssl_local.h"
d5f9166b 14#include "internal/e_os.h"
ec577822 15#include <openssl/objects.h>
bb7cd4e3 16#include <openssl/x509v3.h>
6434abbf 17#include <openssl/rand.h>
67c8e7f4 18#include <openssl/ocsp.h>
3c27208f
RS		 19#include <openssl/dh.h>
20#include <openssl/engine.h>
07bbc92c 21#include <openssl/async.h>
3c27208f 22#include <openssl/ct.h>
77359d22 23#include <openssl/trace.h>
4566dae7 24#include <openssl/core_names.h>
67dc995e 25#include "internal/cryptlib.h"
f2a6f838 26#include "internal/nelem.h"
cd420b0b 27#include "internal/refcount.h"
50ec7505 28#include "internal/ktls.h"
03bacce8 29#include "quic/quic_local.h"
0f113f3e 30
38b051a1 31static int ssl_undefined_function_3(SSL_CONNECTION *sc, unsigned char *r,
fce78bd4
BE		 32 unsigned char *s, size_t t, size_t *u)
33{
38b051a1 34 return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
fce78bd4
BE		 35}
36
38b051a1 37static int ssl_undefined_function_4(SSL_CONNECTION *sc, int r)
fce78bd4 38{
38b051a1 39 return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
fce78bd4
BE		 40}
41
38b051a1
TM		 42static size_t ssl_undefined_function_5(SSL_CONNECTION *sc, const char *r,
43 size_t s, unsigned char *t)
fce78bd4 44{
38b051a1 45 return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
fce78bd4
BE		 46}
47
48static int ssl_undefined_function_6(int r)
49{
fce78bd4
BE		 50 return ssl_undefined_function(NULL);
51}
52
38b051a1
TM		 53static int ssl_undefined_function_7(SSL_CONNECTION *sc, unsigned char *r,
54 size_t s, const char *t, size_t u,
fce78bd4
BE		 55 const unsigned char *v, size_t w, int x)
56{
38b051a1
TM		 57 return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
58}
59
60static int ssl_undefined_function_8(SSL_CONNECTION *sc)
61{
62 return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
fce78bd4
BE		 63}
64
0f113f3e 65SSL3_ENC_METHOD ssl3_undef_enc_method = {
38b051a1 66 ssl_undefined_function_8,
fce78bd4
BE		 67 ssl_undefined_function_3,
68 ssl_undefined_function_4,
69 ssl_undefined_function_5,
0f113f3e
MC		 70 NULL, /* client_finished_label */
71 0, /* client_finished_label_len */
72 NULL, /* server_finished_label */
73 0, /* server_finished_label_len */
fce78bd4
BE		 74 ssl_undefined_function_6,
75 ssl_undefined_function_7,
0f113f3e 76};
d02b48c6 77
07bbc92c
MC		 78struct ssl_async_args {
79 SSL *s;
80 void *buf;
348240c6 81 size_t num;
a230b26e 82 enum { READFUNC, WRITEFUNC, OTHERFUNC } type;
add2f5ca 83 union {
eda75751 84 int (*func_read) (SSL *, void *, size_t, size_t *);
7ee8627f 85 int (*func_write) (SSL *, const void *, size_t, size_t *);
a230b26e 86 int (*func_other) (SSL *);
add2f5ca 87 } f;
07bbc92c
MC		 88};
89
919ba009
VD		 90static const struct {
91 uint8_t mtype;
92 uint8_t ord;
a230b26e 93 int nid;
919ba009 94} dane_mds[] = {
a230b26e
EK		 95 {
96 DANETLS_MATCHING_FULL, 0, NID_undef
97 },
98 {
99 DANETLS_MATCHING_2256, 1, NID_sha256
100 },
101 {
102 DANETLS_MATCHING_2512, 2, NID_sha512
103 },
919ba009
VD		 104};
105
106static int dane_ctx_enable(struct dane_ctx_st *dctx)
107{
108 const EVP_MD **mdevp;
109 uint8_t *mdord;
110 uint8_t mdmax = DANETLS_MATCHING_LAST;
a230b26e 111 int n = ((int)mdmax) + 1; /* int to handle PrivMatch(255) */
919ba009
VD		 112 size_t i;
113
5ae4ceb9
VD		 114 if (dctx->mdevp != NULL)
115 return 1;
116
919ba009
VD		 117 mdevp = OPENSSL_zalloc(n * sizeof(*mdevp));
118 mdord = OPENSSL_zalloc(n * sizeof(*mdord));
119
120 if (mdord == NULL || mdevp == NULL) {
b3bd3d5a 121 OPENSSL_free(mdord);
919ba009 122 OPENSSL_free(mdevp);
919ba009
VD		 123 return 0;
124 }
125
126 /* Install default entries */
127 for (i = 0; i < OSSL_NELEM(dane_mds); ++i) {
128 const EVP_MD *md;
129
130 if (dane_mds[i].nid == NID_undef ||
131 (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL)
132 continue;
133 mdevp[dane_mds[i].mtype] = md;
134 mdord[dane_mds[i].mtype] = dane_mds[i].ord;
135 }
136
137 dctx->mdevp = mdevp;
138 dctx->mdord = mdord;
139 dctx->mdmax = mdmax;
140
141 return 1;
142}
143
144static void dane_ctx_final(struct dane_ctx_st *dctx)
145{
146 OPENSSL_free(dctx->mdevp);
147 dctx->mdevp = NULL;
148
149 OPENSSL_free(dctx->mdord);
150 dctx->mdord = NULL;
151 dctx->mdmax = 0;
152}
153
154static void tlsa_free(danetls_record *t)
155{
156 if (t == NULL)
157 return;
158 OPENSSL_free(t->data);
159 EVP_PKEY_free(t->spki);
160 OPENSSL_free(t);
161}
162
b9aec69a 163static void dane_final(SSL_DANE *dane)
919ba009
VD		 164{
165 sk_danetls_record_pop_free(dane->trecs, tlsa_free);
166 dane->trecs = NULL;
167
79b2a2f2 168 OSSL_STACK_OF_X509_free(dane->certs);
919ba009
VD		 169 dane->certs = NULL;
170
171 X509_free(dane->mcert);
172 dane->mcert = NULL;
173 dane->mtlsa = NULL;
174 dane->mdpth = -1;
175 dane->pdpth = -1;
176}
177
178/*
179 * dane_copy - Copy dane configuration, sans verification state.
180 */
38b051a1 181static int ssl_dane_dup(SSL_CONNECTION *to, SSL_CONNECTION *from)
919ba009
VD		 182{
183 int num;
184 int i;
185
186 if (!DANETLS_ENABLED(&from->dane))
187 return 1;
188
e431363f 189 num = sk_danetls_record_num(from->dane.trecs);
919ba009 190 dane_final(&to->dane);
5ae4ceb9 191 to->dane.flags = from->dane.flags;
38b051a1 192 to->dane.dctx = &SSL_CONNECTION_GET_CTX(to)->dane;
7a908204 193 to->dane.trecs = sk_danetls_record_new_reserve(NULL, num);
9f6b22b8
VD		 194
195 if (to->dane.trecs == NULL) {
e077455e 196 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
9f6b22b8
VD		 197 return 0;
198 }
919ba009 199
919ba009
VD		 200 for (i = 0; i < num; ++i) {
201 danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);
9f6b22b8 202
38b051a1
TM		 203 if (SSL_dane_tlsa_add(SSL_CONNECTION_GET_SSL(to), t->usage,
204 t->selector, t->mtype, t->data, t->dlen) <= 0)
919ba009
VD		 205 return 0;
206 }
207 return 1;
208}
209
a230b26e
EK		 210static int dane_mtype_set(struct dane_ctx_st *dctx,
211 const EVP_MD *md, uint8_t mtype, uint8_t ord)
919ba009
VD		 212{
213 int i;
214
215 if (mtype == DANETLS_MATCHING_FULL && md != NULL) {
6849b73c 216 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL);
919ba009
VD		 217 return 0;
218 }
219
220 if (mtype > dctx->mdmax) {
221 const EVP_MD **mdevp;
222 uint8_t *mdord;
a230b26e 223 int n = ((int)mtype) + 1;
919ba009
VD		 224
225 mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(*mdevp));
e077455e 226 if (mdevp == NULL)
919ba009 227 return -1;
919ba009
VD		 228 dctx->mdevp = mdevp;
229
230 mdord = OPENSSL_realloc(dctx->mdord, n * sizeof(*mdord));
e077455e 231 if (mdord == NULL)
919ba009 232 return -1;
919ba009
VD		 233 dctx->mdord = mdord;
234
235 /* Zero-fill any gaps */
a230b26e 236 for (i = dctx->mdmax + 1; i < mtype; ++i) {
919ba009
VD		 237 mdevp[i] = NULL;
238 mdord[i] = 0;
239 }
240
241 dctx->mdmax = mtype;
242 }
243
244 dctx->mdevp[mtype] = md;
245 /* Coerce ordinal of disabled matching types to 0 */
246 dctx->mdord[mtype] = (md == NULL) ? 0 : ord;
247
248 return 1;
249}
250
b9aec69a 251static const EVP_MD *tlsa_md_get(SSL_DANE *dane, uint8_t mtype)
919ba009
VD		 252{
253 if (mtype > dane->dctx->mdmax)
254 return NULL;
255 return dane->dctx->mdevp[mtype];
256}
257
a230b26e
EK		 258static int dane_tlsa_add(SSL_DANE *dane,
259 uint8_t usage,
260 uint8_t selector,
6d4313f0 261 uint8_t mtype, const unsigned char *data, size_t dlen)
919ba009
VD		 262{
263 danetls_record *t;
264 const EVP_MD *md = NULL;
265 int ilen = (int)dlen;
266 int i;
9f6b22b8 267 int num;
919ba009
VD		 268
269 if (dane->trecs == NULL) {
6849b73c 270 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_NOT_ENABLED);
919ba009
VD		 271 return -1;
272 }
273
274 if (ilen < 0 || dlen != (size_t)ilen) {
6849b73c 275 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_DATA_LENGTH);
919ba009
VD		 276 return 0;
277 }
278
279 if (usage > DANETLS_USAGE_LAST) {
6849b73c 280 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE);
919ba009
VD		 281 return 0;
282 }
283
284 if (selector > DANETLS_SELECTOR_LAST) {
6849b73c 285 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_SELECTOR);
919ba009
VD		 286 return 0;
287 }
288
289 if (mtype != DANETLS_MATCHING_FULL) {
290 md = tlsa_md_get(dane, mtype);
291 if (md == NULL) {
6849b73c 292 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE);
919ba009
VD		 293 return 0;
294 }
295 }
296
ed576acd 297 if (md != NULL && dlen != (size_t)EVP_MD_get_size(md)) {
6849b73c 298 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH);
919ba009
VD		 299 return 0;
300 }
301 if (!data) {
6849b73c 302 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_NULL_DATA);
919ba009
VD		 303 return 0;
304 }
305
e077455e 306 if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL)
919ba009 307 return -1;
919ba009
VD		 308
309 t->usage = usage;
310 t->selector = selector;
311 t->mtype = mtype;
348240c6 312 t->data = OPENSSL_malloc(dlen);
919ba009
VD		 313 if (t->data == NULL) {
314 tlsa_free(t);
919ba009
VD		 315 return -1;
316 }
348240c6
MC		 317 memcpy(t->data, data, dlen);
318 t->dlen = dlen;
919ba009
VD		 319
320 /* Validate and cache full certificate or public key */
321 if (mtype == DANETLS_MATCHING_FULL) {
322 const unsigned char *p = data;
323 X509 *cert = NULL;
324 EVP_PKEY *pkey = NULL;
325
326 switch (selector) {
327 case DANETLS_SELECTOR_CERT:
348240c6 328 if (!d2i_X509(&cert, &p, ilen) || p < data ||
919ba009
VD		 329 dlen != (size_t)(p - data)) {
330 tlsa_free(t);
6849b73c 331 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
919ba009
VD		 332 return 0;
333 }
334 if (X509_get0_pubkey(cert) == NULL) {
335 tlsa_free(t);
6849b73c 336 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
919ba009
VD		 337 return 0;
338 }
339
340 if ((DANETLS_USAGE_BIT(usage) & DANETLS_TA_MASK) == 0) {
341 X509_free(cert);
342 break;
343 }
344
345 /*
346 * For usage DANE-TA(2), we support authentication via "2 0 0" TLSA
347 * records that contain full certificates of trust-anchors that are
348 * not present in the wire chain. For usage PKIX-TA(0), we augment
349 * the chain with untrusted Full(0) certificates from DNS, in case
350 * they are missing from the chain.
351 */
352 if ((dane->certs == NULL &&
353 (dane->certs = sk_X509_new_null()) == NULL) ||
354 !sk_X509_push(dane->certs, cert)) {
e077455e 355 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
919ba009
VD		 356 X509_free(cert);
357 tlsa_free(t);
358 return -1;
359 }
360 break;
361
362 case DANETLS_SELECTOR_SPKI:
348240c6 363 if (!d2i_PUBKEY(&pkey, &p, ilen) || p < data ||
919ba009
VD		 364 dlen != (size_t)(p - data)) {
365 tlsa_free(t);
6849b73c 366 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY);
919ba009
VD		 367 return 0;
368 }
369
370 /*
371 * For usage DANE-TA(2), we support authentication via "2 1 0" TLSA
372 * records that contain full bare keys of trust-anchors that are
373 * not present in the wire chain.
374 */
375 if (usage == DANETLS_USAGE_DANE_TA)
376 t->spki = pkey;
377 else
378 EVP_PKEY_free(pkey);
379 break;
380 }
381 }
382
383 /*-
384 * Find the right insertion point for the new record.
385 *
386 * See crypto/x509/x509_vfy.c. We sort DANE-EE(3) records first, so that
387 * they can be processed first, as they require no chain building, and no
388 * expiration or hostname checks. Because DANE-EE(3) is numerically
389 * largest, this is accomplished via descending sort by "usage".
390 *
391 * We also sort in descending order by matching ordinal to simplify
392 * the implementation of digest agility in the verification code.
393 *
394 * The choice of order for the selector is not significant, so we
395 * use the same descending order for consistency.
396 */
9f6b22b8
VD		 397 num = sk_danetls_record_num(dane->trecs);
398 for (i = 0; i < num; ++i) {
919ba009 399 danetls_record *rec = sk_danetls_record_value(dane->trecs, i);
9f6b22b8 400
919ba009
VD		 401 if (rec->usage > usage)
402 continue;
403 if (rec->usage < usage)
404 break;
405 if (rec->selector > selector)
406 continue;
407 if (rec->selector < selector)
408 break;
409 if (dane->dctx->mdord[rec->mtype] > dane->dctx->mdord[mtype])
410 continue;
411 break;
412 }
413
414 if (!sk_danetls_record_insert(dane->trecs, t, i)) {
415 tlsa_free(t);
e077455e 416 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
919ba009
VD		 417 return -1;
418 }
419 dane->umask |= DANETLS_USAGE_BIT(usage);
420
421 return 1;
422}
423
c8feba72
BK		 424/*
425 * Return 0 if there is only one version configured and it was disabled
426 * at configure time. Return 1 otherwise.
427 */
428static int ssl_check_allowed_versions(int min_version, int max_version)
429{
430 int minisdtls = 0, maxisdtls = 0;
431
432 /* Figure out if we're doing DTLS versions or TLS versions */
433 if (min_version == DTLS1_BAD_VER
434 || min_version >> 8 == DTLS1_VERSION_MAJOR)
435 minisdtls = 1;
436 if (max_version == DTLS1_BAD_VER
437 || max_version >> 8 == DTLS1_VERSION_MAJOR)
438 maxisdtls = 1;
439 /* A wildcard version of 0 could be DTLS or TLS. */
440 if ((minisdtls && !maxisdtls && max_version != 0)
441 || (maxisdtls && !minisdtls && min_version != 0)) {
442 /* Mixing DTLS and TLS versions will lead to sadness; deny it. */
443 return 0;
444 }
445
446 if (minisdtls || maxisdtls) {
447 /* Do DTLS version checks. */
448 if (min_version == 0)
449 /* Ignore DTLS1_BAD_VER */
450 min_version = DTLS1_VERSION;
451 if (max_version == 0)
452 max_version = DTLS1_2_VERSION;
453#ifdef OPENSSL_NO_DTLS1_2
454 if (max_version == DTLS1_2_VERSION)
455 max_version = DTLS1_VERSION;
456#endif
457#ifdef OPENSSL_NO_DTLS1
458 if (min_version == DTLS1_VERSION)
459 min_version = DTLS1_2_VERSION;
460#endif
79b4444d
DMSP		 461 /* Done massaging versions; do the check. */
462 if (0
c8feba72
BK		 463#ifdef OPENSSL_NO_DTLS1
464 || (DTLS_VERSION_GE(min_version, DTLS1_VERSION)
465 && DTLS_VERSION_GE(DTLS1_VERSION, max_version))
466#endif
467#ifdef OPENSSL_NO_DTLS1_2
468 || (DTLS_VERSION_GE(min_version, DTLS1_2_VERSION)
469 && DTLS_VERSION_GE(DTLS1_2_VERSION, max_version))
470#endif
471 )
472 return 0;
473 } else {
474 /* Regular TLS version checks. */
79b4444d
DMSP		 475 if (min_version == 0)
476 min_version = SSL3_VERSION;
477 if (max_version == 0)
478 max_version = TLS1_3_VERSION;
c8feba72 479#ifdef OPENSSL_NO_TLS1_3
79b4444d
DMSP		 480 if (max_version == TLS1_3_VERSION)
481 max_version = TLS1_2_VERSION;
c8feba72
BK		 482#endif
483#ifdef OPENSSL_NO_TLS1_2
79b4444d
DMSP		 484 if (max_version == TLS1_2_VERSION)
485 max_version = TLS1_1_VERSION;
c8feba72
BK		 486#endif
487#ifdef OPENSSL_NO_TLS1_1
79b4444d
DMSP		 488 if (max_version == TLS1_1_VERSION)
489 max_version = TLS1_VERSION;
c8feba72
BK		 490#endif
491#ifdef OPENSSL_NO_TLS1
79b4444d
DMSP		 492 if (max_version == TLS1_VERSION)
493 max_version = SSL3_VERSION;
c8feba72
BK		 494#endif
495#ifdef OPENSSL_NO_SSL3
79b4444d
DMSP		 496 if (min_version == SSL3_VERSION)
497 min_version = TLS1_VERSION;
c8feba72
BK		 498#endif
499#ifdef OPENSSL_NO_TLS1
79b4444d
DMSP		 500 if (min_version == TLS1_VERSION)
501 min_version = TLS1_1_VERSION;
c8feba72
BK		 502#endif
503#ifdef OPENSSL_NO_TLS1_1
79b4444d
DMSP		 504 if (min_version == TLS1_1_VERSION)
505 min_version = TLS1_2_VERSION;
c8feba72
BK		 506#endif
507#ifdef OPENSSL_NO_TLS1_2
79b4444d
DMSP		 508 if (min_version == TLS1_2_VERSION)
509 min_version = TLS1_3_VERSION;
c8feba72 510#endif
79b4444d
DMSP		 511 /* Done massaging versions; do the check. */
512 if (0
c8feba72
BK		 513#ifdef OPENSSL_NO_SSL3
514 || (min_version <= SSL3_VERSION && SSL3_VERSION <= max_version)
515#endif
516#ifdef OPENSSL_NO_TLS1
517 || (min_version <= TLS1_VERSION && TLS1_VERSION <= max_version)
518#endif
519#ifdef OPENSSL_NO_TLS1_1
520 || (min_version <= TLS1_1_VERSION && TLS1_1_VERSION <= max_version)
521#endif
522#ifdef OPENSSL_NO_TLS1_2
523 || (min_version <= TLS1_2_VERSION && TLS1_2_VERSION <= max_version)
524#endif
525#ifdef OPENSSL_NO_TLS1_3
526 || (min_version <= TLS1_3_VERSION && TLS1_3_VERSION <= max_version)
527#endif
528 )
529 return 0;
530 }
531 return 1;
532}
533
08073700
RB		 534#if defined(__TANDEM) && defined(OPENSSL_VPROC)
535/*
536 * Define a VPROC function for HP NonStop build ssl library.
537 * This is used by platform version identification tools.
538 * Do not inline this procedure or make it static.
539 */
540# define OPENSSL_VPROC_STRING_(x) x##_SSL
541# define OPENSSL_VPROC_STRING(x) OPENSSL_VPROC_STRING_(x)
542# define OPENSSL_VPROC_FUNC OPENSSL_VPROC_STRING(OPENSSL_VPROC)
543void OPENSSL_VPROC_FUNC(void) {}
544#endif
545
6d814fd6 546static int clear_record_layer(SSL_CONNECTION *s)
d31fb0b5 547{
6d814fd6
MC		 548 int ret;
549
550 /* We try and reset both record layers even if one fails */
551
552 ret = ssl_set_new_record_layer(s,
553 SSL_CONNECTION_IS_DTLS(s) ? DTLS_ANY_VERSION
554 : TLS_ANY_VERSION,
555 OSSL_RECORD_DIRECTION_READ,
3f9175c7 556 OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0,
6d814fd6 557 NULL, 0, NULL, 0, NULL, 0, NULL, 0,
3f9175c7 558 NID_undef, NULL, NULL, NULL);
6d814fd6
MC		 559
560 ret &= ssl_set_new_record_layer(s,
561 SSL_CONNECTION_IS_DTLS(s) ? DTLS_ANY_VERSION
562 : TLS_ANY_VERSION,
563 OSSL_RECORD_DIRECTION_WRITE,
3f9175c7 564 OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0,
6d814fd6 565 NULL, 0, NULL, 0, NULL, 0, NULL, 0,
3f9175c7
MC		 566 NID_undef, NULL, NULL, NULL);
567
6d814fd6
MC		 568 /* SSLfatal already called in the event of failure */
569 return ret;
d31fb0b5
RS		 570}
571
4f43d0e7 572int SSL_clear(SSL *s)
0f113f3e 573{
0f113f3e 574 if (s->method == NULL) {
6849b73c 575 ERR_raise(ERR_LIB_SSL, SSL_R_NO_METHOD_SPECIFIED);
a89325e4 576 return 0;
0f113f3e 577 }
d02b48c6 578
38b051a1
TM		 579 return s->method->ssl_reset(s);
580}
581
582int ossl_ssl_connection_reset(SSL *s)
583{
584 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
585
586 if (sc == NULL)
587 return 0;
588
589 if (ssl_clear_bad_session(sc)) {
590 SSL_SESSION_free(sc->session);
591 sc->session = NULL;
0f113f3e 592 }
38b051a1
TM		 593 SSL_SESSION_free(sc->psksession);
594 sc->psksession = NULL;
595 OPENSSL_free(sc->psksession_id);
596 sc->psksession_id = NULL;
597 sc->psksession_id_len = 0;
598 sc->hello_retry_request = 0;
599 sc->sent_tickets = 0;
d62bfb39 600
38b051a1
TM		 601 sc->error = 0;
602 sc->hit = 0;
603 sc->shutdown = 0;
d02b48c6 604
38b051a1 605 if (sc->renegotiate) {
6849b73c 606 ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
0f113f3e
MC		 607 return 0;
608 }
d02b48c6 609
38b051a1 610 ossl_statem_clear(sc);
413c4f45 611
38b051a1
TM		 612 /* TODO(QUIC): Version handling not yet clear */
613 sc->version = s->method->version;
614 sc->client_version = sc->version;
615 sc->rwstate = SSL_NOTHING;
d02b48c6 616
38b051a1
TM		 617 BUF_MEM_free(sc->init_buf);
618 sc->init_buf = NULL;
38b051a1 619 sc->first_packet = 0;
d02b48c6 620
38b051a1 621 sc->key_update = SSL_KEY_UPDATE_NONE;
b67cb09f
TS		 622 memset(sc->ext.compress_certificate_from_peer, 0,
623 sizeof(sc->ext.compress_certificate_from_peer));
624 sc->ext.compress_certificate_sent = 0;
44c04a2e 625
38b051a1
TM		 626 EVP_MD_CTX_free(sc->pha_dgst);
627 sc->pha_dgst = NULL;
88834998 628
919ba009 629 /* Reset DANE verification result state */
38b051a1
TM		 630 sc->dane.mdpth = -1;
631 sc->dane.pdpth = -1;
632 X509_free(sc->dane.mcert);
633 sc->dane.mcert = NULL;
634 sc->dane.mtlsa = NULL;
919ba009
VD		 635
636 /* Clear the verification result peername */
38b051a1 637 X509_VERIFY_PARAM_move_peername(sc->param, NULL);
919ba009 638
29948ac8 639 /* Clear any shared connection state */
38b051a1
TM		 640 OPENSSL_free(sc->shared_sigalgs);
641 sc->shared_sigalgs = NULL;
642 sc->shared_sigalgslen = 0;
29948ac8 643
0f113f3e
MC		 644 /*
645 * Check to see if we were changed into a different method, if so, revert
24252537 646 * back.
0f113f3e 647 */
a7f41885 648 if (s->method != s->defltmeth) {
38b051a1 649 s->method->ssl_deinit(s);
a7f41885 650 s->method = s->defltmeth;
38b051a1 651 if (!s->method->ssl_init(s))
a89325e4 652 return 0;
b77f3ed1
MC		 653 } else {
654 if (!s->method->ssl_clear(s))
655 return 0;
656 }
33d23b87 657
38b051a1 658 RECORD_LAYER_clear(&sc->rlayer);
cffafb5f
MC		 659 BIO_free(sc->rlayer.rrlnext);
660 sc->rlayer.rrlnext = NULL;
33d23b87 661
6d814fd6 662 if (!clear_record_layer(sc))
2b71b042 663 return 0;
aedbb71b 664
a89325e4 665 return 1;
0f113f3e 666}
d02b48c6 667
dd0164e7 668#ifndef OPENSSL_NO_DEPRECATED_3_0
4f43d0e7 669/** Used to change an SSL_CTXs default SSL method type */
0f113f3e
MC		 670int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
671{
672 STACK_OF(SSL_CIPHER) *sk;
673
674 ctx->method = meth;
675
5d120511 676 if (!SSL_CTX_set_ciphersuites(ctx, OSSL_default_ciphersuites())) {
6849b73c 677 ERR_raise(ERR_LIB_SSL, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
2340ed27
BK		 678 return 0;
679 }
a68eee67 680 sk = ssl_create_cipher_list(ctx,
f865b081
MC		 681 ctx->tls13_ciphersuites,
682 &(ctx->cipher_list),
0f113f3e 683 &(ctx->cipher_list_by_id),
5d120511 684 OSSL_default_cipher_list(), ctx->cert);
0f113f3e 685 if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) {
6849b73c 686 ERR_raise(ERR_LIB_SSL, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
26a7d938 687 return 0;
0f113f3e 688 }
208fb891 689 return 1;
0f113f3e 690}
dd0164e7 691#endif
d02b48c6 692
4f43d0e7 693SSL *SSL_new(SSL_CTX *ctx)
0f113f3e 694{
0f113f3e 695 if (ctx == NULL) {
6849b73c 696 ERR_raise(ERR_LIB_SSL, SSL_R_NULL_SSL_CTX);
26a7d938 697 return NULL;
0f113f3e
MC		 698 }
699 if (ctx->method == NULL) {
6849b73c 700 ERR_raise(ERR_LIB_SSL, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
26a7d938 701 return NULL;
0f113f3e 702 }
38b051a1
TM		 703 return ctx->method->ssl_new(ctx);
704}
705
a7f41885 706int ossl_ssl_init(SSL *ssl, SSL_CTX *ctx, const SSL_METHOD *method, int type)
38b051a1
TM		 707{
708 ssl->type = type;
709
38b051a1
TM		 710 ssl->lock = CRYPTO_THREAD_lock_new();
711 if (ssl->lock == NULL)
712 return 0;
713
43a07d6d
P		 714 if (!CRYPTO_NEW_REF(&ssl->references, 1)) {
715 CRYPTO_THREAD_lock_free(ssl->lock);
716 return 0;
717 }
718
c10ded8c
TS		 719 if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, ssl, &ssl->ex_data)) {
720 CRYPTO_THREAD_lock_free(ssl->lock);
43a07d6d 721 CRYPTO_FREE_REF(&ssl->references);
c10ded8c
TS		 722 ssl->lock = NULL;
723 return 0;
724 }
725
38b051a1
TM		 726 SSL_CTX_up_ref(ctx);
727 ssl->ctx = ctx;
728
a7f41885 729 ssl->defltmeth = ssl->method = method;
38b051a1 730
38b051a1
TM		 731 return 1;
732}
733
a7f41885 734SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, const SSL_METHOD *method)
38b051a1
TM		 735{
736 SSL_CONNECTION *s;
737 SSL *ssl;
0f113f3e 738
b51bce94 739 s = OPENSSL_zalloc(sizeof(*s));
0f113f3e 740 if (s == NULL)
38b051a1 741 return NULL;
0f113f3e 742
38b051a1 743 ssl = &s->ssl;
a7f41885 744 if (!ossl_ssl_init(ssl, ctx, method, SSL_TYPE_SSL_CONNECTION)) {
e6b10c34
BE		 745 OPENSSL_free(s);
746 s = NULL;
c4a44e7b 747 ssl = NULL;
e077455e 748 goto sslerr;
e6b10c34 749 }
ae3947de 750
c036e210 751 RECORD_LAYER_init(&s->rlayer, s);
28d59af8 752
0f113f3e 753 s->options = ctx->options;
5ae4ceb9 754 s->dane.flags = ctx->dane.flags;
4f373a97
TM		 755 if (method->version == ctx->method->version) {
756 s->min_proto_version = ctx->min_proto_version;
757 s->max_proto_version = ctx->max_proto_version;
758 }
0f113f3e
MC		 759 s->mode = ctx->mode;
760 s->max_cert_list = ctx->max_cert_list;
3fc8d856 761 s->max_early_data = ctx->max_early_data;
4e8548e8 762 s->recv_max_early_data = ctx->recv_max_early_data;
9d0a8bb7 763 s->num_tickets = ctx->num_tickets;
e97be718 764 s->pha_enabled = ctx->pha_enabled;
0f113f3e 765
f865b081
MC		 766 /* Shallow copy of the ciphersuites stack */
767 s->tls13_ciphersuites = sk_SSL_CIPHER_dup(ctx->tls13_ciphersuites);
768 if (s->tls13_ciphersuites == NULL)
e077455e 769 goto cerr;
f865b081 770
2c382349
KR		 771 /*
772 * Earlier library versions used to copy the pointer to the CERT, not
773 * its contents; only when setting new parameters for the per-SSL
774 * copy, ssl_cert_new would be called (and the direct reference to
775 * the per-SSL_CTX settings would be lost, but those still were
776 * indirectly accessed for various purposes, and for that reason they
777 * used to be known as s->ctx->default_cert). Now we don't look at the
778 * SSL_CTX's CERT after having duplicated it once.
779 */
780 s->cert = ssl_cert_dup(ctx->cert);
781 if (s->cert == NULL)
e077455e 782 goto sslerr;
0f113f3e 783
52e1d7b1 784 RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead);
0f113f3e
MC		 785 s->msg_callback = ctx->msg_callback;
786 s->msg_callback_arg = ctx->msg_callback_arg;
787 s->verify_mode = ctx->verify_mode;
788 s->not_resumable_session_cb = ctx->not_resumable_session_cb;
eb7d6c2a
MC		 789 s->rlayer.record_padding_cb = ctx->record_padding_cb;
790 s->rlayer.record_padding_arg = ctx->record_padding_arg;
791 s->rlayer.block_padding = ctx->block_padding;
0f113f3e 792 s->sid_ctx_length = ctx->sid_ctx_length;
cbe29648 793 if (!ossl_assert(s->sid_ctx_length <= sizeof(s->sid_ctx)))
380a522f 794 goto err;
0f113f3e
MC		 795 memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx));
796 s->verify_callback = ctx->default_verify_callback;
797 s->generate_session_id = ctx->generate_session_id;
798
799 s->param = X509_VERIFY_PARAM_new();
a71edf3b 800 if (s->param == NULL)
e077455e 801 goto asn1err;
0f113f3e 802 X509_VERIFY_PARAM_inherit(s->param, ctx->param);
0f113f3e 803 s->quiet_shutdown = ctx->quiet_shutdown;
cf72c757
F		 804
805 s->ext.max_fragment_len_mode = ctx->ext.max_fragment_len_mode;
0f113f3e 806 s->max_send_fragment = ctx->max_send_fragment;
d102d9df
MC		 807 s->split_send_fragment = ctx->split_send_fragment;
808 s->max_pipelines = ctx->max_pipelines;
cffafb5f 809 s->rlayer.default_read_buf_len = ctx->default_read_buf_len;
bf21446a 810
aff8c126
RS		 811 s->ext.debug_cb = 0;
812 s->ext.debug_arg = NULL;
813 s->ext.ticket_expected = 0;
814 s->ext.status_type = ctx->ext.status_type;
815 s->ext.status_expected = 0;
816 s->ext.ocsp.ids = NULL;
817 s->ext.ocsp.exts = NULL;
818 s->ext.ocsp.resp = NULL;
819 s->ext.ocsp.resp_len = 0;
16203f7b 820 SSL_CTX_up_ref(ctx);
222da979 821 s->session_ctx = ctx;
aff8c126
RS		 822 if (ctx->ext.ecpointformats) {
823 s->ext.ecpointformats =
824 OPENSSL_memdup(ctx->ext.ecpointformats,
825 ctx->ext.ecpointformats_len);
39a14059
MC		 826 if (!s->ext.ecpointformats) {
827 s->ext.ecpointformats_len = 0;
0f113f3e 828 goto err;
39a14059 829 }
aff8c126
RS		 830 s->ext.ecpointformats_len =
831 ctx->ext.ecpointformats_len;
832 }
833 if (ctx->ext.supportedgroups) {
834 s->ext.supportedgroups =
835 OPENSSL_memdup(ctx->ext.supportedgroups,
9e84a42d 836 ctx->ext.supportedgroups_len
b92d7b62 837 * sizeof(*ctx->ext.supportedgroups));
39a14059
MC		 838 if (!s->ext.supportedgroups) {
839 s->ext.supportedgroups_len = 0;
0f113f3e 840 goto err;
39a14059 841 }
aff8c126 842 s->ext.supportedgroups_len = ctx->ext.supportedgroups_len;
0f113f3e 843 }
dbc6268f 844
a230b26e 845#ifndef OPENSSL_NO_NEXTPROTONEG
aff8c126 846 s->ext.npn = NULL;
a230b26e 847#endif
6f017a8f 848
38b051a1
TM		 849 if (ctx->ext.alpn != NULL) {
850 s->ext.alpn = OPENSSL_malloc(ctx->ext.alpn_len);
39a14059
MC		 851 if (s->ext.alpn == NULL) {
852 s->ext.alpn_len = 0;
0f113f3e 853 goto err;
39a14059 854 }
38b051a1
TM		 855 memcpy(s->ext.alpn, ctx->ext.alpn, ctx->ext.alpn_len);
856 s->ext.alpn_len = ctx->ext.alpn_len;
0f113f3e 857 }
d02b48c6 858
696178ed 859 s->verified_chain = NULL;
0f113f3e 860 s->verify_result = X509_V_OK;
d02b48c6 861
a974e64a
MC		 862 s->default_passwd_callback = ctx->default_passwd_callback;
863 s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;
864
44c04a2e
MC		 865 s->key_update = SSL_KEY_UPDATE_NONE;
866
c9598459
MC		 867 s->allow_early_data_cb = ctx->allow_early_data_cb;
868 s->allow_early_data_cb_data = ctx->allow_early_data_cb_data;
869
a7f41885 870 if (!method->ssl_init(ssl))
e077455e 871 goto sslerr;
d02b48c6 872
a7f41885 873 s->server = (method->ssl_accept == ssl_undefined_function) ? 0 : 1;
bf21446a 874
a7f41885 875 if (!method->ssl_reset(ssl))
e077455e 876 goto sslerr;
58964a49 877
ddac1974 878#ifndef OPENSSL_NO_PSK
0f113f3e
MC		 879 s->psk_client_callback = ctx->psk_client_callback;
880 s->psk_server_callback = ctx->psk_server_callback;
ddac1974 881#endif
f46184bd
MC		 882 s->psk_find_session_cb = ctx->psk_find_session_cb;
883 s->psk_use_session_cb = ctx->psk_use_session_cb;
ddac1974 884
9f5a87fd
PY		 885 s->async_cb = ctx->async_cb;
886 s->async_cb_arg = ctx->async_cb_arg;
887
07bbc92c
MC		 888 s->job = NULL;
889
b67cb09f
TS		 890#ifndef OPENSSL_NO_COMP_ALG
891 memcpy(s->cert_comp_prefs, ctx->cert_comp_prefs, sizeof(s->cert_comp_prefs));
892#endif
3c95ef22
TS		 893 if (ctx->client_cert_type != NULL) {
894 s->client_cert_type = OPENSSL_memdup(ctx->client_cert_type,
895 ctx->client_cert_type_len);
896 if (s->client_cert_type == NULL)
897 goto sslerr;
898 s->client_cert_type_len = ctx->client_cert_type_len;
899 }
900 if (ctx->server_cert_type != NULL) {
901 s->server_cert_type = OPENSSL_memdup(ctx->server_cert_type,
902 ctx->server_cert_type_len);
903 if (s->server_cert_type == NULL)
904 goto sslerr;
905 s->server_cert_type_len = ctx->server_cert_type_len;
906 }
b67cb09f 907
ed29e82a 908#ifndef OPENSSL_NO_CT
38b051a1 909 if (!SSL_set_ct_validation_callback(ssl, ctx->ct_validation_callback,
a230b26e 910 ctx->ct_validation_callback_arg))
e077455e 911 goto sslerr;
ed29e82a
RP		 912#endif
913
ee58915c 914 s->ssl_pkey_num = SSL_PKEY_NUM + ctx->sigalg_list_len;
38b051a1 915 return ssl;
e077455e
RL		 916 cerr:
917 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
918 goto err;
919 asn1err:
920 ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
921 goto err;
922 sslerr:
923 ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
0f113f3e 924 err:
38b051a1 925 SSL_free(ssl);
16203f7b 926 return NULL;
0f113f3e 927}
d02b48c6 928
a7f41885
MC		 929SSL *ossl_ssl_connection_new(SSL_CTX *ctx)
930{
931 return ossl_ssl_connection_new_int(ctx, ctx->method);
932}
933
e417070c
RS		 934int SSL_is_dtls(const SSL *s)
935{
38b051a1
TM		 936 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
937
50769b15 938#ifndef OPENSSL_NO_QUIC
f8636c7e 939 if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO)
50769b15
MC		 940 return 0;
941#endif
942
38b051a1
TM		 943 if (sc == NULL)
944 return 0;
945
946 return SSL_CONNECTION_IS_DTLS(sc) ? 1 : 0;
e417070c
RS		 947}
948
50769b15
MC		 949int SSL_is_tls(const SSL *s)
950{
951 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
952
953#ifndef OPENSSL_NO_QUIC
f8636c7e 954 if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO)
50769b15
MC		 955 return 0;
956#endif
957
958 if (sc == NULL)
959 return 0;
960
961 return SSL_CONNECTION_IS_DTLS(sc) ? 0 : 1;
962}
963
964int SSL_is_quic(const SSL *s)
965{
966#ifndef OPENSSL_NO_QUIC
f8636c7e 967 if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO)
50769b15
MC		 968 return 1;
969#endif
970 return 0;
971}
972
c5ebfcab 973int SSL_up_ref(SSL *s)
a18a31e4 974{
16203f7b 975 int i;
c5ebfcab 976
43a07d6d 977 if (CRYPTO_UP_REF(&s->references, &i) <= 0)
c5ebfcab
F		 978 return 0;
979
980 REF_PRINT_COUNT("SSL", s);
981 REF_ASSERT_ISNT(i < 2);
982 return ((i > 1) ? 1 : 0);
a18a31e4
MC		 983}
984
0f113f3e
MC		 985int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
986 unsigned int sid_ctx_len)
987{
fe9edc9d 988 if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
6849b73c 989 ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
0f113f3e
MC		 990 return 0;
991 }
992 ctx->sid_ctx_length = sid_ctx_len;
993 memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len);
4eb77b26
BM		 994
995 return 1;
0f113f3e 996}
4eb77b26 997
0f113f3e
MC		 998int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
999 unsigned int sid_ctx_len)
1000{
38b051a1
TM		 1001 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
1002
1003 if (sc == NULL)
1004 return 0;
1005
0f113f3e 1006 if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
6849b73c 1007 ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
0f113f3e
MC		 1008 return 0;
1009 }
38b051a1
TM		 1010 sc->sid_ctx_length = sid_ctx_len;
1011 memcpy(sc->sid_ctx, sid_ctx, sid_ctx_len);
b4cadc6e
BL		 1012
1013 return 1;
0f113f3e 1014}
b4cadc6e 1015
dc644fe2 1016int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
0f113f3e 1017{
cd3f8c1b
RS		 1018 if (!CRYPTO_THREAD_write_lock(ctx->lock))
1019 return 0;
0f113f3e 1020 ctx->generate_session_id = cb;
16203f7b 1021 CRYPTO_THREAD_unlock(ctx->lock);
0f113f3e
MC		 1022 return 1;
1023}
dc644fe2
GT		 1024
1025int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
0f113f3e 1026{
38b051a1
TM		 1027 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
1028
1029 if (sc == NULL || !CRYPTO_THREAD_write_lock(ssl->lock))
cd3f8c1b 1030 return 0;
38b051a1 1031 sc->generate_session_id = cb;
16203f7b 1032 CRYPTO_THREAD_unlock(ssl->lock);
0f113f3e
MC		 1033 return 1;
1034}
dc644fe2 1035
f85c9904 1036int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
0f113f3e
MC		 1037 unsigned int id_len)
1038{
1039 /*
1040 * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
69687aa8 1041 * we can "construct" a session to give us the desired check - i.e. to
0f113f3e
MC		 1042 * find if there's a session in the hash table that would conflict with
1043 * any new session built out of this id/id_len and the ssl_version in use
1044 * by this SSL.
1045 */
1046 SSL_SESSION r, *p;
38b051a1 1047 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
0f113f3e 1048
38b051a1 1049 if (sc == NULL || id_len > sizeof(r.session_id))
0f113f3e
MC		 1050 return 0;
1051
38b051a1 1052 r.ssl_version = sc->version;
0f113f3e
MC		 1053 r.session_id_length = id_len;
1054 memcpy(r.session_id, id, id_len);
1055
38b051a1 1056 if (!CRYPTO_THREAD_read_lock(sc->session_ctx->lock))
cd3f8c1b 1057 return 0;
38b051a1
TM		 1058 p = lh_SSL_SESSION_retrieve(sc->session_ctx->sessions, &r);
1059 CRYPTO_THREAD_unlock(sc->session_ctx->lock);
0f113f3e
MC		 1060 return (p != NULL);
1061}
dc644fe2 1062
bb7cd4e3 1063int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
0f113f3e
MC		 1064{
1065 return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
1066}
bb7cd4e3
DSH		 1067
1068int SSL_set_purpose(SSL *s, int purpose)
0f113f3e 1069{
38b051a1
TM		 1070 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1071
1072 if (sc == NULL)
1073 return 0;
1074
1075 return X509_VERIFY_PARAM_set_purpose(sc->param, purpose);
0f113f3e 1076}
926a56bf 1077
bb7cd4e3 1078int SSL_CTX_set_trust(SSL_CTX *s, int trust)
0f113f3e
MC		 1079{
1080 return X509_VERIFY_PARAM_set_trust(s->param, trust);
1081}
bb7cd4e3
DSH		 1082
1083int SSL_set_trust(SSL *s, int trust)
0f113f3e 1084{
38b051a1
TM		 1085 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1086
1087 if (sc == NULL)
1088 return 0;
1089
1090 return X509_VERIFY_PARAM_set_trust(sc->param, trust);
0f113f3e 1091}
bb7cd4e3 1092
919ba009
VD		 1093int SSL_set1_host(SSL *s, const char *hostname)
1094{
38b051a1
TM		 1095 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1096
1097 if (sc == NULL)
1098 return 0;
1099
c832840e
DW		 1100 /* If a hostname is provided and parses as an IP address,
1101 * treat it as such. */
38b051a1
TM		 1102 if (hostname != NULL
1103 && X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname) == 1)
c832840e
DW		 1104 return 1;
1105
38b051a1 1106 return X509_VERIFY_PARAM_set1_host(sc->param, hostname, 0);
919ba009
VD		 1107}
1108
1109int SSL_add1_host(SSL *s, const char *hostname)
1110{
38b051a1
TM		 1111 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1112
1113 if (sc == NULL)
1114 return 0;
1115
c832840e
DW		 1116 /* If a hostname is provided and parses as an IP address,
1117 * treat it as such. */
892a9e4c
DW		 1118 if (hostname)
1119 {
1120 ASN1_OCTET_STRING *ip;
1121 char *old_ip;
1122
1123 ip = a2i_IPADDRESS(hostname);
1124 if (ip) {
1125 /* We didn't want it; only to check if it *is* an IP address */
1126 ASN1_OCTET_STRING_free(ip);
1127
38b051a1 1128 old_ip = X509_VERIFY_PARAM_get1_ip_asc(sc->param);
892a9e4c
DW		 1129 if (old_ip)
1130 {
f2bfc53b 1131 OPENSSL_free(old_ip);
892a9e4c
DW		 1132 /* There can be only one IP address */
1133 return 0;
1134 }
1135
38b051a1 1136 return X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname);
892a9e4c
DW		 1137 }
1138 }
c832840e 1139
38b051a1 1140 return X509_VERIFY_PARAM_add1_host(sc->param, hostname, 0);
919ba009
VD		 1141}
1142
1143void SSL_set_hostflags(SSL *s, unsigned int flags)
1144{
38b051a1
TM		 1145 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1146
1147 if (sc == NULL)
1148 return;
1149
1150 X509_VERIFY_PARAM_set_hostflags(sc->param, flags);
919ba009
VD		 1151}
1152
4588cb44 1153const char *SSL_get0_peername(SSL *s)
919ba009 1154{
38b051a1
TM		 1155 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1156
1157 if (sc == NULL)
1158 return NULL;
1159
1160 return X509_VERIFY_PARAM_get0_peername(sc->param);
919ba009
VD		 1161}
1162
1163int SSL_CTX_dane_enable(SSL_CTX *ctx)
1164{
1165 return dane_ctx_enable(&ctx->dane);
1166}
1167
5ae4ceb9
VD		 1168unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags)
1169{
1170 unsigned long orig = ctx->dane.flags;
1171
1172 ctx->dane.flags |= flags;
1173 return orig;
1174}
1175
1176unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags)
1177{
1178 unsigned long orig = ctx->dane.flags;
1179
1180 ctx->dane.flags &= ~flags;
1181 return orig;
1182}
1183
919ba009
VD		 1184int SSL_dane_enable(SSL *s, const char *basedomain)
1185{
38b051a1
TM		 1186 SSL_DANE *dane;
1187 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
919ba009 1188
38b051a1
TM		 1189 if (sc == NULL)
1190 return 0;
1191
1192 dane = &sc->dane;
919ba009 1193 if (s->ctx->dane.mdmax == 0) {
6849b73c 1194 ERR_raise(ERR_LIB_SSL, SSL_R_CONTEXT_NOT_DANE_ENABLED);
919ba009
VD		 1195 return 0;
1196 }
1197 if (dane->trecs != NULL) {
6849b73c 1198 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_ALREADY_ENABLED);
919ba009
VD		 1199 return 0;
1200 }
1201
8d887efa
VD		 1202 /*
1203 * Default SNI name. This rejects empty names, while set1_host below
9929c817 1204 * accepts them and disables hostname checks. To avoid side-effects with
8d887efa
VD		 1205 * invalid input, set the SNI name first.
1206 */
38b051a1 1207 if (sc->ext.hostname == NULL) {
dccd20d1 1208 if (!SSL_set_tlsext_host_name(s, basedomain)) {
6849b73c 1209 ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
dccd20d1 1210 return -1;
8d887efa
VD		 1211 }
1212 }
1213
919ba009 1214 /* Primary RFC6125 reference identifier */
38b051a1 1215 if (!X509_VERIFY_PARAM_set1_host(sc->param, basedomain, 0)) {
6849b73c 1216 ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
919ba009
VD		 1217 return -1;
1218 }
1219
919ba009
VD		 1220 dane->mdpth = -1;
1221 dane->pdpth = -1;
1222 dane->dctx = &s->ctx->dane;
1223 dane->trecs = sk_danetls_record_new_null();
1224
1225 if (dane->trecs == NULL) {
e077455e 1226 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
919ba009
VD		 1227 return -1;
1228 }
1229 return 1;
1230}
1231
5ae4ceb9
VD		 1232unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags)
1233{
38b051a1
TM		 1234 unsigned long orig;
1235 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
1236
1237 if (sc == NULL)
1238 return 0;
1239
1240 orig = sc->dane.flags;
5ae4ceb9 1241
38b051a1 1242 sc->dane.flags |= flags;
5ae4ceb9
VD		 1243 return orig;
1244}
1245
1246unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags)
1247{
38b051a1
TM		 1248 unsigned long orig;
1249 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
5ae4ceb9 1250
38b051a1
TM		 1251 if (sc == NULL)
1252 return 0;
1253
1254 orig = sc->dane.flags;
1255
1256 sc->dane.flags &= ~flags;
5ae4ceb9
VD		 1257 return orig;
1258}
1259
919ba009
VD		 1260int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki)
1261{
38b051a1
TM		 1262 SSL_DANE *dane;
1263 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
919ba009 1264
38b051a1
TM		 1265 if (sc == NULL)
1266 return -1;
1267
1268 dane = &sc->dane;
1269
1270 if (!DANETLS_ENABLED(dane) || sc->verify_result != X509_V_OK)
919ba009
VD		 1271 return -1;
1272 if (dane->mtlsa) {
1273 if (mcert)
1274 *mcert = dane->mcert;
1275 if (mspki)
1276 *mspki = (dane->mcert == NULL) ? dane->mtlsa->spki : NULL;
1277 }
1278 return dane->mdpth;
1279}
1280
1281int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
6d4313f0 1282 uint8_t *mtype, const unsigned char **data, size_t *dlen)
919ba009 1283{
38b051a1
TM		 1284 SSL_DANE *dane;
1285 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
919ba009 1286
38b051a1
TM		 1287 if (sc == NULL)
1288 return -1;
1289
1290 dane = &sc->dane;
1291
1292 if (!DANETLS_ENABLED(dane) || sc->verify_result != X509_V_OK)
919ba009
VD		 1293 return -1;
1294 if (dane->mtlsa) {
1295 if (usage)
1296 *usage = dane->mtlsa->usage;
1297 if (selector)
1298 *selector = dane->mtlsa->selector;
1299 if (mtype)
1300 *mtype = dane->mtlsa->mtype;
1301 if (data)
1302 *data = dane->mtlsa->data;
1303 if (dlen)
1304 *dlen = dane->mtlsa->dlen;
1305 }
1306 return dane->mdpth;
1307}
1308
b9aec69a 1309SSL_DANE *SSL_get0_dane(SSL *s)
919ba009 1310{
38b051a1
TM		 1311 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1312
1313 if (sc == NULL)
1314 return NULL;
1315
1316 return &sc->dane;
919ba009
VD		 1317}
1318
1319int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
6d4313f0 1320 uint8_t mtype, const unsigned char *data, size_t dlen)
919ba009 1321{
38b051a1
TM		 1322 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1323
1324 if (sc == NULL)
1325 return 0;
1326
1327 return dane_tlsa_add(&sc->dane, usage, selector, mtype, data, dlen);
919ba009
VD		 1328}
1329
a230b26e
EK		 1330int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, uint8_t mtype,
1331 uint8_t ord)
919ba009
VD		 1332{
1333 return dane_mtype_set(&ctx->dane, md, mtype, ord);
1334}
1335
ccf11751 1336int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
0f113f3e
MC		 1337{
1338 return X509_VERIFY_PARAM_set1(ctx->param, vpm);
1339}
ccf11751
DSH		 1340
1341int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
0f113f3e 1342{
38b051a1
TM		 1343 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
1344
1345 if (sc == NULL)
1346 return 0;
1347
1348 return X509_VERIFY_PARAM_set1(sc->param, vpm);
0f113f3e 1349}
ccf11751 1350
7af31968 1351X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
0f113f3e
MC		 1352{
1353 return ctx->param;
1354}
7af31968
DSH		 1355
1356X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
0f113f3e 1357{
38b051a1
TM		 1358 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
1359
1360 if (sc == NULL)
1361 return NULL;
1362
1363 return sc->param;
0f113f3e 1364}
7af31968 1365
a5ee80b9 1366void SSL_certs_clear(SSL *s)
0f113f3e 1367{
38b051a1
TM		 1368 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1369
1370 if (sc == NULL)
1371 return;
1372
1373 ssl_cert_clear_certs(sc->cert);
0f113f3e 1374}
a5ee80b9 1375
4f43d0e7 1376void SSL_free(SSL *s)
0f113f3e
MC		 1377{
1378 int i;
58964a49 1379
e6e9170d
RS		 1380 if (s == NULL)
1381 return;
43a07d6d 1382 CRYPTO_DOWN_REF(&s->references, &i);
f3f1cf84 1383 REF_PRINT_COUNT("SSL", s);
0f113f3e
MC		 1384 if (i > 0)
1385 return;
f3f1cf84 1386 REF_ASSERT_ISNT(i < 0);
d02b48c6 1387
38b051a1
TM		 1388 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
1389
1390 if (s->method != NULL)
1391 s->method->ssl_free(s);
1392
1393 SSL_CTX_free(s->ctx);
1394 CRYPTO_THREAD_lock_free(s->lock);
43a07d6d 1395 CRYPTO_FREE_REF(&s->references);
38b051a1
TM		 1396
1397 OPENSSL_free(s);
1398}
1399
1400void ossl_ssl_connection_free(SSL *ssl)
1401{
1402 SSL_CONNECTION *s;
1403
1404 s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
1405 if (s == NULL)
1406 return;
1407
222561fe 1408 X509_VERIFY_PARAM_free(s->param);
919ba009 1409 dane_final(&s->dane);
0f113f3e 1410
b77f3ed1 1411 /* Ignore return value */
2e7dc7cd
MC		 1412 ssl_free_wbio_buffer(s);
1413
9ff51954
MC		 1414 RECORD_LAYER_clear(&s->rlayer);
1415
25aaa98a 1416 BUF_MEM_free(s->init_buf);
0f113f3e
MC		 1417
1418 /* add extra stuff */
25aaa98a
RS		 1419 sk_SSL_CIPHER_free(s->cipher_list);
1420 sk_SSL_CIPHER_free(s->cipher_list_by_id);
f865b081 1421 sk_SSL_CIPHER_free(s->tls13_ciphersuites);
eee2a6a7 1422 sk_SSL_CIPHER_free(s->peer_ciphers);
0f113f3e
MC		 1423
1424 /* Make the next call work :-) */
1425 if (s->session != NULL) {
1426 ssl_clear_bad_session(s);
1427 SSL_SESSION_free(s->session);
1428 }
9368f865 1429 SSL_SESSION_free(s->psksession);
add8d0e9 1430 OPENSSL_free(s->psksession_id);
0f113f3e 1431
e0e920b1 1432 ssl_cert_free(s->cert);
29948ac8 1433 OPENSSL_free(s->shared_sigalgs);
0f113f3e 1434 /* Free up if allocated */
d02b48c6 1435
aff8c126 1436 OPENSSL_free(s->ext.hostname);
222da979 1437 SSL_CTX_free(s->session_ctx);
aff8c126 1438 OPENSSL_free(s->ext.ecpointformats);
cd0fb43c 1439 OPENSSL_free(s->ext.peer_ecpointformats);
aff8c126 1440 OPENSSL_free(s->ext.supportedgroups);
45436e61 1441 OPENSSL_free(s->ext.peer_supportedgroups);
aff8c126 1442 sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts, X509_EXTENSION_free);
3e41ac35 1443#ifndef OPENSSL_NO_OCSP
aff8c126 1444 sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free);
3e41ac35 1445#endif
ed29e82a
RP		 1446#ifndef OPENSSL_NO_CT
1447 SCT_LIST_free(s->scts);
aff8c126 1448 OPENSSL_free(s->ext.scts);
ed29e82a 1449#endif
aff8c126
RS		 1450 OPENSSL_free(s->ext.ocsp.resp);
1451 OPENSSL_free(s->ext.alpn);
cfef5027 1452 OPENSSL_free(s->ext.tls13_cookie);
94941cad
MK		 1453 if (s->clienthello != NULL)
1454 OPENSSL_free(s->clienthello->pre_proc_exts);
6b1bb98f 1455 OPENSSL_free(s->clienthello);
9d75dce3
TS		 1456 OPENSSL_free(s->pha_context);
1457 EVP_MD_CTX_free(s->pha_dgst);
0f113f3e 1458
fa7c2637 1459 sk_X509_NAME_pop_free(s->ca_names, X509_NAME_free);
98732979 1460 sk_X509_NAME_pop_free(s->client_ca_names, X509_NAME_free);
0f113f3e 1461
3c95ef22
TS		 1462 OPENSSL_free(s->client_cert_type);
1463 OPENSSL_free(s->server_cert_type);
1464
79b2a2f2 1465 OSSL_STACK_OF_X509_free(s->verified_chain);
696178ed 1466
38b051a1
TM		 1467 if (ssl->method != NULL)
1468 ssl->method->ssl_deinit(ssl);
7c3908dd 1469
ff75a257
MC		 1470 ASYNC_WAIT_CTX_free(s->waitctx);
1471
e481f9b9 1472#if !defined(OPENSSL_NO_NEXTPROTONEG)
aff8c126 1473 OPENSSL_free(s->ext.npn);
ee2ffc27
BL		 1474#endif
1475
e783bae2 1476#ifndef OPENSSL_NO_SRTP
25aaa98a 1477 sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
0f113f3e 1478#endif
cd6e89b6
MC		 1479
1480 /*
1481 * We do this late. We want to ensure that any other references we held to
1482 * these BIOs are freed first *before* we call BIO_free_all(), because
1483 * BIO_free_all() will only free each BIO in the chain if the number of
1484 * references to the first BIO have dropped to 0
1485 */
1486 BIO_free_all(s->wbio);
1487 s->wbio = NULL;
1488 BIO_free_all(s->rbio);
1489 s->rbio = NULL;
ee58915c 1490 OPENSSL_free(s->s3.tmp.valid_flags);
0f113f3e
MC		 1491}
1492
65e2d672 1493void SSL_set0_rbio(SSL *s, BIO *rbio)
3ffbe008 1494{
38b051a1 1495 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
03bacce8 1496
6d495cc4
HL		 1497#ifndef OPENSSL_NO_QUIC
1498 if (IS_QUIC(s)) {
1499 ossl_quic_conn_set0_net_rbio(s, rbio);
03bacce8
HL		 1500 return;
1501 }
1502#endif
38b051a1
TM		 1503
1504 if (sc == NULL)
1505 return;
1506
1507 BIO_free_all(sc->rbio);
1508 sc->rbio = rbio;
cffafb5f 1509 sc->rlayer.rrlmethod->set1_bio(sc->rlayer.rrl, sc->rbio);
3ffbe008
MC		 1510}
1511
65e2d672 1512void SSL_set0_wbio(SSL *s, BIO *wbio)
0f113f3e 1513{
38b051a1 1514 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
03bacce8 1515
6d495cc4
HL		 1516#ifndef OPENSSL_NO_QUIC
1517 if (IS_QUIC(s)) {
1518 ossl_quic_conn_set0_net_wbio(s, wbio);
03bacce8
HL		 1519 return;
1520 }
1521#endif
38b051a1
TM		 1522
1523 if (sc == NULL)
1524 return;
1525
0f113f3e
MC		 1526 /*
1527 * If the output buffering BIO is still in place, remove it
1528 */
38b051a1
TM		 1529 if (sc->bbio != NULL)
1530 sc->wbio = BIO_pop(sc->wbio);
2e7dc7cd 1531
38b051a1
TM		 1532 BIO_free_all(sc->wbio);
1533 sc->wbio = wbio;
2e7dc7cd
MC		 1534
1535 /* Re-attach |bbio| to the new |wbio|. */
38b051a1
TM		 1536 if (sc->bbio != NULL)
1537 sc->wbio = BIO_push(sc->bbio, sc->wbio);
b5cf81f7
MC		 1538
1539 sc->rlayer.wrlmethod->set1_bio(sc->rlayer.wrl, sc->wbio);
0f113f3e 1540}
d02b48c6 1541
3ffbe008
MC		 1542void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
1543{
65e2d672
MC		 1544 /*
1545 * For historical reasons, this function has many different cases in
1546 * ownership handling.
1547 */
1548
1549 /* If nothing has changed, do nothing */
1550 if (rbio == SSL_get_rbio(s) && wbio == SSL_get_wbio(s))
1551 return;
1552
1553 /*
1554 * If the two arguments are equal then one fewer reference is granted by the
1555 * caller than we want to take
1556 */
1557 if (rbio != NULL && rbio == wbio)
1558 BIO_up_ref(rbio);
1559
1560 /*
1561 * If only the wbio is changed only adopt one reference.
1562 */
1563 if (rbio == SSL_get_rbio(s)) {
1564 SSL_set0_wbio(s, wbio);
1565 return;
1566 }
1567 /*
1568 * There is an asymmetry here for historical reasons. If only the rbio is
1569 * changed AND the rbio and wbio were originally different, then we only
1570 * adopt one reference.
1571 */
1572 if (wbio == SSL_get_wbio(s) && SSL_get_rbio(s) != SSL_get_wbio(s)) {
1573 SSL_set0_rbio(s, rbio);
1574 return;
1575 }
1576
1577 /* Otherwise, adopt both references. */
1578 SSL_set0_rbio(s, rbio);
1579 SSL_set0_wbio(s, wbio);
3ffbe008
MC		 1580}
1581
0821bcd4 1582BIO *SSL_get_rbio(const SSL *s)
0f113f3e 1583{
38b051a1 1584 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
03bacce8 1585
6d495cc4
HL		 1586#ifndef OPENSSL_NO_QUIC
1587 if (IS_QUIC(s))
1588 return ossl_quic_conn_get_net_rbio(s);
03bacce8 1589#endif
38b051a1
TM		 1590
1591 if (sc == NULL)
1592 return NULL;
1593
1594 return sc->rbio;
0f113f3e 1595}
d02b48c6 1596
0821bcd4 1597BIO *SSL_get_wbio(const SSL *s)
0f113f3e 1598{
38b051a1 1599 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
03bacce8 1600
6d495cc4
HL		 1601#ifndef OPENSSL_NO_QUIC
1602 if (IS_QUIC(s))
1603 return ossl_quic_conn_get_net_wbio(s);
03bacce8 1604#endif
38b051a1
TM		 1605
1606 if (sc == NULL)
1607 return NULL;
1608
1609 if (sc->bbio != NULL) {
2e7dc7cd
MC		 1610 /*
1611 * If |bbio| is active, the true caller-configured BIO is its
1612 * |next_bio|.
1613 */
38b051a1 1614 return BIO_next(sc->bbio);
2e7dc7cd 1615 }
38b051a1 1616 return sc->wbio;
0f113f3e 1617}
d02b48c6 1618
0821bcd4 1619int SSL_get_fd(const SSL *s)
0f113f3e 1620{
2e7dc7cd 1621 return SSL_get_rfd(s);
0f113f3e 1622}
24cbf3ef 1623
0821bcd4 1624int SSL_get_rfd(const SSL *s)
0f113f3e
MC		 1625{
1626 int ret = -1;
1627 BIO *b, *r;
1628
1629 b = SSL_get_rbio(s);
1630 r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1631 if (r != NULL)
1632 BIO_get_fd(r, &ret);
26a7d938 1633 return ret;
0f113f3e 1634}
d02b48c6 1635
0821bcd4 1636int SSL_get_wfd(const SSL *s)
0f113f3e
MC		 1637{
1638 int ret = -1;
1639 BIO *b, *r;
1640
1641 b = SSL_get_wbio(s);
1642 r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR);
1643 if (r != NULL)
1644 BIO_get_fd(r, &ret);
26a7d938 1645 return ret;
0f113f3e 1646}
24cbf3ef 1647
bc36ee62 1648#ifndef OPENSSL_NO_SOCK
0f113f3e
MC		 1649int SSL_set_fd(SSL *s, int fd)
1650{
1651 int ret = 0;
1652 BIO *bio = NULL;
1653
1654 bio = BIO_new(BIO_s_socket());
1655
1656 if (bio == NULL) {
6849b73c 1657 ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
0f113f3e
MC		 1658 goto err;
1659 }
1660 BIO_set_fd(bio, fd, BIO_NOCLOSE);
1661 SSL_set_bio(s, bio, bio);
50ec7505
BP		 1662#ifndef OPENSSL_NO_KTLS
1663 /*
1664 * The new socket is created successfully regardless of ktls_enable.
1665 * ktls_enable doesn't change any functionality of the socket, except
1666 * changing the setsockopt to enable the processing of ktls_start.
1667 * Thus, it is not a problem to call it for non-TLS sockets.
1668 */
1669 ktls_enable(fd);
1670#endif /* OPENSSL_NO_KTLS */
0f113f3e
MC		 1671 ret = 1;
1672 err:
26a7d938 1673 return ret;
0f113f3e 1674}
d02b48c6 1675
0f113f3e
MC		 1676int SSL_set_wfd(SSL *s, int fd)
1677{
2e7dc7cd 1678 BIO *rbio = SSL_get_rbio(s);
0f113f3e 1679
2e7dc7cd
MC		 1680 if (rbio == NULL || BIO_method_type(rbio) != BIO_TYPE_SOCKET
1681 || (int)BIO_get_fd(rbio, NULL) != fd) {
1682 BIO *bio = BIO_new(BIO_s_socket());
0f113f3e
MC		 1683
1684 if (bio == NULL) {
6849b73c 1685 ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
2e7dc7cd 1686 return 0;
0f113f3e
MC		 1687 }
1688 BIO_set_fd(bio, fd, BIO_NOCLOSE);
65e2d672 1689 SSL_set0_wbio(s, bio);
50ec7505
BP		 1690#ifndef OPENSSL_NO_KTLS
1691 /*
1692 * The new socket is created successfully regardless of ktls_enable.
1693 * ktls_enable doesn't change any functionality of the socket, except
1694 * changing the setsockopt to enable the processing of ktls_start.
1695 * Thus, it is not a problem to call it for non-TLS sockets.
1696 */
1697 ktls_enable(fd);
1698#endif /* OPENSSL_NO_KTLS */
2e7dc7cd 1699 } else {
65e2d672
MC		 1700 BIO_up_ref(rbio);
1701 SSL_set0_wbio(s, rbio);
2e7dc7cd
MC		 1702 }
1703 return 1;
0f113f3e
MC		 1704}
1705
1706int SSL_set_rfd(SSL *s, int fd)
1707{
2e7dc7cd 1708 BIO *wbio = SSL_get_wbio(s);
0f113f3e 1709
2e7dc7cd
MC		 1710 if (wbio == NULL || BIO_method_type(wbio) != BIO_TYPE_SOCKET
1711 || ((int)BIO_get_fd(wbio, NULL) != fd)) {
1712 BIO *bio = BIO_new(BIO_s_socket());
0f113f3e
MC		 1713
1714 if (bio == NULL) {
6849b73c 1715 ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
2e7dc7cd 1716 return 0;
0f113f3e
MC		 1717 }
1718 BIO_set_fd(bio, fd, BIO_NOCLOSE);
65e2d672 1719 SSL_set0_rbio(s, bio);
2e7dc7cd 1720 } else {
65e2d672
MC		 1721 BIO_up_ref(wbio);
1722 SSL_set0_rbio(s, wbio);
2e7dc7cd
MC		 1723 }
1724
1725 return 1;
0f113f3e
MC		 1726}
1727#endif
ca03109c
BM		 1728
1729/* return length of latest Finished message we sent, copy to 'buf' */
0821bcd4 1730size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
0f113f3e
MC		 1731{
1732 size_t ret = 0;
38b051a1
TM		 1733 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
1734
1735 if (sc == NULL)
1736 return 0;
0f113f3e 1737
38b051a1 1738 ret = sc->s3.tmp.finish_md_len;
555cbb32
TS		 1739 if (count > ret)
1740 count = ret;
38b051a1 1741 memcpy(buf, sc->s3.tmp.finish_md, count);
0f113f3e
MC		 1742 return ret;
1743}
ca03109c
BM		 1744
1745/* return length of latest Finished message we expected, copy to 'buf' */
0821bcd4 1746size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
0f113f3e
MC		 1747{
1748 size_t ret = 0;
38b051a1 1749 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
ca03109c 1750
38b051a1
TM		 1751 if (sc == NULL)
1752 return 0;
1753
1754 ret = sc->s3.tmp.peer_finish_md_len;
555cbb32
TS		 1755 if (count > ret)
1756 count = ret;
38b051a1 1757 memcpy(buf, sc->s3.tmp.peer_finish_md, count);
0f113f3e
MC		 1758 return ret;
1759}
ca03109c 1760
0821bcd4 1761int SSL_get_verify_mode(const SSL *s)
0f113f3e 1762{
38b051a1
TM		 1763 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
1764
1765 if (sc == NULL)
1766 return 0;
1767
1768 return sc->verify_mode;
0f113f3e 1769}
d02b48c6 1770
0821bcd4 1771int SSL_get_verify_depth(const SSL *s)
0f113f3e 1772{
38b051a1
TM		 1773 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
1774
1775 if (sc == NULL)
1776 return 0;
1777
1778 return X509_VERIFY_PARAM_get_depth(sc->param);
0f113f3e 1779}
7f89714e 1780
0f113f3e 1781int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
38b051a1
TM		 1782 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
1783
1784 if (sc == NULL)
1785 return NULL;
1786
1787 return sc->verify_callback;
0f113f3e 1788}
d02b48c6 1789
0821bcd4 1790int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
0f113f3e 1791{
26a7d938 1792 return ctx->verify_mode;
0f113f3e 1793}
d02b48c6 1794
0821bcd4 1795int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
0f113f3e
MC		 1796{
1797 return X509_VERIFY_PARAM_get_depth(ctx->param);
1798}
1799
1800int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
26a7d938 1801 return ctx->default_verify_callback;
0f113f3e
MC		 1802}
1803
1804void SSL_set_verify(SSL *s, int mode,
1805 int (*callback) (int ok, X509_STORE_CTX *ctx))
1806{
38b051a1
TM		 1807 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1808
1809 if (sc == NULL)
1810 return;
1811
1812 sc->verify_mode = mode;
0f113f3e 1813 if (callback != NULL)
38b051a1 1814 sc->verify_callback = callback;
0f113f3e
MC		 1815}
1816
1817void SSL_set_verify_depth(SSL *s, int depth)
1818{
38b051a1
TM		 1819 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
1820
1821 if (sc == NULL)
1822 return;
1823
1824 X509_VERIFY_PARAM_set_depth(sc->param, depth);
0f113f3e
MC		 1825}
1826
1827void SSL_set_read_ahead(SSL *s, int yes)
1828{
38b051a1 1829 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4566dae7 1830 OSSL_PARAM options[2], *opts = options;
38b051a1
TM		 1831
1832 if (sc == NULL)
1833 return;
1834
1835 RECORD_LAYER_set_read_ahead(&sc->rlayer, yes);
4566dae7
MC		 1836
1837 *opts++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD,
1838 &sc->rlayer.read_ahead);
1839 *opts = OSSL_PARAM_construct_end();
1840
1841 /* Ignore return value */
1842 sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options);
0f113f3e 1843}
d02b48c6 1844
0821bcd4 1845int SSL_get_read_ahead(const SSL *s)
0f113f3e 1846{
38b051a1
TM		 1847 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
1848
1849 if (sc == NULL)
1850 return 0;
1851
1852 return RECORD_LAYER_get_read_ahead(&sc->rlayer);
0f113f3e 1853}
d02b48c6 1854
0821bcd4 1855int SSL_pending(const SSL *s)
0f113f3e 1856{
8b0e934a
MC		 1857 size_t pending = s->method->ssl_pending(s);
1858
0f113f3e
MC		 1859 /*
1860 * SSL_pending cannot work properly if read-ahead is enabled
1861 * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)), and it is
1862 * impossible to fix since SSL_pending cannot report errors that may be
1863 * observed while scanning the new data. (Note that SSL_pending() is
1864 * often used as a boolean value, so we'd better not return -1.)
8b0e934a
MC		 1865 *
1866 * SSL_pending also cannot work properly if the value >INT_MAX. In that case
1867 * we just return INT_MAX.
0f113f3e 1868 */
348240c6 1869 return pending < INT_MAX ? (int)pending : INT_MAX;
0f113f3e 1870}
d02b48c6 1871
49580f25
MC		 1872int SSL_has_pending(const SSL *s)
1873{
1874 /*
1875 * Similar to SSL_pending() but returns a 1 to indicate that we have
6d6b295a
MC		 1876 * processed or unprocessed data available or 0 otherwise (as opposed to the
1877 * number of bytes available). Unlike SSL_pending() this will take into
1878 * account read_ahead data. A 1 return simply indicates that we have data.
1879 * That data may not result in any application data, or we may fail to parse
1880 * the records for some reason.
49580f25 1881 */
560470b5 1882 const SSL_CONNECTION *sc;
560470b5 1883
22b1a96f
HL		 1884#ifndef OPENSSL_NO_QUIC
1885 if (IS_QUIC(s))
6d495cc4 1886 return ossl_quic_has_pending(s);
560470b5
MC		 1887#endif
1888
560470b5 1889 sc = SSL_CONNECTION_FROM_CONST_SSL(s);
38b051a1 1890
6d6b295a
MC		 1891 /* Check buffered app data if any first */
1892 if (SSL_CONNECTION_IS_DTLS(sc)) {
eddb067e 1893 TLS_RECORD *rdata;
6d6b295a
MC		 1894 pitem *item, *iter;
1895
1896 iter = pqueue_iterator(sc->rlayer.d->buffered_app_data.q);
1897 while ((item = pqueue_next(&iter)) != NULL) {
1898 rdata = item->data;
eddb067e 1899 if (rdata->length > 0)
6d6b295a
MC		 1900 return 1;
1901 }
1902 }
38b051a1
TM		 1903
1904 if (RECORD_LAYER_processed_read_pending(&sc->rlayer))
49580f25
MC		 1905 return 1;
1906
38b051a1 1907 return RECORD_LAYER_read_pending(&sc->rlayer);
49580f25
MC		 1908}
1909
8c2bfd25 1910X509 *SSL_get1_peer_certificate(const SSL *s)
0f113f3e 1911{
8c2bfd25 1912 X509 *r = SSL_get0_peer_certificate(s);
d02b48c6 1913
8c2bfd25
TS		 1914 if (r != NULL)
1915 X509_up_ref(r);
0f113f3e 1916
26a7d938 1917 return r;
0f113f3e 1918}
d02b48c6 1919
8c2bfd25
TS		 1920X509 *SSL_get0_peer_certificate(const SSL *s)
1921{
38b051a1
TM		 1922 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
1923
1924 if (sc == NULL)
1925 return NULL;
1926
1927 if (sc->session == NULL)
8c2bfd25
TS		 1928 return NULL;
1929 else
38b051a1 1930 return sc->session->peer;
8c2bfd25
TS		 1931}
1932
0821bcd4 1933STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
0f113f3e
MC		 1934{
1935 STACK_OF(X509) *r;
38b051a1 1936 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
0f113f3e 1937
38b051a1
TM		 1938 if (sc == NULL)
1939 return NULL;
1940
1941 if (sc->session == NULL)
0f113f3e
MC		 1942 r = NULL;
1943 else
38b051a1 1944 r = sc->session->peer_chain;
0f113f3e
MC		 1945
1946 /*
1947 * If we are a client, cert_chain includes the peer's own certificate; if
1948 * we are a server, it does not.
1949 */
1950
26a7d938 1951 return r;
0f113f3e
MC		 1952}
1953
1954/*
1955 * Now in theory, since the calling process own 't' it should be safe to
1956 * modify. We need to be able to read f without being hassled
1957 */
17dd65e6 1958int SSL_copy_session_id(SSL *t, const SSL *f)
0f113f3e 1959{
16203f7b 1960 int i;
38b051a1
TM		 1961 /* TODO(QUIC): Do we want to support this for QUIC connections? */
1962 SSL_CONNECTION *tsc = SSL_CONNECTION_FROM_SSL_ONLY(t);
1963 const SSL_CONNECTION *fsc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(f);
1964
1965 if (tsc == NULL || fsc == NULL)
1966 return 0;
1967
3e6a0d57 1968 /* Do we need to do SSL locking? */
61986d32 1969 if (!SSL_set_session(t, SSL_get_session(f))) {
17dd65e6 1970 return 0;
69f68237 1971 }
0f113f3e
MC		 1972
1973 /*
87d9cafa 1974 * what if we are setup for one protocol version but want to talk another
0f113f3e
MC		 1975 */
1976 if (t->method != f->method) {
38b051a1 1977 t->method->ssl_deinit(t);
919ba009 1978 t->method = f->method;
38b051a1 1979 if (t->method->ssl_init(t) == 0)
919ba009 1980 return 0;
0f113f3e
MC		 1981 }
1982
43a07d6d 1983 CRYPTO_UP_REF(&fsc->cert->references, &i);
38b051a1
TM		 1984 ssl_cert_free(tsc->cert);
1985 tsc->cert = fsc->cert;
1986 if (!SSL_set_session_id_context(t, fsc->sid_ctx, (int)fsc->sid_ctx_length)) {
17dd65e6 1987 return 0;
69f68237 1988 }
17dd65e6
MC		 1989
1990 return 1;
0f113f3e 1991}
d02b48c6 1992
58964a49 1993/* Fix this so it checks all the valid key/cert options */
0821bcd4 1994int SSL_CTX_check_private_key(const SSL_CTX *ctx)
0f113f3e 1995{
a230b26e 1996 if ((ctx == NULL) || (ctx->cert->key->x509 == NULL)) {
6849b73c 1997 ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED);
26a7d938 1998 return 0;
0f113f3e
MC		 1999 }
2000 if (ctx->cert->key->privatekey == NULL) {
6849b73c 2001 ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
26a7d938 2002 return 0;
0f113f3e 2003 }
26a7d938
K		 2004 return X509_check_private_key
2005 (ctx->cert->key->x509, ctx->cert->key->privatekey);
0f113f3e 2006}
d02b48c6 2007
58964a49 2008/* Fix this function so that it takes an optional type parameter */
0821bcd4 2009int SSL_check_private_key(const SSL *ssl)
0f113f3e 2010{
38b051a1
TM		 2011 const SSL_CONNECTION *sc;
2012
2013 if ((sc = SSL_CONNECTION_FROM_CONST_SSL(ssl)) == NULL) {
6849b73c 2014 ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
26a7d938 2015 return 0;
0f113f3e 2016 }
38b051a1 2017 if (sc->cert->key->x509 == NULL) {
6849b73c 2018 ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED);
26a7d938 2019 return 0;
0f113f3e 2020 }
38b051a1 2021 if (sc->cert->key->privatekey == NULL) {
6849b73c 2022 ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
26a7d938 2023 return 0;
0f113f3e 2024 }
38b051a1
TM		 2025 return X509_check_private_key(sc->cert->key->x509,
2026 sc->cert->key->privatekey);
0f113f3e 2027}
d02b48c6 2028
07bbc92c
MC		 2029int SSL_waiting_for_async(SSL *s)
2030{
38b051a1
TM		 2031 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
2032
2033 if (sc == NULL)
2034 return 0;
2035
2036 if (sc->job)
82676094
MC		 2037 return 1;
2038
07bbc92c
MC		 2039 return 0;
2040}
2041
ff75a257 2042int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds)
f4da39d2 2043{
38b051a1
TM		 2044 ASYNC_WAIT_CTX *ctx;
2045 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
ff75a257 2046
38b051a1
TM		 2047 if (sc == NULL)
2048 return 0;
2049
2050 if ((ctx = sc->waitctx) == NULL)
ff75a257
MC		 2051 return 0;
2052 return ASYNC_WAIT_CTX_get_all_fds(ctx, fds, numfds);
2053}
f4da39d2 2054
ff75a257
MC		 2055int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds,
2056 OSSL_ASYNC_FD *delfd, size_t *numdelfds)
2057{
38b051a1
TM		 2058 ASYNC_WAIT_CTX *ctx;
2059 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
ff75a257 2060
38b051a1
TM		 2061 if (sc == NULL)
2062 return 0;
2063
2064 if ((ctx = sc->waitctx) == NULL)
ff75a257
MC		 2065 return 0;
2066 return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd,
2067 numdelfds);
f4da39d2
MC		 2068}
2069
9f5a87fd
PY		 2070int SSL_CTX_set_async_callback(SSL_CTX *ctx, SSL_async_callback_fn callback)
2071{
2072 ctx->async_cb = callback;
2073 return 1;
2074}
2075
2076int SSL_CTX_set_async_callback_arg(SSL_CTX *ctx, void *arg)
2077{
2078 ctx->async_cb_arg = arg;
2079 return 1;
2080}
2081
2082int SSL_set_async_callback(SSL *s, SSL_async_callback_fn callback)
2083{
38b051a1
TM		 2084 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
2085
2086 if (sc == NULL)
2087 return 0;
2088
2089 sc->async_cb = callback;
9f5a87fd
PY		 2090 return 1;
2091}
2092
2093int SSL_set_async_callback_arg(SSL *s, void *arg)
2094{
38b051a1
TM		 2095 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
2096
2097 if (sc == NULL)
2098 return 0;
2099
2100 sc->async_cb_arg = arg;
9f5a87fd
PY		 2101 return 1;
2102}
2103
2104int SSL_get_async_status(SSL *s, int *status)
2105{
38b051a1
TM		 2106 ASYNC_WAIT_CTX *ctx;
2107 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
9f5a87fd 2108
38b051a1
TM		 2109 if (sc == NULL)
2110 return 0;
2111
2112 if ((ctx = sc->waitctx) == NULL)
9f5a87fd
PY		 2113 return 0;
2114 *status = ASYNC_WAIT_CTX_get_status(ctx);
2115 return 1;
2116}
2117
4f43d0e7 2118int SSL_accept(SSL *s)
0f113f3e 2119{
38b051a1 2120 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
03bacce8 2121
6d495cc4
HL		 2122#ifndef OPENSSL_NO_QUIC
2123 if (IS_QUIC(s))
03bacce8 2124 return s->method->ssl_accept(s);
6292519c 2125#endif
38b051a1
TM		 2126
2127 if (sc == NULL)
2128 return 0;
2129
2130 if (sc->handshake_func == NULL) {
0f113f3e
MC		 2131 /* Not properly initialized yet */
2132 SSL_set_accept_state(s);
07bbc92c 2133 }
add2f5ca
MC		 2134
2135 return SSL_do_handshake(s);
0f113f3e 2136}
d02b48c6 2137
4f43d0e7 2138int SSL_connect(SSL *s)
0f113f3e 2139{
38b051a1 2140 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
03bacce8 2141
6d495cc4
HL		 2142#ifndef OPENSSL_NO_QUIC
2143 if (IS_QUIC(s))
03bacce8 2144 return s->method->ssl_connect(s);
6292519c 2145#endif
38b051a1
TM		 2146
2147 if (sc == NULL)
2148 return 0;
2149
2150 if (sc->handshake_func == NULL) {
0f113f3e
MC		 2151 /* Not properly initialized yet */
2152 SSL_set_connect_state(s);
add2f5ca 2153 }
b31b04d9 2154
add2f5ca 2155 return SSL_do_handshake(s);
0f113f3e 2156}
d02b48c6 2157
0821bcd4 2158long SSL_get_default_timeout(const SSL *s)
0f113f3e 2159{
f0131dc0 2160 return (long int)ossl_time2seconds(s->method->get_timeout());
0f113f3e
MC		 2161}
2162
9f5a87fd
PY		 2163static int ssl_async_wait_ctx_cb(void *arg)
2164{
2165 SSL *s = (SSL *)arg;
38b051a1 2166 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
9f5a87fd 2167
38b051a1
TM		 2168 if (sc == NULL)
2169 return 0;
2170
2171 return sc->async_cb(s, sc->async_cb_arg);
9f5a87fd
PY		 2172}
2173
7fecbf6f 2174static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
a230b26e
EK		 2175 int (*func) (void *))
2176{
add2f5ca 2177 int ret;
38b051a1
TM		 2178 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
2179
2180 if (sc == NULL)
2181 return 0;
2182
2183 if (sc->waitctx == NULL) {
2184 sc->waitctx = ASYNC_WAIT_CTX_new();
2185 if (sc->waitctx == NULL)
ff75a257 2186 return -1;
38b051a1 2187 if (sc->async_cb != NULL
9f5a87fd 2188 && !ASYNC_WAIT_CTX_set_callback
38b051a1 2189 (sc->waitctx, ssl_async_wait_ctx_cb, s))
9f5a87fd 2190 return -1;
ff75a257 2191 }
07f620e3 2192
38b051a1
TM		 2193 sc->rwstate = SSL_NOTHING;
2194 switch (ASYNC_start_job(&sc->job, sc->waitctx, &ret, func, args,
a230b26e 2195 sizeof(struct ssl_async_args))) {
add2f5ca 2196 case ASYNC_ERR:
38b051a1 2197 sc->rwstate = SSL_NOTHING;
6849b73c 2198 ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_INIT_ASYNC);
add2f5ca
MC		 2199 return -1;
2200 case ASYNC_PAUSE:
38b051a1 2201 sc->rwstate = SSL_ASYNC_PAUSED;
add2f5ca 2202 return -1;
fc7f190c 2203 case ASYNC_NO_JOBS:
38b051a1 2204 sc->rwstate = SSL_ASYNC_NO_JOBS;
fc7f190c 2205 return -1;
add2f5ca 2206 case ASYNC_FINISH:
38b051a1 2207 sc->job = NULL;
add2f5ca
MC		 2208 return ret;
2209 default:
38b051a1 2210 sc->rwstate = SSL_NOTHING;
6849b73c 2211 ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
add2f5ca
MC		 2212 /* Shouldn't happen */
2213 return -1;
2214 }
2215}
07bbc92c 2216
add2f5ca 2217static int ssl_io_intern(void *vargs)
07bbc92c
MC		 2218{
2219 struct ssl_async_args *args;
2220 SSL *s;
2221 void *buf;
348240c6 2222 size_t num;
38b051a1 2223 SSL_CONNECTION *sc;
07bbc92c
MC		 2224
2225 args = (struct ssl_async_args *)vargs;
2226 s = args->s;
2227 buf = args->buf;
2228 num = args->num;
38b051a1
TM		 2229 if ((sc = SSL_CONNECTION_FROM_SSL(s)) == NULL)
2230 return -1;
2231
ec447924
MC		 2232 switch (args->type) {
2233 case READFUNC:
38b051a1 2234 return args->f.func_read(s, buf, num, &sc->asyncrw);
ec447924 2235 case WRITEFUNC:
38b051a1 2236 return args->f.func_write(s, buf, num, &sc->asyncrw);
ec447924
MC		 2237 case OTHERFUNC:
2238 return args->f.func_other(s);
2239 }
2240 return -1;
07bbc92c
MC		 2241}
2242
4ee7d3f9 2243int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes)
0f113f3e 2244{
38b051a1 2245 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
03bacce8 2246
6d495cc4
HL		 2247#ifndef OPENSSL_NO_QUIC
2248 if (IS_QUIC(s))
03bacce8 2249 return s->method->ssl_read(s, buf, num, readbytes);
6292519c 2250#endif
38b051a1
TM		 2251
2252 if (sc == NULL)
2253 return -1;
2254
2255 if (sc->handshake_func == NULL) {
6849b73c 2256 ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
0f113f3e
MC		 2257 return -1;
2258 }
2259
38b051a1
TM		 2260 if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) {
2261 sc->rwstate = SSL_NOTHING;
4ee7d3f9 2262 return 0;
0f113f3e 2263 }
07bbc92c 2264
38b051a1
TM		 2265 if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
2266 || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY) {
6849b73c 2267 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
0a5ece5b
MC		 2268 return 0;
2269 }
564547e4
MC		 2270 /*
2271 * If we are a client and haven't received the ServerHello etc then we
2272 * better do that
2273 */
38b051a1 2274 ossl_statem_check_finish_init(sc, 0);
0a5ece5b 2275
38b051a1 2276 if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
add2f5ca 2277 struct ssl_async_args args;
eda75751 2278 int ret;
add2f5ca
MC		 2279
2280 args.s = s;
2281 args.buf = buf;
2282 args.num = num;
ec447924
MC		 2283 args.type = READFUNC;
2284 args.f.func_read = s->method->ssl_read;
add2f5ca 2285
eda75751 2286 ret = ssl_start_async_job(s, &args, ssl_io_intern);
38b051a1 2287 *readbytes = sc->asyncrw;
eda75751 2288 return ret;
07bbc92c 2289 } else {
54105ddd 2290 return s->method->ssl_read(s, buf, num, readbytes);
07bbc92c 2291 }
0f113f3e
MC		 2292}
2293
4ee7d3f9 2294int SSL_read(SSL *s, void *buf, int num)
eda75751
MC		 2295{
2296 int ret;
54105ddd 2297 size_t readbytes;
eda75751
MC		 2298
2299 if (num < 0) {
6849b73c 2300 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH);
eda75751
MC		 2301 return -1;
2302 }
2303
4ee7d3f9 2304 ret = ssl_read_internal(s, buf, (size_t)num, &readbytes);
eda75751
MC		 2305
2306 /*
2307 * The cast is safe here because ret should be <= INT_MAX because num is
2308 * <= INT_MAX
2309 */
2310 if (ret > 0)
54105ddd 2311 ret = (int)readbytes;
eda75751
MC		 2312
2313 return ret;
2314}
2315
4ee7d3f9
KR		 2316int SSL_read_ex(SSL *s, void *buf, size_t num, size_t *readbytes)
2317{
2318 int ret = ssl_read_internal(s, buf, num, readbytes);
2319
2320 if (ret < 0)
2321 ret = 0;
2322 return ret;
2323}
2324
f533fbd4 2325int SSL_read_early_data(SSL *s, void *buf, size_t num, size_t *readbytes)
d781d247
MC		 2326{
2327 int ret;
38b051a1
TM		 2328 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
2329
2330 /* TODO(QUIC): This will need special handling for QUIC */
2331 if (sc == NULL)
2332 return 0;
d781d247 2333
38b051a1 2334 if (!sc->server) {
6849b73c 2335 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
f533fbd4 2336 return SSL_READ_EARLY_DATA_ERROR;
d781d247
MC		 2337 }
2338
38b051a1 2339 switch (sc->early_data_state) {
d781d247
MC		 2340 case SSL_EARLY_DATA_NONE:
2341 if (!SSL_in_before(s)) {
6849b73c 2342 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
f533fbd4 2343 return SSL_READ_EARLY_DATA_ERROR;
d781d247
MC		 2344 }
2345 /* fall through */
2346
2347 case SSL_EARLY_DATA_ACCEPT_RETRY:
38b051a1 2348 sc->early_data_state = SSL_EARLY_DATA_ACCEPTING;
d781d247
MC		 2349 ret = SSL_accept(s);
2350 if (ret <= 0) {
2351 /* NBIO or error */
38b051a1 2352 sc->early_data_state = SSL_EARLY_DATA_ACCEPT_RETRY;
f533fbd4 2353 return SSL_READ_EARLY_DATA_ERROR;
d781d247
MC		 2354 }
2355 /* fall through */
2356
2357 case SSL_EARLY_DATA_READ_RETRY:
38b051a1
TM		 2358 if (sc->ext.early_data == SSL_EARLY_DATA_ACCEPTED) {
2359 sc->early_data_state = SSL_EARLY_DATA_READING;
d781d247
MC		 2360 ret = SSL_read_ex(s, buf, num, readbytes);
2361 /*
ef6c191b
MC		 2362 * State machine will update early_data_state to
2363 * SSL_EARLY_DATA_FINISHED_READING if we get an EndOfEarlyData
2364 * message
d781d247 2365 */
38b051a1 2366 if (ret > 0 || (ret <= 0 && sc->early_data_state
d781d247 2367 != SSL_EARLY_DATA_FINISHED_READING)) {
38b051a1 2368 sc->early_data_state = SSL_EARLY_DATA_READ_RETRY;
f533fbd4
MC		 2369 return ret > 0 ? SSL_READ_EARLY_DATA_SUCCESS
2370 : SSL_READ_EARLY_DATA_ERROR;
d781d247
MC		 2371 }
2372 } else {
38b051a1 2373 sc->early_data_state = SSL_EARLY_DATA_FINISHED_READING;
d781d247
MC		 2374 }
2375 *readbytes = 0;
f533fbd4 2376 return SSL_READ_EARLY_DATA_FINISH;
d781d247
MC		 2377
2378 default:
6849b73c 2379 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
f533fbd4 2380 return SSL_READ_EARLY_DATA_ERROR;
d781d247
MC		 2381 }
2382}
2383
f5b519c4 2384int SSL_get_early_data_status(const SSL *s)
1ea4d09a 2385{
38b051a1
TM		 2386 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
2387
2388 /* TODO(QUIC): This will need special handling for QUIC */
2389 if (sc == NULL)
2390 return 0;
2391
2392 return sc->ext.early_data;
1ea4d09a
MC		 2393}
2394
4ee7d3f9 2395static int ssl_peek_internal(SSL *s, void *buf, size_t num, size_t *readbytes)
0f113f3e 2396{
38b051a1 2397 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
03bacce8 2398
6d495cc4
HL		 2399#ifndef OPENSSL_NO_QUIC
2400 if (IS_QUIC(s))
03bacce8 2401 return s->method->ssl_peek(s, buf, num, readbytes);
6292519c 2402#endif
38b051a1
TM		 2403
2404 if (sc == NULL)
2405 return 0;
2406
2407 if (sc->handshake_func == NULL) {
6849b73c 2408 ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
0f113f3e
MC		 2409 return -1;
2410 }
2411
38b051a1 2412 if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) {
4ee7d3f9 2413 return 0;
0f113f3e 2414 }
38b051a1 2415 if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
add2f5ca 2416 struct ssl_async_args args;
eda75751 2417 int ret;
0f113f3e 2418
add2f5ca
MC		 2419 args.s = s;
2420 args.buf = buf;
2421 args.num = num;
ec447924
MC		 2422 args.type = READFUNC;
2423 args.f.func_read = s->method->ssl_peek;
07bbc92c 2424
eda75751 2425 ret = ssl_start_async_job(s, &args, ssl_io_intern);
38b051a1 2426 *readbytes = sc->asyncrw;
eda75751 2427 return ret;
add2f5ca 2428 } else {
54105ddd 2429 return s->method->ssl_peek(s, buf, num, readbytes);
add2f5ca 2430 }
07bbc92c
MC		 2431}
2432
4ee7d3f9 2433int SSL_peek(SSL *s, void *buf, int num)
7ee8627f
MC		 2434{
2435 int ret;
4ee7d3f9 2436 size_t readbytes;
7ee8627f
MC		 2437
2438 if (num < 0) {
6849b73c 2439 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH);
7ee8627f
MC		 2440 return -1;
2441 }
2442
4ee7d3f9 2443 ret = ssl_peek_internal(s, buf, (size_t)num, &readbytes);
7ee8627f
MC		 2444
2445 /*
2446 * The cast is safe here because ret should be <= INT_MAX because num is
2447 * <= INT_MAX
2448 */
2449 if (ret > 0)
4ee7d3f9 2450 ret = (int)readbytes;
7ee8627f
MC		 2451
2452 return ret;
2453}
2454
4ee7d3f9
KR		 2455
2456int SSL_peek_ex(SSL *s, void *buf, size_t num, size_t *readbytes)
2457{
2458 int ret = ssl_peek_internal(s, buf, num, readbytes);
2459
2460 if (ret < 0)
2461 ret = 0;
2462 return ret;
2463}
2464
2465int ssl_write_internal(SSL *s, const void *buf, size_t num, size_t *written)
0f113f3e 2466{
38b051a1 2467 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
03bacce8 2468
6d495cc4
HL		 2469#ifndef OPENSSL_NO_QUIC
2470 if (IS_QUIC(s))
03bacce8 2471 return s->method->ssl_write(s, buf, num, written);
6292519c 2472#endif
38b051a1
TM		 2473
2474 if (sc == NULL)
2475 return 0;
2476
2477 if (sc->handshake_func == NULL) {
6849b73c 2478 ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
0f113f3e
MC		 2479 return -1;
2480 }
2481
38b051a1
TM		 2482 if (sc->shutdown & SSL_SENT_SHUTDOWN) {
2483 sc->rwstate = SSL_NOTHING;
6849b73c 2484 ERR_raise(ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
4ee7d3f9 2485 return -1;
0f113f3e 2486 }
07bbc92c 2487
38b051a1
TM		 2488 if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
2489 || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY
2490 || sc->early_data_state == SSL_EARLY_DATA_READ_RETRY) {
6849b73c 2491 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
49e7fe12 2492 return 0;
0a5ece5b 2493 }
564547e4 2494 /* If we are a client and haven't sent the Finished we better do that */
38b051a1 2495 ossl_statem_check_finish_init(sc, 1);
49e7fe12 2496
38b051a1 2497 if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
7ee8627f 2498 int ret;
add2f5ca
MC		 2499 struct ssl_async_args args;
2500
2501 args.s = s;
2502 args.buf = (void *)buf;
2503 args.num = num;
ec447924
MC		 2504 args.type = WRITEFUNC;
2505 args.f.func_write = s->method->ssl_write;
add2f5ca 2506
7ee8627f 2507 ret = ssl_start_async_job(s, &args, ssl_io_intern);
38b051a1 2508 *written = sc->asyncrw;
7ee8627f 2509 return ret;
07bbc92c 2510 } else {
7ee8627f 2511 return s->method->ssl_write(s, buf, num, written);
07bbc92c 2512 }
0f113f3e 2513}
d02b48c6 2514
7c3a7561
BP		 2515ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size, int flags)
2516{
2517 ossl_ssize_t ret;
38b051a1 2518 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
7c3a7561 2519
38b051a1
TM		 2520 if (sc == NULL)
2521 return 0;
2522
2523 if (sc->handshake_func == NULL) {
6849b73c 2524 ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
7c3a7561
BP		 2525 return -1;
2526 }
2527
38b051a1
TM		 2528 if (sc->shutdown & SSL_SENT_SHUTDOWN) {
2529 sc->rwstate = SSL_NOTHING;
6849b73c 2530 ERR_raise(ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN);
7c3a7561
BP		 2531 return -1;
2532 }
2533
38b051a1 2534 if (!BIO_get_ktls_send(sc->wbio)) {
6849b73c 2535 ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
7c3a7561
BP		 2536 return -1;
2537 }
2538
2539 /* If we have an alert to send, lets send it */
73243502 2540 if (sc->s3.alert_dispatch > 0) {
7c3a7561
BP		 2541 ret = (ossl_ssize_t)s->method->ssl_dispatch_alert(s);
2542 if (ret <= 0) {
2543 /* SSLfatal() already called if appropriate */
2544 return ret;
2545 }
2546 /* if it went, fall through and send more stuff */
2547 }
2548
38b051a1
TM		 2549 sc->rwstate = SSL_WRITING;
2550 if (BIO_flush(sc->wbio) <= 0) {
2551 if (!BIO_should_retry(sc->wbio)) {
2552 sc->rwstate = SSL_NOTHING;
7c3a7561
BP		 2553 } else {
2554#ifdef EAGAIN
2555 set_sys_error(EAGAIN);
2556#endif
2557 }
2558 return -1;
2559 }
2560
712c0942 2561#ifdef OPENSSL_NO_KTLS
fa7a8074
RL		 2562 ERR_raise_data(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR,
2563 "can't call ktls_sendfile(), ktls disabled");
712c0942 2564 return -1;
7c3a7561 2565#else
712c0942 2566 ret = ktls_sendfile(SSL_get_wfd(s), fd, offset, size, flags);
7c3a7561
BP		 2567 if (ret < 0) {
2568#if defined(EAGAIN) && defined(EINTR) && defined(EBUSY)
2569 if ((get_last_sys_error() == EAGAIN) ||
2570 (get_last_sys_error() == EINTR) ||
2571 (get_last_sys_error() == EBUSY))
38b051a1 2572 BIO_set_retry_write(sc->wbio);
7c3a7561
BP		 2573 else
2574#endif
6849b73c 2575 ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
7c3a7561
BP		 2576 return ret;
2577 }
38b051a1 2578 sc->rwstate = SSL_NOTHING;
7c3a7561 2579 return ret;
712c0942 2580#endif
7c3a7561
BP		 2581}
2582
4ee7d3f9
KR		 2583int SSL_write(SSL *s, const void *buf, int num)
2584{
2585 int ret;
2586 size_t written;
2587
2588 if (num < 0) {
6849b73c 2589 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH);
4ee7d3f9
KR		 2590 return -1;
2591 }
2592
2593 ret = ssl_write_internal(s, buf, (size_t)num, &written);
2594
2595 /*
2596 * The cast is safe here because ret should be <= INT_MAX because num is
2597 * <= INT_MAX
2598 */
2599 if (ret > 0)
2600 ret = (int)written;
2601
2602 return ret;
2603}
2604
2605int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written)
2606{
2607 int ret = ssl_write_internal(s, buf, num, written);
2608
2609 if (ret < 0)
2610 ret = 0;
2611 return ret;
2612}
2613
0665b4ed 2614int SSL_write_early_data(SSL *s, const void *buf, size_t num, size_t *written)
49e7fe12 2615{
a0cb628b 2616 int ret, early_data_state;
2a8db717 2617 size_t writtmp;
f7414b08 2618 uint32_t partialwrite;
38b051a1
TM		 2619 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
2620
2621 /* TODO(QUIC): This will need special handling for QUIC */
2622 if (sc == NULL)
2623 return 0;
49e7fe12 2624
38b051a1 2625 switch (sc->early_data_state) {
49e7fe12 2626 case SSL_EARLY_DATA_NONE:
38b051a1 2627 if (sc->server
09f28874 2628 || !SSL_in_before(s)
38b051a1
TM		 2629 || ((sc->session == NULL || sc->session->ext.max_early_data == 0)
2630 && (sc->psk_use_session_cb == NULL))) {
6849b73c 2631 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
49e7fe12
MC		 2632 return 0;
2633 }
2634 /* fall through */
2635
2636 case SSL_EARLY_DATA_CONNECT_RETRY:
38b051a1 2637 sc->early_data_state = SSL_EARLY_DATA_CONNECTING;
49e7fe12
MC		 2638 ret = SSL_connect(s);
2639 if (ret <= 0) {
2640 /* NBIO or error */
38b051a1 2641 sc->early_data_state = SSL_EARLY_DATA_CONNECT_RETRY;
49e7fe12
MC		 2642 return 0;
2643 }
2644 /* fall through */
2645
2646 case SSL_EARLY_DATA_WRITE_RETRY:
38b051a1 2647 sc->early_data_state = SSL_EARLY_DATA_WRITING;
f7414b08
MC		 2648 /*
2649 * We disable partial write for early data because we don't keep track
2650 * of how many bytes we've written between the SSL_write_ex() call and
2651 * the flush if the flush needs to be retried)
2652 */
38b051a1
TM		 2653 partialwrite = sc->mode & SSL_MODE_ENABLE_PARTIAL_WRITE;
2654 sc->mode &= ~SSL_MODE_ENABLE_PARTIAL_WRITE;
2a8db717 2655 ret = SSL_write_ex(s, buf, num, &writtmp);
38b051a1 2656 sc->mode |= partialwrite;
2a8db717 2657 if (!ret) {
38b051a1 2658 sc->early_data_state = SSL_EARLY_DATA_WRITE_RETRY;
2a8db717
MC		 2659 return ret;
2660 }
38b051a1 2661 sc->early_data_state = SSL_EARLY_DATA_WRITE_FLUSH;
2a8db717
MC		 2662 /* fall through */
2663
2664 case SSL_EARLY_DATA_WRITE_FLUSH:
2665 /* The buffering BIO is still in place so we need to flush it */
38b051a1 2666 if (statem_flush(sc) != 1)
2a8db717 2667 return 0;
2a8db717 2668 *written = num;
38b051a1 2669 sc->early_data_state = SSL_EARLY_DATA_WRITE_RETRY;
2a8db717 2670 return 1;
49e7fe12 2671
116d0da5 2672 case SSL_EARLY_DATA_FINISHED_READING:
a0cb628b 2673 case SSL_EARLY_DATA_READ_RETRY:
38b051a1 2674 early_data_state = sc->early_data_state;
09f28874 2675 /* We are a server writing to an unauthenticated client */
38b051a1 2676 sc->early_data_state = SSL_EARLY_DATA_UNAUTH_WRITING;
09f28874 2677 ret = SSL_write_ex(s, buf, num, written);
5fe37157
MC		 2678 /* The buffering BIO is still in place */
2679 if (ret)
38b051a1
TM		 2680 (void)BIO_flush(sc->wbio);
2681 sc->early_data_state = early_data_state;
09f28874
MC		 2682 return ret;
2683
49e7fe12 2684 default:
6849b73c 2685 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
49e7fe12
MC		 2686 return 0;
2687 }
2688}
2689
4f43d0e7 2690int SSL_shutdown(SSL *s)
0f113f3e
MC		 2691{
2692 /*
2693 * Note that this function behaves differently from what one might
2694 * expect. Return values are 0 for no success (yet), 1 for success; but
2695 * calling it once is usually not enough, even if blocking I/O is used
2696 * (see ssl3_shutdown).
2697 */
38b051a1 2698 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
e8043229 2699
22b1a96f
HL		 2700#ifndef OPENSSL_NO_QUIC
2701 if (IS_QUIC(s))
6d495cc4 2702 return ossl_quic_conn_shutdown(s, 0, NULL, 0);
e8043229 2703#endif
0f113f3e 2704
38b051a1
TM		 2705 if (sc == NULL)
2706 return -1;
2707
2708 if (sc->handshake_func == NULL) {
6849b73c 2709 ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED);
0f113f3e
MC		 2710 return -1;
2711 }
2712
64f9f406 2713 if (!SSL_in_init(s)) {
38b051a1 2714 if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
64f9f406 2715 struct ssl_async_args args;
ec447924 2716
09134f18 2717 memset(&args, 0, sizeof(args));
64f9f406
MC		 2718 args.s = s;
2719 args.type = OTHERFUNC;
2720 args.f.func_other = s->method->ssl_shutdown;
ec447924 2721
64f9f406
MC		 2722 return ssl_start_async_job(s, &args, ssl_io_intern);
2723 } else {
2724 return s->method->ssl_shutdown(s);
2725 }
ec447924 2726 } else {
6849b73c 2727 ERR_raise(ERR_LIB_SSL, SSL_R_SHUTDOWN_WHILE_IN_INIT);
64f9f406 2728 return -1;
ec447924 2729 }
0f113f3e 2730}
d02b48c6 2731
4fbfe86a 2732int SSL_key_update(SSL *s, int updatetype)
44c04a2e 2733{
38b051a1
TM		 2734 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
2735
2525109f
HL		 2736#ifndef OPENSSL_NO_QUIC
2737 if (IS_QUIC(s))
2738 return ossl_quic_key_update(s, updatetype);
2739#endif
2740
38b051a1
TM		 2741 if (sc == NULL)
2742 return 0;
2743
2744 if (!SSL_CONNECTION_IS_TLS13(sc)) {
6849b73c 2745 ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION);
44c04a2e
MC		 2746 return 0;
2747 }
2748
2749 if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED
2750 && updatetype != SSL_KEY_UPDATE_REQUESTED) {
6849b73c 2751 ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_KEY_UPDATE_TYPE);
44c04a2e
MC		 2752 return 0;
2753 }
2754
2755 if (!SSL_is_init_finished(s)) {
6849b73c 2756 ERR_raise(ERR_LIB_SSL, SSL_R_STILL_IN_INIT);
44c04a2e
MC		 2757 return 0;
2758 }
2759
38b051a1 2760 if (RECORD_LAYER_write_pending(&sc->rlayer)) {
3bec4851
MC		 2761 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_WRITE_RETRY);
2762 return 0;
2763 }
2764
38b051a1
TM		 2765 ossl_statem_set_in_init(sc, 1);
2766 sc->key_update = updatetype;
44c04a2e
MC		 2767 return 1;
2768}
2769
3499327b 2770int SSL_get_key_update_type(const SSL *s)
53d1d07d 2771{
38b051a1
TM		 2772 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
2773
2525109f
HL		 2774#ifndef OPENSSL_NO_QUIC
2775 if (IS_QUIC(s))
2776 return ossl_quic_get_key_update_type(s);
2777#endif
2778
38b051a1
TM		 2779 if (sc == NULL)
2780 return 0;
2781
2782 return sc->key_update;
53d1d07d
MC		 2783}
2784
55373bfd
RS		 2785/*
2786 * Can we accept a renegotiation request? If yes, set the flag and
2787 * return 1 if yes. If not, raise error and return 0.
2788 */
38b051a1 2789static int can_renegotiate(const SSL_CONNECTION *sc)
0f113f3e 2790{
38b051a1 2791 if (SSL_CONNECTION_IS_TLS13(sc)) {
6849b73c 2792 ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION);
2c0980d2 2793 return 0;
44c04a2e 2794 }
cda6b998 2795
38b051a1 2796 if ((sc->options & SSL_OP_NO_RENEGOTIATION) != 0) {
6849b73c 2797 ERR_raise(ERR_LIB_SSL, SSL_R_NO_RENEGOTIATION);
db0f35dd
TS		 2798 return 0;
2799 }
44959ee4 2800
55373bfd
RS		 2801 return 1;
2802}
2803
2804int SSL_renegotiate(SSL *s)
2805{
38b051a1
TM		 2806 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
2807
2808 if (sc == NULL)
55373bfd
RS		 2809 return 0;
2810
38b051a1
TM		 2811 if (!can_renegotiate(sc))
2812 return 0;
2813
2814 sc->renegotiate = 1;
2815 sc->new_session = 1;
26a7d938 2816 return s->method->ssl_renegotiate(s);
0f113f3e 2817}
d02b48c6 2818
44959ee4 2819int SSL_renegotiate_abbreviated(SSL *s)
0f113f3e 2820{
38b051a1
TM		 2821 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
2822
2823 if (sc == NULL)
2824 return 0;
2825
2826 if (!can_renegotiate(sc))
2c0980d2 2827 return 0;
c519e89f 2828
38b051a1
TM		 2829 sc->renegotiate = 1;
2830 sc->new_session = 0;
26a7d938 2831 return s->method->ssl_renegotiate(s);
0f113f3e 2832}
44959ee4 2833
3499327b 2834int SSL_renegotiate_pending(const SSL *s)
0f113f3e 2835{
38b051a1
TM		 2836 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
2837
2838 if (sc == NULL)
2839 return 0;
2840
0f113f3e
MC		 2841 /*
2842 * becomes true when negotiation is requested; false again once a
2843 * handshake has finished
2844 */
38b051a1 2845 return (sc->renegotiate != 0);
0f113f3e
MC		 2846}
2847
3bfacb5f
BK		 2848int SSL_new_session_ticket(SSL *s)
2849{
38b051a1
TM		 2850 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
2851
2852 if (sc == NULL)
2853 return 0;
2854
7c73fefe 2855 /* If we are in init because we're sending tickets, okay to send more. */
38b051a1
TM		 2856 if ((SSL_in_init(s) && sc->ext.extra_tickets_expected == 0)
2857 || SSL_IS_FIRST_HANDSHAKE(sc) || !sc->server
2858 || !SSL_CONNECTION_IS_TLS13(sc))
35774d55 2859 return 0;
38b051a1
TM		 2860 sc->ext.extra_tickets_expected++;
2861 if (!RECORD_LAYER_write_pending(&sc->rlayer) && !SSL_in_init(s))
2862 ossl_statem_set_in_init(sc, 1);
35774d55 2863 return 1;
3bfacb5f
BK		 2864}
2865
0f113f3e
MC		 2866long SSL_ctrl(SSL *s, int cmd, long larg, void *parg)
2867{
2868 long l;
38b051a1
TM		 2869 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
2870
2871 /* TODO(QUIC): Special handling for some ctrls will be needed */
2872 if (sc == NULL)
2873 return 0;
0f113f3e
MC		 2874
2875 switch (cmd) {
2876 case SSL_CTRL_GET_READ_AHEAD:
38b051a1 2877 return RECORD_LAYER_get_read_ahead(&sc->rlayer);
0f113f3e 2878 case SSL_CTRL_SET_READ_AHEAD:
38b051a1
TM		 2879 l = RECORD_LAYER_get_read_ahead(&sc->rlayer);
2880 RECORD_LAYER_set_read_ahead(&sc->rlayer, larg);
26a7d938 2881 return l;
0f113f3e 2882
0f113f3e 2883 case SSL_CTRL_MODE:
4566dae7
MC		 2884 {
2885 OSSL_PARAM options[2], *opts = options;
2886
2887 sc->mode |= larg;
2888
2889 *opts++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE,
2890 &sc->mode);
2891 *opts = OSSL_PARAM_construct_end();
2892
2893 /* Ignore return value */
2894 sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options);
2895
2896 return sc->mode;
2897 }
0f113f3e 2898 case SSL_CTRL_CLEAR_MODE:
38b051a1 2899 return (sc->mode &= ~larg);
0f113f3e 2900 case SSL_CTRL_GET_MAX_CERT_LIST:
38b051a1 2901 return (long)sc->max_cert_list;
0f113f3e 2902 case SSL_CTRL_SET_MAX_CERT_LIST:
348240c6
MC		 2903 if (larg < 0)
2904 return 0;
38b051a1
TM		 2905 l = (long)sc->max_cert_list;
2906 sc->max_cert_list = (size_t)larg;
348240c6 2907 return l;
0f113f3e
MC		 2908 case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
2909 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
2910 return 0;
50ec7505 2911#ifndef OPENSSL_NO_KTLS
38b051a1 2912 if (sc->wbio != NULL && BIO_get_ktls_send(sc->wbio))
50ec7505
BP		 2913 return 0;
2914#endif /* OPENSSL_NO_KTLS */
38b051a1
TM		 2915 sc->max_send_fragment = larg;
2916 if (sc->max_send_fragment < sc->split_send_fragment)
2917 sc->split_send_fragment = sc->max_send_fragment;
435d88d7 2918 sc->rlayer.wrlmethod->set_max_frag_len(sc->rlayer.wrl, larg);
d102d9df
MC		 2919 return 1;
2920 case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
38b051a1 2921 if ((size_t)larg > sc->max_send_fragment || larg == 0)
d102d9df 2922 return 0;
38b051a1 2923 sc->split_send_fragment = larg;
0f113f3e 2924 return 1;
d102d9df
MC		 2925 case SSL_CTRL_SET_MAX_PIPELINES:
2926 if (larg < 1 || larg > SSL_MAX_PIPELINES)
2927 return 0;
38b051a1 2928 sc->max_pipelines = larg;
cffafb5f
MC		 2929 if (sc->rlayer.rrlmethod->set_max_pipelines != NULL)
2930 sc->rlayer.rrlmethod->set_max_pipelines(sc->rlayer.rrl, (size_t)larg);
07077415 2931 return 1;
0f113f3e 2932 case SSL_CTRL_GET_RI_SUPPORT:
38b051a1 2933 return sc->s3.send_connection_binding;
dfb39f73 2934 case SSL_CTRL_SET_RETRY_VERIFY:
38b051a1 2935 sc->rwstate = SSL_RETRY_VERIFY;
dfb39f73 2936 return 1;
0f113f3e 2937 case SSL_CTRL_CERT_FLAGS:
38b051a1 2938 return (sc->cert->cert_flags |= larg);
0f113f3e 2939 case SSL_CTRL_CLEAR_CERT_FLAGS:
38b051a1 2940 return (sc->cert->cert_flags &= ~larg);
0f113f3e
MC		 2941
2942 case SSL_CTRL_GET_RAW_CIPHERLIST:
2943 if (parg) {
38b051a1 2944 if (sc->s3.tmp.ciphers_raw == NULL)
0f113f3e 2945 return 0;
38b051a1
TM		 2946 *(unsigned char **)parg = sc->s3.tmp.ciphers_raw;
2947 return (int)sc->s3.tmp.ciphers_rawlen;
e9fa092e
EK		 2948 } else {
2949 return TLS_CIPHER_LEN;
2950 }
c5364614 2951 case SSL_CTRL_GET_EXTMS_SUPPORT:
38b051a1 2952 if (!sc->session || SSL_in_init(s) || ossl_statem_get_in_handshake(sc))
a230b26e 2953 return -1;
38b051a1 2954 if (sc->session->flags & SSL_SESS_FLAG_EXTMS)
c5364614
DSH		 2955 return 1;
2956 else
2957 return 0;
7946ab33 2958 case SSL_CTRL_SET_MIN_PROTO_VERSION:
38b051a1 2959 return ssl_check_allowed_versions(larg, sc->max_proto_version)
a7f41885 2960 && ssl_set_version_bound(s->defltmeth->version, (int)larg,
38b051a1 2961 &sc->min_proto_version);
3edabd3c 2962 case SSL_CTRL_GET_MIN_PROTO_VERSION:
38b051a1 2963 return sc->min_proto_version;
7946ab33 2964 case SSL_CTRL_SET_MAX_PROTO_VERSION:
38b051a1 2965 return ssl_check_allowed_versions(sc->min_proto_version, larg)
a7f41885 2966 && ssl_set_version_bound(s->defltmeth->version, (int)larg,
38b051a1 2967 &sc->max_proto_version);
3edabd3c 2968 case SSL_CTRL_GET_MAX_PROTO_VERSION:
38b051a1 2969 return sc->max_proto_version;
0f113f3e 2970 default:
26a7d938 2971 return s->method->ssl_ctrl(s, cmd, larg, parg);
0f113f3e
MC		 2972 }
2973}
2974
2975long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
2976{
63dfde87 2977 return s->method->ssl_callback_ctrl(s, cmd, fp);
0f113f3e 2978}
d3442bc7 2979
3c1d6bbc 2980LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
0f113f3e
MC		 2981{
2982 return ctx->sessions;
2983}
2984
acce0557
P		 2985static int ssl_tsan_load(SSL_CTX *ctx, TSAN_QUALIFIER int *stat)
2986{
2987 int res = 0;
2988
2989 if (ssl_tsan_lock(ctx)) {
2990 res = tsan_load(stat);
2991 ssl_tsan_unlock(ctx);
2992 }
2993 return res;
2994}
2995
0f113f3e
MC		 2996long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
2997{
2998 long l;
2999 /* For some cases with ctx == NULL perform syntax checks */
3000 if (ctx == NULL) {
3001 switch (cmd) {
de4d764e 3002 case SSL_CTRL_SET_GROUPS_LIST:
260009d8 3003 return tls1_set_groups_list(ctx, NULL, NULL, parg);
0f113f3e
MC		 3004 case SSL_CTRL_SET_SIGALGS_LIST:
3005 case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
3006 return tls1_set_sigalgs_list(NULL, parg, 0);
3007 default:
3008 return 0;
3009 }
3010 }
3011
3012 switch (cmd) {
3013 case SSL_CTRL_GET_READ_AHEAD:
26a7d938 3014 return ctx->read_ahead;
0f113f3e
MC		 3015 case SSL_CTRL_SET_READ_AHEAD:
3016 l = ctx->read_ahead;
3017 ctx->read_ahead = larg;
26a7d938 3018 return l;
0f113f3e
MC		 3019
3020 case SSL_CTRL_SET_MSG_CALLBACK_ARG:
3021 ctx->msg_callback_arg = parg;
3022 return 1;
3023
3024 case SSL_CTRL_GET_MAX_CERT_LIST:
26a7d938 3025 return (long)ctx->max_cert_list;
0f113f3e 3026 case SSL_CTRL_SET_MAX_CERT_LIST:
348240c6
MC		 3027 if (larg < 0)
3028 return 0;
3029 l = (long)ctx->max_cert_list;
3030 ctx->max_cert_list = (size_t)larg;
3031 return l;
0f113f3e
MC		 3032
3033 case SSL_CTRL_SET_SESS_CACHE_SIZE:
348240c6
MC		 3034 if (larg < 0)
3035 return 0;
3036 l = (long)ctx->session_cache_size;
3037 ctx->session_cache_size = (size_t)larg;
3038 return l;
0f113f3e 3039 case SSL_CTRL_GET_SESS_CACHE_SIZE:
26a7d938 3040 return (long)ctx->session_cache_size;
0f113f3e
MC		 3041 case SSL_CTRL_SET_SESS_CACHE_MODE:
3042 l = ctx->session_cache_mode;
3043 ctx->session_cache_mode = larg;
26a7d938 3044 return l;
0f113f3e 3045 case SSL_CTRL_GET_SESS_CACHE_MODE:
26a7d938 3046 return ctx->session_cache_mode;
0f113f3e
MC		 3047
3048 case SSL_CTRL_SESS_NUMBER:
26a7d938 3049 return lh_SSL_SESSION_num_items(ctx->sessions);
0f113f3e 3050 case SSL_CTRL_SESS_CONNECT:
acce0557 3051 return ssl_tsan_load(ctx, &ctx->stats.sess_connect);
0f113f3e 3052 case SSL_CTRL_SESS_CONNECT_GOOD:
acce0557 3053 return ssl_tsan_load(ctx, &ctx->stats.sess_connect_good);
0f113f3e 3054 case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
acce0557 3055 return ssl_tsan_load(ctx, &ctx->stats.sess_connect_renegotiate);
0f113f3e 3056 case SSL_CTRL_SESS_ACCEPT:
acce0557 3057 return ssl_tsan_load(ctx, &ctx->stats.sess_accept);
0f113f3e 3058 case SSL_CTRL_SESS_ACCEPT_GOOD:
acce0557 3059 return ssl_tsan_load(ctx, &ctx->stats.sess_accept_good);
0f113f3e 3060 case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
acce0557 3061 return ssl_tsan_load(ctx, &ctx->stats.sess_accept_renegotiate);
0f113f3e 3062 case SSL_CTRL_SESS_HIT:
acce0557 3063 return ssl_tsan_load(ctx, &ctx->stats.sess_hit);
0f113f3e 3064 case SSL_CTRL_SESS_CB_HIT:
acce0557 3065 return ssl_tsan_load(ctx, &ctx->stats.sess_cb_hit);
0f113f3e 3066 case SSL_CTRL_SESS_MISSES:
acce0557 3067 return ssl_tsan_load(ctx, &ctx->stats.sess_miss);
0f113f3e 3068 case SSL_CTRL_SESS_TIMEOUTS:
acce0557 3069 return ssl_tsan_load(ctx, &ctx->stats.sess_timeout);
0f113f3e 3070 case SSL_CTRL_SESS_CACHE_FULL:
acce0557 3071 return ssl_tsan_load(ctx, &ctx->stats.sess_cache_full);
0f113f3e
MC		 3072 case SSL_CTRL_MODE:
3073 return (ctx->mode |= larg);
3074 case SSL_CTRL_CLEAR_MODE:
3075 return (ctx->mode &= ~larg);
3076 case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
3077 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
3078 return 0;
3079 ctx->max_send_fragment = larg;
d102d9df 3080 if (ctx->max_send_fragment < ctx->split_send_fragment)
bfb155c1 3081 ctx->split_send_fragment = ctx->max_send_fragment;
0f113f3e 3082 return 1;
d102d9df 3083 case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT:
7ee8627f 3084 if ((size_t)larg > ctx->max_send_fragment || larg == 0)
d102d9df
MC		 3085 return 0;
3086 ctx->split_send_fragment = larg;
3087 return 1;
3088 case SSL_CTRL_SET_MAX_PIPELINES:
3089 if (larg < 1 || larg > SSL_MAX_PIPELINES)
3090 return 0;
3091 ctx->max_pipelines = larg;
07077415 3092 return 1;
0f113f3e
MC		 3093 case SSL_CTRL_CERT_FLAGS:
3094 return (ctx->cert->cert_flags |= larg);
3095 case SSL_CTRL_CLEAR_CERT_FLAGS:
3096 return (ctx->cert->cert_flags &= ~larg);
7946ab33 3097 case SSL_CTRL_SET_MIN_PROTO_VERSION:
c8feba72
BK		 3098 return ssl_check_allowed_versions(larg, ctx->max_proto_version)
3099 && ssl_set_version_bound(ctx->method->version, (int)larg,
3100 &ctx->min_proto_version);
3edabd3c
CH		 3101 case SSL_CTRL_GET_MIN_PROTO_VERSION:
3102 return ctx->min_proto_version;
7946ab33 3103 case SSL_CTRL_SET_MAX_PROTO_VERSION:
c8feba72
BK		 3104 return ssl_check_allowed_versions(ctx->min_proto_version, larg)
3105 && ssl_set_version_bound(ctx->method->version, (int)larg,
3106 &ctx->max_proto_version);
3edabd3c
CH		 3107 case SSL_CTRL_GET_MAX_PROTO_VERSION:
3108 return ctx->max_proto_version;
0f113f3e 3109 default:
26a7d938 3110 return ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg);
0f113f3e
MC		 3111 }
3112}
3113
3114long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
3115{
3116 switch (cmd) {
3117 case SSL_CTRL_SET_MSG_CALLBACK:
3118 ctx->msg_callback = (void (*)
3119 (int write_p, int version, int content_type,
3120 const void *buf, size_t len, SSL *ssl,
3121 void *arg))(fp);
3122 return 1;
3123
3124 default:
26a7d938 3125 return ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp);
0f113f3e
MC		 3126 }
3127}
d3442bc7 3128
ccd86b68 3129int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
0f113f3e 3130{
90d9e49a
DSH		 3131 if (a->id > b->id)
3132 return 1;
3133 if (a->id < b->id)
3134 return -1;
3135 return 0;
0f113f3e
MC		 3136}
3137
3138int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
3139 const SSL_CIPHER *const *bp)
3140{
90d9e49a
DSH		 3141 if ((*ap)->id > (*bp)->id)
3142 return 1;
3143 if ((*ap)->id < (*bp)->id)
3144 return -1;
3145 return 0;
0f113f3e 3146}
d02b48c6 3147
38b051a1
TM		 3148/*
3149 * return a STACK of the ciphers available for the SSL and in order of
3150 * preference
3151 */
0821bcd4 3152STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
0f113f3e 3153{
38b051a1
TM		 3154 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
3155
3156 if (sc != NULL) {
3157 if (sc->cipher_list != NULL) {
3158 return sc->cipher_list;
0f113f3e 3159 } else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) {
26a7d938 3160 return s->ctx->cipher_list;
0f113f3e
MC		 3161 }
3162 }
26a7d938 3163 return NULL;
0f113f3e
MC		 3164}
3165
831eef2c
NM		 3166STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s)
3167{
38b051a1
TM		 3168 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
3169
3170 if (sc == NULL || !sc->server)
831eef2c 3171 return NULL;
38b051a1 3172 return sc->peer_ciphers;
831eef2c
NM		 3173}
3174
8b8e5bed 3175STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s)
0f113f3e
MC		 3176{
3177 STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers;
3178 int i;
38b051a1
TM		 3179 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
3180
3181 if (sc == NULL)
3182 return NULL;
1d0c08b4 3183
0f113f3e
MC		 3184 ciphers = SSL_get_ciphers(s);
3185 if (!ciphers)
3186 return NULL;
38b051a1 3187 if (!ssl_set_client_disabled(sc))
1d0c08b4 3188 return NULL;
0f113f3e
MC		 3189 for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
3190 const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
38b051a1 3191 if (!ssl_cipher_disabled(sc, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) {
0f113f3e
MC		 3192 if (!sk)
3193 sk = sk_SSL_CIPHER_new_null();
3194 if (!sk)
3195 return NULL;
3196 if (!sk_SSL_CIPHER_push(sk, c)) {
3197 sk_SSL_CIPHER_free(sk);
3198 return NULL;
3199 }
3200 }
3201 }
3202 return sk;
3203}
8b8e5bed 3204
4f43d0e7 3205/** return a STACK of the ciphers available for the SSL and in order of
d02b48c6 3206 * algorithm id */
38b051a1 3207STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL_CONNECTION *s)
0f113f3e
MC		 3208{
3209 if (s != NULL) {
38b051a1 3210 if (s->cipher_list_by_id != NULL)
26a7d938 3211 return s->cipher_list_by_id;
38b051a1
TM		 3212 else if (s->ssl.ctx != NULL
3213 && s->ssl.ctx->cipher_list_by_id != NULL)
3214 return s->ssl.ctx->cipher_list_by_id;
0f113f3e 3215 }
26a7d938 3216 return NULL;
0f113f3e 3217}
d02b48c6 3218
4f43d0e7 3219/** The old interface to get the same thing as SSL_get_ciphers() */
0f113f3e
MC		 3220const char *SSL_get_cipher_list(const SSL *s, int n)
3221{
4a640fb6 3222 const SSL_CIPHER *c;
0f113f3e
MC		 3223 STACK_OF(SSL_CIPHER) *sk;
3224
3225 if (s == NULL)
26a7d938 3226 return NULL;
0f113f3e
MC		 3227 sk = SSL_get_ciphers(s);
3228 if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
26a7d938 3229 return NULL;
0f113f3e
MC		 3230 c = sk_SSL_CIPHER_value(sk, n);
3231 if (c == NULL)
26a7d938
K		 3232 return NULL;
3233 return c->name;
0f113f3e 3234}
d02b48c6 3235
9d5ac953
KY		 3236/** return a STACK of the ciphers available for the SSL_CTX and in order of
3237 * preference */
3238STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx)
3239{
3240 if (ctx != NULL)
3241 return ctx->cipher_list;
3242 return NULL;
3243}
3244
3c83c5ba
SR		 3245/*
3246 * Distinguish between ciphers controlled by set_ciphersuite() and
3247 * set_cipher_list() when counting.
3248 */
3249static int cipher_list_tls12_num(STACK_OF(SSL_CIPHER) *sk)
3250{
3251 int i, num = 0;
3252 const SSL_CIPHER *c;
3253
3254 if (sk == NULL)
3255 return 0;
3256 for (i = 0; i < sk_SSL_CIPHER_num(sk); ++i) {
3257 c = sk_SSL_CIPHER_value(sk, i);
3258 if (c->min_tls >= TLS1_3_VERSION)
3259 continue;
3260 num++;
3261 }
3262 return num;
3263}
3264
25f923dd 3265/** specify the ciphers to be used by default by the SSL_CTX */
018e57c7 3266int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
0f113f3e
MC		 3267{
3268 STACK_OF(SSL_CIPHER) *sk;
3269
a68eee67 3270 sk = ssl_create_cipher_list(ctx, ctx->tls13_ciphersuites,
f865b081
MC		 3271 &ctx->cipher_list, &ctx->cipher_list_by_id, str,
3272 ctx->cert);
0f113f3e
MC		 3273 /*
3274 * ssl_create_cipher_list may return an empty stack if it was unable to
3275 * find a cipher matching the given rule string (for example if the rule
3276 * string specifies a cipher which has been disabled). This is not an
3277 * error as far as ssl_create_cipher_list is concerned, and hence
3278 * ctx->cipher_list and ctx->cipher_list_by_id has been updated.
3279 */
3280 if (sk == NULL)
3281 return 0;
3c83c5ba 3282 else if (cipher_list_tls12_num(sk) == 0) {
6849b73c 3283 ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH);
0f113f3e
MC		 3284 return 0;
3285 }
3286 return 1;
3287}
d02b48c6 3288
4f43d0e7 3289/** specify the ciphers to be used by the SSL */
0f113f3e
MC		 3290int SSL_set_cipher_list(SSL *s, const char *str)
3291{
3292 STACK_OF(SSL_CIPHER) *sk;
38b051a1 3293 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
0f113f3e 3294
38b051a1
TM		 3295 if (sc == NULL)
3296 return 0;
3297
3298 sk = ssl_create_cipher_list(s->ctx, sc->tls13_ciphersuites,
3299 &sc->cipher_list, &sc->cipher_list_by_id, str,
3300 sc->cert);
0f113f3e
MC		 3301 /* see comment in SSL_CTX_set_cipher_list */
3302 if (sk == NULL)
3303 return 0;
3c83c5ba 3304 else if (cipher_list_tls12_num(sk) == 0) {
6849b73c 3305 ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH);
0f113f3e
MC		 3306 return 0;
3307 }
3308 return 1;
3309}
d02b48c6 3310
a216df59 3311char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size)
0f113f3e
MC		 3312{
3313 char *p;
a216df59 3314 STACK_OF(SSL_CIPHER) *clntsk, *srvrsk;
4a640fb6 3315 const SSL_CIPHER *c;
0f113f3e 3316 int i;
38b051a1
TM		 3317 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
3318
3319 if (sc == NULL)
3320 return NULL;
0f113f3e 3321
38b051a1
TM		 3322 if (!sc->server
3323 || sc->peer_ciphers == NULL
a216df59 3324 || size < 2)
26a7d938 3325 return NULL;
0f113f3e
MC		 3326
3327 p = buf;
38b051a1 3328 clntsk = sc->peer_ciphers;
a216df59
MC		 3329 srvrsk = SSL_get_ciphers(s);
3330 if (clntsk == NULL || srvrsk == NULL)
3331 return NULL;
0f113f3e 3332
a216df59 3333 if (sk_SSL_CIPHER_num(clntsk) == 0 || sk_SSL_CIPHER_num(srvrsk) == 0)
0f113f3e
MC		 3334 return NULL;
3335
a216df59 3336 for (i = 0; i < sk_SSL_CIPHER_num(clntsk); i++) {
0f113f3e
MC		 3337 int n;
3338
a216df59
MC		 3339 c = sk_SSL_CIPHER_value(clntsk, i);
3340 if (sk_SSL_CIPHER_find(srvrsk, c) < 0)
3341 continue;
3342
0f113f3e 3343 n = strlen(c->name);
a216df59 3344 if (n + 1 > size) {
0f113f3e
MC		 3345 if (p != buf)
3346 --p;
3347 *p = '\0';
3348 return buf;
3349 }
4cacc9d5 3350 strcpy(p, c->name);
0f113f3e
MC		 3351 p += n;
3352 *(p++) = ':';
a216df59 3353 size -= n + 1;
0f113f3e
MC		 3354 }
3355 p[-1] = '\0';
26a7d938 3356 return buf;
0f113f3e
MC		 3357}
3358
7955c1f1
MC		 3359/**
3360 * Return the requested servername (SNI) value. Note that the behaviour varies
3361 * depending on:
3362 * - whether this is called by the client or the server,
3363 * - if we are before or during/after the handshake,
3364 * - if a resumption or normal handshake is being attempted/has occurred
3365 * - whether we have negotiated TLSv1.2 (or below) or TLSv1.3
38b051a1 3366 *
7955c1f1 3367 * Note that only the host_name type is defined (RFC 3546).
ed3883d2 3368 */
f1fd4544 3369const char *SSL_get_servername(const SSL *s, const int type)
0f113f3e 3370{
38b051a1
TM		 3371 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
3372 int server;
3373
3374 if (sc == NULL)
3375 return NULL;
3376
7955c1f1
MC		 3377 /*
3378 * If we don't know if we are the client or the server yet then we assume
3379 * client.
3380 */
38b051a1
TM		 3381 server = sc->handshake_func == NULL ? 0 : sc->server;
3382
0f113f3e
MC		 3383 if (type != TLSEXT_NAMETYPE_host_name)
3384 return NULL;
a13c20f6 3385
7955c1f1
MC		 3386 if (server) {
3387 /**
3388 * Server side
3389 * In TLSv1.3 on the server SNI is not associated with the session
3390 * but in TLSv1.2 or below it is.
3391 *
3392 * Before the handshake:
3393 * - return NULL
3394 *
3395 * During/after the handshake (TLSv1.2 or below resumption occurred):
3396 * - If a servername was accepted by the server in the original
3397 * handshake then it will return that servername, or NULL otherwise.
3398 *
3399 * During/after the handshake (TLSv1.2 or below resumption did not occur):
3400 * - The function will return the servername requested by the client in
3401 * this handshake or NULL if none was requested.
3402 */
38b051a1
TM		 3403 if (sc->hit && !SSL_CONNECTION_IS_TLS13(sc))
3404 return sc->session->ext.hostname;
7955c1f1
MC		 3405 } else {
3406 /**
3407 * Client side
3408 *
3409 * Before the handshake:
3410 * - If a servername has been set via a call to
3411 * SSL_set_tlsext_host_name() then it will return that servername
3412 * - If one has not been set, but a TLSv1.2 resumption is being
3413 * attempted and the session from the original handshake had a
3414 * servername accepted by the server then it will return that
3415 * servername
3416 * - Otherwise it returns NULL
3417 *
3418 * During/after the handshake (TLSv1.2 or below resumption occurred):
9f7505ab 3419 * - If the session from the original handshake had a servername accepted
7955c1f1
MC		 3420 * by the server then it will return that servername.
3421 * - Otherwise it returns the servername set via
3422 * SSL_set_tlsext_host_name() (or NULL if it was not called).
3423 *
3424 * During/after the handshake (TLSv1.2 or below resumption did not occur):
3425 * - It will return the servername set via SSL_set_tlsext_host_name()
3426 * (or NULL if it was not called).
3427 */
3428 if (SSL_in_before(s)) {
38b051a1
TM		 3429 if (sc->ext.hostname == NULL
3430 && sc->session != NULL
3431 && sc->session->ssl_version != TLS1_3_VERSION)
3432 return sc->session->ext.hostname;
7955c1f1 3433 } else {
38b051a1
TM		 3434 if (!SSL_CONNECTION_IS_TLS13(sc) && sc->hit
3435 && sc->session->ext.hostname != NULL)
3436 return sc->session->ext.hostname;
7955c1f1
MC		 3437 }
3438 }
3439
38b051a1 3440 return sc->ext.hostname;
0f113f3e 3441}
ed3883d2 3442
f1fd4544 3443int SSL_get_servername_type(const SSL *s)
0f113f3e 3444{
7955c1f1 3445 if (SSL_get_servername(s, TLSEXT_NAMETYPE_host_name) != NULL)
0f113f3e
MC		 3446 return TLSEXT_NAMETYPE_host_name;
3447 return -1;
3448}
ee2ffc27 3449
0f113f3e
MC		 3450/*
3451 * SSL_select_next_proto implements the standard protocol selection. It is
ee2ffc27 3452 * expected that this function is called from the callback set by
0f113f3e
MC		 3453 * SSL_CTX_set_next_proto_select_cb. The protocol data is assumed to be a
3454 * vector of 8-bit, length prefixed byte strings. The length byte itself is
3455 * not included in the length. A byte string of length 0 is invalid. No byte
3456 * string may be truncated. The current, but experimental algorithm for
3457 * selecting the protocol is: 1) If the server doesn't support NPN then this
3458 * is indicated to the callback. In this case, the client application has to
3459 * abort the connection or have a default application level protocol. 2) If
3460 * the server supports NPN, but advertises an empty list then the client
f430ba31 3461 * selects the first protocol in its list, but indicates via the API that this
0f113f3e
MC		 3462 * fallback case was enacted. 3) Otherwise, the client finds the first
3463 * protocol in the server's list that it supports and selects this protocol.
3464 * This is because it's assumed that the server has better information about
3465 * which protocol a client should use. 4) If the client doesn't support any
3466 * of the server's advertised protocols, then this is treated the same as
3467 * case 2. It returns either OPENSSL_NPN_NEGOTIATED if a common protocol was
3468 * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
ee2ffc27 3469 */
0f113f3e
MC		 3470int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
3471 const unsigned char *server,
3472 unsigned int server_len,
a230b26e 3473 const unsigned char *client, unsigned int client_len)
0f113f3e
MC		 3474{
3475 unsigned int i, j;
3476 const unsigned char *result;
3477 int status = OPENSSL_NPN_UNSUPPORTED;
3478
3479 /*
3480 * For each protocol in server preference order, see if we support it.
3481 */
3482 for (i = 0; i < server_len;) {
3483 for (j = 0; j < client_len;) {
3484 if (server[i] == client[j] &&
3485 memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) {
3486 /* We found a match */
3487 result = &server[i];
3488 status = OPENSSL_NPN_NEGOTIATED;
3489 goto found;
3490 }
3491 j += client[j];
3492 j++;
3493 }
3494 i += server[i];
3495 i++;
3496 }
3497
3498 /* There's no overlap between our protocols and the server's list. */
3499 result = client;
3500 status = OPENSSL_NPN_NO_OVERLAP;
3501
3502 found:
3503 *out = (unsigned char *)result + 1;
3504 *outlen = result[0];
3505 return status;
3506}
ee2ffc27 3507
e481f9b9 3508#ifndef OPENSSL_NO_NEXTPROTONEG
0f113f3e
MC		 3509/*
3510 * SSL_get0_next_proto_negotiated sets *data and *len to point to the
3511 * client's requested protocol for this connection and returns 0. If the
3512 * client didn't request any protocol, then *data is set to NULL. Note that
3513 * the client can request any protocol it chooses. The value returned from
3514 * this function need not be a member of the list of supported protocols
ee2ffc27
BL		 3515 * provided by the callback.
3516 */
0f113f3e
MC		 3517void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
3518 unsigned *len)
3519{
38b051a1
TM		 3520 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
3521
3522 if (sc == NULL) {
3523 /* We have no other way to indicate error */
3524 *data = NULL;
3525 *len = 0;
3526 return;
3527 }
3528
3529 *data = sc->ext.npn;
12a765a5 3530 if (*data == NULL) {
0f113f3e
MC		 3531 *len = 0;
3532 } else {
38b051a1 3533 *len = (unsigned int)sc->ext.npn_len;
0f113f3e
MC		 3534 }
3535}
3536
3537/*
aff8c126 3538 * SSL_CTX_set_npn_advertised_cb sets a callback that is called when
0f113f3e
MC		 3539 * a TLS server needs a list of supported protocols for Next Protocol
3540 * Negotiation. The returned list must be in wire format. The list is
3541 * returned by setting |out| to point to it and |outlen| to its length. This
3542 * memory will not be modified, but one should assume that the SSL* keeps a
3543 * reference to it. The callback should return SSL_TLSEXT_ERR_OK if it
3544 * wishes to advertise. Otherwise, no such extension will be included in the
3545 * ServerHello.
3546 */
aff8c126 3547void SSL_CTX_set_npn_advertised_cb(SSL_CTX *ctx,
8cbfcc70 3548 SSL_CTX_npn_advertised_cb_func cb,
aff8c126 3549 void *arg)
0f113f3e 3550{
68dbff4c
HL		 3551 if (IS_QUIC_CTX(ctx))
3552 /* NPN not allowed for QUIC */
3553 return;
3554
aff8c126
RS		 3555 ctx->ext.npn_advertised_cb = cb;
3556 ctx->ext.npn_advertised_cb_arg = arg;
0f113f3e
MC		 3557}
3558
3559/*
3560 * SSL_CTX_set_next_proto_select_cb sets a callback that is called when a
ee2ffc27
BL		 3561 * client needs to select a protocol from the server's provided list. |out|
3562 * must be set to point to the selected protocol (which may be within |in|).
0f113f3e
MC		 3563 * The length of the protocol name must be written into |outlen|. The
3564 * server's advertised protocols are provided in |in| and |inlen|. The
3565 * callback can assume that |in| is syntactically valid. The client must
3566 * select a protocol. It is fatal to the connection if this callback returns
3567 * a value other than SSL_TLSEXT_ERR_OK.
ee2ffc27 3568 */
aff8c126 3569void SSL_CTX_set_npn_select_cb(SSL_CTX *ctx,
8cbfcc70 3570 SSL_CTX_npn_select_cb_func cb,
aff8c126 3571 void *arg)
0f113f3e 3572{
68dbff4c
HL		 3573 if (IS_QUIC_CTX(ctx))
3574 /* NPN not allowed for QUIC */
3575 return;
3576
aff8c126
RS		 3577 ctx->ext.npn_select_cb = cb;
3578 ctx->ext.npn_select_cb_arg = arg;
0f113f3e 3579}
e481f9b9 3580#endif
a398f821 3581
feba11cf
TS		 3582static int alpn_value_ok(const unsigned char *protos, unsigned int protos_len)
3583{
3584 unsigned int idx;
3585
3586 if (protos_len < 2 || protos == NULL)
3587 return 0;
3588
3589 for (idx = 0; idx < protos_len; idx += protos[idx] + 1) {
3590 if (protos[idx] == 0)
3591 return 0;
3592 }
3593 return idx == protos_len;
3594}
0f113f3e
MC		 3595/*
3596 * SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|.
6f017a8f 3597 * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
0f113f3e
MC		 3598 * length-prefixed strings). Returns 0 on success.
3599 */
3600int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
817cd0d5 3601 unsigned int protos_len)
0f113f3e 3602{
feba11cf
TS		 3603 unsigned char *alpn;
3604
3605 if (protos_len == 0 || protos == NULL) {
3606 OPENSSL_free(ctx->ext.alpn);
3607 ctx->ext.alpn = NULL;
39a14059 3608 ctx->ext.alpn_len = 0;
feba11cf
TS		 3609 return 0;
3610 }
3611 /* Not valid per RFC */
3612 if (!alpn_value_ok(protos, protos_len))
3613 return 1;
3614
3615 alpn = OPENSSL_memdup(protos, protos_len);
e077455e 3616 if (alpn == NULL)
0f113f3e 3617 return 1;
feba11cf
TS		 3618 OPENSSL_free(ctx->ext.alpn);
3619 ctx->ext.alpn = alpn;
aff8c126 3620 ctx->ext.alpn_len = protos_len;
0f113f3e
MC		 3621
3622 return 0;
3623}
3624
3625/*
3626 * SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|.
6f017a8f 3627 * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit
0f113f3e
MC		 3628 * length-prefixed strings). Returns 0 on success.
3629 */
3630int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
817cd0d5 3631 unsigned int protos_len)
0f113f3e 3632{
feba11cf 3633 unsigned char *alpn;
38b051a1
TM		 3634 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
3635
3636 if (sc == NULL)
3637 return 1;
feba11cf
TS		 3638
3639 if (protos_len == 0 || protos == NULL) {
38b051a1
TM		 3640 OPENSSL_free(sc->ext.alpn);
3641 sc->ext.alpn = NULL;
3642 sc->ext.alpn_len = 0;
feba11cf
TS		 3643 return 0;
3644 }
3645 /* Not valid per RFC */
3646 if (!alpn_value_ok(protos, protos_len))
3647 return 1;
3648
3649 alpn = OPENSSL_memdup(protos, protos_len);
e077455e 3650 if (alpn == NULL)
0f113f3e 3651 return 1;
38b051a1
TM		 3652 OPENSSL_free(sc->ext.alpn);
3653 sc->ext.alpn = alpn;
3654 sc->ext.alpn_len = protos_len;
0f113f3e
MC		 3655
3656 return 0;
3657}
3658
3659/*
3660 * SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is
3661 * called during ClientHello processing in order to select an ALPN protocol
3662 * from the client's list of offered protocols.
3663 */
3664void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
8cbfcc70
RS		 3665 SSL_CTX_alpn_select_cb_func cb,
3666 void *arg)
0f113f3e 3667{
aff8c126
RS		 3668 ctx->ext.alpn_select_cb = cb;
3669 ctx->ext.alpn_select_cb_arg = arg;
0f113f3e
MC		 3670}
3671
3672/*
69687aa8
F		 3673 * SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from |ssl|.
3674 * On return it sets |*data| to point to |*len| bytes of protocol name
0f113f3e
MC		 3675 * (not including the leading length-prefix byte). If the server didn't
3676 * respond with a negotiated protocol then |*len| will be zero.
3677 */
6f017a8f 3678void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
817cd0d5 3679 unsigned int *len)
0f113f3e 3680{
38b051a1
TM		 3681 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
3682
3683 if (sc == NULL) {
3684 /* We have no other way to indicate error */
3685 *data = NULL;
3686 *len = 0;
3687 return;
3688 }
3689
3690 *data = sc->s3.alpn_selected;
0f113f3e
MC		 3691 if (*data == NULL)
3692 *len = 0;
3693 else
38b051a1 3694 *len = (unsigned int)sc->s3.alpn_selected_len;
0f113f3e
MC		 3695}
3696
74b4b494 3697int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
0f113f3e 3698 const char *label, size_t llen,
23cec1f4 3699 const unsigned char *context, size_t contextlen,
0f113f3e
MC		 3700 int use_context)
3701{
38b051a1
TM		 3702 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
3703
3704 if (sc == NULL)
3705 return -1;
3706
3707 if (sc->session == NULL
3708 || (sc->version < TLS1_VERSION && sc->version != DTLS1_BAD_VER))
0f113f3e 3709 return -1;
e0af0405 3710
38b051a1 3711 return s->method->ssl3_enc->export_keying_material(sc, out, olen, label,
23cec1f4
MC		 3712 llen, context,
3713 contextlen, use_context);
0f113f3e 3714}
e0af0405 3715
b38ede80
TT		 3716int SSL_export_keying_material_early(SSL *s, unsigned char *out, size_t olen,
3717 const char *label, size_t llen,
3718 const unsigned char *context,
3719 size_t contextlen)
3720{
38b051a1
TM		 3721 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
3722
3723 if (sc == NULL)
3724 return -1;
3725
3726 if (sc->version != TLS1_3_VERSION)
b38ede80
TT		 3727 return 0;
3728
38b051a1 3729 return tls13_export_keying_material_early(sc, out, olen, label, llen,
b38ede80
TT		 3730 context, contextlen);
3731}
3732
3c1d6bbc 3733static unsigned long ssl_session_hash(const SSL_SESSION *a)
0f113f3e 3734{
bd5d27c1 3735 const unsigned char *session_id = a->session_id;
0f113f3e 3736 unsigned long l;
bd5d27c1
DB		 3737 unsigned char tmp_storage[4];
3738
3739 if (a->session_id_length < sizeof(tmp_storage)) {
3740 memset(tmp_storage, 0, sizeof(tmp_storage));
3741 memcpy(tmp_storage, a->session_id, a->session_id_length);
3742 session_id = tmp_storage;
3743 }
0f113f3e
MC		 3744
3745 l = (unsigned long)
bd5d27c1
DB		 3746 ((unsigned long)session_id[0]) |
3747 ((unsigned long)session_id[1] << 8L) |
3748 ((unsigned long)session_id[2] << 16L) |
3749 ((unsigned long)session_id[3] << 24L);
26a7d938 3750 return l;
0f113f3e
MC		 3751}
3752
3753/*
3754 * NB: If this function (or indeed the hash function which uses a sort of
dc644fe2 3755 * coarser function than this one) is changed, ensure
0f113f3e
MC		 3756 * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on
3757 * being able to construct an SSL_SESSION that will collide with any existing
3758 * session with a matching session ID.
3759 */
3760static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b)
3761{
3762 if (a->ssl_version != b->ssl_version)
208fb891 3763 return 1;
0f113f3e 3764 if (a->session_id_length != b->session_id_length)
208fb891 3765 return 1;
26a7d938 3766 return memcmp(a->session_id, b->session_id, a->session_id_length);
0f113f3e
MC		 3767}
3768
3769/*
3770 * These wrapper functions should remain rather than redeclaring
d0fa136c 3771 * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
0f113f3e
MC		 3772 * variable. The reason is that the functions aren't static, they're exposed
3773 * via ssl.h.
3774 */
97b17195 3775
b4250010 3776SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
d8652be0 3777 const SSL_METHOD *meth)
0f113f3e
MC		 3778{
3779 SSL_CTX *ret = NULL;
b67cb09f
TS		 3780#ifndef OPENSSL_NO_COMP_ALG
3781 int i;
3782#endif
0f113f3e
MC		 3783
3784 if (meth == NULL) {
6849b73c 3785 ERR_raise(ERR_LIB_SSL, SSL_R_NULL_SSL_METHOD_PASSED);
26a7d938 3786 return NULL;
0f113f3e
MC		 3787 }
3788
0fc32b07
MC		 3789 if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL))
3790 return NULL;
7fa792d1 3791
97beb77f 3792 /* Doing this for the run once effect */
0f113f3e 3793 if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) {
6849b73c 3794 ERR_raise(ERR_LIB_SSL, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
0f113f3e
MC		 3795 goto err;
3796 }
43a07d6d 3797
b51bce94 3798 ret = OPENSSL_zalloc(sizeof(*ret));
0f113f3e 3799 if (ret == NULL)
97beb77f 3800 return NULL;
0f113f3e 3801
045a8930 3802 /* Init the reference counting before any call to SSL_CTX_free */
97beb77f
P		 3803 if (!CRYPTO_NEW_REF(&ret->references, 1)) {
3804 OPENSSL_free(ret);
3805 return NULL;
3806 }
43a07d6d 3807
045a8930
F		 3808 ret->lock = CRYPTO_THREAD_lock_new();
3809 if (ret->lock == NULL) {
e077455e
RL		 3810 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
3811 goto err;
045a8930
F		 3812 }
3813
acce0557
P		 3814#ifdef TSAN_REQUIRES_LOCKING
3815 ret->tsan_lock = CRYPTO_THREAD_lock_new();
3816 if (ret->tsan_lock == NULL) {
e077455e 3817 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
acce0557
P		 3818 goto err;
3819 }
3820#endif
3821
ba18627e
MC		 3822 ret->libctx = libctx;
3823 if (propq != NULL) {
3824 ret->propq = OPENSSL_strdup(propq);
3825 if (ret->propq == NULL)
3826 goto err;
3827 }
3828
0f113f3e 3829 ret->method = meth;
7946ab33
KR		 3830 ret->min_proto_version = 0;
3831 ret->max_proto_version = 0;
693cf80c 3832 ret->mode = SSL_MODE_AUTO_RETRY;
0f113f3e
MC		 3833 ret->session_cache_mode = SSL_SESS_CACHE_SERVER;
3834 ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
64b25758 3835 /* We take the system default. */
0f113f3e 3836 ret->session_timeout = meth->get_timeout();
0f113f3e 3837 ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT;
0f113f3e 3838 ret->verify_mode = SSL_VERIFY_NONE;
0f113f3e 3839
62d0577e 3840 ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp);
e077455e
RL		 3841 if (ret->sessions == NULL) {
3842 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
0f113f3e 3843 goto err;
e077455e 3844 }
0f113f3e 3845 ret->cert_store = X509_STORE_new();
e077455e
RL		 3846 if (ret->cert_store == NULL) {
3847 ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
0f113f3e 3848 goto err;
e077455e 3849 }
ed29e82a 3850#ifndef OPENSSL_NO_CT
d8652be0 3851 ret->ctlog_store = CTLOG_STORE_new_ex(libctx, propq);
e077455e
RL		 3852 if (ret->ctlog_store == NULL) {
3853 ERR_raise(ERR_LIB_SSL, ERR_R_CT_LIB);
ed29e82a 3854 goto err;
e077455e 3855 }
ed29e82a 3856#endif
f865b081 3857
c8f6c28a 3858 /* initialize cipher/digest methods table */
ee58915c
MB		 3859 if (!ssl_load_ciphers(ret)) {
3860 ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
e077455e 3861 goto err;
ee58915c
MB		 3862 }
3863
3864 if (!ssl_load_groups(ret)) {
3865 ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
3866 goto err;
3867 }
3868
3869 /* load provider sigalgs */
3870 if (!ssl_load_sigalgs(ret)) {
3871 ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
e077455e 3872 goto err;
ee58915c 3873 }
c8f6c28a 3874
ee58915c
MB		 3875 /* initialise sig algs */
3876 if (!ssl_setup_sigalgs(ret)) {
3877 ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
e077455e 3878 goto err;
ee58915c 3879 }
9d2d857f 3880
e077455e
RL		 3881 if (!SSL_CTX_set_ciphersuites(ret, OSSL_default_ciphersuites())) {
3882 ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
f865b081 3883 goto err;
e077455e 3884 }
f865b081 3885
ee58915c
MB		 3886 if ((ret->cert = ssl_cert_new(SSL_PKEY_NUM + ret->sigalg_list_len)) == NULL) {
3887 ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
3888 goto err;
3889 }
3890
a68eee67 3891 if (!ssl_create_cipher_list(ret,
f865b081 3892 ret->tls13_ciphersuites,
a230b26e 3893 &ret->cipher_list, &ret->cipher_list_by_id,
5d120511 3894 OSSL_default_cipher_list(), ret->cert)
a230b26e 3895 || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
6849b73c 3896 ERR_raise(ERR_LIB_SSL, SSL_R_LIBRARY_HAS_NO_CIPHERS);
e077455e 3897 goto err;
0f113f3e
MC		 3898 }
3899
3900 ret->param = X509_VERIFY_PARAM_new();
e077455e
RL		 3901 if (ret->param == NULL) {
3902 ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB);
0f113f3e 3903 goto err;
e077455e 3904 }
0f113f3e 3905
c8f6c28a
MC		 3906 /*
3907 * If these aren't available from the provider we'll get NULL returns.
3908 * That's fine but will cause errors later if SSLv3 is negotiated
3909 */
3910 ret->md5 = ssl_evp_md_fetch(libctx, NID_md5, propq);
3911 ret->sha1 = ssl_evp_md_fetch(libctx, NID_sha1, propq);
0f113f3e 3912
e077455e
RL		 3913 if ((ret->ca_names = sk_X509_NAME_new_null()) == NULL) {
3914 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
0f113f3e 3915 goto err;
e077455e 3916 }
0f113f3e 3917
e077455e
RL		 3918 if ((ret->client_ca_names = sk_X509_NAME_new_null()) == NULL) {
3919 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
98732979 3920 goto err;
e077455e 3921 }
98732979 3922
e077455e
RL		 3923 if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data)) {
3924 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
25a807bc 3925 goto err;
e077455e 3926 }
0f113f3e 3927
4bfb96f2
TS		 3928 if ((ret->ext.secure = OPENSSL_secure_zalloc(sizeof(*ret->ext.secure))) == NULL)
3929 goto err;
3930
0f113f3e
MC		 3931 /* No compression for DTLS */
3932 if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS))
3933 ret->comp_methods = SSL_COMP_get_compression_methods();
3934
3935 ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
d102d9df 3936 ret->split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
566dda07 3937
4e2e1ec9 3938 /* Setup RFC5077 ticket keys */
8f21260b 3939 if ((RAND_bytes_ex(libctx, ret->ext.tick_key_name,
0f8815aa 3940 sizeof(ret->ext.tick_key_name), 0) <= 0)
8f21260b 3941 || (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_hmac_key,
0f8815aa 3942 sizeof(ret->ext.secure->tick_hmac_key), 0) <= 0)
8f21260b 3943 || (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_aes_key,
0f8815aa 3944 sizeof(ret->ext.secure->tick_aes_key), 0) <= 0))
0f113f3e 3945 ret->options |= SSL_OP_NO_TICKET;
6434abbf 3946
8f21260b 3947 if (RAND_priv_bytes_ex(libctx, ret->ext.cookie_hmac_key,
e077455e
RL		 3948 sizeof(ret->ext.cookie_hmac_key), 0) <= 0) {
3949 ERR_raise(ERR_LIB_SSL, ERR_R_RAND_LIB);
43054d3d 3950 goto err;
e077455e 3951 }
43054d3d 3952
edc032b5 3953#ifndef OPENSSL_NO_SRP
e077455e
RL		 3954 if (!ssl_ctx_srp_ctx_init_intern(ret)) {
3955 ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
69f68237 3956 goto err;
e077455e 3957 }
edc032b5 3958#endif
4db9677b 3959#ifndef OPENSSL_NO_ENGINE
0f113f3e
MC		 3960# ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
3961# define eng_strx(x) #x
3962# define eng_str(x) eng_strx(x)
3963 /* Use specific client engine automatically... ignore errors */
3964 {
3965 ENGINE *eng;
3966 eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
3967 if (!eng) {
3968 ERR_clear_error();
3969 ENGINE_load_builtin_engines();
3970 eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
3971 }
3972 if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
3973 ERR_clear_error();
3974 }
3975# endif
b67cb09f
TS		 3976#endif
3977
3978#ifndef OPENSSL_NO_COMP_ALG
3979 /*
3980 * Set the default order: brotli, zlib, zstd
3981 * Including only those enabled algorithms
3982 */
3983 memset(ret->cert_comp_prefs, 0, sizeof(ret->cert_comp_prefs));
3984 i = 0;
3985 if (ossl_comp_has_alg(TLSEXT_comp_cert_brotli))
3986 ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_brotli;
3987 if (ossl_comp_has_alg(TLSEXT_comp_cert_zlib))
3988 ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_zlib;
3989 if (ossl_comp_has_alg(TLSEXT_comp_cert_zstd))
3990 ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_zstd;
0f113f3e 3991#endif
dc5744cb
EK		 3992 /*
3993 * Disable compression by default to prevent CRIME. Applications can
3994 * re-enable compression by configuring
3995 * SSL_CTX_clear_options(ctx, SSL_OP_NO_COMPRESSION);
a5816a5a
MC		 3996 * or by using the SSL_CONF library. Similarly we also enable TLSv1.3
3997 * middlebox compatibility by default. This may be disabled by default in
3998 * a later OpenSSL version.
dc5744cb 3999 */
a5816a5a 4000 ret->options |= SSL_OP_NO_COMPRESSION | SSL_OP_ENABLE_MIDDLEBOX_COMPAT;
0f113f3e 4001
aff8c126 4002 ret->ext.status_type = TLSEXT_STATUSTYPE_nothing;
ba261f71 4003
bfa9a9af 4004 /*
c39e4048
BK		 4005 * We cannot usefully set a default max_early_data here (which gets
4006 * propagated in SSL_new(), for the following reason: setting the
4007 * SSL field causes tls_construct_stoc_early_data() to tell the
4008 * client that early data will be accepted when constructing a TLS 1.3
4009 * session ticket, and the client will accordingly send us early data
4010 * when using that ticket (if the client has early data to send).
4011 * However, in order for the early data to actually be consumed by
4012 * the application, the application must also have calls to
4013 * SSL_read_early_data(); otherwise we'll just skip past the early data
4014 * and ignore it. So, since the application must add calls to
4015 * SSL_read_early_data(), we also require them to add
4016 * calls to SSL_CTX_set_max_early_data() in order to use early data,
4017 * eliminating the bandwidth-wasting early data in the case described
4018 * above.
bfa9a9af 4019 */
c39e4048 4020 ret->max_early_data = 0;
bfa9a9af 4021
4e8548e8
MC		 4022 /*
4023 * Default recv_max_early_data is a fully loaded single record. Could be
4024 * split across multiple records in practice. We set this differently to
4025 * max_early_data so that, in the default case, we do not advertise any
4026 * support for early_data, but if a client were to send us some (e.g.
4027 * because of an old, stale ticket) then we will tolerate it and skip over
4028 * it.
4029 */
4030 ret->recv_max_early_data = SSL3_RT_MAX_PLAIN_LENGTH;
4031
36ff232c
MC		 4032 /* By default we send two session tickets automatically in TLSv1.3 */
4033 ret->num_tickets = 2;
9d0a8bb7 4034
8a5ed9dc
TM		 4035 ssl_ctx_system_config(ret);
4036
16203f7b 4037 return ret;
0f113f3e 4038 err:
e0e920b1 4039 SSL_CTX_free(ret);
16203f7b 4040 return NULL;
0f113f3e 4041}
d02b48c6 4042
ba18627e
MC		 4043SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
4044{
d8652be0 4045 return SSL_CTX_new_ex(NULL, NULL, meth);
ba18627e
MC		 4046}
4047
c5ebfcab 4048int SSL_CTX_up_ref(SSL_CTX *ctx)
a18a31e4 4049{
16203f7b 4050 int i;
c5ebfcab 4051
43a07d6d 4052 if (CRYPTO_UP_REF(&ctx->references, &i) <= 0)
c5ebfcab
F		 4053 return 0;
4054
4055 REF_PRINT_COUNT("SSL_CTX", ctx);
4056 REF_ASSERT_ISNT(i < 2);
4057 return ((i > 1) ? 1 : 0);
a18a31e4
MC		 4058}
4059
4f43d0e7 4060void SSL_CTX_free(SSL_CTX *a)
0f113f3e
MC		 4061{
4062 int i;
9d2d857f 4063 size_t j;
d02b48c6 4064
0f113f3e
MC		 4065 if (a == NULL)
4066 return;
d02b48c6 4067
43a07d6d 4068 CRYPTO_DOWN_REF(&a->references, &i);
f3f1cf84 4069 REF_PRINT_COUNT("SSL_CTX", a);
0f113f3e
MC		 4070 if (i > 0)
4071 return;
f3f1cf84 4072 REF_ASSERT_ISNT(i < 0);
0f113f3e 4073
222561fe 4074 X509_VERIFY_PARAM_free(a->param);
919ba009 4075 dane_ctx_final(&a->dane);
0f113f3e
MC		 4076
4077 /*
4078 * Free internal session cache. However: the remove_cb() may reference
4079 * the ex_data of SSL_CTX, thus the ex_data store can only be removed
4080 * after the sessions were flushed.
4081 * As the ex_data handling routines might also touch the session cache,
4082 * the most secure solution seems to be: empty (flush) the cache, then
4083 * free ex_data, then finally free the cache.
4084 * (See ticket [openssl.org #212].)
4085 */
4086 if (a->sessions != NULL)
4087 SSL_CTX_flush_sessions(a, 0);
4088
4089 CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
25aaa98a 4090 lh_SSL_SESSION_free(a->sessions);
222561fe 4091 X509_STORE_free(a->cert_store);
ed29e82a
RP		 4092#ifndef OPENSSL_NO_CT
4093 CTLOG_STORE_free(a->ctlog_store);
4094#endif
25aaa98a
RS		 4095 sk_SSL_CIPHER_free(a->cipher_list);
4096 sk_SSL_CIPHER_free(a->cipher_list_by_id);
f865b081 4097 sk_SSL_CIPHER_free(a->tls13_ciphersuites);
e0e920b1 4098 ssl_cert_free(a->cert);
fa7c2637 4099 sk_X509_NAME_pop_free(a->ca_names, X509_NAME_free);
98732979 4100 sk_X509_NAME_pop_free(a->client_ca_names, X509_NAME_free);
79b2a2f2 4101 OSSL_STACK_OF_X509_free(a->extra_certs);
0f113f3e 4102 a->comp_methods = NULL;
e783bae2 4103#ifndef OPENSSL_NO_SRTP
25aaa98a 4104 sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles);
e783bae2 4105#endif
edc032b5 4106#ifndef OPENSSL_NO_SRP
76cb077f 4107 ssl_ctx_srp_ctx_free_intern(a);
edc032b5 4108#endif
bdfe932d 4109#ifndef OPENSSL_NO_ENGINE
301fcb28 4110 tls_engine_finish(a->client_cert_engine);
ddac1974 4111#endif
8671b898 4112
aff8c126 4113 OPENSSL_free(a->ext.ecpointformats);
187753e0 4114 OPENSSL_free(a->ext.supportedgroups);
ddf8f1ce 4115 OPENSSL_free(a->ext.supported_groups_default);
aff8c126 4116 OPENSSL_free(a->ext.alpn);
4bfb96f2 4117 OPENSSL_secure_free(a->ext.secure);
8671b898 4118
c8f6c28a
MC		 4119 ssl_evp_md_free(a->md5);
4120 ssl_evp_md_free(a->sha1);
4121
9d2d857f
MC		 4122 for (j = 0; j < SSL_ENC_NUM_IDX; j++)
4123 ssl_evp_cipher_free(a->ssl_cipher_methods[j]);
4124 for (j = 0; j < SSL_MD_NUM_IDX; j++)
4125 ssl_evp_md_free(a->ssl_digest_methods[j]);
4126 for (j = 0; j < a->group_list_len; j++) {
4127 OPENSSL_free(a->group_list[j].tlsname);
4128 OPENSSL_free(a->group_list[j].realname);
4129 OPENSSL_free(a->group_list[j].algorithm);
4130 }
4131 OPENSSL_free(a->group_list);
ee58915c
MB		 4132 for (j = 0; j < a->sigalg_list_len; j++) {
4133 OPENSSL_free(a->sigalg_list[j].name);
4134 OPENSSL_free(a->sigalg_list[j].sigalg_name);
4135 OPENSSL_free(a->sigalg_list[j].sigalg_oid);
4136 OPENSSL_free(a->sigalg_list[j].sig_name);
4137 OPENSSL_free(a->sigalg_list[j].sig_oid);
4138 OPENSSL_free(a->sigalg_list[j].hash_name);
4139 OPENSSL_free(a->sigalg_list[j].hash_oid);
4140 OPENSSL_free(a->sigalg_list[j].keytype);
4141 OPENSSL_free(a->sigalg_list[j].keytype_oid);
4142 }
4143 OPENSSL_free(a->sigalg_list);
4144 OPENSSL_free(a->ssl_cert_info);
c8f6c28a 4145
263ff2c9 4146 OPENSSL_free(a->sigalg_lookup_cache);
ee58915c 4147 OPENSSL_free(a->tls12_sigalgs);
263ff2c9 4148
3c95ef22
TS		 4149 OPENSSL_free(a->client_cert_type);
4150 OPENSSL_free(a->server_cert_type);
4151
16203f7b 4152 CRYPTO_THREAD_lock_free(a->lock);
43a07d6d 4153 CRYPTO_FREE_REF(&a->references);
acce0557
P		 4154#ifdef TSAN_REQUIRES_LOCKING
4155 CRYPTO_THREAD_lock_free(a->tsan_lock);
4156#endif
16203f7b 4157
ba18627e
MC		 4158 OPENSSL_free(a->propq);
4159
0f113f3e
MC		 4160 OPENSSL_free(a);
4161}
d02b48c6 4162
3ae76679 4163void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
0f113f3e
MC		 4164{
4165 ctx->default_passwd_callback = cb;
4166}
4167
4168void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u)
4169{
4170 ctx->default_passwd_callback_userdata = u;
4171}
4172
0c452abc
CH		 4173pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)
4174{
4175 return ctx->default_passwd_callback;
4176}
4177
4178void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx)
4179{
4180 return ctx->default_passwd_callback_userdata;
4181}
4182
a974e64a
MC		 4183void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb)
4184{
38b051a1
TM		 4185 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4186
4187 if (sc == NULL)
4188 return;
4189
4190 sc->default_passwd_callback = cb;
a974e64a
MC		 4191}
4192
4193void SSL_set_default_passwd_cb_userdata(SSL *s, void *u)
4194{
38b051a1
TM		 4195 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4196
4197 if (sc == NULL)
4198 return;
4199
4200 sc->default_passwd_callback_userdata = u;
a974e64a
MC		 4201}
4202
0c452abc
CH		 4203pem_password_cb *SSL_get_default_passwd_cb(SSL *s)
4204{
38b051a1
TM		 4205 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4206
4207 if (sc == NULL)
4208 return NULL;
4209
4210 return sc->default_passwd_callback;
0c452abc
CH		 4211}
4212
4213void *SSL_get_default_passwd_cb_userdata(SSL *s)
4214{
38b051a1
TM		 4215 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4216
4217 if (sc == NULL)
4218 return NULL;
4219
4220 return sc->default_passwd_callback_userdata;
0c452abc
CH		 4221}
4222
0f113f3e
MC		 4223void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
4224 int (*cb) (X509_STORE_CTX *, void *),
4225 void *arg)
4226{
4227 ctx->app_verify_callback = cb;
4228 ctx->app_verify_arg = arg;
4229}
4230
4231void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
4232 int (*cb) (int, X509_STORE_CTX *))
4233{
4234 ctx->verify_mode = mode;
4235 ctx->default_verify_callback = cb;
4236}
4237
4238void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
4239{
4240 X509_VERIFY_PARAM_set_depth(ctx->param, depth);
4241}
4242
a230b26e 4243void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg), void *arg)
0f113f3e
MC		 4244{
4245 ssl_cert_set_cert_cb(c->cert, cb, arg);
4246}
4247
4248void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
4249{
38b051a1
TM		 4250 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4251
4252 if (sc == NULL)
4253 return;
4254
4255 ssl_cert_set_cert_cb(sc->cert, cb, arg);
0f113f3e 4256}
18d71588 4257
38b051a1 4258void ssl_set_masks(SSL_CONNECTION *s)
0f113f3e 4259{
6383d316 4260 CERT *c = s->cert;
555cbb32 4261 uint32_t *pvalid = s->s3.tmp.valid_flags;
bc71f910 4262 int rsa_enc, rsa_sign, dh_tmp, dsa_sign;
361a1191 4263 unsigned long mask_k, mask_a;
361a1191 4264 int have_ecc_cert, ecdsa_ok;
462f4f4b 4265
0f113f3e
MC		 4266 if (c == NULL)
4267 return;
d02b48c6 4268
13c45372 4269 dh_tmp = (c->dh_tmp != NULL
13c45372 4270 || c->dh_tmp_cb != NULL
13c45372 4271 || c->dh_tmp_auto);
d02b48c6 4272
d0ff28f8 4273 rsa_enc = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID;
38e8f3cd
DSH		 4274 rsa_sign = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID;
4275 dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_VALID;
6383d316 4276 have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID;
0f113f3e
MC		 4277 mask_k = 0;
4278 mask_a = 0;
0e1dba93 4279
77359d22
RL		 4280 OSSL_TRACE4(TLS_CIPHER, "dh_tmp=%d rsa_enc=%d rsa_sign=%d dsa_sign=%d\n",
4281 dh_tmp, rsa_enc, rsa_sign, dsa_sign);
0f113f3e 4282
2a9b9654 4283#ifndef OPENSSL_NO_GOST
4020c0b3 4284 if (ssl_has_cert(s, SSL_PKEY_GOST12_512)) {
5a5530a2 4285 mask_k |= SSL_kGOST | SSL_kGOST18;
e44380a9
DB		 4286 mask_a |= SSL_aGOST12;
4287 }
4020c0b3 4288 if (ssl_has_cert(s, SSL_PKEY_GOST12_256)) {
5a5530a2 4289 mask_k |= SSL_kGOST | SSL_kGOST18;
e44380a9
DB		 4290 mask_a |= SSL_aGOST12;
4291 }
4020c0b3 4292 if (ssl_has_cert(s, SSL_PKEY_GOST01)) {
0f113f3e
MC		 4293 mask_k |= SSL_kGOST;
4294 mask_a |= SSL_aGOST01;
4295 }
2a9b9654 4296#endif
0f113f3e 4297
361a1191 4298 if (rsa_enc)
0f113f3e 4299 mask_k |= SSL_kRSA;
d02b48c6 4300
0f113f3e
MC		 4301 if (dh_tmp)
4302 mask_k |= SSL_kDHE;
d02b48c6 4303
6aaa29fb
DSH		 4304 /*
4305 * If we only have an RSA-PSS certificate allow RSA authentication
4306 * if TLS 1.2 and peer supports it.
4307 */
4308
4309 if (rsa_enc || rsa_sign || (ssl_has_cert(s, SSL_PKEY_RSA_PSS_SIGN)
4310 && pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_EXPLICIT_SIGN
38b051a1 4311 && TLS1_get_version(&s->ssl) == TLS1_2_VERSION))
0f113f3e 4312 mask_a |= SSL_aRSA;
d02b48c6 4313
0f113f3e
MC		 4314 if (dsa_sign) {
4315 mask_a |= SSL_aDSS;
0f113f3e 4316 }
d02b48c6 4317
0f113f3e 4318 mask_a |= SSL_aNULL;
d02b48c6 4319
3c95ef22
TS		 4320 /*
4321 * You can do anything with an RPK key, since there's no cert to restrict it
4322 * But we need to check for private keys
4323 */
4324 if (pvalid[SSL_PKEY_RSA] & CERT_PKEY_RPK) {
4325 mask_a |= SSL_aRSA;
4326 mask_k |= SSL_kRSA;
4327 }
4328 if (pvalid[SSL_PKEY_ECC] & CERT_PKEY_RPK)
4329 mask_a |= SSL_aECDSA;
4330 if (TLS1_get_version(&s->ssl) == TLS1_2_VERSION) {
4331 if (pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_RPK)
4332 mask_a |= SSL_aRSA;
4333 if (pvalid[SSL_PKEY_ED25519] & CERT_PKEY_RPK
4334 || pvalid[SSL_PKEY_ED448] & CERT_PKEY_RPK)
4335 mask_a |= SSL_aECDSA;
4336 }
4337
0f113f3e
MC		 4338 /*
4339 * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites
4340 * depending on the key usage extension.
4341 */
0f113f3e 4342 if (have_ecc_cert) {
a8d8e06b 4343 uint32_t ex_kusage;
4020c0b3 4344 ex_kusage = X509_get_key_usage(c->pkeys[SSL_PKEY_ECC].x509);
a8d8e06b 4345 ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE;
6383d316 4346 if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN))
0f113f3e 4347 ecdsa_ok = 0;
c7c46256 4348 if (ecdsa_ok)
0f113f3e 4349 mask_a |= SSL_aECDSA;
0f113f3e 4350 }
b2021556
DSH		 4351 /* Allow Ed25519 for TLS 1.2 if peer supports it */
4352 if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED25519)
4353 && pvalid[SSL_PKEY_ED25519] & CERT_PKEY_EXPLICIT_SIGN
38b051a1 4354 && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)
b2021556 4355 mask_a |= SSL_aECDSA;
0e1d6ecf
MC		 4356
4357 /* Allow Ed448 for TLS 1.2 if peer supports it */
4358 if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED448)
4359 && pvalid[SSL_PKEY_ED448] & CERT_PKEY_EXPLICIT_SIGN
38b051a1 4360 && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)
0e1d6ecf 4361 mask_a |= SSL_aECDSA;
ea262260 4362
fe6ef247 4363 mask_k |= SSL_kECDHE;
ddac1974
NL		 4364
4365#ifndef OPENSSL_NO_PSK
0f113f3e
MC		 4366 mask_k |= SSL_kPSK;
4367 mask_a |= SSL_aPSK;
526f94ad
DSH		 4368 if (mask_k & SSL_kRSA)
4369 mask_k |= SSL_kRSAPSK;
4370 if (mask_k & SSL_kDHE)
4371 mask_k |= SSL_kDHEPSK;
4372 if (mask_k & SSL_kECDHE)
4373 mask_k |= SSL_kECDHEPSK;
ddac1974
NL		 4374#endif
4375
555cbb32
TS		 4376 s->s3.tmp.mask_k = mask_k;
4377 s->s3.tmp.mask_a = mask_a;
0f113f3e 4378}
d02b48c6 4379
38b051a1 4380int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL_CONNECTION *s)
0f113f3e 4381{
555cbb32 4382 if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aECDSA) {
0f113f3e 4383 /* key usage, if present, must allow signing */
ce0c1f2b 4384 if (!(X509_get_key_usage(x) & X509v3_KU_DIGITAL_SIGNATURE)) {
6849b73c 4385 ERR_raise(ERR_LIB_SSL, SSL_R_ECC_CERT_NOT_FOR_SIGNING);
0f113f3e
MC		 4386 return 0;
4387 }
4388 }
0f113f3e
MC		 4389 return 1; /* all checks are ok */
4390}
ea262260 4391
38b051a1
TM		 4392int ssl_get_server_cert_serverinfo(SSL_CONNECTION *s,
4393 const unsigned char **serverinfo,
0f113f3e
MC		 4394 size_t *serverinfo_length)
4395{
555cbb32 4396 CERT_PKEY *cpk = s->s3.tmp.cert;
0f113f3e
MC		 4397 *serverinfo_length = 0;
4398
a497cf25 4399 if (cpk == NULL || cpk->serverinfo == NULL)
0f113f3e
MC		 4400 return 0;
4401
a497cf25
DSH		 4402 *serverinfo = cpk->serverinfo;
4403 *serverinfo_length = cpk->serverinfo_length;
0f113f3e
MC		 4404 return 1;
4405}
0f113f3e 4406
38b051a1 4407void ssl_update_cache(SSL_CONNECTION *s, int mode)
0f113f3e
MC		 4408{
4409 int i;
4410
4411 /*
4412 * If the session_id_length is 0, we are not supposed to cache it, and it
4413 * would be rather hard to do anyway :-)
4414 */
4415 if (s->session->session_id_length == 0)
4416 return;
4417
d316cdcf
BK		 4418 /*
4419 * If sid_ctx_length is 0 there is no specific application context
4420 * associated with this session, so when we try to resume it and
c4fa1f7f
BK		 4421 * SSL_VERIFY_PEER is requested to verify the client identity, we have no
4422 * indication that this is actually a session for the proper application
4423 * context, and the *handshake* will fail, not just the resumption attempt.
4424 * Do not cache (on the server) these sessions that are not resumable
4425 * (clients can set SSL_VERIFY_PEER without needing a sid_ctx set).
d316cdcf 4426 */
c4fa1f7f 4427 if (s->server && s->session->sid_ctx_length == 0
d316cdcf
BK		 4428 && (s->verify_mode & SSL_VERIFY_PEER) != 0)
4429 return;
4430
0f113f3e 4431 i = s->session_ctx->session_cache_mode;
5d61491c 4432 if ((i & mode) != 0
38b051a1 4433 && (!s->hit || SSL_CONNECTION_IS_TLS13(s))) {
ee94ec2e
MC		 4434 /*
4435 * Add the session to the internal cache. In server side TLSv1.3 we
6cc0b3c2
MC		 4436 * normally don't do this because by default it's a full stateless ticket
4437 * with only a dummy session id so there is no reason to cache it,
4438 * unless:
ee94ec2e
MC		 4439 * - we are doing early_data, in which case we cache so that we can
4440 * detect replays
4441 * - the application has set a remove_session_cb so needs to know about
4442 * session timeout events
6cc0b3c2 4443 * - SSL_OP_NO_TICKET is set in which case it is a stateful ticket
ee94ec2e
MC		 4444 */
4445 if ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0
38b051a1 4446 && (!SSL_CONNECTION_IS_TLS13(s)
ee94ec2e 4447 || !s->server
5d263fb7
MC		 4448 || (s->max_early_data > 0
4449 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0)
6cc0b3c2
MC		 4450 || s->session_ctx->remove_session_cb != NULL
4451 || (s->options & SSL_OP_NO_TICKET) != 0))
ee94ec2e
MC		 4452 SSL_CTX_add_session(s->session_ctx, s->session);
4453
4454 /*
4455 * Add the session to the external cache. We do this even in server side
4456 * TLSv1.3 without early data because some applications just want to
4457 * know about the creation of a session and aren't doing a full cache.
4458 */
4459 if (s->session_ctx->new_session_cb != NULL) {
4460 SSL_SESSION_up_ref(s->session);
38b051a1
TM		 4461 if (!s->session_ctx->new_session_cb(SSL_CONNECTION_GET_SSL(s),
4462 s->session))
ee94ec2e
MC		 4463 SSL_SESSION_free(s->session);
4464 }
0f113f3e
MC		 4465 }
4466
4467 /* auto flush every 255 connections */
4468 if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) {
9ef9088c 4469 TSAN_QUALIFIER int *stat;
acce0557 4470
1fcb4e4d
BK		 4471 if (mode & SSL_SESS_CACHE_CLIENT)
4472 stat = &s->session_ctx->stats.sess_connect_good;
4473 else
4474 stat = &s->session_ctx->stats.sess_accept_good;
acce0557 4475 if ((ssl_tsan_load(s->session_ctx, stat) & 0xff) == 0xff)
0f113f3e 4476 SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL));
0f113f3e
MC		 4477 }
4478}
d02b48c6 4479
3499327b 4480const SSL_METHOD *SSL_CTX_get_ssl_method(const SSL_CTX *ctx)
0f113f3e
MC		 4481{
4482 return ctx->method;
4483}
ba168244 4484
3499327b 4485const SSL_METHOD *SSL_get_ssl_method(const SSL *s)
0f113f3e 4486{
26a7d938 4487 return s->method;
0f113f3e 4488}
d02b48c6 4489
4ebb342f 4490int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
0f113f3e 4491{
0f113f3e 4492 int ret = 1;
38b051a1
TM		 4493 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4494
4495 /* TODO(QUIC): Do we want this for QUIC? */
4496 if (sc == NULL
4497 || (s->type != SSL_TYPE_SSL_CONNECTION && s->method != meth))
4498 return 0;
0f113f3e
MC		 4499
4500 if (s->method != meth) {
919ba009 4501 const SSL_METHOD *sm = s->method;
38b051a1 4502 int (*hf) (SSL *) = sc->handshake_func;
0f113f3e 4503
919ba009 4504 if (sm->version == meth->version)
0f113f3e
MC		 4505 s->method = meth;
4506 else {
38b051a1 4507 sm->ssl_deinit(s);
0f113f3e 4508 s->method = meth;
38b051a1 4509 ret = s->method->ssl_init(s);
0f113f3e
MC		 4510 }
4511
919ba009 4512 if (hf == sm->ssl_connect)
38b051a1 4513 sc->handshake_func = meth->ssl_connect;
919ba009 4514 else if (hf == sm->ssl_accept)
38b051a1 4515 sc->handshake_func = meth->ssl_accept;
0f113f3e 4516 }
26a7d938 4517 return ret;
0f113f3e
MC		 4518}
4519
4520int SSL_get_error(const SSL *s, int i)
4521{
4522 int reason;
4523 unsigned long l;
4524 BIO *bio;
38b051a1 4525 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
0f113f3e
MC		 4526
4527 if (i > 0)
26a7d938 4528 return SSL_ERROR_NONE;
0f113f3e 4529
e30c502a 4530#ifndef OPENSSL_NO_QUIC
6d495cc4
HL		 4531 if (IS_QUIC(s)) {
4532 reason = ossl_quic_get_error(s, i);
e30c502a
HL		 4533 if (reason != SSL_ERROR_NONE)
4534 return reason;
4535 }
4536#endif
4537
38b051a1
TM		 4538 if (sc == NULL)
4539 return SSL_ERROR_SSL;
4540
0f113f3e
MC		 4541 /*
4542 * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc,
4543 * where we do encode the error
4544 */
4545 if ((l = ERR_peek_error()) != 0) {
4546 if (ERR_GET_LIB(l) == ERR_LIB_SYS)
26a7d938 4547 return SSL_ERROR_SYSCALL;
0f113f3e 4548 else
26a7d938 4549 return SSL_ERROR_SSL;
0f113f3e
MC		 4550 }
4551
03bacce8 4552#ifndef OPENSSL_NO_QUIC
6d495cc4 4553 if (!IS_QUIC(s))
03bacce8
HL		 4554#endif
4555 {
4556 if (SSL_want_read(s)) {
4557 bio = SSL_get_rbio(s);
4558 if (BIO_should_read(bio))
4559 return SSL_ERROR_WANT_READ;
4560 else if (BIO_should_write(bio))
4561 /*
4562 * This one doesn't make too much sense ... We never try to
4563 * write to the rbio, and an application program where rbio and
4564 * wbio are separate couldn't even know what it should wait for.
4565 * However if we ever set s->rwstate incorrectly (so that we
4566 * have SSL_want_read(s) instead of SSL_want_write(s)) and rbio
4567 * and wbio *are* the same, this test works around that bug; so
4568 * it might be safer to keep it.
4569 */
4570 return SSL_ERROR_WANT_WRITE;
4571 else if (BIO_should_io_special(bio)) {
4572 reason = BIO_get_retry_reason(bio);
4573 if (reason == BIO_RR_CONNECT)
4574 return SSL_ERROR_WANT_CONNECT;
4575 else if (reason == BIO_RR_ACCEPT)
4576 return SSL_ERROR_WANT_ACCEPT;
4577 else
4578 return SSL_ERROR_SYSCALL; /* unknown */
4579 }
4580 }
4581
4582 if (SSL_want_write(s)) {
2e7dc7cd 4583 /*
03bacce8
HL		 4584 * Access wbio directly - in order to use the buffered bio if
4585 * present
2e7dc7cd 4586 */
03bacce8
HL		 4587 bio = sc->wbio;
4588 if (BIO_should_write(bio))
4589 return SSL_ERROR_WANT_WRITE;
4590 else if (BIO_should_read(bio))
4591 /*
4592 * See above (SSL_want_read(s) with BIO_should_write(bio))
4593 */
4594 return SSL_ERROR_WANT_READ;
4595 else if (BIO_should_io_special(bio)) {
4596 reason = BIO_get_retry_reason(bio);
4597 if (reason == BIO_RR_CONNECT)
4598 return SSL_ERROR_WANT_CONNECT;
4599 else if (reason == BIO_RR_ACCEPT)
4600 return SSL_ERROR_WANT_ACCEPT;
4601 else
4602 return SSL_ERROR_SYSCALL;
4603 }
0f113f3e 4604 }
07bbc92c 4605 }
03bacce8 4606
6b1bb98f 4607 if (SSL_want_x509_lookup(s))
26a7d938 4608 return SSL_ERROR_WANT_X509_LOOKUP;
0c3eb279
DDO		 4609 if (SSL_want_retry_verify(s))
4610 return SSL_ERROR_WANT_RETRY_VERIFY;
6b1bb98f 4611 if (SSL_want_async(s))
8051ab2b 4612 return SSL_ERROR_WANT_ASYNC;
6b1bb98f 4613 if (SSL_want_async_job(s))
8051ab2b 4614 return SSL_ERROR_WANT_ASYNC_JOB;
a9c0d8be
DB		 4615 if (SSL_want_client_hello_cb(s))
4616 return SSL_ERROR_WANT_CLIENT_HELLO_CB;
8051ab2b 4617
38b051a1
TM		 4618 if ((sc->shutdown & SSL_RECEIVED_SHUTDOWN) &&
4619 (sc->s3.warn_alert == SSL_AD_CLOSE_NOTIFY))
26a7d938 4620 return SSL_ERROR_ZERO_RETURN;
8051ab2b 4621
26a7d938 4622 return SSL_ERROR_SYSCALL;
0f113f3e 4623}
d02b48c6 4624
add2f5ca
MC		 4625static int ssl_do_handshake_intern(void *vargs)
4626{
38b051a1
TM		 4627 struct ssl_async_args *args = (struct ssl_async_args *)vargs;
4628 SSL *s = args->s;
4629 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
add2f5ca 4630
38b051a1
TM		 4631 if (sc == NULL)
4632 return -1;
add2f5ca 4633
38b051a1 4634 return sc->handshake_func(s);
add2f5ca
MC		 4635}
4636
4f43d0e7 4637int SSL_do_handshake(SSL *s)
0f113f3e
MC		 4638{
4639 int ret = 1;
38b051a1
TM		 4640 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4641
6d495cc4
HL		 4642#ifndef OPENSSL_NO_QUIC
4643 if (IS_QUIC(s))
4644 return ossl_quic_do_handshake(s);
03bacce8 4645#endif
0f113f3e 4646
38b051a1 4647 if (sc->handshake_func == NULL) {
6849b73c 4648 ERR_raise(ERR_LIB_SSL, SSL_R_CONNECTION_TYPE_NOT_SET);
add2f5ca 4649 return -1;
0f113f3e
MC		 4650 }
4651
38b051a1 4652 ossl_statem_check_finish_init(sc, -1);
49e7fe12 4653
c7f47786 4654 s->method->ssl_renegotiate_check(s, 0);
0f113f3e
MC		 4655
4656 if (SSL_in_init(s) || SSL_in_before(s)) {
38b051a1 4657 if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) {
add2f5ca
MC		 4658 struct ssl_async_args args;
4659
09134f18 4660 memset(&args, 0, sizeof(args));
add2f5ca
MC		 4661 args.s = s;
4662
7fecbf6f 4663 ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern);
add2f5ca 4664 } else {
38b051a1 4665 ret = sc->handshake_func(s);
add2f5ca 4666 }
0f113f3e 4667 }
add2f5ca 4668 return ret;
0f113f3e
MC		 4669}
4670
4f43d0e7 4671void SSL_set_accept_state(SSL *s)
0f113f3e 4672{
03bacce8 4673 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
38b051a1 4674
6d495cc4
HL		 4675#ifndef OPENSSL_NO_QUIC
4676 if (IS_QUIC(s)) {
4677 ossl_quic_set_accept_state(s);
38b051a1 4678 return;
03bacce8
HL		 4679 }
4680#endif
38b051a1
TM		 4681
4682 sc->server = 1;
4683 sc->shutdown = 0;
4684 ossl_statem_clear(sc);
4685 sc->handshake_func = s->method->ssl_accept;
6d814fd6
MC		 4686 /* Ignore return value. Its a void public API function */
4687 clear_record_layer(sc);
0f113f3e 4688}
d02b48c6 4689
4f43d0e7 4690void SSL_set_connect_state(SSL *s)
0f113f3e 4691{
03bacce8 4692 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
38b051a1 4693
6d495cc4
HL		 4694#ifndef OPENSSL_NO_QUIC
4695 if (IS_QUIC(s)) {
4696 ossl_quic_set_connect_state(s);
38b051a1 4697 return;
03bacce8
HL		 4698 }
4699#endif
38b051a1
TM		 4700
4701 sc->server = 0;
4702 sc->shutdown = 0;
4703 ossl_statem_clear(sc);
4704 sc->handshake_func = s->method->ssl_connect;
6d814fd6
MC		 4705 /* Ignore return value. Its a void public API function */
4706 clear_record_layer(sc);
0f113f3e 4707}
d02b48c6 4708
4f43d0e7 4709int ssl_undefined_function(SSL *s)
0f113f3e 4710{
6849b73c 4711 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
26a7d938 4712 return 0;
0f113f3e 4713}
d02b48c6 4714
41a15c4f 4715int ssl_undefined_void_function(void)
0f113f3e 4716{
6849b73c 4717 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
26a7d938 4718 return 0;
0f113f3e 4719}
41a15c4f 4720
0821bcd4 4721int ssl_undefined_const_function(const SSL *s)
0f113f3e 4722{
26a7d938 4723 return 0;
0f113f3e 4724}
0821bcd4 4725
2b8fa1d5 4726const SSL_METHOD *ssl_bad_method(int ver)
0f113f3e 4727{
6849b73c 4728 ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
26a7d938 4729 return NULL;
0f113f3e 4730}
d02b48c6 4731
3eb2aff4 4732const char *ssl_protocol_to_string(int version)
7d650072 4733{
1287dabd 4734 switch (version)
2abacef1
MC		 4735 {
4736 case TLS1_3_VERSION:
582a17d6 4737 return "TLSv1.3";
2abacef1
MC		 4738
4739 case TLS1_2_VERSION:
7d650072 4740 return "TLSv1.2";
2abacef1
MC		 4741
4742 case TLS1_1_VERSION:
7d650072 4743 return "TLSv1.1";
2abacef1
MC		 4744
4745 case TLS1_VERSION:
ee3a6c64 4746 return "TLSv1";
2abacef1
MC		 4747
4748 case SSL3_VERSION:
7d650072 4749 return "SSLv3";
2abacef1
MC		 4750
4751 case DTLS1_BAD_VER:
7d650072 4752 return "DTLSv0.9";
2abacef1
MC		 4753
4754 case DTLS1_VERSION:
7d650072 4755 return "DTLSv1";
2abacef1
MC		 4756
4757 case DTLS1_2_VERSION:
7d650072 4758 return "DTLSv1.2";
2abacef1
MC		 4759
4760 default:
4761 return "unknown";
4762 }
0f113f3e 4763}
d02b48c6 4764
7d650072
KR		 4765const char *SSL_get_version(const SSL *s)
4766{
38b051a1
TM		 4767 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
4768
50769b15
MC		 4769#ifndef OPENSSL_NO_QUIC
4770 /* We only support QUICv1 - so if its QUIC its QUICv1 */
f8636c7e 4771 if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO)
50769b15
MC		 4772 return "QUICv1";
4773#endif
4774
38b051a1
TM		 4775 if (sc == NULL)
4776 return NULL;
4777
4778 return ssl_protocol_to_string(sc->version);
7d650072
KR		 4779}
4780
cee0628e
JC		 4781__owur int SSL_get_handshake_rtt(const SSL *s, uint64_t *rtt)
4782{
4783 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
4784
4785 if (sc == NULL)
4786 return -1;
4787 if (sc->ts_msg_write.t <= 0 || sc->ts_msg_read.t <= 0)
4788 return 0; /* data not (yet) available */
4789 if (sc->ts_msg_read.t < sc->ts_msg_write.t)
4790 return -1;
4791
4792 *rtt = ossl_time2us(ossl_time_subtract(sc->ts_msg_read, sc->ts_msg_write));
4793 return 1;
4794}
4795
98732979 4796static int dup_ca_names(STACK_OF(X509_NAME) **dst, STACK_OF(X509_NAME) *src)
0f113f3e
MC		 4797{
4798 STACK_OF(X509_NAME) *sk;
4799 X509_NAME *xn;
98732979
MC		 4800 int i;
4801
4802 if (src == NULL) {
4803 *dst = NULL;
4804 return 1;
4805 }
4806
4807 if ((sk = sk_X509_NAME_new_null()) == NULL)
4808 return 0;
4809 for (i = 0; i < sk_X509_NAME_num(src); i++) {
4810 xn = X509_NAME_dup(sk_X509_NAME_value(src, i));
4811 if (xn == NULL) {
4812 sk_X509_NAME_pop_free(sk, X509_NAME_free);
4813 return 0;
4814 }
4815 if (sk_X509_NAME_insert(sk, xn, i) == 0) {
4816 X509_NAME_free(xn);
4817 sk_X509_NAME_pop_free(sk, X509_NAME_free);
4818 return 0;
4819 }
4820 }
4821 *dst = sk;
4822
4823 return 1;
4824}
4825
4826SSL *SSL_dup(SSL *s)
4827{
0f113f3e
MC		 4828 SSL *ret;
4829 int i;
38b051a1
TM		 4830 /* TODO(QUIC): Add a SSL_METHOD function for duplication */
4831 SSL_CONNECTION *retsc;
4832 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
4833
4834 if (sc == NULL)
4835 return NULL;
0f113f3e 4836
919ba009
VD		 4837 /* If we're not quiescent, just up_ref! */
4838 if (!SSL_in_init(s) || !SSL_in_before(s)) {
43a07d6d 4839 CRYPTO_UP_REF(&s->references, &i);
919ba009
VD		 4840 return s;
4841 }
4842
4843 /*
4844 * Otherwise, copy configuration state, and session if set.
4845 */
0f113f3e 4846 if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL)
26a7d938 4847 return NULL;
38b051a1
TM		 4848 if ((retsc = SSL_CONNECTION_FROM_SSL_ONLY(ret)) == NULL)
4849 goto err;
0f113f3e 4850
38b051a1 4851 if (sc->session != NULL) {
919ba009
VD		 4852 /*
4853 * Arranges to share the same session via up_ref. This "copies"
4854 * session-id, SSL_METHOD, sid_ctx, and 'cert'
4855 */
61986d32 4856 if (!SSL_copy_session_id(ret, s))
17dd65e6 4857 goto err;
0f113f3e
MC		 4858 } else {
4859 /*
4860 * No session has been established yet, so we have to expect that
4861 * s->cert or ret->cert will be changed later -- they should not both
4862 * point to the same object, and thus we can't use
4863 * SSL_copy_session_id.
4864 */
919ba009
VD		 4865 if (!SSL_set_ssl_method(ret, s->method))
4866 goto err;
0f113f3e 4867
38b051a1
TM		 4868 if (sc->cert != NULL) {
4869 ssl_cert_free(retsc->cert);
4870 retsc->cert = ssl_cert_dup(sc->cert);
4871 if (retsc->cert == NULL)
0f113f3e
MC		 4872 goto err;
4873 }
4874
38b051a1
TM		 4875 if (!SSL_set_session_id_context(ret, sc->sid_ctx,
4876 (int)sc->sid_ctx_length))
69f68237 4877 goto err;
0f113f3e
MC		 4878 }
4879
38b051a1 4880 if (!ssl_dane_dup(retsc, sc))
9f6b22b8 4881 goto err;
38b051a1
TM		 4882 retsc->version = sc->version;
4883 retsc->options = sc->options;
4884 retsc->min_proto_version = sc->min_proto_version;
4885 retsc->max_proto_version = sc->max_proto_version;
4886 retsc->mode = sc->mode;
0f113f3e
MC		 4887 SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s));
4888 SSL_set_read_ahead(ret, SSL_get_read_ahead(s));
38b051a1
TM		 4889 retsc->msg_callback = sc->msg_callback;
4890 retsc->msg_callback_arg = sc->msg_callback_arg;
0f113f3e
MC		 4891 SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s));
4892 SSL_set_verify_depth(ret, SSL_get_verify_depth(s));
38b051a1 4893 retsc->generate_session_id = sc->generate_session_id;
0f113f3e
MC		 4894
4895 SSL_set_info_callback(ret, SSL_get_info_callback(s));
4896
0f113f3e
MC		 4897 /* copy app data, a little dangerous perhaps */
4898 if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
4899 goto err;
4900
38b051a1
TM		 4901 retsc->server = sc->server;
4902 if (sc->handshake_func) {
4903 if (sc->server)
919ba009
VD		 4904 SSL_set_accept_state(ret);
4905 else
4906 SSL_set_connect_state(ret);
4907 }
38b051a1
TM		 4908 retsc->shutdown = sc->shutdown;
4909 retsc->hit = sc->hit;
0f113f3e 4910
38b051a1
TM		 4911 retsc->default_passwd_callback = sc->default_passwd_callback;
4912 retsc->default_passwd_callback_userdata = sc->default_passwd_callback_userdata;
a974e64a 4913
38b051a1 4914 X509_VERIFY_PARAM_inherit(retsc->param, sc->param);
0f113f3e
MC		 4915
4916 /* dup the cipher_list and cipher_list_by_id stacks */
38b051a1
TM		 4917 if (sc->cipher_list != NULL) {
4918 if ((retsc->cipher_list = sk_SSL_CIPHER_dup(sc->cipher_list)) == NULL)
0f113f3e
MC		 4919 goto err;
4920 }
38b051a1
TM		 4921 if (sc->cipher_list_by_id != NULL)
4922 if ((retsc->cipher_list_by_id = sk_SSL_CIPHER_dup(sc->cipher_list_by_id))
0f113f3e
MC		 4923 == NULL)
4924 goto err;
4925
4926 /* Dup the client_CA list */
38b051a1
TM		 4927 if (!dup_ca_names(&retsc->ca_names, sc->ca_names)
4928 || !dup_ca_names(&retsc->client_ca_names, sc->client_ca_names))
98732979
MC		 4929 goto err;
4930
66696478 4931 return ret;
0f113f3e 4932
0f113f3e 4933 err:
66696478
RS		 4934 SSL_free(ret);
4935 return NULL;
0f113f3e 4936}
d02b48c6 4937
0821bcd4 4938X509 *SSL_get_certificate(const SSL *s)
0f113f3e 4939{
38b051a1
TM		 4940 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
4941
4942 if (sc == NULL)
4943 return NULL;
4944
4945 if (sc->cert != NULL)
4946 return sc->cert->key->x509;
0f113f3e 4947 else
26a7d938 4948 return NULL;
0f113f3e 4949}
d02b48c6 4950
a25f9adc 4951EVP_PKEY *SSL_get_privatekey(const SSL *s)
0f113f3e 4952{
38b051a1
TM		 4953 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
4954
4955 if (sc == NULL)
4956 return NULL;
4957
4958 if (sc->cert != NULL)
4959 return sc->cert->key->privatekey;
0f113f3e 4960 else
26a7d938 4961 return NULL;
0f113f3e 4962}
d02b48c6 4963
a25f9adc 4964X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx)
0f113f3e
MC		 4965{
4966 if (ctx->cert != NULL)
4967 return ctx->cert->key->x509;
4968 else
4969 return NULL;
4970}
a25f9adc
DSH		 4971
4972EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx)
0f113f3e
MC		 4973{
4974 if (ctx->cert != NULL)
4975 return ctx->cert->key->privatekey;
4976 else
4977 return NULL;
4978}
a25f9adc 4979
babb3798 4980const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
0f113f3e 4981{
38b051a1
TM		 4982 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
4983
4984 if (sc == NULL)
4985 return NULL;
4986
4987 if ((sc->session != NULL) && (sc->session->cipher != NULL))
4988 return sc->session->cipher;
26a7d938 4989 return NULL;
0f113f3e
MC		 4990}
4991
0aed6e44
BK		 4992const SSL_CIPHER *SSL_get_pending_cipher(const SSL *s)
4993{
38b051a1
TM		 4994 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
4995
4996 if (sc == NULL)
4997 return NULL;
4998
4999 return sc->s3.tmp.new_cipher;
0aed6e44
BK		 5000}
5001
3499327b 5002const COMP_METHOD *SSL_get_current_compression(const SSL *s)
0f113f3e 5003{
9a555706 5004#ifndef OPENSSL_NO_COMP
38b051a1
TM		 5005 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
5006
5007 if (sc == NULL)
5008 return NULL;
5009
1e76110b 5010 return sc->rlayer.wrlmethod->get_compression(sc->rlayer.wrl);
9a555706
RS		 5011#else
5012 return NULL;
5013#endif
0f113f3e 5014}
377dcdba 5015
3499327b 5016const COMP_METHOD *SSL_get_current_expansion(const SSL *s)
0f113f3e 5017{
9a555706 5018#ifndef OPENSSL_NO_COMP
38b051a1
TM		 5019 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
5020
5021 if (sc == NULL)
5022 return NULL;
5023
1e76110b 5024 return sc->rlayer.rrlmethod->get_compression(sc->rlayer.rrl);
9a555706
RS		 5025#else
5026 return NULL;
0f113f3e 5027#endif
9a555706 5028}
0f113f3e 5029
38b051a1 5030int ssl_init_wbio_buffer(SSL_CONNECTION *s)
0f113f3e
MC		 5031{
5032 BIO *bbio;
5033
2e7dc7cd
MC		 5034 if (s->bbio != NULL) {
5035 /* Already buffered. */
5036 return 1;
0f113f3e 5037 }
46417569 5038
2e7dc7cd 5039 bbio = BIO_new(BIO_f_buffer());
25d02f33 5040 if (bbio == NULL || BIO_set_read_buffer_size(bbio, 1) <= 0) {
2e7dc7cd 5041 BIO_free(bbio);
6849b73c 5042 ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB);
46417569 5043 return 0;
0f113f3e 5044 }
2e7dc7cd
MC		 5045 s->bbio = bbio;
5046 s->wbio = BIO_push(bbio, s->wbio);
46417569 5047
b5cf81f7
MC		 5048 s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio);
5049
46417569 5050 return 1;
0f113f3e 5051}
413c4f45 5052
38b051a1 5053int ssl_free_wbio_buffer(SSL_CONNECTION *s)
0f113f3e 5054{
62adbcee 5055 /* callers ensure s is never null */
0f113f3e 5056 if (s->bbio == NULL)
b77f3ed1 5057 return 1;
0f113f3e 5058
2e7dc7cd 5059 s->wbio = BIO_pop(s->wbio);
b5cf81f7
MC		 5060 s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio);
5061
0f113f3e
MC		 5062 BIO_free(s->bbio);
5063 s->bbio = NULL;
b77f3ed1
MC		 5064
5065 return 1;
0f113f3e
MC		 5066}
5067
5068void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode)
5069{
5070 ctx->quiet_shutdown = mode;
5071}
58964a49 5072
0821bcd4 5073int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
0f113f3e 5074{
26a7d938 5075 return ctx->quiet_shutdown;
0f113f3e 5076}
58964a49 5077
0f113f3e
MC		 5078void SSL_set_quiet_shutdown(SSL *s, int mode)
5079{
38b051a1
TM		 5080 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
5081
5082 /* TODO(QUIC): Do we want this for QUIC? */
5083 if (sc == NULL)
5084 return;
5085
5086 sc->quiet_shutdown = mode;
0f113f3e 5087}
58964a49 5088
0821bcd4 5089int SSL_get_quiet_shutdown(const SSL *s)
0f113f3e 5090{
38b051a1
TM		 5091 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
5092
5093 /* TODO(QUIC): Do we want this for QUIC? */
5094 if (sc == NULL)
5095 return 0;
5096
5097 return sc->quiet_shutdown;
0f113f3e 5098}
58964a49 5099
0f113f3e
MC		 5100void SSL_set_shutdown(SSL *s, int mode)
5101{
38b051a1
TM		 5102 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
5103
5104 /* TODO(QUIC): Do we want this for QUIC? */
5105 if (sc == NULL)
5106 return;
5107
5108 sc->shutdown = mode;
0f113f3e 5109}
58964a49 5110
0821bcd4 5111int SSL_get_shutdown(const SSL *s)
0f113f3e 5112{
38b051a1
TM		 5113 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s);
5114
5115 /* TODO(QUIC): Do we want this for QUIC? */
5116 if (sc == NULL)
5117 return 0;
5118
5119 return sc->shutdown;
0f113f3e 5120}
58964a49 5121
0821bcd4 5122int SSL_version(const SSL *s)
0f113f3e 5123{
38b051a1
TM		 5124 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5125
50769b15
MC		 5126#ifndef OPENSSL_NO_QUIC
5127 /* We only support QUICv1 - so if its QUIC its QUICv1 */
f8636c7e 5128 if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO)
50769b15
MC		 5129 return OSSL_QUIC1_VERSION;
5130#endif
38b051a1
TM		 5131 /* TODO(QUIC): Do we want to report QUIC version this way instead? */
5132 if (sc == NULL)
5133 return 0;
5134
5135 return sc->version;
6546e9b2
AG		 5136}
5137
5138int SSL_client_version(const SSL *s)
5139{
38b051a1
TM		 5140 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5141
5142 /* TODO(QUIC): Do we want to report QUIC version this way instead? */
5143 if (sc == NULL)
5144 return 0;
5145
5146 return sc->client_version;
0f113f3e 5147}
58964a49 5148
0821bcd4 5149SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
0f113f3e 5150{
6546e9b2 5151 return ssl->ctx;
0f113f3e
MC		 5152}
5153
5154SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
5155{
24a0d393 5156 CERT *new_cert;
38b051a1
TM		 5157 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
5158
5159 /* TODO(QUIC): Do we need this for QUIC support? */
5160 if (sc == NULL)
5161 return NULL;
5162
0f113f3e
MC		 5163 if (ssl->ctx == ctx)
5164 return ssl->ctx;
0f113f3e 5165 if (ctx == NULL)
38b051a1 5166 ctx = sc->session_ctx;
24a0d393
KR		 5167 new_cert = ssl_cert_dup(ctx->cert);
5168 if (new_cert == NULL) {
5169 return NULL;
0f113f3e 5170 }
21181889 5171
38b051a1 5172 if (!custom_exts_copy_flags(&new_cert->custext, &sc->cert->custext)) {
21181889
MC		 5173 ssl_cert_free(new_cert);
5174 return NULL;
5175 }
5176
38b051a1
TM		 5177 ssl_cert_free(sc->cert);
5178 sc->cert = new_cert;
0f113f3e
MC		 5179
5180 /*
5181 * Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH),
5182 * so setter APIs must prevent invalid lengths from entering the system.
5183 */
38b051a1 5184 if (!ossl_assert(sc->sid_ctx_length <= sizeof(sc->sid_ctx)))
380a522f 5185 return NULL;
0f113f3e
MC		 5186
5187 /*
5188 * If the session ID context matches that of the parent SSL_CTX,
5189 * inherit it from the new SSL_CTX as well. If however the context does
5190 * not match (i.e., it was set per-ssl with SSL_set_session_id_context),
5191 * leave it unchanged.
5192 */
5193 if ((ssl->ctx != NULL) &&
38b051a1
TM		 5194 (sc->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
5195 (memcmp(sc->sid_ctx, ssl->ctx->sid_ctx, sc->sid_ctx_length) == 0)) {
5196 sc->sid_ctx_length = ctx->sid_ctx_length;
5197 memcpy(&sc->sid_ctx, &ctx->sid_ctx, sizeof(sc->sid_ctx));
0f113f3e
MC		 5198 }
5199
16203f7b 5200 SSL_CTX_up_ref(ctx);
a230b26e 5201 SSL_CTX_free(ssl->ctx); /* decrement reference count */
0f113f3e
MC		 5202 ssl->ctx = ctx;
5203
16203f7b 5204 return ssl->ctx;
0f113f3e 5205}
ed3883d2 5206
4f43d0e7 5207int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
0f113f3e 5208{
d8652be0
MC		 5209 return X509_STORE_set_default_paths_ex(ctx->cert_store, ctx->libctx,
5210 ctx->propq);
0f113f3e 5211}
58964a49 5212
d84a7b20
MC		 5213int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx)
5214{
5215 X509_LOOKUP *lookup;
5216
5217 lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_hash_dir());
5218 if (lookup == NULL)
5219 return 0;
6dcb100f
RL		 5220
5221 /* We ignore errors, in case the directory doesn't exist */
5222 ERR_set_mark();
5223
d84a7b20
MC		 5224 X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
5225
6dcb100f 5226 ERR_pop_to_mark();
d84a7b20
MC		 5227
5228 return 1;
5229}
5230
5231int SSL_CTX_set_default_verify_file(SSL_CTX *ctx)
5232{
5233 X509_LOOKUP *lookup;
5234
5235 lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_file());
5236 if (lookup == NULL)
5237 return 0;
5238
492bc359 5239 /* We ignore errors, in case the file doesn't exist */
6dcb100f
RL		 5240 ERR_set_mark();
5241
d8652be0
MC		 5242 X509_LOOKUP_load_file_ex(lookup, NULL, X509_FILETYPE_DEFAULT, ctx->libctx,
5243 ctx->propq);
d84a7b20 5244
6dcb100f
RL		 5245 ERR_pop_to_mark();
5246
5247 return 1;
5248}
5249
5250int SSL_CTX_set_default_verify_store(SSL_CTX *ctx)
5251{
5252 X509_LOOKUP *lookup;
5253
5254 lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_store());
5255 if (lookup == NULL)
5256 return 0;
5257
5258 /* We ignore errors, in case the directory doesn't exist */
5259 ERR_set_mark();
5260
d8652be0 5261 X509_LOOKUP_add_store_ex(lookup, NULL, ctx->libctx, ctx->propq);
6dcb100f
RL		 5262
5263 ERR_pop_to_mark();
d84a7b20
MC		 5264
5265 return 1;
5266}
5267
6dcb100f
RL		 5268int SSL_CTX_load_verify_file(SSL_CTX *ctx, const char *CAfile)
5269{
d8652be0
MC		 5270 return X509_STORE_load_file_ex(ctx->cert_store, CAfile, ctx->libctx,
5271 ctx->propq);
6dcb100f
RL		 5272}
5273
5274int SSL_CTX_load_verify_dir(SSL_CTX *ctx, const char *CApath)
5275{
5276 return X509_STORE_load_path(ctx->cert_store, CApath);
5277}
5278
5279int SSL_CTX_load_verify_store(SSL_CTX *ctx, const char *CAstore)
5280{
d8652be0
MC		 5281 return X509_STORE_load_store_ex(ctx->cert_store, CAstore, ctx->libctx,
5282 ctx->propq);
6dcb100f
RL		 5283}
5284
303c0028 5285int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
0f113f3e
MC		 5286 const char *CApath)
5287{
6dcb100f
RL		 5288 if (CAfile == NULL && CApath == NULL)
5289 return 0;
5290 if (CAfile != NULL && !SSL_CTX_load_verify_file(ctx, CAfile))
5291 return 0;
5292 if (CApath != NULL && !SSL_CTX_load_verify_dir(ctx, CApath))
5293 return 0;
5294 return 1;
0f113f3e 5295}
58964a49 5296
45d87a1f 5297void SSL_set_info_callback(SSL *ssl,
0f113f3e
MC		 5298 void (*cb) (const SSL *ssl, int type, int val))
5299{
38b051a1
TM		 5300 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
5301
5302 if (sc == NULL)
5303 return;
5304
5305 sc->info_callback = cb;
0f113f3e
MC		 5306}
5307
5308/*
5309 * One compiler (Diab DCC) doesn't like argument names in returned function
5310 * pointer.
5311 */
5312void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
5313 int /* type */ ,
5314 int /* val */ ) {
38b051a1
TM		 5315 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
5316
5317 if (sc == NULL)
5318 return NULL;
5319
5320 return sc->info_callback;
0f113f3e 5321}
58964a49 5322
0f113f3e
MC		 5323void SSL_set_verify_result(SSL *ssl, long arg)
5324{
38b051a1
TM		 5325 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
5326
5327 if (sc == NULL)
5328 return;
5329
5330 sc->verify_result = arg;
0f113f3e 5331}
58964a49 5332
0821bcd4 5333long SSL_get_verify_result(const SSL *ssl)
0f113f3e 5334{
38b051a1
TM		 5335 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
5336
5337 if (sc == NULL)
5338 return 0;
5339
5340 return sc->verify_result;
0f113f3e
MC		 5341}
5342
d9f1c639 5343size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen)
858618e7 5344{
38b051a1
TM		 5345 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
5346
5347 if (sc == NULL)
5348 return 0;
5349
6b8f5d0d 5350 if (outlen == 0)
38b051a1
TM		 5351 return sizeof(sc->s3.client_random);
5352 if (outlen > sizeof(sc->s3.client_random))
5353 outlen = sizeof(sc->s3.client_random);
5354 memcpy(out, sc->s3.client_random, outlen);
d9f1c639 5355 return outlen;
858618e7
NM		 5356}
5357
d9f1c639 5358size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
858618e7 5359{
38b051a1
TM		 5360 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
5361
5362 if (sc == NULL)
5363 return 0;
5364
6b8f5d0d 5365 if (outlen == 0)
38b051a1
TM		 5366 return sizeof(sc->s3.server_random);
5367 if (outlen > sizeof(sc->s3.server_random))
5368 outlen = sizeof(sc->s3.server_random);
5369 memcpy(out, sc->s3.server_random, outlen);
d9f1c639 5370 return outlen;
858618e7
NM		 5371}
5372
d9f1c639 5373size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
a230b26e 5374 unsigned char *out, size_t outlen)
858618e7 5375{
d9f1c639
MC		 5376 if (outlen == 0)
5377 return session->master_key_length;
8c1a5343 5378 if (outlen > session->master_key_length)
858618e7
NM		 5379 outlen = session->master_key_length;
5380 memcpy(out, session->master_key, outlen);
d9f1c639 5381 return outlen;
858618e7
NM		 5382}
5383
725b0f1e 5384int SSL_SESSION_set1_master_key(SSL_SESSION *sess, const unsigned char *in,
911d63f2
MC		 5385 size_t len)
5386{
5387 if (len > sizeof(sess->master_key))
5388 return 0;
5389
5390 memcpy(sess->master_key, in, len);
5391 sess->master_key_length = len;
911d63f2
MC		 5392 return 1;
5393}
5394
5395
0f113f3e
MC		 5396int SSL_set_ex_data(SSL *s, int idx, void *arg)
5397{
26a7d938 5398 return CRYPTO_set_ex_data(&s->ex_data, idx, arg);
0f113f3e
MC		 5399}
5400
5401void *SSL_get_ex_data(const SSL *s, int idx)
5402{
26a7d938 5403 return CRYPTO_get_ex_data(&s->ex_data, idx);
0f113f3e
MC		 5404}
5405
0f113f3e
MC		 5406int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg)
5407{
26a7d938 5408 return CRYPTO_set_ex_data(&s->ex_data, idx, arg);
0f113f3e
MC		 5409}
5410
5411void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx)
5412{
26a7d938 5413 return CRYPTO_get_ex_data(&s->ex_data, idx);
0f113f3e 5414}
58964a49 5415
0821bcd4 5416X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
0f113f3e 5417{
26a7d938 5418 return ctx->cert_store;
0f113f3e 5419}
413c4f45 5420
0f113f3e
MC		 5421void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store)
5422{
222561fe 5423 X509_STORE_free(ctx->cert_store);
0f113f3e
MC		 5424 ctx->cert_store = store;
5425}
413c4f45 5426
b50052db
TS		 5427void SSL_CTX_set1_cert_store(SSL_CTX *ctx, X509_STORE *store)
5428{
5429 if (store != NULL)
5430 X509_STORE_up_ref(store);
5431 SSL_CTX_set_cert_store(ctx, store);
5432}
5433
0821bcd4 5434int SSL_want(const SSL *s)
0f113f3e 5435{
38b051a1
TM		 5436 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5437
5438 if (sc == NULL)
5439 return SSL_NOTHING;
5440
5441 return sc->rwstate;
0f113f3e 5442}
413c4f45 5443
ddac1974
NL		 5444#ifndef OPENSSL_NO_PSK
5445int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
0f113f3e
MC		 5446{
5447 if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
6849b73c 5448 ERR_raise(ERR_LIB_SSL, SSL_R_DATA_LENGTH_TOO_LONG);
0f113f3e
MC		 5449 return 0;
5450 }
df6da24b 5451 OPENSSL_free(ctx->cert->psk_identity_hint);
0f113f3e 5452 if (identity_hint != NULL) {
7644a9ae 5453 ctx->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
df6da24b 5454 if (ctx->cert->psk_identity_hint == NULL)
0f113f3e
MC		 5455 return 0;
5456 } else
df6da24b 5457 ctx->cert->psk_identity_hint = NULL;
0f113f3e
MC		 5458 return 1;
5459}
ddac1974
NL		 5460
5461int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
0f113f3e 5462{
38b051a1
TM		 5463 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5464
5465 if (sc == NULL)
0f113f3e
MC		 5466 return 0;
5467
0f113f3e 5468 if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) {
6849b73c 5469 ERR_raise(ERR_LIB_SSL, SSL_R_DATA_LENGTH_TOO_LONG);
0f113f3e
MC		 5470 return 0;
5471 }
38b051a1 5472 OPENSSL_free(sc->cert->psk_identity_hint);
0f113f3e 5473 if (identity_hint != NULL) {
38b051a1
TM		 5474 sc->cert->psk_identity_hint = OPENSSL_strdup(identity_hint);
5475 if (sc->cert->psk_identity_hint == NULL)
0f113f3e
MC		 5476 return 0;
5477 } else
38b051a1 5478 sc->cert->psk_identity_hint = NULL;
0f113f3e
MC		 5479 return 1;
5480}
ddac1974
NL		 5481
5482const char *SSL_get_psk_identity_hint(const SSL *s)
0f113f3e 5483{
38b051a1
TM		 5484 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5485
5486 if (sc == NULL || sc->session == NULL)
0f113f3e 5487 return NULL;
38b051a1
TM		 5488
5489 return sc->session->psk_identity_hint;
0f113f3e 5490}
ddac1974
NL		 5491
5492const char *SSL_get_psk_identity(const SSL *s)
0f113f3e 5493{
38b051a1
TM		 5494 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5495
5496 if (sc == NULL || sc->session == NULL)
0f113f3e 5497 return NULL;
38b051a1
TM		 5498
5499 return sc->session->psk_identity;
0f113f3e 5500}
7806f3dd 5501
8cbfcc70 5502void SSL_set_psk_client_callback(SSL *s, SSL_psk_client_cb_func cb)
0f113f3e 5503{
38b051a1
TM		 5504 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5505
5506 if (sc == NULL)
5507 return;
5508
5509 sc->psk_client_callback = cb;
0f113f3e 5510}
7806f3dd 5511
8cbfcc70 5512void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb)
0f113f3e
MC		 5513{
5514 ctx->psk_client_callback = cb;
5515}
7806f3dd 5516
8cbfcc70 5517void SSL_set_psk_server_callback(SSL *s, SSL_psk_server_cb_func cb)
0f113f3e 5518{
38b051a1
TM		 5519 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5520
5521 if (sc == NULL)
5522 return;
5523
5524 sc->psk_server_callback = cb;
0f113f3e 5525}
7806f3dd 5526
8cbfcc70 5527void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb)
0f113f3e
MC		 5528{
5529 ctx->psk_server_callback = cb;
5530}
5531#endif
5532
f46184bd
MC		 5533void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb)
5534{
38b051a1
TM		 5535 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5536
5537 if (sc == NULL)
5538 return;
5539
5540 sc->psk_find_session_cb = cb;
f46184bd
MC		 5541}
5542
5543void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx,
5544 SSL_psk_find_session_cb_func cb)
5545{
5546 ctx->psk_find_session_cb = cb;
5547}
5548
5549void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb)
5550{
38b051a1
TM		 5551 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5552
5553 if (sc == NULL)
5554 return;
5555
5556 sc->psk_use_session_cb = cb;
f46184bd
MC		 5557}
5558
5559void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx,
5560 SSL_psk_use_session_cb_func cb)
5561{
5562 ctx->psk_use_session_cb = cb;
5563}
5564
0f113f3e
MC		 5565void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
5566 void (*cb) (int write_p, int version,
5567 int content_type, const void *buf,
5568 size_t len, SSL *ssl, void *arg))
5569{
5570 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
5571}
5572
5573void SSL_set_msg_callback(SSL *ssl,
5574 void (*cb) (int write_p, int version,
5575 int content_type, const void *buf,
5576 size_t len, SSL *ssl, void *arg))
5577{
5578 SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
5579}
a661b653 5580
7c2d4fee 5581void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
0f113f3e
MC		 5582 int (*cb) (SSL *ssl,
5583 int
5584 is_forward_secure))
5585{
5586 SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
5587 (void (*)(void))cb);
5588}
5589
7c2d4fee 5590void SSL_set_not_resumable_session_callback(SSL *ssl,
0f113f3e
MC		 5591 int (*cb) (SSL *ssl,
5592 int is_forward_secure))
5593{
5594 SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
5595 (void (*)(void))cb);
5596}
5597
c649d10d
TS		 5598void SSL_CTX_set_record_padding_callback(SSL_CTX *ctx,
5599 size_t (*cb) (SSL *ssl, int type,
5600 size_t len, void *arg))
5601{
5602 ctx->record_padding_cb = cb;
5603}
5604
5605void SSL_CTX_set_record_padding_callback_arg(SSL_CTX *ctx, void *arg)
5606{
5607 ctx->record_padding_arg = arg;
5608}
5609
3499327b 5610void *SSL_CTX_get_record_padding_callback_arg(const SSL_CTX *ctx)
c649d10d
TS		 5611{
5612 return ctx->record_padding_arg;
5613}
5614
5615int SSL_CTX_set_block_padding(SSL_CTX *ctx, size_t block_size)
5616{
5617 /* block size of 0 or 1 is basically no padding */
5618 if (block_size == 1)
5619 ctx->block_padding = 0;
5620 else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH)
5621 ctx->block_padding = block_size;
5622 else
5623 return 0;
5624 return 1;
5625}
5626
a6d36303 5627int SSL_set_record_padding_callback(SSL *ssl,
c649d10d
TS		 5628 size_t (*cb) (SSL *ssl, int type,
5629 size_t len, void *arg))
5630{
a6d36303 5631 BIO *b;
38b051a1
TM		 5632 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
5633
5634 if (sc == NULL)
5635 return 0;
a6d36303
VF		 5636
5637 b = SSL_get_wbio(ssl);
5638 if (b == NULL || !BIO_get_ktls_send(b)) {
eb7d6c2a 5639 sc->rlayer.record_padding_cb = cb;
a6d36303
VF		 5640 return 1;
5641 }
5642 return 0;
c649d10d
TS		 5643}
5644
5645void SSL_set_record_padding_callback_arg(SSL *ssl, void *arg)
5646{
38b051a1
TM		 5647 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
5648
5649 if (sc == NULL)
5650 return;
5651
eb7d6c2a 5652 sc->rlayer.record_padding_arg = arg;
c649d10d
TS		 5653}
5654
3499327b 5655void *SSL_get_record_padding_callback_arg(const SSL *ssl)
c649d10d 5656{
38b051a1
TM		 5657 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
5658
5659 if (sc == NULL)
5660 return NULL;
5661
eb7d6c2a 5662 return sc->rlayer.record_padding_arg;
c649d10d
TS		 5663}
5664
5665int SSL_set_block_padding(SSL *ssl, size_t block_size)
5666{
38b051a1
TM		 5667 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
5668
5669 if (sc == NULL)
5670 return 0;
5671
c649d10d
TS		 5672 /* block size of 0 or 1 is basically no padding */
5673 if (block_size == 1)
eb7d6c2a 5674 sc->rlayer.block_padding = 0;
c649d10d 5675 else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH)
eb7d6c2a 5676 sc->rlayer.block_padding = block_size;
c649d10d
TS		 5677 else
5678 return 0;
5679 return 1;
5680}
5681
9d0a8bb7
MC		 5682int SSL_set_num_tickets(SSL *s, size_t num_tickets)
5683{
38b051a1
TM		 5684 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5685
5686 if (sc == NULL)
5687 return 0;
5688
5689 sc->num_tickets = num_tickets;
9d0a8bb7
MC		 5690
5691 return 1;
5692}
5693
3499327b 5694size_t SSL_get_num_tickets(const SSL *s)
9d0a8bb7 5695{
38b051a1
TM		 5696 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5697
5698 if (sc == NULL)
5699 return 0;
5700
5701 return sc->num_tickets;
9d0a8bb7
MC		 5702}
5703
5704int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets)
5705{
5706 ctx->num_tickets = num_tickets;
5707
5708 return 1;
5709}
5710
3499327b 5711size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx)
9d0a8bb7
MC		 5712{
5713 return ctx->num_tickets;
5714}
5715
48fbcbac 5716/* Retrieve handshake hashes */
38b051a1
TM		 5717int ssl_handshake_hash(SSL_CONNECTION *s,
5718 unsigned char *out, size_t outlen,
8c1a5343 5719 size_t *hashlen)
48fbcbac 5720{
6e59a892 5721 EVP_MD_CTX *ctx = NULL;
555cbb32 5722 EVP_MD_CTX *hdgst = s->s3.handshake_dgst;
ed576acd 5723 int hashleni = EVP_MD_CTX_get_size(hdgst);
8c1a5343
MC		 5724 int ret = 0;
5725
f63a17d6 5726 if (hashleni < 0 || (size_t)hashleni > outlen) {
c48ffbcc 5727 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
28ba2541 5728 goto err;
f63a17d6 5729 }
8c1a5343 5730
bfb0641f 5731 ctx = EVP_MD_CTX_new();
147ed5f9
TL		 5732 if (ctx == NULL) {
5733 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
6e59a892 5734 goto err;
147ed5f9 5735 }
8c1a5343 5736
6e59a892 5737 if (!EVP_MD_CTX_copy_ex(ctx, hdgst)
f63a17d6 5738 || EVP_DigestFinal_ex(ctx, out, NULL) <= 0) {
c48ffbcc 5739 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
8c1a5343 5740 goto err;
f63a17d6 5741 }
8c1a5343
MC		 5742
5743 *hashlen = hashleni;
5744
5745 ret = 1;
48fbcbac 5746 err:
bfb0641f 5747 EVP_MD_CTX_free(ctx);
48fbcbac
DSH		 5748 return ret;
5749}
5750
c04b66b1 5751int SSL_session_reused(const SSL *s)
0f113f3e 5752{
38b051a1
TM		 5753 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5754
5755 if (sc == NULL)
5756 return 0;
5757
5758 return sc->hit;
0f113f3e 5759}
08557cf2 5760
69443116 5761int SSL_is_server(const SSL *s)
0f113f3e 5762{
38b051a1
TM		 5763 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5764
5765 if (sc == NULL)
5766 return 0;
5767
5768 return sc->server;
0f113f3e 5769}
87adf1fa 5770
00db8c60 5771#ifndef OPENSSL_NO_DEPRECATED_1_1_0
47153c72
RS		 5772void SSL_set_debug(SSL *s, int debug)
5773{
5774 /* Old function was do-nothing anyway... */
5775 (void)s;
5776 (void)debug;
5777}
5778#endif
5779
b362ccab 5780void SSL_set_security_level(SSL *s, int level)
0f113f3e 5781{
38b051a1
TM		 5782 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5783
5784 if (sc == NULL)
5785 return;
5786
5787 sc->cert->sec_level = level;
0f113f3e 5788}
b362ccab
DSH		 5789
5790int SSL_get_security_level(const SSL *s)
0f113f3e 5791{
38b051a1
TM		 5792 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5793
5794 if (sc == NULL)
5795 return 0;
5796
5797 return sc->cert->sec_level;
0f113f3e 5798}
b362ccab 5799
0f113f3e 5800void SSL_set_security_callback(SSL *s,
a230b26e
EK		 5801 int (*cb) (const SSL *s, const SSL_CTX *ctx,
5802 int op, int bits, int nid,
5803 void *other, void *ex))
0f113f3e 5804{
38b051a1
TM		 5805 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5806
5807 if (sc == NULL)
5808 return;
5809
5810 sc->cert->sec_cb = cb;
0f113f3e 5811}
b362ccab 5812
a230b26e
EK		 5813int (*SSL_get_security_callback(const SSL *s)) (const SSL *s,
5814 const SSL_CTX *ctx, int op,
5815 int bits, int nid, void *other,
5816 void *ex) {
38b051a1
TM		 5817 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5818
5819 if (sc == NULL)
5820 return NULL;
5821
5822 return sc->cert->sec_cb;
0f113f3e 5823}
b362ccab
DSH		 5824
5825void SSL_set0_security_ex_data(SSL *s, void *ex)
0f113f3e 5826{
38b051a1
TM		 5827 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5828
5829 if (sc == NULL)
5830 return;
5831
5832 sc->cert->sec_ex = ex;
0f113f3e 5833}
b362ccab
DSH		 5834
5835void *SSL_get0_security_ex_data(const SSL *s)
0f113f3e 5836{
38b051a1
TM		 5837 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5838
5839 if (sc == NULL)
5840 return NULL;
5841
5842 return sc->cert->sec_ex;
0f113f3e 5843}
b362ccab
DSH		 5844
5845void SSL_CTX_set_security_level(SSL_CTX *ctx, int level)
0f113f3e
MC		 5846{
5847 ctx->cert->sec_level = level;
5848}
b362ccab
DSH		 5849
5850int SSL_CTX_get_security_level(const SSL_CTX *ctx)
0f113f3e
MC		 5851{
5852 return ctx->cert->sec_level;
5853}
b362ccab 5854
0f113f3e 5855void SSL_CTX_set_security_callback(SSL_CTX *ctx,
a230b26e
EK		 5856 int (*cb) (const SSL *s, const SSL_CTX *ctx,
5857 int op, int bits, int nid,
5858 void *other, void *ex))
0f113f3e
MC		 5859{
5860 ctx->cert->sec_cb = cb;
5861}
b362ccab 5862
e4646a89
KR		 5863int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
5864 const SSL_CTX *ctx,
0f113f3e
MC		 5865 int op, int bits,
5866 int nid,
5867 void *other,
5868 void *ex) {
5869 return ctx->cert->sec_cb;
5870}
b362ccab
DSH		 5871
5872void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex)
0f113f3e
MC		 5873{
5874 ctx->cert->sec_ex = ex;
5875}
b362ccab
DSH		 5876
5877void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx)
0f113f3e
MC		 5878{
5879 return ctx->cert->sec_ex;
5880}
b362ccab 5881
56bd1783 5882uint64_t SSL_CTX_get_options(const SSL_CTX *ctx)
8106cb8b
VD		 5883{
5884 return ctx->options;
5885}
a230b26e 5886
56bd1783 5887uint64_t SSL_get_options(const SSL *s)
8106cb8b 5888{
38b051a1
TM		 5889 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5890
5891 if (sc == NULL)
5892 return 0;
5893
5894 return sc->options;
8106cb8b 5895}
a230b26e 5896
56bd1783 5897uint64_t SSL_CTX_set_options(SSL_CTX *ctx, uint64_t op)
8106cb8b
VD		 5898{
5899 return ctx->options |= op;
5900}
a230b26e 5901
56bd1783 5902uint64_t SSL_set_options(SSL *s, uint64_t op)
8106cb8b 5903{
a02571a0 5904 SSL_CONNECTION *sc;
4566dae7 5905 OSSL_PARAM options[2], *opts = options;
38b051a1 5906
a02571a0
TM		 5907#ifndef OPENSSL_NO_QUIC
5908 if (IS_QUIC(s) && ossl_quic_set_ssl_op(s, op))
5909 /* Handled by QUIC, return as set */
5910 return op;
5911#endif
5912
5913 sc = SSL_CONNECTION_FROM_SSL(s);
5914 if (sc == NULL)
38b051a1
TM		 5915 return 0;
5916
4566dae7
MC		 5917 sc->options |= op;
5918
5919 *opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS,
5920 &sc->options);
5921 *opts = OSSL_PARAM_construct_end();
5922
5923 /* Ignore return value */
5924 sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options);
5925
5926 return sc->options;
8106cb8b 5927}
a230b26e 5928
56bd1783 5929uint64_t SSL_CTX_clear_options(SSL_CTX *ctx, uint64_t op)
8106cb8b
VD		 5930{
5931 return ctx->options &= ~op;
5932}
a230b26e 5933
56bd1783 5934uint64_t SSL_clear_options(SSL *s, uint64_t op)
8106cb8b 5935{
38b051a1
TM		 5936 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
5937
5938 if (sc == NULL)
5939 return 0;
5940
5941 return sc->options &= ~op;
8106cb8b
VD		 5942}
5943
696178ed
DSH		 5944STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s)
5945{
38b051a1
TM		 5946 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
5947
5948 if (sc == NULL)
5949 return NULL;
5950
5951 return sc->verified_chain;
696178ed
DSH		 5952}
5953
0f113f3e 5954IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
ed29e82a
RP		 5955
5956#ifndef OPENSSL_NO_CT
5957
5958/*
5959 * Moves SCTs from the |src| stack to the |dst| stack.
5960 * The source of each SCT will be set to |origin|.
5961 * If |dst| points to a NULL pointer, a new stack will be created and owned by
5962 * the caller.
5963 * Returns the number of SCTs moved, or a negative integer if an error occurs.
5964 */
a230b26e
EK		 5965static int ct_move_scts(STACK_OF(SCT) **dst, STACK_OF(SCT) *src,
5966 sct_source_t origin)
ed29e82a
RP		 5967{
5968 int scts_moved = 0;
5969 SCT *sct = NULL;
5970
5971 if (*dst == NULL) {
5972 *dst = sk_SCT_new_null();
5973 if (*dst == NULL) {
e077455e 5974 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
ed29e82a
RP		 5975 goto err;
5976 }
5977 }
5978
a8086e6b 5979 while ((sct = sk_SCT_pop(src)) != NULL) {
ed29e82a
RP		 5980 if (SCT_set_source(sct, origin) != 1)
5981 goto err;
5982
5983 if (sk_SCT_push(*dst, sct) <= 0)
5984 goto err;
5985 scts_moved += 1;
5986 }
5987
5988 return scts_moved;
a230b26e 5989 err:
ed29e82a 5990 if (sct != NULL)
a230b26e 5991 sk_SCT_push(src, sct); /* Put the SCT back */
cc7113e8 5992 return -1;
ed29e82a
RP		 5993}
5994
5995/*
a230b26e 5996 * Look for data collected during ServerHello and parse if found.
6b13bd1d 5997 * Returns the number of SCTs extracted.
a230b26e 5998 */
38b051a1 5999static int ct_extract_tls_extension_scts(SSL_CONNECTION *s)
ed29e82a
RP		 6000{
6001 int scts_extracted = 0;
6002
aff8c126
RS		 6003 if (s->ext.scts != NULL) {
6004 const unsigned char *p = s->ext.scts;
6005 STACK_OF(SCT) *scts = o2i_SCT_LIST(NULL, &p, s->ext.scts_len);
ed29e82a
RP		 6006
6007 scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_TLS_EXTENSION);
6008
6009 SCT_LIST_free(scts);
6010 }
6011
6012 return scts_extracted;
6013}
6014
6015/*
6016 * Checks for an OCSP response and then attempts to extract any SCTs found if it
6017 * contains an SCT X509 extension. They will be stored in |s->scts|.
6018 * Returns:
6019 * - The number of SCTs extracted, assuming an OCSP response exists.
6020 * - 0 if no OCSP response exists or it contains no SCTs.
6021 * - A negative integer if an error occurs.
6022 */
38b051a1 6023static int ct_extract_ocsp_response_scts(SSL_CONNECTION *s)
ed29e82a 6024{
a230b26e 6025# ifndef OPENSSL_NO_OCSP
ed29e82a
RP		 6026 int scts_extracted = 0;
6027 const unsigned char *p;
6028 OCSP_BASICRESP *br = NULL;
6029 OCSP_RESPONSE *rsp = NULL;
6030 STACK_OF(SCT) *scts = NULL;
6031 int i;
6032
aff8c126 6033 if (s->ext.ocsp.resp == NULL || s->ext.ocsp.resp_len == 0)
ed29e82a
RP		 6034 goto err;
6035
aff8c126
RS		 6036 p = s->ext.ocsp.resp;
6037 rsp = d2i_OCSP_RESPONSE(NULL, &p, (int)s->ext.ocsp.resp_len);
ed29e82a
RP		 6038 if (rsp == NULL)
6039 goto err;
6040
6041 br = OCSP_response_get1_basic(rsp);
6042 if (br == NULL)
6043 goto err;
6044
6045 for (i = 0; i < OCSP_resp_count(br); ++i) {
6046 OCSP_SINGLERESP *single = OCSP_resp_get0(br, i);
6047
6048 if (single == NULL)
6049 continue;
6050
a230b26e
EK		 6051 scts =
6052 OCSP_SINGLERESP_get1_ext_d2i(single, NID_ct_cert_scts, NULL, NULL);
6053 scts_extracted =
6054 ct_move_scts(&s->scts, scts, SCT_SOURCE_OCSP_STAPLED_RESPONSE);
ed29e82a
RP		 6055 if (scts_extracted < 0)
6056 goto err;
6057 }
a230b26e 6058 err:
ed29e82a
RP		 6059 SCT_LIST_free(scts);
6060 OCSP_BASICRESP_free(br);
6061 OCSP_RESPONSE_free(rsp);
6062 return scts_extracted;
a230b26e 6063# else
3e41ac35
MC		 6064 /* Behave as if no OCSP response exists */
6065 return 0;
a230b26e 6066# endif
ed29e82a
RP		 6067}
6068
6069/*
6070 * Attempts to extract SCTs from the peer certificate.
6071 * Return the number of SCTs extracted, or a negative integer if an error
6072 * occurs.
6073 */
38b051a1 6074static int ct_extract_x509v3_extension_scts(SSL_CONNECTION *s)
ed29e82a
RP		 6075{
6076 int scts_extracted = 0;
3f3c7d26 6077 X509 *cert = s->session != NULL ? s->session->peer : NULL;
ed29e82a
RP		 6078
6079 if (cert != NULL) {
6080 STACK_OF(SCT) *scts =
6081 X509_get_ext_d2i(cert, NID_ct_precert_scts, NULL, NULL);
6082
6083 scts_extracted =
6084 ct_move_scts(&s->scts, scts, SCT_SOURCE_X509V3_EXTENSION);
6085
6086 SCT_LIST_free(scts);
6087 }
6088
6089 return scts_extracted;
6090}
6091
6092/*
6093 * Attempts to find all received SCTs by checking TLS extensions, the OCSP
6094 * response (if it exists) and X509v3 extensions in the certificate.
6095 * Returns NULL if an error occurs.
6096 */
6097const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s)
6098{
38b051a1
TM		 6099 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6100
6101 if (sc == NULL)
6102 return NULL;
6103
6104 if (!sc->scts_parsed) {
6105 if (ct_extract_tls_extension_scts(sc) < 0 ||
6106 ct_extract_ocsp_response_scts(sc) < 0 ||
6107 ct_extract_x509v3_extension_scts(sc) < 0)
ed29e82a
RP		 6108 goto err;
6109
38b051a1 6110 sc->scts_parsed = 1;
ed29e82a 6111 }
38b051a1 6112 return sc->scts;
a230b26e 6113 err:
ed29e82a
RP		 6114 return NULL;
6115}
6116
a230b26e 6117static int ct_permissive(const CT_POLICY_EVAL_CTX * ctx,
43341433 6118 const STACK_OF(SCT) *scts, void *unused_arg)
ed29e82a 6119{
43341433
VD		 6120 return 1;
6121}
6122
a230b26e 6123static int ct_strict(const CT_POLICY_EVAL_CTX * ctx,
43341433
VD		 6124 const STACK_OF(SCT) *scts, void *unused_arg)
6125{
6126 int count = scts != NULL ? sk_SCT_num(scts) : 0;
6127 int i;
ed29e82a 6128
43341433
VD		 6129 for (i = 0; i < count; ++i) {
6130 SCT *sct = sk_SCT_value(scts, i);
6131 int status = SCT_get_validation_status(sct);
6132
6133 if (status == SCT_VALIDATION_STATUS_VALID)
6134 return 1;
6135 }
6849b73c 6136 ERR_raise(ERR_LIB_SSL, SSL_R_NO_VALID_SCTS);
43341433
VD		 6137 return 0;
6138}
6139
6140int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
6141 void *arg)
6142{
38b051a1
TM		 6143 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6144
6145 if (sc == NULL)
6146 return 0;
6147
ed29e82a
RP		 6148 /*
6149 * Since code exists that uses the custom extension handler for CT, look
6150 * for this and throw an error if they have already registered to use CT.
6151 */
6152 if (callback != NULL && SSL_CTX_has_client_custom_ext(s->ctx,
a230b26e
EK		 6153 TLSEXT_TYPE_signed_certificate_timestamp))
6154 {
6849b73c 6155 ERR_raise(ERR_LIB_SSL, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
43341433 6156 return 0;
ed29e82a
RP		 6157 }
6158
ed29e82a 6159 if (callback != NULL) {
a230b26e
EK		 6160 /*
6161 * If we are validating CT, then we MUST accept SCTs served via OCSP
6162 */
ed29e82a 6163 if (!SSL_set_tlsext_status_type(s, TLSEXT_STATUSTYPE_ocsp))
43341433 6164 return 0;
ed29e82a
RP		 6165 }
6166
38b051a1
TM		 6167 sc->ct_validation_callback = callback;
6168 sc->ct_validation_callback_arg = arg;
43341433
VD		 6169
6170 return 1;
ed29e82a
RP		 6171}
6172
43341433 6173int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
a230b26e 6174 ssl_ct_validation_cb callback, void *arg)
ed29e82a 6175{
ed29e82a
RP		 6176 /*
6177 * Since code exists that uses the custom extension handler for CT, look for
6178 * this and throw an error if they have already registered to use CT.
6179 */
6180 if (callback != NULL && SSL_CTX_has_client_custom_ext(ctx,
a230b26e
EK		 6181 TLSEXT_TYPE_signed_certificate_timestamp))
6182 {
6849b73c 6183 ERR_raise(ERR_LIB_SSL, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
43341433 6184 return 0;
ed29e82a
RP		 6185 }
6186
6187 ctx->ct_validation_callback = callback;
6188 ctx->ct_validation_callback_arg = arg;
43341433 6189 return 1;
ed29e82a
RP		 6190}
6191
43341433 6192int SSL_ct_is_enabled(const SSL *s)
ed29e82a 6193{
38b051a1
TM		 6194 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
6195
6196 if (sc == NULL)
6197 return 0;
6198
6199 return sc->ct_validation_callback != NULL;
ed29e82a
RP		 6200}
6201
43341433 6202int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx)
ed29e82a 6203{
43341433 6204 return ctx->ct_validation_callback != NULL;
ed29e82a
RP		 6205}
6206
38b051a1 6207int ssl_validate_ct(SSL_CONNECTION *s)
ed29e82a
RP		 6208{
6209 int ret = 0;
3f3c7d26 6210 X509 *cert = s->session != NULL ? s->session->peer : NULL;
43341433 6211 X509 *issuer;
b9aec69a 6212 SSL_DANE *dane = &s->dane;
ed29e82a
RP		 6213 CT_POLICY_EVAL_CTX *ctx = NULL;
6214 const STACK_OF(SCT) *scts;
6215
43341433
VD		 6216 /*
6217 * If no callback is set, the peer is anonymous, or its chain is invalid,
6218 * skip SCT validation - just return success. Applications that continue
6219 * handshakes without certificates, with unverified chains, or pinned leaf
6220 * certificates are outside the scope of the WebPKI and CT.
6221 *
6222 * The above exclusions notwithstanding the vast majority of peers will
6223 * have rather ordinary certificate chains validated by typical
6224 * applications that perform certificate verification and therefore will
6225 * process SCTs when enabled.
6226 */
6227 if (s->ct_validation_callback == NULL || cert == NULL ||
6228 s->verify_result != X509_V_OK ||
a230b26e 6229 s->verified_chain == NULL || sk_X509_num(s->verified_chain) <= 1)
ed29e82a
RP		 6230 return 1;
6231
43341433
VD		 6232 /*
6233 * CT not applicable for chains validated via DANE-TA(2) or DANE-EE(3)
6234 * trust-anchors. See https://tools.ietf.org/html/rfc7671#section-4.2
6235 */
6236 if (DANETLS_ENABLED(dane) && dane->mtlsa != NULL) {
6237 switch (dane->mtlsa->usage) {
6238 case DANETLS_USAGE_DANE_TA:
6239 case DANETLS_USAGE_DANE_EE:
6240 return 1;
6241 }
ed29e82a
RP		 6242 }
6243
38b051a1
TM		 6244 ctx = CT_POLICY_EVAL_CTX_new_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
6245 SSL_CONNECTION_GET_CTX(s)->propq);
ed29e82a 6246 if (ctx == NULL) {
e077455e 6247 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CT_LIB);
ed29e82a
RP		 6248 goto end;
6249 }
6250
43341433 6251 issuer = sk_X509_value(s->verified_chain, 1);
a1bb7708
RP		 6252 CT_POLICY_EVAL_CTX_set1_cert(ctx, cert);
6253 CT_POLICY_EVAL_CTX_set1_issuer(ctx, issuer);
38b051a1
TM		 6254 CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(ctx,
6255 SSL_CONNECTION_GET_CTX(s)->ctlog_store);
6a71e06d 6256 CT_POLICY_EVAL_CTX_set_time(
38b051a1 6257 ctx, (uint64_t)SSL_SESSION_get_time(s->session) * 1000);
ed29e82a 6258
38b051a1 6259 scts = SSL_get0_peer_scts(SSL_CONNECTION_GET_SSL(s));
ed29e82a 6260
43341433
VD		 6261 /*
6262 * This function returns success (> 0) only when all the SCTs are valid, 0
6263 * when some are invalid, and < 0 on various internal errors (out of
6264 * memory, etc.). Having some, or even all, invalid SCTs is not sufficient
6265 * reason to abort the handshake, that decision is up to the callback.
6266 * Therefore, we error out only in the unexpected case that the return
6267 * value is negative.
6268 *
6269 * XXX: One might well argue that the return value of this function is an
f430ba31 6270 * unfortunate design choice. Its job is only to determine the validation
43341433
VD		 6271 * status of each of the provided SCTs. So long as it correctly separates
6272 * the wheat from the chaff it should return success. Failure in this case
6273 * ought to correspond to an inability to carry out its duties.
6274 */
6275 if (SCT_LIST_validate(scts, ctx) < 0) {
c48ffbcc 6276 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_SCT_VERIFICATION_FAILED);
ed29e82a
RP		 6277 goto end;
6278 }
6279
6280 ret = s->ct_validation_callback(ctx, scts, s->ct_validation_callback_arg);
6281 if (ret < 0)
a230b26e 6282 ret = 0; /* This function returns 0 on failure */
f63a17d6 6283 if (!ret)
c48ffbcc 6284 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_CALLBACK_FAILED);
ed29e82a 6285
a230b26e 6286 end:
ed29e82a 6287 CT_POLICY_EVAL_CTX_free(ctx);
f75b34c8
VD		 6288 /*
6289 * With SSL_VERIFY_NONE the session may be cached and re-used despite a
6290 * failure return code here. Also the application may wish the complete
6291 * the handshake, and then disconnect cleanly at a higher layer, after
6292 * checking the verification status of the completed connection.
6293 *
6294 * We therefore force a certificate verification failure which will be
6295 * visible via SSL_get_verify_result() and cached as part of any resumed
6296 * session.
6297 *
6298 * Note: the permissive callback is for information gathering only, always
6299 * returns success, and does not affect verification status. Only the
6300 * strict callback or a custom application-specified callback can trigger
6301 * connection failure or record a verification error.
6302 */
6303 if (ret <= 0)
6304 s->verify_result = X509_V_ERR_NO_VALID_SCTS;
ed29e82a
RP		 6305 return ret;
6306}
6307
43341433
VD		 6308int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode)
6309{
6310 switch (validation_mode) {
6311 default:
6849b73c 6312 ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CT_VALIDATION_TYPE);
43341433
VD		 6313 return 0;
6314 case SSL_CT_VALIDATION_PERMISSIVE:
6315 return SSL_CTX_set_ct_validation_callback(ctx, ct_permissive, NULL);
6316 case SSL_CT_VALIDATION_STRICT:
6317 return SSL_CTX_set_ct_validation_callback(ctx, ct_strict, NULL);
6318 }
6319}
6320
6321int SSL_enable_ct(SSL *s, int validation_mode)
6322{
6323 switch (validation_mode) {
6324 default:
6849b73c 6325 ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CT_VALIDATION_TYPE);
43341433
VD		 6326 return 0;
6327 case SSL_CT_VALIDATION_PERMISSIVE:
6328 return SSL_set_ct_validation_callback(s, ct_permissive, NULL);
6329 case SSL_CT_VALIDATION_STRICT:
6330 return SSL_set_ct_validation_callback(s, ct_strict, NULL);
6331 }
6332}
6333
ed29e82a
RP		 6334int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx)
6335{
328f36c5 6336 return CTLOG_STORE_load_default_file(ctx->ctlog_store);
ed29e82a
RP		 6337}
6338
6339int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path)
6340{
6341 return CTLOG_STORE_load_file(ctx->ctlog_store, path);
6342}
6343
a230b26e 6344void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE * logs)
8359b57f
RP		 6345{
6346 CTLOG_STORE_free(ctx->ctlog_store);
6347 ctx->ctlog_store = logs;
6348}
6349
6350const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx)
6351{
6352 return ctx->ctlog_store;
6353}
6354
6b1bb98f
BK		 6355#endif /* OPENSSL_NO_CT */
6356
a9c0d8be
DB		 6357void SSL_CTX_set_client_hello_cb(SSL_CTX *c, SSL_client_hello_cb_fn cb,
6358 void *arg)
6b1bb98f 6359{
a9c0d8be
DB		 6360 c->client_hello_cb = cb;
6361 c->client_hello_cb_arg = arg;
6b1bb98f
BK		 6362}
6363
a9c0d8be 6364int SSL_client_hello_isv2(SSL *s)
6b1bb98f 6365{
38b051a1
TM		 6366 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6367
6368 if (sc == NULL)
6369 return 0;
6370
6371 if (sc->clienthello == NULL)
6b1bb98f 6372 return 0;
38b051a1 6373 return sc->clienthello->isv2;
6b1bb98f
BK		 6374}
6375
a9c0d8be 6376unsigned int SSL_client_hello_get0_legacy_version(SSL *s)
6b1bb98f 6377{
38b051a1
TM		 6378 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6379
6380 if (sc == NULL)
6381 return 0;
6382
6383 if (sc->clienthello == NULL)
6b1bb98f 6384 return 0;
38b051a1 6385 return sc->clienthello->legacy_version;
6b1bb98f
BK		 6386}
6387
a9c0d8be 6388size_t SSL_client_hello_get0_random(SSL *s, const unsigned char **out)
6b1bb98f 6389{
38b051a1
TM		 6390 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6391
6392 if (sc == NULL)
6393 return 0;
6394
6395 if (sc->clienthello == NULL)
6b1bb98f
BK		 6396 return 0;
6397 if (out != NULL)
38b051a1 6398 *out = sc->clienthello->random;
6b1bb98f
BK		 6399 return SSL3_RANDOM_SIZE;
6400}
6401
a9c0d8be 6402size_t SSL_client_hello_get0_session_id(SSL *s, const unsigned char **out)
6b1bb98f 6403{
38b051a1
TM		 6404 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6405
6406 if (sc == NULL)
6407 return 0;
6408
6409 if (sc->clienthello == NULL)
6b1bb98f
BK		 6410 return 0;
6411 if (out != NULL)
38b051a1
TM		 6412 *out = sc->clienthello->session_id;
6413 return sc->clienthello->session_id_len;
6b1bb98f
BK		 6414}
6415
a9c0d8be 6416size_t SSL_client_hello_get0_ciphers(SSL *s, const unsigned char **out)
6b1bb98f 6417{
38b051a1
TM		 6418 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6419
6420 if (sc == NULL)
6421 return 0;
6422
6423 if (sc->clienthello == NULL)
6b1bb98f
BK		 6424 return 0;
6425 if (out != NULL)
38b051a1
TM		 6426 *out = PACKET_data(&sc->clienthello->ciphersuites);
6427 return PACKET_remaining(&sc->clienthello->ciphersuites);
6b1bb98f
BK		 6428}
6429
a9c0d8be 6430size_t SSL_client_hello_get0_compression_methods(SSL *s, const unsigned char **out)
6b1bb98f 6431{
38b051a1
TM		 6432 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6433
6434 if (sc == NULL)
6435 return 0;
6436
6437 if (sc->clienthello == NULL)
6b1bb98f
BK		 6438 return 0;
6439 if (out != NULL)
38b051a1
TM		 6440 *out = sc->clienthello->compressions;
6441 return sc->clienthello->compressions_len;
6b1bb98f
BK		 6442}
6443
a9c0d8be 6444int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen)
193b5d76
BK		 6445{
6446 RAW_EXTENSION *ext;
6447 int *present;
6448 size_t num = 0, i;
38b051a1 6449 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
193b5d76 6450
38b051a1 6451 if (sc == NULL)
193b5d76 6452 return 0;
38b051a1
TM		 6453
6454 if (sc->clienthello == NULL || out == NULL || outlen == NULL)
6455 return 0;
6456 for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
6457 ext = sc->clienthello->pre_proc_exts + i;
193b5d76
BK		 6458 if (ext->present)
6459 num++;
6460 }
6fda11ae 6461 if (num == 0) {
6462 *out = NULL;
6463 *outlen = 0;
6464 return 1;
6465 }
e077455e 6466 if ((present = OPENSSL_malloc(sizeof(*present) * num)) == NULL)
193b5d76 6467 return 0;
38b051a1
TM		 6468 for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
6469 ext = sc->clienthello->pre_proc_exts + i;
193b5d76
BK		 6470 if (ext->present) {
6471 if (ext->received_order >= num)
6472 goto err;
6473 present[ext->received_order] = ext->type;
6474 }
6475 }
6476 *out = present;
6477 *outlen = num;
6478 return 1;
6479 err:
6480 OPENSSL_free(present);
6481 return 0;
6482}
6483
13a53fbf
PL		 6484int SSL_client_hello_get_extension_order(SSL *s, uint16_t *exts, size_t *num_exts)
6485{
6486 RAW_EXTENSION *ext;
6487 size_t num = 0, i;
38b051a1
TM		 6488 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6489
6490 if (sc == NULL)
6491 return 0;
13a53fbf 6492
38b051a1 6493 if (sc->clienthello == NULL || num_exts == NULL)
13a53fbf 6494 return 0;
38b051a1
TM		 6495 for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
6496 ext = sc->clienthello->pre_proc_exts + i;
13a53fbf
PL		 6497 if (ext->present)
6498 num++;
6499 }
6500 if (num == 0) {
6501 *num_exts = 0;
6502 return 1;
6503 }
6504 if (exts == NULL) {
6505 *num_exts = num;
6506 return 1;
6507 }
6508 if (*num_exts < num)
6509 return 0;
38b051a1
TM		 6510 for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) {
6511 ext = sc->clienthello->pre_proc_exts + i;
13a53fbf
PL		 6512 if (ext->present) {
6513 if (ext->received_order >= num)
6514 return 0;
6515 exts[ext->received_order] = ext->type;
6516 }
6517 }
6518 *num_exts = num;
6519 return 1;
6520}
6521
a9c0d8be 6522int SSL_client_hello_get0_ext(SSL *s, unsigned int type, const unsigned char **out,
6b1bb98f
BK		 6523 size_t *outlen)
6524{
6525 size_t i;
6526 RAW_EXTENSION *r;
38b051a1 6527 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6b1bb98f 6528
38b051a1 6529 if (sc == NULL)
6b1bb98f 6530 return 0;
38b051a1
TM		 6531
6532 if (sc->clienthello == NULL)
6533 return 0;
6534 for (i = 0; i < sc->clienthello->pre_proc_exts_len; ++i) {
6535 r = sc->clienthello->pre_proc_exts + i;
6b1bb98f
BK		 6536 if (r->present && r->type == type) {
6537 if (out != NULL)
6538 *out = PACKET_data(&r->data);
6539 if (outlen != NULL)
6540 *outlen = PACKET_remaining(&r->data);
6541 return 1;
6542 }
6543 }
6544 return 0;
6545}
2faa1b48 6546
a58eb06d
TS		 6547int SSL_free_buffers(SSL *ssl)
6548{
38b051a1
TM		 6549 RECORD_LAYER *rl;
6550 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
6551
6552 if (sc == NULL)
6553 return 0;
6554
6555 rl = &sc->rlayer;
a58eb06d 6556
7eb39ecb
MC		 6557 return rl->rrlmethod->free_buffers(rl->rrl)
6558 && rl->wrlmethod->free_buffers(rl->wrl);
a58eb06d
TS		 6559}
6560
6561int SSL_alloc_buffers(SSL *ssl)
6562{
7eb39ecb 6563 RECORD_LAYER *rl;
38b051a1
TM		 6564 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
6565
6566 if (sc == NULL)
6567 return 0;
6568
7eb39ecb
MC		 6569 rl = &sc->rlayer;
6570
6571 return rl->rrlmethod->alloc_buffers(rl->rrl)
6572 && rl->wrlmethod->alloc_buffers(rl->wrl);
a58eb06d
TS		 6573}
6574
2faa1b48
CB		 6575void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb)
6576{
6577 ctx->keylog_callback = cb;
6578}
6579
6580SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx)
6581{
6582 return ctx->keylog_callback;
6583}
6584
6585static int nss_keylog_int(const char *prefix,
38b051a1 6586 SSL_CONNECTION *sc,
2faa1b48
CB		 6587 const uint8_t *parameter_1,
6588 size_t parameter_1_len,
6589 const uint8_t *parameter_2,
6590 size_t parameter_2_len)
6591{
6592 char *out = NULL;
6593 char *cursor = NULL;
6594 size_t out_len = 0;
6595 size_t i;
6596 size_t prefix_len;
38b051a1 6597 SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(sc);
2faa1b48 6598
38b051a1 6599 if (sctx->keylog_callback == NULL)
20870286 6600 return 1;
2faa1b48
CB		 6601
6602 /*
6603 * Our output buffer will contain the following strings, rendered with
6604 * space characters in between, terminated by a NULL character: first the
6605 * prefix, then the first parameter, then the second parameter. The
6606 * meaning of each parameter depends on the specific key material being
6607 * logged. Note that the first and second parameters are encoded in
6608 * hexadecimal, so we need a buffer that is twice their lengths.
6609 */
6610 prefix_len = strlen(prefix);
e931f370 6611 out_len = prefix_len + (2 * parameter_1_len) + (2 * parameter_2_len) + 3;
e077455e 6612 if ((out = cursor = OPENSSL_malloc(out_len)) == NULL)
2faa1b48 6613 return 0;
2faa1b48
CB		 6614
6615 strcpy(cursor, prefix);
6616 cursor += prefix_len;
6617 *cursor++ = ' ';
6618
6619 for (i = 0; i < parameter_1_len; i++) {
6620 sprintf(cursor, "%02x", parameter_1[i]);
6621 cursor += 2;
6622 }
6623 *cursor++ = ' ';
6624
6625 for (i = 0; i < parameter_2_len; i++) {
6626 sprintf(cursor, "%02x", parameter_2[i]);
6627 cursor += 2;
6628 }
6629 *cursor = '\0';
6630
38b051a1 6631 sctx->keylog_callback(SSL_CONNECTION_GET_SSL(sc), (const char *)out);
e931f370 6632 OPENSSL_clear_free(out, out_len);
2faa1b48
CB		 6633 return 1;
6634
6635}
6636
38b051a1 6637int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *sc,
2faa1b48
CB		 6638 const uint8_t *encrypted_premaster,
6639 size_t encrypted_premaster_len,
6640 const uint8_t *premaster,
6641 size_t premaster_len)
6642{
6643 if (encrypted_premaster_len < 8) {
38b051a1 6644 SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
2faa1b48
CB		 6645 return 0;
6646 }
6647
f0deb4d3 6648 /* We only want the first 8 bytes of the encrypted premaster as a tag. */
2faa1b48 6649 return nss_keylog_int("RSA",
38b051a1 6650 sc,
2faa1b48 6651 encrypted_premaster,
f0deb4d3 6652 8,
2faa1b48
CB		 6653 premaster,
6654 premaster_len);
6655}
6656
38b051a1 6657int ssl_log_secret(SSL_CONNECTION *sc,
2c7bd692
CB		 6658 const char *label,
6659 const uint8_t *secret,
6660 size_t secret_len)
2faa1b48 6661{
2c7bd692 6662 return nss_keylog_int(label,
38b051a1
TM		 6663 sc,
6664 sc->s3.client_random,
2c7bd692
CB		 6665 SSL3_RANDOM_SIZE,
6666 secret,
6667 secret_len);
2faa1b48
CB		 6668}
6669
ccb8e6e0
BK		 6670#define SSLV2_CIPHER_LEN 3
6671
38b051a1 6672int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites, int sslv2format)
ccb8e6e0 6673{
ccb8e6e0 6674 int n;
ccb8e6e0
BK		 6675
6676 n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN;
6677
6678 if (PACKET_remaining(cipher_suites) == 0) {
c48ffbcc 6679 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CIPHERS_SPECIFIED);
90134d98 6680 return 0;
ccb8e6e0
BK		 6681 }
6682
6683 if (PACKET_remaining(cipher_suites) % n != 0) {
c48ffbcc 6684 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
90134d98 6685 return 0;
ccb8e6e0
BK		 6686 }
6687
555cbb32
TS		 6688 OPENSSL_free(s->s3.tmp.ciphers_raw);
6689 s->s3.tmp.ciphers_raw = NULL;
6690 s->s3.tmp.ciphers_rawlen = 0;
ccb8e6e0
BK		 6691
6692 if (sslv2format) {
6693 size_t numciphers = PACKET_remaining(cipher_suites) / n;
6694 PACKET sslv2ciphers = *cipher_suites;
6695 unsigned int leadbyte;
6696 unsigned char *raw;
6697
6698 /*
6699 * We store the raw ciphers list in SSLv3+ format so we need to do some
6700 * preprocessing to convert the list first. If there are any SSLv2 only
6701 * ciphersuites with a non-zero leading byte then we are going to
6702 * slightly over allocate because we won't store those. But that isn't a
6703 * problem.
6704 */
6705 raw = OPENSSL_malloc(numciphers * TLS_CIPHER_LEN);
555cbb32 6706 s->s3.tmp.ciphers_raw = raw;
ccb8e6e0 6707 if (raw == NULL) {
e077455e 6708 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
f63a17d6 6709 return 0;
ccb8e6e0 6710 }
555cbb32 6711 for (s->s3.tmp.ciphers_rawlen = 0;
ccb8e6e0
BK		 6712 PACKET_remaining(&sslv2ciphers) > 0;
6713 raw += TLS_CIPHER_LEN) {
6714 if (!PACKET_get_1(&sslv2ciphers, &leadbyte)
6715 || (leadbyte == 0
6716 && !PACKET_copy_bytes(&sslv2ciphers, raw,
6717 TLS_CIPHER_LEN))
6718 || (leadbyte != 0
6719 && !PACKET_forward(&sslv2ciphers, TLS_CIPHER_LEN))) {
c48ffbcc 6720 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_PACKET);
555cbb32
TS		 6721 OPENSSL_free(s->s3.tmp.ciphers_raw);
6722 s->s3.tmp.ciphers_raw = NULL;
6723 s->s3.tmp.ciphers_rawlen = 0;
f63a17d6 6724 return 0;
ccb8e6e0
BK		 6725 }
6726 if (leadbyte == 0)
555cbb32 6727 s->s3.tmp.ciphers_rawlen += TLS_CIPHER_LEN;
ccb8e6e0 6728 }
555cbb32
TS		 6729 } else if (!PACKET_memdup(cipher_suites, &s->s3.tmp.ciphers_raw,
6730 &s->s3.tmp.ciphers_rawlen)) {
c48ffbcc 6731 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
f63a17d6 6732 return 0;
ccb8e6e0 6733 }
90134d98 6734 return 1;
90134d98
BK		 6735}
6736
6737int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len,
6738 int isv2format, STACK_OF(SSL_CIPHER) **sk,
6739 STACK_OF(SSL_CIPHER) **scsvs)
6740{
90134d98 6741 PACKET pkt;
38b051a1
TM		 6742 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6743
6744 if (sc == NULL)
6745 return 0;
90134d98
BK		 6746
6747 if (!PACKET_buf_init(&pkt, bytes, len))
6748 return 0;
38b051a1 6749 return ossl_bytes_to_cipher_list(sc, &pkt, sk, scsvs, isv2format, 0);
90134d98
BK		 6750}
6751
38b051a1
TM		 6752int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites,
6753 STACK_OF(SSL_CIPHER) **skp,
6754 STACK_OF(SSL_CIPHER) **scsvs_out,
6755 int sslv2format, int fatal)
90134d98
BK		 6756{
6757 const SSL_CIPHER *c;
6758 STACK_OF(SSL_CIPHER) *sk = NULL;
6759 STACK_OF(SSL_CIPHER) *scsvs = NULL;
6760 int n;
6761 /* 3 = SSLV2_CIPHER_LEN > TLS_CIPHER_LEN = 2. */
6762 unsigned char cipher[SSLV2_CIPHER_LEN];
6763
6764 n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN;
6765
6766 if (PACKET_remaining(cipher_suites) == 0) {
f63a17d6 6767 if (fatal)
c48ffbcc 6768 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CIPHERS_SPECIFIED);
f63a17d6 6769 else
6849b73c 6770 ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHERS_SPECIFIED);
90134d98
BK		 6771 return 0;
6772 }
6773
6774 if (PACKET_remaining(cipher_suites) % n != 0) {
f63a17d6 6775 if (fatal)
c48ffbcc 6776 SSLfatal(s, SSL_AD_DECODE_ERROR,
f63a17d6
MC		 6777 SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
6778 else
6849b73c 6779 ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
90134d98
BK		 6780 return 0;
6781 }
6782
6783 sk = sk_SSL_CIPHER_new_null();
6784 scsvs = sk_SSL_CIPHER_new_null();
6785 if (sk == NULL || scsvs == NULL) {
f63a17d6 6786 if (fatal)
e077455e 6787 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
f63a17d6 6788 else
e077455e 6789 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
90134d98
BK		 6790 goto err;
6791 }
ccb8e6e0
BK		 6792
6793 while (PACKET_copy_bytes(cipher_suites, cipher, n)) {
6794 /*
6795 * SSLv3 ciphers wrapped in an SSLv2-compatible ClientHello have the
6796 * first byte set to zero, while true SSLv2 ciphers have a non-zero
6797 * first byte. We don't support any true SSLv2 ciphers, so skip them.
6798 */
6799 if (sslv2format && cipher[0] != '\0')
6800 continue;
6801
ccb8e6e0
BK		 6802 /* For SSLv2-compat, ignore leading 0-byte. */
6803 c = ssl_get_cipher_by_char(s, sslv2format ? &cipher[1] : cipher, 1);
6804 if (c != NULL) {
90134d98
BK		 6805 if ((c->valid && !sk_SSL_CIPHER_push(sk, c)) ||
6806 (!c->valid && !sk_SSL_CIPHER_push(scsvs, c))) {
f63a17d6 6807 if (fatal)
e077455e 6808 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
f63a17d6 6809 else
e077455e 6810 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
ccb8e6e0
BK		 6811 goto err;
6812 }
6813 }
6814 }
6815 if (PACKET_remaining(cipher_suites) > 0) {
f63a17d6 6816 if (fatal)
c48ffbcc 6817 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH);
f63a17d6 6818 else
6849b73c 6819 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH);
ccb8e6e0
BK		 6820 goto err;
6821 }
6822
90134d98
BK		 6823 if (skp != NULL)
6824 *skp = sk;
6825 else
6826 sk_SSL_CIPHER_free(sk);
6827 if (scsvs_out != NULL)
6828 *scsvs_out = scsvs;
6829 else
6830 sk_SSL_CIPHER_free(scsvs);
6831 return 1;
ccb8e6e0
BK		 6832 err:
6833 sk_SSL_CIPHER_free(sk);
90134d98
BK		 6834 sk_SSL_CIPHER_free(scsvs);
6835 return 0;
ccb8e6e0 6836}
3fc8d856
MC		 6837
6838int SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data)
6839{
6840 ctx->max_early_data = max_early_data;
6841
6842 return 1;
6843}
6844
46dcb945 6845uint32_t SSL_CTX_get_max_early_data(const SSL_CTX *ctx)
3fc8d856
MC		 6846{
6847 return ctx->max_early_data;
6848}
6849
6850int SSL_set_max_early_data(SSL *s, uint32_t max_early_data)
6851{
38b051a1
TM		 6852 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6853
6854 if (sc == NULL)
6855 return 0;
6856
6857 sc->max_early_data = max_early_data;
3fc8d856
MC		 6858
6859 return 1;
6860}
6861
a8e75d56 6862uint32_t SSL_get_max_early_data(const SSL *s)
3fc8d856 6863{
38b051a1
TM		 6864 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
6865
6866 if (sc == NULL)
6867 return 0;
6868
6869 return sc->max_early_data;
3fc8d856 6870}
ae3947de 6871
4e8548e8
MC		 6872int SSL_CTX_set_recv_max_early_data(SSL_CTX *ctx, uint32_t recv_max_early_data)
6873{
6874 ctx->recv_max_early_data = recv_max_early_data;
6875
6876 return 1;
6877}
6878
6879uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX *ctx)
6880{
6881 return ctx->recv_max_early_data;
6882}
6883
6884int SSL_set_recv_max_early_data(SSL *s, uint32_t recv_max_early_data)
6885{
38b051a1
TM		 6886 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6887
6888 if (sc == NULL)
6889 return 0;
6890
6891 sc->recv_max_early_data = recv_max_early_data;
4e8548e8
MC		 6892
6893 return 1;
6894}
6895
6896uint32_t SSL_get_recv_max_early_data(const SSL *s)
6897{
38b051a1
TM		 6898 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
6899
6900 if (sc == NULL)
6901 return 0;
6902
6903 return sc->recv_max_early_data;
4e8548e8
MC		 6904}
6905
38b051a1 6906__owur unsigned int ssl_get_max_send_fragment(const SSL_CONNECTION *sc)
cf72c757
F		 6907{
6908 /* Return any active Max Fragment Len extension */
38b051a1
TM		 6909 if (sc->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(sc->session))
6910 return GET_MAX_FRAGMENT_LENGTH(sc->session);
cf72c757
F		 6911
6912 /* return current SSL connection setting */
38b051a1 6913 return sc->max_send_fragment;
cf72c757
F		 6914}
6915
38b051a1 6916__owur unsigned int ssl_get_split_send_fragment(const SSL_CONNECTION *sc)
cf72c757
F		 6917{
6918 /* Return a value regarding an active Max Fragment Len extension */
38b051a1
TM		 6919 if (sc->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(sc->session)
6920 && sc->split_send_fragment > GET_MAX_FRAGMENT_LENGTH(sc->session))
6921 return GET_MAX_FRAGMENT_LENGTH(sc->session);
cf72c757
F		 6922
6923 /* else limit |split_send_fragment| to current |max_send_fragment| */
38b051a1
TM		 6924 if (sc->split_send_fragment > sc->max_send_fragment)
6925 return sc->max_send_fragment;
cf72c757
F		 6926
6927 /* return current SSL connection setting */
38b051a1 6928 return sc->split_send_fragment;
cf72c757 6929}
042c5753
MC		 6930
6931int SSL_stateless(SSL *s)
6932{
6933 int ret;
38b051a1
TM		 6934 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
6935
6936 /* TODO(QUIC): This will need further work. */
6937 if (sc == NULL)
6938 return 0;
042c5753
MC		 6939
6940 /* Ensure there is no state left over from a previous invocation */
6941 if (!SSL_clear(s))
d6bb50a5 6942 return 0;
042c5753
MC		 6943
6944 ERR_clear_error();
6945
38b051a1 6946 sc->s3.flags |= TLS1_FLAGS_STATELESS;
042c5753 6947 ret = SSL_accept(s);
38b051a1 6948 sc->s3.flags &= ~TLS1_FLAGS_STATELESS;
042c5753 6949
38b051a1 6950 if (ret > 0 && sc->ext.cookieok)
c36001c3
MC		 6951 return 1;
6952
38b051a1 6953 if (sc->hello_retry_request == SSL_HRR_PENDING && !ossl_statem_in_error(sc))
e440f513
MC		 6954 return 0;
6955
6956 return -1;
042c5753 6957}
9d75dce3 6958
e97be718
MC		 6959void SSL_CTX_set_post_handshake_auth(SSL_CTX *ctx, int val)
6960{
6961 ctx->pha_enabled = val;
6962}
6963
32097b33 6964void SSL_set_post_handshake_auth(SSL *ssl, int val)
9d75dce3 6965{
38b051a1
TM		 6966 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
6967
6968 if (sc == NULL)
6969 return;
6970
6971 sc->pha_enabled = val;
9d75dce3
TS		 6972}
6973
6974int SSL_verify_client_post_handshake(SSL *ssl)
6975{
38b051a1
TM		 6976 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
6977
6978 if (sc == NULL)
6979 return 0;
6980
6981 if (!SSL_CONNECTION_IS_TLS13(sc)) {
6849b73c 6982 ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION);
9d75dce3
TS		 6983 return 0;
6984 }
38b051a1 6985 if (!sc->server) {
6849b73c 6986 ERR_raise(ERR_LIB_SSL, SSL_R_NOT_SERVER);
9d75dce3
TS		 6987 return 0;
6988 }
6989
6990 if (!SSL_is_init_finished(ssl)) {
6849b73c 6991 ERR_raise(ERR_LIB_SSL, SSL_R_STILL_IN_INIT);
9d75dce3
TS		 6992 return 0;
6993 }
6994
38b051a1 6995 switch (sc->post_handshake_auth) {
9d75dce3 6996 case SSL_PHA_NONE:
6849b73c 6997 ERR_raise(ERR_LIB_SSL, SSL_R_EXTENSION_NOT_RECEIVED);
9d75dce3
TS		 6998 return 0;
6999 default:
7000 case SSL_PHA_EXT_SENT:
6849b73c 7001 ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
9d75dce3
TS		 7002 return 0;
7003 case SSL_PHA_EXT_RECEIVED:
7004 break;
7005 case SSL_PHA_REQUEST_PENDING:
6849b73c 7006 ERR_raise(ERR_LIB_SSL, SSL_R_REQUEST_PENDING);
9d75dce3
TS		 7007 return 0;
7008 case SSL_PHA_REQUESTED:
6849b73c 7009 ERR_raise(ERR_LIB_SSL, SSL_R_REQUEST_SENT);
9d75dce3
TS		 7010 return 0;
7011 }
7012
38b051a1 7013 sc->post_handshake_auth = SSL_PHA_REQUEST_PENDING;
9d75dce3
TS		 7014
7015 /* checks verify_mode and algorithm_auth */
38b051a1
TM		 7016 if (!send_certificate_request(sc)) {
7017 sc->post_handshake_auth = SSL_PHA_EXT_RECEIVED; /* restore on error */
6849b73c 7018 ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CONFIG);
9d75dce3
TS		 7019 return 0;
7020 }
7021
38b051a1 7022 ossl_statem_set_in_init(sc, 1);
9d75dce3
TS		 7023 return 1;
7024}
df0fed9a
TS		 7025
7026int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx,
7027 SSL_CTX_generate_session_ticket_fn gen_cb,
7028 SSL_CTX_decrypt_session_ticket_fn dec_cb,
7029 void *arg)
7030{
7031 ctx->generate_ticket_cb = gen_cb;
7032 ctx->decrypt_ticket_cb = dec_cb;
7033 ctx->ticket_cb_data = arg;
7034 return 1;
7035}
c9598459
MC		 7036
7037void SSL_CTX_set_allow_early_data_cb(SSL_CTX *ctx,
7038 SSL_allow_early_data_cb_fn cb,
7039 void *arg)
7040{
7041 ctx->allow_early_data_cb = cb;
7042 ctx->allow_early_data_cb_data = arg;
7043}
7044
7045void SSL_set_allow_early_data_cb(SSL *s,
7046 SSL_allow_early_data_cb_fn cb,
7047 void *arg)
7048{
38b051a1
TM		 7049 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
7050
7051 if (sc == NULL)
7052 return;
7053
7054 sc->allow_early_data_cb = cb;
7055 sc->allow_early_data_cb_data = arg;
c9598459 7056}
c8f6c28a 7057
b4250010 7058const EVP_CIPHER *ssl_evp_cipher_fetch(OSSL_LIB_CTX *libctx,
c8f6c28a
MC		 7059 int nid,
7060 const char *properties)
7061{
301fcb28 7062 const EVP_CIPHER *ciph;
5fcb97c6 7063
301fcb28
MC		 7064 ciph = tls_get_cipher_from_engine(nid);
7065 if (ciph != NULL)
7066 return ciph;
0618b62c 7067
c8f6c28a 7068 /*
301fcb28
MC		 7069 * If there is no engine cipher then we do an explicit fetch. This may fail
7070 * and that could be ok
c8f6c28a 7071 */
5fcb97c6
MC		 7072 ERR_set_mark();
7073 ciph = EVP_CIPHER_fetch(libctx, OBJ_nid2sn(nid), properties);
7074 ERR_pop_to_mark();
7075 return ciph;
c8f6c28a
MC		 7076}
7077
7078
7079int ssl_evp_cipher_up_ref(const EVP_CIPHER *cipher)
7080{
7081 /* Don't up-ref an implicit EVP_CIPHER */
ed576acd 7082 if (EVP_CIPHER_get0_provider(cipher) == NULL)
c8f6c28a
MC		 7083 return 1;
7084
7085 /*
7086 * The cipher was explicitly fetched and therefore it is safe to cast
7087 * away the const
7088 */
7089 return EVP_CIPHER_up_ref((EVP_CIPHER *)cipher);
7090}
7091
7092void ssl_evp_cipher_free(const EVP_CIPHER *cipher)
7093{
7094 if (cipher == NULL)
7095 return;
7096
ed576acd 7097 if (EVP_CIPHER_get0_provider(cipher) != NULL) {
c8f6c28a
MC		 7098 /*
7099 * The cipher was explicitly fetched and therefore it is safe to cast
7100 * away the const
7101 */
7102 EVP_CIPHER_free((EVP_CIPHER *)cipher);
7103 }
7104}
7105
b4250010 7106const EVP_MD *ssl_evp_md_fetch(OSSL_LIB_CTX *libctx,
c8f6c28a
MC		 7107 int nid,
7108 const char *properties)
7109{
301fcb28 7110 const EVP_MD *md;
5fcb97c6 7111
301fcb28
MC		 7112 md = tls_get_digest_from_engine(nid);
7113 if (md != NULL)
7114 return md;
c8f6c28a
MC		 7115
7116 /* Otherwise we do an explicit fetch */
5fcb97c6
MC		 7117 ERR_set_mark();
7118 md = EVP_MD_fetch(libctx, OBJ_nid2sn(nid), properties);
7119 ERR_pop_to_mark();
7120 return md;
c8f6c28a
MC		 7121}
7122
7123int ssl_evp_md_up_ref(const EVP_MD *md)
7124{
7125 /* Don't up-ref an implicit EVP_MD */
ed576acd 7126 if (EVP_MD_get0_provider(md) == NULL)
c8f6c28a
MC		 7127 return 1;
7128
7129 /*
7130 * The digest was explicitly fetched and therefore it is safe to cast
7131 * away the const
7132 */
7133 return EVP_MD_up_ref((EVP_MD *)md);
7134}
7135
7136void ssl_evp_md_free(const EVP_MD *md)
7137{
7138 if (md == NULL)
7139 return;
7140
ed576acd 7141 if (EVP_MD_get0_provider(md) != NULL) {
c8f6c28a
MC		 7142 /*
7143 * The digest was explicitly fetched and therefore it is safe to cast
7144 * away the const
7145 */
7146 EVP_MD_free((EVP_MD *)md);
7147 }
7148}
163f6dc1
MC		 7149
7150int SSL_set0_tmp_dh_pkey(SSL *s, EVP_PKEY *dhpkey)
7151{
38b051a1
TM		 7152 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
7153
7154 if (sc == NULL)
7155 return 0;
7156
7157 if (!ssl_security(sc, SSL_SECOP_TMP_DH,
ed576acd 7158 EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) {
276d6c68 7159 ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL);
163f6dc1
MC		 7160 return 0;
7161 }
38b051a1
TM		 7162 EVP_PKEY_free(sc->cert->dh_tmp);
7163 sc->cert->dh_tmp = dhpkey;
163f6dc1
MC		 7164 return 1;
7165}
7166
7167int SSL_CTX_set0_tmp_dh_pkey(SSL_CTX *ctx, EVP_PKEY *dhpkey)
7168{
7169 if (!ssl_ctx_security(ctx, SSL_SECOP_TMP_DH,
ed576acd 7170 EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) {
276d6c68 7171 ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL);
163f6dc1
MC		 7172 return 0;
7173 }
7174 EVP_PKEY_free(ctx->cert->dh_tmp);
7175 ctx->cert->dh_tmp = dhpkey;
7176 return 1;
7177}
68801bcb 7178
03bacce8 7179/* QUIC-specific methods which are supported on QUIC connections only. */
6084e04b 7180int SSL_handle_events(SSL *s)
03bacce8
HL		 7181{
7182 SSL_CONNECTION *sc;
03bacce8 7183
6d495cc4
HL		 7184#ifndef OPENSSL_NO_QUIC
7185 if (IS_QUIC(s))
6084e04b 7186 return ossl_quic_handle_events(s);
03bacce8
HL		 7187#endif
7188
7189 sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
7190 if (sc != NULL && SSL_CONNECTION_IS_DTLS(sc))
fbe2573d
HL		 7191 /*
7192 * DTLSv1_handle_timeout returns 0 if the timer wasn't expired yet,
7193 * which we consider a success case. Theoretically DTLSv1_handle_timeout
7194 * can also return 0 if s is NULL or not a DTLS object, but we've
7195 * already ruled out those possibilities above, so this is not possible
7196 * here. Thus the only failure cases are where DTLSv1_handle_timeout
7197 * returns -1.
7198 */
7199 return DTLSv1_handle_timeout(s) >= 0;
03bacce8 7200
fbe2573d 7201 return 1;
03bacce8
HL		 7202}
7203
7ea49713 7204int SSL_get_event_timeout(SSL *s, struct timeval *tv, int *is_infinite)
03bacce8
HL		 7205{
7206 SSL_CONNECTION *sc;
03bacce8 7207
6d495cc4
HL		 7208#ifndef OPENSSL_NO_QUIC
7209 if (IS_QUIC(s))
7ea49713 7210 return ossl_quic_get_event_timeout(s, tv, is_infinite);
03bacce8
HL		 7211#endif
7212
7213 sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
fbe2573d 7214 if (sc != NULL && SSL_CONNECTION_IS_DTLS(sc)
7ea49713
HL		 7215 && DTLSv1_get_timeout(s, tv)) {
7216 *is_infinite = 0;
03bacce8 7217 return 1;
7ea49713 7218 }
03bacce8 7219
7ea49713 7220 tv->tv_sec = 1000000;
fbe2573d 7221 tv->tv_usec = 0;
7ea49713 7222 *is_infinite = 1;
fbe2573d 7223 return 1;
03bacce8
HL		 7224}
7225
68801bcb
HL		 7226int SSL_get_rpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc)
7227{
7228#ifndef OPENSSL_NO_QUIC
6d495cc4 7229 if (!IS_QUIC(s))
68801bcb
HL		 7230 return -1;
7231
6d495cc4 7232 return ossl_quic_get_rpoll_descriptor(s, desc);
68801bcb
HL		 7233#else
7234 return -1;
7235#endif
7236}
7237
7238int SSL_get_wpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc)
7239{
7240#ifndef OPENSSL_NO_QUIC
6d495cc4 7241 if (!IS_QUIC(s))
68801bcb
HL		 7242 return -1;
7243
6d495cc4 7244 return ossl_quic_get_wpoll_descriptor(s, desc);
03bacce8
HL		 7245#else
7246 return -1;
7247#endif
7248}
7249
b639475a 7250int SSL_net_read_desired(SSL *s)
03bacce8
HL		 7251{
7252#ifndef OPENSSL_NO_QUIC
6d495cc4 7253 if (!IS_QUIC(s))
03bacce8
HL		 7254 return 0;
7255
6d495cc4 7256 return ossl_quic_get_net_read_desired(s);
03bacce8
HL		 7257#else
7258 return 0;
7259#endif
7260}
7261
b639475a 7262int SSL_net_write_desired(SSL *s)
03bacce8
HL		 7263{
7264#ifndef OPENSSL_NO_QUIC
6d495cc4 7265 if (!IS_QUIC(s))
03bacce8
HL		 7266 return 0;
7267
6d495cc4 7268 return ossl_quic_get_net_write_desired(s);
03bacce8
HL		 7269#else
7270 return 0;
7271#endif
7272}
7273
7274int SSL_set_blocking_mode(SSL *s, int blocking)
7275{
7276#ifndef OPENSSL_NO_QUIC
6d495cc4 7277 if (!IS_QUIC(s))
03bacce8
HL		 7278 return 0;
7279
6d495cc4 7280 return ossl_quic_conn_set_blocking_mode(s, blocking);
03bacce8
HL		 7281#else
7282 return 0;
7283#endif
7284}
7285
7286int SSL_get_blocking_mode(SSL *s)
7287{
7288#ifndef OPENSSL_NO_QUIC
6d495cc4 7289 if (!IS_QUIC(s))
03bacce8
HL		 7290 return -1;
7291
6d495cc4 7292 return ossl_quic_conn_get_blocking_mode(s);
03bacce8
HL		 7293#else
7294 return -1;
7295#endif
7296}
7297
7298int SSL_set_initial_peer_addr(SSL *s, const BIO_ADDR *peer_addr)
7299{
7300#ifndef OPENSSL_NO_QUIC
6d495cc4 7301 if (!IS_QUIC(s))
e8043229 7302 return 0;
03bacce8 7303
6d495cc4 7304 return ossl_quic_conn_set_initial_peer_addr(s, peer_addr);
68801bcb 7305#else
e8043229
HL		 7306 return 0;
7307#endif
7308}
7309
7310int SSL_shutdown_ex(SSL *ssl, uint64_t flags,
7311 const SSL_SHUTDOWN_EX_ARGS *args,
7312 size_t args_len)
7313{
7314#ifndef OPENSSL_NO_QUIC
6d495cc4 7315 if (!IS_QUIC(ssl))
e8043229
HL		 7316 return SSL_shutdown(ssl);
7317
6d495cc4 7318 return ossl_quic_conn_shutdown(ssl, flags, args, args_len);
e8043229
HL		 7319#else
7320 return SSL_shutdown(ssl);
68801bcb
HL		 7321#endif
7322}
a9979965
HL		 7323
7324int SSL_stream_conclude(SSL *ssl, uint64_t flags)
7325{
7326#ifndef OPENSSL_NO_QUIC
6d495cc4 7327 if (!IS_QUIC(ssl))
a9979965
HL		 7328 return 0;
7329
6d495cc4 7330 return ossl_quic_conn_stream_conclude(ssl);
a9979965
HL		 7331#else
7332 return 0;
7333#endif
7334}
3c95ef22 7335
cb5c208b
HL		 7336SSL *SSL_new_stream(SSL *s, uint64_t flags)
7337{
7338#ifndef OPENSSL_NO_QUIC
7339 if (!IS_QUIC(s))
7340 return NULL;
7341
7342 return ossl_quic_conn_stream_new(s, flags);
7343#else
7344 return NULL;
7345#endif
7346}
7347
020d0389
HL		 7348SSL *SSL_get0_connection(SSL *s)
7349{
7350#ifndef OPENSSL_NO_QUIC
7351 if (!IS_QUIC(s))
7352 return s;
7353
7354 return ossl_quic_get0_connection(s);
7355#else
7356 return s;
7357#endif
7358}
7359
e1dee2e3
HL		 7360int SSL_is_connection(SSL *s)
7361{
7362 return SSL_get0_connection(s) == s;
7363}
7364
1bca3f1b
HL		 7365int SSL_get_stream_type(SSL *s)
7366{
7367#ifndef OPENSSL_NO_QUIC
7368 if (!IS_QUIC(s))
7369 return SSL_STREAM_TYPE_BIDI;
7370
7371 return ossl_quic_get_stream_type(s);
7372#else
7373 return SSL_STREAM_TYPE_BIDI;
7374#endif
7375}
7376
19cb0887
HL		 7377uint64_t SSL_get_stream_id(SSL *s)
7378{
7379#ifndef OPENSSL_NO_QUIC
7380 if (!IS_QUIC(s))
7381 return UINT64_MAX;
7382
7383 return ossl_quic_get_stream_id(s);
7384#else
7385 return UINT64_MAX;
7386#endif
7387}
7388
8b7be3aa
HL		 7389int SSL_set_default_stream_mode(SSL *s, uint32_t mode)
7390{
7391#ifndef OPENSSL_NO_QUIC
7392 if (!IS_QUIC(s))
7393 return 0;
7394
7395 return ossl_quic_set_default_stream_mode(s, mode);
7396#else
7397 return 0;
7398#endif
7399}
7400
83df44ae 7401int SSL_set_incoming_stream_policy(SSL *s, int policy, uint64_t aec)
8a90df34
HL		 7402{
7403#ifndef OPENSSL_NO_QUIC
7404 if (!IS_QUIC(s))
7405 return 0;
7406
83df44ae 7407 return ossl_quic_set_incoming_stream_policy(s, policy, aec);
8a90df34
HL		 7408#else
7409 return 0;
7410#endif
7411}
7412
cb68ce9f
HL		 7413SSL *SSL_accept_stream(SSL *s, uint64_t flags)
7414{
7415#ifndef OPENSSL_NO_QUIC
7416 if (!IS_QUIC(s))
7417 return NULL;
7418
7419 return ossl_quic_accept_stream(s, flags);
7420#else
7421 return NULL;
7422#endif
7423}
7424
7425size_t SSL_get_accept_stream_queue_len(SSL *s)
7426{
7427#ifndef OPENSSL_NO_QUIC
7428 if (!IS_QUIC(s))
7429 return 0;
7430
7431 return ossl_quic_get_accept_stream_queue_len(s);
7432#else
7433 return 0;
7434#endif
7435}
7436
c3a04ea2
HL		 7437int SSL_stream_reset(SSL *s,
7438 const SSL_STREAM_RESET_ARGS *args,
7439 size_t args_len)
7440{
7441#ifndef OPENSSL_NO_QUIC
7442 if (!IS_QUIC(s))
7443 return 0;
7444
7445 return ossl_quic_stream_reset(s, args, args_len);
7446#else
7447 return 0;
7448#endif
7449}
7450
7451int SSL_get_stream_read_state(SSL *s)
7452{
7453#ifndef OPENSSL_NO_QUIC
7454 if (!IS_QUIC(s))
7455 return SSL_STREAM_STATE_NONE;
7456
7457 return ossl_quic_get_stream_read_state(s);
7458#else
7459 return SSL_STREAM_STATE_NONE;
7460#endif
7461}
7462
7463int SSL_get_stream_write_state(SSL *s)
7464{
7465#ifndef OPENSSL_NO_QUIC
7466 if (!IS_QUIC(s))
7467 return SSL_STREAM_STATE_NONE;
7468
7469 return ossl_quic_get_stream_write_state(s);
7470#else
7471 return SSL_STREAM_STATE_NONE;
7472#endif
7473}
7474
7475int SSL_get_stream_read_error_code(SSL *s, uint64_t *app_error_code)
7476{
7477#ifndef OPENSSL_NO_QUIC
7478 if (!IS_QUIC(s))
7479 return -1;
7480
7481 return ossl_quic_get_stream_read_error_code(s, app_error_code);
7482#else
7483 return -1;
7484#endif
7485}
7486
7487int SSL_get_stream_write_error_code(SSL *s, uint64_t *app_error_code)
7488{
7489#ifndef OPENSSL_NO_QUIC
7490 if (!IS_QUIC(s))
7491 return -1;
7492
7493 return ossl_quic_get_stream_write_error_code(s, app_error_code);
7494#else
7495 return -1;
7496#endif
7497}
7498
7499int SSL_get_conn_close_info(SSL *s, SSL_CONN_CLOSE_INFO *info,
7500 size_t info_len)
7501{
7502#ifndef OPENSSL_NO_QUIC
7503 if (!IS_QUIC(s))
7504 return -1;
7505
7506 return ossl_quic_get_conn_close_info(s, info, info_len);
7507#else
7508 return -1;
7509#endif
7510}
7511
3c95ef22
TS		 7512int SSL_add_expected_rpk(SSL *s, EVP_PKEY *rpk)
7513{
7514 unsigned char *data = NULL;
7515 SSL_DANE *dane = SSL_get0_dane(s);
7516 int ret;
7517
7518 if (dane == NULL || dane->dctx == NULL)
7519 return 0;
7520 if ((ret = i2d_PUBKEY(rpk, &data)) <= 0)
7521 return 0;
7522
7523 ret = SSL_dane_tlsa_add(s, DANETLS_USAGE_DANE_EE,
7524 DANETLS_SELECTOR_SPKI,
7525 DANETLS_MATCHING_FULL,
7526 data, (size_t)ret) > 0;
7527 OPENSSL_free(data);
7528 return ret;
7529}
7530
7531EVP_PKEY *SSL_get0_peer_rpk(const SSL *s)
7532{
7533 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
7534
7535 if (sc == NULL || sc->session == NULL)
7536 return NULL;
7537 return sc->session->peer_rpk;
7538}
7539
7540int SSL_get_negotiated_client_cert_type(const SSL *s)
7541{
7542 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
7543
7544 if (sc == NULL)
7545 return 0;
7546
7547 return sc->ext.client_cert_type;
7548}
7549
7550int SSL_get_negotiated_server_cert_type(const SSL *s)
7551{
7552 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
7553
7554 if (sc == NULL)
7555 return 0;
7556
7557 return sc->ext.server_cert_type;
7558}
7559
7560static int validate_cert_type(const unsigned char *val, size_t len)
7561{
7562 size_t i;
7563 int saw_rpk = 0;
7564 int saw_x509 = 0;
7565
7566 if (val == NULL && len == 0)
7567 return 1;
7568
7569 if (val == NULL || len == 0)
7570 return 0;
7571
7572 for (i = 0; i < len; i++) {
7573 switch (val[i]) {
7574 case TLSEXT_cert_type_rpk:
7575 if (saw_rpk)
7576 return 0;
7577 saw_rpk = 1;
7578 break;
7579 case TLSEXT_cert_type_x509:
7580 if (saw_x509)
7581 return 0;
7582 saw_x509 = 1;
7583 break;
7584 case TLSEXT_cert_type_pgp:
7585 case TLSEXT_cert_type_1609dot2:
7586 default:
7587 return 0;
7588 }
7589 }
7590 return 1;
7591}
7592
7593static int set_cert_type(unsigned char **cert_type,
7594 size_t *cert_type_len,
7595 const unsigned char *val,
7596 size_t len)
7597{
7598 unsigned char *tmp = NULL;
7599
7600 if (!validate_cert_type(val, len))
7601 return 0;
7602
7603 if (val != NULL && (tmp = OPENSSL_memdup(val, len)) == NULL)
7604 return 0;
7605
7606 OPENSSL_free(*cert_type);
7607 *cert_type = tmp;
7608 *cert_type_len = len;
7609 return 1;
7610}
7611
7612int SSL_set1_client_cert_type(SSL *s, const unsigned char *val, size_t len)
7613{
7614 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
7615
7616 return set_cert_type(&sc->client_cert_type, &sc->client_cert_type_len,
7617 val, len);
7618}
7619
7620int SSL_set1_server_cert_type(SSL *s, const unsigned char *val, size_t len)
7621{
7622 SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
7623
7624 return set_cert_type(&sc->server_cert_type, &sc->server_cert_type_len,
7625 val, len);
7626}
7627
7628int SSL_CTX_set1_client_cert_type(SSL_CTX *ctx, const unsigned char *val, size_t len)
7629{
7630 return set_cert_type(&ctx->client_cert_type, &ctx->client_cert_type_len,
7631 val, len);
7632}
7633
7634int SSL_CTX_set1_server_cert_type(SSL_CTX *ctx, const unsigned char *val, size_t len)
7635{
7636 return set_cert_type(&ctx->server_cert_type, &ctx->server_cert_type_len,
7637 val, len);
7638}
7639
7640int SSL_get0_client_cert_type(const SSL *s, unsigned char **t, size_t *len)
7641{
7642 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
7643
7644 if (t == NULL || len == NULL)
7645 return 0;
7646
7647 *t = sc->client_cert_type;
7648 *len = sc->client_cert_type_len;
7649 return 1;
7650}
7651
7652int SSL_get0_server_cert_type(const SSL *s, unsigned char **t, size_t *len)
7653{
7654 const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
7655
7656 if (t == NULL || len == NULL)
7657 return 0;
7658
7659 *t = sc->server_cert_type;
7660 *len = sc->server_cert_type_len;
7661 return 1;
7662}
7663
7664int SSL_CTX_get0_client_cert_type(const SSL_CTX *ctx, unsigned char **t, size_t *len)
7665{
7666 if (t == NULL || len == NULL)
7667 return 0;
7668
7669 *t = ctx->client_cert_type;
7670 *len = ctx->client_cert_type_len;
7671 return 1;
7672}
7673
7674int SSL_CTX_get0_server_cert_type(const SSL_CTX *ctx, unsigned char **t, size_t *len)
7675{
7676 if (t == NULL || len == NULL)
7677 return 0;
7678
7679 *t = ctx->server_cert_type;
7680 *len = ctx->server_cert_type_len;
7681 return 1;
7682}
A mirror of the official openssl repository