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