0ho/openssl_C · Datasets at Hugging Face

file_path stringlengths 19 75	code stringlengths 279 1.37M
./openssl/apps/lib/log.c	/* * Copyright 2020-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/trace.h> #include "apps.h" #include "log.h" static int verbosity = LOG_INFO; int log_set_verbosity(const char prog, int level) { if (level < LOG_EMERG \|\| level > LOG_TRACE) { trace_log_message(-1, prog, LOG_ERR, "Invalid verbosity level %d", level); return 0; } verbosity = level; return 1; } int log_get_verbosity(void) { return verbosity; } #ifdef HTTP_DAEMON static int print_syslog(const char str, size_t len, void levPtr) { int level = (int )levPtr; int ilen = len > MAXERRLEN ? MAXERRLEN : len; syslog(level, "%.s", ilen, str); return ilen; } #endif static void log_with_prefix(const char prog, const char fmt, va_list ap) { char prefix[80]; BIO bio, pre = BIO_new(BIO_f_prefix()); (void)BIO_snprintf(prefix, sizeof(prefix), "%s: ", prog); (void)BIO_set_prefix(pre, prefix); bio = BIO_push(pre, bio_err); (void)BIO_vprintf(bio, fmt, ap); (void)BIO_printf(bio, "\n"); (void)BIO_flush(bio); (void)BIO_pop(pre); BIO_free(pre); } / * Unfortunately, C before C99 does not define va_copy, so we must * check if it can be assumed to be present. We do that with an internal * antifeature macro. * C versions since C94 define __STDC_VERSION__, so it's enough to * check its existence and value. / #undef OSSL_NO_C99 #if !defined(__STDC_VERSION__) \|\| __STDC_VERSION__ + 0 < 199900L # define OSSL_NO_C99 #endif void trace_log_message(int category, const char prog, int level, const char fmt, ...) { va_list ap; va_start(ap, fmt); #ifdef OSSL_NO_C99 if (verbosity >= level) category = -1; / disabling trace output in addition to logging / #endif if (category >= 0 && OSSL_trace_enabled(category)) { BIO out = OSSL_trace_begin(category); #ifndef OSSL_NO_C99 va_list ap_copy; va_copy(ap_copy, ap); (void)BIO_vprintf(out, fmt, ap_copy); va_end(ap_copy); #else (void)BIO_vprintf(out, fmt, ap); #endif (void)BIO_printf(out, "\n"); OSSL_trace_end(category, out); } if (verbosity < level) { va_end(ap); return; } #ifdef HTTP_DAEMON if (n_responders != 0) { vsyslog(level, fmt, ap); if (level <= LOG_ERR) ERR_print_errors_cb(print_syslog, &level); } else #endif log_with_prefix(prog, fmt, ap); va_end(ap); }
./openssl/apps/lib/http_server.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / Very basic HTTP server / #if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS) / * On VMS, you need to define this to get the declaration of fileno(). The * value 2 is to make sure no function defined in POSIX-2 is left undefined. / # define _POSIX_C_SOURCE 2 #endif #include <ctype.h> #include "http_server.h" #include "internal/sockets.h" #include <openssl/err.h> #include <openssl/trace.h> #include <openssl/rand.h> #include "s_apps.h" #include "log.h" #if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_fork)> # endif #endif #define HTTP_PREFIX "HTTP/" #define HTTP_VERSION_PATT "1." / allow 1.x / #define HTTP_PREFIX_VERSION HTTP_PREFIX""HTTP_VERSION_PATT #define HTTP_1_0 HTTP_PREFIX_VERSION"0" / "HTTP/1.0" / #define HTTP_VERSION_STR " "HTTP_PREFIX_VERSION #define log_HTTP(prog, level, text) \ trace_log_message(OSSL_TRACE_CATEGORY_HTTP, prog, level, "%s", text) #define log_HTTP1(prog, level, fmt, arg) \ trace_log_message(OSSL_TRACE_CATEGORY_HTTP, prog, level, fmt, arg) #define log_HTTP2(prog, level, fmt, arg1, arg2) \ trace_log_message(OSSL_TRACE_CATEGORY_HTTP, prog, level, fmt, arg1, arg2) #define log_HTTP3(prog, level, fmt, a1, a2, a3) \ trace_log_message(OSSL_TRACE_CATEGORY_HTTP, prog, level, fmt, a1, a2, a3) #ifdef HTTP_DAEMON int n_responders = 0; / run multiple responder processes, set by ocsp.c / int acfd = (int)INVALID_SOCKET; void socket_timeout(int signum) { if (acfd != (int)INVALID_SOCKET) (void)shutdown(acfd, SHUT_RD); } static void killall(int ret, pid_t kidpids) { int i; for (i = 0; i < n_responders; ++i) if (kidpids[i] != 0) (void)kill(kidpids[i], SIGTERM); OPENSSL_free(kidpids); OSSL_sleep(1000); exit(ret); } static int termsig = 0; static void noteterm(int sig) { termsig = sig; } /* * Loop spawning up to `multi` child processes, only child processes return * from this function. The parent process loops until receiving a termination * signal, kills extant children and exits without returning. / void spawn_loop(const char prog) { pid_t kidpids = NULL; int status; int procs = 0; int i; openlog(prog, LOG_PID, LOG_DAEMON); if (setpgid(0, 0)) { log_HTTP1(prog, LOG_CRIT, "error detaching from parent process group: %s", strerror(errno)); exit(1); } kidpids = app_malloc(n_responders sizeof(kidpids), "child PID array"); for (i = 0; i < n_responders; ++i) kidpids[i] = 0; signal(SIGINT, noteterm); signal(SIGTERM, noteterm); while (termsig == 0) { pid_t fpid; / * Wait for a child to replace when we're at the limit. * Slow down if a child exited abnormally or waitpid() < 0 / while (termsig == 0 && procs >= n_responders) { if ((fpid = waitpid(-1, &status, 0)) > 0) { for (i = 0; i < procs; ++i) { if (kidpids[i] == fpid) { kidpids[i] = 0; --procs; break; } } if (i >= n_responders) { log_HTTP1(prog, LOG_CRIT, "internal error: no matching child slot for pid: %ld", (long)fpid); killall(1, kidpids); } if (status != 0) { if (WIFEXITED(status)) { log_HTTP2(prog, LOG_WARNING, "child process: %ld, exit status: %d", (long)fpid, WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { char dumped = ""; # ifdef WCOREDUMP if (WCOREDUMP(status)) dumped = " (core dumped)"; # endif log_HTTP3(prog, LOG_WARNING, "child process: %ld, term signal %d%s", (long)fpid, WTERMSIG(status), dumped); } OSSL_sleep(1000); } break; } else if (errno != EINTR) { log_HTTP1(prog, LOG_CRIT, "waitpid() failed: %s", strerror(errno)); killall(1, kidpids); } } if (termsig) break; switch (fpid = fork()) { case -1: /* error / / System critically low on memory, pause and try again later / OSSL_sleep(30000); break; case 0: / child / OPENSSL_free(kidpids); signal(SIGINT, SIG_DFL); signal(SIGTERM, SIG_DFL); if (termsig) _exit(0); if (RAND_poll() <= 0) { log_HTTP(prog, LOG_CRIT, "RAND_poll() failed"); _exit(1); } return; default: / parent / for (i = 0; i < n_responders; ++i) { if (kidpids[i] == 0) { kidpids[i] = fpid; procs++; break; } } if (i >= n_responders) { log_HTTP(prog, LOG_CRIT, "internal error: no free child slots"); killall(1, kidpids); } break; } } / The loop above can only break on termsig / log_HTTP1(prog, LOG_INFO, "terminating on signal: %d", termsig); killall(0, kidpids); } #endif #ifndef OPENSSL_NO_SOCK BIO http_server_init(const char prog, const char port, int verb) { BIO acbio = NULL, bufbio; int asock; int port_num; char name[40]; snprintf(name, sizeof(name), ":%s", port); / port may be "0" / if (verb >= 0 && !log_set_verbosity(prog, verb)) return NULL; bufbio = BIO_new(BIO_f_buffer()); if (bufbio == NULL) goto err; acbio = BIO_new(BIO_s_accept()); if (acbio == NULL \|\| BIO_set_bind_mode(acbio, BIO_BIND_REUSEADDR) < 0 \|\| BIO_set_accept_name(acbio, name) < 0) { log_HTTP(prog, LOG_ERR, "error setting up accept BIO"); goto err; } BIO_set_accept_bios(acbio, bufbio); bufbio = NULL; if (BIO_do_accept(acbio) <= 0) { log_HTTP1(prog, LOG_ERR, "error setting accept on port %s", port); goto err; } / Report back what address and port are used / BIO_get_fd(acbio, &asock); port_num = report_server_accept(bio_out, asock, 1, 1); if (port_num == 0) { log_HTTP(prog, LOG_ERR, "error printing ACCEPT string"); goto err; } return acbio; err: ERR_print_errors(bio_err); BIO_free_all(acbio); BIO_free(bufbio); return NULL; } / * Decode %xx URL-decoding in-place. Ignores malformed sequences. / static int urldecode(char p) { unsigned char out = (unsigned char )p; unsigned char save = out; for (; p; p++) { if (p != '%') { out++ = p; } else if (isxdigit(_UC(p[1])) && isxdigit(_UC(p[2]))) { / Don't check, can't fail because of ixdigit() call. / out++ = (OPENSSL_hexchar2int(p[1]) << 4) \| OPENSSL_hexchar2int(p[2]); p += 2; } else { return -1; } } out = '\0'; return (int)(out - save); } / if pcbio != NULL, continue given connected session, else accept new / /* if found_keep_alive != NULL, return this way connection persistence state / int http_server_get_asn1_req(const ASN1_ITEM it, ASN1_VALUE preq, char ppath, BIO *pcbio, BIO acbio, int found_keep_alive, const char prog, int accept_get, int timeout) { BIO cbio = pcbio, getbio = NULL, b64 = NULL; int len; char reqbuf[2048], inbuf[2048]; char meth, url, end; ASN1_VALUE req; int ret = 0; preq = NULL; if (ppath != NULL) ppath = NULL; if (cbio == NULL) { char port; get_sock_info_address(BIO_get_fd(acbio, NULL), NULL, &port); if (port == NULL) { log_HTTP(prog, LOG_ERR, "cannot get port listening on"); goto fatal; } log_HTTP1(prog, LOG_DEBUG, "awaiting new connection on port %s ...", port); OPENSSL_free(port); if (BIO_do_accept(acbio) <= 0) / Connection loss before accept() is routine, ignore silently / return ret; pcbio = cbio = BIO_pop(acbio); } else { log_HTTP(prog, LOG_DEBUG, "awaiting next request ..."); } if (cbio == NULL) { /* Cannot call http_server_send_status(..., cbio, ...) / ret = -1; goto out; } # ifdef HTTP_DAEMON if (timeout > 0) { (void)BIO_get_fd(cbio, &acfd); alarm(timeout); } # endif / Read the request line. / len = BIO_gets(cbio, reqbuf, sizeof(reqbuf)); if (len == 0) return ret; ret = 1; if (len < 0) { log_HTTP(prog, LOG_WARNING, "request line read error"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } if (((end = strchr(reqbuf, '\r')) != NULL && end[1] == '\n') \|\| (end = strchr(reqbuf, '\n')) != NULL) end = '\0'; if (log_get_verbosity() < LOG_TRACE) trace_log_message(-1, prog, LOG_INFO, "received request, 1st line: %s", reqbuf); log_HTTP(prog, LOG_TRACE, "received request header:"); log_HTTP1(prog, LOG_TRACE, "%s", reqbuf); if (end == NULL) { log_HTTP(prog, LOG_WARNING, "cannot parse HTTP header: missing end of line"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } url = meth = reqbuf; if ((accept_get && CHECK_AND_SKIP_PREFIX(url, "GET ")) \|\| CHECK_AND_SKIP_PREFIX(url, "POST ")) { /* Expecting (GET\|POST) {sp} /URL {sp} HTTP/1.x / url[-1] = '\0'; while (url == ' ') url++; if (url != '/') { log_HTTP2(prog, LOG_WARNING, "invalid %s -- URL does not begin with '/': %s", meth, url); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } url++; / Splice off the HTTP version identifier. / for (end = url; end != '\0'; end++) if (end == ' ') break; if (!HAS_PREFIX(end, HTTP_VERSION_STR)) { log_HTTP2(prog, LOG_WARNING, "invalid %s -- bad HTTP/version string: %s", meth, end + 1); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } end = '\0'; /* above HTTP 1.0, connection persistence is the default / if (found_keep_alive != NULL) found_keep_alive = end[sizeof(HTTP_VERSION_STR) - 1] > '0'; /- Skip "GET / HTTP..." requests often used by load-balancers. * 'url' was incremented above to point to the first byte after * the leading slash, so in case 'GET / ' it is now an empty string. / if (strlen(meth) == 3 && url[0] == '\0') { (void)http_server_send_status(prog, cbio, 200, "OK"); goto out; } len = urldecode(url); if (len < 0) { log_HTTP2(prog, LOG_WARNING, "invalid %s request -- bad URL encoding: %s", meth, url); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } if (strlen(meth) == 3) { / GET / if ((getbio = BIO_new_mem_buf(url, len)) == NULL \|\| (b64 = BIO_new(BIO_f_base64())) == NULL) { log_HTTP1(prog, LOG_ERR, "could not allocate base64 bio with size = %d", len); goto fatal; } BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); getbio = BIO_push(b64, getbio); } } else { log_HTTP2(prog, LOG_WARNING, "HTTP request does not begin with %sPOST: %s", accept_get ? "GET or " : "", reqbuf); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } / chop any further/duplicate leading or trailing '/' / while (url == '/') url++; while (end >= url + 2 && end[-2] == '/' && end[-1] == '/') end--; end = '\0'; / Read and skip past the headers. / for (;;) { char key, value; len = BIO_gets(cbio, inbuf, sizeof(inbuf)); if (len <= 0) { log_HTTP(prog, LOG_WARNING, "error reading HTTP header"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } if (((end = strchr(inbuf, '\r')) != NULL && end[1] == '\n') \|\| (end = strchr(inbuf, '\n')) != NULL) end = '\0'; log_HTTP1(prog, LOG_TRACE, "%s", inbuf == '\0' ? " " / workaround for "" getting ignored / : inbuf); if (end == NULL) { log_HTTP(prog, LOG_WARNING, "error parsing HTTP header: missing end of line"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } if (inbuf[0] == '\0') break; key = inbuf; value = strchr(key, ':'); if (value == NULL) { log_HTTP(prog, LOG_WARNING, "error parsing HTTP header: missing ':'"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } (value++) = '\0'; while (value == ' ') value++; / https://tools.ietf.org/html/rfc7230#section-6.3 Persistence / if (found_keep_alive != NULL && OPENSSL_strcasecmp(key, "Connection") == 0) { if (OPENSSL_strcasecmp(value, "keep-alive") == 0) found_keep_alive = 1; else if (OPENSSL_strcasecmp(value, "close") == 0) found_keep_alive = 0; } } # ifdef HTTP_DAEMON / Clear alarm before we close the client socket / alarm(0); timeout = 0; # endif / Try to read and parse request / req = ASN1_item_d2i_bio(it, getbio != NULL ? getbio : cbio, NULL); if (req == NULL) { log_HTTP(prog, LOG_WARNING, "error parsing DER-encoded request content"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); } else if (ppath != NULL && (ppath = OPENSSL_strdup(url)) == NULL) { log_HTTP1(prog, LOG_ERR, "out of memory allocating %zu bytes", strlen(url) + 1); ASN1_item_free(req, it); goto fatal; } preq = req; out: BIO_free_all(getbio); # ifdef HTTP_DAEMON if (timeout > 0) alarm(0); acfd = (int)INVALID_SOCKET; # endif return ret; fatal: (void)http_server_send_status(prog, cbio, 500, "Internal Server Error"); if (ppath != NULL) { OPENSSL_free(ppath); ppath = NULL; } BIO_free_all(cbio); pcbio = NULL; ret = -1; goto out; } /* assumes that cbio does not do an encoding that changes the output length / int http_server_send_asn1_resp(const char prog, BIO cbio, int keep_alive, const char content_type, const ASN1_ITEM it, const ASN1_VALUE resp) { char buf[200], p; int ret = BIO_snprintf(buf, sizeof(buf), HTTP_1_0" 200 OK\r\n%s" "Content-type: %s\r\n" "Content-Length: %d\r\n", keep_alive ? "Connection: keep-alive\r\n" : "", content_type, ASN1_item_i2d(resp, NULL, it)); if (ret < 0 \|\| (size_t)ret >= sizeof(buf)) return 0; if (log_get_verbosity() < LOG_TRACE && (p = strchr(buf, '\r')) != NULL) trace_log_message(-1, prog, LOG_INFO, "sending response, 1st line: %.s", (int)(p - buf), buf); log_HTTP1(prog, LOG_TRACE, "sending response header:\n%s", buf); ret = BIO_printf(cbio, "%s\r\n", buf) > 0 && ASN1_item_i2d_bio(it, cbio, resp) > 0; (void)BIO_flush(cbio); return ret; } int http_server_send_status(const char prog, BIO cbio, int status, const char reason) { char buf[200]; int ret = BIO_snprintf(buf, sizeof(buf), HTTP_1_0" %d %s\r\n\r\n", / This implicitly cancels keep-alive */ status, reason); if (ret < 0 \|\| (size_t)ret >= sizeof(buf)) return 0; log_HTTP1(prog, LOG_TRACE, "sending response header:\n%s", buf); ret = BIO_printf(cbio, "%s\r\n", buf) > 0; (void)BIO_flush(cbio); return ret; } #endif
./openssl/apps/lib/opt.c	/* * Copyright 2015-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / * This file is also used by the test suite. Do not #include "apps.h". / #include "opt.h" #include "fmt.h" #include "app_libctx.h" #include "internal/nelem.h" #include "internal/numbers.h" #include <string.h> #if !defined(OPENSSL_SYS_MSDOS) # include <unistd.h> #endif #include <stdlib.h> #include <errno.h> #include <ctype.h> #include <limits.h> #include <openssl/err.h> #include <openssl/bio.h> #include <openssl/x509v3.h> #define MAX_OPT_HELP_WIDTH 30 const char OPT_HELP_STR[] = "-H"; const char OPT_MORE_STR[] = "-M"; const char OPT_SECTION_STR[] = "-S"; const char OPT_PARAM_STR[] = "-P"; / Our state / static char argv; static int argc; static int opt_index; static char arg; static char flag; static char dunno; static const char unknown_name; static const OPTIONS unknown; static const OPTIONS opts; static char prog[40]; / * Return the simple name of the program; removing various platform gunk. / #if defined(OPENSSL_SYS_WIN32) const char opt_path_end(const char filename) { const char p; /* find the last '/', '\' or ':' / for (p = filename + strlen(filename); --p > filename; ) if (p == '/' \|\| p == '\\' \|\| p == ':') { p++; break; } return p; } char opt_progname(const char argv0) { size_t i, n; const char p; char q; p = opt_path_end(argv0); /* Strip off trailing nonsense. / n = strlen(p); if (n > 4 && (strcmp(&p[n - 4], ".exe") == 0 \|\| strcmp(&p[n - 4], ".EXE") == 0)) n -= 4; / Copy over the name, in lowercase. / if (n > sizeof(prog) - 1) n = sizeof(prog) - 1; for (q = prog, i = 0; i < n; i++, p++) q++ = tolower((unsigned char)p); q = '\0'; return prog; } #elif defined(OPENSSL_SYS_VMS) const char opt_path_end(const char filename) { const char p; / Find last special character sys:[foo.bar]openssl / for (p = filename + strlen(filename); --p > filename;) if (p == ':' \|\| p == ']' \|\| p == '>') { p++; break; } return p; } char opt_progname(const char argv0) { const char p, q; /* Find last special character sys:[foo.bar]openssl / p = opt_path_end(argv0); q = strrchr(p, '.'); if (prog != p) strncpy(prog, p, sizeof(prog) - 1); prog[sizeof(prog) - 1] = '\0'; if (q != NULL && q - p < sizeof(prog)) prog[q - p] = '\0'; return prog; } #else const char opt_path_end(const char filename) { const char p; /* Could use strchr, but this is like the ones above. / for (p = filename + strlen(filename); --p > filename;) if (p == '/') { p++; break; } return p; } char opt_progname(const char argv0) { const char p; p = opt_path_end(argv0); if (prog != p) strncpy(prog, p, sizeof(prog) - 1); prog[sizeof(prog) - 1] = '\0'; return prog; } #endif char opt_appname(const char argv0) { size_t len = strlen(prog); if (argv0 != NULL) BIO_snprintf(prog + len, sizeof(prog) - len - 1, " %s", argv0); return prog; } char opt_getprog(void) { return prog; } /* Set up the arg parsing. / char opt_init(int ac, char *av, const OPTIONS o) { /* Store state. / argc = ac; argv = av; opt_begin(); opts = o; unknown = NULL; / Make sure prog name is set for usage output / (void)opt_progname(argv[0]); / Check all options up until the PARAM marker (if present) / for (; o->name != NULL && o->name != OPT_PARAM_STR; ++o) { #ifndef NDEBUG const OPTIONS next; int duplicated, i; #endif if (o->name == OPT_HELP_STR \|\| o->name == OPT_MORE_STR \|\| o->name == OPT_SECTION_STR) continue; #ifndef NDEBUG i = o->valtype; /* Make sure options are legit. / OPENSSL_assert(o->name[0] != '-'); if (o->valtype == '.') OPENSSL_assert(o->retval == OPT_PARAM); else OPENSSL_assert(o->retval == OPT_DUP \|\| o->retval > OPT_PARAM); switch (i) { case 0: case '-': case '.': case '/': case '<': case '>': case 'E': case 'F': case 'M': case 'U': case 'f': case 'l': case 'n': case 'p': case 's': case 'u': case 'c': case ':': case 'N': case 'A': break; default: OPENSSL_assert(0); } / Make sure there are no duplicates. / for (next = o + 1; next->name; ++next) { / * Some compilers inline strcmp and the assert string is too long. / duplicated = next->retval != OPT_DUP && strcmp(o->name, next->name) == 0; if (duplicated) { opt_printf_stderr("%s: Internal error: duplicate option %s\n", prog, o->name); OPENSSL_assert(!duplicated); } } #endif if (o->name[0] == '\0') { OPENSSL_assert(unknown_name != NULL); OPENSSL_assert(unknown == NULL); unknown = o; OPENSSL_assert(unknown->valtype == 0 \|\| unknown->valtype == '-'); } } return prog; } static OPT_PAIR formats[] = { {"pem", OPT_FMT_PEM}, {"der", OPT_FMT_DER}, {"b64", OPT_FMT_B64}, {"pkcs12", OPT_FMT_PKCS12}, {"smime", OPT_FMT_SMIME}, {"engine", OPT_FMT_ENGINE}, {"msblob", OPT_FMT_MSBLOB}, {"nss", OPT_FMT_NSS}, {"text", OPT_FMT_TEXT}, {"http", OPT_FMT_HTTP}, {"pvk", OPT_FMT_PVK}, {NULL} }; void opt_set_unknown_name(const char name) { unknown_name = name; } /* Print an error message about a failed format parse. / static int opt_format_error(const char s, unsigned long flags) { OPT_PAIR ap; opt_printf_stderr("%s: Bad format \"%s\"; must be one of: ", prog, s); for (ap = formats; ap->name; ap++) if (flags & ap->retval) opt_printf_stderr(" %s", ap->name); opt_printf_stderr("\n"); return 0; } / Parse a format string, put it into result; return 0 on failure, else 1. / int opt_format(const char s, unsigned long flags, int result) { switch (s) { default: opt_printf_stderr("%s: Bad format \"%s\"\n", prog, s); return 0; case 'B': case 'b': if (s[1] == '\0' \|\| strcmp(s, "B64") == 0 \|\| strcmp(s, "b64") == 0 \|\| strcmp(s, "BASE64") == 0 \|\| strcmp(s, "base64") == 0 ) { if ((flags & OPT_FMT_B64) == 0) return opt_format_error(s, flags); result = FORMAT_BASE64; } else { return 0; } break; case 'D': case 'd': if ((flags & OPT_FMT_DER) == 0) return opt_format_error(s, flags); result = FORMAT_ASN1; break; case 'T': case 't': if ((flags & OPT_FMT_TEXT) == 0) return opt_format_error(s, flags); result = FORMAT_TEXT; break; case 'N': case 'n': if ((flags & OPT_FMT_NSS) == 0) return opt_format_error(s, flags); if (strcmp(s, "NSS") != 0 && strcmp(s, "nss") != 0) return opt_format_error(s, flags); result = FORMAT_NSS; break; case 'S': case 's': if ((flags & OPT_FMT_SMIME) == 0) return opt_format_error(s, flags); result = FORMAT_SMIME; break; case 'M': case 'm': if ((flags & OPT_FMT_MSBLOB) == 0) return opt_format_error(s, flags); result = FORMAT_MSBLOB; break; case 'E': case 'e': if ((flags & OPT_FMT_ENGINE) == 0) return opt_format_error(s, flags); result = FORMAT_ENGINE; break; case 'H': case 'h': if ((flags & OPT_FMT_HTTP) == 0) return opt_format_error(s, flags); result = FORMAT_HTTP; break; case '1': if ((flags & OPT_FMT_PKCS12) == 0) return opt_format_error(s, flags); result = FORMAT_PKCS12; break; case 'P': case 'p': if (s[1] == '\0' \|\| strcmp(s, "PEM") == 0 \|\| strcmp(s, "pem") == 0) { if ((flags & OPT_FMT_PEM) == 0) return opt_format_error(s, flags); result = FORMAT_PEM; } else if (strcmp(s, "PVK") == 0 \|\| strcmp(s, "pvk") == 0) { if ((flags & OPT_FMT_PVK) == 0) return opt_format_error(s, flags); result = FORMAT_PVK; } else if (strcmp(s, "P12") == 0 \|\| strcmp(s, "p12") == 0 \|\| strcmp(s, "PKCS12") == 0 \|\| strcmp(s, "pkcs12") == 0) { if ((flags & OPT_FMT_PKCS12) == 0) return opt_format_error(s, flags); result = FORMAT_PKCS12; } else { opt_printf_stderr("%s: Bad format \"%s\"\n", prog, s); return 0; } break; } return 1; } / Return string representing the given format. / static const char format2str(int format) { switch (format) { default: return "(undefined)"; case FORMAT_PEM: return "PEM"; case FORMAT_ASN1: return "DER"; case FORMAT_TEXT: return "TEXT"; case FORMAT_NSS: return "NSS"; case FORMAT_SMIME: return "SMIME"; case FORMAT_MSBLOB: return "MSBLOB"; case FORMAT_ENGINE: return "ENGINE"; case FORMAT_HTTP: return "HTTP"; case FORMAT_PKCS12: return "P12"; case FORMAT_PVK: return "PVK"; } } /* Print an error message about unsuitable/unsupported format requested. / void print_format_error(int format, unsigned long flags) { (void)opt_format_error(format2str(format), flags); } / * Parse a cipher name, put it in cipherp after freeing what was there, if cipherp is not NULL. Return 0 on failure, else 1. / int opt_cipher_silent(const char name, EVP_CIPHER *cipherp) { EVP_CIPHER c; ERR_set_mark(); if ((c = EVP_CIPHER_fetch(app_get0_libctx(), name, app_get0_propq())) != NULL \|\| (opt_legacy_okay() && (c = (EVP_CIPHER )EVP_get_cipherbyname(name)) != NULL)) { ERR_pop_to_mark(); if (cipherp != NULL) { EVP_CIPHER_free(cipherp); cipherp = c; } else { EVP_CIPHER_free(c); } return 1; } ERR_clear_last_mark(); return 0; } int opt_cipher_any(const char name, EVP_CIPHER *cipherp) { int ret; if (name == NULL) return 1; if ((ret = opt_cipher_silent(name, cipherp)) == 0) opt_printf_stderr("%s: Unknown option or cipher: %s\n", prog, name); return ret; } int opt_cipher(const char name, EVP_CIPHER *cipherp) { int mode, ret = 0; unsigned long int flags; EVP_CIPHER c = NULL; if (name == NULL) return 1; if (opt_cipher_any(name, &c)) { mode = EVP_CIPHER_get_mode(c); flags = EVP_CIPHER_get_flags(c); if (mode == EVP_CIPH_XTS_MODE) { opt_printf_stderr("%s XTS ciphers not supported\n", prog); } else if ((flags & EVP_CIPH_FLAG_AEAD_CIPHER) != 0) { opt_printf_stderr("%s: AEAD ciphers not supported\n", prog); } else { ret = 1; if (cipherp != NULL) cipherp = c; } } return ret; } / * Parse message digest name, put it in EVP_MD; return 0 on failure, else 1. / int opt_md_silent(const char name, EVP_MD mdp) { EVP_MD md; ERR_set_mark(); if ((md = EVP_MD_fetch(app_get0_libctx(), name, app_get0_propq())) != NULL \|\| (opt_legacy_okay() && (md = (EVP_MD )EVP_get_digestbyname(name)) != NULL)) { ERR_pop_to_mark(); if (mdp != NULL) { EVP_MD_free(mdp); mdp = md; } else { EVP_MD_free(md); } return 1; } ERR_clear_last_mark(); return 0; } int opt_md(const char name, EVP_MD *mdp) { int ret; if (name == NULL) return 1; if ((ret = opt_md_silent(name, mdp)) == 0) opt_printf_stderr("%s: Unknown option or message digest: %s\n", prog, name); return ret; } int opt_check_md(const char name) { if (opt_md(name, NULL)) return 1; ERR_clear_error(); return 0; } /* Look through a list of name/value pairs. / int opt_pair(const char name, const OPT_PAIR* pairs, int result) { const OPT_PAIR pp; for (pp = pairs; pp->name; pp++) if (strcmp(pp->name, name) == 0) { result = pp->retval; return 1; } opt_printf_stderr("%s: Value must be one of:\n", prog); for (pp = pairs; pp->name; pp++) opt_printf_stderr("\t%s\n", pp->name); return 0; } / Look through a list of valid names / int opt_string(const char name, const char options) { const char p; for (p = options; p != NULL; p++) if (strcmp(p, name) == 0) return 1; opt_printf_stderr("%s: Value must be one of:\n", prog); for (p = options; p != NULL; p++) opt_printf_stderr("\t%s\n", p); return 0; } /* Parse an int, put it into result; return 0 on failure, else 1. / int opt_int(const char value, int result) { long l; if (!opt_long(value, &l)) return 0; result = (int)l; if (result != l) { opt_printf_stderr("%s: Value \"%s\" outside integer range\n", prog, value); return 0; } return 1; } /* Parse and return an integer, assuming range has been checked before. / int opt_int_arg(void) { int result = -1; (void)opt_int(arg, &result); return result; } static void opt_number_error(const char v) { size_t i = 0; struct strstr_pair_st { char prefix; char name; } b[] = { {"0x", "a hexadecimal"}, {"0X", "a hexadecimal"}, {"0", "an octal"} }; for (i = 0; i < OSSL_NELEM(b); i++) { if (strncmp(v, b[i].prefix, strlen(b[i].prefix)) == 0) { opt_printf_stderr("%s: Can't parse \"%s\" as %s number\n", prog, v, b[i].name); return; } } opt_printf_stderr("%s: Can't parse \"%s\" as a number\n", prog, v); return; } /* Parse a long, put it into result; return 0 on failure, else 1. / int opt_long(const char value, long result) { int oerrno = errno; long l; char endp; errno = 0; l = strtol(value, &endp, 0); if (endp \|\| endp == value \|\| ((l == LONG_MAX \|\| l == LONG_MIN) && errno == ERANGE) \|\| (l == 0 && errno != 0)) { opt_number_error(value); errno = oerrno; return 0; } result = l; errno = oerrno; return 1; } #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \ defined(INTMAX_MAX) && defined(UINTMAX_MAX) && \ !defined(OPENSSL_NO_INTTYPES_H) / Parse an intmax_t, put it into result; return 0 on failure, else 1. / int opt_intmax(const char value, ossl_intmax_t result) { int oerrno = errno; intmax_t m; char endp; errno = 0; m = strtoimax(value, &endp, 0); if (endp \|\| endp == value \|\| ((m == INTMAX_MAX \|\| m == INTMAX_MIN) && errno == ERANGE) \|\| (m == 0 && errno != 0)) { opt_number_error(value); errno = oerrno; return 0; } /* Ensure that the value in \|m\| is never too big for \|result\| / if (sizeof(m) > sizeof(result) && (m < OSSL_INTMAX_MIN \|\| m > OSSL_INTMAX_MAX)) { opt_number_error(value); return 0; } result = (ossl_intmax_t)m; errno = oerrno; return 1; } /* Parse a uintmax_t, put it into result; return 0 on failure, else 1. / int opt_uintmax(const char value, ossl_uintmax_t result) { int oerrno = errno; uintmax_t m; char endp; errno = 0; m = strtoumax(value, &endp, 0); if (endp \|\| endp == value \|\| (m == UINTMAX_MAX && errno == ERANGE) \|\| (m == 0 && errno != 0)) { opt_number_error(value); errno = oerrno; return 0; } /* Ensure that the value in \|m\| is never too big for \|result\| / if (sizeof(m) > sizeof(result) && m > OSSL_UINTMAX_MAX) { opt_number_error(value); return 0; } result = (ossl_intmax_t)m; errno = oerrno; return 1; } #else /* Fallback implementations based on long / int opt_intmax(const char value, ossl_intmax_t result) { long m; int ret; if ((ret = opt_long(value, &m))) result = m; return ret; } int opt_uintmax(const char value, ossl_uintmax_t result) { unsigned long m; int ret; if ((ret = opt_ulong(value, &m))) result = m; return ret; } #endif / * Parse an unsigned long, put it into result; return 0 on failure, else 1. / int opt_ulong(const char value, unsigned long result) { int oerrno = errno; char endptr; unsigned long l; errno = 0; l = strtoul(value, &endptr, 0); if (endptr \|\| endptr == value \|\| ((l == ULONG_MAX) && errno == ERANGE) \|\| (l == 0 && errno != 0)) { opt_number_error(value); errno = oerrno; return 0; } result = l; errno = oerrno; return 1; } / * We pass opt as an int but cast it to "enum range" so that all the * items in the OPT_V_ENUM enumeration are caught; this makes -Wswitch * in gcc do the right thing. / enum range { OPT_V_ENUM }; int opt_verify(int opt, X509_VERIFY_PARAM vpm) { int i; ossl_intmax_t t = 0; ASN1_OBJECT otmp; X509_PURPOSE xptmp; const X509_VERIFY_PARAM vtmp; OPENSSL_assert(vpm != NULL); OPENSSL_assert(opt > OPT_V__FIRST); OPENSSL_assert(opt < OPT_V__LAST); switch ((enum range)opt) { case OPT_V__FIRST: case OPT_V__LAST: return 0; case OPT_V_POLICY: otmp = OBJ_txt2obj(opt_arg(), 0); if (otmp == NULL) { opt_printf_stderr("%s: Invalid Policy %s\n", prog, opt_arg()); return 0; } if (!X509_VERIFY_PARAM_add0_policy(vpm, otmp)) { ASN1_OBJECT_free(otmp); opt_printf_stderr("%s: Internal error adding Policy %s\n", prog, opt_arg()); return 0; } break; case OPT_V_PURPOSE: / purpose name -> purpose index / i = X509_PURPOSE_get_by_sname(opt_arg()); if (i < 0) { opt_printf_stderr("%s: Invalid purpose %s\n", prog, opt_arg()); return 0; } / purpose index -> purpose object / xptmp = X509_PURPOSE_get0(i); / purpose object -> purpose value / i = X509_PURPOSE_get_id(xptmp); if (!X509_VERIFY_PARAM_set_purpose(vpm, i)) { opt_printf_stderr("%s: Internal error setting purpose %s\n", prog, opt_arg()); return 0; } break; case OPT_V_VERIFY_NAME: vtmp = X509_VERIFY_PARAM_lookup(opt_arg()); if (vtmp == NULL) { opt_printf_stderr("%s: Invalid verify name %s\n", prog, opt_arg()); return 0; } X509_VERIFY_PARAM_set1(vpm, vtmp); break; case OPT_V_VERIFY_DEPTH: i = atoi(opt_arg()); if (i >= 0) X509_VERIFY_PARAM_set_depth(vpm, i); break; case OPT_V_VERIFY_AUTH_LEVEL: i = atoi(opt_arg()); if (i >= 0) X509_VERIFY_PARAM_set_auth_level(vpm, i); break; case OPT_V_ATTIME: if (!opt_intmax(opt_arg(), &t)) return 0; if (t != (time_t)t) { opt_printf_stderr("%s: epoch time out of range %s\n", prog, opt_arg()); return 0; } X509_VERIFY_PARAM_set_time(vpm, (time_t)t); break; case OPT_V_VERIFY_HOSTNAME: if (!X509_VERIFY_PARAM_set1_host(vpm, opt_arg(), 0)) return 0; break; case OPT_V_VERIFY_EMAIL: if (!X509_VERIFY_PARAM_set1_email(vpm, opt_arg(), 0)) return 0; break; case OPT_V_VERIFY_IP: if (!X509_VERIFY_PARAM_set1_ip_asc(vpm, opt_arg())) return 0; break; case OPT_V_IGNORE_CRITICAL: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_IGNORE_CRITICAL); break; case OPT_V_ISSUER_CHECKS: / NOP, deprecated / break; case OPT_V_CRL_CHECK: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CRL_CHECK); break; case OPT_V_CRL_CHECK_ALL: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CRL_CHECK \| X509_V_FLAG_CRL_CHECK_ALL); break; case OPT_V_POLICY_CHECK: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_POLICY_CHECK); break; case OPT_V_EXPLICIT_POLICY: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_EXPLICIT_POLICY); break; case OPT_V_INHIBIT_ANY: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_INHIBIT_ANY); break; case OPT_V_INHIBIT_MAP: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_INHIBIT_MAP); break; case OPT_V_X509_STRICT: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_X509_STRICT); break; case OPT_V_EXTENDED_CRL: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_EXTENDED_CRL_SUPPORT); break; case OPT_V_USE_DELTAS: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_USE_DELTAS); break; case OPT_V_POLICY_PRINT: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NOTIFY_POLICY); break; case OPT_V_CHECK_SS_SIG: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CHECK_SS_SIGNATURE); break; case OPT_V_TRUSTED_FIRST: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_TRUSTED_FIRST); break; case OPT_V_SUITEB_128_ONLY: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_128_LOS_ONLY); break; case OPT_V_SUITEB_128: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_128_LOS); break; case OPT_V_SUITEB_192: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_192_LOS); break; case OPT_V_PARTIAL_CHAIN: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_PARTIAL_CHAIN); break; case OPT_V_NO_ALT_CHAINS: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NO_ALT_CHAINS); break; case OPT_V_NO_CHECK_TIME: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NO_CHECK_TIME); break; case OPT_V_ALLOW_PROXY_CERTS: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_ALLOW_PROXY_CERTS); break; } return 1; } void opt_begin(void) { opt_index = 1; arg = NULL; flag = NULL; } / * Parse the next flag (and value if specified), return 0 if done, -1 on * error, otherwise the flag's retval. / int opt_next(void) { char p; const OPTIONS o; int ival; long lval; unsigned long ulval; ossl_intmax_t imval; ossl_uintmax_t umval; / Look at current arg; at end of the list? / arg = NULL; p = argv[opt_index]; if (p == NULL) return 0; / If word doesn't start with a -, we're done. / if (p != '-') return 0; /* Hit "--" ? We're done. / opt_index++; if (strcmp(p, "--") == 0) return 0; / Allow -nnn and --nnn / if (++p == '-') p++; flag = p - 1; /* If we have --flag=foo, snip it off / if ((arg = strchr(p, '=')) != NULL) arg++ = '\0'; for (o = opts; o->name; ++o) { /* If not this option, move on to the next one. / if (!(strcmp(p, "h") == 0 && strcmp(o->name, "help") == 0) && strcmp(p, o->name) != 0) continue; / If it doesn't take a value, make sure none was given. / if (o->valtype == 0 \|\| o->valtype == '-') { if (arg) { opt_printf_stderr("%s: Option -%s does not take a value\n", prog, p); return -1; } return o->retval; } / Want a value; get the next param if =foo not used. / if (arg == NULL) { if (argv[opt_index] == NULL) { opt_printf_stderr("%s: Option -%s needs a value\n", prog, o->name); return -1; } arg = argv[opt_index++]; } / Syntax-check value. / switch (o->valtype) { default: case 's': case ':': / Just a string. / break; case '.': / Parameters / break; case '/': if (opt_isdir(arg) > 0) break; opt_printf_stderr("%s: Not a directory: %s\n", prog, arg); return -1; case '<': / Input file. / break; case '>': / Output file. / break; case 'p': case 'n': case 'N': if (!opt_int(arg, &ival)) return -1; if (o->valtype == 'p' && ival <= 0) { opt_printf_stderr("%s: Non-positive number \"%s\" for option -%s\n", prog, arg, o->name); return -1; } if (o->valtype == 'N' && ival < 0) { opt_printf_stderr("%s: Negative number \"%s\" for option -%s\n", prog, arg, o->name); return -1; } break; case 'M': if (!opt_intmax(arg, &imval)) return -1; break; case 'U': if (!opt_uintmax(arg, &umval)) return -1; break; case 'l': if (!opt_long(arg, &lval)) return -1; break; case 'u': if (!opt_ulong(arg, &ulval)) return -1; break; case 'c': case 'E': case 'F': case 'f': case 'A': case 'a': if (opt_format(arg, o->valtype == 'c' ? OPT_FMT_PDS : o->valtype == 'E' ? OPT_FMT_PDE : o->valtype == 'F' ? OPT_FMT_PEMDER : o->valtype == 'A' ? OPT_FMT_ASN1 : OPT_FMT_ANY, &ival)) break; opt_printf_stderr("%s: Invalid format \"%s\" for option -%s\n", prog, arg, o->name); return -1; } / Return the flag value. / return o->retval; } if (unknown != NULL) { if (dunno != NULL) { opt_printf_stderr("%s: Multiple %s or unknown options: -%s and -%s\n", prog, unknown_name, dunno, p); return -1; } dunno = p; return unknown->retval; } opt_printf_stderr("%s: Unknown option: -%s\n", prog, p); return -1; } / Return the most recent flag parameter. / char opt_arg(void) { return arg; } /* Return the most recent flag (option name including the preceding '-'). / char opt_flag(void) { return flag; } /* Return the unknown option. / char opt_unknown(void) { return dunno; } /* Reset the unknown option; needed by ocsp to allow multiple digest options. / void reset_unknown(void) { dunno = NULL; } / Return the rest of the arguments after parsing flags. / char opt_rest(void) { return &argv[opt_index]; } / How many items in remaining args? / int opt_num_rest(void) { int i = 0; char pp; for (pp = opt_rest(); pp; pp++, i++) continue; return i; } int opt_check_rest_arg(const char expected) { char opt = opt_rest(); if (opt == NULL \|\| opt == '\0') { if (expected == NULL) return 1; opt_printf_stderr("%s: Missing argument: %s\n", prog, expected); return 0; } if (expected != NULL) { opt = argv[opt_index + 1]; if (opt == NULL \|\| opt == '\0') return 1; opt_printf_stderr("%s: Extra argument after %s: \"%s\"\n", prog, expected, opt); return 0; } if (opt_unknown() == NULL) opt_printf_stderr("%s: Extra option: \"%s\"\n", prog, opt); else opt_printf_stderr("%s: Extra (unknown) options: \"%s\" \"%s\"\n", prog, opt_unknown(), opt); return 0; } / Return a string describing the parameter type. / static const char valtype2param(const OPTIONS o) { switch (o->valtype) { case 0: case '-': return ""; case ':': return "uri"; case 's': return "val"; case '/': return "dir"; case '<': return "infile"; case '>': return "outfile"; case 'p': return "+int"; case 'n': return "int"; case 'l': return "long"; case 'u': return "ulong"; case 'E': return "PEM\|DER\|ENGINE"; case 'F': return "PEM\|DER"; case 'f': return "format"; case 'M': return "intmax"; case 'N': return "nonneg"; case 'U': return "uintmax"; } return "parm"; } static void opt_print(const OPTIONS o, int doingparams, int width) { const char* help; char start[80 + 1]; int linelen, printlen; /* Avoid OOB if width is beyond the buffer size of start / if (width >= (int)sizeof(start)) width = (int)sizeof(start) - 1; help = o->helpstr ? o->helpstr : "(No additional info)"; if (o->name == OPT_HELP_STR) { opt_printf_stderr(help, prog); return; } else if (o->name == OPT_SECTION_STR) { opt_printf_stderr("\n"); opt_printf_stderr(help, prog); return; } else if (o->name == OPT_PARAM_STR) { opt_printf_stderr("\nParameters:\n"); return; } / Pad out prefix / memset(start, ' ', sizeof(start) - 1); start[sizeof(start) - 1] = '\0'; if (o->name == OPT_MORE_STR) { / Continuation of previous line; pad and print. / start[width] = '\0'; opt_printf_stderr("%s %s\n", start, help); return; } / Build up the "-flag [param]" part. / linelen = 0; printlen = opt_printf_stderr(" %s", !doingparams ? "-" : ""); linelen += (printlen > 0) ? printlen : MAX_OPT_HELP_WIDTH; printlen = opt_printf_stderr("%s" , o->name[0] ? o->name : ""); linelen += (printlen > 0) ? printlen : MAX_OPT_HELP_WIDTH; if (o->valtype != '-') { printlen = opt_printf_stderr(" %s" , valtype2param(o)); linelen += (printlen > 0) ? printlen : MAX_OPT_HELP_WIDTH; } if (linelen >= MAX_OPT_HELP_WIDTH \|\| linelen > width) { opt_printf_stderr("%s", "\n"); memset(start, ' ', sizeof(start)); linelen = 0; } width -= linelen; start[width] = '\0'; opt_printf_stderr("%s %s\n", start, help); } void opt_help(const OPTIONS list) { const OPTIONS o; int i, sawparams = 0, width = 5; int standard_prolog; /* Starts with its own help message? / standard_prolog = list[0].name != OPT_HELP_STR; / Find the widest help. / for (o = list; o->name; o++) { if (o->name == OPT_MORE_STR) continue; i = 2 + (int)strlen(o->name); if (o->valtype != '-') i += 1 + strlen(valtype2param(o)); if (i > width) width = i; } if (width > MAX_OPT_HELP_WIDTH) width = MAX_OPT_HELP_WIDTH; if (standard_prolog) { opt_printf_stderr("Usage: %s [options]\n", prog); if (list[0].name != OPT_SECTION_STR) opt_printf_stderr("Valid options are:\n", prog); } / Now let's print. / for (o = list; o->name; o++) { if (o->name == OPT_PARAM_STR) sawparams = 1; opt_print(o, sawparams, width); } } / opt_isdir section / #ifdef _WIN32 # include <windows.h> int opt_isdir(const char name) { DWORD attr; # if defined(UNICODE) \|\| defined(_UNICODE) size_t i, len_0 = strlen(name) + 1; WCHAR tempname[MAX_PATH]; if (len_0 > MAX_PATH) return -1; # if !defined(_WIN32_WCE) \|\| _WIN32_WCE>=101 if (!MultiByteToWideChar(CP_ACP, 0, name, len_0, tempname, MAX_PATH)) # endif for (i = 0; i < len_0; i++) tempname[i] = (WCHAR)name[i]; attr = GetFileAttributes(tempname); # else attr = GetFileAttributes(name); # endif if (attr == INVALID_FILE_ATTRIBUTES) return -1; return ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0); } #else # include <sys/stat.h> # ifndef S_ISDIR # if defined(_S_IFMT) && defined(_S_IFDIR) # define S_ISDIR(a) (((a) & _S_IFMT) == _S_IFDIR) # else # define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR) # endif # endif int opt_isdir(const char *name) { # if defined(S_ISDIR) struct stat st; if (stat(name, &st) == 0) return S_ISDIR(st.st_mode); else return -1; # else return -1; # endif } #endif
./openssl/apps/lib/s_cb.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / * callback functions used by s_client, s_server, and s_time, * as well as other common logic for those apps / #include <stdio.h> #include <stdlib.h> #include <string.h> / for memcpy() and strcmp() / #include "apps.h" #include <openssl/core_names.h> #include <openssl/params.h> #include <openssl/err.h> #include <openssl/rand.h> #include <openssl/x509.h> #include <openssl/ssl.h> #include <openssl/bn.h> #ifndef OPENSSL_NO_DH # include <openssl/dh.h> #endif #include "s_apps.h" #define COOKIE_SECRET_LENGTH 16 VERIFY_CB_ARGS verify_args = { -1, 0, X509_V_OK, 0 }; #ifndef OPENSSL_NO_SOCK static unsigned char cookie_secret[COOKIE_SECRET_LENGTH]; static int cookie_initialized = 0; #endif static BIO bio_keylog = NULL; static const char lookup(int val, const STRINT_PAIR list, const char* def) { for ( ; list->name; ++list) if (list->retval == val) return list->name; return def; } int verify_callback(int ok, X509_STORE_CTX ctx) { X509 err_cert; int err, depth; err_cert = X509_STORE_CTX_get_current_cert(ctx); err = X509_STORE_CTX_get_error(ctx); depth = X509_STORE_CTX_get_error_depth(ctx); if (!verify_args.quiet \|\| !ok) { BIO_printf(bio_err, "depth=%d ", depth); if (err_cert != NULL) { X509_NAME_print_ex(bio_err, X509_get_subject_name(err_cert), 0, get_nameopt()); BIO_puts(bio_err, "\n"); } else { BIO_puts(bio_err, "<no cert>\n"); } } if (!ok) { BIO_printf(bio_err, "verify error:num=%d:%s\n", err, X509_verify_cert_error_string(err)); if (verify_args.depth < 0 \|\| verify_args.depth >= depth) { if (!verify_args.return_error) ok = 1; verify_args.error = err; } else { ok = 0; verify_args.error = X509_V_ERR_CERT_CHAIN_TOO_LONG; } } switch (err) { case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: if (err_cert != NULL) { BIO_puts(bio_err, "issuer= "); X509_NAME_print_ex(bio_err, X509_get_issuer_name(err_cert), 0, get_nameopt()); BIO_puts(bio_err, "\n"); } break; case X509_V_ERR_CERT_NOT_YET_VALID: case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: if (err_cert != NULL) { BIO_printf(bio_err, "notBefore="); ASN1_TIME_print(bio_err, X509_get0_notBefore(err_cert)); BIO_printf(bio_err, "\n"); } break; case X509_V_ERR_CERT_HAS_EXPIRED: case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: if (err_cert != NULL) { BIO_printf(bio_err, "notAfter="); ASN1_TIME_print(bio_err, X509_get0_notAfter(err_cert)); BIO_printf(bio_err, "\n"); } break; case X509_V_ERR_NO_EXPLICIT_POLICY: if (!verify_args.quiet) policies_print(ctx); break; } if (err == X509_V_OK && ok == 2 && !verify_args.quiet) policies_print(ctx); if (ok && !verify_args.quiet) BIO_printf(bio_err, "verify return:%d\n", ok); return ok; } int set_cert_stuff(SSL_CTX ctx, char cert_file, char key_file) { if (cert_file != NULL) { if (SSL_CTX_use_certificate_file(ctx, cert_file, SSL_FILETYPE_PEM) <= 0) { BIO_printf(bio_err, "unable to get certificate from '%s'\n", cert_file); ERR_print_errors(bio_err); return 0; } if (key_file == NULL) key_file = cert_file; if (SSL_CTX_use_PrivateKey_file(ctx, key_file, SSL_FILETYPE_PEM) <= 0) { BIO_printf(bio_err, "unable to get private key from '%s'\n", key_file); ERR_print_errors(bio_err); return 0; } / * If we are using DSA, we can copy the parameters from the private * key / / * Now we know that a key and cert have been set against the SSL * context / if (!SSL_CTX_check_private_key(ctx)) { BIO_printf(bio_err, "Private key does not match the certificate public key\n"); return 0; } } return 1; } int set_cert_key_stuff(SSL_CTX ctx, X509 cert, EVP_PKEY key, STACK_OF(X509) chain, int build_chain) { int chflags = chain ? SSL_BUILD_CHAIN_FLAG_CHECK : 0; if (cert == NULL) return 1; if (SSL_CTX_use_certificate(ctx, cert) <= 0) { BIO_printf(bio_err, "error setting certificate\n"); ERR_print_errors(bio_err); return 0; } if (SSL_CTX_use_PrivateKey(ctx, key) <= 0) { BIO_printf(bio_err, "error setting private key\n"); ERR_print_errors(bio_err); return 0; } / * Now we know that a key and cert have been set against the SSL context / if (!SSL_CTX_check_private_key(ctx)) { BIO_printf(bio_err, "Private key does not match the certificate public key\n"); return 0; } if (chain && !SSL_CTX_set1_chain(ctx, chain)) { BIO_printf(bio_err, "error setting certificate chain\n"); ERR_print_errors(bio_err); return 0; } if (build_chain && !SSL_CTX_build_cert_chain(ctx, chflags)) { BIO_printf(bio_err, "error building certificate chain\n"); ERR_print_errors(bio_err); return 0; } return 1; } static STRINT_PAIR cert_type_list[] = { {"RSA sign", TLS_CT_RSA_SIGN}, {"DSA sign", TLS_CT_DSS_SIGN}, {"RSA fixed DH", TLS_CT_RSA_FIXED_DH}, {"DSS fixed DH", TLS_CT_DSS_FIXED_DH}, {"ECDSA sign", TLS_CT_ECDSA_SIGN}, {"RSA fixed ECDH", TLS_CT_RSA_FIXED_ECDH}, {"ECDSA fixed ECDH", TLS_CT_ECDSA_FIXED_ECDH}, {"GOST01 Sign", TLS_CT_GOST01_SIGN}, {"GOST12 Sign", TLS_CT_GOST12_IANA_SIGN}, {NULL} }; static void ssl_print_client_cert_types(BIO bio, SSL s) { const unsigned char p; int i; int cert_type_num = SSL_get0_certificate_types(s, &p); if (!cert_type_num) return; BIO_puts(bio, "Client Certificate Types: "); for (i = 0; i < cert_type_num; i++) { unsigned char cert_type = p[i]; const char cname = lookup((int)cert_type, cert_type_list, NULL); if (i) BIO_puts(bio, ", "); if (cname != NULL) BIO_puts(bio, cname); else BIO_printf(bio, "UNKNOWN (%d),", cert_type); } BIO_puts(bio, "\n"); } static const char get_sigtype(int nid) { switch (nid) { case EVP_PKEY_RSA: return "RSA"; case EVP_PKEY_RSA_PSS: return "RSA-PSS"; case EVP_PKEY_DSA: return "DSA"; case EVP_PKEY_EC: return "ECDSA"; case NID_ED25519: return "Ed25519"; case NID_ED448: return "Ed448"; case NID_id_GostR3410_2001: return "gost2001"; case NID_id_GostR3410_2012_256: return "gost2012_256"; case NID_id_GostR3410_2012_512: return "gost2012_512"; default: /* Try to output provider-registered sig alg name / return OBJ_nid2sn(nid); } } static int do_print_sigalgs(BIO out, SSL s, int shared) { int i, nsig, client; client = SSL_is_server(s) ? 0 : 1; if (shared) nsig = SSL_get_shared_sigalgs(s, 0, NULL, NULL, NULL, NULL, NULL); else nsig = SSL_get_sigalgs(s, -1, NULL, NULL, NULL, NULL, NULL); if (nsig == 0) return 1; if (shared) BIO_puts(out, "Shared "); if (client) BIO_puts(out, "Requested "); BIO_puts(out, "Signature Algorithms: "); for (i = 0; i < nsig; i++) { int hash_nid, sign_nid; unsigned char rhash, rsign; const char sstr = NULL; if (shared) SSL_get_shared_sigalgs(s, i, &sign_nid, &hash_nid, NULL, &rsign, &rhash); else SSL_get_sigalgs(s, i, &sign_nid, &hash_nid, NULL, &rsign, &rhash); if (i) BIO_puts(out, ":"); sstr = get_sigtype(sign_nid); if (sstr) BIO_printf(out, "%s", sstr); else BIO_printf(out, "0x%02X", (int)rsign); if (hash_nid != NID_undef) BIO_printf(out, "+%s", OBJ_nid2sn(hash_nid)); else if (sstr == NULL) BIO_printf(out, "+0x%02X", (int)rhash); } BIO_puts(out, "\n"); return 1; } int ssl_print_sigalgs(BIO out, SSL s) { int nid; if (!SSL_is_server(s)) ssl_print_client_cert_types(out, s); do_print_sigalgs(out, s, 0); do_print_sigalgs(out, s, 1); if (SSL_get_peer_signature_nid(s, &nid) && nid != NID_undef) BIO_printf(out, "Peer signing digest: %s\n", OBJ_nid2sn(nid)); if (SSL_get_peer_signature_type_nid(s, &nid)) BIO_printf(out, "Peer signature type: %s\n", get_sigtype(nid)); return 1; } #ifndef OPENSSL_NO_EC int ssl_print_point_formats(BIO out, SSL s) { int i, nformats; const char pformats; nformats = SSL_get0_ec_point_formats(s, &pformats); if (nformats <= 0) return 1; BIO_puts(out, "Supported Elliptic Curve Point Formats: "); for (i = 0; i < nformats; i++, pformats++) { if (i) BIO_puts(out, ":"); switch (pformats) { case TLSEXT_ECPOINTFORMAT_uncompressed: BIO_puts(out, "uncompressed"); break; case TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime: BIO_puts(out, "ansiX962_compressed_prime"); break; case TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2: BIO_puts(out, "ansiX962_compressed_char2"); break; default: BIO_printf(out, "unknown(%d)", (int)pformats); break; } } BIO_puts(out, "\n"); return 1; } int ssl_print_groups(BIO out, SSL s, int noshared) { int i, ngroups, groups, nid; ngroups = SSL_get1_groups(s, NULL); if (ngroups <= 0) return 1; groups = app_malloc(ngroups * sizeof(int), "groups to print"); SSL_get1_groups(s, groups); BIO_puts(out, "Supported groups: "); for (i = 0; i < ngroups; i++) { if (i) BIO_puts(out, ":"); nid = groups[i]; BIO_printf(out, "%s", SSL_group_to_name(s, nid)); } OPENSSL_free(groups); if (noshared) { BIO_puts(out, "\n"); return 1; } BIO_puts(out, "\nShared groups: "); ngroups = SSL_get_shared_group(s, -1); for (i = 0; i < ngroups; i++) { if (i) BIO_puts(out, ":"); nid = SSL_get_shared_group(s, i); BIO_printf(out, "%s", SSL_group_to_name(s, nid)); } if (ngroups == 0) BIO_puts(out, "NONE"); BIO_puts(out, "\n"); return 1; } #endif int ssl_print_tmp_key(BIO out, SSL s) { EVP_PKEY key; if (!SSL_get_peer_tmp_key(s, &key)) return 1; BIO_puts(out, "Server Temp Key: "); switch (EVP_PKEY_get_id(key)) { case EVP_PKEY_RSA: BIO_printf(out, "RSA, %d bits\n", EVP_PKEY_get_bits(key)); break; case EVP_PKEY_DH: BIO_printf(out, "DH, %d bits\n", EVP_PKEY_get_bits(key)); break; #ifndef OPENSSL_NO_EC case EVP_PKEY_EC: { char name[80]; size_t name_len; if (!EVP_PKEY_get_utf8_string_param(key, OSSL_PKEY_PARAM_GROUP_NAME, name, sizeof(name), &name_len)) strcpy(name, "?"); BIO_printf(out, "ECDH, %s, %d bits\n", name, EVP_PKEY_get_bits(key)); } break; #endif default: BIO_printf(out, "%s, %d bits\n", OBJ_nid2sn(EVP_PKEY_get_id(key)), EVP_PKEY_get_bits(key)); } EVP_PKEY_free(key); return 1; } long bio_dump_callback(BIO bio, int cmd, const char argp, size_t len, int argi, long argl, int ret, size_t processed) { BIO out; BIO_MMSG_CB_ARGS mmsgargs; size_t i; out = (BIO )BIO_get_callback_arg(bio); if (out == NULL) return ret; switch (cmd) { case (BIO_CB_READ \| BIO_CB_RETURN): if (ret > 0 && processed != NULL) { BIO_printf(out, "read from %p [%p] (%zu bytes => %zu (0x%zX))\n", (void )bio, (void )argp, len, processed, processed); BIO_dump(out, argp, (int)processed); } else { BIO_printf(out, "read from %p [%p] (%zu bytes => %d)\n", (void )bio, (void )argp, len, ret); } break; case (BIO_CB_WRITE \| BIO_CB_RETURN): if (ret > 0 && processed != NULL) { BIO_printf(out, "write to %p [%p] (%zu bytes => %zu (0x%zX))\n", (void )bio, (void )argp, len, processed, processed); BIO_dump(out, argp, (int)processed); } else { BIO_printf(out, "write to %p [%p] (%zu bytes => %d)\n", (void )bio, (void )argp, len, ret); } break; case (BIO_CB_RECVMMSG \| BIO_CB_RETURN): mmsgargs = (BIO_MMSG_CB_ARGS )argp; if (ret > 0) { for (i = 0; i < (mmsgargs->msgs_processed); i++) { BIO_MSG msg = (BIO_MSG )((char )mmsgargs->msg + (i * mmsgargs->stride)); BIO_printf(out, "read from %p [%p] (%zu bytes => %zu (0x%zX))\n", (void )bio, (void )msg->data, msg->data_len, msg->data_len, msg->data_len); BIO_dump(out, msg->data, msg->data_len); } } else if (mmsgargs->num_msg > 0) { BIO_MSG msg = mmsgargs->msg; BIO_printf(out, "read from %p [%p] (%zu bytes => %d)\n", (void )bio, (void )msg->data, msg->data_len, ret); } break; case (BIO_CB_SENDMMSG \| BIO_CB_RETURN): mmsgargs = (BIO_MMSG_CB_ARGS )argp; if (ret > 0) { for (i = 0; i < (mmsgargs->msgs_processed); i++) { BIO_MSG msg = (BIO_MSG )((char )mmsgargs->msg + (i * mmsgargs->stride)); BIO_printf(out, "write to %p [%p] (%zu bytes => %zu (0x%zX))\n", (void )bio, (void )msg->data, msg->data_len, msg->data_len, msg->data_len); BIO_dump(out, msg->data, msg->data_len); } } else if (mmsgargs->num_msg > 0) { BIO_MSG msg = mmsgargs->msg; BIO_printf(out, "write to %p [%p] (%zu bytes => %d)\n", (void )bio, (void )msg->data, msg->data_len, ret); } break; default: / do nothing / break; } return ret; } void apps_ssl_info_callback(const SSL s, int where, int ret) { const char str; int w; w = where & ~SSL_ST_MASK; if (w & SSL_ST_CONNECT) str = "SSL_connect"; else if (w & SSL_ST_ACCEPT) str = "SSL_accept"; else str = "undefined"; if (where & SSL_CB_LOOP) { BIO_printf(bio_err, "%s:%s\n", str, SSL_state_string_long(s)); } else if (where & SSL_CB_ALERT) { str = (where & SSL_CB_READ) ? "read" : "write"; BIO_printf(bio_err, "SSL3 alert %s:%s:%s\n", str, SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret)); } else if (where & SSL_CB_EXIT) { if (ret == 0) BIO_printf(bio_err, "%s:failed in %s\n", str, SSL_state_string_long(s)); else if (ret < 0) BIO_printf(bio_err, "%s:error in %s\n", str, SSL_state_string_long(s)); } } static STRINT_PAIR ssl_versions[] = { {"SSL 3.0", SSL3_VERSION}, {"TLS 1.0", TLS1_VERSION}, {"TLS 1.1", TLS1_1_VERSION}, {"TLS 1.2", TLS1_2_VERSION}, {"TLS 1.3", TLS1_3_VERSION}, {"DTLS 1.0", DTLS1_VERSION}, {"DTLS 1.0 (bad)", DTLS1_BAD_VER}, {NULL} }; static STRINT_PAIR alert_types[] = { {" close_notify", 0}, {" end_of_early_data", 1}, {" unexpected_message", 10}, {" bad_record_mac", 20}, {" decryption_failed", 21}, {" record_overflow", 22}, {" decompression_failure", 30}, {" handshake_failure", 40}, {" bad_certificate", 42}, {" unsupported_certificate", 43}, {" certificate_revoked", 44}, {" certificate_expired", 45}, {" certificate_unknown", 46}, {" illegal_parameter", 47}, {" unknown_ca", 48}, {" access_denied", 49}, {" decode_error", 50}, {" decrypt_error", 51}, {" export_restriction", 60}, {" protocol_version", 70}, {" insufficient_security", 71}, {" internal_error", 80}, {" inappropriate_fallback", 86}, {" user_canceled", 90}, {" no_renegotiation", 100}, {" missing_extension", 109}, {" unsupported_extension", 110}, {" certificate_unobtainable", 111}, {" unrecognized_name", 112}, {" bad_certificate_status_response", 113}, {" bad_certificate_hash_value", 114}, {" unknown_psk_identity", 115}, {" certificate_required", 116}, {NULL} }; static STRINT_PAIR handshakes[] = { {", HelloRequest", SSL3_MT_HELLO_REQUEST}, {", ClientHello", SSL3_MT_CLIENT_HELLO}, {", ServerHello", SSL3_MT_SERVER_HELLO}, {", HelloVerifyRequest", DTLS1_MT_HELLO_VERIFY_REQUEST}, {", NewSessionTicket", SSL3_MT_NEWSESSION_TICKET}, {", EndOfEarlyData", SSL3_MT_END_OF_EARLY_DATA}, {", EncryptedExtensions", SSL3_MT_ENCRYPTED_EXTENSIONS}, {", Certificate", SSL3_MT_CERTIFICATE}, {", ServerKeyExchange", SSL3_MT_SERVER_KEY_EXCHANGE}, {", CertificateRequest", SSL3_MT_CERTIFICATE_REQUEST}, {", ServerHelloDone", SSL3_MT_SERVER_DONE}, {", CertificateVerify", SSL3_MT_CERTIFICATE_VERIFY}, {", ClientKeyExchange", SSL3_MT_CLIENT_KEY_EXCHANGE}, {", Finished", SSL3_MT_FINISHED}, {", CertificateUrl", SSL3_MT_CERTIFICATE_URL}, {", CertificateStatus", SSL3_MT_CERTIFICATE_STATUS}, {", SupplementalData", SSL3_MT_SUPPLEMENTAL_DATA}, {", KeyUpdate", SSL3_MT_KEY_UPDATE}, {", CompressedCertificate", SSL3_MT_COMPRESSED_CERTIFICATE}, #ifndef OPENSSL_NO_NEXTPROTONEG {", NextProto", SSL3_MT_NEXT_PROTO}, #endif {", MessageHash", SSL3_MT_MESSAGE_HASH}, {NULL} }; void msg_cb(int write_p, int version, int content_type, const void buf, size_t len, SSL ssl, void arg) { BIO bio = arg; const char str_write_p = write_p ? ">>>" : "<<<"; char tmpbuf[128]; const char str_version, str_content_type = "", str_details1 = "", str_details2 = ""; const unsigned char* bp = buf; if (version == SSL3_VERSION \|\| version == TLS1_VERSION \|\| version == TLS1_1_VERSION \|\| version == TLS1_2_VERSION \|\| version == TLS1_3_VERSION \|\| version == DTLS1_VERSION \|\| version == DTLS1_BAD_VER) { str_version = lookup(version, ssl_versions, "???"); switch (content_type) { case SSL3_RT_CHANGE_CIPHER_SPEC: /* type 20 / str_content_type = ", ChangeCipherSpec"; break; case SSL3_RT_ALERT: / type 21 / str_content_type = ", Alert"; str_details1 = ", ???"; if (len == 2) { switch (bp[0]) { case 1: str_details1 = ", warning"; break; case 2: str_details1 = ", fatal"; break; } str_details2 = lookup((int)bp[1], alert_types, " ???"); } break; case SSL3_RT_HANDSHAKE: / type 22 / str_content_type = ", Handshake"; str_details1 = "???"; if (len > 0) str_details1 = lookup((int)bp[0], handshakes, "???"); break; case SSL3_RT_APPLICATION_DATA: / type 23 / str_content_type = ", ApplicationData"; break; case SSL3_RT_HEADER: / type 256 / str_content_type = ", RecordHeader"; break; case SSL3_RT_INNER_CONTENT_TYPE: / type 257 / str_content_type = ", InnerContent"; break; default: BIO_snprintf(tmpbuf, sizeof(tmpbuf)-1, ", Unknown (content_type=%d)", content_type); str_content_type = tmpbuf; } } else { BIO_snprintf(tmpbuf, sizeof(tmpbuf)-1, "Not TLS data or unknown version (version=%d, content_type=%d)", version, content_type); str_version = tmpbuf; } BIO_printf(bio, "%s %s%s [length %04lx]%s%s\n", str_write_p, str_version, str_content_type, (unsigned long)len, str_details1, str_details2); if (len > 0) { size_t num, i; BIO_printf(bio, " "); num = len; for (i = 0; i < num; i++) { if (i % 16 == 0 && i > 0) BIO_printf(bio, "\n "); BIO_printf(bio, " %02x", ((const unsigned char )buf)[i]); } if (i < len) BIO_printf(bio, " ..."); BIO_printf(bio, "\n"); } (void)BIO_flush(bio); } static STRINT_PAIR tlsext_types[] = { {"server name", TLSEXT_TYPE_server_name}, {"max fragment length", TLSEXT_TYPE_max_fragment_length}, {"client certificate URL", TLSEXT_TYPE_client_certificate_url}, {"trusted CA keys", TLSEXT_TYPE_trusted_ca_keys}, {"truncated HMAC", TLSEXT_TYPE_truncated_hmac}, {"status request", TLSEXT_TYPE_status_request}, {"user mapping", TLSEXT_TYPE_user_mapping}, {"client authz", TLSEXT_TYPE_client_authz}, {"server authz", TLSEXT_TYPE_server_authz}, {"cert type", TLSEXT_TYPE_cert_type}, {"supported_groups", TLSEXT_TYPE_supported_groups}, {"EC point formats", TLSEXT_TYPE_ec_point_formats}, {"SRP", TLSEXT_TYPE_srp}, {"signature algorithms", TLSEXT_TYPE_signature_algorithms}, {"use SRTP", TLSEXT_TYPE_use_srtp}, {"session ticket", TLSEXT_TYPE_session_ticket}, {"renegotiation info", TLSEXT_TYPE_renegotiate}, {"signed certificate timestamps", TLSEXT_TYPE_signed_certificate_timestamp}, {"client cert type", TLSEXT_TYPE_client_cert_type}, {"server cert type", TLSEXT_TYPE_server_cert_type}, {"TLS padding", TLSEXT_TYPE_padding}, #ifdef TLSEXT_TYPE_next_proto_neg {"next protocol", TLSEXT_TYPE_next_proto_neg}, #endif #ifdef TLSEXT_TYPE_encrypt_then_mac {"encrypt-then-mac", TLSEXT_TYPE_encrypt_then_mac}, #endif #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation {"application layer protocol negotiation", TLSEXT_TYPE_application_layer_protocol_negotiation}, #endif #ifdef TLSEXT_TYPE_extended_master_secret {"extended master secret", TLSEXT_TYPE_extended_master_secret}, #endif {"compress certificate", TLSEXT_TYPE_compress_certificate}, {"key share", TLSEXT_TYPE_key_share}, {"supported versions", TLSEXT_TYPE_supported_versions}, {"psk", TLSEXT_TYPE_psk}, {"psk kex modes", TLSEXT_TYPE_psk_kex_modes}, {"certificate authorities", TLSEXT_TYPE_certificate_authorities}, {"post handshake auth", TLSEXT_TYPE_post_handshake_auth}, {NULL} }; /* from rfc8446 4.2.3. + gost (https://tools.ietf.org/id/draft-smyshlyaev-tls12-gost-suites-04.html) / static STRINT_PAIR signature_tls13_scheme_list[] = { {"rsa_pkcs1_sha1", 0x0201 / TLSEXT_SIGALG_rsa_pkcs1_sha1 /}, {"ecdsa_sha1", 0x0203 / TLSEXT_SIGALG_ecdsa_sha1 /}, / {"rsa_pkcs1_sha224", 0x0301 TLSEXT_SIGALG_rsa_pkcs1_sha224}, not in rfc8446 / / {"ecdsa_sha224", 0x0303 TLSEXT_SIGALG_ecdsa_sha224} not in rfc8446 / {"rsa_pkcs1_sha256", 0x0401 / TLSEXT_SIGALG_rsa_pkcs1_sha256 /}, {"ecdsa_secp256r1_sha256", 0x0403 / TLSEXT_SIGALG_ecdsa_secp256r1_sha256 /}, {"rsa_pkcs1_sha384", 0x0501 / TLSEXT_SIGALG_rsa_pkcs1_sha384 /}, {"ecdsa_secp384r1_sha384", 0x0503 / TLSEXT_SIGALG_ecdsa_secp384r1_sha384 /}, {"rsa_pkcs1_sha512", 0x0601 / TLSEXT_SIGALG_rsa_pkcs1_sha512 /}, {"ecdsa_secp521r1_sha512", 0x0603 / TLSEXT_SIGALG_ecdsa_secp521r1_sha512 /}, {"rsa_pss_rsae_sha256", 0x0804 / TLSEXT_SIGALG_rsa_pss_rsae_sha256 /}, {"rsa_pss_rsae_sha384", 0x0805 / TLSEXT_SIGALG_rsa_pss_rsae_sha384 /}, {"rsa_pss_rsae_sha512", 0x0806 / TLSEXT_SIGALG_rsa_pss_rsae_sha512 /}, {"ed25519", 0x0807 / TLSEXT_SIGALG_ed25519 /}, {"ed448", 0x0808 / TLSEXT_SIGALG_ed448 /}, {"rsa_pss_pss_sha256", 0x0809 / TLSEXT_SIGALG_rsa_pss_pss_sha256 /}, {"rsa_pss_pss_sha384", 0x080a / TLSEXT_SIGALG_rsa_pss_pss_sha384 /}, {"rsa_pss_pss_sha512", 0x080b / TLSEXT_SIGALG_rsa_pss_pss_sha512 /}, {"gostr34102001", 0xeded / TLSEXT_SIGALG_gostr34102001_gostr3411 /}, {"gostr34102012_256", 0xeeee / TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256 /}, {"gostr34102012_512", 0xefef / TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512 /}, {NULL} }; / from rfc5246 7.4.1.4.1. / static STRINT_PAIR signature_tls12_alg_list[] = { {"anonymous", TLSEXT_signature_anonymous / 0 /}, {"RSA", TLSEXT_signature_rsa / 1 /}, {"DSA", TLSEXT_signature_dsa / 2 /}, {"ECDSA", TLSEXT_signature_ecdsa / 3 /}, {NULL} }; / from rfc5246 7.4.1.4.1. / static STRINT_PAIR signature_tls12_hash_list[] = { {"none", TLSEXT_hash_none / 0 /}, {"MD5", TLSEXT_hash_md5 / 1 /}, {"SHA1", TLSEXT_hash_sha1 / 2 /}, {"SHA224", TLSEXT_hash_sha224 / 3 /}, {"SHA256", TLSEXT_hash_sha256 / 4 /}, {"SHA384", TLSEXT_hash_sha384 / 5 /}, {"SHA512", TLSEXT_hash_sha512 / 6 /}, {NULL} }; void tlsext_cb(SSL s, int client_server, int type, const unsigned char data, int len, void arg) { BIO bio = arg; const char extname = lookup(type, tlsext_types, "unknown"); BIO_printf(bio, "TLS %s extension \"%s\" (id=%d), len=%d\n", client_server ? "server" : "client", extname, type, len); BIO_dump(bio, (const char )data, len); (void)BIO_flush(bio); } #ifndef OPENSSL_NO_SOCK int generate_stateless_cookie_callback(SSL ssl, unsigned char cookie, size_t cookie_len) { unsigned char buffer = NULL; size_t length = 0; unsigned short port; BIO_ADDR lpeer = NULL, peer = NULL; int res = 0; / Initialize a random secret / if (!cookie_initialized) { if (RAND_bytes(cookie_secret, COOKIE_SECRET_LENGTH) <= 0) { BIO_printf(bio_err, "error setting random cookie secret\n"); return 0; } cookie_initialized = 1; } if (SSL_is_dtls(ssl)) { lpeer = peer = BIO_ADDR_new(); if (peer == NULL) { BIO_printf(bio_err, "memory full\n"); return 0; } / Read peer information / (void)BIO_dgram_get_peer(SSL_get_rbio(ssl), peer); } else { peer = ourpeer; } / Create buffer with peer's address and port / if (!BIO_ADDR_rawaddress(peer, NULL, &length)) { BIO_printf(bio_err, "Failed getting peer address\n"); BIO_ADDR_free(lpeer); return 0; } OPENSSL_assert(length != 0); port = BIO_ADDR_rawport(peer); length += sizeof(port); buffer = app_malloc(length, "cookie generate buffer"); memcpy(buffer, &port, sizeof(port)); BIO_ADDR_rawaddress(peer, buffer + sizeof(port), NULL); if (EVP_Q_mac(NULL, "HMAC", NULL, "SHA1", NULL, cookie_secret, COOKIE_SECRET_LENGTH, buffer, length, cookie, DTLS1_COOKIE_LENGTH, cookie_len) == NULL) { BIO_printf(bio_err, "Error calculating HMAC-SHA1 of buffer with secret\n"); goto end; } res = 1; end: OPENSSL_free(buffer); BIO_ADDR_free(lpeer); return res; } int verify_stateless_cookie_callback(SSL ssl, const unsigned char cookie, size_t cookie_len) { unsigned char result[EVP_MAX_MD_SIZE]; size_t resultlength; / Note: we check cookie_initialized because if it's not, * it cannot be valid / if (cookie_initialized && generate_stateless_cookie_callback(ssl, result, &resultlength) && cookie_len == resultlength && memcmp(result, cookie, resultlength) == 0) return 1; return 0; } int generate_cookie_callback(SSL ssl, unsigned char cookie, unsigned int cookie_len) { size_t temp = 0; int res = generate_stateless_cookie_callback(ssl, cookie, &temp); if (res != 0) cookie_len = (unsigned int)temp; return res; } int verify_cookie_callback(SSL ssl, const unsigned char cookie, unsigned int cookie_len) { return verify_stateless_cookie_callback(ssl, cookie, cookie_len); } #endif / * Example of extended certificate handling. Where the standard support of * one certificate per algorithm is not sufficient an application can decide * which certificate(s) to use at runtime based on whatever criteria it deems * appropriate. / / Linked list of certificates, keys and chains / struct ssl_excert_st { int certform; const char certfile; int keyform; const char keyfile; const char chainfile; X509 cert; EVP_PKEY key; STACK_OF(X509) chain; int build_chain; struct ssl_excert_st next, prev; }; static STRINT_PAIR chain_flags[] = { {"Overall Validity", CERT_PKEY_VALID}, {"Sign with EE key", CERT_PKEY_SIGN}, {"EE signature", CERT_PKEY_EE_SIGNATURE}, {"CA signature", CERT_PKEY_CA_SIGNATURE}, {"EE key parameters", CERT_PKEY_EE_PARAM}, {"CA key parameters", CERT_PKEY_CA_PARAM}, {"Explicitly sign with EE key", CERT_PKEY_EXPLICIT_SIGN}, {"Issuer Name", CERT_PKEY_ISSUER_NAME}, {"Certificate Type", CERT_PKEY_CERT_TYPE}, {NULL} }; static void print_chain_flags(SSL s, int flags) { STRINT_PAIR pp; for (pp = chain_flags; pp->name; ++pp) BIO_printf(bio_err, "\t%s: %s\n", pp->name, (flags & pp->retval) ? "OK" : "NOT OK"); BIO_printf(bio_err, "\tSuite B: "); if (SSL_set_cert_flags(s, 0) & SSL_CERT_FLAG_SUITEB_128_LOS) BIO_puts(bio_err, flags & CERT_PKEY_SUITEB ? "OK\n" : "NOT OK\n"); else BIO_printf(bio_err, "not tested\n"); } / * Very basic selection callback: just use any certificate chain reported as * valid. More sophisticated could prioritise according to local policy. / static int set_cert_cb(SSL ssl, void arg) { int i, rv; SSL_EXCERT exc = arg; #ifdef CERT_CB_TEST_RETRY static int retry_cnt; if (retry_cnt < 5) { retry_cnt++; BIO_printf(bio_err, "Certificate callback retry test: count %d\n", retry_cnt); return -1; } #endif SSL_certs_clear(ssl); if (exc == NULL) return 1; /* * Go to end of list and traverse backwards since we prepend newer * entries this retains the original order. / while (exc->next != NULL) exc = exc->next; i = 0; while (exc != NULL) { i++; rv = SSL_check_chain(ssl, exc->cert, exc->key, exc->chain); BIO_printf(bio_err, "Checking cert chain %d:\nSubject: ", i); X509_NAME_print_ex(bio_err, X509_get_subject_name(exc->cert), 0, get_nameopt()); BIO_puts(bio_err, "\n"); print_chain_flags(ssl, rv); if (rv & CERT_PKEY_VALID) { if (!SSL_use_certificate(ssl, exc->cert) \|\| !SSL_use_PrivateKey(ssl, exc->key)) { return 0; } / * NB: we wouldn't normally do this as it is not efficient * building chains on each connection better to cache the chain * in advance. / if (exc->build_chain) { if (!SSL_build_cert_chain(ssl, 0)) return 0; } else if (exc->chain != NULL) { if (!SSL_set1_chain(ssl, exc->chain)) return 0; } } exc = exc->prev; } return 1; } void ssl_ctx_set_excert(SSL_CTX ctx, SSL_EXCERT exc) { SSL_CTX_set_cert_cb(ctx, set_cert_cb, exc); } static int ssl_excert_prepend(SSL_EXCERT pexc) { SSL_EXCERT exc = app_malloc(sizeof(exc), "prepend cert"); memset(exc, 0, sizeof(exc)); exc->next = pexc; pexc = exc; if (exc->next) { exc->certform = exc->next->certform; exc->keyform = exc->next->keyform; exc->next->prev = exc; } else { exc->certform = FORMAT_PEM; exc->keyform = FORMAT_PEM; } return 1; } void ssl_excert_free(SSL_EXCERT exc) { SSL_EXCERT curr; if (exc == NULL) return; while (exc) { X509_free(exc->cert); EVP_PKEY_free(exc->key); OSSL_STACK_OF_X509_free(exc->chain); curr = exc; exc = exc->next; OPENSSL_free(curr); } } int load_excert(SSL_EXCERT *pexc) { SSL_EXCERT exc = pexc; if (exc == NULL) return 1; / If nothing in list, free and set to NULL / if (exc->certfile == NULL && exc->next == NULL) { ssl_excert_free(exc); pexc = NULL; return 1; } for (; exc; exc = exc->next) { if (exc->certfile == NULL) { BIO_printf(bio_err, "Missing filename\n"); return 0; } exc->cert = load_cert(exc->certfile, exc->certform, "Server Certificate"); if (exc->cert == NULL) return 0; if (exc->keyfile != NULL) { exc->key = load_key(exc->keyfile, exc->keyform, 0, NULL, NULL, "server key"); } else { exc->key = load_key(exc->certfile, exc->certform, 0, NULL, NULL, "server key"); } if (exc->key == NULL) return 0; if (exc->chainfile != NULL) { if (!load_certs(exc->chainfile, 0, &exc->chain, NULL, "server chain")) return 0; } } return 1; } enum range { OPT_X_ENUM }; int args_excert(int opt, SSL_EXCERT *pexc) { SSL_EXCERT exc = pexc; assert(opt > OPT_X__FIRST); assert(opt < OPT_X__LAST); if (exc == NULL) { if (!ssl_excert_prepend(&exc)) { BIO_printf(bio_err, " %s: Error initialising xcert\n", opt_getprog()); goto err; } pexc = exc; } switch ((enum range)opt) { case OPT_X__FIRST: case OPT_X__LAST: return 0; case OPT_X_CERT: if (exc->certfile != NULL && !ssl_excert_prepend(&exc)) { BIO_printf(bio_err, "%s: Error adding xcert\n", opt_getprog()); goto err; } pexc = exc; exc->certfile = opt_arg(); break; case OPT_X_KEY: if (exc->keyfile != NULL) { BIO_printf(bio_err, "%s: Key already specified\n", opt_getprog()); goto err; } exc->keyfile = opt_arg(); break; case OPT_X_CHAIN: if (exc->chainfile != NULL) { BIO_printf(bio_err, "%s: Chain already specified\n", opt_getprog()); goto err; } exc->chainfile = opt_arg(); break; case OPT_X_CHAIN_BUILD: exc->build_chain = 1; break; case OPT_X_CERTFORM: if (!opt_format(opt_arg(), OPT_FMT_ANY, &exc->certform)) return 0; break; case OPT_X_KEYFORM: if (!opt_format(opt_arg(), OPT_FMT_ANY, &exc->keyform)) return 0; break; } return 1; err: ERR_print_errors(bio_err); ssl_excert_free(exc); pexc = NULL; return 0; } static void print_raw_cipherlist(SSL s) { const unsigned char rlist; static const unsigned char scsv_id[] = { 0, 0xFF }; size_t i, rlistlen, num; if (!SSL_is_server(s)) return; num = SSL_get0_raw_cipherlist(s, NULL); OPENSSL_assert(num == 2); rlistlen = SSL_get0_raw_cipherlist(s, &rlist); BIO_puts(bio_err, "Client cipher list: "); for (i = 0; i < rlistlen; i += num, rlist += num) { const SSL_CIPHER c = SSL_CIPHER_find(s, rlist); if (i) BIO_puts(bio_err, ":"); if (c != NULL) { BIO_puts(bio_err, SSL_CIPHER_get_name(c)); } else if (memcmp(rlist, scsv_id, num) == 0) { BIO_puts(bio_err, "SCSV"); } else { size_t j; BIO_puts(bio_err, "0x"); for (j = 0; j < num; j++) BIO_printf(bio_err, "%02X", rlist[j]); } } BIO_puts(bio_err, "\n"); } / * Hex encoder for TLSA RRdata, not ':' delimited. / static char hexencode(const unsigned char data, size_t len) { static const char hex = "0123456789abcdef"; char out; char cp; size_t outlen = 2 * len + 1; int ilen = (int) outlen; if (outlen < len \|\| ilen < 0 \|\| outlen != (size_t)ilen) { BIO_printf(bio_err, "%s: %zu-byte buffer too large to hexencode\n", opt_getprog(), len); exit(1); } cp = out = app_malloc(ilen, "TLSA hex data buffer"); while (len-- > 0) { cp++ = hex[(data >> 4) & 0x0f]; cp++ = hex[data++ & 0x0f]; } cp = '\0'; return out; } void print_verify_detail(SSL s, BIO bio) { int mdpth; EVP_PKEY mspki = NULL; long verify_err = SSL_get_verify_result(s); if (verify_err == X509_V_OK) { const char peername = SSL_get0_peername(s); BIO_printf(bio, "Verification: OK\n"); if (peername != NULL) BIO_printf(bio, "Verified peername: %s\n", peername); } else { const char reason = X509_verify_cert_error_string(verify_err); BIO_printf(bio, "Verification error: %s\n", reason); } if ((mdpth = SSL_get0_dane_authority(s, NULL, &mspki)) >= 0) { uint8_t usage, selector, mtype; const unsigned char data = NULL; size_t dlen = 0; char hexdata; mdpth = SSL_get0_dane_tlsa(s, &usage, &selector, &mtype, &data, &dlen); /* * The TLSA data field can be quite long when it is a certificate, * public key or even a SHA2-512 digest. Because the initial octets of * ASN.1 certificates and public keys contain mostly boilerplate OIDs * and lengths, we show the last 12 bytes of the data instead, as these * are more likely to distinguish distinct TLSA records. / #define TLSA_TAIL_SIZE 12 if (dlen > TLSA_TAIL_SIZE) hexdata = hexencode(data + dlen - TLSA_TAIL_SIZE, TLSA_TAIL_SIZE); else hexdata = hexencode(data, dlen); BIO_printf(bio, "DANE TLSA %d %d %d %s%s ", usage, selector, mtype, (dlen > TLSA_TAIL_SIZE) ? "..." : "", hexdata); if (SSL_get0_peer_rpk(s) == NULL) BIO_printf(bio, "%s certificate at depth %d\n", (mspki != NULL) ? "signed the peer" : mdpth ? "matched the TA" : "matched the EE", mdpth); else BIO_printf(bio, "matched the peer raw public key\n"); OPENSSL_free(hexdata); } } void print_ssl_summary(SSL s) { const SSL_CIPHER c; X509 peer = SSL_get0_peer_certificate(s); EVP_PKEY peer_rpk = SSL_get0_peer_rpk(s); int nid; BIO_printf(bio_err, "Protocol version: %s\n", SSL_get_version(s)); print_raw_cipherlist(s); c = SSL_get_current_cipher(s); BIO_printf(bio_err, "Ciphersuite: %s\n", SSL_CIPHER_get_name(c)); do_print_sigalgs(bio_err, s, 0); if (peer != NULL) { BIO_puts(bio_err, "Peer certificate: "); X509_NAME_print_ex(bio_err, X509_get_subject_name(peer), 0, get_nameopt()); BIO_puts(bio_err, "\n"); if (SSL_get_peer_signature_nid(s, &nid)) BIO_printf(bio_err, "Hash used: %s\n", OBJ_nid2sn(nid)); if (SSL_get_peer_signature_type_nid(s, &nid)) BIO_printf(bio_err, "Signature type: %s\n", get_sigtype(nid)); print_verify_detail(s, bio_err); } else if (peer_rpk != NULL) { BIO_printf(bio_err, "Peer used raw public key\n"); if (SSL_get_peer_signature_type_nid(s, &nid)) BIO_printf(bio_err, "Signature type: %s\n", get_sigtype(nid)); print_verify_detail(s, bio_err); } else { BIO_puts(bio_err, "No peer certificate or raw public key\n"); } #ifndef OPENSSL_NO_EC ssl_print_point_formats(bio_err, s); if (SSL_is_server(s)) ssl_print_groups(bio_err, s, 1); else ssl_print_tmp_key(bio_err, s); #else if (!SSL_is_server(s)) ssl_print_tmp_key(bio_err, s); #endif } int config_ctx(SSL_CONF_CTX cctx, STACK_OF(OPENSSL_STRING) str, SSL_CTX ctx) { int i; SSL_CONF_CTX_set_ssl_ctx(cctx, ctx); for (i = 0; i < sk_OPENSSL_STRING_num(str); i += 2) { const char flag = sk_OPENSSL_STRING_value(str, i); const char arg = sk_OPENSSL_STRING_value(str, i + 1); if (SSL_CONF_cmd(cctx, flag, arg) <= 0) { BIO_printf(bio_err, "Call to SSL_CONF_cmd(%s, %s) failed\n", flag, arg == NULL ? "<NULL>" : arg); ERR_print_errors(bio_err); return 0; } } if (!SSL_CONF_CTX_finish(cctx)) { BIO_puts(bio_err, "Error finishing context\n"); ERR_print_errors(bio_err); return 0; } return 1; } static int add_crls_store(X509_STORE st, STACK_OF(X509_CRL) crls) { X509_CRL crl; int i, ret = 1; for (i = 0; i < sk_X509_CRL_num(crls); i++) { crl = sk_X509_CRL_value(crls, i); if (!X509_STORE_add_crl(st, crl)) ret = 0; } return ret; } int ssl_ctx_add_crls(SSL_CTX ctx, STACK_OF(X509_CRL) crls, int crl_download) { X509_STORE st; st = SSL_CTX_get_cert_store(ctx); add_crls_store(st, crls); if (crl_download) store_setup_crl_download(st); return 1; } int ssl_load_stores(SSL_CTX ctx, const char vfyCApath, const char vfyCAfile, const char vfyCAstore, const char chCApath, const char chCAfile, const char chCAstore, STACK_OF(X509_CRL) crls, int crl_download) { X509_STORE vfy = NULL, ch = NULL; int rv = 0; if (vfyCApath != NULL \|\| vfyCAfile != NULL \|\| vfyCAstore != NULL) { vfy = X509_STORE_new(); if (vfy == NULL) goto err; if (vfyCAfile != NULL && !X509_STORE_load_file(vfy, vfyCAfile)) goto err; if (vfyCApath != NULL && !X509_STORE_load_path(vfy, vfyCApath)) goto err; if (vfyCAstore != NULL && !X509_STORE_load_store(vfy, vfyCAstore)) goto err; add_crls_store(vfy, crls); SSL_CTX_set1_verify_cert_store(ctx, vfy); if (crl_download) store_setup_crl_download(vfy); } if (chCApath != NULL \|\| chCAfile != NULL \|\| chCAstore != NULL) { ch = X509_STORE_new(); if (ch == NULL) goto err; if (chCAfile != NULL && !X509_STORE_load_file(ch, chCAfile)) goto err; if (chCApath != NULL && !X509_STORE_load_path(ch, chCApath)) goto err; if (chCAstore != NULL && !X509_STORE_load_store(ch, chCAstore)) goto err; SSL_CTX_set1_chain_cert_store(ctx, ch); } rv = 1; err: X509_STORE_free(vfy); X509_STORE_free(ch); return rv; } /* Verbose print out of security callback / typedef struct { BIO out; int verbose; int (old_cb) (const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex); } security_debug_ex; static STRINT_PAIR callback_types[] = { {"Supported Ciphersuite", SSL_SECOP_CIPHER_SUPPORTED}, {"Shared Ciphersuite", SSL_SECOP_CIPHER_SHARED}, {"Check Ciphersuite", SSL_SECOP_CIPHER_CHECK}, #ifndef OPENSSL_NO_DH {"Temp DH key bits", SSL_SECOP_TMP_DH}, #endif {"Supported Curve", SSL_SECOP_CURVE_SUPPORTED}, {"Shared Curve", SSL_SECOP_CURVE_SHARED}, {"Check Curve", SSL_SECOP_CURVE_CHECK}, {"Supported Signature Algorithm", SSL_SECOP_SIGALG_SUPPORTED}, {"Shared Signature Algorithm", SSL_SECOP_SIGALG_SHARED}, {"Check Signature Algorithm", SSL_SECOP_SIGALG_CHECK}, {"Signature Algorithm mask", SSL_SECOP_SIGALG_MASK}, {"Certificate chain EE key", SSL_SECOP_EE_KEY}, {"Certificate chain CA key", SSL_SECOP_CA_KEY}, {"Peer Chain EE key", SSL_SECOP_PEER_EE_KEY}, {"Peer Chain CA key", SSL_SECOP_PEER_CA_KEY}, {"Certificate chain CA digest", SSL_SECOP_CA_MD}, {"Peer chain CA digest", SSL_SECOP_PEER_CA_MD}, {"SSL compression", SSL_SECOP_COMPRESSION}, {"Session ticket", SSL_SECOP_TICKET}, {NULL} }; static int security_callback_debug(const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex) { security_debug_ex sdb = ex; int rv, show_bits = 1, cert_md = 0; const char nm; int show_nm; rv = sdb->old_cb(s, ctx, op, bits, nid, other, ex); if (rv == 1 && sdb->verbose < 2) return 1; BIO_puts(sdb->out, "Security callback: "); nm = lookup(op, callback_types, NULL); show_nm = nm != NULL; switch (op) { case SSL_SECOP_TICKET: case SSL_SECOP_COMPRESSION: show_bits = 0; show_nm = 0; break; case SSL_SECOP_VERSION: BIO_printf(sdb->out, "Version=%s", lookup(nid, ssl_versions, "???")); show_bits = 0; show_nm = 0; break; case SSL_SECOP_CA_MD: case SSL_SECOP_PEER_CA_MD: cert_md = 1; break; case SSL_SECOP_SIGALG_SUPPORTED: case SSL_SECOP_SIGALG_SHARED: case SSL_SECOP_SIGALG_CHECK: case SSL_SECOP_SIGALG_MASK: show_nm = 0; break; } if (show_nm) BIO_printf(sdb->out, "%s=", nm); switch (op & SSL_SECOP_OTHER_TYPE) { case SSL_SECOP_OTHER_CIPHER: BIO_puts(sdb->out, SSL_CIPHER_get_name(other)); break; #ifndef OPENSSL_NO_EC case SSL_SECOP_OTHER_CURVE: { const char cname; cname = EC_curve_nid2nist(nid); if (cname == NULL) cname = OBJ_nid2sn(nid); BIO_puts(sdb->out, cname); } break; #endif case SSL_SECOP_OTHER_CERT: { if (cert_md) { int sig_nid = X509_get_signature_nid(other); BIO_puts(sdb->out, OBJ_nid2sn(sig_nid)); } else { EVP_PKEY pkey = X509_get0_pubkey(other); if (pkey == NULL) { BIO_printf(sdb->out, "Public key missing"); } else { const char algname = ""; EVP_PKEY_asn1_get0_info(NULL, NULL, NULL, NULL, &algname, EVP_PKEY_get0_asn1(pkey)); BIO_printf(sdb->out, "%s, bits=%d", algname, EVP_PKEY_get_bits(pkey)); } } break; } case SSL_SECOP_OTHER_SIGALG: { const unsigned char salg = other; const char sname = NULL; int raw_sig_code = (salg[0] << 8) + salg[1]; /* always big endian (msb, lsb) / / raw_sig_code: signature_scheme from tls1.3, or signature_and_hash from tls1.2 / if (nm != NULL) BIO_printf(sdb->out, "%s", nm); else BIO_printf(sdb->out, "s_cb.c:security_callback_debug op=0x%x", op); sname = lookup(raw_sig_code, signature_tls13_scheme_list, NULL); if (sname != NULL) { BIO_printf(sdb->out, " scheme=%s", sname); } else { int alg_code = salg[1]; int hash_code = salg[0]; const char alg_str = lookup(alg_code, signature_tls12_alg_list, NULL); const char hash_str = lookup(hash_code, signature_tls12_hash_list, NULL); if (alg_str != NULL && hash_str != NULL) BIO_printf(sdb->out, " digest=%s, algorithm=%s", hash_str, alg_str); else BIO_printf(sdb->out, " scheme=unknown(0x%04x)", raw_sig_code); } } } if (show_bits) BIO_printf(sdb->out, ", security bits=%d", bits); BIO_printf(sdb->out, ": %s\n", rv ? "yes" : "no"); return rv; } void ssl_ctx_security_debug(SSL_CTX ctx, int verbose) { static security_debug_ex sdb; sdb.out = bio_err; sdb.verbose = verbose; sdb.old_cb = SSL_CTX_get_security_callback(ctx); SSL_CTX_set_security_callback(ctx, security_callback_debug); SSL_CTX_set0_security_ex_data(ctx, &sdb); } static void keylog_callback(const SSL ssl, const char line) { if (bio_keylog == NULL) { BIO_printf(bio_err, "Keylog callback is invoked without valid file!\n"); return; } /* * There might be concurrent writers to the keylog file, so we must ensure * that the given line is written at once. / BIO_printf(bio_keylog, "%s\n", line); (void)BIO_flush(bio_keylog); } int set_keylog_file(SSL_CTX ctx, const char keylog_file) { / Close any open files / BIO_free_all(bio_keylog); bio_keylog = NULL; if (ctx == NULL \|\| keylog_file == NULL) { / Keylogging is disabled, OK. / return 0; } / * Append rather than write in order to allow concurrent modification. * Furthermore, this preserves existing keylog files which is useful when * the tool is run multiple times. / bio_keylog = BIO_new_file(keylog_file, "a"); if (bio_keylog == NULL) { BIO_printf(bio_err, "Error writing keylog file %s\n", keylog_file); return 1; } / Write a header for seekable, empty files (this excludes pipes). / if (BIO_tell(bio_keylog) == 0) { BIO_puts(bio_keylog, "# SSL/TLS secrets log file, generated by OpenSSL\n"); (void)BIO_flush(bio_keylog); } SSL_CTX_set_keylog_callback(ctx, keylog_callback); return 0; } void print_ca_names(BIO bio, SSL s) { const char cs = SSL_is_server(s) ? "server" : "client"; const STACK_OF(X509_NAME) sk = SSL_get0_peer_CA_list(s); int i; if (sk == NULL \|\| sk_X509_NAME_num(sk) == 0) { if (!SSL_is_server(s)) BIO_printf(bio, "---\nNo %s certificate CA names sent\n", cs); return; } BIO_printf(bio, "---\nAcceptable %s certificate CA names\n", cs); for (i = 0; i < sk_X509_NAME_num(sk); i++) { X509_NAME_print_ex(bio, sk_X509_NAME_value(sk, i), 0, get_nameopt()); BIO_write(bio, "\n", 1); } } void ssl_print_secure_renegotiation_notes(BIO bio, SSL s) { if (SSL_VERSION_ALLOWS_RENEGOTIATION(s)) { BIO_printf(bio, "Secure Renegotiation IS%s supported\n", SSL_get_secure_renegotiation_support(s) ? "" : " NOT"); } else { BIO_printf(bio, "This TLS version forbids renegotiation.\n"); } } int progress_cb(EVP_PKEY_CTX ctx) { BIO b = EVP_PKEY_CTX_get_app_data(ctx); int p = EVP_PKEY_CTX_get_keygen_info(ctx, 0); static const char symbols[] = ".+\n"; char c = (p >= 0 && (size_t)p <= sizeof(symbols) - 1) ? symbols[p] : '?'; BIO_write(b, &c, 1); (void)BIO_flush(b); return 1; }
./openssl/apps/lib/app_libctx.c	/* * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "app_libctx.h" #include "apps.h" static OSSL_LIB_CTX app_libctx = NULL; static const char app_propq = NULL; int app_set_propq(const char arg) { app_propq = arg; return 1; } const char app_get0_propq(void) { return app_propq; } OSSL_LIB_CTX app_get0_libctx(void) { return app_libctx; } OSSL_LIB_CTX app_create_libctx(void) { / * Load the NULL provider into the default library context and create a * library context which will then be used for any OPT_PROV options. */ if (app_libctx == NULL) { if (!app_provider_load(NULL, "null")) { opt_printf_stderr("Failed to create null provider\n"); return NULL; } app_libctx = OSSL_LIB_CTX_new(); } if (app_libctx == NULL) opt_printf_stderr("Failed to create library context\n"); return app_libctx; }
./openssl/apps/lib/columns.c	/* * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <string.h> #include "apps.h" #include "function.h" void calculate_columns(FUNCTION functions, DISPLAY_COLUMNS dc) { FUNCTION f; int len, maxlen = 0; for (f = functions; f->name != NULL; ++f) if (f->type == FT_general \|\| f->type == FT_md \|\| f->type == FT_cipher) if ((len = strlen(f->name)) > maxlen) maxlen = len; dc->width = maxlen + 2; dc->columns = (80 - 1) / dc->width; }
./openssl/apps/lib/app_x509.c	/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <string.h> #include "apps.h" / * X509_ctrl_str() is sorely lacking in libcrypto, but is still needed to * allow the application to process verification options in a manner similar * to signature or other options that pass through EVP_PKEY_CTX_ctrl_str(), * for uniformity. * * As soon as more stuff is added, the code will need serious rework. For * the moment, it only handles the FIPS 196 / SM2 distinguishing ID. / #ifdef EVP_PKEY_CTRL_SET1_ID static ASN1_OCTET_STRING mk_octet_string(void value, size_t value_n) { ASN1_OCTET_STRING v = ASN1_OCTET_STRING_new(); if (v == NULL) { BIO_printf(bio_err, "error: allocation failed\n"); } else if (!ASN1_OCTET_STRING_set(v, value, (int)value_n)) { ASN1_OCTET_STRING_free(v); v = NULL; } return v; } #endif static int x509_ctrl(void object, int cmd, void value, size_t value_n) { switch (cmd) { #ifdef EVP_PKEY_CTRL_SET1_ID case EVP_PKEY_CTRL_SET1_ID: { ASN1_OCTET_STRING v = mk_octet_string(value, value_n); if (v == NULL) { BIO_printf(bio_err, "error: setting distinguishing ID in certificate failed\n"); return 0; } X509_set0_distinguishing_id(object, v); return 1; } #endif default: break; } return -2; / typical EVP_PKEY return for "unsupported" / } static int x509_req_ctrl(void object, int cmd, void value, size_t value_n) { switch (cmd) { #ifdef EVP_PKEY_CTRL_SET1_ID case EVP_PKEY_CTRL_SET1_ID: { ASN1_OCTET_STRING v = mk_octet_string(value, value_n); if (v == NULL) { BIO_printf(bio_err, "error: setting distinguishing ID in certificate signing request failed\n"); return 0; } X509_REQ_set0_distinguishing_id(object, v); return 1; } #endif default: break; } return -2; /* typical EVP_PKEY return for "unsupported" / } static int do_x509_ctrl_string(int (ctrl)(void object, int cmd, void value, size_t value_n), void object, const char value) { int rv = 0; char stmp, vtmp = NULL; size_t vtmp_len = 0; int cmd = 0; /* Will get command values that make sense somehow / stmp = OPENSSL_strdup(value); if (stmp == NULL) return -1; vtmp = strchr(stmp, ':'); if (vtmp != NULL) { vtmp = 0; vtmp++; vtmp_len = strlen(vtmp); } if (strcmp(stmp, "distid") == 0) { #ifdef EVP_PKEY_CTRL_SET1_ID cmd = EVP_PKEY_CTRL_SET1_ID; /* ... except we put it in X509 / #endif } else if (strcmp(stmp, "hexdistid") == 0) { if (vtmp != NULL) { void hexid; long hexid_len = 0; hexid = OPENSSL_hexstr2buf((const char )vtmp, &hexid_len); OPENSSL_free(stmp); stmp = vtmp = hexid; vtmp_len = (size_t)hexid_len; } #ifdef EVP_PKEY_CTRL_SET1_ID cmd = EVP_PKEY_CTRL_SET1_ID; / ... except we put it in X509 / #endif } rv = ctrl(object, cmd, vtmp, vtmp_len); OPENSSL_free(stmp); return rv; } int x509_ctrl_string(X509 x, const char value) { return do_x509_ctrl_string(x509_ctrl, x, value); } int x509_req_ctrl_string(X509_REQ x, const char *value) { return do_x509_ctrl_string(x509_req_ctrl, x, value); }
./openssl/apps/lib/s_socket.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / socket-related functions used by s_client and s_server / #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <signal.h> #include <openssl/opensslconf.h> / * With IPv6, it looks like Digital has mixed up the proper order of * recursive header file inclusion, resulting in the compiler complaining * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is * needed to have fileno() declared correctly... So let's define u_int / #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT) # define __U_INT typedef unsigned int u_int; #endif #ifdef _WIN32 # include <process.h> / MSVC renamed some POSIX functions to have an underscore prefix. / # ifdef _MSC_VER # define getpid _getpid # endif #endif #ifndef OPENSSL_NO_SOCK # include "apps.h" # include "s_apps.h" # include "internal/sockets.h" # if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_read)> # endif # endif # include <openssl/bio.h> # include <openssl/err.h> / Keep track of our peer's address for the cookie callback / BIO_ADDR ourpeer = NULL; /* * init_client - helper routine to set up socket communication * @sock: pointer to storage of resulting socket. * @host: the hostname or path (for AF_UNIX) to connect to. * @port: the port to connect to (ignored for AF_UNIX). * @bindhost: source host or path (for AF_UNIX). * @bindport: source port (ignored for AF_UNIX). * @family: desired socket family, may be AF_INET, AF_INET6, AF_UNIX or * AF_UNSPEC * @type: socket type, must be SOCK_STREAM or SOCK_DGRAM * @protocol: socket protocol, e.g. IPPROTO_TCP or IPPROTO_UDP (or 0 for any) * @tfo: flag to enable TCP Fast Open * @doconn: whether we should call BIO_connect() on the socket * @ba_ret: BIO_ADDR for the remote peer, to be freed by caller * * This will create a socket and use it to connect to a host:port, or if * family == AF_UNIX, to the path found in host. * * If the host has more than one address, it will try them one by one until * a successful connection is established. The resulting socket will be * found in sock on success, it will be given INVALID_SOCKET otherwise. * Returns 1 on success, 0 on failure. / int init_client(int sock, const char host, const char port, const char bindhost, const char bindport, int family, int type, int protocol, int tfo, int doconn, BIO_ADDR *ba_ret) { BIO_ADDRINFO res = NULL; BIO_ADDRINFO bindaddr = NULL; const BIO_ADDRINFO ai = NULL; const BIO_ADDRINFO bi = NULL; int found = 0; int ret; int options = 0; if (tfo && ba_ret != NULL) ba_ret = NULL; if (BIO_sock_init() != 1) return 0; ret = BIO_lookup_ex(host, port, BIO_LOOKUP_CLIENT, family, type, protocol, &res); if (ret == 0) { ERR_print_errors(bio_err); return 0; } if (bindhost != NULL \|\| bindport != NULL) { ret = BIO_lookup_ex(bindhost, bindport, BIO_LOOKUP_CLIENT, family, type, protocol, &bindaddr); if (ret == 0) { ERR_print_errors (bio_err); goto out; } } ret = 0; for (ai = res; ai != NULL; ai = BIO_ADDRINFO_next(ai)) { /* Admittedly, these checks are quite paranoid, we should not get * anything in the BIO_ADDRINFO chain that we haven't * asked for. / OPENSSL_assert((family == AF_UNSPEC \|\| family == BIO_ADDRINFO_family(ai)) && (type == 0 \|\| type == BIO_ADDRINFO_socktype(ai)) && (protocol == 0 \|\| protocol == BIO_ADDRINFO_protocol(ai))); if (bindaddr != NULL) { for (bi = bindaddr; bi != NULL; bi = BIO_ADDRINFO_next(bi)) { if (BIO_ADDRINFO_family(bi) == BIO_ADDRINFO_family(ai)) break; } if (bi == NULL) continue; ++found; } sock = BIO_socket(BIO_ADDRINFO_family(ai), BIO_ADDRINFO_socktype(ai), BIO_ADDRINFO_protocol(ai), 0); if (sock == INVALID_SOCKET) { / Maybe the kernel doesn't support the socket family, even if * BIO_lookup() added it in the returned result... / continue; } if (bi != NULL) { if (!BIO_bind(sock, BIO_ADDRINFO_address(bi), BIO_SOCK_REUSEADDR)) { BIO_closesocket(sock); sock = INVALID_SOCKET; break; } } #ifndef OPENSSL_NO_SCTP if (protocol == IPPROTO_SCTP) { /* * For SCTP we have to set various options on the socket prior to * connecting. This is done automatically by BIO_new_dgram_sctp(). * We don't actually need the created BIO though so we free it again * immediately. / BIO tmpbio = BIO_new_dgram_sctp(sock, BIO_NOCLOSE); if (tmpbio == NULL) { ERR_print_errors(bio_err); return 0; } BIO_free(tmpbio); } #endif if (BIO_ADDRINFO_protocol(ai) == IPPROTO_TCP) { options \|= BIO_SOCK_NODELAY; if (tfo) options \|= BIO_SOCK_TFO; } if (doconn && !BIO_connect(sock, BIO_ADDRINFO_address(ai), options)) { BIO_closesocket(sock); sock = INVALID_SOCKET; continue; } /* Save the address / if (tfo \|\| !doconn) ba_ret = BIO_ADDR_dup(BIO_ADDRINFO_address(ai)); /* Success, don't try any more addresses / break; } if (sock == INVALID_SOCKET) { if (bindaddr != NULL && !found) { BIO_printf(bio_err, "Can't bind %saddress for %s%s%s\n", #ifdef AF_INET6 BIO_ADDRINFO_family(res) == AF_INET6 ? "IPv6 " : #endif BIO_ADDRINFO_family(res) == AF_INET ? "IPv4 " : BIO_ADDRINFO_family(res) == AF_UNIX ? "unix " : "", bindhost != NULL ? bindhost : "", bindport != NULL ? ":" : "", bindport != NULL ? bindport : ""); ERR_clear_error(); ret = 0; } ERR_print_errors(bio_err); } else { char hostname = NULL; hostname = BIO_ADDR_hostname_string(BIO_ADDRINFO_address(ai), 1); if (hostname != NULL) { BIO_printf(bio_err, "Connecting to %s\n", hostname); OPENSSL_free(hostname); } / Remove any stale errors from previous connection attempts / ERR_clear_error(); ret = 1; } out: if (bindaddr != NULL) { BIO_ADDRINFO_free (bindaddr); } BIO_ADDRINFO_free(res); return ret; } void get_sock_info_address(int asock, char hostname, char service) { union BIO_sock_info_u info; if (hostname != NULL) hostname = NULL; if (service != NULL) service = NULL; if ((info.addr = BIO_ADDR_new()) != NULL && BIO_sock_info(asock, BIO_SOCK_INFO_ADDRESS, &info)) { if (hostname != NULL) hostname = BIO_ADDR_hostname_string(info.addr, 1); if (service != NULL) service = BIO_ADDR_service_string(info.addr, 1); } BIO_ADDR_free(info.addr); } int report_server_accept(BIO out, int asock, int with_address, int with_pid) { int success = 1; if (BIO_printf(out, "ACCEPT") <= 0) return 0; if (with_address) { char hostname, service; get_sock_info_address(asock, &hostname, &service); success = hostname != NULL && service != NULL; if (success) success = BIO_printf(out, strchr(hostname, ':') == NULL ? /* IPv4 / " %s:%s" : / IPv6 / " [%s]:%s", hostname, service) > 0; else (void)BIO_printf(out, "unknown:error\n"); OPENSSL_free(hostname); OPENSSL_free(service); } if (with_pid) success = BIO_printf(out, " PID=%d", getpid()) > 0; success = BIO_printf(out, "\n") > 0; (void)BIO_flush(out); return success; } / * do_server - helper routine to perform a server operation * @accept_sock: pointer to storage of resulting socket. * @host: the hostname or path (for AF_UNIX) to connect to. * @port: the port to connect to (ignored for AF_UNIX). * @family: desired socket family, may be AF_INET, AF_INET6, AF_UNIX or * AF_UNSPEC * @type: socket type, must be SOCK_STREAM or SOCK_DGRAM * @cb: pointer to a function that receives the accepted socket and * should perform the communication with the connecting client. * @context: pointer to memory that's passed verbatim to the cb function. * @naccept: number of times an incoming connect should be accepted. If -1, * unlimited number. * * This will create a socket and use it to listen to a host:port, or if * family == AF_UNIX, to the path found in host, then start accepting * incoming connections and run cb on the resulting socket. * * 0 on failure, something other on success. / int do_server(int accept_sock, const char host, const char port, int family, int type, int protocol, do_server_cb cb, unsigned char context, int naccept, BIO bio_s_out, int tfo) { int asock = 0; int sock; int i; BIO_ADDRINFO res = NULL; const BIO_ADDRINFO next; int sock_family, sock_type, sock_protocol, sock_port; const BIO_ADDR sock_address; int sock_family_fallback = AF_UNSPEC; const BIO_ADDR sock_address_fallback = NULL; int sock_options = BIO_SOCK_REUSEADDR; int ret = 0; if (BIO_sock_init() != 1) return 0; if (!BIO_lookup_ex(host, port, BIO_LOOKUP_SERVER, family, type, protocol, &res)) { ERR_print_errors(bio_err); return 0; } /* Admittedly, these checks are quite paranoid, we should not get * anything in the BIO_ADDRINFO chain that we haven't asked for / OPENSSL_assert((family == AF_UNSPEC \|\| family == BIO_ADDRINFO_family(res)) && (type == 0 \|\| type == BIO_ADDRINFO_socktype(res)) && (protocol == 0 \|\| protocol == BIO_ADDRINFO_protocol(res))); sock_family = BIO_ADDRINFO_family(res); sock_type = BIO_ADDRINFO_socktype(res); sock_protocol = BIO_ADDRINFO_protocol(res); sock_address = BIO_ADDRINFO_address(res); next = BIO_ADDRINFO_next(res); if (tfo && sock_type == SOCK_STREAM) sock_options \|= BIO_SOCK_TFO; #ifdef AF_INET6 if (sock_family == AF_INET6) sock_options \|= BIO_SOCK_V6_ONLY; if (next != NULL && BIO_ADDRINFO_socktype(next) == sock_type && BIO_ADDRINFO_protocol(next) == sock_protocol) { if (sock_family == AF_INET && BIO_ADDRINFO_family(next) == AF_INET6) { / In case AF_INET6 is returned but not supported by the * kernel, retry with the first detected address family / sock_family_fallback = sock_family; sock_address_fallback = sock_address; sock_family = AF_INET6; sock_address = BIO_ADDRINFO_address(next); } else if (sock_family == AF_INET6 && BIO_ADDRINFO_family(next) == AF_INET) { sock_options &= ~BIO_SOCK_V6_ONLY; } } #endif asock = BIO_socket(sock_family, sock_type, sock_protocol, 0); if (asock == INVALID_SOCKET && sock_family_fallback != AF_UNSPEC) { asock = BIO_socket(sock_family_fallback, sock_type, sock_protocol, 0); sock_address = sock_address_fallback; } if (asock == INVALID_SOCKET \|\| !BIO_listen(asock, sock_address, sock_options)) { BIO_ADDRINFO_free(res); ERR_print_errors(bio_err); if (asock != INVALID_SOCKET) BIO_closesocket(asock); goto end; } #ifndef OPENSSL_NO_SCTP if (protocol == IPPROTO_SCTP) { / * For SCTP we have to set various options on the socket prior to * accepting. This is done automatically by BIO_new_dgram_sctp(). * We don't actually need the created BIO though so we free it again * immediately. / BIO tmpbio = BIO_new_dgram_sctp(asock, BIO_NOCLOSE); if (tmpbio == NULL) { BIO_closesocket(asock); ERR_print_errors(bio_err); goto end; } BIO_free(tmpbio); } #endif sock_port = BIO_ADDR_rawport(sock_address); BIO_ADDRINFO_free(res); res = NULL; if (!report_server_accept(bio_s_out, asock, sock_port == 0, 0)) { BIO_closesocket(asock); ERR_print_errors(bio_err); goto end; } if (accept_sock != NULL) accept_sock = asock; for (;;) { char sink[64]; struct timeval timeout; fd_set readfds; if (type == SOCK_STREAM) { BIO_ADDR_free(ourpeer); ourpeer = BIO_ADDR_new(); if (ourpeer == NULL) { BIO_closesocket(asock); ERR_print_errors(bio_err); goto end; } do { sock = BIO_accept_ex(asock, ourpeer, 0); } while (sock < 0 && BIO_sock_should_retry(sock)); if (sock < 0) { ERR_print_errors(bio_err); BIO_closesocket(asock); break; } BIO_set_tcp_ndelay(sock, 1); i = (cb)(sock, type, protocol, context); /* * If we ended with an alert being sent, but still with data in the * network buffer to be read, then calling BIO_closesocket() will * result in a TCP-RST being sent. On some platforms (notably * Windows) then this will result in the peer immediately abandoning * the connection including any buffered alert data before it has * had a chance to be read. Shutting down the sending side first, * and then closing the socket sends TCP-FIN first followed by * TCP-RST. This seems to allow the peer to read the alert data. / shutdown(sock, 1); / SHUT_WR / / * We just said we have nothing else to say, but it doesn't mean * that the other side has nothing. It's even recommended to * consume incoming data. [In testing context this ensures that * alerts are passed on...] / timeout.tv_sec = 0; timeout.tv_usec = 500000; / some extreme round-trip / do { FD_ZERO(&readfds); openssl_fdset(sock, &readfds); } while (select(sock + 1, &readfds, NULL, NULL, &timeout) > 0 && readsocket(sock, sink, sizeof(sink)) > 0); BIO_closesocket(sock); } else { i = (cb)(asock, type, protocol, context); } if (naccept != -1) naccept--; if (i < 0 \|\| naccept == 0) { BIO_closesocket(asock); ret = i; break; } } end: # ifdef AF_UNIX if (family == AF_UNIX) unlink(host); # endif BIO_ADDR_free(ourpeer); ourpeer = NULL; return ret; } void do_ssl_shutdown(SSL ssl) { int ret; do { / We only do unidirectional shutdown / ret = SSL_shutdown(ssl); if (ret < 0) { switch (SSL_get_error(ssl, ret)) { case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_ASYNC: case SSL_ERROR_WANT_ASYNC_JOB: / We just do busy waiting. Nothing clever / continue; } ret = 0; } } while (ret < 0); } #endif / OPENSSL_NO_SOCK */
./openssl/apps/lib/win32_init.c	/* * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <windows.h> #include <stdlib.h> #include <string.h> #include <malloc.h> #if defined(CP_UTF8) static UINT saved_cp; static int newargc; static char newargv; static void cleanup(void) { int i; SetConsoleOutputCP(saved_cp); for (i = 0; i < newargc; i++) free(newargv[i]); free(newargv); } / * Incrementally [re]allocate newargv and keep it NULL-terminated. / static int validate_argv(int argc) { static int size = 0; if (argc >= size) { char ptr; while (argc >= size) size += 64; ptr = realloc(newargv, size sizeof(newargv[0])); if (ptr == NULL) return 0; (newargv = ptr)[argc] = NULL; } else { newargv[argc] = NULL; } return 1; } static int process_glob(WCHAR wstr, int wlen) { int i, slash, udlen; WCHAR saved_char; WIN32_FIND_DATAW data; HANDLE h; / * Note that we support wildcard characters only in filename part * of the path, and not in directories. Windows users are used to * this, that's why recursive glob processing is not implemented. / / * Start by looking for last slash or backslash, ... / for (slash = 0, i = 0; i < wlen; i++) if (wstr[i] == L'/' \|\| wstr[i] == L'\\') slash = i + 1; / * ... then look for asterisk or question mark in the file name. / for (i = slash; i < wlen; i++) if (wstr[i] == L'' \|\| wstr[i] == L'?') break; if (i == wlen) return 0; /* definitely not a glob / saved_char = wstr[wlen]; wstr[wlen] = L'\0'; h = FindFirstFileW(wstr, &data); wstr[wlen] = saved_char; if (h == INVALID_HANDLE_VALUE) return 0; / not a valid glob, just pass... / if (slash) udlen = WideCharToMultiByte(CP_UTF8, 0, wstr, slash, NULL, 0, NULL, NULL); else udlen = 0; do { int uflen; char arg; /* * skip over . and .. / if (data.cFileName[0] == L'.') { if ((data.cFileName[1] == L'\0') \|\| (data.cFileName[1] == L'.' && data.cFileName[2] == L'\0')) continue; } if (!validate_argv(newargc + 1)) break; / * -1 below means "scan for trailing '\0' and count it", * so that \|uflen\| covers even trailing '\0'. / uflen = WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1, NULL, 0, NULL, NULL); arg = malloc(udlen + uflen); if (arg == NULL) break; if (udlen) WideCharToMultiByte(CP_UTF8, 0, wstr, slash, arg, udlen, NULL, NULL); WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1, arg + udlen, uflen, NULL, NULL); newargv[newargc++] = arg; } while (FindNextFileW(h, &data)); CloseHandle(h); return 1; } void win32_utf8argv(int argc, char *argv[]) { const WCHAR wcmdline; WCHAR warg, wend, p; int wlen, ulen, valid = 1; char arg; if (GetEnvironmentVariableW(L"OPENSSL_WIN32_UTF8", NULL, 0) == 0) return; newargc = 0; newargv = NULL; if (!validate_argv(newargc)) return; wcmdline = GetCommandLineW(); if (wcmdline == NULL) return; /* * make a copy of the command line, since we might have to modify it... / wlen = wcslen(wcmdline); p = _alloca((wlen + 1) sizeof(WCHAR)); wcscpy(p, wcmdline); while (p != L'\0') { int in_quote = 0; if (p == L' ' \|\| p == L'\t') { p++; / skip over whitespace / continue; } / * Note: because we may need to fiddle with the number of backslashes, * the argument string is copied into itself. This is safe because * the number of characters will never expand. / warg = wend = p; while (p != L'\0' && (in_quote \|\| (p != L' ' && p != L'\t'))) { switch (p) { case L'\\': / * Microsoft documentation on how backslashes are treated * is: * * + Backslashes are interpreted literally, unless they * immediately precede a double quotation mark. * + If an even number of backslashes is followed by a double * quotation mark, one backslash is placed in the argv array * for every pair of backslashes, and the double quotation * mark is interpreted as a string delimiter. * + If an odd number of backslashes is followed by a double * quotation mark, one backslash is placed in the argv array * for every pair of backslashes, and the double quotation * mark is "escaped" by the remaining backslash, causing a * literal double quotation mark (") to be placed in argv. * * Ref: https://msdn.microsoft.com/en-us/library/17w5ykft.aspx * * Though referred page doesn't mention it, multiple qouble * quotes are also special. Pair of double quotes in quoted * string is counted as single double quote. / { const WCHAR q = p; int i; while (p == L'\\') p++; if (p == L'"') { int i; for (i = (p - q) / 2; i > 0; i--) wend++ = L'\\'; / * if odd amount of backslashes before the quote, * said quote is part of the argument, not a delimiter / if ((p - q) % 2 == 1) wend++ = p++; } else { for (i = p - q; i > 0; i--) wend++ = L'\\'; } } break; case L'"': /* * Without the preceding backslash (or when preceded with an * even number of backslashes), the double quote is a simple * string delimiter and just slightly change the parsing state / if (in_quote && p[1] == L'"') wend++ = p++; else in_quote = !in_quote; p++; break; default: / * Any other non-delimiter character is just taken verbatim / wend++ = p++; } } wlen = wend - warg; if (wlen == 0 \|\| !process_glob(warg, wlen)) { if (!validate_argv(newargc + 1)) { valid = 0; break; } ulen = 0; if (wlen > 0) { ulen = WideCharToMultiByte(CP_UTF8, 0, warg, wlen, NULL, 0, NULL, NULL); if (ulen <= 0) continue; } arg = malloc(ulen + 1); if (arg == NULL) { valid = 0; break; } if (wlen > 0) WideCharToMultiByte(CP_UTF8, 0, warg, wlen, arg, ulen, NULL, NULL); arg[ulen] = '\0'; newargv[newargc++] = arg; } } if (valid) { saved_cp = GetConsoleOutputCP(); SetConsoleOutputCP(CP_UTF8); argc = newargc; argv = newargv; atexit(cleanup); } else if (newargv != NULL) { int i; for (i = 0; i < newargc; i++) free(newargv[i]); free(newargv); newargc = 0; newargv = NULL; } return; } #else void win32_utf8argv(int argc, char **argv[]) { return; } #endif
./openssl/apps/lib/vms_term_sock.c	/* * Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2016 VMS Software, Inc. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #ifdef __VMS # define OPENSSL_SYS_VMS # pragma message disable DOLLARID # include <openssl/opensslconf.h> # if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS) / * On VMS, you need to define this to get the declaration of fileno(). The * value 2 is to make sure no function defined in POSIX-2 is left undefined. / # define _POSIX_C_SOURCE 2 # endif # include <stdio.h> # undef _POSIX_C_SOURCE # include <sys/types.h> # include <sys/socket.h> # include <netinet/in.h> # include <inet.h> # include <unistd.h> # include <string.h> # include <errno.h> # include <starlet.h> # include <iodef.h> # ifdef __alpha # include <iosbdef.h> # else typedef struct _iosb { / Copied from IOSBDEF.H for Alpha / # pragma __nomember_alignment __union { __struct { unsigned short int iosb$w_status; / Final I/O status / __union { __struct { / 16-bit byte count variant / unsigned short int iosb$w_bcnt; / 16-bit byte count / __union { unsigned int iosb$l_dev_depend; / 32-bit device dependent info / unsigned int iosb$l_pid; / 32-bit pid / } iosb$r_l; } iosb$r_bcnt_16; __struct { / 32-bit byte count variant / unsigned int iosb$l_bcnt; / 32-bit byte count (unaligned) / unsigned short int iosb$w_dev_depend_high; / 16-bit device dependent info / } iosb$r_bcnt_32; } iosb$r_devdepend; } iosb$r_io_64; __struct { __union { unsigned int iosb$l_getxxi_status; / Final GETxxI status / unsigned int iosb$l_reg_status; / Final $Registry status / } iosb$r_l_status; unsigned int iosb$l_reserved; / Reserved field / } iosb$r_get_64; } iosb$r_io_get; } IOSB; # if !defined(__VAXC) # define iosb$w_status iosb$r_io_get.iosb$r_io_64.iosb$w_status # define iosb$w_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$w_bcnt # define iosb$r_l iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$r_l # define iosb$l_dev_depend iosb$r_l.iosb$l_dev_depend # define iosb$l_pid iosb$r_l.iosb$l_pid # define iosb$l_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$l_bcnt # define iosb$w_dev_depend_high iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$w_dev_depend_high # define iosb$l_getxxi_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_getxxi_status # define iosb$l_reg_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_reg_status # endif / #if !defined(__VAXC) / # endif / End of IOSBDEF / # include <efndef.h> # include <stdlib.h> # include <ssdef.h> # include <time.h> # include <stdarg.h> # include <descrip.h> # include "vms_term_sock.h" # ifdef __alpha static struct _iosb TerminalDeviceIosb; # else IOSB TerminalDeviceIosb; # endif static char TerminalDeviceBuff[255 + 2]; static int TerminalSocketPair[2] = {0, 0}; static unsigned short TerminalDeviceChan = 0; static int CreateSocketPair (int, int, int, int ); static void SocketPairTimeoutAst (int); static int TerminalDeviceAst (int); static void LogMessage (char , ...); / ** Socket Pair Timeout Value (must be 0-59 seconds) / # define SOCKET_PAIR_TIMEOUT_VALUE 20 / ** Socket Pair Timeout Block which is passed to timeout AST / typedef struct _SocketPairTimeoutBlock { unsigned short SockChan1; unsigned short SockChan2; } SPTB; # ifdef TERM_SOCK_TEST /----------------------------------------------------------------------------/ / / /----------------------------------------------------------------------------/ int main (int argc, char argv[], char envp[]) { char TermBuff[80]; int TermSock, status, len; LogMessage ("Enter 'q' or 'Q' to quit ..."); while (OPENSSL_strcasecmp (TermBuff, "Q")) { / ** Create the terminal socket / status = TerminalSocket (TERM_SOCK_CREATE, &TermSock); if (status != TERM_SOCK_SUCCESS) exit (1); / ** Process the terminal input / LogMessage ("Waiting on terminal I/O ...\n"); len = recv (TermSock, TermBuff, sizeof(TermBuff), 0) ; TermBuff[len] = '\0'; LogMessage ("Received terminal I/O [%s]", TermBuff); / ** Delete the terminal socket / status = TerminalSocket (TERM_SOCK_DELETE, &TermSock); if (status != TERM_SOCK_SUCCESS) exit (1); } return 1; } # endif /----------------------------------------------------------------------------/ / / /----------------------------------------------------------------------------/ int TerminalSocket (int FunctionCode, int ReturnSocket) { int status; $DESCRIPTOR (TerminalDeviceDesc, "SYS$COMMAND"); /* ** Process the requested function code / switch (FunctionCode) { case TERM_SOCK_CREATE: / ** Create a socket pair / status = CreateSocketPair (AF_INET, SOCK_STREAM, 0, TerminalSocketPair); if (status == -1) { LogMessage ("TerminalSocket: CreateSocketPair () - %08X", status); if (TerminalSocketPair[0]) close (TerminalSocketPair[0]); if (TerminalSocketPair[1]) close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } / ** Assign a channel to the terminal device / status = sys$assign (&TerminalDeviceDesc, &TerminalDeviceChan, 0, 0, 0); if (! (status & 1)) { LogMessage ("TerminalSocket: SYS$ASSIGN () - %08X", status); close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } / ** Queue an async IO to the terminal device / status = sys$qio (EFN$C_ENF, TerminalDeviceChan, IO$_READVBLK, &TerminalDeviceIosb, TerminalDeviceAst, 0, TerminalDeviceBuff, sizeof(TerminalDeviceBuff) - 2, 0, 0, 0, 0); if (! (status & 1)) { LogMessage ("TerminalSocket: SYS$QIO () - %08X", status); close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } / ** Return the input side of the socket pair / ReturnSocket = TerminalSocketPair[1]; break; case TERM_SOCK_DELETE: /* ** Cancel any pending IO on the terminal channel / status = sys$cancel (TerminalDeviceChan); if (! (status & 1)) { LogMessage ("TerminalSocket: SYS$CANCEL () - %08X", status); close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } / ** Deassign the terminal channel / status = sys$dassgn (TerminalDeviceChan); if (! (status & 1)) { LogMessage ("TerminalSocket: SYS$DASSGN () - %08X", status); close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } / ** Close the terminal socket pair / close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); / ** Return the initialized socket / ReturnSocket = 0; break; default: /* ** Invalid function code / LogMessage ("TerminalSocket: Invalid Function Code - %d", FunctionCode); return TERM_SOCK_FAILURE; break; } / ** Return success / return TERM_SOCK_SUCCESS; } /----------------------------------------------------------------------------/ / / /----------------------------------------------------------------------------/ static int CreateSocketPair (int SocketFamily, int SocketType, int SocketProtocol, int SocketPair) { struct dsc$descriptor AscTimeDesc = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL}; static const char* LocalHostAddr = {"127.0.0.1"}; unsigned short TcpAcceptChan = 0, TcpDeviceChan = 0; unsigned long BinTimeBuff[2]; struct sockaddr_in sin; char AscTimeBuff[32]; short LocalHostPort; int status; unsigned int slen; # ifdef __alpha struct _iosb iosb; # else IOSB iosb; # endif int SockDesc1 = 0, SockDesc2 = 0; SPTB sptb; $DESCRIPTOR (TcpDeviceDesc, "TCPIP$DEVICE"); /* ** Create a socket / SockDesc1 = socket (SocketFamily, SocketType, 0); if (SockDesc1 < 0) { LogMessage ("CreateSocketPair: socket () - %d", errno); return -1; } / ** Initialize the socket information / slen = sizeof(sin); memset ((char ) &sin, 0, slen); sin.sin_family = SocketFamily; sin.sin_addr.s_addr = inet_addr (LocalHostAddr); sin.sin_port = 0; /* ** Bind the socket to the local IP / status = bind (SockDesc1, (struct sockaddr ) &sin, slen); if (status < 0) { LogMessage ("CreateSocketPair: bind () - %d", errno); close (SockDesc1); return -1; } /* ** Get the socket name so we can save the port number / status = getsockname (SockDesc1, (struct sockaddr ) &sin, &slen); if (status < 0) { LogMessage ("CreateSocketPair: getsockname () - %d", errno); close (SockDesc1); return -1; } else LocalHostPort = sin.sin_port; /* ** Setup a listen for the socket / listen (SockDesc1, 5); / ** Get the binary (64-bit) time of the specified timeout value / sprintf (AscTimeBuff, "0 0:0:%02d.00", SOCKET_PAIR_TIMEOUT_VALUE); AscTimeDesc.dsc$w_length = strlen (AscTimeBuff); AscTimeDesc.dsc$a_pointer = AscTimeBuff; status = sys$bintim (&AscTimeDesc, BinTimeBuff); if (! (status & 1)) { LogMessage ("CreateSocketPair: SYS$BINTIM () - %08X", status); close (SockDesc1); return -1; } / Assign another channel to the TCP/IP device for the accept. This is the channel that ends up being connected to. / status = sys$assign (&TcpDeviceDesc, &TcpDeviceChan, 0, 0, 0); if (! (status & 1)) { LogMessage ("CreateSocketPair: SYS$ASSIGN () - %08X", status); close (SockDesc1); return -1; } / ** Get the channel of the first socket for the accept / TcpAcceptChan = decc$get_sdc (SockDesc1); / ** Perform the accept using $QIO so we can do this asynchronously / status = sys$qio (EFN$C_ENF, TcpAcceptChan, IO$_ACCESS \| IO$M_ACCEPT, &iosb, 0, 0, 0, 0, 0, &TcpDeviceChan, 0, 0); if (! (status & 1)) { LogMessage ("CreateSocketPair: SYS$QIO () - %08X", status); close (SockDesc1); sys$dassgn (TcpDeviceChan); return -1; } / ** Create the second socket to do the connect / SockDesc2 = socket (SocketFamily, SocketType, 0); if (SockDesc2 < 0) { LogMessage ("CreateSocketPair: socket () - %d", errno); sys$cancel (TcpAcceptChan); close (SockDesc1); sys$dassgn (TcpDeviceChan); return (-1) ; } / ** Setup the Socket Pair Timeout Block / sptb.SockChan1 = TcpAcceptChan; sptb.SockChan2 = decc$get_sdc (SockDesc2); / Before we block on the connect, set a timer that can cancel I/O on our two sockets if it never connects. / status = sys$setimr (EFN$C_ENF, BinTimeBuff, SocketPairTimeoutAst, &sptb, 0); if (! (status & 1)) { LogMessage ("CreateSocketPair: SYS$SETIMR () - %08X", status); sys$cancel (TcpAcceptChan); close (SockDesc1); close (SockDesc2); sys$dassgn (TcpDeviceChan); return -1; } / ** Now issue the connect / memset ((char ) &sin, 0, sizeof(sin)) ; sin.sin_family = SocketFamily; sin.sin_addr.s_addr = inet_addr (LocalHostAddr) ; sin.sin_port = LocalHostPort ; status = connect (SockDesc2, (struct sockaddr ) &sin, sizeof(sin)); if (status < 0) { LogMessage ("CreateSocketPair: connect () - %d", errno); sys$cantim (&sptb, 0); sys$cancel (TcpAcceptChan); close (SockDesc1); close (SockDesc2); sys$dassgn (TcpDeviceChan); return -1; } / Wait for the asynch $QIO to finish. Note that if the I/O was aborted (SS$_ABORT), then we probably canceled it from the AST routine - so log ** a timeout. / status = sys$synch (EFN$C_ENF, &iosb); if (! (iosb.iosb$w_status & 1)) { if (iosb.iosb$w_status == SS$_ABORT) LogMessage ("CreateSocketPair: SYS$QIO(iosb) timeout"); else { LogMessage ("CreateSocketPair: SYS$QIO(iosb) - %d", iosb.iosb$w_status); sys$cantim (&sptb, 0); } close (SockDesc1); close (SockDesc2); sys$dassgn (TcpDeviceChan); return -1; } / Here we're successfully connected, so cancel the timer, convert the I/O channel to a socket fd, close the listener socket and return the ** connected pair. / sys$cantim (&sptb, 0); close (SockDesc1) ; SocketPair[0] = SockDesc2 ; SocketPair[1] = socket_fd (TcpDeviceChan); return (0) ; } /----------------------------------------------------------------------------/ / / /----------------------------------------------------------------------------/ static void SocketPairTimeoutAst (int astparm) { SPTB sptb = (SPTB ) astparm; sys$cancel (sptb->SockChan2); / Cancel the connect() / sys$cancel (sptb->SockChan1); / Cancel the accept() / return; } /----------------------------------------------------------------------------/ / / /----------------------------------------------------------------------------/ static int TerminalDeviceAst (int astparm) { int status; / ** Terminate the terminal buffer / TerminalDeviceBuff[TerminalDeviceIosb.iosb$w_bcnt] = '\0'; strcat (TerminalDeviceBuff, "\n"); / ** Send the data read from the terminal device through the socket pair / send (TerminalSocketPair[0], TerminalDeviceBuff, TerminalDeviceIosb.iosb$w_bcnt + 1, 0); / ** Queue another async IO to the terminal device / status = sys$qio (EFN$C_ENF, TerminalDeviceChan, IO$_READVBLK, &TerminalDeviceIosb, TerminalDeviceAst, 0, TerminalDeviceBuff, sizeof(TerminalDeviceBuff) - 1, 0, 0, 0, 0); / ** Return status / return status; } /----------------------------------------------------------------------------/ / / /----------------------------------------------------------------------------/ static void LogMessage (char msg, ...) { char Month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; static unsigned int pid = 0; va_list args; time_t CurTime; struct tm LocTime; char MsgBuff[256]; /* ** Get the process pid / if (pid == 0) pid = getpid (); / ** Convert the current time into local time / CurTime = time (NULL); LocTime = localtime (&CurTime); / ** Format the message buffer / sprintf (MsgBuff, "%02d-%s-%04d %02d:%02d:%02d [%08X] %s\n", LocTime->tm_mday, Month[LocTime->tm_mon], (LocTime->tm_year + 1900), LocTime->tm_hour, LocTime->tm_min, LocTime->tm_sec, pid, msg); / Get any variable arguments and add them to the print of the message buffer / va_start (args, msg); vfprintf (stderr, MsgBuff, args); va_end (args); / ** Flush standard error output */ fsync (fileno (stderr)); return; } #endif
./openssl/apps/lib/apps.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS) / * On VMS, you need to define this to get the declaration of fileno(). The * value 2 is to make sure no function defined in POSIX-2 is left undefined. / # define _POSIX_C_SOURCE 2 #endif #ifndef OPENSSL_NO_ENGINE / We need to use some deprecated APIs / # define OPENSSL_SUPPRESS_DEPRECATED # include <openssl/engine.h> #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #ifndef OPENSSL_NO_POSIX_IO # include <sys/stat.h> # include <fcntl.h> #endif #include <ctype.h> #include <errno.h> #include <openssl/err.h> #include <openssl/x509.h> #include <openssl/x509v3.h> #include <openssl/http.h> #include <openssl/pem.h> #include <openssl/store.h> #include <openssl/pkcs12.h> #include <openssl/ui.h> #include <openssl/safestack.h> #include <openssl/rsa.h> #include <openssl/rand.h> #include <openssl/bn.h> #include <openssl/ssl.h> #include <openssl/core_names.h> #include "s_apps.h" #include "apps.h" #ifdef _WIN32 static int WIN32_rename(const char from, const char to); # define rename(from, to) WIN32_rename((from), (to)) #endif #if defined(OPENSSL_SYS_WINDOWS) \|\| defined(OPENSSL_SYS_MSDOS) # include <conio.h> #endif #if defined(OPENSSL_SYS_MSDOS) && !defined(_WIN32) \|\| defined(__BORLANDC__) # define _kbhit kbhit #endif static BIO bio_open_default_(const char filename, char mode, int format, int quiet); #define PASS_SOURCE_SIZE_MAX 4 DEFINE_STACK_OF(CONF) typedef struct { const char name; unsigned long flag; unsigned long mask; } NAME_EX_TBL; static int set_table_opts(unsigned long flags, const char arg, const NAME_EX_TBL in_tbl); static int set_multi_opts(unsigned long flags, const char arg, const NAME_EX_TBL in_tbl); int app_init(long mesgwin); int chopup_args(ARGS arg, char buf) { int quoted; char c = '\0', p = NULL; arg->argc = 0; if (arg->size == 0) { arg->size = 20; arg->argv = app_malloc(sizeof(arg->argv) * arg->size, "argv space"); } for (p = buf;;) { /* Skip whitespace. / while (p && isspace(_UC(p))) p++; if (p == '\0') break; /* The start of something good :-) / if (arg->argc >= arg->size) { char tmp; arg->size += 20; tmp = OPENSSL_realloc(arg->argv, sizeof(arg->argv) * arg->size); if (tmp == NULL) return 0; arg->argv = tmp; } quoted = p == '\'' \|\| p == '"'; if (quoted) c = p++; arg->argv[arg->argc++] = p; / now look for the end of this / if (quoted) { while (p && p != c) p++; p++ = '\0'; } else { while (p && !isspace(_UC(p))) p++; if (p) p++ = '\0'; } } arg->argv[arg->argc] = NULL; return 1; } #ifndef APP_INIT int app_init(long mesgwin) { return 1; } #endif int ctx_set_verify_locations(SSL_CTX ctx, const char CAfile, int noCAfile, const char CApath, int noCApath, const char CAstore, int noCAstore) { if (CAfile == NULL && CApath == NULL && CAstore == NULL) { if (!noCAfile && SSL_CTX_set_default_verify_file(ctx) <= 0) return 0; if (!noCApath && SSL_CTX_set_default_verify_dir(ctx) <= 0) return 0; if (!noCAstore && SSL_CTX_set_default_verify_store(ctx) <= 0) return 0; return 1; } if (CAfile != NULL && !SSL_CTX_load_verify_file(ctx, CAfile)) return 0; if (CApath != NULL && !SSL_CTX_load_verify_dir(ctx, CApath)) return 0; if (CAstore != NULL && !SSL_CTX_load_verify_store(ctx, CAstore)) return 0; return 1; } #ifndef OPENSSL_NO_CT int ctx_set_ctlog_list_file(SSL_CTX ctx, const char path) { if (path == NULL) return SSL_CTX_set_default_ctlog_list_file(ctx); return SSL_CTX_set_ctlog_list_file(ctx, path); } #endif static unsigned long nmflag = 0; static char nmflag_set = 0; int set_nameopt(const char arg) { int ret = set_name_ex(&nmflag, arg); if (ret) nmflag_set = 1; return ret; } unsigned long get_nameopt(void) { return nmflag_set ? nmflag : XN_FLAG_SEP_CPLUS_SPC \| ASN1_STRFLGS_UTF8_CONVERT; } void dump_cert_text(BIO out, X509 x) { print_name(out, "subject=", X509_get_subject_name(x)); print_name(out, "issuer=", X509_get_issuer_name(x)); } int wrap_password_callback(char buf, int bufsiz, int verify, void userdata) { return password_callback(buf, bufsiz, verify, (PW_CB_DATA )userdata); } static char app_get_pass(const char arg, int keepbio); char get_passwd(const char pass, const char desc) { char result = NULL; if (desc == NULL) desc = "<unknown>"; if (!app_passwd(pass, NULL, &result, NULL)) BIO_printf(bio_err, "Error getting password for %s\n", desc); if (pass != NULL && result == NULL) { BIO_printf(bio_err, "Trying plain input string (better precede with 'pass:')\n"); result = OPENSSL_strdup(pass); if (result == NULL) BIO_printf(bio_err, "Out of memory getting password for %s\n", desc); } return result; } int app_passwd(const char arg1, const char arg2, char pass1, char pass2) { int same = arg1 != NULL && arg2 != NULL && strcmp(arg1, arg2) == 0; if (arg1 != NULL) { pass1 = app_get_pass(arg1, same); if (pass1 == NULL) return 0; } else if (pass1 != NULL) { pass1 = NULL; } if (arg2 != NULL) { pass2 = app_get_pass(arg2, same ? 2 : 0); if (pass2 == NULL) return 0; } else if (pass2 != NULL) { pass2 = NULL; } return 1; } static char app_get_pass(const char arg, int keepbio) { static BIO pwdbio = NULL; char tmp, tpass[APP_PASS_LEN]; int i; /* PASS_SOURCE_SIZE_MAX = max number of chars before ':' in below strings / if (CHECK_AND_SKIP_PREFIX(arg, "pass:")) return OPENSSL_strdup(arg); if (CHECK_AND_SKIP_PREFIX(arg, "env:")) { tmp = getenv(arg); if (tmp == NULL) { BIO_printf(bio_err, "No environment variable %s\n", arg); return NULL; } return OPENSSL_strdup(tmp); } if (!keepbio \|\| pwdbio == NULL) { if (CHECK_AND_SKIP_PREFIX(arg, "file:")) { pwdbio = BIO_new_file(arg, "r"); if (pwdbio == NULL) { BIO_printf(bio_err, "Can't open file %s\n", arg); return NULL; } #if !defined(_WIN32) / * Under _WIN32, which covers even Win64 and CE, file * descriptors referenced by BIO_s_fd are not inherited * by child process and therefore below is not an option. * It could have been an option if bss_fd.c was operating * on real Windows descriptors, such as those obtained * with CreateFile. / } else if (CHECK_AND_SKIP_PREFIX(arg, "fd:")) { BIO btmp; i = atoi(arg); if (i >= 0) pwdbio = BIO_new_fd(i, BIO_NOCLOSE); if ((i < 0) \|\| pwdbio == NULL) { BIO_printf(bio_err, "Can't access file descriptor %s\n", arg); return NULL; } /* * Can't do BIO_gets on an fd BIO so add a buffering BIO / btmp = BIO_new(BIO_f_buffer()); if (btmp == NULL) { BIO_free_all(pwdbio); pwdbio = NULL; BIO_printf(bio_err, "Out of memory\n"); return NULL; } pwdbio = BIO_push(btmp, pwdbio); #endif } else if (strcmp(arg, "stdin") == 0) { unbuffer(stdin); pwdbio = dup_bio_in(FORMAT_TEXT); if (pwdbio == NULL) { BIO_printf(bio_err, "Can't open BIO for stdin\n"); return NULL; } } else { / argument syntax error; do not reveal too much about arg / tmp = strchr(arg, ':'); if (tmp == NULL \|\| tmp - arg > PASS_SOURCE_SIZE_MAX) BIO_printf(bio_err, "Invalid password argument, missing ':' within the first %d chars\n", PASS_SOURCE_SIZE_MAX + 1); else BIO_printf(bio_err, "Invalid password argument, starting with \"%.s\"\n", (int)(tmp - arg + 1), arg); return NULL; } } i = BIO_gets(pwdbio, tpass, APP_PASS_LEN); if (keepbio != 1) { BIO_free_all(pwdbio); pwdbio = NULL; } if (i <= 0) { BIO_printf(bio_err, "Error reading password from BIO\n"); return NULL; } tmp = strchr(tpass, '\n'); if (tmp != NULL) tmp = 0; return OPENSSL_strdup(tpass); } char app_conf_try_string(const CONF conf, const char group, const char name) { char res; ERR_set_mark(); res = NCONF_get_string(conf, group, name); if (res == NULL) ERR_pop_to_mark(); else ERR_clear_last_mark(); return res; } int app_conf_try_number(const CONF conf, const char group, const char name, long result) { int ok; ERR_set_mark(); ok = NCONF_get_number(conf, group, name, result); if (!ok) ERR_pop_to_mark(); else ERR_clear_last_mark(); return ok; } CONF app_load_config_bio(BIO in, const char filename) { long errorline = -1; CONF conf; int i; conf = NCONF_new_ex(app_get0_libctx(), NULL); i = NCONF_load_bio(conf, in, &errorline); if (i > 0) return conf; if (errorline <= 0) { BIO_printf(bio_err, "%s: Can't load ", opt_getprog()); } else { BIO_printf(bio_err, "%s: Error on line %ld of ", opt_getprog(), errorline); } if (filename != NULL) BIO_printf(bio_err, "config file \"%s\"\n", filename); else BIO_printf(bio_err, "config input"); NCONF_free(conf); return NULL; } CONF app_load_config_verbose(const char filename, int verbose) { if (verbose) { if (filename == '\0') BIO_printf(bio_err, "No configuration used\n"); else BIO_printf(bio_err, "Using configuration from %s\n", filename); } return app_load_config_internal(filename, 0); } CONF app_load_config_internal(const char filename, int quiet) { BIO in; CONF conf; if (filename == NULL \|\| filename != '\0') { if ((in = bio_open_default_(filename, 'r', FORMAT_TEXT, quiet)) == NULL) return NULL; conf = app_load_config_bio(in, filename); BIO_free(in); } else { /* Return empty config if filename is empty string. / conf = NCONF_new_ex(app_get0_libctx(), NULL); } return conf; } int app_load_modules(const CONF config) { CONF to_free = NULL; if (config == NULL) config = to_free = app_load_config_quiet(default_config_file); if (config == NULL) return 1; if (CONF_modules_load(config, NULL, 0) <= 0) { BIO_printf(bio_err, "Error configuring OpenSSL modules\n"); ERR_print_errors(bio_err); NCONF_free(to_free); return 0; } NCONF_free(to_free); return 1; } int add_oid_section(CONF conf) { char p; STACK_OF(CONF_VALUE) sktmp; CONF_VALUE cnf; int i; if ((p = app_conf_try_string(conf, NULL, "oid_section")) == NULL) return 1; if ((sktmp = NCONF_get_section(conf, p)) == NULL) { BIO_printf(bio_err, "problem loading oid section %s\n", p); return 0; } for (i = 0; i < sk_CONF_VALUE_num(sktmp); i++) { cnf = sk_CONF_VALUE_value(sktmp, i); if (OBJ_create(cnf->value, cnf->name, cnf->name) == NID_undef) { BIO_printf(bio_err, "problem creating object %s=%s\n", cnf->name, cnf->value); return 0; } } return 1; } CONF app_load_config_modules(const char configfile) { CONF conf = NULL; if (configfile != NULL) { if ((conf = app_load_config_verbose(configfile, 1)) == NULL) return NULL; if (configfile != default_config_file && !app_load_modules(conf)) { NCONF_free(conf); conf = NULL; } } return conf; } #define IS_HTTP(uri) ((uri) != NULL && HAS_PREFIX(uri, OSSL_HTTP_PREFIX)) #define IS_HTTPS(uri) ((uri) != NULL && HAS_PREFIX(uri, OSSL_HTTPS_PREFIX)) X509 load_cert_pass(const char uri, int format, int maybe_stdin, const char pass, const char desc) { X509 cert = NULL; if (desc == NULL) desc = "certificate"; if (IS_HTTPS(uri)) { BIO_printf(bio_err, "Loading %s over HTTPS is unsupported\n", desc); } else if (IS_HTTP(uri)) { cert = X509_load_http(uri, NULL, NULL, 0 / timeout /); if (cert == NULL) { ERR_print_errors(bio_err); BIO_printf(bio_err, "Unable to load %s from %s\n", desc, uri); } } else { (void)load_key_certs_crls(uri, format, maybe_stdin, pass, desc, 0, NULL, NULL, NULL, &cert, NULL, NULL, NULL); } return cert; } X509_CRL load_crl(const char uri, int format, int maybe_stdin, const char desc) { X509_CRL crl = NULL; if (desc == NULL) desc = "CRL"; if (IS_HTTPS(uri)) { BIO_printf(bio_err, "Loading %s over HTTPS is unsupported\n", desc); } else if (IS_HTTP(uri)) { crl = X509_CRL_load_http(uri, NULL, NULL, 0 / timeout /); if (crl == NULL) { ERR_print_errors(bio_err); BIO_printf(bio_err, "Unable to load %s from %s\n", desc, uri); } } else { (void)load_key_certs_crls(uri, format, maybe_stdin, NULL, desc, 0, NULL, NULL, NULL, NULL, NULL, &crl, NULL); } return crl; } / Could be simplified if OSSL_STORE supported CSRs, see FR #15725 / X509_REQ load_csr(const char file, int format, const char desc) { X509_REQ req = NULL; BIO in; if (format == FORMAT_UNDEF) format = FORMAT_PEM; in = bio_open_default(file, 'r', format); if (in == NULL) goto end; if (format == FORMAT_ASN1) req = d2i_X509_REQ_bio(in, NULL); else if (format == FORMAT_PEM) req = PEM_read_bio_X509_REQ(in, NULL, NULL, NULL); else print_format_error(format, OPT_FMT_PEMDER); end: if (req == NULL) { ERR_print_errors(bio_err); if (desc != NULL) BIO_printf(bio_err, "Unable to load %s\n", desc); } BIO_free(in); return req; } /* Better extend OSSL_STORE to support CSRs, see FR #15725 / X509_REQ load_csr_autofmt(const char infile, int format, STACK_OF(OPENSSL_STRING) vfyopts, const char desc) { X509_REQ csr; if (format != FORMAT_UNDEF) { csr = load_csr(infile, format, desc); } else { /* try PEM, then DER / BIO bio_bak = bio_err; bio_err = NULL; /* do not show errors on more than one try / csr = load_csr(infile, FORMAT_PEM, NULL / desc /); bio_err = bio_bak; if (csr == NULL) { ERR_clear_error(); csr = load_csr(infile, FORMAT_ASN1, NULL / desc /); } if (csr == NULL) { BIO_printf(bio_err, "error: unable to load %s from file '%s'\n", desc, infile); } } if (csr != NULL) { EVP_PKEY pkey = X509_REQ_get0_pubkey(csr); int ret = do_X509_REQ_verify(csr, pkey, vfyopts); if (pkey == NULL \|\| ret < 0) BIO_puts(bio_err, "Warning: error while verifying CSR self-signature\n"); else if (ret == 0) BIO_puts(bio_err, "Warning: CSR self-signature does not match the contents\n"); return csr; } return csr; } void cleanse(char str) { if (str != NULL) OPENSSL_cleanse(str, strlen(str)); } void clear_free(char str) { if (str != NULL) OPENSSL_clear_free(str, strlen(str)); } EVP_PKEY load_key(const char uri, int format, int may_stdin, const char pass, ENGINE e, const char desc) { EVP_PKEY pkey = NULL; char allocated_uri = NULL; if (desc == NULL) desc = "private key"; if (format == FORMAT_ENGINE) uri = allocated_uri = make_engine_uri(e, uri, desc); (void)load_key_certs_crls(uri, format, may_stdin, pass, desc, 0, &pkey, NULL, NULL, NULL, NULL, NULL, NULL); OPENSSL_free(allocated_uri); return pkey; } / first try reading public key, on failure resort to loading private key / EVP_PKEY load_pubkey(const char uri, int format, int maybe_stdin, const char pass, ENGINE e, const char desc) { EVP_PKEY pkey = NULL; char allocated_uri = NULL; if (desc == NULL) desc = "public key"; if (format == FORMAT_ENGINE) uri = allocated_uri = make_engine_uri(e, uri, desc); (void)load_key_certs_crls(uri, format, maybe_stdin, pass, desc, 1, NULL, &pkey, NULL, NULL, NULL, NULL, NULL); if (pkey == NULL) (void)load_key_certs_crls(uri, format, maybe_stdin, pass, desc, 0, &pkey, NULL, NULL, NULL, NULL, NULL, NULL); OPENSSL_free(allocated_uri); return pkey; } EVP_PKEY load_keyparams_suppress(const char uri, int format, int maybe_stdin, const char keytype, const char desc, int suppress_decode_errors) { EVP_PKEY params = NULL; if (desc == NULL) desc = "key parameters"; (void)load_key_certs_crls(uri, format, maybe_stdin, NULL, desc, suppress_decode_errors, NULL, NULL, &params, NULL, NULL, NULL, NULL); if (params != NULL && keytype != NULL && !EVP_PKEY_is_a(params, keytype)) { ERR_print_errors(bio_err); BIO_printf(bio_err, "Unable to load %s from %s (unexpected parameters type)\n", desc, uri); EVP_PKEY_free(params); params = NULL; } return params; } EVP_PKEY load_keyparams(const char uri, int format, int maybe_stdin, const char keytype, const char desc) { return load_keyparams_suppress(uri, format, maybe_stdin, keytype, desc, 0); } void app_bail_out(char fmt, ...) { va_list args; va_start(args, fmt); BIO_vprintf(bio_err, fmt, args); va_end(args); ERR_print_errors(bio_err); exit(EXIT_FAILURE); } void app_malloc(size_t sz, const char what) { void vp = OPENSSL_malloc(sz); if (vp == NULL) app_bail_out("%s: Could not allocate %zu bytes for %s\n", opt_getprog(), sz, what); return vp; } char next_item(char opt) / in list separated by comma and/or space / { / advance to separator (comma or whitespace), if any / while (opt != ',' && !isspace(_UC(opt)) && opt != '\0') opt++; if (opt != '\0') { / terminate current item / opt++ = '\0'; /* skip over any whitespace after separator / while (isspace(_UC(opt))) opt++; } return opt == '\0' ? NULL : opt; / NULL indicates end of input / } static void warn_cert_msg(const char uri, X509 cert, const char msg) { char subj = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0); BIO_printf(bio_err, "Warning: certificate from '%s' with subject '%s' %s\n", uri, subj, msg); OPENSSL_free(subj); } static void warn_cert(const char uri, X509 cert, int warn_EE, X509_VERIFY_PARAM vpm) { uint32_t ex_flags = X509_get_extension_flags(cert); int res = X509_cmp_timeframe(vpm, X509_get0_notBefore(cert), X509_get0_notAfter(cert)); if (res != 0) warn_cert_msg(uri, cert, res > 0 ? "has expired" : "not yet valid"); if (warn_EE && (ex_flags & EXFLAG_V1) == 0 && (ex_flags & EXFLAG_CA) == 0) warn_cert_msg(uri, cert, "is not a CA cert"); } static void warn_certs(const char uri, STACK_OF(X509) certs, int warn_EE, X509_VERIFY_PARAM vpm) { int i; for (i = 0; i < sk_X509_num(certs); i++) warn_cert(uri, sk_X509_value(certs, i), warn_EE, vpm); } int load_cert_certs(const char uri, X509 pcert, STACK_OF(X509) pcerts, int exclude_http, const char pass, const char desc, X509_VERIFY_PARAM vpm) { int ret = 0; char pass_string; if (desc == NULL) desc = pcerts == NULL ? "certificate" : "certificates"; if (exclude_http && (HAS_CASE_PREFIX(uri, "http://") \|\| HAS_CASE_PREFIX(uri, "https://"))) { BIO_printf(bio_err, "error: HTTP retrieval not allowed for %s\n", desc); return ret; } pass_string = get_passwd(pass, desc); ret = load_key_certs_crls(uri, FORMAT_UNDEF, 0, pass_string, desc, 0, NULL, NULL, NULL, pcert, pcerts, NULL, NULL); clear_free(pass_string); if (ret) { if (pcert != NULL) warn_cert(uri, pcert, 0, vpm); if (pcerts != NULL) warn_certs(uri, pcerts, 1, vpm); } else { if (pcerts != NULL) { OSSL_STACK_OF_X509_free(pcerts); pcerts = NULL; } } return ret; } STACK_OF(X509) load_certs_multifile(char files, const char pass, const char desc, X509_VERIFY_PARAM vpm) { STACK_OF(X509) certs = NULL; STACK_OF(X509) result = sk_X509_new_null(); if (files == NULL) goto err; if (result == NULL) goto oom; while (files != NULL) { char next = next_item(files); if (!load_cert_certs(files, NULL, &certs, 0, pass, desc, vpm)) goto err; if (!X509_add_certs(result, certs, X509_ADD_FLAG_UP_REF \| X509_ADD_FLAG_NO_DUP)) goto oom; OSSL_STACK_OF_X509_free(certs); certs = NULL; files = next; } return result; oom: BIO_printf(bio_err, "out of memory\n"); err: OSSL_STACK_OF_X509_free(certs); OSSL_STACK_OF_X509_free(result); return NULL; } static X509_STORE sk_X509_to_store(X509_STORE store /* may be NULL /, const STACK_OF(X509) certs /* may NULL /) { int i; if (store == NULL) store = X509_STORE_new(); if (store == NULL) return NULL; for (i = 0; i < sk_X509_num(certs); i++) { if (!X509_STORE_add_cert(store, sk_X509_value(certs, i))) { X509_STORE_free(store); return NULL; } } return store; } / * Create cert store structure with certificates read from given file(s). * Returns pointer to created X509_STORE on success, NULL on error. / X509_STORE load_certstore(char input, const char pass, const char desc, X509_VERIFY_PARAM vpm) { X509_STORE store = NULL; STACK_OF(X509) certs = NULL; while (input != NULL) { char next = next_item(input); int ok; if (!load_cert_certs(input, NULL, &certs, 1, pass, desc, vpm)) { X509_STORE_free(store); return NULL; } ok = (store = sk_X509_to_store(store, certs)) != NULL; OSSL_STACK_OF_X509_free(certs); certs = NULL; if (!ok) return NULL; input = next; } return store; } / * Initialize or extend, if certs != NULL, a certificate stack. The caller is responsible for freeing certs if its value is left not NULL. / int load_certs(const char uri, int maybe_stdin, STACK_OF(X509) certs, const char pass, const char desc) { int ret, was_NULL = certs == NULL; if (desc == NULL) desc = "certificates"; ret = load_key_certs_crls(uri, FORMAT_UNDEF, maybe_stdin, pass, desc, 0, NULL, NULL, NULL, NULL, certs, NULL, NULL); if (!ret && was_NULL) { OSSL_STACK_OF_X509_free(certs); certs = NULL; } return ret; } /* * Initialize or extend, if crls != NULL, a certificate stack. The caller is responsible for freeing crls if its value is left not NULL. / int load_crls(const char uri, STACK_OF(X509_CRL) crls, const char pass, const char desc) { int ret, was_NULL = crls == NULL; if (desc == NULL) desc = "CRLs"; ret = load_key_certs_crls(uri, FORMAT_UNDEF, 0, pass, desc, 0, NULL, NULL, NULL, NULL, NULL, NULL, crls); if (!ret && was_NULL) { sk_X509_CRL_pop_free(crls, X509_CRL_free); crls = NULL; } return ret; } static const char format2string(int format) { switch (format) { case FORMAT_PEM: return "PEM"; case FORMAT_ASN1: return "DER"; } return NULL; } / Set type expectation, but clear it if objects of different types expected. / #define SET_EXPECT(val) \ (expect = expect < 0 ? (val) : (expect == (val) ? (val) : 0)) #define SET_EXPECT1(pvar, val) \ if ((pvar) != NULL) { \ (pvar) = NULL; \ SET_EXPECT(val); \ } #define FAIL_NAME \ (ppkey != NULL ? "private key" : ppubkey != NULL ? "public key" : \ pparams != NULL ? "key parameters" : \ pcert != NULL ? "certificate" : pcerts != NULL ? "certificates" : \ pcrl != NULL ? "CRL" : pcrls != NULL ? "CRLs" : NULL) /* * Load those types of credentials for which the result pointer is not NULL. * Reads from stdio if uri is NULL and maybe_stdin is nonzero. * For non-NULL ppkey, pcert, and pcrl the first suitable value found is loaded. * If pcerts is non-NULL and pcerts == NULL then a new cert list is allocated. If pcerts is non-NULL then all available certificates are appended to pcerts except any certificate assigned to pcert. If pcrls is non-NULL and pcrls == NULL then a new list of CRLs is allocated. If pcrls is non-NULL then all available CRLs are appended to pcerts except any CRL assigned to pcrl. In any case (also on error) the caller is responsible for freeing all members * of pcerts and pcrls (as far as they are not NULL). / int load_key_certs_crls(const char uri, int format, int maybe_stdin, const char pass, const char desc, int quiet, EVP_PKEY ppkey, EVP_PKEY ppubkey, EVP_PKEY pparams, X509 pcert, STACK_OF(X509) pcerts, X509_CRL pcrl, STACK_OF(X509_CRL) *pcrls) { PW_CB_DATA uidata; OSSL_STORE_CTX ctx = NULL; OSSL_LIB_CTX libctx = app_get0_libctx(); const char propq = app_get0_propq(); int ncerts = 0, ncrls = 0, expect = -1; const char failed = FAIL_NAME; const char input_type; OSSL_PARAM itp[2]; const OSSL_PARAM params = NULL; if (failed == NULL) { if (!quiet) BIO_printf(bio_err, "Internal error: nothing to load from %s\n", uri != NULL ? uri : "<stdin>"); return 0; } ERR_set_mark(); SET_EXPECT1(ppkey, OSSL_STORE_INFO_PKEY); SET_EXPECT1(ppubkey, OSSL_STORE_INFO_PUBKEY); SET_EXPECT1(pparams, OSSL_STORE_INFO_PARAMS); SET_EXPECT1(pcert, OSSL_STORE_INFO_CERT); if (pcerts != NULL) { if (pcerts == NULL && (pcerts = sk_X509_new_null()) == NULL) { if (!quiet) BIO_printf(bio_err, "Out of memory loading"); goto end; } SET_EXPECT(OSSL_STORE_INFO_CERT); } SET_EXPECT1(pcrl, OSSL_STORE_INFO_CRL); if (pcrls != NULL) { if (pcrls == NULL && (pcrls = sk_X509_CRL_new_null()) == NULL) { if (!quiet) BIO_printf(bio_err, "Out of memory loading"); goto end; } SET_EXPECT(OSSL_STORE_INFO_CRL); } uidata.password = pass; uidata.prompt_info = uri; if ((input_type = format2string(format)) != NULL) { itp[0] = OSSL_PARAM_construct_utf8_string(OSSL_STORE_PARAM_INPUT_TYPE, (char )input_type, 0); itp[1] = OSSL_PARAM_construct_end(); params = itp; } if (uri == NULL) { BIO bio; if (!maybe_stdin) { if (!quiet) BIO_printf(bio_err, "No filename or uri specified for loading\n"); goto end; } uri = "<stdin>"; unbuffer(stdin); bio = BIO_new_fp(stdin, 0); if (bio != NULL) { ctx = OSSL_STORE_attach(bio, "file", libctx, propq, get_ui_method(), &uidata, params, NULL, NULL); BIO_free(bio); } } else { ctx = OSSL_STORE_open_ex(uri, libctx, propq, get_ui_method(), &uidata, params, NULL, NULL); } if (ctx == NULL) { if (!quiet) BIO_printf(bio_err, "Could not open file or uri for loading"); goto end; } if (expect > 0 && !OSSL_STORE_expect(ctx, expect)) { if (!quiet) BIO_printf(bio_err, "Internal error trying to load"); goto end; } failed = NULL; while ((ppkey != NULL \|\| ppubkey != NULL \|\| pparams != NULL \|\| pcert != NULL \|\| pcerts != NULL \|\| pcrl != NULL \|\| pcrls != NULL) && !OSSL_STORE_eof(ctx)) { OSSL_STORE_INFO info = OSSL_STORE_load(ctx); int type, ok = 1; /* * This can happen (for example) if we attempt to load a file with * multiple different types of things in it - but the thing we just * tried to load wasn't one of the ones we wanted, e.g. if we're trying * to load a certificate but the file has both the private key and the * certificate in it. We just retry until eof. / if (info == NULL) { continue; } type = OSSL_STORE_INFO_get_type(info); switch (type) { case OSSL_STORE_INFO_PKEY: if (ppkey != NULL) { ok = (ppkey = OSSL_STORE_INFO_get1_PKEY(info)) != NULL; if (ok) ppkey = NULL; break; } /* * An EVP_PKEY with private parts also holds the public parts, * so if the caller asked for a public key, and we got a private * key, we can still pass it back. / / fall through / case OSSL_STORE_INFO_PUBKEY: if (ppubkey != NULL) { ok = (ppubkey = OSSL_STORE_INFO_get1_PUBKEY(info)) != NULL; if (ok) ppubkey = NULL; } break; case OSSL_STORE_INFO_PARAMS: if (pparams != NULL) { ok = (pparams = OSSL_STORE_INFO_get1_PARAMS(info)) != NULL; if (ok) pparams = NULL; } break; case OSSL_STORE_INFO_CERT: if (pcert != NULL) { ok = (pcert = OSSL_STORE_INFO_get1_CERT(info)) != NULL; if (ok) pcert = NULL; } else if (pcerts != NULL) { ok = X509_add_cert(pcerts, OSSL_STORE_INFO_get1_CERT(info), X509_ADD_FLAG_DEFAULT); } ncerts += ok; break; case OSSL_STORE_INFO_CRL: if (pcrl != NULL) { ok = (pcrl = OSSL_STORE_INFO_get1_CRL(info)) != NULL; if (ok) pcrl = NULL; } else if (pcrls != NULL) { ok = sk_X509_CRL_push(pcrls, OSSL_STORE_INFO_get1_CRL(info)); } ncrls += ok; break; default: / skip any other type / break; } OSSL_STORE_INFO_free(info); if (!ok) { failed = OSSL_STORE_INFO_type_string(type); if (!quiet) BIO_printf(bio_err, "Error reading"); break; } } end: OSSL_STORE_close(ctx); if (ncerts > 0) pcerts = NULL; if (ncrls > 0) pcrls = NULL; if (failed == NULL) { failed = FAIL_NAME; if (failed != NULL && !quiet) BIO_printf(bio_err, "Could not find"); } if (failed != NULL && !quiet) { unsigned long err = ERR_peek_last_error(); if (desc != NULL && strstr(desc, failed) != NULL) { BIO_printf(bio_err, " %s", desc); } else { BIO_printf(bio_err, " %s", failed); if (desc != NULL) BIO_printf(bio_err, " of %s", desc); } if (uri != NULL) BIO_printf(bio_err, " from %s", uri); if (ERR_SYSTEM_ERROR(err)) { / provide more readable diagnostic output / BIO_printf(bio_err, ": %s", strerror(ERR_GET_REASON(err))); ERR_pop_to_mark(); ERR_set_mark(); } BIO_printf(bio_err, "\n"); ERR_print_errors(bio_err); } if (quiet \|\| failed == NULL) / clear any suppressed or spurious errors / ERR_pop_to_mark(); else ERR_clear_last_mark(); return failed == NULL; } #define X509V3_EXT_UNKNOWN_MASK (0xfL << 16) #define X509V3_EXT_DEFAULT 0 / Return error for unknown exts / #define X509V3_EXT_ERROR_UNKNOWN (1L << 16) / Print error for unknown exts / #define X509V3_EXT_PARSE_UNKNOWN (2L << 16) / ASN1 parse unknown extensions / #define X509V3_EXT_DUMP_UNKNOWN (3L << 16) / BIO_dump unknown extensions / #define X509_FLAG_CA (X509_FLAG_NO_ISSUER \| X509_FLAG_NO_PUBKEY \| \ X509_FLAG_NO_HEADER \| X509_FLAG_NO_VERSION) int set_cert_ex(unsigned long flags, const char arg) { static const NAME_EX_TBL cert_tbl[] = { {"compatible", X509_FLAG_COMPAT, 0xffffffffl}, {"ca_default", X509_FLAG_CA, 0xffffffffl}, {"no_header", X509_FLAG_NO_HEADER, 0}, {"no_version", X509_FLAG_NO_VERSION, 0}, {"no_serial", X509_FLAG_NO_SERIAL, 0}, {"no_signame", X509_FLAG_NO_SIGNAME, 0}, {"no_validity", X509_FLAG_NO_VALIDITY, 0}, {"no_subject", X509_FLAG_NO_SUBJECT, 0}, {"no_issuer", X509_FLAG_NO_ISSUER, 0}, {"no_pubkey", X509_FLAG_NO_PUBKEY, 0}, {"no_extensions", X509_FLAG_NO_EXTENSIONS, 0}, {"no_sigdump", X509_FLAG_NO_SIGDUMP, 0}, {"no_aux", X509_FLAG_NO_AUX, 0}, {"no_attributes", X509_FLAG_NO_ATTRIBUTES, 0}, {"ext_default", X509V3_EXT_DEFAULT, X509V3_EXT_UNKNOWN_MASK}, {"ext_error", X509V3_EXT_ERROR_UNKNOWN, X509V3_EXT_UNKNOWN_MASK}, {"ext_parse", X509V3_EXT_PARSE_UNKNOWN, X509V3_EXT_UNKNOWN_MASK}, {"ext_dump", X509V3_EXT_DUMP_UNKNOWN, X509V3_EXT_UNKNOWN_MASK}, {NULL, 0, 0} }; return set_multi_opts(flags, arg, cert_tbl); } int set_name_ex(unsigned long flags, const char arg) { static const NAME_EX_TBL ex_tbl[] = { {"esc_2253", ASN1_STRFLGS_ESC_2253, 0}, {"esc_2254", ASN1_STRFLGS_ESC_2254, 0}, {"esc_ctrl", ASN1_STRFLGS_ESC_CTRL, 0}, {"esc_msb", ASN1_STRFLGS_ESC_MSB, 0}, {"use_quote", ASN1_STRFLGS_ESC_QUOTE, 0}, {"utf8", ASN1_STRFLGS_UTF8_CONVERT, 0}, {"ignore_type", ASN1_STRFLGS_IGNORE_TYPE, 0}, {"show_type", ASN1_STRFLGS_SHOW_TYPE, 0}, {"dump_all", ASN1_STRFLGS_DUMP_ALL, 0}, {"dump_nostr", ASN1_STRFLGS_DUMP_UNKNOWN, 0}, {"dump_der", ASN1_STRFLGS_DUMP_DER, 0}, {"compat", XN_FLAG_COMPAT, 0xffffffffL}, {"sep_comma_plus", XN_FLAG_SEP_COMMA_PLUS, XN_FLAG_SEP_MASK}, {"sep_comma_plus_space", XN_FLAG_SEP_CPLUS_SPC, XN_FLAG_SEP_MASK}, {"sep_semi_plus_space", XN_FLAG_SEP_SPLUS_SPC, XN_FLAG_SEP_MASK}, {"sep_multiline", XN_FLAG_SEP_MULTILINE, XN_FLAG_SEP_MASK}, {"dn_rev", XN_FLAG_DN_REV, 0}, {"nofname", XN_FLAG_FN_NONE, XN_FLAG_FN_MASK}, {"sname", XN_FLAG_FN_SN, XN_FLAG_FN_MASK}, {"lname", XN_FLAG_FN_LN, XN_FLAG_FN_MASK}, {"align", XN_FLAG_FN_ALIGN, 0}, {"oid", XN_FLAG_FN_OID, XN_FLAG_FN_MASK}, {"space_eq", XN_FLAG_SPC_EQ, 0}, {"dump_unknown", XN_FLAG_DUMP_UNKNOWN_FIELDS, 0}, {"RFC2253", XN_FLAG_RFC2253, 0xffffffffL}, {"oneline", XN_FLAG_ONELINE, 0xffffffffL}, {"multiline", XN_FLAG_MULTILINE, 0xffffffffL}, {"ca_default", XN_FLAG_MULTILINE, 0xffffffffL}, {NULL, 0, 0} }; if (set_multi_opts(flags, arg, ex_tbl) == 0) return 0; if (flags != XN_FLAG_COMPAT && (flags & XN_FLAG_SEP_MASK) == 0) flags \|= XN_FLAG_SEP_CPLUS_SPC; return 1; } int set_dateopt(unsigned long dateopt, const char arg) { if (OPENSSL_strcasecmp(arg, "rfc_822") == 0) dateopt = ASN1_DTFLGS_RFC822; else if (OPENSSL_strcasecmp(arg, "iso_8601") == 0) dateopt = ASN1_DTFLGS_ISO8601; else return 0; return 1; } int set_ext_copy(int copy_type, const char arg) { if (OPENSSL_strcasecmp(arg, "none") == 0) copy_type = EXT_COPY_NONE; else if (OPENSSL_strcasecmp(arg, "copy") == 0) copy_type = EXT_COPY_ADD; else if (OPENSSL_strcasecmp(arg, "copyall") == 0) copy_type = EXT_COPY_ALL; else return 0; return 1; } int copy_extensions(X509 x, X509_REQ req, int copy_type) { STACK_OF(X509_EXTENSION) exts; int i, ret = 0; if (x == NULL \|\| req == NULL) return 0; if (copy_type == EXT_COPY_NONE) return 1; exts = X509_REQ_get_extensions(req); for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) { X509_EXTENSION ext = sk_X509_EXTENSION_value(exts, i); ASN1_OBJECT obj = X509_EXTENSION_get_object(ext); int idx = X509_get_ext_by_OBJ(x, obj, -1); /* Does extension exist in target? / if (idx != -1) { / If normal copy don't override existing extension / if (copy_type == EXT_COPY_ADD) continue; / Delete all extensions of same type / do { X509_EXTENSION_free(X509_delete_ext(x, idx)); idx = X509_get_ext_by_OBJ(x, obj, -1); } while (idx != -1); } if (!X509_add_ext(x, ext, -1)) goto end; } ret = 1; end: sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free); return ret; } static int set_multi_opts(unsigned long flags, const char arg, const NAME_EX_TBL in_tbl) { STACK_OF(CONF_VALUE) vals; CONF_VALUE val; int i, ret = 1; if (!arg) return 0; vals = X509V3_parse_list(arg); for (i = 0; i < sk_CONF_VALUE_num(vals); i++) { val = sk_CONF_VALUE_value(vals, i); if (!set_table_opts(flags, val->name, in_tbl)) ret = 0; } sk_CONF_VALUE_pop_free(vals, X509V3_conf_free); return ret; } static int set_table_opts(unsigned long flags, const char arg, const NAME_EX_TBL in_tbl) { char c; const NAME_EX_TBL ptbl; c = arg[0]; if (c == '-') { c = 0; arg++; } else if (c == '+') { c = 1; arg++; } else { c = 1; } for (ptbl = in_tbl; ptbl->name; ptbl++) { if (OPENSSL_strcasecmp(arg, ptbl->name) == 0) { flags &= ~ptbl->mask; if (c) flags \|= ptbl->flag; else flags &= ~ptbl->flag; return 1; } } return 0; } void print_name(BIO out, const char title, const X509_NAME nm) { char buf; char mline = 0; int indent = 0; unsigned long lflags = get_nameopt(); if (out == NULL) return; if (title != NULL) BIO_puts(out, title); if ((lflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) { mline = 1; indent = 4; } if (lflags == XN_FLAG_COMPAT) { buf = X509_NAME_oneline(nm, 0, 0); BIO_puts(out, buf); BIO_puts(out, "\n"); OPENSSL_free(buf); } else { if (mline) BIO_puts(out, "\n"); X509_NAME_print_ex(out, nm, indent, lflags); BIO_puts(out, "\n"); } } void print_bignum_var(BIO out, const BIGNUM in, const char var, int len, unsigned char buffer) { BIO_printf(out, " static unsigned char %s_%d[] = {", var, len); if (BN_is_zero(in)) { BIO_printf(out, "\n 0x00"); } else { int i, l; l = BN_bn2bin(in, buffer); for (i = 0; i < l; i++) { BIO_printf(out, (i % 10) == 0 ? "\n " : " "); if (i < l - 1) BIO_printf(out, "0x%02X,", buffer[i]); else BIO_printf(out, "0x%02X", buffer[i]); } } BIO_printf(out, "\n };\n"); } void print_array(BIO out, const char title, int len, const unsigned char d) { int i; BIO_printf(out, "unsigned char %s[%d] = {", title, len); for (i = 0; i < len; i++) { if ((i % 10) == 0) BIO_printf(out, "\n "); if (i < len - 1) BIO_printf(out, "0x%02X, ", d[i]); else BIO_printf(out, "0x%02X", d[i]); } BIO_printf(out, "\n};\n"); } X509_STORE setup_verify(const char CAfile, int noCAfile, const char CApath, int noCApath, const char CAstore, int noCAstore) { X509_STORE store = X509_STORE_new(); X509_LOOKUP lookup; OSSL_LIB_CTX libctx = app_get0_libctx(); const char propq = app_get0_propq(); if (store == NULL) goto end; if (CAfile != NULL \|\| !noCAfile) { lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file()); if (lookup == NULL) goto end; if (CAfile != NULL) { if (X509_LOOKUP_load_file_ex(lookup, CAfile, X509_FILETYPE_PEM, libctx, propq) <= 0) { ERR_clear_error(); if (X509_LOOKUP_load_file_ex(lookup, CAfile, X509_FILETYPE_ASN1, libctx, propq) <= 0) { BIO_printf(bio_err, "Error loading file %s\n", CAfile); goto end; } } } else { X509_LOOKUP_load_file_ex(lookup, NULL, X509_FILETYPE_DEFAULT, libctx, propq); } } if (CApath != NULL \|\| !noCApath) { lookup = X509_STORE_add_lookup(store, X509_LOOKUP_hash_dir()); if (lookup == NULL) goto end; if (CApath != NULL) { if (X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM) <= 0) { BIO_printf(bio_err, "Error loading directory %s\n", CApath); goto end; } } else { X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT); } } if (CAstore != NULL \|\| !noCAstore) { lookup = X509_STORE_add_lookup(store, X509_LOOKUP_store()); if (lookup == NULL) goto end; if (!X509_LOOKUP_add_store_ex(lookup, CAstore, libctx, propq)) { if (CAstore != NULL) BIO_printf(bio_err, "Error loading store URI %s\n", CAstore); goto end; } } ERR_clear_error(); return store; end: ERR_print_errors(bio_err); X509_STORE_free(store); return NULL; } static unsigned long index_serial_hash(const OPENSSL_CSTRING a) { const char n; n = a[DB_serial]; while (n == '0') n++; return OPENSSL_LH_strhash(n); } static int index_serial_cmp(const OPENSSL_CSTRING a, const OPENSSL_CSTRING b) { const char aa, bb; for (aa = a[DB_serial]; aa == '0'; aa++) ; for (bb = b[DB_serial]; bb == '0'; bb++) ; return strcmp(aa, bb); } static int index_name_qual(char a) { return (a[0][0] == 'V'); } static unsigned long index_name_hash(const OPENSSL_CSTRING a) { return OPENSSL_LH_strhash(a[DB_name]); } int index_name_cmp(const OPENSSL_CSTRING a, const OPENSSL_CSTRING b) { return strcmp(a[DB_name], b[DB_name]); } static IMPLEMENT_LHASH_HASH_FN(index_serial, OPENSSL_CSTRING) static IMPLEMENT_LHASH_COMP_FN(index_serial, OPENSSL_CSTRING) static IMPLEMENT_LHASH_HASH_FN(index_name, OPENSSL_CSTRING) static IMPLEMENT_LHASH_COMP_FN(index_name, OPENSSL_CSTRING) #undef BSIZE #define BSIZE 256 BIGNUM load_serial(const char serialfile, int exists, int create, ASN1_INTEGER retai) { BIO in = NULL; BIGNUM ret = NULL; char buf[1024]; ASN1_INTEGER ai = NULL; ai = ASN1_INTEGER_new(); if (ai == NULL) goto err; in = BIO_new_file(serialfile, "r"); if (exists != NULL) exists = in != NULL; if (in == NULL) { if (!create) { perror(serialfile); goto err; } ERR_clear_error(); ret = BN_new(); if (ret == NULL) { BIO_printf(bio_err, "Out of memory\n"); } else if (!rand_serial(ret, ai)) { BIO_printf(bio_err, "Error creating random number to store in %s\n", serialfile); BN_free(ret); ret = NULL; } } else { if (!a2i_ASN1_INTEGER(in, ai, buf, 1024)) { BIO_printf(bio_err, "Unable to load number from %s\n", serialfile); goto err; } ret = ASN1_INTEGER_to_BN(ai, NULL); if (ret == NULL) { BIO_printf(bio_err, "Error converting number from bin to BIGNUM\n"); goto err; } } if (ret != NULL && retai != NULL) { retai = ai; ai = NULL; } err: if (ret == NULL) ERR_print_errors(bio_err); BIO_free(in); ASN1_INTEGER_free(ai); return ret; } int save_serial(const char serialfile, const char suffix, const BIGNUM serial, ASN1_INTEGER retai) { char buf[1][BSIZE]; BIO out = NULL; int ret = 0; ASN1_INTEGER ai = NULL; int j; if (suffix == NULL) j = strlen(serialfile); else j = strlen(serialfile) + strlen(suffix) + 1; if (j >= BSIZE) { BIO_printf(bio_err, "File name too long\n"); goto err; } if (suffix == NULL) { OPENSSL_strlcpy(buf[0], serialfile, BSIZE); } else { #ifndef OPENSSL_SYS_VMS j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s.%s", serialfile, suffix); #else j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s-%s", serialfile, suffix); #endif } out = BIO_new_file(buf[0], "w"); if (out == NULL) { goto err; } if ((ai = BN_to_ASN1_INTEGER(serial, NULL)) == NULL) { BIO_printf(bio_err, "error converting serial to ASN.1 format\n"); goto err; } i2a_ASN1_INTEGER(out, ai); BIO_puts(out, "\n"); ret = 1; if (retai) { retai = ai; ai = NULL; } err: if (!ret) ERR_print_errors(bio_err); BIO_free_all(out); ASN1_INTEGER_free(ai); return ret; } int rotate_serial(const char serialfile, const char new_suffix, const char old_suffix) { char buf[2][BSIZE]; int i, j; i = strlen(serialfile) + strlen(old_suffix); j = strlen(serialfile) + strlen(new_suffix); if (i > j) j = i; if (j + 1 >= BSIZE) { BIO_printf(bio_err, "File name too long\n"); goto err; } #ifndef OPENSSL_SYS_VMS j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s.%s", serialfile, new_suffix); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s.%s", serialfile, old_suffix); #else j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s-%s", serialfile, new_suffix); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s-%s", serialfile, old_suffix); #endif if (rename(serialfile, buf[1]) < 0 && errno != ENOENT #ifdef ENOTDIR && errno != ENOTDIR #endif ) { BIO_printf(bio_err, "Unable to rename %s to %s\n", serialfile, buf[1]); perror("reason"); goto err; } if (rename(buf[0], serialfile) < 0) { BIO_printf(bio_err, "Unable to rename %s to %s\n", buf[0], serialfile); perror("reason"); rename(buf[1], serialfile); goto err; } return 1; err: ERR_print_errors(bio_err); return 0; } int rand_serial(BIGNUM b, ASN1_INTEGER ai) { BIGNUM btmp; int ret = 0; btmp = b == NULL ? BN_new() : b; if (btmp == NULL) return 0; if (!BN_rand(btmp, SERIAL_RAND_BITS, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY)) goto error; if (ai && !BN_to_ASN1_INTEGER(btmp, ai)) goto error; ret = 1; error: if (btmp != b) BN_free(btmp); return ret; } CA_DB load_index(const char dbfile, DB_ATTR db_attr) { CA_DB retdb = NULL; TXT_DB tmpdb = NULL; BIO in; CONF dbattr_conf = NULL; char buf[BSIZE]; #ifndef OPENSSL_NO_POSIX_IO FILE dbfp; struct stat dbst; #endif in = BIO_new_file(dbfile, "r"); if (in == NULL) goto err; #ifndef OPENSSL_NO_POSIX_IO BIO_get_fp(in, &dbfp); if (fstat(fileno(dbfp), &dbst) == -1) { ERR_raise_data(ERR_LIB_SYS, errno, "calling fstat(%s)", dbfile); goto err; } #endif if ((tmpdb = TXT_DB_read(in, DB_NUMBER)) == NULL) goto err; #ifndef OPENSSL_SYS_VMS BIO_snprintf(buf, sizeof(buf), "%s.attr", dbfile); #else BIO_snprintf(buf, sizeof(buf), "%s-attr", dbfile); #endif dbattr_conf = app_load_config_quiet(buf); retdb = app_malloc(sizeof(retdb), "new DB"); retdb->db = tmpdb; tmpdb = NULL; if (db_attr) retdb->attributes = db_attr; else retdb->attributes.unique_subject = 1; if (dbattr_conf != NULL) { char p = app_conf_try_string(dbattr_conf, NULL, "unique_subject"); if (p != NULL) retdb->attributes.unique_subject = parse_yesno(p, 1); } retdb->dbfname = OPENSSL_strdup(dbfile); #ifndef OPENSSL_NO_POSIX_IO retdb->dbst = dbst; #endif err: ERR_print_errors(bio_err); NCONF_free(dbattr_conf); TXT_DB_free(tmpdb); BIO_free_all(in); return retdb; } / * Returns > 0 on success, <= 0 on error / int index_index(CA_DB db) { if (!TXT_DB_create_index(db->db, DB_serial, NULL, LHASH_HASH_FN(index_serial), LHASH_COMP_FN(index_serial))) { BIO_printf(bio_err, "Error creating serial number index:(%ld,%ld,%ld)\n", db->db->error, db->db->arg1, db->db->arg2); goto err; } if (db->attributes.unique_subject && !TXT_DB_create_index(db->db, DB_name, index_name_qual, LHASH_HASH_FN(index_name), LHASH_COMP_FN(index_name))) { BIO_printf(bio_err, "Error creating name index:(%ld,%ld,%ld)\n", db->db->error, db->db->arg1, db->db->arg2); goto err; } return 1; err: ERR_print_errors(bio_err); return 0; } int save_index(const char dbfile, const char suffix, CA_DB db) { char buf[3][BSIZE]; BIO out; int j; j = strlen(dbfile) + strlen(suffix); if (j + 6 >= BSIZE) { BIO_printf(bio_err, "File name too long\n"); goto err; } #ifndef OPENSSL_SYS_VMS j = BIO_snprintf(buf[2], sizeof(buf[2]), "%s.attr", dbfile); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s.attr.%s", dbfile, suffix); j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s.%s", dbfile, suffix); #else j = BIO_snprintf(buf[2], sizeof(buf[2]), "%s-attr", dbfile); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s-attr-%s", dbfile, suffix); j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s-%s", dbfile, suffix); #endif out = BIO_new_file(buf[0], "w"); if (out == NULL) { perror(dbfile); BIO_printf(bio_err, "Unable to open '%s'\n", dbfile); goto err; } j = TXT_DB_write(out, db->db); BIO_free(out); if (j <= 0) goto err; out = BIO_new_file(buf[1], "w"); if (out == NULL) { perror(buf[2]); BIO_printf(bio_err, "Unable to open '%s'\n", buf[2]); goto err; } BIO_printf(out, "unique_subject = %s\n", db->attributes.unique_subject ? "yes" : "no"); BIO_free(out); return 1; err: ERR_print_errors(bio_err); return 0; } int rotate_index(const char dbfile, const char new_suffix, const char old_suffix) { char buf[5][BSIZE]; int i, j; i = strlen(dbfile) + strlen(old_suffix); j = strlen(dbfile) + strlen(new_suffix); if (i > j) j = i; if (j + 6 >= BSIZE) { BIO_printf(bio_err, "File name too long\n"); goto err; } #ifndef OPENSSL_SYS_VMS j = BIO_snprintf(buf[4], sizeof(buf[4]), "%s.attr", dbfile); j = BIO_snprintf(buf[3], sizeof(buf[3]), "%s.attr.%s", dbfile, old_suffix); j = BIO_snprintf(buf[2], sizeof(buf[2]), "%s.attr.%s", dbfile, new_suffix); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s.%s", dbfile, old_suffix); j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s.%s", dbfile, new_suffix); #else j = BIO_snprintf(buf[4], sizeof(buf[4]), "%s-attr", dbfile); j = BIO_snprintf(buf[3], sizeof(buf[3]), "%s-attr-%s", dbfile, old_suffix); j = BIO_snprintf(buf[2], sizeof(buf[2]), "%s-attr-%s", dbfile, new_suffix); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s-%s", dbfile, old_suffix); j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s-%s", dbfile, new_suffix); #endif if (rename(dbfile, buf[1]) < 0 && errno != ENOENT #ifdef ENOTDIR && errno != ENOTDIR #endif ) { BIO_printf(bio_err, "Unable to rename %s to %s\n", dbfile, buf[1]); perror("reason"); goto err; } if (rename(buf[0], dbfile) < 0) { BIO_printf(bio_err, "Unable to rename %s to %s\n", buf[0], dbfile); perror("reason"); rename(buf[1], dbfile); goto err; } if (rename(buf[4], buf[3]) < 0 && errno != ENOENT #ifdef ENOTDIR && errno != ENOTDIR #endif ) { BIO_printf(bio_err, "Unable to rename %s to %s\n", buf[4], buf[3]); perror("reason"); rename(dbfile, buf[0]); rename(buf[1], dbfile); goto err; } if (rename(buf[2], buf[4]) < 0) { BIO_printf(bio_err, "Unable to rename %s to %s\n", buf[2], buf[4]); perror("reason"); rename(buf[3], buf[4]); rename(dbfile, buf[0]); rename(buf[1], dbfile); goto err; } return 1; err: ERR_print_errors(bio_err); return 0; } void free_index(CA_DB db) { if (db) { TXT_DB_free(db->db); OPENSSL_free(db->dbfname); OPENSSL_free(db); } } int parse_yesno(const char str, int def) { if (str) { switch (str) { case 'f': /* false / case 'F': / FALSE / case 'n': / no / case 'N': / NO / case '0': / 0 / return 0; case 't': / true / case 'T': / TRUE / case 'y': / yes / case 'Y': / YES / case '1': / 1 / return 1; } } return def; } / * name is expected to be in the format /type0=value0/type1=value1/type2=... * where + can be used instead of / to form multi-valued RDNs if canmulti * and characters may be escaped by \ / X509_NAME parse_name(const char cp, int chtype, int canmulti, const char desc) { int nextismulti = 0; char work; X509_NAME n; if (cp++ != '/') { BIO_printf(bio_err, "%s: %s name is expected to be in the format " "/type0=value0/type1=value1/type2=... where characters may " "be escaped by \\. This name is not in that format: '%s'\n", opt_getprog(), desc, --cp); return NULL; } n = X509_NAME_new(); if (n == NULL) { BIO_printf(bio_err, "%s: Out of memory\n", opt_getprog()); return NULL; } work = OPENSSL_strdup(cp); if (work == NULL) { BIO_printf(bio_err, "%s: Error copying %s name input\n", opt_getprog(), desc); goto err; } while (cp != '\0') { char bp = work; char typestr = bp; unsigned char valstr; int nid; int ismulti = nextismulti; nextismulti = 0; / Collect the type / while (cp != '\0' && cp != '=') bp++ = cp++; bp++ = '\0'; if (cp == '\0') { BIO_printf(bio_err, "%s: Missing '=' after RDN type string '%s' in %s name string\n", opt_getprog(), typestr, desc); goto err; } ++cp; / Collect the value. / valstr = (unsigned char )bp; for (; cp != '\0' && cp != '/'; bp++ = cp++) { /* unescaped '+' symbol string signals further member of multiRDN / if (canmulti && cp == '+') { nextismulti = 1; break; } if (cp == '\\' && ++cp == '\0') { BIO_printf(bio_err, "%s: Escape character at end of %s name string\n", opt_getprog(), desc); goto err; } } bp++ = '\0'; / If not at EOS (must be + or /), move forward. / if (cp != '\0') ++cp; /* Parse / nid = OBJ_txt2nid(typestr); if (nid == NID_undef) { BIO_printf(bio_err, "%s warning: Skipping unknown %s name attribute \"%s\"\n", opt_getprog(), desc, typestr); if (ismulti) BIO_printf(bio_err, "%s hint: a '+' in a value string needs be escaped using '\\' else a new member of a multi-valued RDN is expected\n", opt_getprog()); continue; } if (valstr == '\0') { BIO_printf(bio_err, "%s warning: No value provided for %s name attribute \"%s\", skipped\n", opt_getprog(), desc, typestr); continue; } if (!X509_NAME_add_entry_by_NID(n, nid, chtype, valstr, strlen((char )valstr), -1, ismulti ? -1 : 0)) { ERR_print_errors(bio_err); BIO_printf(bio_err, "%s: Error adding %s name attribute \"/%s=%s\"\n", opt_getprog(), desc, typestr, valstr); goto err; } } OPENSSL_free(work); return n; err: X509_NAME_free(n); OPENSSL_free(work); return NULL; } / * Read whole contents of a BIO into an allocated memory buffer and return * it. / int bio_to_mem(unsigned char out, int maxlen, BIO in) { BIO mem; int len, ret; unsigned char tbuf[1024]; mem = BIO_new(BIO_s_mem()); if (mem == NULL) return -1; for (;;) { if ((maxlen != -1) && maxlen < 1024) len = maxlen; else len = 1024; len = BIO_read(in, tbuf, len); if (len < 0) { BIO_free(mem); return -1; } if (len == 0) break; if (BIO_write(mem, tbuf, len) != len) { BIO_free(mem); return -1; } if (maxlen != -1) maxlen -= len; if (maxlen == 0) break; } ret = BIO_get_mem_data(mem, (char )out); BIO_set_flags(mem, BIO_FLAGS_MEM_RDONLY); BIO_free(mem); return ret; } int pkey_ctrl_string(EVP_PKEY_CTX ctx, const char value) { int rv = 0; char stmp, vtmp = NULL; stmp = OPENSSL_strdup(value); if (stmp == NULL) return -1; vtmp = strchr(stmp, ':'); if (vtmp == NULL) goto err; vtmp = 0; vtmp++; rv = EVP_PKEY_CTX_ctrl_str(ctx, stmp, vtmp); err: OPENSSL_free(stmp); return rv; } static void nodes_print(const char name, STACK_OF(X509_POLICY_NODE) nodes) { X509_POLICY_NODE node; int i; BIO_printf(bio_err, "%s Policies:", name); if (nodes) { BIO_puts(bio_err, "\n"); for (i = 0; i < sk_X509_POLICY_NODE_num(nodes); i++) { node = sk_X509_POLICY_NODE_value(nodes, i); X509_POLICY_NODE_print(bio_err, node, 2); } } else { BIO_puts(bio_err, " <empty>\n"); } } void policies_print(X509_STORE_CTX ctx) { X509_POLICY_TREE tree; int explicit_policy; tree = X509_STORE_CTX_get0_policy_tree(ctx); explicit_policy = X509_STORE_CTX_get_explicit_policy(ctx); BIO_printf(bio_err, "Require explicit Policy: %s\n", explicit_policy ? "True" : "False"); nodes_print("Authority", X509_policy_tree_get0_policies(tree)); nodes_print("User", X509_policy_tree_get0_user_policies(tree)); } /- * next_protos_parse parses a comma separated list of strings into a string * in a format suitable for passing to SSL_CTX_set_next_protos_advertised. * outlen: (output) set to the length of the resulting buffer on success. * err: (maybe NULL) on failure, an error message line is written to this BIO. * in: a NUL terminated string like "abc,def,ghi" * * returns: a malloc'd buffer or NULL on failure. / unsigned char next_protos_parse(size_t outlen, const char in) { size_t len; unsigned char out; size_t i, start = 0; size_t skipped = 0; len = strlen(in); if (len == 0 \|\| len >= 65535) return NULL; out = app_malloc(len + 1, "NPN buffer"); for (i = 0; i <= len; ++i) { if (i == len \|\| in[i] == ',') { / * Zero-length ALPN elements are invalid on the wire, we could be * strict and reject the entire string, but just ignoring extra * commas seems harmless and more friendly. * * Every comma we skip in this way puts the input buffer another * byte ahead of the output buffer, so all stores into the output * buffer need to be decremented by the number commas skipped. / if (i == start) { ++start; ++skipped; continue; } if (i - start > 255) { OPENSSL_free(out); return NULL; } out[start - skipped] = (unsigned char)(i - start); start = i + 1; } else { out[i + 1 - skipped] = in[i]; } } if (len <= skipped) { OPENSSL_free(out); return NULL; } outlen = len + 1 - skipped; return out; } int check_cert_attributes(BIO bio, X509 x, const char checkhost, const char checkemail, const char checkip, int print) { int valid_host = 0; int valid_mail = 0; int valid_ip = 0; int ret = 1; if (x == NULL) return 0; if (checkhost != NULL) { valid_host = X509_check_host(x, checkhost, 0, 0, NULL); if (print) BIO_printf(bio, "Hostname %s does%s match certificate\n", checkhost, valid_host == 1 ? "" : " NOT"); ret = ret && valid_host; } if (checkemail != NULL) { valid_mail = X509_check_email(x, checkemail, 0, 0); if (print) BIO_printf(bio, "Email %s does%s match certificate\n", checkemail, valid_mail ? "" : " NOT"); ret = ret && valid_mail; } if (checkip != NULL) { valid_ip = X509_check_ip_asc(x, checkip, 0); if (print) BIO_printf(bio, "IP %s does%s match certificate\n", checkip, valid_ip ? "" : " NOT"); ret = ret && valid_ip; } return ret; } static int do_pkey_ctx_init(EVP_PKEY_CTX pkctx, STACK_OF(OPENSSL_STRING) opts) { int i; if (opts == NULL) return 1; for (i = 0; i < sk_OPENSSL_STRING_num(opts); i++) { char opt = sk_OPENSSL_STRING_value(opts, i); if (pkey_ctrl_string(pkctx, opt) <= 0) { BIO_printf(bio_err, "parameter error \"%s\"\n", opt); ERR_print_errors(bio_err); return 0; } } return 1; } static int do_x509_init(X509 x, STACK_OF(OPENSSL_STRING) opts) { int i; if (opts == NULL) return 1; for (i = 0; i < sk_OPENSSL_STRING_num(opts); i++) { char opt = sk_OPENSSL_STRING_value(opts, i); if (x509_ctrl_string(x, opt) <= 0) { BIO_printf(bio_err, "parameter error \"%s\"\n", opt); ERR_print_errors(bio_err); return 0; } } return 1; } static int do_x509_req_init(X509_REQ x, STACK_OF(OPENSSL_STRING) opts) { int i; if (opts == NULL) return 1; for (i = 0; i < sk_OPENSSL_STRING_num(opts); i++) { char opt = sk_OPENSSL_STRING_value(opts, i); if (x509_req_ctrl_string(x, opt) <= 0) { BIO_printf(bio_err, "parameter error \"%s\"\n", opt); ERR_print_errors(bio_err); return 0; } } return 1; } static int do_sign_init(EVP_MD_CTX ctx, EVP_PKEY pkey, const char md, STACK_OF(OPENSSL_STRING) sigopts) { EVP_PKEY_CTX pkctx = NULL; char def_md[80]; if (ctx == NULL) return 0; / * EVP_PKEY_get_default_digest_name() returns 2 if the digest is mandatory * for this algorithm. / if (EVP_PKEY_get_default_digest_name(pkey, def_md, sizeof(def_md)) == 2 && strcmp(def_md, "UNDEF") == 0) { / The signing algorithm requires there to be no digest / md = NULL; } return EVP_DigestSignInit_ex(ctx, &pkctx, md, app_get0_libctx(), app_get0_propq(), pkey, NULL) && do_pkey_ctx_init(pkctx, sigopts); } static int adapt_keyid_ext(X509 cert, X509V3_CTX ext_ctx, const char name, const char value, int add_default) { const STACK_OF(X509_EXTENSION) exts = X509_get0_extensions(cert); X509_EXTENSION new_ext = X509V3_EXT_nconf(NULL, ext_ctx, name, value); int idx, rv = 0; if (new_ext == NULL) return rv; idx = X509v3_get_ext_by_OBJ(exts, X509_EXTENSION_get_object(new_ext), -1); if (idx >= 0) { X509_EXTENSION found_ext = X509v3_get_ext(exts, idx); ASN1_OCTET_STRING encoded = X509_EXTENSION_get_data(found_ext); int disabled = ASN1_STRING_length(encoded) <= 2; / indicating "none" / if (disabled) { X509_delete_ext(cert, idx); X509_EXTENSION_free(found_ext); } / else keep existing key identifier, which might be outdated / rv = 1; } else { rv = !add_default \|\| X509_add_ext(cert, new_ext, -1); } X509_EXTENSION_free(new_ext); return rv; } int cert_matches_key(const X509 cert, const EVP_PKEY pkey) { int match; ERR_set_mark(); match = X509_check_private_key(cert, pkey); ERR_pop_to_mark(); return match; } / Ensure RFC 5280 compliance, adapt keyIDs as needed, and sign the cert info / int do_X509_sign(X509 cert, int force_v1, EVP_PKEY pkey, const char md, STACK_OF(OPENSSL_STRING) sigopts, X509V3_CTX ext_ctx) { EVP_MD_CTX mctx = EVP_MD_CTX_new(); int self_sign; int rv = 0; if (!force_v1) { if (!X509_set_version(cert, X509_VERSION_3)) goto end; / * Add default SKID before AKID such that AKID can make use of it * in case the certificate is self-signed / / Prevent X509_V_ERR_MISSING_SUBJECT_KEY_IDENTIFIER / if (!adapt_keyid_ext(cert, ext_ctx, "subjectKeyIdentifier", "hash", 1)) goto end; / Prevent X509_V_ERR_MISSING_AUTHORITY_KEY_IDENTIFIER / self_sign = cert_matches_key(cert, pkey); if (!adapt_keyid_ext(cert, ext_ctx, "authorityKeyIdentifier", "keyid, issuer", !self_sign)) goto end; } / May add further measures for ensuring RFC 5280 compliance, see #19805 / if (mctx != NULL && do_sign_init(mctx, pkey, md, sigopts) > 0) rv = (X509_sign_ctx(cert, mctx) > 0); end: EVP_MD_CTX_free(mctx); return rv; } / Sign the certificate request info / int do_X509_REQ_sign(X509_REQ x, EVP_PKEY pkey, const char md, STACK_OF(OPENSSL_STRING) sigopts) { int rv = 0; EVP_MD_CTX mctx = EVP_MD_CTX_new(); if (do_sign_init(mctx, pkey, md, sigopts) > 0) rv = (X509_REQ_sign_ctx(x, mctx) > 0); EVP_MD_CTX_free(mctx); return rv; } /* Sign the CRL info / int do_X509_CRL_sign(X509_CRL x, EVP_PKEY pkey, const char md, STACK_OF(OPENSSL_STRING) sigopts) { int rv = 0; EVP_MD_CTX mctx = EVP_MD_CTX_new(); if (do_sign_init(mctx, pkey, md, sigopts) > 0) rv = (X509_CRL_sign_ctx(x, mctx) > 0); EVP_MD_CTX_free(mctx); return rv; } /* * do_X509_verify returns 1 if the signature is valid, * 0 if the signature check fails, or -1 if error occurs. / int do_X509_verify(X509 x, EVP_PKEY pkey, STACK_OF(OPENSSL_STRING) vfyopts) { int rv = 0; if (do_x509_init(x, vfyopts) > 0) rv = X509_verify(x, pkey); else rv = -1; return rv; } /* * do_X509_REQ_verify returns 1 if the signature is valid, * 0 if the signature check fails, or -1 if error occurs. / int do_X509_REQ_verify(X509_REQ x, EVP_PKEY pkey, STACK_OF(OPENSSL_STRING) vfyopts) { int rv = 0; if (do_x509_req_init(x, vfyopts) > 0) rv = X509_REQ_verify_ex(x, pkey, app_get0_libctx(), app_get0_propq()); else rv = -1; return rv; } /* Get first http URL from a DIST_POINT structure / static const char get_dp_url(DIST_POINT dp) { GENERAL_NAMES gens; GENERAL_NAME gen; int i, gtype; ASN1_STRING uri; if (!dp->distpoint \|\| dp->distpoint->type != 0) return NULL; gens = dp->distpoint->name.fullname; for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) { gen = sk_GENERAL_NAME_value(gens, i); uri = GENERAL_NAME_get0_value(gen, &gtype); if (gtype == GEN_URI && ASN1_STRING_length(uri) > 6) { const char uptr = (const char )ASN1_STRING_get0_data(uri); if (IS_HTTP(uptr)) /* can/should not use HTTPS here / return uptr; } } return NULL; } / * Look through a CRLDP structure and attempt to find an http URL to * downloads a CRL from. / static X509_CRL load_crl_crldp(STACK_OF(DIST_POINT) crldp) { int i; const char urlptr = NULL; for (i = 0; i < sk_DIST_POINT_num(crldp); i++) { DIST_POINT dp = sk_DIST_POINT_value(crldp, i); urlptr = get_dp_url(dp); if (urlptr != NULL) return load_crl(urlptr, FORMAT_UNDEF, 0, "CRL via CDP"); } return NULL; } / * Example of downloading CRLs from CRLDP: * not usable for real world as it always downloads and doesn't cache anything. / static STACK_OF(X509_CRL) crls_http_cb(const X509_STORE_CTX ctx, const X509_NAME nm) { X509 x; STACK_OF(X509_CRL) crls = NULL; X509_CRL crl; STACK_OF(DIST_POINT) crldp; crls = sk_X509_CRL_new_null(); if (!crls) return NULL; x = X509_STORE_CTX_get_current_cert(ctx); crldp = X509_get_ext_d2i(x, NID_crl_distribution_points, NULL, NULL); crl = load_crl_crldp(crldp); sk_DIST_POINT_pop_free(crldp, DIST_POINT_free); if (!crl) { sk_X509_CRL_free(crls); return NULL; } sk_X509_CRL_push(crls, crl); /* Try to download delta CRL / crldp = X509_get_ext_d2i(x, NID_freshest_crl, NULL, NULL); crl = load_crl_crldp(crldp); sk_DIST_POINT_pop_free(crldp, DIST_POINT_free); if (crl) sk_X509_CRL_push(crls, crl); return crls; } void store_setup_crl_download(X509_STORE st) { X509_STORE_set_lookup_crls_cb(st, crls_http_cb); } #if !defined(OPENSSL_NO_SOCK) && !defined(OPENSSL_NO_HTTP) static const char tls_error_hint(void) { unsigned long err = ERR_peek_error(); if (ERR_GET_LIB(err) != ERR_LIB_SSL) err = ERR_peek_last_error(); if (ERR_GET_LIB(err) != ERR_LIB_SSL) return NULL; / likely no TLS error / switch (ERR_GET_REASON(err)) { case SSL_R_WRONG_VERSION_NUMBER: return "The server does not support (a suitable version of) TLS"; case SSL_R_UNKNOWN_PROTOCOL: return "The server does not support HTTPS"; case SSL_R_CERTIFICATE_VERIFY_FAILED: return "Cannot authenticate server via its TLS certificate, likely due to mismatch with our trusted TLS certs or missing revocation status"; case SSL_AD_REASON_OFFSET + TLS1_AD_UNKNOWN_CA: return "Server did not accept our TLS certificate, likely due to mismatch with server's trust anchor or missing revocation status"; case SSL_AD_REASON_OFFSET + SSL3_AD_HANDSHAKE_FAILURE: return "TLS handshake failure. Possibly the server requires our TLS certificate but did not receive it"; default: return NULL; / no hint available for TLS error / } } static BIO http_tls_shutdown(BIO bio) { if (bio != NULL) { BIO cbio; const char hint = tls_error_hint(); if (hint != NULL) BIO_printf(bio_err, "%s\n", hint); (void)ERR_set_mark(); BIO_ssl_shutdown(bio); cbio = BIO_pop(bio); / connect+HTTP BIO / BIO_free(bio); / SSL BIO / (void)ERR_pop_to_mark(); / hide SSL_R_READ_BIO_NOT_SET etc. / bio = cbio; } return bio; } / HTTP callback function that supports TLS connection also via HTTPS proxy / BIO app_http_tls_cb(BIO bio, void arg, int connect, int detail) { APP_HTTP_TLS_INFO info = (APP_HTTP_TLS_INFO )arg; SSL_CTX ssl_ctx = info->ssl_ctx; if (ssl_ctx == NULL) / not using TLS / return bio; if (connect) { SSL ssl; BIO sbio = NULL; X509_STORE ts = SSL_CTX_get_cert_store(ssl_ctx); X509_VERIFY_PARAM vpm = X509_STORE_get0_param(ts); const char host = vpm == NULL ? NULL : X509_VERIFY_PARAM_get0_host(vpm, 0 /* first hostname /); / adapt after fixing callback design flaw, see #17088 / if ((info->use_proxy && !OSSL_HTTP_proxy_connect(bio, info->server, info->port, NULL, NULL, / no proxy credentials / info->timeout, bio_err, opt_getprog())) \|\| (sbio = BIO_new(BIO_f_ssl())) == NULL) { return NULL; } if ((ssl = SSL_new(ssl_ctx)) == NULL) { BIO_free(sbio); return NULL; } if (vpm != NULL) SSL_set_tlsext_host_name(ssl, host / may be NULL /); SSL_set_connect_state(ssl); BIO_set_ssl(sbio, ssl, BIO_CLOSE); bio = BIO_push(sbio, bio); } else { / disconnect from TLS / bio = http_tls_shutdown(bio); } return bio; } void APP_HTTP_TLS_INFO_free(APP_HTTP_TLS_INFO info) { if (info != NULL) { SSL_CTX_free(info->ssl_ctx); OPENSSL_free(info); } } ASN1_VALUE app_http_get_asn1(const char url, const char proxy, const char no_proxy, SSL_CTX ssl_ctx, const STACK_OF(CONF_VALUE) headers, long timeout, const char expected_content_type, const ASN1_ITEM it) { APP_HTTP_TLS_INFO info; char server; char port; int use_ssl; BIO mem; ASN1_VALUE resp = NULL; if (url == NULL \|\| it == NULL) { ERR_raise(ERR_LIB_HTTP, ERR_R_PASSED_NULL_PARAMETER); return NULL; } if (!OSSL_HTTP_parse_url(url, &use_ssl, NULL /* userinfo /, &server, &port, NULL / port_num, /, NULL, NULL, NULL)) return NULL; if (use_ssl && ssl_ctx == NULL) { ERR_raise_data(ERR_LIB_HTTP, ERR_R_PASSED_NULL_PARAMETER, "missing SSL_CTX"); goto end; } if (!use_ssl && ssl_ctx != NULL) { ERR_raise_data(ERR_LIB_HTTP, ERR_R_PASSED_INVALID_ARGUMENT, "SSL_CTX given but use_ssl == 0"); goto end; } info.server = server; info.port = port; info.use_proxy = / workaround for callback design flaw, see #17088 / OSSL_HTTP_adapt_proxy(proxy, no_proxy, server, use_ssl) != NULL; info.timeout = timeout; info.ssl_ctx = ssl_ctx; mem = OSSL_HTTP_get(url, proxy, no_proxy, NULL / bio /, NULL / rbio /, app_http_tls_cb, &info, 0 / buf_size /, headers, expected_content_type, 1 / expect_asn1 /, OSSL_HTTP_DEFAULT_MAX_RESP_LEN, timeout); resp = ASN1_item_d2i_bio(it, mem, NULL); BIO_free(mem); end: OPENSSL_free(server); OPENSSL_free(port); return resp; } ASN1_VALUE app_http_post_asn1(const char host, const char port, const char path, const char proxy, const char no_proxy, SSL_CTX ssl_ctx, const STACK_OF(CONF_VALUE) headers, const char content_type, ASN1_VALUE req, const ASN1_ITEM req_it, const char expected_content_type, long timeout, const ASN1_ITEM rsp_it) { int use_ssl = ssl_ctx != NULL; APP_HTTP_TLS_INFO info; BIO rsp, req_mem = ASN1_item_i2d_mem_bio(req_it, req); ASN1_VALUE res; if (req_mem == NULL) return NULL; info.server = host; info.port = port; info.use_proxy = / workaround for callback design flaw, see #17088 / OSSL_HTTP_adapt_proxy(proxy, no_proxy, host, use_ssl) != NULL; info.timeout = timeout; info.ssl_ctx = ssl_ctx; rsp = OSSL_HTTP_transfer(NULL, host, port, path, use_ssl, proxy, no_proxy, NULL / bio /, NULL / rbio /, app_http_tls_cb, &info, 0 / buf_size /, headers, content_type, req_mem, expected_content_type, 1 / expect_asn1 /, OSSL_HTTP_DEFAULT_MAX_RESP_LEN, timeout, 0 / keep_alive /); BIO_free(req_mem); res = ASN1_item_d2i_bio(rsp_it, rsp, NULL); BIO_free(rsp); return res; } #endif / * Platform-specific sections / #if defined(_WIN32) # ifdef fileno # undef fileno # define fileno(a) (int)_fileno(a) # endif # include <windows.h> # include <tchar.h> static int WIN32_rename(const char from, const char to) { TCHAR tfrom = NULL, tto; DWORD err; int ret = 0; if (sizeof(TCHAR) == 1) { tfrom = (TCHAR )from; tto = (TCHAR )to; } else { / UNICODE path / size_t i, flen = strlen(from) + 1, tlen = strlen(to) + 1; tfrom = malloc(sizeof(tfrom) * (flen + tlen)); if (tfrom == NULL) goto err; tto = tfrom + flen; # if !defined(_WIN32_WCE) \|\| _WIN32_WCE >= 101 if (!MultiByteToWideChar(CP_ACP, 0, from, flen, (WCHAR )tfrom, flen)) # endif for (i = 0; i < flen; i++) tfrom[i] = (TCHAR)from[i]; # if !defined(_WIN32_WCE) \|\| _WIN32_WCE >= 101 if (!MultiByteToWideChar(CP_ACP, 0, to, tlen, (WCHAR )tto, tlen)) # endif for (i = 0; i < tlen; i++) tto[i] = (TCHAR)to[i]; } if (MoveFile(tfrom, tto)) goto ok; err = GetLastError(); if (err == ERROR_ALREADY_EXISTS \|\| err == ERROR_FILE_EXISTS) { if (DeleteFile(tto) && MoveFile(tfrom, tto)) goto ok; err = GetLastError(); } if (err == ERROR_FILE_NOT_FOUND \|\| err == ERROR_PATH_NOT_FOUND) errno = ENOENT; else if (err == ERROR_ACCESS_DENIED) errno = EACCES; else errno = EINVAL; /* we could map more codes... / err: ret = -1; ok: if (tfrom != NULL && tfrom != (TCHAR )from) free(tfrom); return ret; } #endif /* app_tminterval section / #if defined(_WIN32) double app_tminterval(int stop, int usertime) { FILETIME now; double ret = 0; static ULARGE_INTEGER tmstart; static int warning = 1; int use_GetSystemTime = 1; # ifdef _WIN32_WINNT static HANDLE proc = NULL; if (proc == NULL) { if (check_winnt()) proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId()); if (proc == NULL) proc = (HANDLE) - 1; } if (usertime && proc != (HANDLE) - 1) { FILETIME junk; GetProcessTimes(proc, &junk, &junk, &junk, &now); use_GetSystemTime = 0; } # endif if (use_GetSystemTime) { SYSTEMTIME systime; if (usertime && warning) { BIO_printf(bio_err, "To get meaningful results, run " "this program on idle system.\n"); warning = 0; } GetSystemTime(&systime); SystemTimeToFileTime(&systime, &now); } if (stop == TM_START) { tmstart.u.LowPart = now.dwLowDateTime; tmstart.u.HighPart = now.dwHighDateTime; } else { ULARGE_INTEGER tmstop; tmstop.u.LowPart = now.dwLowDateTime; tmstop.u.HighPart = now.dwHighDateTime; ret = (__int64)(tmstop.QuadPart - tmstart.QuadPart) 1e-7; } return ret; } #elif defined(OPENSSL_SYS_VXWORKS) # include <time.h> double app_tminterval(int stop, int usertime) { double ret = 0; # ifdef CLOCK_REALTIME static struct timespec tmstart; struct timespec now; # else static unsigned long tmstart; unsigned long now; # endif static int warning = 1; if (usertime && warning) { BIO_printf(bio_err, "To get meaningful results, run " "this program on idle system.\n"); warning = 0; } # ifdef CLOCK_REALTIME clock_gettime(CLOCK_REALTIME, &now); if (stop == TM_START) tmstart = now; else ret = ((now.tv_sec + now.tv_nsec * 1e-9) - (tmstart.tv_sec + tmstart.tv_nsec * 1e-9)); # else now = tickGet(); if (stop == TM_START) tmstart = now; else ret = (now - tmstart) / (double)sysClkRateGet(); # endif return ret; } #elif defined(_SC_CLK_TCK) /* by means of unistd.h / # include <sys/times.h> double app_tminterval(int stop, int usertime) { double ret = 0; struct tms rus; clock_t now = times(&rus); static clock_t tmstart; if (usertime) now = rus.tms_utime; if (stop == TM_START) { tmstart = now; } else { long int tck = sysconf(_SC_CLK_TCK); ret = (now - tmstart) / (double)tck; } return ret; } #else # include <sys/time.h> # include <sys/resource.h> double app_tminterval(int stop, int usertime) { double ret = 0; struct rusage rus; struct timeval now; static struct timeval tmstart; if (usertime) getrusage(RUSAGE_SELF, &rus), now = rus.ru_utime; else gettimeofday(&now, NULL); if (stop == TM_START) tmstart = now; else ret = ((now.tv_sec + now.tv_usec 1e-6) - (tmstart.tv_sec + tmstart.tv_usec * 1e-6)); return ret; } #endif int app_access(const char name, int flag) { #ifdef _WIN32 return _access(name, flag); #else return access(name, flag); #endif } int app_isdir(const char name) { return opt_isdir(name); } /* raw_read\|write section / #if defined(__VMS) # include "vms_term_sock.h" static int stdin_sock = -1; static void close_stdin_sock(void) { TerminalSocket(TERM_SOCK_DELETE, &stdin_sock); } int fileno_stdin(void) { if (stdin_sock == -1) { TerminalSocket(TERM_SOCK_CREATE, &stdin_sock); atexit(close_stdin_sock); } return stdin_sock; } #else int fileno_stdin(void) { return fileno(stdin); } #endif int fileno_stdout(void) { return fileno(stdout); } #if defined(_WIN32) && defined(STD_INPUT_HANDLE) int raw_read_stdin(void buf, int siz) { DWORD n; if (ReadFile(GetStdHandle(STD_INPUT_HANDLE), buf, siz, &n, NULL)) return n; else return -1; } #elif defined(__VMS) # include <sys/socket.h> int raw_read_stdin(void buf, int siz) { return recv(fileno_stdin(), buf, siz, 0); } #else # if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_read)> # endif # endif int raw_read_stdin(void buf, int siz) { return read(fileno_stdin(), buf, siz); } #endif #if defined(_WIN32) && defined(STD_OUTPUT_HANDLE) int raw_write_stdout(const void buf, int siz) { DWORD n; if (WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, siz, &n, NULL)) return n; else return -1; } #elif defined(OPENSSL_SYS_TANDEM) && defined(OPENSSL_THREADS) \ && defined(_SPT_MODEL_) # if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_write)> # endif # endif int raw_write_stdout(const void buf, int siz) { return write(fileno(stdout), (void )buf, siz); } #else # if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_write)> # endif # endif int raw_write_stdout(const void buf, int siz) { return write(fileno_stdout(), buf, siz); } #endif /* * Centralized handling of input and output files with format specification * The format is meant to show what the input and output is supposed to be, * and is therefore a show of intent more than anything else. However, it * does impact behavior on some platforms, such as differentiating between * text and binary input/output on non-Unix platforms / BIO dup_bio_in(int format) { return BIO_new_fp(stdin, BIO_NOCLOSE \| (FMT_istext(format) ? BIO_FP_TEXT : 0)); } BIO dup_bio_out(int format) { BIO b = BIO_new_fp(stdout, BIO_NOCLOSE \| (FMT_istext(format) ? BIO_FP_TEXT : 0)); void prefix = NULL; if (b == NULL) return NULL; #ifdef OPENSSL_SYS_VMS if (FMT_istext(format)) b = BIO_push(BIO_new(BIO_f_linebuffer()), b); #endif if (FMT_istext(format) && (prefix = getenv("HARNESS_OSSL_PREFIX")) != NULL) { b = BIO_push(BIO_new(BIO_f_prefix()), b); BIO_set_prefix(b, prefix); } return b; } BIO dup_bio_err(int format) { BIO b = BIO_new_fp(stderr, BIO_NOCLOSE \| (FMT_istext(format) ? BIO_FP_TEXT : 0)); #ifdef OPENSSL_SYS_VMS if (b != NULL && FMT_istext(format)) b = BIO_push(BIO_new(BIO_f_linebuffer()), b); #endif return b; } void unbuffer(FILE fp) { /* * On VMS, setbuf() will only take 32-bit pointers, and a compilation * with /POINTER_SIZE=64 will give off a MAYLOSEDATA2 warning here. * However, we trust that the C RTL will never give us a FILE pointer * above the first 4 GB of memory, so we simply turn off the warning * temporarily. / #if defined(OPENSSL_SYS_VMS) && defined(__DECC) # pragma environment save # pragma message disable maylosedata2 #endif setbuf(fp, NULL); #if defined(OPENSSL_SYS_VMS) && defined(__DECC) # pragma environment restore #endif } static const char modestr(char mode, int format) { OPENSSL_assert(mode == 'a' \|\| mode == 'r' \|\| mode == 'w'); switch (mode) { case 'a': return FMT_istext(format) ? "a" : "ab"; case 'r': return FMT_istext(format) ? "r" : "rb"; case 'w': return FMT_istext(format) ? "w" : "wb"; } /* The assert above should make sure we never reach this point / return NULL; } static const char modeverb(char mode) { switch (mode) { case 'a': return "appending"; case 'r': return "reading"; case 'w': return "writing"; } return "(doing something)"; } /* * Open a file for writing, owner-read-only. / BIO bio_open_owner(const char filename, int format, int private) { FILE fp = NULL; BIO b = NULL; int textmode, bflags; #ifndef OPENSSL_NO_POSIX_IO int fd = -1, mode; #endif if (!private \|\| filename == NULL \|\| strcmp(filename, "-") == 0) return bio_open_default(filename, 'w', format); textmode = FMT_istext(format); #ifndef OPENSSL_NO_POSIX_IO mode = O_WRONLY; # ifdef O_CREAT mode \|= O_CREAT; # endif # ifdef O_TRUNC mode \|= O_TRUNC; # endif if (!textmode) { # ifdef O_BINARY mode \|= O_BINARY; # elif defined(_O_BINARY) mode \|= _O_BINARY; # endif } # ifdef OPENSSL_SYS_VMS / * VMS doesn't have O_BINARY, it just doesn't make sense. But, * it still needs to know that we're going binary, or fdopen() * will fail with "invalid argument"... so we tell VMS what the * context is. / if (!textmode) fd = open(filename, mode, 0600, "ctx=bin"); else # endif fd = open(filename, mode, 0600); if (fd < 0) goto err; fp = fdopen(fd, modestr('w', format)); #else / OPENSSL_NO_POSIX_IO / / Have stdio but not Posix IO, do the best we can / fp = fopen(filename, modestr('w', format)); #endif / OPENSSL_NO_POSIX_IO / if (fp == NULL) goto err; bflags = BIO_CLOSE; if (textmode) bflags \|= BIO_FP_TEXT; b = BIO_new_fp(fp, bflags); if (b != NULL) return b; err: BIO_printf(bio_err, "%s: Can't open \"%s\" for writing, %s\n", opt_getprog(), filename, strerror(errno)); ERR_print_errors(bio_err); / If we have fp, then fdopen took over fd, so don't close both. / if (fp != NULL) fclose(fp); #ifndef OPENSSL_NO_POSIX_IO else if (fd >= 0) close(fd); #endif return NULL; } static BIO bio_open_default_(const char filename, char mode, int format, int quiet) { BIO ret; if (filename == NULL \|\| strcmp(filename, "-") == 0) { ret = mode == 'r' ? dup_bio_in(format) : dup_bio_out(format); if (quiet) { ERR_clear_error(); return ret; } if (ret != NULL) return ret; BIO_printf(bio_err, "Can't open %s, %s\n", mode == 'r' ? "stdin" : "stdout", strerror(errno)); } else { ret = BIO_new_file(filename, modestr(mode, format)); if (quiet) { ERR_clear_error(); return ret; } if (ret != NULL) return ret; BIO_printf(bio_err, "Can't open \"%s\" for %s, %s\n", filename, modeverb(mode), strerror(errno)); } ERR_print_errors(bio_err); return NULL; } BIO bio_open_default(const char filename, char mode, int format) { return bio_open_default_(filename, mode, format, 0); } BIO bio_open_default_quiet(const char filename, char mode, int format) { return bio_open_default_(filename, mode, format, 1); } void wait_for_async(SSL s) { / On Windows select only works for sockets, so we simply don't wait / #ifndef OPENSSL_SYS_WINDOWS int width = 0; fd_set asyncfds; OSSL_ASYNC_FD fds; size_t numfds; size_t i; if (!SSL_get_all_async_fds(s, NULL, &numfds)) return; if (numfds == 0) return; fds = app_malloc(sizeof(OSSL_ASYNC_FD) * numfds, "allocate async fds"); if (!SSL_get_all_async_fds(s, fds, &numfds)) { OPENSSL_free(fds); return; } FD_ZERO(&asyncfds); for (i = 0; i < numfds; i++) { if (width <= (int)fds[i]) width = (int)fds[i] + 1; openssl_fdset((int)fds[i], &asyncfds); } select(width, (void )&asyncfds, NULL, NULL, NULL); OPENSSL_free(fds); #endif } / if OPENSSL_SYS_WINDOWS is defined then so is OPENSSL_SYS_MSDOS / #if defined(OPENSSL_SYS_MSDOS) int has_stdin_waiting(void) { # if defined(OPENSSL_SYS_WINDOWS) HANDLE inhand = GetStdHandle(STD_INPUT_HANDLE); DWORD events = 0; INPUT_RECORD inputrec; DWORD insize = 1; BOOL peeked; if (inhand == INVALID_HANDLE_VALUE) { return 0; } peeked = PeekConsoleInput(inhand, &inputrec, insize, &events); if (!peeked) { / Probably redirected input? _kbhit() does not work in this case / if (!feof(stdin)) { return 1; } return 0; } # endif return _kbhit(); } #endif / Corrupt a signature by modifying final byte / void corrupt_signature(const ASN1_STRING signature) { unsigned char s = signature->data; s[signature->length - 1] ^= 0x1; } int set_cert_times(X509 x, const char startdate, const char enddate, int days) { if (startdate == NULL \|\| strcmp(startdate, "today") == 0) { if (X509_gmtime_adj(X509_getm_notBefore(x), 0) == NULL) return 0; } else { if (!ASN1_TIME_set_string_X509(X509_getm_notBefore(x), startdate)) return 0; } if (enddate == NULL) { if (X509_time_adj_ex(X509_getm_notAfter(x), days, 0, NULL) == NULL) return 0; } else if (!ASN1_TIME_set_string_X509(X509_getm_notAfter(x), enddate)) { return 0; } return 1; } int set_crl_lastupdate(X509_CRL crl, const char lastupdate) { int ret = 0; ASN1_TIME tm = ASN1_TIME_new(); if (tm == NULL) goto end; if (lastupdate == NULL) { if (X509_gmtime_adj(tm, 0) == NULL) goto end; } else { if (!ASN1_TIME_set_string_X509(tm, lastupdate)) goto end; } if (!X509_CRL_set1_lastUpdate(crl, tm)) goto end; ret = 1; end: ASN1_TIME_free(tm); return ret; } int set_crl_nextupdate(X509_CRL crl, const char nextupdate, long days, long hours, long secs) { int ret = 0; ASN1_TIME tm = ASN1_TIME_new(); if (tm == NULL) goto end; if (nextupdate == NULL) { if (X509_time_adj_ex(tm, days, hours * 60 * 60 + secs, NULL) == NULL) goto end; } else { if (!ASN1_TIME_set_string_X509(tm, nextupdate)) goto end; } if (!X509_CRL_set1_nextUpdate(crl, tm)) goto end; ret = 1; end: ASN1_TIME_free(tm); return ret; } void make_uppercase(char string) { int i; for (i = 0; string[i] != '\0'; i++) string[i] = toupper((unsigned char)string[i]); } OSSL_PARAM app_params_new_from_opts(STACK_OF(OPENSSL_STRING) opts, const OSSL_PARAM paramdefs) { OSSL_PARAM params = NULL; size_t sz = (size_t)sk_OPENSSL_STRING_num(opts); size_t params_n; char opt = "", stmp, vtmp = NULL; int found = 1; if (opts == NULL) return NULL; params = OPENSSL_zalloc(sizeof(OSSL_PARAM) * (sz + 1)); if (params == NULL) return NULL; for (params_n = 0; params_n < sz; params_n++) { opt = sk_OPENSSL_STRING_value(opts, (int)params_n); if ((stmp = OPENSSL_strdup(opt)) == NULL \|\| (vtmp = strchr(stmp, ':')) == NULL) goto err; /* Replace ':' with 0 to terminate the string pointed to by stmp / vtmp = 0; /* Skip over the separator so that vmtp points to the value / vtmp++; if (!OSSL_PARAM_allocate_from_text(&params[params_n], paramdefs, stmp, vtmp, strlen(vtmp), &found)) goto err; OPENSSL_free(stmp); } params[params_n] = OSSL_PARAM_construct_end(); return params; err: OPENSSL_free(stmp); BIO_printf(bio_err, "Parameter %s '%s'\n", found ? "error" : "unknown", opt); ERR_print_errors(bio_err); app_params_free(params); return NULL; } void app_params_free(OSSL_PARAM params) { int i; if (params != NULL) { for (i = 0; params[i].key != NULL; ++i) OPENSSL_free(params[i].data); OPENSSL_free(params); } } EVP_PKEY app_keygen(EVP_PKEY_CTX ctx, const char alg, int bits, int verbose) { EVP_PKEY res = NULL; if (verbose && alg != NULL) { BIO_printf(bio_err, "Generating %s key", alg); if (bits > 0) BIO_printf(bio_err, " with %d bits\n", bits); else BIO_printf(bio_err, "\n"); } if (!RAND_status()) BIO_printf(bio_err, "Warning: generating random key material may take a long time\n" "if the system has a poor entropy source\n"); if (EVP_PKEY_keygen(ctx, &res) <= 0) BIO_printf(bio_err, "%s: Error generating %s key\n", opt_getprog(), alg != NULL ? alg : "asymmetric"); return res; } EVP_PKEY app_paramgen(EVP_PKEY_CTX ctx, const char alg) { EVP_PKEY res = NULL; if (!RAND_status()) BIO_printf(bio_err, "Warning: generating random key parameters may take a long time\n" "if the system has a poor entropy source\n"); if (EVP_PKEY_paramgen(ctx, &res) <= 0) BIO_printf(bio_err, "%s: Generating %s key parameters failed\n", opt_getprog(), alg != NULL ? alg : "asymmetric"); return res; } /* * Return non-zero if the legacy path is still an option. * This decision is based on the global command line operations and the * behaviour thus far. / int opt_legacy_okay(void) { int provider_options = opt_provider_option_given(); int libctx = app_get0_libctx() != NULL \|\| app_get0_propq() != NULL; / * Having a provider option specified or a custom library context or * property query, is a sure sign we're not using legacy. */ if (provider_options \|\| libctx) return 0; return 1; }
./openssl/apps/lib/app_rand.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "apps.h" #include <openssl/bio.h> #include <openssl/err.h> #include <openssl/rand.h> #include <openssl/conf.h> static char save_rand_file; static STACK_OF(OPENSSL_STRING) randfiles; void app_RAND_load_conf(CONF c, const char section) { const char randfile = app_conf_try_string(c, section, "RANDFILE"); if (randfile == NULL) return; if (RAND_load_file(randfile, -1) < 0) { BIO_printf(bio_err, "Can't load %s into RNG\n", randfile); ERR_print_errors(bio_err); } if (save_rand_file == NULL) { save_rand_file = OPENSSL_strdup(randfile); /* If some internal memory errors have occurred / if (save_rand_file == NULL) { BIO_printf(bio_err, "Can't duplicate %s\n", randfile); ERR_print_errors(bio_err); } } } static int loadfiles(char name) { char p; int last, ret = 1; for (;;) { last = 0; for (p = name; p != '\0' && p != LIST_SEPARATOR_CHAR; p++) continue; if (p == '\0') last = 1; p = '\0'; if (RAND_load_file(name, -1) < 0) { BIO_printf(bio_err, "Can't load %s into RNG\n", name); ERR_print_errors(bio_err); ret = 0; } if (last) break; name = p + 1; if (name == '\0') break; } return ret; } int app_RAND_load(void) { char p; int i, ret = 1; for (i = 0; i < sk_OPENSSL_STRING_num(randfiles); i++) { p = sk_OPENSSL_STRING_value(randfiles, i); if (!loadfiles(p)) ret = 0; } sk_OPENSSL_STRING_free(randfiles); return ret; } int app_RAND_write(void) { int ret = 1; if (save_rand_file == NULL) return 1; if (RAND_write_file(save_rand_file) == -1) { BIO_printf(bio_err, "Cannot write random bytes:\n"); ERR_print_errors(bio_err); ret = 0; } OPENSSL_free(save_rand_file); save_rand_file = NULL; return ret; } / * See comments in opt_verify for explanation of this. */ enum r_range { OPT_R_ENUM }; int opt_rand(int opt) { switch ((enum r_range)opt) { case OPT_R__FIRST: case OPT_R__LAST: break; case OPT_R_RAND: if (randfiles == NULL && (randfiles = sk_OPENSSL_STRING_new_null()) == NULL) return 0; if (!sk_OPENSSL_STRING_push(randfiles, opt_arg())) return 0; break; case OPT_R_WRITERAND: OPENSSL_free(save_rand_file); save_rand_file = OPENSSL_strdup(opt_arg()); if (save_rand_file == NULL) return 0; break; } return 1; }
./openssl/apps/lib/apps_ui.c	/* * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <string.h> #include <openssl/err.h> #include <openssl/ui.h> #include "apps_ui.h" static UI_METHOD ui_method = NULL; static const UI_METHOD ui_base_method = NULL; static int ui_open(UI ui) { int (opener)(UI ui) = UI_method_get_opener(ui_base_method); if (opener != NULL) return opener(ui); return 1; } static int ui_read(UI ui, UI_STRING uis) { int (reader)(UI ui, UI_STRING uis) = NULL; if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD && UI_get0_user_data(ui)) { switch (UI_get_string_type(uis)) { case UIT_PROMPT: case UIT_VERIFY: { const char password = ((PW_CB_DATA )UI_get0_user_data(ui))->password; if (password != NULL) { UI_set_result(ui, uis, password); return 1; } } break; case UIT_NONE: case UIT_BOOLEAN: case UIT_INFO: case UIT_ERROR: break; } } reader = UI_method_get_reader(ui_base_method); if (reader != NULL) return reader(ui, uis); / Default to the empty password if we've got nothing better / UI_set_result(ui, uis, ""); return 1; } static int ui_write(UI ui, UI_STRING uis) { int (writer)(UI ui, UI_STRING uis) = NULL; if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD && UI_get0_user_data(ui)) { switch (UI_get_string_type(uis)) { case UIT_PROMPT: case UIT_VERIFY: { const char password = ((PW_CB_DATA )UI_get0_user_data(ui))->password; if (password != NULL) return 1; } break; case UIT_NONE: case UIT_BOOLEAN: case UIT_INFO: case UIT_ERROR: break; } } writer = UI_method_get_writer(ui_base_method); if (writer != NULL) return writer(ui, uis); return 1; } static int ui_close(UI ui) { int (closer)(UI ui) = UI_method_get_closer(ui_base_method); if (closer != NULL) return closer(ui); return 1; } / object_name defaults to prompt_info from ui user data if present / static char ui_prompt_construct(UI ui, const char phrase_desc, const char object_name) { PW_CB_DATA cb_data = (PW_CB_DATA )UI_get0_user_data(ui); if (phrase_desc == NULL) phrase_desc = "pass phrase"; if (object_name == NULL && cb_data != NULL) object_name = cb_data->prompt_info; return UI_construct_prompt(NULL, phrase_desc, object_name); } int set_base_ui_method(const UI_METHOD ui_meth) { if (ui_meth == NULL) ui_meth = UI_null(); ui_base_method = ui_meth; return 1; } int setup_ui_method(void) { ui_base_method = UI_null(); #ifndef OPENSSL_NO_UI_CONSOLE ui_base_method = UI_OpenSSL(); #endif ui_method = UI_create_method("OpenSSL application user interface"); return ui_method != NULL && 0 == UI_method_set_opener(ui_method, ui_open) && 0 == UI_method_set_reader(ui_method, ui_read) && 0 == UI_method_set_writer(ui_method, ui_write) && 0 == UI_method_set_closer(ui_method, ui_close) && 0 == UI_method_set_prompt_constructor(ui_method, ui_prompt_construct); } void destroy_ui_method(void) { if (ui_method != NULL) { UI_destroy_method(ui_method); ui_method = NULL; } } const UI_METHOD get_ui_method(void) { return ui_method; } static void ui_malloc(int sz, const char what) { void vp = OPENSSL_malloc(sz); if (vp == NULL) { BIO_printf(bio_err, "Could not allocate %d bytes for %s\n", sz, what); ERR_print_errors(bio_err); exit(1); } return vp; } int password_callback(char buf, int bufsiz, int verify, PW_CB_DATA cb_data) { int res = 0; UI ui; int ok = 0; char buff = NULL; int ui_flags = 0; const char prompt_info = NULL; char prompt; if ((ui = UI_new_method(ui_method)) == NULL) return 0; if (cb_data != NULL && cb_data->prompt_info != NULL) prompt_info = cb_data->prompt_info; prompt = UI_construct_prompt(ui, "pass phrase", prompt_info); if (prompt == NULL) { BIO_printf(bio_err, "Out of memory\n"); UI_free(ui); return 0; } ui_flags \|= UI_INPUT_FLAG_DEFAULT_PWD; UI_ctrl(ui, UI_CTRL_PRINT_ERRORS, 1, 0, 0); /* We know that there is no previous user data to return to us */ (void)UI_add_user_data(ui, cb_data); ok = UI_add_input_string(ui, prompt, ui_flags, buf, PW_MIN_LENGTH, bufsiz - 1); if (ok >= 0 && verify) { buff = ui_malloc(bufsiz, "password buffer"); ok = UI_add_verify_string(ui, prompt, ui_flags, buff, PW_MIN_LENGTH, bufsiz - 1, buf); } if (ok >= 0) do { ok = UI_process(ui); } while (ok < 0 && UI_ctrl(ui, UI_CTRL_IS_REDOABLE, 0, 0, 0)); OPENSSL_clear_free(buff, (unsigned int)bufsiz); if (ok >= 0) res = strlen(buf); if (ok == -1) { BIO_printf(bio_err, "User interface error\n"); ERR_print_errors(bio_err); OPENSSL_cleanse(buf, (unsigned int)bufsiz); res = 0; } if (ok == -2) { BIO_printf(bio_err, "aborted!\n"); OPENSSL_cleanse(buf, (unsigned int)bufsiz); res = 0; } UI_free(ui); OPENSSL_free(prompt); return res; }
./openssl/apps/lib/app_params.c	/* * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "apps.h" #include "app_params.h" static int describe_param_type(char buf, size_t bufsz, const OSSL_PARAM param) { const char type_mod = ""; const char type = NULL; int show_type_number = 0; int printed_len; switch (param->data_type) { case OSSL_PARAM_UNSIGNED_INTEGER: type_mod = "unsigned "; / FALLTHRU / case OSSL_PARAM_INTEGER: type = "integer"; break; case OSSL_PARAM_UTF8_PTR: type_mod = "pointer to a "; / FALLTHRU / case OSSL_PARAM_UTF8_STRING: type = "UTF8 encoded string"; break; case OSSL_PARAM_OCTET_PTR: type_mod = "pointer to an "; / FALLTHRU / case OSSL_PARAM_OCTET_STRING: type = "octet string"; break; default: type = "unknown type"; show_type_number = 1; break; } printed_len = BIO_snprintf(buf, bufsz, "%s: ", param->key); if (printed_len > 0) { buf += printed_len; bufsz -= printed_len; } printed_len = BIO_snprintf(buf, bufsz, "%s%s", type_mod, type); if (printed_len > 0) { buf += printed_len; bufsz -= printed_len; } if (show_type_number) { printed_len = BIO_snprintf(buf, bufsz, " [%d]", param->data_type); if (printed_len > 0) { buf += printed_len; bufsz -= printed_len; } } if (param->data_size == 0) printed_len = BIO_snprintf(buf, bufsz, " (arbitrary size)"); else printed_len = BIO_snprintf(buf, bufsz, " (max %zu bytes large)", param->data_size); if (printed_len > 0) { buf += printed_len; bufsz -= printed_len; } buf = '\0'; return 1; } int print_param_types(const char thing, const OSSL_PARAM pdefs, int indent) { if (pdefs == NULL) { return 1; } else if (pdefs->key == NULL) { /* * An empty list? This shouldn't happen, but let's just make sure to * say something if there's a badly written provider... / BIO_printf(bio_out, "%sEmpty list of %s (!!!)\n", indent, "", thing); } else { BIO_printf(bio_out, "%s%s:\n", indent, "", thing); for (; pdefs->key != NULL; pdefs++) { char buf[200]; / This should be ample space / describe_param_type(buf, sizeof(buf), pdefs); BIO_printf(bio_out, "%s %s\n", indent, "", buf); } } return 1; } void print_param_value(const OSSL_PARAM p, int indent) { int64_t i; uint64_t u; printf("%s%s: ", indent, "", p->key); switch (p->data_type) { case OSSL_PARAM_UNSIGNED_INTEGER: if (OSSL_PARAM_get_uint64(p, &u)) BIO_printf(bio_out, "%llu\n", (unsigned long long int)u); else BIO_printf(bio_out, "error getting value\n"); break; case OSSL_PARAM_INTEGER: if (OSSL_PARAM_get_int64(p, &i)) BIO_printf(bio_out, "%lld\n", (long long int)i); else BIO_printf(bio_out, "error getting value\n"); break; case OSSL_PARAM_UTF8_PTR: BIO_printf(bio_out, "'%s'\n", (char )(p->data)); break; case OSSL_PARAM_UTF8_STRING: BIO_printf(bio_out, "'%s'\n", (char )p->data); break; case OSSL_PARAM_OCTET_PTR: case OSSL_PARAM_OCTET_STRING: BIO_printf(bio_out, "<%zu bytes>\n", p->data_size); break; default: BIO_printf(bio_out, "unknown type (%u) of %zu bytes\n", p->data_type, p->data_size); break; } }
./openssl/apps/lib/fmt.c	/* * Copyright 2018-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "fmt.h" int FMT_istext(int format) { return (format & B_FORMAT_TEXT) == B_FORMAT_TEXT; }
./openssl/apps/lib/app_provider.c	/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "apps.h" #include <string.h> #include <openssl/err.h> #include <openssl/provider.h> #include <openssl/safestack.h> / Non-zero if any of the provider options have been seen / static int provider_option_given = 0; DEFINE_STACK_OF(OSSL_PROVIDER) / * See comments in opt_verify for explanation of this. / enum prov_range { OPT_PROV_ENUM }; static STACK_OF(OSSL_PROVIDER) app_providers = NULL; static void provider_free(OSSL_PROVIDER prov) { OSSL_PROVIDER_unload(prov); } int app_provider_load(OSSL_LIB_CTX libctx, const char provider_name) { OSSL_PROVIDER prov; prov = OSSL_PROVIDER_load(libctx, provider_name); if (prov == NULL) { opt_printf_stderr("%s: unable to load provider %s\n" "Hint: use -provider-path option or OPENSSL_MODULES environment variable.\n", opt_getprog(), provider_name); ERR_print_errors(bio_err); return 0; } if (app_providers == NULL) app_providers = sk_OSSL_PROVIDER_new_null(); if (app_providers == NULL \|\| !sk_OSSL_PROVIDER_push(app_providers, prov)) { app_providers_cleanup(); return 0; } return 1; } void app_providers_cleanup(void) { sk_OSSL_PROVIDER_pop_free(app_providers, provider_free); app_providers = NULL; } static int opt_provider_path(const char path) { if (path != NULL && path == '\0') path = NULL; return OSSL_PROVIDER_set_default_search_path(app_get0_libctx(), path); } int opt_provider(int opt) { const int given = provider_option_given; provider_option_given = 1; switch ((enum prov_range)opt) { case OPT_PROV__FIRST: case OPT_PROV__LAST: return 1; case OPT_PROV_PROVIDER: return app_provider_load(app_get0_libctx(), opt_arg()); case OPT_PROV_PROVIDER_PATH: return opt_provider_path(opt_arg()); case OPT_PROV_PROPQUERY: return app_set_propq(opt_arg()); } /* Should never get here but if we do, undo what we did earlier */ provider_option_given = given; return 0; } int opt_provider_option_given(void) { return provider_option_given; }
./openssl/ms/applink.c	/* * Copyright 2004-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #define APPLINK_STDIN 1 #define APPLINK_STDOUT 2 #define APPLINK_STDERR 3 #define APPLINK_FPRINTF 4 #define APPLINK_FGETS 5 #define APPLINK_FREAD 6 #define APPLINK_FWRITE 7 #define APPLINK_FSETMOD 8 #define APPLINK_FEOF 9 #define APPLINK_FCLOSE 10 / should not be used / #define APPLINK_FOPEN 11 / solely for completeness / #define APPLINK_FSEEK 12 #define APPLINK_FTELL 13 #define APPLINK_FFLUSH 14 #define APPLINK_FERROR 15 #define APPLINK_CLEARERR 16 #define APPLINK_FILENO 17 / to be used with below / #define APPLINK_OPEN 18 / formally can't be used, as flags can vary / #define APPLINK_READ 19 #define APPLINK_WRITE 20 #define APPLINK_LSEEK 21 #define APPLINK_CLOSE 22 #define APPLINK_MAX 22 / always same as last macro / #ifndef APPMACROS_ONLY / * Normally, do not define APPLINK_NO_INCLUDES. Define it if you are using * symbol preprocessing and do not want the preprocessing to affect the * following included header files. You will need to put these * include lines somewhere in the file that is including applink.c. / # ifndef APPLINK_NO_INCLUDES # include <stdio.h> # include <io.h> # include <fcntl.h> # endif # ifdef __BORLANDC__ / _lseek in <io.h> is a function-like macro so we can't take its address / # undef _lseek # define _lseek lseek # endif static void app_stdin(void) { return stdin; } static void app_stdout(void) { return stdout; } static void app_stderr(void) { return stderr; } static int app_feof(FILE fp) { return feof(fp); } static int app_ferror(FILE fp) { return ferror(fp); } static void app_clearerr(FILE fp) { clearerr(fp); } static int app_fileno(FILE fp) { return _fileno(fp); } static int app_fsetmod(FILE fp, char mod) { return _setmode(_fileno(fp), mod == 'b' ? _O_BINARY : _O_TEXT); } #ifdef __cplusplus extern "C" { #endif __declspec(dllexport) void * # if defined(__BORLANDC__) /* * __stdcall appears to be the only way to get the name * decoration right with Borland C. Otherwise it works * purely incidentally, as we pass no parameters. / __stdcall # else __cdecl # endif OPENSSL_Applink(void) { static int once = 1; static void OPENSSL_ApplinkTable[APPLINK_MAX + 1] = { (void *)APPLINK_MAX }; if (once) { OPENSSL_ApplinkTable[APPLINK_STDIN] = app_stdin; OPENSSL_ApplinkTable[APPLINK_STDOUT] = app_stdout; OPENSSL_ApplinkTable[APPLINK_STDERR] = app_stderr; OPENSSL_ApplinkTable[APPLINK_FPRINTF] = fprintf; OPENSSL_ApplinkTable[APPLINK_FGETS] = fgets; OPENSSL_ApplinkTable[APPLINK_FREAD] = fread; OPENSSL_ApplinkTable[APPLINK_FWRITE] = fwrite; OPENSSL_ApplinkTable[APPLINK_FSETMOD] = app_fsetmod; OPENSSL_ApplinkTable[APPLINK_FEOF] = app_feof; OPENSSL_ApplinkTable[APPLINK_FCLOSE] = fclose; OPENSSL_ApplinkTable[APPLINK_FOPEN] = fopen; OPENSSL_ApplinkTable[APPLINK_FSEEK] = fseek; OPENSSL_ApplinkTable[APPLINK_FTELL] = ftell; OPENSSL_ApplinkTable[APPLINK_FFLUSH] = fflush; OPENSSL_ApplinkTable[APPLINK_FERROR] = app_ferror; OPENSSL_ApplinkTable[APPLINK_CLEARERR] = app_clearerr; OPENSSL_ApplinkTable[APPLINK_FILENO] = app_fileno; OPENSSL_ApplinkTable[APPLINK_OPEN] = _open; OPENSSL_ApplinkTable[APPLINK_READ] = _read; OPENSSL_ApplinkTable[APPLINK_WRITE] = _write; OPENSSL_ApplinkTable[APPLINK_LSEEK] = _lseek; OPENSSL_ApplinkTable[APPLINK_CLOSE] = _close; once = 0; } return OPENSSL_ApplinkTable; } #ifdef __cplusplus } #endif #endif
./openssl/ms/uplink.h	/* * Copyright 2004-2016 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #define APPMACROS_ONLY #include "applink.c" extern void OPENSSL_UplinkTable[]; #define UP_stdin ((void ()(void))OPENSSL_UplinkTable[APPLINK_STDIN])() #define UP_stdout ((void ()(void))OPENSSL_UplinkTable[APPLINK_STDOUT])() #define UP_stderr ((void ()(void))OPENSSL_UplinkTable[APPLINK_STDERR])() #define UP_fprintf ((int ()(void ,const char ,...))OPENSSL_UplinkTable[APPLINK_FPRINTF]) #define UP_fgets ((char ()(char ,int,void ))OPENSSL_UplinkTable[APPLINK_FGETS]) #define UP_fread ((size_t ()(void ,size_t,size_t,void ))OPENSSL_UplinkTable[APPLINK_FREAD]) #define UP_fwrite ((size_t ()(const void ,size_t,size_t,void ))OPENSSL_UplinkTable[APPLINK_FWRITE]) #define UP_fsetmod ((int ()(void ,char))OPENSSL_UplinkTable[APPLINK_FSETMOD]) #define UP_feof ((int ()(void ))OPENSSL_UplinkTable[APPLINK_FEOF]) #define UP_fclose ((int ()(void ))OPENSSL_UplinkTable[APPLINK_FCLOSE]) #define UP_fopen ((void ()(const char ,const char ))OPENSSL_UplinkTable[APPLINK_FOPEN]) #define UP_fseek ((int ()(void ,long,int))OPENSSL_UplinkTable[APPLINK_FSEEK]) #define UP_ftell ((long ()(void ))OPENSSL_UplinkTable[APPLINK_FTELL]) #define UP_fflush ((int ()(void ))OPENSSL_UplinkTable[APPLINK_FFLUSH]) #define UP_ferror ((int ()(void ))OPENSSL_UplinkTable[APPLINK_FERROR]) #define UP_clearerr ((void ()(void ))OPENSSL_UplinkTable[APPLINK_CLEARERR]) #define UP_fileno ((int ()(void ))OPENSSL_UplinkTable[APPLINK_FILENO]) #define UP_open ((int ()(const char ,int,...))OPENSSL_UplinkTable[APPLINK_OPEN]) #define UP_read ((ossl_ssize_t ()(int,void ,size_t))OPENSSL_UplinkTable[APPLINK_READ]) #define UP_write ((ossl_ssize_t ()(int,const void ,size_t))OPENSSL_UplinkTable[APPLINK_WRITE]) #define UP_lseek ((long ()(int,long,int))OPENSSL_UplinkTable[APPLINK_LSEEK]) #define UP_close ((int (*)(int))OPENSSL_UplinkTable[APPLINK_CLOSE])
./openssl/ms/uplink.c	/* * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #if (defined(_WIN64) \|\| defined(_WIN32_WCE)) && !defined(UNICODE) # define UNICODE #endif #if defined(UNICODE) && !defined(_UNICODE) # define _UNICODE #endif #if defined(_UNICODE) && !defined(UNICODE) # define UNICODE #endif #include <windows.h> #include <tchar.h> #include <stdio.h> #include "uplink.h" void OPENSSL_showfatal(const char , ...); static TCHAR msg[128]; static void unimplemented(void) { OPENSSL_showfatal(sizeof(TCHAR) == sizeof(char) ? "%s\n" : "%S\n", msg); TerminateProcess(GetCurrentProcess(), 1); } void OPENSSL_Uplink(volatile void table, int index) { static HMODULE volatile apphandle = NULL; static void volatile applinktable = NULL; int len; void (func) (void) = unimplemented; HANDLE h; void p; / * Note that the below code is not MT-safe in respect to msg buffer, but * what's the worst thing that can happen? Error message might be * misleading or corrupted. As error condition is fatal and should never * be risen, I accept the risk... / / * One can argue that I should have used InterlockedExchangePointer or * something to update static variables and table[]. Well, store * instructions are as atomic as they can get and assigned values are * effectively constant... So that volatile qualifier should be * sufficient [it prohibits compiler to reorder memory access * instructions]. / do { len = _sntprintf(msg, sizeof(msg) / sizeof(TCHAR), _T("OPENSSL_Uplink(%p,%02X): "), table, index); _tcscpy(msg + len, _T("unimplemented function")); if ((h = apphandle) == NULL) { if ((h = GetModuleHandle(NULL)) == NULL) { apphandle = (HMODULE) - 1; _tcscpy(msg + len, _T("no host application")); break; } apphandle = h; } if ((h = apphandle) == (HMODULE) - 1) / revalidate / break; if (applinktable == NULL) { void (applink) (); applink = (void *()())GetProcAddress(h, "OPENSSL_Applink"); if (applink == NULL) { apphandle = (HMODULE) - 1; _tcscpy(msg + len, _T("no OPENSSL_Applink")); break; } p = (applink) (); if (p == NULL) { apphandle = (HMODULE) - 1; _tcscpy(msg + len, _T("no ApplinkTable")); break; } applinktable = p; } else p = applinktable; if (index > (int)p[0]) break; if (p[index]) func = p[index]; } while (0); table[index] = func; } #if (defined(_MSC_VER) \|\| defined(__BORLANDC__)) && defined(_M_IX86) # if defined(_MSC_VER) # define LAZY(i) \ __declspec(naked) static void lazy##i (void) { \ _asm push i \ _asm push OFFSET OPENSSL_UplinkTable \ _asm call OPENSSL_Uplink \ _asm add esp,8 \ _asm jmp OPENSSL_UplinkTable+4i } # elif defined(__BORLANDC__) && defined(__clang__) void OPENSSL_UplinkTable[26]; / C++Builder requires declaration before use / # define LAZY(i) \ __declspec(naked) static void lazy##i (void) { \ __asm__("pushl $" #i "; " \ "pushl %0; " \ "call %P1; " \ "addl $8, %%esp; " \ "jmp %2 " \ : /* no outputs / \ : "i" (OPENSSL_UplinkTable), \ "i" (OPENSSL_Uplink), \ "m" (OPENSSL_UplinkTable[i])); } # endif # if APPLINK_MAX>25 # error "Add more stubs..." # endif / make some in advance... / LAZY(1) LAZY(2) LAZY(3) LAZY(4) LAZY(5) LAZY(6) LAZY(7) LAZY(8) LAZY(9) LAZY(10) LAZY(11) LAZY(12) LAZY(13) LAZY(14) LAZY(15) LAZY(16) LAZY(17) LAZY(18) LAZY(19) LAZY(20) LAZY(21) LAZY(22) LAZY(23) LAZY(24) LAZY(25) void OPENSSL_UplinkTable[] = { (void *)APPLINK_MAX, lazy1, lazy2, lazy3, lazy4, lazy5, lazy6, lazy7, lazy8, lazy9, lazy10, lazy11, lazy12, lazy13, lazy14, lazy15, lazy16, lazy17, lazy18, lazy19, lazy20, lazy21, lazy22, lazy23, lazy24, lazy25, }; #endif #ifdef SELFTEST main() { UP_fprintf(UP_stdout, "hello, world!\n"); } #endif
./openssl/ssl/t1_enc.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include "ssl_local.h" #include "record/record_local.h" #include "internal/ktls.h" #include "internal/cryptlib.h" #include <openssl/comp.h> #include <openssl/evp.h> #include <openssl/kdf.h> #include <openssl/rand.h> #include <openssl/obj_mac.h> #include <openssl/core_names.h> #include <openssl/trace.h> / seed1 through seed5 are concatenated / static int tls1_PRF(SSL_CONNECTION s, const void seed1, size_t seed1_len, const void seed2, size_t seed2_len, const void seed3, size_t seed3_len, const void seed4, size_t seed4_len, const void seed5, size_t seed5_len, const unsigned char sec, size_t slen, unsigned char out, size_t olen, int fatal) { const EVP_MD md = ssl_prf_md(s); EVP_KDF kdf; EVP_KDF_CTX kctx = NULL; OSSL_PARAM params[8], p = params; const char mdname; if (md == NULL) { /* Should never happen / if (fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); else ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } kdf = EVP_KDF_fetch(SSL_CONNECTION_GET_CTX(s)->libctx, OSSL_KDF_NAME_TLS1_PRF, SSL_CONNECTION_GET_CTX(s)->propq); if (kdf == NULL) goto err; kctx = EVP_KDF_CTX_new(kdf); EVP_KDF_free(kdf); if (kctx == NULL) goto err; mdname = EVP_MD_get0_name(md); p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char )mdname, 0); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET, (unsigned char )sec, (size_t)slen); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void )seed1, (size_t)seed1_len); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void )seed2, (size_t)seed2_len); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void )seed3, (size_t)seed3_len); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void )seed4, (size_t)seed4_len); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void )seed5, (size_t)seed5_len); p = OSSL_PARAM_construct_end(); if (EVP_KDF_derive(kctx, out, olen, params)) { EVP_KDF_CTX_free(kctx); return 1; } err: if (fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); else ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); EVP_KDF_CTX_free(kctx); return 0; } static int tls1_generate_key_block(SSL_CONNECTION s, unsigned char km, size_t num) { int ret; /* Calls SSLfatal() as required / ret = tls1_PRF(s, TLS_MD_KEY_EXPANSION_CONST, TLS_MD_KEY_EXPANSION_CONST_SIZE, s->s3.server_random, SSL3_RANDOM_SIZE, s->s3.client_random, SSL3_RANDOM_SIZE, NULL, 0, NULL, 0, s->session->master_key, s->session->master_key_length, km, num, 1); return ret; } static int tls_iv_length_within_key_block(const EVP_CIPHER c) { /* If GCM/CCM mode only part of IV comes from PRF / if (EVP_CIPHER_get_mode(c) == EVP_CIPH_GCM_MODE) return EVP_GCM_TLS_FIXED_IV_LEN; else if (EVP_CIPHER_get_mode(c) == EVP_CIPH_CCM_MODE) return EVP_CCM_TLS_FIXED_IV_LEN; else return EVP_CIPHER_get_iv_length(c); } int tls1_change_cipher_state(SSL_CONNECTION s, int which) { unsigned char p, mac_secret; unsigned char key, iv; const EVP_CIPHER c; const SSL_COMP comp = NULL; const EVP_MD m; int mac_type; size_t mac_secret_size; size_t n, i, j, k, cl; int iivlen; / * Taglen is only relevant for CCM ciphersuites. Other ciphersuites * ignore this value so we can default it to 0. / size_t taglen = 0; int direction; c = s->s3.tmp.new_sym_enc; m = s->s3.tmp.new_hash; mac_type = s->s3.tmp.new_mac_pkey_type; #ifndef OPENSSL_NO_COMP comp = s->s3.tmp.new_compression; #endif p = s->s3.tmp.key_block; i = mac_secret_size = s->s3.tmp.new_mac_secret_size; cl = EVP_CIPHER_get_key_length(c); j = cl; iivlen = tls_iv_length_within_key_block(c); if (iivlen < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } k = iivlen; if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) \|\| (which == SSL3_CHANGE_CIPHER_SERVER_READ)) { mac_secret = &(p[0]); n = i + i; key = &(p[n]); n += j + j; iv = &(p[n]); n += k + k; } else { n = i; mac_secret = &(p[n]); n += i + j; key = &(p[n]); n += j + k; iv = &(p[n]); n += k; } if (n > s->s3.tmp.key_block_length) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } switch (EVP_CIPHER_get_mode(c)) { case EVP_CIPH_GCM_MODE: taglen = EVP_GCM_TLS_TAG_LEN; break; case EVP_CIPH_CCM_MODE: if ((s->s3.tmp.new_cipher->algorithm_enc & (SSL_AES128CCM8 \| SSL_AES256CCM8)) != 0) taglen = EVP_CCM8_TLS_TAG_LEN; else taglen = EVP_CCM_TLS_TAG_LEN; break; default: if (EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")) { taglen = EVP_CHACHAPOLY_TLS_TAG_LEN; } else { / MAC secret size corresponds to the MAC output size / taglen = s->s3.tmp.new_mac_secret_size; } break; } if (which & SSL3_CC_READ) { if (s->ext.use_etm) s->s3.flags \|= TLS1_FLAGS_ENCRYPT_THEN_MAC_READ; else s->s3.flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC_READ; if (s->s3.tmp.new_cipher->algorithm2 & TLS1_STREAM_MAC) s->mac_flags \|= SSL_MAC_FLAG_READ_MAC_STREAM; else s->mac_flags &= ~SSL_MAC_FLAG_READ_MAC_STREAM; if (s->s3.tmp.new_cipher->algorithm2 & TLS1_TLSTREE) s->mac_flags \|= SSL_MAC_FLAG_READ_MAC_TLSTREE; else s->mac_flags &= ~SSL_MAC_FLAG_READ_MAC_TLSTREE; direction = OSSL_RECORD_DIRECTION_READ; } else { if (s->ext.use_etm) s->s3.flags \|= TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE; else s->s3.flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE; if (s->s3.tmp.new_cipher->algorithm2 & TLS1_STREAM_MAC) s->mac_flags \|= SSL_MAC_FLAG_WRITE_MAC_STREAM; else s->mac_flags &= ~SSL_MAC_FLAG_WRITE_MAC_STREAM; if (s->s3.tmp.new_cipher->algorithm2 & TLS1_TLSTREE) s->mac_flags \|= SSL_MAC_FLAG_WRITE_MAC_TLSTREE; else s->mac_flags &= ~SSL_MAC_FLAG_WRITE_MAC_TLSTREE; direction = OSSL_RECORD_DIRECTION_WRITE; } if (SSL_CONNECTION_IS_DTLS(s)) dtls1_increment_epoch(s, which); if (!ssl_set_new_record_layer(s, s->version, direction, OSSL_RECORD_PROTECTION_LEVEL_APPLICATION, NULL, 0, key, cl, iv, (size_t)k, mac_secret, mac_secret_size, c, taglen, mac_type, m, comp, NULL)) { / SSLfatal already called / goto err; } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "which = %04X, key:\n", which); BIO_dump_indent(trc_out, key, EVP_CIPHER_get_key_length(c), 4); BIO_printf(trc_out, "iv:\n"); BIO_dump_indent(trc_out, iv, k, 4); } OSSL_TRACE_END(TLS); return 1; err: return 0; } int tls1_setup_key_block(SSL_CONNECTION s) { unsigned char p; const EVP_CIPHER c; const EVP_MD hash; SSL_COMP comp; int mac_type = NID_undef; size_t num, mac_secret_size = 0; int ret = 0; int ivlen; if (s->s3.tmp.key_block_length != 0) return 1; if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash, &mac_type, &mac_secret_size, &comp, s->ext.use_etm)) { /* Error is already recorded / SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); return 0; } ssl_evp_cipher_free(s->s3.tmp.new_sym_enc); s->s3.tmp.new_sym_enc = c; ssl_evp_md_free(s->s3.tmp.new_hash); s->s3.tmp.new_hash = hash; s->s3.tmp.new_mac_pkey_type = mac_type; s->s3.tmp.new_mac_secret_size = mac_secret_size; ivlen = tls_iv_length_within_key_block(c); if (ivlen < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } num = mac_secret_size + EVP_CIPHER_get_key_length(c) + ivlen; num = 2; ssl3_cleanup_key_block(s); if ((p = OPENSSL_malloc(num)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } s->s3.tmp.key_block_length = num; s->s3.tmp.key_block = p; OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "key block length: %zu\n", num); BIO_printf(trc_out, "client random\n"); BIO_dump_indent(trc_out, s->s3.client_random, SSL3_RANDOM_SIZE, 4); BIO_printf(trc_out, "server random\n"); BIO_dump_indent(trc_out, s->s3.server_random, SSL3_RANDOM_SIZE, 4); BIO_printf(trc_out, "master key\n"); BIO_dump_indent(trc_out, s->session->master_key, s->session->master_key_length, 4); } OSSL_TRACE_END(TLS); if (!tls1_generate_key_block(s, p, num)) { /* SSLfatal() already called / goto err; } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "key block\n"); BIO_dump_indent(trc_out, p, num, 4); } OSSL_TRACE_END(TLS); ret = 1; err: return ret; } size_t tls1_final_finish_mac(SSL_CONNECTION s, const char str, size_t slen, unsigned char out) { size_t hashlen; unsigned char hash[EVP_MAX_MD_SIZE]; size_t finished_size = TLS1_FINISH_MAC_LENGTH; if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kGOST18) finished_size = 32; if (!ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called / return 0; } if (!ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) { / SSLfatal() already called / return 0; } if (!tls1_PRF(s, str, slen, hash, hashlen, NULL, 0, NULL, 0, NULL, 0, s->session->master_key, s->session->master_key_length, out, finished_size, 1)) { / SSLfatal() already called / return 0; } OPENSSL_cleanse(hash, hashlen); return finished_size; } int tls1_generate_master_secret(SSL_CONNECTION s, unsigned char out, unsigned char p, size_t len, size_t secret_size) { if (s->session->flags & SSL_SESS_FLAG_EXTMS) { unsigned char hash[EVP_MAX_MD_SIZE 2]; size_t hashlen; /* * Digest cached records keeping record buffer (if present): this won't * affect client auth because we're freezing the buffer at the same * point (after client key exchange and before certificate verify) / if (!ssl3_digest_cached_records(s, 1) \|\| !ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) { / SSLfatal() already called / return 0; } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "Handshake hashes:\n"); BIO_dump(trc_out, (char )hash, hashlen); } OSSL_TRACE_END(TLS); if (!tls1_PRF(s, TLS_MD_EXTENDED_MASTER_SECRET_CONST, TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE, hash, hashlen, NULL, 0, NULL, 0, NULL, 0, p, len, out, SSL3_MASTER_SECRET_SIZE, 1)) { /* SSLfatal() already called / return 0; } OPENSSL_cleanse(hash, hashlen); } else { if (!tls1_PRF(s, TLS_MD_MASTER_SECRET_CONST, TLS_MD_MASTER_SECRET_CONST_SIZE, s->s3.client_random, SSL3_RANDOM_SIZE, NULL, 0, s->s3.server_random, SSL3_RANDOM_SIZE, NULL, 0, p, len, out, SSL3_MASTER_SECRET_SIZE, 1)) { / SSLfatal() already called / return 0; } } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "Premaster Secret:\n"); BIO_dump_indent(trc_out, p, len, 4); BIO_printf(trc_out, "Client Random:\n"); BIO_dump_indent(trc_out, s->s3.client_random, SSL3_RANDOM_SIZE, 4); BIO_printf(trc_out, "Server Random:\n"); BIO_dump_indent(trc_out, s->s3.server_random, SSL3_RANDOM_SIZE, 4); BIO_printf(trc_out, "Master Secret:\n"); BIO_dump_indent(trc_out, s->session->master_key, SSL3_MASTER_SECRET_SIZE, 4); } OSSL_TRACE_END(TLS); secret_size = SSL3_MASTER_SECRET_SIZE; return 1; } int tls1_export_keying_material(SSL_CONNECTION s, unsigned char out, size_t olen, const char label, size_t llen, const unsigned char context, size_t contextlen, int use_context) { unsigned char val = NULL; size_t vallen = 0, currentvalpos; int rv = 0; / * RFC 5705 embeds context length as uint16; reject longer context * before proceeding. / if (contextlen > 0xffff) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); return 0; } / * construct PRF arguments we construct the PRF argument ourself rather * than passing separate values into the TLS PRF to ensure that the * concatenation of values does not create a prohibited label. / vallen = llen + SSL3_RANDOM_SIZE 2; if (use_context) { vallen += 2 + contextlen; } val = OPENSSL_malloc(vallen); if (val == NULL) goto ret; currentvalpos = 0; memcpy(val + currentvalpos, (unsigned char )label, llen); currentvalpos += llen; memcpy(val + currentvalpos, s->s3.client_random, SSL3_RANDOM_SIZE); currentvalpos += SSL3_RANDOM_SIZE; memcpy(val + currentvalpos, s->s3.server_random, SSL3_RANDOM_SIZE); currentvalpos += SSL3_RANDOM_SIZE; if (use_context) { val[currentvalpos] = (contextlen >> 8) & 0xff; currentvalpos++; val[currentvalpos] = contextlen & 0xff; currentvalpos++; if ((contextlen > 0) \|\| (context != NULL)) { memcpy(val + currentvalpos, context, contextlen); } } / * disallow prohibited labels note that SSL3_RANDOM_SIZE > max(prohibited * label len) = 15, so size of val > max(prohibited label len) = 15 and * the comparisons won't have buffer overflow */ if (memcmp(val, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE) == 0) goto err1; if (memcmp(val, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE) == 0) goto err1; if (memcmp(val, TLS_MD_MASTER_SECRET_CONST, TLS_MD_MASTER_SECRET_CONST_SIZE) == 0) goto err1; if (memcmp(val, TLS_MD_EXTENDED_MASTER_SECRET_CONST, TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE) == 0) goto err1; if (memcmp(val, TLS_MD_KEY_EXPANSION_CONST, TLS_MD_KEY_EXPANSION_CONST_SIZE) == 0) goto err1; rv = tls1_PRF(s, val, vallen, NULL, 0, NULL, 0, NULL, 0, NULL, 0, s->session->master_key, s->session->master_key_length, out, olen, 0); goto ret; err1: ERR_raise(ERR_LIB_SSL, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL); ret: OPENSSL_clear_free(val, vallen); return rv; } int tls1_alert_code(int code) { switch (code) { case SSL_AD_CLOSE_NOTIFY: return SSL3_AD_CLOSE_NOTIFY; case SSL_AD_UNEXPECTED_MESSAGE: return SSL3_AD_UNEXPECTED_MESSAGE; case SSL_AD_BAD_RECORD_MAC: return SSL3_AD_BAD_RECORD_MAC; case SSL_AD_DECRYPTION_FAILED: return TLS1_AD_DECRYPTION_FAILED; case SSL_AD_RECORD_OVERFLOW: return TLS1_AD_RECORD_OVERFLOW; case SSL_AD_DECOMPRESSION_FAILURE: return SSL3_AD_DECOMPRESSION_FAILURE; case SSL_AD_HANDSHAKE_FAILURE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_NO_CERTIFICATE: return -1; case SSL_AD_BAD_CERTIFICATE: return SSL3_AD_BAD_CERTIFICATE; case SSL_AD_UNSUPPORTED_CERTIFICATE: return SSL3_AD_UNSUPPORTED_CERTIFICATE; case SSL_AD_CERTIFICATE_REVOKED: return SSL3_AD_CERTIFICATE_REVOKED; case SSL_AD_CERTIFICATE_EXPIRED: return SSL3_AD_CERTIFICATE_EXPIRED; case SSL_AD_CERTIFICATE_UNKNOWN: return SSL3_AD_CERTIFICATE_UNKNOWN; case SSL_AD_ILLEGAL_PARAMETER: return SSL3_AD_ILLEGAL_PARAMETER; case SSL_AD_UNKNOWN_CA: return TLS1_AD_UNKNOWN_CA; case SSL_AD_ACCESS_DENIED: return TLS1_AD_ACCESS_DENIED; case SSL_AD_DECODE_ERROR: return TLS1_AD_DECODE_ERROR; case SSL_AD_DECRYPT_ERROR: return TLS1_AD_DECRYPT_ERROR; case SSL_AD_EXPORT_RESTRICTION: return TLS1_AD_EXPORT_RESTRICTION; case SSL_AD_PROTOCOL_VERSION: return TLS1_AD_PROTOCOL_VERSION; case SSL_AD_INSUFFICIENT_SECURITY: return TLS1_AD_INSUFFICIENT_SECURITY; case SSL_AD_INTERNAL_ERROR: return TLS1_AD_INTERNAL_ERROR; case SSL_AD_USER_CANCELLED: return TLS1_AD_USER_CANCELLED; case SSL_AD_NO_RENEGOTIATION: return TLS1_AD_NO_RENEGOTIATION; case SSL_AD_UNSUPPORTED_EXTENSION: return TLS1_AD_UNSUPPORTED_EXTENSION; case SSL_AD_CERTIFICATE_UNOBTAINABLE: return TLS1_AD_CERTIFICATE_UNOBTAINABLE; case SSL_AD_UNRECOGNIZED_NAME: return TLS1_AD_UNRECOGNIZED_NAME; case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE; case SSL_AD_BAD_CERTIFICATE_HASH_VALUE: return TLS1_AD_BAD_CERTIFICATE_HASH_VALUE; case SSL_AD_UNKNOWN_PSK_IDENTITY: return TLS1_AD_UNKNOWN_PSK_IDENTITY; case SSL_AD_INAPPROPRIATE_FALLBACK: return TLS1_AD_INAPPROPRIATE_FALLBACK; case SSL_AD_NO_APPLICATION_PROTOCOL: return TLS1_AD_NO_APPLICATION_PROTOCOL; case SSL_AD_CERTIFICATE_REQUIRED: return SSL_AD_HANDSHAKE_FAILURE; case TLS13_AD_MISSING_EXTENSION: return SSL_AD_HANDSHAKE_FAILURE; default: return -1; } }
./openssl/ssl/ssl_init.c	/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/e_os.h" #include "internal/err.h" #include <openssl/crypto.h> #include <openssl/evp.h> #include <openssl/trace.h> #include "ssl_local.h" #include "sslerr.h" #include "internal/thread_once.h" static int stopped; static void ssl_library_stop(void); static CRYPTO_ONCE ssl_base = CRYPTO_ONCE_STATIC_INIT; static int ssl_base_inited = 0; DEFINE_RUN_ONCE_STATIC(ossl_init_ssl_base) { #ifndef OPENSSL_NO_COMP OSSL_TRACE(INIT, "ossl_init_ssl_base: " "SSL_COMP_get_compression_methods()\n"); / * This will initialise the built-in compression algorithms. The value * returned is a STACK_OF(SSL_COMP), but that can be discarded safely / SSL_COMP_get_compression_methods(); #endif ssl_sort_cipher_list(); OSSL_TRACE(INIT, "ossl_init_ssl_base: SSL_add_ssl_module()\n"); / * We ignore an error return here. Not much we can do - but not that bad * either. We can still safely continue. / OPENSSL_atexit(ssl_library_stop); ssl_base_inited = 1; return 1; } static CRYPTO_ONCE ssl_strings = CRYPTO_ONCE_STATIC_INIT; DEFINE_RUN_ONCE_STATIC(ossl_init_load_ssl_strings) { / * OPENSSL_NO_AUTOERRINIT is provided here to prevent at compile time * pulling in all the error strings during static linking / #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT) OSSL_TRACE(INIT, "ossl_init_load_ssl_strings: ossl_err_load_SSL_strings()\n"); ossl_err_load_SSL_strings(); #endif return 1; } DEFINE_RUN_ONCE_STATIC_ALT(ossl_init_no_load_ssl_strings, ossl_init_load_ssl_strings) { / Do nothing in this case / return 1; } static void ssl_library_stop(void) { / Might be explicitly called and also by atexit / if (stopped) return; stopped = 1; if (ssl_base_inited) { #ifndef OPENSSL_NO_COMP OSSL_TRACE(INIT, "ssl_library_stop: " "ssl_comp_free_compression_methods_int()\n"); ssl_comp_free_compression_methods_int(); #endif } } / * If this function is called with a non NULL settings value then it must be * called prior to any threads making calls to any OpenSSL functions, * i.e. passing a non-null settings value is assumed to be single-threaded. / int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS settings) { static int stoperrset = 0; if (stopped) { if (!stoperrset) { /* * We only ever set this once to avoid getting into an infinite * loop where the error system keeps trying to init and fails so * sets an error etc */ stoperrset = 1; ERR_raise(ERR_LIB_SSL, ERR_R_INIT_FAIL); } return 0; } opts \|= OPENSSL_INIT_ADD_ALL_CIPHERS \| OPENSSL_INIT_ADD_ALL_DIGESTS; #ifndef OPENSSL_NO_AUTOLOAD_CONFIG if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG) == 0) opts \|= OPENSSL_INIT_LOAD_CONFIG; #endif if (!OPENSSL_init_crypto(opts, settings)) return 0; if (!RUN_ONCE(&ssl_base, ossl_init_ssl_base)) return 0; if ((opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS) && !RUN_ONCE_ALT(&ssl_strings, ossl_init_no_load_ssl_strings, ossl_init_load_ssl_strings)) return 0; if ((opts & OPENSSL_INIT_LOAD_SSL_STRINGS) && !RUN_ONCE(&ssl_strings, ossl_init_load_ssl_strings)) return 0; return 1; }
./openssl/ssl/ssl_rsa_legacy.c	/* * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / We need to use the deprecated RSA low level calls / #define OPENSSL_SUPPRESS_DEPRECATED #include <openssl/err.h> #include <openssl/rsa.h> #include <openssl/ssl.h> int SSL_use_RSAPrivateKey(SSL ssl, RSA rsa) { EVP_PKEY pkey; int ret; if (rsa == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } if ((pkey = EVP_PKEY_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } RSA_up_ref(rsa); if (EVP_PKEY_assign_RSA(pkey, rsa) <= 0) { RSA_free(rsa); EVP_PKEY_free(pkey); return 0; } ret = SSL_use_PrivateKey(ssl, pkey); EVP_PKEY_free(pkey); return ret; } int SSL_use_RSAPrivateKey_file(SSL ssl, const char file, int type) { int j, ret = 0; BIO in; RSA rsa = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; rsa = d2i_RSAPrivateKey_bio(in, NULL); } else if (type == SSL_FILETYPE_PEM) { j = ERR_R_PEM_LIB; rsa = PEM_read_bio_RSAPrivateKey(in, NULL, SSL_get_default_passwd_cb(ssl), SSL_get_default_passwd_cb_userdata(ssl)); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (rsa == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_use_RSAPrivateKey(ssl, rsa); RSA_free(rsa); end: BIO_free(in); return ret; } int SSL_use_RSAPrivateKey_ASN1(SSL ssl, const unsigned char d, long len) { int ret; const unsigned char p; RSA rsa; p = d; if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_use_RSAPrivateKey(ssl, rsa); RSA_free(rsa); return ret; } int SSL_CTX_use_RSAPrivateKey(SSL_CTX ctx, RSA rsa) { int ret; EVP_PKEY pkey; if (rsa == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } if ((pkey = EVP_PKEY_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } RSA_up_ref(rsa); if (EVP_PKEY_assign_RSA(pkey, rsa) <= 0) { RSA_free(rsa); EVP_PKEY_free(pkey); return 0; } ret = SSL_CTX_use_PrivateKey(ctx, pkey); EVP_PKEY_free(pkey); return ret; } int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX ctx, const char file, int type) { int j, ret = 0; BIO in; RSA rsa = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; rsa = d2i_RSAPrivateKey_bio(in, NULL); } else if (type == SSL_FILETYPE_PEM) { j = ERR_R_PEM_LIB; rsa = PEM_read_bio_RSAPrivateKey(in, NULL, SSL_CTX_get_default_passwd_cb(ctx), SSL_CTX_get_default_passwd_cb_userdata(ctx)); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (rsa == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa); RSA_free(rsa); end: BIO_free(in); return ret; } int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX ctx, const unsigned char d, long len) { int ret; const unsigned char p; RSA *rsa; p = d; if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa); RSA_free(rsa); return ret; }
./openssl/ssl/ssl_cert_table.h	/* * Copyright 2017-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / * Certificate table information. NB: table entries must match SSL_PKEY indices / static const SSL_CERT_LOOKUP ssl_cert_info [] = { {EVP_PKEY_RSA, SSL_aRSA}, / SSL_PKEY_RSA / {EVP_PKEY_RSA_PSS, SSL_aRSA}, / SSL_PKEY_RSA_PSS_SIGN / {EVP_PKEY_DSA, SSL_aDSS}, / SSL_PKEY_DSA_SIGN / {EVP_PKEY_EC, SSL_aECDSA}, / SSL_PKEY_ECC / {NID_id_GostR3410_2001, SSL_aGOST01}, / SSL_PKEY_GOST01 / {NID_id_GostR3410_2012_256, SSL_aGOST12}, / SSL_PKEY_GOST12_256 / {NID_id_GostR3410_2012_512, SSL_aGOST12}, / SSL_PKEY_GOST12_512 / {EVP_PKEY_ED25519, SSL_aECDSA}, / SSL_PKEY_ED25519 / {EVP_PKEY_ED448, SSL_aECDSA} / SSL_PKEY_ED448 */ };
./openssl/ssl/tls13_enc.c	/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdlib.h> #include "ssl_local.h" #include "internal/ktls.h" #include "record/record_local.h" #include "internal/cryptlib.h" #include <openssl/evp.h> #include <openssl/kdf.h> #include <openssl/core_names.h> #define TLS13_MAX_LABEL_LEN 249 / ASCII: "tls13 ", in hex for EBCDIC compatibility / static const unsigned char label_prefix[] = "\x74\x6C\x73\x31\x33\x20"; / * Given a \|secret\|; a \|label\| of length \|labellen\|; and \|data\| of length * \|datalen\| (e.g. typically a hash of the handshake messages), derive a new * secret \|outlen\| bytes long and store it in the location pointed to be \|out\|. * The \|data\| value may be zero length. Any errors will be treated as fatal if * \|fatal\| is set. Returns 1 on success 0 on failure. * If \|raise_error\| is set, ERR_raise is called on failure. / int tls13_hkdf_expand_ex(OSSL_LIB_CTX libctx, const char propq, const EVP_MD md, const unsigned char secret, const unsigned char label, size_t labellen, const unsigned char data, size_t datalen, unsigned char out, size_t outlen, int raise_error) { EVP_KDF kdf = EVP_KDF_fetch(libctx, OSSL_KDF_NAME_TLS1_3_KDF, propq); EVP_KDF_CTX kctx; OSSL_PARAM params[7], p = params; int mode = EVP_PKEY_HKDEF_MODE_EXPAND_ONLY; const char mdname = EVP_MD_get0_name(md); int ret; size_t hashlen; kctx = EVP_KDF_CTX_new(kdf); EVP_KDF_free(kdf); if (kctx == NULL) return 0; if (labellen > TLS13_MAX_LABEL_LEN) { if (raise_error) /* * Probably we have been called from SSL_export_keying_material(), * or SSL_export_keying_material_early(). / ERR_raise(ERR_LIB_SSL, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL); EVP_KDF_CTX_free(kctx); return 0; } if ((ret = EVP_MD_get_size(md)) <= 0) { EVP_KDF_CTX_free(kctx); if (raise_error) ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } hashlen = (size_t)ret; p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode); p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char )mdname, 0); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, (unsigned char )secret, hashlen); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_PREFIX, (unsigned char )label_prefix, sizeof(label_prefix) - 1); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_LABEL, (unsigned char )label, labellen); if (data != NULL) p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_DATA, (unsigned char )data, datalen); p++ = OSSL_PARAM_construct_end(); ret = EVP_KDF_derive(kctx, out, outlen, params) <= 0; EVP_KDF_CTX_free(kctx); if (ret != 0) { if (raise_error) ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); } return ret == 0; } int tls13_hkdf_expand(SSL_CONNECTION s, const EVP_MD md, const unsigned char secret, const unsigned char label, size_t labellen, const unsigned char data, size_t datalen, unsigned char out, size_t outlen, int fatal) { int ret; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); ret = tls13_hkdf_expand_ex(sctx->libctx, sctx->propq, md, secret, label, labellen, data, datalen, out, outlen, !fatal); if (ret == 0 && fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return ret; } /* * Given a \|secret\| generate a \|key\| of length \|keylen\| bytes. Returns 1 on * success 0 on failure. / int tls13_derive_key(SSL_CONNECTION s, const EVP_MD md, const unsigned char secret, unsigned char key, size_t keylen) { / ASCII: "key", in hex for EBCDIC compatibility / static const unsigned char keylabel[] = "\x6B\x65\x79"; return tls13_hkdf_expand(s, md, secret, keylabel, sizeof(keylabel) - 1, NULL, 0, key, keylen, 1); } / * Given a \|secret\| generate an \|iv\| of length \|ivlen\| bytes. Returns 1 on * success 0 on failure. / int tls13_derive_iv(SSL_CONNECTION s, const EVP_MD md, const unsigned char secret, unsigned char iv, size_t ivlen) { / ASCII: "iv", in hex for EBCDIC compatibility / static const unsigned char ivlabel[] = "\x69\x76"; return tls13_hkdf_expand(s, md, secret, ivlabel, sizeof(ivlabel) - 1, NULL, 0, iv, ivlen, 1); } int tls13_derive_finishedkey(SSL_CONNECTION s, const EVP_MD md, const unsigned char secret, unsigned char fin, size_t finlen) { / ASCII: "finished", in hex for EBCDIC compatibility / static const unsigned char finishedlabel[] = "\x66\x69\x6E\x69\x73\x68\x65\x64"; return tls13_hkdf_expand(s, md, secret, finishedlabel, sizeof(finishedlabel) - 1, NULL, 0, fin, finlen, 1); } / * Given the previous secret \|prevsecret\| and a new input secret \|insecret\| of * length \|insecretlen\|, generate a new secret and store it in the location * pointed to by \|outsecret\|. Returns 1 on success 0 on failure. / int tls13_generate_secret(SSL_CONNECTION s, const EVP_MD md, const unsigned char prevsecret, const unsigned char insecret, size_t insecretlen, unsigned char outsecret) { size_t mdlen; int mdleni; int ret; EVP_KDF kdf; EVP_KDF_CTX kctx; OSSL_PARAM params[7], p = params; int mode = EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY; const char mdname = EVP_MD_get0_name(md); /* ASCII: "derived", in hex for EBCDIC compatibility / static const char derived_secret_label[] = "\x64\x65\x72\x69\x76\x65\x64"; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); kdf = EVP_KDF_fetch(sctx->libctx, OSSL_KDF_NAME_TLS1_3_KDF, sctx->propq); kctx = EVP_KDF_CTX_new(kdf); EVP_KDF_free(kdf); if (kctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } mdleni = EVP_MD_get_size(md); /* Ensure cast to size_t is safe / if (!ossl_assert(mdleni >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_KDF_CTX_free(kctx); return 0; } mdlen = (size_t)mdleni; p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode); p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char )mdname, 0); if (insecret != NULL) p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, (unsigned char )insecret, insecretlen); if (prevsecret != NULL) p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT, (unsigned char )prevsecret, mdlen); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_PREFIX, (unsigned char )label_prefix, sizeof(label_prefix) - 1); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_LABEL, (unsigned char )derived_secret_label, sizeof(derived_secret_label) - 1); p++ = OSSL_PARAM_construct_end(); ret = EVP_KDF_derive(kctx, outsecret, mdlen, params) <= 0; if (ret != 0) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_KDF_CTX_free(kctx); return ret == 0; } / * Given an input secret \|insecret\| of length \|insecretlen\| generate the * handshake secret. This requires the early secret to already have been * generated. Returns 1 on success 0 on failure. / int tls13_generate_handshake_secret(SSL_CONNECTION s, const unsigned char insecret, size_t insecretlen) { / Calls SSLfatal() if required / return tls13_generate_secret(s, ssl_handshake_md(s), s->early_secret, insecret, insecretlen, (unsigned char )&s->handshake_secret); } /* * Given the handshake secret \|prev\| of length \|prevlen\| generate the master * secret and store its length in \|secret_size\|. Returns 1 on success 0 on failure. / int tls13_generate_master_secret(SSL_CONNECTION s, unsigned char out, unsigned char prev, size_t prevlen, size_t secret_size) { const EVP_MD md = ssl_handshake_md(s); secret_size = EVP_MD_get_size(md); / Calls SSLfatal() if required / return tls13_generate_secret(s, md, prev, NULL, 0, out); } / * Generates the mac for the Finished message. Returns the length of the MAC or * 0 on error. / size_t tls13_final_finish_mac(SSL_CONNECTION s, const char str, size_t slen, unsigned char out) { const EVP_MD md = ssl_handshake_md(s); const char mdname = EVP_MD_get0_name(md); unsigned char hash[EVP_MAX_MD_SIZE]; unsigned char finsecret[EVP_MAX_MD_SIZE]; unsigned char key = NULL; size_t len = 0, hashlen; OSSL_PARAM params[2], p = params; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (md == NULL) return 0; / Safe to cast away const here since we're not "getting" any data / if (sctx->propq != NULL) p++ = OSSL_PARAM_construct_utf8_string(OSSL_ALG_PARAM_PROPERTIES, (char )sctx->propq, 0); p = OSSL_PARAM_construct_end(); if (!ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) { /* SSLfatal() already called / goto err; } if (str == SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->server_finished_label) { key = s->server_finished_secret; } else if (SSL_IS_FIRST_HANDSHAKE(s)) { key = s->client_finished_secret; } else { if (!tls13_derive_finishedkey(s, md, s->client_app_traffic_secret, finsecret, hashlen)) goto err; key = finsecret; } if (!EVP_Q_mac(sctx->libctx, "HMAC", sctx->propq, mdname, params, key, hashlen, hash, hashlen, / outsize as per sizeof(peer_finish_md) / out, EVP_MAX_MD_SIZE 2, &len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } err: OPENSSL_cleanse(finsecret, sizeof(finsecret)); return len; } /* * There isn't really a key block in TLSv1.3, but we still need this function * for initialising the cipher and hash. Returns 1 on success or 0 on failure. / int tls13_setup_key_block(SSL_CONNECTION s) { const EVP_CIPHER c; const EVP_MD hash; s->session->cipher = s->s3.tmp.new_cipher; if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash, NULL, NULL, NULL, 0)) { /* Error is already recorded / SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); return 0; } ssl_evp_cipher_free(s->s3.tmp.new_sym_enc); s->s3.tmp.new_sym_enc = c; ssl_evp_md_free(s->s3.tmp.new_hash); s->s3.tmp.new_hash = hash; return 1; } static int derive_secret_key_and_iv(SSL_CONNECTION s, const EVP_MD md, const EVP_CIPHER ciph, const unsigned char insecret, const unsigned char hash, const unsigned char label, size_t labellen, unsigned char secret, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, size_t taglen) { int hashleni = EVP_MD_get_size(md); size_t hashlen; int mode; / Ensure cast to size_t is safe / if (!ossl_assert(hashleni >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } hashlen = (size_t)hashleni; if (!tls13_hkdf_expand(s, md, insecret, label, labellen, hash, hashlen, secret, hashlen, 1)) { / SSLfatal() already called / return 0; } keylen = EVP_CIPHER_get_key_length(ciph); mode = EVP_CIPHER_get_mode(ciph); if (mode == EVP_CIPH_CCM_MODE) { uint32_t algenc; ivlen = EVP_CCM_TLS_IV_LEN; if (s->s3.tmp.new_cipher != NULL) { algenc = s->s3.tmp.new_cipher->algorithm_enc; } else if (s->session->cipher != NULL) { / We've not selected a cipher yet - we must be doing early data / algenc = s->session->cipher->algorithm_enc; } else if (s->psksession != NULL && s->psksession->cipher != NULL) { / We must be doing early data with out-of-band PSK / algenc = s->psksession->cipher->algorithm_enc; } else { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } if (algenc & (SSL_AES128CCM8 \| SSL_AES256CCM8)) taglen = EVP_CCM8_TLS_TAG_LEN; else taglen = EVP_CCM_TLS_TAG_LEN; } else { int iivlen; if (mode == EVP_CIPH_GCM_MODE) { taglen = EVP_GCM_TLS_TAG_LEN; } else { /* CHACHA20P-POLY1305 / taglen = EVP_CHACHAPOLY_TLS_TAG_LEN; } iivlen = EVP_CIPHER_get_iv_length(ciph); if (iivlen < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } ivlen = iivlen; } if (!tls13_derive_key(s, md, secret, key, keylen) \|\| !tls13_derive_iv(s, md, secret, iv, ivlen)) { / SSLfatal() already called / return 0; } return 1; } int tls13_change_cipher_state(SSL_CONNECTION s, int which) { /* ASCII: "c e traffic", in hex for EBCDIC compatibility / static const unsigned char client_early_traffic[] = "\x63\x20\x65\x20\x74\x72\x61\x66\x66\x69\x63"; / ASCII: "c hs traffic", in hex for EBCDIC compatibility / static const unsigned char client_handshake_traffic[] = "\x63\x20\x68\x73\x20\x74\x72\x61\x66\x66\x69\x63"; / ASCII: "c ap traffic", in hex for EBCDIC compatibility / static const unsigned char client_application_traffic[] = "\x63\x20\x61\x70\x20\x74\x72\x61\x66\x66\x69\x63"; / ASCII: "s hs traffic", in hex for EBCDIC compatibility / static const unsigned char server_handshake_traffic[] = "\x73\x20\x68\x73\x20\x74\x72\x61\x66\x66\x69\x63"; / ASCII: "s ap traffic", in hex for EBCDIC compatibility / static const unsigned char server_application_traffic[] = "\x73\x20\x61\x70\x20\x74\x72\x61\x66\x66\x69\x63"; / ASCII: "exp master", in hex for EBCDIC compatibility / static const unsigned char exporter_master_secret[] = "\x65\x78\x70\x20\x6D\x61\x73\x74\x65\x72"; / ASCII: "res master", in hex for EBCDIC compatibility / static const unsigned char resumption_master_secret[] = "\x72\x65\x73\x20\x6D\x61\x73\x74\x65\x72"; / ASCII: "e exp master", in hex for EBCDIC compatibility / static const unsigned char early_exporter_master_secret[] = "\x65\x20\x65\x78\x70\x20\x6D\x61\x73\x74\x65\x72"; unsigned char iv[EVP_MAX_IV_LENGTH]; unsigned char key[EVP_MAX_KEY_LENGTH]; unsigned char secret[EVP_MAX_MD_SIZE]; unsigned char hashval[EVP_MAX_MD_SIZE]; unsigned char hash = hashval; unsigned char insecret; unsigned char finsecret = NULL; const char log_label = NULL; size_t finsecretlen = 0; const unsigned char label; size_t labellen, hashlen = 0; int ret = 0; const EVP_MD md = NULL; const EVP_CIPHER cipher = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); size_t keylen, ivlen, taglen; int level; int direction = (which & SSL3_CC_READ) != 0 ? OSSL_RECORD_DIRECTION_READ : OSSL_RECORD_DIRECTION_WRITE; if (((which & SSL3_CC_CLIENT) && (which & SSL3_CC_WRITE)) \|\| ((which & SSL3_CC_SERVER) && (which & SSL3_CC_READ))) { if (which & SSL3_CC_EARLY) { EVP_MD_CTX mdctx = NULL; long handlen; void hdata; unsigned int hashlenui; const SSL_CIPHER sslcipher = SSL_SESSION_get0_cipher(s->session); insecret = s->early_secret; label = client_early_traffic; labellen = sizeof(client_early_traffic) - 1; log_label = CLIENT_EARLY_LABEL; handlen = BIO_get_mem_data(s->s3.handshake_buffer, &hdata); if (handlen <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_LENGTH); goto err; } if (s->early_data_state == SSL_EARLY_DATA_CONNECTING && s->max_early_data > 0 && s->session->ext.max_early_data == 0) { /* * If we are attempting to send early data, and we've decided to * actually do it but max_early_data in s->session is 0 then we * must be using an external PSK. / if (!ossl_assert(s->psksession != NULL && s->max_early_data == s->psksession->ext.max_early_data)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } sslcipher = SSL_SESSION_get0_cipher(s->psksession); } if (sslcipher == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); goto err; } / * We need to calculate the handshake digest using the digest from * the session. We haven't yet selected our ciphersuite so we can't * use ssl_handshake_md(). / mdctx = EVP_MD_CTX_new(); if (mdctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } / * This ups the ref count on cipher so we better make sure we free * it again / if (!ssl_cipher_get_evp_cipher(sctx, sslcipher, &cipher)) { / Error is already recorded / SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); EVP_MD_CTX_free(mdctx); goto err; } md = ssl_md(sctx, sslcipher->algorithm2); if (md == NULL \|\| !EVP_DigestInit_ex(mdctx, md, NULL) \|\| !EVP_DigestUpdate(mdctx, hdata, handlen) \|\| !EVP_DigestFinal_ex(mdctx, hashval, &hashlenui)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_MD_CTX_free(mdctx); goto err; } hashlen = hashlenui; EVP_MD_CTX_free(mdctx); if (!tls13_hkdf_expand(s, md, insecret, early_exporter_master_secret, sizeof(early_exporter_master_secret) - 1, hashval, hashlen, s->early_exporter_master_secret, hashlen, 1)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!ssl_log_secret(s, EARLY_EXPORTER_SECRET_LABEL, s->early_exporter_master_secret, hashlen)) { / SSLfatal() already called / goto err; } } else if (which & SSL3_CC_HANDSHAKE) { insecret = s->handshake_secret; finsecret = s->client_finished_secret; finsecretlen = EVP_MD_get_size(ssl_handshake_md(s)); label = client_handshake_traffic; labellen = sizeof(client_handshake_traffic) - 1; log_label = CLIENT_HANDSHAKE_LABEL; / * The handshake hash used for the server read/client write handshake * traffic secret is the same as the hash for the server * write/client read handshake traffic secret. However, if we * processed early data then we delay changing the server * read/client write cipher state until later, and the handshake * hashes have moved on. Therefore we use the value saved earlier * when we did the server write/client read change cipher state. / hash = s->handshake_traffic_hash; } else { insecret = s->master_secret; label = client_application_traffic; labellen = sizeof(client_application_traffic) - 1; log_label = CLIENT_APPLICATION_LABEL; / * For this we only use the handshake hashes up until the server * Finished hash. We do not include the client's Finished, which is * what ssl_handshake_hash() would give us. Instead we use the * previously saved value. / hash = s->server_finished_hash; } } else { / Early data never applies to client-read/server-write / if (which & SSL3_CC_HANDSHAKE) { insecret = s->handshake_secret; finsecret = s->server_finished_secret; finsecretlen = EVP_MD_get_size(ssl_handshake_md(s)); label = server_handshake_traffic; labellen = sizeof(server_handshake_traffic) - 1; log_label = SERVER_HANDSHAKE_LABEL; } else { insecret = s->master_secret; label = server_application_traffic; labellen = sizeof(server_application_traffic) - 1; log_label = SERVER_APPLICATION_LABEL; } } if (!(which & SSL3_CC_EARLY)) { md = ssl_handshake_md(s); cipher = s->s3.tmp.new_sym_enc; if (!ssl3_digest_cached_records(s, 1) \|\| !ssl_handshake_hash(s, hashval, sizeof(hashval), &hashlen)) { / SSLfatal() already called /; goto err; } } / * Save the hash of handshakes up to now for use when we calculate the * client application traffic secret / if (label == server_application_traffic) memcpy(s->server_finished_hash, hashval, hashlen); if (label == server_handshake_traffic) memcpy(s->handshake_traffic_hash, hashval, hashlen); if (label == client_application_traffic) { / * We also create the resumption master secret, but this time use the * hash for the whole handshake including the Client Finished / if (!tls13_hkdf_expand(s, ssl_handshake_md(s), insecret, resumption_master_secret, sizeof(resumption_master_secret) - 1, hashval, hashlen, s->resumption_master_secret, hashlen, 1)) { / SSLfatal() already called / goto err; } } / check whether cipher is known / if (!ossl_assert(cipher != NULL)) goto err; if (!derive_secret_key_and_iv(s, md, cipher, insecret, hash, label, labellen, secret, key, &keylen, iv, &ivlen, &taglen)) { / SSLfatal() already called / goto err; } if (label == server_application_traffic) { memcpy(s->server_app_traffic_secret, secret, hashlen); / Now we create the exporter master secret / if (!tls13_hkdf_expand(s, ssl_handshake_md(s), insecret, exporter_master_secret, sizeof(exporter_master_secret) - 1, hash, hashlen, s->exporter_master_secret, hashlen, 1)) { / SSLfatal() already called / goto err; } if (!ssl_log_secret(s, EXPORTER_SECRET_LABEL, s->exporter_master_secret, hashlen)) { / SSLfatal() already called / goto err; } } else if (label == client_application_traffic) memcpy(s->client_app_traffic_secret, secret, hashlen); if (!ssl_log_secret(s, log_label, secret, hashlen)) { / SSLfatal() already called / goto err; } if (finsecret != NULL && !tls13_derive_finishedkey(s, ssl_handshake_md(s), secret, finsecret, finsecretlen)) { / SSLfatal() already called / goto err; } if ((which & SSL3_CC_WRITE) != 0) { if (!s->server && label == client_early_traffic) s->rlayer.wrlmethod->set_plain_alerts(s->rlayer.wrl, 1); else s->rlayer.wrlmethod->set_plain_alerts(s->rlayer.wrl, 0); } level = (which & SSL3_CC_EARLY) != 0 ? OSSL_RECORD_PROTECTION_LEVEL_EARLY : ((which &SSL3_CC_HANDSHAKE) != 0 ? OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE : OSSL_RECORD_PROTECTION_LEVEL_APPLICATION); if (!ssl_set_new_record_layer(s, s->version, direction, level, secret, hashlen, key, keylen, iv, ivlen, NULL, 0, cipher, taglen, NID_undef, NULL, NULL, md)) { / SSLfatal already called / goto err; } ret = 1; err: if ((which & SSL3_CC_EARLY) != 0) { / We up-refed this so now we need to down ref / ssl_evp_cipher_free(cipher); } OPENSSL_cleanse(key, sizeof(key)); OPENSSL_cleanse(secret, sizeof(secret)); return ret; } int tls13_update_key(SSL_CONNECTION s, int sending) { /* ASCII: "traffic upd", in hex for EBCDIC compatibility / static const unsigned char application_traffic[] = "\x74\x72\x61\x66\x66\x69\x63\x20\x75\x70\x64"; const EVP_MD md = ssl_handshake_md(s); size_t hashlen; unsigned char key[EVP_MAX_KEY_LENGTH]; unsigned char insecret; unsigned char secret[EVP_MAX_MD_SIZE]; char log_label; size_t keylen, ivlen, taglen; int ret = 0, l; int direction = sending ? OSSL_RECORD_DIRECTION_WRITE : OSSL_RECORD_DIRECTION_READ; unsigned char iv[EVP_MAX_IV_LENGTH]; if ((l = EVP_MD_get_size(md)) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } hashlen = (size_t)l; if (s->server == sending) insecret = s->server_app_traffic_secret; else insecret = s->client_app_traffic_secret; if (!derive_secret_key_and_iv(s, md, s->s3.tmp.new_sym_enc, insecret, NULL, application_traffic, sizeof(application_traffic) - 1, secret, key, &keylen, iv, &ivlen, &taglen)) { /* SSLfatal() already called / goto err; } memcpy(insecret, secret, hashlen); if (!ssl_set_new_record_layer(s, s->version, direction, OSSL_RECORD_PROTECTION_LEVEL_APPLICATION, insecret, hashlen, key, keylen, iv, ivlen, NULL, 0, s->s3.tmp.new_sym_enc, taglen, NID_undef, NULL, NULL, md)) { / SSLfatal already called / goto err; } / Call Key log on successful traffic secret update / log_label = s->server == sending ? SERVER_APPLICATION_N_LABEL : CLIENT_APPLICATION_N_LABEL; if (!ssl_log_secret(s, log_label, secret, hashlen)) { / SSLfatal() already called / goto err; } ret = 1; err: OPENSSL_cleanse(key, sizeof(key)); OPENSSL_cleanse(secret, sizeof(secret)); return ret; } int tls13_alert_code(int code) { / There are 2 additional alerts in TLSv1.3 compared to TLSv1.2 / if (code == SSL_AD_MISSING_EXTENSION \|\| code == SSL_AD_CERTIFICATE_REQUIRED) return code; return tls1_alert_code(code); } int tls13_export_keying_material(SSL_CONNECTION s, unsigned char out, size_t olen, const char label, size_t llen, const unsigned char context, size_t contextlen, int use_context) { unsigned char exportsecret[EVP_MAX_MD_SIZE]; / ASCII: "exporter", in hex for EBCDIC compatibility / static const unsigned char exporterlabel[] = "\x65\x78\x70\x6F\x72\x74\x65\x72"; unsigned char hash[EVP_MAX_MD_SIZE], data[EVP_MAX_MD_SIZE]; const EVP_MD md = ssl_handshake_md(s); EVP_MD_CTX ctx = EVP_MD_CTX_new(); unsigned int hashsize, datalen; int ret = 0; if (ctx == NULL \|\| md == NULL \|\| !ossl_statem_export_allowed(s)) goto err; if (!use_context) contextlen = 0; if (EVP_DigestInit_ex(ctx, md, NULL) <= 0 \|\| EVP_DigestUpdate(ctx, context, contextlen) <= 0 \|\| EVP_DigestFinal_ex(ctx, hash, &hashsize) <= 0 \|\| EVP_DigestInit_ex(ctx, md, NULL) <= 0 \|\| EVP_DigestFinal_ex(ctx, data, &datalen) <= 0 \|\| !tls13_hkdf_expand(s, md, s->exporter_master_secret, (const unsigned char )label, llen, data, datalen, exportsecret, hashsize, 0) \|\| !tls13_hkdf_expand(s, md, exportsecret, exporterlabel, sizeof(exporterlabel) - 1, hash, hashsize, out, olen, 0)) goto err; ret = 1; err: EVP_MD_CTX_free(ctx); return ret; } int tls13_export_keying_material_early(SSL_CONNECTION s, unsigned char out, size_t olen, const char label, size_t llen, const unsigned char context, size_t contextlen) { /* ASCII: "exporter", in hex for EBCDIC compatibility / static const unsigned char exporterlabel[] = "\x65\x78\x70\x6F\x72\x74\x65\x72"; unsigned char exportsecret[EVP_MAX_MD_SIZE]; unsigned char hash[EVP_MAX_MD_SIZE], data[EVP_MAX_MD_SIZE]; const EVP_MD md; EVP_MD_CTX ctx = EVP_MD_CTX_new(); unsigned int hashsize, datalen; int ret = 0; const SSL_CIPHER sslcipher; if (ctx == NULL \|\| !ossl_statem_export_early_allowed(s)) goto err; if (!s->server && s->max_early_data > 0 && s->session->ext.max_early_data == 0) sslcipher = SSL_SESSION_get0_cipher(s->psksession); else sslcipher = SSL_SESSION_get0_cipher(s->session); md = ssl_md(SSL_CONNECTION_GET_CTX(s), sslcipher->algorithm2); /* * Calculate the hash value and store it in \|data\|. The reason why * the empty string is used is that the definition of TLS-Exporter * is like so: * * TLS-Exporter(label, context_value, key_length) = * HKDF-Expand-Label(Derive-Secret(Secret, label, ""), * "exporter", Hash(context_value), key_length) * * Derive-Secret(Secret, Label, Messages) = * HKDF-Expand-Label(Secret, Label, * Transcript-Hash(Messages), Hash.length) * * Here Transcript-Hash is the cipher suite hash algorithm. / if (md == NULL \|\| EVP_DigestInit_ex(ctx, md, NULL) <= 0 \|\| EVP_DigestUpdate(ctx, context, contextlen) <= 0 \|\| EVP_DigestFinal_ex(ctx, hash, &hashsize) <= 0 \|\| EVP_DigestInit_ex(ctx, md, NULL) <= 0 \|\| EVP_DigestFinal_ex(ctx, data, &datalen) <= 0 \|\| !tls13_hkdf_expand(s, md, s->early_exporter_master_secret, (const unsigned char )label, llen, data, datalen, exportsecret, hashsize, 0) \|\| !tls13_hkdf_expand(s, md, exportsecret, exporterlabel, sizeof(exporterlabel) - 1, hash, hashsize, out, olen, 0)) goto err; ret = 1; err: EVP_MD_CTX_free(ctx); return ret; }
./openssl/ssl/tls_depr.c	/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / We need to use some engine and HMAC deprecated APIs / #define OPENSSL_SUPPRESS_DEPRECATED #include <openssl/engine.h> #include "ssl_local.h" / * Engine APIs are only used to support applications that still use ENGINEs. * Once ENGINE is removed completely, all of this code can also be removed. / #ifndef OPENSSL_NO_ENGINE void tls_engine_finish(ENGINE e) { ENGINE_finish(e); } #endif const EVP_CIPHER tls_get_cipher_from_engine(int nid) { const EVP_CIPHER ret = NULL; #ifndef OPENSSL_NO_ENGINE ENGINE eng; / * If there is an Engine available for this cipher we use the "implicit" * form to ensure we use that engine later. / eng = ENGINE_get_cipher_engine(nid); if (eng != NULL) { ret = ENGINE_get_cipher(eng, nid); ENGINE_finish(eng); } #endif return ret; } const EVP_MD tls_get_digest_from_engine(int nid) { const EVP_MD ret = NULL; #ifndef OPENSSL_NO_ENGINE ENGINE eng; /* * If there is an Engine available for this digest we use the "implicit" * form to ensure we use that engine later. / eng = ENGINE_get_digest_engine(nid); if (eng != NULL) { ret = ENGINE_get_digest(eng, nid); ENGINE_finish(eng); } #endif return ret; } #ifndef OPENSSL_NO_ENGINE int tls_engine_load_ssl_client_cert(SSL_CONNECTION s, X509 px509, EVP_PKEY ppkey) { SSL ssl = SSL_CONNECTION_GET_SSL(s); return ENGINE_load_ssl_client_cert(SSL_CONNECTION_GET_CTX(s)->client_cert_engine, ssl, SSL_get_client_CA_list(ssl), px509, ppkey, NULL, NULL, NULL); } #endif #ifndef OPENSSL_NO_ENGINE int SSL_CTX_set_client_cert_engine(SSL_CTX ctx, ENGINE e) { if (!ENGINE_init(e)) { ERR_raise(ERR_LIB_SSL, ERR_R_ENGINE_LIB); return 0; } if (!ENGINE_get_ssl_client_cert_function(e)) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CLIENT_CERT_METHOD); ENGINE_finish(e); return 0; } ctx->client_cert_engine = e; return 1; } #endif / * The HMAC APIs below are only used to support the deprecated public API * macro SSL_CTX_set_tlsext_ticket_key_cb(). The application supplied callback * takes an HMAC_CTX in its argument list. The preferred alternative is * SSL_CTX_set_tlsext_ticket_key_evp_cb(). Once * SSL_CTX_set_tlsext_ticket_key_cb() is removed, then all of this code can also * be removed. / #ifndef OPENSSL_NO_DEPRECATED_3_0 int ssl_hmac_old_new(SSL_HMAC ret) { ret->old_ctx = HMAC_CTX_new(); if (ret->old_ctx == NULL) return 0; return 1; } void ssl_hmac_old_free(SSL_HMAC ctx) { HMAC_CTX_free(ctx->old_ctx); } int ssl_hmac_old_init(SSL_HMAC ctx, void key, size_t len, char md) { return HMAC_Init_ex(ctx->old_ctx, key, len, EVP_get_digestbyname(md), NULL); } int ssl_hmac_old_update(SSL_HMAC ctx, const unsigned char data, size_t len) { return HMAC_Update(ctx->old_ctx, data, len); } int ssl_hmac_old_final(SSL_HMAC ctx, unsigned char md, size_t len) { unsigned int l; if (HMAC_Final(ctx->old_ctx, md, &l) > 0) { if (len != NULL) len = l; return 1; } return 0; } size_t ssl_hmac_old_size(const SSL_HMAC ctx) { return HMAC_size(ctx->old_ctx); } HMAC_CTX ssl_hmac_get0_HMAC_CTX(SSL_HMAC ctx) { return ctx->old_ctx; } / Some deprecated public APIs pass DH objects / EVP_PKEY ssl_dh_to_pkey(DH dh) { # ifndef OPENSSL_NO_DH EVP_PKEY ret; if (dh == NULL) return NULL; ret = EVP_PKEY_new(); if (EVP_PKEY_set1_DH(ret, dh) <= 0) { EVP_PKEY_free(ret); return NULL; } return ret; # else return NULL; # endif } /* Some deprecated public APIs pass EC_KEY objects / int ssl_set_tmp_ecdh_groups(uint16_t pext, size_t pextlen, void key) { # ifndef OPENSSL_NO_EC const EC_GROUP group = EC_KEY_get0_group((const EC_KEY )key); int nid; if (group == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_MISSING_PARAMETERS); return 0; } nid = EC_GROUP_get_curve_name(group); if (nid == NID_undef) return 0; return tls1_set_groups(pext, pextlen, &nid, 1); # else return 0; # endif } / * Set the callback for generating temporary DH keys. * ctx: the SSL context. * dh: the callback / # if !defined(OPENSSL_NO_DH) void SSL_CTX_set_tmp_dh_callback(SSL_CTX ctx, DH (dh) (SSL ssl, int is_export, int keylength)) { SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void ()(void))dh); } void SSL_set_tmp_dh_callback(SSL ssl, DH (dh) (SSL ssl, int is_export, int keylength)) { SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void ()(void))dh); } # endif #endif / OPENSSL_NO_DEPRECATED */
./openssl/ssl/bio_ssl.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <openssl/crypto.h> #include "internal/bio.h" #include <openssl/err.h> #include "ssl_local.h" static int ssl_write(BIO h, const char buf, size_t size, size_t written); static int ssl_read(BIO b, char buf, size_t size, size_t readbytes); static int ssl_puts(BIO h, const char str); static long ssl_ctrl(BIO h, int cmd, long arg1, void arg2); static int ssl_new(BIO h); static int ssl_free(BIO data); static long ssl_callback_ctrl(BIO h, int cmd, BIO_info_cb fp); typedef struct bio_ssl_st { SSL ssl; /* The ssl handle :-) / / * Re-negotiate every time the total number of bytes is this size * or when timeout expires. * There is no proper support for TLS-1.3 or QUIC yet. / int num_renegotiates; unsigned long renegotiate_count; size_t byte_count; unsigned long renegotiate_timeout; unsigned long last_time; } BIO_SSL; static const BIO_METHOD methods_sslp = { BIO_TYPE_SSL, "ssl", ssl_write, NULL, / ssl_write_old, / ssl_read, NULL, / ssl_read_old, / ssl_puts, NULL, / ssl_gets, / ssl_ctrl, ssl_new, ssl_free, ssl_callback_ctrl, }; const BIO_METHOD BIO_f_ssl(void) { return &methods_sslp; } static int ssl_new(BIO bi) { BIO_SSL bs = OPENSSL_zalloc(sizeof(bs)); if (bs == NULL) return 0; BIO_set_init(bi, 0); BIO_set_data(bi, bs); / Clear all flags / BIO_clear_flags(bi, ~0); return 1; } static int ssl_free(BIO a) { BIO_SSL bs; if (a == NULL) return 0; bs = BIO_get_data(a); if (BIO_get_shutdown(a)) { if (bs->ssl != NULL) SSL_shutdown(bs->ssl); if (BIO_get_init(a)) SSL_free(bs->ssl); BIO_clear_flags(a, ~0); / Clear all flags / BIO_set_init(a, 0); } OPENSSL_free(bs); return 1; } static int ssl_read(BIO b, char buf, size_t size, size_t readbytes) { int ret = 1; BIO_SSL sb; SSL ssl; int retry_reason = 0; int r = 0; if (buf == NULL) return 0; sb = BIO_get_data(b); ssl = sb->ssl; BIO_clear_retry_flags(b); ret = ssl_read_internal(ssl, buf, size, readbytes); switch (SSL_get_error(ssl, ret)) { case SSL_ERROR_NONE: if (sb->renegotiate_count > 0) { sb->byte_count += readbytes; if (sb->byte_count > sb->renegotiate_count) { sb->byte_count = 0; sb->num_renegotiates++; SSL_renegotiate(ssl); r = 1; } } if ((sb->renegotiate_timeout > 0) && (!r)) { unsigned long tm; tm = (unsigned long)time(NULL); if (tm > sb->last_time + sb->renegotiate_timeout) { sb->last_time = tm; sb->num_renegotiates++; SSL_renegotiate(ssl); } } break; case SSL_ERROR_WANT_READ: BIO_set_retry_read(b); break; case SSL_ERROR_WANT_WRITE: BIO_set_retry_write(b); break; case SSL_ERROR_WANT_X509_LOOKUP: BIO_set_retry_special(b); retry_reason = BIO_RR_SSL_X509_LOOKUP; break; case SSL_ERROR_WANT_ACCEPT: BIO_set_retry_special(b); retry_reason = BIO_RR_ACCEPT; break; case SSL_ERROR_WANT_CONNECT: BIO_set_retry_special(b); retry_reason = BIO_RR_CONNECT; break; case SSL_ERROR_SYSCALL: case SSL_ERROR_SSL: case SSL_ERROR_ZERO_RETURN: default: break; } BIO_set_retry_reason(b, retry_reason); return ret; } static int ssl_write(BIO b, const char buf, size_t size, size_t written) { int ret, r = 0; int retry_reason = 0; SSL ssl; BIO_SSL bs; if (buf == NULL) return 0; bs = BIO_get_data(b); ssl = bs->ssl; BIO_clear_retry_flags(b); ret = ssl_write_internal(ssl, buf, size, written); switch (SSL_get_error(ssl, ret)) { case SSL_ERROR_NONE: if (bs->renegotiate_count > 0) { bs->byte_count += written; if (bs->byte_count > bs->renegotiate_count) { bs->byte_count = 0; bs->num_renegotiates++; SSL_renegotiate(ssl); r = 1; } } if ((bs->renegotiate_timeout > 0) && (!r)) { unsigned long tm; tm = (unsigned long)time(NULL); if (tm > bs->last_time + bs->renegotiate_timeout) { bs->last_time = tm; bs->num_renegotiates++; SSL_renegotiate(ssl); } } break; case SSL_ERROR_WANT_WRITE: BIO_set_retry_write(b); break; case SSL_ERROR_WANT_READ: BIO_set_retry_read(b); break; case SSL_ERROR_WANT_X509_LOOKUP: BIO_set_retry_special(b); retry_reason = BIO_RR_SSL_X509_LOOKUP; break; case SSL_ERROR_WANT_CONNECT: BIO_set_retry_special(b); retry_reason = BIO_RR_CONNECT; case SSL_ERROR_SYSCALL: case SSL_ERROR_SSL: default: break; } BIO_set_retry_reason(b, retry_reason); return ret; } static long ssl_ctrl(BIO b, int cmd, long num, void ptr) { SSL sslp, ssl; BIO_SSL bs, dbs; BIO dbio, bio; long ret = 1; BIO next; SSL_CONNECTION sc = NULL; bs = BIO_get_data(b); next = BIO_next(b); ssl = bs->ssl; if (ssl == NULL && cmd != BIO_C_SET_SSL) return 0; switch (cmd) { case BIO_CTRL_RESET: /* TODO(QUIC FUTURE): Add support when SSL_clear() is supported / if ((sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl)) == NULL) return 0; SSL_shutdown(ssl); if (sc->handshake_func == ssl->method->ssl_connect) SSL_set_connect_state(ssl); else if (sc->handshake_func == ssl->method->ssl_accept) SSL_set_accept_state(ssl); if (!SSL_clear(ssl)) { ret = 0; break; } if (next != NULL) ret = BIO_ctrl(next, cmd, num, ptr); else if (sc->rbio != NULL) ret = BIO_ctrl(sc->rbio, cmd, num, ptr); else ret = 1; break; case BIO_CTRL_INFO: ret = 0; break; case BIO_C_SSL_MODE: if (num) / client mode / SSL_set_connect_state(ssl); else SSL_set_accept_state(ssl); break; case BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT: ret = bs->renegotiate_timeout; if (num < 60) num = 5; bs->renegotiate_timeout = (unsigned long)num; bs->last_time = (unsigned long)time(NULL); break; case BIO_C_SET_SSL_RENEGOTIATE_BYTES: ret = bs->renegotiate_count; if ((long)num >= 512) bs->renegotiate_count = (unsigned long)num; break; case BIO_C_GET_SSL_NUM_RENEGOTIATES: ret = bs->num_renegotiates; break; case BIO_C_SET_SSL: if (ssl != NULL) { ssl_free(b); if (!ssl_new(b)) return 0; bs = BIO_get_data(b); } BIO_set_shutdown(b, num); ssl = (SSL )ptr; bs->ssl = ssl; bio = SSL_get_rbio(ssl); if (bio != NULL) { if (next != NULL) BIO_push(bio, next); BIO_set_next(b, bio); BIO_up_ref(bio); } BIO_set_init(b, 1); break; case BIO_C_GET_SSL: if (ptr != NULL) { sslp = (SSL *)ptr; sslp = ssl; } else ret = 0; break; case BIO_CTRL_GET_CLOSE: ret = BIO_get_shutdown(b); break; case BIO_CTRL_SET_CLOSE: BIO_set_shutdown(b, (int)num); break; case BIO_CTRL_WPENDING: ret = BIO_ctrl(SSL_get_wbio(ssl), cmd, num, ptr); break; case BIO_CTRL_PENDING: ret = SSL_pending(ssl); if (ret == 0) ret = BIO_pending(SSL_get_rbio(ssl)); break; case BIO_CTRL_FLUSH: BIO_clear_retry_flags(b); ret = BIO_ctrl(SSL_get_wbio(ssl), cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_PUSH: if ((next != NULL) && (next != SSL_get_rbio(ssl))) { /* * We are going to pass ownership of next to the SSL object...but * we don't own a reference to pass yet - so up ref / BIO_up_ref(next); SSL_set_bio(ssl, next, next); } break; case BIO_CTRL_POP: / Only detach if we are the BIO explicitly being popped / if (b == ptr) { / This will clear the reference we obtained during push / SSL_set_bio(ssl, NULL, NULL); } break; case BIO_C_DO_STATE_MACHINE: BIO_clear_retry_flags(b); BIO_set_retry_reason(b, 0); ret = (int)SSL_do_handshake(ssl); switch (SSL_get_error(ssl, (int)ret)) { case SSL_ERROR_WANT_READ: BIO_set_flags(b, BIO_FLAGS_READ \| BIO_FLAGS_SHOULD_RETRY); break; case SSL_ERROR_WANT_WRITE: BIO_set_flags(b, BIO_FLAGS_WRITE \| BIO_FLAGS_SHOULD_RETRY); break; case SSL_ERROR_WANT_CONNECT: BIO_set_flags(b, BIO_FLAGS_IO_SPECIAL \| BIO_FLAGS_SHOULD_RETRY); BIO_set_retry_reason(b, BIO_get_retry_reason(next)); break; case SSL_ERROR_WANT_X509_LOOKUP: BIO_set_retry_special(b); BIO_set_retry_reason(b, BIO_RR_SSL_X509_LOOKUP); break; default: break; } break; case BIO_CTRL_DUP: dbio = (BIO )ptr; dbs = BIO_get_data(dbio); SSL_free(dbs->ssl); dbs->ssl = SSL_dup(ssl); dbs->num_renegotiates = bs->num_renegotiates; dbs->renegotiate_count = bs->renegotiate_count; dbs->byte_count = bs->byte_count; dbs->renegotiate_timeout = bs->renegotiate_timeout; dbs->last_time = bs->last_time; ret = (dbs->ssl != NULL); break; case BIO_C_GET_FD: ret = BIO_ctrl(SSL_get_rbio(ssl), cmd, num, ptr); break; case BIO_CTRL_SET_CALLBACK: ret = 0; /* use callback ctrl / break; case BIO_CTRL_GET_RPOLL_DESCRIPTOR: if (!SSL_get_rpoll_descriptor(ssl, (BIO_POLL_DESCRIPTOR )ptr)) ret = 0; break; case BIO_CTRL_GET_WPOLL_DESCRIPTOR: if (!SSL_get_wpoll_descriptor(ssl, (BIO_POLL_DESCRIPTOR )ptr)) ret = 0; break; default: ret = BIO_ctrl(SSL_get_rbio(ssl), cmd, num, ptr); break; } return ret; } static long ssl_callback_ctrl(BIO b, int cmd, BIO_info_cb fp) { SSL ssl; BIO_SSL bs; long ret = 1; bs = BIO_get_data(b); ssl = bs->ssl; switch (cmd) { case BIO_CTRL_SET_CALLBACK: ret = BIO_callback_ctrl(SSL_get_rbio(ssl), cmd, fp); break; default: ret = 0; break; } return ret; } static int ssl_puts(BIO bp, const char str) { int n, ret; n = strlen(str); ret = BIO_write(bp, str, n); return ret; } BIO BIO_new_buffer_ssl_connect(SSL_CTX ctx) { #ifndef OPENSSL_NO_SOCK BIO ret = NULL, buf = NULL, ssl = NULL; # ifndef OPENSSL_NO_QUIC if (ctx != NULL && IS_QUIC_CTX(ctx)) /* Never use buffering for QUIC. / return BIO_new_ssl_connect(ctx); # endif if ((buf = BIO_new(BIO_f_buffer())) == NULL) return NULL; if ((ssl = BIO_new_ssl_connect(ctx)) == NULL) goto err; if ((ret = BIO_push(buf, ssl)) == NULL) goto err; return ret; err: BIO_free(buf); BIO_free(ssl); #endif return NULL; } BIO BIO_new_ssl_connect(SSL_CTX ctx) { #ifndef OPENSSL_NO_SOCK BIO ret = NULL, con = NULL, ssl = NULL; if ((con = BIO_new(BIO_s_connect())) == NULL) return NULL; # ifndef OPENSSL_NO_QUIC if (ctx != NULL && IS_QUIC_CTX(ctx)) if (!BIO_set_sock_type(con, SOCK_DGRAM)) goto err; #endif if ((ssl = BIO_new_ssl(ctx, 1)) == NULL) goto err; if ((ret = BIO_push(ssl, con)) == NULL) goto err; return ret; err: BIO_free(ssl); BIO_free(con); #endif return NULL; } BIO BIO_new_ssl(SSL_CTX ctx, int client) { BIO ret; SSL ssl; if ((ret = BIO_new(BIO_f_ssl())) == NULL) return NULL; if ((ssl = SSL_new(ctx)) == NULL) { BIO_free(ret); return NULL; } if (client) SSL_set_connect_state(ssl); else SSL_set_accept_state(ssl); BIO_set_ssl(ret, ssl, BIO_CLOSE); return ret; } int BIO_ssl_copy_session_id(BIO t, BIO f) { BIO_SSL tdata, fdata; t = BIO_find_type(t, BIO_TYPE_SSL); f = BIO_find_type(f, BIO_TYPE_SSL); if ((t == NULL) \|\| (f == NULL)) return 0; tdata = BIO_get_data(t); fdata = BIO_get_data(f); if ((tdata->ssl == NULL) \|\| (fdata->ssl == NULL)) return 0; if (!SSL_copy_session_id(tdata->ssl, (fdata->ssl))) return 0; return 1; } void BIO_ssl_shutdown(BIO b) { BIO_SSL bdata; for (; b != NULL; b = BIO_next(b)) { if (BIO_method_type(b) != BIO_TYPE_SSL) continue; bdata = BIO_get_data(b); if (bdata != NULL && bdata->ssl != NULL) SSL_shutdown(bdata->ssl); } }
./openssl/ssl/s3_msg.c	/* * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "ssl_local.h" int ssl3_do_change_cipher_spec(SSL_CONNECTION s) { int i; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->server) i = SSL3_CHANGE_CIPHER_SERVER_READ; else i = SSL3_CHANGE_CIPHER_CLIENT_READ; if (s->s3.tmp.key_block == NULL) { if (s->session == NULL \|\| s->session->master_key_length == 0) { / might happen if dtls1_read_bytes() calls this / ERR_raise(ERR_LIB_SSL, SSL_R_CCS_RECEIVED_EARLY); return 0; } s->session->cipher = s->s3.tmp.new_cipher; if (!ssl->method->ssl3_enc->setup_key_block(s)) { / SSLfatal() already called / return 0; } } if (!ssl->method->ssl3_enc->change_cipher_state(s, i)) { / SSLfatal() already called / return 0; } return 1; } int ssl3_send_alert(SSL_CONNECTION s, int level, int desc) { SSL ssl = SSL_CONNECTION_GET_SSL(s); / Map tls/ssl alert value to correct one / if (SSL_CONNECTION_TREAT_AS_TLS13(s)) desc = tls13_alert_code(desc); else desc = ssl->method->ssl3_enc->alert_value(desc); if (s->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION) desc = SSL_AD_HANDSHAKE_FAILURE; / SSL 3.0 does not have * protocol_version alerts / if (desc < 0) return -1; if (s->shutdown & SSL_SENT_SHUTDOWN && desc != SSL_AD_CLOSE_NOTIFY) return -1; / If a fatal one, remove from cache / if ((level == SSL3_AL_FATAL) && (s->session != NULL)) SSL_CTX_remove_session(s->session_ctx, s->session); s->s3.alert_dispatch = SSL_ALERT_DISPATCH_PENDING; s->s3.send_alert[0] = level; s->s3.send_alert[1] = desc; if (!RECORD_LAYER_write_pending(&s->rlayer)) { / data still being written out? / return ssl->method->ssl_dispatch_alert(ssl); } / * else data is still being written out, we will get written some time in * the future / return -1; } int ssl3_dispatch_alert(SSL s) { int i, j; void (cb) (const SSL ssl, int type, int val) = NULL; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); OSSL_RECORD_TEMPLATE templ; if (sc == NULL) return -1; if (sc->rlayer.wrlmethod == NULL) { / No write record layer so we can't sent and alert. We just ignore it / sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; return 1; } templ.type = SSL3_RT_ALERT; templ.version = (sc->version == TLS1_3_VERSION) ? TLS1_2_VERSION : sc->version; if (SSL_get_state(s) == TLS_ST_CW_CLNT_HELLO && !sc->renegotiate && TLS1_get_version(s) > TLS1_VERSION && sc->hello_retry_request == SSL_HRR_NONE) { templ.version = TLS1_VERSION; } templ.buf = &sc->s3.send_alert[0]; templ.buflen = 2; if (RECORD_LAYER_write_pending(&sc->rlayer)) { if (sc->s3.alert_dispatch != SSL_ALERT_DISPATCH_RETRY) { / * We have a write pending but it wasn't from a previous call to * this function! Can we ever get here? Maybe via API misuse?? * Give up. / sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; return -1; } / Retry what we've already got pending / i = HANDLE_RLAYER_WRITE_RETURN(sc, sc->rlayer.wrlmethod->retry_write_records(sc->rlayer.wrl)); if (i <= 0) { / Could be NBIO. Keep alert_dispatch as SSL_ALERT_DISPATCH_RETRY / return -1; } sc->rlayer.wpend_tot = 0; sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; return 1; } i = HANDLE_RLAYER_WRITE_RETURN(sc, sc->rlayer.wrlmethod->write_records(sc->rlayer.wrl, &templ, 1)); if (i <= 0) { sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_RETRY; sc->rlayer.wpend_tot = templ.buflen; sc->rlayer.wpend_type = templ.type; sc->rlayer.wpend_buf = templ.buf; } else { / * Alert sent to BIO - now flush. If the message does not get sent due * to non-blocking IO, we will not worry too much. */ (void)BIO_flush(sc->wbio); sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; if (sc->msg_callback) sc->msg_callback(1, sc->version, SSL3_RT_ALERT, sc->s3.send_alert, 2, s, sc->msg_callback_arg); if (sc->info_callback != NULL) cb = sc->info_callback; else if (s->ctx->info_callback != NULL) cb = s->ctx->info_callback; if (cb != NULL) { j = (sc->s3.send_alert[0] << 8) \| sc->s3.send_alert[1]; cb(s, SSL_CB_WRITE_ALERT, j); } } return i; }
./openssl/ssl/tls_srp.c	/* * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2004, EdelKey Project. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html * * Originally written by Christophe Renou and Peter Sylvester, * for the EdelKey project. / / * We need to use the SRP deprecated APIs in order to implement the SSL SRP * APIs - which are themselves deprecated. / #define OPENSSL_SUPPRESS_DEPRECATED #include <openssl/crypto.h> #include <openssl/rand.h> #include <openssl/err.h> #include "ssl_local.h" #ifndef OPENSSL_NO_SRP # include <openssl/srp.h> / * The public API SSL_CTX_SRP_CTX_free() is deprecated so we use * ssl_ctx_srp_ctx_free_intern() internally. / int ssl_ctx_srp_ctx_free_intern(SSL_CTX ctx) { if (ctx == NULL) return 0; OPENSSL_free(ctx->srp_ctx.login); OPENSSL_free(ctx->srp_ctx.info); BN_free(ctx->srp_ctx.N); BN_free(ctx->srp_ctx.g); BN_free(ctx->srp_ctx.s); BN_free(ctx->srp_ctx.B); BN_free(ctx->srp_ctx.A); BN_free(ctx->srp_ctx.a); BN_free(ctx->srp_ctx.b); BN_free(ctx->srp_ctx.v); memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx)); ctx->srp_ctx.strength = SRP_MINIMAL_N; return 1; } int SSL_CTX_SRP_CTX_free(SSL_CTX ctx) { return ssl_ctx_srp_ctx_free_intern(ctx); } / * The public API SSL_SRP_CTX_free() is deprecated so we use * ssl_srp_ctx_free_intern() internally. / int ssl_srp_ctx_free_intern(SSL_CONNECTION s) { if (s == NULL) return 0; OPENSSL_free(s->srp_ctx.login); OPENSSL_free(s->srp_ctx.info); BN_free(s->srp_ctx.N); BN_free(s->srp_ctx.g); BN_free(s->srp_ctx.s); BN_free(s->srp_ctx.B); BN_free(s->srp_ctx.A); BN_free(s->srp_ctx.a); BN_free(s->srp_ctx.b); BN_free(s->srp_ctx.v); memset(&s->srp_ctx, 0, sizeof(s->srp_ctx)); s->srp_ctx.strength = SRP_MINIMAL_N; return 1; } int SSL_SRP_CTX_free(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); /* the call works with NULL sc / return ssl_srp_ctx_free_intern(sc); } / * The public API SSL_SRP_CTX_init() is deprecated so we use * ssl_srp_ctx_init_intern() internally. / int ssl_srp_ctx_init_intern(SSL_CONNECTION s) { SSL_CTX ctx; if (s == NULL \|\| (ctx = SSL_CONNECTION_GET_CTX(s)) == NULL) return 0; memset(&s->srp_ctx, 0, sizeof(s->srp_ctx)); s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg; / set client Hello login callback / s->srp_ctx.TLS_ext_srp_username_callback = ctx->srp_ctx.TLS_ext_srp_username_callback; / set SRP N/g param callback for verification / s->srp_ctx.SRP_verify_param_callback = ctx->srp_ctx.SRP_verify_param_callback; / set SRP client passwd callback / s->srp_ctx.SRP_give_srp_client_pwd_callback = ctx->srp_ctx.SRP_give_srp_client_pwd_callback; s->srp_ctx.strength = ctx->srp_ctx.strength; if (((ctx->srp_ctx.N != NULL) && ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) \|\| ((ctx->srp_ctx.g != NULL) && ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) \|\| ((ctx->srp_ctx.s != NULL) && ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) \|\| ((ctx->srp_ctx.B != NULL) && ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) \|\| ((ctx->srp_ctx.A != NULL) && ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) \|\| ((ctx->srp_ctx.a != NULL) && ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) \|\| ((ctx->srp_ctx.v != NULL) && ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) \|\| ((ctx->srp_ctx.b != NULL) && ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL))) { ERR_raise(ERR_LIB_SSL, ERR_R_BN_LIB); goto err; } if ((ctx->srp_ctx.login != NULL) && ((s->srp_ctx.login = OPENSSL_strdup(ctx->srp_ctx.login)) == NULL)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); goto err; } if ((ctx->srp_ctx.info != NULL) && ((s->srp_ctx.info = OPENSSL_strdup(ctx->srp_ctx.info)) == NULL)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); goto err; } s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask; return 1; err: OPENSSL_free(s->srp_ctx.login); OPENSSL_free(s->srp_ctx.info); BN_free(s->srp_ctx.N); BN_free(s->srp_ctx.g); BN_free(s->srp_ctx.s); BN_free(s->srp_ctx.B); BN_free(s->srp_ctx.A); BN_free(s->srp_ctx.a); BN_free(s->srp_ctx.b); BN_free(s->srp_ctx.v); memset(&s->srp_ctx, 0, sizeof(s->srp_ctx)); return 0; } int SSL_SRP_CTX_init(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); / the call works with NULL sc / return ssl_srp_ctx_init_intern(sc); } / * The public API SSL_CTX_SRP_CTX_init() is deprecated so we use * ssl_ctx_srp_ctx_init_intern() internally. / int ssl_ctx_srp_ctx_init_intern(SSL_CTX ctx) { if (ctx == NULL) return 0; memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx)); ctx->srp_ctx.strength = SRP_MINIMAL_N; return 1; } int SSL_CTX_SRP_CTX_init(SSL_CTX ctx) { return ssl_ctx_srp_ctx_init_intern(ctx); } / server side / / * The public API SSL_srp_server_param_with_username() is deprecated so we use * ssl_srp_server_param_with_username_intern() internally. / int ssl_srp_server_param_with_username_intern(SSL_CONNECTION s, int ad) { unsigned char b[SSL_MAX_MASTER_KEY_LENGTH]; int al; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); ad = SSL_AD_UNKNOWN_PSK_IDENTITY; if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) && ((al = s->srp_ctx.TLS_ext_srp_username_callback(SSL_CONNECTION_GET_SSL(s), ad, s->srp_ctx.SRP_cb_arg)) != SSL_ERROR_NONE)) return al; ad = SSL_AD_INTERNAL_ERROR; if ((s->srp_ctx.N == NULL) \|\| (s->srp_ctx.g == NULL) \|\| (s->srp_ctx.s == NULL) \|\| (s->srp_ctx.v == NULL)) return SSL3_AL_FATAL; if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, b, sizeof(b), 0) <= 0) return SSL3_AL_FATAL; s->srp_ctx.b = BN_bin2bn(b, sizeof(b), NULL); OPENSSL_cleanse(b, sizeof(b)); /* Calculate: B = (kv + g^b) % N / return ((s->srp_ctx.B = SRP_Calc_B_ex(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g, s->srp_ctx.v, sctx->libctx, sctx->propq)) != NULL) ? SSL_ERROR_NONE : SSL3_AL_FATAL; } int SSL_srp_server_param_with_username(SSL s, int ad) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return SSL3_AL_FATAL; return ssl_srp_server_param_with_username_intern(sc, ad); } /* * If the server just has the raw password, make up a verifier entry on the * fly / int SSL_set_srp_server_param_pw(SSL s, const char user, const char pass, const char grp) { SRP_gN GN; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; GN = SRP_get_default_gN(grp); if (GN == NULL) return -1; sc->srp_ctx.N = BN_dup(GN->N); sc->srp_ctx.g = BN_dup(GN->g); BN_clear_free(sc->srp_ctx.v); sc->srp_ctx.v = NULL; BN_clear_free(sc->srp_ctx.s); sc->srp_ctx.s = NULL; if (!SRP_create_verifier_BN_ex(user, pass, &sc->srp_ctx.s, &sc->srp_ctx.v, sc->srp_ctx.N, sc->srp_ctx.g, s->ctx->libctx, s->ctx->propq)) return -1; return 1; } int SSL_set_srp_server_param(SSL s, const BIGNUM N, const BIGNUM g, BIGNUM sa, BIGNUM v, char info) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; if (N != NULL) { if (sc->srp_ctx.N != NULL) { if (!BN_copy(sc->srp_ctx.N, N)) { BN_free(sc->srp_ctx.N); sc->srp_ctx.N = NULL; } } else sc->srp_ctx.N = BN_dup(N); } if (g != NULL) { if (sc->srp_ctx.g != NULL) { if (!BN_copy(sc->srp_ctx.g, g)) { BN_free(sc->srp_ctx.g); sc->srp_ctx.g = NULL; } } else sc->srp_ctx.g = BN_dup(g); } if (sa != NULL) { if (sc->srp_ctx.s != NULL) { if (!BN_copy(sc->srp_ctx.s, sa)) { BN_free(sc->srp_ctx.s); sc->srp_ctx.s = NULL; } } else sc->srp_ctx.s = BN_dup(sa); } if (v != NULL) { if (sc->srp_ctx.v != NULL) { if (!BN_copy(sc->srp_ctx.v, v)) { BN_free(sc->srp_ctx.v); sc->srp_ctx.v = NULL; } } else sc->srp_ctx.v = BN_dup(v); } if (info != NULL) { if (sc->srp_ctx.info) OPENSSL_free(sc->srp_ctx.info); if ((sc->srp_ctx.info = OPENSSL_strdup(info)) == NULL) return -1; } if (!(sc->srp_ctx.N) \|\| !(sc->srp_ctx.g) \|\| !(sc->srp_ctx.s) \|\| !(sc->srp_ctx.v)) return -1; return 1; } int srp_generate_server_master_secret(SSL_CONNECTION s) { BIGNUM K = NULL, u = NULL; int ret = 0, tmp_len = 0; unsigned char tmp = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (!SRP_Verify_A_mod_N(s->srp_ctx.A, s->srp_ctx.N)) goto err; if ((u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N, sctx->libctx, sctx->propq)) == NULL) goto err; if ((K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b, s->srp_ctx.N)) == NULL) goto err; tmp_len = BN_num_bytes(K); if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } BN_bn2bin(K, tmp); / Calls SSLfatal() as required / ret = ssl_generate_master_secret(s, tmp, tmp_len, 1); err: BN_clear_free(K); BN_clear_free(u); return ret; } / client side / int srp_generate_client_master_secret(SSL_CONNECTION s) { BIGNUM x = NULL, u = NULL, K = NULL; int ret = 0, tmp_len = 0; char passwd = NULL; unsigned char tmp = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); /* * Checks if b % n == 0 / if (SRP_Verify_B_mod_N(s->srp_ctx.B, s->srp_ctx.N) == 0 \|\| (u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N, sctx->libctx, sctx->propq)) == NULL \|\| s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if ((passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(SSL_CONNECTION_GET_SSL(s), s->srp_ctx.SRP_cb_arg)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED); goto err; } if ((x = SRP_Calc_x_ex(s->srp_ctx.s, s->srp_ctx.login, passwd, sctx->libctx, sctx->propq)) == NULL \|\| (K = SRP_Calc_client_key_ex(s->srp_ctx.N, s->srp_ctx.B, s->srp_ctx.g, x, s->srp_ctx.a, u, sctx->libctx, sctx->propq)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } tmp_len = BN_num_bytes(K); if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } BN_bn2bin(K, tmp); / Calls SSLfatal() as required / ret = ssl_generate_master_secret(s, tmp, tmp_len, 1); err: BN_clear_free(K); BN_clear_free(x); if (passwd != NULL) OPENSSL_clear_free(passwd, strlen(passwd)); BN_clear_free(u); return ret; } int srp_verify_server_param(SSL_CONNECTION s) { SRP_CTX srp = &s->srp_ctx; / * Sanity check parameters: we can quickly check B % N == 0 by checking B * != 0 since B < N / if (BN_ucmp(srp->g, srp->N) >= 0 \|\| BN_ucmp(srp->B, srp->N) >= 0 \|\| BN_is_zero(srp->B)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DATA); return 0; } if (BN_num_bits(srp->N) < srp->strength) { SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_INSUFFICIENT_SECURITY); return 0; } if (srp->SRP_verify_param_callback) { if (srp->SRP_verify_param_callback(SSL_CONNECTION_GET_SSL(s), srp->SRP_cb_arg) <= 0) { SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_CALLBACK_FAILED); return 0; } } else if (!SRP_check_known_gN_param(srp->g, srp->N)) { SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_INSUFFICIENT_SECURITY); return 0; } return 1; } / * The public API SRP_Calc_A_param() is deprecated so we use * ssl_srp_calc_a_param_intern() internally. / int ssl_srp_calc_a_param_intern(SSL_CONNECTION s) { unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH]; if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, rnd, sizeof(rnd), 0) <= 0) return 0; s->srp_ctx.a = BN_bin2bn(rnd, sizeof(rnd), s->srp_ctx.a); OPENSSL_cleanse(rnd, sizeof(rnd)); if (!(s->srp_ctx.A = SRP_Calc_A(s->srp_ctx.a, s->srp_ctx.N, s->srp_ctx.g))) return 0; return 1; } int SRP_Calc_A_param(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return ssl_srp_calc_a_param_intern(sc); } BIGNUM SSL_get_srp_g(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->srp_ctx.g != NULL) return sc->srp_ctx.g; return s->ctx->srp_ctx.g; } BIGNUM SSL_get_srp_N(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->srp_ctx.N != NULL) return sc->srp_ctx.N; return s->ctx->srp_ctx.N; } char SSL_get_srp_username(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->srp_ctx.login != NULL) return sc->srp_ctx.login; return s->ctx->srp_ctx.login; } char SSL_get_srp_userinfo(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->srp_ctx.info != NULL) return sc->srp_ctx.info; return s->ctx->srp_ctx.info; } # define tls1_ctx_ctrl ssl3_ctx_ctrl # define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl int SSL_CTX_set_srp_username(SSL_CTX ctx, char name) { return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME, 0, name); } int SSL_CTX_set_srp_password(SSL_CTX ctx, char password) { return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD, 0, password); } int SSL_CTX_set_srp_strength(SSL_CTX ctx, int strength) { return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength, NULL); } int SSL_CTX_set_srp_verify_param_callback(SSL_CTX ctx, int (cb) (SSL , void )) { return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_VERIFY_PARAM_CB, (void ()(void))cb); } int SSL_CTX_set_srp_cb_arg(SSL_CTX ctx, void arg) { return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_SRP_ARG, 0, arg); } int SSL_CTX_set_srp_username_callback(SSL_CTX ctx, int (cb) (SSL , int , void )) { return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB, (void ()(void))cb); } int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX ctx, char (cb) (SSL , void )) { return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB, (void ()(void))cb); } #endif
./openssl/ssl/ssl_ciph.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <ctype.h> #include <openssl/objects.h> #include <openssl/comp.h> #include <openssl/engine.h> #include <openssl/crypto.h> #include <openssl/conf.h> #include <openssl/trace.h> #include "internal/nelem.h" #include "ssl_local.h" #include "internal/thread_once.h" #include "internal/cryptlib.h" / NB: make sure indices in these tables match values above / typedef struct { uint32_t mask; int nid; } ssl_cipher_table; / Table of NIDs for each cipher / static const ssl_cipher_table ssl_cipher_table_cipher[SSL_ENC_NUM_IDX] = { {SSL_DES, NID_des_cbc}, / SSL_ENC_DES_IDX 0 / {SSL_3DES, NID_des_ede3_cbc}, / SSL_ENC_3DES_IDX 1 / {SSL_RC4, NID_rc4}, / SSL_ENC_RC4_IDX 2 / {SSL_RC2, NID_rc2_cbc}, / SSL_ENC_RC2_IDX 3 / {SSL_IDEA, NID_idea_cbc}, / SSL_ENC_IDEA_IDX 4 / {SSL_eNULL, NID_undef}, / SSL_ENC_NULL_IDX 5 / {SSL_AES128, NID_aes_128_cbc}, / SSL_ENC_AES128_IDX 6 / {SSL_AES256, NID_aes_256_cbc}, / SSL_ENC_AES256_IDX 7 / {SSL_CAMELLIA128, NID_camellia_128_cbc}, / SSL_ENC_CAMELLIA128_IDX 8 / {SSL_CAMELLIA256, NID_camellia_256_cbc}, / SSL_ENC_CAMELLIA256_IDX 9 / {SSL_eGOST2814789CNT, NID_gost89_cnt}, / SSL_ENC_GOST89_IDX 10 / {SSL_SEED, NID_seed_cbc}, / SSL_ENC_SEED_IDX 11 / {SSL_AES128GCM, NID_aes_128_gcm}, / SSL_ENC_AES128GCM_IDX 12 / {SSL_AES256GCM, NID_aes_256_gcm}, / SSL_ENC_AES256GCM_IDX 13 / {SSL_AES128CCM, NID_aes_128_ccm}, / SSL_ENC_AES128CCM_IDX 14 / {SSL_AES256CCM, NID_aes_256_ccm}, / SSL_ENC_AES256CCM_IDX 15 / {SSL_AES128CCM8, NID_aes_128_ccm}, / SSL_ENC_AES128CCM8_IDX 16 / {SSL_AES256CCM8, NID_aes_256_ccm}, / SSL_ENC_AES256CCM8_IDX 17 / {SSL_eGOST2814789CNT12, NID_gost89_cnt_12}, / SSL_ENC_GOST8912_IDX 18 / {SSL_CHACHA20POLY1305, NID_chacha20_poly1305}, / SSL_ENC_CHACHA_IDX 19 / {SSL_ARIA128GCM, NID_aria_128_gcm}, / SSL_ENC_ARIA128GCM_IDX 20 / {SSL_ARIA256GCM, NID_aria_256_gcm}, / SSL_ENC_ARIA256GCM_IDX 21 / {SSL_MAGMA, NID_magma_ctr_acpkm}, / SSL_ENC_MAGMA_IDX / {SSL_KUZNYECHIK, NID_kuznyechik_ctr_acpkm}, / SSL_ENC_KUZNYECHIK_IDX / }; #define SSL_COMP_NULL_IDX 0 #define SSL_COMP_ZLIB_IDX 1 #define SSL_COMP_NUM_IDX 2 static STACK_OF(SSL_COMP) ssl_comp_methods = NULL; #ifndef OPENSSL_NO_COMP static CRYPTO_ONCE ssl_load_builtin_comp_once = CRYPTO_ONCE_STATIC_INIT; #endif /* NB: make sure indices in this table matches values above / static const ssl_cipher_table ssl_cipher_table_mac[SSL_MD_NUM_IDX] = { {SSL_MD5, NID_md5}, / SSL_MD_MD5_IDX 0 / {SSL_SHA1, NID_sha1}, / SSL_MD_SHA1_IDX 1 / {SSL_GOST94, NID_id_GostR3411_94}, / SSL_MD_GOST94_IDX 2 / {SSL_GOST89MAC, NID_id_Gost28147_89_MAC}, / SSL_MD_GOST89MAC_IDX 3 / {SSL_SHA256, NID_sha256}, / SSL_MD_SHA256_IDX 4 / {SSL_SHA384, NID_sha384}, / SSL_MD_SHA384_IDX 5 / {SSL_GOST12_256, NID_id_GostR3411_2012_256}, / SSL_MD_GOST12_256_IDX 6 / {SSL_GOST89MAC12, NID_gost_mac_12}, / SSL_MD_GOST89MAC12_IDX 7 / {SSL_GOST12_512, NID_id_GostR3411_2012_512}, / SSL_MD_GOST12_512_IDX 8 / {0, NID_md5_sha1}, / SSL_MD_MD5_SHA1_IDX 9 / {0, NID_sha224}, / SSL_MD_SHA224_IDX 10 / {0, NID_sha512}, / SSL_MD_SHA512_IDX 11 / {SSL_MAGMAOMAC, NID_magma_mac}, / sSL_MD_MAGMAOMAC_IDX / {SSL_KUZNYECHIKOMAC, NID_kuznyechik_mac} / SSL_MD_KUZNYECHIKOMAC_IDX / }; / INDENT-OFF / static const ssl_cipher_table ssl_cipher_table_kx[] = { {SSL_kRSA, NID_kx_rsa}, {SSL_kECDHE, NID_kx_ecdhe}, {SSL_kDHE, NID_kx_dhe}, {SSL_kECDHEPSK, NID_kx_ecdhe_psk}, {SSL_kDHEPSK, NID_kx_dhe_psk}, {SSL_kRSAPSK, NID_kx_rsa_psk}, {SSL_kPSK, NID_kx_psk}, {SSL_kSRP, NID_kx_srp}, {SSL_kGOST, NID_kx_gost}, {SSL_kGOST18, NID_kx_gost18}, {SSL_kANY, NID_kx_any} }; static const ssl_cipher_table ssl_cipher_table_auth[] = { {SSL_aRSA, NID_auth_rsa}, {SSL_aECDSA, NID_auth_ecdsa}, {SSL_aPSK, NID_auth_psk}, {SSL_aDSS, NID_auth_dss}, {SSL_aGOST01, NID_auth_gost01}, {SSL_aGOST12, NID_auth_gost12}, {SSL_aSRP, NID_auth_srp}, {SSL_aNULL, NID_auth_null}, {SSL_aANY, NID_auth_any} }; / INDENT-ON / / Utility function for table lookup / static int ssl_cipher_info_find(const ssl_cipher_table table, size_t table_cnt, uint32_t mask) { size_t i; for (i = 0; i < table_cnt; i++, table++) { if (table->mask == mask) return (int)i; } return -1; } #define ssl_cipher_info_lookup(table, x) \ ssl_cipher_info_find(table, OSSL_NELEM(table), x) /* * PKEY_TYPE for GOST89MAC is known in advance, but, because implementation * is engine-provided, we'll fill it only if corresponding EVP_PKEY_METHOD is * found / static const int default_mac_pkey_id[SSL_MD_NUM_IDX] = { / MD5, SHA, GOST94, MAC89 / EVP_PKEY_HMAC, EVP_PKEY_HMAC, EVP_PKEY_HMAC, NID_undef, / SHA256, SHA384, GOST2012_256, MAC89-12 / EVP_PKEY_HMAC, EVP_PKEY_HMAC, EVP_PKEY_HMAC, NID_undef, / GOST2012_512 / EVP_PKEY_HMAC, / MD5/SHA1, SHA224, SHA512, MAGMAOMAC, KUZNYECHIKOMAC / NID_undef, NID_undef, NID_undef, NID_undef, NID_undef }; #define CIPHER_ADD 1 #define CIPHER_KILL 2 #define CIPHER_DEL 3 #define CIPHER_ORD 4 #define CIPHER_SPECIAL 5 / * Bump the ciphers to the top of the list. * This rule isn't currently supported by the public cipherstring API. / #define CIPHER_BUMP 6 typedef struct cipher_order_st { const SSL_CIPHER cipher; int active; int dead; struct cipher_order_st next, prev; } CIPHER_ORDER; static const SSL_CIPHER cipher_aliases[] = { /* "ALL" doesn't include eNULL (must be specifically enabled) / {0, SSL_TXT_ALL, NULL, 0, 0, 0, ~SSL_eNULL}, / "COMPLEMENTOFALL" / {0, SSL_TXT_CMPALL, NULL, 0, 0, 0, SSL_eNULL}, / * "COMPLEMENTOFDEFAULT" (does not include ciphersuites not found in * ALL!) / {0, SSL_TXT_CMPDEF, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_NOT_DEFAULT}, / * key exchange aliases (some of those using only a single bit here * combine multiple key exchange algs according to the RFCs, e.g. kDHE * combines DHE_DSS and DHE_RSA) / {0, SSL_TXT_kRSA, NULL, 0, SSL_kRSA}, {0, SSL_TXT_kEDH, NULL, 0, SSL_kDHE}, {0, SSL_TXT_kDHE, NULL, 0, SSL_kDHE}, {0, SSL_TXT_DH, NULL, 0, SSL_kDHE}, {0, SSL_TXT_kEECDH, NULL, 0, SSL_kECDHE}, {0, SSL_TXT_kECDHE, NULL, 0, SSL_kECDHE}, {0, SSL_TXT_ECDH, NULL, 0, SSL_kECDHE}, {0, SSL_TXT_kPSK, NULL, 0, SSL_kPSK}, {0, SSL_TXT_kRSAPSK, NULL, 0, SSL_kRSAPSK}, {0, SSL_TXT_kECDHEPSK, NULL, 0, SSL_kECDHEPSK}, {0, SSL_TXT_kDHEPSK, NULL, 0, SSL_kDHEPSK}, {0, SSL_TXT_kSRP, NULL, 0, SSL_kSRP}, {0, SSL_TXT_kGOST, NULL, 0, SSL_kGOST}, {0, SSL_TXT_kGOST18, NULL, 0, SSL_kGOST18}, / server authentication aliases / {0, SSL_TXT_aRSA, NULL, 0, 0, SSL_aRSA}, {0, SSL_TXT_aDSS, NULL, 0, 0, SSL_aDSS}, {0, SSL_TXT_DSS, NULL, 0, 0, SSL_aDSS}, {0, SSL_TXT_aNULL, NULL, 0, 0, SSL_aNULL}, {0, SSL_TXT_aECDSA, NULL, 0, 0, SSL_aECDSA}, {0, SSL_TXT_ECDSA, NULL, 0, 0, SSL_aECDSA}, {0, SSL_TXT_aPSK, NULL, 0, 0, SSL_aPSK}, {0, SSL_TXT_aGOST01, NULL, 0, 0, SSL_aGOST01}, {0, SSL_TXT_aGOST12, NULL, 0, 0, SSL_aGOST12}, {0, SSL_TXT_aGOST, NULL, 0, 0, SSL_aGOST01 \| SSL_aGOST12}, {0, SSL_TXT_aSRP, NULL, 0, 0, SSL_aSRP}, / aliases combining key exchange and server authentication / {0, SSL_TXT_EDH, NULL, 0, SSL_kDHE, ~SSL_aNULL}, {0, SSL_TXT_DHE, NULL, 0, SSL_kDHE, ~SSL_aNULL}, {0, SSL_TXT_EECDH, NULL, 0, SSL_kECDHE, ~SSL_aNULL}, {0, SSL_TXT_ECDHE, NULL, 0, SSL_kECDHE, ~SSL_aNULL}, {0, SSL_TXT_NULL, NULL, 0, 0, 0, SSL_eNULL}, {0, SSL_TXT_RSA, NULL, 0, SSL_kRSA, SSL_aRSA}, {0, SSL_TXT_ADH, NULL, 0, SSL_kDHE, SSL_aNULL}, {0, SSL_TXT_AECDH, NULL, 0, SSL_kECDHE, SSL_aNULL}, {0, SSL_TXT_PSK, NULL, 0, SSL_PSK}, {0, SSL_TXT_SRP, NULL, 0, SSL_kSRP}, / symmetric encryption aliases / {0, SSL_TXT_3DES, NULL, 0, 0, 0, SSL_3DES}, {0, SSL_TXT_RC4, NULL, 0, 0, 0, SSL_RC4}, {0, SSL_TXT_RC2, NULL, 0, 0, 0, SSL_RC2}, {0, SSL_TXT_IDEA, NULL, 0, 0, 0, SSL_IDEA}, {0, SSL_TXT_SEED, NULL, 0, 0, 0, SSL_SEED}, {0, SSL_TXT_eNULL, NULL, 0, 0, 0, SSL_eNULL}, {0, SSL_TXT_GOST, NULL, 0, 0, 0, SSL_eGOST2814789CNT \| SSL_eGOST2814789CNT12 \| SSL_MAGMA \| SSL_KUZNYECHIK}, {0, SSL_TXT_AES128, NULL, 0, 0, 0, SSL_AES128 \| SSL_AES128GCM \| SSL_AES128CCM \| SSL_AES128CCM8}, {0, SSL_TXT_AES256, NULL, 0, 0, 0, SSL_AES256 \| SSL_AES256GCM \| SSL_AES256CCM \| SSL_AES256CCM8}, {0, SSL_TXT_AES, NULL, 0, 0, 0, SSL_AES}, {0, SSL_TXT_AES_GCM, NULL, 0, 0, 0, SSL_AES128GCM \| SSL_AES256GCM}, {0, SSL_TXT_AES_CCM, NULL, 0, 0, 0, SSL_AES128CCM \| SSL_AES256CCM \| SSL_AES128CCM8 \| SSL_AES256CCM8}, {0, SSL_TXT_AES_CCM_8, NULL, 0, 0, 0, SSL_AES128CCM8 \| SSL_AES256CCM8}, {0, SSL_TXT_CAMELLIA128, NULL, 0, 0, 0, SSL_CAMELLIA128}, {0, SSL_TXT_CAMELLIA256, NULL, 0, 0, 0, SSL_CAMELLIA256}, {0, SSL_TXT_CAMELLIA, NULL, 0, 0, 0, SSL_CAMELLIA}, {0, SSL_TXT_CHACHA20, NULL, 0, 0, 0, SSL_CHACHA20}, {0, SSL_TXT_GOST2012_GOST8912_GOST8912, NULL, 0, 0, 0, SSL_eGOST2814789CNT12}, {0, SSL_TXT_ARIA, NULL, 0, 0, 0, SSL_ARIA}, {0, SSL_TXT_ARIA_GCM, NULL, 0, 0, 0, SSL_ARIA128GCM \| SSL_ARIA256GCM}, {0, SSL_TXT_ARIA128, NULL, 0, 0, 0, SSL_ARIA128GCM}, {0, SSL_TXT_ARIA256, NULL, 0, 0, 0, SSL_ARIA256GCM}, {0, SSL_TXT_CBC, NULL, 0, 0, 0, SSL_CBC}, / MAC aliases / {0, SSL_TXT_MD5, NULL, 0, 0, 0, 0, SSL_MD5}, {0, SSL_TXT_SHA1, NULL, 0, 0, 0, 0, SSL_SHA1}, {0, SSL_TXT_SHA, NULL, 0, 0, 0, 0, SSL_SHA1}, {0, SSL_TXT_GOST94, NULL, 0, 0, 0, 0, SSL_GOST94}, {0, SSL_TXT_GOST89MAC, NULL, 0, 0, 0, 0, SSL_GOST89MAC \| SSL_GOST89MAC12}, {0, SSL_TXT_SHA256, NULL, 0, 0, 0, 0, SSL_SHA256}, {0, SSL_TXT_SHA384, NULL, 0, 0, 0, 0, SSL_SHA384}, {0, SSL_TXT_GOST12, NULL, 0, 0, 0, 0, SSL_GOST12_256}, / protocol version aliases / {0, SSL_TXT_SSLV3, NULL, 0, 0, 0, 0, 0, SSL3_VERSION}, {0, SSL_TXT_TLSV1, NULL, 0, 0, 0, 0, 0, TLS1_VERSION}, {0, "TLSv1.0", NULL, 0, 0, 0, 0, 0, TLS1_VERSION}, {0, SSL_TXT_TLSV1_2, NULL, 0, 0, 0, 0, 0, TLS1_2_VERSION}, / strength classes / {0, SSL_TXT_LOW, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_LOW}, {0, SSL_TXT_MEDIUM, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_MEDIUM}, {0, SSL_TXT_HIGH, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_HIGH}, / FIPS 140-2 approved ciphersuite / {0, SSL_TXT_FIPS, NULL, 0, 0, 0, ~SSL_eNULL, 0, 0, 0, 0, 0, SSL_FIPS}, / "EDH-" aliases to "DHE-" labels (for backward compatibility) / {0, SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA, NULL, 0, SSL_kDHE, SSL_aDSS, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH \| SSL_FIPS}, {0, SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA, NULL, 0, SSL_kDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH \| SSL_FIPS}, }; / * Search for public key algorithm with given name and return its pkey_id if * it is available. Otherwise return 0 / #ifdef OPENSSL_NO_ENGINE static int get_optional_pkey_id(const char pkey_name) { const EVP_PKEY_ASN1_METHOD ameth; int pkey_id = 0; ameth = EVP_PKEY_asn1_find_str(NULL, pkey_name, -1); if (ameth && EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, ameth) > 0) return pkey_id; return 0; } #else static int get_optional_pkey_id(const char pkey_name) { const EVP_PKEY_ASN1_METHOD ameth; ENGINE tmpeng = NULL; int pkey_id = 0; ameth = EVP_PKEY_asn1_find_str(&tmpeng, pkey_name, -1); if (ameth) { if (EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, ameth) <= 0) pkey_id = 0; } tls_engine_finish(tmpeng); return pkey_id; } #endif int ssl_load_ciphers(SSL_CTX ctx) { size_t i; const ssl_cipher_table t; EVP_KEYEXCH kex = NULL; EVP_SIGNATURE sig = NULL; ctx->disabled_enc_mask = 0; for (i = 0, t = ssl_cipher_table_cipher; i < SSL_ENC_NUM_IDX; i++, t++) { if (t->nid != NID_undef) { const EVP_CIPHER cipher = ssl_evp_cipher_fetch(ctx->libctx, t->nid, ctx->propq); ctx->ssl_cipher_methods[i] = cipher; if (cipher == NULL) ctx->disabled_enc_mask \|= t->mask; } } ctx->disabled_mac_mask = 0; for (i = 0, t = ssl_cipher_table_mac; i < SSL_MD_NUM_IDX; i++, t++) { const EVP_MD md = ssl_evp_md_fetch(ctx->libctx, t->nid, ctx->propq); ctx->ssl_digest_methods[i] = md; if (md == NULL) { ctx->disabled_mac_mask \|= t->mask; } else { int tmpsize = EVP_MD_get_size(md); if (!ossl_assert(tmpsize >= 0)) return 0; ctx->ssl_mac_secret_size[i] = tmpsize; } } ctx->disabled_mkey_mask = 0; ctx->disabled_auth_mask = 0; /* * We ignore any errors from the fetches below. They are expected to fail * if these algorithms are not available. / ERR_set_mark(); sig = EVP_SIGNATURE_fetch(ctx->libctx, "DSA", ctx->propq); if (sig == NULL) ctx->disabled_auth_mask \|= SSL_aDSS; else EVP_SIGNATURE_free(sig); kex = EVP_KEYEXCH_fetch(ctx->libctx, "DH", ctx->propq); if (kex == NULL) ctx->disabled_mkey_mask \|= SSL_kDHE \| SSL_kDHEPSK; else EVP_KEYEXCH_free(kex); kex = EVP_KEYEXCH_fetch(ctx->libctx, "ECDH", ctx->propq); if (kex == NULL) ctx->disabled_mkey_mask \|= SSL_kECDHE \| SSL_kECDHEPSK; else EVP_KEYEXCH_free(kex); sig = EVP_SIGNATURE_fetch(ctx->libctx, "ECDSA", ctx->propq); if (sig == NULL) ctx->disabled_auth_mask \|= SSL_aECDSA; else EVP_SIGNATURE_free(sig); ERR_pop_to_mark(); #ifdef OPENSSL_NO_PSK ctx->disabled_mkey_mask \|= SSL_PSK; ctx->disabled_auth_mask \|= SSL_aPSK; #endif #ifdef OPENSSL_NO_SRP ctx->disabled_mkey_mask \|= SSL_kSRP; #endif / * Check for presence of GOST 34.10 algorithms, and if they are not * present, disable appropriate auth and key exchange / memcpy(ctx->ssl_mac_pkey_id, default_mac_pkey_id, sizeof(ctx->ssl_mac_pkey_id)); ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX] = get_optional_pkey_id(SN_id_Gost28147_89_MAC); if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX]) ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC_IDX] = 32; else ctx->disabled_mac_mask \|= SSL_GOST89MAC; ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX] = get_optional_pkey_id(SN_gost_mac_12); if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX]) ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC12_IDX] = 32; else ctx->disabled_mac_mask \|= SSL_GOST89MAC12; ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX] = get_optional_pkey_id(SN_magma_mac); if (ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX]) ctx->ssl_mac_secret_size[SSL_MD_MAGMAOMAC_IDX] = 32; else ctx->disabled_mac_mask \|= SSL_MAGMAOMAC; ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX] = get_optional_pkey_id(SN_kuznyechik_mac); if (ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX]) ctx->ssl_mac_secret_size[SSL_MD_KUZNYECHIKOMAC_IDX] = 32; else ctx->disabled_mac_mask \|= SSL_KUZNYECHIKOMAC; if (!get_optional_pkey_id(SN_id_GostR3410_2001)) ctx->disabled_auth_mask \|= SSL_aGOST01 \| SSL_aGOST12; if (!get_optional_pkey_id(SN_id_GostR3410_2012_256)) ctx->disabled_auth_mask \|= SSL_aGOST12; if (!get_optional_pkey_id(SN_id_GostR3410_2012_512)) ctx->disabled_auth_mask \|= SSL_aGOST12; / * Disable GOST key exchange if no GOST signature algs are available * / if ((ctx->disabled_auth_mask & (SSL_aGOST01 \| SSL_aGOST12)) == (SSL_aGOST01 \| SSL_aGOST12)) ctx->disabled_mkey_mask \|= SSL_kGOST; if ((ctx->disabled_auth_mask & SSL_aGOST12) == SSL_aGOST12) ctx->disabled_mkey_mask \|= SSL_kGOST18; return 1; } #ifndef OPENSSL_NO_COMP static int sk_comp_cmp(const SSL_COMP const a, const SSL_COMP const b) { return ((a)->id - (b)->id); } DEFINE_RUN_ONCE_STATIC(do_load_builtin_compressions) { SSL_COMP comp = NULL; COMP_METHOD method = COMP_zlib(); ssl_comp_methods = sk_SSL_COMP_new(sk_comp_cmp); if (COMP_get_type(method) != NID_undef && ssl_comp_methods != NULL) { comp = OPENSSL_malloc(sizeof(comp)); if (comp != NULL) { comp->method = method; comp->id = SSL_COMP_ZLIB_IDX; comp->name = COMP_get_name(method); if (!sk_SSL_COMP_push(ssl_comp_methods, comp)) OPENSSL_free(comp); sk_SSL_COMP_sort(ssl_comp_methods); } } return 1; } static int load_builtin_compressions(void) { return RUN_ONCE(&ssl_load_builtin_comp_once, do_load_builtin_compressions); } #endif int ssl_cipher_get_evp_cipher(SSL_CTX ctx, const SSL_CIPHER sslc, const EVP_CIPHER *enc) { int i = ssl_cipher_info_lookup(ssl_cipher_table_cipher, sslc->algorithm_enc); if (i == -1) { enc = NULL; } else { if (i == SSL_ENC_NULL_IDX) { /* * We assume we don't care about this coming from an ENGINE so * just do a normal EVP_CIPHER_fetch instead of * ssl_evp_cipher_fetch() / enc = EVP_CIPHER_fetch(ctx->libctx, "NULL", ctx->propq); if (enc == NULL) return 0; } else { const EVP_CIPHER cipher = ctx->ssl_cipher_methods[i]; if (cipher == NULL \|\| !ssl_evp_cipher_up_ref(cipher)) return 0; enc = ctx->ssl_cipher_methods[i]; } } return 1; } int ssl_cipher_get_evp(SSL_CTX ctx, const SSL_SESSION s, const EVP_CIPHER enc, const EVP_MD md, int mac_pkey_type, size_t mac_secret_size, SSL_COMP comp, int use_etm) { int i; const SSL_CIPHER c; c = s->cipher; if (c == NULL) return 0; if (comp != NULL) { SSL_COMP ctmp; #ifndef OPENSSL_NO_COMP if (!load_builtin_compressions()) { /* * Currently don't care, since a failure only means that * ssl_comp_methods is NULL, which is perfectly OK / } #endif comp = NULL; ctmp.id = s->compress_meth; if (ssl_comp_methods != NULL) { i = sk_SSL_COMP_find(ssl_comp_methods, &ctmp); if (i >= 0) comp = sk_SSL_COMP_value(ssl_comp_methods, i); } / If were only interested in comp then return success / if ((enc == NULL) && (md == NULL)) return 1; } if ((enc == NULL) \|\| (md == NULL)) return 0; if (!ssl_cipher_get_evp_cipher(ctx, c, enc)) return 0; i = ssl_cipher_info_lookup(ssl_cipher_table_mac, c->algorithm_mac); if (i == -1) { md = NULL; if (mac_pkey_type != NULL) mac_pkey_type = NID_undef; if (mac_secret_size != NULL) mac_secret_size = 0; if (c->algorithm_mac == SSL_AEAD) mac_pkey_type = NULL; } else { const EVP_MD digest = ctx->ssl_digest_methods[i]; if (digest == NULL \|\| !ssl_evp_md_up_ref(digest)) { ssl_evp_cipher_free(enc); return 0; } md = digest; if (mac_pkey_type != NULL) mac_pkey_type = ctx->ssl_mac_pkey_id[i]; if (mac_secret_size != NULL) mac_secret_size = ctx->ssl_mac_secret_size[i]; } if ((enc != NULL) && (md != NULL \|\| (EVP_CIPHER_get_flags(enc) & EVP_CIPH_FLAG_AEAD_CIPHER)) && (!mac_pkey_type \|\| mac_pkey_type != NID_undef)) { const EVP_CIPHER evp = NULL; if (use_etm \|\| s->ssl_version >> 8 != TLS1_VERSION_MAJOR \|\| s->ssl_version < TLS1_VERSION) return 1; if (c->algorithm_enc == SSL_RC4 && c->algorithm_mac == SSL_MD5) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_rc4_hmac_md5, ctx->propq); else if (c->algorithm_enc == SSL_AES128 && c->algorithm_mac == SSL_SHA1) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_aes_128_cbc_hmac_sha1, ctx->propq); else if (c->algorithm_enc == SSL_AES256 && c->algorithm_mac == SSL_SHA1) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_aes_256_cbc_hmac_sha1, ctx->propq); else if (c->algorithm_enc == SSL_AES128 && c->algorithm_mac == SSL_SHA256) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_aes_128_cbc_hmac_sha256, ctx->propq); else if (c->algorithm_enc == SSL_AES256 && c->algorithm_mac == SSL_SHA256) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_aes_256_cbc_hmac_sha256, ctx->propq); if (evp != NULL) { ssl_evp_cipher_free(enc); ssl_evp_md_free(md); enc = evp; md = NULL; } return 1; } return 0; } const EVP_MD ssl_md(SSL_CTX ctx, int idx) { idx &= SSL_HANDSHAKE_MAC_MASK; if (idx < 0 \|\| idx >= SSL_MD_NUM_IDX) return NULL; return ctx->ssl_digest_methods[idx]; } const EVP_MD ssl_handshake_md(SSL_CONNECTION s) { return ssl_md(SSL_CONNECTION_GET_CTX(s), ssl_get_algorithm2(s)); } const EVP_MD ssl_prf_md(SSL_CONNECTION s) { return ssl_md(SSL_CONNECTION_GET_CTX(s), ssl_get_algorithm2(s) >> TLS1_PRF_DGST_SHIFT); } #define ITEM_SEP(a) \ (((a) == ':') \|\| ((a) == ' ') \|\| ((a) == ';') \|\| ((a) == ',')) static void ll_append_tail(CIPHER_ORDER *head, CIPHER_ORDER curr, CIPHER_ORDER *tail) { if (curr == tail) return; if (curr == head) head = curr->next; if (curr->prev != NULL) curr->prev->next = curr->next; if (curr->next != NULL) curr->next->prev = curr->prev; (tail)->next = curr; curr->prev = tail; curr->next = NULL; tail = curr; } static void ll_append_head(CIPHER_ORDER head, CIPHER_ORDER curr, CIPHER_ORDER *tail) { if (curr == head) return; if (curr == tail) tail = curr->prev; if (curr->next != NULL) curr->next->prev = curr->prev; if (curr->prev != NULL) curr->prev->next = curr->next; (head)->prev = curr; curr->next = head; curr->prev = NULL; head = curr; } static void ssl_cipher_collect_ciphers(const SSL_METHOD ssl_method, int num_of_ciphers, uint32_t disabled_mkey, uint32_t disabled_auth, uint32_t disabled_enc, uint32_t disabled_mac, CIPHER_ORDER co_list, CIPHER_ORDER head_p, CIPHER_ORDER tail_p) { int i, co_list_num; const SSL_CIPHER c; /* * We have num_of_ciphers descriptions compiled in, depending on the * method selected (SSLv3, TLSv1 etc). * These will later be sorted in a linked list with at most num * entries. / / Get the initial list of ciphers / co_list_num = 0; / actual count of ciphers / for (i = 0; i < num_of_ciphers; i++) { c = ssl_method->get_cipher(i); / drop those that use any of that is not available / if (c == NULL \|\| !c->valid) continue; if ((c->algorithm_mkey & disabled_mkey) \|\| (c->algorithm_auth & disabled_auth) \|\| (c->algorithm_enc & disabled_enc) \|\| (c->algorithm_mac & disabled_mac)) continue; if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) == 0) && c->min_tls == 0) continue; if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) != 0) && c->min_dtls == 0) continue; co_list[co_list_num].cipher = c; co_list[co_list_num].next = NULL; co_list[co_list_num].prev = NULL; co_list[co_list_num].active = 0; co_list_num++; } / * Prepare linked list from list entries / if (co_list_num > 0) { co_list[0].prev = NULL; if (co_list_num > 1) { co_list[0].next = &co_list[1]; for (i = 1; i < co_list_num - 1; i++) { co_list[i].prev = &co_list[i - 1]; co_list[i].next = &co_list[i + 1]; } co_list[co_list_num - 1].prev = &co_list[co_list_num - 2]; } co_list[co_list_num - 1].next = NULL; head_p = &co_list[0]; tail_p = &co_list[co_list_num - 1]; } } static void ssl_cipher_collect_aliases(const SSL_CIPHER ca_list, int num_of_group_aliases, uint32_t disabled_mkey, uint32_t disabled_auth, uint32_t disabled_enc, uint32_t disabled_mac, CIPHER_ORDER head) { CIPHER_ORDER ciph_curr; const SSL_CIPHER ca_curr; int i; uint32_t mask_mkey = ~disabled_mkey; uint32_t mask_auth = ~disabled_auth; uint32_t mask_enc = ~disabled_enc; uint32_t mask_mac = ~disabled_mac; / * First, add the real ciphers as already collected / ciph_curr = head; ca_curr = ca_list; while (ciph_curr != NULL) { ca_curr = ciph_curr->cipher; ca_curr++; ciph_curr = ciph_curr->next; } /* * Now we add the available ones from the cipher_aliases[] table. * They represent either one or more algorithms, some of which * in any affected category must be supported (set in enabled_mask), * or represent a cipher strength value (will be added in any case because algorithms=0). / for (i = 0; i < num_of_group_aliases; i++) { uint32_t algorithm_mkey = cipher_aliases[i].algorithm_mkey; uint32_t algorithm_auth = cipher_aliases[i].algorithm_auth; uint32_t algorithm_enc = cipher_aliases[i].algorithm_enc; uint32_t algorithm_mac = cipher_aliases[i].algorithm_mac; if (algorithm_mkey) if ((algorithm_mkey & mask_mkey) == 0) continue; if (algorithm_auth) if ((algorithm_auth & mask_auth) == 0) continue; if (algorithm_enc) if ((algorithm_enc & mask_enc) == 0) continue; if (algorithm_mac) if ((algorithm_mac & mask_mac) == 0) continue; ca_curr = (SSL_CIPHER )(cipher_aliases + i); ca_curr++; } ca_curr = NULL; /* end of list / } static void ssl_cipher_apply_rule(uint32_t cipher_id, uint32_t alg_mkey, uint32_t alg_auth, uint32_t alg_enc, uint32_t alg_mac, int min_tls, uint32_t algo_strength, int rule, int32_t strength_bits, CIPHER_ORDER head_p, CIPHER_ORDER tail_p) { CIPHER_ORDER head, tail, curr, next, last; const SSL_CIPHER cp; int reverse = 0; OSSL_TRACE_BEGIN(TLS_CIPHER) { BIO_printf(trc_out, "Applying rule %d with %08x/%08x/%08x/%08x/%08x %08x (%d)\n", rule, (unsigned int)alg_mkey, (unsigned int)alg_auth, (unsigned int)alg_enc, (unsigned int)alg_mac, min_tls, (unsigned int)algo_strength, (int)strength_bits); } if (rule == CIPHER_DEL \|\| rule == CIPHER_BUMP) reverse = 1; / needed to maintain sorting between currently * deleted ciphers / head = head_p; tail = tail_p; if (reverse) { next = tail; last = head; } else { next = head; last = tail; } curr = NULL; for (;;) { if (curr == last) break; curr = next; if (curr == NULL) break; next = reverse ? curr->prev : curr->next; cp = curr->cipher; / * Selection criteria is either the value of strength_bits * or the algorithms used. / if (strength_bits >= 0) { if (strength_bits != cp->strength_bits) continue; } else { if (trc_out != NULL) { BIO_printf(trc_out, "\nName: %s:" "\nAlgo = %08x/%08x/%08x/%08x/%08x Algo_strength = %08x\n", cp->name, (unsigned int)cp->algorithm_mkey, (unsigned int)cp->algorithm_auth, (unsigned int)cp->algorithm_enc, (unsigned int)cp->algorithm_mac, cp->min_tls, (unsigned int)cp->algo_strength); } if (cipher_id != 0 && (cipher_id != cp->id)) continue; if (alg_mkey && !(alg_mkey & cp->algorithm_mkey)) continue; if (alg_auth && !(alg_auth & cp->algorithm_auth)) continue; if (alg_enc && !(alg_enc & cp->algorithm_enc)) continue; if (alg_mac && !(alg_mac & cp->algorithm_mac)) continue; if (min_tls && (min_tls != cp->min_tls)) continue; if ((algo_strength & SSL_STRONG_MASK) && !(algo_strength & SSL_STRONG_MASK & cp->algo_strength)) continue; if ((algo_strength & SSL_DEFAULT_MASK) && !(algo_strength & SSL_DEFAULT_MASK & cp->algo_strength)) continue; } if (trc_out != NULL) BIO_printf(trc_out, "Action = %d\n", rule); / add the cipher if it has not been added yet. / if (rule == CIPHER_ADD) { / reverse == 0 / if (!curr->active) { ll_append_tail(&head, curr, &tail); curr->active = 1; } } / Move the added cipher to this location / else if (rule == CIPHER_ORD) { / reverse == 0 / if (curr->active) { ll_append_tail(&head, curr, &tail); } } else if (rule == CIPHER_DEL) { / reverse == 1 / if (curr->active) { / * most recently deleted ciphersuites get best positions for * any future CIPHER_ADD (note that the CIPHER_DEL loop works * in reverse to maintain the order) / ll_append_head(&head, curr, &tail); curr->active = 0; } } else if (rule == CIPHER_BUMP) { if (curr->active) ll_append_head(&head, curr, &tail); } else if (rule == CIPHER_KILL) { / reverse == 0 / if (head == curr) head = curr->next; else curr->prev->next = curr->next; if (tail == curr) tail = curr->prev; curr->active = 0; if (curr->next != NULL) curr->next->prev = curr->prev; if (curr->prev != NULL) curr->prev->next = curr->next; curr->next = NULL; curr->prev = NULL; } } head_p = head; tail_p = tail; OSSL_TRACE_END(TLS_CIPHER); } static int ssl_cipher_strength_sort(CIPHER_ORDER head_p, CIPHER_ORDER tail_p) { int32_t max_strength_bits; int i, number_uses; CIPHER_ORDER curr; / * This routine sorts the ciphers with descending strength. The sorting * must keep the pre-sorted sequence, so we apply the normal sorting * routine as '+' movement to the end of the list. / max_strength_bits = 0; curr = head_p; while (curr != NULL) { if (curr->active && (curr->cipher->strength_bits > max_strength_bits)) max_strength_bits = curr->cipher->strength_bits; curr = curr->next; } number_uses = OPENSSL_zalloc(sizeof(int) * (max_strength_bits + 1)); if (number_uses == NULL) return 0; /* * Now find the strength_bits values actually used / curr = head_p; while (curr != NULL) { if (curr->active) number_uses[curr->cipher->strength_bits]++; curr = curr->next; } /* * Go through the list of used strength_bits values in descending * order. / for (i = max_strength_bits; i >= 0; i--) if (number_uses[i] > 0) ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ORD, i, head_p, tail_p); OPENSSL_free(number_uses); return 1; } static int ssl_cipher_process_rulestr(const char rule_str, CIPHER_ORDER head_p, CIPHER_ORDER tail_p, const SSL_CIPHER *ca_list, CERT c) { uint32_t alg_mkey, alg_auth, alg_enc, alg_mac, algo_strength; int min_tls; const char l, buf; int j, multi, found, rule, retval, ok, buflen; uint32_t cipher_id = 0; char ch; retval = 1; l = rule_str; for (;;) { ch = l; if (ch == '\0') break; / done / if (ch == '-') { rule = CIPHER_DEL; l++; } else if (ch == '+') { rule = CIPHER_ORD; l++; } else if (ch == '!') { rule = CIPHER_KILL; l++; } else if (ch == '@') { rule = CIPHER_SPECIAL; l++; } else { rule = CIPHER_ADD; } if (ITEM_SEP(ch)) { l++; continue; } alg_mkey = 0; alg_auth = 0; alg_enc = 0; alg_mac = 0; min_tls = 0; algo_strength = 0; for (;;) { ch = l; buf = l; buflen = 0; #ifndef CHARSET_EBCDIC while (((ch >= 'A') && (ch <= 'Z')) \|\| ((ch >= '0') && (ch <= '9')) \|\| ((ch >= 'a') && (ch <= 'z')) \|\| (ch == '-') \|\| (ch == '_') \|\| (ch == '.') \|\| (ch == '=')) #else while (isalnum((unsigned char)ch) \|\| (ch == '-') \|\| (ch == '_') \|\| (ch == '.') \|\| (ch == '=')) #endif { ch = (++l); buflen++; } if (buflen == 0) { / * We hit something we cannot deal with, * it is no command or separator nor * alphanumeric, so we call this an error. / ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); return 0; } if (rule == CIPHER_SPECIAL) { found = 0; / unused -- avoid compiler warning / break; / special treatment / } / check for multi-part specification / if (ch == '+') { multi = 1; l++; } else { multi = 0; } / * Now search for the cipher alias in the ca_list. Be careful * with the strncmp, because the "buflen" limitation * will make the rule "ADH:SOME" and the cipher * "ADH-MY-CIPHER" look like a match for buflen=3. * So additionally check whether the cipher name found * has the correct length. We can save a strlen() call: * just checking for the '\0' at the right place is * sufficient, we have to strncmp() anyway. (We cannot * use strcmp(), because buf is not '\0' terminated.) / j = found = 0; cipher_id = 0; while (ca_list[j]) { if (strncmp(buf, ca_list[j]->name, buflen) == 0 && (ca_list[j]->name[buflen] == '\0')) { found = 1; break; } else if (ca_list[j]->stdname != NULL && strncmp(buf, ca_list[j]->stdname, buflen) == 0 && ca_list[j]->stdname[buflen] == '\0') { found = 1; break; } else j++; } if (!found) break; / ignore this entry / if (ca_list[j]->algorithm_mkey) { if (alg_mkey) { alg_mkey &= ca_list[j]->algorithm_mkey; if (!alg_mkey) { found = 0; break; } } else { alg_mkey = ca_list[j]->algorithm_mkey; } } if (ca_list[j]->algorithm_auth) { if (alg_auth) { alg_auth &= ca_list[j]->algorithm_auth; if (!alg_auth) { found = 0; break; } } else { alg_auth = ca_list[j]->algorithm_auth; } } if (ca_list[j]->algorithm_enc) { if (alg_enc) { alg_enc &= ca_list[j]->algorithm_enc; if (!alg_enc) { found = 0; break; } } else { alg_enc = ca_list[j]->algorithm_enc; } } if (ca_list[j]->algorithm_mac) { if (alg_mac) { alg_mac &= ca_list[j]->algorithm_mac; if (!alg_mac) { found = 0; break; } } else { alg_mac = ca_list[j]->algorithm_mac; } } if (ca_list[j]->algo_strength & SSL_STRONG_MASK) { if (algo_strength & SSL_STRONG_MASK) { algo_strength &= (ca_list[j]->algo_strength & SSL_STRONG_MASK) \| ~SSL_STRONG_MASK; if (!(algo_strength & SSL_STRONG_MASK)) { found = 0; break; } } else { algo_strength = ca_list[j]->algo_strength & SSL_STRONG_MASK; } } if (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) { if (algo_strength & SSL_DEFAULT_MASK) { algo_strength &= (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) \| ~SSL_DEFAULT_MASK; if (!(algo_strength & SSL_DEFAULT_MASK)) { found = 0; break; } } else { algo_strength \|= ca_list[j]->algo_strength & SSL_DEFAULT_MASK; } } if (ca_list[j]->valid) { / * explicit ciphersuite found; its protocol version does not * become part of the search pattern! / cipher_id = ca_list[j]->id; } else { / * not an explicit ciphersuite; only in this case, the * protocol version is considered part of the search pattern / if (ca_list[j]->min_tls) { if (min_tls != 0 && min_tls != ca_list[j]->min_tls) { found = 0; break; } else { min_tls = ca_list[j]->min_tls; } } } if (!multi) break; } / * Ok, we have the rule, now apply it / if (rule == CIPHER_SPECIAL) { / special command / ok = 0; if ((buflen == 8) && HAS_PREFIX(buf, "STRENGTH")) { ok = ssl_cipher_strength_sort(head_p, tail_p); } else if (buflen == 10 && CHECK_AND_SKIP_PREFIX(buf, "SECLEVEL=")) { int level = buf - '0'; if (level < 0 \|\| level > 5) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); } else { c->sec_level = level; ok = 1; } } else { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); } if (ok == 0) retval = 0; /* * We do not support any "multi" options * together with "@", so throw away the * rest of the command, if any left, until * end or ':' is found. / while ((l != '\0') && !ITEM_SEP(l)) l++; } else if (found) { ssl_cipher_apply_rule(cipher_id, alg_mkey, alg_auth, alg_enc, alg_mac, min_tls, algo_strength, rule, -1, head_p, tail_p); } else { while ((l != '\0') && !ITEM_SEP(l)) l++; } if (l == '\0') break; /* done / } return retval; } static int check_suiteb_cipher_list(const SSL_METHOD meth, CERT c, const char prule_str) { unsigned int suiteb_flags = 0, suiteb_comb2 = 0; if (HAS_PREFIX(prule_str, "SUITEB128ONLY")) { suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS_ONLY; } else if (HAS_PREFIX(prule_str, "SUITEB128C2")) { suiteb_comb2 = 1; suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS; } else if (HAS_PREFIX(prule_str, "SUITEB128")) { suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS; } else if (HAS_PREFIX(prule_str, "SUITEB192")) { suiteb_flags = SSL_CERT_FLAG_SUITEB_192_LOS; } if (suiteb_flags) { c->cert_flags &= ~SSL_CERT_FLAG_SUITEB_128_LOS; c->cert_flags \|= suiteb_flags; } else { suiteb_flags = c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS; } if (!suiteb_flags) return 1; / Check version: if TLS 1.2 ciphers allowed we can use Suite B / if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS)) { ERR_raise(ERR_LIB_SSL, SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE); return 0; } switch (suiteb_flags) { case SSL_CERT_FLAG_SUITEB_128_LOS: if (suiteb_comb2) prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384"; else prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384"; break; case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY: prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256"; break; case SSL_CERT_FLAG_SUITEB_192_LOS: prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384"; break; } return 1; } static int ciphersuite_cb(const char elem, int len, void arg) { STACK_OF(SSL_CIPHER) ciphersuites = (STACK_OF(SSL_CIPHER) )arg; const SSL_CIPHER cipher; /* Arbitrary sized temp buffer for the cipher name. Should be big enough / char name[80]; if (len > (int)(sizeof(name) - 1)) / Anyway return 1 so we can parse rest of the list / return 1; memcpy(name, elem, len); name[len] = '\0'; cipher = ssl3_get_cipher_by_std_name(name); if (cipher == NULL) / Ciphersuite not found but return 1 to parse rest of the list / return 1; if (!sk_SSL_CIPHER_push(ciphersuites, cipher)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } return 1; } static __owur int set_ciphersuites(STACK_OF(SSL_CIPHER) currciphers, const char str) { STACK_OF(SSL_CIPHER) newciphers = sk_SSL_CIPHER_new_null(); if (newciphers == NULL) return 0; / Parse the list. We explicitly allow an empty list / if (str != '\0' && (CONF_parse_list(str, ':', 1, ciphersuite_cb, newciphers) <= 0 \|\| sk_SSL_CIPHER_num(newciphers) == 0)) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH); sk_SSL_CIPHER_free(newciphers); return 0; } sk_SSL_CIPHER_free(currciphers); currciphers = newciphers; return 1; } static int update_cipher_list_by_id(STACK_OF(SSL_CIPHER) *cipher_list_by_id, STACK_OF(SSL_CIPHER) cipherstack) { STACK_OF(SSL_CIPHER) tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack); if (tmp_cipher_list == NULL) { return 0; } sk_SSL_CIPHER_free(cipher_list_by_id); cipher_list_by_id = tmp_cipher_list; (void)sk_SSL_CIPHER_set_cmp_func(cipher_list_by_id, ssl_cipher_ptr_id_cmp); sk_SSL_CIPHER_sort(cipher_list_by_id); return 1; } static int update_cipher_list(SSL_CTX ctx, STACK_OF(SSL_CIPHER) cipher_list, STACK_OF(SSL_CIPHER) cipher_list_by_id, STACK_OF(SSL_CIPHER) tls13_ciphersuites) { int i; STACK_OF(SSL_CIPHER) tmp_cipher_list = sk_SSL_CIPHER_dup(cipher_list); if (tmp_cipher_list == NULL) return 0; / * Delete any existing TLSv1.3 ciphersuites. These are always first in the * list. / while (sk_SSL_CIPHER_num(tmp_cipher_list) > 0 && sk_SSL_CIPHER_value(tmp_cipher_list, 0)->min_tls == TLS1_3_VERSION) (void)sk_SSL_CIPHER_delete(tmp_cipher_list, 0); / Insert the new TLSv1.3 ciphersuites / for (i = sk_SSL_CIPHER_num(tls13_ciphersuites) - 1; i >= 0; i--) { const SSL_CIPHER sslc = sk_SSL_CIPHER_value(tls13_ciphersuites, i); /* Don't include any TLSv1.3 ciphersuites that are disabled / if ((sslc->algorithm_enc & ctx->disabled_enc_mask) == 0 && (ssl_cipher_table_mac[sslc->algorithm2 & SSL_HANDSHAKE_MAC_MASK].mask & ctx->disabled_mac_mask) == 0) { sk_SSL_CIPHER_unshift(tmp_cipher_list, sslc); } } if (!update_cipher_list_by_id(cipher_list_by_id, tmp_cipher_list)) { sk_SSL_CIPHER_free(tmp_cipher_list); return 0; } sk_SSL_CIPHER_free(cipher_list); cipher_list = tmp_cipher_list; return 1; } int SSL_CTX_set_ciphersuites(SSL_CTX ctx, const char str) { int ret = set_ciphersuites(&(ctx->tls13_ciphersuites), str); if (ret && ctx->cipher_list != NULL) return update_cipher_list(ctx, &ctx->cipher_list, &ctx->cipher_list_by_id, ctx->tls13_ciphersuites); return ret; } int SSL_set_ciphersuites(SSL s, const char str) { STACK_OF(SSL_CIPHER) cipher_list; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); int ret; if (sc == NULL) return 0; ret = set_ciphersuites(&(sc->tls13_ciphersuites), str); if (sc->cipher_list == NULL) { if ((cipher_list = SSL_get_ciphers(s)) != NULL) sc->cipher_list = sk_SSL_CIPHER_dup(cipher_list); } if (ret && sc->cipher_list != NULL) return update_cipher_list(s->ctx, &sc->cipher_list, &sc->cipher_list_by_id, sc->tls13_ciphersuites); return ret; } STACK_OF(SSL_CIPHER) ssl_create_cipher_list(SSL_CTX ctx, STACK_OF(SSL_CIPHER) tls13_ciphersuites, STACK_OF(SSL_CIPHER) cipher_list, STACK_OF(SSL_CIPHER) cipher_list_by_id, const char rule_str, CERT c) { int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases, i; uint32_t disabled_mkey, disabled_auth, disabled_enc, disabled_mac; STACK_OF(SSL_CIPHER) cipherstack; const char rule_p; CIPHER_ORDER co_list = NULL, head = NULL, tail = NULL, curr; const SSL_CIPHER *ca_list = NULL; const SSL_METHOD ssl_method = ctx->method; /* * Return with error if nothing to do. / if (rule_str == NULL \|\| cipher_list == NULL \|\| cipher_list_by_id == NULL) return NULL; if (!check_suiteb_cipher_list(ssl_method, c, &rule_str)) return NULL; / * To reduce the work to do we only want to process the compiled * in algorithms, so we first get the mask of disabled ciphers. / disabled_mkey = ctx->disabled_mkey_mask; disabled_auth = ctx->disabled_auth_mask; disabled_enc = ctx->disabled_enc_mask; disabled_mac = ctx->disabled_mac_mask; / * Now we have to collect the available ciphers from the compiled * in ciphers. We cannot get more than the number compiled in, so * it is used for allocation. / num_of_ciphers = ssl_method->num_ciphers(); if (num_of_ciphers > 0) { co_list = OPENSSL_malloc(sizeof(co_list) * num_of_ciphers); if (co_list == NULL) return NULL; /* Failure / } ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers, disabled_mkey, disabled_auth, disabled_enc, disabled_mac, co_list, &head, &tail); / Now arrange all ciphers by preference. / / * Everything else being equal, prefer ephemeral ECDH over other key * exchange mechanisms. * For consistency, prefer ECDSA over RSA (though this only matters if the * server has both certificates, and is using the DEFAULT, or a client * preference). / ssl_cipher_apply_rule(0, SSL_kECDHE, SSL_aECDSA, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail); / Within each strength group, we prefer GCM over CHACHA... / ssl_cipher_apply_rule(0, 0, 0, SSL_AESGCM, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); ssl_cipher_apply_rule(0, 0, 0, SSL_CHACHA20, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); / * ...and generally, our preferred cipher is AES. * Note that AEADs will be bumped to take preference after sorting by * strength. / ssl_cipher_apply_rule(0, 0, 0, SSL_AES ^ SSL_AESGCM, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); / Temporarily enable everything else for sorting / ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); / Low priority for MD5 / ssl_cipher_apply_rule(0, 0, 0, 0, SSL_MD5, 0, 0, CIPHER_ORD, -1, &head, &tail); / * Move anonymous ciphers to the end. Usually, these will remain * disabled. (For applications that allow them, they aren't too bad, but * we prefer authenticated ciphers.) / ssl_cipher_apply_rule(0, 0, SSL_aNULL, 0, 0, 0, 0, CIPHER_ORD, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kRSA, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kPSK, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head, &tail); / RC4 is sort-of broken -- move to the end / ssl_cipher_apply_rule(0, 0, 0, SSL_RC4, 0, 0, 0, CIPHER_ORD, -1, &head, &tail); / * Now sort by symmetric encryption strength. The above ordering remains * in force within each class / if (!ssl_cipher_strength_sort(&head, &tail)) { OPENSSL_free(co_list); return NULL; } / * Partially overrule strength sort to prefer TLS 1.2 ciphers/PRFs. / ssl_cipher_apply_rule(0, 0, 0, 0, 0, TLS1_2_VERSION, 0, CIPHER_BUMP, -1, &head, &tail); / * Irrespective of strength, enforce the following order: * (EC)DHE + AEAD > (EC)DHE > rest of AEAD > rest. * Within each group, ciphers remain sorted by strength and previous * preference, i.e., * 1) ECDHE > DHE * 2) GCM > CHACHA * 3) AES > rest * 4) TLS 1.2 > legacy * * Because we now bump ciphers to the top of the list, we proceed in * reverse order of preference. / ssl_cipher_apply_rule(0, 0, 0, 0, SSL_AEAD, 0, 0, CIPHER_BUMP, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kDHE \| SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_BUMP, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kDHE \| SSL_kECDHE, 0, 0, SSL_AEAD, 0, 0, CIPHER_BUMP, -1, &head, &tail); / Now disable everything (maintaining the ordering!) / ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail); / * We also need cipher aliases for selecting based on the rule_str. * There might be two types of entries in the rule_str: 1) names * of ciphers themselves 2) aliases for groups of ciphers. * For 1) we need the available ciphers and for 2) the cipher * groups of cipher_aliases added together in one list (otherwise * we would be happy with just the cipher_aliases table). / num_of_group_aliases = OSSL_NELEM(cipher_aliases); num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1; ca_list = OPENSSL_malloc(sizeof(ca_list) * num_of_alias_max); if (ca_list == NULL) { OPENSSL_free(co_list); return NULL; /* Failure / } ssl_cipher_collect_aliases(ca_list, num_of_group_aliases, disabled_mkey, disabled_auth, disabled_enc, disabled_mac, head); / * If the rule_string begins with DEFAULT, apply the default rule * before using the (possibly available) additional rules. / ok = 1; rule_p = rule_str; if (HAS_PREFIX(rule_str, "DEFAULT")) { ok = ssl_cipher_process_rulestr(OSSL_default_cipher_list(), &head, &tail, ca_list, c); rule_p += 7; if (rule_p == ':') rule_p++; } if (ok && (rule_p[0] != '\0')) ok = ssl_cipher_process_rulestr(rule_p, &head, &tail, ca_list, c); OPENSSL_free(ca_list); /* Not needed anymore / if (!ok) { / Rule processing failure / OPENSSL_free(co_list); return NULL; } / * Allocate new "cipherstack" for the result, return with error * if we cannot get one. / if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL) { OPENSSL_free(co_list); return NULL; } / Add TLSv1.3 ciphers first - we always prefer those if possible / for (i = 0; i < sk_SSL_CIPHER_num(tls13_ciphersuites); i++) { const SSL_CIPHER sslc = sk_SSL_CIPHER_value(tls13_ciphersuites, i); /* Don't include any TLSv1.3 ciphers that are disabled / if ((sslc->algorithm_enc & disabled_enc) != 0 \|\| (ssl_cipher_table_mac[sslc->algorithm2 & SSL_HANDSHAKE_MAC_MASK].mask & ctx->disabled_mac_mask) != 0) { sk_SSL_CIPHER_delete(tls13_ciphersuites, i); i--; continue; } if (!sk_SSL_CIPHER_push(cipherstack, sslc)) { OPENSSL_free(co_list); sk_SSL_CIPHER_free(cipherstack); return NULL; } } OSSL_TRACE_BEGIN(TLS_CIPHER) { BIO_printf(trc_out, "cipher selection:\n"); } / * The cipher selection for the list is done. The ciphers are added * to the resulting precedence to the STACK_OF(SSL_CIPHER). / for (curr = head; curr != NULL; curr = curr->next) { if (curr->active) { if (!sk_SSL_CIPHER_push(cipherstack, curr->cipher)) { OPENSSL_free(co_list); sk_SSL_CIPHER_free(cipherstack); OSSL_TRACE_CANCEL(TLS_CIPHER); return NULL; } if (trc_out != NULL) BIO_printf(trc_out, "<%s>\n", curr->cipher->name); } } OPENSSL_free(co_list); / Not needed any longer / OSSL_TRACE_END(TLS_CIPHER); if (!update_cipher_list_by_id(cipher_list_by_id, cipherstack)) { sk_SSL_CIPHER_free(cipherstack); return NULL; } sk_SSL_CIPHER_free(cipher_list); cipher_list = cipherstack; return cipherstack; } char SSL_CIPHER_description(const SSL_CIPHER cipher, char buf, int len) { const char ver; const char kx, au, enc, mac; uint32_t alg_mkey, alg_auth, alg_enc, alg_mac; static const char format = "%-30s %-7s Kx=%-8s Au=%-5s Enc=%-22s Mac=%-4s\n"; if (buf == NULL) { len = 128; if ((buf = OPENSSL_malloc(len)) == NULL) return NULL; } else if (len < 128) { return NULL; } alg_mkey = cipher->algorithm_mkey; alg_auth = cipher->algorithm_auth; alg_enc = cipher->algorithm_enc; alg_mac = cipher->algorithm_mac; ver = ssl_protocol_to_string(cipher->min_tls); switch (alg_mkey) { case SSL_kRSA: kx = "RSA"; break; case SSL_kDHE: kx = "DH"; break; case SSL_kECDHE: kx = "ECDH"; break; case SSL_kPSK: kx = "PSK"; break; case SSL_kRSAPSK: kx = "RSAPSK"; break; case SSL_kECDHEPSK: kx = "ECDHEPSK"; break; case SSL_kDHEPSK: kx = "DHEPSK"; break; case SSL_kSRP: kx = "SRP"; break; case SSL_kGOST: kx = "GOST"; break; case SSL_kGOST18: kx = "GOST18"; break; case SSL_kANY: kx = "any"; break; default: kx = "unknown"; } switch (alg_auth) { case SSL_aRSA: au = "RSA"; break; case SSL_aDSS: au = "DSS"; break; case SSL_aNULL: au = "None"; break; case SSL_aECDSA: au = "ECDSA"; break; case SSL_aPSK: au = "PSK"; break; case SSL_aSRP: au = "SRP"; break; case SSL_aGOST01: au = "GOST01"; break; /* New GOST ciphersuites have both SSL_aGOST12 and SSL_aGOST01 bits / case (SSL_aGOST12 \| SSL_aGOST01): au = "GOST12"; break; case SSL_aANY: au = "any"; break; default: au = "unknown"; break; } switch (alg_enc) { case SSL_DES: enc = "DES(56)"; break; case SSL_3DES: enc = "3DES(168)"; break; case SSL_RC4: enc = "RC4(128)"; break; case SSL_RC2: enc = "RC2(128)"; break; case SSL_IDEA: enc = "IDEA(128)"; break; case SSL_eNULL: enc = "None"; break; case SSL_AES128: enc = "AES(128)"; break; case SSL_AES256: enc = "AES(256)"; break; case SSL_AES128GCM: enc = "AESGCM(128)"; break; case SSL_AES256GCM: enc = "AESGCM(256)"; break; case SSL_AES128CCM: enc = "AESCCM(128)"; break; case SSL_AES256CCM: enc = "AESCCM(256)"; break; case SSL_AES128CCM8: enc = "AESCCM8(128)"; break; case SSL_AES256CCM8: enc = "AESCCM8(256)"; break; case SSL_CAMELLIA128: enc = "Camellia(128)"; break; case SSL_CAMELLIA256: enc = "Camellia(256)"; break; case SSL_ARIA128GCM: enc = "ARIAGCM(128)"; break; case SSL_ARIA256GCM: enc = "ARIAGCM(256)"; break; case SSL_SEED: enc = "SEED(128)"; break; case SSL_eGOST2814789CNT: case SSL_eGOST2814789CNT12: enc = "GOST89(256)"; break; case SSL_MAGMA: enc = "MAGMA"; break; case SSL_KUZNYECHIK: enc = "KUZNYECHIK"; break; case SSL_CHACHA20POLY1305: enc = "CHACHA20/POLY1305(256)"; break; default: enc = "unknown"; break; } switch (alg_mac) { case SSL_MD5: mac = "MD5"; break; case SSL_SHA1: mac = "SHA1"; break; case SSL_SHA256: mac = "SHA256"; break; case SSL_SHA384: mac = "SHA384"; break; case SSL_AEAD: mac = "AEAD"; break; case SSL_GOST89MAC: case SSL_GOST89MAC12: mac = "GOST89"; break; case SSL_GOST94: mac = "GOST94"; break; case SSL_GOST12_256: case SSL_GOST12_512: mac = "GOST2012"; break; default: mac = "unknown"; break; } BIO_snprintf(buf, len, format, cipher->name, ver, kx, au, enc, mac); return buf; } const char SSL_CIPHER_get_version(const SSL_CIPHER c) { if (c == NULL) return "(NONE)"; / * Backwards-compatibility crutch. In almost all contexts we report TLS * 1.0 as "TLSv1", but for ciphers we report "TLSv1.0". / if (c->min_tls == TLS1_VERSION) return "TLSv1.0"; return ssl_protocol_to_string(c->min_tls); } / return the actual cipher being used / const char SSL_CIPHER_get_name(const SSL_CIPHER c) { if (c != NULL) return c->name; return "(NONE)"; } / return the actual cipher being used in RFC standard name / const char SSL_CIPHER_standard_name(const SSL_CIPHER c) { if (c != NULL) return c->stdname; return "(NONE)"; } / return the OpenSSL name based on given RFC standard name / const char OPENSSL_cipher_name(const char stdname) { const SSL_CIPHER c; if (stdname == NULL) return "(NONE)"; c = ssl3_get_cipher_by_std_name(stdname); return SSL_CIPHER_get_name(c); } /* number of bits for symmetric cipher / int SSL_CIPHER_get_bits(const SSL_CIPHER c, int alg_bits) { int ret = 0; if (c != NULL) { if (alg_bits != NULL) alg_bits = (int)c->alg_bits; ret = (int)c->strength_bits; } return ret; } uint32_t SSL_CIPHER_get_id(const SSL_CIPHER c) { return c->id; } uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER c) { return c->id & 0xFFFF; } SSL_COMP ssl3_comp_find(STACK_OF(SSL_COMP) sk, int n) { SSL_COMP ctmp; int i, nn; if ((n == 0) \|\| (sk == NULL)) return NULL; nn = sk_SSL_COMP_num(sk); for (i = 0; i < nn; i++) { ctmp = sk_SSL_COMP_value(sk, i); if (ctmp->id == n) return ctmp; } return NULL; } #ifdef OPENSSL_NO_COMP STACK_OF(SSL_COMP) SSL_COMP_get_compression_methods(void) { return NULL; } STACK_OF(SSL_COMP) SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP) meths) { return meths; } int SSL_COMP_add_compression_method(int id, COMP_METHOD cm) { return 1; } #else STACK_OF(SSL_COMP) SSL_COMP_get_compression_methods(void) { load_builtin_compressions(); return ssl_comp_methods; } STACK_OF(SSL_COMP) SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP) meths) { STACK_OF(SSL_COMP) old_meths = ssl_comp_methods; ssl_comp_methods = meths; return old_meths; } static void cmeth_free(SSL_COMP cm) { OPENSSL_free(cm); } void ssl_comp_free_compression_methods_int(void) { STACK_OF(SSL_COMP) old_meths = ssl_comp_methods; ssl_comp_methods = NULL; sk_SSL_COMP_pop_free(old_meths, cmeth_free); } int SSL_COMP_add_compression_method(int id, COMP_METHOD cm) { SSL_COMP comp; if (cm == NULL \|\| COMP_get_type(cm) == NID_undef) return 1; /- * According to draft-ietf-tls-compression-04.txt, the * compression number ranges should be the following: * * 0 to 63: methods defined by the IETF * 64 to 192: external party methods assigned by IANA * 193 to 255: reserved for private use / if (id < 193 \|\| id > 255) { ERR_raise(ERR_LIB_SSL, SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE); return 1; } comp = OPENSSL_malloc(sizeof(comp)); if (comp == NULL) return 1; comp->id = id; comp->method = cm; load_builtin_compressions(); if (ssl_comp_methods && sk_SSL_COMP_find(ssl_comp_methods, comp) >= 0) { OPENSSL_free(comp); ERR_raise(ERR_LIB_SSL, SSL_R_DUPLICATE_COMPRESSION_ID); return 1; } if (ssl_comp_methods == NULL \|\| !sk_SSL_COMP_push(ssl_comp_methods, comp)) { OPENSSL_free(comp); ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 1; } return 0; } #endif const char SSL_COMP_get_name(const COMP_METHOD comp) { #ifndef OPENSSL_NO_COMP return comp ? COMP_get_name(comp) : NULL; #else return NULL; #endif } const char SSL_COMP_get0_name(const SSL_COMP comp) { #ifndef OPENSSL_NO_COMP return comp->name; #else return NULL; #endif } int SSL_COMP_get_id(const SSL_COMP comp) { #ifndef OPENSSL_NO_COMP return comp->id; #else return -1; #endif } const SSL_CIPHER ssl_get_cipher_by_char(SSL_CONNECTION s, const unsigned char ptr, int all) { const SSL_CIPHER c = SSL_CONNECTION_GET_SSL(s)->method->get_cipher_by_char(ptr); if (c == NULL \|\| (!all && c->valid == 0)) return NULL; return c; } const SSL_CIPHER SSL_CIPHER_find(SSL ssl, const unsigned char ptr) { return ssl->method->get_cipher_by_char(ptr); } int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER c) { int i; if (c == NULL) return NID_undef; i = ssl_cipher_info_lookup(ssl_cipher_table_cipher, c->algorithm_enc); if (i == -1) return NID_undef; return ssl_cipher_table_cipher[i].nid; } int SSL_CIPHER_get_digest_nid(const SSL_CIPHER c) { int i = ssl_cipher_info_lookup(ssl_cipher_table_mac, c->algorithm_mac); if (i == -1) return NID_undef; return ssl_cipher_table_mac[i].nid; } int SSL_CIPHER_get_kx_nid(const SSL_CIPHER c) { int i = ssl_cipher_info_lookup(ssl_cipher_table_kx, c->algorithm_mkey); if (i == -1) return NID_undef; return ssl_cipher_table_kx[i].nid; } int SSL_CIPHER_get_auth_nid(const SSL_CIPHER c) { int i = ssl_cipher_info_lookup(ssl_cipher_table_auth, c->algorithm_auth); if (i == -1) return NID_undef; return ssl_cipher_table_auth[i].nid; } int ssl_get_md_idx(int md_nid) { int i; for(i = 0; i < SSL_MD_NUM_IDX; i++) { if (md_nid == ssl_cipher_table_mac[i].nid) return i; } return -1; } const EVP_MD SSL_CIPHER_get_handshake_digest(const SSL_CIPHER c) { int idx = c->algorithm2 & SSL_HANDSHAKE_MAC_MASK; if (idx < 0 \|\| idx >= SSL_MD_NUM_IDX) return NULL; return EVP_get_digestbynid(ssl_cipher_table_mac[idx].nid); } int SSL_CIPHER_is_aead(const SSL_CIPHER c) { return (c->algorithm_mac & SSL_AEAD) ? 1 : 0; } int ssl_cipher_get_overhead(const SSL_CIPHER c, size_t mac_overhead, size_t int_overhead, size_t blocksize, size_t ext_overhead) { size_t mac = 0, in = 0, blk = 0, out = 0; /* Some hard-coded numbers for the CCM/Poly1305 MAC overhead * because there are no handy #defines for those. / if (c->algorithm_enc & (SSL_AESGCM \| SSL_ARIAGCM)) { out = EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN; } else if (c->algorithm_enc & (SSL_AES128CCM \| SSL_AES256CCM)) { out = EVP_CCM_TLS_EXPLICIT_IV_LEN + 16; } else if (c->algorithm_enc & (SSL_AES128CCM8 \| SSL_AES256CCM8)) { out = EVP_CCM_TLS_EXPLICIT_IV_LEN + 8; } else if (c->algorithm_enc & SSL_CHACHA20POLY1305) { out = 16; } else if (c->algorithm_mac & SSL_AEAD) { / We're supposed to have handled all the AEAD modes above / return 0; } else { / Non-AEAD modes. Calculate MAC/cipher overhead separately / int digest_nid = SSL_CIPHER_get_digest_nid(c); const EVP_MD e_md = EVP_get_digestbynid(digest_nid); if (e_md == NULL) return 0; mac = EVP_MD_get_size(e_md); if (c->algorithm_enc != SSL_eNULL) { int cipher_nid = SSL_CIPHER_get_cipher_nid(c); const EVP_CIPHER e_ciph = EVP_get_cipherbynid(cipher_nid); / If it wasn't AEAD or SSL_eNULL, we expect it to be a known CBC cipher. / if (e_ciph == NULL \|\| EVP_CIPHER_get_mode(e_ciph) != EVP_CIPH_CBC_MODE) return 0; in = 1; / padding length byte / out = EVP_CIPHER_get_iv_length(e_ciph); blk = EVP_CIPHER_get_block_size(e_ciph); } } mac_overhead = mac; int_overhead = in; blocksize = blk; ext_overhead = out; return 1; } int ssl_cert_is_disabled(SSL_CTX ctx, size_t idx) { const SSL_CERT_LOOKUP cl; / A provider-loaded key type is always enabled / if (idx >= SSL_PKEY_NUM) return 0; cl = ssl_cert_lookup_by_idx(idx, ctx); if (cl == NULL \|\| (cl->amask & ctx->disabled_auth_mask) != 0) return 1; return 0; } / * Default list of TLSv1.2 (and earlier) ciphers * SSL_DEFAULT_CIPHER_LIST deprecated in 3.0.0 * Update both macro and function simultaneously / const char OSSL_default_cipher_list(void) { return "ALL:!COMPLEMENTOFDEFAULT:!eNULL"; } /* * Default list of TLSv1.3 (and later) ciphers * TLS_DEFAULT_CIPHERSUITES deprecated in 3.0.0 * Update both macro and function simultaneously / const char OSSL_default_ciphersuites(void) { return "TLS_AES_256_GCM_SHA384:" "TLS_CHACHA20_POLY1305_SHA256:" "TLS_AES_128_GCM_SHA256"; }
./openssl/ssl/t1_trce.c	/* * Copyright 2012-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "ssl_local.h" #ifndef OPENSSL_NO_SSL_TRACE / Packet trace support for OpenSSL / #include "internal/nelem.h" typedef struct { int num; const char name; } ssl_trace_tbl; # define ssl_trace_str(val, tbl) \ do_ssl_trace_str(val, tbl, OSSL_NELEM(tbl)) # define ssl_trace_list(bio, indent, msg, msglen, value, table) \ do_ssl_trace_list(bio, indent, msg, msglen, value, \ table, OSSL_NELEM(table)) static const char do_ssl_trace_str(int val, const ssl_trace_tbl tbl, size_t ntbl) { size_t i; for (i = 0; i < ntbl; i++, tbl++) { if (tbl->num == val) return tbl->name; } return "UNKNOWN"; } static int do_ssl_trace_list(BIO bio, int indent, const unsigned char msg, size_t msglen, size_t vlen, const ssl_trace_tbl tbl, size_t ntbl) { int val; if (msglen % vlen) return 0; while (msglen) { val = msg[0]; if (vlen == 2) val = (val << 8) \| msg[1]; BIO_indent(bio, indent, 80); BIO_printf(bio, "%s (%d)\n", do_ssl_trace_str(val, tbl, ntbl), val); msg += vlen; msglen -= vlen; } return 1; } / Version number / static const ssl_trace_tbl ssl_version_tbl[] = { {SSL3_VERSION, "SSL 3.0"}, {TLS1_VERSION, "TLS 1.0"}, {TLS1_1_VERSION, "TLS 1.1"}, {TLS1_2_VERSION, "TLS 1.2"}, {TLS1_3_VERSION, "TLS 1.3"}, {DTLS1_VERSION, "DTLS 1.0"}, {DTLS1_2_VERSION, "DTLS 1.2"}, {DTLS1_BAD_VER, "DTLS 1.0 (bad)"} }; static const ssl_trace_tbl ssl_content_tbl[] = { {SSL3_RT_CHANGE_CIPHER_SPEC, "ChangeCipherSpec"}, {SSL3_RT_ALERT, "Alert"}, {SSL3_RT_HANDSHAKE, "Handshake"}, {SSL3_RT_APPLICATION_DATA, "ApplicationData"}, }; / Handshake types, sorted by ascending id / static const ssl_trace_tbl ssl_handshake_tbl[] = { {SSL3_MT_HELLO_REQUEST, "HelloRequest"}, {SSL3_MT_CLIENT_HELLO, "ClientHello"}, {SSL3_MT_SERVER_HELLO, "ServerHello"}, {DTLS1_MT_HELLO_VERIFY_REQUEST, "HelloVerifyRequest"}, {SSL3_MT_NEWSESSION_TICKET, "NewSessionTicket"}, {SSL3_MT_END_OF_EARLY_DATA, "EndOfEarlyData"}, {SSL3_MT_ENCRYPTED_EXTENSIONS, "EncryptedExtensions"}, {SSL3_MT_CERTIFICATE, "Certificate"}, {SSL3_MT_SERVER_KEY_EXCHANGE, "ServerKeyExchange"}, {SSL3_MT_CERTIFICATE_REQUEST, "CertificateRequest"}, {SSL3_MT_SERVER_DONE, "ServerHelloDone"}, {SSL3_MT_CERTIFICATE_VERIFY, "CertificateVerify"}, {SSL3_MT_CLIENT_KEY_EXCHANGE, "ClientKeyExchange"}, {SSL3_MT_FINISHED, "Finished"}, {SSL3_MT_CERTIFICATE_URL, "CertificateUrl"}, {SSL3_MT_CERTIFICATE_STATUS, "CertificateStatus"}, {SSL3_MT_SUPPLEMENTAL_DATA, "SupplementalData"}, {SSL3_MT_KEY_UPDATE, "KeyUpdate"}, {SSL3_MT_COMPRESSED_CERTIFICATE, "CompressedCertificate"}, # ifndef OPENSSL_NO_NEXTPROTONEG {SSL3_MT_NEXT_PROTO, "NextProto"}, # endif {SSL3_MT_MESSAGE_HASH, "MessageHash"} }; / Cipher suites / static const ssl_trace_tbl ssl_ciphers_tbl[] = { {0x0000, "TLS_NULL_WITH_NULL_NULL"}, {0x0001, "TLS_RSA_WITH_NULL_MD5"}, {0x0002, "TLS_RSA_WITH_NULL_SHA"}, {0x0003, "TLS_RSA_EXPORT_WITH_RC4_40_MD5"}, {0x0004, "TLS_RSA_WITH_RC4_128_MD5"}, {0x0005, "TLS_RSA_WITH_RC4_128_SHA"}, {0x0006, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5"}, {0x0007, "TLS_RSA_WITH_IDEA_CBC_SHA"}, {0x0008, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA"}, {0x0009, "TLS_RSA_WITH_DES_CBC_SHA"}, {0x000A, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"}, {0x000B, "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA"}, {0x000C, "TLS_DH_DSS_WITH_DES_CBC_SHA"}, {0x000D, "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA"}, {0x000E, "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA"}, {0x000F, "TLS_DH_RSA_WITH_DES_CBC_SHA"}, {0x0010, "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA"}, {0x0011, "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA"}, {0x0012, "TLS_DHE_DSS_WITH_DES_CBC_SHA"}, {0x0013, "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"}, {0x0014, "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA"}, {0x0015, "TLS_DHE_RSA_WITH_DES_CBC_SHA"}, {0x0016, "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"}, {0x0017, "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5"}, {0x0018, "TLS_DH_anon_WITH_RC4_128_MD5"}, {0x0019, "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA"}, {0x001A, "TLS_DH_anon_WITH_DES_CBC_SHA"}, {0x001B, "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"}, {0x001D, "SSL_FORTEZZA_KEA_WITH_FORTEZZA_CBC_SHA"}, {0x001E, "SSL_FORTEZZA_KEA_WITH_RC4_128_SHA"}, {0x001F, "TLS_KRB5_WITH_3DES_EDE_CBC_SHA"}, {0x0020, "TLS_KRB5_WITH_RC4_128_SHA"}, {0x0021, "TLS_KRB5_WITH_IDEA_CBC_SHA"}, {0x0022, "TLS_KRB5_WITH_DES_CBC_MD5"}, {0x0023, "TLS_KRB5_WITH_3DES_EDE_CBC_MD5"}, {0x0024, "TLS_KRB5_WITH_RC4_128_MD5"}, {0x0025, "TLS_KRB5_WITH_IDEA_CBC_MD5"}, {0x0026, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA"}, {0x0027, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA"}, {0x0028, "TLS_KRB5_EXPORT_WITH_RC4_40_SHA"}, {0x0029, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5"}, {0x002A, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5"}, {0x002B, "TLS_KRB5_EXPORT_WITH_RC4_40_MD5"}, {0x002C, "TLS_PSK_WITH_NULL_SHA"}, {0x002D, "TLS_DHE_PSK_WITH_NULL_SHA"}, {0x002E, "TLS_RSA_PSK_WITH_NULL_SHA"}, {0x002F, "TLS_RSA_WITH_AES_128_CBC_SHA"}, {0x0030, "TLS_DH_DSS_WITH_AES_128_CBC_SHA"}, {0x0031, "TLS_DH_RSA_WITH_AES_128_CBC_SHA"}, {0x0032, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"}, {0x0033, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"}, {0x0034, "TLS_DH_anon_WITH_AES_128_CBC_SHA"}, {0x0035, "TLS_RSA_WITH_AES_256_CBC_SHA"}, {0x0036, "TLS_DH_DSS_WITH_AES_256_CBC_SHA"}, {0x0037, "TLS_DH_RSA_WITH_AES_256_CBC_SHA"}, {0x0038, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"}, {0x0039, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"}, {0x003A, "TLS_DH_anon_WITH_AES_256_CBC_SHA"}, {0x003B, "TLS_RSA_WITH_NULL_SHA256"}, {0x003C, "TLS_RSA_WITH_AES_128_CBC_SHA256"}, {0x003D, "TLS_RSA_WITH_AES_256_CBC_SHA256"}, {0x003E, "TLS_DH_DSS_WITH_AES_128_CBC_SHA256"}, {0x003F, "TLS_DH_RSA_WITH_AES_128_CBC_SHA256"}, {0x0040, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"}, {0x0041, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"}, {0x0042, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA"}, {0x0043, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA"}, {0x0044, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"}, {0x0045, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"}, {0x0046, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"}, {0x0067, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"}, {0x0068, "TLS_DH_DSS_WITH_AES_256_CBC_SHA256"}, {0x0069, "TLS_DH_RSA_WITH_AES_256_CBC_SHA256"}, {0x006A, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"}, {0x006B, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"}, {0x006C, "TLS_DH_anon_WITH_AES_128_CBC_SHA256"}, {0x006D, "TLS_DH_anon_WITH_AES_256_CBC_SHA256"}, {0x0081, "TLS_GOSTR341001_WITH_28147_CNT_IMIT"}, {0x0083, "TLS_GOSTR341001_WITH_NULL_GOSTR3411"}, {0x0084, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"}, {0x0085, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA"}, {0x0086, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA"}, {0x0087, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"}, {0x0088, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"}, {0x0089, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"}, {0x008A, "TLS_PSK_WITH_RC4_128_SHA"}, {0x008B, "TLS_PSK_WITH_3DES_EDE_CBC_SHA"}, {0x008C, "TLS_PSK_WITH_AES_128_CBC_SHA"}, {0x008D, "TLS_PSK_WITH_AES_256_CBC_SHA"}, {0x008E, "TLS_DHE_PSK_WITH_RC4_128_SHA"}, {0x008F, "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"}, {0x0090, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"}, {0x0091, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"}, {0x0092, "TLS_RSA_PSK_WITH_RC4_128_SHA"}, {0x0093, "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"}, {0x0094, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"}, {0x0095, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"}, {0x0096, "TLS_RSA_WITH_SEED_CBC_SHA"}, {0x0097, "TLS_DH_DSS_WITH_SEED_CBC_SHA"}, {0x0098, "TLS_DH_RSA_WITH_SEED_CBC_SHA"}, {0x0099, "TLS_DHE_DSS_WITH_SEED_CBC_SHA"}, {0x009A, "TLS_DHE_RSA_WITH_SEED_CBC_SHA"}, {0x009B, "TLS_DH_anon_WITH_SEED_CBC_SHA"}, {0x009C, "TLS_RSA_WITH_AES_128_GCM_SHA256"}, {0x009D, "TLS_RSA_WITH_AES_256_GCM_SHA384"}, {0x009E, "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"}, {0x009F, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"}, {0x00A0, "TLS_DH_RSA_WITH_AES_128_GCM_SHA256"}, {0x00A1, "TLS_DH_RSA_WITH_AES_256_GCM_SHA384"}, {0x00A2, "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"}, {0x00A3, "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"}, {0x00A4, "TLS_DH_DSS_WITH_AES_128_GCM_SHA256"}, {0x00A5, "TLS_DH_DSS_WITH_AES_256_GCM_SHA384"}, {0x00A6, "TLS_DH_anon_WITH_AES_128_GCM_SHA256"}, {0x00A7, "TLS_DH_anon_WITH_AES_256_GCM_SHA384"}, {0x00A8, "TLS_PSK_WITH_AES_128_GCM_SHA256"}, {0x00A9, "TLS_PSK_WITH_AES_256_GCM_SHA384"}, {0x00AA, "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"}, {0x00AB, "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"}, {0x00AC, "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"}, {0x00AD, "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"}, {0x00AE, "TLS_PSK_WITH_AES_128_CBC_SHA256"}, {0x00AF, "TLS_PSK_WITH_AES_256_CBC_SHA384"}, {0x00B0, "TLS_PSK_WITH_NULL_SHA256"}, {0x00B1, "TLS_PSK_WITH_NULL_SHA384"}, {0x00B2, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"}, {0x00B3, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"}, {0x00B4, "TLS_DHE_PSK_WITH_NULL_SHA256"}, {0x00B5, "TLS_DHE_PSK_WITH_NULL_SHA384"}, {0x00B6, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"}, {0x00B7, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"}, {0x00B8, "TLS_RSA_PSK_WITH_NULL_SHA256"}, {0x00B9, "TLS_RSA_PSK_WITH_NULL_SHA384"}, {0x00BA, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BB, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BC, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BD, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BE, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BF, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00C0, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C1, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C2, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C3, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C4, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C5, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00FF, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV"}, {0x5600, "TLS_FALLBACK_SCSV"}, {0xC001, "TLS_ECDH_ECDSA_WITH_NULL_SHA"}, {0xC002, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA"}, {0xC003, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA"}, {0xC004, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"}, {0xC005, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"}, {0xC006, "TLS_ECDHE_ECDSA_WITH_NULL_SHA"}, {0xC007, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"}, {0xC008, "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"}, {0xC009, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"}, {0xC00A, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"}, {0xC00B, "TLS_ECDH_RSA_WITH_NULL_SHA"}, {0xC00C, "TLS_ECDH_RSA_WITH_RC4_128_SHA"}, {0xC00D, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA"}, {0xC00E, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"}, {0xC00F, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"}, {0xC010, "TLS_ECDHE_RSA_WITH_NULL_SHA"}, {0xC011, "TLS_ECDHE_RSA_WITH_RC4_128_SHA"}, {0xC012, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"}, {0xC013, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"}, {0xC014, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"}, {0xC015, "TLS_ECDH_anon_WITH_NULL_SHA"}, {0xC016, "TLS_ECDH_anon_WITH_RC4_128_SHA"}, {0xC017, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"}, {0xC018, "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"}, {0xC019, "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"}, {0xC01A, "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"}, {0xC01B, "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"}, {0xC01C, "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"}, {0xC01D, "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"}, {0xC01E, "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"}, {0xC01F, "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"}, {0xC020, "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"}, {0xC021, "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"}, {0xC022, "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"}, {0xC023, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"}, {0xC024, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"}, {0xC025, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"}, {0xC026, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"}, {0xC027, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"}, {0xC028, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"}, {0xC029, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"}, {0xC02A, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"}, {0xC02B, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"}, {0xC02C, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"}, {0xC02D, "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"}, {0xC02E, "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"}, {0xC02F, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"}, {0xC030, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"}, {0xC031, "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"}, {0xC032, "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"}, {0xC033, "TLS_ECDHE_PSK_WITH_RC4_128_SHA"}, {0xC034, "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"}, {0xC035, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"}, {0xC036, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"}, {0xC037, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"}, {0xC038, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"}, {0xC039, "TLS_ECDHE_PSK_WITH_NULL_SHA"}, {0xC03A, "TLS_ECDHE_PSK_WITH_NULL_SHA256"}, {0xC03B, "TLS_ECDHE_PSK_WITH_NULL_SHA384"}, {0xC03C, "TLS_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC03D, "TLS_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC03E, "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256"}, {0xC03F, "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384"}, {0xC040, "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC041, "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC042, "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256"}, {0xC043, "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384"}, {0xC044, "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC045, "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC046, "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256"}, {0xC047, "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384"}, {0xC048, "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256"}, {0xC049, "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384"}, {0xC04A, "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256"}, {0xC04B, "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384"}, {0xC04C, "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC04D, "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC04E, "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC04F, "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC050, "TLS_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC051, "TLS_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC052, "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC053, "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC054, "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC055, "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC056, "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"}, {0xC057, "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"}, {0xC058, "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"}, {0xC059, "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"}, {0xC05A, "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"}, {0xC05B, "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"}, {0xC05C, "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"}, {0xC05D, "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"}, {0xC05E, "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"}, {0xC05F, "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"}, {0xC060, "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC061, "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC062, "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC063, "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC064, "TLS_PSK_WITH_ARIA_128_CBC_SHA256"}, {0xC065, "TLS_PSK_WITH_ARIA_256_CBC_SHA384"}, {0xC066, "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256"}, {0xC067, "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384"}, {0xC068, "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256"}, {0xC069, "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384"}, {0xC06A, "TLS_PSK_WITH_ARIA_128_GCM_SHA256"}, {0xC06B, "TLS_PSK_WITH_ARIA_256_GCM_SHA384"}, {0xC06C, "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"}, {0xC06D, "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"}, {0xC06E, "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"}, {0xC06F, "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"}, {0xC070, "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256"}, {0xC071, "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384"}, {0xC072, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC073, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC074, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC075, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC076, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC077, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC078, "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC079, "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC07A, "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC07B, "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC07C, "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC07D, "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC07E, "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC07F, "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC080, "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC081, "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC082, "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC083, "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC084, "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC085, "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC086, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC087, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC088, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC089, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC08A, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC08B, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC08C, "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC08D, "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC08E, "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC08F, "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC090, "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC091, "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC092, "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC093, "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC094, "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC095, "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC096, "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC097, "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC098, "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC099, "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC09A, "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC09B, "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC09C, "TLS_RSA_WITH_AES_128_CCM"}, {0xC09D, "TLS_RSA_WITH_AES_256_CCM"}, {0xC09E, "TLS_DHE_RSA_WITH_AES_128_CCM"}, {0xC09F, "TLS_DHE_RSA_WITH_AES_256_CCM"}, {0xC0A0, "TLS_RSA_WITH_AES_128_CCM_8"}, {0xC0A1, "TLS_RSA_WITH_AES_256_CCM_8"}, {0xC0A2, "TLS_DHE_RSA_WITH_AES_128_CCM_8"}, {0xC0A3, "TLS_DHE_RSA_WITH_AES_256_CCM_8"}, {0xC0A4, "TLS_PSK_WITH_AES_128_CCM"}, {0xC0A5, "TLS_PSK_WITH_AES_256_CCM"}, {0xC0A6, "TLS_DHE_PSK_WITH_AES_128_CCM"}, {0xC0A7, "TLS_DHE_PSK_WITH_AES_256_CCM"}, {0xC0A8, "TLS_PSK_WITH_AES_128_CCM_8"}, {0xC0A9, "TLS_PSK_WITH_AES_256_CCM_8"}, {0xC0AA, "TLS_PSK_DHE_WITH_AES_128_CCM_8"}, {0xC0AB, "TLS_PSK_DHE_WITH_AES_256_CCM_8"}, {0xC0AC, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"}, {0xC0AD, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"}, {0xC0AE, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"}, {0xC0AF, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"}, {0xC102, "IANA-GOST2012-GOST8912-GOST8912"}, {0xCCA8, "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCA9, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAA, "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAB, "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAC, "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAD, "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAE, "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"}, {0x1301, "TLS_AES_128_GCM_SHA256"}, {0x1302, "TLS_AES_256_GCM_SHA384"}, {0x1303, "TLS_CHACHA20_POLY1305_SHA256"}, {0x1304, "TLS_AES_128_CCM_SHA256"}, {0x1305, "TLS_AES_128_CCM_8_SHA256"}, {0xFEFE, "SSL_RSA_FIPS_WITH_DES_CBC_SHA"}, {0xFEFF, "SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA"}, {0xFF85, "LEGACY-GOST2012-GOST8912-GOST8912"}, {0xFF87, "GOST2012-NULL-GOST12"}, {0xC100, "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC"}, {0xC101, "GOST2012-MAGMA-MAGMAOMAC"}, {0xC102, "GOST2012-GOST8912-IANA"}, }; / Compression methods / static const ssl_trace_tbl ssl_comp_tbl[] = { {0x0000, "No Compression"}, {0x0001, "Zlib Compression"} }; / Extensions sorted by ascending id / static const ssl_trace_tbl ssl_exts_tbl[] = { {TLSEXT_TYPE_server_name, "server_name"}, {TLSEXT_TYPE_max_fragment_length, "max_fragment_length"}, {TLSEXT_TYPE_client_certificate_url, "client_certificate_url"}, {TLSEXT_TYPE_trusted_ca_keys, "trusted_ca_keys"}, {TLSEXT_TYPE_truncated_hmac, "truncated_hmac"}, {TLSEXT_TYPE_status_request, "status_request"}, {TLSEXT_TYPE_user_mapping, "user_mapping"}, {TLSEXT_TYPE_client_authz, "client_authz"}, {TLSEXT_TYPE_server_authz, "server_authz"}, {TLSEXT_TYPE_cert_type, "cert_type"}, {TLSEXT_TYPE_supported_groups, "supported_groups"}, {TLSEXT_TYPE_ec_point_formats, "ec_point_formats"}, {TLSEXT_TYPE_srp, "srp"}, {TLSEXT_TYPE_signature_algorithms, "signature_algorithms"}, {TLSEXT_TYPE_use_srtp, "use_srtp"}, {TLSEXT_TYPE_application_layer_protocol_negotiation, "application_layer_protocol_negotiation"}, {TLSEXT_TYPE_signed_certificate_timestamp, "signed_certificate_timestamps"}, {TLSEXT_TYPE_client_cert_type, "client_cert_type"}, {TLSEXT_TYPE_server_cert_type, "server_cert_type"}, {TLSEXT_TYPE_padding, "padding"}, {TLSEXT_TYPE_encrypt_then_mac, "encrypt_then_mac"}, {TLSEXT_TYPE_extended_master_secret, "extended_master_secret"}, {TLSEXT_TYPE_compress_certificate, "compress_certificate"}, {TLSEXT_TYPE_session_ticket, "session_ticket"}, {TLSEXT_TYPE_psk, "psk"}, {TLSEXT_TYPE_early_data, "early_data"}, {TLSEXT_TYPE_supported_versions, "supported_versions"}, {TLSEXT_TYPE_cookie, "cookie_ext"}, {TLSEXT_TYPE_psk_kex_modes, "psk_key_exchange_modes"}, {TLSEXT_TYPE_certificate_authorities, "certificate_authorities"}, {TLSEXT_TYPE_post_handshake_auth, "post_handshake_auth"}, {TLSEXT_TYPE_signature_algorithms_cert, "signature_algorithms_cert"}, {TLSEXT_TYPE_key_share, "key_share"}, {TLSEXT_TYPE_renegotiate, "renegotiate"}, # ifndef OPENSSL_NO_NEXTPROTONEG {TLSEXT_TYPE_next_proto_neg, "next_proto_neg"}, # endif }; static const ssl_trace_tbl ssl_groups_tbl[] = { {1, "sect163k1 (K-163)"}, {2, "sect163r1"}, {3, "sect163r2 (B-163)"}, {4, "sect193r1"}, {5, "sect193r2"}, {6, "sect233k1 (K-233)"}, {7, "sect233r1 (B-233)"}, {8, "sect239k1"}, {9, "sect283k1 (K-283)"}, {10, "sect283r1 (B-283)"}, {11, "sect409k1 (K-409)"}, {12, "sect409r1 (B-409)"}, {13, "sect571k1 (K-571)"}, {14, "sect571r1 (B-571)"}, {15, "secp160k1"}, {16, "secp160r1"}, {17, "secp160r2"}, {18, "secp192k1"}, {19, "secp192r1 (P-192)"}, {20, "secp224k1"}, {21, "secp224r1 (P-224)"}, {22, "secp256k1"}, {23, "secp256r1 (P-256)"}, {24, "secp384r1 (P-384)"}, {25, "secp521r1 (P-521)"}, {26, "brainpoolP256r1"}, {27, "brainpoolP384r1"}, {28, "brainpoolP512r1"}, {29, "ecdh_x25519"}, {30, "ecdh_x448"}, {31, "brainpoolP256r1tls13"}, {32, "brainpoolP384r1tls13"}, {33, "brainpoolP512r1tls13"}, {34, "GC256A"}, {35, "GC256B"}, {36, "GC256C"}, {37, "GC256D"}, {38, "GC512A"}, {39, "GC512B"}, {40, "GC512C"}, {256, "ffdhe2048"}, {257, "ffdhe3072"}, {258, "ffdhe4096"}, {259, "ffdhe6144"}, {260, "ffdhe8192"}, {25497, "X25519Kyber768Draft00"}, {25498, "SecP256r1Kyber768Draft00"}, {0xFF01, "arbitrary_explicit_prime_curves"}, {0xFF02, "arbitrary_explicit_char2_curves"} }; static const ssl_trace_tbl ssl_point_tbl[] = { {0, "uncompressed"}, {1, "ansiX962_compressed_prime"}, {2, "ansiX962_compressed_char2"} }; static const ssl_trace_tbl ssl_mfl_tbl[] = { {0, "disabled"}, {1, "max_fragment_length := 2^9 (512 bytes)"}, {2, "max_fragment_length := 2^10 (1024 bytes)"}, {3, "max_fragment_length := 2^11 (2048 bytes)"}, {4, "max_fragment_length := 2^12 (4096 bytes)"} }; static const ssl_trace_tbl ssl_sigalg_tbl[] = { {TLSEXT_SIGALG_ecdsa_secp256r1_sha256, "ecdsa_secp256r1_sha256"}, {TLSEXT_SIGALG_ecdsa_secp384r1_sha384, "ecdsa_secp384r1_sha384"}, {TLSEXT_SIGALG_ecdsa_secp521r1_sha512, "ecdsa_secp521r1_sha512"}, {TLSEXT_SIGALG_ecdsa_sha224, "ecdsa_sha224"}, {TLSEXT_SIGALG_ed25519, "ed25519"}, {TLSEXT_SIGALG_ed448, "ed448"}, {TLSEXT_SIGALG_ecdsa_sha1, "ecdsa_sha1"}, {TLSEXT_SIGALG_rsa_pss_rsae_sha256, "rsa_pss_rsae_sha256"}, {TLSEXT_SIGALG_rsa_pss_rsae_sha384, "rsa_pss_rsae_sha384"}, {TLSEXT_SIGALG_rsa_pss_rsae_sha512, "rsa_pss_rsae_sha512"}, {TLSEXT_SIGALG_rsa_pss_pss_sha256, "rsa_pss_pss_sha256"}, {TLSEXT_SIGALG_rsa_pss_pss_sha384, "rsa_pss_pss_sha384"}, {TLSEXT_SIGALG_rsa_pss_pss_sha512, "rsa_pss_pss_sha512"}, {TLSEXT_SIGALG_rsa_pkcs1_sha256, "rsa_pkcs1_sha256"}, {TLSEXT_SIGALG_rsa_pkcs1_sha384, "rsa_pkcs1_sha384"}, {TLSEXT_SIGALG_rsa_pkcs1_sha512, "rsa_pkcs1_sha512"}, {TLSEXT_SIGALG_rsa_pkcs1_sha224, "rsa_pkcs1_sha224"}, {TLSEXT_SIGALG_rsa_pkcs1_sha1, "rsa_pkcs1_sha1"}, {TLSEXT_SIGALG_dsa_sha256, "dsa_sha256"}, {TLSEXT_SIGALG_dsa_sha384, "dsa_sha384"}, {TLSEXT_SIGALG_dsa_sha512, "dsa_sha512"}, {TLSEXT_SIGALG_dsa_sha224, "dsa_sha224"}, {TLSEXT_SIGALG_dsa_sha1, "dsa_sha1"}, {TLSEXT_SIGALG_gostr34102012_256_intrinsic, "gost2012_256"}, {TLSEXT_SIGALG_gostr34102012_512_intrinsic, "gost2012_512"}, {TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, "gost2012_256"}, {TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, "gost2012_512"}, {TLSEXT_SIGALG_gostr34102001_gostr3411, "gost2001_gost94"}, {TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, "ecdsa_brainpoolP256r1_sha256"}, {TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, "ecdsa_brainpoolP384r1_sha384"}, {TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, "ecdsa_brainpoolP512r1_sha512"}, }; static const ssl_trace_tbl ssl_ctype_tbl[] = { {1, "rsa_sign"}, {2, "dss_sign"}, {3, "rsa_fixed_dh"}, {4, "dss_fixed_dh"}, {5, "rsa_ephemeral_dh"}, {6, "dss_ephemeral_dh"}, {20, "fortezza_dms"}, {64, "ecdsa_sign"}, {65, "rsa_fixed_ecdh"}, {66, "ecdsa_fixed_ecdh"}, {67, "gost_sign256"}, {68, "gost_sign512"}, }; static const ssl_trace_tbl ssl_psk_kex_modes_tbl[] = { {TLSEXT_KEX_MODE_KE, "psk_ke"}, {TLSEXT_KEX_MODE_KE_DHE, "psk_dhe_ke"} }; static const ssl_trace_tbl ssl_key_update_tbl[] = { {SSL_KEY_UPDATE_NOT_REQUESTED, "update_not_requested"}, {SSL_KEY_UPDATE_REQUESTED, "update_requested"} }; static const ssl_trace_tbl ssl_comp_cert_tbl[] = { {TLSEXT_comp_cert_none, "none"}, {TLSEXT_comp_cert_zlib, "zlib"}, {TLSEXT_comp_cert_brotli, "brotli"}, {TLSEXT_comp_cert_zstd, "zstd"} }; / * "pgp" and "1609dot2" are defined in RFC7250, * although OpenSSL doesn't support them, it can * at least report them in traces / static const ssl_trace_tbl ssl_cert_type_tbl[] = { {TLSEXT_cert_type_x509, "x509"}, {TLSEXT_cert_type_pgp, "pgp"}, {TLSEXT_cert_type_rpk, "rpk"}, {TLSEXT_cert_type_1609dot2, "1609dot2"} }; static void ssl_print_hex(BIO bio, int indent, const char name, const unsigned char msg, size_t msglen) { size_t i; BIO_indent(bio, indent, 80); BIO_printf(bio, "%s (len=%d): ", name, (int)msglen); for (i = 0; i < msglen; i++) BIO_printf(bio, "%02X", msg[i]); BIO_puts(bio, "\n"); } static int ssl_print_hexbuf(BIO bio, int indent, const char name, size_t nlen, const unsigned char *pmsg, size_t pmsglen) { size_t blen; const unsigned char p = pmsg; if (pmsglen < nlen) return 0; blen = p[0]; if (nlen > 1) blen = (blen << 8) \| p[1]; if (pmsglen < nlen + blen) return 0; p += nlen; ssl_print_hex(bio, indent, name, p, blen); pmsg += blen + nlen; pmsglen -= blen + nlen; return 1; } static int ssl_print_version(BIO bio, int indent, const char name, const unsigned char *pmsg, size_t pmsglen, unsigned int version) { int vers; if (pmsglen < 2) return 0; vers = ((pmsg)[0] << 8) \| (pmsg)[1]; if (version != NULL) version = vers; BIO_indent(bio, indent, 80); BIO_printf(bio, "%s=0x%x (%s)\n", name, vers, ssl_trace_str(vers, ssl_version_tbl)); pmsg += 2; pmsglen -= 2; return 1; } static int ssl_print_random(BIO bio, int indent, const unsigned char *pmsg, size_t pmsglen) { unsigned int tm; const unsigned char p = pmsg; if (pmsglen < 32) return 0; tm = ((unsigned int)p[0] << 24) \| ((unsigned int)p[1] << 16) \| ((unsigned int)p[2] << 8) \| (unsigned int)p[3]; p += 4; BIO_indent(bio, indent, 80); BIO_puts(bio, "Random:\n"); BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "gmt_unix_time=0x%08X\n", tm); ssl_print_hex(bio, indent + 2, "random_bytes", p, 28); pmsg += 32; pmsglen -= 32; return 1; } static int ssl_print_signature(BIO bio, int indent, const SSL_CONNECTION sc, const unsigned char pmsg, size_t pmsglen) { if (pmsglen < 2) return 0; if (SSL_USE_SIGALGS(sc)) { const unsigned char p = pmsg; unsigned int sigalg = (p[0] << 8) \| p[1]; BIO_indent(bio, indent, 80); BIO_printf(bio, "Signature Algorithm: %s (0x%04x)\n", ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); pmsg += 2; pmsglen -= 2; } return ssl_print_hexbuf(bio, indent, "Signature", 2, pmsg, pmsglen); } static int ssl_print_extension(BIO bio, int indent, int server, unsigned char mt, int extype, const unsigned char ext, size_t extlen) { size_t xlen, share_len; unsigned int sigalg; uint32_t max_early_data; BIO_indent(bio, indent, 80); BIO_printf(bio, "extension_type=%s(%d), length=%d\n", ssl_trace_str(extype, ssl_exts_tbl), extype, (int)extlen); switch (extype) { case TLSEXT_TYPE_compress_certificate: if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2, ssl_comp_cert_tbl); case TLSEXT_TYPE_max_fragment_length: if (extlen < 1) return 0; xlen = extlen; return ssl_trace_list(bio, indent + 2, ext, xlen, 1, ssl_mfl_tbl); case TLSEXT_TYPE_ec_point_formats: if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_point_tbl); case TLSEXT_TYPE_supported_groups: if (extlen < 2) return 0; xlen = (ext[0] << 8) \| ext[1]; if (extlen != xlen + 2) return 0; return ssl_trace_list(bio, indent + 2, ext + 2, xlen, 2, ssl_groups_tbl); case TLSEXT_TYPE_application_layer_protocol_negotiation: if (extlen < 2) return 0; xlen = (ext[0] << 8) \| ext[1]; if (extlen != xlen + 2) return 0; ext += 2; while (xlen > 0) { size_t plen = ext++; if (plen + 1 > xlen) return 0; BIO_indent(bio, indent + 2, 80); BIO_write(bio, ext, plen); BIO_puts(bio, "\n"); ext += plen; xlen -= plen + 1; } return 1; case TLSEXT_TYPE_signature_algorithms: if (extlen < 2) return 0; xlen = (ext[0] << 8) \| ext[1]; if (extlen != xlen + 2) return 0; if (xlen & 1) return 0; ext += 2; while (xlen > 0) { BIO_indent(bio, indent + 2, 80); sigalg = (ext[0] << 8) \| ext[1]; BIO_printf(bio, "%s (0x%04x)\n", ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); xlen -= 2; ext += 2; } break; case TLSEXT_TYPE_renegotiate: if (extlen < 1) return 0; xlen = ext[0]; if (xlen + 1 != extlen) return 0; ext++; if (xlen) { if (server) { if (xlen & 1) return 0; xlen >>= 1; } ssl_print_hex(bio, indent + 4, "client_verify_data", ext, xlen); if (server) { ext += xlen; ssl_print_hex(bio, indent + 4, "server_verify_data", ext, xlen); } } else { BIO_indent(bio, indent + 4, 80); BIO_puts(bio, "<EMPTY>\n"); } break; case TLSEXT_TYPE_session_ticket: if (extlen != 0) ssl_print_hex(bio, indent + 4, "ticket", ext, extlen); break; case TLSEXT_TYPE_key_share: if (server && extlen == 2) { int group_id; /* We assume this is an HRR, otherwise this is an invalid key_share / group_id = (ext[0] << 8) \| ext[1]; BIO_indent(bio, indent + 4, 80); BIO_printf(bio, "NamedGroup: %s (%d)\n", ssl_trace_str(group_id, ssl_groups_tbl), group_id); break; } if (extlen < 2) return 0; if (server) { xlen = extlen; } else { xlen = (ext[0] << 8) \| ext[1]; if (extlen != xlen + 2) return 0; ext += 2; } for (; xlen > 0; ext += share_len, xlen -= share_len) { int group_id; if (xlen < 4) return 0; group_id = (ext[0] << 8) \| ext[1]; share_len = (ext[2] << 8) \| ext[3]; ext += 4; xlen -= 4; if (xlen < share_len) return 0; BIO_indent(bio, indent + 4, 80); BIO_printf(bio, "NamedGroup: %s (%d)\n", ssl_trace_str(group_id, ssl_groups_tbl), group_id); ssl_print_hex(bio, indent + 4, "key_exchange: ", ext, share_len); } break; case TLSEXT_TYPE_supported_versions: if (server) { int version; if (extlen != 2) return 0; version = (ext[0] << 8) \| ext[1]; BIO_indent(bio, indent + 4, 80); BIO_printf(bio, "%s (%d)\n", ssl_trace_str(version, ssl_version_tbl), version); break; } if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2, ssl_version_tbl); case TLSEXT_TYPE_psk_kex_modes: if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_psk_kex_modes_tbl); case TLSEXT_TYPE_early_data: if (mt != SSL3_MT_NEWSESSION_TICKET) break; if (extlen != 4) return 0; max_early_data = ((unsigned int)ext[0] << 24) \| ((unsigned int)ext[1] << 16) \| ((unsigned int)ext[2] << 8) \| (unsigned int)ext[3]; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "max_early_data=%u\n", (unsigned int)max_early_data); break; case TLSEXT_TYPE_server_cert_type: case TLSEXT_TYPE_client_cert_type: if (server) { if (extlen != 1) return 0; return ssl_trace_list(bio, indent + 2, ext, 1, 1, ssl_cert_type_tbl); } if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_cert_type_tbl); default: BIO_dump_indent(bio, (const char )ext, extlen, indent + 2); } return 1; } static int ssl_print_extensions(BIO bio, int indent, int server, unsigned char mt, const unsigned char msgin, size_t msginlen) { size_t extslen, msglen = msginlen; const unsigned char msg = msgin; BIO_indent(bio, indent, 80); if (msglen == 0) { BIO_puts(bio, "No extensions\n"); return 1; } if (msglen < 2) return 0; extslen = (msg[0] << 8) \| msg[1]; msglen -= 2; msg += 2; if (extslen == 0) { BIO_puts(bio, "No extensions\n"); msgin = msg; msginlen = msglen; return 1; } if (extslen > msglen) return 0; BIO_printf(bio, "extensions, length = %d\n", (int)extslen); msglen -= extslen; while (extslen > 0) { int extype; size_t extlen; if (extslen < 4) return 0; extype = (msg[0] << 8) \| msg[1]; extlen = (msg[2] << 8) \| msg[3]; if (extslen < extlen + 4) { BIO_printf(bio, "extensions, extype = %d, extlen = %d\n", extype, (int)extlen); BIO_dump_indent(bio, (const char )msg, extslen, indent + 2); return 0; } msg += 4; if (!ssl_print_extension(bio, indent + 2, server, mt, extype, msg, extlen)) return 0; msg += extlen; extslen -= extlen + 4; } msgin = msg; msginlen = msglen; return 1; } static int ssl_print_client_hello(BIO bio, const SSL_CONNECTION sc, int indent, const unsigned char msg, size_t msglen) { size_t len; unsigned int cs; if (!ssl_print_version(bio, indent, "client_version", &msg, &msglen, NULL)) return 0; if (!ssl_print_random(bio, indent, &msg, &msglen)) return 0; if (!ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen)) return 0; if (SSL_CONNECTION_IS_DTLS(sc)) { if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen)) return 0; } if (msglen < 2) return 0; len = (msg[0] << 8) \| msg[1]; msg += 2; msglen -= 2; BIO_indent(bio, indent, 80); BIO_printf(bio, "cipher_suites (len=%d)\n", (int)len); if (msglen < len \|\| len & 1) return 0; while (len > 0) { cs = (msg[0] << 8) \| msg[1]; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "{0x%02X, 0x%02X} %s\n", msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl)); msg += 2; msglen -= 2; len -= 2; } if (msglen < 1) return 0; len = msg[0]; msg++; msglen--; if (msglen < len) return 0; BIO_indent(bio, indent, 80); BIO_printf(bio, "compression_methods (len=%d)\n", (int)len); while (len > 0) { BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "%s (0x%02X)\n", ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]); msg++; msglen--; len--; } if (!ssl_print_extensions(bio, indent, 0, SSL3_MT_CLIENT_HELLO, &msg, &msglen)) return 0; return 1; } static int dtls_print_hello_vfyrequest(BIO bio, int indent, const unsigned char msg, size_t msglen) { if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, NULL)) return 0; if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen)) return 0; return 1; } static int ssl_print_server_hello(BIO bio, int indent, const unsigned char msg, size_t msglen) { unsigned int cs; unsigned int vers; if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, &vers)) return 0; if (!ssl_print_random(bio, indent, &msg, &msglen)) return 0; if (vers != TLS1_3_VERSION && !ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen)) return 0; if (msglen < 2) return 0; cs = (msg[0] << 8) \| msg[1]; BIO_indent(bio, indent, 80); BIO_printf(bio, "cipher_suite {0x%02X, 0x%02X} %s\n", msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl)); msg += 2; msglen -= 2; if (vers != TLS1_3_VERSION) { if (msglen < 1) return 0; BIO_indent(bio, indent, 80); BIO_printf(bio, "compression_method: %s (0x%02X)\n", ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]); msg++; msglen--; } if (!ssl_print_extensions(bio, indent, 1, SSL3_MT_SERVER_HELLO, &msg, &msglen)) return 0; return 1; } static int ssl_get_keyex(const char pname, const SSL_CONNECTION sc) { unsigned long alg_k = sc->s3.tmp.new_cipher->algorithm_mkey; if (alg_k & SSL_kRSA) { pname = "rsa"; return SSL_kRSA; } if (alg_k & SSL_kDHE) { pname = "DHE"; return SSL_kDHE; } if (alg_k & SSL_kECDHE) { pname = "ECDHE"; return SSL_kECDHE; } if (alg_k & SSL_kPSK) { pname = "PSK"; return SSL_kPSK; } if (alg_k & SSL_kRSAPSK) { pname = "RSAPSK"; return SSL_kRSAPSK; } if (alg_k & SSL_kDHEPSK) { pname = "DHEPSK"; return SSL_kDHEPSK; } if (alg_k & SSL_kECDHEPSK) { pname = "ECDHEPSK"; return SSL_kECDHEPSK; } if (alg_k & SSL_kSRP) { pname = "SRP"; return SSL_kSRP; } if (alg_k & SSL_kGOST) { pname = "GOST"; return SSL_kGOST; } if (alg_k & SSL_kGOST18) { pname = "GOST18"; return SSL_kGOST18; } pname = "UNKNOWN"; return 0; } static int ssl_print_client_keyex(BIO bio, int indent, const SSL_CONNECTION sc, const unsigned char msg, size_t msglen) { const char algname; int id = ssl_get_keyex(&algname, sc); BIO_indent(bio, indent, 80); BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname); if (id & SSL_PSK) { if (!ssl_print_hexbuf(bio, indent + 2, "psk_identity", 2, &msg, &msglen)) return 0; } switch (id) { case SSL_kRSA: case SSL_kRSAPSK: if (TLS1_get_version(SSL_CONNECTION_GET_SSL(sc)) == SSL3_VERSION) { ssl_print_hex(bio, indent + 2, "EncryptedPreMasterSecret", msg, msglen); } else { if (!ssl_print_hexbuf(bio, indent + 2, "EncryptedPreMasterSecret", 2, &msg, &msglen)) return 0; } break; case SSL_kDHE: case SSL_kDHEPSK: if (!ssl_print_hexbuf(bio, indent + 2, "dh_Yc", 2, &msg, &msglen)) return 0; break; case SSL_kECDHE: case SSL_kECDHEPSK: if (!ssl_print_hexbuf(bio, indent + 2, "ecdh_Yc", 1, &msg, &msglen)) return 0; break; case SSL_kGOST: ssl_print_hex(bio, indent + 2, "GostKeyTransportBlob", msg, msglen); msglen = 0; break; case SSL_kGOST18: ssl_print_hex(bio, indent + 2, "GOST-wrapped PreMasterSecret", msg, msglen); msglen = 0; break; } return !msglen; } static int ssl_print_server_keyex(BIO bio, int indent, const SSL_CONNECTION sc, const unsigned char msg, size_t msglen) { const char algname; int id = ssl_get_keyex(&algname, sc); BIO_indent(bio, indent, 80); BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname); if (id & SSL_PSK) { if (!ssl_print_hexbuf(bio, indent + 2, "psk_identity_hint", 2, &msg, &msglen)) return 0; } switch (id) { case SSL_kRSA: if (!ssl_print_hexbuf(bio, indent + 2, "rsa_modulus", 2, &msg, &msglen)) return 0; if (!ssl_print_hexbuf(bio, indent + 2, "rsa_exponent", 2, &msg, &msglen)) return 0; break; case SSL_kDHE: case SSL_kDHEPSK: if (!ssl_print_hexbuf(bio, indent + 2, "dh_p", 2, &msg, &msglen)) return 0; if (!ssl_print_hexbuf(bio, indent + 2, "dh_g", 2, &msg, &msglen)) return 0; if (!ssl_print_hexbuf(bio, indent + 2, "dh_Ys", 2, &msg, &msglen)) return 0; break; case SSL_kECDHE: case SSL_kECDHEPSK: if (msglen < 1) return 0; BIO_indent(bio, indent + 2, 80); if (msg[0] == EXPLICIT_PRIME_CURVE_TYPE) BIO_puts(bio, "explicit_prime\n"); else if (msg[0] == EXPLICIT_CHAR2_CURVE_TYPE) BIO_puts(bio, "explicit_char2\n"); else if (msg[0] == NAMED_CURVE_TYPE) { int curve; if (msglen < 3) return 0; curve = (msg[1] << 8) \| msg[2]; BIO_printf(bio, "named_curve: %s (%d)\n", ssl_trace_str(curve, ssl_groups_tbl), curve); msg += 3; msglen -= 3; if (!ssl_print_hexbuf(bio, indent + 2, "point", 1, &msg, &msglen)) return 0; } else { BIO_printf(bio, "UNKNOWN CURVE PARAMETER TYPE %d\n", msg[0]); return 0; } break; case SSL_kPSK: case SSL_kRSAPSK: break; } if (!(id & SSL_PSK)) ssl_print_signature(bio, indent, sc, &msg, &msglen); return !msglen; } static int ssl_print_certificate(BIO bio, const SSL_CONNECTION sc, int indent, const unsigned char pmsg, size_t pmsglen) { size_t msglen = pmsglen; size_t clen; X509 x; const unsigned char p = pmsg, q; SSL_CTX ctx = SSL_CONNECTION_GET_CTX(sc); if (msglen < 3) return 0; clen = (p[0] << 16) \| (p[1] << 8) \| p[2]; if (msglen < clen + 3) return 0; q = p + 3; BIO_indent(bio, indent, 80); BIO_printf(bio, "ASN.1Cert, length=%d", (int)clen); x = X509_new_ex(ctx->libctx, ctx->propq); if (x != NULL && d2i_X509(&x, &q, clen) == NULL) { X509_free(x); x = NULL; } if (x == NULL) BIO_puts(bio, "<UNPARSEABLE CERTIFICATE>\n"); else { BIO_puts(bio, "\n------details-----\n"); X509_print_ex(bio, x, XN_FLAG_ONELINE, 0); PEM_write_bio_X509(bio, x); /* Print certificate stuff / BIO_puts(bio, "------------------\n"); X509_free(x); } if (q != p + 3 + clen) { BIO_puts(bio, "<TRAILING GARBAGE AFTER CERTIFICATE>\n"); } pmsg += clen + 3; pmsglen -= clen + 3; return 1; } static int ssl_print_raw_public_key(BIO bio, const SSL ssl, int server, int indent, const unsigned char pmsg, size_t pmsglen) { EVP_PKEY pkey; size_t clen; const unsigned char msg = pmsg; size_t msglen = pmsglen; if (msglen < 3) return 0; clen = (msg[0] << 16) \| (msg[1] << 8) \| msg[2]; if (msglen < clen + 3) return 0; msg += 3; BIO_indent(bio, indent, 80); BIO_printf(bio, "raw_public_key, length=%d\n", (int)clen); pkey = d2i_PUBKEY_ex(NULL, &msg, clen, ssl->ctx->libctx, ssl->ctx->propq); if (pkey == NULL) return 0; EVP_PKEY_print_public(bio, pkey, indent + 2, NULL); EVP_PKEY_free(pkey); pmsg += clen + 3; pmsglen -= clen + 3; return 1; } static int ssl_print_certificates(BIO bio, const SSL_CONNECTION sc, int server, int indent, const unsigned char msg, size_t msglen) { size_t clen; if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_print_hexbuf(bio, indent, "context", 1, &msg, &msglen)) return 0; if (msglen < 3) return 0; clen = (msg[0] << 16) \| (msg[1] << 8) \| msg[2]; if (msglen != clen + 3) return 0; msg += 3; if ((server && sc->ext.server_cert_type == TLSEXT_cert_type_rpk) \|\| (!server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk)) { if (!ssl_print_raw_public_key(bio, &sc->ssl, server, indent, &msg, &clen)) return 0; if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_print_extensions(bio, indent + 2, server, SSL3_MT_CERTIFICATE, &msg, &clen)) return 0; return 1; } BIO_indent(bio, indent, 80); BIO_printf(bio, "certificate_list, length=%d\n", (int)clen); while (clen > 0) { if (!ssl_print_certificate(bio, sc, indent + 2, &msg, &clen)) return 0; if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_print_extensions(bio, indent + 2, server, SSL3_MT_CERTIFICATE, &msg, &clen)) return 0; } return 1; } static int ssl_print_compressed_certificates(BIO bio, const SSL_CONNECTION sc, int server, int indent, const unsigned char msg, size_t msglen) { size_t uclen; size_t clen; unsigned int alg; int ret = 1; #ifndef OPENSSL_NO_COMP_ALG COMP_METHOD method; COMP_CTX comp = NULL; unsigned char* ucdata = NULL; #endif if (msglen < 8) return 0; alg = (msg[0] << 8) \| msg[1]; uclen = (msg[2] << 16) \| (msg[3] << 8) \| msg[4]; clen = (msg[5] << 16) \| (msg[6] << 8) \| msg[7]; if (msglen != clen + 8) return 0; msg += 8; BIO_indent(bio, indent, 80); BIO_printf(bio, "Compression type=%s (0x%04x)\n", ssl_trace_str(alg, ssl_comp_cert_tbl), alg); BIO_indent(bio, indent, 80); BIO_printf(bio, "Uncompressed length=%d\n", (int)uclen); BIO_indent(bio, indent, 80); if (clen > 0) BIO_printf(bio, "Compressed length=%d, Ratio=%f:1\n", (int)clen, (float)uclen / (float)clen); else BIO_printf(bio, "Compressed length=%d, Ratio=unknown\n", (int)clen); BIO_dump_indent(bio, (const char )msg, clen, indent); #ifndef OPENSSL_NO_COMP_ALG if (!ossl_comp_has_alg(alg)) return 0; / Check against certificate maximum size (coverity) / if (uclen == 0 \|\| uclen > 0xFFFFFF \|\| (ucdata = OPENSSL_malloc(uclen)) == NULL) return 0; switch (alg) { case TLSEXT_comp_cert_zlib: method = COMP_zlib(); break; case TLSEXT_comp_cert_brotli: method = COMP_brotli_oneshot(); break; case TLSEXT_comp_cert_zstd: method = COMP_zstd_oneshot(); break; default: goto err; } if ((comp = COMP_CTX_new(method)) == NULL \|\| COMP_expand_block(comp, ucdata, uclen, (unsigned char)msg, clen) != (int)uclen) goto err; ret = ssl_print_certificates(bio, sc, server, indent, ucdata, uclen); err: COMP_CTX_free(comp); OPENSSL_free(ucdata); #endif return ret; } static int ssl_print_cert_request(BIO bio, int indent, const SSL_CONNECTION sc, const unsigned char msg, size_t msglen) { size_t xlen; unsigned int sigalg; if (SSL_CONNECTION_IS_TLS13(sc)) { if (!ssl_print_hexbuf(bio, indent, "request_context", 1, &msg, &msglen)) return 0; if (!ssl_print_extensions(bio, indent, 1, SSL3_MT_CERTIFICATE_REQUEST, &msg, &msglen)) return 0; return 1; } else { if (msglen < 1) return 0; xlen = msg[0]; if (msglen < xlen + 1) return 0; msg++; BIO_indent(bio, indent, 80); BIO_printf(bio, "certificate_types (len=%d)\n", (int)xlen); if (!ssl_trace_list(bio, indent + 2, msg, xlen, 1, ssl_ctype_tbl)) return 0; msg += xlen; msglen -= xlen + 1; } if (SSL_USE_SIGALGS(sc)) { if (msglen < 2) return 0; xlen = (msg[0] << 8) \| msg[1]; if (msglen < xlen + 2 \|\| (xlen & 1)) return 0; msg += 2; msglen -= xlen + 2; BIO_indent(bio, indent, 80); BIO_printf(bio, "signature_algorithms (len=%d)\n", (int)xlen); while (xlen > 0) { BIO_indent(bio, indent + 2, 80); sigalg = (msg[0] << 8) \| msg[1]; BIO_printf(bio, "%s (0x%04x)\n", ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); xlen -= 2; msg += 2; } msg += xlen; } if (msglen < 2) return 0; xlen = (msg[0] << 8) \| msg[1]; BIO_indent(bio, indent, 80); if (msglen < xlen + 2) return 0; msg += 2; msglen -= 2 + xlen; BIO_printf(bio, "certificate_authorities (len=%d)\n", (int)xlen); while (xlen > 0) { size_t dlen; X509_NAME nm; const unsigned char p; if (xlen < 2) return 0; dlen = (msg[0] << 8) \| msg[1]; if (xlen < dlen + 2) return 0; msg += 2; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "DistinguishedName (len=%d): ", (int)dlen); p = msg; nm = d2i_X509_NAME(NULL, &p, dlen); if (!nm) { BIO_puts(bio, "<UNPARSEABLE DN>\n"); } else { X509_NAME_print_ex(bio, nm, 0, XN_FLAG_ONELINE); BIO_puts(bio, "\n"); X509_NAME_free(nm); } xlen -= dlen + 2; msg += dlen; } if (SSL_CONNECTION_IS_TLS13(sc)) { if (!ssl_print_hexbuf(bio, indent, "request_extensions", 2, &msg, &msglen)) return 0; } return msglen == 0; } static int ssl_print_ticket(BIO bio, int indent, const SSL_CONNECTION sc, const unsigned char msg, size_t msglen) { unsigned int tick_life; if (msglen == 0) { BIO_indent(bio, indent + 2, 80); BIO_puts(bio, "No Ticket\n"); return 1; } if (msglen < 4) return 0; tick_life = ((unsigned int)msg[0] << 24) \| ((unsigned int)msg[1] << 16) \| ((unsigned int)msg[2] << 8) \| (unsigned int)msg[3]; msglen -= 4; msg += 4; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "ticket_lifetime_hint=%u\n", tick_life); if (SSL_CONNECTION_IS_TLS13(sc)) { unsigned int ticket_age_add; if (msglen < 4) return 0; ticket_age_add = ((unsigned int)msg[0] << 24) \| ((unsigned int)msg[1] << 16) \| ((unsigned int)msg[2] << 8) \| (unsigned int)msg[3]; msglen -= 4; msg += 4; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "ticket_age_add=%u\n", ticket_age_add); if (!ssl_print_hexbuf(bio, indent + 2, "ticket_nonce", 1, &msg, &msglen)) return 0; } if (!ssl_print_hexbuf(bio, indent + 2, "ticket", 2, &msg, &msglen)) return 0; if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_print_extensions(bio, indent + 2, 0, SSL3_MT_NEWSESSION_TICKET, &msg, &msglen)) return 0; if (msglen) return 0; return 1; } static int ssl_print_handshake(BIO bio, const SSL_CONNECTION sc, int server, const unsigned char msg, size_t msglen, int indent) { size_t hlen; unsigned char htype; if (msglen < 4) return 0; htype = msg[0]; hlen = (msg[1] << 16) \| (msg[2] << 8) \| msg[3]; BIO_indent(bio, indent, 80); BIO_printf(bio, "%s, Length=%d\n", ssl_trace_str(htype, ssl_handshake_tbl), (int)hlen); msg += 4; msglen -= 4; if (SSL_CONNECTION_IS_DTLS(sc)) { if (msglen < 8) return 0; BIO_indent(bio, indent, 80); BIO_printf(bio, "message_seq=%d, fragment_offset=%d, " "fragment_length=%d\n", (msg[0] << 8) \| msg[1], (msg[2] << 16) \| (msg[3] << 8) \| msg[4], (msg[5] << 16) \| (msg[6] << 8) \| msg[7]); msg += 8; msglen -= 8; } if (msglen < hlen) return 0; switch (htype) { case SSL3_MT_CLIENT_HELLO: if (!ssl_print_client_hello(bio, sc, indent + 2, msg, msglen)) return 0; break; case DTLS1_MT_HELLO_VERIFY_REQUEST: if (!dtls_print_hello_vfyrequest(bio, indent + 2, msg, msglen)) return 0; break; case SSL3_MT_SERVER_HELLO: if (!ssl_print_server_hello(bio, indent + 2, msg, msglen)) return 0; break; case SSL3_MT_SERVER_KEY_EXCHANGE: if (!ssl_print_server_keyex(bio, indent + 2, sc, msg, msglen)) return 0; break; case SSL3_MT_CLIENT_KEY_EXCHANGE: if (!ssl_print_client_keyex(bio, indent + 2, sc, msg, msglen)) return 0; break; case SSL3_MT_CERTIFICATE: if (!ssl_print_certificates(bio, sc, server, indent + 2, msg, msglen)) return 0; break; case SSL3_MT_COMPRESSED_CERTIFICATE: if (!ssl_print_compressed_certificates(bio, sc, server, indent + 2, msg, msglen)) return 0; break; case SSL3_MT_CERTIFICATE_VERIFY: if (!ssl_print_signature(bio, indent + 2, sc, &msg, &msglen)) return 0; break; case SSL3_MT_CERTIFICATE_REQUEST: if (!ssl_print_cert_request(bio, indent + 2, sc, msg, msglen)) return 0; break; case SSL3_MT_FINISHED: ssl_print_hex(bio, indent + 2, "verify_data", msg, msglen); break; case SSL3_MT_SERVER_DONE: if (msglen != 0) ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen); break; case SSL3_MT_NEWSESSION_TICKET: if (!ssl_print_ticket(bio, indent + 2, sc, msg, msglen)) return 0; break; case SSL3_MT_ENCRYPTED_EXTENSIONS: if (!ssl_print_extensions(bio, indent + 2, 1, SSL3_MT_ENCRYPTED_EXTENSIONS, &msg, &msglen)) return 0; break; case SSL3_MT_KEY_UPDATE: if (msglen != 1) { ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen); return 0; } if (!ssl_trace_list(bio, indent + 2, msg, msglen, 1, ssl_key_update_tbl)) return 0; break; default: BIO_indent(bio, indent + 2, 80); BIO_puts(bio, "Unsupported, hex dump follows:\n"); BIO_dump_indent(bio, (const char )msg, msglen, indent + 4); } return 1; } void SSL_trace(int write_p, int version, int content_type, const void buf, size_t msglen, SSL ssl, void arg) { const unsigned char msg = buf; BIO bio = arg; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); #ifndef OPENSSL_NO_QUIC QUIC_CONNECTION qc = QUIC_CONNECTION_FROM_SSL(ssl); if (qc != NULL) { if (ossl_quic_trace(write_p, version, content_type, buf, msglen, ssl, arg)) return; / * Otherwise ossl_quic_trace didn't handle this content_type so we * fallback to standard TLS handling / } #endif if (sc == NULL) return; switch (content_type) { case SSL3_RT_HEADER: { int hvers; / avoid overlapping with length at the end of buffer */ if (msglen < (size_t)(SSL_CONNECTION_IS_DTLS(sc) ? DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH)) { BIO_puts(bio, write_p ? "Sent" : "Received"); ssl_print_hex(bio, 0, " too short message", msg, msglen); break; } hvers = msg[1] << 8 \| msg[2]; BIO_puts(bio, write_p ? "Sent" : "Received"); BIO_printf(bio, " TLS Record\nHeader:\n Version = %s (0x%x)\n", ssl_trace_str(hvers, ssl_version_tbl), hvers); if (SSL_CONNECTION_IS_DTLS(sc)) { BIO_printf(bio, " epoch=%d, sequence_number=%04x%04x%04x\n", (msg[3] << 8 \| msg[4]), (msg[5] << 8 \| msg[6]), (msg[7] << 8 \| msg[8]), (msg[9] << 8 \| msg[10])); } BIO_printf(bio, " Content Type = %s (%d)\n Length = %d", ssl_trace_str(msg[0], ssl_content_tbl), msg[0], msg[msglen - 2] << 8 \| msg[msglen - 1]); } break; case SSL3_RT_INNER_CONTENT_TYPE: BIO_printf(bio, " Inner Content Type = %s (%d)", ssl_trace_str(msg[0], ssl_content_tbl), msg[0]); break; case SSL3_RT_HANDSHAKE: if (!ssl_print_handshake(bio, sc, sc->server ? write_p : !write_p, msg, msglen, 4)) BIO_printf(bio, "Message length parse error!\n"); break; case SSL3_RT_CHANGE_CIPHER_SPEC: if (msglen == 1 && msg[0] == 1) BIO_puts(bio, " change_cipher_spec (1)\n"); else ssl_print_hex(bio, 4, "unknown value", msg, msglen); break; case SSL3_RT_ALERT: if (msglen != 2) BIO_puts(bio, " Illegal Alert Length\n"); else { BIO_printf(bio, " Level=%s(%d), description=%s(%d)\n", SSL_alert_type_string_long(msg[0] << 8), msg[0], SSL_alert_desc_string_long(msg[1]), msg[1]); } } BIO_puts(bio, "\n"); } #endif
./openssl/ssl/sslerr.h	/* * Generated by util/mkerr.pl DO NOT EDIT * Copyright 2020-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #ifndef OSSL_SSLERR_H # define OSSL_SSLERR_H # pragma once # include <openssl/opensslconf.h> # include <openssl/symhacks.h> # ifdef __cplusplus extern "C" { # endif int ossl_err_load_SSL_strings(void); # ifdef __cplusplus } # endif #endif
./openssl/ssl/d1_srtp.c	/* * Copyright 2011-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / * DTLS code by Eric Rescorla <ekr@rtfm.com> * * Copyright (C) 2006, Network Resonance, Inc. Copyright (C) 2011, RTFM, Inc. / #include <stdio.h> #include <openssl/objects.h> #include "ssl_local.h" #include "quic/quic_local.h" #ifndef OPENSSL_NO_SRTP static SRTP_PROTECTION_PROFILE srtp_known_profiles[] = { { "SRTP_AES128_CM_SHA1_80", SRTP_AES128_CM_SHA1_80, }, { "SRTP_AES128_CM_SHA1_32", SRTP_AES128_CM_SHA1_32, }, { "SRTP_AEAD_AES_128_GCM", SRTP_AEAD_AES_128_GCM, }, { "SRTP_AEAD_AES_256_GCM", SRTP_AEAD_AES_256_GCM, }, { "SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM", SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM, }, { "SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM", SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM, }, { "SRTP_ARIA_128_CTR_HMAC_SHA1_80", SRTP_ARIA_128_CTR_HMAC_SHA1_80, }, { "SRTP_ARIA_128_CTR_HMAC_SHA1_32", SRTP_ARIA_128_CTR_HMAC_SHA1_32, }, { "SRTP_ARIA_256_CTR_HMAC_SHA1_80", SRTP_ARIA_256_CTR_HMAC_SHA1_80, }, { "SRTP_ARIA_256_CTR_HMAC_SHA1_32", SRTP_ARIA_256_CTR_HMAC_SHA1_32, }, { "SRTP_AEAD_ARIA_128_GCM", SRTP_AEAD_ARIA_128_GCM, }, { "SRTP_AEAD_ARIA_256_GCM", SRTP_AEAD_ARIA_256_GCM, }, {0} }; static int find_profile_by_name(char profile_name, SRTP_PROTECTION_PROFILE *pptr, size_t len) { SRTP_PROTECTION_PROFILE p; p = srtp_known_profiles; while (p->name) { if ((len == strlen(p->name)) && strncmp(p->name, profile_name, len) == 0) { pptr = p; return 0; } p++; } return 1; } static int ssl_ctx_make_profiles(const char profiles_string, STACK_OF(SRTP_PROTECTION_PROFILE) *out) { STACK_OF(SRTP_PROTECTION_PROFILE) profiles; char col; char ptr = (char )profiles_string; SRTP_PROTECTION_PROFILE p; if ((profiles = sk_SRTP_PROTECTION_PROFILE_new_null()) == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES); return 1; } do { col = strchr(ptr, ':'); if (!find_profile_by_name(ptr, &p, col ? (size_t)(col - ptr) : strlen(ptr))) { if (sk_SRTP_PROTECTION_PROFILE_find(profiles, p) >= 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); goto err; } if (!sk_SRTP_PROTECTION_PROFILE_push(profiles, p)) { ERR_raise(ERR_LIB_SSL, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES); goto err; } } else { ERR_raise(ERR_LIB_SSL, SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE); goto err; } if (col) ptr = col + 1; } while (col); sk_SRTP_PROTECTION_PROFILE_free(out); out = profiles; return 0; err: sk_SRTP_PROTECTION_PROFILE_free(profiles); return 1; } int SSL_CTX_set_tlsext_use_srtp(SSL_CTX ctx, const char profiles) { if (IS_QUIC_METHOD(ctx->method)) return 1; return ssl_ctx_make_profiles(profiles, &ctx->srtp_profiles); } int SSL_set_tlsext_use_srtp(SSL s, const char profiles) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 1; return ssl_ctx_make_profiles(profiles, &sc->srtp_profiles); } STACK_OF(SRTP_PROTECTION_PROFILE) SSL_get_srtp_profiles(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc != NULL) { if (sc->srtp_profiles != NULL) { return sc->srtp_profiles; } else if ((s->ctx != NULL) && (s->ctx->srtp_profiles != NULL)) { return s->ctx->srtp_profiles; } } return NULL; } SRTP_PROTECTION_PROFILE SSL_get_selected_srtp_profile(SSL s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; return sc->srtp_profile; } #endif
./openssl/ssl/ssl_stat.c	/* * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include "ssl_local.h" const char SSL_state_string_long(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL \|\| ossl_statem_in_error(sc)) return "error"; switch (SSL_get_state(s)) { case TLS_ST_CR_CERT_STATUS: return "SSLv3/TLS read certificate status"; case TLS_ST_CW_NEXT_PROTO: return "SSLv3/TLS write next proto"; case TLS_ST_SR_NEXT_PROTO: return "SSLv3/TLS read next proto"; case TLS_ST_SW_CERT_STATUS: return "SSLv3/TLS write certificate status"; case TLS_ST_BEFORE: return "before SSL initialization"; case TLS_ST_OK: return "SSL negotiation finished successfully"; case TLS_ST_CW_CLNT_HELLO: return "SSLv3/TLS write client hello"; case TLS_ST_CR_SRVR_HELLO: return "SSLv3/TLS read server hello"; case TLS_ST_CR_CERT: return "SSLv3/TLS read server certificate"; case TLS_ST_CR_COMP_CERT: return "TLSv1.3 read server compressed certificate"; case TLS_ST_CR_KEY_EXCH: return "SSLv3/TLS read server key exchange"; case TLS_ST_CR_CERT_REQ: return "SSLv3/TLS read server certificate request"; case TLS_ST_CR_SESSION_TICKET: return "SSLv3/TLS read server session ticket"; case TLS_ST_CR_SRVR_DONE: return "SSLv3/TLS read server done"; case TLS_ST_CW_CERT: return "SSLv3/TLS write client certificate"; case TLS_ST_CW_COMP_CERT: return "TLSv1.3 write client compressed certificate"; case TLS_ST_CW_KEY_EXCH: return "SSLv3/TLS write client key exchange"; case TLS_ST_CW_CERT_VRFY: return "SSLv3/TLS write certificate verify"; case TLS_ST_CW_CHANGE: case TLS_ST_SW_CHANGE: return "SSLv3/TLS write change cipher spec"; case TLS_ST_CW_FINISHED: case TLS_ST_SW_FINISHED: return "SSLv3/TLS write finished"; case TLS_ST_CR_CHANGE: case TLS_ST_SR_CHANGE: return "SSLv3/TLS read change cipher spec"; case TLS_ST_CR_FINISHED: case TLS_ST_SR_FINISHED: return "SSLv3/TLS read finished"; case TLS_ST_SR_CLNT_HELLO: return "SSLv3/TLS read client hello"; case TLS_ST_SW_HELLO_REQ: return "SSLv3/TLS write hello request"; case TLS_ST_SW_SRVR_HELLO: return "SSLv3/TLS write server hello"; case TLS_ST_SW_CERT: return "SSLv3/TLS write certificate"; case TLS_ST_SW_COMP_CERT: return "TLSv1.3 write server compressed certificate"; case TLS_ST_SW_KEY_EXCH: return "SSLv3/TLS write key exchange"; case TLS_ST_SW_CERT_REQ: return "SSLv3/TLS write certificate request"; case TLS_ST_SW_SESSION_TICKET: return "SSLv3/TLS write session ticket"; case TLS_ST_SW_SRVR_DONE: return "SSLv3/TLS write server done"; case TLS_ST_SR_CERT: return "SSLv3/TLS read client certificate"; case TLS_ST_SR_COMP_CERT: return "TLSv1.3 read client compressed certificate"; case TLS_ST_SR_KEY_EXCH: return "SSLv3/TLS read client key exchange"; case TLS_ST_SR_CERT_VRFY: return "SSLv3/TLS read certificate verify"; case DTLS_ST_CR_HELLO_VERIFY_REQUEST: return "DTLS1 read hello verify request"; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: return "DTLS1 write hello verify request"; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: return "TLSv1.3 write encrypted extensions"; case TLS_ST_CR_ENCRYPTED_EXTENSIONS: return "TLSv1.3 read encrypted extensions"; case TLS_ST_CR_CERT_VRFY: return "TLSv1.3 read server certificate verify"; case TLS_ST_SW_CERT_VRFY: return "TLSv1.3 write server certificate verify"; case TLS_ST_CR_HELLO_REQ: return "SSLv3/TLS read hello request"; case TLS_ST_SW_KEY_UPDATE: return "TLSv1.3 write server key update"; case TLS_ST_CW_KEY_UPDATE: return "TLSv1.3 write client key update"; case TLS_ST_SR_KEY_UPDATE: return "TLSv1.3 read client key update"; case TLS_ST_CR_KEY_UPDATE: return "TLSv1.3 read server key update"; case TLS_ST_EARLY_DATA: return "TLSv1.3 early data"; case TLS_ST_PENDING_EARLY_DATA_END: return "TLSv1.3 pending early data end"; case TLS_ST_CW_END_OF_EARLY_DATA: return "TLSv1.3 write end of early data"; case TLS_ST_SR_END_OF_EARLY_DATA: return "TLSv1.3 read end of early data"; default: return "unknown state"; } } const char SSL_state_string(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL \|\| ossl_statem_in_error(sc)) return "SSLERR"; switch (SSL_get_state(s)) { case TLS_ST_SR_NEXT_PROTO: return "TRNP"; case TLS_ST_SW_SESSION_TICKET: return "TWST"; case TLS_ST_SW_CERT_STATUS: return "TWCS"; case TLS_ST_CR_CERT_STATUS: return "TRCS"; case TLS_ST_CR_SESSION_TICKET: return "TRST"; case TLS_ST_CW_NEXT_PROTO: return "TWNP"; case TLS_ST_BEFORE: return "PINIT"; case TLS_ST_OK: return "SSLOK"; case TLS_ST_CW_CLNT_HELLO: return "TWCH"; case TLS_ST_CR_SRVR_HELLO: return "TRSH"; case TLS_ST_CR_CERT: return "TRSC"; case TLS_ST_CR_COMP_CERT: return "TRSCC"; case TLS_ST_CR_KEY_EXCH: return "TRSKE"; case TLS_ST_CR_CERT_REQ: return "TRCR"; case TLS_ST_CR_SRVR_DONE: return "TRSD"; case TLS_ST_CW_CERT: return "TWCC"; case TLS_ST_CW_COMP_CERT: return "TWCCC"; case TLS_ST_CW_KEY_EXCH: return "TWCKE"; case TLS_ST_CW_CERT_VRFY: return "TWCV"; case TLS_ST_SW_CHANGE: case TLS_ST_CW_CHANGE: return "TWCCS"; case TLS_ST_SW_FINISHED: case TLS_ST_CW_FINISHED: return "TWFIN"; case TLS_ST_SR_CHANGE: case TLS_ST_CR_CHANGE: return "TRCCS"; case TLS_ST_SR_FINISHED: case TLS_ST_CR_FINISHED: return "TRFIN"; case TLS_ST_SW_HELLO_REQ: return "TWHR"; case TLS_ST_SR_CLNT_HELLO: return "TRCH"; case TLS_ST_SW_SRVR_HELLO: return "TWSH"; case TLS_ST_SW_CERT: return "TWSC"; case TLS_ST_SW_COMP_CERT: return "TWSCC"; case TLS_ST_SW_KEY_EXCH: return "TWSKE"; case TLS_ST_SW_CERT_REQ: return "TWCR"; case TLS_ST_SW_SRVR_DONE: return "TWSD"; case TLS_ST_SR_CERT: return "TRCC"; case TLS_ST_SR_COMP_CERT: return "TRCCC"; case TLS_ST_SR_KEY_EXCH: return "TRCKE"; case TLS_ST_SR_CERT_VRFY: return "TRCV"; case DTLS_ST_CR_HELLO_VERIFY_REQUEST: return "DRCHV"; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: return "DWCHV"; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: return "TWEE"; case TLS_ST_CR_ENCRYPTED_EXTENSIONS: return "TREE"; case TLS_ST_CR_CERT_VRFY: return "TRSCV"; case TLS_ST_SW_CERT_VRFY: return "TWSCV"; case TLS_ST_CR_HELLO_REQ: return "TRHR"; case TLS_ST_SW_KEY_UPDATE: return "TWSKU"; case TLS_ST_CW_KEY_UPDATE: return "TWCKU"; case TLS_ST_SR_KEY_UPDATE: return "TRCKU"; case TLS_ST_CR_KEY_UPDATE: return "TRSKU"; case TLS_ST_EARLY_DATA: return "TED"; case TLS_ST_PENDING_EARLY_DATA_END: return "TPEDE"; case TLS_ST_CW_END_OF_EARLY_DATA: return "TWEOED"; case TLS_ST_SR_END_OF_EARLY_DATA: return "TWEOED"; default: return "UNKWN"; } } const char SSL_alert_type_string_long(int value) { switch (value >> 8) { case SSL3_AL_WARNING: return "warning"; case SSL3_AL_FATAL: return "fatal"; default: return "unknown"; } } const char SSL_alert_type_string(int value) { switch (value >> 8) { case SSL3_AL_WARNING: return "W"; case SSL3_AL_FATAL: return "F"; default: return "U"; } } const char SSL_alert_desc_string(int value) { switch (value & 0xff) { case SSL3_AD_CLOSE_NOTIFY: return "CN"; case SSL3_AD_UNEXPECTED_MESSAGE: return "UM"; case SSL3_AD_BAD_RECORD_MAC: return "BM"; case SSL3_AD_DECOMPRESSION_FAILURE: return "DF"; case SSL3_AD_HANDSHAKE_FAILURE: return "HF"; case SSL3_AD_NO_CERTIFICATE: return "NC"; case SSL3_AD_BAD_CERTIFICATE: return "BC"; case SSL3_AD_UNSUPPORTED_CERTIFICATE: return "UC"; case SSL3_AD_CERTIFICATE_REVOKED: return "CR"; case SSL3_AD_CERTIFICATE_EXPIRED: return "CE"; case SSL3_AD_CERTIFICATE_UNKNOWN: return "CU"; case SSL3_AD_ILLEGAL_PARAMETER: return "IP"; case TLS1_AD_DECRYPTION_FAILED: return "DC"; case TLS1_AD_RECORD_OVERFLOW: return "RO"; case TLS1_AD_UNKNOWN_CA: return "CA"; case TLS1_AD_ACCESS_DENIED: return "AD"; case TLS1_AD_DECODE_ERROR: return "DE"; case TLS1_AD_DECRYPT_ERROR: return "CY"; case TLS1_AD_EXPORT_RESTRICTION: return "ER"; case TLS1_AD_PROTOCOL_VERSION: return "PV"; case TLS1_AD_INSUFFICIENT_SECURITY: return "IS"; case TLS1_AD_INTERNAL_ERROR: return "IE"; case TLS1_AD_USER_CANCELLED: return "US"; case TLS1_AD_NO_RENEGOTIATION: return "NR"; case TLS1_AD_UNSUPPORTED_EXTENSION: return "UE"; case TLS1_AD_CERTIFICATE_UNOBTAINABLE: return "CO"; case TLS1_AD_UNRECOGNIZED_NAME: return "UN"; case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return "BR"; case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE: return "BH"; case TLS1_AD_UNKNOWN_PSK_IDENTITY: return "UP"; default: return "UK"; } } const char *SSL_alert_desc_string_long(int value) { switch (value & 0xff) { case SSL3_AD_CLOSE_NOTIFY: return "close notify"; case SSL3_AD_UNEXPECTED_MESSAGE: return "unexpected_message"; case SSL3_AD_BAD_RECORD_MAC: return "bad record mac"; case SSL3_AD_DECOMPRESSION_FAILURE: return "decompression failure"; case SSL3_AD_HANDSHAKE_FAILURE: return "handshake failure"; case SSL3_AD_NO_CERTIFICATE: return "no certificate"; case SSL3_AD_BAD_CERTIFICATE: return "bad certificate"; case SSL3_AD_UNSUPPORTED_CERTIFICATE: return "unsupported certificate"; case SSL3_AD_CERTIFICATE_REVOKED: return "certificate revoked"; case SSL3_AD_CERTIFICATE_EXPIRED: return "certificate expired"; case SSL3_AD_CERTIFICATE_UNKNOWN: return "certificate unknown"; case SSL3_AD_ILLEGAL_PARAMETER: return "illegal parameter"; case TLS1_AD_DECRYPTION_FAILED: return "decryption failed"; case TLS1_AD_RECORD_OVERFLOW: return "record overflow"; case TLS1_AD_UNKNOWN_CA: return "unknown CA"; case TLS1_AD_ACCESS_DENIED: return "access denied"; case TLS1_AD_DECODE_ERROR: return "decode error"; case TLS1_AD_DECRYPT_ERROR: return "decrypt error"; case TLS1_AD_EXPORT_RESTRICTION: return "export restriction"; case TLS1_AD_PROTOCOL_VERSION: return "protocol version"; case TLS1_AD_INSUFFICIENT_SECURITY: return "insufficient security"; case TLS1_AD_INTERNAL_ERROR: return "internal error"; case TLS1_AD_USER_CANCELLED: return "user canceled"; case TLS1_AD_NO_RENEGOTIATION: return "no renegotiation"; case TLS1_AD_UNSUPPORTED_EXTENSION: return "unsupported extension"; case TLS1_AD_CERTIFICATE_UNOBTAINABLE: return "certificate unobtainable"; case TLS1_AD_UNRECOGNIZED_NAME: return "unrecognized name"; case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return "bad certificate status response"; case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE: return "bad certificate hash value"; case TLS1_AD_UNKNOWN_PSK_IDENTITY: return "unknown PSK identity"; case TLS1_AD_NO_APPLICATION_PROTOCOL: return "no application protocol"; default: return "unknown"; } }
./openssl/ssl/ssl_err_legacy.c	/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / This is the C source file where we include this header directly */ #include <openssl/sslerr_legacy.h> #include "sslerr.h" #ifndef OPENSSL_NO_DEPRECATED_3_0 int ERR_load_SSL_strings(void) { return ossl_err_load_SSL_strings(); } #else NON_EMPTY_TRANSLATION_UNIT #endif
./openssl/ssl/t1_lib.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <stdlib.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/hmac.h> #include <openssl/core_names.h> #include <openssl/ocsp.h> #include <openssl/conf.h> #include <openssl/x509v3.h> #include <openssl/dh.h> #include <openssl/bn.h> #include <openssl/provider.h> #include <openssl/param_build.h> #include "internal/nelem.h" #include "internal/sizes.h" #include "internal/tlsgroups.h" #include "ssl_local.h" #include "quic/quic_local.h" #include <openssl/ct.h> static const SIGALG_LOOKUP find_sig_alg(SSL_CONNECTION s, X509 x, EVP_PKEY pkey); static int tls12_sigalg_allowed(const SSL_CONNECTION s, int op, const SIGALG_LOOKUP lu); SSL3_ENC_METHOD const TLSv1_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, 0, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; SSL3_ENC_METHOD const TLSv1_1_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, SSL_ENC_FLAG_EXPLICIT_IV, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; SSL3_ENC_METHOD const TLSv1_2_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, SSL_ENC_FLAG_EXPLICIT_IV \| SSL_ENC_FLAG_SIGALGS \| SSL_ENC_FLAG_SHA256_PRF \| SSL_ENC_FLAG_TLS1_2_CIPHERS, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; SSL3_ENC_METHOD const TLSv1_3_enc_data = { tls13_setup_key_block, tls13_generate_master_secret, tls13_change_cipher_state, tls13_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls13_alert_code, tls13_export_keying_material, SSL_ENC_FLAG_SIGALGS \| SSL_ENC_FLAG_SHA256_PRF, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; OSSL_TIME tls1_default_timeout(void) { / * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for * http, the cache would over fill / return ossl_seconds2time(60 60 * 2); } int tls1_new(SSL s) { if (!ssl3_new(s)) return 0; if (!s->method->ssl_clear(s)) return 0; return 1; } void tls1_free(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; OPENSSL_free(sc->ext.session_ticket); ssl3_free(s); } int tls1_clear(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (!ssl3_clear(s)) return 0; if (s->method->version == TLS_ANY_VERSION) sc->version = TLS_MAX_VERSION_INTERNAL; else sc->version = s->method->version; return 1; } / Legacy NID to group_id mapping. Only works for groups we know about / static const struct { int nid; uint16_t group_id; } nid_to_group[] = { {NID_sect163k1, OSSL_TLS_GROUP_ID_sect163k1}, {NID_sect163r1, OSSL_TLS_GROUP_ID_sect163r1}, {NID_sect163r2, OSSL_TLS_GROUP_ID_sect163r2}, {NID_sect193r1, OSSL_TLS_GROUP_ID_sect193r1}, {NID_sect193r2, OSSL_TLS_GROUP_ID_sect193r2}, {NID_sect233k1, OSSL_TLS_GROUP_ID_sect233k1}, {NID_sect233r1, OSSL_TLS_GROUP_ID_sect233r1}, {NID_sect239k1, OSSL_TLS_GROUP_ID_sect239k1}, {NID_sect283k1, OSSL_TLS_GROUP_ID_sect283k1}, {NID_sect283r1, OSSL_TLS_GROUP_ID_sect283r1}, {NID_sect409k1, OSSL_TLS_GROUP_ID_sect409k1}, {NID_sect409r1, OSSL_TLS_GROUP_ID_sect409r1}, {NID_sect571k1, OSSL_TLS_GROUP_ID_sect571k1}, {NID_sect571r1, OSSL_TLS_GROUP_ID_sect571r1}, {NID_secp160k1, OSSL_TLS_GROUP_ID_secp160k1}, {NID_secp160r1, OSSL_TLS_GROUP_ID_secp160r1}, {NID_secp160r2, OSSL_TLS_GROUP_ID_secp160r2}, {NID_secp192k1, OSSL_TLS_GROUP_ID_secp192k1}, {NID_X9_62_prime192v1, OSSL_TLS_GROUP_ID_secp192r1}, {NID_secp224k1, OSSL_TLS_GROUP_ID_secp224k1}, {NID_secp224r1, OSSL_TLS_GROUP_ID_secp224r1}, {NID_secp256k1, OSSL_TLS_GROUP_ID_secp256k1}, {NID_X9_62_prime256v1, OSSL_TLS_GROUP_ID_secp256r1}, {NID_secp384r1, OSSL_TLS_GROUP_ID_secp384r1}, {NID_secp521r1, OSSL_TLS_GROUP_ID_secp521r1}, {NID_brainpoolP256r1, OSSL_TLS_GROUP_ID_brainpoolP256r1}, {NID_brainpoolP384r1, OSSL_TLS_GROUP_ID_brainpoolP384r1}, {NID_brainpoolP512r1, OSSL_TLS_GROUP_ID_brainpoolP512r1}, {EVP_PKEY_X25519, OSSL_TLS_GROUP_ID_x25519}, {EVP_PKEY_X448, OSSL_TLS_GROUP_ID_x448}, {NID_brainpoolP256r1tls13, OSSL_TLS_GROUP_ID_brainpoolP256r1_tls13}, {NID_brainpoolP384r1tls13, OSSL_TLS_GROUP_ID_brainpoolP384r1_tls13}, {NID_brainpoolP512r1tls13, OSSL_TLS_GROUP_ID_brainpoolP512r1_tls13}, {NID_id_tc26_gost_3410_2012_256_paramSetA, OSSL_TLS_GROUP_ID_gc256A}, {NID_id_tc26_gost_3410_2012_256_paramSetB, OSSL_TLS_GROUP_ID_gc256B}, {NID_id_tc26_gost_3410_2012_256_paramSetC, OSSL_TLS_GROUP_ID_gc256C}, {NID_id_tc26_gost_3410_2012_256_paramSetD, OSSL_TLS_GROUP_ID_gc256D}, {NID_id_tc26_gost_3410_2012_512_paramSetA, OSSL_TLS_GROUP_ID_gc512A}, {NID_id_tc26_gost_3410_2012_512_paramSetB, OSSL_TLS_GROUP_ID_gc512B}, {NID_id_tc26_gost_3410_2012_512_paramSetC, OSSL_TLS_GROUP_ID_gc512C}, {NID_ffdhe2048, OSSL_TLS_GROUP_ID_ffdhe2048}, {NID_ffdhe3072, OSSL_TLS_GROUP_ID_ffdhe3072}, {NID_ffdhe4096, OSSL_TLS_GROUP_ID_ffdhe4096}, {NID_ffdhe6144, OSSL_TLS_GROUP_ID_ffdhe6144}, {NID_ffdhe8192, OSSL_TLS_GROUP_ID_ffdhe8192} }; static const unsigned char ecformats_default[] = { TLSEXT_ECPOINTFORMAT_uncompressed, TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime, TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2 }; / The default curves / static const uint16_t supported_groups_default[] = { OSSL_TLS_GROUP_ID_x25519, / X25519 (29) / OSSL_TLS_GROUP_ID_secp256r1, / secp256r1 (23) / OSSL_TLS_GROUP_ID_x448, / X448 (30) / OSSL_TLS_GROUP_ID_secp521r1, / secp521r1 (25) / OSSL_TLS_GROUP_ID_secp384r1, / secp384r1 (24) / OSSL_TLS_GROUP_ID_gc256A, / GC256A (34) / OSSL_TLS_GROUP_ID_gc256B, / GC256B (35) / OSSL_TLS_GROUP_ID_gc256C, / GC256C (36) / OSSL_TLS_GROUP_ID_gc256D, / GC256D (37) / OSSL_TLS_GROUP_ID_gc512A, / GC512A (38) / OSSL_TLS_GROUP_ID_gc512B, / GC512B (39) / OSSL_TLS_GROUP_ID_gc512C, / GC512C (40) / OSSL_TLS_GROUP_ID_ffdhe2048, / ffdhe2048 (0x100) / OSSL_TLS_GROUP_ID_ffdhe3072, / ffdhe3072 (0x101) / OSSL_TLS_GROUP_ID_ffdhe4096, / ffdhe4096 (0x102) / OSSL_TLS_GROUP_ID_ffdhe6144, / ffdhe6144 (0x103) / OSSL_TLS_GROUP_ID_ffdhe8192, / ffdhe8192 (0x104) / }; static const uint16_t suiteb_curves[] = { OSSL_TLS_GROUP_ID_secp256r1, OSSL_TLS_GROUP_ID_secp384r1, }; struct provider_ctx_data_st { SSL_CTX ctx; OSSL_PROVIDER provider; }; #define TLS_GROUP_LIST_MALLOC_BLOCK_SIZE 10 static OSSL_CALLBACK add_provider_groups; static int add_provider_groups(const OSSL_PARAM params[], void data) { struct provider_ctx_data_st pgd = data; SSL_CTX ctx = pgd->ctx; OSSL_PROVIDER provider = pgd->provider; const OSSL_PARAM p; TLS_GROUP_INFO ginf = NULL; EVP_KEYMGMT keymgmt; unsigned int gid; unsigned int is_kem = 0; int ret = 0; if (ctx->group_list_max_len == ctx->group_list_len) { TLS_GROUP_INFO tmp = NULL; if (ctx->group_list_max_len == 0) tmp = OPENSSL_malloc(sizeof(TLS_GROUP_INFO) TLS_GROUP_LIST_MALLOC_BLOCK_SIZE); else tmp = OPENSSL_realloc(ctx->group_list, (ctx->group_list_max_len + TLS_GROUP_LIST_MALLOC_BLOCK_SIZE) * sizeof(TLS_GROUP_INFO)); if (tmp == NULL) return 0; ctx->group_list = tmp; memset(tmp + ctx->group_list_max_len, 0, sizeof(TLS_GROUP_INFO) * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE); ctx->group_list_max_len += TLS_GROUP_LIST_MALLOC_BLOCK_SIZE; } ginf = &ctx->group_list[ctx->group_list_len]; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_NAME); if (p == NULL \|\| p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->tlsname = OPENSSL_strdup(p->data); if (ginf->tlsname == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL); if (p == NULL \|\| p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->realname = OPENSSL_strdup(p->data); if (ginf->realname == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_ID); if (p == NULL \|\| !OSSL_PARAM_get_uint(p, &gid) \|\| gid > UINT16_MAX) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->group_id = (uint16_t)gid; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_ALG); if (p == NULL \|\| p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->algorithm = OPENSSL_strdup(p->data); if (ginf->algorithm == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS); if (p == NULL \|\| !OSSL_PARAM_get_uint(p, &ginf->secbits)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_IS_KEM); if (p != NULL && (!OSSL_PARAM_get_uint(p, &is_kem) \|\| is_kem > 1)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->is_kem = 1 & is_kem; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MIN_TLS); if (p == NULL \|\| !OSSL_PARAM_get_int(p, &ginf->mintls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MAX_TLS); if (p == NULL \|\| !OSSL_PARAM_get_int(p, &ginf->maxtls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS); if (p == NULL \|\| !OSSL_PARAM_get_int(p, &ginf->mindtls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS); if (p == NULL \|\| !OSSL_PARAM_get_int(p, &ginf->maxdtls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } /* * Now check that the algorithm is actually usable for our property query * string. Regardless of the result we still return success because we have * successfully processed this group, even though we may decide not to use * it. / ret = 1; ERR_set_mark(); keymgmt = EVP_KEYMGMT_fetch(ctx->libctx, ginf->algorithm, ctx->propq); if (keymgmt != NULL) { / * We have successfully fetched the algorithm - however if the provider * doesn't match this one then we ignore it. * * Note: We're cheating a little here. Technically if the same algorithm * is available from more than one provider then it is undefined which * implementation you will get back. Theoretically this could be * different every time...we assume here that you'll always get the * same one back if you repeat the exact same fetch. Is this a reasonable * assumption to make (in which case perhaps we should document this * behaviour)? / if (EVP_KEYMGMT_get0_provider(keymgmt) == provider) { / We have a match - so we will use this group / ctx->group_list_len++; ginf = NULL; } EVP_KEYMGMT_free(keymgmt); } ERR_pop_to_mark(); err: if (ginf != NULL) { OPENSSL_free(ginf->tlsname); OPENSSL_free(ginf->realname); OPENSSL_free(ginf->algorithm); ginf->algorithm = ginf->tlsname = ginf->realname = NULL; } return ret; } static int discover_provider_groups(OSSL_PROVIDER provider, void vctx) { struct provider_ctx_data_st pgd; pgd.ctx = vctx; pgd.provider = provider; return OSSL_PROVIDER_get_capabilities(provider, "TLS-GROUP", add_provider_groups, &pgd); } int ssl_load_groups(SSL_CTX ctx) { size_t i, j, num_deflt_grps = 0; uint16_t tmp_supp_groups[OSSL_NELEM(supported_groups_default)]; if (!OSSL_PROVIDER_do_all(ctx->libctx, discover_provider_groups, ctx)) return 0; for (i = 0; i < OSSL_NELEM(supported_groups_default); i++) { for (j = 0; j < ctx->group_list_len; j++) { if (ctx->group_list[j].group_id == supported_groups_default[i]) { tmp_supp_groups[num_deflt_grps++] = ctx->group_list[j].group_id; break; } } } if (num_deflt_grps == 0) return 1; ctx->ext.supported_groups_default = OPENSSL_malloc(sizeof(uint16_t) * num_deflt_grps); if (ctx->ext.supported_groups_default == NULL) return 0; memcpy(ctx->ext.supported_groups_default, tmp_supp_groups, num_deflt_grps * sizeof(tmp_supp_groups[0])); ctx->ext.supported_groups_default_len = num_deflt_grps; return 1; } #define TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE 10 static OSSL_CALLBACK add_provider_sigalgs; static int add_provider_sigalgs(const OSSL_PARAM params[], void data) { struct provider_ctx_data_st pgd = data; SSL_CTX ctx = pgd->ctx; OSSL_PROVIDER provider = pgd->provider; const OSSL_PARAM p; TLS_SIGALG_INFO sinf = NULL; EVP_KEYMGMT keymgmt; const char keytype; unsigned int code_point = 0; int ret = 0; if (ctx->sigalg_list_max_len == ctx->sigalg_list_len) { TLS_SIGALG_INFO tmp = NULL; if (ctx->sigalg_list_max_len == 0) tmp = OPENSSL_malloc(sizeof(TLS_SIGALG_INFO) TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE); else tmp = OPENSSL_realloc(ctx->sigalg_list, (ctx->sigalg_list_max_len + TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE) * sizeof(TLS_SIGALG_INFO)); if (tmp == NULL) return 0; ctx->sigalg_list = tmp; memset(tmp + ctx->sigalg_list_max_len, 0, sizeof(TLS_SIGALG_INFO) * TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE); ctx->sigalg_list_max_len += TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE; } sinf = &ctx->sigalg_list[ctx->sigalg_list_len]; /* First, mandatory parameters / p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_NAME); if (p == NULL \|\| p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } OPENSSL_free(sinf->sigalg_name); sinf->sigalg_name = OPENSSL_strdup(p->data); if (sinf->sigalg_name == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME); if (p == NULL \|\| p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } OPENSSL_free(sinf->name); sinf->name = OPENSSL_strdup(p->data); if (sinf->name == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT); if (p == NULL \|\| !OSSL_PARAM_get_uint(p, &code_point) \|\| code_point > UINT16_MAX) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } sinf->code_point = (uint16_t)code_point; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS); if (p == NULL \|\| !OSSL_PARAM_get_uint(p, &sinf->secbits)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } / Now, optional parameters / p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_OID); if (p == NULL) { sinf->sigalg_oid = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->sigalg_oid); sinf->sigalg_oid = OPENSSL_strdup(p->data); if (sinf->sigalg_oid == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_SIG_NAME); if (p == NULL) { sinf->sig_name = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->sig_name); sinf->sig_name = OPENSSL_strdup(p->data); if (sinf->sig_name == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_SIG_OID); if (p == NULL) { sinf->sig_oid = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->sig_oid); sinf->sig_oid = OPENSSL_strdup(p->data); if (sinf->sig_oid == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_HASH_NAME); if (p == NULL) { sinf->hash_name = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->hash_name); sinf->hash_name = OPENSSL_strdup(p->data); if (sinf->hash_name == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_HASH_OID); if (p == NULL) { sinf->hash_oid = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->hash_oid); sinf->hash_oid = OPENSSL_strdup(p->data); if (sinf->hash_oid == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE); if (p == NULL) { sinf->keytype = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->keytype); sinf->keytype = OPENSSL_strdup(p->data); if (sinf->keytype == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE_OID); if (p == NULL) { sinf->keytype_oid = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->keytype_oid); sinf->keytype_oid = OPENSSL_strdup(p->data); if (sinf->keytype_oid == NULL) goto err; } / The remaining parameters below are mandatory again / p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS); if (p == NULL \|\| !OSSL_PARAM_get_int(p, &sinf->mintls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if ((sinf->mintls != 0) && (sinf->mintls != -1) && ((sinf->mintls < TLS1_3_VERSION))) { / ignore this sigalg as this OpenSSL doesn't know how to handle it / ret = 1; goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS); if (p == NULL \|\| !OSSL_PARAM_get_int(p, &sinf->maxtls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if ((sinf->maxtls != 0) && (sinf->maxtls != -1) && ((sinf->maxtls < sinf->mintls))) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if ((sinf->maxtls != 0) && (sinf->maxtls != -1) && ((sinf->maxtls < TLS1_3_VERSION))) { / ignore this sigalg as this OpenSSL doesn't know how to handle it / ret = 1; goto err; } / * Now check that the algorithm is actually usable for our property query * string. Regardless of the result we still return success because we have * successfully processed this signature, even though we may decide not to * use it. / ret = 1; ERR_set_mark(); keytype = (sinf->keytype != NULL ? sinf->keytype : (sinf->sig_name != NULL ? sinf->sig_name : sinf->sigalg_name)); keymgmt = EVP_KEYMGMT_fetch(ctx->libctx, keytype, ctx->propq); if (keymgmt != NULL) { / * We have successfully fetched the algorithm - however if the provider * doesn't match this one then we ignore it. * * Note: We're cheating a little here. Technically if the same algorithm * is available from more than one provider then it is undefined which * implementation you will get back. Theoretically this could be * different every time...we assume here that you'll always get the * same one back if you repeat the exact same fetch. Is this a reasonable * assumption to make (in which case perhaps we should document this * behaviour)? / if (EVP_KEYMGMT_get0_provider(keymgmt) == provider) { / * We have a match - so we could use this signature; * Check proper object registration first, though. * Don't care about return value as this may have been * done within providers or previous calls to * add_provider_sigalgs. / OBJ_create(sinf->sigalg_oid, sinf->sigalg_name, NULL); / sanity check: Without successful registration don't use alg / if ((OBJ_txt2nid(sinf->sigalg_name) == NID_undef) \|\| (OBJ_nid2obj(OBJ_txt2nid(sinf->sigalg_name)) == NULL)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if (sinf->sig_name != NULL) OBJ_create(sinf->sig_oid, sinf->sig_name, NULL); if (sinf->keytype != NULL) OBJ_create(sinf->keytype_oid, sinf->keytype, NULL); if (sinf->hash_name != NULL) OBJ_create(sinf->hash_oid, sinf->hash_name, NULL); OBJ_add_sigid(OBJ_txt2nid(sinf->sigalg_name), (sinf->hash_name != NULL ? OBJ_txt2nid(sinf->hash_name) : NID_undef), OBJ_txt2nid(keytype)); ctx->sigalg_list_len++; sinf = NULL; } EVP_KEYMGMT_free(keymgmt); } ERR_pop_to_mark(); err: if (sinf != NULL) { OPENSSL_free(sinf->name); sinf->name = NULL; OPENSSL_free(sinf->sigalg_name); sinf->sigalg_name = NULL; OPENSSL_free(sinf->sigalg_oid); sinf->sigalg_oid = NULL; OPENSSL_free(sinf->sig_name); sinf->sig_name = NULL; OPENSSL_free(sinf->sig_oid); sinf->sig_oid = NULL; OPENSSL_free(sinf->hash_name); sinf->hash_name = NULL; OPENSSL_free(sinf->hash_oid); sinf->hash_oid = NULL; OPENSSL_free(sinf->keytype); sinf->keytype = NULL; OPENSSL_free(sinf->keytype_oid); sinf->keytype_oid = NULL; } return ret; } static int discover_provider_sigalgs(OSSL_PROVIDER provider, void vctx) { struct provider_ctx_data_st pgd; pgd.ctx = vctx; pgd.provider = provider; OSSL_PROVIDER_get_capabilities(provider, "TLS-SIGALG", add_provider_sigalgs, &pgd); / * Always OK, even if provider doesn't support the capability: * Reconsider testing retval when legacy sigalgs are also loaded this way. / return 1; } int ssl_load_sigalgs(SSL_CTX ctx) { size_t i; SSL_CERT_LOOKUP lu; if (!OSSL_PROVIDER_do_all(ctx->libctx, discover_provider_sigalgs, ctx)) return 0; /* now populate ctx->ssl_cert_info / if (ctx->sigalg_list_len > 0) { ctx->ssl_cert_info = OPENSSL_zalloc(sizeof(lu) ctx->sigalg_list_len); if (ctx->ssl_cert_info == NULL) return 0; for(i = 0; i < ctx->sigalg_list_len; i++) { ctx->ssl_cert_info[i].nid = OBJ_txt2nid(ctx->sigalg_list[i].sigalg_name); ctx->ssl_cert_info[i].amask = SSL_aANY; } } /* * For now, leave it at this: legacy sigalgs stay in their own * data structures until "legacy cleanup" occurs. / return 1; } static uint16_t tls1_group_name2id(SSL_CTX ctx, const char name) { size_t i; for (i = 0; i < ctx->group_list_len; i++) { if (strcmp(ctx->group_list[i].tlsname, name) == 0 \|\| strcmp(ctx->group_list[i].realname, name) == 0) return ctx->group_list[i].group_id; } return 0; } const TLS_GROUP_INFO tls1_group_id_lookup(SSL_CTX ctx, uint16_t group_id) { size_t i; for (i = 0; i < ctx->group_list_len; i++) { if (ctx->group_list[i].group_id == group_id) return &ctx->group_list[i]; } return NULL; } const char tls1_group_id2name(SSL_CTX ctx, uint16_t group_id) { const TLS_GROUP_INFO tls_group_info = tls1_group_id_lookup(ctx, group_id); if (tls_group_info == NULL) return NULL; return tls_group_info->tlsname; } int tls1_group_id2nid(uint16_t group_id, int include_unknown) { size_t i; if (group_id == 0) return NID_undef; /* * Return well known Group NIDs - for backwards compatibility. This won't * work for groups we don't know about. / for (i = 0; i < OSSL_NELEM(nid_to_group); i++) { if (nid_to_group[i].group_id == group_id) return nid_to_group[i].nid; } if (!include_unknown) return NID_undef; return TLSEXT_nid_unknown \| (int)group_id; } uint16_t tls1_nid2group_id(int nid) { size_t i; / * Return well known Group ids - for backwards compatibility. This won't * work for groups we don't know about. / for (i = 0; i < OSSL_NELEM(nid_to_group); i++) { if (nid_to_group[i].nid == nid) return nid_to_group[i].group_id; } return 0; } / * Set pgroups to the supported groups list and pgroupslen to * the number of groups supported. / void tls1_get_supported_groups(SSL_CONNECTION s, const uint16_t *pgroups, size_t pgroupslen) { SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); / For Suite B mode only include P-256, P-384 / switch (tls1_suiteb(s)) { case SSL_CERT_FLAG_SUITEB_128_LOS: pgroups = suiteb_curves; pgroupslen = OSSL_NELEM(suiteb_curves); break; case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY: pgroups = suiteb_curves; pgroupslen = 1; break; case SSL_CERT_FLAG_SUITEB_192_LOS: pgroups = suiteb_curves + 1; pgroupslen = 1; break; default: if (s->ext.supportedgroups == NULL) { pgroups = sctx->ext.supported_groups_default; pgroupslen = sctx->ext.supported_groups_default_len; } else { pgroups = s->ext.supportedgroups; pgroupslen = s->ext.supportedgroups_len; } break; } } int tls_valid_group(SSL_CONNECTION s, uint16_t group_id, int minversion, int maxversion, int isec, int okfortls13) { const TLS_GROUP_INFO ginfo = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s), group_id); int ret; int group_minversion, group_maxversion; if (okfortls13 != NULL) okfortls13 = 0; if (ginfo == NULL) return 0; group_minversion = SSL_CONNECTION_IS_DTLS(s) ? ginfo->mindtls : ginfo->mintls; group_maxversion = SSL_CONNECTION_IS_DTLS(s) ? ginfo->maxdtls : ginfo->maxtls; if (group_minversion < 0 \|\| group_maxversion < 0) return 0; if (group_maxversion == 0) ret = 1; else ret = (ssl_version_cmp(s, minversion, group_maxversion) <= 0); if (group_minversion > 0) ret &= (ssl_version_cmp(s, maxversion, group_minversion) >= 0); if (!SSL_CONNECTION_IS_DTLS(s)) { if (ret && okfortls13 != NULL && maxversion == TLS1_3_VERSION) okfortls13 = (group_maxversion == 0) \|\| (group_maxversion >= TLS1_3_VERSION); } ret &= !isec \|\| strcmp(ginfo->algorithm, "EC") == 0 \|\| strcmp(ginfo->algorithm, "X25519") == 0 \|\| strcmp(ginfo->algorithm, "X448") == 0; return ret; } /* See if group is allowed by security callback / int tls_group_allowed(SSL_CONNECTION s, uint16_t group, int op) { const TLS_GROUP_INFO ginfo = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s), group); unsigned char gtmp[2]; if (ginfo == NULL) return 0; gtmp[0] = group >> 8; gtmp[1] = group & 0xff; return ssl_security(s, op, ginfo->secbits, tls1_group_id2nid(ginfo->group_id, 0), (void )gtmp); } /* Return 1 if "id" is in "list" / static int tls1_in_list(uint16_t id, const uint16_t list, size_t listlen) { size_t i; for (i = 0; i < listlen; i++) if (list[i] == id) return 1; return 0; } /- For nmatch >= 0, return the id of the \|nmatch\|th shared group or 0 * if there is no match. * For nmatch == -1, return number of matches * For nmatch == -2, return the id of the group to use for * a tmp key, or 0 if there is no match. / uint16_t tls1_shared_group(SSL_CONNECTION s, int nmatch) { const uint16_t pref, supp; size_t num_pref, num_supp, i; int k; SSL_CTX ctx = SSL_CONNECTION_GET_CTX(s); / Can't do anything on client side / if (s->server == 0) return 0; if (nmatch == -2) { if (tls1_suiteb(s)) { / * For Suite B ciphersuite determines curve: we already know * these are acceptable due to previous checks. / unsigned long cid = s->s3.tmp.new_cipher->id; if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) return OSSL_TLS_GROUP_ID_secp256r1; if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) return OSSL_TLS_GROUP_ID_secp384r1; / Should never happen / return 0; } / If not Suite B just return first preference shared curve / nmatch = 0; } / * If server preference set, our groups are the preference order * otherwise peer decides. / if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) { tls1_get_supported_groups(s, &pref, &num_pref); tls1_get_peer_groups(s, &supp, &num_supp); } else { tls1_get_peer_groups(s, &pref, &num_pref); tls1_get_supported_groups(s, &supp, &num_supp); } for (k = 0, i = 0; i < num_pref; i++) { uint16_t id = pref[i]; const TLS_GROUP_INFO inf; int minversion, maxversion; if (!tls1_in_list(id, supp, num_supp) \|\| !tls_group_allowed(s, id, SSL_SECOP_CURVE_SHARED)) continue; inf = tls1_group_id_lookup(ctx, id); if (!ossl_assert(inf != NULL)) return 0; minversion = SSL_CONNECTION_IS_DTLS(s) ? inf->mindtls : inf->mintls; maxversion = SSL_CONNECTION_IS_DTLS(s) ? inf->maxdtls : inf->maxtls; if (maxversion == -1) continue; if ((minversion != 0 && ssl_version_cmp(s, s->version, minversion) < 0) \|\| (maxversion != 0 && ssl_version_cmp(s, s->version, maxversion) > 0)) continue; if (nmatch == k) return id; k++; } if (nmatch == -1) return k; /* Out of range (nmatch > k). / return 0; } int tls1_set_groups(uint16_t pext, size_t pextlen, int groups, size_t ngroups) { uint16_t glist; size_t i; /* * Bitmap of groups included to detect duplicates: two variables are added * to detect duplicates as some values are more than 32. / unsigned long dup_list = NULL; unsigned long dup_list_egrp = 0; unsigned long dup_list_dhgrp = 0; if (ngroups == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); return 0; } if ((glist = OPENSSL_malloc(ngroups * sizeof(glist))) == NULL) return 0; for (i = 0; i < ngroups; i++) { unsigned long idmask; uint16_t id; id = tls1_nid2group_id(groups[i]); if ((id & 0x00FF) >= (sizeof(unsigned long) 8)) goto err; idmask = 1L << (id & 0x00FF); dup_list = (id < 0x100) ? &dup_list_egrp : &dup_list_dhgrp; if (!id \|\| ((dup_list) & idmask)) goto err; dup_list \|= idmask; glist[i] = id; } OPENSSL_free(pext); pext = glist; pextlen = ngroups; return 1; err: OPENSSL_free(glist); return 0; } # define GROUPLIST_INCREMENT 40 # define GROUP_NAME_BUFFER_LENGTH 64 typedef struct { SSL_CTX ctx; size_t gidcnt; size_t gidmax; uint16_t gid_arr; } gid_cb_st; static int gid_cb(const char elem, int len, void arg) { gid_cb_st garg = arg; size_t i; uint16_t gid = 0; char etmp[GROUP_NAME_BUFFER_LENGTH]; if (elem == NULL) return 0; if (garg->gidcnt == garg->gidmax) { uint16_t tmp = OPENSSL_realloc(garg->gid_arr, garg->gidmax + GROUPLIST_INCREMENT); if (tmp == NULL) return 0; garg->gidmax += GROUPLIST_INCREMENT; garg->gid_arr = tmp; } if (len > (int)(sizeof(etmp) - 1)) return 0; memcpy(etmp, elem, len); etmp[len] = 0; gid = tls1_group_name2id(garg->ctx, etmp); if (gid == 0) { ERR_raise_data(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT, "group '%s' cannot be set", etmp); return 0; } for (i = 0; i < garg->gidcnt; i++) if (garg->gid_arr[i] == gid) return 0; garg->gid_arr[garg->gidcnt++] = gid; return 1; } / Set groups based on a colon separated list / int tls1_set_groups_list(SSL_CTX ctx, uint16_t *pext, size_t pextlen, const char str) { gid_cb_st gcb; uint16_t tmparr; int ret = 0; gcb.gidcnt = 0; gcb.gidmax = GROUPLIST_INCREMENT; gcb.gid_arr = OPENSSL_malloc(gcb.gidmax * sizeof(gcb.gid_arr)); if (gcb.gid_arr == NULL) return 0; gcb.ctx = ctx; if (!CONF_parse_list(str, ':', 1, gid_cb, &gcb)) goto end; if (pext == NULL) { ret = 1; goto end; } / * gid_cb ensurse there are no duplicates so we can just go ahead and set * the result / tmparr = OPENSSL_memdup(gcb.gid_arr, gcb.gidcnt sizeof(tmparr)); if (tmparr == NULL) goto end; OPENSSL_free(pext); pext = tmparr; pextlen = gcb.gidcnt; ret = 1; end: OPENSSL_free(gcb.gid_arr); return ret; } /* Check a group id matches preferences / int tls1_check_group_id(SSL_CONNECTION s, uint16_t group_id, int check_own_groups) { const uint16_t groups; size_t groups_len; if (group_id == 0) return 0; / Check for Suite B compliance / if (tls1_suiteb(s) && s->s3.tmp.new_cipher != NULL) { unsigned long cid = s->s3.tmp.new_cipher->id; if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) { if (group_id != OSSL_TLS_GROUP_ID_secp256r1) return 0; } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) { if (group_id != OSSL_TLS_GROUP_ID_secp384r1) return 0; } else { / Should never happen / return 0; } } if (check_own_groups) { / Check group is one of our preferences / tls1_get_supported_groups(s, &groups, &groups_len); if (!tls1_in_list(group_id, groups, groups_len)) return 0; } if (!tls_group_allowed(s, group_id, SSL_SECOP_CURVE_CHECK)) return 0; / For clients, nothing more to check / if (!s->server) return 1; / Check group is one of peers preferences / tls1_get_peer_groups(s, &groups, &groups_len); / * RFC 4492 does not require the supported elliptic curves extension * so if it is not sent we can just choose any curve. * It is invalid to send an empty list in the supported groups * extension, so groups_len == 0 always means no extension. / if (groups_len == 0) return 1; return tls1_in_list(group_id, groups, groups_len); } void tls1_get_formatlist(SSL_CONNECTION s, const unsigned char *pformats, size_t num_formats) { /* * If we have a custom point format list use it otherwise use default / if (s->ext.ecpointformats) { pformats = s->ext.ecpointformats; num_formats = s->ext.ecpointformats_len; } else { pformats = ecformats_default; /* For Suite B we don't support char2 fields / if (tls1_suiteb(s)) num_formats = sizeof(ecformats_default) - 1; else num_formats = sizeof(ecformats_default); } } / Check a key is compatible with compression extension / static int tls1_check_pkey_comp(SSL_CONNECTION s, EVP_PKEY pkey) { unsigned char comp_id; size_t i; int point_conv; / If not an EC key nothing to check / if (!EVP_PKEY_is_a(pkey, "EC")) return 1; / Get required compression id / point_conv = EVP_PKEY_get_ec_point_conv_form(pkey); if (point_conv == 0) return 0; if (point_conv == POINT_CONVERSION_UNCOMPRESSED) { comp_id = TLSEXT_ECPOINTFORMAT_uncompressed; } else if (SSL_CONNECTION_IS_TLS13(s)) { / * ec_point_formats extension is not used in TLSv1.3 so we ignore * this check. / return 1; } else { int field_type = EVP_PKEY_get_field_type(pkey); if (field_type == NID_X9_62_prime_field) comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime; else if (field_type == NID_X9_62_characteristic_two_field) comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2; else return 0; } / * If point formats extension present check it, otherwise everything is * supported (see RFC4492). / if (s->ext.peer_ecpointformats == NULL) return 1; for (i = 0; i < s->ext.peer_ecpointformats_len; i++) { if (s->ext.peer_ecpointformats[i] == comp_id) return 1; } return 0; } / Return group id of a key / static uint16_t tls1_get_group_id(EVP_PKEY pkey) { int curve_nid = ssl_get_EC_curve_nid(pkey); if (curve_nid == NID_undef) return 0; return tls1_nid2group_id(curve_nid); } /* * Check cert parameters compatible with extensions: currently just checks EC * certificates have compatible curves and compression. / static int tls1_check_cert_param(SSL_CONNECTION s, X509 x, int check_ee_md) { uint16_t group_id; EVP_PKEY pkey; pkey = X509_get0_pubkey(x); if (pkey == NULL) return 0; /* If not EC nothing to do / if (!EVP_PKEY_is_a(pkey, "EC")) return 1; / Check compression / if (!tls1_check_pkey_comp(s, pkey)) return 0; group_id = tls1_get_group_id(pkey); / * For a server we allow the certificate to not be in our list of supported * groups. / if (!tls1_check_group_id(s, group_id, !s->server)) return 0; / * Special case for suite B. We MUST sign using SHA256+P-256 or * SHA384+P-384. / if (check_ee_md && tls1_suiteb(s)) { int check_md; size_t i; / Check to see we have necessary signing algorithm / if (group_id == OSSL_TLS_GROUP_ID_secp256r1) check_md = NID_ecdsa_with_SHA256; else if (group_id == OSSL_TLS_GROUP_ID_secp384r1) check_md = NID_ecdsa_with_SHA384; else return 0; / Should never happen / for (i = 0; i < s->shared_sigalgslen; i++) { if (check_md == s->shared_sigalgs[i]->sigandhash) return 1; } return 0; } return 1; } / * tls1_check_ec_tmp_key - Check EC temporary key compatibility * @s: SSL connection * @cid: Cipher ID we're considering using * * Checks that the kECDHE cipher suite we're considering using * is compatible with the client extensions. * * Returns 0 when the cipher can't be used or 1 when it can. / int tls1_check_ec_tmp_key(SSL_CONNECTION s, unsigned long cid) { /* If not Suite B just need a shared group / if (!tls1_suiteb(s)) return tls1_shared_group(s, 0) != 0; / * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other * curves permitted. / if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) return tls1_check_group_id(s, OSSL_TLS_GROUP_ID_secp256r1, 1); if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) return tls1_check_group_id(s, OSSL_TLS_GROUP_ID_secp384r1, 1); return 0; } / Default sigalg schemes / static const uint16_t tls12_sigalgs[] = { TLSEXT_SIGALG_ecdsa_secp256r1_sha256, TLSEXT_SIGALG_ecdsa_secp384r1_sha384, TLSEXT_SIGALG_ecdsa_secp521r1_sha512, TLSEXT_SIGALG_ed25519, TLSEXT_SIGALG_ed448, TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, TLSEXT_SIGALG_rsa_pss_pss_sha256, TLSEXT_SIGALG_rsa_pss_pss_sha384, TLSEXT_SIGALG_rsa_pss_pss_sha512, TLSEXT_SIGALG_rsa_pss_rsae_sha256, TLSEXT_SIGALG_rsa_pss_rsae_sha384, TLSEXT_SIGALG_rsa_pss_rsae_sha512, TLSEXT_SIGALG_rsa_pkcs1_sha256, TLSEXT_SIGALG_rsa_pkcs1_sha384, TLSEXT_SIGALG_rsa_pkcs1_sha512, TLSEXT_SIGALG_ecdsa_sha224, TLSEXT_SIGALG_ecdsa_sha1, TLSEXT_SIGALG_rsa_pkcs1_sha224, TLSEXT_SIGALG_rsa_pkcs1_sha1, TLSEXT_SIGALG_dsa_sha224, TLSEXT_SIGALG_dsa_sha1, TLSEXT_SIGALG_dsa_sha256, TLSEXT_SIGALG_dsa_sha384, TLSEXT_SIGALG_dsa_sha512, #ifndef OPENSSL_NO_GOST TLSEXT_SIGALG_gostr34102012_256_intrinsic, TLSEXT_SIGALG_gostr34102012_512_intrinsic, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, TLSEXT_SIGALG_gostr34102001_gostr3411, #endif }; static const uint16_t suiteb_sigalgs[] = { TLSEXT_SIGALG_ecdsa_secp256r1_sha256, TLSEXT_SIGALG_ecdsa_secp384r1_sha384 }; static const SIGALG_LOOKUP sigalg_lookup_tbl[] = { {"ecdsa_secp256r1_sha256", TLSEXT_SIGALG_ecdsa_secp256r1_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA256, NID_X9_62_prime256v1, 1}, {"ecdsa_secp384r1_sha384", TLSEXT_SIGALG_ecdsa_secp384r1_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA384, NID_secp384r1, 1}, {"ecdsa_secp521r1_sha512", TLSEXT_SIGALG_ecdsa_secp521r1_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA512, NID_secp521r1, 1}, {"ed25519", TLSEXT_SIGALG_ed25519, NID_undef, -1, EVP_PKEY_ED25519, SSL_PKEY_ED25519, NID_undef, NID_undef, 1}, {"ed448", TLSEXT_SIGALG_ed448, NID_undef, -1, EVP_PKEY_ED448, SSL_PKEY_ED448, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_ecdsa_sha224, NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA224, NID_undef, 1}, {NULL, TLSEXT_SIGALG_ecdsa_sha1, NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA1, NID_undef, 1}, {"ecdsa_brainpoolP256r1_sha256", TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA256, NID_brainpoolP256r1, 1}, {"ecdsa_brainpoolP384r1_sha384", TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA384, NID_brainpoolP384r1, 1}, {"ecdsa_brainpoolP512r1_sha512", TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA512, NID_brainpoolP512r1, 1}, {"rsa_pss_rsae_sha256", TLSEXT_SIGALG_rsa_pss_rsae_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA, NID_undef, NID_undef, 1}, {"rsa_pss_rsae_sha384", TLSEXT_SIGALG_rsa_pss_rsae_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA, NID_undef, NID_undef, 1}, {"rsa_pss_rsae_sha512", TLSEXT_SIGALG_rsa_pss_rsae_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA, NID_undef, NID_undef, 1}, {"rsa_pss_pss_sha256", TLSEXT_SIGALG_rsa_pss_pss_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN, NID_undef, NID_undef, 1}, {"rsa_pss_pss_sha384", TLSEXT_SIGALG_rsa_pss_pss_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN, NID_undef, NID_undef, 1}, {"rsa_pss_pss_sha512", TLSEXT_SIGALG_rsa_pss_pss_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN, NID_undef, NID_undef, 1}, {"rsa_pkcs1_sha256", TLSEXT_SIGALG_rsa_pkcs1_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha256WithRSAEncryption, NID_undef, 1}, {"rsa_pkcs1_sha384", TLSEXT_SIGALG_rsa_pkcs1_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha384WithRSAEncryption, NID_undef, 1}, {"rsa_pkcs1_sha512", TLSEXT_SIGALG_rsa_pkcs1_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha512WithRSAEncryption, NID_undef, 1}, {"rsa_pkcs1_sha224", TLSEXT_SIGALG_rsa_pkcs1_sha224, NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha224WithRSAEncryption, NID_undef, 1}, {"rsa_pkcs1_sha1", TLSEXT_SIGALG_rsa_pkcs1_sha1, NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha1WithRSAEncryption, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_dsa_with_SHA256, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha224, NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha1, NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_dsaWithSHA1, NID_undef, 1}, #ifndef OPENSSL_NO_GOST {NULL, TLSEXT_SIGALG_gostr34102012_256_intrinsic, NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX, NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_gostr34102012_512_intrinsic, NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX, NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX, NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX, NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_gostr34102001_gostr3411, NID_id_GostR3411_94, SSL_MD_GOST94_IDX, NID_id_GostR3410_2001, SSL_PKEY_GOST01, NID_undef, NID_undef, 1} #endif }; / Legacy sigalgs for TLS < 1.2 RSA TLS signatures / static const SIGALG_LOOKUP legacy_rsa_sigalg = { "rsa_pkcs1_md5_sha1", 0, NID_md5_sha1, SSL_MD_MD5_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_undef, NID_undef, 1 }; / * Default signature algorithm values used if signature algorithms not present. * From RFC5246. Note: order must match certificate index order. / static const uint16_t tls_default_sigalg[] = { TLSEXT_SIGALG_rsa_pkcs1_sha1, / SSL_PKEY_RSA / 0, / SSL_PKEY_RSA_PSS_SIGN / TLSEXT_SIGALG_dsa_sha1, / SSL_PKEY_DSA_SIGN / TLSEXT_SIGALG_ecdsa_sha1, / SSL_PKEY_ECC / TLSEXT_SIGALG_gostr34102001_gostr3411, / SSL_PKEY_GOST01 / TLSEXT_SIGALG_gostr34102012_256_intrinsic, / SSL_PKEY_GOST12_256 / TLSEXT_SIGALG_gostr34102012_512_intrinsic, / SSL_PKEY_GOST12_512 / 0, / SSL_PKEY_ED25519 / 0, / SSL_PKEY_ED448 / }; int ssl_setup_sigalgs(SSL_CTX ctx) { size_t i, cache_idx, sigalgs_len; const SIGALG_LOOKUP lu; SIGALG_LOOKUP cache = NULL; uint16_t tls12_sigalgs_list = NULL; EVP_PKEY tmpkey = EVP_PKEY_new(); int ret = 0; if (ctx == NULL) goto err; sigalgs_len = OSSL_NELEM(sigalg_lookup_tbl) + ctx->sigalg_list_len; cache = OPENSSL_malloc(sizeof(const SIGALG_LOOKUP) * sigalgs_len); if (cache == NULL \|\| tmpkey == NULL) goto err; tls12_sigalgs_list = OPENSSL_malloc(sizeof(uint16_t) * sigalgs_len); if (tls12_sigalgs_list == NULL) goto err; ERR_set_mark(); /* First fill cache and tls12_sigalgs list from legacy algorithm list / for (i = 0, lu = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl); lu++, i++) { EVP_PKEY_CTX pctx; cache[i] = lu; tls12_sigalgs_list[i] = tls12_sigalgs[i]; / * Check hash is available. * This test is not perfect. A provider could have support * for a signature scheme, but not a particular hash. However the hash * could be available from some other loaded provider. In that case it * could be that the signature is available, and the hash is available * independently - but not as a combination. We ignore this for now. / if (lu->hash != NID_undef && ctx->ssl_digest_methods[lu->hash_idx] == NULL) { cache[i].enabled = 0; continue; } if (!EVP_PKEY_set_type(tmpkey, lu->sig)) { cache[i].enabled = 0; continue; } pctx = EVP_PKEY_CTX_new_from_pkey(ctx->libctx, tmpkey, ctx->propq); / If unable to create pctx we assume the sig algorithm is unavailable / if (pctx == NULL) cache[i].enabled = 0; EVP_PKEY_CTX_free(pctx); } / Now complete cache and tls12_sigalgs list with provider sig information / cache_idx = OSSL_NELEM(sigalg_lookup_tbl); for (i = 0; i < ctx->sigalg_list_len; i++) { TLS_SIGALG_INFO si = ctx->sigalg_list[i]; cache[cache_idx].name = si.name; cache[cache_idx].sigalg = si.code_point; tls12_sigalgs_list[cache_idx] = si.code_point; cache[cache_idx].hash = si.hash_name?OBJ_txt2nid(si.hash_name):NID_undef; cache[cache_idx].hash_idx = ssl_get_md_idx(cache[cache_idx].hash); cache[cache_idx].sig = OBJ_txt2nid(si.sigalg_name); cache[cache_idx].sig_idx = i + SSL_PKEY_NUM; cache[cache_idx].sigandhash = OBJ_txt2nid(si.sigalg_name); cache[cache_idx].curve = NID_undef; / all provided sigalgs are enabled by load / cache[cache_idx].enabled = 1; cache_idx++; } ERR_pop_to_mark(); ctx->sigalg_lookup_cache = cache; ctx->tls12_sigalgs = tls12_sigalgs_list; ctx->tls12_sigalgs_len = sigalgs_len; cache = NULL; tls12_sigalgs_list = NULL; ret = 1; err: OPENSSL_free(cache); OPENSSL_free(tls12_sigalgs_list); EVP_PKEY_free(tmpkey); return ret; } / Lookup TLS signature algorithm / static const SIGALG_LOOKUP tls1_lookup_sigalg(const SSL_CONNECTION s, uint16_t sigalg) { size_t i; const SIGALG_LOOKUP lu; for (i = 0, lu = SSL_CONNECTION_GET_CTX(s)->sigalg_lookup_cache; i < SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs_len; lu++, i++) { if (lu->sigalg == sigalg) { if (!lu->enabled) return NULL; return lu; } } return NULL; } /* Lookup hash: return 0 if invalid or not enabled / int tls1_lookup_md(SSL_CTX ctx, const SIGALG_LOOKUP lu, const EVP_MD pmd) { const EVP_MD md; if (lu == NULL) return 0; /* lu->hash == NID_undef means no associated digest / if (lu->hash == NID_undef) { md = NULL; } else { md = ssl_md(ctx, lu->hash_idx); if (md == NULL) return 0; } if (pmd) pmd = md; return 1; } /* * Check if key is large enough to generate RSA-PSS signature. * * The key must greater than or equal to 2 * hash length + 2. * SHA512 has a hash length of 64 bytes, which is incompatible * with a 128 byte (1024 bit) key. / #define RSA_PSS_MINIMUM_KEY_SIZE(md) (2 EVP_MD_get_size(md) + 2) static int rsa_pss_check_min_key_size(SSL_CTX ctx, const EVP_PKEY pkey, const SIGALG_LOOKUP lu) { const EVP_MD md; if (pkey == NULL) return 0; if (!tls1_lookup_md(ctx, lu, &md) \|\| md == NULL) return 0; if (EVP_PKEY_get_size(pkey) < RSA_PSS_MINIMUM_KEY_SIZE(md)) return 0; return 1; } /* * Returns a signature algorithm when the peer did not send a list of supported * signature algorithms. The signature algorithm is fixed for the certificate * type. \|idx\| is a certificate type index (SSL_PKEY_). When \|idx\| is -1 the certificate type from \|s\| will be used. * Returns the signature algorithm to use, or NULL on error. / static const SIGALG_LOOKUP tls1_get_legacy_sigalg(const SSL_CONNECTION s, int idx) { if (idx == -1) { if (s->server) { size_t i; / Work out index corresponding to ciphersuite / for (i = 0; i < s->ssl_pkey_num; i++) { const SSL_CERT_LOOKUP clu = ssl_cert_lookup_by_idx(i, SSL_CONNECTION_GET_CTX(s)); if (clu == NULL) continue; if (clu->amask & s->s3.tmp.new_cipher->algorithm_auth) { idx = i; break; } } /* * Some GOST ciphersuites allow more than one signature algorithms * / if (idx == SSL_PKEY_GOST01 && s->s3.tmp.new_cipher->algorithm_auth != SSL_aGOST01) { int real_idx; for (real_idx = SSL_PKEY_GOST12_512; real_idx >= SSL_PKEY_GOST01; real_idx--) { if (s->cert->pkeys[real_idx].privatekey != NULL) { idx = real_idx; break; } } } / * As both SSL_PKEY_GOST12_512 and SSL_PKEY_GOST12_256 indices can be used * with new (aGOST12-only) ciphersuites, we should find out which one is available really. / else if (idx == SSL_PKEY_GOST12_256) { int real_idx; for (real_idx = SSL_PKEY_GOST12_512; real_idx >= SSL_PKEY_GOST12_256; real_idx--) { if (s->cert->pkeys[real_idx].privatekey != NULL) { idx = real_idx; break; } } } } else { idx = s->cert->key - s->cert->pkeys; } } if (idx < 0 \|\| idx >= (int)OSSL_NELEM(tls_default_sigalg)) return NULL; if (SSL_USE_SIGALGS(s) \|\| idx != SSL_PKEY_RSA) { const SIGALG_LOOKUP lu = tls1_lookup_sigalg(s, tls_default_sigalg[idx]); if (lu == NULL) return NULL; if (!tls1_lookup_md(SSL_CONNECTION_GET_CTX(s), lu, NULL)) return NULL; if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, lu)) return NULL; return lu; } if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, &legacy_rsa_sigalg)) return NULL; return &legacy_rsa_sigalg; } /* Set peer sigalg based key type / int tls1_set_peer_legacy_sigalg(SSL_CONNECTION s, const EVP_PKEY pkey) { size_t idx; const SIGALG_LOOKUP lu; if (ssl_cert_lookup_by_pkey(pkey, &idx, SSL_CONNECTION_GET_CTX(s)) == NULL) return 0; lu = tls1_get_legacy_sigalg(s, idx); if (lu == NULL) return 0; s->s3.tmp.peer_sigalg = lu; return 1; } size_t tls12_get_psigalgs(SSL_CONNECTION s, int sent, const uint16_t psigs) { / * If Suite B mode use Suite B sigalgs only, ignore any other * preferences. / switch (tls1_suiteb(s)) { case SSL_CERT_FLAG_SUITEB_128_LOS: psigs = suiteb_sigalgs; return OSSL_NELEM(suiteb_sigalgs); case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY: psigs = suiteb_sigalgs; return 1; case SSL_CERT_FLAG_SUITEB_192_LOS: psigs = suiteb_sigalgs + 1; return 1; } /* * We use client_sigalgs (if not NULL) if we're a server * and sending a certificate request or if we're a client and * determining which shared algorithm to use. / if ((s->server == sent) && s->cert->client_sigalgs != NULL) { psigs = s->cert->client_sigalgs; return s->cert->client_sigalgslen; } else if (s->cert->conf_sigalgs) { psigs = s->cert->conf_sigalgs; return s->cert->conf_sigalgslen; } else { psigs = SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs; return SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs_len; } } /* * Called by servers only. Checks that we have a sig alg that supports the * specified EC curve. / int tls_check_sigalg_curve(const SSL_CONNECTION s, int curve) { const uint16_t sigs; size_t siglen, i; if (s->cert->conf_sigalgs) { sigs = s->cert->conf_sigalgs; siglen = s->cert->conf_sigalgslen; } else { sigs = SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs; siglen = SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs_len; } for (i = 0; i < siglen; i++) { const SIGALG_LOOKUP lu = tls1_lookup_sigalg(s, sigs[i]); if (lu == NULL) continue; if (lu->sig == EVP_PKEY_EC && lu->curve != NID_undef && curve == lu->curve) return 1; } return 0; } /* * Return the number of security bits for the signature algorithm, or 0 on * error. / static int sigalg_security_bits(SSL_CTX ctx, const SIGALG_LOOKUP lu) { const EVP_MD md = NULL; int secbits = 0; if (!tls1_lookup_md(ctx, lu, &md)) return 0; if (md != NULL) { int md_type = EVP_MD_get_type(md); /* Security bits: half digest bits / secbits = EVP_MD_get_size(md) 4; /* * SHA1 and MD5 are known to be broken. Reduce security bits so that * they're no longer accepted at security level 1. The real values don't * really matter as long as they're lower than 80, which is our * security level 1. * https://eprint.iacr.org/2020/014 puts a chosen-prefix attack for * SHA1 at 2^63.4 and MD5+SHA1 at 2^67.2 * https://documents.epfl.ch/users/l/le/lenstra/public/papers/lat.pdf * puts a chosen-prefix attack for MD5 at 2^39. / if (md_type == NID_sha1) secbits = 64; else if (md_type == NID_md5_sha1) secbits = 67; else if (md_type == NID_md5) secbits = 39; } else { / Values from https://tools.ietf.org/html/rfc8032#section-8.5 / if (lu->sigalg == TLSEXT_SIGALG_ed25519) secbits = 128; else if (lu->sigalg == TLSEXT_SIGALG_ed448) secbits = 224; } / * For provider-based sigalgs we have secbits information available * in the (provider-loaded) sigalg_list structure / if ((secbits == 0) && (lu->sig_idx >= SSL_PKEY_NUM) && ((lu->sig_idx - SSL_PKEY_NUM) < (int)ctx->sigalg_list_len)) { secbits = ctx->sigalg_list[lu->sig_idx - SSL_PKEY_NUM].secbits; } return secbits; } / * Check signature algorithm is consistent with sent supported signature * algorithms and if so set relevant digest and signature scheme in * s. / int tls12_check_peer_sigalg(SSL_CONNECTION s, uint16_t sig, EVP_PKEY pkey) { const uint16_t sent_sigs; const EVP_MD md = NULL; char sigalgstr[2]; size_t sent_sigslen, i, cidx; int pkeyid = -1; const SIGALG_LOOKUP lu; int secbits = 0; pkeyid = EVP_PKEY_get_id(pkey); if (SSL_CONNECTION_IS_TLS13(s)) { /* Disallow DSA for TLS 1.3 / if (pkeyid == EVP_PKEY_DSA) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } / Only allow PSS for TLS 1.3 / if (pkeyid == EVP_PKEY_RSA) pkeyid = EVP_PKEY_RSA_PSS; } lu = tls1_lookup_sigalg(s, sig); / if this sigalg is loaded, set so far unknown pkeyid to its sig NID / if ((pkeyid == EVP_PKEY_KEYMGMT) && (lu != NULL)) pkeyid = lu->sig; / Should never happen / if (pkeyid == -1) return -1; / * Check sigalgs is known. Disallow SHA1/SHA224 with TLS 1.3. Check key type * is consistent with signature: RSA keys can be used for RSA-PSS / if (lu == NULL \|\| (SSL_CONNECTION_IS_TLS13(s) && (lu->hash == NID_sha1 \|\| lu->hash == NID_sha224)) \|\| (pkeyid != lu->sig && (lu->sig != EVP_PKEY_RSA_PSS \|\| pkeyid != EVP_PKEY_RSA))) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } / Check the sigalg is consistent with the key OID / if (!ssl_cert_lookup_by_nid( (pkeyid == EVP_PKEY_RSA_PSS) ? EVP_PKEY_get_id(pkey) : pkeyid, &cidx, SSL_CONNECTION_GET_CTX(s)) \|\| lu->sig_idx != (int)cidx) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } if (pkeyid == EVP_PKEY_EC) { / Check point compression is permitted / if (!tls1_check_pkey_comp(s, pkey)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_ILLEGAL_POINT_COMPRESSION); return 0; } / For TLS 1.3 or Suite B check curve matches signature algorithm / if (SSL_CONNECTION_IS_TLS13(s) \|\| tls1_suiteb(s)) { int curve = ssl_get_EC_curve_nid(pkey); if (lu->curve != NID_undef && curve != lu->curve) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE); return 0; } } if (!SSL_CONNECTION_IS_TLS13(s)) { / Check curve matches extensions / if (!tls1_check_group_id(s, tls1_get_group_id(pkey), 1)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE); return 0; } if (tls1_suiteb(s)) { / Check sigalg matches a permissible Suite B value / if (sig != TLSEXT_SIGALG_ecdsa_secp256r1_sha256 && sig != TLSEXT_SIGALG_ecdsa_secp384r1_sha384) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } } } } else if (tls1_suiteb(s)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } / Check signature matches a type we sent / sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs); for (i = 0; i < sent_sigslen; i++, sent_sigs++) { if (sig == sent_sigs) break; } /* Allow fallback to SHA1 if not strict mode / if (i == sent_sigslen && (lu->hash != NID_sha1 \|\| s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } if (!tls1_lookup_md(SSL_CONNECTION_GET_CTX(s), lu, &md)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNKNOWN_DIGEST); return 0; } / * Make sure security callback allows algorithm. For historical * reasons we have to pass the sigalg as a two byte char array. / sigalgstr[0] = (sig >> 8) & 0xff; sigalgstr[1] = sig & 0xff; secbits = sigalg_security_bits(SSL_CONNECTION_GET_CTX(s), lu); if (secbits == 0 \|\| !ssl_security(s, SSL_SECOP_SIGALG_CHECK, secbits, md != NULL ? EVP_MD_get_type(md) : NID_undef, (void )sigalgstr)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } /* Store the sigalg the peer uses / s->s3.tmp.peer_sigalg = lu; return 1; } int SSL_get_peer_signature_type_nid(const SSL s, int pnid) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; if (sc->s3.tmp.peer_sigalg == NULL) return 0; pnid = sc->s3.tmp.peer_sigalg->sig; return 1; } int SSL_get_signature_type_nid(const SSL s, int pnid) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; if (sc->s3.tmp.sigalg == NULL) return 0; pnid = sc->s3.tmp.sigalg->sig; return 1; } / * Set a mask of disabled algorithms: an algorithm is disabled if it isn't * supported, doesn't appear in supported signature algorithms, isn't supported * by the enabled protocol versions or by the security level. * * This function should only be used for checking which ciphers are supported * by the client. * * Call ssl_cipher_disabled() to check that it's enabled or not. / int ssl_set_client_disabled(SSL_CONNECTION s) { s->s3.tmp.mask_a = 0; s->s3.tmp.mask_k = 0; ssl_set_sig_mask(&s->s3.tmp.mask_a, s, SSL_SECOP_SIGALG_MASK); if (ssl_get_min_max_version(s, &s->s3.tmp.min_ver, &s->s3.tmp.max_ver, NULL) != 0) return 0; #ifndef OPENSSL_NO_PSK /* with PSK there must be client callback set / if (!s->psk_client_callback) { s->s3.tmp.mask_a \|= SSL_aPSK; s->s3.tmp.mask_k \|= SSL_PSK; } #endif / OPENSSL_NO_PSK / #ifndef OPENSSL_NO_SRP if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) { s->s3.tmp.mask_a \|= SSL_aSRP; s->s3.tmp.mask_k \|= SSL_kSRP; } #endif return 1; } / * ssl_cipher_disabled - check that a cipher is disabled or not * @s: SSL connection that you want to use the cipher on * @c: cipher to check * @op: Security check that you want to do * @ecdhe: If set to 1 then TLSv1 ECDHE ciphers are also allowed in SSLv3 * * Returns 1 when it's disabled, 0 when enabled. / int ssl_cipher_disabled(const SSL_CONNECTION s, const SSL_CIPHER c, int op, int ecdhe) { int minversion = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls; int maxversion = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls; if (c->algorithm_mkey & s->s3.tmp.mask_k \|\| c->algorithm_auth & s->s3.tmp.mask_a) return 1; if (s->s3.tmp.max_ver == 0) return 1; if (SSL_IS_QUIC_HANDSHAKE(s)) / For QUIC, only allow these ciphersuites. / switch (SSL_CIPHER_get_id(c)) { case TLS1_3_CK_AES_128_GCM_SHA256: case TLS1_3_CK_AES_256_GCM_SHA384: case TLS1_3_CK_CHACHA20_POLY1305_SHA256: break; default: return 1; } / * For historical reasons we will allow ECHDE to be selected by a server * in SSLv3 if we are a client / if (minversion == TLS1_VERSION && ecdhe && (c->algorithm_mkey & (SSL_kECDHE \| SSL_kECDHEPSK)) != 0) minversion = SSL3_VERSION; if (ssl_version_cmp(s, minversion, s->s3.tmp.max_ver) > 0 \|\| ssl_version_cmp(s, maxversion, s->s3.tmp.min_ver) < 0) return 1; return !ssl_security(s, op, c->strength_bits, 0, (void )c); } int tls_use_ticket(SSL_CONNECTION s) { if ((s->options & SSL_OP_NO_TICKET)) return 0; return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL); } int tls1_set_server_sigalgs(SSL_CONNECTION s) { size_t i; /* Clear any shared signature algorithms / OPENSSL_free(s->shared_sigalgs); s->shared_sigalgs = NULL; s->shared_sigalgslen = 0; / Clear certificate validity flags / if (s->s3.tmp.valid_flags) memset(s->s3.tmp.valid_flags, 0, s->ssl_pkey_num sizeof(uint32_t)); else s->s3.tmp.valid_flags = OPENSSL_zalloc(s->ssl_pkey_num * sizeof(uint32_t)); if (s->s3.tmp.valid_flags == NULL) return 0; /* * If peer sent no signature algorithms check to see if we support * the default algorithm for each certificate type / if (s->s3.tmp.peer_cert_sigalgs == NULL && s->s3.tmp.peer_sigalgs == NULL) { const uint16_t sent_sigs; size_t sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs); for (i = 0; i < s->ssl_pkey_num; i++) { const SIGALG_LOOKUP lu = tls1_get_legacy_sigalg(s, i); size_t j; if (lu == NULL) continue; / Check default matches a type we sent / for (j = 0; j < sent_sigslen; j++) { if (lu->sigalg == sent_sigs[j]) { s->s3.tmp.valid_flags[i] = CERT_PKEY_SIGN; break; } } } return 1; } if (!tls1_process_sigalgs(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (s->shared_sigalgs != NULL) return 1; / Fatal error if no shared signature algorithms / SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS); return 0; } /- * Gets the ticket information supplied by the client if any. * * hello: The parsed ClientHello data * ret: (output) on return, if a ticket was decrypted, then this is set to * point to the resulting session. / SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION s, CLIENTHELLO_MSG hello, SSL_SESSION ret) { size_t size; RAW_EXTENSION ticketext; ret = NULL; s->ext.ticket_expected = 0; / * If tickets disabled or not supported by the protocol version * (e.g. TLSv1.3) behave as if no ticket present to permit stateful * resumption. / if (s->version <= SSL3_VERSION \|\| !tls_use_ticket(s)) return SSL_TICKET_NONE; ticketext = &hello->pre_proc_exts[TLSEXT_IDX_session_ticket]; if (!ticketext->present) return SSL_TICKET_NONE; size = PACKET_remaining(&ticketext->data); return tls_decrypt_ticket(s, PACKET_data(&ticketext->data), size, hello->session_id, hello->session_id_len, ret); } /- * tls_decrypt_ticket attempts to decrypt a session ticket. * * If s->tls_session_secret_cb is set and we're not doing TLSv1.3 then we are * expecting a pre-shared key ciphersuite, in which case we have no use for * session tickets and one will never be decrypted, nor will * s->ext.ticket_expected be set to 1. * * Side effects: * Sets s->ext.ticket_expected to 1 if the server will have to issue * a new session ticket to the client because the client indicated support * (and s->tls_session_secret_cb is NULL) but the client either doesn't have * a session ticket or we couldn't use the one it gave us, or if * s->ctx->ext.ticket_key_cb asked to renew the client's ticket. * Otherwise, s->ext.ticket_expected is set to 0. * * etick: points to the body of the session ticket extension. * eticklen: the length of the session tickets extension. * sess_id: points at the session ID. * sesslen: the length of the session ID. * psess: (output) on return, if a ticket was decrypted, then this is set to * point to the resulting session. / SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION s, const unsigned char etick, size_t eticklen, const unsigned char sess_id, size_t sesslen, SSL_SESSION *psess) { SSL_SESSION sess = NULL; unsigned char sdec; const unsigned char p; int slen, ivlen, renew_ticket = 0, declen; SSL_TICKET_STATUS ret = SSL_TICKET_FATAL_ERR_OTHER; size_t mlen; unsigned char tick_hmac[EVP_MAX_MD_SIZE]; SSL_HMAC hctx = NULL; EVP_CIPHER_CTX ctx = NULL; SSL_CTX tctx = s->session_ctx; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (eticklen == 0) { /* * The client will accept a ticket but doesn't currently have * one (TLSv1.2 and below), or treated as a fatal error in TLSv1.3 / ret = SSL_TICKET_EMPTY; goto end; } if (!SSL_CONNECTION_IS_TLS13(s) && s->ext.session_secret_cb) { / * Indicate that the ticket couldn't be decrypted rather than * generating the session from ticket now, trigger * abbreviated handshake based on external mechanism to * calculate the master secret later. / ret = SSL_TICKET_NO_DECRYPT; goto end; } / Need at least keyname + iv / if (eticklen < TLSEXT_KEYNAME_LENGTH + EVP_MAX_IV_LENGTH) { ret = SSL_TICKET_NO_DECRYPT; goto end; } / Initialize session ticket encryption and HMAC contexts / hctx = ssl_hmac_new(tctx); if (hctx == NULL) { ret = SSL_TICKET_FATAL_ERR_MALLOC; goto end; } ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) { ret = SSL_TICKET_FATAL_ERR_MALLOC; goto end; } #ifndef OPENSSL_NO_DEPRECATED_3_0 if (tctx->ext.ticket_key_evp_cb != NULL \|\| tctx->ext.ticket_key_cb != NULL) #else if (tctx->ext.ticket_key_evp_cb != NULL) #endif { unsigned char nctick = (unsigned char )etick; int rv = 0; if (tctx->ext.ticket_key_evp_cb != NULL) rv = tctx->ext.ticket_key_evp_cb(SSL_CONNECTION_GET_SSL(s), nctick, nctick + TLSEXT_KEYNAME_LENGTH, ctx, ssl_hmac_get0_EVP_MAC_CTX(hctx), 0); #ifndef OPENSSL_NO_DEPRECATED_3_0 else if (tctx->ext.ticket_key_cb != NULL) / if 0 is returned, write an empty ticket / rv = tctx->ext.ticket_key_cb(SSL_CONNECTION_GET_SSL(s), nctick, nctick + TLSEXT_KEYNAME_LENGTH, ctx, ssl_hmac_get0_HMAC_CTX(hctx), 0); #endif if (rv < 0) { ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } if (rv == 0) { ret = SSL_TICKET_NO_DECRYPT; goto end; } if (rv == 2) renew_ticket = 1; } else { EVP_CIPHER aes256cbc = NULL; /* Check key name matches / if (memcmp(etick, tctx->ext.tick_key_name, TLSEXT_KEYNAME_LENGTH) != 0) { ret = SSL_TICKET_NO_DECRYPT; goto end; } aes256cbc = EVP_CIPHER_fetch(sctx->libctx, "AES-256-CBC", sctx->propq); if (aes256cbc == NULL \|\| ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key, sizeof(tctx->ext.secure->tick_hmac_key), "SHA256") <= 0 \|\| EVP_DecryptInit_ex(ctx, aes256cbc, NULL, tctx->ext.secure->tick_aes_key, etick + TLSEXT_KEYNAME_LENGTH) <= 0) { EVP_CIPHER_free(aes256cbc); ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } EVP_CIPHER_free(aes256cbc); if (SSL_CONNECTION_IS_TLS13(s)) renew_ticket = 1; } / * Attempt to process session ticket, first conduct sanity and integrity * checks on ticket. / mlen = ssl_hmac_size(hctx); if (mlen == 0) { ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } ivlen = EVP_CIPHER_CTX_get_iv_length(ctx); if (ivlen < 0) { ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } / Sanity check ticket length: must exceed keyname + IV + HMAC / if (eticklen <= TLSEXT_KEYNAME_LENGTH + ivlen + mlen) { ret = SSL_TICKET_NO_DECRYPT; goto end; } eticklen -= mlen; / Check HMAC of encrypted ticket / if (ssl_hmac_update(hctx, etick, eticklen) <= 0 \|\| ssl_hmac_final(hctx, tick_hmac, NULL, sizeof(tick_hmac)) <= 0) { ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) { ret = SSL_TICKET_NO_DECRYPT; goto end; } / Attempt to decrypt session data / / Move p after IV to start of encrypted ticket, update length / p = etick + TLSEXT_KEYNAME_LENGTH + ivlen; eticklen -= TLSEXT_KEYNAME_LENGTH + ivlen; sdec = OPENSSL_malloc(eticklen); if (sdec == NULL \|\| EVP_DecryptUpdate(ctx, sdec, &slen, p, (int)eticklen) <= 0) { OPENSSL_free(sdec); ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) { OPENSSL_free(sdec); ret = SSL_TICKET_NO_DECRYPT; goto end; } slen += declen; p = sdec; sess = d2i_SSL_SESSION_ex(NULL, &p, slen, sctx->libctx, sctx->propq); slen -= p - sdec; OPENSSL_free(sdec); if (sess) { / Some additional consistency checks / if (slen != 0) { SSL_SESSION_free(sess); sess = NULL; ret = SSL_TICKET_NO_DECRYPT; goto end; } / * The session ID, if non-empty, is used by some clients to detect * that the ticket has been accepted. So we copy it to the session * structure. If it is empty set length to zero as required by * standard. / if (sesslen) { memcpy(sess->session_id, sess_id, sesslen); sess->session_id_length = sesslen; } if (renew_ticket) ret = SSL_TICKET_SUCCESS_RENEW; else ret = SSL_TICKET_SUCCESS; goto end; } ERR_clear_error(); / * For session parse failure, indicate that we need to send a new ticket. / ret = SSL_TICKET_NO_DECRYPT; end: EVP_CIPHER_CTX_free(ctx); ssl_hmac_free(hctx); / * If set, the decrypt_ticket_cb() is called unless a fatal error was * detected above. The callback is responsible for checking \|ret\| before it * performs any action / if (s->session_ctx->decrypt_ticket_cb != NULL && (ret == SSL_TICKET_EMPTY \|\| ret == SSL_TICKET_NO_DECRYPT \|\| ret == SSL_TICKET_SUCCESS \|\| ret == SSL_TICKET_SUCCESS_RENEW)) { size_t keyname_len = eticklen; int retcb; if (keyname_len > TLSEXT_KEYNAME_LENGTH) keyname_len = TLSEXT_KEYNAME_LENGTH; retcb = s->session_ctx->decrypt_ticket_cb(SSL_CONNECTION_GET_SSL(s), sess, etick, keyname_len, ret, s->session_ctx->ticket_cb_data); switch (retcb) { case SSL_TICKET_RETURN_ABORT: ret = SSL_TICKET_FATAL_ERR_OTHER; break; case SSL_TICKET_RETURN_IGNORE: ret = SSL_TICKET_NONE; SSL_SESSION_free(sess); sess = NULL; break; case SSL_TICKET_RETURN_IGNORE_RENEW: if (ret != SSL_TICKET_EMPTY && ret != SSL_TICKET_NO_DECRYPT) ret = SSL_TICKET_NO_DECRYPT; / else the value of \|ret\| will already do the right thing / SSL_SESSION_free(sess); sess = NULL; break; case SSL_TICKET_RETURN_USE: case SSL_TICKET_RETURN_USE_RENEW: if (ret != SSL_TICKET_SUCCESS && ret != SSL_TICKET_SUCCESS_RENEW) ret = SSL_TICKET_FATAL_ERR_OTHER; else if (retcb == SSL_TICKET_RETURN_USE) ret = SSL_TICKET_SUCCESS; else ret = SSL_TICKET_SUCCESS_RENEW; break; default: ret = SSL_TICKET_FATAL_ERR_OTHER; } } if (s->ext.session_secret_cb == NULL \|\| SSL_CONNECTION_IS_TLS13(s)) { switch (ret) { case SSL_TICKET_NO_DECRYPT: case SSL_TICKET_SUCCESS_RENEW: case SSL_TICKET_EMPTY: s->ext.ticket_expected = 1; } } psess = sess; return ret; } /* Check to see if a signature algorithm is allowed / static int tls12_sigalg_allowed(const SSL_CONNECTION s, int op, const SIGALG_LOOKUP lu) { unsigned char sigalgstr[2]; int secbits; if (lu == NULL \|\| !lu->enabled) return 0; / DSA is not allowed in TLS 1.3 / if (SSL_CONNECTION_IS_TLS13(s) && lu->sig == EVP_PKEY_DSA) return 0; / * At some point we should fully axe DSA/etc. in ClientHello as per TLS 1.3 * spec / if (!s->server && !SSL_CONNECTION_IS_DTLS(s) && s->s3.tmp.min_ver >= TLS1_3_VERSION && (lu->sig == EVP_PKEY_DSA \|\| lu->hash_idx == SSL_MD_SHA1_IDX \|\| lu->hash_idx == SSL_MD_MD5_IDX \|\| lu->hash_idx == SSL_MD_SHA224_IDX)) return 0; / See if public key algorithm allowed / if (ssl_cert_is_disabled(SSL_CONNECTION_GET_CTX(s), lu->sig_idx)) return 0; if (lu->sig == NID_id_GostR3410_2012_256 \|\| lu->sig == NID_id_GostR3410_2012_512 \|\| lu->sig == NID_id_GostR3410_2001) { / We never allow GOST sig algs on the server with TLSv1.3 / if (s->server && SSL_CONNECTION_IS_TLS13(s)) return 0; if (!s->server && SSL_CONNECTION_GET_SSL(s)->method->version == TLS_ANY_VERSION && s->s3.tmp.max_ver >= TLS1_3_VERSION) { int i, num; STACK_OF(SSL_CIPHER) sk; /* * We're a client that could negotiate TLSv1.3. We only allow GOST * sig algs if we could negotiate TLSv1.2 or below and we have GOST * ciphersuites enabled. / if (s->s3.tmp.min_ver >= TLS1_3_VERSION) return 0; sk = SSL_get_ciphers(SSL_CONNECTION_GET_SSL(s)); num = sk != NULL ? sk_SSL_CIPHER_num(sk) : 0; for (i = 0; i < num; i++) { const SSL_CIPHER c; c = sk_SSL_CIPHER_value(sk, i); /* Skip disabled ciphers / if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) continue; if ((c->algorithm_mkey & (SSL_kGOST \| SSL_kGOST18)) != 0) break; } if (i == num) return 0; } } / Finally see if security callback allows it / secbits = sigalg_security_bits(SSL_CONNECTION_GET_CTX(s), lu); sigalgstr[0] = (lu->sigalg >> 8) & 0xff; sigalgstr[1] = lu->sigalg & 0xff; return ssl_security(s, op, secbits, lu->hash, (void )sigalgstr); } /* * Get a mask of disabled public key algorithms based on supported signature * algorithms. For example if no signature algorithm supports RSA then RSA is * disabled. / void ssl_set_sig_mask(uint32_t pmask_a, SSL_CONNECTION s, int op) { const uint16_t sigalgs; size_t i, sigalgslen; uint32_t disabled_mask = SSL_aRSA \| SSL_aDSS \| SSL_aECDSA; /* * Go through all signature algorithms seeing if we support any * in disabled_mask. / sigalgslen = tls12_get_psigalgs(s, 1, &sigalgs); for (i = 0; i < sigalgslen; i++, sigalgs++) { const SIGALG_LOOKUP lu = tls1_lookup_sigalg(s, sigalgs); const SSL_CERT_LOOKUP clu; if (lu == NULL) continue; clu = ssl_cert_lookup_by_idx(lu->sig_idx, SSL_CONNECTION_GET_CTX(s)); if (clu == NULL) continue; /* If algorithm is disabled see if we can enable it / if ((clu->amask & disabled_mask) != 0 && tls12_sigalg_allowed(s, op, lu)) disabled_mask &= ~clu->amask; } pmask_a \|= disabled_mask; } int tls12_copy_sigalgs(SSL_CONNECTION s, WPACKET pkt, const uint16_t psig, size_t psiglen) { size_t i; int rv = 0; for (i = 0; i < psiglen; i++, psig++) { const SIGALG_LOOKUP lu = tls1_lookup_sigalg(s, psig); if (lu == NULL \|\| !tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, lu)) continue; if (!WPACKET_put_bytes_u16(pkt, psig)) return 0; /* * If TLS 1.3 must have at least one valid TLS 1.3 message * signing algorithm: i.e. neither RSA nor SHA1/SHA224 / if (rv == 0 && (!SSL_CONNECTION_IS_TLS13(s) \|\| (lu->sig != EVP_PKEY_RSA && lu->hash != NID_sha1 && lu->hash != NID_sha224))) rv = 1; } if (rv == 0) ERR_raise(ERR_LIB_SSL, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return rv; } / Given preference and allowed sigalgs set shared sigalgs / static size_t tls12_shared_sigalgs(SSL_CONNECTION s, const SIGALG_LOOKUP *shsig, const uint16_t pref, size_t preflen, const uint16_t allow, size_t allowlen) { const uint16_t ptmp, atmp; size_t i, j, nmatch = 0; for (i = 0, ptmp = pref; i < preflen; i++, ptmp++) { const SIGALG_LOOKUP lu = tls1_lookup_sigalg(s, ptmp); / Skip disabled hashes or signature algorithms / if (lu == NULL \|\| !tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, lu)) continue; for (j = 0, atmp = allow; j < allowlen; j++, atmp++) { if (ptmp == atmp) { nmatch++; if (shsig) shsig++ = lu; break; } } } return nmatch; } /* Set shared signature algorithms for SSL structures / static int tls1_set_shared_sigalgs(SSL_CONNECTION s) { const uint16_t pref, allow, conf; size_t preflen, allowlen, conflen; size_t nmatch; const SIGALG_LOOKUP salgs = NULL; CERT c = s->cert; unsigned int is_suiteb = tls1_suiteb(s); OPENSSL_free(s->shared_sigalgs); s->shared_sigalgs = NULL; s->shared_sigalgslen = 0; /* If client use client signature algorithms if not NULL / if (!s->server && c->client_sigalgs && !is_suiteb) { conf = c->client_sigalgs; conflen = c->client_sigalgslen; } else if (c->conf_sigalgs && !is_suiteb) { conf = c->conf_sigalgs; conflen = c->conf_sigalgslen; } else conflen = tls12_get_psigalgs(s, 0, &conf); if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE \|\| is_suiteb) { pref = conf; preflen = conflen; allow = s->s3.tmp.peer_sigalgs; allowlen = s->s3.tmp.peer_sigalgslen; } else { allow = conf; allowlen = conflen; pref = s->s3.tmp.peer_sigalgs; preflen = s->s3.tmp.peer_sigalgslen; } nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen); if (nmatch) { if ((salgs = OPENSSL_malloc(nmatch sizeof(salgs))) == NULL) return 0; nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen); } else { salgs = NULL; } s->shared_sigalgs = salgs; s->shared_sigalgslen = nmatch; return 1; } int tls1_save_u16(PACKET pkt, uint16_t *pdest, size_t pdestlen) { unsigned int stmp; size_t size, i; uint16_t buf; size = PACKET_remaining(pkt); / Invalid data length / if (size == 0 \|\| (size & 1) != 0) return 0; size >>= 1; if ((buf = OPENSSL_malloc(size sizeof(buf))) == NULL) return 0; for (i = 0; i < size && PACKET_get_net_2(pkt, &stmp); i++) buf[i] = stmp; if (i != size) { OPENSSL_free(buf); return 0; } OPENSSL_free(pdest); pdest = buf; pdestlen = size; return 1; } int tls1_save_sigalgs(SSL_CONNECTION s, PACKET pkt, int cert) { /* Extension ignored for inappropriate versions / if (!SSL_USE_SIGALGS(s)) return 1; / Should never happen / if (s->cert == NULL) return 0; if (cert) return tls1_save_u16(pkt, &s->s3.tmp.peer_cert_sigalgs, &s->s3.tmp.peer_cert_sigalgslen); else return tls1_save_u16(pkt, &s->s3.tmp.peer_sigalgs, &s->s3.tmp.peer_sigalgslen); } / Set preferred digest for each key type / int tls1_process_sigalgs(SSL_CONNECTION s) { size_t i; uint32_t pvalid = s->s3.tmp.valid_flags; if (!tls1_set_shared_sigalgs(s)) return 0; for (i = 0; i < s->ssl_pkey_num; i++) pvalid[i] = 0; for (i = 0; i < s->shared_sigalgslen; i++) { const SIGALG_LOOKUP sigptr = s->shared_sigalgs[i]; int idx = sigptr->sig_idx; /* Ignore PKCS1 based sig algs in TLSv1.3 / if (SSL_CONNECTION_IS_TLS13(s) && sigptr->sig == EVP_PKEY_RSA) continue; / If not disabled indicate we can explicitly sign / if (pvalid[idx] == 0 && !ssl_cert_is_disabled(SSL_CONNECTION_GET_CTX(s), idx)) pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN \| CERT_PKEY_SIGN; } return 1; } int SSL_get_sigalgs(SSL s, int idx, int psign, int phash, int psignhash, unsigned char rsig, unsigned char rhash) { uint16_t psig; size_t numsigalgs; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; psig = sc->s3.tmp.peer_sigalgs; numsigalgs = sc->s3.tmp.peer_sigalgslen; if (psig == NULL \|\| numsigalgs > INT_MAX) return 0; if (idx >= 0) { const SIGALG_LOOKUP lu; if (idx >= (int)numsigalgs) return 0; psig += idx; if (rhash != NULL) rhash = (unsigned char)((psig >> 8) & 0xff); if (rsig != NULL) rsig = (unsigned char)(psig & 0xff); lu = tls1_lookup_sigalg(sc, psig); if (psign != NULL) psign = lu != NULL ? lu->sig : NID_undef; if (phash != NULL) phash = lu != NULL ? lu->hash : NID_undef; if (psignhash != NULL) psignhash = lu != NULL ? lu->sigandhash : NID_undef; } return (int)numsigalgs; } int SSL_get_shared_sigalgs(SSL s, int idx, int psign, int phash, int psignhash, unsigned char rsig, unsigned char rhash) { const SIGALG_LOOKUP shsigalgs; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->shared_sigalgs == NULL \|\| idx < 0 \|\| idx >= (int)sc->shared_sigalgslen \|\| sc->shared_sigalgslen > INT_MAX) return 0; shsigalgs = sc->shared_sigalgs[idx]; if (phash != NULL) phash = shsigalgs->hash; if (psign != NULL) psign = shsigalgs->sig; if (psignhash != NULL) psignhash = shsigalgs->sigandhash; if (rsig != NULL) rsig = (unsigned char)(shsigalgs->sigalg & 0xff); if (rhash != NULL) rhash = (unsigned char)((shsigalgs->sigalg >> 8) & 0xff); return (int)sc->shared_sigalgslen; } / Maximum possible number of unique entries in sigalgs array / #define TLS_MAX_SIGALGCNT (OSSL_NELEM(sigalg_lookup_tbl) 2) typedef struct { size_t sigalgcnt; /* TLSEXT_SIGALG_XXX values / uint16_t sigalgs[TLS_MAX_SIGALGCNT]; } sig_cb_st; static void get_sigorhash(int psig, int phash, const char str) { if (strcmp(str, "RSA") == 0) { psig = EVP_PKEY_RSA; } else if (strcmp(str, "RSA-PSS") == 0 \|\| strcmp(str, "PSS") == 0) { psig = EVP_PKEY_RSA_PSS; } else if (strcmp(str, "DSA") == 0) { psig = EVP_PKEY_DSA; } else if (strcmp(str, "ECDSA") == 0) { psig = EVP_PKEY_EC; } else { phash = OBJ_sn2nid(str); if (phash == NID_undef) phash = OBJ_ln2nid(str); } } / Maximum length of a signature algorithm string component / #define TLS_MAX_SIGSTRING_LEN 40 static int sig_cb(const char elem, int len, void arg) { sig_cb_st sarg = arg; size_t i; const SIGALG_LOOKUP s; char etmp[TLS_MAX_SIGSTRING_LEN], p; int sig_alg = NID_undef, hash_alg = NID_undef; if (elem == NULL) return 0; if (sarg->sigalgcnt == TLS_MAX_SIGALGCNT) return 0; if (len > (int)(sizeof(etmp) - 1)) return 0; memcpy(etmp, elem, len); etmp[len] = 0; p = strchr(etmp, '+'); /* * We only allow SignatureSchemes listed in the sigalg_lookup_tbl; * if there's no '+' in the provided name, look for the new-style combined * name. If not, match both sig+hash to find the needed SIGALG_LOOKUP. * Just sig+hash is not unique since TLS 1.3 adds rsa_pss_pss_* and * rsa_pss_rsae_* that differ only by public key OID; in such cases * we will pick the _rsae_ variant, by virtue of them appearing earlier * in the table. / if (p == NULL) { for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl); i++, s++) { if (s->name != NULL && strcmp(etmp, s->name) == 0) { sarg->sigalgs[sarg->sigalgcnt++] = s->sigalg; break; } } if (i == OSSL_NELEM(sigalg_lookup_tbl)) return 0; } else { p = 0; p++; if (p == 0) return 0; get_sigorhash(&sig_alg, &hash_alg, etmp); get_sigorhash(&sig_alg, &hash_alg, p); if (sig_alg == NID_undef \|\| hash_alg == NID_undef) return 0; for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl); i++, s++) { if (s->hash == hash_alg && s->sig == sig_alg) { sarg->sigalgs[sarg->sigalgcnt++] = s->sigalg; break; } } if (i == OSSL_NELEM(sigalg_lookup_tbl)) return 0; } / Reject duplicates / for (i = 0; i < sarg->sigalgcnt - 1; i++) { if (sarg->sigalgs[i] == sarg->sigalgs[sarg->sigalgcnt - 1]) { sarg->sigalgcnt--; return 0; } } return 1; } / * Set supported signature algorithms based on a colon separated list of the * form sig+hash e.g. RSA+SHA512:DSA+SHA512 / int tls1_set_sigalgs_list(CERT c, const char str, int client) { sig_cb_st sig; sig.sigalgcnt = 0; if (!CONF_parse_list(str, ':', 1, sig_cb, &sig)) return 0; if (c == NULL) return 1; return tls1_set_raw_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client); } int tls1_set_raw_sigalgs(CERT c, const uint16_t psigs, size_t salglen, int client) { uint16_t sigalgs; if ((sigalgs = OPENSSL_malloc(salglen * sizeof(sigalgs))) == NULL) return 0; memcpy(sigalgs, psigs, salglen sizeof(sigalgs)); if (client) { OPENSSL_free(c->client_sigalgs); c->client_sigalgs = sigalgs; c->client_sigalgslen = salglen; } else { OPENSSL_free(c->conf_sigalgs); c->conf_sigalgs = sigalgs; c->conf_sigalgslen = salglen; } return 1; } int tls1_set_sigalgs(CERT c, const int psig_nids, size_t salglen, int client) { uint16_t sigalgs, sptr; size_t i; if (salglen & 1) return 0; if ((sigalgs = OPENSSL_malloc((salglen / 2) sizeof(sigalgs))) == NULL) return 0; for (i = 0, sptr = sigalgs; i < salglen; i += 2) { size_t j; const SIGALG_LOOKUP curr; int md_id = psig_nids++; int sig_id = psig_nids++; for (j = 0, curr = sigalg_lookup_tbl; j < OSSL_NELEM(sigalg_lookup_tbl); j++, curr++) { if (curr->hash == md_id && curr->sig == sig_id) { sptr++ = curr->sigalg; break; } } if (j == OSSL_NELEM(sigalg_lookup_tbl)) goto err; } if (client) { OPENSSL_free(c->client_sigalgs); c->client_sigalgs = sigalgs; c->client_sigalgslen = salglen / 2; } else { OPENSSL_free(c->conf_sigalgs); c->conf_sigalgs = sigalgs; c->conf_sigalgslen = salglen / 2; } return 1; err: OPENSSL_free(sigalgs); return 0; } static int tls1_check_sig_alg(SSL_CONNECTION s, X509 x, int default_nid) { int sig_nid, use_pc_sigalgs = 0; size_t i; const SIGALG_LOOKUP sigalg; size_t sigalgslen; if (default_nid == -1) return 1; sig_nid = X509_get_signature_nid(x); if (default_nid) return sig_nid == default_nid ? 1 : 0; if (SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.peer_cert_sigalgs != NULL) { /* * If we're in TLSv1.3 then we only get here if we're checking the * chain. If the peer has specified peer_cert_sigalgs then we use them * otherwise we default to normal sigalgs. / sigalgslen = s->s3.tmp.peer_cert_sigalgslen; use_pc_sigalgs = 1; } else { sigalgslen = s->shared_sigalgslen; } for (i = 0; i < sigalgslen; i++) { sigalg = use_pc_sigalgs ? tls1_lookup_sigalg(s, s->s3.tmp.peer_cert_sigalgs[i]) : s->shared_sigalgs[i]; if (sigalg != NULL && sig_nid == sigalg->sigandhash) return 1; } return 0; } / Check to see if a certificate issuer name matches list of CA names / static int ssl_check_ca_name(STACK_OF(X509_NAME) names, X509 x) { const X509_NAME nm; int i; nm = X509_get_issuer_name(x); for (i = 0; i < sk_X509_NAME_num(names); i++) { if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i))) return 1; } return 0; } /* * Check certificate chain is consistent with TLS extensions and is usable by * server. This servers two purposes: it allows users to check chains before * passing them to the server and it allows the server to check chains before * attempting to use them. / / Flags which need to be set for a certificate when strict mode not set / #define CERT_PKEY_VALID_FLAGS \ (CERT_PKEY_EE_SIGNATURE\|CERT_PKEY_EE_PARAM) / Strict mode flags / #define CERT_PKEY_STRICT_FLAGS \ (CERT_PKEY_VALID_FLAGS\|CERT_PKEY_CA_SIGNATURE\|CERT_PKEY_CA_PARAM \ \| CERT_PKEY_ISSUER_NAME\|CERT_PKEY_CERT_TYPE) int tls1_check_chain(SSL_CONNECTION s, X509 x, EVP_PKEY pk, STACK_OF(X509) chain, int idx) { int i; int rv = 0; int check_flags = 0, strict_mode; CERT_PKEY cpk = NULL; CERT c = s->cert; uint32_t pvalid; unsigned int suiteb_flags = tls1_suiteb(s); /* * Meaning of idx: * idx == -1 means SSL_check_chain() invocation * idx == -2 means checking client certificate chains * idx >= 0 means checking SSL_PKEY index * * For RPK, where there may be no cert, we ignore -1 / if (idx != -1) { if (idx == -2) { cpk = c->key; idx = (int)(cpk - c->pkeys); } else cpk = c->pkeys + idx; pvalid = s->s3.tmp.valid_flags + idx; x = cpk->x509; pk = cpk->privatekey; chain = cpk->chain; strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT; if (tls12_rpk_and_privkey(s, idx)) { if (EVP_PKEY_is_a(pk, "EC") && !tls1_check_pkey_comp(s, pk)) return 0; pvalid = rv = CERT_PKEY_RPK; return rv; } /* If no cert or key, forget it / if (x == NULL \|\| pk == NULL) goto end; } else { size_t certidx; if (x == NULL \|\| pk == NULL) return 0; if (ssl_cert_lookup_by_pkey(pk, &certidx, SSL_CONNECTION_GET_CTX(s)) == NULL) return 0; idx = certidx; pvalid = s->s3.tmp.valid_flags + idx; if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT) check_flags = CERT_PKEY_STRICT_FLAGS; else check_flags = CERT_PKEY_VALID_FLAGS; strict_mode = 1; } if (suiteb_flags) { int ok; if (check_flags) check_flags \|= CERT_PKEY_SUITEB; ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags); if (ok == X509_V_OK) rv \|= CERT_PKEY_SUITEB; else if (!check_flags) goto end; } / * Check all signature algorithms are consistent with signature * algorithms extension if TLS 1.2 or later and strict mode. / if (TLS1_get_version(SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION && strict_mode) { int default_nid; int rsign = 0; if (s->s3.tmp.peer_cert_sigalgs != NULL \|\| s->s3.tmp.peer_sigalgs != NULL) { default_nid = 0; / If no sigalgs extension use defaults from RFC5246 / } else { switch (idx) { case SSL_PKEY_RSA: rsign = EVP_PKEY_RSA; default_nid = NID_sha1WithRSAEncryption; break; case SSL_PKEY_DSA_SIGN: rsign = EVP_PKEY_DSA; default_nid = NID_dsaWithSHA1; break; case SSL_PKEY_ECC: rsign = EVP_PKEY_EC; default_nid = NID_ecdsa_with_SHA1; break; case SSL_PKEY_GOST01: rsign = NID_id_GostR3410_2001; default_nid = NID_id_GostR3411_94_with_GostR3410_2001; break; case SSL_PKEY_GOST12_256: rsign = NID_id_GostR3410_2012_256; default_nid = NID_id_tc26_signwithdigest_gost3410_2012_256; break; case SSL_PKEY_GOST12_512: rsign = NID_id_GostR3410_2012_512; default_nid = NID_id_tc26_signwithdigest_gost3410_2012_512; break; default: default_nid = -1; break; } } / * If peer sent no signature algorithms extension and we have set * preferred signature algorithms check we support sha1. / if (default_nid > 0 && c->conf_sigalgs) { size_t j; const uint16_t p = c->conf_sigalgs; for (j = 0; j < c->conf_sigalgslen; j++, p++) { const SIGALG_LOOKUP lu = tls1_lookup_sigalg(s, p); if (lu != NULL && lu->hash == NID_sha1 && lu->sig == rsign) break; } if (j == c->conf_sigalgslen) { if (check_flags) goto skip_sigs; else goto end; } } /* Check signature algorithm of each cert in chain / if (SSL_CONNECTION_IS_TLS13(s)) { / * We only get here if the application has called SSL_check_chain(), * so check_flags is always set. / if (find_sig_alg(s, x, pk) != NULL) rv \|= CERT_PKEY_EE_SIGNATURE; } else if (!tls1_check_sig_alg(s, x, default_nid)) { if (!check_flags) goto end; } else rv \|= CERT_PKEY_EE_SIGNATURE; rv \|= CERT_PKEY_CA_SIGNATURE; for (i = 0; i < sk_X509_num(chain); i++) { if (!tls1_check_sig_alg(s, sk_X509_value(chain, i), default_nid)) { if (check_flags) { rv &= ~CERT_PKEY_CA_SIGNATURE; break; } else goto end; } } } / Else not TLS 1.2, so mark EE and CA signing algorithms OK / else if (check_flags) rv \|= CERT_PKEY_EE_SIGNATURE \| CERT_PKEY_CA_SIGNATURE; skip_sigs: / Check cert parameters are consistent / if (tls1_check_cert_param(s, x, 1)) rv \|= CERT_PKEY_EE_PARAM; else if (!check_flags) goto end; if (!s->server) rv \|= CERT_PKEY_CA_PARAM; / In strict mode check rest of chain too / else if (strict_mode) { rv \|= CERT_PKEY_CA_PARAM; for (i = 0; i < sk_X509_num(chain); i++) { X509 ca = sk_X509_value(chain, i); if (!tls1_check_cert_param(s, ca, 0)) { if (check_flags) { rv &= ~CERT_PKEY_CA_PARAM; break; } else goto end; } } } if (!s->server && strict_mode) { STACK_OF(X509_NAME) ca_dn; int check_type = 0; if (EVP_PKEY_is_a(pk, "RSA")) check_type = TLS_CT_RSA_SIGN; else if (EVP_PKEY_is_a(pk, "DSA")) check_type = TLS_CT_DSS_SIGN; else if (EVP_PKEY_is_a(pk, "EC")) check_type = TLS_CT_ECDSA_SIGN; if (check_type) { const uint8_t ctypes = s->s3.tmp.ctype; size_t j; for (j = 0; j < s->s3.tmp.ctype_len; j++, ctypes++) { if (ctypes == check_type) { rv \|= CERT_PKEY_CERT_TYPE; break; } } if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags) goto end; } else { rv \|= CERT_PKEY_CERT_TYPE; } ca_dn = s->s3.tmp.peer_ca_names; if (ca_dn == NULL \|\| sk_X509_NAME_num(ca_dn) == 0 \|\| ssl_check_ca_name(ca_dn, x)) rv \|= CERT_PKEY_ISSUER_NAME; else for (i = 0; i < sk_X509_num(chain); i++) { X509 xtmp = sk_X509_value(chain, i); if (ssl_check_ca_name(ca_dn, xtmp)) { rv \|= CERT_PKEY_ISSUER_NAME; break; } } if (!check_flags && !(rv & CERT_PKEY_ISSUER_NAME)) goto end; } else rv \|= CERT_PKEY_ISSUER_NAME \| CERT_PKEY_CERT_TYPE; if (!check_flags \|\| (rv & check_flags) == check_flags) rv \|= CERT_PKEY_VALID; end: if (TLS1_get_version(SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION) rv \|= pvalid & (CERT_PKEY_EXPLICIT_SIGN \| CERT_PKEY_SIGN); else rv \|= CERT_PKEY_SIGN \| CERT_PKEY_EXPLICIT_SIGN; / * When checking a CERT_PKEY structure all flags are irrelevant if the * chain is invalid. / if (!check_flags) { if (rv & CERT_PKEY_VALID) { pvalid = rv; } else { /* Preserve sign and explicit sign flag, clear rest / pvalid &= CERT_PKEY_EXPLICIT_SIGN \| CERT_PKEY_SIGN; return 0; } } return rv; } /* Set validity of certificates in an SSL structure / void tls1_set_cert_validity(SSL_CONNECTION s) { tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_PSS_SIGN); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DSA_SIGN); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ECC); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST01); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_256); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_512); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ED25519); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ED448); } /* User level utility function to check a chain is suitable / int SSL_check_chain(SSL s, X509 x, EVP_PKEY pk, STACK_OF(X509) chain) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return tls1_check_chain(sc, x, pk, chain, -1); } EVP_PKEY ssl_get_auto_dh(SSL_CONNECTION s) { EVP_PKEY dhp = NULL; BIGNUM p; int dh_secbits = 80, sec_level_bits; EVP_PKEY_CTX pctx = NULL; OSSL_PARAM_BLD tmpl = NULL; OSSL_PARAM params = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (s->cert->dh_tmp_auto != 2) { if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL \| SSL_aPSK)) { if (s->s3.tmp.new_cipher->strength_bits == 256) dh_secbits = 128; else dh_secbits = 80; } else { if (s->s3.tmp.cert == NULL) return NULL; dh_secbits = EVP_PKEY_get_security_bits(s->s3.tmp.cert->privatekey); } } /* Do not pick a prime that is too weak for the current security level / sec_level_bits = ssl_get_security_level_bits(SSL_CONNECTION_GET_SSL(s), NULL, NULL); if (dh_secbits < sec_level_bits) dh_secbits = sec_level_bits; if (dh_secbits >= 192) p = BN_get_rfc3526_prime_8192(NULL); else if (dh_secbits >= 152) p = BN_get_rfc3526_prime_4096(NULL); else if (dh_secbits >= 128) p = BN_get_rfc3526_prime_3072(NULL); else if (dh_secbits >= 112) p = BN_get_rfc3526_prime_2048(NULL); else p = BN_get_rfc2409_prime_1024(NULL); if (p == NULL) goto err; pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, "DH", sctx->propq); if (pctx == NULL \|\| EVP_PKEY_fromdata_init(pctx) != 1) goto err; tmpl = OSSL_PARAM_BLD_new(); if (tmpl == NULL \|\| !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p) \|\| !OSSL_PARAM_BLD_push_uint(tmpl, OSSL_PKEY_PARAM_FFC_G, 2)) goto err; params = OSSL_PARAM_BLD_to_param(tmpl); if (params == NULL \|\| EVP_PKEY_fromdata(pctx, &dhp, EVP_PKEY_KEY_PARAMETERS, params) != 1) goto err; err: OSSL_PARAM_free(params); OSSL_PARAM_BLD_free(tmpl); EVP_PKEY_CTX_free(pctx); BN_free(p); return dhp; } static int ssl_security_cert_key(SSL_CONNECTION s, SSL_CTX ctx, X509 x, int op) { int secbits = -1; EVP_PKEY pkey = X509_get0_pubkey(x); if (pkey) { / * If no parameters this will return -1 and fail using the default * security callback for any non-zero security level. This will * reject keys which omit parameters but this only affects DSA and * omission of parameters is never (?) done in practice. / secbits = EVP_PKEY_get_security_bits(pkey); } if (s != NULL) return ssl_security(s, op, secbits, 0, x); else return ssl_ctx_security(ctx, op, secbits, 0, x); } static int ssl_security_cert_sig(SSL_CONNECTION s, SSL_CTX ctx, X509 x, int op) { /* Lookup signature algorithm digest / int secbits, nid, pknid; / Don't check signature if self signed / if ((X509_get_extension_flags(x) & EXFLAG_SS) != 0) return 1; if (!X509_get_signature_info(x, &nid, &pknid, &secbits, NULL)) secbits = -1; / If digest NID not defined use signature NID / if (nid == NID_undef) nid = pknid; if (s != NULL) return ssl_security(s, op, secbits, nid, x); else return ssl_ctx_security(ctx, op, secbits, nid, x); } int ssl_security_cert(SSL_CONNECTION s, SSL_CTX ctx, X509 x, int vfy, int is_ee) { if (vfy) vfy = SSL_SECOP_PEER; if (is_ee) { if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_EE_KEY \| vfy)) return SSL_R_EE_KEY_TOO_SMALL; } else { if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_CA_KEY \| vfy)) return SSL_R_CA_KEY_TOO_SMALL; } if (!ssl_security_cert_sig(s, ctx, x, SSL_SECOP_CA_MD \| vfy)) return SSL_R_CA_MD_TOO_WEAK; return 1; } /* * Check security of a chain, if \|sk\| includes the end entity certificate then * \|x\| is NULL. If \|vfy\| is 1 then we are verifying a peer chain and not sending * one to the peer. Return values: 1 if ok otherwise error code to use / int ssl_security_cert_chain(SSL_CONNECTION s, STACK_OF(X509) sk, X509 x, int vfy) { int rv, start_idx, i; if (x == NULL) { x = sk_X509_value(sk, 0); if (x == NULL) return ERR_R_INTERNAL_ERROR; start_idx = 1; } else start_idx = 0; rv = ssl_security_cert(s, NULL, x, vfy, 1); if (rv != 1) return rv; for (i = start_idx; i < sk_X509_num(sk); i++) { x = sk_X509_value(sk, i); rv = ssl_security_cert(s, NULL, x, vfy, 0); if (rv != 1) return rv; } return 1; } /* * For TLS 1.2 servers check if we have a certificate which can be used * with the signature algorithm "lu" and return index of certificate. / static int tls12_get_cert_sigalg_idx(const SSL_CONNECTION s, const SIGALG_LOOKUP lu) { int sig_idx = lu->sig_idx; const SSL_CERT_LOOKUP clu = ssl_cert_lookup_by_idx(sig_idx, SSL_CONNECTION_GET_CTX(s)); /* If not recognised or not supported by cipher mask it is not suitable / if (clu == NULL \|\| (clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0 \|\| (clu->nid == EVP_PKEY_RSA_PSS && (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kRSA) != 0)) return -1; / If doing RPK, the CERT_PKEY won't be "valid" / if (tls12_rpk_and_privkey(s, sig_idx)) return s->s3.tmp.valid_flags[sig_idx] & CERT_PKEY_RPK ? sig_idx : -1; return s->s3.tmp.valid_flags[sig_idx] & CERT_PKEY_VALID ? sig_idx : -1; } / * Checks the given cert against signature_algorithm_cert restrictions sent by * the peer (if any) as well as whether the hash from the sigalg is usable with * the key. * Returns true if the cert is usable and false otherwise. / static int check_cert_usable(SSL_CONNECTION s, const SIGALG_LOOKUP sig, X509 x, EVP_PKEY pkey) { const SIGALG_LOOKUP lu; int mdnid, pknid, supported; size_t i; const char mdname = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); /* * If the given EVP_PKEY cannot support signing with this digest, * the answer is simply 'no'. / if (sig->hash != NID_undef) mdname = OBJ_nid2sn(sig->hash); supported = EVP_PKEY_digestsign_supports_digest(pkey, sctx->libctx, mdname, sctx->propq); if (supported <= 0) return 0; / * The TLS 1.3 signature_algorithms_cert extension places restrictions * on the sigalg with which the certificate was signed (by its issuer). / if (s->s3.tmp.peer_cert_sigalgs != NULL) { if (!X509_get_signature_info(x, &mdnid, &pknid, NULL, NULL)) return 0; for (i = 0; i < s->s3.tmp.peer_cert_sigalgslen; i++) { lu = tls1_lookup_sigalg(s, s->s3.tmp.peer_cert_sigalgs[i]); if (lu == NULL) continue; / * This does not differentiate between the * rsa_pss_pss_* and rsa_pss_rsae_* schemes since we do not * have a chain here that lets us look at the key OID in the * signing certificate. / if (mdnid == lu->hash && pknid == lu->sig) return 1; } return 0; } / * Without signat_algorithms_cert, any certificate for which we have * a viable public key is permitted. / return 1; } / * Returns true if \|s\| has a usable certificate configured for use * with signature scheme \|sig\|. * "Usable" includes a check for presence as well as applying * the signature_algorithm_cert restrictions sent by the peer (if any). * Returns false if no usable certificate is found. / static int has_usable_cert(SSL_CONNECTION s, const SIGALG_LOOKUP sig, int idx) { / TLS 1.2 callers can override sig->sig_idx, but not TLS 1.3 callers. / if (idx == -1) idx = sig->sig_idx; if (!ssl_has_cert(s, idx)) return 0; return check_cert_usable(s, sig, s->cert->pkeys[idx].x509, s->cert->pkeys[idx].privatekey); } / * Returns true if the supplied cert \|x\| and key \|pkey\| is usable with the * specified signature scheme \|sig\|, or false otherwise. / static int is_cert_usable(SSL_CONNECTION s, const SIGALG_LOOKUP sig, X509 x, EVP_PKEY pkey) { size_t idx; if (ssl_cert_lookup_by_pkey(pkey, &idx, SSL_CONNECTION_GET_CTX(s)) == NULL) return 0; / Check the key is consistent with the sig alg / if ((int)idx != sig->sig_idx) return 0; return check_cert_usable(s, sig, x, pkey); } / * Find a signature scheme that works with the supplied certificate \|x\| and key * \|pkey\|. \|x\| and \|pkey\| may be NULL in which case we additionally look at our * available certs/keys to find one that works. / static const SIGALG_LOOKUP find_sig_alg(SSL_CONNECTION s, X509 x, EVP_PKEY pkey) { const SIGALG_LOOKUP lu = NULL; size_t i; int curve = -1; EVP_PKEY tmppkey; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); /* Look for a shared sigalgs matching possible certificates / for (i = 0; i < s->shared_sigalgslen; i++) { lu = s->shared_sigalgs[i]; / Skip SHA1, SHA224, DSA and RSA if not PSS / if (lu->hash == NID_sha1 \|\| lu->hash == NID_sha224 \|\| lu->sig == EVP_PKEY_DSA \|\| lu->sig == EVP_PKEY_RSA) continue; / Check that we have a cert, and signature_algorithms_cert / if (!tls1_lookup_md(sctx, lu, NULL)) continue; if ((pkey == NULL && !has_usable_cert(s, lu, -1)) \|\| (pkey != NULL && !is_cert_usable(s, lu, x, pkey))) continue; tmppkey = (pkey != NULL) ? pkey : s->cert->pkeys[lu->sig_idx].privatekey; if (lu->sig == EVP_PKEY_EC) { if (curve == -1) curve = ssl_get_EC_curve_nid(tmppkey); if (lu->curve != NID_undef && curve != lu->curve) continue; } else if (lu->sig == EVP_PKEY_RSA_PSS) { / validate that key is large enough for the signature algorithm / if (!rsa_pss_check_min_key_size(sctx, tmppkey, lu)) continue; } break; } if (i == s->shared_sigalgslen) return NULL; return lu; } / * Choose an appropriate signature algorithm based on available certificates * Sets chosen certificate and signature algorithm. * * For servers if we fail to find a required certificate it is a fatal error, * an appropriate error code is set and a TLS alert is sent. * * For clients fatalerrs is set to 0. If a certificate is not suitable it is not * a fatal error: we will either try another certificate or not present one * to the server. In this case no error is set. / int tls_choose_sigalg(SSL_CONNECTION s, int fatalerrs) { const SIGALG_LOOKUP lu = NULL; int sig_idx = -1; s->s3.tmp.cert = NULL; s->s3.tmp.sigalg = NULL; if (SSL_CONNECTION_IS_TLS13(s)) { lu = find_sig_alg(s, NULL, NULL); if (lu == NULL) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } } else { / If ciphersuite doesn't require a cert nothing to do / if (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aCERT)) return 1; if (!s->server && !ssl_has_cert(s, s->cert->key - s->cert->pkeys)) return 1; if (SSL_USE_SIGALGS(s)) { size_t i; if (s->s3.tmp.peer_sigalgs != NULL) { int curve = -1; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); /* For Suite B need to match signature algorithm to curve / if (tls1_suiteb(s)) curve = ssl_get_EC_curve_nid(s->cert->pkeys[SSL_PKEY_ECC] .privatekey); / * Find highest preference signature algorithm matching * cert type / for (i = 0; i < s->shared_sigalgslen; i++) { lu = s->shared_sigalgs[i]; if (s->server) { if ((sig_idx = tls12_get_cert_sigalg_idx(s, lu)) == -1) continue; } else { int cc_idx = s->cert->key - s->cert->pkeys; sig_idx = lu->sig_idx; if (cc_idx != sig_idx) continue; } / Check that we have a cert, and sig_algs_cert / if (!has_usable_cert(s, lu, sig_idx)) continue; if (lu->sig == EVP_PKEY_RSA_PSS) { / validate that key is large enough for the signature algorithm / EVP_PKEY pkey = s->cert->pkeys[sig_idx].privatekey; if (!rsa_pss_check_min_key_size(sctx, pkey, lu)) continue; } if (curve == -1 \|\| lu->curve == curve) break; } #ifndef OPENSSL_NO_GOST /* * Some Windows-based implementations do not send GOST algorithms indication * in supported_algorithms extension, so when we have GOST-based ciphersuite, * we have to assume GOST support. / if (i == s->shared_sigalgslen && (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aGOST01 \| SSL_aGOST12)) != 0) { if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } else { i = 0; sig_idx = lu->sig_idx; } } #endif if (i == s->shared_sigalgslen) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } } else { / * If we have no sigalg use defaults / const uint16_t sent_sigs; size_t sent_sigslen; if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } /* Check signature matches a type we sent / sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs); for (i = 0; i < sent_sigslen; i++, sent_sigs++) { if (lu->sigalg == sent_sigs && has_usable_cert(s, lu, lu->sig_idx)) break; } if (i == sent_sigslen) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } } } else { if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } } } if (sig_idx == -1) sig_idx = lu->sig_idx; s->s3.tmp.cert = &s->cert->pkeys[sig_idx]; s->cert->key = s->s3.tmp.cert; s->s3.tmp.sigalg = lu; return 1; } int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX ctx, uint8_t mode) { if (mode != TLSEXT_max_fragment_length_DISABLED && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } ctx->ext.max_fragment_len_mode = mode; return 1; } int SSL_set_tlsext_max_fragment_length(SSL ssl, uint8_t mode) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL \|\| (IS_QUIC(ssl) && mode != TLSEXT_max_fragment_length_DISABLED)) return 0; if (mode != TLSEXT_max_fragment_length_DISABLED && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } sc->ext.max_fragment_len_mode = mode; return 1; } uint8_t SSL_SESSION_get_max_fragment_length(const SSL_SESSION session) { return session->ext.max_fragment_len_mode; } /* * Helper functions for HMAC access with legacy support included. / SSL_HMAC ssl_hmac_new(const SSL_CTX ctx) { SSL_HMAC ret = OPENSSL_zalloc(sizeof(ret)); EVP_MAC mac = NULL; if (ret == NULL) return NULL; #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->ext.ticket_key_evp_cb == NULL && ctx->ext.ticket_key_cb != NULL) { if (!ssl_hmac_old_new(ret)) goto err; return ret; } #endif mac = EVP_MAC_fetch(ctx->libctx, "HMAC", ctx->propq); if (mac == NULL \|\| (ret->ctx = EVP_MAC_CTX_new(mac)) == NULL) goto err; EVP_MAC_free(mac); return ret; err: EVP_MAC_CTX_free(ret->ctx); EVP_MAC_free(mac); OPENSSL_free(ret); return NULL; } void ssl_hmac_free(SSL_HMAC ctx) { if (ctx != NULL) { EVP_MAC_CTX_free(ctx->ctx); #ifndef OPENSSL_NO_DEPRECATED_3_0 ssl_hmac_old_free(ctx); #endif OPENSSL_free(ctx); } } EVP_MAC_CTX ssl_hmac_get0_EVP_MAC_CTX(SSL_HMAC ctx) { return ctx->ctx; } int ssl_hmac_init(SSL_HMAC ctx, void key, size_t len, char md) { OSSL_PARAM params[2], p = params; if (ctx->ctx != NULL) { p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, md, 0); p = OSSL_PARAM_construct_end(); if (EVP_MAC_init(ctx->ctx, key, len, params)) return 1; } #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->old_ctx != NULL) return ssl_hmac_old_init(ctx, key, len, md); #endif return 0; } int ssl_hmac_update(SSL_HMAC ctx, const unsigned char data, size_t len) { if (ctx->ctx != NULL) return EVP_MAC_update(ctx->ctx, data, len); #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->old_ctx != NULL) return ssl_hmac_old_update(ctx, data, len); #endif return 0; } int ssl_hmac_final(SSL_HMAC ctx, unsigned char md, size_t len, size_t max_size) { if (ctx->ctx != NULL) return EVP_MAC_final(ctx->ctx, md, len, max_size); #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->old_ctx != NULL) return ssl_hmac_old_final(ctx, md, len); #endif return 0; } size_t ssl_hmac_size(const SSL_HMAC ctx) { if (ctx->ctx != NULL) return EVP_MAC_CTX_get_mac_size(ctx->ctx); #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->old_ctx != NULL) return ssl_hmac_old_size(ctx); #endif return 0; } int ssl_get_EC_curve_nid(const EVP_PKEY pkey) { char gname[OSSL_MAX_NAME_SIZE]; if (EVP_PKEY_get_group_name(pkey, gname, sizeof(gname), NULL) > 0) return OBJ_txt2nid(gname); return NID_undef; } __owur int tls13_set_encoded_pub_key(EVP_PKEY pkey, const unsigned char enckey, size_t enckeylen) { if (EVP_PKEY_is_a(pkey, "DH")) { int bits = EVP_PKEY_get_bits(pkey); if (bits <= 0 \|\| enckeylen != (size_t)bits / 8) /* the encoded key must be padded to the length of the p / return 0; } else if (EVP_PKEY_is_a(pkey, "EC")) { if (enckeylen < 3 / point format and at least 1 byte for x and y */ \|\| enckey[0] != 0x04) return 0; } return EVP_PKEY_set1_encoded_public_key(pkey, enckey, enckeylen); }
./openssl/ssl/ssl_utst.c	/* * Copyright 2014-2016 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "ssl_local.h" #ifndef OPENSSL_NO_UNIT_TEST static const struct openssl_ssl_test_functions ssl_test_functions = { ssl_init_wbio_buffer, }; const struct openssl_ssl_test_functions SSL_test_functions(void) { return &ssl_test_functions; } #endif
./openssl/ssl/ssl_sess.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #if defined(__TANDEM) && defined(_SPT_MODEL_) # include <spthread.h> # include <spt_extensions.h> / timeval / #endif #include <stdio.h> #include <openssl/rand.h> #include <openssl/engine.h> #include "internal/refcount.h" #include "internal/cryptlib.h" #include "ssl_local.h" #include "statem/statem_local.h" static void SSL_SESSION_list_remove(SSL_CTX ctx, SSL_SESSION s); static void SSL_SESSION_list_add(SSL_CTX ctx, SSL_SESSION s); static int remove_session_lock(SSL_CTX ctx, SSL_SESSION c, int lck); DEFINE_STACK_OF(SSL_SESSION) __owur static ossl_inline int sess_timedout(OSSL_TIME t, SSL_SESSION ss) { return ossl_time_compare(t, ss->calc_timeout) > 0; } /* * Returns -1/0/+1 as other XXXcmp-type functions * Takes calculated timeout into consideration / __owur static ossl_inline int timeoutcmp(SSL_SESSION a, SSL_SESSION b) { return ossl_time_compare(a->calc_timeout, b->calc_timeout); } / * Calculates effective timeout * Locking must be done by the caller of this function / void ssl_session_calculate_timeout(SSL_SESSION ss) { ss->calc_timeout = ossl_time_add(ss->time, ss->timeout); } /* * SSL_get_session() and SSL_get1_session() are problematic in TLS1.3 because, * unlike in earlier protocol versions, the session ticket may not have been * sent yet even though a handshake has finished. The session ticket data could * come in sometime later...or even change if multiple session ticket messages * are sent from the server. The preferred way for applications to obtain * a resumable session is to use SSL_CTX_sess_set_new_cb(). / SSL_SESSION SSL_get_session(const SSL ssl) / aka SSL_get0_session; gets 0 objects, just returns a copy of the pointer / { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return NULL; return sc->session; } SSL_SESSION SSL_get1_session(SSL ssl) /* variant of SSL_get_session: caller really gets something / { SSL_SESSION sess; /* * Need to lock this all up rather than just use CRYPTO_add so that * somebody doesn't free ssl->session between when we check it's non-null * and when we up the reference count. / if (!CRYPTO_THREAD_read_lock(ssl->lock)) return NULL; sess = SSL_get_session(ssl); if (sess != NULL) SSL_SESSION_up_ref(sess); CRYPTO_THREAD_unlock(ssl->lock); return sess; } int SSL_SESSION_set_ex_data(SSL_SESSION s, int idx, void arg) { return CRYPTO_set_ex_data(&s->ex_data, idx, arg); } void SSL_SESSION_get_ex_data(const SSL_SESSION s, int idx) { return CRYPTO_get_ex_data(&s->ex_data, idx); } SSL_SESSION SSL_SESSION_new(void) { SSL_SESSION ss; if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL)) return NULL; ss = OPENSSL_zalloc(sizeof(ss)); if (ss == NULL) return NULL; ss->verify_result = 1; /* avoid 0 (= X509_V_OK) just in case / / 5 minute timeout by default / ss->timeout = ossl_seconds2time(60 5 + 4); ss->time = ossl_time_now(); ssl_session_calculate_timeout(ss); if (!CRYPTO_NEW_REF(&ss->references, 1)) { OPENSSL_free(ss); return NULL; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data)) { CRYPTO_FREE_REF(&ss->references); OPENSSL_free(ss); return NULL; } return ss; } SSL_SESSION SSL_SESSION_dup(const SSL_SESSION src) { return ssl_session_dup(src, 1); } /* * Create a new SSL_SESSION and duplicate the contents of \|src\| into it. If * ticket == 0 then no ticket information is duplicated, otherwise it is. / SSL_SESSION ssl_session_dup(const SSL_SESSION src, int ticket) { SSL_SESSION dest; dest = OPENSSL_malloc(sizeof(dest)); if (dest == NULL) return NULL; memcpy(dest, src, sizeof(dest)); /* * Set the various pointers to NULL so that we can call SSL_SESSION_free in * the case of an error whilst halfway through constructing dest / #ifndef OPENSSL_NO_PSK dest->psk_identity_hint = NULL; dest->psk_identity = NULL; #endif dest->ext.hostname = NULL; dest->ext.tick = NULL; dest->ext.alpn_selected = NULL; #ifndef OPENSSL_NO_SRP dest->srp_username = NULL; #endif dest->peer_chain = NULL; dest->peer = NULL; dest->peer_rpk = NULL; dest->ticket_appdata = NULL; memset(&dest->ex_data, 0, sizeof(dest->ex_data)); / As the copy is not in the cache, we remove the associated pointers / dest->prev = NULL; dest->next = NULL; dest->owner = NULL; if (!CRYPTO_NEW_REF(&dest->references, 1)) { OPENSSL_free(dest); return NULL; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, dest, &dest->ex_data)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if (src->peer != NULL) { if (!X509_up_ref(src->peer)) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } dest->peer = src->peer; } if (src->peer_chain != NULL) { dest->peer_chain = X509_chain_up_ref(src->peer_chain); if (dest->peer_chain == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } } if (src->peer_rpk != NULL) { if (!EVP_PKEY_up_ref(src->peer_rpk)) goto err; dest->peer_rpk = src->peer_rpk; } #ifndef OPENSSL_NO_PSK if (src->psk_identity_hint) { dest->psk_identity_hint = OPENSSL_strdup(src->psk_identity_hint); if (dest->psk_identity_hint == NULL) goto err; } if (src->psk_identity) { dest->psk_identity = OPENSSL_strdup(src->psk_identity); if (dest->psk_identity == NULL) goto err; } #endif if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, &dest->ex_data, &src->ex_data)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if (src->ext.hostname) { dest->ext.hostname = OPENSSL_strdup(src->ext.hostname); if (dest->ext.hostname == NULL) goto err; } if (ticket != 0 && src->ext.tick != NULL) { dest->ext.tick = OPENSSL_memdup(src->ext.tick, src->ext.ticklen); if (dest->ext.tick == NULL) goto err; } else { dest->ext.tick_lifetime_hint = 0; dest->ext.ticklen = 0; } if (src->ext.alpn_selected != NULL) { dest->ext.alpn_selected = OPENSSL_memdup(src->ext.alpn_selected, src->ext.alpn_selected_len); if (dest->ext.alpn_selected == NULL) goto err; } #ifndef OPENSSL_NO_SRP if (src->srp_username) { dest->srp_username = OPENSSL_strdup(src->srp_username); if (dest->srp_username == NULL) goto err; } #endif if (src->ticket_appdata != NULL) { dest->ticket_appdata = OPENSSL_memdup(src->ticket_appdata, src->ticket_appdata_len); if (dest->ticket_appdata == NULL) goto err; } return dest; err: SSL_SESSION_free(dest); return NULL; } const unsigned char SSL_SESSION_get_id(const SSL_SESSION s, unsigned int len) { if (len) len = (unsigned int)s->session_id_length; return s->session_id; } const unsigned char SSL_SESSION_get0_id_context(const SSL_SESSION s, unsigned int len) { if (len != NULL) len = (unsigned int)s->sid_ctx_length; return s->sid_ctx; } unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION s) { return s->compress_meth; } /* * SSLv3/TLSv1 has 32 bytes (256 bits) of session ID space. As such, filling * the ID with random junk repeatedly until we have no conflict is going to * complete in one iteration pretty much "most" of the time (btw: * understatement). So, if it takes us 10 iterations and we still can't avoid * a conflict - well that's a reasonable point to call it quits. Either the * RAND code is broken or someone is trying to open roughly very close to * 2^256 SSL sessions to our server. How you might store that many sessions * is perhaps a more interesting question ... / #define MAX_SESS_ID_ATTEMPTS 10 static int def_generate_session_id(SSL ssl, unsigned char id, unsigned int id_len) { unsigned int retry = 0; do { if (RAND_bytes_ex(ssl->ctx->libctx, id, id_len, 0) <= 0) return 0; #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if (retry > 0) { id[0]++; } #endif } while (SSL_has_matching_session_id(ssl, id, id_len) && (++retry < MAX_SESS_ID_ATTEMPTS)) ; if (retry < MAX_SESS_ID_ATTEMPTS) return 1; /* else - woops a session_id match / / * XXX We should also check the external cache -- but the probability of * a collision is negligible, and we could not prevent the concurrent * creation of sessions with identical IDs since we currently don't have * means to atomically check whether a session ID already exists and make * a reservation for it if it does not (this problem applies to the * internal cache as well). / return 0; } int ssl_generate_session_id(SSL_CONNECTION s, SSL_SESSION ss) { unsigned int tmp; GEN_SESSION_CB cb = def_generate_session_id; SSL ssl = SSL_CONNECTION_GET_SSL(s); switch (s->version) { case SSL3_VERSION: case TLS1_VERSION: case TLS1_1_VERSION: case TLS1_2_VERSION: case TLS1_3_VERSION: case DTLS1_BAD_VER: case DTLS1_VERSION: case DTLS1_2_VERSION: ss->session_id_length = SSL3_SSL_SESSION_ID_LENGTH; break; default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNSUPPORTED_SSL_VERSION); return 0; } /- If RFC5077 ticket, use empty session ID (as server). * Note that: * (a) ssl_get_prev_session() does lookahead into the * ClientHello extensions to find the session ticket. * When ssl_get_prev_session() fails, statem_srvr.c calls * ssl_get_new_session() in tls_process_client_hello(). * At that point, it has not yet parsed the extensions, * however, because of the lookahead, it already knows * whether a ticket is expected or not. * * (b) statem_clnt.c calls ssl_get_new_session() before parsing * ServerHello extensions, and before recording the session * ID received from the server, so this block is a noop. / if (s->ext.ticket_expected) { ss->session_id_length = 0; return 1; } / Choose which callback will set the session ID / if (!CRYPTO_THREAD_read_lock(SSL_CONNECTION_GET_SSL(s)->lock)) return 0; if (!CRYPTO_THREAD_read_lock(s->session_ctx->lock)) { CRYPTO_THREAD_unlock(ssl->lock); SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED); return 0; } if (s->generate_session_id) cb = s->generate_session_id; else if (s->session_ctx->generate_session_id) cb = s->session_ctx->generate_session_id; CRYPTO_THREAD_unlock(s->session_ctx->lock); CRYPTO_THREAD_unlock(ssl->lock); / Choose a session ID / memset(ss->session_id, 0, ss->session_id_length); tmp = (int)ss->session_id_length; if (!cb(ssl, ss->session_id, &tmp)) { / The callback failed / SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SSL_SESSION_ID_CALLBACK_FAILED); return 0; } / * Don't allow the callback to set the session length to zero. nor * set it higher than it was. / if (tmp == 0 \|\| tmp > ss->session_id_length) { / The callback set an illegal length / SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH); return 0; } ss->session_id_length = tmp; / Finally, check for a conflict / if (SSL_has_matching_session_id(ssl, ss->session_id, (unsigned int)ss->session_id_length)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SSL_SESSION_ID_CONFLICT); return 0; } return 1; } int ssl_get_new_session(SSL_CONNECTION s, int session) { /* This gets used by clients and servers. / SSL_SESSION ss = NULL; if ((ss = SSL_SESSION_new()) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); return 0; } /* If the context has a default timeout, use it / if (ossl_time_is_zero(s->session_ctx->session_timeout)) ss->timeout = SSL_CONNECTION_GET_SSL(s)->method->get_timeout(); else ss->timeout = s->session_ctx->session_timeout; ssl_session_calculate_timeout(ss); SSL_SESSION_free(s->session); s->session = NULL; if (session) { if (SSL_CONNECTION_IS_TLS13(s)) { / * We generate the session id while constructing the * NewSessionTicket in TLSv1.3. / ss->session_id_length = 0; } else if (!ssl_generate_session_id(s, ss)) { / SSLfatal() already called / SSL_SESSION_free(ss); return 0; } } else { ss->session_id_length = 0; } if (s->sid_ctx_length > sizeof(ss->sid_ctx)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); SSL_SESSION_free(ss); return 0; } memcpy(ss->sid_ctx, s->sid_ctx, s->sid_ctx_length); ss->sid_ctx_length = s->sid_ctx_length; s->session = ss; ss->ssl_version = s->version; ss->verify_result = X509_V_OK; / If client supports extended master secret set it in session / if (s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) ss->flags \|= SSL_SESS_FLAG_EXTMS; return 1; } SSL_SESSION lookup_sess_in_cache(SSL_CONNECTION s, const unsigned char sess_id, size_t sess_id_len) { SSL_SESSION ret = NULL; if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP) == 0) { SSL_SESSION data; data.ssl_version = s->version; if (!ossl_assert(sess_id_len <= SSL_MAX_SSL_SESSION_ID_LENGTH)) return NULL; memcpy(data.session_id, sess_id, sess_id_len); data.session_id_length = sess_id_len; if (!CRYPTO_THREAD_read_lock(s->session_ctx->lock)) return NULL; ret = lh_SSL_SESSION_retrieve(s->session_ctx->sessions, &data); if (ret != NULL) { / don't allow other threads to steal it: / SSL_SESSION_up_ref(ret); } CRYPTO_THREAD_unlock(s->session_ctx->lock); if (ret == NULL) ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_miss); } if (ret == NULL && s->session_ctx->get_session_cb != NULL) { int copy = 1; ret = s->session_ctx->get_session_cb(SSL_CONNECTION_GET_SSL(s), sess_id, sess_id_len, &copy); if (ret != NULL) { ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_cb_hit); / * Increment reference count now if the session callback asks us * to do so (note that if the session structures returned by the * callback are shared between threads, it must handle the * reference count itself [i.e. copy == 0], or things won't be * thread-safe). / if (copy) SSL_SESSION_up_ref(ret); / * Add the externally cached session to the internal cache as * well if and only if we are supposed to. / if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0) { / * Either return value of SSL_CTX_add_session should not * interrupt the session resumption process. The return * value is intentionally ignored. / (void)SSL_CTX_add_session(s->session_ctx, ret); } } } return ret; } /- * ssl_get_prev attempts to find an SSL_SESSION to be used to resume this * connection. It is only called by servers. * * hello: The parsed ClientHello data * * Returns: * -1: fatal error * 0: no session found * 1: a session may have been found. * * Side effects: * - If a session is found then s->session is pointed at it (after freeing an * existing session if need be) and s->verify_result is set from the session. * - Both for new and resumed sessions, s->ext.ticket_expected is set to 1 * if the server should issue a new session ticket (to 0 otherwise). / int ssl_get_prev_session(SSL_CONNECTION s, CLIENTHELLO_MSG hello) { / This is used only by servers. / SSL_SESSION ret = NULL; int fatal = 0; int try_session_cache = 0; SSL_TICKET_STATUS r; if (SSL_CONNECTION_IS_TLS13(s)) { /* * By default we will send a new ticket. This can be overridden in the * ticket processing. / s->ext.ticket_expected = 1; if (!tls_parse_extension(s, TLSEXT_IDX_psk_kex_modes, SSL_EXT_CLIENT_HELLO, hello->pre_proc_exts, NULL, 0) \|\| !tls_parse_extension(s, TLSEXT_IDX_psk, SSL_EXT_CLIENT_HELLO, hello->pre_proc_exts, NULL, 0)) return -1; ret = s->session; } else { / sets s->ext.ticket_expected / r = tls_get_ticket_from_client(s, hello, &ret); switch (r) { case SSL_TICKET_FATAL_ERR_MALLOC: case SSL_TICKET_FATAL_ERR_OTHER: fatal = 1; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; case SSL_TICKET_NONE: case SSL_TICKET_EMPTY: if (hello->session_id_len > 0) { try_session_cache = 1; ret = lookup_sess_in_cache(s, hello->session_id, hello->session_id_len); } break; case SSL_TICKET_NO_DECRYPT: case SSL_TICKET_SUCCESS: case SSL_TICKET_SUCCESS_RENEW: break; } } if (ret == NULL) goto err; / Now ret is non-NULL and we own one of its reference counts. / / Check TLS version consistency / if (ret->ssl_version != s->version) goto err; if (ret->sid_ctx_length != s->sid_ctx_length \|\| memcmp(ret->sid_ctx, s->sid_ctx, ret->sid_ctx_length)) { / * We have the session requested by the client, but we don't want to * use it in this context. / goto err; / treat like cache miss / } if ((s->verify_mode & SSL_VERIFY_PEER) && s->sid_ctx_length == 0) { / * We can't be sure if this session is being used out of context, * which is especially important for SSL_VERIFY_PEER. The application * should have used SSL[_CTX]_set_session_id_context. For this error * case, we generate an error instead of treating the event like a * cache miss (otherwise it would be easy for applications to * effectively disable the session cache by accident without anyone * noticing). / SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED); fatal = 1; goto err; } if (sess_timedout(ossl_time_now(), ret)) { ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_timeout); if (try_session_cache) { / session was from the cache, so remove it / SSL_CTX_remove_session(s->session_ctx, ret); } goto err; } / Check extended master secret extension consistency / if (ret->flags & SSL_SESS_FLAG_EXTMS) { / If old session includes extms, but new does not: abort handshake / if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INCONSISTENT_EXTMS); fatal = 1; goto err; } } else if (s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) { / If new session includes extms, but old does not: do not resume / goto err; } if (!SSL_CONNECTION_IS_TLS13(s)) { / We already did this for TLS1.3 / SSL_SESSION_free(s->session); s->session = ret; } ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_hit); s->verify_result = s->session->verify_result; return 1; err: if (ret != NULL) { SSL_SESSION_free(ret); / In TLSv1.3 s->session was already set to ret, so we NULL it out / if (SSL_CONNECTION_IS_TLS13(s)) s->session = NULL; if (!try_session_cache) { / * The session was from a ticket, so we should issue a ticket for * the new session / s->ext.ticket_expected = 1; } } if (fatal) return -1; return 0; } int SSL_CTX_add_session(SSL_CTX ctx, SSL_SESSION c) { int ret = 0; SSL_SESSION s; /* * add just 1 reference count for the SSL_CTX's session cache even though * it has two ways of access: each session is in a doubly linked list and * an lhash / SSL_SESSION_up_ref(c); / * if session c is in already in cache, we take back the increment later / if (!CRYPTO_THREAD_write_lock(ctx->lock)) { SSL_SESSION_free(c); return 0; } s = lh_SSL_SESSION_insert(ctx->sessions, c); / * s != NULL iff we already had a session with the given PID. In this * case, s == c should hold (then we did not really modify * ctx->sessions), or we're in trouble. / if (s != NULL && s != c) { / We are in trouble ... / SSL_SESSION_list_remove(ctx, s); SSL_SESSION_free(s); / * ... so pretend the other session did not exist in cache (we cannot * handle two SSL_SESSION structures with identical session ID in the * same cache, which could happen e.g. when two threads concurrently * obtain the same session from an external cache) / s = NULL; } else if (s == NULL && lh_SSL_SESSION_retrieve(ctx->sessions, c) == NULL) { / s == NULL can also mean OOM error in lh_SSL_SESSION_insert ... / / * ... so take back the extra reference and also don't add * the session to the SSL_SESSION_list at this time / s = c; } / Adjust last used time, and add back into the cache at the appropriate spot / if (ctx->session_cache_mode & SSL_SESS_CACHE_UPDATE_TIME) { c->time = ossl_time_now(); ssl_session_calculate_timeout(c); } if (s == NULL) { / * new cache entry -- remove old ones if cache has become too large * delete cache entry before add, so we don't remove the one we're adding! / ret = 1; if (SSL_CTX_sess_get_cache_size(ctx) > 0) { while (SSL_CTX_sess_number(ctx) >= SSL_CTX_sess_get_cache_size(ctx)) { if (!remove_session_lock(ctx, ctx->session_cache_tail, 0)) break; else ssl_tsan_counter(ctx, &ctx->stats.sess_cache_full); } } } SSL_SESSION_list_add(ctx, c); if (s != NULL) { / * existing cache entry -- decrement previously incremented reference * count because it already takes into account the cache / SSL_SESSION_free(s); / s == c / ret = 0; } CRYPTO_THREAD_unlock(ctx->lock); return ret; } int SSL_CTX_remove_session(SSL_CTX ctx, SSL_SESSION c) { return remove_session_lock(ctx, c, 1); } static int remove_session_lock(SSL_CTX ctx, SSL_SESSION c, int lck) { SSL_SESSION r; int ret = 0; if ((c != NULL) && (c->session_id_length != 0)) { if (lck) { if (!CRYPTO_THREAD_write_lock(ctx->lock)) return 0; } if ((r = lh_SSL_SESSION_retrieve(ctx->sessions, c)) != NULL) { ret = 1; r = lh_SSL_SESSION_delete(ctx->sessions, r); SSL_SESSION_list_remove(ctx, r); } c->not_resumable = 1; if (lck) CRYPTO_THREAD_unlock(ctx->lock); if (ctx->remove_session_cb != NULL) ctx->remove_session_cb(ctx, c); if (ret) SSL_SESSION_free(r); } return ret; } void SSL_SESSION_free(SSL_SESSION ss) { int i; if (ss == NULL) return; CRYPTO_DOWN_REF(&ss->references, &i); REF_PRINT_COUNT("SSL_SESSION", ss); if (i > 0) return; REF_ASSERT_ISNT(i < 0); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data); OPENSSL_cleanse(ss->master_key, sizeof(ss->master_key)); OPENSSL_cleanse(ss->session_id, sizeof(ss->session_id)); X509_free(ss->peer); EVP_PKEY_free(ss->peer_rpk); OSSL_STACK_OF_X509_free(ss->peer_chain); OPENSSL_free(ss->ext.hostname); OPENSSL_free(ss->ext.tick); #ifndef OPENSSL_NO_PSK OPENSSL_free(ss->psk_identity_hint); OPENSSL_free(ss->psk_identity); #endif #ifndef OPENSSL_NO_SRP OPENSSL_free(ss->srp_username); #endif OPENSSL_free(ss->ext.alpn_selected); OPENSSL_free(ss->ticket_appdata); CRYPTO_FREE_REF(&ss->references); OPENSSL_clear_free(ss, sizeof(ss)); } int SSL_SESSION_up_ref(SSL_SESSION ss) { int i; if (CRYPTO_UP_REF(&ss->references, &i) <= 0) return 0; REF_PRINT_COUNT("SSL_SESSION", ss); REF_ASSERT_ISNT(i < 2); return ((i > 1) ? 1 : 0); } int SSL_set_session(SSL s, SSL_SESSION session) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; ssl_clear_bad_session(sc); if (s->defltmeth != s->method) { if (!SSL_set_ssl_method(s, s->defltmeth)) return 0; } if (session != NULL) { SSL_SESSION_up_ref(session); sc->verify_result = session->verify_result; } SSL_SESSION_free(sc->session); sc->session = session; return 1; } int SSL_SESSION_set1_id(SSL_SESSION s, const unsigned char sid, unsigned int sid_len) { if (sid_len > SSL_MAX_SSL_SESSION_ID_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_TOO_LONG); return 0; } s->session_id_length = sid_len; if (sid != s->session_id) memcpy(s->session_id, sid, sid_len); return 1; } long SSL_SESSION_set_timeout(SSL_SESSION s, long t) { OSSL_TIME new_timeout = ossl_seconds2time(t); if (s == NULL \|\| t < 0) return 0; if (s->owner != NULL) { if (!CRYPTO_THREAD_write_lock(s->owner->lock)) return 0; s->timeout = new_timeout; ssl_session_calculate_timeout(s); SSL_SESSION_list_add(s->owner, s); CRYPTO_THREAD_unlock(s->owner->lock); } else { s->timeout = new_timeout; ssl_session_calculate_timeout(s); } return 1; } long SSL_SESSION_get_timeout(const SSL_SESSION s) { if (s == NULL) return 0; return (long)ossl_time_to_time_t(s->timeout); } long SSL_SESSION_get_time(const SSL_SESSION s) { if (s == NULL) return 0; return (long)ossl_time_to_time_t(s->time); } long SSL_SESSION_set_time(SSL_SESSION s, long t) { OSSL_TIME new_time = ossl_time_from_time_t((time_t)t); if (s == NULL) return 0; if (s->owner != NULL) { if (!CRYPTO_THREAD_write_lock(s->owner->lock)) return 0; s->time = new_time; ssl_session_calculate_timeout(s); SSL_SESSION_list_add(s->owner, s); CRYPTO_THREAD_unlock(s->owner->lock); } else { s->time = new_time; ssl_session_calculate_timeout(s); } return t; } int SSL_SESSION_get_protocol_version(const SSL_SESSION s) { return s->ssl_version; } int SSL_SESSION_set_protocol_version(SSL_SESSION s, int version) { s->ssl_version = version; return 1; } const SSL_CIPHER SSL_SESSION_get0_cipher(const SSL_SESSION s) { return s->cipher; } int SSL_SESSION_set_cipher(SSL_SESSION s, const SSL_CIPHER cipher) { s->cipher = cipher; return 1; } const char SSL_SESSION_get0_hostname(const SSL_SESSION s) { return s->ext.hostname; } int SSL_SESSION_set1_hostname(SSL_SESSION s, const char hostname) { OPENSSL_free(s->ext.hostname); if (hostname == NULL) { s->ext.hostname = NULL; return 1; } s->ext.hostname = OPENSSL_strdup(hostname); return s->ext.hostname != NULL; } int SSL_SESSION_has_ticket(const SSL_SESSION s) { return (s->ext.ticklen > 0) ? 1 : 0; } unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION s) { return s->ext.tick_lifetime_hint; } void SSL_SESSION_get0_ticket(const SSL_SESSION s, const unsigned char tick, size_t len) { len = s->ext.ticklen; if (tick != NULL) tick = s->ext.tick; } uint32_t SSL_SESSION_get_max_early_data(const SSL_SESSION s) { return s->ext.max_early_data; } int SSL_SESSION_set_max_early_data(SSL_SESSION s, uint32_t max_early_data) { s->ext.max_early_data = max_early_data; return 1; } void SSL_SESSION_get0_alpn_selected(const SSL_SESSION s, const unsigned char alpn, size_t len) { alpn = s->ext.alpn_selected; len = s->ext.alpn_selected_len; } int SSL_SESSION_set1_alpn_selected(SSL_SESSION s, const unsigned char alpn, size_t len) { OPENSSL_free(s->ext.alpn_selected); if (alpn == NULL \|\| len == 0) { s->ext.alpn_selected = NULL; s->ext.alpn_selected_len = 0; return 1; } s->ext.alpn_selected = OPENSSL_memdup(alpn, len); if (s->ext.alpn_selected == NULL) { s->ext.alpn_selected_len = 0; return 0; } s->ext.alpn_selected_len = len; return 1; } X509 SSL_SESSION_get0_peer(SSL_SESSION s) { return s->peer; } EVP_PKEY SSL_SESSION_get0_peer_rpk(SSL_SESSION s) { return s->peer_rpk; } int SSL_SESSION_set1_id_context(SSL_SESSION s, const unsigned char sid_ctx, unsigned int sid_ctx_len) { if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG); return 0; } s->sid_ctx_length = sid_ctx_len; if (sid_ctx != s->sid_ctx) memcpy(s->sid_ctx, sid_ctx, sid_ctx_len); return 1; } int SSL_SESSION_is_resumable(const SSL_SESSION s) { / * In the case of EAP-FAST, we can have a pre-shared "ticket" without a * session ID. / return !s->not_resumable && (s->session_id_length > 0 \|\| s->ext.ticklen > 0); } long SSL_CTX_set_timeout(SSL_CTX s, long t) { long l; if (s == NULL) return 0; l = (long)ossl_time2seconds(s->session_timeout); s->session_timeout = ossl_seconds2time(t); return l; } long SSL_CTX_get_timeout(const SSL_CTX s) { if (s == NULL) return 0; return (long)ossl_time2seconds(s->session_timeout); } int SSL_set_session_secret_cb(SSL s, tls_session_secret_cb_fn tls_session_secret_cb, void arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->ext.session_secret_cb = tls_session_secret_cb; sc->ext.session_secret_cb_arg = arg; return 1; } int SSL_set_session_ticket_ext_cb(SSL s, tls_session_ticket_ext_cb_fn cb, void arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->ext.session_ticket_cb = cb; sc->ext.session_ticket_cb_arg = arg; return 1; } int SSL_set_session_ticket_ext(SSL s, void ext_data, int ext_len) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->version >= TLS1_VERSION) { OPENSSL_free(sc->ext.session_ticket); sc->ext.session_ticket = NULL; sc->ext.session_ticket = OPENSSL_malloc(sizeof(TLS_SESSION_TICKET_EXT) + ext_len); if (sc->ext.session_ticket == NULL) return 0; if (ext_data != NULL) { sc->ext.session_ticket->length = ext_len; sc->ext.session_ticket->data = sc->ext.session_ticket + 1; memcpy(sc->ext.session_ticket->data, ext_data, ext_len); } else { sc->ext.session_ticket->length = 0; sc->ext.session_ticket->data = NULL; } return 1; } return 0; } void SSL_CTX_flush_sessions(SSL_CTX s, long t) { STACK_OF(SSL_SESSION) sk; SSL_SESSION current; unsigned long i; const OSSL_TIME timeout = ossl_time_from_time_t(t); if (!CRYPTO_THREAD_write_lock(s->lock)) return; sk = sk_SSL_SESSION_new_null(); i = lh_SSL_SESSION_get_down_load(s->sessions); lh_SSL_SESSION_set_down_load(s->sessions, 0); / * Iterate over the list from the back (oldest), and stop * when a session can no longer be removed. * Add the session to a temporary list to be freed outside * the SSL_CTX lock. * But still do the remove_session_cb() within the lock. / while (s->session_cache_tail != NULL) { current = s->session_cache_tail; if (t == 0 \|\| sess_timedout(timeout, current)) { lh_SSL_SESSION_delete(s->sessions, current); SSL_SESSION_list_remove(s, current); current->not_resumable = 1; if (s->remove_session_cb != NULL) s->remove_session_cb(s, current); / * Throw the session on a stack, it's entirely plausible * that while freeing outside the critical section, the * session could be re-added, so avoid using the next/prev * pointers. If the stack failed to create, or the session * couldn't be put on the stack, just free it here / if (sk == NULL \|\| !sk_SSL_SESSION_push(sk, current)) SSL_SESSION_free(current); } else { break; } } lh_SSL_SESSION_set_down_load(s->sessions, i); CRYPTO_THREAD_unlock(s->lock); sk_SSL_SESSION_pop_free(sk, SSL_SESSION_free); } int ssl_clear_bad_session(SSL_CONNECTION s) { if ((s->session != NULL) && !(s->shutdown & SSL_SENT_SHUTDOWN) && !(SSL_in_init(SSL_CONNECTION_GET_SSL(s)) \|\| SSL_in_before(SSL_CONNECTION_GET_SSL(s)))) { SSL_CTX_remove_session(s->session_ctx, s->session); return 1; } else return 0; } /* locked by SSL_CTX in the calling function / static void SSL_SESSION_list_remove(SSL_CTX ctx, SSL_SESSION s) { if ((s->next == NULL) \|\| (s->prev == NULL)) return; if (s->next == (SSL_SESSION )&(ctx->session_cache_tail)) { /* last element in list / if (s->prev == (SSL_SESSION )&(ctx->session_cache_head)) { /* only one element in list / ctx->session_cache_head = NULL; ctx->session_cache_tail = NULL; } else { ctx->session_cache_tail = s->prev; s->prev->next = (SSL_SESSION )&(ctx->session_cache_tail); } } else { if (s->prev == (SSL_SESSION )&(ctx->session_cache_head)) { / first element in list / ctx->session_cache_head = s->next; s->next->prev = (SSL_SESSION )&(ctx->session_cache_head); } else { /* middle of list / s->next->prev = s->prev; s->prev->next = s->next; } } s->prev = s->next = NULL; s->owner = NULL; } static void SSL_SESSION_list_add(SSL_CTX ctx, SSL_SESSION s) { SSL_SESSION next; if ((s->next != NULL) && (s->prev != NULL)) SSL_SESSION_list_remove(ctx, s); if (ctx->session_cache_head == NULL) { ctx->session_cache_head = s; ctx->session_cache_tail = s; s->prev = (SSL_SESSION )&(ctx->session_cache_head); s->next = (SSL_SESSION )&(ctx->session_cache_tail); } else { if (timeoutcmp(s, ctx->session_cache_head) >= 0) { /* * if we timeout after (or the same time as) the first * session, put us first - usual case / s->next = ctx->session_cache_head; s->next->prev = s; s->prev = (SSL_SESSION )&(ctx->session_cache_head); ctx->session_cache_head = s; } else if (timeoutcmp(s, ctx->session_cache_tail) < 0) { /* if we timeout before the last session, put us last / s->prev = ctx->session_cache_tail; s->prev->next = s; s->next = (SSL_SESSION )&(ctx->session_cache_tail); ctx->session_cache_tail = s; } else { /* * we timeout somewhere in-between - if there is only * one session in the cache it will be caught above / next = ctx->session_cache_head->next; while (next != (SSL_SESSION)&(ctx->session_cache_tail)) { if (timeoutcmp(s, next) >= 0) { s->next = next; s->prev = next->prev; next->prev->next = s; next->prev = s; break; } next = next->next; } } } s->owner = ctx; } void SSL_CTX_sess_set_new_cb(SSL_CTX ctx, int (cb) (struct ssl_st ssl, SSL_SESSION sess)) { ctx->new_session_cb = cb; } int (SSL_CTX_sess_get_new_cb(SSL_CTX ctx)) (SSL ssl, SSL_SESSION sess) { return ctx->new_session_cb; } void SSL_CTX_sess_set_remove_cb(SSL_CTX ctx, void (cb) (SSL_CTX ctx, SSL_SESSION sess)) { ctx->remove_session_cb = cb; } void (SSL_CTX_sess_get_remove_cb(SSL_CTX ctx)) (SSL_CTX ctx, SSL_SESSION sess) { return ctx->remove_session_cb; } void SSL_CTX_sess_set_get_cb(SSL_CTX ctx, SSL_SESSION (cb) (SSL ssl, const unsigned char data, int len, int copy)) { ctx->get_session_cb = cb; } SSL_SESSION (SSL_CTX_sess_get_get_cb(SSL_CTX ctx)) (SSL ssl, const unsigned char data, int len, int copy) { return ctx->get_session_cb; } void SSL_CTX_set_info_callback(SSL_CTX ctx, void (cb) (const SSL ssl, int type, int val)) { ctx->info_callback = cb; } void (SSL_CTX_get_info_callback(SSL_CTX ctx)) (const SSL ssl, int type, int val) { return ctx->info_callback; } void SSL_CTX_set_client_cert_cb(SSL_CTX ctx, int (cb) (SSL ssl, X509 x509, EVP_PKEY pkey)) { ctx->client_cert_cb = cb; } int (SSL_CTX_get_client_cert_cb(SSL_CTX ctx)) (SSL ssl, X509 x509, EVP_PKEY pkey) { return ctx->client_cert_cb; } void SSL_CTX_set_cookie_generate_cb(SSL_CTX ctx, int (cb) (SSL ssl, unsigned char cookie, unsigned int cookie_len)) { ctx->app_gen_cookie_cb = cb; } void SSL_CTX_set_cookie_verify_cb(SSL_CTX ctx, int (cb) (SSL ssl, const unsigned char cookie, unsigned int cookie_len)) { ctx->app_verify_cookie_cb = cb; } int SSL_SESSION_set1_ticket_appdata(SSL_SESSION ss, const void data, size_t len) { OPENSSL_free(ss->ticket_appdata); ss->ticket_appdata_len = 0; if (data == NULL \|\| len == 0) { ss->ticket_appdata = NULL; return 1; } ss->ticket_appdata = OPENSSL_memdup(data, len); if (ss->ticket_appdata != NULL) { ss->ticket_appdata_len = len; return 1; } return 0; } int SSL_SESSION_get0_ticket_appdata(SSL_SESSION ss, void *data, size_t len) { data = ss->ticket_appdata; len = ss->ticket_appdata_len; return 1; } void SSL_CTX_set_stateless_cookie_generate_cb( SSL_CTX ctx, int (cb) (SSL ssl, unsigned char cookie, size_t cookie_len)) { ctx->gen_stateless_cookie_cb = cb; } void SSL_CTX_set_stateless_cookie_verify_cb( SSL_CTX ctx, int (cb) (SSL ssl, const unsigned char *cookie, size_t cookie_len)) { ctx->verify_stateless_cookie_cb = cb; } IMPLEMENT_PEM_rw(SSL_SESSION, SSL_SESSION, PEM_STRING_SSL_SESSION, SSL_SESSION)
./openssl/ssl/ssl_local.h	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #ifndef OSSL_SSL_LOCAL_H # define OSSL_SSL_LOCAL_H # include "internal/e_os.h" / struct timeval for DTLS / # include <stdlib.h> # include <time.h> # include <errno.h> # include "internal/common.h" / for HAS_PREFIX / # include <openssl/buffer.h> # include <openssl/bio.h> # include <openssl/comp.h> # include <openssl/dsa.h> # include <openssl/err.h> # include <openssl/ssl.h> # include <openssl/async.h> # include <openssl/symhacks.h> # include <openssl/ct.h> # include "internal/recordmethod.h" # include "internal/statem.h" # include "internal/packet.h" # include "internal/dane.h" # include "internal/refcount.h" # include "internal/tsan_assist.h" # include "internal/bio.h" # include "internal/ktls.h" # include "internal/time.h" # include "internal/ssl.h" # include "record/record.h" # ifdef OPENSSL_BUILD_SHLIBSSL # undef OPENSSL_EXTERN # define OPENSSL_EXTERN OPENSSL_EXPORT # endif # define TLS_MAX_VERSION_INTERNAL TLS1_3_VERSION # define DTLS_MAX_VERSION_INTERNAL DTLS1_2_VERSION / * DTLS version numbers are strange because they're inverted. Except for * DTLS1_BAD_VER, which should be considered "lower" than the rest. / # define dtls_ver_ordinal(v1) (((v1) == DTLS1_BAD_VER) ? 0xff00 : (v1)) # define DTLS_VERSION_GT(v1, v2) (dtls_ver_ordinal(v1) < dtls_ver_ordinal(v2)) # define DTLS_VERSION_GE(v1, v2) (dtls_ver_ordinal(v1) <= dtls_ver_ordinal(v2)) # define DTLS_VERSION_LT(v1, v2) (dtls_ver_ordinal(v1) > dtls_ver_ordinal(v2)) # define DTLS_VERSION_LE(v1, v2) (dtls_ver_ordinal(v1) >= dtls_ver_ordinal(v2)) # define SSL_AD_NO_ALERT -1 / * Define the Bitmasks for SSL_CIPHER.algorithms. * This bits are used packed as dense as possible. If new methods/ciphers * etc will be added, the bits a likely to change, so this information * is for internal library use only, even though SSL_CIPHER.algorithms * can be publicly accessed. * Use the according functions for cipher management instead. * * The bit mask handling in the selection and sorting scheme in * ssl_create_cipher_list() has only limited capabilities, reflecting * that the different entities within are mutually exclusive: * ONLY ONE BIT PER MASK CAN BE SET AT A TIME. / / Bits for algorithm_mkey (key exchange algorithm) / / RSA key exchange / # define SSL_kRSA 0x00000001U / tmp DH key no DH cert / # define SSL_kDHE 0x00000002U / synonym / # define SSL_kEDH SSL_kDHE / ephemeral ECDH / # define SSL_kECDHE 0x00000004U / synonym / # define SSL_kEECDH SSL_kECDHE / PSK / # define SSL_kPSK 0x00000008U / GOST key exchange / # define SSL_kGOST 0x00000010U / SRP / # define SSL_kSRP 0x00000020U # define SSL_kRSAPSK 0x00000040U # define SSL_kECDHEPSK 0x00000080U # define SSL_kDHEPSK 0x00000100U / GOST KDF key exchange, draft-smyshlyaev-tls12-gost-suites / # define SSL_kGOST18 0x00000200U / all PSK / # define SSL_PSK (SSL_kPSK \| SSL_kRSAPSK \| SSL_kECDHEPSK \| SSL_kDHEPSK) / Any appropriate key exchange algorithm (for TLS 1.3 ciphersuites) / # define SSL_kANY 0x00000000U / Bits for algorithm_auth (server authentication) / / RSA auth / # define SSL_aRSA 0x00000001U / DSS auth / # define SSL_aDSS 0x00000002U / no auth (i.e. use ADH or AECDH) / # define SSL_aNULL 0x00000004U / ECDSA auth/ # define SSL_aECDSA 0x00000008U / PSK auth / # define SSL_aPSK 0x00000010U / GOST R 34.10-2001 signature auth / # define SSL_aGOST01 0x00000020U / SRP auth / # define SSL_aSRP 0x00000040U / GOST R 34.10-2012 signature auth / # define SSL_aGOST12 0x00000080U / Any appropriate signature auth (for TLS 1.3 ciphersuites) / # define SSL_aANY 0x00000000U / All bits requiring a certificate / #define SSL_aCERT \ (SSL_aRSA \| SSL_aDSS \| SSL_aECDSA \| SSL_aGOST01 \| SSL_aGOST12) / Bits for algorithm_enc (symmetric encryption) / # define SSL_DES 0x00000001U # define SSL_3DES 0x00000002U # define SSL_RC4 0x00000004U # define SSL_RC2 0x00000008U # define SSL_IDEA 0x00000010U # define SSL_eNULL 0x00000020U # define SSL_AES128 0x00000040U # define SSL_AES256 0x00000080U # define SSL_CAMELLIA128 0x00000100U # define SSL_CAMELLIA256 0x00000200U # define SSL_eGOST2814789CNT 0x00000400U # define SSL_SEED 0x00000800U # define SSL_AES128GCM 0x00001000U # define SSL_AES256GCM 0x00002000U # define SSL_AES128CCM 0x00004000U # define SSL_AES256CCM 0x00008000U # define SSL_AES128CCM8 0x00010000U # define SSL_AES256CCM8 0x00020000U # define SSL_eGOST2814789CNT12 0x00040000U # define SSL_CHACHA20POLY1305 0x00080000U # define SSL_ARIA128GCM 0x00100000U # define SSL_ARIA256GCM 0x00200000U # define SSL_MAGMA 0x00400000U # define SSL_KUZNYECHIK 0x00800000U # define SSL_AESGCM (SSL_AES128GCM \| SSL_AES256GCM) # define SSL_AESCCM (SSL_AES128CCM \| SSL_AES256CCM \| SSL_AES128CCM8 \| SSL_AES256CCM8) # define SSL_AES (SSL_AES128\|SSL_AES256\|SSL_AESGCM\|SSL_AESCCM) # define SSL_CAMELLIA (SSL_CAMELLIA128\|SSL_CAMELLIA256) # define SSL_CHACHA20 (SSL_CHACHA20POLY1305) # define SSL_ARIAGCM (SSL_ARIA128GCM \| SSL_ARIA256GCM) # define SSL_ARIA (SSL_ARIAGCM) # define SSL_CBC (SSL_DES \| SSL_3DES \| SSL_RC2 \| SSL_IDEA \ \| SSL_AES128 \| SSL_AES256 \| SSL_CAMELLIA128 \ \| SSL_CAMELLIA256 \| SSL_SEED) / Bits for algorithm_mac (symmetric authentication) / # define SSL_MD5 0x00000001U # define SSL_SHA1 0x00000002U # define SSL_GOST94 0x00000004U # define SSL_GOST89MAC 0x00000008U # define SSL_SHA256 0x00000010U # define SSL_SHA384 0x00000020U / Not a real MAC, just an indication it is part of cipher / # define SSL_AEAD 0x00000040U # define SSL_GOST12_256 0x00000080U # define SSL_GOST89MAC12 0x00000100U # define SSL_GOST12_512 0x00000200U # define SSL_MAGMAOMAC 0x00000400U # define SSL_KUZNYECHIKOMAC 0x00000800U / * When adding new digest in the ssl_ciph.c and increment SSL_MD_NUM_IDX make * sure to update this constant too / # define SSL_MD_MD5_IDX 0 # define SSL_MD_SHA1_IDX 1 # define SSL_MD_GOST94_IDX 2 # define SSL_MD_GOST89MAC_IDX 3 # define SSL_MD_SHA256_IDX 4 # define SSL_MD_SHA384_IDX 5 # define SSL_MD_GOST12_256_IDX 6 # define SSL_MD_GOST89MAC12_IDX 7 # define SSL_MD_GOST12_512_IDX 8 # define SSL_MD_MD5_SHA1_IDX 9 # define SSL_MD_SHA224_IDX 10 # define SSL_MD_SHA512_IDX 11 # define SSL_MD_MAGMAOMAC_IDX 12 # define SSL_MD_KUZNYECHIKOMAC_IDX 13 # define SSL_MAX_DIGEST 14 #define SSL_MD_NUM_IDX SSL_MAX_DIGEST / Bits for algorithm2 (handshake digests and other extra flags) / / Bits 0-7 are handshake MAC / # define SSL_HANDSHAKE_MAC_MASK 0xFF # define SSL_HANDSHAKE_MAC_MD5_SHA1 SSL_MD_MD5_SHA1_IDX # define SSL_HANDSHAKE_MAC_SHA256 SSL_MD_SHA256_IDX # define SSL_HANDSHAKE_MAC_SHA384 SSL_MD_SHA384_IDX # define SSL_HANDSHAKE_MAC_GOST94 SSL_MD_GOST94_IDX # define SSL_HANDSHAKE_MAC_GOST12_256 SSL_MD_GOST12_256_IDX # define SSL_HANDSHAKE_MAC_GOST12_512 SSL_MD_GOST12_512_IDX # define SSL_HANDSHAKE_MAC_DEFAULT SSL_HANDSHAKE_MAC_MD5_SHA1 / Bits 8-15 bits are PRF / # define TLS1_PRF_DGST_SHIFT 8 # define TLS1_PRF_SHA1_MD5 (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_SHA256 (SSL_MD_SHA256_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_SHA384 (SSL_MD_SHA384_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_GOST94 (SSL_MD_GOST94_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_GOST12_256 (SSL_MD_GOST12_256_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_GOST12_512 (SSL_MD_GOST12_512_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT) / * Stream MAC for GOST ciphersuites from cryptopro draft (currently this also * goes into algorithm2) / # define TLS1_STREAM_MAC 0x10000 / * TLSTREE cipher/mac key derivation from draft-smyshlyaev-tls12-gost-suites * (currently this also goes into algorithm2) / # define TLS1_TLSTREE 0x20000 / Ciphersuite supported in QUIC / # define SSL_QUIC 0x00040000U # define SSL_STRONG_MASK 0x0000001FU # define SSL_DEFAULT_MASK 0X00000020U # define SSL_STRONG_NONE 0x00000001U # define SSL_LOW 0x00000002U # define SSL_MEDIUM 0x00000004U # define SSL_HIGH 0x00000008U # define SSL_FIPS 0x00000010U # define SSL_NOT_DEFAULT 0x00000020U / we have used 0000003f - 26 bits left to go / / Flag used on OpenSSL ciphersuite ids to indicate they are for SSLv3+ / # define SSL3_CK_CIPHERSUITE_FLAG 0x03000000 / Check if an SSL structure is using DTLS / # define SSL_CONNECTION_IS_DTLS(s) \ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) / Check if we are using TLSv1.3 / # define SSL_CONNECTION_IS_TLS13(s) (!SSL_CONNECTION_IS_DTLS(s) \ && SSL_CONNECTION_GET_SSL(s)->method->version >= TLS1_3_VERSION \ && SSL_CONNECTION_GET_SSL(s)->method->version != TLS_ANY_VERSION) # define SSL_CONNECTION_TREAT_AS_TLS13(s) \ (SSL_CONNECTION_IS_TLS13(s) \ \|\| (s)->early_data_state == SSL_EARLY_DATA_CONNECTING \ \|\| (s)->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY \ \|\| (s)->early_data_state == SSL_EARLY_DATA_WRITING \ \|\| (s)->early_data_state == SSL_EARLY_DATA_WRITE_RETRY \ \|\| (s)->hello_retry_request == SSL_HRR_PENDING) # define SSL_IS_FIRST_HANDSHAKE(s) ((s)->s3.tmp.finish_md_len == 0 \ \|\| (s)->s3.tmp.peer_finish_md_len == 0) / See if we need explicit IV / # define SSL_USE_EXPLICIT_IV(s) \ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_EXPLICIT_IV) / * See if we use signature algorithms extension and signature algorithm * before signatures. / # define SSL_USE_SIGALGS(s) \ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SIGALGS) / * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may * apply to others in future. / # define SSL_USE_TLS1_2_CIPHERS(s) \ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS) / * Determine if a client can use TLS 1.2 ciphersuites: can't rely on method * flags because it may not be set to correct version yet. / # define SSL_CLIENT_USE_TLS1_2_CIPHERS(s) \ ((!SSL_CONNECTION_IS_DTLS(s) && s->client_version >= TLS1_2_VERSION) \|\| \ (SSL_CONNECTION_IS_DTLS(s) && DTLS_VERSION_GE(s->client_version, DTLS1_2_VERSION))) / * Determine if a client should send signature algorithms extension: * as with TLS1.2 cipher we can't rely on method flags. / # define SSL_CLIENT_USE_SIGALGS(s) \ SSL_CLIENT_USE_TLS1_2_CIPHERS(s) # define IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value) \ (((value) >= TLSEXT_max_fragment_length_512) && \ ((value) <= TLSEXT_max_fragment_length_4096)) # define USE_MAX_FRAGMENT_LENGTH_EXT(session) \ IS_MAX_FRAGMENT_LENGTH_EXT_VALID(session->ext.max_fragment_len_mode) # define GET_MAX_FRAGMENT_LENGTH(session) \ (512U << (session->ext.max_fragment_len_mode - 1)) # define SSL_READ_ETM(s) (s->s3.flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_READ) # define SSL_WRITE_ETM(s) (s->s3.flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE) # define SSL_IS_QUIC_HANDSHAKE(s) (((s)->s3.flags & TLS1_FLAGS_QUIC) != 0) / alert_dispatch values / / No alert pending / # define SSL_ALERT_DISPATCH_NONE 0 / Alert pending / # define SSL_ALERT_DISPATCH_PENDING 1 / Pending alert write needs to be retried / # define SSL_ALERT_DISPATCH_RETRY 2 / Mostly for SSLv3 / # define SSL_PKEY_RSA 0 # define SSL_PKEY_RSA_PSS_SIGN 1 # define SSL_PKEY_DSA_SIGN 2 # define SSL_PKEY_ECC 3 # define SSL_PKEY_GOST01 4 # define SSL_PKEY_GOST12_256 5 # define SSL_PKEY_GOST12_512 6 # define SSL_PKEY_ED25519 7 # define SSL_PKEY_ED448 8 # define SSL_PKEY_NUM 9 # define SSL_ENC_DES_IDX 0 # define SSL_ENC_3DES_IDX 1 # define SSL_ENC_RC4_IDX 2 # define SSL_ENC_RC2_IDX 3 # define SSL_ENC_IDEA_IDX 4 # define SSL_ENC_NULL_IDX 5 # define SSL_ENC_AES128_IDX 6 # define SSL_ENC_AES256_IDX 7 # define SSL_ENC_CAMELLIA128_IDX 8 # define SSL_ENC_CAMELLIA256_IDX 9 # define SSL_ENC_GOST89_IDX 10 # define SSL_ENC_SEED_IDX 11 # define SSL_ENC_AES128GCM_IDX 12 # define SSL_ENC_AES256GCM_IDX 13 # define SSL_ENC_AES128CCM_IDX 14 # define SSL_ENC_AES256CCM_IDX 15 # define SSL_ENC_AES128CCM8_IDX 16 # define SSL_ENC_AES256CCM8_IDX 17 # define SSL_ENC_GOST8912_IDX 18 # define SSL_ENC_CHACHA_IDX 19 # define SSL_ENC_ARIA128GCM_IDX 20 # define SSL_ENC_ARIA256GCM_IDX 21 # define SSL_ENC_MAGMA_IDX 22 # define SSL_ENC_KUZNYECHIK_IDX 23 # define SSL_ENC_NUM_IDX 24 /- * SSL_kRSA <- RSA_ENC * SSL_kDH <- DH_ENC & (RSA_ENC \| RSA_SIGN \| DSA_SIGN) * SSL_kDHE <- RSA_ENC \| RSA_SIGN \| DSA_SIGN * SSL_aRSA <- RSA_ENC \| RSA_SIGN * SSL_aDSS <- DSA_SIGN / /- #define CERT_INVALID 0 #define CERT_PUBLIC_KEY 1 #define CERT_PRIVATE_KEY 2 / / Certificate Type State / # define OSSL_CERT_TYPE_CTOS_NONE 0 # define OSSL_CERT_TYPE_CTOS_GOOD 1 # define OSSL_CERT_TYPE_CTOS_ERROR 2 / Post-Handshake Authentication state / typedef enum { SSL_PHA_NONE = 0, SSL_PHA_EXT_SENT, / client-side only: extension sent / SSL_PHA_EXT_RECEIVED, / server-side only: extension received / SSL_PHA_REQUEST_PENDING, / server-side only: request pending / SSL_PHA_REQUESTED / request received by client, or sent by server / } SSL_PHA_STATE; / CipherSuite length. SSLv3 and all TLS versions. / # define TLS_CIPHER_LEN 2 / used to hold info on the particular ciphers used / struct ssl_cipher_st { uint32_t valid; const char name; /* text name / const char stdname; /* RFC name / uint32_t id; / id, 4 bytes, first is version / / * changed in 1.0.0: these four used to be portions of a single value * 'algorithms' / uint32_t algorithm_mkey; / key exchange algorithm / uint32_t algorithm_auth; / server authentication / uint32_t algorithm_enc; / symmetric encryption / uint32_t algorithm_mac; / symmetric authentication / int min_tls; / minimum SSL/TLS protocol version / int max_tls; / maximum SSL/TLS protocol version / int min_dtls; / minimum DTLS protocol version / int max_dtls; / maximum DTLS protocol version / uint32_t algo_strength; / strength and export flags / uint32_t algorithm2; / Extra flags / int32_t strength_bits; / Number of bits really used / uint32_t alg_bits; / Number of bits for algorithm / }; / Used to hold SSL/TLS functions / struct ssl_method_st { int version; unsigned flags; unsigned long mask; SSL (ssl_new) (SSL_CTX ctx); void (ssl_free) (SSL s); int (ssl_reset) (SSL s); int (ssl_init) (SSL s); int (ssl_clear) (SSL s); void (ssl_deinit) (SSL s); int (ssl_accept) (SSL s); int (ssl_connect) (SSL s); int (ssl_read) (SSL s, void buf, size_t len, size_t readbytes); int (ssl_peek) (SSL s, void buf, size_t len, size_t readbytes); int (ssl_write) (SSL s, const void buf, size_t len, size_t written); int (ssl_shutdown) (SSL s); int (ssl_renegotiate) (SSL s); int (ssl_renegotiate_check) (SSL s, int); int (ssl_read_bytes) (SSL s, uint8_t type, uint8_t recvd_type, unsigned char buf, size_t len, int peek, size_t readbytes); int (ssl_write_bytes) (SSL s, uint8_t type, const void buf_, size_t len, size_t written); int (ssl_dispatch_alert) (SSL s); long (ssl_ctrl) (SSL s, int cmd, long larg, void parg); long (ssl_ctx_ctrl) (SSL_CTX ctx, int cmd, long larg, void parg); const SSL_CIPHER (get_cipher_by_char) (const unsigned char ptr); int (put_cipher_by_char) (const SSL_CIPHER cipher, WPACKET pkt, size_t len); size_t (ssl_pending) (const SSL s); int (num_ciphers) (void); const SSL_CIPHER (get_cipher) (unsigned ncipher); OSSL_TIME (get_timeout) (void); const struct ssl3_enc_method ssl3_enc; / Extra SSLv3/TLS stuff / int (ssl_version) (void); long (ssl_callback_ctrl) (SSL s, int cb_id, void (fp) (void)); long (ssl_ctx_callback_ctrl) (SSL_CTX s, int cb_id, void (fp) (void)); }; /* * Matches the length of PSK_MAX_PSK_LEN. We keep it the same value for * consistency, even in the event of OPENSSL_NO_PSK being defined. / # define TLS13_MAX_RESUMPTION_PSK_LENGTH 512 /- * Lets make this into an ASN.1 type structure as follows * SSL_SESSION_ID ::= SEQUENCE { * version INTEGER, -- structure version number * SSLversion INTEGER, -- SSL version number * Cipher OCTET STRING, -- the 3 byte cipher ID * Session_ID OCTET STRING, -- the Session ID * Master_key OCTET STRING, -- the master key * Key_Arg [ 0 ] IMPLICIT OCTET STRING, -- the optional Key argument * Time [ 1 ] EXPLICIT INTEGER, -- optional Start Time * Timeout [ 2 ] EXPLICIT INTEGER, -- optional Timeout ins seconds * Peer [ 3 ] EXPLICIT X509, -- optional Peer Certificate * Session_ID_context [ 4 ] EXPLICIT OCTET STRING, -- the Session ID context * Verify_result [ 5 ] EXPLICIT INTEGER, -- X509_V_... code for `Peer' * HostName [ 6 ] EXPLICIT OCTET STRING, -- optional HostName from servername TLS extension * PSK_identity_hint [ 7 ] EXPLICIT OCTET STRING, -- optional PSK identity hint * PSK_identity [ 8 ] EXPLICIT OCTET STRING, -- optional PSK identity * Ticket_lifetime_hint [9] EXPLICIT INTEGER, -- server's lifetime hint for session ticket * Ticket [10] EXPLICIT OCTET STRING, -- session ticket (clients only) * Compression_meth [11] EXPLICIT OCTET STRING, -- optional compression method * SRP_username [ 12 ] EXPLICIT OCTET STRING -- optional SRP username * flags [ 13 ] EXPLICIT INTEGER -- optional flags * } * Look in ssl/ssl_asn1.c for more details * I'm using EXPLICIT tags so I can read the damn things using asn1parse :-). / struct ssl_session_st { int ssl_version; / what ssl version session info is being kept * in here? / size_t master_key_length; / TLSv1.3 early_secret used for external PSKs / unsigned char early_secret[EVP_MAX_MD_SIZE]; / * For <=TLS1.2 this is the master_key. For TLS1.3 this is the resumption * PSK / unsigned char master_key[TLS13_MAX_RESUMPTION_PSK_LENGTH]; / session_id - valid? / size_t session_id_length; unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; / * this is used to determine whether the session is being reused in the * appropriate context. It is up to the application to set this, via * SSL_new / size_t sid_ctx_length; unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; # ifndef OPENSSL_NO_PSK char psk_identity_hint; char psk_identity; # endif / * Used to indicate that session resumption is not allowed. Applications * can also set this bit for a new session via not_resumable_session_cb * to disable session caching and tickets. / int not_resumable; / Peer raw public key, if available / EVP_PKEY peer_rpk; /* This is the cert and type for the other end. / X509 peer; /* Certificate chain peer sent. / STACK_OF(X509) peer_chain; /* * when app_verify_callback accepts a session where the peer's * certificate is not ok, we must remember the error for session reuse: / long verify_result; / only for servers / CRYPTO_REF_COUNT references; OSSL_TIME timeout; OSSL_TIME time; OSSL_TIME calc_timeout; unsigned int compress_meth; / Need to lookup the method / const SSL_CIPHER cipher; unsigned long cipher_id; /* when ASN.1 loaded, this needs to be used to * load the 'cipher' structure / unsigned int kex_group; / TLS group from key exchange / CRYPTO_EX_DATA ex_data; / application specific data / / * These are used to make removal of session-ids more efficient and to * implement a maximum cache size. / struct ssl_session_st prev, next; struct { char hostname; /* RFC4507 info / unsigned char tick; /* Session ticket / size_t ticklen; / Session ticket length / / Session lifetime hint in seconds / unsigned long tick_lifetime_hint; uint32_t tick_age_add; / Max number of bytes that can be sent as early data / uint32_t max_early_data; / The ALPN protocol selected for this session / unsigned char alpn_selected; size_t alpn_selected_len; /* * Maximum Fragment Length as per RFC 4366. * If this value does not contain RFC 4366 allowed values (1-4) then * either the Maximum Fragment Length Negotiation failed or was not * performed at all. / uint8_t max_fragment_len_mode; } ext; # ifndef OPENSSL_NO_SRP char srp_username; # endif unsigned char ticket_appdata; size_t ticket_appdata_len; uint32_t flags; SSL_CTX owner; }; /* Extended master secret support / # define SSL_SESS_FLAG_EXTMS 0x1 # ifndef OPENSSL_NO_SRP typedef struct srp_ctx_st { / param for all the callbacks / void SRP_cb_arg; /* set client Hello login callback / int (TLS_ext_srp_username_callback) (SSL , int , void ); / set SRP N/g param callback for verification / int (SRP_verify_param_callback) (SSL , void ); /* set SRP client passwd callback / char (SRP_give_srp_client_pwd_callback) (SSL , void ); char login; BIGNUM N, g, s, B, A; BIGNUM a, b, v; char info; int strength; unsigned long srp_Mask; } SRP_CTX; # endif typedef enum { SSL_EARLY_DATA_NONE = 0, SSL_EARLY_DATA_CONNECT_RETRY, SSL_EARLY_DATA_CONNECTING, SSL_EARLY_DATA_WRITE_RETRY, SSL_EARLY_DATA_WRITING, SSL_EARLY_DATA_WRITE_FLUSH, SSL_EARLY_DATA_UNAUTH_WRITING, SSL_EARLY_DATA_FINISHED_WRITING, SSL_EARLY_DATA_ACCEPT_RETRY, SSL_EARLY_DATA_ACCEPTING, SSL_EARLY_DATA_READ_RETRY, SSL_EARLY_DATA_READING, SSL_EARLY_DATA_FINISHED_READING } SSL_EARLY_DATA_STATE; / * We check that the amount of unreadable early data doesn't exceed * max_early_data. max_early_data is given in plaintext bytes. However if it is * unreadable then we only know the number of ciphertext bytes. We also don't * know how much the overhead should be because it depends on the ciphersuite. * We make a small allowance. We assume 5 records of actual data plus the end * of early data alert record. Each record has a tag and a content type byte. * The longest tag length we know of is EVP_GCM_TLS_TAG_LEN. We don't count the * content of the alert record either which is 2 bytes. / # define EARLY_DATA_CIPHERTEXT_OVERHEAD ((6 (EVP_GCM_TLS_TAG_LEN + 1)) + 2) /* * The allowance we have between the client's calculated ticket age and our own. * We allow for 10 seconds. If a ticket is presented and the * client's age calculation is different by more than this than our own then we * do not allow that ticket for early_data. / # define TICKET_AGE_ALLOWANCE ossl_seconds2time(10) #define MAX_COMPRESSIONS_SIZE 255 struct ssl_comp_st { int id; const char name; COMP_METHOD method; }; typedef struct raw_extension_st { / Raw packet data for the extension / PACKET data; / Set to 1 if the extension is present or 0 otherwise / int present; / Set to 1 if we have already parsed the extension or 0 otherwise / int parsed; / The type of this extension, i.e. a TLSEXT_TYPE_* value / unsigned int type; / Track what order extensions are received in (0-based). / size_t received_order; } RAW_EXTENSION; typedef struct { unsigned int isv2; unsigned int legacy_version; unsigned char random[SSL3_RANDOM_SIZE]; size_t session_id_len; unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; size_t dtls_cookie_len; unsigned char dtls_cookie[DTLS1_COOKIE_LENGTH]; PACKET ciphersuites; size_t compressions_len; unsigned char compressions[MAX_COMPRESSIONS_SIZE]; PACKET extensions; size_t pre_proc_exts_len; RAW_EXTENSION pre_proc_exts; } CLIENTHELLO_MSG; /* * Extension index values NOTE: Any updates to these defines should be mirrored * with equivalent updates to ext_defs in extensions.c / typedef enum tlsext_index_en { TLSEXT_IDX_renegotiate, TLSEXT_IDX_server_name, TLSEXT_IDX_max_fragment_length, TLSEXT_IDX_srp, TLSEXT_IDX_ec_point_formats, TLSEXT_IDX_supported_groups, TLSEXT_IDX_session_ticket, TLSEXT_IDX_status_request, TLSEXT_IDX_next_proto_neg, TLSEXT_IDX_application_layer_protocol_negotiation, TLSEXT_IDX_use_srtp, TLSEXT_IDX_encrypt_then_mac, TLSEXT_IDX_signed_certificate_timestamp, TLSEXT_IDX_extended_master_secret, TLSEXT_IDX_signature_algorithms_cert, TLSEXT_IDX_post_handshake_auth, TLSEXT_IDX_client_cert_type, TLSEXT_IDX_server_cert_type, TLSEXT_IDX_signature_algorithms, TLSEXT_IDX_supported_versions, TLSEXT_IDX_psk_kex_modes, TLSEXT_IDX_key_share, TLSEXT_IDX_cookie, TLSEXT_IDX_cryptopro_bug, TLSEXT_IDX_compress_certificate, TLSEXT_IDX_early_data, TLSEXT_IDX_certificate_authorities, TLSEXT_IDX_padding, TLSEXT_IDX_psk, / Dummy index - must always be the last entry / TLSEXT_IDX_num_builtins } TLSEXT_INDEX; DEFINE_LHASH_OF_EX(SSL_SESSION); / Needed in ssl_cert.c / DEFINE_LHASH_OF_EX(X509_NAME); # define TLSEXT_KEYNAME_LENGTH 16 # define TLSEXT_TICK_KEY_LENGTH 32 typedef struct ssl_ctx_ext_secure_st { unsigned char tick_hmac_key[TLSEXT_TICK_KEY_LENGTH]; unsigned char tick_aes_key[TLSEXT_TICK_KEY_LENGTH]; } SSL_CTX_EXT_SECURE; / * Helper function for HMAC * The structure should be considered opaque, it will change once the low * level deprecated calls are removed. At that point it can be replaced * by EVP_MAC_CTX and most of the functions converted to macros or inlined * directly. / typedef struct ssl_hmac_st { EVP_MAC_CTX ctx; # ifndef OPENSSL_NO_DEPRECATED_3_0 HMAC_CTX old_ctx; # endif } SSL_HMAC; SSL_HMAC ssl_hmac_new(const SSL_CTX ctx); void ssl_hmac_free(SSL_HMAC ctx); # ifndef OPENSSL_NO_DEPRECATED_3_0 HMAC_CTX ssl_hmac_get0_HMAC_CTX(SSL_HMAC ctx); # endif EVP_MAC_CTX ssl_hmac_get0_EVP_MAC_CTX(SSL_HMAC ctx); int ssl_hmac_init(SSL_HMAC ctx, void key, size_t len, char md); int ssl_hmac_update(SSL_HMAC ctx, const unsigned char data, size_t len); int ssl_hmac_final(SSL_HMAC ctx, unsigned char md, size_t len, size_t max_size); size_t ssl_hmac_size(const SSL_HMAC ctx); int ssl_get_EC_curve_nid(const EVP_PKEY pkey); __owur int tls13_set_encoded_pub_key(EVP_PKEY pkey, const unsigned char enckey, size_t enckeylen); typedef struct tls_group_info_st { char tlsname; / Curve Name as in TLS specs / char realname; /* Curve Name according to provider / char algorithm; /* Algorithm name to fetch / unsigned int secbits; / Bits of security (from SP800-57) / uint16_t group_id; / Group ID / int mintls; / Minimum TLS version, -1 unsupported / int maxtls; / Maximum TLS version (or 0 for undefined) / int mindtls; / Minimum DTLS version, -1 unsupported / int maxdtls; / Maximum DTLS version (or 0 for undefined) / char is_kem; / Mode for this Group: 0 is KEX, 1 is KEM / } TLS_GROUP_INFO; typedef struct tls_sigalg_info_st { char name; /* name as in IANA TLS specs / uint16_t code_point; / IANA-specified code point of sigalg-name / char sigalg_name; /* (combined) sigalg name / char sigalg_oid; /* (combined) sigalg OID / char sig_name; /* pure signature algorithm name / char sig_oid; /* pure signature algorithm OID / char hash_name; /* hash algorithm name / char hash_oid; /* hash algorithm OID / char keytype; /* keytype name / char keytype_oid; /* keytype OID / unsigned int secbits; / Bits of security (from SP800-57) / int mintls; / Minimum TLS version, -1 unsupported / int maxtls; / Maximum TLS version (or 0 for undefined) / } TLS_SIGALG_INFO; / * Structure containing table entry of certificate info corresponding to * CERT_PKEY entries / typedef struct { int nid; / NID of public key algorithm / uint32_t amask; / authmask corresponding to key type / } SSL_CERT_LOOKUP; / flags values / # define TLS_GROUP_TYPE 0x0000000FU / Mask for group type / # define TLS_GROUP_CURVE_PRIME 0x00000001U # define TLS_GROUP_CURVE_CHAR2 0x00000002U # define TLS_GROUP_CURVE_CUSTOM 0x00000004U # define TLS_GROUP_FFDHE 0x00000008U # define TLS_GROUP_ONLY_FOR_TLS1_3 0x00000010U # define TLS_GROUP_FFDHE_FOR_TLS1_3 (TLS_GROUP_FFDHE\|TLS_GROUP_ONLY_FOR_TLS1_3) struct ssl_ctx_st { OSSL_LIB_CTX libctx; const SSL_METHOD method; STACK_OF(SSL_CIPHER) cipher_list; /* same as above but sorted for lookup / STACK_OF(SSL_CIPHER) cipher_list_by_id; /* TLSv1.3 specific ciphersuites / STACK_OF(SSL_CIPHER) tls13_ciphersuites; struct x509_store_st /* X509_STORE / cert_store; LHASH_OF(SSL_SESSION) sessions; / * Most session-ids that will be cached, default is * SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited. / size_t session_cache_size; struct ssl_session_st session_cache_head; struct ssl_session_st session_cache_tail; / * This can have one of 2 values, ored together, SSL_SESS_CACHE_CLIENT, * SSL_SESS_CACHE_SERVER, Default is SSL_SESSION_CACHE_SERVER, which * means only SSL_accept will cache SSL_SESSIONS. / uint32_t session_cache_mode; / * If timeout is not 0, it is the default timeout value set when * SSL_new() is called. This has been put in to make life easier to set * things up / OSSL_TIME session_timeout; / * If this callback is not null, it will be called each time a session id * is added to the cache. If this function returns 1, it means that the * callback will do a SSL_SESSION_free() when it has finished using it. * Otherwise, on 0, it means the callback has finished with it. If * remove_session_cb is not null, it will be called when a session-id is * removed from the cache. After the call, OpenSSL will * SSL_SESSION_free() it. / int (new_session_cb) (struct ssl_st ssl, SSL_SESSION sess); void (remove_session_cb) (struct ssl_ctx_st ctx, SSL_SESSION sess); SSL_SESSION (get_session_cb) (struct ssl_st ssl, const unsigned char data, int len, int copy); struct { TSAN_QUALIFIER int sess_connect; /* SSL new conn - started / TSAN_QUALIFIER int sess_connect_renegotiate; / SSL reneg - requested / TSAN_QUALIFIER int sess_connect_good; / SSL new conne/reneg - finished / TSAN_QUALIFIER int sess_accept; / SSL new accept - started / TSAN_QUALIFIER int sess_accept_renegotiate; / SSL reneg - requested / TSAN_QUALIFIER int sess_accept_good; / SSL accept/reneg - finished / TSAN_QUALIFIER int sess_miss; / session lookup misses / TSAN_QUALIFIER int sess_timeout; / reuse attempt on timeouted session / TSAN_QUALIFIER int sess_cache_full; / session removed due to full cache / TSAN_QUALIFIER int sess_hit; / session reuse actually done / TSAN_QUALIFIER int sess_cb_hit; / session-id that was not in * the cache was passed back via * the callback. This indicates * that the application is * supplying session-id's from * other processes - spooky * :-) / } stats; #ifdef TSAN_REQUIRES_LOCKING CRYPTO_RWLOCK tsan_lock; #endif CRYPTO_REF_COUNT references; /* if defined, these override the X509_verify_cert() calls / int (app_verify_callback) (X509_STORE_CTX , void ); void app_verify_arg; / * before OpenSSL 0.9.7, 'app_verify_arg' was ignored * ('app_verify_callback' was called with just one argument) / / Default password callback. / pem_password_cb default_passwd_callback; /* Default password callback user data. / void default_passwd_callback_userdata; /* get client cert callback / int (client_cert_cb) (SSL ssl, X509 x509, EVP_PKEY pkey); / cookie generate callback / int (app_gen_cookie_cb) (SSL ssl, unsigned char cookie, unsigned int cookie_len); / verify cookie callback / int (app_verify_cookie_cb) (SSL ssl, const unsigned char cookie, unsigned int cookie_len); /* TLS1.3 app-controlled cookie generate callback / int (gen_stateless_cookie_cb) (SSL ssl, unsigned char cookie, size_t cookie_len); / TLS1.3 verify app-controlled cookie callback / int (verify_stateless_cookie_cb) (SSL ssl, const unsigned char cookie, size_t cookie_len); CRYPTO_EX_DATA ex_data; const EVP_MD md5; / For SSLv3/TLSv1 'ssl3-md5' / const EVP_MD sha1; /* For SSLv3/TLSv1 'ssl3-sha1' / STACK_OF(X509) extra_certs; STACK_OF(SSL_COMP) comp_methods; / stack of SSL_COMP, SSLv3/TLSv1 / / Default values used when no per-SSL value is defined follow / / used if SSL's info_callback is NULL / void (info_callback) (const SSL ssl, int type, int val); / * What we put in certificate_authorities extension for TLS 1.3 * (ClientHello and CertificateRequest) or just client cert requests for * earlier versions. If client_ca_names is populated then it is only used * for client cert requests, and in preference to ca_names. / STACK_OF(X509_NAME) ca_names; STACK_OF(X509_NAME) client_ca_names; / * Default values to use in SSL structures follow (these are copied by * SSL_new) / uint64_t options; uint32_t mode; int min_proto_version; int max_proto_version; size_t max_cert_list; struct cert_st / CERT / cert; SSL_CERT_LOOKUP ssl_cert_info; int read_ahead; / callback that allows applications to peek at protocol messages / ossl_msg_cb msg_callback; void msg_callback_arg; uint32_t verify_mode; size_t sid_ctx_length; unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; /* called 'verify_callback' in the SSL / int (default_verify_callback) (int ok, X509_STORE_CTX ctx); / Default generate session ID callback. / GEN_SESSION_CB generate_session_id; X509_VERIFY_PARAM param; int quiet_shutdown; # ifndef OPENSSL_NO_CT CTLOG_STORE ctlog_store; / CT Log Store / / * Validates that the SCTs (Signed Certificate Timestamps) are sufficient. * If they are not, the connection should be aborted. / ssl_ct_validation_cb ct_validation_callback; void ct_validation_callback_arg; # endif /* * If we're using more than one pipeline how should we divide the data * up between the pipes? / size_t split_send_fragment; / * Maximum amount of data to send in one fragment. actual record size can * be more than this due to padding and MAC overheads. / size_t max_send_fragment; / Up to how many pipelines should we use? If 0 then 1 is assumed / size_t max_pipelines; / The default read buffer length to use (0 means not set) / size_t default_read_buf_len; # ifndef OPENSSL_NO_ENGINE / * Engine to pass requests for client certs to / ENGINE client_cert_engine; # endif /* ClientHello callback. Mostly for extensions, but not entirely. / SSL_client_hello_cb_fn client_hello_cb; void client_hello_cb_arg; /* TLS extensions. / struct { / TLS extensions servername callback / int (servername_cb) (SSL , int , void ); void servername_arg; /* RFC 4507 session ticket keys / unsigned char tick_key_name[TLSEXT_KEYNAME_LENGTH]; SSL_CTX_EXT_SECURE secure; # ifndef OPENSSL_NO_DEPRECATED_3_0 /* Callback to support customisation of ticket key setting / int (ticket_key_cb) (SSL ssl, unsigned char name, unsigned char iv, EVP_CIPHER_CTX ectx, HMAC_CTX hctx, int enc); #endif int (ticket_key_evp_cb) (SSL ssl, unsigned char name, unsigned char iv, EVP_CIPHER_CTX ectx, EVP_MAC_CTX hctx, int enc); / certificate status request info / / Callback for status request / int (status_cb) (SSL ssl, void arg); void status_arg; / ext status type used for CSR extension (OCSP Stapling) / int status_type; / RFC 4366 Maximum Fragment Length Negotiation / uint8_t max_fragment_len_mode; / EC extension values inherited by SSL structure / size_t ecpointformats_len; unsigned char ecpointformats; size_t supportedgroups_len; uint16_t supportedgroups; uint16_t supported_groups_default; size_t supported_groups_default_len; /* * ALPN information (we are in the process of transitioning from NPN to * ALPN.) / /- * For a server, this contains a callback function that allows the * server to select the protocol for the connection. * out: on successful return, this must point to the raw protocol * name (without the length prefix). * outlen: on successful return, this contains the length of \|out\|. in: points to the client's list of supported protocols in * wire-format. * inlen: the length of \|in\|. / int (alpn_select_cb) (SSL s, const unsigned char out, unsigned char outlen, const unsigned char in, unsigned int inlen, void arg); void alpn_select_cb_arg; / * For a client, this contains the list of supported protocols in wire * format. / unsigned char alpn; size_t alpn_len; # ifndef OPENSSL_NO_NEXTPROTONEG /* Next protocol negotiation information / / * For a server, this contains a callback function by which the set of * advertised protocols can be provided. / SSL_CTX_npn_advertised_cb_func npn_advertised_cb; void npn_advertised_cb_arg; /* * For a client, this contains a callback function that selects the next * protocol from the list provided by the server. / SSL_CTX_npn_select_cb_func npn_select_cb; void npn_select_cb_arg; # endif unsigned char cookie_hmac_key[SHA256_DIGEST_LENGTH]; } ext; # ifndef OPENSSL_NO_PSK SSL_psk_client_cb_func psk_client_callback; SSL_psk_server_cb_func psk_server_callback; # endif SSL_psk_find_session_cb_func psk_find_session_cb; SSL_psk_use_session_cb_func psk_use_session_cb; # ifndef OPENSSL_NO_SRP SRP_CTX srp_ctx; /* ctx for SRP authentication / # endif / Shared DANE context / struct dane_ctx_st dane; # ifndef OPENSSL_NO_SRTP / SRTP profiles we are willing to do from RFC 5764 / STACK_OF(SRTP_PROTECTION_PROFILE) srtp_profiles; # endif /* * Callback for disabling session caching and ticket support on a session * basis, depending on the chosen cipher. / int (not_resumable_session_cb) (SSL ssl, int is_forward_secure); CRYPTO_RWLOCK lock; /* * Callback for logging key material for use with debugging tools like * Wireshark. The callback should log `line` followed by a newline. / SSL_CTX_keylog_cb_func keylog_callback; / * The maximum number of bytes advertised in session tickets that can be * sent as early data. / uint32_t max_early_data; / * The maximum number of bytes of early data that a server will tolerate * (which should be at least as much as max_early_data). / uint32_t recv_max_early_data; / TLS1.3 padding callback / size_t (record_padding_cb)(SSL s, int type, size_t len, void arg); void record_padding_arg; size_t block_padding; / Session ticket appdata / SSL_CTX_generate_session_ticket_fn generate_ticket_cb; SSL_CTX_decrypt_session_ticket_fn decrypt_ticket_cb; void ticket_cb_data; /* The number of TLS1.3 tickets to automatically send / size_t num_tickets; / Callback to determine if early_data is acceptable or not / SSL_allow_early_data_cb_fn allow_early_data_cb; void allow_early_data_cb_data; /* Do we advertise Post-handshake auth support? / int pha_enabled; / Callback for SSL async handling / SSL_async_callback_fn async_cb; void async_cb_arg; char propq; int ssl_mac_pkey_id[SSL_MD_NUM_IDX]; const EVP_CIPHER ssl_cipher_methods[SSL_ENC_NUM_IDX]; const EVP_MD ssl_digest_methods[SSL_MD_NUM_IDX]; size_t ssl_mac_secret_size[SSL_MD_NUM_IDX]; size_t tls12_sigalgs_len; / Cache of all sigalgs we know and whether they are available or not / struct sigalg_lookup_st sigalg_lookup_cache; /* List of all sigalgs (code points) available, incl. from providers / uint16_t tls12_sigalgs; TLS_GROUP_INFO group_list; size_t group_list_len; size_t group_list_max_len; TLS_SIGALG_INFO sigalg_list; size_t sigalg_list_len; size_t sigalg_list_max_len; /* masks of disabled algorithms / uint32_t disabled_enc_mask; uint32_t disabled_mac_mask; uint32_t disabled_mkey_mask; uint32_t disabled_auth_mask; #ifndef OPENSSL_NO_COMP_ALG / certificate compression preferences / int cert_comp_prefs[TLSEXT_comp_cert_limit]; #endif / Certificate Type stuff - for RPK vs X.509 / unsigned char client_cert_type; size_t client_cert_type_len; unsigned char server_cert_type; size_t server_cert_type_len; }; typedef struct cert_pkey_st CERT_PKEY; #define SSL_TYPE_SSL_CONNECTION 0 #define SSL_TYPE_QUIC_CONNECTION 1 #define SSL_TYPE_QUIC_XSO 2 struct ssl_st { int type; SSL_CTX ctx; const SSL_METHOD defltmeth; const SSL_METHOD method; CRYPTO_REF_COUNT references; CRYPTO_RWLOCK lock; / extra application data / CRYPTO_EX_DATA ex_data; }; struct ssl_connection_st { / type identifier and common data / struct ssl_st ssl; / * protocol version (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION, * DTLS1_VERSION) / int version; / * There are 2 BIO's even though they are normally both the same. This * is so data can be read and written to different handlers / / used by SSL_read / BIO rbio; /* used by SSL_write / BIO wbio; /* used during session-id reuse to concatenate messages / BIO bbio; /* * This holds a variable that indicates what we were doing when a 0 or -1 * is returned. This is needed for non-blocking IO so we know what * request needs re-doing when in SSL_accept or SSL_connect / int rwstate; int (handshake_func) (SSL ); / * Imagine that here's a boolean member "init" that is switched as soon * as SSL_set_{accept/connect}_state is called for the first time, so * that "state" and "handshake_func" are properly initialized. But as * handshake_func is == 0 until then, we use this test instead of an * "init" member. / / are we the server side? / int server; / * Generate a new session or reuse an old one. * NB: For servers, the 'new' session may actually be a previously * cached session or even the previous session unless * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set / int new_session; / don't send shutdown packets / int quiet_shutdown; / we have shut things down, 0x01 sent, 0x02 for received / int shutdown; / Timestamps used to calculate the handshake RTT / OSSL_TIME ts_msg_write; OSSL_TIME ts_msg_read; / where we are / OSSL_STATEM statem; SSL_EARLY_DATA_STATE early_data_state; BUF_MEM init_buf; /* buffer used during init / void init_msg; /* pointer to handshake message body, set by * tls_get_message_header() / size_t init_num; / amount read/written / size_t init_off; / amount read/written / size_t ssl_pkey_num; struct { long flags; unsigned char server_random[SSL3_RANDOM_SIZE]; unsigned char client_random[SSL3_RANDOM_SIZE]; / used during startup, digest all incoming/outgoing packets / BIO handshake_buffer; /* * When handshake digest is determined, buffer is hashed and * freed and MD_CTX for the required digest is stored here. / EVP_MD_CTX handshake_dgst; /* * Set whenever an expected ChangeCipherSpec message is processed. * Unset when the peer's Finished message is received. * Unexpected ChangeCipherSpec messages trigger a fatal alert. / int change_cipher_spec; int warn_alert; int fatal_alert; / * we allow one fatal and one warning alert to be outstanding, send close * alert via the warning alert / int alert_dispatch; unsigned char send_alert[2]; / * This flag is set when we should renegotiate ASAP, basically when there * is no more data in the read or write buffers / int renegotiate; int total_renegotiations; int num_renegotiations; int in_read_app_data; struct { / actually only need to be 16+20 for SSLv3 and 12 for TLS / unsigned char finish_md[EVP_MAX_MD_SIZE 2]; size_t finish_md_len; unsigned char peer_finish_md[EVP_MAX_MD_SIZE * 2]; size_t peer_finish_md_len; size_t message_size; int message_type; /* used to hold the new cipher we are going to use / const SSL_CIPHER new_cipher; EVP_PKEY pkey; / holds short lived key exchange key / / used for certificate requests / int cert_req; / Certificate types in certificate request message. / uint8_t ctype; size_t ctype_len; /* Certificate authorities list peer sent / STACK_OF(X509_NAME) peer_ca_names; size_t key_block_length; unsigned char key_block; const EVP_CIPHER new_sym_enc; const EVP_MD new_hash; int new_mac_pkey_type; size_t new_mac_secret_size; # ifndef OPENSSL_NO_COMP const SSL_COMP new_compression; # else char new_compression; # endif int cert_request; / Raw values of the cipher list from a client / unsigned char ciphers_raw; size_t ciphers_rawlen; /* Temporary storage for premaster secret / unsigned char pms; size_t pmslen; # ifndef OPENSSL_NO_PSK /* Temporary storage for PSK key / unsigned char psk; size_t psklen; # endif /* Signature algorithm we actually use / const struct sigalg_lookup_st sigalg; /* Pointer to certificate we use / CERT_PKEY cert; /* * signature algorithms peer reports: e.g. supported signature * algorithms extension for server or as part of a certificate * request for client. * Keep track of the algorithms for TLS and X.509 usage separately. / uint16_t peer_sigalgs; uint16_t peer_cert_sigalgs; / Size of above arrays / size_t peer_sigalgslen; size_t peer_cert_sigalgslen; / Sigalg peer actually uses / const struct sigalg_lookup_st peer_sigalg; /* * Set if corresponding CERT_PKEY can be used with current * SSL session: e.g. appropriate curve, signature algorithms etc. * If zero it can't be used at all. / uint32_t valid_flags; /* * For servers the following masks are for the key and auth algorithms * that are supported by the certs below. For clients they are masks of * disabled algorithms based on the current session. / uint32_t mask_k; uint32_t mask_a; / * The following are used by the client to see if a cipher is allowed or * not. It contains the minimum and maximum version the client's using * based on what it knows so far. / int min_ver; int max_ver; } tmp; / Connection binding to prevent renegotiation attacks / unsigned char previous_client_finished[EVP_MAX_MD_SIZE]; size_t previous_client_finished_len; unsigned char previous_server_finished[EVP_MAX_MD_SIZE]; size_t previous_server_finished_len; int send_connection_binding; # ifndef OPENSSL_NO_NEXTPROTONEG / * Set if we saw the Next Protocol Negotiation extension from our peer. / int npn_seen; # endif / * ALPN information (we are in the process of transitioning from NPN to * ALPN.) / / * In a server these point to the selected ALPN protocol after the * ClientHello has been processed. In a client these contain the protocol * that the server selected once the ServerHello has been processed. / unsigned char alpn_selected; size_t alpn_selected_len; /* used by the server to know what options were proposed / unsigned char alpn_proposed; size_t alpn_proposed_len; /* used by the client to know if it actually sent alpn / int alpn_sent; / * This is set to true if we believe that this is a version of Safari * running on OS X 10.6 or newer. We wish to know this because Safari on * 10.8 .. 10.8.3 has broken ECDHE-ECDSA support. / char is_probably_safari; / * Track whether we did a key exchange this handshake or not, so * SSL_get_negotiated_group() knows whether to fall back to the * value in the SSL_SESSION. / char did_kex; / For clients: peer temporary key / / The group_id for the key exchange key / uint16_t group_id; EVP_PKEY peer_tmp; } s3; struct dtls1_state_st d1; / DTLSv1 variables / / callback that allows applications to peek at protocol messages / void (msg_callback) (int write_p, int version, int content_type, const void buf, size_t len, SSL ssl, void arg); void msg_callback_arg; int hit; /* reusing a previous session / X509_VERIFY_PARAM param; /* Per connection DANE state / SSL_DANE dane; / crypto / STACK_OF(SSL_CIPHER) peer_ciphers; STACK_OF(SSL_CIPHER) cipher_list; STACK_OF(SSL_CIPHER) cipher_list_by_id; /* TLSv1.3 specific ciphersuites / STACK_OF(SSL_CIPHER) tls13_ciphersuites; /* * These are the ones being used, the ones in SSL_SESSION are the ones to * be 'copied' into these ones / uint32_t mac_flags; / * The TLS1.3 secrets. / unsigned char early_secret[EVP_MAX_MD_SIZE]; unsigned char handshake_secret[EVP_MAX_MD_SIZE]; unsigned char master_secret[EVP_MAX_MD_SIZE]; unsigned char resumption_master_secret[EVP_MAX_MD_SIZE]; unsigned char client_finished_secret[EVP_MAX_MD_SIZE]; unsigned char server_finished_secret[EVP_MAX_MD_SIZE]; unsigned char server_finished_hash[EVP_MAX_MD_SIZE]; unsigned char handshake_traffic_hash[EVP_MAX_MD_SIZE]; unsigned char client_app_traffic_secret[EVP_MAX_MD_SIZE]; unsigned char server_app_traffic_secret[EVP_MAX_MD_SIZE]; unsigned char exporter_master_secret[EVP_MAX_MD_SIZE]; unsigned char early_exporter_master_secret[EVP_MAX_MD_SIZE]; / session info / / client cert? / / This is used to hold the server certificate used / struct cert_st / CERT / cert; /* * The hash of all messages prior to the CertificateVerify, and the length * of that hash. / unsigned char cert_verify_hash[EVP_MAX_MD_SIZE]; size_t cert_verify_hash_len; / Flag to indicate whether we should send a HelloRetryRequest or not / enum {SSL_HRR_NONE = 0, SSL_HRR_PENDING, SSL_HRR_COMPLETE} hello_retry_request; / * the session_id_context is used to ensure sessions are only reused in * the appropriate context / size_t sid_ctx_length; unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; / This can also be in the session once a session is established / SSL_SESSION session; /* TLSv1.3 PSK session / SSL_SESSION psksession; unsigned char psksession_id; size_t psksession_id_len; / Default generate session ID callback. / GEN_SESSION_CB generate_session_id; / * The temporary TLSv1.3 session id. This isn't really a session id at all * but is a random value sent in the legacy session id field. / unsigned char tmp_session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; size_t tmp_session_id_len; / Used in SSL3 / / * 0 don't care about verify failure. * 1 fail if verify fails / uint32_t verify_mode; / fail if callback returns 0 / int (verify_callback) (int ok, X509_STORE_CTX ctx); / optional informational callback / void (info_callback) (const SSL ssl, int type, int val); / error bytes to be written / int error; / actual code / int error_code; # ifndef OPENSSL_NO_PSK SSL_psk_client_cb_func psk_client_callback; SSL_psk_server_cb_func psk_server_callback; # endif SSL_psk_find_session_cb_func psk_find_session_cb; SSL_psk_use_session_cb_func psk_use_session_cb; / Verified chain of peer / STACK_OF(X509) verified_chain; long verify_result; /* * What we put in certificate_authorities extension for TLS 1.3 * (ClientHello and CertificateRequest) or just client cert requests for * earlier versions. If client_ca_names is populated then it is only used * for client cert requests, and in preference to ca_names. / STACK_OF(X509_NAME) ca_names; STACK_OF(X509_NAME) client_ca_names; / protocol behaviour / uint64_t options; / API behaviour / uint32_t mode; int min_proto_version; int max_proto_version; size_t max_cert_list; int first_packet; / * What was passed in ClientHello.legacy_version. Used for RSA pre-master * secret and SSLv3/TLS (<=1.2) rollback check / int client_version; / * If we're using more than one pipeline how should we divide the data * up between the pipes? / size_t split_send_fragment; / * Maximum amount of data to send in one fragment. actual record size can * be more than this due to padding and MAC overheads. / size_t max_send_fragment; / Up to how many pipelines should we use? If 0 then 1 is assumed / size_t max_pipelines; struct { / Built-in extension flags / uint8_t extflags[TLSEXT_IDX_num_builtins]; / TLS extension debug callback / void (debug_cb)(SSL s, int client_server, int type, const unsigned char data, int len, void arg); void debug_arg; char hostname; / certificate status request info / / Status type or -1 if no status type / int status_type; / Raw extension data, if seen / unsigned char scts; /* Length of raw extension data, if seen / uint16_t scts_len; / Expect OCSP CertificateStatus message / int status_expected; struct { / OCSP status request only / STACK_OF(OCSP_RESPID) ids; X509_EXTENSIONS exts; / OCSP response received or to be sent / unsigned char resp; size_t resp_len; } ocsp; /* RFC4507 session ticket expected to be received or sent / int ticket_expected; / TLS 1.3 tickets requested by the application. / int extra_tickets_expected; size_t ecpointformats_len; / our list / unsigned char ecpointformats; size_t peer_ecpointformats_len; /* peer's list / unsigned char peer_ecpointformats; size_t supportedgroups_len; /* our list / uint16_t supportedgroups; size_t peer_supportedgroups_len; /* peer's list / uint16_t peer_supportedgroups; /* TLS Session Ticket extension override / TLS_SESSION_TICKET_EXT session_ticket; /* TLS Session Ticket extension callback / tls_session_ticket_ext_cb_fn session_ticket_cb; void session_ticket_cb_arg; /* TLS pre-shared secret session resumption / tls_session_secret_cb_fn session_secret_cb; void session_secret_cb_arg; /* * For a client, this contains the list of supported protocols in wire * format. / unsigned char alpn; size_t alpn_len; /* * Next protocol negotiation. For the client, this is the protocol that * we sent in NextProtocol and is set when handling ServerHello * extensions. For a server, this is the client's selected_protocol from * NextProtocol and is set when handling the NextProtocol message, before * the Finished message. / unsigned char npn; size_t npn_len; /* The available PSK key exchange modes / int psk_kex_mode; / Set to one if we have negotiated ETM / int use_etm; / Are we expecting to receive early data? / int early_data; / Is the session suitable for early data? / int early_data_ok; / May be sent by a server in HRR. Must be echoed back in ClientHello / unsigned char tls13_cookie; size_t tls13_cookie_len; /* Have we received a cookie from the client? / int cookieok; / * Maximum Fragment Length as per RFC 4366. * If this member contains one of the allowed values (1-4) * then we should include Maximum Fragment Length Negotiation * extension in Client Hello. * Please note that value of this member does not have direct * effect. The actual (binding) value is stored in SSL_SESSION, * as this extension is optional on server side. / uint8_t max_fragment_len_mode; / * On the client side the number of ticket identities we sent in the * ClientHello. On the server side the identity of the ticket we * selected. / int tick_identity; / This is the list of algorithms the peer supports that we also support / int compress_certificate_from_peer[TLSEXT_comp_cert_limit]; / indicate that we sent the extension, so we'll accept it / int compress_certificate_sent; uint8_t client_cert_type; uint8_t client_cert_type_ctos; uint8_t server_cert_type; uint8_t server_cert_type_ctos; } ext; / * Parsed form of the ClientHello, kept around across client_hello_cb * calls. / CLIENTHELLO_MSG clienthello; /- no further mod of servername * 0 : call the servername extension callback. * 1 : prepare 2, allow last ack just after in server callback. * 2 : don't call servername callback, no ack in server hello / int servername_done; # ifndef OPENSSL_NO_CT / * Validates that the SCTs (Signed Certificate Timestamps) are sufficient. * If they are not, the connection should be aborted. / ssl_ct_validation_cb ct_validation_callback; / User-supplied argument that is passed to the ct_validation_callback / void ct_validation_callback_arg; /* * Consolidated stack of SCTs from all sources. * Lazily populated by CT_get_peer_scts(SSL) / STACK_OF(SCT) scts; / Have we attempted to find/parse SCTs yet? / int scts_parsed; # endif SSL_CTX session_ctx; /* initial ctx, used to store sessions / # ifndef OPENSSL_NO_SRTP / What we'll do / STACK_OF(SRTP_PROTECTION_PROFILE) srtp_profiles; /* What's been chosen / SRTP_PROTECTION_PROFILE srtp_profile; # endif /- 1 if we are renegotiating. * 2 if we are a server and are inside a handshake * (i.e. not just sending a HelloRequest) / int renegotiate; / If sending a KeyUpdate is pending / int key_update; / Post-handshake authentication state / SSL_PHA_STATE post_handshake_auth; int pha_enabled; uint8_t pha_context; size_t pha_context_len; int certreqs_sent; EVP_MD_CTX pha_dgst; / this is just the digest through ClientFinished / # ifndef OPENSSL_NO_SRP / ctx for SRP authentication / SRP_CTX srp_ctx; # endif / * Callback for disabling session caching and ticket support on a session * basis, depending on the chosen cipher. / int (not_resumable_session_cb) (SSL ssl, int is_forward_secure); / Record layer data / RECORD_LAYER rlayer; / Default password callback. / pem_password_cb default_passwd_callback; /* Default password callback user data. / void default_passwd_callback_userdata; /* Async Job info / ASYNC_JOB job; ASYNC_WAIT_CTX waitctx; size_t asyncrw; / * The maximum number of bytes advertised in session tickets that can be * sent as early data. / uint32_t max_early_data; / * The maximum number of bytes of early data that a server will tolerate * (which should be at least as much as max_early_data). / uint32_t recv_max_early_data; / * The number of bytes of early data received so far. If we accepted early * data then this is a count of the plaintext bytes. If we rejected it then * this is a count of the ciphertext bytes. / uint32_t early_data_count; / The number of TLS1.3 tickets to automatically send / size_t num_tickets; / The number of TLS1.3 tickets actually sent so far / size_t sent_tickets; / The next nonce value to use when we send a ticket on this connection / uint64_t next_ticket_nonce; / Callback to determine if early_data is acceptable or not / SSL_allow_early_data_cb_fn allow_early_data_cb; void allow_early_data_cb_data; /* Callback for SSL async handling / SSL_async_callback_fn async_cb; void async_cb_arg; /* * Signature algorithms shared by client and server: cached because these * are used most often. / const struct sigalg_lookup_st shared_sigalgs; size_t shared_sigalgslen; #ifndef OPENSSL_NO_COMP_ALG / certificate compression preferences / int cert_comp_prefs[TLSEXT_comp_cert_limit]; #endif / Certificate Type stuff - for RPK vs X.509 / unsigned char client_cert_type; size_t client_cert_type_len; unsigned char server_cert_type; size_t server_cert_type_len; }; # define SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, c) \ ((ssl) == NULL ? NULL \ : ((ssl)->type == SSL_TYPE_SSL_CONNECTION \ ? (c SSL_CONNECTION )(ssl) \ : NULL)) # define SSL_CONNECTION_NO_CONST # define SSL_CONNECTION_FROM_SSL_ONLY(ssl) \ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, SSL_CONNECTION_NO_CONST) # define SSL_CONNECTION_FROM_CONST_SSL_ONLY(ssl) \ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, const) # define SSL_CONNECTION_GET_CTX(sc) ((sc)->ssl.ctx) # define SSL_CONNECTION_GET_SSL(sc) (&(sc)->ssl) # ifndef OPENSSL_NO_QUIC # include "quic/quic_local.h" # define SSL_CONNECTION_FROM_SSL_int(ssl, c) \ ((ssl) == NULL ? NULL \ : ((ssl)->type == SSL_TYPE_SSL_CONNECTION \ ? (c SSL_CONNECTION )(ssl) \ : ((ssl)->type == SSL_TYPE_QUIC_CONNECTION \ ? (c SSL_CONNECTION )((c QUIC_CONNECTION )(ssl))->tls \ : NULL))) # define SSL_CONNECTION_FROM_SSL(ssl) \ SSL_CONNECTION_FROM_SSL_int(ssl, SSL_CONNECTION_NO_CONST) # define SSL_CONNECTION_FROM_CONST_SSL(ssl) \ SSL_CONNECTION_FROM_SSL_int(ssl, const) # else # define SSL_CONNECTION_FROM_SSL(ssl) \ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, SSL_CONNECTION_NO_CONST) # define SSL_CONNECTION_FROM_CONST_SSL(ssl) \ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, const) # endif / * Structure containing table entry of values associated with the signature * algorithms (signature scheme) extension / typedef struct sigalg_lookup_st { / TLS 1.3 signature scheme name / const char name; /* Raw value used in extension / uint16_t sigalg; / NID of hash algorithm or NID_undef if no hash / int hash; / Index of hash algorithm or -1 if no hash algorithm / int hash_idx; / NID of signature algorithm / int sig; / Index of signature algorithm / int sig_idx; / Combined hash and signature NID, if any / int sigandhash; / Required public key curve (ECDSA only) / int curve; / Whether this signature algorithm is actually available for use / int enabled; } SIGALG_LOOKUP; / DTLS structures / # ifndef OPENSSL_NO_SCTP # define DTLS1_SCTP_AUTH_LABEL "EXPORTER_DTLS_OVER_SCTP" # endif / Max MTU overhead we know about so far is 40 for IPv6 + 8 for UDP / # define DTLS1_MAX_MTU_OVERHEAD 48 / * Flag used in message reuse to indicate the buffer contains the record * header as well as the handshake message header. / # define DTLS1_SKIP_RECORD_HEADER 2 struct dtls1_retransmit_state { const OSSL_RECORD_METHOD wrlmethod; OSSL_RECORD_LAYER wrl; }; struct hm_header_st { unsigned char type; size_t msg_len; unsigned short seq; size_t frag_off; size_t frag_len; unsigned int is_ccs; struct dtls1_retransmit_state saved_retransmit_state; }; typedef struct hm_fragment_st { struct hm_header_st msg_header; unsigned char fragment; unsigned char reassembly; } hm_fragment; typedef struct pqueue_st pqueue; typedef struct pitem_st pitem; struct pitem_st { unsigned char priority[8]; / 64-bit value in big-endian encoding / void data; pitem next; }; typedef struct pitem_st piterator; pitem pitem_new(unsigned char prio64be, void data); void pitem_free(pitem item); pqueue pqueue_new(void); void pqueue_free(pqueue pq); pitem pqueue_insert(pqueue pq, pitem item); pitem pqueue_peek(pqueue pq); pitem pqueue_pop(pqueue pq); pitem pqueue_find(pqueue pq, unsigned char prio64be); pitem pqueue_iterator(pqueue pq); pitem pqueue_next(piterator iter); size_t pqueue_size(pqueue pq); typedef struct dtls1_state_st { unsigned char cookie[DTLS1_COOKIE_LENGTH]; size_t cookie_len; unsigned int cookie_verified; / handshake message numbers / unsigned short handshake_write_seq; unsigned short next_handshake_write_seq; unsigned short handshake_read_seq; / Buffered handshake messages / pqueue buffered_messages; /* Buffered (sent) handshake records / pqueue sent_messages; size_t link_mtu; /* max on-the-wire DTLS packet size / size_t mtu; / max DTLS packet size / struct hm_header_st w_msg_hdr; struct hm_header_st r_msg_hdr; / Number of alerts received so far / unsigned int timeout_num_alerts; / * Indicates when the last handshake msg sent will timeout / OSSL_TIME next_timeout; / Timeout duration / unsigned int timeout_duration_us; unsigned int retransmitting; # ifndef OPENSSL_NO_SCTP int shutdown_received; # endif DTLS_timer_cb timer_cb; } DTLS1_STATE; / * From ECC-TLS draft, used in encoding the curve type in ECParameters / # define EXPLICIT_PRIME_CURVE_TYPE 1 # define EXPLICIT_CHAR2_CURVE_TYPE 2 # define NAMED_CURVE_TYPE 3 # ifndef OPENSSL_NO_COMP_ALG struct ossl_comp_cert_st { unsigned char data; size_t len; size_t orig_len; CRYPTO_REF_COUNT references; int alg; }; typedef struct ossl_comp_cert_st OSSL_COMP_CERT; void OSSL_COMP_CERT_free(OSSL_COMP_CERT c); int OSSL_COMP_CERT_up_ref(OSSL_COMP_CERT c); # endif struct cert_pkey_st { X509 x509; EVP_PKEY privatekey; /* Chain for this certificate / STACK_OF(X509) chain; /- serverinfo data for this certificate. The data is in TLS Extension * wire format, specifically it's a series of records like: * uint16_t extension_type; // (RFC 5246, 7.4.1.4, Extension) * uint16_t length; * uint8_t data[length]; / unsigned char serverinfo; size_t serverinfo_length; # ifndef OPENSSL_NO_COMP_ALG /* Compressed certificate data - index 0 is unused / OSSL_COMP_CERT comp_cert[TLSEXT_comp_cert_limit]; int cert_comp_used; # endif }; /* Retrieve Suite B flags / # define tls1_suiteb(s) (s->cert->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS) / Uses to check strict mode: suite B modes are always strict / # define SSL_CERT_FLAGS_CHECK_TLS_STRICT \ (SSL_CERT_FLAG_SUITEB_128_LOS\|SSL_CERT_FLAG_TLS_STRICT) typedef enum { ENDPOINT_CLIENT = 0, ENDPOINT_SERVER, ENDPOINT_BOTH } ENDPOINT; typedef struct { unsigned short ext_type; ENDPOINT role; / The context which this extension applies to / unsigned int context; / * Per-connection flags relating to this extension type: not used if * part of an SSL_CTX structure. / uint32_t ext_flags; SSL_custom_ext_add_cb_ex add_cb; SSL_custom_ext_free_cb_ex free_cb; void add_arg; SSL_custom_ext_parse_cb_ex parse_cb; void parse_arg; } custom_ext_method; / ext_flags values / / * Indicates an extension has been received. Used to check for unsolicited or * duplicate extensions. / # define SSL_EXT_FLAG_RECEIVED 0x1 / * Indicates an extension has been sent: used to enable sending of * corresponding ServerHello extension. / # define SSL_EXT_FLAG_SENT 0x2 typedef struct { custom_ext_method meths; size_t meths_count; } custom_ext_methods; typedef struct cert_st { /* Current active set / / * ALWAYS points to an element of the pkeys array * Probably it would make more sense to store * an index, not a pointer. / CERT_PKEY key; EVP_PKEY dh_tmp; DH (dh_tmp_cb) (SSL ssl, int is_export, int keysize); int dh_tmp_auto; /* Flags related to certificates / uint32_t cert_flags; CERT_PKEY pkeys; size_t ssl_pkey_num; /* Custom certificate types sent in certificate request message. / uint8_t ctype; size_t ctype_len; /* * supported signature algorithms. When set on a client this is sent in * the client hello as the supported signature algorithms extension. For * servers it represents the signature algorithms we are willing to use. / uint16_t conf_sigalgs; /* Size of above array / size_t conf_sigalgslen; / * Client authentication signature algorithms, if not set then uses * conf_sigalgs. On servers these will be the signature algorithms sent * to the client in a certificate request for TLS 1.2. On a client this * represents the signature algorithms we are willing to use for client * authentication. / uint16_t client_sigalgs; /* Size of above array / size_t client_sigalgslen; / * Certificate setup callback: if set is called whenever a certificate * may be required (client or server). the callback can then examine any * appropriate parameters and setup any certificates required. This * allows advanced applications to select certificates on the fly: for * example based on supported signature algorithms or curves. / int (cert_cb) (SSL ssl, void arg); void cert_cb_arg; / * Optional X509_STORE for chain building or certificate validation If * NULL the parent SSL_CTX store is used instead. / X509_STORE chain_store; X509_STORE verify_store; / Custom extensions / custom_ext_methods custext; / Security callback / int (sec_cb) (const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex); /* Security level / int sec_level; void sec_ex; # ifndef OPENSSL_NO_PSK /* If not NULL psk identity hint to use for servers / char psk_identity_hint; # endif CRYPTO_REF_COUNT references; /* >1 only if SSL_copy_session_id is used / } CERT; # define FP_ICC (int ()(const void ,const void )) /* * This is for the SSLv3/TLSv1.0 differences in crypto/hash stuff It is a bit * of a mess of functions, but hell, think of it as an opaque structure :-) / typedef struct ssl3_enc_method { int (setup_key_block) (SSL_CONNECTION ); int (generate_master_secret) (SSL_CONNECTION , unsigned char , unsigned char , size_t, size_t ); int (change_cipher_state) (SSL_CONNECTION , int); size_t (final_finish_mac) (SSL_CONNECTION , const char , size_t, unsigned char ); const char client_finished_label; size_t client_finished_label_len; const char server_finished_label; size_t server_finished_label_len; int (alert_value) (int); int (export_keying_material) (SSL_CONNECTION , unsigned char , size_t, const char , size_t, const unsigned char , size_t, int use_context); /* Various flags indicating protocol version requirements / uint32_t enc_flags; / Set the handshake header / int (set_handshake_header) (SSL_CONNECTION s, WPACKET pkt, int type); /* Close construction of the handshake message / int (close_construct_packet) (SSL_CONNECTION s, WPACKET pkt, int htype); /* Write out handshake message / int (do_write) (SSL_CONNECTION s); } SSL3_ENC_METHOD; # define ssl_set_handshake_header(s, pkt, htype) \ SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->set_handshake_header((s), (pkt), (htype)) # define ssl_close_construct_packet(s, pkt, htype) \ SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->close_construct_packet((s), (pkt), (htype)) # define ssl_do_write(s) SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->do_write(s) / Values for enc_flags / / Uses explicit IV for CBC mode / # define SSL_ENC_FLAG_EXPLICIT_IV 0x1 / Uses signature algorithms extension / # define SSL_ENC_FLAG_SIGALGS 0x2 / Uses SHA256 default PRF / # define SSL_ENC_FLAG_SHA256_PRF 0x4 / Is DTLS / # define SSL_ENC_FLAG_DTLS 0x8 / * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may * apply to others in future. / # define SSL_ENC_FLAG_TLS1_2_CIPHERS 0x10 typedef enum downgrade_en { DOWNGRADE_NONE, DOWNGRADE_TO_1_2, DOWNGRADE_TO_1_1 } DOWNGRADE; / * Dummy status type for the status_type extension. Indicates no status type * set / #define TLSEXT_STATUSTYPE_nothing -1 / Sigalgs values / #define TLSEXT_SIGALG_ecdsa_secp256r1_sha256 0x0403 #define TLSEXT_SIGALG_ecdsa_secp384r1_sha384 0x0503 #define TLSEXT_SIGALG_ecdsa_secp521r1_sha512 0x0603 #define TLSEXT_SIGALG_ecdsa_sha224 0x0303 #define TLSEXT_SIGALG_ecdsa_sha1 0x0203 #define TLSEXT_SIGALG_rsa_pss_rsae_sha256 0x0804 #define TLSEXT_SIGALG_rsa_pss_rsae_sha384 0x0805 #define TLSEXT_SIGALG_rsa_pss_rsae_sha512 0x0806 #define TLSEXT_SIGALG_rsa_pss_pss_sha256 0x0809 #define TLSEXT_SIGALG_rsa_pss_pss_sha384 0x080a #define TLSEXT_SIGALG_rsa_pss_pss_sha512 0x080b #define TLSEXT_SIGALG_rsa_pkcs1_sha256 0x0401 #define TLSEXT_SIGALG_rsa_pkcs1_sha384 0x0501 #define TLSEXT_SIGALG_rsa_pkcs1_sha512 0x0601 #define TLSEXT_SIGALG_rsa_pkcs1_sha224 0x0301 #define TLSEXT_SIGALG_rsa_pkcs1_sha1 0x0201 #define TLSEXT_SIGALG_dsa_sha256 0x0402 #define TLSEXT_SIGALG_dsa_sha384 0x0502 #define TLSEXT_SIGALG_dsa_sha512 0x0602 #define TLSEXT_SIGALG_dsa_sha224 0x0302 #define TLSEXT_SIGALG_dsa_sha1 0x0202 #define TLSEXT_SIGALG_gostr34102012_256_intrinsic 0x0840 #define TLSEXT_SIGALG_gostr34102012_512_intrinsic 0x0841 #define TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256 0xeeee #define TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512 0xefef #define TLSEXT_SIGALG_gostr34102001_gostr3411 0xeded #define TLSEXT_SIGALG_ed25519 0x0807 #define TLSEXT_SIGALG_ed448 0x0808 #define TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256 0x081a #define TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384 0x081b #define TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512 0x081c / Known PSK key exchange modes / #define TLSEXT_KEX_MODE_KE 0x00 #define TLSEXT_KEX_MODE_KE_DHE 0x01 / * Internal representations of key exchange modes / #define TLSEXT_KEX_MODE_FLAG_NONE 0 #define TLSEXT_KEX_MODE_FLAG_KE 1 #define TLSEXT_KEX_MODE_FLAG_KE_DHE 2 #define SSL_USE_PSS(s) (s->s3.tmp.peer_sigalg != NULL && \ s->s3.tmp.peer_sigalg->sig == EVP_PKEY_RSA_PSS) / A dummy signature value not valid for TLSv1.2 signature algs / #define TLSEXT_signature_rsa_pss 0x0101 / TLSv1.3 downgrade protection sentinel values / extern const unsigned char tls11downgrade[8]; extern const unsigned char tls12downgrade[8]; extern SSL3_ENC_METHOD ssl3_undef_enc_method; __owur const SSL_METHOD ssl_bad_method(int ver); __owur const SSL_METHOD sslv3_method(void); __owur const SSL_METHOD sslv3_server_method(void); __owur const SSL_METHOD sslv3_client_method(void); __owur const SSL_METHOD tlsv1_method(void); __owur const SSL_METHOD tlsv1_server_method(void); __owur const SSL_METHOD tlsv1_client_method(void); __owur const SSL_METHOD tlsv1_1_method(void); __owur const SSL_METHOD tlsv1_1_server_method(void); __owur const SSL_METHOD tlsv1_1_client_method(void); __owur const SSL_METHOD tlsv1_2_method(void); __owur const SSL_METHOD tlsv1_2_server_method(void); __owur const SSL_METHOD tlsv1_2_client_method(void); __owur const SSL_METHOD tlsv1_3_method(void); __owur const SSL_METHOD tlsv1_3_server_method(void); __owur const SSL_METHOD tlsv1_3_client_method(void); __owur const SSL_METHOD dtlsv1_method(void); __owur const SSL_METHOD dtlsv1_server_method(void); __owur const SSL_METHOD dtlsv1_client_method(void); __owur const SSL_METHOD dtls_bad_ver_client_method(void); __owur const SSL_METHOD dtlsv1_2_method(void); __owur const SSL_METHOD dtlsv1_2_server_method(void); __owur const SSL_METHOD dtlsv1_2_client_method(void); extern const SSL3_ENC_METHOD TLSv1_enc_data; extern const SSL3_ENC_METHOD TLSv1_1_enc_data; extern const SSL3_ENC_METHOD TLSv1_2_enc_data; extern const SSL3_ENC_METHOD TLSv1_3_enc_data; extern const SSL3_ENC_METHOD SSLv3_enc_data; extern const SSL3_ENC_METHOD DTLSv1_enc_data; extern const SSL3_ENC_METHOD DTLSv1_2_enc_data; /* * Flags for SSL methods / # define SSL_METHOD_NO_FIPS (1U<<0) # define SSL_METHOD_NO_SUITEB (1U<<1) # define IMPLEMENT_tls_meth_func(version, flags, mask, func_name, s_accept, \ s_connect, enc_data) \ const SSL_METHOD func_name(void) \ { \ static const SSL_METHOD func_name##_data= { \ version, \ flags, \ mask, \ ossl_ssl_connection_new, \ ossl_ssl_connection_free, \ ossl_ssl_connection_reset, \ tls1_new, \ tls1_clear, \ tls1_free, \ s_accept, \ s_connect, \ ssl3_read, \ ssl3_peek, \ ssl3_write, \ ssl3_shutdown, \ ssl3_renegotiate, \ ssl3_renegotiate_check, \ ssl3_read_bytes, \ ssl3_write_bytes, \ ssl3_dispatch_alert, \ ssl3_ctrl, \ ssl3_ctx_ctrl, \ ssl3_get_cipher_by_char, \ ssl3_put_cipher_by_char, \ ssl3_pending, \ ssl3_num_ciphers, \ ssl3_get_cipher, \ tls1_default_timeout, \ &enc_data, \ ssl_undefined_void_function, \ ssl3_callback_ctrl, \ ssl3_ctx_callback_ctrl, \ }; \ return &func_name##_data; \ } # define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect) \ const SSL_METHOD func_name(void) \ { \ static const SSL_METHOD func_name##_data= { \ SSL3_VERSION, \ SSL_METHOD_NO_FIPS \| SSL_METHOD_NO_SUITEB, \ SSL_OP_NO_SSLv3, \ ossl_ssl_connection_new, \ ossl_ssl_connection_free, \ ossl_ssl_connection_reset, \ ssl3_new, \ ssl3_clear, \ ssl3_free, \ s_accept, \ s_connect, \ ssl3_read, \ ssl3_peek, \ ssl3_write, \ ssl3_shutdown, \ ssl3_renegotiate, \ ssl3_renegotiate_check, \ ssl3_read_bytes, \ ssl3_write_bytes, \ ssl3_dispatch_alert, \ ssl3_ctrl, \ ssl3_ctx_ctrl, \ ssl3_get_cipher_by_char, \ ssl3_put_cipher_by_char, \ ssl3_pending, \ ssl3_num_ciphers, \ ssl3_get_cipher, \ ssl3_default_timeout, \ &SSLv3_enc_data, \ ssl_undefined_void_function, \ ssl3_callback_ctrl, \ ssl3_ctx_callback_ctrl, \ }; \ return &func_name##_data; \ } # define IMPLEMENT_dtls1_meth_func(version, flags, mask, func_name, s_accept, \ s_connect, enc_data) \ const SSL_METHOD func_name(void) \ { \ static const SSL_METHOD func_name##_data= { \ version, \ flags, \ mask, \ ossl_ssl_connection_new, \ ossl_ssl_connection_free, \ ossl_ssl_connection_reset, \ dtls1_new, \ dtls1_clear, \ dtls1_free, \ s_accept, \ s_connect, \ ssl3_read, \ ssl3_peek, \ ssl3_write, \ dtls1_shutdown, \ ssl3_renegotiate, \ ssl3_renegotiate_check, \ dtls1_read_bytes, \ dtls1_write_app_data_bytes, \ dtls1_dispatch_alert, \ dtls1_ctrl, \ ssl3_ctx_ctrl, \ ssl3_get_cipher_by_char, \ ssl3_put_cipher_by_char, \ ssl3_pending, \ ssl3_num_ciphers, \ ssl3_get_cipher, \ dtls1_default_timeout, \ &enc_data, \ ssl_undefined_void_function, \ ssl3_callback_ctrl, \ ssl3_ctx_callback_ctrl, \ }; \ return &func_name##_data; \ } struct openssl_ssl_test_functions { int (p_ssl_init_wbio_buffer) (SSL_CONNECTION s); }; const char ssl_protocol_to_string(int version); static ossl_inline int tls12_rpk_and_privkey(const SSL_CONNECTION sc, int idx) { /* * This is to check for special cases when using RPK with just * a private key, and NO CERTIFICATE / return ((sc->server && sc->ext.server_cert_type == TLSEXT_cert_type_rpk) \|\| (!sc->server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk)) && sc->cert->pkeys[idx].privatekey != NULL && sc->cert->pkeys[idx].x509 == NULL; } static ossl_inline int ssl_has_cert_type(const SSL_CONNECTION sc, unsigned char ct) { unsigned char ptr; size_t len; if (sc->server) { ptr = sc->server_cert_type; len = sc->server_cert_type_len; } else { ptr = sc->client_cert_type; len = sc->client_cert_type_len; } if (ptr == NULL) return 0; return memchr(ptr, ct, len) != NULL; } / Returns true if certificate and private key for 'idx' are present / static ossl_inline int ssl_has_cert(const SSL_CONNECTION s, int idx) { if (idx < 0 \|\| idx >= (int)s->ssl_pkey_num) return 0; /* If RPK is enabled for this SSL... only require private key / if (ssl_has_cert_type(s, TLSEXT_cert_type_rpk)) return s->cert->pkeys[idx].privatekey != NULL; return s->cert->pkeys[idx].x509 != NULL && s->cert->pkeys[idx].privatekey != NULL; } static ossl_inline void tls1_get_peer_groups(SSL_CONNECTION s, const uint16_t *pgroups, size_t pgroupslen) { pgroups = s->ext.peer_supportedgroups; pgroupslen = s->ext.peer_supportedgroups_len; } # ifndef OPENSSL_UNIT_TEST __owur int ossl_ssl_init(SSL ssl, SSL_CTX ctx, const SSL_METHOD method, int type); __owur SSL ossl_ssl_connection_new_int(SSL_CTX ctx, const SSL_METHOD method); __owur SSL ossl_ssl_connection_new(SSL_CTX ctx); void ossl_ssl_connection_free(SSL ssl); __owur int ossl_ssl_connection_reset(SSL ssl); __owur int ssl_read_internal(SSL s, void buf, size_t num, size_t readbytes); __owur int ssl_write_internal(SSL s, const void buf, size_t num, size_t written); int ssl_clear_bad_session(SSL_CONNECTION s); __owur CERT ssl_cert_new(size_t ssl_pkey_num); __owur CERT ssl_cert_dup(CERT cert); void ssl_cert_clear_certs(CERT c); void ssl_cert_free(CERT c); __owur int ssl_generate_session_id(SSL_CONNECTION s, SSL_SESSION ss); __owur int ssl_get_new_session(SSL_CONNECTION s, int session); __owur SSL_SESSION lookup_sess_in_cache(SSL_CONNECTION s, const unsigned char sess_id, size_t sess_id_len); __owur int ssl_get_prev_session(SSL_CONNECTION s, CLIENTHELLO_MSG hello); __owur SSL_SESSION ssl_session_dup(const SSL_SESSION src, int ticket); __owur int ssl_cipher_id_cmp(const SSL_CIPHER a, const SSL_CIPHER b); DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id); __owur int ssl_cipher_ptr_id_cmp(const SSL_CIPHER const ap, const SSL_CIPHER const bp); __owur STACK_OF(SSL_CIPHER) ssl_create_cipher_list(SSL_CTX ctx, STACK_OF(SSL_CIPHER) tls13_ciphersuites, STACK_OF(SSL_CIPHER) cipher_list, STACK_OF(SSL_CIPHER) cipher_list_by_id, const char rule_str, CERT c); __owur int ssl_cache_cipherlist(SSL_CONNECTION s, PACKET cipher_suites, int sslv2format); __owur int ossl_bytes_to_cipher_list(SSL_CONNECTION s, PACKET cipher_suites, STACK_OF(SSL_CIPHER) skp, STACK_OF(SSL_CIPHER) scsvs, int sslv2format, int fatal); void ssl_update_cache(SSL_CONNECTION s, int mode); __owur int ssl_cipher_get_evp_cipher(SSL_CTX ctx, const SSL_CIPHER sslc, const EVP_CIPHER *enc); __owur int ssl_cipher_get_evp(SSL_CTX ctxc, const SSL_SESSION s, const EVP_CIPHER enc, const EVP_MD md, int mac_pkey_type, size_t mac_secret_size, SSL_COMP comp, int use_etm); __owur int ssl_cipher_get_overhead(const SSL_CIPHER c, size_t mac_overhead, size_t int_overhead, size_t blocksize, size_t ext_overhead); __owur int ssl_cert_is_disabled(SSL_CTX ctx, size_t idx); __owur const SSL_CIPHER ssl_get_cipher_by_char(SSL_CONNECTION ssl, const unsigned char ptr, int all); __owur int ssl_cert_set0_chain(SSL_CONNECTION s, SSL_CTX ctx, STACK_OF(X509) chain); __owur int ssl_cert_set1_chain(SSL_CONNECTION s, SSL_CTX ctx, STACK_OF(X509) chain); __owur int ssl_cert_add0_chain_cert(SSL_CONNECTION s, SSL_CTX ctx, X509 x); __owur int ssl_cert_add1_chain_cert(SSL_CONNECTION s, SSL_CTX ctx, X509 x); __owur int ssl_cert_select_current(CERT c, X509 x); __owur int ssl_cert_set_current(CERT c, long arg); void ssl_cert_set_cert_cb(CERT c, int (cb) (SSL ssl, void arg), void arg); __owur int ssl_verify_cert_chain(SSL_CONNECTION s, STACK_OF(X509) sk); __owur int ssl_verify_rpk(SSL_CONNECTION s, EVP_PKEY rpk); __owur int ssl_build_cert_chain(SSL_CONNECTION s, SSL_CTX ctx, int flags); __owur int ssl_cert_set_cert_store(CERT c, X509_STORE store, int chain, int ref); __owur int ssl_cert_get_cert_store(CERT c, X509_STORE pstore, int chain); __owur int ssl_security(const SSL_CONNECTION s, int op, int bits, int nid, void other); __owur int ssl_ctx_security(const SSL_CTX ctx, int op, int bits, int nid, void other); int ssl_get_security_level_bits(const SSL s, const SSL_CTX ctx, int levelp); __owur int ssl_cert_lookup_by_nid(int nid, size_t pidx, SSL_CTX ctx); __owur const SSL_CERT_LOOKUP ssl_cert_lookup_by_pkey(const EVP_PKEY pk, size_t pidx, SSL_CTX ctx); __owur const SSL_CERT_LOOKUP ssl_cert_lookup_by_idx(size_t idx, SSL_CTX ctx); int ssl_undefined_function(SSL s); __owur int ssl_undefined_void_function(void); __owur int ssl_undefined_const_function(const SSL s); __owur int ssl_get_server_cert_serverinfo(SSL_CONNECTION s, const unsigned char serverinfo, size_t serverinfo_length); void ssl_set_masks(SSL_CONNECTION s); __owur STACK_OF(SSL_CIPHER) ssl_get_ciphers_by_id(SSL_CONNECTION sc); __owur int ssl_x509err2alert(int type); void ssl_sort_cipher_list(void); int ssl_load_ciphers(SSL_CTX ctx); __owur int ssl_setup_sigalgs(SSL_CTX ctx); int ssl_load_groups(SSL_CTX ctx); int ssl_load_sigalgs(SSL_CTX ctx); __owur int ssl_fill_hello_random(SSL_CONNECTION s, int server, unsigned char field, size_t len, DOWNGRADE dgrd); __owur int ssl_generate_master_secret(SSL_CONNECTION s, unsigned char pms, size_t pmslen, int free_pms); __owur EVP_PKEY ssl_generate_pkey(SSL_CONNECTION s, EVP_PKEY pm); __owur int ssl_gensecret(SSL_CONNECTION s, unsigned char pms, size_t pmslen); __owur int ssl_derive(SSL_CONNECTION s, EVP_PKEY privkey, EVP_PKEY pubkey, int genmaster); __owur int ssl_decapsulate(SSL_CONNECTION s, EVP_PKEY privkey, const unsigned char ct, size_t ctlen, int gensecret); __owur int ssl_encapsulate(SSL_CONNECTION s, EVP_PKEY pubkey, unsigned char *ctp, size_t ctlenp, int gensecret); __owur EVP_PKEY ssl_dh_to_pkey(DH dh); __owur int ssl_set_tmp_ecdh_groups(uint16_t *pext, size_t pextlen, void key); __owur unsigned int ssl_get_max_send_fragment(const SSL_CONNECTION sc); __owur unsigned int ssl_get_split_send_fragment(const SSL_CONNECTION sc); __owur const SSL_CIPHER ssl3_get_cipher_by_id(uint32_t id); __owur const SSL_CIPHER ssl3_get_cipher_by_std_name(const char stdname); __owur const SSL_CIPHER ssl3_get_cipher_by_char(const unsigned char p); __owur int ssl3_put_cipher_by_char(const SSL_CIPHER c, WPACKET pkt, size_t len); int ssl3_init_finished_mac(SSL_CONNECTION s); __owur int ssl3_setup_key_block(SSL_CONNECTION s); __owur int ssl3_change_cipher_state(SSL_CONNECTION s, int which); void ssl3_cleanup_key_block(SSL_CONNECTION s); __owur int ssl3_do_write(SSL_CONNECTION s, uint8_t type); int ssl3_send_alert(SSL_CONNECTION s, int level, int desc); __owur int ssl3_generate_master_secret(SSL_CONNECTION s, unsigned char out, unsigned char p, size_t len, size_t secret_size); __owur int ssl3_get_req_cert_type(SSL_CONNECTION s, WPACKET pkt); __owur int ssl3_num_ciphers(void); __owur const SSL_CIPHER ssl3_get_cipher(unsigned int u); int ssl3_renegotiate(SSL ssl); int ssl3_renegotiate_check(SSL ssl, int initok); void ssl3_digest_master_key_set_params(const SSL_SESSION session, OSSL_PARAM params[]); __owur int ssl3_dispatch_alert(SSL s); __owur size_t ssl3_final_finish_mac(SSL_CONNECTION s, const char sender, size_t slen, unsigned char p); __owur int ssl3_finish_mac(SSL_CONNECTION s, const unsigned char buf, size_t len); void ssl3_free_digest_list(SSL_CONNECTION s); __owur unsigned long ssl3_output_cert_chain(SSL_CONNECTION s, WPACKET pkt, CERT_PKEY cpk, int for_comp); __owur const SSL_CIPHER ssl3_choose_cipher(SSL_CONNECTION s, STACK_OF(SSL_CIPHER) clnt, STACK_OF(SSL_CIPHER) srvr); __owur int ssl3_digest_cached_records(SSL_CONNECTION s, int keep); __owur int ssl3_new(SSL s); void ssl3_free(SSL s); __owur int ssl3_read(SSL s, void buf, size_t len, size_t readbytes); __owur int ssl3_peek(SSL s, void buf, size_t len, size_t readbytes); __owur int ssl3_write(SSL s, const void buf, size_t len, size_t written); __owur int ssl3_shutdown(SSL s); int ssl3_clear(SSL s); __owur long ssl3_ctrl(SSL s, int cmd, long larg, void parg); __owur long ssl3_ctx_ctrl(SSL_CTX s, int cmd, long larg, void parg); __owur long ssl3_callback_ctrl(SSL s, int cmd, void (fp) (void)); __owur long ssl3_ctx_callback_ctrl(SSL_CTX s, int cmd, void (fp) (void)); __owur int ssl3_do_change_cipher_spec(SSL_CONNECTION s); __owur OSSL_TIME ssl3_default_timeout(void); __owur int ssl3_set_handshake_header(SSL_CONNECTION s, WPACKET pkt, int htype); __owur int tls_close_construct_packet(SSL_CONNECTION s, WPACKET pkt, int htype); __owur int tls_setup_handshake(SSL_CONNECTION s); __owur int dtls1_set_handshake_header(SSL_CONNECTION s, WPACKET pkt, int htype); __owur int dtls1_close_construct_packet(SSL_CONNECTION s, WPACKET pkt, int htype); __owur int ssl3_handshake_write(SSL_CONNECTION s); __owur int ssl_allow_compression(SSL_CONNECTION s); __owur int ssl_version_cmp(const SSL_CONNECTION s, int versiona, int versionb); __owur int ssl_version_supported(const SSL_CONNECTION s, int version, const SSL_METHOD meth); __owur int ssl_set_client_hello_version(SSL_CONNECTION s); __owur int ssl_check_version_downgrade(SSL_CONNECTION s); __owur int ssl_set_version_bound(int method_version, int version, int bound); __owur int ssl_choose_server_version(SSL_CONNECTION s, CLIENTHELLO_MSG hello, DOWNGRADE dgrd); __owur int ssl_choose_client_version(SSL_CONNECTION s, int version, RAW_EXTENSION extensions); __owur int ssl_get_min_max_version(const SSL_CONNECTION s, int min_version, int max_version, int real_max); __owur OSSL_TIME tls1_default_timeout(void); __owur int dtls1_do_write(SSL_CONNECTION s, uint8_t type); void dtls1_set_message_header(SSL_CONNECTION s, unsigned char mt, size_t len, size_t frag_off, size_t frag_len); int dtls1_write_app_data_bytes(SSL s, uint8_t type, const void buf_, size_t len, size_t written); __owur int dtls1_read_failed(SSL_CONNECTION s, int code); __owur int dtls1_buffer_message(SSL_CONNECTION s, int ccs); __owur int dtls1_retransmit_message(SSL_CONNECTION s, unsigned short seq, int found); __owur int dtls1_get_queue_priority(unsigned short seq, int is_ccs); int dtls1_retransmit_buffered_messages(SSL_CONNECTION s); void dtls1_clear_received_buffer(SSL_CONNECTION s); void dtls1_clear_sent_buffer(SSL_CONNECTION s); void dtls1_get_message_header(const unsigned char data, struct hm_header_st msg_hdr); __owur OSSL_TIME dtls1_default_timeout(void); __owur int dtls1_get_timeout(const SSL_CONNECTION s, OSSL_TIME timeleft); __owur int dtls1_check_timeout_num(SSL_CONNECTION s); __owur int dtls1_handle_timeout(SSL_CONNECTION s); void dtls1_start_timer(SSL_CONNECTION s); void dtls1_stop_timer(SSL_CONNECTION s); __owur int dtls1_is_timer_expired(SSL_CONNECTION s); __owur int dtls_raw_hello_verify_request(WPACKET pkt, unsigned char cookie, size_t cookie_len); __owur size_t dtls1_min_mtu(SSL_CONNECTION s); void dtls1_hm_fragment_free(hm_fragment frag); __owur int dtls1_query_mtu(SSL_CONNECTION s); __owur int tls1_new(SSL s); void tls1_free(SSL s); int tls1_clear(SSL s); __owur int dtls1_new(SSL s); void dtls1_free(SSL s); int dtls1_clear(SSL s); long dtls1_ctrl(SSL s, int cmd, long larg, void parg); __owur int dtls1_shutdown(SSL s); __owur int dtls1_dispatch_alert(SSL s); __owur int ssl_init_wbio_buffer(SSL_CONNECTION s); int ssl_free_wbio_buffer(SSL_CONNECTION s); __owur int tls1_change_cipher_state(SSL_CONNECTION s, int which); __owur int tls1_setup_key_block(SSL_CONNECTION s); __owur size_t tls1_final_finish_mac(SSL_CONNECTION s, const char str, size_t slen, unsigned char p); __owur int tls1_generate_master_secret(SSL_CONNECTION s, unsigned char out, unsigned char p, size_t len, size_t secret_size); __owur int tls13_setup_key_block(SSL_CONNECTION s); __owur size_t tls13_final_finish_mac(SSL_CONNECTION s, const char str, size_t slen, unsigned char p); __owur int tls13_change_cipher_state(SSL_CONNECTION s, int which); __owur int tls13_update_key(SSL_CONNECTION s, int send); __owur int tls13_hkdf_expand(SSL_CONNECTION s, const EVP_MD md, const unsigned char secret, const unsigned char label, size_t labellen, const unsigned char data, size_t datalen, unsigned char out, size_t outlen, int fatal); __owur int tls13_hkdf_expand_ex(OSSL_LIB_CTX libctx, const char propq, const EVP_MD md, const unsigned char secret, const unsigned char label, size_t labellen, const unsigned char data, size_t datalen, unsigned char out, size_t outlen, int raise_error); __owur int tls13_derive_key(SSL_CONNECTION s, const EVP_MD md, const unsigned char secret, unsigned char key, size_t keylen); __owur int tls13_derive_iv(SSL_CONNECTION s, const EVP_MD md, const unsigned char secret, unsigned char iv, size_t ivlen); __owur int tls13_derive_finishedkey(SSL_CONNECTION s, const EVP_MD md, const unsigned char secret, unsigned char fin, size_t finlen); int tls13_generate_secret(SSL_CONNECTION s, const EVP_MD md, const unsigned char prevsecret, const unsigned char insecret, size_t insecretlen, unsigned char outsecret); __owur int tls13_generate_handshake_secret(SSL_CONNECTION s, const unsigned char insecret, size_t insecretlen); __owur int tls13_generate_master_secret(SSL_CONNECTION s, unsigned char out, unsigned char prev, size_t prevlen, size_t secret_size); __owur int tls1_export_keying_material(SSL_CONNECTION s, unsigned char out, size_t olen, const char label, size_t llen, const unsigned char p, size_t plen, int use_context); __owur int tls13_export_keying_material(SSL_CONNECTION s, unsigned char out, size_t olen, const char label, size_t llen, const unsigned char context, size_t contextlen, int use_context); __owur int tls13_export_keying_material_early(SSL_CONNECTION s, unsigned char out, size_t olen, const char label, size_t llen, const unsigned char context, size_t contextlen); __owur int tls1_alert_code(int code); __owur int tls13_alert_code(int code); __owur int ssl3_alert_code(int code); __owur int ssl_check_srvr_ecc_cert_and_alg(X509 x, SSL_CONNECTION s); SSL_COMP ssl3_comp_find(STACK_OF(SSL_COMP) sk, int n); __owur const TLS_GROUP_INFO tls1_group_id_lookup(SSL_CTX ctx, uint16_t curve_id); __owur const char tls1_group_id2name(SSL_CTX ctx, uint16_t group_id); __owur int tls1_group_id2nid(uint16_t group_id, int include_unknown); __owur uint16_t tls1_nid2group_id(int nid); __owur int tls1_check_group_id(SSL_CONNECTION s, uint16_t group_id, int check_own_curves); __owur uint16_t tls1_shared_group(SSL_CONNECTION s, int nmatch); __owur int tls1_set_groups(uint16_t *pext, size_t pextlen, int curves, size_t ncurves); __owur int tls1_set_groups_list(SSL_CTX ctx, uint16_t *pext, size_t pextlen, const char str); __owur EVP_PKEY ssl_generate_pkey_group(SSL_CONNECTION s, uint16_t id); __owur int tls_valid_group(SSL_CONNECTION s, uint16_t group_id, int minversion, int maxversion, int isec, int okfortls13); __owur EVP_PKEY ssl_generate_param_group(SSL_CONNECTION s, uint16_t id); void tls1_get_formatlist(SSL_CONNECTION s, const unsigned char *pformats, size_t num_formats); __owur int tls1_check_ec_tmp_key(SSL_CONNECTION s, unsigned long id); __owur int tls_group_allowed(SSL_CONNECTION s, uint16_t curve, int op); void tls1_get_supported_groups(SSL_CONNECTION s, const uint16_t pgroups, size_t pgroupslen); __owur int tls1_set_server_sigalgs(SSL_CONNECTION s); __owur SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION s, CLIENTHELLO_MSG hello, SSL_SESSION ret); __owur SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION s, const unsigned char etick, size_t eticklen, const unsigned char sess_id, size_t sesslen, SSL_SESSION *psess); __owur int tls_use_ticket(SSL_CONNECTION s); void ssl_set_sig_mask(uint32_t pmask_a, SSL_CONNECTION s, int op); __owur int tls1_set_sigalgs_list(CERT c, const char str, int client); __owur int tls1_set_raw_sigalgs(CERT c, const uint16_t psigs, size_t salglen, int client); __owur int tls1_set_sigalgs(CERT c, const int salg, size_t salglen, int client); int tls1_check_chain(SSL_CONNECTION s, X509 x, EVP_PKEY pk, STACK_OF(X509) chain, int idx); void tls1_set_cert_validity(SSL_CONNECTION s); # ifndef OPENSSL_NO_CT __owur int ssl_validate_ct(SSL_CONNECTION s); # endif __owur EVP_PKEY ssl_get_auto_dh(SSL_CONNECTION s); __owur int ssl_security_cert(SSL_CONNECTION s, SSL_CTX ctx, X509 x, int vfy, int is_ee); __owur int ssl_security_cert_chain(SSL_CONNECTION s, STACK_OF(X509) sk, X509 ex, int vfy); int tls_choose_sigalg(SSL_CONNECTION s, int fatalerrs); __owur long ssl_get_algorithm2(SSL_CONNECTION s); __owur int tls12_copy_sigalgs(SSL_CONNECTION s, WPACKET pkt, const uint16_t psig, size_t psiglen); __owur int tls1_save_u16(PACKET pkt, uint16_t *pdest, size_t pdestlen); __owur int tls1_save_sigalgs(SSL_CONNECTION s, PACKET pkt, int cert); __owur int tls1_process_sigalgs(SSL_CONNECTION s); __owur int tls1_set_peer_legacy_sigalg(SSL_CONNECTION s, const EVP_PKEY pkey); __owur int tls1_lookup_md(SSL_CTX ctx, const SIGALG_LOOKUP lu, const EVP_MD pmd); __owur size_t tls12_get_psigalgs(SSL_CONNECTION s, int sent, const uint16_t *psigs); __owur int tls_check_sigalg_curve(const SSL_CONNECTION s, int curve); __owur int tls12_check_peer_sigalg(SSL_CONNECTION s, uint16_t, EVP_PKEY pkey); __owur int ssl_set_client_disabled(SSL_CONNECTION s); __owur int ssl_cipher_disabled(const SSL_CONNECTION s, const SSL_CIPHER c, int op, int echde); __owur int ssl_handshake_hash(SSL_CONNECTION s, unsigned char out, size_t outlen, size_t hashlen); __owur const EVP_MD ssl_md(SSL_CTX ctx, int idx); int ssl_get_md_idx(int md_nid); __owur const EVP_MD ssl_handshake_md(SSL_CONNECTION s); __owur const EVP_MD ssl_prf_md(SSL_CONNECTION s); /* * ssl_log_rsa_client_key_exchange logs \|premaster\| to the SSL_CTX associated * with \|ssl\|, if logging is enabled. It returns one on success and zero on * failure. The entry is identified by the first 8 bytes of * \|encrypted_premaster\|. / __owur int ssl_log_rsa_client_key_exchange(SSL_CONNECTION s, const uint8_t encrypted_premaster, size_t encrypted_premaster_len, const uint8_t premaster, size_t premaster_len); /* * ssl_log_secret logs \|secret\| to the SSL_CTX associated with \|ssl\|, if * logging is available. It returns one on success and zero on failure. It tags * the entry with \|label\|. / __owur int ssl_log_secret(SSL_CONNECTION s, const char label, const uint8_t secret, size_t secret_len); #define MASTER_SECRET_LABEL "CLIENT_RANDOM" #define CLIENT_EARLY_LABEL "CLIENT_EARLY_TRAFFIC_SECRET" #define CLIENT_HANDSHAKE_LABEL "CLIENT_HANDSHAKE_TRAFFIC_SECRET" #define SERVER_HANDSHAKE_LABEL "SERVER_HANDSHAKE_TRAFFIC_SECRET" #define CLIENT_APPLICATION_LABEL "CLIENT_TRAFFIC_SECRET_0" #define CLIENT_APPLICATION_N_LABEL "CLIENT_TRAFFIC_SECRET_N" #define SERVER_APPLICATION_LABEL "SERVER_TRAFFIC_SECRET_0" #define SERVER_APPLICATION_N_LABEL "SERVER_TRAFFIC_SECRET_N" #define EARLY_EXPORTER_SECRET_LABEL "EARLY_EXPORTER_SECRET" #define EXPORTER_SECRET_LABEL "EXPORTER_SECRET" __owur int srp_generate_server_master_secret(SSL_CONNECTION s); __owur int srp_generate_client_master_secret(SSL_CONNECTION s); __owur int srp_verify_server_param(SSL_CONNECTION s); / statem/statem_srvr.c / __owur int send_certificate_request(SSL_CONNECTION s); /* statem/extensions_cust.c / custom_ext_method custom_ext_find(const custom_ext_methods exts, ENDPOINT role, unsigned int ext_type, size_t idx); void custom_ext_init(custom_ext_methods meths); int ossl_tls_add_custom_ext_intern(SSL_CTX ctx, custom_ext_methods exts, ENDPOINT role, unsigned int ext_type, unsigned int context, SSL_custom_ext_add_cb_ex add_cb, SSL_custom_ext_free_cb_ex free_cb, void add_arg, SSL_custom_ext_parse_cb_ex parse_cb, void parse_arg); __owur int custom_ext_parse(SSL_CONNECTION s, unsigned int context, unsigned int ext_type, const unsigned char ext_data, size_t ext_size, X509 x, size_t chainidx); __owur int custom_ext_add(SSL_CONNECTION s, int context, WPACKET pkt, X509 x, size_t chainidx, int maxversion); __owur int custom_exts_copy(custom_ext_methods dst, const custom_ext_methods src); __owur int custom_exts_copy_flags(custom_ext_methods dst, const custom_ext_methods src); void custom_exts_free(custom_ext_methods exts); void ssl_comp_free_compression_methods_int(void); /* ssl_mcnf.c / void ssl_ctx_system_config(SSL_CTX ctx); const EVP_CIPHER ssl_evp_cipher_fetch(OSSL_LIB_CTX libctx, int nid, const char properties); int ssl_evp_cipher_up_ref(const EVP_CIPHER cipher); void ssl_evp_cipher_free(const EVP_CIPHER cipher); const EVP_MD ssl_evp_md_fetch(OSSL_LIB_CTX libctx, int nid, const char properties); int ssl_evp_md_up_ref(const EVP_MD md); void ssl_evp_md_free(const EVP_MD md); void tls_engine_finish(ENGINE e); const EVP_CIPHER tls_get_cipher_from_engine(int nid); const EVP_MD tls_get_digest_from_engine(int nid); int tls_engine_load_ssl_client_cert(SSL_CONNECTION s, X509 px509, EVP_PKEY ppkey); int ssl_hmac_old_new(SSL_HMAC ret); void ssl_hmac_old_free(SSL_HMAC ctx); int ssl_hmac_old_init(SSL_HMAC ctx, void key, size_t len, char md); int ssl_hmac_old_update(SSL_HMAC ctx, const unsigned char data, size_t len); int ssl_hmac_old_final(SSL_HMAC ctx, unsigned char md, size_t len); size_t ssl_hmac_old_size(const SSL_HMAC ctx); int ssl_ctx_srp_ctx_free_intern(SSL_CTX ctx); int ssl_ctx_srp_ctx_init_intern(SSL_CTX ctx); int ssl_srp_ctx_free_intern(SSL_CONNECTION s); int ssl_srp_ctx_init_intern(SSL_CONNECTION s); int ssl_srp_calc_a_param_intern(SSL_CONNECTION s); int ssl_srp_server_param_with_username_intern(SSL_CONNECTION s, int ad); void ssl_session_calculate_timeout(SSL_SESSION ss); # else / OPENSSL_UNIT_TEST / # define ssl_init_wbio_buffer SSL_test_functions()->p_ssl_init_wbio_buffer # endif / Some helper routines to support TSAN operations safely / static ossl_unused ossl_inline int ssl_tsan_lock(const SSL_CTX ctx) { #ifdef TSAN_REQUIRES_LOCKING if (!CRYPTO_THREAD_write_lock(ctx->tsan_lock)) return 0; #endif return 1; } static ossl_unused ossl_inline void ssl_tsan_unlock(const SSL_CTX ctx) { #ifdef TSAN_REQUIRES_LOCKING CRYPTO_THREAD_unlock(ctx->tsan_lock); #endif } static ossl_unused ossl_inline void ssl_tsan_counter(const SSL_CTX ctx, TSAN_QUALIFIER int stat) { if (ssl_tsan_lock(ctx)) { tsan_counter(stat); ssl_tsan_unlock(ctx); } } int ossl_comp_has_alg(int a); size_t ossl_calculate_comp_expansion(int alg, size_t length); void ossl_ssl_set_custom_record_layer(SSL_CONNECTION s, const OSSL_RECORD_METHOD meth, void rlarg); long ossl_ctrl_internal(SSL s, int cmd, long larg, void parg, int no_quic); /* * Options which no longer have any effect, but which can be implemented * as no-ops for QUIC. / #define OSSL_LEGACY_SSL_OPTIONS \ (SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG \| \ SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER \| \ SSL_OP_SSLEAY_080_CLIENT_DH_BUG \| \ SSL_OP_TLS_D5_BUG \| \ SSL_OP_TLS_BLOCK_PADDING_BUG \| \ SSL_OP_MSIE_SSLV2_RSA_PADDING \| \ SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG \| \ SSL_OP_MICROSOFT_SESS_ID_BUG \| \ SSL_OP_NETSCAPE_CHALLENGE_BUG \| \ SSL_OP_PKCS1_CHECK_1 \| \ SSL_OP_PKCS1_CHECK_2 \| \ SSL_OP_SINGLE_DH_USE \| \ SSL_OP_SINGLE_ECDH_USE \| \ SSL_OP_EPHEMERAL_RSA ) / This option is undefined in public headers with no-dtls1-method. / #ifndef SSL_OP_CISCO_ANYCONNECT # define SSL_OP_CISCO_ANYCONNECT 0 #endif / * Options which are no-ops under QUIC or TLSv1.3 and which are therefore * allowed but ignored under QUIC. / #define OSSL_TLS1_2_OPTIONS \ (SSL_OP_CRYPTOPRO_TLSEXT_BUG \| \ SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS \| \ SSL_OP_ALLOW_CLIENT_RENEGOTIATION \| \ SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION \| \ SSL_OP_NO_COMPRESSION \| \ SSL_OP_NO_SSLv3 \| \ SSL_OP_NO_TLSv1 \| \ SSL_OP_NO_TLSv1_1 \| \ SSL_OP_NO_TLSv1_2 \| \ SSL_OP_NO_DTLSv1 \| \ SSL_OP_NO_DTLSv1_2 \| \ SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION \| \ SSL_OP_CISCO_ANYCONNECT \| \ SSL_OP_NO_RENEGOTIATION \| \ SSL_OP_NO_EXTENDED_MASTER_SECRET \| \ SSL_OP_NO_ENCRYPT_THEN_MAC \| \ SSL_OP_COOKIE_EXCHANGE \| \ SSL_OP_LEGACY_SERVER_CONNECT \| \ SSL_OP_IGNORE_UNEXPECTED_EOF ) / Total mask of connection-level options permitted or ignored under QUIC. / #define OSSL_QUIC_PERMITTED_OPTIONS_CONN \ (OSSL_LEGACY_SSL_OPTIONS \| \ OSSL_TLS1_2_OPTIONS \| \ SSL_OP_CIPHER_SERVER_PREFERENCE \| \ SSL_OP_DISABLE_TLSEXT_CA_NAMES \| \ SSL_OP_NO_TX_CERTIFICATE_COMPRESSION \| \ SSL_OP_NO_RX_CERTIFICATE_COMPRESSION \| \ SSL_OP_PRIORITIZE_CHACHA \| \ SSL_OP_NO_QUERY_MTU \| \ SSL_OP_NO_TICKET \| \ SSL_OP_NO_ANTI_REPLAY ) / Total mask of stream-level options permitted or ignored under QUIC. / #define OSSL_QUIC_PERMITTED_OPTIONS_STREAM \ (OSSL_LEGACY_SSL_OPTIONS \| \ OSSL_TLS1_2_OPTIONS \| \ SSL_OP_CLEANSE_PLAINTEXT ) / Total mask of options permitted on either connections or streams. */ #define OSSL_QUIC_PERMITTED_OPTIONS \ (OSSL_QUIC_PERMITTED_OPTIONS_CONN \| \ OSSL_QUIC_PERMITTED_OPTIONS_STREAM) #endif
./openssl/ssl/ssl_conf.c	/* * Copyright 2012-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include "ssl_local.h" #include <openssl/conf.h> #include <openssl/objects.h> #include <openssl/decoder.h> #include <openssl/core_dispatch.h> #include "internal/nelem.h" / * structure holding name tables. This is used for permitted elements in lists * such as TLSv1. / typedef struct { const char name; int namelen; unsigned int name_flags; uint64_t option_value; } ssl_flag_tbl; /* Switch table: use for single command line switches like no_tls2 / typedef struct { uint64_t option_value; unsigned int name_flags; } ssl_switch_tbl; / Sense of name is inverted e.g. "TLSv1" will clear SSL_OP_NO_TLSv1 / #define SSL_TFLAG_INV 0x1 / Mask for type of flag referred to / #define SSL_TFLAG_TYPE_MASK 0xf00 / Flag is for options / #define SSL_TFLAG_OPTION 0x000 / Flag is for cert_flags / #define SSL_TFLAG_CERT 0x100 / Flag is for verify mode / #define SSL_TFLAG_VFY 0x200 / Option can only be used for clients / #define SSL_TFLAG_CLIENT SSL_CONF_FLAG_CLIENT / Option can only be used for servers / #define SSL_TFLAG_SERVER SSL_CONF_FLAG_SERVER #define SSL_TFLAG_BOTH (SSL_TFLAG_CLIENT\|SSL_TFLAG_SERVER) #define SSL_FLAG_TBL(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_BOTH, flag} #define SSL_FLAG_TBL_SRV(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_SERVER, flag} #define SSL_FLAG_TBL_CLI(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_CLIENT, flag} #define SSL_FLAG_TBL_INV(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV\|SSL_TFLAG_BOTH, flag} #define SSL_FLAG_TBL_SRV_INV(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV\|SSL_TFLAG_SERVER, flag} #define SSL_FLAG_TBL_CERT(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_CERT\|SSL_TFLAG_BOTH, flag} #define SSL_FLAG_VFY_CLI(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY \| SSL_TFLAG_CLIENT, flag} #define SSL_FLAG_VFY_SRV(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY \| SSL_TFLAG_SERVER, flag} / * Opaque structure containing SSL configuration context. / struct ssl_conf_ctx_st { / * Various flags indicating (among other things) which options we will * recognise. / unsigned int flags; / Prefix and length of commands / char prefix; size_t prefixlen; /* SSL_CTX or SSL structure to perform operations on / SSL_CTX ctx; SSL ssl; / Pointer to SSL or SSL_CTX options field or NULL if none / uint64_t poptions; /* Certificate filenames for each type / char cert_filename[SSL_PKEY_NUM]; /* Pointer to SSL or SSL_CTX cert_flags or NULL if none / uint32_t pcert_flags; /* Pointer to SSL or SSL_CTX verify_mode or NULL if none / uint32_t pvfy_flags; /* Pointer to SSL or SSL_CTX min_version field or NULL if none / int min_version; /* Pointer to SSL or SSL_CTX max_version field or NULL if none / int max_version; /* Current flag table being worked on / const ssl_flag_tbl tbl; /* Size of table / size_t ntbl; / Client CA names / STACK_OF(X509_NAME) canames; }; static void ssl_set_option(SSL_CONF_CTX cctx, unsigned int name_flags, uint64_t option_value, int onoff) { uint32_t pflags; if (cctx->poptions == NULL) return; if (name_flags & SSL_TFLAG_INV) onoff ^= 1; switch (name_flags & SSL_TFLAG_TYPE_MASK) { case SSL_TFLAG_CERT: pflags = cctx->pcert_flags; break; case SSL_TFLAG_VFY: pflags = cctx->pvfy_flags; break; case SSL_TFLAG_OPTION: if (onoff) cctx->poptions \|= option_value; else cctx->poptions &= ~option_value; return; default: return; } if (onoff) pflags \|= option_value; else pflags &= ~option_value; } static int ssl_match_option(SSL_CONF_CTX cctx, const ssl_flag_tbl tbl, const char name, int namelen, int onoff) { / If name not relevant for context skip / if (!(cctx->flags & tbl->name_flags & SSL_TFLAG_BOTH)) return 0; if (namelen == -1) { if (strcmp(tbl->name, name)) return 0; } else if (tbl->namelen != namelen \|\| OPENSSL_strncasecmp(tbl->name, name, namelen)) return 0; ssl_set_option(cctx, tbl->name_flags, tbl->option_value, onoff); return 1; } static int ssl_set_option_list(const char elem, int len, void usr) { SSL_CONF_CTX cctx = usr; size_t i; const ssl_flag_tbl tbl; int onoff = 1; / * len == -1 indicates not being called in list context, just for single * command line switches, so don't allow +, -. / if (elem == NULL) return 0; if (len != -1) { if (elem == '+') { elem++; len--; onoff = 1; } else if (elem == '-') { elem++; len--; onoff = 0; } } for (i = 0, tbl = cctx->tbl; i < cctx->ntbl; i++, tbl++) { if (ssl_match_option(cctx, tbl, elem, len, onoff)) return 1; } return 0; } / Set supported signature algorithms / static int cmd_SignatureAlgorithms(SSL_CONF_CTX cctx, const char value) { int rv; if (cctx->ssl) rv = SSL_set1_sigalgs_list(cctx->ssl, value); / NB: ctx == NULL performs syntax checking only / else rv = SSL_CTX_set1_sigalgs_list(cctx->ctx, value); return rv > 0; } / Set supported client signature algorithms / static int cmd_ClientSignatureAlgorithms(SSL_CONF_CTX cctx, const char value) { int rv; if (cctx->ssl) rv = SSL_set1_client_sigalgs_list(cctx->ssl, value); / NB: ctx == NULL performs syntax checking only / else rv = SSL_CTX_set1_client_sigalgs_list(cctx->ctx, value); return rv > 0; } static int cmd_Groups(SSL_CONF_CTX cctx, const char value) { int rv; if (cctx->ssl) rv = SSL_set1_groups_list(cctx->ssl, value); / NB: ctx == NULL performs syntax checking only / else rv = SSL_CTX_set1_groups_list(cctx->ctx, value); return rv > 0; } / This is the old name for cmd_Groups - retained for backwards compatibility / static int cmd_Curves(SSL_CONF_CTX cctx, const char value) { return cmd_Groups(cctx, value); } / ECDH temporary parameters / static int cmd_ECDHParameters(SSL_CONF_CTX cctx, const char value) { int rv = 1; / Ignore values supported by 1.0.2 for the automatic selection / if ((cctx->flags & SSL_CONF_FLAG_FILE) && (OPENSSL_strcasecmp(value, "+automatic") == 0 \|\| OPENSSL_strcasecmp(value, "automatic") == 0)) return 1; if ((cctx->flags & SSL_CONF_FLAG_CMDLINE) && strcmp(value, "auto") == 0) return 1; / ECDHParameters accepts a single group name / if (strstr(value, ":") != NULL) return 0; if (cctx->ctx) rv = SSL_CTX_set1_groups_list(cctx->ctx, value); else if (cctx->ssl) rv = SSL_set1_groups_list(cctx->ssl, value); return rv > 0; } static int cmd_CipherString(SSL_CONF_CTX cctx, const char value) { int rv = 1; if (cctx->ctx) rv = SSL_CTX_set_cipher_list(cctx->ctx, value); if (cctx->ssl) rv = SSL_set_cipher_list(cctx->ssl, value); return rv > 0; } static int cmd_Ciphersuites(SSL_CONF_CTX cctx, const char value) { int rv = 1; if (cctx->ctx) rv = SSL_CTX_set_ciphersuites(cctx->ctx, value); if (cctx->ssl) rv = SSL_set_ciphersuites(cctx->ssl, value); return rv > 0; } static int cmd_Protocol(SSL_CONF_CTX cctx, const char value) { static const ssl_flag_tbl ssl_protocol_list[] = { SSL_FLAG_TBL_INV("ALL", SSL_OP_NO_SSL_MASK), SSL_FLAG_TBL_INV("SSLv2", SSL_OP_NO_SSLv2), SSL_FLAG_TBL_INV("SSLv3", SSL_OP_NO_SSLv3), SSL_FLAG_TBL_INV("TLSv1", SSL_OP_NO_TLSv1), SSL_FLAG_TBL_INV("TLSv1.1", SSL_OP_NO_TLSv1_1), SSL_FLAG_TBL_INV("TLSv1.2", SSL_OP_NO_TLSv1_2), SSL_FLAG_TBL_INV("TLSv1.3", SSL_OP_NO_TLSv1_3), SSL_FLAG_TBL_INV("DTLSv1", SSL_OP_NO_DTLSv1), SSL_FLAG_TBL_INV("DTLSv1.2", SSL_OP_NO_DTLSv1_2) }; cctx->tbl = ssl_protocol_list; cctx->ntbl = OSSL_NELEM(ssl_protocol_list); return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx); } / * protocol_from_string - converts a protocol version string to a number * * Returns -1 on failure or the version on success / static int protocol_from_string(const char value) { struct protocol_versions { const char name; int version; }; / * Note: To avoid breaking previously valid configurations, we must retain * legacy entries in this table even if the underlying protocol is no * longer supported. This also means that the constants SSL3_VERSION, ... * need to be retained indefinitely. This table can only grow, never * shrink. / static const struct protocol_versions versions[] = { {"None", 0}, {"SSLv3", SSL3_VERSION}, {"TLSv1", TLS1_VERSION}, {"TLSv1.1", TLS1_1_VERSION}, {"TLSv1.2", TLS1_2_VERSION}, {"TLSv1.3", TLS1_3_VERSION}, {"DTLSv1", DTLS1_VERSION}, {"DTLSv1.2", DTLS1_2_VERSION} }; size_t i; size_t n = OSSL_NELEM(versions); for (i = 0; i < n; i++) if (strcmp(versions[i].name, value) == 0) return versions[i].version; return -1; } static int min_max_proto(SSL_CONF_CTX cctx, const char value, int bound) { int method_version; int new_version; if (cctx->ctx != NULL) method_version = cctx->ctx->method->version; else if (cctx->ssl != NULL) method_version = cctx->ssl->defltmeth->version; else return 0; if ((new_version = protocol_from_string(value)) < 0) return 0; return ssl_set_version_bound(method_version, new_version, bound); } /* * cmd_MinProtocol - Set min protocol version * @cctx: config structure to save settings in * @value: The min protocol version in string form * * Returns 1 on success and 0 on failure. / static int cmd_MinProtocol(SSL_CONF_CTX cctx, const char value) { return min_max_proto(cctx, value, cctx->min_version); } / * cmd_MaxProtocol - Set max protocol version * @cctx: config structure to save settings in * @value: The max protocol version in string form * * Returns 1 on success and 0 on failure. / static int cmd_MaxProtocol(SSL_CONF_CTX cctx, const char value) { return min_max_proto(cctx, value, cctx->max_version); } static int cmd_Options(SSL_CONF_CTX cctx, const char value) { static const ssl_flag_tbl ssl_option_list[] = { SSL_FLAG_TBL_INV("SessionTicket", SSL_OP_NO_TICKET), SSL_FLAG_TBL_INV("EmptyFragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS), SSL_FLAG_TBL("Bugs", SSL_OP_ALL), SSL_FLAG_TBL_INV("Compression", SSL_OP_NO_COMPRESSION), SSL_FLAG_TBL_SRV("ServerPreference", SSL_OP_CIPHER_SERVER_PREFERENCE), SSL_FLAG_TBL_SRV("NoResumptionOnRenegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION), SSL_FLAG_TBL_SRV("DHSingle", SSL_OP_SINGLE_DH_USE), SSL_FLAG_TBL_SRV("ECDHSingle", SSL_OP_SINGLE_ECDH_USE), SSL_FLAG_TBL("UnsafeLegacyRenegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION), SSL_FLAG_TBL("UnsafeLegacyServerConnect", SSL_OP_LEGACY_SERVER_CONNECT), SSL_FLAG_TBL("ClientRenegotiation", SSL_OP_ALLOW_CLIENT_RENEGOTIATION), SSL_FLAG_TBL_INV("EncryptThenMac", SSL_OP_NO_ENCRYPT_THEN_MAC), SSL_FLAG_TBL("NoRenegotiation", SSL_OP_NO_RENEGOTIATION), SSL_FLAG_TBL("AllowNoDHEKEX", SSL_OP_ALLOW_NO_DHE_KEX), SSL_FLAG_TBL("PreferNoDHEKEX", SSL_OP_PREFER_NO_DHE_KEX), SSL_FLAG_TBL("PrioritizeChaCha", SSL_OP_PRIORITIZE_CHACHA), SSL_FLAG_TBL("MiddleboxCompat", SSL_OP_ENABLE_MIDDLEBOX_COMPAT), SSL_FLAG_TBL_INV("AntiReplay", SSL_OP_NO_ANTI_REPLAY), SSL_FLAG_TBL_INV("ExtendedMasterSecret", SSL_OP_NO_EXTENDED_MASTER_SECRET), SSL_FLAG_TBL_INV("CANames", SSL_OP_DISABLE_TLSEXT_CA_NAMES), SSL_FLAG_TBL("KTLS", SSL_OP_ENABLE_KTLS), SSL_FLAG_TBL_CERT("StrictCertCheck", SSL_CERT_FLAG_TLS_STRICT), SSL_FLAG_TBL_INV("TxCertificateCompression", SSL_OP_NO_TX_CERTIFICATE_COMPRESSION), SSL_FLAG_TBL_INV("RxCertificateCompression", SSL_OP_NO_RX_CERTIFICATE_COMPRESSION), SSL_FLAG_TBL("KTLSTxZerocopySendfile", SSL_OP_ENABLE_KTLS_TX_ZEROCOPY_SENDFILE), SSL_FLAG_TBL("IgnoreUnexpectedEOF", SSL_OP_IGNORE_UNEXPECTED_EOF), }; if (value == NULL) return -3; cctx->tbl = ssl_option_list; cctx->ntbl = OSSL_NELEM(ssl_option_list); return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx); } static int cmd_VerifyMode(SSL_CONF_CTX cctx, const char value) { static const ssl_flag_tbl ssl_vfy_list[] = { SSL_FLAG_VFY_CLI("Peer", SSL_VERIFY_PEER), SSL_FLAG_VFY_SRV("Request", SSL_VERIFY_PEER), SSL_FLAG_VFY_SRV("Require", SSL_VERIFY_PEER \| SSL_VERIFY_FAIL_IF_NO_PEER_CERT), SSL_FLAG_VFY_SRV("Once", SSL_VERIFY_PEER \| SSL_VERIFY_CLIENT_ONCE), SSL_FLAG_VFY_SRV("RequestPostHandshake", SSL_VERIFY_PEER \| SSL_VERIFY_POST_HANDSHAKE), SSL_FLAG_VFY_SRV("RequirePostHandshake", SSL_VERIFY_PEER \| SSL_VERIFY_POST_HANDSHAKE \| SSL_VERIFY_FAIL_IF_NO_PEER_CERT), }; if (value == NULL) return -3; cctx->tbl = ssl_vfy_list; cctx->ntbl = OSSL_NELEM(ssl_vfy_list); return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx); } static int cmd_Certificate(SSL_CONF_CTX cctx, const char value) { int rv = 1; CERT c = NULL; if (cctx->ctx != NULL) { rv = SSL_CTX_use_certificate_chain_file(cctx->ctx, value); c = cctx->ctx->cert; } if (cctx->ssl != NULL) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(cctx->ssl); if (sc != NULL) { rv = SSL_use_certificate_chain_file(cctx->ssl, value); c = sc->cert; } else { rv = 0; } } if (rv > 0 && c != NULL && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) { char pfilename = &cctx->cert_filename[c->key - c->pkeys]; OPENSSL_free(pfilename); pfilename = OPENSSL_strdup(value); if (pfilename == NULL) rv = 0; } return rv > 0; } static int cmd_PrivateKey(SSL_CONF_CTX cctx, const char value) { int rv = 1; if (!(cctx->flags & SSL_CONF_FLAG_CERTIFICATE)) return -2; if (cctx->ctx) rv = SSL_CTX_use_PrivateKey_file(cctx->ctx, value, SSL_FILETYPE_PEM); if (cctx->ssl) rv = SSL_use_PrivateKey_file(cctx->ssl, value, SSL_FILETYPE_PEM); return rv > 0; } static int cmd_ServerInfoFile(SSL_CONF_CTX cctx, const char value) { int rv = 1; if (cctx->ctx) rv = SSL_CTX_use_serverinfo_file(cctx->ctx, value); return rv > 0; } static int do_store(SSL_CONF_CTX cctx, const char CAfile, const char CApath, const char CAstore, int verify_store) { CERT cert; X509_STORE st; SSL_CTX ctx; OSSL_LIB_CTX libctx = NULL; const char propq = NULL; if (cctx->ctx != NULL) { cert = cctx->ctx->cert; ctx = cctx->ctx; } else if (cctx->ssl != NULL) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(cctx->ssl); if (sc == NULL) return 0; cert = sc->cert; ctx = cctx->ssl->ctx; } else { return 1; } if (ctx != NULL) { libctx = ctx->libctx; propq = ctx->propq; } st = verify_store ? &cert->verify_store : &cert->chain_store; if (st == NULL) { st = X509_STORE_new(); if (st == NULL) return 0; } if (CAfile != NULL && !X509_STORE_load_file_ex(st, CAfile, libctx, propq)) return 0; if (CApath != NULL && !X509_STORE_load_path(st, CApath)) return 0; if (CAstore != NULL && !X509_STORE_load_store_ex(st, CAstore, libctx, propq)) return 0; return 1; } static int cmd_ChainCAPath(SSL_CONF_CTX cctx, const char value) { return do_store(cctx, NULL, value, NULL, 0); } static int cmd_ChainCAFile(SSL_CONF_CTX cctx, const char value) { return do_store(cctx, value, NULL, NULL, 0); } static int cmd_ChainCAStore(SSL_CONF_CTX cctx, const char value) { return do_store(cctx, NULL, NULL, value, 0); } static int cmd_VerifyCAPath(SSL_CONF_CTX cctx, const char value) { return do_store(cctx, NULL, value, NULL, 1); } static int cmd_VerifyCAFile(SSL_CONF_CTX cctx, const char value) { return do_store(cctx, value, NULL, NULL, 1); } static int cmd_VerifyCAStore(SSL_CONF_CTX cctx, const char value) { return do_store(cctx, NULL, NULL, value, 1); } static int cmd_RequestCAFile(SSL_CONF_CTX cctx, const char value) { if (cctx->canames == NULL) cctx->canames = sk_X509_NAME_new_null(); if (cctx->canames == NULL) return 0; return SSL_add_file_cert_subjects_to_stack(cctx->canames, value); } static int cmd_ClientCAFile(SSL_CONF_CTX cctx, const char value) { return cmd_RequestCAFile(cctx, value); } static int cmd_RequestCAPath(SSL_CONF_CTX cctx, const char value) { if (cctx->canames == NULL) cctx->canames = sk_X509_NAME_new_null(); if (cctx->canames == NULL) return 0; return SSL_add_dir_cert_subjects_to_stack(cctx->canames, value); } static int cmd_ClientCAPath(SSL_CONF_CTX cctx, const char value) { return cmd_RequestCAPath(cctx, value); } static int cmd_RequestCAStore(SSL_CONF_CTX cctx, const char value) { if (cctx->canames == NULL) cctx->canames = sk_X509_NAME_new_null(); if (cctx->canames == NULL) return 0; return SSL_add_store_cert_subjects_to_stack(cctx->canames, value); } static int cmd_ClientCAStore(SSL_CONF_CTX cctx, const char value) { return cmd_RequestCAStore(cctx, value); } static int cmd_DHParameters(SSL_CONF_CTX cctx, const char value) { int rv = 0; EVP_PKEY dhpkey = NULL; BIO in = NULL; SSL_CTX sslctx = (cctx->ssl != NULL) ? cctx->ssl->ctx : cctx->ctx; OSSL_DECODER_CTX decoderctx = NULL; if (cctx->ctx != NULL \|\| cctx->ssl != NULL) { in = BIO_new(BIO_s_file()); if (in == NULL) goto end; if (BIO_read_filename(in, value) <= 0) goto end; decoderctx = OSSL_DECODER_CTX_new_for_pkey(&dhpkey, "PEM", NULL, "DH", OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS, sslctx->libctx, sslctx->propq); if (decoderctx == NULL) goto end; ERR_set_mark(); while (!OSSL_DECODER_from_bio(decoderctx, in) && dhpkey == NULL && !BIO_eof(in)); OSSL_DECODER_CTX_free(decoderctx); if (dhpkey == NULL) { ERR_clear_last_mark(); goto end; } ERR_pop_to_mark(); } else { return 1; } if (cctx->ctx != NULL) { if ((rv = SSL_CTX_set0_tmp_dh_pkey(cctx->ctx, dhpkey)) > 0) dhpkey = NULL; } if (cctx->ssl != NULL) { if ((rv = SSL_set0_tmp_dh_pkey(cctx->ssl, dhpkey)) > 0) dhpkey = NULL; } end: EVP_PKEY_free(dhpkey); BIO_free(in); return rv > 0; } static int cmd_RecordPadding(SSL_CONF_CTX cctx, const char value) { int rv = 0; int block_size = atoi(value); / * All we care about is a non-negative value, * the setters check the range / if (block_size >= 0) { if (cctx->ctx) rv = SSL_CTX_set_block_padding(cctx->ctx, block_size); if (cctx->ssl) rv = SSL_set_block_padding(cctx->ssl, block_size); } return rv; } static int cmd_NumTickets(SSL_CONF_CTX cctx, const char value) { int rv = 0; int num_tickets = atoi(value); if (num_tickets >= 0) { if (cctx->ctx) rv = SSL_CTX_set_num_tickets(cctx->ctx, num_tickets); if (cctx->ssl) rv = SSL_set_num_tickets(cctx->ssl, num_tickets); } return rv; } typedef struct { int (cmd) (SSL_CONF_CTX cctx, const char value); const char str_file; const char str_cmdline; unsigned short flags; unsigned short value_type; } ssl_conf_cmd_tbl; /* Table of supported parameters / #define SSL_CONF_CMD(name, cmdopt, flags, type) \ {cmd_##name, #name, cmdopt, flags, type} #define SSL_CONF_CMD_STRING(name, cmdopt, flags) \ SSL_CONF_CMD(name, cmdopt, flags, SSL_CONF_TYPE_STRING) #define SSL_CONF_CMD_SWITCH(name, flags) \ {0, NULL, name, flags, SSL_CONF_TYPE_NONE} / See apps/include/opt.h if you change this table. / / The SSL_CONF_CMD_SWITCH should be the same order as ssl_cmd_switches / static const ssl_conf_cmd_tbl ssl_conf_cmds[] = { SSL_CONF_CMD_SWITCH("no_ssl3", 0), SSL_CONF_CMD_SWITCH("no_tls1", 0), SSL_CONF_CMD_SWITCH("no_tls1_1", 0), SSL_CONF_CMD_SWITCH("no_tls1_2", 0), SSL_CONF_CMD_SWITCH("no_tls1_3", 0), SSL_CONF_CMD_SWITCH("bugs", 0), SSL_CONF_CMD_SWITCH("no_comp", 0), SSL_CONF_CMD_SWITCH("comp", 0), SSL_CONF_CMD_SWITCH("no_tx_cert_comp", 0), SSL_CONF_CMD_SWITCH("tx_cert_comp", 0), SSL_CONF_CMD_SWITCH("no_rx_cert_comp", 0), SSL_CONF_CMD_SWITCH("rx_cert_comp", 0), SSL_CONF_CMD_SWITCH("ecdh_single", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("no_ticket", 0), SSL_CONF_CMD_SWITCH("serverpref", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("legacy_renegotiation", 0), SSL_CONF_CMD_SWITCH("client_renegotiation", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("legacy_server_connect", SSL_CONF_FLAG_CLIENT), SSL_CONF_CMD_SWITCH("no_renegotiation", 0), SSL_CONF_CMD_SWITCH("no_resumption_on_reneg", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("no_legacy_server_connect", SSL_CONF_FLAG_CLIENT), SSL_CONF_CMD_SWITCH("allow_no_dhe_kex", 0), SSL_CONF_CMD_SWITCH("prefer_no_dhe_kex", 0), SSL_CONF_CMD_SWITCH("prioritize_chacha", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("strict", 0), SSL_CONF_CMD_SWITCH("no_middlebox", 0), SSL_CONF_CMD_SWITCH("anti_replay", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("no_anti_replay", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("no_etm", 0), SSL_CONF_CMD_SWITCH("no_ems", 0), SSL_CONF_CMD_STRING(SignatureAlgorithms, "sigalgs", 0), SSL_CONF_CMD_STRING(ClientSignatureAlgorithms, "client_sigalgs", 0), SSL_CONF_CMD_STRING(Curves, "curves", 0), SSL_CONF_CMD_STRING(Groups, "groups", 0), SSL_CONF_CMD_STRING(ECDHParameters, "named_curve", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_STRING(CipherString, "cipher", 0), SSL_CONF_CMD_STRING(Ciphersuites, "ciphersuites", 0), SSL_CONF_CMD_STRING(Protocol, NULL, 0), SSL_CONF_CMD_STRING(MinProtocol, "min_protocol", 0), SSL_CONF_CMD_STRING(MaxProtocol, "max_protocol", 0), SSL_CONF_CMD_STRING(Options, NULL, 0), SSL_CONF_CMD_STRING(VerifyMode, NULL, 0), SSL_CONF_CMD(Certificate, "cert", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(PrivateKey, "key", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(ServerInfoFile, NULL, SSL_CONF_FLAG_SERVER \| SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(ChainCAPath, "chainCApath", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_DIR), SSL_CONF_CMD(ChainCAFile, "chainCAfile", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(ChainCAStore, "chainCAstore", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_STORE), SSL_CONF_CMD(VerifyCAPath, "verifyCApath", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_DIR), SSL_CONF_CMD(VerifyCAFile, "verifyCAfile", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(VerifyCAStore, "verifyCAstore", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_STORE), SSL_CONF_CMD(RequestCAFile, "requestCAFile", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(ClientCAFile, NULL, SSL_CONF_FLAG_SERVER \| SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(RequestCAPath, NULL, SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_DIR), SSL_CONF_CMD(ClientCAPath, NULL, SSL_CONF_FLAG_SERVER \| SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_DIR), SSL_CONF_CMD(RequestCAStore, "requestCAStore", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_STORE), SSL_CONF_CMD(ClientCAStore, NULL, SSL_CONF_FLAG_SERVER \| SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_STORE), SSL_CONF_CMD(DHParameters, "dhparam", SSL_CONF_FLAG_SERVER \| SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD_STRING(RecordPadding, "record_padding", 0), SSL_CONF_CMD_STRING(NumTickets, "num_tickets", SSL_CONF_FLAG_SERVER), }; / Supported switches: must match order of switches in ssl_conf_cmds / static const ssl_switch_tbl ssl_cmd_switches[] = { {SSL_OP_NO_SSLv3, 0}, / no_ssl3 / {SSL_OP_NO_TLSv1, 0}, / no_tls1 / {SSL_OP_NO_TLSv1_1, 0}, / no_tls1_1 / {SSL_OP_NO_TLSv1_2, 0}, / no_tls1_2 / {SSL_OP_NO_TLSv1_3, 0}, / no_tls1_3 / {SSL_OP_ALL, 0}, / bugs / {SSL_OP_NO_COMPRESSION, 0}, / no_comp / {SSL_OP_NO_COMPRESSION, SSL_TFLAG_INV}, / comp / {SSL_OP_NO_TX_CERTIFICATE_COMPRESSION, 0}, / no_tx_cert_comp / {SSL_OP_NO_TX_CERTIFICATE_COMPRESSION, SSL_TFLAG_INV}, / tx_cert_comp / {SSL_OP_NO_RX_CERTIFICATE_COMPRESSION, 0}, / no_rx_cert_comp / {SSL_OP_NO_RX_CERTIFICATE_COMPRESSION, SSL_TFLAG_INV}, / rx_cert_comp / {SSL_OP_SINGLE_ECDH_USE, 0}, / ecdh_single / {SSL_OP_NO_TICKET, 0}, / no_ticket / {SSL_OP_CIPHER_SERVER_PREFERENCE, 0}, / serverpref / / legacy_renegotiation / {SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, 0}, / Allow client renegotiation / {SSL_OP_ALLOW_CLIENT_RENEGOTIATION, 0}, / legacy_server_connect / {SSL_OP_LEGACY_SERVER_CONNECT, 0}, / no_renegotiation / {SSL_OP_NO_RENEGOTIATION, 0}, / no_resumption_on_reneg / {SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, 0}, / no_legacy_server_connect / {SSL_OP_LEGACY_SERVER_CONNECT, SSL_TFLAG_INV}, / allow_no_dhe_kex / {SSL_OP_ALLOW_NO_DHE_KEX, 0}, / prefer_no_dhe_kex / {SSL_OP_PREFER_NO_DHE_KEX, 0}, / chacha reprioritization / {SSL_OP_PRIORITIZE_CHACHA, 0}, {SSL_CERT_FLAG_TLS_STRICT, SSL_TFLAG_CERT}, / strict / / no_middlebox / {SSL_OP_ENABLE_MIDDLEBOX_COMPAT, SSL_TFLAG_INV}, / anti_replay / {SSL_OP_NO_ANTI_REPLAY, SSL_TFLAG_INV}, / no_anti_replay / {SSL_OP_NO_ANTI_REPLAY, 0}, / no Encrypt-then-Mac / {SSL_OP_NO_ENCRYPT_THEN_MAC, 0}, / no Extended master secret / {SSL_OP_NO_EXTENDED_MASTER_SECRET, 0}, }; static int ssl_conf_cmd_skip_prefix(SSL_CONF_CTX cctx, const char *pcmd) { if (pcmd == NULL \|\| pcmd == NULL) return 0; /* If a prefix is set, check and skip / if (cctx->prefix) { if (strlen(pcmd) <= cctx->prefixlen) return 0; if (cctx->flags & SSL_CONF_FLAG_CMDLINE && strncmp(pcmd, cctx->prefix, cctx->prefixlen)) return 0; if (cctx->flags & SSL_CONF_FLAG_FILE && OPENSSL_strncasecmp(pcmd, cctx->prefix, cctx->prefixlen)) return 0; pcmd += cctx->prefixlen; } else if (cctx->flags & SSL_CONF_FLAG_CMDLINE) { if (pcmd != '-' \|\| !(pcmd)[1]) return 0; pcmd += 1; } return 1; } / Determine if a command is allowed according to cctx flags / static int ssl_conf_cmd_allowed(SSL_CONF_CTX cctx, const ssl_conf_cmd_tbl t) { unsigned int tfl = t->flags; unsigned int cfl = cctx->flags; if ((tfl & SSL_CONF_FLAG_SERVER) && !(cfl & SSL_CONF_FLAG_SERVER)) return 0; if ((tfl & SSL_CONF_FLAG_CLIENT) && !(cfl & SSL_CONF_FLAG_CLIENT)) return 0; if ((tfl & SSL_CONF_FLAG_CERTIFICATE) && !(cfl & SSL_CONF_FLAG_CERTIFICATE)) return 0; return 1; } static const ssl_conf_cmd_tbl ssl_conf_cmd_lookup(SSL_CONF_CTX cctx, const char cmd) { const ssl_conf_cmd_tbl t; size_t i; if (cmd == NULL) return NULL; / Look for matching parameter name in table / for (i = 0, t = ssl_conf_cmds; i < OSSL_NELEM(ssl_conf_cmds); i++, t++) { if (ssl_conf_cmd_allowed(cctx, t)) { if (cctx->flags & SSL_CONF_FLAG_CMDLINE) { if (t->str_cmdline && strcmp(t->str_cmdline, cmd) == 0) return t; } if (cctx->flags & SSL_CONF_FLAG_FILE) { if (t->str_file && OPENSSL_strcasecmp(t->str_file, cmd) == 0) return t; } } } return NULL; } static int ctrl_switch_option(SSL_CONF_CTX cctx, const ssl_conf_cmd_tbl cmd) { / Find index of command in table / size_t idx = cmd - ssl_conf_cmds; const ssl_switch_tbl scmd; /* Sanity check index / if (idx >= OSSL_NELEM(ssl_cmd_switches)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } / Obtain switches entry with same index / scmd = ssl_cmd_switches + idx; ssl_set_option(cctx, scmd->name_flags, scmd->option_value, 1); return 1; } int SSL_CONF_cmd(SSL_CONF_CTX cctx, const char cmd, const char value) { const ssl_conf_cmd_tbl runcmd; if (cmd == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_NULL_CMD_NAME); return 0; } if (!ssl_conf_cmd_skip_prefix(cctx, &cmd)) goto unknown_cmd; runcmd = ssl_conf_cmd_lookup(cctx, cmd); if (runcmd) { int rv = -3; if (runcmd->value_type == SSL_CONF_TYPE_NONE) { return ctrl_switch_option(cctx, runcmd); } if (value == NULL) goto bad_value; rv = runcmd->cmd(cctx, value); if (rv > 0) return 2; if (rv != -2) rv = 0; bad_value: if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS) ERR_raise_data(ERR_LIB_SSL, SSL_R_BAD_VALUE, "cmd=%s, value=%s", cmd, value != NULL ? value : "<EMPTY>"); return rv; } unknown_cmd: if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS) ERR_raise_data(ERR_LIB_SSL, SSL_R_UNKNOWN_CMD_NAME, "cmd=%s", cmd); return -2; } int SSL_CONF_cmd_argv(SSL_CONF_CTX cctx, int pargc, char *pargv) { int rv; const char arg = NULL, argn; if (pargc != NULL && pargc == 0) return 0; if (pargc == NULL \|\| pargc > 0) arg = pargv; if (arg == NULL) return 0; if (pargc == NULL \|\| pargc > 1) argn = (pargv)[1]; else argn = NULL; cctx->flags &= ~SSL_CONF_FLAG_FILE; cctx->flags \|= SSL_CONF_FLAG_CMDLINE; rv = SSL_CONF_cmd(cctx, arg, argn); if (rv > 0) { / Success: update pargc, pargv / (pargv) += rv; if (pargc) (pargc) -= rv; return rv; } / Unknown switch: indicate no arguments processed / if (rv == -2) return 0; / Some error occurred processing command, return fatal error / if (rv == 0) return -1; return rv; } int SSL_CONF_cmd_value_type(SSL_CONF_CTX cctx, const char cmd) { if (ssl_conf_cmd_skip_prefix(cctx, &cmd)) { const ssl_conf_cmd_tbl runcmd; runcmd = ssl_conf_cmd_lookup(cctx, cmd); if (runcmd) return runcmd->value_type; } return SSL_CONF_TYPE_UNKNOWN; } SSL_CONF_CTX SSL_CONF_CTX_new(void) { SSL_CONF_CTX ret = OPENSSL_zalloc(sizeof(ret)); return ret; } int SSL_CONF_CTX_finish(SSL_CONF_CTX cctx) { /* See if any certificates are missing private keys / size_t i; CERT c = NULL; if (cctx->ctx != NULL) { c = cctx->ctx->cert; } else if (cctx->ssl != NULL) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(cctx->ssl); if (sc != NULL) c = sc->cert; } if (c != NULL && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) { for (i = 0; i < SSL_PKEY_NUM; i++) { const char p = cctx->cert_filename[i]; /* * If missing private key try to load one from certificate file / if (p && !c->pkeys[i].privatekey) { if (!cmd_PrivateKey(cctx, p)) return 0; } } } if (cctx->canames) { if (cctx->ssl) SSL_set0_CA_list(cctx->ssl, cctx->canames); else if (cctx->ctx) SSL_CTX_set0_CA_list(cctx->ctx, cctx->canames); else sk_X509_NAME_pop_free(cctx->canames, X509_NAME_free); cctx->canames = NULL; } return 1; } void SSL_CONF_CTX_free(SSL_CONF_CTX cctx) { if (cctx) { size_t i; for (i = 0; i < SSL_PKEY_NUM; i++) OPENSSL_free(cctx->cert_filename[i]); OPENSSL_free(cctx->prefix); sk_X509_NAME_pop_free(cctx->canames, X509_NAME_free); OPENSSL_free(cctx); } } unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX cctx, unsigned int flags) { cctx->flags \|= flags; return cctx->flags; } unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX cctx, unsigned int flags) { cctx->flags &= ~flags; return cctx->flags; } int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX cctx, const char pre) { char tmp = NULL; if (pre) { tmp = OPENSSL_strdup(pre); if (tmp == NULL) return 0; } OPENSSL_free(cctx->prefix); cctx->prefix = tmp; if (tmp) cctx->prefixlen = strlen(tmp); else cctx->prefixlen = 0; return 1; } void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX cctx, SSL ssl) { cctx->ssl = ssl; cctx->ctx = NULL; if (ssl != NULL) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return; cctx->poptions = &sc->options; cctx->min_version = &sc->min_proto_version; cctx->max_version = &sc->max_proto_version; cctx->pcert_flags = &sc->cert->cert_flags; cctx->pvfy_flags = &sc->verify_mode; } else { cctx->poptions = NULL; cctx->min_version = NULL; cctx->max_version = NULL; cctx->pcert_flags = NULL; cctx->pvfy_flags = NULL; } } void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX cctx, SSL_CTX ctx) { cctx->ctx = ctx; cctx->ssl = NULL; if (ctx) { cctx->poptions = &ctx->options; cctx->min_version = &ctx->min_proto_version; cctx->max_version = &ctx->max_proto_version; cctx->pcert_flags = &ctx->cert->cert_flags; cctx->pvfy_flags = &ctx->verify_mode; } else { cctx->poptions = NULL; cctx->min_version = NULL; cctx->max_version = NULL; cctx->pcert_flags = NULL; cctx->pvfy_flags = NULL; } }
./openssl/ssl/methods.c	/* * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <openssl/macros.h> #include <openssl/objects.h> #include "ssl_local.h" /- * TLS/SSLv3 methods / IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0, TLS_method, ossl_statem_accept, ossl_statem_connect, TLSv1_2_enc_data) IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3, tlsv1_3_method, ossl_statem_accept, ossl_statem_connect, TLSv1_3_enc_data) #ifndef OPENSSL_NO_TLS1_2_METHOD IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2, tlsv1_2_method, ossl_statem_accept, ossl_statem_connect, TLSv1_2_enc_data) #endif #ifndef OPENSSL_NO_TLS1_1_METHOD IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1, tlsv1_1_method, ossl_statem_accept, ossl_statem_connect, TLSv1_1_enc_data) #endif #ifndef OPENSSL_NO_TLS1_METHOD IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1, tlsv1_method, ossl_statem_accept, ossl_statem_connect, TLSv1_enc_data) #endif #ifndef OPENSSL_NO_SSL3_METHOD IMPLEMENT_ssl3_meth_func(sslv3_method, ossl_statem_accept, ossl_statem_connect) #endif /- * TLS/SSLv3 server methods / IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0, TLS_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_2_enc_data) IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3, tlsv1_3_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_3_enc_data) #ifndef OPENSSL_NO_TLS1_2_METHOD IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2, tlsv1_2_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_2_enc_data) #endif #ifndef OPENSSL_NO_TLS1_1_METHOD IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1, tlsv1_1_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_1_enc_data) #endif #ifndef OPENSSL_NO_TLS1_METHOD IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1, tlsv1_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_enc_data) #endif #ifndef OPENSSL_NO_SSL3_METHOD IMPLEMENT_ssl3_meth_func(sslv3_server_method, ossl_statem_accept, ssl_undefined_function) #endif /- * TLS/SSLv3 client methods / IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0, TLS_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_2_enc_data) IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3, tlsv1_3_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_3_enc_data) #ifndef OPENSSL_NO_TLS1_2_METHOD IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2, tlsv1_2_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_2_enc_data) #endif #ifndef OPENSSL_NO_TLS1_1_METHOD IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1, tlsv1_1_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_1_enc_data) #endif #ifndef OPENSSL_NO_TLS1_METHOD IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1, tlsv1_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_enc_data) #endif #ifndef OPENSSL_NO_SSL3_METHOD IMPLEMENT_ssl3_meth_func(sslv3_client_method, ssl_undefined_function, ossl_statem_connect) #endif /- * DTLS methods / #ifndef OPENSSL_NO_DTLS1_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1, dtlsv1_method, ossl_statem_accept, ossl_statem_connect, DTLSv1_enc_data) #endif #ifndef OPENSSL_NO_DTLS1_2_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2, dtlsv1_2_method, ossl_statem_accept, ossl_statem_connect, DTLSv1_2_enc_data) #endif IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0, DTLS_method, ossl_statem_accept, ossl_statem_connect, DTLSv1_2_enc_data) /- * DTLS server methods / #ifndef OPENSSL_NO_DTLS1_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1, dtlsv1_server_method, ossl_statem_accept, ssl_undefined_function, DTLSv1_enc_data) #endif #ifndef OPENSSL_NO_DTLS1_2_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2, dtlsv1_2_server_method, ossl_statem_accept, ssl_undefined_function, DTLSv1_2_enc_data) #endif IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0, DTLS_server_method, ossl_statem_accept, ssl_undefined_function, DTLSv1_2_enc_data) /- * DTLS client methods / #ifndef OPENSSL_NO_DTLS1_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1, dtlsv1_client_method, ssl_undefined_function, ossl_statem_connect, DTLSv1_enc_data) IMPLEMENT_dtls1_meth_func(DTLS1_BAD_VER, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1, dtls_bad_ver_client_method, ssl_undefined_function, ossl_statem_connect, DTLSv1_enc_data) #endif #ifndef OPENSSL_NO_DTLS1_2_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2, dtlsv1_2_client_method, ssl_undefined_function, ossl_statem_connect, DTLSv1_2_enc_data) #endif IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0, DTLS_client_method, ssl_undefined_function, ossl_statem_connect, DTLSv1_2_enc_data) #ifndef OPENSSL_NO_DEPRECATED_1_1_0 # ifndef OPENSSL_NO_TLS1_2_METHOD const SSL_METHOD TLSv1_2_method(void) { return tlsv1_2_method(); } const SSL_METHOD TLSv1_2_server_method(void) { return tlsv1_2_server_method(); } const SSL_METHOD TLSv1_2_client_method(void) { return tlsv1_2_client_method(); } # endif # ifndef OPENSSL_NO_TLS1_1_METHOD const SSL_METHOD TLSv1_1_method(void) { return tlsv1_1_method(); } const SSL_METHOD TLSv1_1_server_method(void) { return tlsv1_1_server_method(); } const SSL_METHOD TLSv1_1_client_method(void) { return tlsv1_1_client_method(); } # endif # ifndef OPENSSL_NO_TLS1_METHOD const SSL_METHOD TLSv1_method(void) { return tlsv1_method(); } const SSL_METHOD TLSv1_server_method(void) { return tlsv1_server_method(); } const SSL_METHOD TLSv1_client_method(void) { return tlsv1_client_method(); } # endif # ifndef OPENSSL_NO_SSL3_METHOD const SSL_METHOD SSLv3_method(void) { return sslv3_method(); } const SSL_METHOD SSLv3_server_method(void) { return sslv3_server_method(); } const SSL_METHOD SSLv3_client_method(void) { return sslv3_client_method(); } # endif # ifndef OPENSSL_NO_DTLS1_2_METHOD const SSL_METHOD DTLSv1_2_method(void) { return dtlsv1_2_method(); } const SSL_METHOD DTLSv1_2_server_method(void) { return dtlsv1_2_server_method(); } const SSL_METHOD DTLSv1_2_client_method(void) { return dtlsv1_2_client_method(); } # endif # ifndef OPENSSL_NO_DTLS1_METHOD const SSL_METHOD DTLSv1_method(void) { return dtlsv1_method(); } const SSL_METHOD DTLSv1_server_method(void) { return dtlsv1_server_method(); } const SSL_METHOD *DTLSv1_client_method(void) { return dtlsv1_client_method(); } # endif #endif
./openssl/ssl/ssl_cert_comp.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include "ssl_local.h" #include "internal/e_os.h" #include "internal/refcount.h" size_t ossl_calculate_comp_expansion(int alg, size_t length) { size_t ret; / * Uncompressibility expansion: * ZLIB: N + 11 + 5 * (N >> 14) * Brotli: per RFC7932: N + 5 + 3 * (N >> 16) * ZSTD: N + 4 + 14 + 3 * (N >> 17) + 4 / switch (alg) { case TLSEXT_comp_cert_zlib: ret = length + 11 + 5 (length >> 14); break; case TLSEXT_comp_cert_brotli: ret = length + 5 + 3 * (length >> 16); break; case TLSEXT_comp_cert_zstd: ret = length + 22 + 3 * (length >> 17); break; default: return 0; } /* Check for overflow / if (ret < length) return 0; return ret; } int ossl_comp_has_alg(int a) { #ifndef OPENSSL_NO_COMP_ALG / 0 means "any" algorithm / if ((a == 0 \|\| a == TLSEXT_comp_cert_brotli) && BIO_f_brotli() != NULL) return 1; if ((a == 0 \|\| a == TLSEXT_comp_cert_zstd) && BIO_f_zstd() != NULL) return 1; if ((a == 0 \|\| a == TLSEXT_comp_cert_zlib) && BIO_f_zlib() != NULL) return 1; #endif return 0; } / New operation Helper routine / #ifndef OPENSSL_NO_COMP_ALG static OSSL_COMP_CERT OSSL_COMP_CERT_new(unsigned char data, size_t len, size_t orig_len, int alg) { OSSL_COMP_CERT ret = NULL; if (!ossl_comp_has_alg(alg) \|\| data == NULL \|\| (ret = OPENSSL_zalloc(sizeof(ret))) == NULL \|\| !CRYPTO_NEW_REF(&ret->references, 1)) goto err; ret->data = data; ret->len = len; ret->orig_len = orig_len; ret->alg = alg; return ret; err: ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE); OPENSSL_free(data); OPENSSL_free(ret); return NULL; } __owur static OSSL_COMP_CERT OSSL_COMP_CERT_from_compressed_data(unsigned char data, size_t len, size_t orig_len, int alg) { return OSSL_COMP_CERT_new(OPENSSL_memdup(data, len), len, orig_len, alg); } __owur static OSSL_COMP_CERT OSSL_COMP_CERT_from_uncompressed_data(unsigned char data, size_t len, int alg) { OSSL_COMP_CERT ret = NULL; size_t max_length; int comp_length; COMP_METHOD method; unsigned char comp_data = NULL; COMP_CTX comp_ctx = NULL; switch (alg) { case TLSEXT_comp_cert_brotli: method = COMP_brotli_oneshot(); break; case TLSEXT_comp_cert_zlib: method = COMP_zlib_oneshot(); break; case TLSEXT_comp_cert_zstd: method = COMP_zstd_oneshot(); break; default: goto err; } if ((max_length = ossl_calculate_comp_expansion(alg, len)) == 0 \|\| method == NULL \|\| (comp_ctx = COMP_CTX_new(method)) == NULL \|\| (comp_data = OPENSSL_zalloc(max_length)) == NULL) goto err; comp_length = COMP_compress_block(comp_ctx, comp_data, max_length, data, len); if (comp_length <= 0) goto err; ret = OSSL_COMP_CERT_new(comp_data, comp_length, len, alg); comp_data = NULL; err: OPENSSL_free(comp_data); COMP_CTX_free(comp_ctx); return ret; } void OSSL_COMP_CERT_free(OSSL_COMP_CERT cc) { int i; if (cc == NULL) return; CRYPTO_DOWN_REF(&cc->references, &i); REF_PRINT_COUNT("OSSL_COMP_CERT", cc); if (i > 0) return; REF_ASSERT_ISNT(i < 0); OPENSSL_free(cc->data); CRYPTO_FREE_REF(&cc->references); OPENSSL_free(cc); } int OSSL_COMP_CERT_up_ref(OSSL_COMP_CERT cc) { int i; if (CRYPTO_UP_REF(&cc->references, &i) <= 0) return 0; REF_PRINT_COUNT("OSSL_COMP_CERT", cc); REF_ASSERT_ISNT(i < 2); return ((i > 1) ? 1 : 0); } static int ssl_set_cert_comp_pref(int prefs, int algs, size_t len) { size_t j = 0; size_t i; int found = 0; int already_set[TLSEXT_comp_cert_limit]; int tmp_prefs[TLSEXT_comp_cert_limit]; / Note that \|len\| is the number of \|algs\| elements / / clear all algorithms / if (len == 0 \|\| algs == NULL) { memset(prefs, 0, sizeof(tmp_prefs)); return 1; } / This will 0-terminate the array / memset(tmp_prefs, 0, sizeof(tmp_prefs)); memset(already_set, 0, sizeof(already_set)); / Include only those algorithms we support, ignoring duplicates and unknowns / for (i = 0; i < len; i++) { if (algs[i] != 0 && ossl_comp_has_alg(algs[i])) { / Check for duplicate / if (already_set[algs[i]]) return 0; tmp_prefs[j++] = algs[i]; already_set[algs[i]] = 1; found = 1; } } if (found) memcpy(prefs, tmp_prefs, sizeof(tmp_prefs)); return found; } static size_t ssl_get_cert_to_compress(SSL ssl, CERT_PKEY cpk, unsigned char data) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); WPACKET tmppkt; BUF_MEM buf = { 0 }; size_t ret = 0; if (sc == NULL \|\| cpk == NULL \|\| !sc->server \|\| !SSL_in_before(ssl)) return 0; /* Use the \|tmppkt\| for the to-be-compressed data / if (!WPACKET_init(&tmppkt, &buf)) goto out; / no context present, add 0-length context / if (!WPACKET_put_bytes_u8(&tmppkt, 0)) goto out; / * ssl3_output_cert_chain() may generate an SSLfatal() error, * for this case, we want to ignore it, argument for_comp = 1 / if (!ssl3_output_cert_chain(sc, &tmppkt, cpk, 1)) goto out; WPACKET_get_total_written(&tmppkt, &ret); out: WPACKET_cleanup(&tmppkt); if (ret != 0 && data != NULL) data = (unsigned char )buf.data; else OPENSSL_free(buf.data); return ret; } static int ssl_compress_one_cert(SSL ssl, CERT_PKEY cpk, int alg) { unsigned char cert_data = NULL; OSSL_COMP_CERT comp_cert = NULL; size_t length; if (cpk == NULL \|\| alg == TLSEXT_comp_cert_none \|\| !ossl_comp_has_alg(alg)) return 0; if ((length = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0) return 0; comp_cert = OSSL_COMP_CERT_from_uncompressed_data(cert_data, length, alg); OPENSSL_free(cert_data); if (comp_cert == NULL) return 0; OSSL_COMP_CERT_free(cpk->comp_cert[alg]); cpk->comp_cert[alg] = comp_cert; return 1; } / alg_in can be 0, meaning any/all algorithms / static int ssl_compress_certs(SSL ssl, CERT_PKEY cpks, int alg_in) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); int i; int j; int alg; int count = 0; if (sc == NULL \|\| cpks == NULL \|\| !ossl_comp_has_alg(alg_in)) return 0; /* Look through the preferences to see what we have / for (i = 0; i < TLSEXT_comp_cert_limit; i++) { / * alg = 0 means compress for everything, but only for algorithms enabled * alg != 0 means compress for that algorithm if enabled / alg = sc->cert_comp_prefs[i]; if ((alg_in == 0 && alg != TLSEXT_comp_cert_none) \|\| (alg_in != 0 && alg == alg_in)) { for (j = 0; j < SSL_PKEY_NUM; j++) { / No cert, move on / if (cpks[j].x509 == NULL) continue; if (!ssl_compress_one_cert(ssl, &cpks[j], alg)) return 0; / if the cert expanded, set the value in the CERT_PKEY to NULL / if (cpks[j].comp_cert[alg]->len >= cpks[j].comp_cert[alg]->orig_len) { OSSL_COMP_CERT_free(cpks[j].comp_cert[alg]); cpks[j].comp_cert[alg] = NULL; } else { count++; } } } } return (count > 0); } static size_t ssl_get_compressed_cert(SSL ssl, CERT_PKEY cpk, int alg, unsigned char data, size_t orig_len) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); size_t cert_len = 0; size_t comp_len = 0; unsigned char cert_data = NULL; OSSL_COMP_CERT comp_cert = NULL; if (sc == NULL \|\| cpk == NULL \|\| data == NULL \|\| orig_len == NULL \|\| !sc->server \|\| !SSL_in_before(ssl) \|\| !ossl_comp_has_alg(alg)) return 0; if ((cert_len = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0) goto err; comp_cert = OSSL_COMP_CERT_from_uncompressed_data(cert_data, cert_len, alg); OPENSSL_free(cert_data); if (comp_cert == NULL) goto err; comp_len = comp_cert->len; orig_len = comp_cert->orig_len; data = comp_cert->data; comp_cert->data = NULL; err: OSSL_COMP_CERT_free(comp_cert); return comp_len; } static int ossl_set1_compressed_cert(CERT cert, int algorithm, unsigned char comp_data, size_t comp_length, size_t orig_length) { OSSL_COMP_CERT comp_cert; /* No explicit cert set / if (cert == NULL \|\| cert->key == NULL) return 0; comp_cert = OSSL_COMP_CERT_from_compressed_data(comp_data, comp_length, orig_length, algorithm); if (comp_cert == NULL) return 0; OSSL_COMP_CERT_free(cert->key->comp_cert[algorithm]); cert->key->comp_cert[algorithm] = comp_cert; return 1; } #endif /- * Public API / int SSL_CTX_set1_cert_comp_preference(SSL_CTX ctx, int algs, size_t len) { #ifndef OPENSSL_NO_COMP_ALG return ssl_set_cert_comp_pref(ctx->cert_comp_prefs, algs, len); #else return 0; #endif } int SSL_set1_cert_comp_preference(SSL ssl, int algs, size_t len) { #ifndef OPENSSL_NO_COMP_ALG SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; return ssl_set_cert_comp_pref(sc->cert_comp_prefs, algs, len); #else return 0; #endif } int SSL_compress_certs(SSL ssl, int alg) { #ifndef OPENSSL_NO_COMP_ALG SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL \|\| sc->cert == NULL) return 0; return ssl_compress_certs(ssl, sc->cert->pkeys, alg); #endif return 0; } int SSL_CTX_compress_certs(SSL_CTX ctx, int alg) { int ret = 0; #ifndef OPENSSL_NO_COMP_ALG SSL new = SSL_new(ctx); if (new == NULL) return 0; ret = ssl_compress_certs(new, ctx->cert->pkeys, alg); SSL_free(new); #endif return ret; } size_t SSL_get1_compressed_cert(SSL ssl, int alg, unsigned char data, size_t orig_len) { #ifndef OPENSSL_NO_COMP_ALG SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); CERT_PKEY cpk = NULL; if (sc->cert != NULL) cpk = sc->cert->key; else cpk = ssl->ctx->cert->key; return ssl_get_compressed_cert(ssl, cpk, alg, data, orig_len); #else return 0; #endif } size_t SSL_CTX_get1_compressed_cert(SSL_CTX ctx, int alg, unsigned char data, size_t orig_len) { #ifndef OPENSSL_NO_COMP_ALG size_t ret; SSL new = SSL_new(ctx); ret = ssl_get_compressed_cert(new, ctx->cert->key, alg, data, orig_len); SSL_free(new); return ret; #else return 0; #endif } int SSL_CTX_set1_compressed_cert(SSL_CTX ctx, int algorithm, unsigned char comp_data, size_t comp_length, size_t orig_length) { #ifndef OPENSSL_NO_COMP_ALG return ossl_set1_compressed_cert(ctx->cert, algorithm, comp_data, comp_length, orig_length); #else return 0; #endif } int SSL_set1_compressed_cert(SSL ssl, int algorithm, unsigned char comp_data, size_t comp_length, size_t orig_length) { #ifndef OPENSSL_NO_COMP_ALG SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); /* Cannot set a pre-compressed certificate on a client */ if (sc == NULL \|\| !sc->server) return 0; return ossl_set1_compressed_cert(sc->cert, algorithm, comp_data, comp_length, orig_length); #else return 0; #endif }
./openssl/ssl/ssl_txt.c	/* * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <openssl/buffer.h> #include "ssl_local.h" #ifndef OPENSSL_NO_STDIO int SSL_SESSION_print_fp(FILE fp, const SSL_SESSION x) { BIO b; int ret; if ((b = BIO_new(BIO_s_file())) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); return 0; } BIO_set_fp(b, fp, BIO_NOCLOSE); ret = SSL_SESSION_print(b, x); BIO_free(b); return ret; } #endif int SSL_SESSION_print(BIO bp, const SSL_SESSION x) { size_t i; const char s; int istls13; if (x == NULL) goto err; istls13 = (x->ssl_version == TLS1_3_VERSION); if (BIO_puts(bp, "SSL-Session:\n") <= 0) goto err; s = ssl_protocol_to_string(x->ssl_version); if (BIO_printf(bp, " Protocol : %s\n", s) <= 0) goto err; if (x->cipher == NULL) { if (((x->cipher_id) & 0xff000000) == 0x02000000) { if (BIO_printf(bp, " Cipher : %06lX\n", x->cipher_id & 0xffffff) <= 0) goto err; } else { if (BIO_printf(bp, " Cipher : %04lX\n", x->cipher_id & 0xffff) <= 0) goto err; } } else { if (BIO_printf(bp, " Cipher : %s\n", ((x->cipher->name == NULL) ? "unknown" : x->cipher->name)) <= 0) goto err; } if (BIO_puts(bp, " Session-ID: ") <= 0) goto err; for (i = 0; i < x->session_id_length; i++) { if (BIO_printf(bp, "%02X", x->session_id[i]) <= 0) goto err; } if (BIO_puts(bp, "\n Session-ID-ctx: ") <= 0) goto err; for (i = 0; i < x->sid_ctx_length; i++) { if (BIO_printf(bp, "%02X", x->sid_ctx[i]) <= 0) goto err; } if (istls13) { if (BIO_puts(bp, "\n Resumption PSK: ") <= 0) goto err; } else if (BIO_puts(bp, "\n Master-Key: ") <= 0) goto err; for (i = 0; i < x->master_key_length; i++) { if (BIO_printf(bp, "%02X", x->master_key[i]) <= 0) goto err; } #ifndef OPENSSL_NO_PSK if (BIO_puts(bp, "\n PSK identity: ") <= 0) goto err; if (BIO_printf(bp, "%s", x->psk_identity ? x->psk_identity : "None") <= 0) goto err; if (BIO_puts(bp, "\n PSK identity hint: ") <= 0) goto err; if (BIO_printf (bp, "%s", x->psk_identity_hint ? x->psk_identity_hint : "None") <= 0) goto err; #endif #ifndef OPENSSL_NO_SRP if (BIO_puts(bp, "\n SRP username: ") <= 0) goto err; if (BIO_printf(bp, "%s", x->srp_username ? x->srp_username : "None") <= 0) goto err; #endif if (x->ext.tick_lifetime_hint) { if (BIO_printf(bp, "\n TLS session ticket lifetime hint: %ld (seconds)", x->ext.tick_lifetime_hint) <= 0) goto err; } if (x->ext.tick) { if (BIO_puts(bp, "\n TLS session ticket:\n") <= 0) goto err; if (BIO_dump_indent (bp, (const char )x->ext.tick, (int)x->ext.ticklen, 4) <= 0) goto err; } #ifndef OPENSSL_NO_COMP if (x->compress_meth != 0) { SSL_COMP comp = NULL; if (!ssl_cipher_get_evp(NULL, x, NULL, NULL, NULL, NULL, &comp, 0)) goto err; if (comp == NULL) { if (BIO_printf(bp, "\n Compression: %d", x->compress_meth) <= 0) goto err; } else { if (BIO_printf(bp, "\n Compression: %d (%s)", comp->id, comp->name) <= 0) goto err; } } #endif if (!ossl_time_is_zero(x->time)) { if (BIO_printf(bp, "\n Start Time: %lld", (long long)ossl_time_to_time_t(x->time)) <= 0) goto err; } if (!ossl_time_is_zero(x->timeout)) { if (BIO_printf(bp, "\n Timeout : %lld (sec)", (long long)ossl_time2seconds(x->timeout)) <= 0) goto err; } if (BIO_puts(bp, "\n") <= 0) goto err; if (BIO_puts(bp, " Verify return code: ") <= 0) goto err; if (BIO_printf(bp, "%ld (%s)\n", x->verify_result, X509_verify_cert_error_string(x->verify_result)) <= 0) goto err; if (BIO_printf(bp, " Extended master secret: %s\n", x->flags & SSL_SESS_FLAG_EXTMS ? "yes" : "no") <= 0) goto err; if (istls13) { if (BIO_printf(bp, " Max Early Data: %u\n", (unsigned int)x->ext.max_early_data) <= 0) goto err; } return 1; err: return 0; } / * print session id and master key in NSS keylog format (RSA * Session-ID:<session id> Master-Key:<master key>) / int SSL_SESSION_print_keylog(BIO bp, const SSL_SESSION x) { size_t i; if (x == NULL) goto err; if (x->session_id_length == 0 \|\| x->master_key_length == 0) goto err; / * the RSA prefix is required by the format's definition although there's * nothing RSA-specific in the output, therefore, we don't have to check if * the cipher suite is based on RSA */ if (BIO_puts(bp, "RSA ") <= 0) goto err; if (BIO_puts(bp, "Session-ID:") <= 0) goto err; for (i = 0; i < x->session_id_length; i++) { if (BIO_printf(bp, "%02X", x->session_id[i]) <= 0) goto err; } if (BIO_puts(bp, " Master-Key:") <= 0) goto err; for (i = 0; i < x->master_key_length; i++) { if (BIO_printf(bp, "%02X", x->master_key[i]) <= 0) goto err; } if (BIO_puts(bp, "\n") <= 0) goto err; return 1; err: return 0; }
./openssl/ssl/s3_enc.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include "ssl_local.h" #include <openssl/evp.h> #include <openssl/md5.h> #include <openssl/core_names.h> #include "internal/cryptlib.h" static int ssl3_generate_key_block(SSL_CONNECTION s, unsigned char km, int num) { const EVP_MD md5 = NULL, sha1 = NULL; EVP_MD_CTX m5; EVP_MD_CTX s1; unsigned char buf[16], smd[SHA_DIGEST_LENGTH]; unsigned char c = 'A'; unsigned int i, k; int ret = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); #ifdef CHARSET_EBCDIC c = os_toascii[c]; /* 'A' in ASCII / #endif k = 0; md5 = ssl_evp_md_fetch(sctx->libctx, NID_md5, sctx->propq); sha1 = ssl_evp_md_fetch(sctx->libctx, NID_sha1, sctx->propq); m5 = EVP_MD_CTX_new(); s1 = EVP_MD_CTX_new(); if (md5 == NULL \|\| sha1 == NULL \|\| m5 == NULL \|\| s1 == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } for (i = 0; (int)i < num; i += MD5_DIGEST_LENGTH) { k++; if (k > sizeof(buf)) { / bug: 'buf' is too small for this ciphersuite / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } memset(buf, c, k); c++; if (!EVP_DigestInit_ex(s1, sha1, NULL) \|\| !EVP_DigestUpdate(s1, buf, k) \|\| !EVP_DigestUpdate(s1, s->session->master_key, s->session->master_key_length) \|\| !EVP_DigestUpdate(s1, s->s3.server_random, SSL3_RANDOM_SIZE) \|\| !EVP_DigestUpdate(s1, s->s3.client_random, SSL3_RANDOM_SIZE) \|\| !EVP_DigestFinal_ex(s1, smd, NULL) \|\| !EVP_DigestInit_ex(m5, md5, NULL) \|\| !EVP_DigestUpdate(m5, s->session->master_key, s->session->master_key_length) \|\| !EVP_DigestUpdate(m5, smd, SHA_DIGEST_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if ((int)(i + MD5_DIGEST_LENGTH) > num) { if (!EVP_DigestFinal_ex(m5, smd, NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } memcpy(km, smd, (num - i)); } else { if (!EVP_DigestFinal_ex(m5, km, NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } km += MD5_DIGEST_LENGTH; } OPENSSL_cleanse(smd, sizeof(smd)); ret = 1; err: EVP_MD_CTX_free(m5); EVP_MD_CTX_free(s1); ssl_evp_md_free(md5); ssl_evp_md_free(sha1); return ret; } int ssl3_change_cipher_state(SSL_CONNECTION s, int which) { unsigned char p, mac_secret; size_t md_len; unsigned char key, iv; const EVP_CIPHER ciph; const SSL_COMP comp = NULL; const EVP_MD md; int mdi; size_t n, iv_len, key_len; int direction = (which & SSL3_CC_READ) != 0 ? OSSL_RECORD_DIRECTION_READ : OSSL_RECORD_DIRECTION_WRITE; ciph = s->s3.tmp.new_sym_enc; md = s->s3.tmp.new_hash; / m == NULL will lead to a crash later / if (!ossl_assert(md != NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } #ifndef OPENSSL_NO_COMP comp = s->s3.tmp.new_compression; #endif p = s->s3.tmp.key_block; mdi = EVP_MD_get_size(md); if (mdi < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } md_len = (size_t)mdi; key_len = EVP_CIPHER_get_key_length(ciph); iv_len = EVP_CIPHER_get_iv_length(ciph); if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) \|\| (which == SSL3_CHANGE_CIPHER_SERVER_READ)) { mac_secret = &(p[0]); n = md_len + md_len; key = &(p[n]); n += key_len + key_len; iv = &(p[n]); n += iv_len + iv_len; } else { n = md_len; mac_secret = &(p[n]); n += md_len + key_len; key = &(p[n]); n += key_len + iv_len; iv = &(p[n]); n += iv_len; } if (n > s->s3.tmp.key_block_length) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!ssl_set_new_record_layer(s, SSL3_VERSION, direction, OSSL_RECORD_PROTECTION_LEVEL_APPLICATION, NULL, 0, key, key_len, iv, iv_len, mac_secret, md_len, ciph, 0, NID_undef, md, comp, NULL)) { / SSLfatal already called / goto err; } return 1; err: return 0; } int ssl3_setup_key_block(SSL_CONNECTION s) { unsigned char p; const EVP_CIPHER c; const EVP_MD hash; int num; int ret = 0; SSL_COMP comp; if (s->s3.tmp.key_block_length != 0) return 1; if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash, NULL, NULL, &comp, 0)) { /* Error is already recorded / SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); return 0; } ssl_evp_cipher_free(s->s3.tmp.new_sym_enc); s->s3.tmp.new_sym_enc = c; ssl_evp_md_free(s->s3.tmp.new_hash); s->s3.tmp.new_hash = hash; #ifdef OPENSSL_NO_COMP s->s3.tmp.new_compression = NULL; #else s->s3.tmp.new_compression = comp; #endif num = EVP_MD_get_size(hash); if (num < 0) return 0; num = EVP_CIPHER_get_key_length(c) + num + EVP_CIPHER_get_iv_length(c); num = 2; ssl3_cleanup_key_block(s); if ((p = OPENSSL_malloc(num)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } s->s3.tmp.key_block_length = num; s->s3.tmp.key_block = p; /* Calls SSLfatal() as required / ret = ssl3_generate_key_block(s, p, num); return ret; } void ssl3_cleanup_key_block(SSL_CONNECTION s) { OPENSSL_clear_free(s->s3.tmp.key_block, s->s3.tmp.key_block_length); s->s3.tmp.key_block = NULL; s->s3.tmp.key_block_length = 0; } int ssl3_init_finished_mac(SSL_CONNECTION s) { BIO buf = BIO_new(BIO_s_mem()); if (buf == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BIO_LIB); return 0; } ssl3_free_digest_list(s); s->s3.handshake_buffer = buf; (void)BIO_set_close(s->s3.handshake_buffer, BIO_CLOSE); return 1; } /* * Free digest list. Also frees handshake buffer since they are always freed * together. / void ssl3_free_digest_list(SSL_CONNECTION s) { BIO_free(s->s3.handshake_buffer); s->s3.handshake_buffer = NULL; EVP_MD_CTX_free(s->s3.handshake_dgst); s->s3.handshake_dgst = NULL; } int ssl3_finish_mac(SSL_CONNECTION s, const unsigned char buf, size_t len) { int ret; if (s->s3.handshake_dgst == NULL) { /* Note: this writes to a memory BIO so a failure is a fatal error / if (len > INT_MAX) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_OVERFLOW_ERROR); return 0; } ret = BIO_write(s->s3.handshake_buffer, (void )buf, (int)len); if (ret <= 0 \|\| ret != (int)len) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } else { ret = EVP_DigestUpdate(s->s3.handshake_dgst, buf, len); if (!ret) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int ssl3_digest_cached_records(SSL_CONNECTION s, int keep) { const EVP_MD md; long hdatalen; void hdata; if (s->s3.handshake_dgst == NULL) { hdatalen = BIO_get_mem_data(s->s3.handshake_buffer, &hdata); if (hdatalen <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_LENGTH); return 0; } s->s3.handshake_dgst = EVP_MD_CTX_new(); if (s->s3.handshake_dgst == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } md = ssl_handshake_md(s); if (md == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM); return 0; } if (!EVP_DigestInit_ex(s->s3.handshake_dgst, md, NULL) \|\| !EVP_DigestUpdate(s->s3.handshake_dgst, hdata, hdatalen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } if (keep == 0) { BIO_free(s->s3.handshake_buffer); s->s3.handshake_buffer = NULL; } return 1; } void ssl3_digest_master_key_set_params(const SSL_SESSION session, OSSL_PARAM params[]) { int n = 0; params[n++] = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS, (void )session->master_key, session->master_key_length); params[n++] = OSSL_PARAM_construct_end(); } size_t ssl3_final_finish_mac(SSL_CONNECTION s, const char sender, size_t len, unsigned char p) { int ret; EVP_MD_CTX ctx = NULL; if (!ssl3_digest_cached_records(s, 0)) { / SSLfatal() already called / return 0; } if (EVP_MD_CTX_get_type(s->s3.handshake_dgst) != NID_md5_sha1) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_REQUIRED_DIGEST); return 0; } ctx = EVP_MD_CTX_new(); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } if (!EVP_MD_CTX_copy_ex(ctx, s->s3.handshake_dgst)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); ret = 0; goto err; } ret = EVP_MD_CTX_get_size(ctx); if (ret < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); ret = 0; goto err; } if (sender != NULL) { OSSL_PARAM digest_cmd_params[3]; ssl3_digest_master_key_set_params(s->session, digest_cmd_params); if (EVP_DigestUpdate(ctx, sender, len) <= 0 \|\| EVP_MD_CTX_set_params(ctx, digest_cmd_params) <= 0 \|\| EVP_DigestFinal_ex(ctx, p, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); ret = 0; } } err: EVP_MD_CTX_free(ctx); return ret; } int ssl3_generate_master_secret(SSL_CONNECTION s, unsigned char out, unsigned char p, size_t len, size_t secret_size) { static const unsigned char salt[3] = { #ifndef CHARSET_EBCDIC (const unsigned char )"A", (const unsigned char )"BB", (const unsigned char )"CCC", #else (const unsigned char )"\x41", (const unsigned char )"\x42\x42", (const unsigned char )"\x43\x43\x43", #endif }; unsigned char buf[EVP_MAX_MD_SIZE]; EVP_MD_CTX ctx = EVP_MD_CTX_new(); int i, ret = 1; unsigned int n; size_t ret_secret_size = 0; if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } for (i = 0; i < 3; i++) { if (EVP_DigestInit_ex(ctx, SSL_CONNECTION_GET_CTX(s)->sha1, NULL) <= 0 \|\| EVP_DigestUpdate(ctx, salt[i], strlen((const char )salt[i])) <= 0 \|\| EVP_DigestUpdate(ctx, p, len) <= 0 \|\| EVP_DigestUpdate(ctx, &(s->s3.client_random[0]), SSL3_RANDOM_SIZE) <= 0 \|\| EVP_DigestUpdate(ctx, &(s->s3.server_random[0]), SSL3_RANDOM_SIZE) <= 0 \|\| EVP_DigestFinal_ex(ctx, buf, &n) <= 0 \|\| EVP_DigestInit_ex(ctx, SSL_CONNECTION_GET_CTX(s)->md5, NULL) <= 0 \|\| EVP_DigestUpdate(ctx, p, len) <= 0 \|\| EVP_DigestUpdate(ctx, buf, n) <= 0 \|\| EVP_DigestFinal_ex(ctx, out, &n) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); ret = 0; break; } out += n; ret_secret_size += n; } EVP_MD_CTX_free(ctx); OPENSSL_cleanse(buf, sizeof(buf)); if (ret) secret_size = ret_secret_size; return ret; } int ssl3_alert_code(int code) { switch (code) { case SSL_AD_CLOSE_NOTIFY: return SSL3_AD_CLOSE_NOTIFY; case SSL_AD_UNEXPECTED_MESSAGE: return SSL3_AD_UNEXPECTED_MESSAGE; case SSL_AD_BAD_RECORD_MAC: return SSL3_AD_BAD_RECORD_MAC; case SSL_AD_DECRYPTION_FAILED: return SSL3_AD_BAD_RECORD_MAC; case SSL_AD_RECORD_OVERFLOW: return SSL3_AD_BAD_RECORD_MAC; case SSL_AD_DECOMPRESSION_FAILURE: return SSL3_AD_DECOMPRESSION_FAILURE; case SSL_AD_HANDSHAKE_FAILURE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_NO_CERTIFICATE: return SSL3_AD_NO_CERTIFICATE; case SSL_AD_BAD_CERTIFICATE: return SSL3_AD_BAD_CERTIFICATE; case SSL_AD_UNSUPPORTED_CERTIFICATE: return SSL3_AD_UNSUPPORTED_CERTIFICATE; case SSL_AD_CERTIFICATE_REVOKED: return SSL3_AD_CERTIFICATE_REVOKED; case SSL_AD_CERTIFICATE_EXPIRED: return SSL3_AD_CERTIFICATE_EXPIRED; case SSL_AD_CERTIFICATE_UNKNOWN: return SSL3_AD_CERTIFICATE_UNKNOWN; case SSL_AD_ILLEGAL_PARAMETER: return SSL3_AD_ILLEGAL_PARAMETER; case SSL_AD_UNKNOWN_CA: return SSL3_AD_BAD_CERTIFICATE; case SSL_AD_ACCESS_DENIED: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_DECODE_ERROR: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_DECRYPT_ERROR: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_EXPORT_RESTRICTION: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_PROTOCOL_VERSION: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_INSUFFICIENT_SECURITY: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_INTERNAL_ERROR: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_USER_CANCELLED: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_NO_RENEGOTIATION: return -1; / Don't send it :-) */ case SSL_AD_UNSUPPORTED_EXTENSION: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_CERTIFICATE_UNOBTAINABLE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_UNRECOGNIZED_NAME: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_BAD_CERTIFICATE_HASH_VALUE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_UNKNOWN_PSK_IDENTITY: return TLS1_AD_UNKNOWN_PSK_IDENTITY; case SSL_AD_INAPPROPRIATE_FALLBACK: return TLS1_AD_INAPPROPRIATE_FALLBACK; case SSL_AD_NO_APPLICATION_PROTOCOL: return TLS1_AD_NO_APPLICATION_PROTOCOL; case SSL_AD_CERTIFICATE_REQUIRED: return SSL_AD_HANDSHAKE_FAILURE; case TLS13_AD_MISSING_EXTENSION: return SSL_AD_HANDSHAKE_FAILURE; default: return -1; } }
./openssl/ssl/ssl_rsa.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include "ssl_local.h" #include "internal/packet.h" #include <openssl/bio.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/x509.h> #include <openssl/x509v3.h> #include <openssl/pem.h> static int ssl_set_cert(CERT c, X509 x509, SSL_CTX ctx); static int ssl_set_pkey(CERT c, EVP_PKEY pkey, SSL_CTX ctx); #define SYNTHV1CONTEXT (SSL_EXT_TLS1_2_AND_BELOW_ONLY \ \| SSL_EXT_CLIENT_HELLO \ \| SSL_EXT_TLS1_2_SERVER_HELLO \ \| SSL_EXT_IGNORE_ON_RESUMPTION) #define NAME_PREFIX1 "SERVERINFO FOR " #define NAME_PREFIX2 "SERVERINFOV2 FOR " int SSL_use_certificate(SSL ssl, X509 x) { int rv; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } rv = ssl_security_cert(sc, NULL, x, 0, 1); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); return 0; } return ssl_set_cert(sc->cert, x, SSL_CONNECTION_GET_CTX(sc)); } int SSL_use_certificate_file(SSL ssl, const char file, int type) { int j; BIO in; int ret = 0; X509 cert = NULL, x = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } x = X509_new_ex(ssl->ctx->libctx, ssl->ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto end; } if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; cert = d2i_X509_bio(in, &x); } else if (type == SSL_FILETYPE_PEM) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) goto end; j = ERR_R_PEM_LIB; cert = PEM_read_bio_X509(in, &x, sc->default_passwd_callback, sc->default_passwd_callback_userdata); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (cert == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_use_certificate(ssl, x); end: X509_free(x); BIO_free(in); return ret; } int SSL_use_certificate_ASN1(SSL ssl, const unsigned char d, int len) { X509 x; int ret; x = X509_new_ex(ssl->ctx->libctx, ssl->ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } if (d2i_X509(&x, &d, (long)len)== NULL) { X509_free(x); ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_use_certificate(ssl, x); X509_free(x); return ret; } static int ssl_set_pkey(CERT c, EVP_PKEY pkey, SSL_CTX ctx) { size_t i; if (ssl_cert_lookup_by_pkey(pkey, &i, ctx) == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE); return 0; } if (c->pkeys[i].x509 != NULL && !X509_check_private_key(c->pkeys[i].x509, pkey)) return 0; EVP_PKEY_free(c->pkeys[i].privatekey); EVP_PKEY_up_ref(pkey); c->pkeys[i].privatekey = pkey; c->key = &c->pkeys[i]; return 1; } int SSL_use_PrivateKey(SSL ssl, EVP_PKEY pkey) { int ret; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } ret = ssl_set_pkey(sc->cert, pkey, SSL_CONNECTION_GET_CTX(sc)); return ret; } int SSL_use_PrivateKey_file(SSL ssl, const char file, int type) { int j, ret = 0; BIO in; EVP_PKEY pkey = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } if (type == SSL_FILETYPE_PEM) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) goto end; j = ERR_R_PEM_LIB; pkey = PEM_read_bio_PrivateKey_ex(in, NULL, sc->default_passwd_callback, sc->default_passwd_callback_userdata, ssl->ctx->libctx, ssl->ctx->propq); } else if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; pkey = d2i_PrivateKey_ex_bio(in, NULL, ssl->ctx->libctx, ssl->ctx->propq); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_use_PrivateKey(ssl, pkey); EVP_PKEY_free(pkey); end: BIO_free(in); return ret; } int SSL_use_PrivateKey_ASN1(int type, SSL ssl, const unsigned char d, long len) { int ret; const unsigned char p; EVP_PKEY pkey; p = d; if ((pkey = d2i_PrivateKey_ex(type, NULL, &p, (long)len, ssl->ctx->libctx, ssl->ctx->propq)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_use_PrivateKey(ssl, pkey); EVP_PKEY_free(pkey); return ret; } int SSL_CTX_use_certificate(SSL_CTX ctx, X509 x) { int rv; if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } rv = ssl_security_cert(NULL, ctx, x, 0, 1); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); return 0; } return ssl_set_cert(ctx->cert, x, ctx); } static int ssl_set_cert(CERT c, X509 x, SSL_CTX ctx) { EVP_PKEY pkey; size_t i; pkey = X509_get0_pubkey(x); if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_X509_LIB); return 0; } if (ssl_cert_lookup_by_pkey(pkey, &i, ctx) == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE); return 0; } if (i == SSL_PKEY_ECC && !EVP_PKEY_can_sign(pkey)) { ERR_raise(ERR_LIB_SSL, SSL_R_ECC_CERT_NOT_FOR_SIGNING); return 0; } if (c->pkeys[i].privatekey != NULL) { /* * The return code from EVP_PKEY_copy_parameters is deliberately * ignored. Some EVP_PKEY types cannot do this. * coverity[check_return] / EVP_PKEY_copy_parameters(pkey, c->pkeys[i].privatekey); ERR_clear_error(); if (!X509_check_private_key(x, c->pkeys[i].privatekey)) { / * don't fail for a cert/key mismatch, just free current private * key (when switching to a different cert & key, first this * function should be used, then ssl_set_pkey / EVP_PKEY_free(c->pkeys[i].privatekey); c->pkeys[i].privatekey = NULL; / clear error queue / ERR_clear_error(); } } X509_free(c->pkeys[i].x509); X509_up_ref(x); c->pkeys[i].x509 = x; c->key = &(c->pkeys[i]); return 1; } int SSL_CTX_use_certificate_file(SSL_CTX ctx, const char file, int type) { int j = SSL_R_BAD_VALUE; BIO in; int ret = 0; X509 x = NULL, cert = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } x = X509_new_ex(ctx->libctx, ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto end; } if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; cert = d2i_X509_bio(in, &x); } else if (type == SSL_FILETYPE_PEM) { j = ERR_R_PEM_LIB; cert = PEM_read_bio_X509(in, &x, ctx->default_passwd_callback, ctx->default_passwd_callback_userdata); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (cert == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_CTX_use_certificate(ctx, x); end: X509_free(x); BIO_free(in); return ret; } int SSL_CTX_use_certificate_ASN1(SSL_CTX ctx, int len, const unsigned char d) { X509 x; int ret; x = X509_new_ex(ctx->libctx, ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } if (d2i_X509(&x, &d, (long)len) == NULL) { X509_free(x); ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_CTX_use_certificate(ctx, x); X509_free(x); return ret; } int SSL_CTX_use_PrivateKey(SSL_CTX ctx, EVP_PKEY pkey) { if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } return ssl_set_pkey(ctx->cert, pkey, ctx); } int SSL_CTX_use_PrivateKey_file(SSL_CTX ctx, const char file, int type) { int j, ret = 0; BIO in; EVP_PKEY pkey = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } if (type == SSL_FILETYPE_PEM) { j = ERR_R_PEM_LIB; pkey = PEM_read_bio_PrivateKey_ex(in, NULL, ctx->default_passwd_callback, ctx->default_passwd_callback_userdata, ctx->libctx, ctx->propq); } else if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; pkey = d2i_PrivateKey_ex_bio(in, NULL, ctx->libctx, ctx->propq); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_CTX_use_PrivateKey(ctx, pkey); EVP_PKEY_free(pkey); end: BIO_free(in); return ret; } int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX ctx, const unsigned char d, long len) { int ret; const unsigned char p; EVP_PKEY pkey; p = d; if ((pkey = d2i_PrivateKey_ex(type, NULL, &p, (long)len, ctx->libctx, ctx->propq)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_CTX_use_PrivateKey(ctx, pkey); EVP_PKEY_free(pkey); return ret; } / * Read a file that contains our certificate in "PEM" format, possibly * followed by a sequence of CA certificates that should be sent to the peer * in the Certificate message. / static int use_certificate_chain_file(SSL_CTX ctx, SSL ssl, const char file) { BIO in; int ret = 0; X509 x = NULL; pem_password_cb passwd_callback; void passwd_callback_userdata; SSL_CTX real_ctx = (ssl == NULL) ? ctx : ssl->ctx; if (ctx == NULL && ssl == NULL) return 0; ERR_clear_error(); / clear error stack for * SSL_CTX_use_certificate() / if (ctx != NULL) { passwd_callback = ctx->default_passwd_callback; passwd_callback_userdata = ctx->default_passwd_callback_userdata; } else { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; passwd_callback = sc->default_passwd_callback; passwd_callback_userdata = sc->default_passwd_callback_userdata; } in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } x = X509_new_ex(real_ctx->libctx, real_ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto end; } if (PEM_read_bio_X509_AUX(in, &x, passwd_callback, passwd_callback_userdata) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PEM_LIB); goto end; } if (ctx) ret = SSL_CTX_use_certificate(ctx, x); else ret = SSL_use_certificate(ssl, x); if (ERR_peek_error() != 0) ret = 0; /* Key/certificate mismatch doesn't imply * ret==0 ... / if (ret) { / * If we could set up our certificate, now proceed to the CA * certificates. / X509 ca; int r; unsigned long err; if (ctx) r = SSL_CTX_clear_chain_certs(ctx); else r = SSL_clear_chain_certs(ssl); if (r == 0) { ret = 0; goto end; } while (1) { ca = X509_new_ex(real_ctx->libctx, real_ctx->propq); if (ca == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto end; } if (PEM_read_bio_X509(in, &ca, passwd_callback, passwd_callback_userdata) != NULL) { if (ctx) r = SSL_CTX_add0_chain_cert(ctx, ca); else r = SSL_add0_chain_cert(ssl, ca); /* * Note that we must not free ca if it was successfully added to * the chain (while we must free the main certificate, since its * reference count is increased by SSL_CTX_use_certificate). / if (!r) { X509_free(ca); ret = 0; goto end; } } else { X509_free(ca); break; } } / When the while loop ends, it's usually just EOF. / err = ERR_peek_last_error(); if (ERR_GET_LIB(err) == ERR_LIB_PEM && ERR_GET_REASON(err) == PEM_R_NO_START_LINE) ERR_clear_error(); else ret = 0; / some real error / } end: X509_free(x); BIO_free(in); return ret; } int SSL_CTX_use_certificate_chain_file(SSL_CTX ctx, const char file) { return use_certificate_chain_file(ctx, NULL, file); } int SSL_use_certificate_chain_file(SSL ssl, const char file) { return use_certificate_chain_file(NULL, ssl, file); } static int serverinfo_find_extension(const unsigned char serverinfo, size_t serverinfo_length, unsigned int extension_type, const unsigned char *extension_data, size_t extension_length) { PACKET pkt, data; extension_data = NULL; extension_length = 0; if (serverinfo == NULL \|\| serverinfo_length == 0) return -1; if (!PACKET_buf_init(&pkt, serverinfo, serverinfo_length)) return -1; for (;;) { unsigned int type = 0; unsigned long context = 0; /* end of serverinfo / if (PACKET_remaining(&pkt) == 0) return 0; / Extension not found / if (!PACKET_get_net_4(&pkt, &context) \|\| !PACKET_get_net_2(&pkt, &type) \|\| !PACKET_get_length_prefixed_2(&pkt, &data)) return -1; if (type == extension_type) { extension_data = PACKET_data(&data); extension_length = PACKET_remaining(&data); return 1; / Success / } } / Unreachable / } static int serverinfoex_srv_parse_cb(SSL s, unsigned int ext_type, unsigned int context, const unsigned char in, size_t inlen, X509 x, size_t chainidx, int al, void arg) { if (inlen != 0) { al = SSL_AD_DECODE_ERROR; return 0; } return 1; } static int serverinfo_srv_parse_cb(SSL s, unsigned int ext_type, const unsigned char in, size_t inlen, int al, void arg) { return serverinfoex_srv_parse_cb(s, ext_type, 0, in, inlen, NULL, 0, al, arg); } static int serverinfoex_srv_add_cb(SSL s, unsigned int ext_type, unsigned int context, const unsigned char *out, size_t outlen, X509 x, size_t chainidx, int al, void arg) { const unsigned char serverinfo = NULL; size_t serverinfo_length = 0; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) { al = SSL_AD_INTERNAL_ERROR; return -1; } /* We only support extensions for the first Certificate / if ((context & SSL_EXT_TLS1_3_CERTIFICATE) != 0 && chainidx > 0) return 0; / Is there serverinfo data for the chosen server cert? / if ((ssl_get_server_cert_serverinfo(sc, &serverinfo, &serverinfo_length)) != 0) { / Find the relevant extension from the serverinfo / int retval = serverinfo_find_extension(serverinfo, serverinfo_length, ext_type, out, outlen); if (retval == -1) { al = SSL_AD_INTERNAL_ERROR; return -1; /* Error / } if (retval == 0) return 0; / No extension found, don't send extension / return 1; / Send extension / } return 0; / No serverinfo data found, don't send * extension / } static int serverinfo_srv_add_cb(SSL s, unsigned int ext_type, const unsigned char *out, size_t outlen, int al, void arg) { return serverinfoex_srv_add_cb(s, ext_type, 0, out, outlen, NULL, 0, al, arg); } /* * With a NULL context, this function just checks that the serverinfo data * parses correctly. With a non-NULL context, it registers callbacks for * the included extensions. / static int serverinfo_process_buffer(unsigned int version, const unsigned char serverinfo, size_t serverinfo_length, SSL_CTX ctx) { PACKET pkt; if (serverinfo == NULL \|\| serverinfo_length == 0) return 0; if (version != SSL_SERVERINFOV1 && version != SSL_SERVERINFOV2) return 0; if (!PACKET_buf_init(&pkt, serverinfo, serverinfo_length)) return 0; while (PACKET_remaining(&pkt)) { unsigned long context = 0; unsigned int ext_type = 0; PACKET data; if ((version == SSL_SERVERINFOV2 && !PACKET_get_net_4(&pkt, &context)) \|\| !PACKET_get_net_2(&pkt, &ext_type) \|\| !PACKET_get_length_prefixed_2(&pkt, &data)) return 0; if (ctx == NULL) continue; / * The old style custom extensions API could be set separately for * server/client, i.e. you could set one custom extension for a client, * and for the same extension in the same SSL_CTX you could set a * custom extension for the server as well. It seems quite weird to be * setting a custom extension for both client and server in a single * SSL_CTX - but theoretically possible. This isn't possible in the * new API. Therefore, if we have V1 serverinfo we use the old API. We * also use the old API even if we have V2 serverinfo but the context * looks like an old style <= TLSv1.2 extension. / if (version == SSL_SERVERINFOV1 \|\| context == SYNTHV1CONTEXT) { if (!SSL_CTX_add_server_custom_ext(ctx, ext_type, serverinfo_srv_add_cb, NULL, NULL, serverinfo_srv_parse_cb, NULL)) return 0; } else { if (!SSL_CTX_add_custom_ext(ctx, ext_type, context, serverinfoex_srv_add_cb, NULL, NULL, serverinfoex_srv_parse_cb, NULL)) return 0; } } return 1; } static size_t extension_contextoff(unsigned int version) { return version == SSL_SERVERINFOV1 ? 4 : 0; } static size_t extension_append_length(unsigned int version, size_t extension_length) { return extension_length + extension_contextoff(version); } static void extension_append(unsigned int version, const unsigned char extension, const size_t extension_length, unsigned char serverinfo) { const size_t contextoff = extension_contextoff(version); if (contextoff > 0) { / We know this only uses the last 2 bytes / serverinfo[0] = 0; serverinfo[1] = 0; serverinfo[2] = (SYNTHV1CONTEXT >> 8) & 0xff; serverinfo[3] = SYNTHV1CONTEXT & 0xff; } memcpy(serverinfo + contextoff, extension, extension_length); } int SSL_CTX_use_serverinfo_ex(SSL_CTX ctx, unsigned int version, const unsigned char serverinfo, size_t serverinfo_length) { unsigned char new_serverinfo = NULL; if (ctx == NULL \|\| serverinfo == NULL \|\| serverinfo_length == 0) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } if (version == SSL_SERVERINFOV1) { /* * Convert serverinfo version v1 to v2 and call yourself recursively * over the converted serverinfo. / const size_t sinfo_length = extension_append_length(SSL_SERVERINFOV1, serverinfo_length); unsigned char sinfo; int ret; sinfo = OPENSSL_malloc(sinfo_length); if (sinfo == NULL) return 0; extension_append(SSL_SERVERINFOV1, serverinfo, serverinfo_length, sinfo); ret = SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV2, sinfo, sinfo_length); OPENSSL_free(sinfo); return ret; } if (!serverinfo_process_buffer(version, serverinfo, serverinfo_length, NULL)) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SERVERINFO_DATA); return 0; } if (ctx->cert->key == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } new_serverinfo = OPENSSL_realloc(ctx->cert->key->serverinfo, serverinfo_length); if (new_serverinfo == NULL) return 0; ctx->cert->key->serverinfo = new_serverinfo; memcpy(ctx->cert->key->serverinfo, serverinfo, serverinfo_length); ctx->cert->key->serverinfo_length = serverinfo_length; /* * Now that the serverinfo is validated and stored, go ahead and * register callbacks. / if (!serverinfo_process_buffer(version, serverinfo, serverinfo_length, ctx)) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SERVERINFO_DATA); return 0; } return 1; } int SSL_CTX_use_serverinfo(SSL_CTX ctx, const unsigned char serverinfo, size_t serverinfo_length) { return SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV1, serverinfo, serverinfo_length); } int SSL_CTX_use_serverinfo_file(SSL_CTX ctx, const char file) { unsigned char serverinfo = NULL; unsigned char tmp; size_t serverinfo_length = 0; unsigned char extension = 0; long extension_length = 0; char name = NULL; char header = NULL; unsigned int name_len; int ret = 0; BIO bin = NULL; size_t num_extensions = 0; if (ctx == NULL \|\| file == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); goto end; } bin = BIO_new(BIO_s_file()); if (bin == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(bin, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } for (num_extensions = 0;; num_extensions++) { unsigned int version; size_t append_length; if (PEM_read_bio(bin, &name, &header, &extension, &extension_length) == 0) { / * There must be at least one extension in this file / if (num_extensions == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_PEM_EXTENSIONS); goto end; } else / End of file, we're done / break; } / Check that PEM name starts with "BEGIN SERVERINFO FOR " / name_len = strlen(name); if (name_len < sizeof(NAME_PREFIX1) - 1) { ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_TOO_SHORT); goto end; } if (HAS_PREFIX(name, NAME_PREFIX1)) { version = SSL_SERVERINFOV1; } else { if (name_len < sizeof(NAME_PREFIX2) - 1) { ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_TOO_SHORT); goto end; } if (!HAS_PREFIX(name, NAME_PREFIX2)) { ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_BAD_PREFIX); goto end; } version = SSL_SERVERINFOV2; } / * Check that the decoded PEM data is plausible (valid length field) / if (version == SSL_SERVERINFOV1) { / 4 byte header: 2 bytes type, 2 bytes len / if (extension_length < 4 \|\| (extension[2] << 8) + extension[3] != extension_length - 4) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA); goto end; } } else { / 8 byte header: 4 bytes context, 2 bytes type, 2 bytes len / if (extension_length < 8 \|\| (extension[6] << 8) + extension[7] != extension_length - 8) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA); goto end; } } / Append the decoded extension to the serverinfo buffer / append_length = extension_append_length(version, extension_length); tmp = OPENSSL_realloc(serverinfo, serverinfo_length + append_length); if (tmp == NULL) goto end; serverinfo = tmp; extension_append(version, extension, extension_length, serverinfo + serverinfo_length); serverinfo_length += append_length; OPENSSL_free(name); name = NULL; OPENSSL_free(header); header = NULL; OPENSSL_free(extension); extension = NULL; } ret = SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV2, serverinfo, serverinfo_length); end: / SSL_CTX_use_serverinfo makes a local copy of the serverinfo. / OPENSSL_free(name); OPENSSL_free(header); OPENSSL_free(extension); OPENSSL_free(serverinfo); BIO_free(bin); return ret; } static int ssl_set_cert_and_key(SSL ssl, SSL_CTX ctx, X509 x509, EVP_PKEY privatekey, STACK_OF(X509) chain, int override) { int ret = 0; size_t i; int j; int rv; CERT c; STACK_OF(X509) dup_chain = NULL; EVP_PKEY pubkey = NULL; SSL_CONNECTION sc = NULL; if (ctx == NULL && (sc = SSL_CONNECTION_FROM_SSL(ssl)) == NULL) return 0; c = sc != NULL ? sc->cert : ctx->cert; /* Do all security checks before anything else / rv = ssl_security_cert(sc, ctx, x509, 0, 1); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); goto out; } for (j = 0; j < sk_X509_num(chain); j++) { rv = ssl_security_cert(sc, ctx, sk_X509_value(chain, j), 0, 0); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); goto out; } } pubkey = X509_get_pubkey(x509); / bumps reference / if (pubkey == NULL) goto out; if (privatekey == NULL) { privatekey = pubkey; } else { / For RSA, which has no parameters, missing returns 0 / if (EVP_PKEY_missing_parameters(privatekey)) { if (EVP_PKEY_missing_parameters(pubkey)) { / nobody has parameters? - error / ERR_raise(ERR_LIB_SSL, SSL_R_MISSING_PARAMETERS); goto out; } else { / copy to privatekey from pubkey / if (!EVP_PKEY_copy_parameters(privatekey, pubkey)) { ERR_raise(ERR_LIB_SSL, SSL_R_COPY_PARAMETERS_FAILED); goto out; } } } else if (EVP_PKEY_missing_parameters(pubkey)) { / copy to pubkey from privatekey / if (!EVP_PKEY_copy_parameters(pubkey, privatekey)) { ERR_raise(ERR_LIB_SSL, SSL_R_COPY_PARAMETERS_FAILED); goto out; } } / else both have parameters / / check that key <-> cert match / if (EVP_PKEY_eq(pubkey, privatekey) != 1) { ERR_raise(ERR_LIB_SSL, SSL_R_PRIVATE_KEY_MISMATCH); goto out; } } if (ssl_cert_lookup_by_pkey(pubkey, &i, ctx) == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE); goto out; } if (!override && (c->pkeys[i].x509 != NULL \|\| c->pkeys[i].privatekey != NULL \|\| c->pkeys[i].chain != NULL)) { / No override, and something already there / ERR_raise(ERR_LIB_SSL, SSL_R_NOT_REPLACING_CERTIFICATE); goto out; } if (chain != NULL) { dup_chain = X509_chain_up_ref(chain); if (dup_chain == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto out; } } OSSL_STACK_OF_X509_free(c->pkeys[i].chain); c->pkeys[i].chain = dup_chain; X509_free(c->pkeys[i].x509); X509_up_ref(x509); c->pkeys[i].x509 = x509; EVP_PKEY_free(c->pkeys[i].privatekey); EVP_PKEY_up_ref(privatekey); c->pkeys[i].privatekey = privatekey; c->key = &(c->pkeys[i]); ret = 1; out: EVP_PKEY_free(pubkey); return ret; } int SSL_use_cert_and_key(SSL ssl, X509 x509, EVP_PKEY privatekey, STACK_OF(X509) chain, int override) { return ssl_set_cert_and_key(ssl, NULL, x509, privatekey, chain, override); } int SSL_CTX_use_cert_and_key(SSL_CTX ctx, X509 x509, EVP_PKEY privatekey, STACK_OF(X509) *chain, int override) { return ssl_set_cert_and_key(NULL, ctx, x509, privatekey, chain, override); }
./openssl/ssl/ssl_cert.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <sys/types.h> #include "internal/nelem.h" #include "internal/o_dir.h" #include <openssl/bio.h> #include <openssl/pem.h> #include <openssl/store.h> #include <openssl/x509v3.h> #include <openssl/dh.h> #include <openssl/bn.h> #include <openssl/crypto.h> #include "internal/refcount.h" #include "ssl_local.h" #include "ssl_cert_table.h" #include "internal/thread_once.h" #ifndef OPENSSL_NO_POSIX_IO # include <sys/stat.h> # ifdef _WIN32 # define stat _stat # endif # ifndef S_ISDIR # define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR) # endif #endif static int ssl_security_default_callback(const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex); static CRYPTO_ONCE ssl_x509_store_ctx_once = CRYPTO_ONCE_STATIC_INIT; static volatile int ssl_x509_store_ctx_idx = -1; DEFINE_RUN_ONCE_STATIC(ssl_x509_store_ctx_init) { ssl_x509_store_ctx_idx = X509_STORE_CTX_get_ex_new_index(0, "SSL for verify callback", NULL, NULL, NULL); return ssl_x509_store_ctx_idx >= 0; } int SSL_get_ex_data_X509_STORE_CTX_idx(void) { if (!RUN_ONCE(&ssl_x509_store_ctx_once, ssl_x509_store_ctx_init)) return -1; return ssl_x509_store_ctx_idx; } CERT ssl_cert_new(size_t ssl_pkey_num) { CERT ret = NULL; / Should never happen / if (!ossl_assert(ssl_pkey_num >= SSL_PKEY_NUM)) return NULL; ret = OPENSSL_zalloc(sizeof(ret)); if (ret == NULL) return NULL; ret->ssl_pkey_num = ssl_pkey_num; ret->pkeys = OPENSSL_zalloc(ret->ssl_pkey_num * sizeof(CERT_PKEY)); if (ret->pkeys == NULL) { OPENSSL_free(ret); return NULL; } ret->key = &(ret->pkeys[SSL_PKEY_RSA]); ret->sec_cb = ssl_security_default_callback; ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL; ret->sec_ex = NULL; if (!CRYPTO_NEW_REF(&ret->references, 1)) { OPENSSL_free(ret->pkeys); OPENSSL_free(ret); return NULL; } return ret; } CERT ssl_cert_dup(CERT cert) { CERT ret = OPENSSL_zalloc(sizeof(ret)); size_t i; #ifndef OPENSSL_NO_COMP_ALG int j; #endif if (ret == NULL) return NULL; ret->ssl_pkey_num = cert->ssl_pkey_num; ret->pkeys = OPENSSL_zalloc(ret->ssl_pkey_num * sizeof(CERT_PKEY)); if (ret->pkeys == NULL) { OPENSSL_free(ret); return NULL; } ret->key = &ret->pkeys[cert->key - cert->pkeys]; if (!CRYPTO_NEW_REF(&ret->references, 1)) { OPENSSL_free(ret->pkeys); OPENSSL_free(ret); return NULL; } if (cert->dh_tmp != NULL) { ret->dh_tmp = cert->dh_tmp; EVP_PKEY_up_ref(ret->dh_tmp); } ret->dh_tmp_cb = cert->dh_tmp_cb; ret->dh_tmp_auto = cert->dh_tmp_auto; for (i = 0; i < ret->ssl_pkey_num; i++) { CERT_PKEY cpk = cert->pkeys + i; CERT_PKEY rpk = ret->pkeys + i; if (cpk->x509 != NULL) { rpk->x509 = cpk->x509; X509_up_ref(rpk->x509); } if (cpk->privatekey != NULL) { rpk->privatekey = cpk->privatekey; EVP_PKEY_up_ref(cpk->privatekey); } if (cpk->chain) { rpk->chain = X509_chain_up_ref(cpk->chain); if (!rpk->chain) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } } if (cpk->serverinfo != NULL) { /* Just copy everything. / rpk->serverinfo = OPENSSL_memdup(cpk->serverinfo, cpk->serverinfo_length); if (rpk->serverinfo == NULL) goto err; rpk->serverinfo_length = cpk->serverinfo_length; } #ifndef OPENSSL_NO_COMP_ALG for (j = TLSEXT_comp_cert_none; j < TLSEXT_comp_cert_limit; j++) { if (cpk->comp_cert[j] != NULL) { if (!OSSL_COMP_CERT_up_ref(cpk->comp_cert[j])) goto err; rpk->comp_cert[j] = cpk->comp_cert[j]; } } #endif } / Configured sigalgs copied across / if (cert->conf_sigalgs) { ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen sizeof(cert->conf_sigalgs)); if (ret->conf_sigalgs == NULL) goto err; memcpy(ret->conf_sigalgs, cert->conf_sigalgs, cert->conf_sigalgslen sizeof(cert->conf_sigalgs)); ret->conf_sigalgslen = cert->conf_sigalgslen; } else ret->conf_sigalgs = NULL; if (cert->client_sigalgs) { ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen sizeof(cert->client_sigalgs)); if (ret->client_sigalgs == NULL) goto err; memcpy(ret->client_sigalgs, cert->client_sigalgs, cert->client_sigalgslen sizeof(cert->client_sigalgs)); ret->client_sigalgslen = cert->client_sigalgslen; } else ret->client_sigalgs = NULL; / Copy any custom client certificate types / if (cert->ctype) { ret->ctype = OPENSSL_memdup(cert->ctype, cert->ctype_len); if (ret->ctype == NULL) goto err; ret->ctype_len = cert->ctype_len; } ret->cert_flags = cert->cert_flags; ret->cert_cb = cert->cert_cb; ret->cert_cb_arg = cert->cert_cb_arg; if (cert->verify_store) { X509_STORE_up_ref(cert->verify_store); ret->verify_store = cert->verify_store; } if (cert->chain_store) { X509_STORE_up_ref(cert->chain_store); ret->chain_store = cert->chain_store; } ret->sec_cb = cert->sec_cb; ret->sec_level = cert->sec_level; ret->sec_ex = cert->sec_ex; if (!custom_exts_copy(&ret->custext, &cert->custext)) goto err; #ifndef OPENSSL_NO_PSK if (cert->psk_identity_hint) { ret->psk_identity_hint = OPENSSL_strdup(cert->psk_identity_hint); if (ret->psk_identity_hint == NULL) goto err; } #endif return ret; err: ssl_cert_free(ret); return NULL; } / Free up and clear all certificates and chains / void ssl_cert_clear_certs(CERT c) { size_t i; #ifndef OPENSSL_NO_COMP_ALG int j; #endif if (c == NULL) return; for (i = 0; i < c->ssl_pkey_num; i++) { CERT_PKEY cpk = c->pkeys + i; X509_free(cpk->x509); cpk->x509 = NULL; EVP_PKEY_free(cpk->privatekey); cpk->privatekey = NULL; OSSL_STACK_OF_X509_free(cpk->chain); cpk->chain = NULL; OPENSSL_free(cpk->serverinfo); cpk->serverinfo = NULL; cpk->serverinfo_length = 0; #ifndef OPENSSL_NO_COMP_ALG for (j = 0; j < TLSEXT_comp_cert_limit; j++) { OSSL_COMP_CERT_free(cpk->comp_cert[j]); cpk->comp_cert[j] = NULL; cpk->cert_comp_used = 0; } #endif } } void ssl_cert_free(CERT c) { int i; if (c == NULL) return; CRYPTO_DOWN_REF(&c->references, &i); REF_PRINT_COUNT("CERT", c); if (i > 0) return; REF_ASSERT_ISNT(i < 0); EVP_PKEY_free(c->dh_tmp); ssl_cert_clear_certs(c); OPENSSL_free(c->conf_sigalgs); OPENSSL_free(c->client_sigalgs); OPENSSL_free(c->ctype); X509_STORE_free(c->verify_store); X509_STORE_free(c->chain_store); custom_exts_free(&c->custext); #ifndef OPENSSL_NO_PSK OPENSSL_free(c->psk_identity_hint); #endif OPENSSL_free(c->pkeys); CRYPTO_FREE_REF(&c->references); OPENSSL_free(c); } int ssl_cert_set0_chain(SSL_CONNECTION s, SSL_CTX ctx, STACK_OF(X509) chain) { int i, r; CERT_PKEY cpk = s != NULL ? s->cert->key : ctx->cert->key; if (!cpk) return 0; for (i = 0; i < sk_X509_num(chain); i++) { X509 x = sk_X509_value(chain, i); r = ssl_security_cert(s, ctx, x, 0, 0); if (r != 1) { ERR_raise(ERR_LIB_SSL, r); return 0; } } OSSL_STACK_OF_X509_free(cpk->chain); cpk->chain = chain; return 1; } int ssl_cert_set1_chain(SSL_CONNECTION s, SSL_CTX ctx, STACK_OF(X509) chain) { STACK_OF(X509) dchain; if (!chain) return ssl_cert_set0_chain(s, ctx, NULL); dchain = X509_chain_up_ref(chain); if (!dchain) return 0; if (!ssl_cert_set0_chain(s, ctx, dchain)) { OSSL_STACK_OF_X509_free(dchain); return 0; } return 1; } int ssl_cert_add0_chain_cert(SSL_CONNECTION s, SSL_CTX ctx, X509 x) { int r; CERT_PKEY cpk = s ? s->cert->key : ctx->cert->key; if (!cpk) return 0; r = ssl_security_cert(s, ctx, x, 0, 0); if (r != 1) { ERR_raise(ERR_LIB_SSL, r); return 0; } if (!cpk->chain) cpk->chain = sk_X509_new_null(); if (!cpk->chain \|\| !sk_X509_push(cpk->chain, x)) return 0; return 1; } int ssl_cert_add1_chain_cert(SSL_CONNECTION s, SSL_CTX ctx, X509 x) { if (!ssl_cert_add0_chain_cert(s, ctx, x)) return 0; X509_up_ref(x); return 1; } int ssl_cert_select_current(CERT c, X509 x) { size_t i; if (x == NULL) return 0; for (i = 0; i < c->ssl_pkey_num; i++) { CERT_PKEY cpk = c->pkeys + i; if (cpk->x509 == x && cpk->privatekey) { c->key = cpk; return 1; } } for (i = 0; i < c->ssl_pkey_num; i++) { CERT_PKEY cpk = c->pkeys + i; if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x)) { c->key = cpk; return 1; } } return 0; } int ssl_cert_set_current(CERT c, long op) { size_t i, idx; if (!c) return 0; if (op == SSL_CERT_SET_FIRST) idx = 0; else if (op == SSL_CERT_SET_NEXT) { idx = (size_t)(c->key - c->pkeys + 1); if (idx >= c->ssl_pkey_num) return 0; } else return 0; for (i = idx; i < c->ssl_pkey_num; i++) { CERT_PKEY cpk = c->pkeys + i; if (cpk->x509 && cpk->privatekey) { c->key = cpk; return 1; } } return 0; } void ssl_cert_set_cert_cb(CERT c, int (cb) (SSL ssl, void arg), void arg) { c->cert_cb = cb; c->cert_cb_arg = arg; } / * Verify a certificate chain/raw public key * Return codes: * 1: Verify success * 0: Verify failure or error * -1: Retry required / static int ssl_verify_internal(SSL_CONNECTION s, STACK_OF(X509) sk, EVP_PKEY rpk) { X509 x; int i = 0; X509_STORE verify_store; X509_STORE_CTX ctx = NULL; X509_VERIFY_PARAM param; SSL_CTX sctx; / Something must be passed in / if ((sk == NULL \|\| sk_X509_num(sk) == 0) && rpk == NULL) return 0; / Only one can be set / if (sk != NULL && rpk != NULL) return 0; sctx = SSL_CONNECTION_GET_CTX(s); if (s->cert->verify_store) verify_store = s->cert->verify_store; else verify_store = sctx->cert_store; ctx = X509_STORE_CTX_new_ex(sctx->libctx, sctx->propq); if (ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); return 0; } if (sk != NULL) { x = sk_X509_value(sk, 0); if (!X509_STORE_CTX_init(ctx, verify_store, x, sk)) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto end; } } else { if (!X509_STORE_CTX_init_rpk(ctx, verify_store, rpk)) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto end; } } param = X509_STORE_CTX_get0_param(ctx); / * XXX: Separate @AUTHSECLEVEL and @TLSSECLEVEL would be useful at some * point, for now a single @SECLEVEL sets the same policy for TLS crypto * and PKI authentication. / X509_VERIFY_PARAM_set_auth_level(param, SSL_get_security_level(SSL_CONNECTION_GET_SSL(s))); / Set suite B flags if needed / X509_STORE_CTX_set_flags(ctx, tls1_suiteb(s)); if (!X509_STORE_CTX_set_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx(), s)) { goto end; } / Verify via DANE if enabled / if (DANETLS_ENABLED(&s->dane)) X509_STORE_CTX_set0_dane(ctx, &s->dane); / * We need to inherit the verify parameters. These can be determined by * the context: if its a server it will verify SSL client certificates or * vice versa. / X509_STORE_CTX_set_default(ctx, s->server ? "ssl_client" : "ssl_server"); / * Anything non-default in "s->param" should overwrite anything in the ctx. / X509_VERIFY_PARAM_set1(param, s->param); if (s->verify_callback) X509_STORE_CTX_set_verify_cb(ctx, s->verify_callback); if (sctx->app_verify_callback != NULL) { i = sctx->app_verify_callback(ctx, sctx->app_verify_arg); } else { i = X509_verify_cert(ctx); / We treat an error in the same way as a failure to verify / if (i < 0) i = 0; } s->verify_result = X509_STORE_CTX_get_error(ctx); OSSL_STACK_OF_X509_free(s->verified_chain); s->verified_chain = NULL; if (sk != NULL && X509_STORE_CTX_get0_chain(ctx) != NULL) { s->verified_chain = X509_STORE_CTX_get1_chain(ctx); if (s->verified_chain == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); i = 0; } } / Move peername from the store context params to the SSL handle's / X509_VERIFY_PARAM_move_peername(s->param, param); end: X509_STORE_CTX_free(ctx); return i; } / * Verify a raw public key * Return codes: * 1: Verify success * 0: Verify failure or error * -1: Retry required / int ssl_verify_rpk(SSL_CONNECTION s, EVP_PKEY rpk) { return ssl_verify_internal(s, NULL, rpk); } / * Verify a certificate chain * Return codes: * 1: Verify success * 0: Verify failure or error * -1: Retry required / int ssl_verify_cert_chain(SSL_CONNECTION s, STACK_OF(X509) sk) { return ssl_verify_internal(s, sk, NULL); } static void set0_CA_list(STACK_OF(X509_NAME) ca_list, STACK_OF(X509_NAME) name_list) { sk_X509_NAME_pop_free(ca_list, X509_NAME_free); ca_list = name_list; } STACK_OF(X509_NAME) SSL_dup_CA_list(const STACK_OF(X509_NAME) sk) { int i; const int num = sk_X509_NAME_num(sk); STACK_OF(X509_NAME) ret; X509_NAME name; ret = sk_X509_NAME_new_reserve(NULL, num); if (ret == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return NULL; } for (i = 0; i < num; i++) { name = X509_NAME_dup(sk_X509_NAME_value(sk, i)); if (name == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); sk_X509_NAME_pop_free(ret, X509_NAME_free); return NULL; } sk_X509_NAME_push(ret, name); /* Cannot fail after reserve call / } return ret; } void SSL_set0_CA_list(SSL s, STACK_OF(X509_NAME) name_list) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; set0_CA_list(&sc->ca_names, name_list); } void SSL_CTX_set0_CA_list(SSL_CTX ctx, STACK_OF(X509_NAME) name_list) { set0_CA_list(&ctx->ca_names, name_list); } const STACK_OF(X509_NAME) SSL_CTX_get0_CA_list(const SSL_CTX ctx) { return ctx->ca_names; } const STACK_OF(X509_NAME) SSL_get0_CA_list(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->ca_names != NULL ? sc->ca_names : s->ctx->ca_names; } void SSL_CTX_set_client_CA_list(SSL_CTX ctx, STACK_OF(X509_NAME) name_list) { set0_CA_list(&ctx->client_ca_names, name_list); } STACK_OF(X509_NAME) SSL_CTX_get_client_CA_list(const SSL_CTX ctx) { return ctx->client_ca_names; } void SSL_set_client_CA_list(SSL s, STACK_OF(X509_NAME) name_list) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; set0_CA_list(&sc->client_ca_names, name_list); } const STACK_OF(X509_NAME) SSL_get0_peer_CA_list(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->s3.tmp.peer_ca_names; } STACK_OF(X509_NAME) SSL_get_client_CA_list(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (!sc->server) return sc->s3.tmp.peer_ca_names; return sc->client_ca_names != NULL ? sc->client_ca_names : s->ctx->client_ca_names; } static int add_ca_name(STACK_OF(X509_NAME) *sk, const X509 x) { X509_NAME name; if (x == NULL) return 0; if (sk == NULL && ((sk = sk_X509_NAME_new_null()) == NULL)) return 0; if ((name = X509_NAME_dup(X509_get_subject_name(x))) == NULL) return 0; if (!sk_X509_NAME_push(sk, name)) { X509_NAME_free(name); return 0; } return 1; } int SSL_add1_to_CA_list(SSL ssl, const X509 x) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; return add_ca_name(&sc->ca_names, x); } int SSL_CTX_add1_to_CA_list(SSL_CTX ctx, const X509 x) { return add_ca_name(&ctx->ca_names, x); } / * The following two are older names are to be replaced with * SSL(_CTX)_add1_to_CA_list / int SSL_add_client_CA(SSL ssl, X509 x) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; return add_ca_name(&sc->client_ca_names, x); } int SSL_CTX_add_client_CA(SSL_CTX ctx, X509 x) { return add_ca_name(&ctx->client_ca_names, x); } static int xname_cmp(const X509_NAME a, const X509_NAME b) { unsigned char abuf = NULL, bbuf = NULL; int alen, blen, ret; /* X509_NAME_cmp() itself casts away constness in this way, so * assume it's safe: / alen = i2d_X509_NAME((X509_NAME )a, &abuf); blen = i2d_X509_NAME((X509_NAME )b, &bbuf); if (alen < 0 \|\| blen < 0) ret = -2; else if (alen != blen) ret = alen - blen; else / alen == blen / ret = memcmp(abuf, bbuf, alen); OPENSSL_free(abuf); OPENSSL_free(bbuf); return ret; } static int xname_sk_cmp(const X509_NAME const a, const X509_NAME const b) { return xname_cmp(a, b); } static unsigned long xname_hash(const X509_NAME a) { /* This returns 0 also if SHA1 is not available / return X509_NAME_hash_ex((X509_NAME )a, NULL, NULL, NULL); } STACK_OF(X509_NAME) SSL_load_client_CA_file_ex(const char file, OSSL_LIB_CTX libctx, const char propq) { BIO in = BIO_new(BIO_s_file()); X509 x = NULL; X509_NAME xn = NULL; STACK_OF(X509_NAME) ret = NULL; LHASH_OF(X509_NAME) name_hash = lh_X509_NAME_new(xname_hash, xname_cmp); OSSL_LIB_CTX prev_libctx = NULL; if (name_hash == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB); goto err; } x = X509_new_ex(libctx, propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } if (BIO_read_filename(in, file) <= 0) goto err; /* Internally lh_X509_NAME_retrieve() needs the libctx to retrieve SHA1 / prev_libctx = OSSL_LIB_CTX_set0_default(libctx); for (;;) { if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL) break; if (ret == NULL) { ret = sk_X509_NAME_new_null(); if (ret == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } } if ((xn = X509_get_subject_name(x)) == NULL) goto err; / check for duplicates / xn = X509_NAME_dup(xn); if (xn == NULL) goto err; if (lh_X509_NAME_retrieve(name_hash, xn) != NULL) { / Duplicate. / X509_NAME_free(xn); xn = NULL; } else { lh_X509_NAME_insert(name_hash, xn); if (!sk_X509_NAME_push(ret, xn)) goto err; } } goto done; err: X509_NAME_free(xn); sk_X509_NAME_pop_free(ret, X509_NAME_free); ret = NULL; done: / restore the old libctx / OSSL_LIB_CTX_set0_default(prev_libctx); BIO_free(in); X509_free(x); lh_X509_NAME_free(name_hash); if (ret != NULL) ERR_clear_error(); return ret; } STACK_OF(X509_NAME) SSL_load_client_CA_file(const char file) { return SSL_load_client_CA_file_ex(file, NULL, NULL); } int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) stack, const char file) { BIO in; X509 x = NULL; X509_NAME xn = NULL; int ret = 1; int (oldcmp) (const X509_NAME const a, const X509_NAME const b); oldcmp = sk_X509_NAME_set_cmp_func(stack, xname_sk_cmp); in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB); goto err; } if (BIO_read_filename(in, file) <= 0) goto err; for (;;) { if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL) break; if ((xn = X509_get_subject_name(x)) == NULL) goto err; xn = X509_NAME_dup(xn); if (xn == NULL) goto err; if (sk_X509_NAME_find(stack, xn) >= 0) { / Duplicate. / X509_NAME_free(xn); } else if (!sk_X509_NAME_push(stack, xn)) { X509_NAME_free(xn); goto err; } } ERR_clear_error(); goto done; err: ret = 0; done: BIO_free(in); X509_free(x); (void)sk_X509_NAME_set_cmp_func(stack, oldcmp); return ret; } int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) stack, const char dir) { OPENSSL_DIR_CTX d = NULL; const char filename; int ret = 0; / Note that a side effect is that the CAs will be sorted by name / while ((filename = OPENSSL_DIR_read(&d, dir))) { char buf[1024]; int r; #ifndef OPENSSL_NO_POSIX_IO struct stat st; #else / Cannot use stat so just skip current and parent directories / if (strcmp(filename, ".") == 0 \|\| strcmp(filename, "..") == 0) continue; #endif if (strlen(dir) + strlen(filename) + 2 > sizeof(buf)) { ERR_raise(ERR_LIB_SSL, SSL_R_PATH_TOO_LONG); goto err; } #ifdef OPENSSL_SYS_VMS r = BIO_snprintf(buf, sizeof(buf), "%s%s", dir, filename); #else r = BIO_snprintf(buf, sizeof(buf), "%s/%s", dir, filename); #endif #ifndef OPENSSL_NO_POSIX_IO / Skip subdirectories / if (!stat(buf, &st) && S_ISDIR(st.st_mode)) continue; #endif if (r <= 0 \|\| r >= (int)sizeof(buf)) goto err; if (!SSL_add_file_cert_subjects_to_stack(stack, buf)) goto err; } if (errno) { ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(), "calling OPENSSL_dir_read(%s)", dir); ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto err; } ret = 1; err: if (d) OPENSSL_DIR_end(&d); return ret; } static int add_uris_recursive(STACK_OF(X509_NAME) stack, const char uri, int depth) { int ok = 1; OSSL_STORE_CTX ctx = NULL; X509 x = NULL; X509_NAME xn = NULL; if ((ctx = OSSL_STORE_open(uri, NULL, NULL, NULL, NULL)) == NULL) goto err; while (!OSSL_STORE_eof(ctx) && !OSSL_STORE_error(ctx)) { OSSL_STORE_INFO info = OSSL_STORE_load(ctx); int infotype = info == 0 ? 0 : OSSL_STORE_INFO_get_type(info); if (info == NULL) continue; if (infotype == OSSL_STORE_INFO_NAME) { / * This is an entry in the "directory" represented by the current * uri. if \|depth\| allows, dive into it. / if (depth > 0) ok = add_uris_recursive(stack, OSSL_STORE_INFO_get0_NAME(info), depth - 1); } else if (infotype == OSSL_STORE_INFO_CERT) { if ((x = OSSL_STORE_INFO_get0_CERT(info)) == NULL \|\| (xn = X509_get_subject_name(x)) == NULL \|\| (xn = X509_NAME_dup(xn)) == NULL) goto err; if (sk_X509_NAME_find(stack, xn) >= 0) { / Duplicate. / X509_NAME_free(xn); } else if (!sk_X509_NAME_push(stack, xn)) { X509_NAME_free(xn); goto err; } } OSSL_STORE_INFO_free(info); } ERR_clear_error(); goto done; err: ok = 0; done: OSSL_STORE_close(ctx); return ok; } int SSL_add_store_cert_subjects_to_stack(STACK_OF(X509_NAME) stack, const char store) { int (oldcmp) (const X509_NAME const a, const X509_NAME const b) = sk_X509_NAME_set_cmp_func(stack, xname_sk_cmp); int ret = add_uris_recursive(stack, store, 1); (void)sk_X509_NAME_set_cmp_func(stack, oldcmp); return ret; } /* Build a certificate chain for current certificate / int ssl_build_cert_chain(SSL_CONNECTION s, SSL_CTX ctx, int flags) { CERT c = s != NULL ? s->cert : ctx->cert; CERT_PKEY cpk = c->key; X509_STORE chain_store = NULL; X509_STORE_CTX xs_ctx = NULL; STACK_OF(X509) chain = NULL, untrusted = NULL; X509 x; SSL_CTX real_ctx = (s == NULL) ? ctx : SSL_CONNECTION_GET_CTX(s); int i, rv = 0; if (cpk->x509 == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_SET); goto err; } / Rearranging and check the chain: add everything to a store / if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) { chain_store = X509_STORE_new(); if (chain_store == NULL) goto err; for (i = 0; i < sk_X509_num(cpk->chain); i++) { x = sk_X509_value(cpk->chain, i); if (!X509_STORE_add_cert(chain_store, x)) goto err; } / Add EE cert too: it might be self signed / if (!X509_STORE_add_cert(chain_store, cpk->x509)) goto err; } else { if (c->chain_store != NULL) chain_store = c->chain_store; else chain_store = real_ctx->cert_store; if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED) untrusted = cpk->chain; } xs_ctx = X509_STORE_CTX_new_ex(real_ctx->libctx, real_ctx->propq); if (xs_ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } if (!X509_STORE_CTX_init(xs_ctx, chain_store, cpk->x509, untrusted)) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } / Set suite B flags if needed / X509_STORE_CTX_set_flags(xs_ctx, c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS); i = X509_verify_cert(xs_ctx); if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) { if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR) ERR_clear_error(); i = 1; rv = 2; } if (i > 0) chain = X509_STORE_CTX_get1_chain(xs_ctx); if (i <= 0) { i = X509_STORE_CTX_get_error(xs_ctx); ERR_raise_data(ERR_LIB_SSL, SSL_R_CERTIFICATE_VERIFY_FAILED, "Verify error:%s", X509_verify_cert_error_string(i)); goto err; } / Remove EE certificate from chain / x = sk_X509_shift(chain); X509_free(x); if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT) { if (sk_X509_num(chain) > 0) { / See if last cert is self signed / x = sk_X509_value(chain, sk_X509_num(chain) - 1); if (X509_get_extension_flags(x) & EXFLAG_SS) { x = sk_X509_pop(chain); X509_free(x); } } } / * Check security level of all CA certificates: EE will have been checked * already. / for (i = 0; i < sk_X509_num(chain); i++) { x = sk_X509_value(chain, i); rv = ssl_security_cert(s, ctx, x, 0, 0); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); OSSL_STACK_OF_X509_free(chain); rv = 0; goto err; } } OSSL_STACK_OF_X509_free(cpk->chain); cpk->chain = chain; if (rv == 0) rv = 1; err: if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) X509_STORE_free(chain_store); X509_STORE_CTX_free(xs_ctx); return rv; } int ssl_cert_set_cert_store(CERT c, X509_STORE store, int chain, int ref) { X509_STORE pstore; if (chain) pstore = &c->chain_store; else pstore = &c->verify_store; X509_STORE_free(pstore); pstore = store; if (ref && store) X509_STORE_up_ref(store); return 1; } int ssl_cert_get_cert_store(CERT c, X509_STORE *pstore, int chain) { pstore = (chain ? c->chain_store : c->verify_store); return 1; } int ssl_get_security_level_bits(const SSL s, const SSL_CTX ctx, int levelp) { int level; / * note that there's a corresponding minbits_table * in crypto/x509/x509_vfy.c that's used for checking the security level * of RSA and DSA keys / static const int minbits_table[5 + 1] = { 0, 80, 112, 128, 192, 256 }; if (ctx != NULL) level = SSL_CTX_get_security_level(ctx); else level = SSL_get_security_level(s); if (level > 5) level = 5; else if (level < 0) level = 0; if (levelp != NULL) levelp = level; return minbits_table[level]; } static int ssl_security_default_callback(const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex) { int level, minbits, pfs_mask; const SSL_CONNECTION sc; minbits = ssl_get_security_level_bits(s, ctx, &level); if (level == 0) { / * No EDH keys weaker than 1024-bits even at level 0, otherwise, * anything goes. / if (op == SSL_SECOP_TMP_DH && bits < 80) return 0; return 1; } switch (op) { case SSL_SECOP_CIPHER_SUPPORTED: case SSL_SECOP_CIPHER_SHARED: case SSL_SECOP_CIPHER_CHECK: { const SSL_CIPHER c = other; /* No ciphers below security level / if (bits < minbits) return 0; / No unauthenticated ciphersuites / if (c->algorithm_auth & SSL_aNULL) return 0; / No MD5 mac ciphersuites / if (c->algorithm_mac & SSL_MD5) return 0; / SHA1 HMAC is 160 bits of security / if (minbits > 160 && c->algorithm_mac & SSL_SHA1) return 0; / Level 3: forward secure ciphersuites only / pfs_mask = SSL_kDHE \| SSL_kECDHE \| SSL_kDHEPSK \| SSL_kECDHEPSK; if (level >= 3 && c->min_tls != TLS1_3_VERSION && !(c->algorithm_mkey & pfs_mask)) return 0; break; } case SSL_SECOP_VERSION: if ((sc = SSL_CONNECTION_FROM_CONST_SSL(s)) == NULL) return 0; if (!SSL_CONNECTION_IS_DTLS(sc)) { / SSLv3, TLS v1.0 and TLS v1.1 only allowed at level 0 / if (nid <= TLS1_1_VERSION && level > 0) return 0; } else { / DTLS v1.0 only allowed at level 0 / if (DTLS_VERSION_LT(nid, DTLS1_2_VERSION) && level > 0) return 0; } break; case SSL_SECOP_COMPRESSION: if (level >= 2) return 0; break; case SSL_SECOP_TICKET: if (level >= 3) return 0; break; default: if (bits < minbits) return 0; } return 1; } int ssl_security(const SSL_CONNECTION s, int op, int bits, int nid, void other) { return s->cert->sec_cb(SSL_CONNECTION_GET_SSL(s), NULL, op, bits, nid, other, s->cert->sec_ex); } int ssl_ctx_security(const SSL_CTX ctx, int op, int bits, int nid, void other) { return ctx->cert->sec_cb(NULL, ctx, op, bits, nid, other, ctx->cert->sec_ex); } int ssl_cert_lookup_by_nid(int nid, size_t pidx, SSL_CTX ctx) { size_t i; for (i = 0; i < OSSL_NELEM(ssl_cert_info); i++) { if (ssl_cert_info[i].nid == nid) { pidx = i; return 1; } } for (i = 0; i < ctx->sigalg_list_len; i++) { if (ctx->ssl_cert_info[i].nid == nid) { pidx = SSL_PKEY_NUM + i; return 1; } } return 0; } const SSL_CERT_LOOKUP ssl_cert_lookup_by_pkey(const EVP_PKEY pk, size_t pidx, SSL_CTX ctx) { size_t i; / check classic pk types / for (i = 0; i < OSSL_NELEM(ssl_cert_info); i++) { const SSL_CERT_LOOKUP tmp_lu = &ssl_cert_info[i]; if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->nid)) \|\| EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->nid))) { if (pidx != NULL) pidx = i; return tmp_lu; } } / check provider-loaded pk types / for (i = 0; ctx->sigalg_list_len; i++) { SSL_CERT_LOOKUP tmp_lu = &(ctx->ssl_cert_info[i]); if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->nid)) \|\| EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->nid))) { if (pidx != NULL) pidx = SSL_PKEY_NUM + i; return &ctx->ssl_cert_info[i]; } } return NULL; } const SSL_CERT_LOOKUP ssl_cert_lookup_by_idx(size_t idx, SSL_CTX *ctx) { if (idx >= (OSSL_NELEM(ssl_cert_info) + ctx->sigalg_list_len)) return NULL; else if (idx >= (OSSL_NELEM(ssl_cert_info))) return &(ctx->ssl_cert_info[idx - SSL_PKEY_NUM]); return &ssl_cert_info[idx]; }
./openssl/ssl/d1_lib.c	/* * Copyright 2005-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/e_os.h" #include <stdio.h> #include <openssl/objects.h> #include <openssl/rand.h> #include "ssl_local.h" #include "internal/time.h" static int dtls1_handshake_write(SSL_CONNECTION s); static size_t dtls1_link_min_mtu(void); /* XDTLS: figure out the right values / static const size_t g_probable_mtu[] = { 1500, 512, 256 }; const SSL3_ENC_METHOD DTLSv1_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, SSL_ENC_FLAG_DTLS \| SSL_ENC_FLAG_EXPLICIT_IV, dtls1_set_handshake_header, dtls1_close_construct_packet, dtls1_handshake_write }; const SSL3_ENC_METHOD DTLSv1_2_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, SSL_ENC_FLAG_DTLS \| SSL_ENC_FLAG_EXPLICIT_IV \| SSL_ENC_FLAG_SIGALGS \| SSL_ENC_FLAG_SHA256_PRF \| SSL_ENC_FLAG_TLS1_2_CIPHERS, dtls1_set_handshake_header, dtls1_close_construct_packet, dtls1_handshake_write }; OSSL_TIME dtls1_default_timeout(void) { / * 2 hours, the 24 hours mentioned in the DTLSv1 spec is way too long for * http, the cache would over fill / return ossl_seconds2time(60 60 * 2); } int dtls1_new(SSL ssl) { DTLS1_STATE d1; SSL_CONNECTION s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return 0; if (!DTLS_RECORD_LAYER_new(&s->rlayer)) { return 0; } if (!ssl3_new(ssl)) return 0; if ((d1 = OPENSSL_zalloc(sizeof(d1))) == NULL) { ssl3_free(ssl); return 0; } d1->buffered_messages = pqueue_new(); d1->sent_messages = pqueue_new(); if (s->server) { d1->cookie_len = sizeof(s->d1->cookie); } d1->link_mtu = 0; d1->mtu = 0; if (d1->buffered_messages == NULL \|\| d1->sent_messages == NULL) { pqueue_free(d1->buffered_messages); pqueue_free(d1->sent_messages); OPENSSL_free(d1); ssl3_free(ssl); return 0; } s->d1 = d1; if (!ssl->method->ssl_clear(ssl)) return 0; return 1; } static void dtls1_clear_queues(SSL_CONNECTION s) { dtls1_clear_received_buffer(s); dtls1_clear_sent_buffer(s); } void dtls1_clear_received_buffer(SSL_CONNECTION s) { pitem item = NULL; hm_fragment frag = NULL; while ((item = pqueue_pop(s->d1->buffered_messages)) != NULL) { frag = (hm_fragment )item->data; dtls1_hm_fragment_free(frag); pitem_free(item); } } void dtls1_clear_sent_buffer(SSL_CONNECTION s) { pitem item = NULL; hm_fragment frag = NULL; while ((item = pqueue_pop(s->d1->sent_messages)) != NULL) { frag = (hm_fragment )item->data; if (frag->msg_header.is_ccs && frag->msg_header.saved_retransmit_state.wrlmethod != NULL && s->rlayer.wrl != frag->msg_header.saved_retransmit_state.wrl) { / * If we're freeing the CCS then we're done with the old wrl and it * can bee freed / frag->msg_header.saved_retransmit_state.wrlmethod->free(frag->msg_header.saved_retransmit_state.wrl); } dtls1_hm_fragment_free(frag); pitem_free(item); } } void dtls1_free(SSL ssl) { SSL_CONNECTION s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return; if (s->d1 != NULL) { dtls1_clear_queues(s); pqueue_free(s->d1->buffered_messages); pqueue_free(s->d1->sent_messages); } DTLS_RECORD_LAYER_free(&s->rlayer); ssl3_free(ssl); OPENSSL_free(s->d1); s->d1 = NULL; } int dtls1_clear(SSL ssl) { pqueue buffered_messages; pqueue sent_messages; size_t mtu; size_t link_mtu; SSL_CONNECTION s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return 0; DTLS_RECORD_LAYER_clear(&s->rlayer); if (s->d1) { DTLS_timer_cb timer_cb = s->d1->timer_cb; buffered_messages = s->d1->buffered_messages; sent_messages = s->d1->sent_messages; mtu = s->d1->mtu; link_mtu = s->d1->link_mtu; dtls1_clear_queues(s); memset(s->d1, 0, sizeof(s->d1)); /* Restore the timer callback from previous state / s->d1->timer_cb = timer_cb; if (s->server) { s->d1->cookie_len = sizeof(s->d1->cookie); } if (SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU) { s->d1->mtu = mtu; s->d1->link_mtu = link_mtu; } s->d1->buffered_messages = buffered_messages; s->d1->sent_messages = sent_messages; } if (!ssl3_clear(ssl)) return 0; if (ssl->method->version == DTLS_ANY_VERSION) s->version = DTLS_MAX_VERSION_INTERNAL; #ifndef OPENSSL_NO_DTLS1_METHOD else if (s->options & SSL_OP_CISCO_ANYCONNECT) s->client_version = s->version = DTLS1_BAD_VER; #endif else s->version = ssl->method->version; return 1; } long dtls1_ctrl(SSL ssl, int cmd, long larg, void parg) { int ret = 0; OSSL_TIME t; SSL_CONNECTION s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return 0; switch (cmd) { case DTLS_CTRL_GET_TIMEOUT: if (dtls1_get_timeout(s, &t)) { (struct timeval )parg = ossl_time_to_timeval(t); ret = 1; } break; case DTLS_CTRL_HANDLE_TIMEOUT: ret = dtls1_handle_timeout(s); break; case DTLS_CTRL_SET_LINK_MTU: if (larg < (long)dtls1_link_min_mtu()) return 0; s->d1->link_mtu = larg; return 1; case DTLS_CTRL_GET_LINK_MIN_MTU: return (long)dtls1_link_min_mtu(); case SSL_CTRL_SET_MTU: /* * We may not have a BIO set yet so can't call dtls1_min_mtu() * We'll have to make do with dtls1_link_min_mtu() and max overhead / if (larg < (long)dtls1_link_min_mtu() - DTLS1_MAX_MTU_OVERHEAD) return 0; s->d1->mtu = larg; return larg; default: ret = ssl3_ctrl(ssl, cmd, larg, parg); break; } return ret; } static void dtls1_bio_set_next_timeout(BIO bio, const DTLS1_STATE d1) { struct timeval tv = ossl_time_to_timeval(d1->next_timeout); BIO_ctrl(bio, BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0, &tv); } void dtls1_start_timer(SSL_CONNECTION s) { OSSL_TIME duration; SSL ssl = SSL_CONNECTION_GET_SSL(s); #ifndef OPENSSL_NO_SCTP / Disable timer for SCTP / if (BIO_dgram_is_sctp(SSL_get_wbio(ssl))) { s->d1->next_timeout = ossl_time_zero(); return; } #endif / * If timer is not set, initialize duration with 1 second or * a user-specified value if the timer callback is installed. / if (ossl_time_is_zero(s->d1->next_timeout)) { if (s->d1->timer_cb != NULL) s->d1->timeout_duration_us = s->d1->timer_cb(ssl, 0); else s->d1->timeout_duration_us = 1000000; } / Set timeout to current time plus duration / duration = ossl_us2time(s->d1->timeout_duration_us); s->d1->next_timeout = ossl_time_add(ossl_time_now(), duration); / set s->d1->next_timeout into ssl->rbio interface / dtls1_bio_set_next_timeout(SSL_get_rbio(ssl), s->d1); } int dtls1_get_timeout(const SSL_CONNECTION s, OSSL_TIME timeleft) { OSSL_TIME timenow; / If no timeout is set, just return NULL / if (ossl_time_is_zero(s->d1->next_timeout)) return 0; / Get current time / timenow = ossl_time_now(); / * If timer already expired or if remaining time is less than 15 ms, * set it to 0 to prevent issues because of small divergences with * socket timeouts. / timeleft = ossl_time_subtract(s->d1->next_timeout, timenow); if (ossl_time_compare(timeleft, ossl_ms2time(15)) <= 0) timeleft = ossl_time_zero(); return 1; } int dtls1_is_timer_expired(SSL_CONNECTION s) { OSSL_TIME timeleft; / Get time left until timeout, return false if no timer running / if (!dtls1_get_timeout(s, &timeleft)) return 0; / Return false if timer is not expired yet / if (!ossl_time_is_zero(timeleft)) return 0; / Timer expired, so return true / return 1; } static void dtls1_double_timeout(SSL_CONNECTION s) { s->d1->timeout_duration_us = 2; if (s->d1->timeout_duration_us > 60000000) s->d1->timeout_duration_us = 60000000; } void dtls1_stop_timer(SSL_CONNECTION s) { /* Reset everything / s->d1->timeout_num_alerts = 0; s->d1->next_timeout = ossl_time_zero(); s->d1->timeout_duration_us = 1000000; dtls1_bio_set_next_timeout(s->rbio, s->d1); / Clear retransmission buffer / dtls1_clear_sent_buffer(s); } int dtls1_check_timeout_num(SSL_CONNECTION s) { size_t mtu; SSL ssl = SSL_CONNECTION_GET_SSL(s); s->d1->timeout_num_alerts++; / Reduce MTU after 2 unsuccessful retransmissions / if (s->d1->timeout_num_alerts > 2 && !(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) { mtu = BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0, NULL); if (mtu < s->d1->mtu) s->d1->mtu = mtu; } if (s->d1->timeout_num_alerts > DTLS1_TMO_ALERT_COUNT) { / fail the connection, enough alerts have been sent / SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_READ_TIMEOUT_EXPIRED); return -1; } return 0; } int dtls1_handle_timeout(SSL_CONNECTION s) { /* if no timer is expired, don't do anything / if (!dtls1_is_timer_expired(s)) { return 0; } if (s->d1->timer_cb != NULL) s->d1->timeout_duration_us = s->d1->timer_cb(SSL_CONNECTION_GET_SSL(s), s->d1->timeout_duration_us); else dtls1_double_timeout(s); if (dtls1_check_timeout_num(s) < 0) { / SSLfatal() already called / return -1; } dtls1_start_timer(s); / Calls SSLfatal() if required / return dtls1_retransmit_buffered_messages(s); } #define LISTEN_SUCCESS 2 #define LISTEN_SEND_VERIFY_REQUEST 1 #ifndef OPENSSL_NO_SOCK int DTLSv1_listen(SSL ssl, BIO_ADDR client) { int next, n, ret = 0; unsigned char cookie[DTLS1_COOKIE_LENGTH]; unsigned char seq[SEQ_NUM_SIZE]; const unsigned char data; unsigned char buf = NULL, wbuf; size_t fragoff, fraglen, msglen; unsigned int rectype, versmajor, versminor, msgseq, msgtype, clientvers, cookielen; BIO rbio, wbio; BIO_ADDR tmpclient = NULL; PACKET pkt, msgpkt, msgpayload, session, cookiepkt; SSL_CONNECTION s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return -1; if (s->handshake_func == NULL) { /* Not properly initialized yet / SSL_set_accept_state(ssl); } / Ensure there is no state left over from a previous invocation / if (!SSL_clear(ssl)) return -1; ERR_clear_error(); rbio = SSL_get_rbio(ssl); wbio = SSL_get_wbio(ssl); if (!rbio \|\| !wbio) { ERR_raise(ERR_LIB_SSL, SSL_R_BIO_NOT_SET); return -1; } / * Note: This check deliberately excludes DTLS1_BAD_VER because that version * requires the MAC to be calculated including the first ClientHello * (without the cookie). Since DTLSv1_listen is stateless that cannot be * supported. DTLS1_BAD_VER must use cookies in a stateful manner (e.g. via * SSL_accept) / if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00)) { ERR_raise(ERR_LIB_SSL, SSL_R_UNSUPPORTED_SSL_VERSION); return -1; } buf = OPENSSL_malloc(DTLS1_RT_HEADER_LENGTH + SSL3_RT_MAX_PLAIN_LENGTH); if (buf == NULL) return -1; wbuf = OPENSSL_malloc(DTLS1_RT_HEADER_LENGTH + SSL3_RT_MAX_PLAIN_LENGTH); if (wbuf == NULL) { OPENSSL_free(buf); return -1; } do { / Get a packet / clear_sys_error(); n = BIO_read(rbio, buf, SSL3_RT_MAX_PLAIN_LENGTH + DTLS1_RT_HEADER_LENGTH); if (n <= 0) { if (BIO_should_retry(rbio)) { / Non-blocking IO / goto end; } ret = -1; goto end; } if (!PACKET_buf_init(&pkt, buf, n)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); ret = -1; goto end; } / * Parse the received record. If there are any problems with it we just * dump it - with no alert. RFC6347 says this "Unlike TLS, DTLS is * resilient in the face of invalid records (e.g., invalid formatting, * length, MAC, etc.). In general, invalid records SHOULD be silently * discarded, thus preserving the association; however, an error MAY be * logged for diagnostic purposes." / / this packet contained a partial record, dump it / if (n < DTLS1_RT_HEADER_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_RECORD_TOO_SMALL); goto end; } / Get the record header / if (!PACKET_get_1(&pkt, &rectype) \|\| !PACKET_get_1(&pkt, &versmajor) \|\| !PACKET_get_1(&pkt, &versminor)) { ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } if (s->msg_callback) s->msg_callback(0, (versmajor << 8) \| versminor, SSL3_RT_HEADER, buf, DTLS1_RT_HEADER_LENGTH, ssl, s->msg_callback_arg); if (rectype != SSL3_RT_HANDSHAKE) { ERR_raise(ERR_LIB_SSL, SSL_R_UNEXPECTED_MESSAGE); goto end; } / * Check record version number. We only check that the major version is * the same. / if (versmajor != DTLS1_VERSION_MAJOR) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_PROTOCOL_VERSION_NUMBER); goto end; } / Save the sequence number: 64 bits, with top 2 bytes = epoch / if (!PACKET_copy_bytes(&pkt, seq, SEQ_NUM_SIZE) \|\| !PACKET_get_length_prefixed_2(&pkt, &msgpkt)) { ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } / * We allow data remaining at the end of the packet because there could * be a second record (but we ignore it) / / This is an initial ClientHello so the epoch has to be 0 / if (seq[0] != 0 \|\| seq[1] != 0) { ERR_raise(ERR_LIB_SSL, SSL_R_UNEXPECTED_MESSAGE); goto end; } / Get a pointer to the raw message for the later callback / data = PACKET_data(&msgpkt); / Finished processing the record header, now process the message / if (!PACKET_get_1(&msgpkt, &msgtype) \|\| !PACKET_get_net_3_len(&msgpkt, &msglen) \|\| !PACKET_get_net_2(&msgpkt, &msgseq) \|\| !PACKET_get_net_3_len(&msgpkt, &fragoff) \|\| !PACKET_get_net_3_len(&msgpkt, &fraglen) \|\| !PACKET_get_sub_packet(&msgpkt, &msgpayload, fraglen) \|\| PACKET_remaining(&msgpkt) != 0) { ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } if (msgtype != SSL3_MT_CLIENT_HELLO) { ERR_raise(ERR_LIB_SSL, SSL_R_UNEXPECTED_MESSAGE); goto end; } / Message sequence number can only be 0 or 1 / if (msgseq > 2) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SEQUENCE_NUMBER); goto end; } / * We don't support fragment reassembly for ClientHellos whilst * listening because that would require server side state (which is * against the whole point of the ClientHello/HelloVerifyRequest * mechanism). Instead we only look at the first ClientHello fragment * and require that the cookie must be contained within it. / if (fragoff != 0 \|\| fraglen > msglen) { / Non initial ClientHello fragment (or bad fragment) / ERR_raise(ERR_LIB_SSL, SSL_R_FRAGMENTED_CLIENT_HELLO); goto end; } if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, data, fraglen + DTLS1_HM_HEADER_LENGTH, ssl, s->msg_callback_arg); if (!PACKET_get_net_2(&msgpayload, &clientvers)) { ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } / * Verify client version is supported / if (DTLS_VERSION_LT(clientvers, (unsigned int)ssl->method->version) && ssl->method->version != DTLS_ANY_VERSION) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_VERSION_NUMBER); goto end; } if (!PACKET_forward(&msgpayload, SSL3_RANDOM_SIZE) \|\| !PACKET_get_length_prefixed_1(&msgpayload, &session) \|\| !PACKET_get_length_prefixed_1(&msgpayload, &cookiepkt)) { / * Could be malformed or the cookie does not fit within the initial * ClientHello fragment. Either way we can't handle it. / ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } / * Check if we have a cookie or not. If not we need to send a * HelloVerifyRequest. / if (PACKET_remaining(&cookiepkt) == 0) { next = LISTEN_SEND_VERIFY_REQUEST; } else { / * We have a cookie, so lets check it. / if (ssl->ctx->app_verify_cookie_cb == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_VERIFY_COOKIE_CALLBACK); / This is fatal / ret = -1; goto end; } if (ssl->ctx->app_verify_cookie_cb(ssl, PACKET_data(&cookiepkt), (unsigned int)PACKET_remaining(&cookiepkt)) == 0) { / * We treat invalid cookies in the same was as no cookie as * per RFC6347 / next = LISTEN_SEND_VERIFY_REQUEST; } else { / Cookie verification succeeded / next = LISTEN_SUCCESS; } } if (next == LISTEN_SEND_VERIFY_REQUEST) { WPACKET wpkt; unsigned int version; size_t wreclen; / * There was no cookie in the ClientHello so we need to send a * HelloVerifyRequest. If this fails we do not worry about trying * to resend, we just drop it. / / Generate the cookie / if (ssl->ctx->app_gen_cookie_cb == NULL \|\| ssl->ctx->app_gen_cookie_cb(ssl, cookie, &cookielen) == 0 \|\| cookielen > 255) { ERR_raise(ERR_LIB_SSL, SSL_R_COOKIE_GEN_CALLBACK_FAILURE); / This is fatal / ret = -1; goto end; } / * Special case: for hello verify request, client version 1.0 and we * haven't decided which version to use yet send back using version * 1.0 header: otherwise some clients will ignore it. / version = (ssl->method->version == DTLS_ANY_VERSION) ? DTLS1_VERSION : s->version; / Construct the record and message headers / if (!WPACKET_init_static_len(&wpkt, wbuf, ssl_get_max_send_fragment(s) + DTLS1_RT_HEADER_LENGTH, 0) \|\| !WPACKET_put_bytes_u8(&wpkt, SSL3_RT_HANDSHAKE) \|\| !WPACKET_put_bytes_u16(&wpkt, version) / * Record sequence number is always the same as in the * received ClientHello / \|\| !WPACKET_memcpy(&wpkt, seq, SEQ_NUM_SIZE) / End of record, start sub packet for message / \|\| !WPACKET_start_sub_packet_u16(&wpkt) / Message type / \|\| !WPACKET_put_bytes_u8(&wpkt, DTLS1_MT_HELLO_VERIFY_REQUEST) / * Message length - doesn't follow normal TLS convention: * the length isn't the last thing in the message header. * We'll need to fill this in later when we know the * length. Set it to zero for now / \|\| !WPACKET_put_bytes_u24(&wpkt, 0) / * Message sequence number is always 0 for a * HelloVerifyRequest / \|\| !WPACKET_put_bytes_u16(&wpkt, 0) / * We never fragment a HelloVerifyRequest, so fragment * offset is 0 / \|\| !WPACKET_put_bytes_u24(&wpkt, 0) / * Fragment length is the same as message length, but * this is the last thing in the message header so we * can just start a sub-packet. No need to come back * later for this one. / \|\| !WPACKET_start_sub_packet_u24(&wpkt) / Create the actual HelloVerifyRequest body / \|\| !dtls_raw_hello_verify_request(&wpkt, cookie, cookielen) / Close message body / \|\| !WPACKET_close(&wpkt) / Close record body / \|\| !WPACKET_close(&wpkt) \|\| !WPACKET_get_total_written(&wpkt, &wreclen) \|\| !WPACKET_finish(&wpkt)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); WPACKET_cleanup(&wpkt); / This is fatal / ret = -1; goto end; } / * Fix up the message len in the message header. Its the same as the * fragment len which has been filled in by WPACKET, so just copy * that. Destination for the message len is after the record header * plus one byte for the message content type. The source is the * last 3 bytes of the message header / memcpy(&wbuf[DTLS1_RT_HEADER_LENGTH + 1], &wbuf[DTLS1_RT_HEADER_LENGTH + DTLS1_HM_HEADER_LENGTH - 3], 3); if (s->msg_callback) s->msg_callback(1, 0, SSL3_RT_HEADER, buf, DTLS1_RT_HEADER_LENGTH, ssl, s->msg_callback_arg); if ((tmpclient = BIO_ADDR_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB); goto end; } / * This is unnecessary if rbio and wbio are one and the same - but * maybe they're not. We ignore errors here - some BIOs do not * support this. / if (BIO_dgram_get_peer(rbio, tmpclient) > 0) { (void)BIO_dgram_set_peer(wbio, tmpclient); } BIO_ADDR_free(tmpclient); tmpclient = NULL; if (BIO_write(wbio, wbuf, wreclen) < (int)wreclen) { if (BIO_should_retry(wbio)) { / * Non-blocking IO...but we're stateless, so we're just * going to drop this packet. / goto end; } ret = -1; goto end; } if (BIO_flush(wbio) <= 0) { if (BIO_should_retry(wbio)) { / * Non-blocking IO...but we're stateless, so we're just * going to drop this packet. / goto end; } ret = -1; goto end; } } } while (next != LISTEN_SUCCESS); / * Set expected sequence numbers to continue the handshake. / s->d1->handshake_read_seq = 1; s->d1->handshake_write_seq = 1; s->d1->next_handshake_write_seq = 1; s->rlayer.wrlmethod->increment_sequence_ctr(s->rlayer.wrl); / * We are doing cookie exchange, so make sure we set that option in the * SSL object / SSL_set_options(ssl, SSL_OP_COOKIE_EXCHANGE); / * Tell the state machine that we've done the initial hello verify * exchange / ossl_statem_set_hello_verify_done(s); / * Some BIOs may not support this. If we fail we clear the client address / if (BIO_dgram_get_peer(rbio, client) <= 0) BIO_ADDR_clear(client); / Buffer the record for use by the record layer / if (BIO_write(s->rlayer.rrlnext, buf, n) != n) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); ret = -1; goto end; } / * Reset the record layer - but this time we can use the record we just * buffered in s->rlayer.rrlnext / if (!ssl_set_new_record_layer(s, DTLS_ANY_VERSION, OSSL_RECORD_DIRECTION_READ, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL)) { / SSLfatal already called / ret = -1; goto end; } ret = 1; end: BIO_ADDR_free(tmpclient); OPENSSL_free(buf); OPENSSL_free(wbuf); return ret; } #endif static int dtls1_handshake_write(SSL_CONNECTION s) { return dtls1_do_write(s, SSL3_RT_HANDSHAKE); } int dtls1_shutdown(SSL s) { int ret; #ifndef OPENSSL_NO_SCTP BIO wbio; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (s == NULL) return -1; wbio = SSL_get_wbio(s); if (wbio != NULL && BIO_dgram_is_sctp(wbio) && !(sc->shutdown & SSL_SENT_SHUTDOWN)) { ret = BIO_dgram_sctp_wait_for_dry(wbio); if (ret < 0) return -1; if (ret == 0) BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 1, NULL); } #endif ret = ssl3_shutdown(s); #ifndef OPENSSL_NO_SCTP BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 0, NULL); #endif return ret; } int dtls1_query_mtu(SSL_CONNECTION s) { SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->d1->link_mtu) { s->d1->mtu = s->d1->link_mtu - BIO_dgram_get_mtu_overhead(SSL_get_wbio(ssl)); s->d1->link_mtu = 0; } / AHA! Figure out the MTU, and stick to the right size / if (s->d1->mtu < dtls1_min_mtu(s)) { if (!(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) { s->d1->mtu = BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL); / * I've seen the kernel return bogus numbers when it doesn't know * (initial write), so just make sure we have a reasonable number / if (s->d1->mtu < dtls1_min_mtu(s)) { / Set to min mtu / s->d1->mtu = dtls1_min_mtu(s); BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SET_MTU, (long)s->d1->mtu, NULL); } } else return 0; } return 1; } static size_t dtls1_link_min_mtu(void) { return (g_probable_mtu[(sizeof(g_probable_mtu) / sizeof(g_probable_mtu[0])) - 1]); } size_t dtls1_min_mtu(SSL_CONNECTION s) { SSL ssl = SSL_CONNECTION_GET_SSL(s); return dtls1_link_min_mtu() - BIO_dgram_get_mtu_overhead(SSL_get_wbio(ssl)); } size_t DTLS_get_data_mtu(const SSL ssl) { size_t mac_overhead, int_overhead, blocksize, ext_overhead; const SSL_CIPHER ciph = SSL_get_current_cipher(ssl); size_t mtu; const SSL_CONNECTION s = SSL_CONNECTION_FROM_CONST_SSL_ONLY(ssl); if (s == NULL) return 0; mtu = s->d1->mtu; if (ciph == NULL) return 0; if (!ssl_cipher_get_overhead(ciph, &mac_overhead, &int_overhead, &blocksize, &ext_overhead)) return 0; if (SSL_READ_ETM(s)) ext_overhead += mac_overhead; else int_overhead += mac_overhead; /* Subtract external overhead (e.g. IV/nonce, separate MAC) / if (ext_overhead + DTLS1_RT_HEADER_LENGTH >= mtu) return 0; mtu -= ext_overhead + DTLS1_RT_HEADER_LENGTH; / Round encrypted payload down to cipher block size (for CBC etc.) * No check for overflow since 'mtu % blocksize' cannot exceed mtu. / if (blocksize) mtu -= (mtu % blocksize); / Subtract internal overhead (e.g. CBC padding len byte) / if (int_overhead >= mtu) return 0; mtu -= int_overhead; return mtu; } void DTLS_set_timer_cb(SSL ssl, DTLS_timer_cb cb) { SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return; s->d1->timer_cb = cb; }
./openssl/ssl/ssl_asn1.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <stdlib.h> #include "ssl_local.h" #include <openssl/asn1t.h> #include <openssl/encoder.h> #include <openssl/x509.h> typedef struct { uint32_t version; int32_t ssl_version; ASN1_OCTET_STRING cipher; ASN1_OCTET_STRING comp_id; ASN1_OCTET_STRING master_key; ASN1_OCTET_STRING session_id; ASN1_OCTET_STRING key_arg; int64_t time; int64_t timeout; X509 peer; ASN1_OCTET_STRING session_id_context; int32_t verify_result; ASN1_OCTET_STRING tlsext_hostname; uint64_t tlsext_tick_lifetime_hint; uint32_t tlsext_tick_age_add; ASN1_OCTET_STRING tlsext_tick; #ifndef OPENSSL_NO_PSK ASN1_OCTET_STRING psk_identity_hint; ASN1_OCTET_STRING psk_identity; #endif #ifndef OPENSSL_NO_SRP ASN1_OCTET_STRING srp_username; #endif uint64_t flags; uint32_t max_early_data; ASN1_OCTET_STRING alpn_selected; uint32_t tlsext_max_fragment_len_mode; ASN1_OCTET_STRING ticket_appdata; uint32_t kex_group; ASN1_OCTET_STRING peer_rpk; } SSL_SESSION_ASN1; ASN1_SEQUENCE(SSL_SESSION_ASN1) = { ASN1_EMBED(SSL_SESSION_ASN1, version, UINT32), ASN1_EMBED(SSL_SESSION_ASN1, ssl_version, INT32), ASN1_SIMPLE(SSL_SESSION_ASN1, cipher, ASN1_OCTET_STRING), ASN1_SIMPLE(SSL_SESSION_ASN1, session_id, ASN1_OCTET_STRING), ASN1_SIMPLE(SSL_SESSION_ASN1, master_key, ASN1_OCTET_STRING), ASN1_IMP_OPT(SSL_SESSION_ASN1, key_arg, ASN1_OCTET_STRING, 0), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, time, ZINT64, 1), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, timeout, ZINT64, 2), ASN1_EXP_OPT(SSL_SESSION_ASN1, peer, X509, 3), ASN1_EXP_OPT(SSL_SESSION_ASN1, session_id_context, ASN1_OCTET_STRING, 4), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, verify_result, ZINT32, 5), ASN1_EXP_OPT(SSL_SESSION_ASN1, tlsext_hostname, ASN1_OCTET_STRING, 6), #ifndef OPENSSL_NO_PSK ASN1_EXP_OPT(SSL_SESSION_ASN1, psk_identity_hint, ASN1_OCTET_STRING, 7), ASN1_EXP_OPT(SSL_SESSION_ASN1, psk_identity, ASN1_OCTET_STRING, 8), #endif ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, tlsext_tick_lifetime_hint, ZUINT64, 9), ASN1_EXP_OPT(SSL_SESSION_ASN1, tlsext_tick, ASN1_OCTET_STRING, 10), ASN1_EXP_OPT(SSL_SESSION_ASN1, comp_id, ASN1_OCTET_STRING, 11), #ifndef OPENSSL_NO_SRP ASN1_EXP_OPT(SSL_SESSION_ASN1, srp_username, ASN1_OCTET_STRING, 12), #endif ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, flags, ZUINT64, 13), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, tlsext_tick_age_add, ZUINT32, 14), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, max_early_data, ZUINT32, 15), ASN1_EXP_OPT(SSL_SESSION_ASN1, alpn_selected, ASN1_OCTET_STRING, 16), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, tlsext_max_fragment_len_mode, ZUINT32, 17), ASN1_EXP_OPT(SSL_SESSION_ASN1, ticket_appdata, ASN1_OCTET_STRING, 18), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, kex_group, UINT32, 19), ASN1_EXP_OPT(SSL_SESSION_ASN1, peer_rpk, ASN1_OCTET_STRING, 20) } static_ASN1_SEQUENCE_END(SSL_SESSION_ASN1) IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(SSL_SESSION_ASN1) /* Utility functions for i2d_SSL_SESSION / / Initialise OCTET STRING from buffer and length / static void ssl_session_oinit(ASN1_OCTET_STRING dest, ASN1_OCTET_STRING os, const unsigned char data, size_t len) { os->data = (unsigned char )data; /* justified cast: data is not modified / os->length = (int)len; os->flags = 0; dest = os; } /* Initialise OCTET STRING from string / static void ssl_session_sinit(ASN1_OCTET_STRING dest, ASN1_OCTET_STRING os, const char data) { if (data != NULL) ssl_session_oinit(dest, os, (const unsigned char )data, strlen(data)); else dest = NULL; } int i2d_SSL_SESSION(const SSL_SESSION in, unsigned char *pp) { SSL_SESSION_ASN1 as; ASN1_OCTET_STRING cipher; unsigned char cipher_data[2]; ASN1_OCTET_STRING master_key, session_id, sid_ctx; #ifndef OPENSSL_NO_COMP ASN1_OCTET_STRING comp_id; unsigned char comp_id_data; #endif ASN1_OCTET_STRING tlsext_hostname, tlsext_tick; #ifndef OPENSSL_NO_SRP ASN1_OCTET_STRING srp_username; #endif #ifndef OPENSSL_NO_PSK ASN1_OCTET_STRING psk_identity, psk_identity_hint; #endif ASN1_OCTET_STRING alpn_selected; ASN1_OCTET_STRING ticket_appdata; ASN1_OCTET_STRING peer_rpk; long l; int ret; if ((in == NULL) \|\| ((in->cipher == NULL) && (in->cipher_id == 0))) return 0; memset(&as, 0, sizeof(as)); as.version = SSL_SESSION_ASN1_VERSION; as.ssl_version = in->ssl_version; as.kex_group = in->kex_group; if (in->cipher == NULL) l = in->cipher_id; else l = in->cipher->id; cipher_data[0] = ((unsigned char)(l >> 8L)) & 0xff; cipher_data[1] = ((unsigned char)(l)) & 0xff; ssl_session_oinit(&as.cipher, &cipher, cipher_data, 2); #ifndef OPENSSL_NO_COMP if (in->compress_meth) { comp_id_data = (unsigned char)in->compress_meth; ssl_session_oinit(&as.comp_id, &comp_id, &comp_id_data, 1); } #endif ssl_session_oinit(&as.master_key, &master_key, in->master_key, in->master_key_length); ssl_session_oinit(&as.session_id, &session_id, in->session_id, in->session_id_length); ssl_session_oinit(&as.session_id_context, &sid_ctx, in->sid_ctx, in->sid_ctx_length); as.time = (int64_t)ossl_time_to_time_t(in->time); as.timeout = (int64_t)ossl_time2seconds(in->timeout); as.verify_result = in->verify_result; as.peer = in->peer; as.peer_rpk = NULL; peer_rpk.data = NULL; if (in->peer_rpk != NULL) { peer_rpk.length = i2d_PUBKEY(in->peer_rpk, &peer_rpk.data); if (peer_rpk.length > 0 && peer_rpk.data != NULL) as.peer_rpk = &peer_rpk; } ssl_session_sinit(&as.tlsext_hostname, &tlsext_hostname, in->ext.hostname); if (in->ext.tick) { ssl_session_oinit(&as.tlsext_tick, &tlsext_tick, in->ext.tick, in->ext.ticklen); } if (in->ext.tick_lifetime_hint > 0) as.tlsext_tick_lifetime_hint = in->ext.tick_lifetime_hint; as.tlsext_tick_age_add = in->ext.tick_age_add; #ifndef OPENSSL_NO_PSK ssl_session_sinit(&as.psk_identity_hint, &psk_identity_hint, in->psk_identity_hint); ssl_session_sinit(&as.psk_identity, &psk_identity, in->psk_identity); #endif / OPENSSL_NO_PSK / #ifndef OPENSSL_NO_SRP ssl_session_sinit(&as.srp_username, &srp_username, in->srp_username); #endif / OPENSSL_NO_SRP / as.flags = in->flags; as.max_early_data = in->ext.max_early_data; if (in->ext.alpn_selected == NULL) as.alpn_selected = NULL; else ssl_session_oinit(&as.alpn_selected, &alpn_selected, in->ext.alpn_selected, in->ext.alpn_selected_len); as.tlsext_max_fragment_len_mode = in->ext.max_fragment_len_mode; if (in->ticket_appdata == NULL) as.ticket_appdata = NULL; else ssl_session_oinit(&as.ticket_appdata, &ticket_appdata, in->ticket_appdata, in->ticket_appdata_len); ret = i2d_SSL_SESSION_ASN1(&as, pp); OPENSSL_free(peer_rpk.data); return ret; } / Utility functions for d2i_SSL_SESSION / / OPENSSL_strndup an OCTET STRING / static int ssl_session_strndup(char pdst, ASN1_OCTET_STRING src) { OPENSSL_free(pdst); pdst = NULL; if (src == NULL) return 1; pdst = OPENSSL_strndup((char )src->data, src->length); if (pdst == NULL) return 0; return 1; } / Copy an OCTET STRING, return error if it exceeds maximum length / static int ssl_session_memcpy(unsigned char dst, size_t pdstlen, ASN1_OCTET_STRING src, size_t maxlen) { if (src == NULL \|\| src->length == 0) { pdstlen = 0; return 1; } if (src->length < 0 \|\| src->length > (int)maxlen) return 0; memcpy(dst, src->data, src->length); pdstlen = src->length; return 1; } SSL_SESSION d2i_SSL_SESSION(SSL_SESSION a, const unsigned char pp, long length) { return d2i_SSL_SESSION_ex(a, pp, length, NULL, NULL); } SSL_SESSION d2i_SSL_SESSION_ex(SSL_SESSION a, const unsigned char pp, long length, OSSL_LIB_CTX libctx, const char propq) { long id; size_t tmpl; const unsigned char p = pp; SSL_SESSION_ASN1 as = NULL; SSL_SESSION ret = NULL; as = d2i_SSL_SESSION_ASN1(NULL, &p, length); /* ASN.1 code returns suitable error / if (as == NULL) goto err; if (a == NULL \|\| a == NULL) { ret = SSL_SESSION_new(); if (ret == NULL) goto err; } else { ret = a; } if (as->version != SSL_SESSION_ASN1_VERSION) { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_SSL_VERSION); goto err; } if ((as->ssl_version >> 8) != SSL3_VERSION_MAJOR && (as->ssl_version >> 8) != DTLS1_VERSION_MAJOR && as->ssl_version != DTLS1_BAD_VER) { ERR_raise(ERR_LIB_SSL, SSL_R_UNSUPPORTED_SSL_VERSION); goto err; } ret->ssl_version = (int)as->ssl_version; ret->kex_group = as->kex_group; if (as->cipher->length != 2) { ERR_raise(ERR_LIB_SSL, SSL_R_CIPHER_CODE_WRONG_LENGTH); goto err; } id = 0x03000000L \| ((unsigned long)as->cipher->data[0] << 8L) \| (unsigned long)as->cipher->data[1]; ret->cipher_id = id; ret->cipher = ssl3_get_cipher_by_id(id); if (ret->cipher == NULL) goto err; if (!ssl_session_memcpy(ret->session_id, &ret->session_id_length, as->session_id, SSL3_MAX_SSL_SESSION_ID_LENGTH)) goto err; if (!ssl_session_memcpy(ret->master_key, &tmpl, as->master_key, TLS13_MAX_RESUMPTION_PSK_LENGTH)) goto err; ret->master_key_length = tmpl; if (as->time != 0) ret->time = ossl_time_from_time_t(as->time); else ret->time = ossl_time_now(); if (as->timeout != 0) ret->timeout = ossl_seconds2time(as->timeout); else ret->timeout = ossl_seconds2time(3); ssl_session_calculate_timeout(ret); X509_free(ret->peer); ret->peer = as->peer; as->peer = NULL; EVP_PKEY_free(ret->peer_rpk); ret->peer_rpk = NULL; if (as->peer_rpk != NULL) { const unsigned char data = as->peer_rpk->data; /* * \|data\| is incremented; we don't want to lose original ptr / ret->peer_rpk = d2i_PUBKEY_ex(NULL, &data, as->peer_rpk->length, libctx, propq); if (ret->peer_rpk == NULL) goto err; } if (!ssl_session_memcpy(ret->sid_ctx, &ret->sid_ctx_length, as->session_id_context, SSL_MAX_SID_CTX_LENGTH)) goto err; / NB: this defaults to zero which is X509_V_OK / ret->verify_result = as->verify_result; if (!ssl_session_strndup(&ret->ext.hostname, as->tlsext_hostname)) goto err; #ifndef OPENSSL_NO_PSK if (!ssl_session_strndup(&ret->psk_identity_hint, as->psk_identity_hint)) goto err; if (!ssl_session_strndup(&ret->psk_identity, as->psk_identity)) goto err; #endif ret->ext.tick_lifetime_hint = (unsigned long)as->tlsext_tick_lifetime_hint; ret->ext.tick_age_add = as->tlsext_tick_age_add; OPENSSL_free(ret->ext.tick); if (as->tlsext_tick != NULL) { ret->ext.tick = as->tlsext_tick->data; ret->ext.ticklen = as->tlsext_tick->length; as->tlsext_tick->data = NULL; } else { ret->ext.tick = NULL; } #ifndef OPENSSL_NO_COMP if (as->comp_id) { if (as->comp_id->length != 1) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); goto err; } ret->compress_meth = as->comp_id->data[0]; } else { ret->compress_meth = 0; } #endif #ifndef OPENSSL_NO_SRP if (!ssl_session_strndup(&ret->srp_username, as->srp_username)) goto err; #endif / OPENSSL_NO_SRP / / Flags defaults to zero which is fine / ret->flags = (int32_t)as->flags; ret->ext.max_early_data = as->max_early_data; OPENSSL_free(ret->ext.alpn_selected); if (as->alpn_selected != NULL) { ret->ext.alpn_selected = as->alpn_selected->data; ret->ext.alpn_selected_len = as->alpn_selected->length; as->alpn_selected->data = NULL; } else { ret->ext.alpn_selected = NULL; ret->ext.alpn_selected_len = 0; } ret->ext.max_fragment_len_mode = as->tlsext_max_fragment_len_mode; OPENSSL_free(ret->ticket_appdata); if (as->ticket_appdata != NULL) { ret->ticket_appdata = as->ticket_appdata->data; ret->ticket_appdata_len = as->ticket_appdata->length; as->ticket_appdata->data = NULL; } else { ret->ticket_appdata = NULL; ret->ticket_appdata_len = 0; } M_ASN1_free_of(as, SSL_SESSION_ASN1); if ((a != NULL) && (a == NULL)) a = ret; pp = p; return ret; err: M_ASN1_free_of(as, SSL_SESSION_ASN1); if ((a == NULL) \|\| (*a != ret)) SSL_SESSION_free(ret); return NULL; }
./openssl/ssl/ssl_lib.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include "ssl_local.h" #include "internal/e_os.h" #include <openssl/objects.h> #include <openssl/x509v3.h> #include <openssl/rand.h> #include <openssl/ocsp.h> #include <openssl/dh.h> #include <openssl/engine.h> #include <openssl/async.h> #include <openssl/ct.h> #include <openssl/trace.h> #include <openssl/core_names.h> #include "internal/cryptlib.h" #include "internal/nelem.h" #include "internal/refcount.h" #include "internal/ktls.h" #include "quic/quic_local.h" static int ssl_undefined_function_3(SSL_CONNECTION sc, unsigned char r, unsigned char s, size_t t, size_t u) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } static int ssl_undefined_function_4(SSL_CONNECTION sc, int r) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } static size_t ssl_undefined_function_5(SSL_CONNECTION sc, const char r, size_t s, unsigned char t) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } static int ssl_undefined_function_6(int r) { return ssl_undefined_function(NULL); } static int ssl_undefined_function_7(SSL_CONNECTION sc, unsigned char r, size_t s, const char t, size_t u, const unsigned char v, size_t w, int x) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } static int ssl_undefined_function_8(SSL_CONNECTION sc) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } SSL3_ENC_METHOD ssl3_undef_enc_method = { ssl_undefined_function_8, ssl_undefined_function_3, ssl_undefined_function_4, ssl_undefined_function_5, NULL, /* client_finished_label / 0, / client_finished_label_len / NULL, / server_finished_label / 0, / server_finished_label_len / ssl_undefined_function_6, ssl_undefined_function_7, }; struct ssl_async_args { SSL s; void buf; size_t num; enum { READFUNC, WRITEFUNC, OTHERFUNC } type; union { int (func_read) (SSL , void , size_t, size_t ); int (func_write) (SSL , const void , size_t, size_t ); int (func_other) (SSL ); } f; }; static const struct { uint8_t mtype; uint8_t ord; int nid; } dane_mds[] = { { DANETLS_MATCHING_FULL, 0, NID_undef }, { DANETLS_MATCHING_2256, 1, NID_sha256 }, { DANETLS_MATCHING_2512, 2, NID_sha512 }, }; static int dane_ctx_enable(struct dane_ctx_st dctx) { const EVP_MD *mdevp; uint8_t mdord; uint8_t mdmax = DANETLS_MATCHING_LAST; int n = ((int)mdmax) + 1; /* int to handle PrivMatch(255) / size_t i; if (dctx->mdevp != NULL) return 1; mdevp = OPENSSL_zalloc(n sizeof(mdevp)); mdord = OPENSSL_zalloc(n sizeof(mdord)); if (mdord == NULL \|\| mdevp == NULL) { OPENSSL_free(mdord); OPENSSL_free(mdevp); return 0; } / Install default entries / for (i = 0; i < OSSL_NELEM(dane_mds); ++i) { const EVP_MD md; if (dane_mds[i].nid == NID_undef \|\| (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL) continue; mdevp[dane_mds[i].mtype] = md; mdord[dane_mds[i].mtype] = dane_mds[i].ord; } dctx->mdevp = mdevp; dctx->mdord = mdord; dctx->mdmax = mdmax; return 1; } static void dane_ctx_final(struct dane_ctx_st dctx) { OPENSSL_free(dctx->mdevp); dctx->mdevp = NULL; OPENSSL_free(dctx->mdord); dctx->mdord = NULL; dctx->mdmax = 0; } static void tlsa_free(danetls_record t) { if (t == NULL) return; OPENSSL_free(t->data); EVP_PKEY_free(t->spki); OPENSSL_free(t); } static void dane_final(SSL_DANE dane) { sk_danetls_record_pop_free(dane->trecs, tlsa_free); dane->trecs = NULL; OSSL_STACK_OF_X509_free(dane->certs); dane->certs = NULL; X509_free(dane->mcert); dane->mcert = NULL; dane->mtlsa = NULL; dane->mdpth = -1; dane->pdpth = -1; } / * dane_copy - Copy dane configuration, sans verification state. / static int ssl_dane_dup(SSL_CONNECTION to, SSL_CONNECTION from) { int num; int i; if (!DANETLS_ENABLED(&from->dane)) return 1; num = sk_danetls_record_num(from->dane.trecs); dane_final(&to->dane); to->dane.flags = from->dane.flags; to->dane.dctx = &SSL_CONNECTION_GET_CTX(to)->dane; to->dane.trecs = sk_danetls_record_new_reserve(NULL, num); if (to->dane.trecs == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 0; } for (i = 0; i < num; ++i) { danetls_record t = sk_danetls_record_value(from->dane.trecs, i); if (SSL_dane_tlsa_add(SSL_CONNECTION_GET_SSL(to), t->usage, t->selector, t->mtype, t->data, t->dlen) <= 0) return 0; } return 1; } static int dane_mtype_set(struct dane_ctx_st dctx, const EVP_MD md, uint8_t mtype, uint8_t ord) { int i; if (mtype == DANETLS_MATCHING_FULL && md != NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL); return 0; } if (mtype > dctx->mdmax) { const EVP_MD *mdevp; uint8_t mdord; int n = ((int)mtype) + 1; mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(mdevp)); if (mdevp == NULL) return -1; dctx->mdevp = mdevp; mdord = OPENSSL_realloc(dctx->mdord, n sizeof(mdord)); if (mdord == NULL) return -1; dctx->mdord = mdord; / Zero-fill any gaps / for (i = dctx->mdmax + 1; i < mtype; ++i) { mdevp[i] = NULL; mdord[i] = 0; } dctx->mdmax = mtype; } dctx->mdevp[mtype] = md; / Coerce ordinal of disabled matching types to 0 / dctx->mdord[mtype] = (md == NULL) ? 0 : ord; return 1; } static const EVP_MD tlsa_md_get(SSL_DANE dane, uint8_t mtype) { if (mtype > dane->dctx->mdmax) return NULL; return dane->dctx->mdevp[mtype]; } static int dane_tlsa_add(SSL_DANE dane, uint8_t usage, uint8_t selector, uint8_t mtype, const unsigned char data, size_t dlen) { danetls_record t; const EVP_MD md = NULL; int ilen = (int)dlen; int i; int num; if (dane->trecs == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_NOT_ENABLED); return -1; } if (ilen < 0 \|\| dlen != (size_t)ilen) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_DATA_LENGTH); return 0; } if (usage > DANETLS_USAGE_LAST) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE); return 0; } if (selector > DANETLS_SELECTOR_LAST) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_SELECTOR); return 0; } if (mtype != DANETLS_MATCHING_FULL) { md = tlsa_md_get(dane, mtype); if (md == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE); return 0; } } if (md != NULL && dlen != (size_t)EVP_MD_get_size(md)) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH); return 0; } if (!data) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_NULL_DATA); return 0; } if ((t = OPENSSL_zalloc(sizeof(t))) == NULL) return -1; t->usage = usage; t->selector = selector; t->mtype = mtype; t->data = OPENSSL_malloc(dlen); if (t->data == NULL) { tlsa_free(t); return -1; } memcpy(t->data, data, dlen); t->dlen = dlen; /* Validate and cache full certificate or public key / if (mtype == DANETLS_MATCHING_FULL) { const unsigned char p = data; X509 cert = NULL; EVP_PKEY pkey = NULL; switch (selector) { case DANETLS_SELECTOR_CERT: if (!d2i_X509(&cert, &p, ilen) \|\| p < data \|\| dlen != (size_t)(p - data)) { X509_free(cert); tlsa_free(t); ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE); return 0; } if (X509_get0_pubkey(cert) == NULL) { X509_free(cert); tlsa_free(t); ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE); return 0; } if ((DANETLS_USAGE_BIT(usage) & DANETLS_TA_MASK) == 0) { /* * The Full(0) certificate decodes to a seemingly valid X.509 * object with a plausible key, so the TLSA record is well * formed. However, we don't actually need the certificate for * usages PKIX-EE(1) or DANE-EE(3), because at least the EE * certificate is always presented by the peer. We discard the * certificate, and just use the TLSA data as an opaque blob * for matching the raw presented DER octets. * * DO NOT FREE `t` here, it will be added to the TLSA record * list below! / X509_free(cert); break; } / * For usage DANE-TA(2), we support authentication via "2 0 0" TLSA * records that contain full certificates of trust-anchors that are * not present in the wire chain. For usage PKIX-TA(0), we augment * the chain with untrusted Full(0) certificates from DNS, in case * they are missing from the chain. / if ((dane->certs == NULL && (dane->certs = sk_X509_new_null()) == NULL) \|\| !sk_X509_push(dane->certs, cert)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); X509_free(cert); tlsa_free(t); return -1; } break; case DANETLS_SELECTOR_SPKI: if (!d2i_PUBKEY(&pkey, &p, ilen) \|\| p < data \|\| dlen != (size_t)(p - data)) { EVP_PKEY_free(pkey); tlsa_free(t); ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY); return 0; } / * For usage DANE-TA(2), we support authentication via "2 1 0" TLSA * records that contain full bare keys of trust-anchors that are * not present in the wire chain. / if (usage == DANETLS_USAGE_DANE_TA) t->spki = pkey; else EVP_PKEY_free(pkey); break; } } /- * Find the right insertion point for the new record. * * See crypto/x509/x509_vfy.c. We sort DANE-EE(3) records first, so that * they can be processed first, as they require no chain building, and no * expiration or hostname checks. Because DANE-EE(3) is numerically * largest, this is accomplished via descending sort by "usage". * * We also sort in descending order by matching ordinal to simplify * the implementation of digest agility in the verification code. * * The choice of order for the selector is not significant, so we * use the same descending order for consistency. / num = sk_danetls_record_num(dane->trecs); for (i = 0; i < num; ++i) { danetls_record rec = sk_danetls_record_value(dane->trecs, i); if (rec->usage > usage) continue; if (rec->usage < usage) break; if (rec->selector > selector) continue; if (rec->selector < selector) break; if (dane->dctx->mdord[rec->mtype] > dane->dctx->mdord[mtype]) continue; break; } if (!sk_danetls_record_insert(dane->trecs, t, i)) { tlsa_free(t); ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return -1; } dane->umask \|= DANETLS_USAGE_BIT(usage); return 1; } /* * Return 0 if there is only one version configured and it was disabled * at configure time. Return 1 otherwise. / static int ssl_check_allowed_versions(int min_version, int max_version) { int minisdtls = 0, maxisdtls = 0; / Figure out if we're doing DTLS versions or TLS versions / if (min_version == DTLS1_BAD_VER \|\| min_version >> 8 == DTLS1_VERSION_MAJOR) minisdtls = 1; if (max_version == DTLS1_BAD_VER \|\| max_version >> 8 == DTLS1_VERSION_MAJOR) maxisdtls = 1; / A wildcard version of 0 could be DTLS or TLS. / if ((minisdtls && !maxisdtls && max_version != 0) \|\| (maxisdtls && !minisdtls && min_version != 0)) { / Mixing DTLS and TLS versions will lead to sadness; deny it. / return 0; } if (minisdtls \|\| maxisdtls) { / Do DTLS version checks. / if (min_version == 0) / Ignore DTLS1_BAD_VER / min_version = DTLS1_VERSION; if (max_version == 0) max_version = DTLS1_2_VERSION; #ifdef OPENSSL_NO_DTLS1_2 if (max_version == DTLS1_2_VERSION) max_version = DTLS1_VERSION; #endif #ifdef OPENSSL_NO_DTLS1 if (min_version == DTLS1_VERSION) min_version = DTLS1_2_VERSION; #endif / Done massaging versions; do the check. / if (0 #ifdef OPENSSL_NO_DTLS1 \|\| (DTLS_VERSION_GE(min_version, DTLS1_VERSION) && DTLS_VERSION_GE(DTLS1_VERSION, max_version)) #endif #ifdef OPENSSL_NO_DTLS1_2 \|\| (DTLS_VERSION_GE(min_version, DTLS1_2_VERSION) && DTLS_VERSION_GE(DTLS1_2_VERSION, max_version)) #endif ) return 0; } else { / Regular TLS version checks. / if (min_version == 0) min_version = SSL3_VERSION; if (max_version == 0) max_version = TLS1_3_VERSION; #ifdef OPENSSL_NO_TLS1_3 if (max_version == TLS1_3_VERSION) max_version = TLS1_2_VERSION; #endif #ifdef OPENSSL_NO_TLS1_2 if (max_version == TLS1_2_VERSION) max_version = TLS1_1_VERSION; #endif #ifdef OPENSSL_NO_TLS1_1 if (max_version == TLS1_1_VERSION) max_version = TLS1_VERSION; #endif #ifdef OPENSSL_NO_TLS1 if (max_version == TLS1_VERSION) max_version = SSL3_VERSION; #endif #ifdef OPENSSL_NO_SSL3 if (min_version == SSL3_VERSION) min_version = TLS1_VERSION; #endif #ifdef OPENSSL_NO_TLS1 if (min_version == TLS1_VERSION) min_version = TLS1_1_VERSION; #endif #ifdef OPENSSL_NO_TLS1_1 if (min_version == TLS1_1_VERSION) min_version = TLS1_2_VERSION; #endif #ifdef OPENSSL_NO_TLS1_2 if (min_version == TLS1_2_VERSION) min_version = TLS1_3_VERSION; #endif / Done massaging versions; do the check. / if (0 #ifdef OPENSSL_NO_SSL3 \|\| (min_version <= SSL3_VERSION && SSL3_VERSION <= max_version) #endif #ifdef OPENSSL_NO_TLS1 \|\| (min_version <= TLS1_VERSION && TLS1_VERSION <= max_version) #endif #ifdef OPENSSL_NO_TLS1_1 \|\| (min_version <= TLS1_1_VERSION && TLS1_1_VERSION <= max_version) #endif #ifdef OPENSSL_NO_TLS1_2 \|\| (min_version <= TLS1_2_VERSION && TLS1_2_VERSION <= max_version) #endif #ifdef OPENSSL_NO_TLS1_3 \|\| (min_version <= TLS1_3_VERSION && TLS1_3_VERSION <= max_version) #endif ) return 0; } return 1; } #if defined(__TANDEM) && defined(OPENSSL_VPROC) / * Define a VPROC function for HP NonStop build ssl library. * This is used by platform version identification tools. * Do not inline this procedure or make it static. / # define OPENSSL_VPROC_STRING_(x) x##_SSL # define OPENSSL_VPROC_STRING(x) OPENSSL_VPROC_STRING_(x) # define OPENSSL_VPROC_FUNC OPENSSL_VPROC_STRING(OPENSSL_VPROC) void OPENSSL_VPROC_FUNC(void) {} #endif static int clear_record_layer(SSL_CONNECTION s) { int ret; /* We try and reset both record layers even if one fails / ret = ssl_set_new_record_layer(s, SSL_CONNECTION_IS_DTLS(s) ? DTLS_ANY_VERSION : TLS_ANY_VERSION, OSSL_RECORD_DIRECTION_READ, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL); ret &= ssl_set_new_record_layer(s, SSL_CONNECTION_IS_DTLS(s) ? DTLS_ANY_VERSION : TLS_ANY_VERSION, OSSL_RECORD_DIRECTION_WRITE, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL); / SSLfatal already called in the event of failure / return ret; } int SSL_clear(SSL s) { if (s->method == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_METHOD_SPECIFIED); return 0; } return s->method->ssl_reset(s); } int ossl_ssl_connection_reset(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (ssl_clear_bad_session(sc)) { SSL_SESSION_free(sc->session); sc->session = NULL; } SSL_SESSION_free(sc->psksession); sc->psksession = NULL; OPENSSL_free(sc->psksession_id); sc->psksession_id = NULL; sc->psksession_id_len = 0; sc->hello_retry_request = SSL_HRR_NONE; sc->sent_tickets = 0; sc->error = 0; sc->hit = 0; sc->shutdown = 0; if (sc->renegotiate) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } ossl_statem_clear(sc); sc->version = s->method->version; sc->client_version = sc->version; sc->rwstate = SSL_NOTHING; BUF_MEM_free(sc->init_buf); sc->init_buf = NULL; sc->first_packet = 0; sc->key_update = SSL_KEY_UPDATE_NONE; memset(sc->ext.compress_certificate_from_peer, 0, sizeof(sc->ext.compress_certificate_from_peer)); sc->ext.compress_certificate_sent = 0; EVP_MD_CTX_free(sc->pha_dgst); sc->pha_dgst = NULL; /* Reset DANE verification result state / sc->dane.mdpth = -1; sc->dane.pdpth = -1; X509_free(sc->dane.mcert); sc->dane.mcert = NULL; sc->dane.mtlsa = NULL; / Clear the verification result peername / X509_VERIFY_PARAM_move_peername(sc->param, NULL); / Clear any shared connection state / OPENSSL_free(sc->shared_sigalgs); sc->shared_sigalgs = NULL; sc->shared_sigalgslen = 0; / * Check to see if we were changed into a different method, if so, revert * back. / if (s->method != s->defltmeth) { s->method->ssl_deinit(s); s->method = s->defltmeth; if (!s->method->ssl_init(s)) return 0; } else { if (!s->method->ssl_clear(s)) return 0; } RECORD_LAYER_clear(&sc->rlayer); BIO_free(sc->rlayer.rrlnext); sc->rlayer.rrlnext = NULL; if (!clear_record_layer(sc)) return 0; return 1; } #ifndef OPENSSL_NO_DEPRECATED_3_0 /* Used to change an SSL_CTXs default SSL method type / int SSL_CTX_set_ssl_version(SSL_CTX ctx, const SSL_METHOD meth) { STACK_OF(SSL_CIPHER) sk; if (IS_QUIC_CTX(ctx)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } ctx->method = meth; if (!SSL_CTX_set_ciphersuites(ctx, OSSL_default_ciphersuites())) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS); return 0; } sk = ssl_create_cipher_list(ctx, ctx->tls13_ciphersuites, &(ctx->cipher_list), &(ctx->cipher_list_by_id), OSSL_default_cipher_list(), ctx->cert); if ((sk == NULL) \|\| (sk_SSL_CIPHER_num(sk) <= 0)) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS); return 0; } return 1; } #endif SSL SSL_new(SSL_CTX ctx) { if (ctx == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NULL_SSL_CTX); return NULL; } if (ctx->method == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION); return NULL; } return ctx->method->ssl_new(ctx); } int ossl_ssl_init(SSL ssl, SSL_CTX ctx, const SSL_METHOD method, int type) { ssl->type = type; ssl->lock = CRYPTO_THREAD_lock_new(); if (ssl->lock == NULL) return 0; if (!CRYPTO_NEW_REF(&ssl->references, 1)) { CRYPTO_THREAD_lock_free(ssl->lock); return 0; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, ssl, &ssl->ex_data)) { CRYPTO_THREAD_lock_free(ssl->lock); CRYPTO_FREE_REF(&ssl->references); ssl->lock = NULL; return 0; } SSL_CTX_up_ref(ctx); ssl->ctx = ctx; ssl->defltmeth = ssl->method = method; return 1; } SSL ossl_ssl_connection_new_int(SSL_CTX ctx, const SSL_METHOD method) { SSL_CONNECTION s; SSL ssl; s = OPENSSL_zalloc(sizeof(s)); if (s == NULL) return NULL; ssl = &s->ssl; if (!ossl_ssl_init(ssl, ctx, method, SSL_TYPE_SSL_CONNECTION)) { OPENSSL_free(s); s = NULL; ssl = NULL; goto sslerr; } RECORD_LAYER_init(&s->rlayer, s); s->options = ctx->options; s->dane.flags = ctx->dane.flags; if (method->version == ctx->method->version) { s->min_proto_version = ctx->min_proto_version; s->max_proto_version = ctx->max_proto_version; } s->mode = ctx->mode; s->max_cert_list = ctx->max_cert_list; s->max_early_data = ctx->max_early_data; s->recv_max_early_data = ctx->recv_max_early_data; s->num_tickets = ctx->num_tickets; s->pha_enabled = ctx->pha_enabled; / Shallow copy of the ciphersuites stack / s->tls13_ciphersuites = sk_SSL_CIPHER_dup(ctx->tls13_ciphersuites); if (s->tls13_ciphersuites == NULL) goto cerr; / * Earlier library versions used to copy the pointer to the CERT, not * its contents; only when setting new parameters for the per-SSL * copy, ssl_cert_new would be called (and the direct reference to * the per-SSL_CTX settings would be lost, but those still were * indirectly accessed for various purposes, and for that reason they * used to be known as s->ctx->default_cert). Now we don't look at the * SSL_CTX's CERT after having duplicated it once. / s->cert = ssl_cert_dup(ctx->cert); if (s->cert == NULL) goto sslerr; RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead); s->msg_callback = ctx->msg_callback; s->msg_callback_arg = ctx->msg_callback_arg; s->verify_mode = ctx->verify_mode; s->not_resumable_session_cb = ctx->not_resumable_session_cb; s->rlayer.record_padding_cb = ctx->record_padding_cb; s->rlayer.record_padding_arg = ctx->record_padding_arg; s->rlayer.block_padding = ctx->block_padding; s->sid_ctx_length = ctx->sid_ctx_length; if (!ossl_assert(s->sid_ctx_length <= sizeof(s->sid_ctx))) goto err; memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx)); s->verify_callback = ctx->default_verify_callback; s->generate_session_id = ctx->generate_session_id; s->param = X509_VERIFY_PARAM_new(); if (s->param == NULL) goto asn1err; X509_VERIFY_PARAM_inherit(s->param, ctx->param); s->quiet_shutdown = IS_QUIC_CTX(ctx) ? 0 : ctx->quiet_shutdown; if (!IS_QUIC_CTX(ctx)) s->ext.max_fragment_len_mode = ctx->ext.max_fragment_len_mode; s->max_send_fragment = ctx->max_send_fragment; s->split_send_fragment = ctx->split_send_fragment; s->max_pipelines = ctx->max_pipelines; s->rlayer.default_read_buf_len = ctx->default_read_buf_len; s->ext.debug_cb = 0; s->ext.debug_arg = NULL; s->ext.ticket_expected = 0; s->ext.status_type = ctx->ext.status_type; s->ext.status_expected = 0; s->ext.ocsp.ids = NULL; s->ext.ocsp.exts = NULL; s->ext.ocsp.resp = NULL; s->ext.ocsp.resp_len = 0; SSL_CTX_up_ref(ctx); s->session_ctx = ctx; if (ctx->ext.ecpointformats) { s->ext.ecpointformats = OPENSSL_memdup(ctx->ext.ecpointformats, ctx->ext.ecpointformats_len); if (!s->ext.ecpointformats) { s->ext.ecpointformats_len = 0; goto err; } s->ext.ecpointformats_len = ctx->ext.ecpointformats_len; } if (ctx->ext.supportedgroups) { s->ext.supportedgroups = OPENSSL_memdup(ctx->ext.supportedgroups, ctx->ext.supportedgroups_len sizeof(ctx->ext.supportedgroups)); if (!s->ext.supportedgroups) { s->ext.supportedgroups_len = 0; goto err; } s->ext.supportedgroups_len = ctx->ext.supportedgroups_len; } #ifndef OPENSSL_NO_NEXTPROTONEG s->ext.npn = NULL; #endif if (ctx->ext.alpn != NULL) { s->ext.alpn = OPENSSL_malloc(ctx->ext.alpn_len); if (s->ext.alpn == NULL) { s->ext.alpn_len = 0; goto err; } memcpy(s->ext.alpn, ctx->ext.alpn, ctx->ext.alpn_len); s->ext.alpn_len = ctx->ext.alpn_len; } s->verified_chain = NULL; s->verify_result = X509_V_OK; s->default_passwd_callback = ctx->default_passwd_callback; s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata; s->key_update = SSL_KEY_UPDATE_NONE; if (!IS_QUIC_CTX(ctx)) { s->allow_early_data_cb = ctx->allow_early_data_cb; s->allow_early_data_cb_data = ctx->allow_early_data_cb_data; } if (!method->ssl_init(ssl)) goto sslerr; s->server = (method->ssl_accept == ssl_undefined_function) ? 0 : 1; if (!method->ssl_reset(ssl)) goto sslerr; #ifndef OPENSSL_NO_PSK s->psk_client_callback = ctx->psk_client_callback; s->psk_server_callback = ctx->psk_server_callback; #endif s->psk_find_session_cb = ctx->psk_find_session_cb; s->psk_use_session_cb = ctx->psk_use_session_cb; s->async_cb = ctx->async_cb; s->async_cb_arg = ctx->async_cb_arg; s->job = NULL; #ifndef OPENSSL_NO_COMP_ALG memcpy(s->cert_comp_prefs, ctx->cert_comp_prefs, sizeof(s->cert_comp_prefs)); #endif if (ctx->client_cert_type != NULL) { s->client_cert_type = OPENSSL_memdup(ctx->client_cert_type, ctx->client_cert_type_len); if (s->client_cert_type == NULL) goto sslerr; s->client_cert_type_len = ctx->client_cert_type_len; } if (ctx->server_cert_type != NULL) { s->server_cert_type = OPENSSL_memdup(ctx->server_cert_type, ctx->server_cert_type_len); if (s->server_cert_type == NULL) goto sslerr; s->server_cert_type_len = ctx->server_cert_type_len; } #ifndef OPENSSL_NO_CT if (!SSL_set_ct_validation_callback(ssl, ctx->ct_validation_callback, ctx->ct_validation_callback_arg)) goto sslerr; #endif s->ssl_pkey_num = SSL_PKEY_NUM + ctx->sigalg_list_len; return ssl; cerr: ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; asn1err: ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto err; sslerr: ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); err: SSL_free(ssl); return NULL; } SSL ossl_ssl_connection_new(SSL_CTX ctx) { return ossl_ssl_connection_new_int(ctx, ctx->method); } int SSL_is_dtls(const SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (s->type == SSL_TYPE_QUIC_CONNECTION \|\| s->type == SSL_TYPE_QUIC_XSO) return 0; #endif if (sc == NULL) return 0; return SSL_CONNECTION_IS_DTLS(sc) ? 1 : 0; } int SSL_is_tls(const SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (s->type == SSL_TYPE_QUIC_CONNECTION \|\| s->type == SSL_TYPE_QUIC_XSO) return 0; #endif if (sc == NULL) return 0; return SSL_CONNECTION_IS_DTLS(sc) ? 0 : 1; } int SSL_is_quic(const SSL s) { #ifndef OPENSSL_NO_QUIC if (s->type == SSL_TYPE_QUIC_CONNECTION \|\| s->type == SSL_TYPE_QUIC_XSO) return 1; #endif return 0; } int SSL_up_ref(SSL s) { int i; if (CRYPTO_UP_REF(&s->references, &i) <= 0) return 0; REF_PRINT_COUNT("SSL", s); REF_ASSERT_ISNT(i < 2); return ((i > 1) ? 1 : 0); } int SSL_CTX_set_session_id_context(SSL_CTX ctx, const unsigned char sid_ctx, unsigned int sid_ctx_len) { if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG); return 0; } ctx->sid_ctx_length = sid_ctx_len; memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len); return 1; } int SSL_set_session_id_context(SSL ssl, const unsigned char sid_ctx, unsigned int sid_ctx_len) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG); return 0; } sc->sid_ctx_length = sid_ctx_len; memcpy(sc->sid_ctx, sid_ctx, sid_ctx_len); return 1; } int SSL_CTX_set_generate_session_id(SSL_CTX ctx, GEN_SESSION_CB cb) { if (!CRYPTO_THREAD_write_lock(ctx->lock)) return 0; ctx->generate_session_id = cb; CRYPTO_THREAD_unlock(ctx->lock); return 1; } int SSL_set_generate_session_id(SSL ssl, GEN_SESSION_CB cb) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL \|\| !CRYPTO_THREAD_write_lock(ssl->lock)) return 0; sc->generate_session_id = cb; CRYPTO_THREAD_unlock(ssl->lock); return 1; } int SSL_has_matching_session_id(const SSL ssl, const unsigned char id, unsigned int id_len) { / * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how * we can "construct" a session to give us the desired check - i.e. to * find if there's a session in the hash table that would conflict with * any new session built out of this id/id_len and the ssl_version in use * by this SSL. / SSL_SESSION r, p; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL \|\| id_len > sizeof(r.session_id)) return 0; r.ssl_version = sc->version; r.session_id_length = id_len; memcpy(r.session_id, id, id_len); if (!CRYPTO_THREAD_read_lock(sc->session_ctx->lock)) return 0; p = lh_SSL_SESSION_retrieve(sc->session_ctx->sessions, &r); CRYPTO_THREAD_unlock(sc->session_ctx->lock); return (p != NULL); } int SSL_CTX_set_purpose(SSL_CTX s, int purpose) { return X509_VERIFY_PARAM_set_purpose(s->param, purpose); } int SSL_set_purpose(SSL s, int purpose) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return X509_VERIFY_PARAM_set_purpose(sc->param, purpose); } int SSL_CTX_set_trust(SSL_CTX s, int trust) { return X509_VERIFY_PARAM_set_trust(s->param, trust); } int SSL_set_trust(SSL s, int trust) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return X509_VERIFY_PARAM_set_trust(sc->param, trust); } int SSL_set1_host(SSL s, const char hostname) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* If a hostname is provided and parses as an IP address, * treat it as such. / if (hostname != NULL && X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname) == 1) return 1; return X509_VERIFY_PARAM_set1_host(sc->param, hostname, 0); } int SSL_add1_host(SSL s, const char hostname) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* If a hostname is provided and parses as an IP address, * treat it as such. / if (hostname) { ASN1_OCTET_STRING ip; char old_ip; ip = a2i_IPADDRESS(hostname); if (ip) { / We didn't want it; only to check if it is an IP address / ASN1_OCTET_STRING_free(ip); old_ip = X509_VERIFY_PARAM_get1_ip_asc(sc->param); if (old_ip) { OPENSSL_free(old_ip); / There can be only one IP address / return 0; } return X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname); } } return X509_VERIFY_PARAM_add1_host(sc->param, hostname, 0); } void SSL_set_hostflags(SSL s, unsigned int flags) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; X509_VERIFY_PARAM_set_hostflags(sc->param, flags); } const char SSL_get0_peername(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return X509_VERIFY_PARAM_get0_peername(sc->param); } int SSL_CTX_dane_enable(SSL_CTX ctx) { return dane_ctx_enable(&ctx->dane); } unsigned long SSL_CTX_dane_set_flags(SSL_CTX ctx, unsigned long flags) { unsigned long orig = ctx->dane.flags; ctx->dane.flags \|= flags; return orig; } unsigned long SSL_CTX_dane_clear_flags(SSL_CTX ctx, unsigned long flags) { unsigned long orig = ctx->dane.flags; ctx->dane.flags &= ~flags; return orig; } int SSL_dane_enable(SSL s, const char basedomain) { SSL_DANE dane; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; dane = &sc->dane; if (s->ctx->dane.mdmax == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_CONTEXT_NOT_DANE_ENABLED); return 0; } if (dane->trecs != NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_ALREADY_ENABLED); return 0; } / * Default SNI name. This rejects empty names, while set1_host below * accepts them and disables hostname checks. To avoid side-effects with * invalid input, set the SNI name first. / if (sc->ext.hostname == NULL) { if (!SSL_set_tlsext_host_name(s, basedomain)) { ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN); return -1; } } / Primary RFC6125 reference identifier / if (!X509_VERIFY_PARAM_set1_host(sc->param, basedomain, 0)) { ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN); return -1; } dane->mdpth = -1; dane->pdpth = -1; dane->dctx = &s->ctx->dane; dane->trecs = sk_danetls_record_new_null(); if (dane->trecs == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return -1; } return 1; } unsigned long SSL_dane_set_flags(SSL ssl, unsigned long flags) { unsigned long orig; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; orig = sc->dane.flags; sc->dane.flags \|= flags; return orig; } unsigned long SSL_dane_clear_flags(SSL ssl, unsigned long flags) { unsigned long orig; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; orig = sc->dane.flags; sc->dane.flags &= ~flags; return orig; } int SSL_get0_dane_authority(SSL s, X509 mcert, EVP_PKEY mspki) { SSL_DANE dane; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; dane = &sc->dane; if (!DANETLS_ENABLED(dane) \|\| sc->verify_result != X509_V_OK) return -1; if (dane->mtlsa) { if (mcert) mcert = dane->mcert; if (mspki) mspki = (dane->mcert == NULL) ? dane->mtlsa->spki : NULL; } return dane->mdpth; } int SSL_get0_dane_tlsa(SSL s, uint8_t usage, uint8_t selector, uint8_t mtype, const unsigned char *data, size_t dlen) { SSL_DANE dane; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; dane = &sc->dane; if (!DANETLS_ENABLED(dane) \|\| sc->verify_result != X509_V_OK) return -1; if (dane->mtlsa) { if (usage) usage = dane->mtlsa->usage; if (selector) selector = dane->mtlsa->selector; if (mtype) mtype = dane->mtlsa->mtype; if (data) data = dane->mtlsa->data; if (dlen) dlen = dane->mtlsa->dlen; } return dane->mdpth; } SSL_DANE SSL_get0_dane(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return &sc->dane; } int SSL_dane_tlsa_add(SSL s, uint8_t usage, uint8_t selector, uint8_t mtype, const unsigned char data, size_t dlen) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return dane_tlsa_add(&sc->dane, usage, selector, mtype, data, dlen); } int SSL_CTX_dane_mtype_set(SSL_CTX ctx, const EVP_MD md, uint8_t mtype, uint8_t ord) { return dane_mtype_set(&ctx->dane, md, mtype, ord); } int SSL_CTX_set1_param(SSL_CTX ctx, X509_VERIFY_PARAM vpm) { return X509_VERIFY_PARAM_set1(ctx->param, vpm); } int SSL_set1_param(SSL ssl, X509_VERIFY_PARAM vpm) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; return X509_VERIFY_PARAM_set1(sc->param, vpm); } X509_VERIFY_PARAM SSL_CTX_get0_param(SSL_CTX ctx) { return ctx->param; } X509_VERIFY_PARAM SSL_get0_param(SSL ssl) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return NULL; return sc->param; } void SSL_certs_clear(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; ssl_cert_clear_certs(sc->cert); } void SSL_free(SSL s) { int i; if (s == NULL) return; CRYPTO_DOWN_REF(&s->references, &i); REF_PRINT_COUNT("SSL", s); if (i > 0) return; REF_ASSERT_ISNT(i < 0); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data); if (s->method != NULL) s->method->ssl_free(s); SSL_CTX_free(s->ctx); CRYPTO_THREAD_lock_free(s->lock); CRYPTO_FREE_REF(&s->references); OPENSSL_free(s); } void ossl_ssl_connection_free(SSL ssl) { SSL_CONNECTION s; s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return; X509_VERIFY_PARAM_free(s->param); dane_final(&s->dane); /* Ignore return value / ssl_free_wbio_buffer(s); RECORD_LAYER_clear(&s->rlayer); BUF_MEM_free(s->init_buf); / add extra stuff / sk_SSL_CIPHER_free(s->cipher_list); sk_SSL_CIPHER_free(s->cipher_list_by_id); sk_SSL_CIPHER_free(s->tls13_ciphersuites); sk_SSL_CIPHER_free(s->peer_ciphers); / Make the next call work :-) / if (s->session != NULL) { ssl_clear_bad_session(s); SSL_SESSION_free(s->session); } SSL_SESSION_free(s->psksession); OPENSSL_free(s->psksession_id); ssl_cert_free(s->cert); OPENSSL_free(s->shared_sigalgs); / Free up if allocated / OPENSSL_free(s->ext.hostname); SSL_CTX_free(s->session_ctx); OPENSSL_free(s->ext.ecpointformats); OPENSSL_free(s->ext.peer_ecpointformats); OPENSSL_free(s->ext.supportedgroups); OPENSSL_free(s->ext.peer_supportedgroups); sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts, X509_EXTENSION_free); #ifndef OPENSSL_NO_OCSP sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free); #endif #ifndef OPENSSL_NO_CT SCT_LIST_free(s->scts); OPENSSL_free(s->ext.scts); #endif OPENSSL_free(s->ext.ocsp.resp); OPENSSL_free(s->ext.alpn); OPENSSL_free(s->ext.tls13_cookie); if (s->clienthello != NULL) OPENSSL_free(s->clienthello->pre_proc_exts); OPENSSL_free(s->clienthello); OPENSSL_free(s->pha_context); EVP_MD_CTX_free(s->pha_dgst); sk_X509_NAME_pop_free(s->ca_names, X509_NAME_free); sk_X509_NAME_pop_free(s->client_ca_names, X509_NAME_free); OPENSSL_free(s->client_cert_type); OPENSSL_free(s->server_cert_type); OSSL_STACK_OF_X509_free(s->verified_chain); if (ssl->method != NULL) ssl->method->ssl_deinit(ssl); ASYNC_WAIT_CTX_free(s->waitctx); #if !defined(OPENSSL_NO_NEXTPROTONEG) OPENSSL_free(s->ext.npn); #endif #ifndef OPENSSL_NO_SRTP sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles); #endif / * We do this late. We want to ensure that any other references we held to * these BIOs are freed first before we call BIO_free_all(), because * BIO_free_all() will only free each BIO in the chain if the number of * references to the first BIO have dropped to 0 / BIO_free_all(s->wbio); s->wbio = NULL; BIO_free_all(s->rbio); s->rbio = NULL; OPENSSL_free(s->s3.tmp.valid_flags); } void SSL_set0_rbio(SSL s, BIO rbio) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { ossl_quic_conn_set0_net_rbio(s, rbio); return; } #endif if (sc == NULL) return; BIO_free_all(sc->rbio); sc->rbio = rbio; sc->rlayer.rrlmethod->set1_bio(sc->rlayer.rrl, sc->rbio); } void SSL_set0_wbio(SSL s, BIO wbio) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { ossl_quic_conn_set0_net_wbio(s, wbio); return; } #endif if (sc == NULL) return; / * If the output buffering BIO is still in place, remove it / if (sc->bbio != NULL) sc->wbio = BIO_pop(sc->wbio); BIO_free_all(sc->wbio); sc->wbio = wbio; / Re-attach \|bbio\| to the new \|wbio\|. / if (sc->bbio != NULL) sc->wbio = BIO_push(sc->bbio, sc->wbio); sc->rlayer.wrlmethod->set1_bio(sc->rlayer.wrl, sc->wbio); } void SSL_set_bio(SSL s, BIO rbio, BIO wbio) { /* * For historical reasons, this function has many different cases in * ownership handling. / / If nothing has changed, do nothing / if (rbio == SSL_get_rbio(s) && wbio == SSL_get_wbio(s)) return; / * If the two arguments are equal then one fewer reference is granted by the * caller than we want to take / if (rbio != NULL && rbio == wbio) BIO_up_ref(rbio); / * If only the wbio is changed only adopt one reference. / if (rbio == SSL_get_rbio(s)) { SSL_set0_wbio(s, wbio); return; } / * There is an asymmetry here for historical reasons. If only the rbio is * changed AND the rbio and wbio were originally different, then we only * adopt one reference. / if (wbio == SSL_get_wbio(s) && SSL_get_rbio(s) != SSL_get_wbio(s)) { SSL_set0_rbio(s, rbio); return; } / Otherwise, adopt both references. / SSL_set0_rbio(s, rbio); SSL_set0_wbio(s, wbio); } BIO SSL_get_rbio(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_conn_get_net_rbio(s); #endif if (sc == NULL) return NULL; return sc->rbio; } BIO SSL_get_wbio(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_conn_get_net_wbio(s); #endif if (sc == NULL) return NULL; if (sc->bbio != NULL) { / * If \|bbio\| is active, the true caller-configured BIO is its * \|next_bio\|. / return BIO_next(sc->bbio); } return sc->wbio; } int SSL_get_fd(const SSL s) { return SSL_get_rfd(s); } int SSL_get_rfd(const SSL s) { int ret = -1; BIO b, r; b = SSL_get_rbio(s); r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR); if (r != NULL) BIO_get_fd(r, &ret); return ret; } int SSL_get_wfd(const SSL s) { int ret = -1; BIO b, r; b = SSL_get_wbio(s); r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR); if (r != NULL) BIO_get_fd(r, &ret); return ret; } #ifndef OPENSSL_NO_SOCK static const BIO_METHOD fd_method(SSL s) { #ifndef OPENSSL_NO_DGRAM if (IS_QUIC(s)) return BIO_s_datagram(); #endif return BIO_s_socket(); } int SSL_set_fd(SSL s, int fd) { int ret = 0; BIO bio = NULL; if (s->type == SSL_TYPE_QUIC_XSO) { ERR_raise(ERR_LIB_SSL, SSL_R_CONN_USE_ONLY); goto err; } bio = BIO_new(fd_method(s)); if (bio == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto err; } BIO_set_fd(bio, fd, BIO_NOCLOSE); SSL_set_bio(s, bio, bio); #ifndef OPENSSL_NO_KTLS /* * The new socket is created successfully regardless of ktls_enable. * ktls_enable doesn't change any functionality of the socket, except * changing the setsockopt to enable the processing of ktls_start. * Thus, it is not a problem to call it for non-TLS sockets. / ktls_enable(fd); #endif / OPENSSL_NO_KTLS / ret = 1; err: return ret; } int SSL_set_wfd(SSL s, int fd) { BIO rbio = SSL_get_rbio(s); int desired_type = IS_QUIC(s) ? BIO_TYPE_DGRAM : BIO_TYPE_SOCKET; if (s->type == SSL_TYPE_QUIC_XSO) { ERR_raise(ERR_LIB_SSL, SSL_R_CONN_USE_ONLY); return 0; } if (rbio == NULL \|\| BIO_method_type(rbio) != desired_type \|\| (int)BIO_get_fd(rbio, NULL) != fd) { BIO bio = BIO_new(fd_method(s)); if (bio == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); return 0; } BIO_set_fd(bio, fd, BIO_NOCLOSE); SSL_set0_wbio(s, bio); #ifndef OPENSSL_NO_KTLS /* * The new socket is created successfully regardless of ktls_enable. * ktls_enable doesn't change any functionality of the socket, except * changing the setsockopt to enable the processing of ktls_start. * Thus, it is not a problem to call it for non-TLS sockets. / ktls_enable(fd); #endif / OPENSSL_NO_KTLS / } else { BIO_up_ref(rbio); SSL_set0_wbio(s, rbio); } return 1; } int SSL_set_rfd(SSL s, int fd) { BIO wbio = SSL_get_wbio(s); int desired_type = IS_QUIC(s) ? BIO_TYPE_DGRAM : BIO_TYPE_SOCKET; if (s->type == SSL_TYPE_QUIC_XSO) { ERR_raise(ERR_LIB_SSL, SSL_R_CONN_USE_ONLY); return 0; } if (wbio == NULL \|\| BIO_method_type(wbio) != desired_type \|\| ((int)BIO_get_fd(wbio, NULL) != fd)) { BIO bio = BIO_new(fd_method(s)); if (bio == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); return 0; } BIO_set_fd(bio, fd, BIO_NOCLOSE); SSL_set0_rbio(s, bio); } else { BIO_up_ref(wbio); SSL_set0_rbio(s, wbio); } return 1; } #endif /* return length of latest Finished message we sent, copy to 'buf' / size_t SSL_get_finished(const SSL s, void buf, size_t count) { size_t ret = 0; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; ret = sc->s3.tmp.finish_md_len; if (count > ret) count = ret; memcpy(buf, sc->s3.tmp.finish_md, count); return ret; } /* return length of latest Finished message we expected, copy to 'buf' / size_t SSL_get_peer_finished(const SSL s, void buf, size_t count) { size_t ret = 0; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; ret = sc->s3.tmp.peer_finish_md_len; if (count > ret) count = ret; memcpy(buf, sc->s3.tmp.peer_finish_md, count); return ret; } int SSL_get_verify_mode(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->verify_mode; } int SSL_get_verify_depth(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return X509_VERIFY_PARAM_get_depth(sc->param); } int (SSL_get_verify_callback(const SSL s)) (int, X509_STORE_CTX ) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->verify_callback; } int SSL_CTX_get_verify_mode(const SSL_CTX ctx) { return ctx->verify_mode; } int SSL_CTX_get_verify_depth(const SSL_CTX ctx) { return X509_VERIFY_PARAM_get_depth(ctx->param); } int (SSL_CTX_get_verify_callback(const SSL_CTX ctx)) (int, X509_STORE_CTX ) { return ctx->default_verify_callback; } void SSL_set_verify(SSL s, int mode, int (callback) (int ok, X509_STORE_CTX ctx)) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->verify_mode = mode; if (callback != NULL) sc->verify_callback = callback; } void SSL_set_verify_depth(SSL s, int depth) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; X509_VERIFY_PARAM_set_depth(sc->param, depth); } void SSL_set_read_ahead(SSL s, int yes) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); OSSL_PARAM options[2], opts = options; if (sc == NULL) return; RECORD_LAYER_set_read_ahead(&sc->rlayer, yes); opts++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD, &sc->rlayer.read_ahead); opts = OSSL_PARAM_construct_end(); /* Ignore return value / sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options); } int SSL_get_read_ahead(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); if (sc == NULL) return 0; return RECORD_LAYER_get_read_ahead(&sc->rlayer); } int SSL_pending(const SSL s) { size_t pending = s->method->ssl_pending(s); /* * SSL_pending cannot work properly if read-ahead is enabled * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)), and it is * impossible to fix since SSL_pending cannot report errors that may be * observed while scanning the new data. (Note that SSL_pending() is * often used as a boolean value, so we'd better not return -1.) * * SSL_pending also cannot work properly if the value >INT_MAX. In that case * we just return INT_MAX. / return pending < INT_MAX ? (int)pending : INT_MAX; } int SSL_has_pending(const SSL s) { /* * Similar to SSL_pending() but returns a 1 to indicate that we have * processed or unprocessed data available or 0 otherwise (as opposed to the * number of bytes available). Unlike SSL_pending() this will take into * account read_ahead data. A 1 return simply indicates that we have data. * That data may not result in any application data, or we may fail to parse * the records for some reason. / const SSL_CONNECTION sc; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_has_pending(s); #endif sc = SSL_CONNECTION_FROM_CONST_SSL(s); /* Check buffered app data if any first / if (SSL_CONNECTION_IS_DTLS(sc)) { TLS_RECORD rdata; pitem item, iter; iter = pqueue_iterator(sc->rlayer.d->buffered_app_data.q); while ((item = pqueue_next(&iter)) != NULL) { rdata = item->data; if (rdata->length > 0) return 1; } } if (RECORD_LAYER_processed_read_pending(&sc->rlayer)) return 1; return RECORD_LAYER_read_pending(&sc->rlayer); } X509 SSL_get1_peer_certificate(const SSL s) { X509 r = SSL_get0_peer_certificate(s); if (r != NULL) X509_up_ref(r); return r; } X509 SSL_get0_peer_certificate(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (sc->session == NULL) return NULL; else return sc->session->peer; } STACK_OF(X509) SSL_get_peer_cert_chain(const SSL s) { STACK_OF(X509) r; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (sc->session == NULL) r = NULL; else r = sc->session->peer_chain; /* * If we are a client, cert_chain includes the peer's own certificate; if * we are a server, it does not. / return r; } / * Now in theory, since the calling process own 't' it should be safe to * modify. We need to be able to read f without being hassled / int SSL_copy_session_id(SSL t, const SSL f) { int i; / TODO(QUIC FUTURE): Not allowed for QUIC currently. / SSL_CONNECTION tsc = SSL_CONNECTION_FROM_SSL_ONLY(t); const SSL_CONNECTION fsc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(f); if (tsc == NULL \|\| fsc == NULL) return 0; / Do we need to do SSL locking? / if (!SSL_set_session(t, SSL_get_session(f))) { return 0; } / * what if we are setup for one protocol version but want to talk another / if (t->method != f->method) { t->method->ssl_deinit(t); t->method = f->method; if (t->method->ssl_init(t) == 0) return 0; } CRYPTO_UP_REF(&fsc->cert->references, &i); ssl_cert_free(tsc->cert); tsc->cert = fsc->cert; if (!SSL_set_session_id_context(t, fsc->sid_ctx, (int)fsc->sid_ctx_length)) { return 0; } return 1; } / Fix this so it checks all the valid key/cert options / int SSL_CTX_check_private_key(const SSL_CTX ctx) { if ((ctx == NULL) \|\| (ctx->cert->key->x509 == NULL)) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED); return 0; } if (ctx->cert->key->privatekey == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED); return 0; } return X509_check_private_key (ctx->cert->key->x509, ctx->cert->key->privatekey); } /* Fix this function so that it takes an optional type parameter / int SSL_check_private_key(const SSL ssl) { const SSL_CONNECTION sc; if ((sc = SSL_CONNECTION_FROM_CONST_SSL(ssl)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } if (sc->cert->key->x509 == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED); return 0; } if (sc->cert->key->privatekey == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED); return 0; } return X509_check_private_key(sc->cert->key->x509, sc->cert->key->privatekey); } int SSL_waiting_for_async(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->job) return 1; return 0; } int SSL_get_all_async_fds(SSL s, OSSL_ASYNC_FD fds, size_t numfds) { ASYNC_WAIT_CTX ctx; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if ((ctx = sc->waitctx) == NULL) return 0; return ASYNC_WAIT_CTX_get_all_fds(ctx, fds, numfds); } int SSL_get_changed_async_fds(SSL s, OSSL_ASYNC_FD addfd, size_t numaddfds, OSSL_ASYNC_FD delfd, size_t numdelfds) { ASYNC_WAIT_CTX ctx; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if ((ctx = sc->waitctx) == NULL) return 0; return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd, numdelfds); } int SSL_CTX_set_async_callback(SSL_CTX ctx, SSL_async_callback_fn callback) { ctx->async_cb = callback; return 1; } int SSL_CTX_set_async_callback_arg(SSL_CTX ctx, void arg) { ctx->async_cb_arg = arg; return 1; } int SSL_set_async_callback(SSL s, SSL_async_callback_fn callback) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->async_cb = callback; return 1; } int SSL_set_async_callback_arg(SSL s, void arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->async_cb_arg = arg; return 1; } int SSL_get_async_status(SSL s, int status) { ASYNC_WAIT_CTX ctx; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if ((ctx = sc->waitctx) == NULL) return 0; status = ASYNC_WAIT_CTX_get_status(ctx); return 1; } int SSL_accept(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_accept(s); #endif if (sc == NULL) return 0; if (sc->handshake_func == NULL) { /* Not properly initialized yet / SSL_set_accept_state(s); } return SSL_do_handshake(s); } int SSL_connect(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_connect(s); #endif if (sc == NULL) return 0; if (sc->handshake_func == NULL) { / Not properly initialized yet / SSL_set_connect_state(s); } return SSL_do_handshake(s); } long SSL_get_default_timeout(const SSL s) { return (long int)ossl_time2seconds(s->method->get_timeout()); } static int ssl_async_wait_ctx_cb(void arg) { SSL s = (SSL )arg; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return sc->async_cb(s, sc->async_cb_arg); } static int ssl_start_async_job(SSL s, struct ssl_async_args args, int (func) (void )) { int ret; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->waitctx == NULL) { sc->waitctx = ASYNC_WAIT_CTX_new(); if (sc->waitctx == NULL) return -1; if (sc->async_cb != NULL && !ASYNC_WAIT_CTX_set_callback (sc->waitctx, ssl_async_wait_ctx_cb, s)) return -1; } sc->rwstate = SSL_NOTHING; switch (ASYNC_start_job(&sc->job, sc->waitctx, &ret, func, args, sizeof(struct ssl_async_args))) { case ASYNC_ERR: sc->rwstate = SSL_NOTHING; ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_INIT_ASYNC); return -1; case ASYNC_PAUSE: sc->rwstate = SSL_ASYNC_PAUSED; return -1; case ASYNC_NO_JOBS: sc->rwstate = SSL_ASYNC_NO_JOBS; return -1; case ASYNC_FINISH: sc->job = NULL; return ret; default: sc->rwstate = SSL_NOTHING; ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); / Shouldn't happen / return -1; } } static int ssl_io_intern(void vargs) { struct ssl_async_args args; SSL s; void buf; size_t num; SSL_CONNECTION sc; args = (struct ssl_async_args )vargs; s = args->s; buf = args->buf; num = args->num; if ((sc = SSL_CONNECTION_FROM_SSL(s)) == NULL) return -1; switch (args->type) { case READFUNC: return args->f.func_read(s, buf, num, &sc->asyncrw); case WRITEFUNC: return args->f.func_write(s, buf, num, &sc->asyncrw); case OTHERFUNC: return args->f.func_other(s); } return -1; } int ssl_read_internal(SSL s, void buf, size_t num, size_t readbytes) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_read(s, buf, num, readbytes); #endif if (sc == NULL) return -1; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) { sc->rwstate = SSL_NOTHING; return 0; } if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY \|\| sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } / * If we are a client and haven't received the ServerHello etc then we * better do that / ossl_statem_check_finish_init(sc, 0); if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { struct ssl_async_args args; int ret; args.s = s; args.buf = buf; args.num = num; args.type = READFUNC; args.f.func_read = s->method->ssl_read; ret = ssl_start_async_job(s, &args, ssl_io_intern); readbytes = sc->asyncrw; return ret; } else { return s->method->ssl_read(s, buf, num, readbytes); } } int SSL_read(SSL s, void buf, int num) { int ret; size_t readbytes; if (num < 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); return -1; } ret = ssl_read_internal(s, buf, (size_t)num, &readbytes); /* * The cast is safe here because ret should be <= INT_MAX because num is * <= INT_MAX / if (ret > 0) ret = (int)readbytes; return ret; } int SSL_read_ex(SSL s, void buf, size_t num, size_t readbytes) { int ret = ssl_read_internal(s, buf, num, readbytes); if (ret < 0) ret = 0; return ret; } int SSL_read_early_data(SSL s, void buf, size_t num, size_t readbytes) { int ret; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); /* TODO(QUIC 0RTT): 0-RTT support / if (sc == NULL \|\| !sc->server) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return SSL_READ_EARLY_DATA_ERROR; } switch (sc->early_data_state) { case SSL_EARLY_DATA_NONE: if (!SSL_in_before(s)) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return SSL_READ_EARLY_DATA_ERROR; } / fall through / case SSL_EARLY_DATA_ACCEPT_RETRY: sc->early_data_state = SSL_EARLY_DATA_ACCEPTING; ret = SSL_accept(s); if (ret <= 0) { / NBIO or error / sc->early_data_state = SSL_EARLY_DATA_ACCEPT_RETRY; return SSL_READ_EARLY_DATA_ERROR; } / fall through / case SSL_EARLY_DATA_READ_RETRY: if (sc->ext.early_data == SSL_EARLY_DATA_ACCEPTED) { sc->early_data_state = SSL_EARLY_DATA_READING; ret = SSL_read_ex(s, buf, num, readbytes); / * State machine will update early_data_state to * SSL_EARLY_DATA_FINISHED_READING if we get an EndOfEarlyData * message / if (ret > 0 \|\| (ret <= 0 && sc->early_data_state != SSL_EARLY_DATA_FINISHED_READING)) { sc->early_data_state = SSL_EARLY_DATA_READ_RETRY; return ret > 0 ? SSL_READ_EARLY_DATA_SUCCESS : SSL_READ_EARLY_DATA_ERROR; } } else { sc->early_data_state = SSL_EARLY_DATA_FINISHED_READING; } readbytes = 0; return SSL_READ_EARLY_DATA_FINISH; default: ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return SSL_READ_EARLY_DATA_ERROR; } } int SSL_get_early_data_status(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); /* TODO(QUIC 0RTT): 0-RTT support / if (sc == NULL) return 0; return sc->ext.early_data; } static int ssl_peek_internal(SSL s, void buf, size_t num, size_t readbytes) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_peek(s, buf, num, readbytes); #endif if (sc == NULL) return 0; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) { return 0; } if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { struct ssl_async_args args; int ret; args.s = s; args.buf = buf; args.num = num; args.type = READFUNC; args.f.func_read = s->method->ssl_peek; ret = ssl_start_async_job(s, &args, ssl_io_intern); readbytes = sc->asyncrw; return ret; } else { return s->method->ssl_peek(s, buf, num, readbytes); } } int SSL_peek(SSL s, void buf, int num) { int ret; size_t readbytes; if (num < 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); return -1; } ret = ssl_peek_internal(s, buf, (size_t)num, &readbytes); /* * The cast is safe here because ret should be <= INT_MAX because num is * <= INT_MAX / if (ret > 0) ret = (int)readbytes; return ret; } int SSL_peek_ex(SSL s, void buf, size_t num, size_t readbytes) { int ret = ssl_peek_internal(s, buf, num, readbytes); if (ret < 0) ret = 0; return ret; } int ssl_write_internal(SSL s, const void buf, size_t num, size_t written) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_write(s, buf, num, written); #endif if (sc == NULL) return 0; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (sc->shutdown & SSL_SENT_SHUTDOWN) { sc->rwstate = SSL_NOTHING; ERR_raise(ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN); return -1; } if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY \|\| sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY \|\| sc->early_data_state == SSL_EARLY_DATA_READ_RETRY) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } /* If we are a client and haven't sent the Finished we better do that / ossl_statem_check_finish_init(sc, 1); if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { int ret; struct ssl_async_args args; args.s = s; args.buf = (void )buf; args.num = num; args.type = WRITEFUNC; args.f.func_write = s->method->ssl_write; ret = ssl_start_async_job(s, &args, ssl_io_intern); written = sc->asyncrw; return ret; } else { return s->method->ssl_write(s, buf, num, written); } } ossl_ssize_t SSL_sendfile(SSL s, int fd, off_t offset, size_t size, int flags) { ossl_ssize_t ret; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (sc->shutdown & SSL_SENT_SHUTDOWN) { sc->rwstate = SSL_NOTHING; ERR_raise(ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN); return -1; } if (!BIO_get_ktls_send(sc->wbio)) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } / If we have an alert to send, lets send it / if (sc->s3.alert_dispatch > 0) { ret = (ossl_ssize_t)s->method->ssl_dispatch_alert(s); if (ret <= 0) { / SSLfatal() already called if appropriate / return ret; } / if it went, fall through and send more stuff / } sc->rwstate = SSL_WRITING; if (BIO_flush(sc->wbio) <= 0) { if (!BIO_should_retry(sc->wbio)) { sc->rwstate = SSL_NOTHING; } else { #ifdef EAGAIN set_sys_error(EAGAIN); #endif } return -1; } #ifdef OPENSSL_NO_KTLS ERR_raise_data(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR, "can't call ktls_sendfile(), ktls disabled"); return -1; #else ret = ktls_sendfile(SSL_get_wfd(s), fd, offset, size, flags); if (ret < 0) { #if defined(EAGAIN) && defined(EINTR) && defined(EBUSY) if ((get_last_sys_error() == EAGAIN) \|\| (get_last_sys_error() == EINTR) \|\| (get_last_sys_error() == EBUSY)) BIO_set_retry_write(sc->wbio); else #endif ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return ret; } sc->rwstate = SSL_NOTHING; return ret; #endif } int SSL_write(SSL s, const void buf, int num) { int ret; size_t written; if (num < 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); return -1; } ret = ssl_write_internal(s, buf, (size_t)num, &written); / * The cast is safe here because ret should be <= INT_MAX because num is * <= INT_MAX / if (ret > 0) ret = (int)written; return ret; } int SSL_write_ex(SSL s, const void buf, size_t num, size_t written) { int ret = ssl_write_internal(s, buf, num, written); if (ret < 0) ret = 0; return ret; } int SSL_write_early_data(SSL s, const void buf, size_t num, size_t written) { int ret, early_data_state; size_t writtmp; uint32_t partialwrite; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); /* TODO(QUIC 0RTT): This will need special handling for QUIC / if (sc == NULL) return 0; switch (sc->early_data_state) { case SSL_EARLY_DATA_NONE: if (sc->server \|\| !SSL_in_before(s) \|\| ((sc->session == NULL \|\| sc->session->ext.max_early_data == 0) && (sc->psk_use_session_cb == NULL))) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } / fall through / case SSL_EARLY_DATA_CONNECT_RETRY: sc->early_data_state = SSL_EARLY_DATA_CONNECTING; ret = SSL_connect(s); if (ret <= 0) { / NBIO or error / sc->early_data_state = SSL_EARLY_DATA_CONNECT_RETRY; return 0; } / fall through / case SSL_EARLY_DATA_WRITE_RETRY: sc->early_data_state = SSL_EARLY_DATA_WRITING; / * We disable partial write for early data because we don't keep track * of how many bytes we've written between the SSL_write_ex() call and * the flush if the flush needs to be retried) / partialwrite = sc->mode & SSL_MODE_ENABLE_PARTIAL_WRITE; sc->mode &= ~SSL_MODE_ENABLE_PARTIAL_WRITE; ret = SSL_write_ex(s, buf, num, &writtmp); sc->mode \|= partialwrite; if (!ret) { sc->early_data_state = SSL_EARLY_DATA_WRITE_RETRY; return ret; } sc->early_data_state = SSL_EARLY_DATA_WRITE_FLUSH; / fall through / case SSL_EARLY_DATA_WRITE_FLUSH: / The buffering BIO is still in place so we need to flush it / if (statem_flush(sc) != 1) return 0; written = num; sc->early_data_state = SSL_EARLY_DATA_WRITE_RETRY; return 1; case SSL_EARLY_DATA_FINISHED_READING: case SSL_EARLY_DATA_READ_RETRY: early_data_state = sc->early_data_state; /* We are a server writing to an unauthenticated client / sc->early_data_state = SSL_EARLY_DATA_UNAUTH_WRITING; ret = SSL_write_ex(s, buf, num, written); / The buffering BIO is still in place / if (ret) (void)BIO_flush(sc->wbio); sc->early_data_state = early_data_state; return ret; default: ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } } int SSL_shutdown(SSL s) { /* * Note that this function behaves differently from what one might * expect. Return values are 0 for no success (yet), 1 for success; but * calling it once is usually not enough, even if blocking I/O is used * (see ssl3_shutdown). / SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_conn_shutdown(s, 0, NULL, 0); #endif if (sc == NULL) return -1; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (!SSL_in_init(s)) { if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { struct ssl_async_args args; memset(&args, 0, sizeof(args)); args.s = s; args.type = OTHERFUNC; args.f.func_other = s->method->ssl_shutdown; return ssl_start_async_job(s, &args, ssl_io_intern); } else { return s->method->ssl_shutdown(s); } } else { ERR_raise(ERR_LIB_SSL, SSL_R_SHUTDOWN_WHILE_IN_INIT); return -1; } } int SSL_key_update(SSL s, int updatetype) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_key_update(s, updatetype); #endif if (sc == NULL) return 0; if (!SSL_CONNECTION_IS_TLS13(sc)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED && updatetype != SSL_KEY_UPDATE_REQUESTED) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_KEY_UPDATE_TYPE); return 0; } if (!SSL_is_init_finished(s)) { ERR_raise(ERR_LIB_SSL, SSL_R_STILL_IN_INIT); return 0; } if (RECORD_LAYER_write_pending(&sc->rlayer)) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_WRITE_RETRY); return 0; } ossl_statem_set_in_init(sc, 1); sc->key_update = updatetype; return 1; } int SSL_get_key_update_type(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_key_update_type(s); #endif if (sc == NULL) return 0; return sc->key_update; } /* * Can we accept a renegotiation request? If yes, set the flag and * return 1 if yes. If not, raise error and return 0. / static int can_renegotiate(const SSL_CONNECTION sc) { if (SSL_CONNECTION_IS_TLS13(sc)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } if ((sc->options & SSL_OP_NO_RENEGOTIATION) != 0) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_RENEGOTIATION); return 0; } return 1; } int SSL_renegotiate(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (!can_renegotiate(sc)) return 0; sc->renegotiate = 1; sc->new_session = 1; return s->method->ssl_renegotiate(s); } int SSL_renegotiate_abbreviated(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (!can_renegotiate(sc)) return 0; sc->renegotiate = 1; sc->new_session = 0; return s->method->ssl_renegotiate(s); } int SSL_renegotiate_pending(const SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; /* * becomes true when negotiation is requested; false again once a * handshake has finished / return (sc->renegotiate != 0); } int SSL_new_session_ticket(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; / If we are in init because we're sending tickets, okay to send more. / if ((SSL_in_init(s) && sc->ext.extra_tickets_expected == 0) \|\| SSL_IS_FIRST_HANDSHAKE(sc) \|\| !sc->server \|\| !SSL_CONNECTION_IS_TLS13(sc)) return 0; sc->ext.extra_tickets_expected++; if (!RECORD_LAYER_write_pending(&sc->rlayer) && !SSL_in_init(s)) ossl_statem_set_in_init(sc, 1); return 1; } long SSL_ctrl(SSL s, int cmd, long larg, void parg) { return ossl_ctrl_internal(s, cmd, larg, parg, /no_quic=/0); } long ossl_ctrl_internal(SSL s, int cmd, long larg, void parg, int no_quic) { long l; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* * Routing of ctrl calls for QUIC is a little counterintuitive: * * - Firstly (no_quic=0), we pass the ctrl directly to our QUIC * implementation in case it wants to handle the ctrl specially. * * - If our QUIC implementation does not care about the ctrl, it * will reenter this function with no_quic=1 and we will try to handle * it directly using the QCSO SSL object stub (not the handshake layer * SSL object). This is important for e.g. the version configuration * ctrls below, which must use s->defltmeth (and not sc->defltmeth). * * - If we don't handle a ctrl here specially, then processing is * redirected to the handshake layer SSL object. / if (!no_quic && IS_QUIC(s)) return s->method->ssl_ctrl(s, cmd, larg, parg); switch (cmd) { case SSL_CTRL_GET_READ_AHEAD: return RECORD_LAYER_get_read_ahead(&sc->rlayer); case SSL_CTRL_SET_READ_AHEAD: l = RECORD_LAYER_get_read_ahead(&sc->rlayer); RECORD_LAYER_set_read_ahead(&sc->rlayer, larg); return l; case SSL_CTRL_MODE: { OSSL_PARAM options[2], opts = options; sc->mode \|= larg; opts++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE, &sc->mode); opts = OSSL_PARAM_construct_end(); /* Ignore return value / sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options); return sc->mode; } case SSL_CTRL_CLEAR_MODE: return (sc->mode &= ~larg); case SSL_CTRL_GET_MAX_CERT_LIST: return (long)sc->max_cert_list; case SSL_CTRL_SET_MAX_CERT_LIST: if (larg < 0) return 0; l = (long)sc->max_cert_list; sc->max_cert_list = (size_t)larg; return l; case SSL_CTRL_SET_MAX_SEND_FRAGMENT: if (larg < 512 \|\| larg > SSL3_RT_MAX_PLAIN_LENGTH) return 0; #ifndef OPENSSL_NO_KTLS if (sc->wbio != NULL && BIO_get_ktls_send(sc->wbio)) return 0; #endif / OPENSSL_NO_KTLS / sc->max_send_fragment = larg; if (sc->max_send_fragment < sc->split_send_fragment) sc->split_send_fragment = sc->max_send_fragment; sc->rlayer.wrlmethod->set_max_frag_len(sc->rlayer.wrl, larg); return 1; case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT: if ((size_t)larg > sc->max_send_fragment \|\| larg == 0) return 0; sc->split_send_fragment = larg; return 1; case SSL_CTRL_SET_MAX_PIPELINES: if (larg < 1 \|\| larg > SSL_MAX_PIPELINES) return 0; sc->max_pipelines = larg; if (sc->rlayer.rrlmethod->set_max_pipelines != NULL) sc->rlayer.rrlmethod->set_max_pipelines(sc->rlayer.rrl, (size_t)larg); return 1; case SSL_CTRL_GET_RI_SUPPORT: return sc->s3.send_connection_binding; case SSL_CTRL_SET_RETRY_VERIFY: sc->rwstate = SSL_RETRY_VERIFY; return 1; case SSL_CTRL_CERT_FLAGS: return (sc->cert->cert_flags \|= larg); case SSL_CTRL_CLEAR_CERT_FLAGS: return (sc->cert->cert_flags &= ~larg); case SSL_CTRL_GET_RAW_CIPHERLIST: if (parg) { if (sc->s3.tmp.ciphers_raw == NULL) return 0; (unsigned char *)parg = sc->s3.tmp.ciphers_raw; return (int)sc->s3.tmp.ciphers_rawlen; } else { return TLS_CIPHER_LEN; } case SSL_CTRL_GET_EXTMS_SUPPORT: if (!sc->session \|\| SSL_in_init(s) \|\| ossl_statem_get_in_handshake(sc)) return -1; if (sc->session->flags & SSL_SESS_FLAG_EXTMS) return 1; else return 0; case SSL_CTRL_SET_MIN_PROTO_VERSION: return ssl_check_allowed_versions(larg, sc->max_proto_version) && ssl_set_version_bound(s->defltmeth->version, (int)larg, &sc->min_proto_version); case SSL_CTRL_GET_MIN_PROTO_VERSION: return sc->min_proto_version; case SSL_CTRL_SET_MAX_PROTO_VERSION: return ssl_check_allowed_versions(sc->min_proto_version, larg) && ssl_set_version_bound(s->defltmeth->version, (int)larg, &sc->max_proto_version); case SSL_CTRL_GET_MAX_PROTO_VERSION: return sc->max_proto_version; default: if (IS_QUIC(s)) return SSL_ctrl((SSL )sc, cmd, larg, parg); else return s->method->ssl_ctrl(s, cmd, larg, parg); } } long SSL_callback_ctrl(SSL s, int cmd, void (fp) (void)) { return s->method->ssl_callback_ctrl(s, cmd, fp); } LHASH_OF(SSL_SESSION) SSL_CTX_sessions(SSL_CTX ctx) { return ctx->sessions; } static int ssl_tsan_load(SSL_CTX ctx, TSAN_QUALIFIER int stat) { int res = 0; if (ssl_tsan_lock(ctx)) { res = tsan_load(stat); ssl_tsan_unlock(ctx); } return res; } long SSL_CTX_ctrl(SSL_CTX ctx, int cmd, long larg, void parg) { long l; /* For some cases with ctx == NULL perform syntax checks / if (ctx == NULL) { switch (cmd) { case SSL_CTRL_SET_GROUPS_LIST: return tls1_set_groups_list(ctx, NULL, NULL, parg); case SSL_CTRL_SET_SIGALGS_LIST: case SSL_CTRL_SET_CLIENT_SIGALGS_LIST: return tls1_set_sigalgs_list(NULL, parg, 0); default: return 0; } } switch (cmd) { case SSL_CTRL_GET_READ_AHEAD: return ctx->read_ahead; case SSL_CTRL_SET_READ_AHEAD: l = ctx->read_ahead; ctx->read_ahead = larg; return l; case SSL_CTRL_SET_MSG_CALLBACK_ARG: ctx->msg_callback_arg = parg; return 1; case SSL_CTRL_GET_MAX_CERT_LIST: return (long)ctx->max_cert_list; case SSL_CTRL_SET_MAX_CERT_LIST: if (larg < 0) return 0; l = (long)ctx->max_cert_list; ctx->max_cert_list = (size_t)larg; return l; case SSL_CTRL_SET_SESS_CACHE_SIZE: if (larg < 0) return 0; l = (long)ctx->session_cache_size; ctx->session_cache_size = (size_t)larg; return l; case SSL_CTRL_GET_SESS_CACHE_SIZE: return (long)ctx->session_cache_size; case SSL_CTRL_SET_SESS_CACHE_MODE: l = ctx->session_cache_mode; ctx->session_cache_mode = larg; return l; case SSL_CTRL_GET_SESS_CACHE_MODE: return ctx->session_cache_mode; case SSL_CTRL_SESS_NUMBER: return lh_SSL_SESSION_num_items(ctx->sessions); case SSL_CTRL_SESS_CONNECT: return ssl_tsan_load(ctx, &ctx->stats.sess_connect); case SSL_CTRL_SESS_CONNECT_GOOD: return ssl_tsan_load(ctx, &ctx->stats.sess_connect_good); case SSL_CTRL_SESS_CONNECT_RENEGOTIATE: return ssl_tsan_load(ctx, &ctx->stats.sess_connect_renegotiate); case SSL_CTRL_SESS_ACCEPT: return ssl_tsan_load(ctx, &ctx->stats.sess_accept); case SSL_CTRL_SESS_ACCEPT_GOOD: return ssl_tsan_load(ctx, &ctx->stats.sess_accept_good); case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE: return ssl_tsan_load(ctx, &ctx->stats.sess_accept_renegotiate); case SSL_CTRL_SESS_HIT: return ssl_tsan_load(ctx, &ctx->stats.sess_hit); case SSL_CTRL_SESS_CB_HIT: return ssl_tsan_load(ctx, &ctx->stats.sess_cb_hit); case SSL_CTRL_SESS_MISSES: return ssl_tsan_load(ctx, &ctx->stats.sess_miss); case SSL_CTRL_SESS_TIMEOUTS: return ssl_tsan_load(ctx, &ctx->stats.sess_timeout); case SSL_CTRL_SESS_CACHE_FULL: return ssl_tsan_load(ctx, &ctx->stats.sess_cache_full); case SSL_CTRL_MODE: return (ctx->mode \|= larg); case SSL_CTRL_CLEAR_MODE: return (ctx->mode &= ~larg); case SSL_CTRL_SET_MAX_SEND_FRAGMENT: if (larg < 512 \|\| larg > SSL3_RT_MAX_PLAIN_LENGTH) return 0; ctx->max_send_fragment = larg; if (ctx->max_send_fragment < ctx->split_send_fragment) ctx->split_send_fragment = ctx->max_send_fragment; return 1; case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT: if ((size_t)larg > ctx->max_send_fragment \|\| larg == 0) return 0; ctx->split_send_fragment = larg; return 1; case SSL_CTRL_SET_MAX_PIPELINES: if (larg < 1 \|\| larg > SSL_MAX_PIPELINES) return 0; ctx->max_pipelines = larg; return 1; case SSL_CTRL_CERT_FLAGS: return (ctx->cert->cert_flags \|= larg); case SSL_CTRL_CLEAR_CERT_FLAGS: return (ctx->cert->cert_flags &= ~larg); case SSL_CTRL_SET_MIN_PROTO_VERSION: return ssl_check_allowed_versions(larg, ctx->max_proto_version) && ssl_set_version_bound(ctx->method->version, (int)larg, &ctx->min_proto_version); case SSL_CTRL_GET_MIN_PROTO_VERSION: return ctx->min_proto_version; case SSL_CTRL_SET_MAX_PROTO_VERSION: return ssl_check_allowed_versions(ctx->min_proto_version, larg) && ssl_set_version_bound(ctx->method->version, (int)larg, &ctx->max_proto_version); case SSL_CTRL_GET_MAX_PROTO_VERSION: return ctx->max_proto_version; default: return ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg); } } long SSL_CTX_callback_ctrl(SSL_CTX ctx, int cmd, void (fp) (void)) { switch (cmd) { case SSL_CTRL_SET_MSG_CALLBACK: ctx->msg_callback = (void () (int write_p, int version, int content_type, const void buf, size_t len, SSL ssl, void arg))(fp); return 1; default: return ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp); } } int ssl_cipher_id_cmp(const SSL_CIPHER a, const SSL_CIPHER b) { if (a->id > b->id) return 1; if (a->id < b->id) return -1; return 0; } int ssl_cipher_ptr_id_cmp(const SSL_CIPHER const ap, const SSL_CIPHER const bp) { if ((ap)->id > (bp)->id) return 1; if ((ap)->id < (bp)->id) return -1; return 0; } / * return a STACK of the ciphers available for the SSL and in order of * preference / STACK_OF(SSL_CIPHER) SSL_get_ciphers(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc != NULL) { if (sc->cipher_list != NULL) { return sc->cipher_list; } else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) { return s->ctx->cipher_list; } } return NULL; } STACK_OF(SSL_CIPHER) SSL_get_client_ciphers(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL \|\| !sc->server) return NULL; return sc->peer_ciphers; } STACK_OF(SSL_CIPHER) SSL_get1_supported_ciphers(SSL s) { STACK_OF(SSL_CIPHER) sk = NULL, ciphers; int i; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; ciphers = SSL_get_ciphers(s); if (!ciphers) return NULL; if (!ssl_set_client_disabled(sc)) return NULL; for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) { const SSL_CIPHER c = sk_SSL_CIPHER_value(ciphers, i); if (!ssl_cipher_disabled(sc, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) { if (!sk) sk = sk_SSL_CIPHER_new_null(); if (!sk) return NULL; if (!sk_SSL_CIPHER_push(sk, c)) { sk_SSL_CIPHER_free(sk); return NULL; } } } return sk; } /* return a STACK of the ciphers available for the SSL and in order of * algorithm id / STACK_OF(SSL_CIPHER) ssl_get_ciphers_by_id(SSL_CONNECTION s) { if (s != NULL) { if (s->cipher_list_by_id != NULL) return s->cipher_list_by_id; else if (s->ssl.ctx != NULL && s->ssl.ctx->cipher_list_by_id != NULL) return s->ssl.ctx->cipher_list_by_id; } return NULL; } /* The old interface to get the same thing as SSL_get_ciphers() / const char SSL_get_cipher_list(const SSL s, int n) { const SSL_CIPHER c; STACK_OF(SSL_CIPHER) sk; if (s == NULL) return NULL; sk = SSL_get_ciphers(s); if ((sk == NULL) \|\| (sk_SSL_CIPHER_num(sk) <= n)) return NULL; c = sk_SSL_CIPHER_value(sk, n); if (c == NULL) return NULL; return c->name; } /* return a STACK of the ciphers available for the SSL_CTX and in order of * preference / STACK_OF(SSL_CIPHER) SSL_CTX_get_ciphers(const SSL_CTX ctx) { if (ctx != NULL) return ctx->cipher_list; return NULL; } / * Distinguish between ciphers controlled by set_ciphersuite() and * set_cipher_list() when counting. / static int cipher_list_tls12_num(STACK_OF(SSL_CIPHER) sk) { int i, num = 0; const SSL_CIPHER c; if (sk == NULL) return 0; for (i = 0; i < sk_SSL_CIPHER_num(sk); ++i) { c = sk_SSL_CIPHER_value(sk, i); if (c->min_tls >= TLS1_3_VERSION) continue; num++; } return num; } /* specify the ciphers to be used by default by the SSL_CTX / int SSL_CTX_set_cipher_list(SSL_CTX ctx, const char str) { STACK_OF(SSL_CIPHER) sk; sk = ssl_create_cipher_list(ctx, ctx->tls13_ciphersuites, &ctx->cipher_list, &ctx->cipher_list_by_id, str, ctx->cert); /* * ssl_create_cipher_list may return an empty stack if it was unable to * find a cipher matching the given rule string (for example if the rule * string specifies a cipher which has been disabled). This is not an * error as far as ssl_create_cipher_list is concerned, and hence * ctx->cipher_list and ctx->cipher_list_by_id has been updated. / if (sk == NULL) return 0; else if (cipher_list_tls12_num(sk) == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH); return 0; } return 1; } /* specify the ciphers to be used by the SSL / int SSL_set_cipher_list(SSL s, const char str) { STACK_OF(SSL_CIPHER) sk; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sk = ssl_create_cipher_list(s->ctx, sc->tls13_ciphersuites, &sc->cipher_list, &sc->cipher_list_by_id, str, sc->cert); / see comment in SSL_CTX_set_cipher_list / if (sk == NULL) return 0; else if (cipher_list_tls12_num(sk) == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH); return 0; } return 1; } char SSL_get_shared_ciphers(const SSL s, char buf, int size) { char p; STACK_OF(SSL_CIPHER) clntsk, srvrsk; const SSL_CIPHER c; int i; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (!sc->server \|\| sc->peer_ciphers == NULL \|\| size < 2) return NULL; p = buf; clntsk = sc->peer_ciphers; srvrsk = SSL_get_ciphers(s); if (clntsk == NULL \|\| srvrsk == NULL) return NULL; if (sk_SSL_CIPHER_num(clntsk) == 0 \|\| sk_SSL_CIPHER_num(srvrsk) == 0) return NULL; for (i = 0; i < sk_SSL_CIPHER_num(clntsk); i++) { int n; c = sk_SSL_CIPHER_value(clntsk, i); if (sk_SSL_CIPHER_find(srvrsk, c) < 0) continue; n = OPENSSL_strnlen(c->name, size); if (n >= size) { if (p != buf) --p; p = '\0'; return buf; } memcpy(p, c->name, n); p += n; (p++) = ':'; size -= n + 1; } p[-1] = '\0'; return buf; } /* * Return the requested servername (SNI) value. Note that the behaviour varies * depending on: * - whether this is called by the client or the server, * - if we are before or during/after the handshake, * - if a resumption or normal handshake is being attempted/has occurred * - whether we have negotiated TLSv1.2 (or below) or TLSv1.3 * * Note that only the host_name type is defined (RFC 3546). / const char SSL_get_servername(const SSL s, const int type) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); int server; if (sc == NULL) return NULL; /* * If we don't know if we are the client or the server yet then we assume * client. / server = sc->handshake_func == NULL ? 0 : sc->server; if (type != TLSEXT_NAMETYPE_host_name) return NULL; if (server) { /* * Server side * In TLSv1.3 on the server SNI is not associated with the session * but in TLSv1.2 or below it is. * * Before the handshake: * - return NULL * * During/after the handshake (TLSv1.2 or below resumption occurred): * - If a servername was accepted by the server in the original * handshake then it will return that servername, or NULL otherwise. * * During/after the handshake (TLSv1.2 or below resumption did not occur): * - The function will return the servername requested by the client in * this handshake or NULL if none was requested. / if (sc->hit && !SSL_CONNECTION_IS_TLS13(sc)) return sc->session->ext.hostname; } else { /* * Client side * * Before the handshake: * - If a servername has been set via a call to * SSL_set_tlsext_host_name() then it will return that servername * - If one has not been set, but a TLSv1.2 resumption is being * attempted and the session from the original handshake had a * servername accepted by the server then it will return that * servername * - Otherwise it returns NULL * * During/after the handshake (TLSv1.2 or below resumption occurred): * - If the session from the original handshake had a servername accepted * by the server then it will return that servername. * - Otherwise it returns the servername set via * SSL_set_tlsext_host_name() (or NULL if it was not called). * * During/after the handshake (TLSv1.2 or below resumption did not occur): * - It will return the servername set via SSL_set_tlsext_host_name() * (or NULL if it was not called). / if (SSL_in_before(s)) { if (sc->ext.hostname == NULL && sc->session != NULL && sc->session->ssl_version != TLS1_3_VERSION) return sc->session->ext.hostname; } else { if (!SSL_CONNECTION_IS_TLS13(sc) && sc->hit && sc->session->ext.hostname != NULL) return sc->session->ext.hostname; } } return sc->ext.hostname; } int SSL_get_servername_type(const SSL s) { if (SSL_get_servername(s, TLSEXT_NAMETYPE_host_name) != NULL) return TLSEXT_NAMETYPE_host_name; return -1; } /* * SSL_select_next_proto implements the standard protocol selection. It is * expected that this function is called from the callback set by * SSL_CTX_set_next_proto_select_cb. The protocol data is assumed to be a * vector of 8-bit, length prefixed byte strings. The length byte itself is * not included in the length. A byte string of length 0 is invalid. No byte * string may be truncated. The current, but experimental algorithm for * selecting the protocol is: 1) If the server doesn't support NPN then this * is indicated to the callback. In this case, the client application has to * abort the connection or have a default application level protocol. 2) If * the server supports NPN, but advertises an empty list then the client * selects the first protocol in its list, but indicates via the API that this * fallback case was enacted. 3) Otherwise, the client finds the first * protocol in the server's list that it supports and selects this protocol. * This is because it's assumed that the server has better information about * which protocol a client should use. 4) If the client doesn't support any * of the server's advertised protocols, then this is treated the same as * case 2. It returns either OPENSSL_NPN_NEGOTIATED if a common protocol was * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached. / int SSL_select_next_proto(unsigned char out, unsigned char outlen, const unsigned char server, unsigned int server_len, const unsigned char client, unsigned int client_len) { unsigned int i, j; const unsigned char result; int status = OPENSSL_NPN_UNSUPPORTED; / * For each protocol in server preference order, see if we support it. / for (i = 0; i < server_len;) { for (j = 0; j < client_len;) { if (server[i] == client[j] && memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) { / We found a match / result = &server[i]; status = OPENSSL_NPN_NEGOTIATED; goto found; } j += client[j]; j++; } i += server[i]; i++; } / There's no overlap between our protocols and the server's list. / result = client; status = OPENSSL_NPN_NO_OVERLAP; found: out = (unsigned char )result + 1; outlen = result[0]; return status; } #ifndef OPENSSL_NO_NEXTPROTONEG /* * SSL_get0_next_proto_negotiated sets data and len to point to the * client's requested protocol for this connection and returns 0. If the * client didn't request any protocol, then data is set to NULL. Note that the client can request any protocol it chooses. The value returned from * this function need not be a member of the list of supported protocols * provided by the callback. / void SSL_get0_next_proto_negotiated(const SSL s, const unsigned char *data, unsigned len) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) { / We have no other way to indicate error / data = NULL; len = 0; return; } data = sc->ext.npn; if (data == NULL) { len = 0; } else { len = (unsigned int)sc->ext.npn_len; } } / * SSL_CTX_set_npn_advertised_cb sets a callback that is called when * a TLS server needs a list of supported protocols for Next Protocol * Negotiation. The returned list must be in wire format. The list is * returned by setting \|out\| to point to it and \|outlen\| to its length. This * memory will not be modified, but one should assume that the SSL* keeps a * reference to it. The callback should return SSL_TLSEXT_ERR_OK if it * wishes to advertise. Otherwise, no such extension will be included in the * ServerHello. / void SSL_CTX_set_npn_advertised_cb(SSL_CTX ctx, SSL_CTX_npn_advertised_cb_func cb, void arg) { if (IS_QUIC_CTX(ctx)) / NPN not allowed for QUIC / return; ctx->ext.npn_advertised_cb = cb; ctx->ext.npn_advertised_cb_arg = arg; } / * SSL_CTX_set_next_proto_select_cb sets a callback that is called when a * client needs to select a protocol from the server's provided list. \|out\| * must be set to point to the selected protocol (which may be within \|in\|). * The length of the protocol name must be written into \|outlen\|. The * server's advertised protocols are provided in \|in\| and \|inlen\|. The * callback can assume that \|in\| is syntactically valid. The client must * select a protocol. It is fatal to the connection if this callback returns * a value other than SSL_TLSEXT_ERR_OK. / void SSL_CTX_set_npn_select_cb(SSL_CTX ctx, SSL_CTX_npn_select_cb_func cb, void arg) { if (IS_QUIC_CTX(ctx)) / NPN not allowed for QUIC / return; ctx->ext.npn_select_cb = cb; ctx->ext.npn_select_cb_arg = arg; } #endif static int alpn_value_ok(const unsigned char protos, unsigned int protos_len) { unsigned int idx; if (protos_len < 2 \|\| protos == NULL) return 0; for (idx = 0; idx < protos_len; idx += protos[idx] + 1) { if (protos[idx] == 0) return 0; } return idx == protos_len; } /* * SSL_CTX_set_alpn_protos sets the ALPN protocol list on \|ctx\| to \|protos\|. * \|protos\| must be in wire-format (i.e. a series of non-empty, 8-bit * length-prefixed strings). Returns 0 on success. / int SSL_CTX_set_alpn_protos(SSL_CTX ctx, const unsigned char protos, unsigned int protos_len) { unsigned char alpn; if (protos_len == 0 \|\| protos == NULL) { OPENSSL_free(ctx->ext.alpn); ctx->ext.alpn = NULL; ctx->ext.alpn_len = 0; return 0; } /* Not valid per RFC / if (!alpn_value_ok(protos, protos_len)) return 1; alpn = OPENSSL_memdup(protos, protos_len); if (alpn == NULL) return 1; OPENSSL_free(ctx->ext.alpn); ctx->ext.alpn = alpn; ctx->ext.alpn_len = protos_len; return 0; } / * SSL_set_alpn_protos sets the ALPN protocol list on \|ssl\| to \|protos\|. * \|protos\| must be in wire-format (i.e. a series of non-empty, 8-bit * length-prefixed strings). Returns 0 on success. / int SSL_set_alpn_protos(SSL ssl, const unsigned char protos, unsigned int protos_len) { unsigned char alpn; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 1; if (protos_len == 0 \|\| protos == NULL) { OPENSSL_free(sc->ext.alpn); sc->ext.alpn = NULL; sc->ext.alpn_len = 0; return 0; } / Not valid per RFC / if (!alpn_value_ok(protos, protos_len)) return 1; alpn = OPENSSL_memdup(protos, protos_len); if (alpn == NULL) return 1; OPENSSL_free(sc->ext.alpn); sc->ext.alpn = alpn; sc->ext.alpn_len = protos_len; return 0; } / * SSL_CTX_set_alpn_select_cb sets a callback function on \|ctx\| that is * called during ClientHello processing in order to select an ALPN protocol * from the client's list of offered protocols. / void SSL_CTX_set_alpn_select_cb(SSL_CTX ctx, SSL_CTX_alpn_select_cb_func cb, void arg) { ctx->ext.alpn_select_cb = cb; ctx->ext.alpn_select_cb_arg = arg; } / * SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from \|ssl\|. * On return it sets \|data\| to point to \|len\| bytes of protocol name * (not including the leading length-prefix byte). If the server didn't * respond with a negotiated protocol then \|len\| will be zero. / void SSL_get0_alpn_selected(const SSL ssl, const unsigned char data, unsigned int len) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) { / We have no other way to indicate error / data = NULL; len = 0; return; } data = sc->s3.alpn_selected; if (data == NULL) len = 0; else len = (unsigned int)sc->s3.alpn_selected_len; } int SSL_export_keying_material(SSL s, unsigned char out, size_t olen, const char label, size_t llen, const unsigned char context, size_t contextlen, int use_context) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; if (sc->session == NULL \|\| (sc->version < TLS1_VERSION && sc->version != DTLS1_BAD_VER)) return -1; return s->method->ssl3_enc->export_keying_material(sc, out, olen, label, llen, context, contextlen, use_context); } int SSL_export_keying_material_early(SSL s, unsigned char out, size_t olen, const char label, size_t llen, const unsigned char context, size_t contextlen) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; if (sc->version != TLS1_3_VERSION) return 0; return tls13_export_keying_material_early(sc, out, olen, label, llen, context, contextlen); } static unsigned long ssl_session_hash(const SSL_SESSION a) { const unsigned char session_id = a->session_id; unsigned long l; unsigned char tmp_storage[4]; if (a->session_id_length < sizeof(tmp_storage)) { memset(tmp_storage, 0, sizeof(tmp_storage)); memcpy(tmp_storage, a->session_id, a->session_id_length); session_id = tmp_storage; } l = (unsigned long) ((unsigned long)session_id[0]) \| ((unsigned long)session_id[1] << 8L) \| ((unsigned long)session_id[2] << 16L) \| ((unsigned long)session_id[3] << 24L); return l; } / * NB: If this function (or indeed the hash function which uses a sort of * coarser function than this one) is changed, ensure * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on * being able to construct an SSL_SESSION that will collide with any existing * session with a matching session ID. / static int ssl_session_cmp(const SSL_SESSION a, const SSL_SESSION b) { if (a->ssl_version != b->ssl_version) return 1; if (a->session_id_length != b->session_id_length) return 1; return memcmp(a->session_id, b->session_id, a->session_id_length); } / * These wrapper functions should remain rather than redeclaring * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each * variable. The reason is that the functions aren't static, they're exposed * via ssl.h. / SSL_CTX SSL_CTX_new_ex(OSSL_LIB_CTX libctx, const char propq, const SSL_METHOD meth) { SSL_CTX ret = NULL; #ifndef OPENSSL_NO_COMP_ALG int i; #endif if (meth == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NULL_SSL_METHOD_PASSED); return NULL; } if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL)) return NULL; /* Doing this for the run once effect / if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) { ERR_raise(ERR_LIB_SSL, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS); goto err; } ret = OPENSSL_zalloc(sizeof(ret)); if (ret == NULL) return NULL; /* Init the reference counting before any call to SSL_CTX_free / if (!CRYPTO_NEW_REF(&ret->references, 1)) { OPENSSL_free(ret); return NULL; } ret->lock = CRYPTO_THREAD_lock_new(); if (ret->lock == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } #ifdef TSAN_REQUIRES_LOCKING ret->tsan_lock = CRYPTO_THREAD_lock_new(); if (ret->tsan_lock == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } #endif ret->libctx = libctx; if (propq != NULL) { ret->propq = OPENSSL_strdup(propq); if (ret->propq == NULL) goto err; } ret->method = meth; ret->min_proto_version = 0; ret->max_proto_version = 0; ret->mode = SSL_MODE_AUTO_RETRY; ret->session_cache_mode = SSL_SESS_CACHE_SERVER; ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT; / We take the system default. / ret->session_timeout = meth->get_timeout(); ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT; ret->verify_mode = SSL_VERIFY_NONE; ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp); if (ret->sessions == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } ret->cert_store = X509_STORE_new(); if (ret->cert_store == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } #ifndef OPENSSL_NO_CT ret->ctlog_store = CTLOG_STORE_new_ex(libctx, propq); if (ret->ctlog_store == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CT_LIB); goto err; } #endif / initialize cipher/digest methods table / if (!ssl_load_ciphers(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } if (!ssl_load_groups(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } / load provider sigalgs / if (!ssl_load_sigalgs(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } / initialise sig algs / if (!ssl_setup_sigalgs(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } if (!SSL_CTX_set_ciphersuites(ret, OSSL_default_ciphersuites())) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } if ((ret->cert = ssl_cert_new(SSL_PKEY_NUM + ret->sigalg_list_len)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } if (!ssl_create_cipher_list(ret, ret->tls13_ciphersuites, &ret->cipher_list, &ret->cipher_list_by_id, OSSL_default_cipher_list(), ret->cert) \|\| sk_SSL_CIPHER_num(ret->cipher_list) <= 0) { ERR_raise(ERR_LIB_SSL, SSL_R_LIBRARY_HAS_NO_CIPHERS); goto err; } ret->param = X509_VERIFY_PARAM_new(); if (ret->param == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } / * If these aren't available from the provider we'll get NULL returns. * That's fine but will cause errors later if SSLv3 is negotiated / ret->md5 = ssl_evp_md_fetch(libctx, NID_md5, propq); ret->sha1 = ssl_evp_md_fetch(libctx, NID_sha1, propq); if ((ret->ca_names = sk_X509_NAME_new_null()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if ((ret->client_ca_names = sk_X509_NAME_new_null()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if ((ret->ext.secure = OPENSSL_secure_zalloc(sizeof(ret->ext.secure))) == NULL) goto err; /* No compression for DTLS / if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS)) ret->comp_methods = SSL_COMP_get_compression_methods(); ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH; ret->split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH; / Setup RFC5077 ticket keys / if ((RAND_bytes_ex(libctx, ret->ext.tick_key_name, sizeof(ret->ext.tick_key_name), 0) <= 0) \|\| (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_hmac_key, sizeof(ret->ext.secure->tick_hmac_key), 0) <= 0) \|\| (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_aes_key, sizeof(ret->ext.secure->tick_aes_key), 0) <= 0)) ret->options \|= SSL_OP_NO_TICKET; if (RAND_priv_bytes_ex(libctx, ret->ext.cookie_hmac_key, sizeof(ret->ext.cookie_hmac_key), 0) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_RAND_LIB); goto err; } #ifndef OPENSSL_NO_SRP if (!ssl_ctx_srp_ctx_init_intern(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } #endif #ifndef OPENSSL_NO_ENGINE # ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO # define eng_strx(x) #x # define eng_str(x) eng_strx(x) / Use specific client engine automatically... ignore errors / { ENGINE eng; eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO)); if (!eng) { ERR_clear_error(); ENGINE_load_builtin_engines(); eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO)); } if (!eng \|\| !SSL_CTX_set_client_cert_engine(ret, eng)) ERR_clear_error(); } # endif #endif #ifndef OPENSSL_NO_COMP_ALG /* * Set the default order: brotli, zlib, zstd * Including only those enabled algorithms / memset(ret->cert_comp_prefs, 0, sizeof(ret->cert_comp_prefs)); i = 0; if (ossl_comp_has_alg(TLSEXT_comp_cert_brotli)) ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_brotli; if (ossl_comp_has_alg(TLSEXT_comp_cert_zlib)) ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_zlib; if (ossl_comp_has_alg(TLSEXT_comp_cert_zstd)) ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_zstd; #endif / * Disable compression by default to prevent CRIME. Applications can * re-enable compression by configuring * SSL_CTX_clear_options(ctx, SSL_OP_NO_COMPRESSION); * or by using the SSL_CONF library. Similarly we also enable TLSv1.3 * middlebox compatibility by default. This may be disabled by default in * a later OpenSSL version. / ret->options \|= SSL_OP_NO_COMPRESSION \| SSL_OP_ENABLE_MIDDLEBOX_COMPAT; ret->ext.status_type = TLSEXT_STATUSTYPE_nothing; / * We cannot usefully set a default max_early_data here (which gets * propagated in SSL_new(), for the following reason: setting the * SSL field causes tls_construct_stoc_early_data() to tell the * client that early data will be accepted when constructing a TLS 1.3 * session ticket, and the client will accordingly send us early data * when using that ticket (if the client has early data to send). * However, in order for the early data to actually be consumed by * the application, the application must also have calls to * SSL_read_early_data(); otherwise we'll just skip past the early data * and ignore it. So, since the application must add calls to * SSL_read_early_data(), we also require them to add * calls to SSL_CTX_set_max_early_data() in order to use early data, * eliminating the bandwidth-wasting early data in the case described * above. / ret->max_early_data = 0; / * Default recv_max_early_data is a fully loaded single record. Could be * split across multiple records in practice. We set this differently to * max_early_data so that, in the default case, we do not advertise any * support for early_data, but if a client were to send us some (e.g. * because of an old, stale ticket) then we will tolerate it and skip over * it. / ret->recv_max_early_data = SSL3_RT_MAX_PLAIN_LENGTH; / By default we send two session tickets automatically in TLSv1.3 / ret->num_tickets = 2; ssl_ctx_system_config(ret); return ret; err: SSL_CTX_free(ret); return NULL; } SSL_CTX SSL_CTX_new(const SSL_METHOD meth) { return SSL_CTX_new_ex(NULL, NULL, meth); } int SSL_CTX_up_ref(SSL_CTX ctx) { int i; if (CRYPTO_UP_REF(&ctx->references, &i) <= 0) return 0; REF_PRINT_COUNT("SSL_CTX", ctx); REF_ASSERT_ISNT(i < 2); return ((i > 1) ? 1 : 0); } void SSL_CTX_free(SSL_CTX a) { int i; size_t j; if (a == NULL) return; CRYPTO_DOWN_REF(&a->references, &i); REF_PRINT_COUNT("SSL_CTX", a); if (i > 0) return; REF_ASSERT_ISNT(i < 0); X509_VERIFY_PARAM_free(a->param); dane_ctx_final(&a->dane); / * Free internal session cache. However: the remove_cb() may reference * the ex_data of SSL_CTX, thus the ex_data store can only be removed * after the sessions were flushed. * As the ex_data handling routines might also touch the session cache, * the most secure solution seems to be: empty (flush) the cache, then * free ex_data, then finally free the cache. * (See ticket [openssl.org #212].) / if (a->sessions != NULL) SSL_CTX_flush_sessions(a, 0); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data); lh_SSL_SESSION_free(a->sessions); X509_STORE_free(a->cert_store); #ifndef OPENSSL_NO_CT CTLOG_STORE_free(a->ctlog_store); #endif sk_SSL_CIPHER_free(a->cipher_list); sk_SSL_CIPHER_free(a->cipher_list_by_id); sk_SSL_CIPHER_free(a->tls13_ciphersuites); ssl_cert_free(a->cert); sk_X509_NAME_pop_free(a->ca_names, X509_NAME_free); sk_X509_NAME_pop_free(a->client_ca_names, X509_NAME_free); OSSL_STACK_OF_X509_free(a->extra_certs); a->comp_methods = NULL; #ifndef OPENSSL_NO_SRTP sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles); #endif #ifndef OPENSSL_NO_SRP ssl_ctx_srp_ctx_free_intern(a); #endif #ifndef OPENSSL_NO_ENGINE tls_engine_finish(a->client_cert_engine); #endif OPENSSL_free(a->ext.ecpointformats); OPENSSL_free(a->ext.supportedgroups); OPENSSL_free(a->ext.supported_groups_default); OPENSSL_free(a->ext.alpn); OPENSSL_secure_free(a->ext.secure); ssl_evp_md_free(a->md5); ssl_evp_md_free(a->sha1); for (j = 0; j < SSL_ENC_NUM_IDX; j++) ssl_evp_cipher_free(a->ssl_cipher_methods[j]); for (j = 0; j < SSL_MD_NUM_IDX; j++) ssl_evp_md_free(a->ssl_digest_methods[j]); for (j = 0; j < a->group_list_len; j++) { OPENSSL_free(a->group_list[j].tlsname); OPENSSL_free(a->group_list[j].realname); OPENSSL_free(a->group_list[j].algorithm); } OPENSSL_free(a->group_list); for (j = 0; j < a->sigalg_list_len; j++) { OPENSSL_free(a->sigalg_list[j].name); OPENSSL_free(a->sigalg_list[j].sigalg_name); OPENSSL_free(a->sigalg_list[j].sigalg_oid); OPENSSL_free(a->sigalg_list[j].sig_name); OPENSSL_free(a->sigalg_list[j].sig_oid); OPENSSL_free(a->sigalg_list[j].hash_name); OPENSSL_free(a->sigalg_list[j].hash_oid); OPENSSL_free(a->sigalg_list[j].keytype); OPENSSL_free(a->sigalg_list[j].keytype_oid); } OPENSSL_free(a->sigalg_list); OPENSSL_free(a->ssl_cert_info); OPENSSL_free(a->sigalg_lookup_cache); OPENSSL_free(a->tls12_sigalgs); OPENSSL_free(a->client_cert_type); OPENSSL_free(a->server_cert_type); CRYPTO_THREAD_lock_free(a->lock); CRYPTO_FREE_REF(&a->references); #ifdef TSAN_REQUIRES_LOCKING CRYPTO_THREAD_lock_free(a->tsan_lock); #endif OPENSSL_free(a->propq); OPENSSL_free(a); } void SSL_CTX_set_default_passwd_cb(SSL_CTX ctx, pem_password_cb cb) { ctx->default_passwd_callback = cb; } void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX ctx, void u) { ctx->default_passwd_callback_userdata = u; } pem_password_cb SSL_CTX_get_default_passwd_cb(SSL_CTX ctx) { return ctx->default_passwd_callback; } void SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX ctx) { return ctx->default_passwd_callback_userdata; } void SSL_set_default_passwd_cb(SSL s, pem_password_cb cb) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->default_passwd_callback = cb; } void SSL_set_default_passwd_cb_userdata(SSL s, void u) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->default_passwd_callback_userdata = u; } pem_password_cb SSL_get_default_passwd_cb(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return sc->default_passwd_callback; } void SSL_get_default_passwd_cb_userdata(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return sc->default_passwd_callback_userdata; } void SSL_CTX_set_cert_verify_callback(SSL_CTX ctx, int (cb) (X509_STORE_CTX , void ), void arg) { ctx->app_verify_callback = cb; ctx->app_verify_arg = arg; } void SSL_CTX_set_verify(SSL_CTX ctx, int mode, int (cb) (int, X509_STORE_CTX )) { ctx->verify_mode = mode; ctx->default_verify_callback = cb; } void SSL_CTX_set_verify_depth(SSL_CTX ctx, int depth) { X509_VERIFY_PARAM_set_depth(ctx->param, depth); } void SSL_CTX_set_cert_cb(SSL_CTX c, int (cb) (SSL ssl, void arg), void arg) { ssl_cert_set_cert_cb(c->cert, cb, arg); } void SSL_set_cert_cb(SSL s, int (cb) (SSL ssl, void arg), void arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; ssl_cert_set_cert_cb(sc->cert, cb, arg); } void ssl_set_masks(SSL_CONNECTION s) { CERT c = s->cert; uint32_t pvalid = s->s3.tmp.valid_flags; int rsa_enc, rsa_sign, dh_tmp, dsa_sign; unsigned long mask_k, mask_a; int have_ecc_cert, ecdsa_ok; if (c == NULL) return; dh_tmp = (c->dh_tmp != NULL \|\| c->dh_tmp_cb != NULL \|\| c->dh_tmp_auto); rsa_enc = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID; rsa_sign = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID; dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_VALID; have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID; mask_k = 0; mask_a = 0; OSSL_TRACE4(TLS_CIPHER, "dh_tmp=%d rsa_enc=%d rsa_sign=%d dsa_sign=%d\n", dh_tmp, rsa_enc, rsa_sign, dsa_sign); #ifndef OPENSSL_NO_GOST if (ssl_has_cert(s, SSL_PKEY_GOST12_512)) { mask_k \|= SSL_kGOST \| SSL_kGOST18; mask_a \|= SSL_aGOST12; } if (ssl_has_cert(s, SSL_PKEY_GOST12_256)) { mask_k \|= SSL_kGOST \| SSL_kGOST18; mask_a \|= SSL_aGOST12; } if (ssl_has_cert(s, SSL_PKEY_GOST01)) { mask_k \|= SSL_kGOST; mask_a \|= SSL_aGOST01; } #endif if (rsa_enc) mask_k \|= SSL_kRSA; if (dh_tmp) mask_k \|= SSL_kDHE; /* * If we only have an RSA-PSS certificate allow RSA authentication * if TLS 1.2 and peer supports it. / if (rsa_enc \|\| rsa_sign \|\| (ssl_has_cert(s, SSL_PKEY_RSA_PSS_SIGN) && pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_EXPLICIT_SIGN && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)) mask_a \|= SSL_aRSA; if (dsa_sign) { mask_a \|= SSL_aDSS; } mask_a \|= SSL_aNULL; / * You can do anything with an RPK key, since there's no cert to restrict it * But we need to check for private keys / if (pvalid[SSL_PKEY_RSA] & CERT_PKEY_RPK) { mask_a \|= SSL_aRSA; mask_k \|= SSL_kRSA; } if (pvalid[SSL_PKEY_ECC] & CERT_PKEY_RPK) mask_a \|= SSL_aECDSA; if (TLS1_get_version(&s->ssl) == TLS1_2_VERSION) { if (pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_RPK) mask_a \|= SSL_aRSA; if (pvalid[SSL_PKEY_ED25519] & CERT_PKEY_RPK \|\| pvalid[SSL_PKEY_ED448] & CERT_PKEY_RPK) mask_a \|= SSL_aECDSA; } / * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites * depending on the key usage extension. / if (have_ecc_cert) { uint32_t ex_kusage; ex_kusage = X509_get_key_usage(c->pkeys[SSL_PKEY_ECC].x509); ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE; if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN)) ecdsa_ok = 0; if (ecdsa_ok) mask_a \|= SSL_aECDSA; } / Allow Ed25519 for TLS 1.2 if peer supports it / if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED25519) && pvalid[SSL_PKEY_ED25519] & CERT_PKEY_EXPLICIT_SIGN && TLS1_get_version(&s->ssl) == TLS1_2_VERSION) mask_a \|= SSL_aECDSA; / Allow Ed448 for TLS 1.2 if peer supports it / if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED448) && pvalid[SSL_PKEY_ED448] & CERT_PKEY_EXPLICIT_SIGN && TLS1_get_version(&s->ssl) == TLS1_2_VERSION) mask_a \|= SSL_aECDSA; mask_k \|= SSL_kECDHE; #ifndef OPENSSL_NO_PSK mask_k \|= SSL_kPSK; mask_a \|= SSL_aPSK; if (mask_k & SSL_kRSA) mask_k \|= SSL_kRSAPSK; if (mask_k & SSL_kDHE) mask_k \|= SSL_kDHEPSK; if (mask_k & SSL_kECDHE) mask_k \|= SSL_kECDHEPSK; #endif s->s3.tmp.mask_k = mask_k; s->s3.tmp.mask_a = mask_a; } int ssl_check_srvr_ecc_cert_and_alg(X509 x, SSL_CONNECTION s) { if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aECDSA) { / key usage, if present, must allow signing / if (!(X509_get_key_usage(x) & X509v3_KU_DIGITAL_SIGNATURE)) { ERR_raise(ERR_LIB_SSL, SSL_R_ECC_CERT_NOT_FOR_SIGNING); return 0; } } return 1; / all checks are ok / } int ssl_get_server_cert_serverinfo(SSL_CONNECTION s, const unsigned char *serverinfo, size_t serverinfo_length) { CERT_PKEY cpk = s->s3.tmp.cert; serverinfo_length = 0; if (cpk == NULL \|\| cpk->serverinfo == NULL) return 0; serverinfo = cpk->serverinfo; serverinfo_length = cpk->serverinfo_length; return 1; } void ssl_update_cache(SSL_CONNECTION s, int mode) { int i; / * If the session_id_length is 0, we are not supposed to cache it, and it * would be rather hard to do anyway :-) / if (s->session->session_id_length == 0) return; / * If sid_ctx_length is 0 there is no specific application context * associated with this session, so when we try to resume it and * SSL_VERIFY_PEER is requested to verify the client identity, we have no * indication that this is actually a session for the proper application * context, and the handshake will fail, not just the resumption attempt. * Do not cache (on the server) these sessions that are not resumable * (clients can set SSL_VERIFY_PEER without needing a sid_ctx set). / if (s->server && s->session->sid_ctx_length == 0 && (s->verify_mode & SSL_VERIFY_PEER) != 0) return; i = s->session_ctx->session_cache_mode; if ((i & mode) != 0 && (!s->hit \|\| SSL_CONNECTION_IS_TLS13(s))) { / * Add the session to the internal cache. In server side TLSv1.3 we * normally don't do this because by default it's a full stateless ticket * with only a dummy session id so there is no reason to cache it, * unless: * - we are doing early_data, in which case we cache so that we can * detect replays * - the application has set a remove_session_cb so needs to know about * session timeout events * - SSL_OP_NO_TICKET is set in which case it is a stateful ticket / if ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0 && (!SSL_CONNECTION_IS_TLS13(s) \|\| !s->server \|\| (s->max_early_data > 0 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0) \|\| s->session_ctx->remove_session_cb != NULL \|\| (s->options & SSL_OP_NO_TICKET) != 0)) SSL_CTX_add_session(s->session_ctx, s->session); / * Add the session to the external cache. We do this even in server side * TLSv1.3 without early data because some applications just want to * know about the creation of a session and aren't doing a full cache. / if (s->session_ctx->new_session_cb != NULL) { SSL_SESSION_up_ref(s->session); if (!s->session_ctx->new_session_cb(SSL_CONNECTION_GET_SSL(s), s->session)) SSL_SESSION_free(s->session); } } / auto flush every 255 connections / if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) { TSAN_QUALIFIER int stat; if (mode & SSL_SESS_CACHE_CLIENT) stat = &s->session_ctx->stats.sess_connect_good; else stat = &s->session_ctx->stats.sess_accept_good; if ((ssl_tsan_load(s->session_ctx, stat) & 0xff) == 0xff) SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL)); } } const SSL_METHOD SSL_CTX_get_ssl_method(const SSL_CTX ctx) { return ctx->method; } const SSL_METHOD SSL_get_ssl_method(const SSL s) { return s->method; } int SSL_set_ssl_method(SSL s, const SSL_METHOD meth) { int ret = 1; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); / Not allowed for QUIC / if (sc == NULL \|\| (s->type != SSL_TYPE_SSL_CONNECTION && s->method != meth) \|\| (s->type == SSL_TYPE_SSL_CONNECTION && IS_QUIC_METHOD(meth))) return 0; if (s->method != meth) { const SSL_METHOD sm = s->method; int (hf) (SSL ) = sc->handshake_func; if (sm->version == meth->version) s->method = meth; else { sm->ssl_deinit(s); s->method = meth; ret = s->method->ssl_init(s); } if (hf == sm->ssl_connect) sc->handshake_func = meth->ssl_connect; else if (hf == sm->ssl_accept) sc->handshake_func = meth->ssl_accept; } return ret; } int SSL_get_error(const SSL s, int i) { return ossl_ssl_get_error(s, i, /check_err=/1); } int ossl_ssl_get_error(const SSL s, int i, int check_err) { int reason; unsigned long l; BIO bio; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (i > 0) return SSL_ERROR_NONE; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { reason = ossl_quic_get_error(s, i); if (reason != SSL_ERROR_NONE) return reason; } #endif if (sc == NULL) return SSL_ERROR_SSL; /* * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc, * where we do encode the error / if (check_err && (l = ERR_peek_error()) != 0) { if (ERR_GET_LIB(l) == ERR_LIB_SYS) return SSL_ERROR_SYSCALL; else return SSL_ERROR_SSL; } #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) #endif { if (SSL_want_read(s)) { bio = SSL_get_rbio(s); if (BIO_should_read(bio)) return SSL_ERROR_WANT_READ; else if (BIO_should_write(bio)) / * This one doesn't make too much sense ... We never try to * write to the rbio, and an application program where rbio and * wbio are separate couldn't even know what it should wait for. * However if we ever set s->rwstate incorrectly (so that we * have SSL_want_read(s) instead of SSL_want_write(s)) and rbio * and wbio are the same, this test works around that bug; so * it might be safer to keep it. / return SSL_ERROR_WANT_WRITE; else if (BIO_should_io_special(bio)) { reason = BIO_get_retry_reason(bio); if (reason == BIO_RR_CONNECT) return SSL_ERROR_WANT_CONNECT; else if (reason == BIO_RR_ACCEPT) return SSL_ERROR_WANT_ACCEPT; else return SSL_ERROR_SYSCALL; / unknown / } } if (SSL_want_write(s)) { / * Access wbio directly - in order to use the buffered bio if * present / bio = sc->wbio; if (BIO_should_write(bio)) return SSL_ERROR_WANT_WRITE; else if (BIO_should_read(bio)) / * See above (SSL_want_read(s) with BIO_should_write(bio)) / return SSL_ERROR_WANT_READ; else if (BIO_should_io_special(bio)) { reason = BIO_get_retry_reason(bio); if (reason == BIO_RR_CONNECT) return SSL_ERROR_WANT_CONNECT; else if (reason == BIO_RR_ACCEPT) return SSL_ERROR_WANT_ACCEPT; else return SSL_ERROR_SYSCALL; } } } if (SSL_want_x509_lookup(s)) return SSL_ERROR_WANT_X509_LOOKUP; if (SSL_want_retry_verify(s)) return SSL_ERROR_WANT_RETRY_VERIFY; if (SSL_want_async(s)) return SSL_ERROR_WANT_ASYNC; if (SSL_want_async_job(s)) return SSL_ERROR_WANT_ASYNC_JOB; if (SSL_want_client_hello_cb(s)) return SSL_ERROR_WANT_CLIENT_HELLO_CB; if ((sc->shutdown & SSL_RECEIVED_SHUTDOWN) && (sc->s3.warn_alert == SSL_AD_CLOSE_NOTIFY)) return SSL_ERROR_ZERO_RETURN; return SSL_ERROR_SYSCALL; } static int ssl_do_handshake_intern(void vargs) { struct ssl_async_args args = (struct ssl_async_args )vargs; SSL s = args->s; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; return sc->handshake_func(s); } int SSL_do_handshake(SSL s) { int ret = 1; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_do_handshake(s); #endif if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_CONNECTION_TYPE_NOT_SET); return -1; } ossl_statem_check_finish_init(sc, -1); s->method->ssl_renegotiate_check(s, 0); if (SSL_in_init(s) \|\| SSL_in_before(s)) { if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { struct ssl_async_args args; memset(&args, 0, sizeof(args)); args.s = s; ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern); } else { ret = sc->handshake_func(s); } } return ret; } void SSL_set_accept_state(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { ossl_quic_set_accept_state(s); return; } #endif sc->server = 1; sc->shutdown = 0; ossl_statem_clear(sc); sc->handshake_func = s->method->ssl_accept; /* Ignore return value. Its a void public API function / clear_record_layer(sc); } void SSL_set_connect_state(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { ossl_quic_set_connect_state(s); return; } #endif sc->server = 0; sc->shutdown = 0; ossl_statem_clear(sc); sc->handshake_func = s->method->ssl_connect; / Ignore return value. Its a void public API function / clear_record_layer(sc); } int ssl_undefined_function(SSL s) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } int ssl_undefined_void_function(void) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } int ssl_undefined_const_function(const SSL s) { return 0; } const SSL_METHOD ssl_bad_method(int ver) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return NULL; } const char ssl_protocol_to_string(int version) { switch (version) { case TLS1_3_VERSION: return "TLSv1.3"; case TLS1_2_VERSION: return "TLSv1.2"; case TLS1_1_VERSION: return "TLSv1.1"; case TLS1_VERSION: return "TLSv1"; case SSL3_VERSION: return "SSLv3"; case DTLS1_BAD_VER: return "DTLSv0.9"; case DTLS1_VERSION: return "DTLSv1"; case DTLS1_2_VERSION: return "DTLSv1.2"; default: return "unknown"; } } const char SSL_get_version(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC /* We only support QUICv1 - so if its QUIC its QUICv1 / if (s->type == SSL_TYPE_QUIC_CONNECTION \|\| s->type == SSL_TYPE_QUIC_XSO) return "QUICv1"; #endif if (sc == NULL) return NULL; return ssl_protocol_to_string(sc->version); } __owur int SSL_get_handshake_rtt(const SSL s, uint64_t rtt) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return -1; if (sc->ts_msg_write.t <= 0 \|\| sc->ts_msg_read.t <= 0) return 0; /* data not (yet) available / if (sc->ts_msg_read.t < sc->ts_msg_write.t) return -1; rtt = ossl_time2us(ossl_time_subtract(sc->ts_msg_read, sc->ts_msg_write)); return 1; } static int dup_ca_names(STACK_OF(X509_NAME) *dst, STACK_OF(X509_NAME) src) { STACK_OF(X509_NAME) sk; X509_NAME xn; int i; if (src == NULL) { dst = NULL; return 1; } if ((sk = sk_X509_NAME_new_null()) == NULL) return 0; for (i = 0; i < sk_X509_NAME_num(src); i++) { xn = X509_NAME_dup(sk_X509_NAME_value(src, i)); if (xn == NULL) { sk_X509_NAME_pop_free(sk, X509_NAME_free); return 0; } if (sk_X509_NAME_insert(sk, xn, i) == 0) { X509_NAME_free(xn); sk_X509_NAME_pop_free(sk, X509_NAME_free); return 0; } } dst = sk; return 1; } SSL SSL_dup(SSL s) { SSL ret; int i; / TODO(QUIC FUTURE): Add a SSL_METHOD function for duplication / SSL_CONNECTION retsc; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return NULL; / If we're not quiescent, just up_ref! / if (!SSL_in_init(s) \|\| !SSL_in_before(s)) { CRYPTO_UP_REF(&s->references, &i); return s; } / * Otherwise, copy configuration state, and session if set. / if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL) return NULL; if ((retsc = SSL_CONNECTION_FROM_SSL_ONLY(ret)) == NULL) goto err; if (sc->session != NULL) { / * Arranges to share the same session via up_ref. This "copies" * session-id, SSL_METHOD, sid_ctx, and 'cert' / if (!SSL_copy_session_id(ret, s)) goto err; } else { / * No session has been established yet, so we have to expect that * s->cert or ret->cert will be changed later -- they should not both * point to the same object, and thus we can't use * SSL_copy_session_id. / if (!SSL_set_ssl_method(ret, s->method)) goto err; if (sc->cert != NULL) { ssl_cert_free(retsc->cert); retsc->cert = ssl_cert_dup(sc->cert); if (retsc->cert == NULL) goto err; } if (!SSL_set_session_id_context(ret, sc->sid_ctx, (int)sc->sid_ctx_length)) goto err; } if (!ssl_dane_dup(retsc, sc)) goto err; retsc->version = sc->version; retsc->options = sc->options; retsc->min_proto_version = sc->min_proto_version; retsc->max_proto_version = sc->max_proto_version; retsc->mode = sc->mode; SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s)); SSL_set_read_ahead(ret, SSL_get_read_ahead(s)); retsc->msg_callback = sc->msg_callback; retsc->msg_callback_arg = sc->msg_callback_arg; SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s)); SSL_set_verify_depth(ret, SSL_get_verify_depth(s)); retsc->generate_session_id = sc->generate_session_id; SSL_set_info_callback(ret, SSL_get_info_callback(s)); / copy app data, a little dangerous perhaps / if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data)) goto err; retsc->server = sc->server; if (sc->handshake_func) { if (sc->server) SSL_set_accept_state(ret); else SSL_set_connect_state(ret); } retsc->shutdown = sc->shutdown; retsc->hit = sc->hit; retsc->default_passwd_callback = sc->default_passwd_callback; retsc->default_passwd_callback_userdata = sc->default_passwd_callback_userdata; X509_VERIFY_PARAM_inherit(retsc->param, sc->param); / dup the cipher_list and cipher_list_by_id stacks / if (sc->cipher_list != NULL) { if ((retsc->cipher_list = sk_SSL_CIPHER_dup(sc->cipher_list)) == NULL) goto err; } if (sc->cipher_list_by_id != NULL) if ((retsc->cipher_list_by_id = sk_SSL_CIPHER_dup(sc->cipher_list_by_id)) == NULL) goto err; / Dup the client_CA list / if (!dup_ca_names(&retsc->ca_names, sc->ca_names) \|\| !dup_ca_names(&retsc->client_ca_names, sc->client_ca_names)) goto err; return ret; err: SSL_free(ret); return NULL; } X509 SSL_get_certificate(const SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->cert != NULL) return sc->cert->key->x509; else return NULL; } EVP_PKEY SSL_get_privatekey(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (sc->cert != NULL) return sc->cert->key->privatekey; else return NULL; } X509 SSL_CTX_get0_certificate(const SSL_CTX ctx) { if (ctx->cert != NULL) return ctx->cert->key->x509; else return NULL; } EVP_PKEY SSL_CTX_get0_privatekey(const SSL_CTX ctx) { if (ctx->cert != NULL) return ctx->cert->key->privatekey; else return NULL; } const SSL_CIPHER SSL_get_current_cipher(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if ((sc->session != NULL) && (sc->session->cipher != NULL)) return sc->session->cipher; return NULL; } const SSL_CIPHER SSL_get_pending_cipher(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->s3.tmp.new_cipher; } const COMP_METHOD SSL_get_current_compression(const SSL s) { #ifndef OPENSSL_NO_COMP const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); if (sc == NULL) return NULL; return sc->rlayer.wrlmethod->get_compression(sc->rlayer.wrl); #else return NULL; #endif } const COMP_METHOD SSL_get_current_expansion(const SSL s) { #ifndef OPENSSL_NO_COMP const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); if (sc == NULL) return NULL; return sc->rlayer.rrlmethod->get_compression(sc->rlayer.rrl); #else return NULL; #endif } int ssl_init_wbio_buffer(SSL_CONNECTION s) { BIO bbio; if (s->bbio != NULL) { / Already buffered. / return 1; } bbio = BIO_new(BIO_f_buffer()); if (bbio == NULL \|\| BIO_set_read_buffer_size(bbio, 1) <= 0) { BIO_free(bbio); ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); return 0; } s->bbio = bbio; s->wbio = BIO_push(bbio, s->wbio); s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio); return 1; } int ssl_free_wbio_buffer(SSL_CONNECTION s) { /* callers ensure s is never null / if (s->bbio == NULL) return 1; s->wbio = BIO_pop(s->wbio); s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio); BIO_free(s->bbio); s->bbio = NULL; return 1; } void SSL_CTX_set_quiet_shutdown(SSL_CTX ctx, int mode) { ctx->quiet_shutdown = mode; } int SSL_CTX_get_quiet_shutdown(const SSL_CTX ctx) { return ctx->quiet_shutdown; } void SSL_set_quiet_shutdown(SSL s, int mode) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); / Not supported with QUIC / if (sc == NULL) return; sc->quiet_shutdown = mode; } int SSL_get_quiet_shutdown(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); / Not supported with QUIC / if (sc == NULL) return 0; return sc->quiet_shutdown; } void SSL_set_shutdown(SSL s, int mode) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); / Not supported with QUIC / if (sc == NULL) return; sc->shutdown = mode; } int SSL_get_shutdown(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); #ifndef OPENSSL_NO_QUIC / QUIC: Just indicate whether the connection was shutdown cleanly. / if (IS_QUIC(s)) return ossl_quic_get_shutdown(s); #endif if (sc == NULL) return 0; return sc->shutdown; } int SSL_version(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC / We only support QUICv1 - so if its QUIC its QUICv1 / if (s->type == SSL_TYPE_QUIC_CONNECTION \|\| s->type == SSL_TYPE_QUIC_XSO) return OSSL_QUIC1_VERSION; #endif if (sc == NULL) return 0; return sc->version; } int SSL_client_version(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC / We only support QUICv1 - so if its QUIC its QUICv1 / if (s->type == SSL_TYPE_QUIC_CONNECTION \|\| s->type == SSL_TYPE_QUIC_XSO) return OSSL_QUIC1_VERSION; #endif if (sc == NULL) return 0; return sc->client_version; } SSL_CTX SSL_get_SSL_CTX(const SSL ssl) { return ssl->ctx; } SSL_CTX SSL_set_SSL_CTX(SSL ssl, SSL_CTX ctx) { CERT new_cert; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl); /* TODO(QUIC FUTURE): Add support for QUIC / if (sc == NULL) return NULL; if (ssl->ctx == ctx) return ssl->ctx; if (ctx == NULL) ctx = sc->session_ctx; new_cert = ssl_cert_dup(ctx->cert); if (new_cert == NULL) { return NULL; } if (!custom_exts_copy_flags(&new_cert->custext, &sc->cert->custext)) { ssl_cert_free(new_cert); return NULL; } ssl_cert_free(sc->cert); sc->cert = new_cert; / * Program invariant: \|sid_ctx\| has fixed size (SSL_MAX_SID_CTX_LENGTH), * so setter APIs must prevent invalid lengths from entering the system. / if (!ossl_assert(sc->sid_ctx_length <= sizeof(sc->sid_ctx))) return NULL; / * If the session ID context matches that of the parent SSL_CTX, * inherit it from the new SSL_CTX as well. If however the context does * not match (i.e., it was set per-ssl with SSL_set_session_id_context), * leave it unchanged. / if ((ssl->ctx != NULL) && (sc->sid_ctx_length == ssl->ctx->sid_ctx_length) && (memcmp(sc->sid_ctx, ssl->ctx->sid_ctx, sc->sid_ctx_length) == 0)) { sc->sid_ctx_length = ctx->sid_ctx_length; memcpy(&sc->sid_ctx, &ctx->sid_ctx, sizeof(sc->sid_ctx)); } SSL_CTX_up_ref(ctx); SSL_CTX_free(ssl->ctx); / decrement reference count / ssl->ctx = ctx; return ssl->ctx; } int SSL_CTX_set_default_verify_paths(SSL_CTX ctx) { return X509_STORE_set_default_paths_ex(ctx->cert_store, ctx->libctx, ctx->propq); } int SSL_CTX_set_default_verify_dir(SSL_CTX ctx) { X509_LOOKUP lookup; lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_hash_dir()); if (lookup == NULL) return 0; /* We ignore errors, in case the directory doesn't exist / ERR_set_mark(); X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT); ERR_pop_to_mark(); return 1; } int SSL_CTX_set_default_verify_file(SSL_CTX ctx) { X509_LOOKUP lookup; lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_file()); if (lookup == NULL) return 0; / We ignore errors, in case the file doesn't exist / ERR_set_mark(); X509_LOOKUP_load_file_ex(lookup, NULL, X509_FILETYPE_DEFAULT, ctx->libctx, ctx->propq); ERR_pop_to_mark(); return 1; } int SSL_CTX_set_default_verify_store(SSL_CTX ctx) { X509_LOOKUP lookup; lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_store()); if (lookup == NULL) return 0; / We ignore errors, in case the directory doesn't exist / ERR_set_mark(); X509_LOOKUP_add_store_ex(lookup, NULL, ctx->libctx, ctx->propq); ERR_pop_to_mark(); return 1; } int SSL_CTX_load_verify_file(SSL_CTX ctx, const char CAfile) { return X509_STORE_load_file_ex(ctx->cert_store, CAfile, ctx->libctx, ctx->propq); } int SSL_CTX_load_verify_dir(SSL_CTX ctx, const char CApath) { return X509_STORE_load_path(ctx->cert_store, CApath); } int SSL_CTX_load_verify_store(SSL_CTX ctx, const char CAstore) { return X509_STORE_load_store_ex(ctx->cert_store, CAstore, ctx->libctx, ctx->propq); } int SSL_CTX_load_verify_locations(SSL_CTX ctx, const char CAfile, const char CApath) { if (CAfile == NULL && CApath == NULL) return 0; if (CAfile != NULL && !SSL_CTX_load_verify_file(ctx, CAfile)) return 0; if (CApath != NULL && !SSL_CTX_load_verify_dir(ctx, CApath)) return 0; return 1; } void SSL_set_info_callback(SSL ssl, void (cb) (const SSL ssl, int type, int val)) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return; sc->info_callback = cb; } /* * One compiler (Diab DCC) doesn't like argument names in returned function * pointer. / void (SSL_get_info_callback(const SSL ssl)) (const SSL /* ssl / , int / type / , int / val / ) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return NULL; return sc->info_callback; } void SSL_set_verify_result(SSL ssl, long arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return; sc->verify_result = arg; } long SSL_get_verify_result(const SSL ssl) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return 0; return sc->verify_result; } size_t SSL_get_client_random(const SSL ssl, unsigned char out, size_t outlen) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return 0; if (outlen == 0) return sizeof(sc->s3.client_random); if (outlen > sizeof(sc->s3.client_random)) outlen = sizeof(sc->s3.client_random); memcpy(out, sc->s3.client_random, outlen); return outlen; } size_t SSL_get_server_random(const SSL ssl, unsigned char out, size_t outlen) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return 0; if (outlen == 0) return sizeof(sc->s3.server_random); if (outlen > sizeof(sc->s3.server_random)) outlen = sizeof(sc->s3.server_random); memcpy(out, sc->s3.server_random, outlen); return outlen; } size_t SSL_SESSION_get_master_key(const SSL_SESSION session, unsigned char out, size_t outlen) { if (outlen == 0) return session->master_key_length; if (outlen > session->master_key_length) outlen = session->master_key_length; memcpy(out, session->master_key, outlen); return outlen; } int SSL_SESSION_set1_master_key(SSL_SESSION sess, const unsigned char in, size_t len) { if (len > sizeof(sess->master_key)) return 0; memcpy(sess->master_key, in, len); sess->master_key_length = len; return 1; } int SSL_set_ex_data(SSL s, int idx, void arg) { return CRYPTO_set_ex_data(&s->ex_data, idx, arg); } void SSL_get_ex_data(const SSL s, int idx) { return CRYPTO_get_ex_data(&s->ex_data, idx); } int SSL_CTX_set_ex_data(SSL_CTX s, int idx, void arg) { return CRYPTO_set_ex_data(&s->ex_data, idx, arg); } void SSL_CTX_get_ex_data(const SSL_CTX s, int idx) { return CRYPTO_get_ex_data(&s->ex_data, idx); } X509_STORE SSL_CTX_get_cert_store(const SSL_CTX ctx) { return ctx->cert_store; } void SSL_CTX_set_cert_store(SSL_CTX ctx, X509_STORE store) { X509_STORE_free(ctx->cert_store); ctx->cert_store = store; } void SSL_CTX_set1_cert_store(SSL_CTX ctx, X509_STORE store) { if (store != NULL) X509_STORE_up_ref(store); SSL_CTX_set_cert_store(ctx, store); } int SSL_want(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_want(s); #endif if (sc == NULL) return SSL_NOTHING; return sc->rwstate; } #ifndef OPENSSL_NO_PSK int SSL_CTX_use_psk_identity_hint(SSL_CTX ctx, const char identity_hint) { if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) { ERR_raise(ERR_LIB_SSL, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } OPENSSL_free(ctx->cert->psk_identity_hint); if (identity_hint != NULL) { ctx->cert->psk_identity_hint = OPENSSL_strdup(identity_hint); if (ctx->cert->psk_identity_hint == NULL) return 0; } else ctx->cert->psk_identity_hint = NULL; return 1; } int SSL_use_psk_identity_hint(SSL s, const char identity_hint) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) { ERR_raise(ERR_LIB_SSL, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } OPENSSL_free(sc->cert->psk_identity_hint); if (identity_hint != NULL) { sc->cert->psk_identity_hint = OPENSSL_strdup(identity_hint); if (sc->cert->psk_identity_hint == NULL) return 0; } else sc->cert->psk_identity_hint = NULL; return 1; } const char SSL_get_psk_identity_hint(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL \|\| sc->session == NULL) return NULL; return sc->session->psk_identity_hint; } const char SSL_get_psk_identity(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL \|\| sc->session == NULL) return NULL; return sc->session->psk_identity; } void SSL_set_psk_client_callback(SSL s, SSL_psk_client_cb_func cb) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->psk_client_callback = cb; } void SSL_CTX_set_psk_client_callback(SSL_CTX ctx, SSL_psk_client_cb_func cb) { ctx->psk_client_callback = cb; } void SSL_set_psk_server_callback(SSL s, SSL_psk_server_cb_func cb) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->psk_server_callback = cb; } void SSL_CTX_set_psk_server_callback(SSL_CTX ctx, SSL_psk_server_cb_func cb) { ctx->psk_server_callback = cb; } #endif void SSL_set_psk_find_session_callback(SSL s, SSL_psk_find_session_cb_func cb) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->psk_find_session_cb = cb; } void SSL_CTX_set_psk_find_session_callback(SSL_CTX ctx, SSL_psk_find_session_cb_func cb) { ctx->psk_find_session_cb = cb; } void SSL_set_psk_use_session_callback(SSL s, SSL_psk_use_session_cb_func cb) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->psk_use_session_cb = cb; } void SSL_CTX_set_psk_use_session_callback(SSL_CTX ctx, SSL_psk_use_session_cb_func cb) { ctx->psk_use_session_cb = cb; } void SSL_CTX_set_msg_callback(SSL_CTX ctx, void (cb) (int write_p, int version, int content_type, const void buf, size_t len, SSL ssl, void arg)) { SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void ()(void))cb); } void SSL_set_msg_callback(SSL ssl, void (cb) (int write_p, int version, int content_type, const void buf, size_t len, SSL ssl, void arg)) { SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void ()(void))cb); } void SSL_CTX_set_not_resumable_session_callback(SSL_CTX ctx, int (cb) (SSL ssl, int is_forward_secure)) { SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB, (void ()(void))cb); } void SSL_set_not_resumable_session_callback(SSL ssl, int (cb) (SSL ssl, int is_forward_secure)) { SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB, (void ()(void))cb); } void SSL_CTX_set_record_padding_callback(SSL_CTX ctx, size_t (cb) (SSL ssl, int type, size_t len, void arg)) { ctx->record_padding_cb = cb; } void SSL_CTX_set_record_padding_callback_arg(SSL_CTX ctx, void arg) { ctx->record_padding_arg = arg; } void SSL_CTX_get_record_padding_callback_arg(const SSL_CTX ctx) { return ctx->record_padding_arg; } int SSL_CTX_set_block_padding(SSL_CTX ctx, size_t block_size) { if (IS_QUIC_CTX(ctx) && block_size > 1) return 0; /* block size of 0 or 1 is basically no padding / if (block_size == 1) ctx->block_padding = 0; else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH) ctx->block_padding = block_size; else return 0; return 1; } int SSL_set_record_padding_callback(SSL ssl, size_t (cb) (SSL ssl, int type, size_t len, void arg)) { BIO b; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (sc == NULL) return 0; b = SSL_get_wbio(ssl); if (b == NULL \|\| !BIO_get_ktls_send(b)) { sc->rlayer.record_padding_cb = cb; return 1; } return 0; } void SSL_set_record_padding_callback_arg(SSL ssl, void arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return; sc->rlayer.record_padding_arg = arg; } void SSL_get_record_padding_callback_arg(const SSL ssl) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return NULL; return sc->rlayer.record_padding_arg; } int SSL_set_block_padding(SSL ssl, size_t block_size) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL \|\| (IS_QUIC(ssl) && block_size > 1)) return 0; / block size of 0 or 1 is basically no padding / if (block_size == 1) sc->rlayer.block_padding = 0; else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH) sc->rlayer.block_padding = block_size; else return 0; return 1; } int SSL_set_num_tickets(SSL s, size_t num_tickets) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->num_tickets = num_tickets; return 1; } size_t SSL_get_num_tickets(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->num_tickets; } int SSL_CTX_set_num_tickets(SSL_CTX ctx, size_t num_tickets) { ctx->num_tickets = num_tickets; return 1; } size_t SSL_CTX_get_num_tickets(const SSL_CTX ctx) { return ctx->num_tickets; } / Retrieve handshake hashes / int ssl_handshake_hash(SSL_CONNECTION s, unsigned char out, size_t outlen, size_t hashlen) { EVP_MD_CTX ctx = NULL; EVP_MD_CTX hdgst = s->s3.handshake_dgst; int hashleni = EVP_MD_CTX_get_size(hdgst); int ret = 0; if (hashleni < 0 \|\| (size_t)hashleni > outlen) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ctx = EVP_MD_CTX_new(); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!EVP_MD_CTX_copy_ex(ctx, hdgst) \|\| EVP_DigestFinal_ex(ctx, out, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hashlen = hashleni; ret = 1; err: EVP_MD_CTX_free(ctx); return ret; } int SSL_session_reused(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->hit; } int SSL_is_server(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->server; } #ifndef OPENSSL_NO_DEPRECATED_1_1_0 void SSL_set_debug(SSL s, int debug) { /* Old function was do-nothing anyway... / (void)s; (void)debug; } #endif void SSL_set_security_level(SSL s, int level) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->cert->sec_level = level; } int SSL_get_security_level(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->cert->sec_level; } void SSL_set_security_callback(SSL s, int (cb) (const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex)) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->cert->sec_cb = cb; } int (SSL_get_security_callback(const SSL s)) (const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->cert->sec_cb; } void SSL_set0_security_ex_data(SSL s, void ex) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->cert->sec_ex = ex; } void SSL_get0_security_ex_data(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->cert->sec_ex; } void SSL_CTX_set_security_level(SSL_CTX ctx, int level) { ctx->cert->sec_level = level; } int SSL_CTX_get_security_level(const SSL_CTX ctx) { return ctx->cert->sec_level; } void SSL_CTX_set_security_callback(SSL_CTX ctx, int (cb) (const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex)) { ctx->cert->sec_cb = cb; } int (SSL_CTX_get_security_callback(const SSL_CTX ctx)) (const SSL s, const SSL_CTX ctx, int op, int bits, int nid, void other, void ex) { return ctx->cert->sec_cb; } void SSL_CTX_set0_security_ex_data(SSL_CTX ctx, void ex) { ctx->cert->sec_ex = ex; } void SSL_CTX_get0_security_ex_data(const SSL_CTX ctx) { return ctx->cert->sec_ex; } uint64_t SSL_CTX_get_options(const SSL_CTX ctx) { return ctx->options; } uint64_t SSL_get_options(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_options(s); #endif if (sc == NULL) return 0; return sc->options; } uint64_t SSL_CTX_set_options(SSL_CTX ctx, uint64_t op) { return ctx->options \|= op; } uint64_t SSL_set_options(SSL s, uint64_t op) { SSL_CONNECTION sc; OSSL_PARAM options[2], opts = options; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_set_options(s, op); #endif sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->options \|= op; opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS, &sc->options); opts = OSSL_PARAM_construct_end(); /* Ignore return value / sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options); sc->rlayer.wrlmethod->set_options(sc->rlayer.wrl, options); return sc->options; } uint64_t SSL_CTX_clear_options(SSL_CTX ctx, uint64_t op) { return ctx->options &= ~op; } uint64_t SSL_clear_options(SSL s, uint64_t op) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); OSSL_PARAM options[2], opts = options; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_clear_options(s, op); #endif if (sc == NULL) return 0; sc->options &= ~op; opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS, &sc->options); opts = OSSL_PARAM_construct_end(); / Ignore return value / sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options); sc->rlayer.wrlmethod->set_options(sc->rlayer.wrl, options); return sc->options; } STACK_OF(X509) SSL_get0_verified_chain(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->verified_chain; } IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id); #ifndef OPENSSL_NO_CT /* * Moves SCTs from the \|src\| stack to the \|dst\| stack. * The source of each SCT will be set to \|origin\|. * If \|dst\| points to a NULL pointer, a new stack will be created and owned by * the caller. * Returns the number of SCTs moved, or a negative integer if an error occurs. * The \|dst\| stack is created and possibly partially populated even in case * of error, likewise the \|src\| stack may be left in an intermediate state. / static int ct_move_scts(STACK_OF(SCT) dst, STACK_OF(SCT) src, sct_source_t origin) { int scts_moved = 0; SCT sct = NULL; if (dst == NULL) { dst = sk_SCT_new_null(); if (dst == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } } while ((sct = sk_SCT_pop(src)) != NULL) { if (SCT_set_source(sct, origin) != 1) goto err; if (!sk_SCT_push(dst, sct)) goto err; scts_moved += 1; } return scts_moved; err: SCT_free(sct); return -1; } / * Look for data collected during ServerHello and parse if found. * Returns the number of SCTs extracted. / static int ct_extract_tls_extension_scts(SSL_CONNECTION s) { int scts_extracted = 0; if (s->ext.scts != NULL) { const unsigned char p = s->ext.scts; STACK_OF(SCT) scts = o2i_SCT_LIST(NULL, &p, s->ext.scts_len); scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_TLS_EXTENSION); SCT_LIST_free(scts); } return scts_extracted; } /* * Checks for an OCSP response and then attempts to extract any SCTs found if it * contains an SCT X509 extension. They will be stored in \|s->scts\|. * Returns: * - The number of SCTs extracted, assuming an OCSP response exists. * - 0 if no OCSP response exists or it contains no SCTs. * - A negative integer if an error occurs. / static int ct_extract_ocsp_response_scts(SSL_CONNECTION s) { # ifndef OPENSSL_NO_OCSP int scts_extracted = 0; const unsigned char p; OCSP_BASICRESP br = NULL; OCSP_RESPONSE rsp = NULL; STACK_OF(SCT) scts = NULL; int i; if (s->ext.ocsp.resp == NULL \|\| s->ext.ocsp.resp_len == 0) goto err; p = s->ext.ocsp.resp; rsp = d2i_OCSP_RESPONSE(NULL, &p, (int)s->ext.ocsp.resp_len); if (rsp == NULL) goto err; br = OCSP_response_get1_basic(rsp); if (br == NULL) goto err; for (i = 0; i < OCSP_resp_count(br); ++i) { OCSP_SINGLERESP single = OCSP_resp_get0(br, i); if (single == NULL) continue; scts = OCSP_SINGLERESP_get1_ext_d2i(single, NID_ct_cert_scts, NULL, NULL); scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_OCSP_STAPLED_RESPONSE); if (scts_extracted < 0) goto err; } err: SCT_LIST_free(scts); OCSP_BASICRESP_free(br); OCSP_RESPONSE_free(rsp); return scts_extracted; # else / Behave as if no OCSP response exists / return 0; # endif } / * Attempts to extract SCTs from the peer certificate. * Return the number of SCTs extracted, or a negative integer if an error * occurs. / static int ct_extract_x509v3_extension_scts(SSL_CONNECTION s) { int scts_extracted = 0; X509 cert = s->session != NULL ? s->session->peer : NULL; if (cert != NULL) { STACK_OF(SCT) scts = X509_get_ext_d2i(cert, NID_ct_precert_scts, NULL, NULL); scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_X509V3_EXTENSION); SCT_LIST_free(scts); } return scts_extracted; } /* * Attempts to find all received SCTs by checking TLS extensions, the OCSP * response (if it exists) and X509v3 extensions in the certificate. * Returns NULL if an error occurs. / const STACK_OF(SCT) SSL_get0_peer_scts(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (!sc->scts_parsed) { if (ct_extract_tls_extension_scts(sc) < 0 \|\| ct_extract_ocsp_response_scts(sc) < 0 \|\| ct_extract_x509v3_extension_scts(sc) < 0) goto err; sc->scts_parsed = 1; } return sc->scts; err: return NULL; } static int ct_permissive(const CT_POLICY_EVAL_CTX ctx, const STACK_OF(SCT) scts, void unused_arg) { return 1; } static int ct_strict(const CT_POLICY_EVAL_CTX ctx, const STACK_OF(SCT) scts, void unused_arg) { int count = scts != NULL ? sk_SCT_num(scts) : 0; int i; for (i = 0; i < count; ++i) { SCT sct = sk_SCT_value(scts, i); int status = SCT_get_validation_status(sct); if (status == SCT_VALIDATION_STATUS_VALID) return 1; } ERR_raise(ERR_LIB_SSL, SSL_R_NO_VALID_SCTS); return 0; } int SSL_set_ct_validation_callback(SSL s, ssl_ct_validation_cb callback, void arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* * Since code exists that uses the custom extension handler for CT, look * for this and throw an error if they have already registered to use CT. / if (callback != NULL && SSL_CTX_has_client_custom_ext(s->ctx, TLSEXT_TYPE_signed_certificate_timestamp)) { ERR_raise(ERR_LIB_SSL, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED); return 0; } if (callback != NULL) { / * If we are validating CT, then we MUST accept SCTs served via OCSP / if (!SSL_set_tlsext_status_type(s, TLSEXT_STATUSTYPE_ocsp)) return 0; } sc->ct_validation_callback = callback; sc->ct_validation_callback_arg = arg; return 1; } int SSL_CTX_set_ct_validation_callback(SSL_CTX ctx, ssl_ct_validation_cb callback, void arg) { / * Since code exists that uses the custom extension handler for CT, look for * this and throw an error if they have already registered to use CT. / if (callback != NULL && SSL_CTX_has_client_custom_ext(ctx, TLSEXT_TYPE_signed_certificate_timestamp)) { ERR_raise(ERR_LIB_SSL, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED); return 0; } ctx->ct_validation_callback = callback; ctx->ct_validation_callback_arg = arg; return 1; } int SSL_ct_is_enabled(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->ct_validation_callback != NULL; } int SSL_CTX_ct_is_enabled(const SSL_CTX ctx) { return ctx->ct_validation_callback != NULL; } int ssl_validate_ct(SSL_CONNECTION s) { int ret = 0; X509 cert = s->session != NULL ? s->session->peer : NULL; X509 issuer; SSL_DANE dane = &s->dane; CT_POLICY_EVAL_CTX ctx = NULL; const STACK_OF(SCT) scts; /* * If no callback is set, the peer is anonymous, or its chain is invalid, * skip SCT validation - just return success. Applications that continue * handshakes without certificates, with unverified chains, or pinned leaf * certificates are outside the scope of the WebPKI and CT. * * The above exclusions notwithstanding the vast majority of peers will * have rather ordinary certificate chains validated by typical * applications that perform certificate verification and therefore will * process SCTs when enabled. / if (s->ct_validation_callback == NULL \|\| cert == NULL \|\| s->verify_result != X509_V_OK \|\| s->verified_chain == NULL \|\| sk_X509_num(s->verified_chain) <= 1) return 1; / * CT not applicable for chains validated via DANE-TA(2) or DANE-EE(3) * trust-anchors. See https://tools.ietf.org/html/rfc7671#section-4.2 / if (DANETLS_ENABLED(dane) && dane->mtlsa != NULL) { switch (dane->mtlsa->usage) { case DANETLS_USAGE_DANE_TA: case DANETLS_USAGE_DANE_EE: return 1; } } ctx = CT_POLICY_EVAL_CTX_new_ex(SSL_CONNECTION_GET_CTX(s)->libctx, SSL_CONNECTION_GET_CTX(s)->propq); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CT_LIB); goto end; } issuer = sk_X509_value(s->verified_chain, 1); CT_POLICY_EVAL_CTX_set1_cert(ctx, cert); CT_POLICY_EVAL_CTX_set1_issuer(ctx, issuer); CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(ctx, SSL_CONNECTION_GET_CTX(s)->ctlog_store); CT_POLICY_EVAL_CTX_set_time( ctx, (uint64_t)SSL_SESSION_get_time(s->session) 1000); scts = SSL_get0_peer_scts(SSL_CONNECTION_GET_SSL(s)); /* * This function returns success (> 0) only when all the SCTs are valid, 0 * when some are invalid, and < 0 on various internal errors (out of * memory, etc.). Having some, or even all, invalid SCTs is not sufficient * reason to abort the handshake, that decision is up to the callback. * Therefore, we error out only in the unexpected case that the return * value is negative. * * XXX: One might well argue that the return value of this function is an * unfortunate design choice. Its job is only to determine the validation * status of each of the provided SCTs. So long as it correctly separates * the wheat from the chaff it should return success. Failure in this case * ought to correspond to an inability to carry out its duties. / if (SCT_LIST_validate(scts, ctx) < 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_SCT_VERIFICATION_FAILED); goto end; } ret = s->ct_validation_callback(ctx, scts, s->ct_validation_callback_arg); if (ret < 0) ret = 0; / This function returns 0 on failure / if (!ret) SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_CALLBACK_FAILED); end: CT_POLICY_EVAL_CTX_free(ctx); / * With SSL_VERIFY_NONE the session may be cached and re-used despite a * failure return code here. Also the application may wish the complete * the handshake, and then disconnect cleanly at a higher layer, after * checking the verification status of the completed connection. * * We therefore force a certificate verification failure which will be * visible via SSL_get_verify_result() and cached as part of any resumed * session. * * Note: the permissive callback is for information gathering only, always * returns success, and does not affect verification status. Only the * strict callback or a custom application-specified callback can trigger * connection failure or record a verification error. / if (ret <= 0) s->verify_result = X509_V_ERR_NO_VALID_SCTS; return ret; } int SSL_CTX_enable_ct(SSL_CTX ctx, int validation_mode) { switch (validation_mode) { default: ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CT_VALIDATION_TYPE); return 0; case SSL_CT_VALIDATION_PERMISSIVE: return SSL_CTX_set_ct_validation_callback(ctx, ct_permissive, NULL); case SSL_CT_VALIDATION_STRICT: return SSL_CTX_set_ct_validation_callback(ctx, ct_strict, NULL); } } int SSL_enable_ct(SSL s, int validation_mode) { switch (validation_mode) { default: ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CT_VALIDATION_TYPE); return 0; case SSL_CT_VALIDATION_PERMISSIVE: return SSL_set_ct_validation_callback(s, ct_permissive, NULL); case SSL_CT_VALIDATION_STRICT: return SSL_set_ct_validation_callback(s, ct_strict, NULL); } } int SSL_CTX_set_default_ctlog_list_file(SSL_CTX ctx) { return CTLOG_STORE_load_default_file(ctx->ctlog_store); } int SSL_CTX_set_ctlog_list_file(SSL_CTX ctx, const char path) { return CTLOG_STORE_load_file(ctx->ctlog_store, path); } void SSL_CTX_set0_ctlog_store(SSL_CTX ctx, CTLOG_STORE logs) { CTLOG_STORE_free(ctx->ctlog_store); ctx->ctlog_store = logs; } const CTLOG_STORE SSL_CTX_get0_ctlog_store(const SSL_CTX ctx) { return ctx->ctlog_store; } #endif /* OPENSSL_NO_CT / void SSL_CTX_set_client_hello_cb(SSL_CTX c, SSL_client_hello_cb_fn cb, void arg) { c->client_hello_cb = cb; c->client_hello_cb_arg = arg; } int SSL_client_hello_isv2(SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; return sc->clienthello->isv2; } unsigned int SSL_client_hello_get0_legacy_version(SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; return sc->clienthello->legacy_version; } size_t SSL_client_hello_get0_random(SSL s, const unsigned char *out) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; if (out != NULL) out = sc->clienthello->random; return SSL3_RANDOM_SIZE; } size_t SSL_client_hello_get0_session_id(SSL s, const unsigned char *out) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; if (out != NULL) out = sc->clienthello->session_id; return sc->clienthello->session_id_len; } size_t SSL_client_hello_get0_ciphers(SSL s, const unsigned char *out) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; if (out != NULL) out = PACKET_data(&sc->clienthello->ciphersuites); return PACKET_remaining(&sc->clienthello->ciphersuites); } size_t SSL_client_hello_get0_compression_methods(SSL s, const unsigned char *out) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; if (out != NULL) out = sc->clienthello->compressions; return sc->clienthello->compressions_len; } int SSL_client_hello_get1_extensions_present(SSL s, int *out, size_t outlen) { RAW_EXTENSION ext; int present; size_t num = 0, i; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL \|\| out == NULL \|\| outlen == NULL) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) { ext = sc->clienthello->pre_proc_exts + i; if (ext->present) num++; } if (num == 0) { out = NULL; outlen = 0; return 1; } if ((present = OPENSSL_malloc(sizeof(present) * num)) == NULL) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) { ext = sc->clienthello->pre_proc_exts + i; if (ext->present) { if (ext->received_order >= num) goto err; present[ext->received_order] = ext->type; } } out = present; outlen = num; return 1; err: OPENSSL_free(present); return 0; } int SSL_client_hello_get_extension_order(SSL s, uint16_t exts, size_t num_exts) { RAW_EXTENSION ext; size_t num = 0, i; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL \|\| num_exts == NULL) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) { ext = sc->clienthello->pre_proc_exts + i; if (ext->present) num++; } if (num == 0) { num_exts = 0; return 1; } if (exts == NULL) { num_exts = num; return 1; } if (num_exts < num) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) { ext = sc->clienthello->pre_proc_exts + i; if (ext->present) { if (ext->received_order >= num) return 0; exts[ext->received_order] = ext->type; } } num_exts = num; return 1; } int SSL_client_hello_get0_ext(SSL s, unsigned int type, const unsigned char *out, size_t outlen) { size_t i; RAW_EXTENSION r; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; ++i) { r = sc->clienthello->pre_proc_exts + i; if (r->present && r->type == type) { if (out != NULL) out = PACKET_data(&r->data); if (outlen != NULL) outlen = PACKET_remaining(&r->data); return 1; } } return 0; } int SSL_free_buffers(SSL ssl) { RECORD_LAYER rl; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (sc == NULL) return 0; rl = &sc->rlayer; return rl->rrlmethod->free_buffers(rl->rrl) && rl->wrlmethod->free_buffers(rl->wrl); } int SSL_alloc_buffers(SSL ssl) { RECORD_LAYER rl; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; /* QUIC always has buffers allocated. / if (IS_QUIC(ssl)) return 1; rl = &sc->rlayer; return rl->rrlmethod->alloc_buffers(rl->rrl) && rl->wrlmethod->alloc_buffers(rl->wrl); } void SSL_CTX_set_keylog_callback(SSL_CTX ctx, SSL_CTX_keylog_cb_func cb) { ctx->keylog_callback = cb; } SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX ctx) { return ctx->keylog_callback; } static int nss_keylog_int(const char prefix, SSL_CONNECTION sc, const uint8_t parameter_1, size_t parameter_1_len, const uint8_t parameter_2, size_t parameter_2_len) { char out = NULL; char cursor = NULL; size_t out_len = 0; size_t i; size_t prefix_len; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(sc); if (sctx->keylog_callback == NULL) return 1; /* * Our output buffer will contain the following strings, rendered with * space characters in between, terminated by a NULL character: first the * prefix, then the first parameter, then the second parameter. The * meaning of each parameter depends on the specific key material being * logged. Note that the first and second parameters are encoded in * hexadecimal, so we need a buffer that is twice their lengths. / prefix_len = strlen(prefix); out_len = prefix_len + (2 parameter_1_len) + (2 * parameter_2_len) + 3; if ((out = cursor = OPENSSL_malloc(out_len)) == NULL) return 0; strcpy(cursor, prefix); cursor += prefix_len; cursor++ = ' '; for (i = 0; i < parameter_1_len; i++) { sprintf(cursor, "%02x", parameter_1[i]); cursor += 2; } cursor++ = ' '; for (i = 0; i < parameter_2_len; i++) { sprintf(cursor, "%02x", parameter_2[i]); cursor += 2; } cursor = '\0'; sctx->keylog_callback(SSL_CONNECTION_GET_SSL(sc), (const char )out); OPENSSL_clear_free(out, out_len); return 1; } int ssl_log_rsa_client_key_exchange(SSL_CONNECTION sc, const uint8_t encrypted_premaster, size_t encrypted_premaster_len, const uint8_t premaster, size_t premaster_len) { if (encrypted_premaster_len < 8) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / We only want the first 8 bytes of the encrypted premaster as a tag. / return nss_keylog_int("RSA", sc, encrypted_premaster, 8, premaster, premaster_len); } int ssl_log_secret(SSL_CONNECTION sc, const char label, const uint8_t secret, size_t secret_len) { return nss_keylog_int(label, sc, sc->s3.client_random, SSL3_RANDOM_SIZE, secret, secret_len); } #define SSLV2_CIPHER_LEN 3 int ssl_cache_cipherlist(SSL_CONNECTION s, PACKET cipher_suites, int sslv2format) { int n; n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN; if (PACKET_remaining(cipher_suites) == 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CIPHERS_SPECIFIED); return 0; } if (PACKET_remaining(cipher_suites) % n != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST); return 0; } OPENSSL_free(s->s3.tmp.ciphers_raw); s->s3.tmp.ciphers_raw = NULL; s->s3.tmp.ciphers_rawlen = 0; if (sslv2format) { size_t numciphers = PACKET_remaining(cipher_suites) / n; PACKET sslv2ciphers = cipher_suites; unsigned int leadbyte; unsigned char raw; /* * We store the raw ciphers list in SSLv3+ format so we need to do some * preprocessing to convert the list first. If there are any SSLv2 only * ciphersuites with a non-zero leading byte then we are going to * slightly over allocate because we won't store those. But that isn't a * problem. / raw = OPENSSL_malloc(numciphers TLS_CIPHER_LEN); s->s3.tmp.ciphers_raw = raw; if (raw == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } for (s->s3.tmp.ciphers_rawlen = 0; PACKET_remaining(&sslv2ciphers) > 0; raw += TLS_CIPHER_LEN) { if (!PACKET_get_1(&sslv2ciphers, &leadbyte) \|\| (leadbyte == 0 && !PACKET_copy_bytes(&sslv2ciphers, raw, TLS_CIPHER_LEN)) \|\| (leadbyte != 0 && !PACKET_forward(&sslv2ciphers, TLS_CIPHER_LEN))) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_PACKET); OPENSSL_free(s->s3.tmp.ciphers_raw); s->s3.tmp.ciphers_raw = NULL; s->s3.tmp.ciphers_rawlen = 0; return 0; } if (leadbyte == 0) s->s3.tmp.ciphers_rawlen += TLS_CIPHER_LEN; } } else if (!PACKET_memdup(cipher_suites, &s->s3.tmp.ciphers_raw, &s->s3.tmp.ciphers_rawlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int SSL_bytes_to_cipher_list(SSL s, const unsigned char bytes, size_t len, int isv2format, STACK_OF(SSL_CIPHER) sk, STACK_OF(SSL_CIPHER) scsvs) { PACKET pkt; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (!PACKET_buf_init(&pkt, bytes, len)) return 0; return ossl_bytes_to_cipher_list(sc, &pkt, sk, scsvs, isv2format, 0); } int ossl_bytes_to_cipher_list(SSL_CONNECTION s, PACKET cipher_suites, STACK_OF(SSL_CIPHER) skp, STACK_OF(SSL_CIPHER) scsvs_out, int sslv2format, int fatal) { const SSL_CIPHER c; STACK_OF(SSL_CIPHER) sk = NULL; STACK_OF(SSL_CIPHER) scsvs = NULL; int n; /* 3 = SSLV2_CIPHER_LEN > TLS_CIPHER_LEN = 2. / unsigned char cipher[SSLV2_CIPHER_LEN]; n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN; if (PACKET_remaining(cipher_suites) == 0) { if (fatal) SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CIPHERS_SPECIFIED); else ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHERS_SPECIFIED); return 0; } if (PACKET_remaining(cipher_suites) % n != 0) { if (fatal) SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST); else ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST); return 0; } sk = sk_SSL_CIPHER_new_null(); scsvs = sk_SSL_CIPHER_new_null(); if (sk == NULL \|\| scsvs == NULL) { if (fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); else ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } while (PACKET_copy_bytes(cipher_suites, cipher, n)) { / * SSLv3 ciphers wrapped in an SSLv2-compatible ClientHello have the * first byte set to zero, while true SSLv2 ciphers have a non-zero * first byte. We don't support any true SSLv2 ciphers, so skip them. / if (sslv2format && cipher[0] != '\0') continue; / For SSLv2-compat, ignore leading 0-byte. / c = ssl_get_cipher_by_char(s, sslv2format ? &cipher[1] : cipher, 1); if (c != NULL) { if ((c->valid && !sk_SSL_CIPHER_push(sk, c)) \|\| (!c->valid && !sk_SSL_CIPHER_push(scsvs, c))) { if (fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); else ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } } } if (PACKET_remaining(cipher_suites) > 0) { if (fatal) SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); else ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); goto err; } if (skp != NULL) skp = sk; else sk_SSL_CIPHER_free(sk); if (scsvs_out != NULL) scsvs_out = scsvs; else sk_SSL_CIPHER_free(scsvs); return 1; err: sk_SSL_CIPHER_free(sk); sk_SSL_CIPHER_free(scsvs); return 0; } int SSL_CTX_set_max_early_data(SSL_CTX ctx, uint32_t max_early_data) { ctx->max_early_data = max_early_data; return 1; } uint32_t SSL_CTX_get_max_early_data(const SSL_CTX ctx) { return ctx->max_early_data; } int SSL_set_max_early_data(SSL s, uint32_t max_early_data) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; sc->max_early_data = max_early_data; return 1; } uint32_t SSL_get_max_early_data(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->max_early_data; } int SSL_CTX_set_recv_max_early_data(SSL_CTX ctx, uint32_t recv_max_early_data) { ctx->recv_max_early_data = recv_max_early_data; return 1; } uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX ctx) { return ctx->recv_max_early_data; } int SSL_set_recv_max_early_data(SSL s, uint32_t recv_max_early_data) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; sc->recv_max_early_data = recv_max_early_data; return 1; } uint32_t SSL_get_recv_max_early_data(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->recv_max_early_data; } __owur unsigned int ssl_get_max_send_fragment(const SSL_CONNECTION sc) { /* Return any active Max Fragment Len extension / if (sc->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(sc->session)) return GET_MAX_FRAGMENT_LENGTH(sc->session); / return current SSL connection setting / return sc->max_send_fragment; } __owur unsigned int ssl_get_split_send_fragment(const SSL_CONNECTION sc) { /* Return a value regarding an active Max Fragment Len extension / if (sc->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(sc->session) && sc->split_send_fragment > GET_MAX_FRAGMENT_LENGTH(sc->session)) return GET_MAX_FRAGMENT_LENGTH(sc->session); / else limit \|split_send_fragment\| to current \|max_send_fragment\| / if (sc->split_send_fragment > sc->max_send_fragment) return sc->max_send_fragment; / return current SSL connection setting / return sc->split_send_fragment; } int SSL_stateless(SSL s) { int ret; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; / Ensure there is no state left over from a previous invocation / if (!SSL_clear(s)) return 0; ERR_clear_error(); sc->s3.flags \|= TLS1_FLAGS_STATELESS; ret = SSL_accept(s); sc->s3.flags &= ~TLS1_FLAGS_STATELESS; if (ret > 0 && sc->ext.cookieok) return 1; if (sc->hello_retry_request == SSL_HRR_PENDING && !ossl_statem_in_error(sc)) return 0; return -1; } void SSL_CTX_set_post_handshake_auth(SSL_CTX ctx, int val) { ctx->pha_enabled = val; } void SSL_set_post_handshake_auth(SSL ssl, int val) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (sc == NULL) return; sc->pha_enabled = val; } int SSL_verify_client_post_handshake(SSL ssl) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(ssl); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(ssl)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } #endif if (sc == NULL) return 0; if (!SSL_CONNECTION_IS_TLS13(sc)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } if (!sc->server) { ERR_raise(ERR_LIB_SSL, SSL_R_NOT_SERVER); return 0; } if (!SSL_is_init_finished(ssl)) { ERR_raise(ERR_LIB_SSL, SSL_R_STILL_IN_INIT); return 0; } switch (sc->post_handshake_auth) { case SSL_PHA_NONE: ERR_raise(ERR_LIB_SSL, SSL_R_EXTENSION_NOT_RECEIVED); return 0; default: case SSL_PHA_EXT_SENT: ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; case SSL_PHA_EXT_RECEIVED: break; case SSL_PHA_REQUEST_PENDING: ERR_raise(ERR_LIB_SSL, SSL_R_REQUEST_PENDING); return 0; case SSL_PHA_REQUESTED: ERR_raise(ERR_LIB_SSL, SSL_R_REQUEST_SENT); return 0; } sc->post_handshake_auth = SSL_PHA_REQUEST_PENDING; /* checks verify_mode and algorithm_auth / if (!send_certificate_request(sc)) { sc->post_handshake_auth = SSL_PHA_EXT_RECEIVED; / restore on error / ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CONFIG); return 0; } ossl_statem_set_in_init(sc, 1); return 1; } int SSL_CTX_set_session_ticket_cb(SSL_CTX ctx, SSL_CTX_generate_session_ticket_fn gen_cb, SSL_CTX_decrypt_session_ticket_fn dec_cb, void arg) { ctx->generate_ticket_cb = gen_cb; ctx->decrypt_ticket_cb = dec_cb; ctx->ticket_cb_data = arg; return 1; } void SSL_CTX_set_allow_early_data_cb(SSL_CTX ctx, SSL_allow_early_data_cb_fn cb, void arg) { ctx->allow_early_data_cb = cb; ctx->allow_early_data_cb_data = arg; } void SSL_set_allow_early_data_cb(SSL s, SSL_allow_early_data_cb_fn cb, void arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return; sc->allow_early_data_cb = cb; sc->allow_early_data_cb_data = arg; } const EVP_CIPHER ssl_evp_cipher_fetch(OSSL_LIB_CTX libctx, int nid, const char properties) { const EVP_CIPHER ciph; ciph = tls_get_cipher_from_engine(nid); if (ciph != NULL) return ciph; /* * If there is no engine cipher then we do an explicit fetch. This may fail * and that could be ok / ERR_set_mark(); ciph = EVP_CIPHER_fetch(libctx, OBJ_nid2sn(nid), properties); ERR_pop_to_mark(); return ciph; } int ssl_evp_cipher_up_ref(const EVP_CIPHER cipher) { /* Don't up-ref an implicit EVP_CIPHER / if (EVP_CIPHER_get0_provider(cipher) == NULL) return 1; / * The cipher was explicitly fetched and therefore it is safe to cast * away the const / return EVP_CIPHER_up_ref((EVP_CIPHER )cipher); } void ssl_evp_cipher_free(const EVP_CIPHER cipher) { if (cipher == NULL) return; if (EVP_CIPHER_get0_provider(cipher) != NULL) { / * The cipher was explicitly fetched and therefore it is safe to cast * away the const / EVP_CIPHER_free((EVP_CIPHER )cipher); } } const EVP_MD ssl_evp_md_fetch(OSSL_LIB_CTX libctx, int nid, const char properties) { const EVP_MD md; md = tls_get_digest_from_engine(nid); if (md != NULL) return md; /* Otherwise we do an explicit fetch / ERR_set_mark(); md = EVP_MD_fetch(libctx, OBJ_nid2sn(nid), properties); ERR_pop_to_mark(); return md; } int ssl_evp_md_up_ref(const EVP_MD md) { /* Don't up-ref an implicit EVP_MD / if (EVP_MD_get0_provider(md) == NULL) return 1; / * The digest was explicitly fetched and therefore it is safe to cast * away the const / return EVP_MD_up_ref((EVP_MD )md); } void ssl_evp_md_free(const EVP_MD md) { if (md == NULL) return; if (EVP_MD_get0_provider(md) != NULL) { / * The digest was explicitly fetched and therefore it is safe to cast * away the const / EVP_MD_free((EVP_MD )md); } } int SSL_set0_tmp_dh_pkey(SSL s, EVP_PKEY dhpkey) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (!ssl_security(sc, SSL_SECOP_TMP_DH, EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) { ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL); return 0; } EVP_PKEY_free(sc->cert->dh_tmp); sc->cert->dh_tmp = dhpkey; return 1; } int SSL_CTX_set0_tmp_dh_pkey(SSL_CTX ctx, EVP_PKEY dhpkey) { if (!ssl_ctx_security(ctx, SSL_SECOP_TMP_DH, EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) { ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL); return 0; } EVP_PKEY_free(ctx->cert->dh_tmp); ctx->cert->dh_tmp = dhpkey; return 1; } / QUIC-specific methods which are supported on QUIC connections only. / int SSL_handle_events(SSL s) { SSL_CONNECTION sc; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_handle_events(s); #endif sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc != NULL && SSL_CONNECTION_IS_DTLS(sc)) / * DTLSv1_handle_timeout returns 0 if the timer wasn't expired yet, * which we consider a success case. Theoretically DTLSv1_handle_timeout * can also return 0 if s is NULL or not a DTLS object, but we've * already ruled out those possibilities above, so this is not possible * here. Thus the only failure cases are where DTLSv1_handle_timeout * returns -1. / return DTLSv1_handle_timeout(s) >= 0; return 1; } int SSL_get_event_timeout(SSL s, struct timeval tv, int is_infinite) { SSL_CONNECTION sc; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_event_timeout(s, tv, is_infinite); #endif sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc != NULL && SSL_CONNECTION_IS_DTLS(sc) && DTLSv1_get_timeout(s, tv)) { is_infinite = 0; return 1; } tv->tv_sec = 1000000; tv->tv_usec = 0; is_infinite = 1; return 1; } int SSL_get_rpoll_descriptor(SSL s, BIO_POLL_DESCRIPTOR desc) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_rpoll_descriptor(s, desc); #endif if (sc == NULL \|\| sc->rbio == NULL) return 0; return BIO_get_rpoll_descriptor(sc->rbio, desc); } int SSL_get_wpoll_descriptor(SSL s, BIO_POLL_DESCRIPTOR desc) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_wpoll_descriptor(s, desc); #endif if (sc == NULL \|\| sc->wbio == NULL) return 0; return BIO_get_wpoll_descriptor(sc->wbio, desc); } int SSL_net_read_desired(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_want_read(s); return ossl_quic_get_net_read_desired(s); #else return SSL_want_read(s); #endif } int SSL_net_write_desired(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_want_write(s); return ossl_quic_get_net_write_desired(s); #else return SSL_want_write(s); #endif } int SSL_set_blocking_mode(SSL s, int blocking) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_conn_set_blocking_mode(s, blocking); #else return 0; #endif } int SSL_get_blocking_mode(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_conn_get_blocking_mode(s); #else return -1; #endif } int SSL_set1_initial_peer_addr(SSL s, const BIO_ADDR peer_addr) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_conn_set_initial_peer_addr(s, peer_addr); #else return 0; #endif } int SSL_shutdown_ex(SSL ssl, uint64_t flags, const SSL_SHUTDOWN_EX_ARGS args, size_t args_len) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(ssl)) return SSL_shutdown(ssl); return ossl_quic_conn_shutdown(ssl, flags, args, args_len); #else return SSL_shutdown(ssl); #endif } int SSL_stream_conclude(SSL ssl, uint64_t flags) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(ssl)) return 0; return ossl_quic_conn_stream_conclude(ssl); #else return 0; #endif } SSL SSL_new_stream(SSL s, uint64_t flags) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return NULL; return ossl_quic_conn_stream_new(s, flags); #else return NULL; #endif } SSL SSL_get0_connection(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return s; return ossl_quic_get0_connection(s); #else return s; #endif } int SSL_is_connection(SSL s) { return SSL_get0_connection(s) == s; } int SSL_get_stream_type(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_STREAM_TYPE_BIDI; return ossl_quic_get_stream_type(s); #else return SSL_STREAM_TYPE_BIDI; #endif } uint64_t SSL_get_stream_id(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return UINT64_MAX; return ossl_quic_get_stream_id(s); #else return UINT64_MAX; #endif } int SSL_is_stream_local(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_is_stream_local(s); #else return -1; #endif } int SSL_set_default_stream_mode(SSL s, uint32_t mode) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_set_default_stream_mode(s, mode); #else return 0; #endif } int SSL_set_incoming_stream_policy(SSL s, int policy, uint64_t aec) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_set_incoming_stream_policy(s, policy, aec); #else return 0; #endif } SSL SSL_accept_stream(SSL s, uint64_t flags) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return NULL; return ossl_quic_accept_stream(s, flags); #else return NULL; #endif } size_t SSL_get_accept_stream_queue_len(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_get_accept_stream_queue_len(s); #else return 0; #endif } int SSL_stream_reset(SSL s, const SSL_STREAM_RESET_ARGS args, size_t args_len) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_stream_reset(s, args, args_len); #else return 0; #endif } int SSL_get_stream_read_state(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_STREAM_STATE_NONE; return ossl_quic_get_stream_read_state(s); #else return SSL_STREAM_STATE_NONE; #endif } int SSL_get_stream_write_state(SSL s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_STREAM_STATE_NONE; return ossl_quic_get_stream_write_state(s); #else return SSL_STREAM_STATE_NONE; #endif } int SSL_get_stream_read_error_code(SSL s, uint64_t app_error_code) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_get_stream_read_error_code(s, app_error_code); #else return -1; #endif } int SSL_get_stream_write_error_code(SSL s, uint64_t app_error_code) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_get_stream_write_error_code(s, app_error_code); #else return -1; #endif } int SSL_get_conn_close_info(SSL s, SSL_CONN_CLOSE_INFO info, size_t info_len) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_get_conn_close_info(s, info, info_len); #else return -1; #endif } int SSL_add_expected_rpk(SSL s, EVP_PKEY rpk) { unsigned char data = NULL; SSL_DANE dane = SSL_get0_dane(s); int ret; if (dane == NULL \|\| dane->dctx == NULL) return 0; if ((ret = i2d_PUBKEY(rpk, &data)) <= 0) return 0; ret = SSL_dane_tlsa_add(s, DANETLS_USAGE_DANE_EE, DANETLS_SELECTOR_SPKI, DANETLS_MATCHING_FULL, data, (size_t)ret) > 0; OPENSSL_free(data); return ret; } EVP_PKEY SSL_get0_peer_rpk(const SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL \|\| sc->session == NULL) return NULL; return sc->session->peer_rpk; } int SSL_get_negotiated_client_cert_type(const SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return sc->ext.client_cert_type; } int SSL_get_negotiated_server_cert_type(const SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return sc->ext.server_cert_type; } static int validate_cert_type(const unsigned char val, size_t len) { size_t i; int saw_rpk = 0; int saw_x509 = 0; if (val == NULL && len == 0) return 1; if (val == NULL \|\| len == 0) return 0; for (i = 0; i < len; i++) { switch (val[i]) { case TLSEXT_cert_type_rpk: if (saw_rpk) return 0; saw_rpk = 1; break; case TLSEXT_cert_type_x509: if (saw_x509) return 0; saw_x509 = 1; break; case TLSEXT_cert_type_pgp: case TLSEXT_cert_type_1609dot2: default: return 0; } } return 1; } static int set_cert_type(unsigned char cert_type, size_t cert_type_len, const unsigned char val, size_t len) { unsigned char tmp = NULL; if (!validate_cert_type(val, len)) return 0; if (val != NULL && (tmp = OPENSSL_memdup(val, len)) == NULL) return 0; OPENSSL_free(cert_type); cert_type = tmp; cert_type_len = len; return 1; } int SSL_set1_client_cert_type(SSL s, const unsigned char val, size_t len) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); return set_cert_type(&sc->client_cert_type, &sc->client_cert_type_len, val, len); } int SSL_set1_server_cert_type(SSL s, const unsigned char val, size_t len) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); return set_cert_type(&sc->server_cert_type, &sc->server_cert_type_len, val, len); } int SSL_CTX_set1_client_cert_type(SSL_CTX ctx, const unsigned char val, size_t len) { return set_cert_type(&ctx->client_cert_type, &ctx->client_cert_type_len, val, len); } int SSL_CTX_set1_server_cert_type(SSL_CTX ctx, const unsigned char val, size_t len) { return set_cert_type(&ctx->server_cert_type, &ctx->server_cert_type_len, val, len); } int SSL_get0_client_cert_type(const SSL s, unsigned char *t, size_t len) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (t == NULL \|\| len == NULL) return 0; t = sc->client_cert_type; len = sc->client_cert_type_len; return 1; } int SSL_get0_server_cert_type(const SSL s, unsigned char *t, size_t len) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (t == NULL \|\| len == NULL) return 0; t = sc->server_cert_type; len = sc->server_cert_type_len; return 1; } int SSL_CTX_get0_client_cert_type(const SSL_CTX ctx, unsigned char *t, size_t len) { if (t == NULL \|\| len == NULL) return 0; t = ctx->client_cert_type; len = ctx->client_cert_type_len; return 1; } int SSL_CTX_get0_server_cert_type(const SSL_CTX ctx, unsigned char t, size_t len) { if (t == NULL \|\| len == NULL) return 0; t = ctx->server_cert_type; len = ctx->server_cert_type_len; return 1; }
./openssl/ssl/event_queue.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdlib.h> #include "internal/event_queue.h" #include "ssl_local.h" struct ossl_event_queue_st { PRIORITY_QUEUE_OF(OSSL_EVENT) timed_events; PRIORITY_QUEUE_OF(OSSL_EVENT) now_events; }; static int event_compare_times(const OSSL_EVENT a, const OSSL_EVENT b) { return ossl_time_compare(a->when, b->when); } static int event_compare_priority(const OSSL_EVENT a, const OSSL_EVENT b) { if (a->priority > b->priority) return -1; if (a->priority < b->priority) return 1; return 0; } OSSL_EVENT_QUEUE ossl_event_queue_new(void) { OSSL_EVENT_QUEUE r = OPENSSL_malloc(sizeof(r)); if (r != NULL) { r->timed_events = ossl_pqueue_OSSL_EVENT_new(&event_compare_times); r->now_events = ossl_pqueue_OSSL_EVENT_new(&event_compare_priority); if (r->timed_events == NULL \|\| r->now_events == NULL) { ossl_event_queue_free(r); return NULL; } } return r; } void ossl_event_free(OSSL_EVENT event) { if (event != NULL) { if (event->flag_dynamic) OPENSSL_free(event); else event->queue = NULL; } } static void event_queue_free(PRIORITY_QUEUE_OF(OSSL_EVENT) queue) { OSSL_EVENT e; if (queue != NULL) { while ((e = ossl_pqueue_OSSL_EVENT_pop(queue)) != NULL) ossl_event_free(e); ossl_pqueue_OSSL_EVENT_free(queue); } } void ossl_event_queue_free(OSSL_EVENT_QUEUE queue) { if (queue != NULL) { event_queue_free(queue->now_events); event_queue_free(queue->timed_events); OPENSSL_free(queue); } } static ossl_inline int event_queue_add(OSSL_EVENT_QUEUE queue, OSSL_EVENT event) { PRIORITY_QUEUE_OF(OSSL_EVENT) pq = ossl_time_compare(event->when, ossl_time_now()) <= 0 ? queue->now_events : queue->timed_events; if (ossl_pqueue_OSSL_EVENT_push(pq, event, &event->ref)) { event->queue = pq; return 1; } return 0; } static ossl_inline void ossl_event_set(OSSL_EVENT event, uint32_t type, uint32_t priority, OSSL_TIME when, void ctx, void payload, size_t payload_size) { event->type = type; event->priority = priority; event->when = when; event->ctx = ctx; event->payload = payload; event->payload_size = payload_size; } OSSL_EVENT ossl_event_queue_add_new(OSSL_EVENT_QUEUE queue, uint32_t type, uint32_t priority, OSSL_TIME when, void ctx, void payload, size_t payload_size) { OSSL_EVENT e = OPENSSL_malloc(sizeof(e)); if (e == NULL \|\| queue == NULL) { OPENSSL_free(e); return NULL; } ossl_event_set(e, type, priority, when, ctx, payload, payload_size); e->flag_dynamic = 1; if (event_queue_add(queue, e)) return e; OPENSSL_free(e); return NULL; } int ossl_event_queue_add(OSSL_EVENT_QUEUE queue, OSSL_EVENT event, uint32_t type, uint32_t priority, OSSL_TIME when, void ctx, void payload, size_t payload_size) { if (event == NULL \|\| queue == NULL) return 0; ossl_event_set(event, type, priority, when, ctx, payload, payload_size); event->flag_dynamic = 0; return event_queue_add(queue, event); } int ossl_event_queue_remove(OSSL_EVENT_QUEUE queue, OSSL_EVENT event) { if (event != NULL && event->queue != NULL) { ossl_pqueue_OSSL_EVENT_remove(event->queue, event->ref); event->queue = NULL; } return 1; } OSSL_TIME ossl_event_time_until(const OSSL_EVENT event) { if (event == NULL) return ossl_time_infinite(); return ossl_time_subtract(event->when, ossl_time_now()); } OSSL_TIME ossl_event_queue_time_until_next(const OSSL_EVENT_QUEUE queue) { if (queue == NULL) return ossl_time_infinite(); if (ossl_pqueue_OSSL_EVENT_num(queue->now_events) > 0) return ossl_time_zero(); return ossl_event_time_until(ossl_pqueue_OSSL_EVENT_peek(queue->timed_events)); } int ossl_event_queue_postpone_until(OSSL_EVENT_QUEUE queue, OSSL_EVENT event, OSSL_TIME when) { if (ossl_event_queue_remove(queue, event)) { event->when = when; return event_queue_add(queue, event); } return 0; } int ossl_event_queue_get1_next_event(OSSL_EVENT_QUEUE queue, OSSL_EVENT event) { OSSL_TIME now = ossl_time_now(); OSSL_EVENT e; /* Check for expired timer based events and convert them to now events / while ((e = ossl_pqueue_OSSL_EVENT_peek(queue->timed_events)) != NULL && ossl_time_compare(e->when, now) <= 0) { e = ossl_pqueue_OSSL_EVENT_pop(queue->timed_events); if (!ossl_pqueue_OSSL_EVENT_push(queue->now_events, e, &e->ref)) { e->queue = NULL; return 0; } } / * Get next event from the now queue. * The pop returns NULL when there is none. / event = ossl_pqueue_OSSL_EVENT_pop(queue->now_events); return 1; }
./openssl/ssl/priority_queue.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/crypto.h> #include <openssl/err.h> #include <assert.h> #include "internal/priority_queue.h" #include "internal/safe_math.h" #include "internal/numbers.h" OSSL_SAFE_MATH_UNSIGNED(size_t, size_t) / * Fundamental operations: * Binary Heap Fibonacci Heap * Get smallest O(1) O(1) * Delete any O(log n) O(log n) average but worst O(n) * Insert O(log n) O(1) * * Not supported: * Merge two structures O(log n) O(1) * Decrease key O(log n) O(1) * Increase key O(log n) ? * * The Fibonacci heap is quite a bit more complicated to implement and has * larger overhead in practice. We favour the binary heap here. A multi-way * (ternary or quaternary) heap might elicit a performance advantage via better * cache access patterns. / struct pq_heap_st { void data; /* User supplied data pointer / size_t index; / Constant index in elements[] / }; struct pq_elem_st { size_t posn; / Current index in heap[] or link in free list / #ifndef NDEBUG int used; / Debug flag indicating that this is in use / #endif }; struct ossl_pqueue_st { struct pq_heap_st heap; struct pq_elem_st elements; int (compare)(const void , const void ); size_t htop; /* Highest used heap element / size_t hmax; / Allocated heap & element space / size_t freelist; / Index into elements[], start of free element list / }; / * The initial and maximum number of elements in the heap. / static const size_t min_nodes = 8; static const size_t max_nodes = SIZE_MAX / (sizeof(struct pq_heap_st) > sizeof(struct pq_elem_st) ? sizeof(struct pq_heap_st) : sizeof(struct pq_elem_st)); #ifndef NDEBUG / Some basic sanity checking of the data structure / # define ASSERT_USED(pq, idx) \ assert(pq->elements[pq->heap[idx].index].used); \ assert(pq->elements[pq->heap[idx].index].posn == idx) # define ASSERT_ELEM_USED(pq, elem) \ assert(pq->elements[elem].used) #else # define ASSERT_USED(pq, idx) # define ASSERT_ELEM_USED(pq, elem) #endif / * Calculate the array growth based on the target size. * * The growth factor is a rational number and is defined by a numerator * and a denominator. According to Andrew Koenig in his paper "Why Are * Vectors Efficient?" from JOOP 11(5) 1998, this factor should be less * than the golden ratio (1.618...). * * We use an expansion factor of 8 / 5 = 1.6 / static ossl_inline size_t compute_pqueue_growth(size_t target, size_t current) { int err = 0; while (current < target) { if (current >= max_nodes) return 0; current = safe_muldiv_size_t(current, 8, 5, &err); if (err) return 0; if (current >= max_nodes) current = max_nodes; } return current; } static ossl_inline void pqueue_swap_elem(OSSL_PQUEUE pq, size_t i, size_t j) { struct pq_heap_st h = pq->heap, t_h; struct pq_elem_st e = pq->elements; ASSERT_USED(pq, i); ASSERT_USED(pq, j); t_h = h[i]; h[i] = h[j]; h[j] = t_h; e[h[i].index].posn = i; e[h[j].index].posn = j; } static ossl_inline void pqueue_move_elem(OSSL_PQUEUE pq, size_t from, size_t to) { struct pq_heap_st h = pq->heap; struct pq_elem_st e = pq->elements; ASSERT_USED(pq, from); h[to] = h[from]; e[h[to].index].posn = to; } / * Force the specified element to the front of the heap. This breaks * the heap partial ordering pre-condition. / static ossl_inline void pqueue_force_bottom(OSSL_PQUEUE pq, size_t n) { ASSERT_USED(pq, n); while (n > 0) { const size_t p = (n - 1) / 2; ASSERT_USED(pq, p); pqueue_swap_elem(pq, n, p); n = p; } } /* * Move an element down to its correct position to restore the partial * order pre-condition. / static ossl_inline void pqueue_move_down(OSSL_PQUEUE pq, size_t n) { struct pq_heap_st h = pq->heap; ASSERT_USED(pq, n); while (n > 0) { const size_t p = (n - 1) / 2; ASSERT_USED(pq, p); if (pq->compare(h[n].data, h[p].data) >= 0) break; pqueue_swap_elem(pq, n, p); n = p; } } / * Move an element up to its correct position to restore the partial * order pre-condition. / static ossl_inline void pqueue_move_up(OSSL_PQUEUE pq, size_t n) { struct pq_heap_st h = pq->heap; size_t p = n 2 + 1; ASSERT_USED(pq, n); if (pq->htop > p + 1) { ASSERT_USED(pq, p); ASSERT_USED(pq, p + 1); if (pq->compare(h[p].data, h[p + 1].data) > 0) p++; } while (pq->htop > p && pq->compare(h[p].data, h[n].data) < 0) { ASSERT_USED(pq, p); pqueue_swap_elem(pq, n, p); n = p; p = n * 2 + 1; if (pq->htop > p + 1) { ASSERT_USED(pq, p + 1); if (pq->compare(h[p].data, h[p + 1].data) > 0) p++; } } } int ossl_pqueue_push(OSSL_PQUEUE pq, void data, size_t elem) { size_t n, m; if (!ossl_pqueue_reserve(pq, 1)) return 0; n = pq->htop++; m = pq->freelist; pq->freelist = pq->elements[m].posn; pq->heap[n].data = data; pq->heap[n].index = m; pq->elements[m].posn = n; #ifndef NDEBUG pq->elements[m].used = 1; #endif pqueue_move_down(pq, n); if (elem != NULL) elem = m; return 1; } void ossl_pqueue_peek(const OSSL_PQUEUE pq) { if (pq->htop > 0) { ASSERT_USED(pq, 0); return pq->heap->data; } return NULL; } void ossl_pqueue_pop(OSSL_PQUEUE pq) { void res; size_t elem; if (pq == NULL \|\| pq->htop == 0) return NULL; ASSERT_USED(pq, 0); res = pq->heap->data; elem = pq->heap->index; if (--pq->htop != 0) { pqueue_move_elem(pq, pq->htop, 0); pqueue_move_up(pq, 0); } pq->elements[elem].posn = pq->freelist; pq->freelist = elem; #ifndef NDEBUG pq->elements[elem].used = 0; #endif return res; } void ossl_pqueue_remove(OSSL_PQUEUE pq, size_t elem) { size_t n; if (pq == NULL \|\| elem >= pq->hmax \|\| pq->htop == 0) return 0; ASSERT_ELEM_USED(pq, elem); n = pq->elements[elem].posn; ASSERT_USED(pq, n); if (n == pq->htop - 1) { pq->elements[elem].posn = pq->freelist; pq->freelist = elem; #ifndef NDEBUG pq->elements[elem].used = 0; #endif return pq->heap[--pq->htop].data; } if (n > 0) pqueue_force_bottom(pq, n); return ossl_pqueue_pop(pq); } static void pqueue_add_freelist(OSSL_PQUEUE pq, size_t from) { struct pq_elem_st e = pq->elements; size_t i; #ifndef NDEBUG for (i = from; i < pq->hmax; i++) e[i].used = 0; #endif e[from].posn = pq->freelist; for (i = from + 1; i < pq->hmax; i++) e[i].posn = i - 1; pq->freelist = pq->hmax - 1; } int ossl_pqueue_reserve(OSSL_PQUEUE pq, size_t n) { size_t new_max, cur_max; struct pq_heap_st h; struct pq_elem_st e; if (pq == NULL) return 0; cur_max = pq->hmax; if (pq->htop + n < cur_max) return 1; new_max = compute_pqueue_growth(n + cur_max, cur_max); if (new_max == 0) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } h = OPENSSL_realloc(pq->heap, new_max * sizeof(pq->heap)); if (h == NULL) return 0; pq->heap = h; e = OPENSSL_realloc(pq->elements, new_max sizeof(pq->elements)); if (e == NULL) return 0; pq->elements = e; pq->hmax = new_max; pqueue_add_freelist(pq, cur_max); return 1; } OSSL_PQUEUE ossl_pqueue_new(int (compare)(const void , const void )) { OSSL_PQUEUE pq; if (compare == NULL) return NULL; pq = OPENSSL_malloc(sizeof(pq)); if (pq == NULL) return NULL; pq->compare = compare; pq->hmax = min_nodes; pq->htop = 0; pq->freelist = 0; pq->heap = OPENSSL_malloc(sizeof(pq->heap) * min_nodes); pq->elements = OPENSSL_malloc(sizeof(pq->elements) min_nodes); if (pq->heap == NULL \|\| pq->elements == NULL) { ossl_pqueue_free(pq); return NULL; } pqueue_add_freelist(pq, 0); return pq; } void ossl_pqueue_free(OSSL_PQUEUE pq) { if (pq != NULL) { OPENSSL_free(pq->heap); OPENSSL_free(pq->elements); OPENSSL_free(pq); } } void ossl_pqueue_pop_free(OSSL_PQUEUE pq, void (freefunc)(void )) { size_t i; if (pq != NULL) { for (i = 0; i < pq->htop; i++) (freefunc)(pq->heap[i].data); ossl_pqueue_free(pq); } } size_t ossl_pqueue_num(const OSSL_PQUEUE pq) { return pq != NULL ? pq->htop : 0; }
./openssl/ssl/pqueue.c	/* * Copyright 2005-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "ssl_local.h" #include <openssl/bn.h> struct pqueue_st { pitem items; int count; }; pitem pitem_new(unsigned char prio64be, void data) { pitem item = OPENSSL_malloc(sizeof(item)); if (item == NULL) return NULL; memcpy(item->priority, prio64be, sizeof(item->priority)); item->data = data; item->next = NULL; return item; } void pitem_free(pitem item) { OPENSSL_free(item); } pqueue pqueue_new(void) { pqueue pq = OPENSSL_zalloc(sizeof(pq)); return pq; } void pqueue_free(pqueue pq) { OPENSSL_free(pq); } pitem pqueue_insert(pqueue pq, pitem item) { pitem curr, next; if (pq->items == NULL) { pq->items = item; return item; } for (curr = NULL, next = pq->items; next != NULL; curr = next, next = next->next) { / * we can compare 64-bit value in big-endian encoding with memcmp:-) / int cmp = memcmp(next->priority, item->priority, 8); if (cmp > 0) { / next > item / item->next = next; if (curr == NULL) pq->items = item; else curr->next = item; return item; } else if (cmp == 0) / duplicates not allowed / return NULL; } item->next = NULL; curr->next = item; return item; } pitem pqueue_peek(pqueue pq) { return pq->items; } pitem pqueue_pop(pqueue pq) { pitem item = pq->items; if (pq->items != NULL) pq->items = pq->items->next; return item; } pitem pqueue_find(pqueue pq, unsigned char prio64be) { pitem next; pitem found = NULL; if (pq->items == NULL) return NULL; for (next = pq->items; next->next != NULL; next = next->next) { if (memcmp(next->priority, prio64be, 8) == 0) { found = next; break; } } / check the one last node / if (memcmp(next->priority, prio64be, 8) == 0) found = next; if (!found) return NULL; return found; } pitem pqueue_iterator(pqueue pq) { return pqueue_peek(pq); } pitem pqueue_next(piterator item) { pitem ret; if (item == NULL \|\| item == NULL) return NULL; / item != NULL / ret = item; item = (item)->next; return ret; } size_t pqueue_size(pqueue pq) { pitem *item = pq->items; size_t count = 0; while (item != NULL) { count++; item = item->next; } return count; }
./openssl/ssl/ssl_mcnf.c	/* * Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <openssl/conf.h> #include <openssl/ssl.h> #include "ssl_local.h" #include "internal/sslconf.h" / SSL library configuration module. / void SSL_add_ssl_module(void) { / Do nothing. This will be added automatically by libcrypto / } static int ssl_do_config(SSL s, SSL_CTX ctx, const char name, int system) { SSL_CONF_CTX cctx = NULL; size_t i, idx, cmd_count; int err = 1; unsigned int flags; const SSL_METHOD meth; const SSL_CONF_CMD cmds; OSSL_LIB_CTX prev_libctx = NULL; OSSL_LIB_CTX libctx = NULL; if (s == NULL && ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); goto err; } if (name == NULL && system) name = "system_default"; if (!conf_ssl_name_find(name, &idx)) { if (!system) ERR_raise_data(ERR_LIB_SSL, SSL_R_INVALID_CONFIGURATION_NAME, "name=%s", name); goto err; } cmds = conf_ssl_get(idx, &name, &cmd_count); cctx = SSL_CONF_CTX_new(); if (cctx == NULL) goto err; flags = SSL_CONF_FLAG_FILE; if (!system) flags \|= SSL_CONF_FLAG_CERTIFICATE \| SSL_CONF_FLAG_REQUIRE_PRIVATE; if (s != NULL) { meth = s->method; SSL_CONF_CTX_set_ssl(cctx, s); libctx = s->ctx->libctx; } else { meth = ctx->method; SSL_CONF_CTX_set_ssl_ctx(cctx, ctx); libctx = ctx->libctx; } if (meth->ssl_accept != ssl_undefined_function) flags \|= SSL_CONF_FLAG_SERVER; if (meth->ssl_connect != ssl_undefined_function) flags \|= SSL_CONF_FLAG_CLIENT; SSL_CONF_CTX_set_flags(cctx, flags); prev_libctx = OSSL_LIB_CTX_set0_default(libctx); err = 0; for (i = 0; i < cmd_count; i++) { char cmdstr, arg; int rv; conf_ssl_get_cmd(cmds, i, &cmdstr, &arg); rv = SSL_CONF_cmd(cctx, cmdstr, arg); if (rv <= 0) ++err; } if (!SSL_CONF_CTX_finish(cctx)) ++err; err: OSSL_LIB_CTX_set0_default(prev_libctx); SSL_CONF_CTX_free(cctx); return err == 0; } int SSL_config(SSL s, const char name) { return ssl_do_config(s, NULL, name, 0); } int SSL_CTX_config(SSL_CTX ctx, const char name) { return ssl_do_config(NULL, ctx, name, 0); } void ssl_ctx_system_config(SSL_CTX ctx) { ssl_do_config(NULL, ctx, NULL, 1); }
./openssl/ssl/d1_msg.c	/* * Copyright 2005-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "ssl_local.h" int dtls1_write_app_data_bytes(SSL s, uint8_t type, const void buf_, size_t len, size_t written) { int i; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return -1; if (SSL_in_init(s) && !ossl_statem_get_in_handshake(sc)) { i = sc->handshake_func(s); if (i < 0) return i; if (i == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_HANDSHAKE_FAILURE); return -1; } } if (len > SSL3_RT_MAX_PLAIN_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_DTLS_MESSAGE_TOO_BIG); return -1; } return dtls1_write_bytes(sc, type, buf_, len, written); } int dtls1_dispatch_alert(SSL ssl) { int i, j; void (cb) (const SSL ssl, int type, int val) = NULL; unsigned char buf[DTLS1_AL_HEADER_LENGTH]; unsigned char ptr = &buf[0]; size_t written; SSL_CONNECTION s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return 0; s->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; memset(buf, 0, sizeof(buf)); ptr++ = s->s3.send_alert[0]; ptr++ = s->s3.send_alert[1]; i = do_dtls1_write(s, SSL3_RT_ALERT, &buf[0], sizeof(buf), &written); if (i <= 0) { s->s3.alert_dispatch = 1; /* fprintf(stderr, "not done with alert\n"); */ } else { (void)BIO_flush(s->wbio); if (s->msg_callback) s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3.send_alert, 2, ssl, s->msg_callback_arg); if (s->info_callback != NULL) cb = s->info_callback; else if (ssl->ctx->info_callback != NULL) cb = ssl->ctx->info_callback; if (cb != NULL) { j = (s->s3.send_alert[0] << 8) \| s->s3.send_alert[1]; cb(ssl, SSL_CB_WRITE_ALERT, j); } } return i; }
./openssl/ssl/ssl_err.c	/* * Generated by util/mkerr.pl DO NOT EDIT * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/err.h> #include <openssl/sslerr.h> #include "sslerr.h" #ifndef OPENSSL_NO_ERR static const ERR_STRING_DATA SSL_str_reasons[] = { {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY), "application data after close notify"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_APP_DATA_IN_HANDSHAKE), "app data in handshake"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT), "attempt to reuse session in different context"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE), "at least (D)TLS 1.2 needed in Suite B mode"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CERTIFICATE), "bad certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CHANGE_CIPHER_SPEC), "bad change cipher spec"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CIPHER), "bad cipher"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_COMPRESSION_ALGORITHM), "bad compression algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DATA), "bad data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DATA_RETURNED_BY_CALLBACK), "bad data returned by callback"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DECOMPRESSION), "bad decompression"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DH_VALUE), "bad dh value"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DIGEST_LENGTH), "bad digest length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_EARLY_DATA), "bad early data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_ECC_CERT), "bad ecc cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_ECPOINT), "bad ecpoint"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_EXTENSION), "bad extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HANDSHAKE_LENGTH), "bad handshake length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HANDSHAKE_STATE), "bad handshake state"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HELLO_REQUEST), "bad hello request"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HRR_VERSION), "bad hrr version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_KEY_SHARE), "bad key share"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_KEY_UPDATE), "bad key update"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_LEGACY_VERSION), "bad legacy version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_LENGTH), "bad length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PACKET), "bad packet"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PACKET_LENGTH), "bad packet length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PROTOCOL_VERSION_NUMBER), "bad protocol version number"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PSK), "bad psk"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PSK_IDENTITY), "bad psk identity"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_RECORD_TYPE), "bad record type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_RSA_ENCRYPT), "bad rsa encrypt"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SIGNATURE), "bad signature"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRP_A_LENGTH), "bad srp a length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRP_PARAMETERS), "bad srp parameters"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRTP_MKI_VALUE), "bad srtp mki value"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST), "bad srtp protection profile list"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SSL_FILETYPE), "bad ssl filetype"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_VALUE), "bad value"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_WRITE_RETRY), "bad write retry"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BINDER_DOES_NOT_VERIFY), "binder does not verify"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BIO_NOT_SET), "bio not set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG), "block cipher pad is wrong"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BN_LIB), "bn lib"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CALLBACK_FAILED), "callback failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CANNOT_CHANGE_CIPHER), "cannot change cipher"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CANNOT_GET_GROUP_NAME), "cannot get group name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_DN_LENGTH_MISMATCH), "ca dn length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_KEY_TOO_SMALL), "ca key too small"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_MD_TOO_WEAK), "ca md too weak"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CCS_RECEIVED_EARLY), "ccs received early"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERTIFICATE_VERIFY_FAILED), "certificate verify failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERT_CB_ERROR), "cert cb error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERT_LENGTH_MISMATCH), "cert length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED), "ciphersuite digest has changed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CIPHER_CODE_WRONG_LENGTH), "cipher code wrong length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CLIENTHELLO_TLSEXT), "clienthello tlsext"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSED_LENGTH_TOO_LONG), "compressed length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_DISABLED), "compression disabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_FAILURE), "compression failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE), "compression id not within private range"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_LIBRARY_ERROR), "compression library error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONNECTION_TYPE_NOT_SET), "connection type not set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONN_USE_ONLY), "conn use only"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONTEXT_NOT_DANE_ENABLED), "context not dane enabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COOKIE_GEN_CALLBACK_FAILURE), "cookie gen callback failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COOKIE_MISMATCH), "cookie mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COPY_PARAMETERS_FAILED), "copy parameters failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED), "custom ext handler already installed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_ALREADY_ENABLED), "dane already enabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL), "dane cannot override mtype full"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_NOT_ENABLED), "dane not enabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_CERTIFICATE), "dane tlsa bad certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE), "dane tlsa bad certificate usage"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_DATA_LENGTH), "dane tlsa bad data length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH), "dane tlsa bad digest length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE), "dane tlsa bad matching type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY), "dane tlsa bad public key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_SELECTOR), "dane tlsa bad selector"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_NULL_DATA), "dane tlsa null data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED), "data between ccs and finished"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DATA_LENGTH_TOO_LONG), "data length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DECRYPTION_FAILED), "decryption failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC), "decryption failed or bad record mac"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DH_KEY_TOO_SMALL), "dh key too small"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG), "dh public value length is wrong"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DIGEST_CHECK_FAILED), "digest check failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DTLS_MESSAGE_TOO_BIG), "dtls message too big"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DUPLICATE_COMPRESSION_ID), "duplicate compression id"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ECC_CERT_NOT_FOR_SIGNING), "ecc cert not for signing"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE), "ecdh required for suiteb mode"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EE_KEY_TOO_SMALL), "ee key too small"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EMPTY_RAW_PUBLIC_KEY), "empty raw public key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST), "empty srtp protection profile list"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ENCRYPTED_LENGTH_TOO_LONG), "encrypted length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST), "error in received cipher list"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN), "error setting tlsa base domain"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE), "exceeds max fragment size"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXCESSIVE_MESSAGE_SIZE), "excessive message size"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXTENSION_NOT_RECEIVED), "extension not received"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXTRA_DATA_IN_MESSAGE), "extra data in message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXT_LENGTH_MISMATCH), "ext length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FAILED_TO_GET_PARAMETER), "failed to get parameter"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FAILED_TO_INIT_ASYNC), "failed to init async"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FRAGMENTED_CLIENT_HELLO), "fragmented client hello"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_GOT_A_FIN_BEFORE_A_CCS), "got a fin before a ccs"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_HTTPS_PROXY_REQUEST), "https proxy request"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_HTTP_REQUEST), "http request"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ILLEGAL_POINT_COMPRESSION), "illegal point compression"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ILLEGAL_SUITEB_DIGEST), "illegal Suite B digest"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INAPPROPRIATE_FALLBACK), "inappropriate fallback"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_COMPRESSION), "inconsistent compression"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EARLY_DATA_ALPN), "inconsistent early data alpn"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EARLY_DATA_SNI), "inconsistent early data sni"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EXTMS), "inconsistent extms"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INSUFFICIENT_SECURITY), "insufficient security"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_ALERT), "invalid alert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CCS_MESSAGE), "invalid ccs message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CERTIFICATE_OR_ALG), "invalid certificate or alg"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_COMMAND), "invalid command"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_COMPRESSION_ALGORITHM), "invalid compression algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONFIG), "invalid config"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONFIGURATION_NAME), "invalid configuration name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONTEXT), "invalid context"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CT_VALIDATION_TYPE), "invalid ct validation type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_KEY_UPDATE_TYPE), "invalid key update type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_MAX_EARLY_DATA), "invalid max early data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_NULL_CMD_NAME), "invalid null cmd name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_RAW_PUBLIC_KEY), "invalid raw public key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_RECORD), "invalid record"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SEQUENCE_NUMBER), "invalid sequence number"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SERVERINFO_DATA), "invalid serverinfo data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SESSION_ID), "invalid session id"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SRP_USERNAME), "invalid srp username"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_STATUS_RESPONSE), "invalid status response"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_TICKET_KEYS_LENGTH), "invalid ticket keys length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED), "legacy sigalg disallowed or unsupported"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_MISMATCH), "length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_TOO_LONG), "length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_TOO_SHORT), "length too short"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LIBRARY_BUG), "library bug"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LIBRARY_HAS_NO_CIPHERS), "library has no ciphers"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MAXIMUM_ENCRYPTED_PKTS_REACHED), "maximum encrypted pkts reached"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_DSA_SIGNING_CERT), "missing dsa signing cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_ECDSA_SIGNING_CERT), "missing ecdsa signing cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_FATAL), "missing fatal"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_PARAMETERS), "missing parameters"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_PSK_KEX_MODES_EXTENSION), "missing psk kex modes extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_CERTIFICATE), "missing rsa certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_ENCRYPTING_CERT), "missing rsa encrypting cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_SIGNING_CERT), "missing rsa signing cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SIGALGS_EXTENSION), "missing sigalgs extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SIGNING_CERT), "missing signing cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SRP_PARAM), "can't find SRP server param"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION), "missing supported groups extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_TMP_DH_KEY), "missing tmp dh key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_TMP_ECDH_KEY), "missing tmp ecdh key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA), "mixed handshake and non handshake data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_ON_RECORD_BOUNDARY), "not on record boundary"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_REPLACING_CERTIFICATE), "not replacing certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_SERVER), "not server"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_APPLICATION_PROTOCOL), "no application protocol"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATES_RETURNED), "no certificates returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATE_ASSIGNED), "no certificate assigned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATE_SET), "no certificate set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CHANGE_FOLLOWING_HRR), "no change following hrr"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHERS_AVAILABLE), "no ciphers available"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHERS_SPECIFIED), "no ciphers specified"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHER_MATCH), "no cipher match"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CLIENT_CERT_METHOD), "no client cert method"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_COMPRESSION_SPECIFIED), "no compression specified"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_COOKIE_CALLBACK_SET), "no cookie callback set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER), "Peer haven't sent GOST certificate, required for selected ciphersuite"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_METHOD_SPECIFIED), "no method specified"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PEM_EXTENSIONS), "no pem extensions"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PRIVATE_KEY_ASSIGNED), "no private key assigned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PROTOCOLS_AVAILABLE), "no protocols available"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_RENEGOTIATION), "no renegotiation"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_REQUIRED_DIGEST), "no required digest"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_CIPHER), "no shared cipher"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_GROUPS), "no shared groups"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS), "no shared signature algorithms"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SRTP_PROFILES), "no srtp profiles"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_STREAM), "no stream"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM), "no suitable digest algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_GROUPS), "no suitable groups"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_KEY_SHARE), "no suitable key share"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_RECORD_LAYER), "no suitable record layer"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM), "no suitable signature algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_VALID_SCTS), "no valid scts"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_VERIFY_COOKIE_CALLBACK), "no verify cookie callback"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NULL_SSL_CTX), "null ssl ctx"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NULL_SSL_METHOD_PASSED), "null ssl method passed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OCSP_CALLBACK_FAILURE), "ocsp callback failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED), "old session cipher not returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED), "old session compression algorithm not returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OVERFLOW_ERROR), "overflow error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PACKET_LENGTH_TOO_LONG), "packet length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PARSE_TLSEXT), "parse tlsext"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PATH_TOO_LONG), "path too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE), "peer did not return a certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEM_NAME_BAD_PREFIX), "pem name bad prefix"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEM_NAME_TOO_SHORT), "pem name too short"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PIPELINE_FAILURE), "pipeline failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR), "post handshake auth encoding err"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PRIVATE_KEY_MISMATCH), "private key mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PROTOCOL_IS_SHUTDOWN), "protocol is shutdown"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_IDENTITY_NOT_FOUND), "psk identity not found"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_NO_CLIENT_CB), "psk no client cb"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_NO_SERVER_CB), "psk no server cb"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_HANDSHAKE_LAYER_ERROR), "quic handshake layer error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_NETWORK_ERROR), "quic network error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_PROTOCOL_ERROR), "quic protocol error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_READ_BIO_NOT_SET), "read bio not set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_READ_TIMEOUT_EXPIRED), "read timeout expired"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORDS_NOT_RELEASED), "records not released"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_LAYER_FAILURE), "record layer failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_LENGTH_MISMATCH), "record length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_TOO_SMALL), "record too small"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REMOTE_PEER_ADDRESS_NOT_SET), "remote peer address not set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATE_EXT_TOO_LONG), "renegotiate ext too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATION_ENCODING_ERR), "renegotiation encoding err"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATION_MISMATCH), "renegotiation mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUEST_PENDING), "request pending"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUEST_SENT), "request sent"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUIRED_CIPHER_MISSING), "required cipher missing"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING), "required compression algorithm missing"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING), "scsv received when renegotiating"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SCT_VERIFICATION_FAILED), "sct verification failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SEQUENCE_CTR_WRAPPED), "sequence ctr wrapped"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SERVERHELLO_TLSEXT), "serverhello tlsext"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED), "session id context uninitialized"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHUTDOWN_WHILE_IN_INIT), "shutdown while in init"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SIGNATURE_ALGORITHMS_ERROR), "signature algorithms error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE), "signature for non signing certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRP_A_CALC), "error with the srp params"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES), "srtp could not allocate profiles"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG), "srtp protection profile list too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE), "srtp unknown protection profile"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH), "ssl3 ext invalid max fragment length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL3_EXT_INVALID_SERVERNAME), "ssl3 ext invalid servername"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE), "ssl3 ext invalid servername type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL3_SESSION_ID_TOO_LONG), "ssl3 session id too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_BAD_CERTIFICATE), "ssl/tls alert bad certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_BAD_RECORD_MAC), "ssl/tls alert bad record mac"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED), "ssl/tls alert certificate expired"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED), "ssl/tls alert certificate revoked"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN), "ssl/tls alert certificate unknown"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE), "ssl/tls alert decompression failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE), "ssl/tls alert handshake failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER), "ssl/tls alert illegal parameter"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_NO_CERTIFICATE), "ssl/tls alert no certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE), "ssl/tls alert unexpected message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE), "ssl/tls alert unsupported certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_COMMAND_SECTION_EMPTY), "ssl command section empty"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_COMMAND_SECTION_NOT_FOUND), "ssl command section not found"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION), "ssl ctx has no default ssl version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_HANDSHAKE_FAILURE), "ssl handshake failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS), "ssl library has no ciphers"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_NEGATIVE_LENGTH), "ssl negative length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SECTION_EMPTY), "ssl section empty"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SECTION_NOT_FOUND), "ssl section not found"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CALLBACK_FAILED), "ssl session id callback failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CONFLICT), "ssl session id conflict"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG), "ssl session id context too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH), "ssl session id has bad length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_TOO_LONG), "ssl session id too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_VERSION_MISMATCH), "ssl session version mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STILL_IN_INIT), "still in init"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_COUNT_LIMITED), "stream count limited"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_FINISHED), "stream finished"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_RECV_ONLY), "stream recv only"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_RESET), "stream reset"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_SEND_ONLY), "stream send only"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED), "tlsv13 alert certificate required"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV13_ALERT_MISSING_EXTENSION), "tlsv13 alert missing extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_ACCESS_DENIED), "tlsv1 alert access denied"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECODE_ERROR), "tlsv1 alert decode error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECRYPTION_FAILED), "tlsv1 alert decryption failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECRYPT_ERROR), "tlsv1 alert decrypt error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION), "tlsv1 alert export restriction"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK), "tlsv1 alert inappropriate fallback"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY), "tlsv1 alert insufficient security"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INTERNAL_ERROR), "tlsv1 alert internal error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_NO_RENEGOTIATION), "tlsv1 alert no renegotiation"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_PROTOCOL_VERSION), "tlsv1 alert protocol version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_RECORD_OVERFLOW), "tlsv1 alert record overflow"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_UNKNOWN_CA), "tlsv1 alert unknown ca"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_USER_CANCELLED), "tlsv1 alert user cancelled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE), "tlsv1 bad certificate hash value"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE), "tlsv1 bad certificate status response"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE), "tlsv1 certificate unobtainable"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_UNRECOGNIZED_NAME), "tlsv1 unrecognized name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_UNSUPPORTED_EXTENSION), "tlsv1 unsupported extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL), "tls illegal exporter label"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST), "tls invalid ecpointformat list"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MANY_KEY_UPDATES), "too many key updates"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MANY_WARN_ALERTS), "too many warn alerts"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MUCH_EARLY_DATA), "too much early data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS), "unable to find ecdh parameters"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS), "unable to find public key parameters"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES), "unable to load ssl3 md5 routines"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES), "unable to load ssl3 sha1 routines"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_CCS_MESSAGE), "unexpected ccs message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_END_OF_EARLY_DATA), "unexpected end of early data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_EOF_WHILE_READING), "unexpected eof while reading"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_MESSAGE), "unexpected message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_RECORD), "unexpected record"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNINITIALIZED), "uninitialized"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_ALERT_TYPE), "unknown alert type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CERTIFICATE_TYPE), "unknown certificate type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CIPHER_RETURNED), "unknown cipher returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CIPHER_TYPE), "unknown cipher type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CMD_NAME), "unknown cmd name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_COMMAND), "unknown command"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_DIGEST), "unknown digest"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE), "unknown key exchange type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_MANDATORY_PARAMETER), "unknown mandatory parameter"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_PKEY_TYPE), "unknown pkey type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_PROTOCOL), "unknown protocol"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_SSL_VERSION), "unknown ssl version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_STATE), "unknown state"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED), "unsafe legacy renegotiation disabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSOLICITED_EXTENSION), "unsolicited extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM), "unsupported compression algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_ELLIPTIC_CURVE), "unsupported elliptic curve"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_PROTOCOL), "unsupported protocol"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_SSL_VERSION), "unsupported ssl version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_STATUS_TYPE), "unsupported status type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_USE_SRTP_NOT_NEGOTIATED), "use srtp not negotiated"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_VERSION_TOO_HIGH), "version too high"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_VERSION_TOO_LOW), "version too low"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CERTIFICATE_TYPE), "wrong certificate type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CIPHER_RETURNED), "wrong cipher returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CURVE), "wrong curve"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_RPK_TYPE), "wrong rpk type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_LENGTH), "wrong signature length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_SIZE), "wrong signature size"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_TYPE), "wrong signature type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SSL_VERSION), "wrong ssl version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_VERSION_NUMBER), "wrong version number"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_X509_LIB), "x509 lib"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS), "x509 verification setup problems"}, {0, NULL} }; #endif int ossl_err_load_SSL_strings(void) { #ifndef OPENSSL_NO_ERR if (ERR_reason_error_string(SSL_str_reasons[0].error) == NULL) ERR_load_strings_const(SSL_str_reasons); #endif return 1; }
./openssl/ssl/s3_lib.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <openssl/objects.h> #include "internal/nelem.h" #include "ssl_local.h" #include <openssl/md5.h> #include <openssl/dh.h> #include <openssl/rand.h> #include <openssl/trace.h> #include <openssl/x509v3.h> #include <openssl/core_names.h> #include "internal/cryptlib.h" #define TLS13_NUM_CIPHERS OSSL_NELEM(tls13_ciphers) #define SSL3_NUM_CIPHERS OSSL_NELEM(ssl3_ciphers) #define SSL3_NUM_SCSVS OSSL_NELEM(ssl3_scsvs) / TLSv1.3 downgrade protection sentinel values / const unsigned char tls11downgrade[] = { 0x44, 0x4f, 0x57, 0x4e, 0x47, 0x52, 0x44, 0x00 }; const unsigned char tls12downgrade[] = { 0x44, 0x4f, 0x57, 0x4e, 0x47, 0x52, 0x44, 0x01 }; / The list of available TLSv1.3 ciphers / static SSL_CIPHER tls13_ciphers[] = { { 1, TLS1_3_RFC_AES_128_GCM_SHA256, TLS1_3_RFC_AES_128_GCM_SHA256, TLS1_3_CK_AES_128_GCM_SHA256, SSL_kANY, SSL_aANY, SSL_AES128GCM, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| SSL_QUIC, 128, 128, }, { 1, TLS1_3_RFC_AES_256_GCM_SHA384, TLS1_3_RFC_AES_256_GCM_SHA384, TLS1_3_CK_AES_256_GCM_SHA384, SSL_kANY, SSL_aANY, SSL_AES256GCM, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| SSL_QUIC, 256, 256, }, { 1, TLS1_3_RFC_CHACHA20_POLY1305_SHA256, TLS1_3_RFC_CHACHA20_POLY1305_SHA256, TLS1_3_CK_CHACHA20_POLY1305_SHA256, SSL_kANY, SSL_aANY, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| SSL_QUIC, 256, 256, }, { 1, TLS1_3_RFC_AES_128_CCM_SHA256, TLS1_3_RFC_AES_128_CCM_SHA256, TLS1_3_CK_AES_128_CCM_SHA256, SSL_kANY, SSL_aANY, SSL_AES128CCM, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256, 128, 128, }, { 1, TLS1_3_RFC_AES_128_CCM_8_SHA256, TLS1_3_RFC_AES_128_CCM_8_SHA256, TLS1_3_CK_AES_128_CCM_8_SHA256, SSL_kANY, SSL_aANY, SSL_AES128CCM8, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 128, } }; / * The list of available ciphers, mostly organized into the following * groups: * Always there * EC * PSK * SRP (within that: RSA EC PSK) * Cipher families: Chacha/poly, Camellia, Gost, IDEA, SEED * Weak ciphers / static SSL_CIPHER ssl3_ciphers[] = { { 1, SSL3_TXT_RSA_NULL_MD5, SSL3_RFC_RSA_NULL_MD5, SSL3_CK_RSA_NULL_MD5, SSL_kRSA, SSL_aRSA, SSL_eNULL, SSL_MD5, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, SSL3_TXT_RSA_NULL_SHA, SSL3_RFC_RSA_NULL_SHA, SSL3_CK_RSA_NULL_SHA, SSL_kRSA, SSL_aRSA, SSL_eNULL, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, #ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, SSL3_TXT_RSA_DES_192_CBC3_SHA, SSL3_RFC_RSA_DES_192_CBC3_SHA, SSL3_CK_RSA_DES_192_CBC3_SHA, SSL_kRSA, SSL_aRSA, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, { 1, SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA, SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA, SSL3_CK_DHE_DSS_DES_192_CBC3_SHA, SSL_kDHE, SSL_aDSS, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, { 1, SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA, SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA, SSL3_CK_DHE_RSA_DES_192_CBC3_SHA, SSL_kDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, { 1, SSL3_TXT_ADH_DES_192_CBC_SHA, SSL3_RFC_ADH_DES_192_CBC_SHA, SSL3_CK_ADH_DES_192_CBC_SHA, SSL_kDHE, SSL_aNULL, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, #endif { 1, TLS1_TXT_RSA_WITH_AES_128_SHA, TLS1_RFC_RSA_WITH_AES_128_SHA, TLS1_CK_RSA_WITH_AES_128_SHA, SSL_kRSA, SSL_aRSA, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_128_SHA, TLS1_RFC_DHE_DSS_WITH_AES_128_SHA, TLS1_CK_DHE_DSS_WITH_AES_128_SHA, SSL_kDHE, SSL_aDSS, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_SHA, TLS1_RFC_DHE_RSA_WITH_AES_128_SHA, TLS1_CK_DHE_RSA_WITH_AES_128_SHA, SSL_kDHE, SSL_aRSA, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_AES_128_SHA, TLS1_RFC_ADH_WITH_AES_128_SHA, TLS1_CK_ADH_WITH_AES_128_SHA, SSL_kDHE, SSL_aNULL, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_SHA, TLS1_RFC_RSA_WITH_AES_256_SHA, TLS1_CK_RSA_WITH_AES_256_SHA, SSL_kRSA, SSL_aRSA, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_256_SHA, TLS1_RFC_DHE_DSS_WITH_AES_256_SHA, TLS1_CK_DHE_DSS_WITH_AES_256_SHA, SSL_kDHE, SSL_aDSS, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_SHA, TLS1_RFC_DHE_RSA_WITH_AES_256_SHA, TLS1_CK_DHE_RSA_WITH_AES_256_SHA, SSL_kDHE, SSL_aRSA, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_AES_256_SHA, TLS1_RFC_ADH_WITH_AES_256_SHA, TLS1_CK_ADH_WITH_AES_256_SHA, SSL_kDHE, SSL_aNULL, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_NULL_SHA256, TLS1_RFC_RSA_WITH_NULL_SHA256, TLS1_CK_RSA_WITH_NULL_SHA256, SSL_kRSA, SSL_aRSA, SSL_eNULL, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_RSA_WITH_AES_128_SHA256, TLS1_RFC_RSA_WITH_AES_128_SHA256, TLS1_CK_RSA_WITH_AES_128_SHA256, SSL_kRSA, SSL_aRSA, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_SHA256, TLS1_RFC_RSA_WITH_AES_256_SHA256, TLS1_CK_RSA_WITH_AES_256_SHA256, SSL_kRSA, SSL_aRSA, SSL_AES256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256, TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256, TLS1_CK_DHE_DSS_WITH_AES_128_SHA256, SSL_kDHE, SSL_aDSS, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256, TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256, TLS1_CK_DHE_RSA_WITH_AES_128_SHA256, SSL_kDHE, SSL_aRSA, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256, TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256, TLS1_CK_DHE_DSS_WITH_AES_256_SHA256, SSL_kDHE, SSL_aDSS, SSL_AES256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256, TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256, TLS1_CK_DHE_RSA_WITH_AES_256_SHA256, SSL_kDHE, SSL_aRSA, SSL_AES256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_AES_128_SHA256, TLS1_RFC_ADH_WITH_AES_128_SHA256, TLS1_CK_ADH_WITH_AES_128_SHA256, SSL_kDHE, SSL_aNULL, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_AES_256_SHA256, TLS1_RFC_ADH_WITH_AES_256_SHA256, TLS1_CK_ADH_WITH_AES_256_SHA256, SSL_kDHE, SSL_aNULL, SSL_AES256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256, TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256, TLS1_CK_RSA_WITH_AES_128_GCM_SHA256, SSL_kRSA, SSL_aRSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384, TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384, TLS1_CK_RSA_WITH_AES_256_GCM_SHA384, SSL_kRSA, SSL_aRSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256, TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256, TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256, SSL_kDHE, SSL_aRSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384, TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384, TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384, SSL_kDHE, SSL_aRSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256, TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256, TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256, SSL_kDHE, SSL_aDSS, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384, TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384, TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384, SSL_kDHE, SSL_aDSS, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256, TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256, TLS1_CK_ADH_WITH_AES_128_GCM_SHA256, SSL_kDHE, SSL_aNULL, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384, TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384, TLS1_CK_ADH_WITH_AES_256_GCM_SHA384, SSL_kDHE, SSL_aNULL, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_AES_128_CCM, TLS1_RFC_RSA_WITH_AES_128_CCM, TLS1_CK_RSA_WITH_AES_128_CCM, SSL_kRSA, SSL_aRSA, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_CCM, TLS1_RFC_RSA_WITH_AES_256_CCM, TLS1_CK_RSA_WITH_AES_256_CCM, SSL_kRSA, SSL_aRSA, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_CCM, TLS1_RFC_DHE_RSA_WITH_AES_128_CCM, TLS1_CK_DHE_RSA_WITH_AES_128_CCM, SSL_kDHE, SSL_aRSA, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_CCM, TLS1_RFC_DHE_RSA_WITH_AES_256_CCM, TLS1_CK_DHE_RSA_WITH_AES_256_CCM, SSL_kDHE, SSL_aRSA, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_AES_128_CCM_8, TLS1_RFC_RSA_WITH_AES_128_CCM_8, TLS1_CK_RSA_WITH_AES_128_CCM_8, SSL_kRSA, SSL_aRSA, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_CCM_8, TLS1_RFC_RSA_WITH_AES_256_CCM_8, TLS1_CK_RSA_WITH_AES_256_CCM_8, SSL_kRSA, SSL_aRSA, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8, TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8, TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8, SSL_kDHE, SSL_aRSA, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8, TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8, TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8, SSL_kDHE, SSL_aRSA, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 256, }, { 1, TLS1_TXT_PSK_WITH_AES_128_CCM, TLS1_RFC_PSK_WITH_AES_128_CCM, TLS1_CK_PSK_WITH_AES_128_CCM, SSL_kPSK, SSL_aPSK, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_CCM, TLS1_RFC_PSK_WITH_AES_256_CCM, TLS1_CK_PSK_WITH_AES_256_CCM, SSL_kPSK, SSL_aPSK, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_CCM, TLS1_RFC_DHE_PSK_WITH_AES_128_CCM, TLS1_CK_DHE_PSK_WITH_AES_128_CCM, SSL_kDHEPSK, SSL_aPSK, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_CCM, TLS1_RFC_DHE_PSK_WITH_AES_256_CCM, TLS1_CK_DHE_PSK_WITH_AES_256_CCM, SSL_kDHEPSK, SSL_aPSK, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_AES_128_CCM_8, TLS1_RFC_PSK_WITH_AES_128_CCM_8, TLS1_CK_PSK_WITH_AES_128_CCM_8, SSL_kPSK, SSL_aPSK, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_CCM_8, TLS1_RFC_PSK_WITH_AES_256_CCM_8, TLS1_CK_PSK_WITH_AES_256_CCM_8, SSL_kPSK, SSL_aPSK, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8, TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8, TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8, SSL_kDHEPSK, SSL_aPSK, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8, TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8, TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8, SSL_kDHEPSK, SSL_aPSK, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM, SSL_kECDHE, SSL_aECDSA, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM, SSL_kECDHE, SSL_aECDSA, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8, SSL_kECDHE, SSL_aECDSA, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8, SSL_kECDHE, SSL_aECDSA, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 64, / CCM8 uses a short tag, so we have a low security strength / 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA, TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA, SSL_kECDHE, SSL_aECDSA, SSL_eNULL, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA, TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA, SSL_kECDHE, SSL_aECDSA, SSL_3DES, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, SSL_kECDHE, SSL_aECDSA, SSL_AES128, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, SSL_kECDHE, SSL_aECDSA, SSL_AES256, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA, TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA, TLS1_CK_ECDHE_RSA_WITH_NULL_SHA, SSL_kECDHE, SSL_aRSA, SSL_eNULL, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA, TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA, TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA, SSL_kECDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA, TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA, TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA, SSL_kECDHE, SSL_aRSA, SSL_AES128, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA, TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA, TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA, SSL_kECDHE, SSL_aRSA, SSL_AES256, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ECDH_anon_WITH_NULL_SHA, TLS1_RFC_ECDH_anon_WITH_NULL_SHA, TLS1_CK_ECDH_anon_WITH_NULL_SHA, SSL_kECDHE, SSL_aNULL, SSL_eNULL, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA, TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA, TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA, SSL_kECDHE, SSL_aNULL, SSL_3DES, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA, TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA, TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA, SSL_kECDHE, SSL_aNULL, SSL_AES128, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA, TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA, TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA, SSL_kECDHE, SSL_aNULL, SSL_AES256, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256, SSL_kECDHE, SSL_aECDSA, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384, SSL_kECDHE, SSL_aECDSA, SSL_AES256, SSL_SHA384, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256, TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256, TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256, SSL_kECDHE, SSL_aRSA, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384, TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384, TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384, SSL_kECDHE, SSL_aRSA, SSL_AES256, SSL_SHA384, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, SSL_kECDHE, SSL_aECDSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, SSL_kECDHE, SSL_aECDSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256, TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256, TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, SSL_kECDHE, SSL_aRSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384, TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384, TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384, SSL_kECDHE, SSL_aRSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_NULL_SHA, TLS1_RFC_PSK_WITH_NULL_SHA, TLS1_CK_PSK_WITH_NULL_SHA, SSL_kPSK, SSL_aPSK, SSL_eNULL, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_DHE_PSK_WITH_NULL_SHA, TLS1_RFC_DHE_PSK_WITH_NULL_SHA, TLS1_CK_DHE_PSK_WITH_NULL_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_RSA_PSK_WITH_NULL_SHA, TLS1_RFC_RSA_PSK_WITH_NULL_SHA, TLS1_CK_RSA_PSK_WITH_NULL_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_eNULL, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA, SSL_kPSK, SSL_aPSK, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_PSK_WITH_AES_128_CBC_SHA, TLS1_RFC_PSK_WITH_AES_128_CBC_SHA, TLS1_CK_PSK_WITH_AES_128_CBC_SHA, SSL_kPSK, SSL_aPSK, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_CBC_SHA, TLS1_RFC_PSK_WITH_AES_256_CBC_SHA, TLS1_CK_PSK_WITH_AES_256_CBC_SHA, SSL_kPSK, SSL_aPSK, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA, TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA, TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA, TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA, TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA, TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA, TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA, TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA, TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256, TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256, TLS1_CK_PSK_WITH_AES_128_GCM_SHA256, SSL_kPSK, SSL_aPSK, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384, TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384, TLS1_CK_PSK_WITH_AES_256_GCM_SHA384, SSL_kPSK, SSL_aPSK, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256, TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256, TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384, TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384, TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256, TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256, TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384, TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384, TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256, TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256, TLS1_CK_PSK_WITH_AES_128_CBC_SHA256, SSL_kPSK, SSL_aPSK, SSL_AES128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384, TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384, TLS1_CK_PSK_WITH_AES_256_CBC_SHA384, SSL_kPSK, SSL_aPSK, SSL_AES256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_NULL_SHA256, TLS1_RFC_PSK_WITH_NULL_SHA256, TLS1_CK_PSK_WITH_NULL_SHA256, SSL_kPSK, SSL_aPSK, SSL_eNULL, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_PSK_WITH_NULL_SHA384, TLS1_RFC_PSK_WITH_NULL_SHA384, TLS1_CK_PSK_WITH_NULL_SHA384, SSL_kPSK, SSL_aPSK, SSL_eNULL, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 0, 0, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256, TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256, TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_AES128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384, TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384, TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_AES256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_NULL_SHA256, TLS1_RFC_DHE_PSK_WITH_NULL_SHA256, TLS1_CK_DHE_PSK_WITH_NULL_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_DHE_PSK_WITH_NULL_SHA384, TLS1_RFC_DHE_PSK_WITH_NULL_SHA384, TLS1_CK_DHE_PSK_WITH_NULL_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 0, 0, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256, TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256, TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_AES128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384, TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384, TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_AES256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_NULL_SHA256, TLS1_RFC_RSA_PSK_WITH_NULL_SHA256, TLS1_CK_RSA_PSK_WITH_NULL_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_eNULL, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_RSA_PSK_WITH_NULL_SHA384, TLS1_RFC_RSA_PSK_WITH_NULL_SHA384, TLS1_CK_RSA_PSK_WITH_NULL_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_eNULL, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_3DES, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA, TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA, TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_AES128, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA, TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA, TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_AES256, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256, TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256, TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256, SSL_kECDHEPSK, SSL_aPSK, SSL_AES128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384, TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384, TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384, SSL_kECDHEPSK, SSL_aPSK, SSL_AES256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA, TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA, TLS1_CK_ECDHE_PSK_WITH_NULL_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256, TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256, TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256, SSL_kECDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384, TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384, TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384, SSL_kECDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE \| SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA, TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA, SSL_kSRP, SSL_aSRP, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, { 1, TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA, TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA, SSL_kSRP, SSL_aRSA, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, { 1, TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA, TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA, SSL_kSRP, SSL_aDSS, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA, TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA, TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA, SSL_kSRP, SSL_aSRP, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA, TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA, TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA, SSL_kSRP, SSL_aRSA, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA, TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA, TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA, SSL_kSRP, SSL_aDSS, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA, TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA, TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA, SSL_kSRP, SSL_aSRP, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA, TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA, TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA, SSL_kSRP, SSL_aRSA, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA, TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA, TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA, SSL_kSRP, SSL_aDSS, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305, TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305, TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305, SSL_kDHE, SSL_aRSA, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305, TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305, TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305, SSL_kECDHE, SSL_aRSA, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, SSL_kECDHE, SSL_aECDSA, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_CHACHA20_POLY1305, TLS1_RFC_PSK_WITH_CHACHA20_POLY1305, TLS1_CK_PSK_WITH_CHACHA20_POLY1305, SSL_kPSK, SSL_aPSK, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305, TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305, TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305, SSL_kECDHEPSK, SSL_aPSK, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305, TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305, TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305, SSL_kDHEPSK, SSL_aPSK, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305, TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305, TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305, SSL_kRSAPSK, SSL_aRSA, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256, SSL_kRSA, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256, SSL_kDHE, SSL_aDSS, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, SSL_kDHE, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256, SSL_kDHE, SSL_aNULL, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256, TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256, TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256, SSL_kRSA, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256, TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256, TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256, SSL_kDHE, SSL_aDSS, SSL_CAMELLIA256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, SSL_kDHE, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256, TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256, TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256, SSL_kDHE, SSL_aNULL, SSL_CAMELLIA256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA, TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA, TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA, SSL_kRSA, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, SSL_kDHE, SSL_aDSS, SSL_CAMELLIA256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, SSL_kDHE, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA, TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA, TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA, SSL_kDHE, SSL_aNULL, SSL_CAMELLIA256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA, TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA, TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA, SSL_kRSA, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, SSL_kDHE, SSL_aDSS, SSL_CAMELLIA128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, SSL_kDHE, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA, TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA, TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA, SSL_kDHE, SSL_aNULL, SSL_CAMELLIA128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, SSL_kECDHE, SSL_aECDSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, SSL_kECDHE, SSL_aECDSA, SSL_CAMELLIA256, SSL_SHA384, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, SSL_kECDHE, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, SSL_kECDHE, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA384, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256, SSL_kPSK, SSL_aPSK, SSL_CAMELLIA128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384, SSL_kPSK, SSL_aPSK, SSL_CAMELLIA256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_CAMELLIA128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_CAMELLIA256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, SSL_kECDHEPSK, SSL_aPSK, SSL_CAMELLIA128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, SSL_kECDHEPSK, SSL_aPSK, SSL_CAMELLIA256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, #ifndef OPENSSL_NO_GOST { 1, "GOST2001-GOST89-GOST89", "TLS_GOSTR341001_WITH_28147_CNT_IMIT", 0x3000081, SSL_kGOST, SSL_aGOST01, SSL_eGOST2814789CNT, SSL_GOST89MAC, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST94 \| TLS1_PRF_GOST94 \| TLS1_STREAM_MAC, 256, 256, }, { 1, "GOST2001-NULL-GOST94", "TLS_GOSTR341001_WITH_NULL_GOSTR3411", 0x3000083, SSL_kGOST, SSL_aGOST01, SSL_eNULL, SSL_GOST94, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_STRONG_NONE, SSL_HANDSHAKE_MAC_GOST94 \| TLS1_PRF_GOST94, 0, 0, }, { 1, "IANA-GOST2012-GOST8912-GOST8912", NULL, 0x0300c102, SSL_kGOST, SSL_aGOST12 \| SSL_aGOST01, SSL_eGOST2814789CNT12, SSL_GOST89MAC12, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST12_256 \| TLS1_PRF_GOST12_256 \| TLS1_STREAM_MAC, 256, 256, }, { 1, "LEGACY-GOST2012-GOST8912-GOST8912", NULL, 0x0300ff85, SSL_kGOST, SSL_aGOST12 \| SSL_aGOST01, SSL_eGOST2814789CNT12, SSL_GOST89MAC12, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST12_256 \| TLS1_PRF_GOST12_256 \| TLS1_STREAM_MAC, 256, 256, }, { 1, "GOST2012-NULL-GOST12", NULL, 0x0300ff87, SSL_kGOST, SSL_aGOST12 \| SSL_aGOST01, SSL_eNULL, SSL_GOST12_256, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_STRONG_NONE, SSL_HANDSHAKE_MAC_GOST12_256 \| TLS1_PRF_GOST12_256 \| TLS1_STREAM_MAC, 0, 0, }, { 1, "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC", NULL, 0x0300C100, SSL_kGOST18, SSL_aGOST12, SSL_KUZNYECHIK, SSL_KUZNYECHIKOMAC, TLS1_2_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST12_256 \| TLS1_PRF_GOST12_256 \| TLS1_TLSTREE, 256, 256, }, { 1, "GOST2012-MAGMA-MAGMAOMAC", NULL, 0x0300C101, SSL_kGOST18, SSL_aGOST12, SSL_MAGMA, SSL_MAGMAOMAC, TLS1_2_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST12_256 \| TLS1_PRF_GOST12_256 \| TLS1_TLSTREE, 256, 256, }, #endif / OPENSSL_NO_GOST / { 1, SSL3_TXT_RSA_IDEA_128_SHA, SSL3_RFC_RSA_IDEA_128_SHA, SSL3_CK_RSA_IDEA_128_SHA, SSL_kRSA, SSL_aRSA, SSL_IDEA, SSL_SHA1, SSL3_VERSION, TLS1_1_VERSION, DTLS1_BAD_VER, DTLS1_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_SEED_SHA, TLS1_RFC_RSA_WITH_SEED_SHA, TLS1_CK_RSA_WITH_SEED_SHA, SSL_kRSA, SSL_aRSA, SSL_SEED, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_SEED_SHA, TLS1_RFC_DHE_DSS_WITH_SEED_SHA, TLS1_CK_DHE_DSS_WITH_SEED_SHA, SSL_kDHE, SSL_aDSS, SSL_SEED, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_SEED_SHA, TLS1_RFC_DHE_RSA_WITH_SEED_SHA, TLS1_CK_DHE_RSA_WITH_SEED_SHA, SSL_kDHE, SSL_aRSA, SSL_SEED, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_SEED_SHA, TLS1_RFC_ADH_WITH_SEED_SHA, TLS1_CK_ADH_WITH_SEED_SHA, SSL_kDHE, SSL_aNULL, SSL_SEED, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 128, 128, }, #ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, SSL3_TXT_RSA_RC4_128_MD5, SSL3_RFC_RSA_RC4_128_MD5, SSL3_CK_RSA_RC4_128_MD5, SSL_kRSA, SSL_aRSA, SSL_RC4, SSL_MD5, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, SSL3_TXT_RSA_RC4_128_SHA, SSL3_RFC_RSA_RC4_128_SHA, SSL3_CK_RSA_RC4_128_SHA, SSL_kRSA, SSL_aRSA, SSL_RC4, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, SSL3_TXT_ADH_RC4_128_MD5, SSL3_RFC_ADH_RC4_128_MD5, SSL3_CK_ADH_RC4_128_MD5, SSL_kDHE, SSL_aNULL, SSL_RC4, SSL_MD5, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA, TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA, TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_RC4, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA, TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA, TLS1_CK_ECDH_anon_WITH_RC4_128_SHA, SSL_kECDHE, SSL_aNULL, SSL_RC4, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA, TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA, SSL_kECDHE, SSL_aECDSA, SSL_RC4, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA, TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA, TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA, SSL_kECDHE, SSL_aRSA, SSL_RC4, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_PSK_WITH_RC4_128_SHA, TLS1_RFC_PSK_WITH_RC4_128_SHA, TLS1_CK_PSK_WITH_RC4_128_SHA, SSL_kPSK, SSL_aPSK, SSL_RC4, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA, TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA, TLS1_CK_RSA_PSK_WITH_RC4_128_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_RC4, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA, TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA, TLS1_CK_DHE_PSK_WITH_RC4_128_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_RC4, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT \| SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF, 80, 128, }, #endif / OPENSSL_NO_WEAK_SSL_CIPHERS / { 1, TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256, SSL_kRSA, SSL_aRSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384, SSL_kRSA, SSL_aRSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256, SSL_kDHE, SSL_aRSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384, SSL_kDHE, SSL_aRSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256, TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256, SSL_kDHE, SSL_aDSS, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384, TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384, SSL_kDHE, SSL_aDSS, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256, TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256, SSL_kECDHE, SSL_aECDSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384, TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384, SSL_kECDHE, SSL_aECDSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256, SSL_kECDHE, SSL_aRSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384, SSL_kECDHE, SSL_aRSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256, SSL_kPSK, SSL_aPSK, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384, SSL_kPSK, SSL_aPSK, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT \| SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384, 256, 256, }, }; / * The list of known Signalling Cipher-Suite Value "ciphers", non-valid * values stuffed into the ciphers field of the wire protocol for signalling * purposes. / static SSL_CIPHER ssl3_scsvs[] = { { 0, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV", "TLS_EMPTY_RENEGOTIATION_INFO_SCSV", SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, { 0, "TLS_FALLBACK_SCSV", "TLS_FALLBACK_SCSV", SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, }; static int cipher_compare(const void a, const void b) { const SSL_CIPHER ap = (const SSL_CIPHER )a; const SSL_CIPHER bp = (const SSL_CIPHER )b; if (ap->id == bp->id) return 0; return ap->id < bp->id ? -1 : 1; } void ssl_sort_cipher_list(void) { qsort(tls13_ciphers, TLS13_NUM_CIPHERS, sizeof(tls13_ciphers[0]), cipher_compare); qsort(ssl3_ciphers, SSL3_NUM_CIPHERS, sizeof(ssl3_ciphers[0]), cipher_compare); qsort(ssl3_scsvs, SSL3_NUM_SCSVS, sizeof(ssl3_scsvs[0]), cipher_compare); } static int sslcon_undefined_function_1(SSL_CONNECTION sc, unsigned char r, size_t s, const char t, size_t u, const unsigned char v, size_t w, int x) { (void)r; (void)s; (void)t; (void)u; (void)v; (void)w; (void)x; return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } const SSL3_ENC_METHOD SSLv3_enc_data = { ssl3_setup_key_block, ssl3_generate_master_secret, ssl3_change_cipher_state, ssl3_final_finish_mac, SSL3_MD_CLIENT_FINISHED_CONST, 4, SSL3_MD_SERVER_FINISHED_CONST, 4, ssl3_alert_code, sslcon_undefined_function_1, 0, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; OSSL_TIME ssl3_default_timeout(void) { / * 2 hours, the 24 hours mentioned in the SSLv3 spec is way too long for * http, the cache would over fill / return ossl_seconds2time(60 60 * 2); } int ssl3_num_ciphers(void) { return SSL3_NUM_CIPHERS; } const SSL_CIPHER ssl3_get_cipher(unsigned int u) { if (u < SSL3_NUM_CIPHERS) return &(ssl3_ciphers[SSL3_NUM_CIPHERS - 1 - u]); else return NULL; } int ssl3_set_handshake_header(SSL_CONNECTION s, WPACKET pkt, int htype) { / No header in the event of a CCS / if (htype == SSL3_MT_CHANGE_CIPHER_SPEC) return 1; / Set the content type and 3 bytes for the message len / if (!WPACKET_put_bytes_u8(pkt, htype) \|\| !WPACKET_start_sub_packet_u24(pkt)) return 0; return 1; } int ssl3_handshake_write(SSL_CONNECTION s) { return ssl3_do_write(s, SSL3_RT_HANDSHAKE); } int ssl3_new(SSL s) { #ifndef OPENSSL_NO_SRP SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (!ssl_srp_ctx_init_intern(sc)) return 0; #endif if (!s->method->ssl_clear(s)) return 0; return 1; } void ssl3_free(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; ssl3_cleanup_key_block(sc); EVP_PKEY_free(sc->s3.peer_tmp); sc->s3.peer_tmp = NULL; EVP_PKEY_free(sc->s3.tmp.pkey); sc->s3.tmp.pkey = NULL; ssl_evp_cipher_free(sc->s3.tmp.new_sym_enc); ssl_evp_md_free(sc->s3.tmp.new_hash); OPENSSL_free(sc->s3.tmp.ctype); sk_X509_NAME_pop_free(sc->s3.tmp.peer_ca_names, X509_NAME_free); OPENSSL_free(sc->s3.tmp.ciphers_raw); OPENSSL_clear_free(sc->s3.tmp.pms, sc->s3.tmp.pmslen); OPENSSL_free(sc->s3.tmp.peer_sigalgs); OPENSSL_free(sc->s3.tmp.peer_cert_sigalgs); OPENSSL_free(sc->s3.tmp.valid_flags); ssl3_free_digest_list(sc); OPENSSL_free(sc->s3.alpn_selected); OPENSSL_free(sc->s3.alpn_proposed); #ifndef OPENSSL_NO_PSK OPENSSL_free(sc->s3.tmp.psk); #endif #ifndef OPENSSL_NO_SRP ssl_srp_ctx_free_intern(sc); #endif memset(&sc->s3, 0, sizeof(sc->s3)); } int ssl3_clear(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); int flags; if (sc == NULL) return 0; ssl3_cleanup_key_block(sc); OPENSSL_free(sc->s3.tmp.ctype); sk_X509_NAME_pop_free(sc->s3.tmp.peer_ca_names, X509_NAME_free); OPENSSL_free(sc->s3.tmp.ciphers_raw); OPENSSL_clear_free(sc->s3.tmp.pms, sc->s3.tmp.pmslen); OPENSSL_free(sc->s3.tmp.peer_sigalgs); OPENSSL_free(sc->s3.tmp.peer_cert_sigalgs); OPENSSL_free(sc->s3.tmp.valid_flags); EVP_PKEY_free(sc->s3.tmp.pkey); EVP_PKEY_free(sc->s3.peer_tmp); ssl3_free_digest_list(sc); OPENSSL_free(sc->s3.alpn_selected); OPENSSL_free(sc->s3.alpn_proposed); /* * NULL/zero-out everything in the s3 struct, but remember if we are doing * QUIC. / flags = sc->s3.flags & TLS1_FLAGS_QUIC; memset(&sc->s3, 0, sizeof(sc->s3)); sc->s3.flags \|= flags; if (!ssl_free_wbio_buffer(sc)) return 0; sc->version = SSL3_VERSION; #if !defined(OPENSSL_NO_NEXTPROTONEG) OPENSSL_free(sc->ext.npn); sc->ext.npn = NULL; sc->ext.npn_len = 0; #endif return 1; } #ifndef OPENSSL_NO_SRP static char srp_password_from_info_cb(SSL s, void arg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return OPENSSL_strdup(sc->srp_ctx.info); } #endif static int ssl3_set_req_cert_type(CERT c, const unsigned char p, size_t len); long ssl3_ctrl(SSL s, int cmd, long larg, void parg) { int ret = 0; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return ret; switch (cmd) { case SSL_CTRL_GET_CLIENT_CERT_REQUEST: break; case SSL_CTRL_GET_NUM_RENEGOTIATIONS: ret = sc->s3.num_renegotiations; break; case SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS: ret = sc->s3.num_renegotiations; sc->s3.num_renegotiations = 0; break; case SSL_CTRL_GET_TOTAL_RENEGOTIATIONS: ret = sc->s3.total_renegotiations; break; case SSL_CTRL_GET_FLAGS: ret = (int)(sc->s3.flags); break; #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_DH: { EVP_PKEY pkdh = NULL; if (parg == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } pkdh = ssl_dh_to_pkey(parg); if (pkdh == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB); return 0; } if (!SSL_set0_tmp_dh_pkey(s, pkdh)) { EVP_PKEY_free(pkdh); return 0; } return 1; } break; case SSL_CTRL_SET_TMP_DH_CB: { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return ret; } #endif case SSL_CTRL_SET_DH_AUTO: sc->cert->dh_tmp_auto = larg; return 1; #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_ECDH: { if (parg == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } return ssl_set_tmp_ecdh_groups(&sc->ext.supportedgroups, &sc->ext.supportedgroups_len, parg); } #endif / !OPENSSL_NO_DEPRECATED_3_0 / case SSL_CTRL_SET_TLSEXT_HOSTNAME: / * This API is only used for a client to set what SNI it will request * from the server, but we currently allow it to be used on servers * as well, which is a programming error. Currently we just clear * the field in SSL_do_handshake() for server SSLs, but when we can * make ABI-breaking changes, we may want to make use of this API * an error on server SSLs. / if (larg == TLSEXT_NAMETYPE_host_name) { size_t len; OPENSSL_free(sc->ext.hostname); sc->ext.hostname = NULL; ret = 1; if (parg == NULL) break; len = strlen((char )parg); if (len == 0 \|\| len > TLSEXT_MAXLEN_host_name) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_SERVERNAME); return 0; } if ((sc->ext.hostname = OPENSSL_strdup((char )parg)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } } else { ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE); return 0; } break; case SSL_CTRL_SET_TLSEXT_DEBUG_ARG: sc->ext.debug_arg = parg; ret = 1; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE: ret = sc->ext.status_type; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE: sc->ext.status_type = larg; ret = 1; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS: (STACK_OF(X509_EXTENSION) *)parg = sc->ext.ocsp.exts; ret = 1; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS: sc->ext.ocsp.exts = parg; ret = 1; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS: (STACK_OF(OCSP_RESPID) *)parg = sc->ext.ocsp.ids; ret = 1; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS: sc->ext.ocsp.ids = parg; ret = 1; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP: (unsigned char *)parg = sc->ext.ocsp.resp; if (sc->ext.ocsp.resp_len == 0 \|\| sc->ext.ocsp.resp_len > LONG_MAX) return -1; return (long)sc->ext.ocsp.resp_len; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP: OPENSSL_free(sc->ext.ocsp.resp); sc->ext.ocsp.resp = parg; sc->ext.ocsp.resp_len = larg; ret = 1; break; case SSL_CTRL_CHAIN: if (larg) return ssl_cert_set1_chain(sc, NULL, (STACK_OF(X509) )parg); else return ssl_cert_set0_chain(sc, NULL, (STACK_OF(X509) )parg); case SSL_CTRL_CHAIN_CERT: if (larg) return ssl_cert_add1_chain_cert(sc, NULL, (X509 )parg); else return ssl_cert_add0_chain_cert(sc, NULL, (X509 )parg); case SSL_CTRL_GET_CHAIN_CERTS: (STACK_OF(X509) *)parg = sc->cert->key->chain; ret = 1; break; case SSL_CTRL_SELECT_CURRENT_CERT: return ssl_cert_select_current(sc->cert, (X509 )parg); case SSL_CTRL_SET_CURRENT_CERT: if (larg == SSL_CERT_SET_SERVER) { const SSL_CIPHER cipher; if (!sc->server) return 0; cipher = sc->s3.tmp.new_cipher; if (cipher == NULL) return 0; / * No certificate for unauthenticated ciphersuites or using SRP * authentication / if (cipher->algorithm_auth & (SSL_aNULL \| SSL_aSRP)) return 2; if (sc->s3.tmp.cert == NULL) return 0; sc->cert->key = sc->s3.tmp.cert; return 1; } return ssl_cert_set_current(sc->cert, larg); case SSL_CTRL_GET_GROUPS: { uint16_t clist; size_t clistlen; if (!sc->session) return 0; clist = sc->ext.peer_supportedgroups; clistlen = sc->ext.peer_supportedgroups_len; if (parg) { size_t i; int cptr = parg; for (i = 0; i < clistlen; i++) { const TLS_GROUP_INFO cinf = tls1_group_id_lookup(s->ctx, clist[i]); if (cinf != NULL) cptr[i] = tls1_group_id2nid(cinf->group_id, 1); else cptr[i] = TLSEXT_nid_unknown \| clist[i]; } } return (int)clistlen; } case SSL_CTRL_SET_GROUPS: return tls1_set_groups(&sc->ext.supportedgroups, &sc->ext.supportedgroups_len, parg, larg); case SSL_CTRL_SET_GROUPS_LIST: return tls1_set_groups_list(s->ctx, &sc->ext.supportedgroups, &sc->ext.supportedgroups_len, parg); case SSL_CTRL_GET_SHARED_GROUP: { uint16_t id = tls1_shared_group(sc, larg); if (larg != -1) return tls1_group_id2nid(id, 1); return id; } case SSL_CTRL_GET_NEGOTIATED_GROUP: { unsigned int id; if (SSL_CONNECTION_IS_TLS13(sc) && sc->s3.did_kex) id = sc->s3.group_id; else id = sc->session->kex_group; ret = tls1_group_id2nid(id, 1); break; } case SSL_CTRL_SET_SIGALGS: return tls1_set_sigalgs(sc->cert, parg, larg, 0); case SSL_CTRL_SET_SIGALGS_LIST: return tls1_set_sigalgs_list(sc->cert, parg, 0); case SSL_CTRL_SET_CLIENT_SIGALGS: return tls1_set_sigalgs(sc->cert, parg, larg, 1); case SSL_CTRL_SET_CLIENT_SIGALGS_LIST: return tls1_set_sigalgs_list(sc->cert, parg, 1); case SSL_CTRL_GET_CLIENT_CERT_TYPES: { const unsigned char *pctype = parg; if (sc->server \|\| !sc->s3.tmp.cert_req) return 0; if (pctype) pctype = sc->s3.tmp.ctype; return sc->s3.tmp.ctype_len; } case SSL_CTRL_SET_CLIENT_CERT_TYPES: if (!sc->server) return 0; return ssl3_set_req_cert_type(sc->cert, parg, larg); case SSL_CTRL_BUILD_CERT_CHAIN: return ssl_build_cert_chain(sc, NULL, larg); case SSL_CTRL_SET_VERIFY_CERT_STORE: return ssl_cert_set_cert_store(sc->cert, parg, 0, larg); case SSL_CTRL_SET_CHAIN_CERT_STORE: return ssl_cert_set_cert_store(sc->cert, parg, 1, larg); case SSL_CTRL_GET_VERIFY_CERT_STORE: return ssl_cert_get_cert_store(sc->cert, parg, 0); case SSL_CTRL_GET_CHAIN_CERT_STORE: return ssl_cert_get_cert_store(sc->cert, parg, 1); case SSL_CTRL_GET_PEER_SIGNATURE_NID: if (sc->s3.tmp.peer_sigalg == NULL) return 0; (int )parg = sc->s3.tmp.peer_sigalg->hash; return 1; case SSL_CTRL_GET_SIGNATURE_NID: if (sc->s3.tmp.sigalg == NULL) return 0; (int )parg = sc->s3.tmp.sigalg->hash; return 1; case SSL_CTRL_GET_PEER_TMP_KEY: if (sc->session == NULL \|\| sc->s3.peer_tmp == NULL) { return 0; } else { EVP_PKEY_up_ref(sc->s3.peer_tmp); (EVP_PKEY )parg = sc->s3.peer_tmp; return 1; } case SSL_CTRL_GET_TMP_KEY: if (sc->session == NULL \|\| sc->s3.tmp.pkey == NULL) { return 0; } else { EVP_PKEY_up_ref(sc->s3.tmp.pkey); (EVP_PKEY )parg = sc->s3.tmp.pkey; return 1; } case SSL_CTRL_GET_EC_POINT_FORMATS: { const unsigned char pformat = parg; if (sc->ext.peer_ecpointformats == NULL) return 0; pformat = sc->ext.peer_ecpointformats; return (int)sc->ext.peer_ecpointformats_len; } case SSL_CTRL_GET_IANA_GROUPS: { if (parg != NULL) { (uint16_t *)parg = (uint16_t )sc->ext.peer_supportedgroups; } return (int)sc->ext.peer_supportedgroups_len; } case SSL_CTRL_SET_MSG_CALLBACK_ARG: sc->msg_callback_arg = parg; return 1; default: break; } return ret; } long ssl3_callback_ctrl(SSL s, int cmd, void (fp) (void)) { int ret = 0; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return ret; switch (cmd) { #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_DH_CB: sc->cert->dh_tmp_cb = (DH ()(SSL , int, int))fp; ret = 1; break; #endif case SSL_CTRL_SET_TLSEXT_DEBUG_CB: sc->ext.debug_cb = (void ()(SSL , int, int, const unsigned char , int, void ))fp; ret = 1; break; case SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB: sc->not_resumable_session_cb = (int ()(SSL , int))fp; ret = 1; break; case SSL_CTRL_SET_MSG_CALLBACK: sc->msg_callback = (ossl_msg_cb)fp; return 1; default: break; } return ret; } long ssl3_ctx_ctrl(SSL_CTX ctx, int cmd, long larg, void parg) { switch (cmd) { #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_DH: { EVP_PKEY pkdh = NULL; if (parg == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } pkdh = ssl_dh_to_pkey(parg); if (pkdh == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB); return 0; } if (!SSL_CTX_set0_tmp_dh_pkey(ctx, pkdh)) { EVP_PKEY_free(pkdh); return 0; } return 1; } case SSL_CTRL_SET_TMP_DH_CB: { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } #endif case SSL_CTRL_SET_DH_AUTO: ctx->cert->dh_tmp_auto = larg; return 1; #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_ECDH: { if (parg == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } return ssl_set_tmp_ecdh_groups(&ctx->ext.supportedgroups, &ctx->ext.supportedgroups_len, parg); } #endif / !OPENSSL_NO_DEPRECATED_3_0 / case SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG: ctx->ext.servername_arg = parg; break; case SSL_CTRL_SET_TLSEXT_TICKET_KEYS: case SSL_CTRL_GET_TLSEXT_TICKET_KEYS: { unsigned char keys = parg; long tick_keylen = (sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key) + sizeof(ctx->ext.secure->tick_aes_key)); if (keys == NULL) return tick_keylen; if (larg != tick_keylen) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_TICKET_KEYS_LENGTH); return 0; } if (cmd == SSL_CTRL_SET_TLSEXT_TICKET_KEYS) { memcpy(ctx->ext.tick_key_name, keys, sizeof(ctx->ext.tick_key_name)); memcpy(ctx->ext.secure->tick_hmac_key, keys + sizeof(ctx->ext.tick_key_name), sizeof(ctx->ext.secure->tick_hmac_key)); memcpy(ctx->ext.secure->tick_aes_key, keys + sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key), sizeof(ctx->ext.secure->tick_aes_key)); } else { memcpy(keys, ctx->ext.tick_key_name, sizeof(ctx->ext.tick_key_name)); memcpy(keys + sizeof(ctx->ext.tick_key_name), ctx->ext.secure->tick_hmac_key, sizeof(ctx->ext.secure->tick_hmac_key)); memcpy(keys + sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key), ctx->ext.secure->tick_aes_key, sizeof(ctx->ext.secure->tick_aes_key)); } return 1; } case SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE: return ctx->ext.status_type; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE: ctx->ext.status_type = larg; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG: ctx->ext.status_arg = parg; return 1; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG: (void)parg = ctx->ext.status_arg; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB: (int (*)(SSL, void))parg = ctx->ext.status_cb; break; #ifndef OPENSSL_NO_SRP case SSL_CTRL_SET_TLS_EXT_SRP_USERNAME: ctx->srp_ctx.srp_Mask \|= SSL_kSRP; OPENSSL_free(ctx->srp_ctx.login); ctx->srp_ctx.login = NULL; if (parg == NULL) break; if (strlen((const char )parg) > 255 \|\| strlen((const char )parg) < 1) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SRP_USERNAME); return 0; } if ((ctx->srp_ctx.login = OPENSSL_strdup((char )parg)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } break; case SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD: ctx->srp_ctx.SRP_give_srp_client_pwd_callback = srp_password_from_info_cb; if (ctx->srp_ctx.info != NULL) OPENSSL_free(ctx->srp_ctx.info); if ((ctx->srp_ctx.info = OPENSSL_strdup((char )parg)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } break; case SSL_CTRL_SET_SRP_ARG: ctx->srp_ctx.srp_Mask \|= SSL_kSRP; ctx->srp_ctx.SRP_cb_arg = parg; break; case SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH: ctx->srp_ctx.strength = larg; break; #endif case SSL_CTRL_SET_GROUPS: return tls1_set_groups(&ctx->ext.supportedgroups, &ctx->ext.supportedgroups_len, parg, larg); case SSL_CTRL_SET_GROUPS_LIST: return tls1_set_groups_list(ctx, &ctx->ext.supportedgroups, &ctx->ext.supportedgroups_len, parg); case SSL_CTRL_SET_SIGALGS: return tls1_set_sigalgs(ctx->cert, parg, larg, 0); case SSL_CTRL_SET_SIGALGS_LIST: return tls1_set_sigalgs_list(ctx->cert, parg, 0); case SSL_CTRL_SET_CLIENT_SIGALGS: return tls1_set_sigalgs(ctx->cert, parg, larg, 1); case SSL_CTRL_SET_CLIENT_SIGALGS_LIST: return tls1_set_sigalgs_list(ctx->cert, parg, 1); case SSL_CTRL_SET_CLIENT_CERT_TYPES: return ssl3_set_req_cert_type(ctx->cert, parg, larg); case SSL_CTRL_BUILD_CERT_CHAIN: return ssl_build_cert_chain(NULL, ctx, larg); case SSL_CTRL_SET_VERIFY_CERT_STORE: return ssl_cert_set_cert_store(ctx->cert, parg, 0, larg); case SSL_CTRL_SET_CHAIN_CERT_STORE: return ssl_cert_set_cert_store(ctx->cert, parg, 1, larg); case SSL_CTRL_GET_VERIFY_CERT_STORE: return ssl_cert_get_cert_store(ctx->cert, parg, 0); case SSL_CTRL_GET_CHAIN_CERT_STORE: return ssl_cert_get_cert_store(ctx->cert, parg, 1); / A Thawte special :-) / case SSL_CTRL_EXTRA_CHAIN_CERT: if (ctx->extra_certs == NULL) { if ((ctx->extra_certs = sk_X509_new_null()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 0; } } if (!sk_X509_push(ctx->extra_certs, (X509 )parg)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 0; } break; case SSL_CTRL_GET_EXTRA_CHAIN_CERTS: if (ctx->extra_certs == NULL && larg == 0) (STACK_OF(X509) )parg = ctx->cert->key->chain; else (STACK_OF(X509) *)parg = ctx->extra_certs; break; case SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS: OSSL_STACK_OF_X509_free(ctx->extra_certs); ctx->extra_certs = NULL; break; case SSL_CTRL_CHAIN: if (larg) return ssl_cert_set1_chain(NULL, ctx, (STACK_OF(X509) )parg); else return ssl_cert_set0_chain(NULL, ctx, (STACK_OF(X509) )parg); case SSL_CTRL_CHAIN_CERT: if (larg) return ssl_cert_add1_chain_cert(NULL, ctx, (X509 )parg); else return ssl_cert_add0_chain_cert(NULL, ctx, (X509 )parg); case SSL_CTRL_GET_CHAIN_CERTS: (STACK_OF(X509) *)parg = ctx->cert->key->chain; break; case SSL_CTRL_SELECT_CURRENT_CERT: return ssl_cert_select_current(ctx->cert, (X509 )parg); case SSL_CTRL_SET_CURRENT_CERT: return ssl_cert_set_current(ctx->cert, larg); default: return 0; } return 1; } long ssl3_ctx_callback_ctrl(SSL_CTX ctx, int cmd, void (fp) (void)) { switch (cmd) { #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_DH_CB: { ctx->cert->dh_tmp_cb = (DH ()(SSL , int, int))fp; } break; #endif case SSL_CTRL_SET_TLSEXT_SERVERNAME_CB: ctx->ext.servername_cb = (int ()(SSL , int , void ))fp; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB: ctx->ext.status_cb = (int ()(SSL , void ))fp; break; # ifndef OPENSSL_NO_DEPRECATED_3_0 case SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB: ctx->ext.ticket_key_cb = (int ()(SSL , unsigned char , unsigned char , EVP_CIPHER_CTX , HMAC_CTX , int))fp; break; #endif #ifndef OPENSSL_NO_SRP case SSL_CTRL_SET_SRP_VERIFY_PARAM_CB: ctx->srp_ctx.srp_Mask \|= SSL_kSRP; ctx->srp_ctx.SRP_verify_param_callback = (int ()(SSL , void ))fp; break; case SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB: ctx->srp_ctx.srp_Mask \|= SSL_kSRP; ctx->srp_ctx.TLS_ext_srp_username_callback = (int ()(SSL , int , void ))fp; break; case SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB: ctx->srp_ctx.srp_Mask \|= SSL_kSRP; ctx->srp_ctx.SRP_give_srp_client_pwd_callback = (char ()(SSL , void ))fp; break; #endif case SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB: { ctx->not_resumable_session_cb = (int ()(SSL , int))fp; } break; default: return 0; } return 1; } int SSL_CTX_set_tlsext_ticket_key_evp_cb (SSL_CTX ctx, int (fp)(SSL , unsigned char , unsigned char , EVP_CIPHER_CTX , EVP_MAC_CTX , int)) { ctx->ext.ticket_key_evp_cb = fp; return 1; } const SSL_CIPHER ssl3_get_cipher_by_id(uint32_t id) { SSL_CIPHER c; const SSL_CIPHER cp; c.id = id; cp = OBJ_bsearch_ssl_cipher_id(&c, tls13_ciphers, TLS13_NUM_CIPHERS); if (cp != NULL) return cp; cp = OBJ_bsearch_ssl_cipher_id(&c, ssl3_ciphers, SSL3_NUM_CIPHERS); if (cp != NULL) return cp; return OBJ_bsearch_ssl_cipher_id(&c, ssl3_scsvs, SSL3_NUM_SCSVS); } const SSL_CIPHER ssl3_get_cipher_by_std_name(const char stdname) { SSL_CIPHER tbl; SSL_CIPHER alltabs[] = {tls13_ciphers, ssl3_ciphers, ssl3_scsvs}; size_t i, j, tblsize[] = {TLS13_NUM_CIPHERS, SSL3_NUM_CIPHERS, SSL3_NUM_SCSVS}; /* this is not efficient, necessary to optimize this? / for (j = 0; j < OSSL_NELEM(alltabs); j++) { for (i = 0, tbl = alltabs[j]; i < tblsize[j]; i++, tbl++) { if (tbl->stdname == NULL) continue; if (strcmp(stdname, tbl->stdname) == 0) { return tbl; } } } return NULL; } / * This function needs to check if the ciphers required are actually * available / const SSL_CIPHER ssl3_get_cipher_by_char(const unsigned char p) { return ssl3_get_cipher_by_id(SSL3_CK_CIPHERSUITE_FLAG \| ((uint32_t)p[0] << 8L) \| (uint32_t)p[1]); } int ssl3_put_cipher_by_char(const SSL_CIPHER c, WPACKET pkt, size_t len) { if ((c->id & 0xff000000) != SSL3_CK_CIPHERSUITE_FLAG) { len = 0; return 1; } if (!WPACKET_put_bytes_u16(pkt, c->id & 0xffff)) return 0; len = 2; return 1; } /* * ssl3_choose_cipher - choose a cipher from those offered by the client * @s: SSL connection * @clnt: ciphers offered by the client * @srvr: ciphers enabled on the server? * * Returns the selected cipher or NULL when no common ciphers. / const SSL_CIPHER ssl3_choose_cipher(SSL_CONNECTION s, STACK_OF(SSL_CIPHER) clnt, STACK_OF(SSL_CIPHER) srvr) { const SSL_CIPHER c, ret = NULL; STACK_OF(SSL_CIPHER) prio, allow; int i, ii, ok, prefer_sha256 = 0; unsigned long alg_k = 0, alg_a = 0, mask_k = 0, mask_a = 0; STACK_OF(SSL_CIPHER) prio_chacha = NULL; /* Let's see which ciphers we can support / / * Do not set the compare functions, because this may lead to a * reordering by "id". We want to keep the original ordering. We may pay * a price in performance during sk_SSL_CIPHER_find(), but would have to * pay with the price of sk_SSL_CIPHER_dup(). / OSSL_TRACE_BEGIN(TLS_CIPHER) { BIO_printf(trc_out, "Server has %d from %p:\n", sk_SSL_CIPHER_num(srvr), (void )srvr); for (i = 0; i < sk_SSL_CIPHER_num(srvr); ++i) { c = sk_SSL_CIPHER_value(srvr, i); BIO_printf(trc_out, "%p:%s\n", (void )c, c->name); } BIO_printf(trc_out, "Client sent %d from %p:\n", sk_SSL_CIPHER_num(clnt), (void )clnt); for (i = 0; i < sk_SSL_CIPHER_num(clnt); ++i) { c = sk_SSL_CIPHER_value(clnt, i); BIO_printf(trc_out, "%p:%s\n", (void )c, c->name); } } OSSL_TRACE_END(TLS_CIPHER); / SUITE-B takes precedence over server preference and ChaCha priortiy / if (tls1_suiteb(s)) { prio = srvr; allow = clnt; } else if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) { prio = srvr; allow = clnt; / If ChaCha20 is at the top of the client preference list, and there are ChaCha20 ciphers in the server list, then temporarily prioritize all ChaCha20 ciphers in the servers list. / if (s->options & SSL_OP_PRIORITIZE_CHACHA && sk_SSL_CIPHER_num(clnt) > 0) { c = sk_SSL_CIPHER_value(clnt, 0); if (c->algorithm_enc == SSL_CHACHA20POLY1305) { / ChaCha20 is client preferred, check server... / int num = sk_SSL_CIPHER_num(srvr); int found = 0; for (i = 0; i < num; i++) { c = sk_SSL_CIPHER_value(srvr, i); if (c->algorithm_enc == SSL_CHACHA20POLY1305) { found = 1; break; } } if (found) { prio_chacha = sk_SSL_CIPHER_new_reserve(NULL, num); / if reserve fails, then there's likely a memory issue / if (prio_chacha != NULL) { / Put all ChaCha20 at the top, starting with the one we just found / sk_SSL_CIPHER_push(prio_chacha, c); for (i++; i < num; i++) { c = sk_SSL_CIPHER_value(srvr, i); if (c->algorithm_enc == SSL_CHACHA20POLY1305) sk_SSL_CIPHER_push(prio_chacha, c); } / Pull in the rest / for (i = 0; i < num; i++) { c = sk_SSL_CIPHER_value(srvr, i); if (c->algorithm_enc != SSL_CHACHA20POLY1305) sk_SSL_CIPHER_push(prio_chacha, c); } prio = prio_chacha; } } } } } else { prio = clnt; allow = srvr; } if (SSL_CONNECTION_IS_TLS13(s)) { #ifndef OPENSSL_NO_PSK size_t j; / * If we allow "old" style PSK callbacks, and we have no certificate (so * we're not going to succeed without a PSK anyway), and we're in * TLSv1.3 then the default hash for a PSK is SHA-256 (as per the * TLSv1.3 spec). Therefore we should prioritise ciphersuites using * that. / if (s->psk_server_callback != NULL) { for (j = 0; j < s->ssl_pkey_num && !ssl_has_cert(s, j); j++); if (j == s->ssl_pkey_num) { / There are no certificates / prefer_sha256 = 1; } } #endif } else { tls1_set_cert_validity(s); ssl_set_masks(s); } for (i = 0; i < sk_SSL_CIPHER_num(prio); i++) { int minversion, maxversion; c = sk_SSL_CIPHER_value(prio, i); minversion = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls; maxversion = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls; / Skip ciphers not supported by the protocol version / if (ssl_version_cmp(s, s->version, minversion) < 0 \|\| ssl_version_cmp(s, s->version, maxversion) > 0) continue; / * Since TLS 1.3 ciphersuites can be used with any auth or * key exchange scheme skip tests. / if (!SSL_CONNECTION_IS_TLS13(s)) { mask_k = s->s3.tmp.mask_k; mask_a = s->s3.tmp.mask_a; #ifndef OPENSSL_NO_SRP if (s->srp_ctx.srp_Mask & SSL_kSRP) { mask_k \|= SSL_kSRP; mask_a \|= SSL_aSRP; } #endif alg_k = c->algorithm_mkey; alg_a = c->algorithm_auth; #ifndef OPENSSL_NO_PSK / with PSK there must be server callback set / if ((alg_k & SSL_PSK) && s->psk_server_callback == NULL) continue; #endif / OPENSSL_NO_PSK / ok = (alg_k & mask_k) && (alg_a & mask_a); OSSL_TRACE7(TLS_CIPHER, "%d:[%08lX:%08lX:%08lX:%08lX]%p:%s\n", ok, alg_k, alg_a, mask_k, mask_a, (void )c, c->name); /* * if we are considering an ECC cipher suite that uses an ephemeral * EC key check it / if (alg_k & SSL_kECDHE) ok = ok && tls1_check_ec_tmp_key(s, c->id); if (!ok) continue; } ii = sk_SSL_CIPHER_find(allow, c); if (ii >= 0) { / Check security callback permits this cipher / if (!ssl_security(s, SSL_SECOP_CIPHER_SHARED, c->strength_bits, 0, (void )c)) continue; if ((alg_k & SSL_kECDHE) && (alg_a & SSL_aECDSA) && s->s3.is_probably_safari) { if (!ret) ret = sk_SSL_CIPHER_value(allow, ii); continue; } if (prefer_sha256) { const SSL_CIPHER tmp = sk_SSL_CIPHER_value(allow, ii); const EVP_MD md = ssl_md(SSL_CONNECTION_GET_CTX(s), tmp->algorithm2); if (md != NULL && EVP_MD_is_a(md, OSSL_DIGEST_NAME_SHA2_256)) { ret = tmp; break; } if (ret == NULL) ret = tmp; continue; } ret = sk_SSL_CIPHER_value(allow, ii); break; } } sk_SSL_CIPHER_free(prio_chacha); return ret; } int ssl3_get_req_cert_type(SSL_CONNECTION s, WPACKET pkt) { uint32_t alg_k, alg_a = 0; /* If we have custom certificate types set, use them / if (s->cert->ctype) return WPACKET_memcpy(pkt, s->cert->ctype, s->cert->ctype_len); / Get mask of algorithms disabled by signature list / ssl_set_sig_mask(&alg_a, s, SSL_SECOP_SIGALG_MASK); alg_k = s->s3.tmp.new_cipher->algorithm_mkey; #ifndef OPENSSL_NO_GOST if (s->version >= TLS1_VERSION && (alg_k & SSL_kGOST)) if (!WPACKET_put_bytes_u8(pkt, TLS_CT_GOST01_SIGN) \|\| !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_IANA_SIGN) \|\| !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_IANA_512_SIGN) \|\| !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_LEGACY_SIGN) \|\| !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_LEGACY_512_SIGN)) return 0; if (s->version >= TLS1_2_VERSION && (alg_k & SSL_kGOST18)) if (!WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_IANA_SIGN) \|\| !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_IANA_512_SIGN)) return 0; #endif if ((s->version == SSL3_VERSION) && (alg_k & SSL_kDHE)) { if (!WPACKET_put_bytes_u8(pkt, SSL3_CT_RSA_EPHEMERAL_DH)) return 0; if (!(alg_a & SSL_aDSS) && !WPACKET_put_bytes_u8(pkt, SSL3_CT_DSS_EPHEMERAL_DH)) return 0; } if (!(alg_a & SSL_aRSA) && !WPACKET_put_bytes_u8(pkt, SSL3_CT_RSA_SIGN)) return 0; if (!(alg_a & SSL_aDSS) && !WPACKET_put_bytes_u8(pkt, SSL3_CT_DSS_SIGN)) return 0; / * ECDSA certs can be used with RSA cipher suites too so we don't * need to check for SSL_kECDH or SSL_kECDHE / if (s->version >= TLS1_VERSION && !(alg_a & SSL_aECDSA) && !WPACKET_put_bytes_u8(pkt, TLS_CT_ECDSA_SIGN)) return 0; return 1; } static int ssl3_set_req_cert_type(CERT c, const unsigned char p, size_t len) { OPENSSL_free(c->ctype); c->ctype = NULL; c->ctype_len = 0; if (p == NULL \|\| len == 0) return 1; if (len > 0xff) return 0; c->ctype = OPENSSL_memdup(p, len); if (c->ctype == NULL) return 0; c->ctype_len = len; return 1; } int ssl3_shutdown(SSL s) { int ret; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; / * Don't do anything much if we have not done the handshake or we don't * want to send messages :-) / if (sc->quiet_shutdown \|\| SSL_in_before(s)) { sc->shutdown = (SSL_SENT_SHUTDOWN \| SSL_RECEIVED_SHUTDOWN); return 1; } if (!(sc->shutdown & SSL_SENT_SHUTDOWN)) { sc->shutdown \|= SSL_SENT_SHUTDOWN; ssl3_send_alert(sc, SSL3_AL_WARNING, SSL_AD_CLOSE_NOTIFY); / * our shutdown alert has been sent now, and if it still needs to be * written, s->s3.alert_dispatch will be > 0 / if (sc->s3.alert_dispatch > 0) return -1; / return WANT_WRITE / } else if (sc->s3.alert_dispatch > 0) { / resend it if not sent / ret = s->method->ssl_dispatch_alert(s); if (ret == -1) { / * we only get to return -1 here the 2nd/Nth invocation, we must * have already signalled return 0 upon a previous invocation, * return WANT_WRITE / return ret; } } else if (!(sc->shutdown & SSL_RECEIVED_SHUTDOWN)) { size_t readbytes; / * If we are waiting for a close from our peer, we are closed / s->method->ssl_read_bytes(s, 0, NULL, NULL, 0, 0, &readbytes); if (!(sc->shutdown & SSL_RECEIVED_SHUTDOWN)) { return -1; / return WANT_READ / } } if ((sc->shutdown == (SSL_SENT_SHUTDOWN \| SSL_RECEIVED_SHUTDOWN)) && sc->s3.alert_dispatch == SSL_ALERT_DISPATCH_NONE) return 1; else return 0; } int ssl3_write(SSL s, const void buf, size_t len, size_t written) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; clear_sys_error(); if (sc->s3.renegotiate) ssl3_renegotiate_check(s, 0); return s->method->ssl_write_bytes(s, SSL3_RT_APPLICATION_DATA, buf, len, written); } static int ssl3_read_internal(SSL s, void buf, size_t len, int peek, size_t readbytes) { int ret; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; clear_sys_error(); if (sc->s3.renegotiate) ssl3_renegotiate_check(s, 0); sc->s3.in_read_app_data = 1; ret = s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf, len, peek, readbytes); if ((ret == -1) && (sc->s3.in_read_app_data == 2)) { / * ssl3_read_bytes decided to call s->handshake_func, which called * ssl3_read_bytes to read handshake data. However, ssl3_read_bytes * actually found application data and thinks that application data * makes sense here; so disable handshake processing and try to read * application data again. / ossl_statem_set_in_handshake(sc, 1); ret = s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf, len, peek, readbytes); ossl_statem_set_in_handshake(sc, 0); } else sc->s3.in_read_app_data = 0; return ret; } int ssl3_read(SSL s, void buf, size_t len, size_t readbytes) { return ssl3_read_internal(s, buf, len, 0, readbytes); } int ssl3_peek(SSL s, void buf, size_t len, size_t readbytes) { return ssl3_read_internal(s, buf, len, 1, readbytes); } int ssl3_renegotiate(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (sc->handshake_func == NULL) return 1; sc->s3.renegotiate = 1; return 1; } / * Check if we are waiting to do a renegotiation and if so whether now is a * good time to do it. If \|initok\| is true then we are being called from inside * the state machine so ignore the result of SSL_in_init(s). Otherwise we * should not do a renegotiation if SSL_in_init(s) is true. Returns 1 if we * should do a renegotiation now and sets up the state machine for it. Otherwise * returns 0. / int ssl3_renegotiate_check(SSL s, int initok) { int ret = 0; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (sc->s3.renegotiate) { if (!RECORD_LAYER_read_pending(&sc->rlayer) && !RECORD_LAYER_write_pending(&sc->rlayer) && (initok \|\| !SSL_in_init(s))) { / * if we are the server, and we have sent a 'RENEGOTIATE' * message, we need to set the state machine into the renegotiate * state. / ossl_statem_set_renegotiate(sc); sc->s3.renegotiate = 0; sc->s3.num_renegotiations++; sc->s3.total_renegotiations++; ret = 1; } } return ret; } / * If we are using default SHA1+MD5 algorithms switch to new SHA256 PRF and * handshake macs if required. * * If PSK and using SHA384 for TLS < 1.2 switch to default. / long ssl_get_algorithm2(SSL_CONNECTION s) { long alg2; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->s3.tmp.new_cipher == NULL) return -1; alg2 = s->s3.tmp.new_cipher->algorithm2; if (ssl->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SHA256_PRF) { if (alg2 == (SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF)) return SSL_HANDSHAKE_MAC_SHA256 \| TLS1_PRF_SHA256; } else if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK) { if (alg2 == (SSL_HANDSHAKE_MAC_SHA384 \| TLS1_PRF_SHA384)) return SSL_HANDSHAKE_MAC_DEFAULT \| TLS1_PRF; } return alg2; } / * Fill a ClientRandom or ServerRandom field of length len. Returns <= 0 on * failure, 1 on success. / int ssl_fill_hello_random(SSL_CONNECTION s, int server, unsigned char result, size_t len, DOWNGRADE dgrd) { int send_time = 0, ret; if (len < 4) return 0; if (server) send_time = (s->mode & SSL_MODE_SEND_SERVERHELLO_TIME) != 0; else send_time = (s->mode & SSL_MODE_SEND_CLIENTHELLO_TIME) != 0; if (send_time) { unsigned long Time = (unsigned long)time(NULL); unsigned char p = result; l2n(Time, p); ret = RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, p, len - 4, 0); } else { ret = RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, result, len, 0); } if (ret > 0) { if (!ossl_assert(sizeof(tls11downgrade) < len) \|\| !ossl_assert(sizeof(tls12downgrade) < len)) return 0; if (dgrd == DOWNGRADE_TO_1_2) memcpy(result + len - sizeof(tls12downgrade), tls12downgrade, sizeof(tls12downgrade)); else if (dgrd == DOWNGRADE_TO_1_1) memcpy(result + len - sizeof(tls11downgrade), tls11downgrade, sizeof(tls11downgrade)); } return ret; } int ssl_generate_master_secret(SSL_CONNECTION s, unsigned char pms, size_t pmslen, int free_pms) { unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey; int ret = 0; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (alg_k & SSL_PSK) { #ifndef OPENSSL_NO_PSK unsigned char pskpms, t; size_t psklen = s->s3.tmp.psklen; size_t pskpmslen; / create PSK premaster_secret / / For plain PSK "other_secret" is psklen zeroes / if (alg_k & SSL_kPSK) pmslen = psklen; pskpmslen = 4 + pmslen + psklen; pskpms = OPENSSL_malloc(pskpmslen); if (pskpms == NULL) goto err; t = pskpms; s2n(pmslen, t); if (alg_k & SSL_kPSK) memset(t, 0, pmslen); else memcpy(t, pms, pmslen); t += pmslen; s2n(psklen, t); memcpy(t, s->s3.tmp.psk, psklen); OPENSSL_clear_free(s->s3.tmp.psk, psklen); s->s3.tmp.psk = NULL; s->s3.tmp.psklen = 0; if (!ssl->method->ssl3_enc->generate_master_secret(s, s->session->master_key, pskpms, pskpmslen, &s->session->master_key_length)) { OPENSSL_clear_free(pskpms, pskpmslen); / SSLfatal() already called / goto err; } OPENSSL_clear_free(pskpms, pskpmslen); #else / Should never happen / goto err; #endif } else { if (!ssl->method->ssl3_enc->generate_master_secret(s, s->session->master_key, pms, pmslen, &s->session->master_key_length)) { / SSLfatal() already called / goto err; } } ret = 1; err: if (pms) { if (free_pms) OPENSSL_clear_free(pms, pmslen); else OPENSSL_cleanse(pms, pmslen); } if (s->server == 0) { s->s3.tmp.pms = NULL; s->s3.tmp.pmslen = 0; } return ret; } / Generate a private key from parameters / EVP_PKEY ssl_generate_pkey(SSL_CONNECTION s, EVP_PKEY pm) { EVP_PKEY_CTX pctx = NULL; EVP_PKEY pkey = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (pm == NULL) return NULL; pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pm, sctx->propq); if (pctx == NULL) goto err; if (EVP_PKEY_keygen_init(pctx) <= 0) goto err; if (EVP_PKEY_keygen(pctx, &pkey) <= 0) { EVP_PKEY_free(pkey); pkey = NULL; } err: EVP_PKEY_CTX_free(pctx); return pkey; } / Generate a private key from a group ID / EVP_PKEY ssl_generate_pkey_group(SSL_CONNECTION s, uint16_t id) { SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); const TLS_GROUP_INFO ginf = tls1_group_id_lookup(sctx, id); EVP_PKEY_CTX pctx = NULL; EVP_PKEY pkey = NULL; if (ginf == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, ginf->algorithm, sctx->propq); if (pctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_keygen_init(pctx) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_CTX_set_group_name(pctx, ginf->realname) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_keygen(pctx, &pkey) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); EVP_PKEY_free(pkey); pkey = NULL; } err: EVP_PKEY_CTX_free(pctx); return pkey; } / * Generate parameters from a group ID / EVP_PKEY ssl_generate_param_group(SSL_CONNECTION s, uint16_t id) { SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); EVP_PKEY_CTX pctx = NULL; EVP_PKEY pkey = NULL; const TLS_GROUP_INFO ginf = tls1_group_id_lookup(sctx, id); if (ginf == NULL) goto err; pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, ginf->algorithm, sctx->propq); if (pctx == NULL) goto err; if (EVP_PKEY_paramgen_init(pctx) <= 0) goto err; if (EVP_PKEY_CTX_set_group_name(pctx, ginf->realname) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_paramgen(pctx, &pkey) <= 0) { EVP_PKEY_free(pkey); pkey = NULL; } err: EVP_PKEY_CTX_free(pctx); return pkey; } / Generate secrets from pms / int ssl_gensecret(SSL_CONNECTION s, unsigned char pms, size_t pmslen) { int rv = 0; / SSLfatal() called as appropriate in the below functions / if (SSL_CONNECTION_IS_TLS13(s)) { / * If we are resuming then we already generated the early secret * when we created the ClientHello, so don't recreate it. / if (!s->hit) rv = tls13_generate_secret(s, ssl_handshake_md(s), NULL, NULL, 0, (unsigned char )&s->early_secret); else rv = 1; rv = rv && tls13_generate_handshake_secret(s, pms, pmslen); } else { rv = ssl_generate_master_secret(s, pms, pmslen, 0); } return rv; } /* Derive secrets for ECDH/DH / int ssl_derive(SSL_CONNECTION s, EVP_PKEY privkey, EVP_PKEY pubkey, int gensecret) { int rv = 0; unsigned char pms = NULL; size_t pmslen = 0; EVP_PKEY_CTX pctx; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (privkey == NULL \|\| pubkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, privkey, sctx->propq); if (EVP_PKEY_derive_init(pctx) <= 0 \|\| EVP_PKEY_derive_set_peer(pctx, pubkey) <= 0 \|\| EVP_PKEY_derive(pctx, NULL, &pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (SSL_CONNECTION_IS_TLS13(s) && EVP_PKEY_is_a(privkey, "DH")) EVP_PKEY_CTX_set_dh_pad(pctx, 1); pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (EVP_PKEY_derive(pctx, pms, &pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (gensecret) { / SSLfatal() called as appropriate in the below functions / rv = ssl_gensecret(s, pms, pmslen); } else { / Save premaster secret / s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; pms = NULL; rv = 1; } err: OPENSSL_clear_free(pms, pmslen); EVP_PKEY_CTX_free(pctx); return rv; } / Decapsulate secrets for KEM / int ssl_decapsulate(SSL_CONNECTION s, EVP_PKEY privkey, const unsigned char ct, size_t ctlen, int gensecret) { int rv = 0; unsigned char pms = NULL; size_t pmslen = 0; EVP_PKEY_CTX pctx; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (privkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, privkey, sctx->propq); if (EVP_PKEY_decapsulate_init(pctx, NULL) <= 0 \|\| EVP_PKEY_decapsulate(pctx, NULL, &pmslen, ct, ctlen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (EVP_PKEY_decapsulate(pctx, pms, &pmslen, ct, ctlen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (gensecret) { / SSLfatal() called as appropriate in the below functions / rv = ssl_gensecret(s, pms, pmslen); } else { / Save premaster secret / s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; pms = NULL; rv = 1; } err: OPENSSL_clear_free(pms, pmslen); EVP_PKEY_CTX_free(pctx); return rv; } int ssl_encapsulate(SSL_CONNECTION s, EVP_PKEY pubkey, unsigned char ctp, size_t ctlenp, int gensecret) { int rv = 0; unsigned char pms = NULL, ct = NULL; size_t pmslen = 0, ctlen = 0; EVP_PKEY_CTX pctx; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (pubkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pubkey, sctx->propq); if (EVP_PKEY_encapsulate_init(pctx, NULL) <= 0 \|\| EVP_PKEY_encapsulate(pctx, NULL, &ctlen, NULL, &pmslen) <= 0 \|\| pmslen == 0 \|\| ctlen == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pms = OPENSSL_malloc(pmslen); ct = OPENSSL_malloc(ctlen); if (pms == NULL \|\| ct == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (EVP_PKEY_encapsulate(pctx, ct, &ctlen, pms, &pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (gensecret) { /* SSLfatal() called as appropriate in the below functions / rv = ssl_gensecret(s, pms, pmslen); } else { / Save premaster secret / s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; pms = NULL; rv = 1; } if (rv > 0) { / Pass ownership of ct to caller / ctp = ct; ctlenp = ctlen; ct = NULL; } err: OPENSSL_clear_free(pms, pmslen); OPENSSL_free(ct); EVP_PKEY_CTX_free(pctx); return rv; } const char SSL_get0_group_name(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); unsigned int id; if (sc == NULL) return NULL; if (SSL_CONNECTION_IS_TLS13(sc) && sc->s3.did_kex) id = sc->s3.group_id; else id = sc->session->kex_group; return tls1_group_id2name(s->ctx, id); } const char SSL_group_to_name(SSL s, int nid) { int group_id = 0; const TLS_GROUP_INFO cinf = NULL; / first convert to real group id for internal and external IDs / if (nid & TLSEXT_nid_unknown) group_id = nid & 0xFFFF; else group_id = tls1_nid2group_id(nid); / then look up */ cinf = tls1_group_id_lookup(s->ctx, group_id); if (cinf != NULL) return cinf->tlsname; return NULL; }
./openssl/ssl/statem/extensions_srvr.c	/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/ocsp.h> #include "../ssl_local.h" #include "statem_local.h" #include "internal/cryptlib.h" #define COOKIE_STATE_FORMAT_VERSION 1 / * 2 bytes for packet length, 2 bytes for format version, 2 bytes for * protocol version, 2 bytes for group id, 2 bytes for cipher id, 1 byte for * key_share present flag, 8 bytes for timestamp, 2 bytes for the hashlen, * EVP_MAX_MD_SIZE for transcript hash, 1 byte for app cookie length, app cookie * length bytes, SHA256_DIGEST_LENGTH bytes for the HMAC of the whole thing. / #define MAX_COOKIE_SIZE (2 + 2 + 2 + 2 + 2 + 1 + 8 + 2 + EVP_MAX_MD_SIZE + 1 \ + SSL_COOKIE_LENGTH + SHA256_DIGEST_LENGTH) / * Message header + 2 bytes for protocol version + number of random bytes + * + 1 byte for legacy session id length + number of bytes in legacy session id * + 2 bytes for ciphersuite + 1 byte for legacy compression * + 2 bytes for extension block length + 6 bytes for key_share extension * + 4 bytes for cookie extension header + the number of bytes in the cookie / #define MAX_HRR_SIZE (SSL3_HM_HEADER_LENGTH + 2 + SSL3_RANDOM_SIZE + 1 \ + SSL_MAX_SSL_SESSION_ID_LENGTH + 2 + 1 + 2 + 6 + 4 \ + MAX_COOKIE_SIZE) / * Parse the client's renegotiation binding and abort if it's not right / int tls_parse_ctos_renegotiate(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned int ilen; const unsigned char data; int ok; / Parse the length byte / if (!PACKET_get_1(pkt, &ilen) \|\| !PACKET_get_bytes(pkt, &data, ilen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RENEGOTIATION_ENCODING_ERR); return 0; } / Check that the extension matches / if (ilen != s->s3.previous_client_finished_len) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_RENEGOTIATION_MISMATCH); return 0; } ok = memcmp(data, s->s3.previous_client_finished, s->s3.previous_client_finished_len); #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if (ok) { if ((data[0] ^ s->s3.previous_client_finished[0]) != 0xFF) { ok = 0; } } #endif if (ok) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_RENEGOTIATION_MISMATCH); return 0; } s->s3.send_connection_binding = 1; return 1; } /- * The servername extension is treated as follows: * * - Only the hostname type is supported with a maximum length of 255. * - The servername is rejected if too long or if it contains zeros, * in which case an fatal alert is generated. * - The servername field is maintained together with the session cache. * - When a session is resumed, the servername call back invoked in order * to allow the application to position itself to the right context. * - The servername is acknowledged if it is new for a session or when * it is identical to a previously used for the same session. * Applications can control the behaviour. They can at any time * set a 'desirable' servername for a new SSL object. This can be the * case for example with HTTPS when a Host: header field is received and * a renegotiation is requested. In this case, a possible servername * presented in the new client hello is only acknowledged if it matches * the value of the Host: field. * - Applications must use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION * if they provide for changing an explicit servername context for the * session, i.e. when the session has been established with a servername * extension. * - On session reconnect, the servername extension may be absent. / int tls_parse_ctos_server_name(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned int servname_type; PACKET sni, hostname; if (!PACKET_as_length_prefixed_2(pkt, &sni) /* ServerNameList must be at least 1 byte long. / \|\| PACKET_remaining(&sni) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / * Although the intent was for server_name to be extensible, RFC 4366 * was not clear about it; and so OpenSSL among other implementations, * always and only allows a 'host_name' name types. * RFC 6066 corrected the mistake but adding new name types * is nevertheless no longer feasible, so act as if no other * SNI types can exist, to simplify parsing. * * Also note that the RFC permits only one SNI value per type, * i.e., we can only have a single hostname. / if (!PACKET_get_1(&sni, &servname_type) \|\| servname_type != TLSEXT_NAMETYPE_host_name \|\| !PACKET_as_length_prefixed_2(&sni, &hostname)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / * In TLSv1.2 and below the SNI is associated with the session. In TLSv1.3 * we always use the SNI value from the handshake. / if (!s->hit \|\| SSL_CONNECTION_IS_TLS13(s)) { if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) { SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME, SSL_R_BAD_EXTENSION); return 0; } if (PACKET_contains_zero_byte(&hostname)) { SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME, SSL_R_BAD_EXTENSION); return 0; } / * Store the requested SNI in the SSL as temporary storage. * If we accept it, it will get stored in the SSL_SESSION as well. / OPENSSL_free(s->ext.hostname); s->ext.hostname = NULL; if (!PACKET_strndup(&hostname, &s->ext.hostname)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->servername_done = 1; } else { / * In TLSv1.2 and below we should check if the SNI is consistent between * the initial handshake and the resumption. In TLSv1.3 SNI is not * associated with the session. / s->servername_done = (s->session->ext.hostname != NULL) && PACKET_equal(&hostname, s->session->ext.hostname, strlen(s->session->ext.hostname)); } return 1; } int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned int value; if (PACKET_remaining(pkt) != 1 \|\| !PACKET_get_1(pkt, &value)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* Received \|value\| should be a valid max-fragment-length code. / if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } / * RFC 6066: The negotiated length applies for the duration of the session * including session resumptions. * We should receive the same code as in resumed session ! / if (s->hit && s->session->ext.max_fragment_len_mode != value) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } / * Store it in session, so it'll become binding for us * and we'll include it in a next Server Hello. / s->session->ext.max_fragment_len_mode = value; return 1; } #ifndef OPENSSL_NO_SRP int tls_parse_ctos_srp(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET srp_I; if (!PACKET_as_length_prefixed_1(pkt, &srp_I) \|\| PACKET_contains_zero_byte(&srp_I)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } #endif int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET ec_point_format_list; if (!PACKET_as_length_prefixed_1(pkt, &ec_point_format_list) \|\| PACKET_remaining(&ec_point_format_list) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit) { if (!PACKET_memdup(&ec_point_format_list, &s->ext.peer_ecpointformats, &s->ext.peer_ecpointformats_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_parse_ctos_session_ticket(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->ext.session_ticket_cb && !s->ext.session_ticket_cb(SSL_CONNECTION_GET_SSL(s), PACKET_data(pkt), PACKET_remaining(pkt), s->ext.session_ticket_cb_arg)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION s, PACKET pkt, ossl_unused unsigned int context, ossl_unused X509 x, ossl_unused size_t chainidx) { PACKET supported_sig_algs; if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs) \|\| PACKET_remaining(&supported_sig_algs) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit && !tls1_save_sigalgs(s, &supported_sig_algs, 1)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } return 1; } int tls_parse_ctos_sig_algs(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET supported_sig_algs; if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs) \|\| PACKET_remaining(&supported_sig_algs) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit && !tls1_save_sigalgs(s, &supported_sig_algs, 0)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } return 1; } #ifndef OPENSSL_NO_OCSP int tls_parse_ctos_status_request(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET responder_id_list, exts; / We ignore this in a resumption handshake / if (s->hit) return 1; / Not defined if we get one of these in a client Certificate / if (x != NULL) return 1; if (!PACKET_get_1(pkt, (unsigned int )&s->ext.status_type)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) { /* * We don't know what to do with any other type so ignore it. / s->ext.status_type = TLSEXT_STATUSTYPE_nothing; return 1; } if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / * We remove any OCSP_RESPIDs from a previous handshake * to prevent unbounded memory growth - CVE-2016-6304 / sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free); if (PACKET_remaining(&responder_id_list) > 0) { s->ext.ocsp.ids = sk_OCSP_RESPID_new_null(); if (s->ext.ocsp.ids == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } } else { s->ext.ocsp.ids = NULL; } while (PACKET_remaining(&responder_id_list) > 0) { OCSP_RESPID id; PACKET responder_id; const unsigned char id_data; if (!PACKET_get_length_prefixed_2(&responder_id_list, &responder_id) \|\| PACKET_remaining(&responder_id) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } id_data = PACKET_data(&responder_id); id = d2i_OCSP_RESPID(NULL, &id_data, (int)PACKET_remaining(&responder_id)); if (id == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (id_data != PACKET_end(&responder_id)) { OCSP_RESPID_free(id); SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!sk_OCSP_RESPID_push(s->ext.ocsp.ids, id)) { OCSP_RESPID_free(id); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } / Read in request_extensions / if (!PACKET_as_length_prefixed_2(pkt, &exts)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (PACKET_remaining(&exts) > 0) { const unsigned char ext_data = PACKET_data(&exts); sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts, X509_EXTENSION_free); s->ext.ocsp.exts = d2i_X509_EXTENSIONS(NULL, &ext_data, (int)PACKET_remaining(&exts)); if (s->ext.ocsp.exts == NULL \|\| ext_data != PACKET_end(&exts)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } } return 1; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG int tls_parse_ctos_npn(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { / * We shouldn't accept this extension on a * renegotiation. / if (SSL_IS_FIRST_HANDSHAKE(s)) s->s3.npn_seen = 1; return 1; } #endif / * Save the ALPN extension in a ClientHello.\|pkt\| holds the contents of the ALPN * extension, not including type and length. Returns: 1 on success, 0 on error. / int tls_parse_ctos_alpn(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET protocol_list, save_protocol_list, protocol; if (!SSL_IS_FIRST_HANDSHAKE(s)) return 1; if (!PACKET_as_length_prefixed_2(pkt, &protocol_list) \|\| PACKET_remaining(&protocol_list) < 2) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } save_protocol_list = protocol_list; do { /* Protocol names can't be empty. / if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol) \|\| PACKET_remaining(&protocol) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } } while (PACKET_remaining(&protocol_list) != 0); OPENSSL_free(s->s3.alpn_proposed); s->s3.alpn_proposed = NULL; s->s3.alpn_proposed_len = 0; if (!PACKET_memdup(&save_protocol_list, &s->s3.alpn_proposed, &s->s3.alpn_proposed_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } #ifndef OPENSSL_NO_SRTP int tls_parse_ctos_use_srtp(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { STACK_OF(SRTP_PROTECTION_PROFILE) srvr; unsigned int ct, mki_len, id; int i, srtp_pref; PACKET subpkt; SSL ssl = SSL_CONNECTION_GET_SSL(s); /* Ignore this if we have no SRTP profiles / if (SSL_get_srtp_profiles(ssl) == NULL) return 1; / Pull off the length of the cipher suite list and check it is even / if (!PACKET_get_net_2(pkt, &ct) \|\| (ct & 1) != 0 \|\| !PACKET_get_sub_packet(pkt, &subpkt, ct)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } srvr = SSL_get_srtp_profiles(ssl); s->srtp_profile = NULL; / Search all profiles for a match initially / srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr); while (PACKET_remaining(&subpkt)) { if (!PACKET_get_net_2(&subpkt, &id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } / * Only look for match in profiles of higher preference than * current match. * If no profiles have been have been configured then this * does nothing. / for (i = 0; i < srtp_pref; i++) { SRTP_PROTECTION_PROFILE sprof = sk_SRTP_PROTECTION_PROFILE_value(srvr, i); if (sprof->id == id) { s->srtp_profile = sprof; srtp_pref = i; break; } } } /* Now extract the MKI value as a sanity check, but discard it for now / if (!PACKET_get_1(pkt, &mki_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } if (!PACKET_forward(pkt, mki_len) \|\| PACKET_remaining(pkt)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_MKI_VALUE); return 0; } return 1; } #endif int tls_parse_ctos_etm(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) s->ext.use_etm = 1; return 1; } /* * Process a psk_kex_modes extension received in the ClientHello. \|pkt\| contains * the raw PACKET data for the extension. Returns 1 on success or 0 on failure. / int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 PACKET psk_kex_modes; unsigned int mode; if (!PACKET_as_length_prefixed_1(pkt, &psk_kex_modes) \|\| PACKET_remaining(&psk_kex_modes) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } while (PACKET_get_1(&psk_kex_modes, &mode)) { if (mode == TLSEXT_KEX_MODE_KE_DHE) s->ext.psk_kex_mode \|= TLSEXT_KEX_MODE_FLAG_KE_DHE; else if (mode == TLSEXT_KEX_MODE_KE && (s->options & SSL_OP_ALLOW_NO_DHE_KEX) != 0) s->ext.psk_kex_mode \|= TLSEXT_KEX_MODE_FLAG_KE; } if (((s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) != 0) && (s->options & SSL_OP_PREFER_NO_DHE_KEX) != 0) { /* * If NO_DHE is supported and preferred, then we only remember this * mode. DHE PSK will not be used for sure, because in any case where * it would be supported (i.e. if a key share is present), NO_DHE would * be supported as well. As the latter is preferred it would be * chosen. By removing DHE PSK here, we don't have to deal with the * SSL_OP_PREFER_NO_DHE_KEX option in any other place. / s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_KE; } #endif return 1; } / * Process a key_share extension received in the ClientHello. \|pkt\| contains * the raw PACKET data for the extension. Returns 1 on success or 0 on failure. / int tls_parse_ctos_key_share(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned int group_id; PACKET key_share_list, encoded_pt; const uint16_t clntgroups, srvrgroups; size_t clnt_num_groups, srvr_num_groups; int found = 0; if (s->hit && (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) == 0) return 1; /* Sanity check / if (s->s3.peer_tmp != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } / Get our list of supported groups / tls1_get_supported_groups(s, &srvrgroups, &srvr_num_groups); / Get the clients list of supported groups. / tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups); if (clnt_num_groups == 0) { / * This can only happen if the supported_groups extension was not sent, * because we verify that the length is non-zero when we process that * extension. / SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION); return 0; } if (s->s3.group_id != 0 && PACKET_remaining(&key_share_list) == 0) { / * If we set a group_id already, then we must have sent an HRR * requesting a new key_share. If we haven't got one then that is an * error / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } while (PACKET_remaining(&key_share_list) > 0) { if (!PACKET_get_net_2(&key_share_list, &group_id) \|\| !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt) \|\| PACKET_remaining(&encoded_pt) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } / * If we already found a suitable key_share we loop through the * rest to verify the structure, but don't process them. / if (found) continue; / * If we sent an HRR then the key_share sent back MUST be for the group * we requested, and must be the only key_share sent. / if (s->s3.group_id != 0 && (group_id != s->s3.group_id \|\| PACKET_remaining(&key_share_list) != 0)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } / Check if this share is in supported_groups sent from client / if (!check_in_list(s, group_id, clntgroups, clnt_num_groups, 0)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } / Check if this share is for a group we can use / if (!check_in_list(s, group_id, srvrgroups, srvr_num_groups, 1) \|\| !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED) / * We tolerate but ignore a group id that we don't think is * suitable for TLSv1.3 / \|\| !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION, 0, NULL)) { / Share not suitable / continue; } s->s3.group_id = group_id; / Cache the selected group ID in the SSL_SESSION / s->session->kex_group = group_id; if ((s->s3.peer_tmp = ssl_generate_param_group(s, group_id)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS); return 0; } if (tls13_set_encoded_pub_key(s->s3.peer_tmp, PACKET_data(&encoded_pt), PACKET_remaining(&encoded_pt)) <= 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT); return 0; } found = 1; } #endif return 1; } int tls_parse_ctos_cookie(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned int format, version, key_share, group_id; EVP_MD_CTX hctx; EVP_PKEY pkey; PACKET cookie, raw, chhash, appcookie; WPACKET hrrpkt; const unsigned char data, mdin, ciphdata; unsigned char hmac[SHA256_DIGEST_LENGTH]; unsigned char hrr[MAX_HRR_SIZE]; size_t rawlen, hmaclen, hrrlen, ciphlen; uint64_t tm, now; SSL ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); / Ignore any cookie if we're not set up to verify it / if (sctx->verify_stateless_cookie_cb == NULL \|\| (s->s3.flags & TLS1_FLAGS_STATELESS) == 0) return 1; if (!PACKET_as_length_prefixed_2(pkt, &cookie)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } raw = cookie; data = PACKET_data(&raw); rawlen = PACKET_remaining(&raw); if (rawlen < SHA256_DIGEST_LENGTH \|\| !PACKET_forward(&raw, rawlen - SHA256_DIGEST_LENGTH)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } mdin = PACKET_data(&raw); / Verify the HMAC of the cookie / hctx = EVP_MD_CTX_create(); pkey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC", sctx->propq, s->session_ctx->ext.cookie_hmac_key, sizeof(s->session_ctx->ext.cookie_hmac_key)); if (hctx == NULL \|\| pkey == NULL) { EVP_MD_CTX_free(hctx); EVP_PKEY_free(pkey); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } hmaclen = SHA256_DIGEST_LENGTH; if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", sctx->libctx, sctx->propq, pkey, NULL) <= 0 \|\| EVP_DigestSign(hctx, hmac, &hmaclen, data, rawlen - SHA256_DIGEST_LENGTH) <= 0 \|\| hmaclen != SHA256_DIGEST_LENGTH) { EVP_MD_CTX_free(hctx); EVP_PKEY_free(pkey); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } EVP_MD_CTX_free(hctx); EVP_PKEY_free(pkey); if (CRYPTO_memcmp(hmac, mdin, SHA256_DIGEST_LENGTH) != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COOKIE_MISMATCH); return 0; } if (!PACKET_get_net_2(&cookie, &format)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } / Check the cookie format is something we recognise. Ignore it if not / if (format != COOKIE_STATE_FORMAT_VERSION) return 1; / * The rest of these checks really shouldn't fail since we have verified the * HMAC above. / / Check the version number is sane / if (!PACKET_get_net_2(&cookie, &version)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (version != TLS1_3_VERSION) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_PROTOCOL_VERSION_NUMBER); return 0; } if (!PACKET_get_net_2(&cookie, &group_id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } ciphdata = PACKET_data(&cookie); if (!PACKET_forward(&cookie, 2)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (group_id != s->s3.group_id \|\| s->s3.tmp.new_cipher != ssl_get_cipher_by_char(s, ciphdata, 0)) { / * We chose a different cipher or group id this time around to what is * in the cookie. Something must have changed. / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_CIPHER); return 0; } if (!PACKET_get_1(&cookie, &key_share) \|\| !PACKET_get_net_8(&cookie, &tm) \|\| !PACKET_get_length_prefixed_2(&cookie, &chhash) \|\| !PACKET_get_length_prefixed_1(&cookie, &appcookie) \|\| PACKET_remaining(&cookie) != SHA256_DIGEST_LENGTH) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } / We tolerate a cookie age of up to 10 minutes (= 60 * 10 seconds) / now = time(NULL); if (tm > now \|\| (now - tm) > 600) { / Cookie is stale. Ignore it / return 1; } / Verify the app cookie / if (sctx->verify_stateless_cookie_cb(ssl, PACKET_data(&appcookie), PACKET_remaining(&appcookie)) == 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COOKIE_MISMATCH); return 0; } / * Reconstruct the HRR that we would have sent in response to the original * ClientHello so we can add it to the transcript hash. * Note: This won't work with custom HRR extensions / if (!WPACKET_init_static_len(&hrrpkt, hrr, sizeof(hrr), 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!WPACKET_put_bytes_u8(&hrrpkt, SSL3_MT_SERVER_HELLO) \|\| !WPACKET_start_sub_packet_u24(&hrrpkt) \|\| !WPACKET_put_bytes_u16(&hrrpkt, TLS1_2_VERSION) \|\| !WPACKET_memcpy(&hrrpkt, hrrrandom, SSL3_RANDOM_SIZE) \|\| !WPACKET_sub_memcpy_u8(&hrrpkt, s->tmp_session_id, s->tmp_session_id_len) \|\| !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, &hrrpkt, &ciphlen) \|\| !WPACKET_put_bytes_u8(&hrrpkt, 0) \|\| !WPACKET_start_sub_packet_u16(&hrrpkt)) { WPACKET_cleanup(&hrrpkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_supported_versions) \|\| !WPACKET_start_sub_packet_u16(&hrrpkt) \|\| !WPACKET_put_bytes_u16(&hrrpkt, s->version) \|\| !WPACKET_close(&hrrpkt)) { WPACKET_cleanup(&hrrpkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (key_share) { if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_key_share) \|\| !WPACKET_start_sub_packet_u16(&hrrpkt) \|\| !WPACKET_put_bytes_u16(&hrrpkt, s->s3.group_id) \|\| !WPACKET_close(&hrrpkt)) { WPACKET_cleanup(&hrrpkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_cookie) \|\| !WPACKET_start_sub_packet_u16(&hrrpkt) \|\| !WPACKET_sub_memcpy_u16(&hrrpkt, data, rawlen) \|\| !WPACKET_close(&hrrpkt) / cookie extension / \|\| !WPACKET_close(&hrrpkt) / extension block / \|\| !WPACKET_close(&hrrpkt) / message / \|\| !WPACKET_get_total_written(&hrrpkt, &hrrlen) \|\| !WPACKET_finish(&hrrpkt)) { WPACKET_cleanup(&hrrpkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / Reconstruct the transcript hash / if (!create_synthetic_message_hash(s, PACKET_data(&chhash), PACKET_remaining(&chhash), hrr, hrrlen)) { / SSLfatal() already called / return 0; } / Act as if this ClientHello came after a HelloRetryRequest / s->hello_retry_request = SSL_HRR_PENDING; s->ext.cookieok = 1; #endif return 1; } int tls_parse_ctos_supported_groups(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET supported_groups_list; /* Each group is 2 bytes and we must have at least 1. / if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list) \|\| PACKET_remaining(&supported_groups_list) == 0 \|\| (PACKET_remaining(&supported_groups_list) % 2) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit \|\| SSL_CONNECTION_IS_TLS13(s)) { OPENSSL_free(s->ext.peer_supportedgroups); s->ext.peer_supportedgroups = NULL; s->ext.peer_supportedgroups_len = 0; if (!tls1_save_u16(&supported_groups_list, &s->ext.peer_supportedgroups, &s->ext.peer_supportedgroups_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_parse_ctos_ems(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { /* The extension must always be empty / if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET) return 1; s->s3.flags \|= TLS1_FLAGS_RECEIVED_EXTMS; return 1; } int tls_parse_ctos_early_data(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (s->hello_retry_request != SSL_HRR_NONE) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); return 0; } return 1; } static SSL_TICKET_STATUS tls_get_stateful_ticket(SSL_CONNECTION s, PACKET tick, SSL_SESSION *sess) { SSL_SESSION tmpsess = NULL; s->ext.ticket_expected = 1; switch (PACKET_remaining(tick)) { case 0: return SSL_TICKET_EMPTY; case SSL_MAX_SSL_SESSION_ID_LENGTH: break; default: return SSL_TICKET_NO_DECRYPT; } tmpsess = lookup_sess_in_cache(s, PACKET_data(tick), SSL_MAX_SSL_SESSION_ID_LENGTH); if (tmpsess == NULL) return SSL_TICKET_NO_DECRYPT; sess = tmpsess; return SSL_TICKET_SUCCESS; } int tls_parse_ctos_psk(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET identities, binders, binder; size_t binderoffset, hashsize; SSL_SESSION sess = NULL; unsigned int id, i, ext = 0; const EVP_MD md = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); SSL ssl = SSL_CONNECTION_GET_SSL(s); /* * If we have no PSK kex mode that we recognise then we can't resume so * ignore this extension / if ((s->ext.psk_kex_mode & (TLSEXT_KEX_MODE_FLAG_KE \| TLSEXT_KEX_MODE_FLAG_KE_DHE)) == 0) return 1; if (!PACKET_get_length_prefixed_2(pkt, &identities)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } s->ext.ticket_expected = 0; for (id = 0; PACKET_remaining(&identities) != 0; id++) { PACKET identity; unsigned long ticket_agel; size_t idlen; if (!PACKET_get_length_prefixed_2(&identities, &identity) \|\| !PACKET_get_net_4(&identities, &ticket_agel)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } idlen = PACKET_remaining(&identity); if (s->psk_find_session_cb != NULL && !s->psk_find_session_cb(ssl, PACKET_data(&identity), idlen, &sess)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_EXTENSION); return 0; } #ifndef OPENSSL_NO_PSK if (sess == NULL && s->psk_server_callback != NULL && idlen <= PSK_MAX_IDENTITY_LEN) { char pskid = NULL; unsigned char pskdata[PSK_MAX_PSK_LEN]; unsigned int pskdatalen; if (!PACKET_strndup(&identity, &pskid)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pskdatalen = s->psk_server_callback(ssl, pskid, pskdata, sizeof(pskdata)); OPENSSL_free(pskid); if (pskdatalen > PSK_MAX_PSK_LEN) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } else if (pskdatalen > 0) { const SSL_CIPHER cipher; const unsigned char tls13_aes128gcmsha256_id[] = { 0x13, 0x01 }; / * We found a PSK using an old style callback. We don't know * the digest so we default to SHA256 as per the TLSv1.3 spec / cipher = SSL_CIPHER_find(ssl, tls13_aes128gcmsha256_id); if (cipher == NULL) { OPENSSL_cleanse(pskdata, pskdatalen); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } sess = SSL_SESSION_new(); if (sess == NULL \|\| !SSL_SESSION_set1_master_key(sess, pskdata, pskdatalen) \|\| !SSL_SESSION_set_cipher(sess, cipher) \|\| !SSL_SESSION_set_protocol_version(sess, TLS1_3_VERSION)) { OPENSSL_cleanse(pskdata, pskdatalen); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } OPENSSL_cleanse(pskdata, pskdatalen); } } #endif / OPENSSL_NO_PSK / if (sess != NULL) { / We found a PSK / SSL_SESSION sesstmp = ssl_session_dup(sess, 0); if (sesstmp == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } SSL_SESSION_free(sess); sess = sesstmp; /* * We've just been told to use this session for this context so * make sure the sid_ctx matches up. / memcpy(sess->sid_ctx, s->sid_ctx, s->sid_ctx_length); sess->sid_ctx_length = s->sid_ctx_length; ext = 1; if (id == 0) s->ext.early_data_ok = 1; s->ext.ticket_expected = 1; } else { OSSL_TIME t, age, expire; int ret; / * If we are using anti-replay protection then we behave as if * SSL_OP_NO_TICKET is set - we are caching tickets anyway so there * is no point in using full stateless tickets. / if ((s->options & SSL_OP_NO_TICKET) != 0 \|\| (s->max_early_data > 0 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0)) ret = tls_get_stateful_ticket(s, &identity, &sess); else ret = tls_decrypt_ticket(s, PACKET_data(&identity), PACKET_remaining(&identity), NULL, 0, &sess); if (ret == SSL_TICKET_EMPTY) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (ret == SSL_TICKET_FATAL_ERR_MALLOC \|\| ret == SSL_TICKET_FATAL_ERR_OTHER) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (ret == SSL_TICKET_NONE \|\| ret == SSL_TICKET_NO_DECRYPT) continue; / Check for replay / if (s->max_early_data > 0 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0 && !SSL_CTX_remove_session(s->session_ctx, sess)) { SSL_SESSION_free(sess); sess = NULL; continue; } age = ossl_time_subtract(ossl_ms2time(ticket_agel), ossl_ms2time(sess->ext.tick_age_add)); t = ossl_time_subtract(ossl_time_now(), sess->time); / * Although internally we use OSS_TIME which has ns granularity, * when SSL_SESSION structures are serialised/deserialised we use * second granularity for the sess->time field. Therefore it could * appear that the client's ticket age is longer than ours (our * ticket age calculation should always be slightly longer than the * client's due to the network latency). Therefore we add 1000ms to * our age calculation to adjust for rounding errors. / expire = ossl_time_add(t, ossl_ms2time(1000)); if (id == 0 && ossl_time_compare(sess->timeout, t) >= 0 && ossl_time_compare(age, expire) <= 0 && ossl_time_compare(ossl_time_add(age, TICKET_AGE_ALLOWANCE), expire) >= 0) { / * Ticket age is within tolerance and not expired. We allow it * for early data / s->ext.early_data_ok = 1; } } md = ssl_md(sctx, sess->cipher->algorithm2); if (md == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!EVP_MD_is_a(md, EVP_MD_get0_name(ssl_md(sctx, s->s3.tmp.new_cipher->algorithm2)))) { / The ciphersuite is not compatible with this session. / SSL_SESSION_free(sess); sess = NULL; s->ext.early_data_ok = 0; s->ext.ticket_expected = 0; continue; } break; } if (sess == NULL) return 1; binderoffset = PACKET_data(pkt) - (const unsigned char )s->init_buf->data; hashsize = EVP_MD_get_size(md); if (!PACKET_get_length_prefixed_2(pkt, &binders)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); goto err; } for (i = 0; i <= id; i++) { if (!PACKET_get_length_prefixed_1(&binders, &binder)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); goto err; } } if (PACKET_remaining(&binder) != hashsize) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); goto err; } if (tls_psk_do_binder(s, md, (const unsigned char )s->init_buf->data, binderoffset, PACKET_data(&binder), NULL, sess, 0, ext) != 1) { / SSLfatal() already called / goto err; } s->ext.tick_identity = id; SSL_SESSION_free(s->session); s->session = sess; return 1; err: SSL_SESSION_free(sess); return 0; } int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION s, PACKET pkt, ossl_unused unsigned int context, ossl_unused X509 x, ossl_unused size_t chainidx) { if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR); return 0; } s->post_handshake_auth = SSL_PHA_EXT_RECEIVED; return 1; } /* * Add the server's renegotiation binding / EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (!s->s3.send_connection_binding) return EXT_RETURN_NOT_SENT; /* Still add this even if SSL_OP_NO_RENEGOTIATION is set / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u8(pkt) \|\| !WPACKET_memcpy(pkt, s->s3.previous_client_finished, s->s3.previous_client_finished_len) \|\| !WPACKET_memcpy(pkt, s->s3.previous_server_finished, s->s3.previous_server_finished_len) \|\| !WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->servername_done != 1) return EXT_RETURN_NOT_SENT; /* * Prior to TLSv1.3 we ignore any SNI in the current handshake if resuming. * We just use the servername from the initial handshake. / if (s->hit && !SSL_CONNECTION_IS_TLS13(s)) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } / Add/include the server's max fragment len extension into ServerHello / EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (!USE_MAX_FRAGMENT_LENGTH_EXT(s->session)) return EXT_RETURN_NOT_SENT; /- 4 bytes for this extension type and extension length * 1 byte for the Max Fragment Length code value. / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u8(pkt, s->session->ext.max_fragment_len_mode) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey; unsigned long alg_a = s->s3.tmp.new_cipher->algorithm_auth; int using_ecc = ((alg_k & SSL_kECDHE) \|\| (alg_a & SSL_aECDSA)) && (s->ext.peer_ecpointformats != NULL); const unsigned char plist; size_t plistlen; if (!using_ecc) return EXT_RETURN_NOT_SENT; tls1_get_formatlist(s, &plist, &plistlen); if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_sub_memcpy_u8(pkt, plist, plistlen) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { const uint16_t groups; size_t numgroups, i, first = 1; int version; / s->s3.group_id is non zero if we accepted a key_share / if (s->s3.group_id == 0) return EXT_RETURN_NOT_SENT; / Get our list of supported groups / tls1_get_supported_groups(s, &groups, &numgroups); if (numgroups == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } / Copy group ID if supported / version = SSL_version(SSL_CONNECTION_GET_SSL(s)); for (i = 0; i < numgroups; i++) { uint16_t group = groups[i]; if (tls_valid_group(s, group, version, version, 0, NULL) && tls_group_allowed(s, group, SSL_SECOP_CURVE_SUPPORTED)) { if (first) { / * Check if the client is already using our preferred group. If * so we don't need to add this extension / if (s->s3.group_id == group) return EXT_RETURN_NOT_SENT; / Add extension header / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups) / Sub-packet for supported_groups extension / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } first = 0; } if (!WPACKET_put_bytes_u16(pkt, group)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } } if (!WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (!s->ext.ticket_expected \|\| !tls_use_ticket(s)) { s->ext.ticket_expected = 0; return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_OCSP EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { / We don't currently support this extension inside a CertificateRequest / if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) return EXT_RETURN_NOT_SENT; if (!s->ext.status_expected) return EXT_RETURN_NOT_SENT; if (SSL_CONNECTION_IS_TLS13(s) && chainidx != 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request) \|\| !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } / * In TLSv1.3 we include the certificate status itself. In <= TLSv1.2 we * send back an empty extension, with the certificate status appearing as a * separate message / if (SSL_CONNECTION_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt)) { / SSLfatal() already called / return EXT_RETURN_FAIL; } if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { const unsigned char npa; unsigned int npalen; int ret; int npn_seen = s->s3.npn_seen; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); s->s3.npn_seen = 0; if (!npn_seen \|\| sctx->ext.npn_advertised_cb == NULL) return EXT_RETURN_NOT_SENT; ret = sctx->ext.npn_advertised_cb(SSL_CONNECTION_GET_SSL(s), &npa, &npalen, sctx->ext.npn_advertised_cb_arg); if (ret == SSL_TLSEXT_ERR_OK) { if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg) \|\| !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->s3.npn_seen = 1; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->s3.alpn_selected == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_application_layer_protocol_negotiation) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_sub_memcpy_u8(pkt, s->s3.alpn_selected, s->s3.alpn_selected_len) \|\| !WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_SRTP EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->srtp_profile == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u16(pkt, 2) \|\| !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id) \|\| !WPACKET_put_bytes_u8(pkt, 0) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (!s->ext.use_etm) return EXT_RETURN_NOT_SENT; / * Don't use encrypt_then_mac if AEAD or RC4 might want to disable * for other cases too. / if (s->s3.tmp.new_cipher->algorithm_mac == SSL_AEAD \|\| s->s3.tmp.new_cipher->algorithm_enc == SSL_RC4 \|\| s->s3.tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT \|\| s->s3.tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12 \|\| s->s3.tmp.new_cipher->algorithm_enc == SSL_MAGMA \|\| s->s3.tmp.new_cipher->algorithm_enc == SSL_KUZNYECHIK) { s->ext.use_etm = 0; return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if ((s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (!ossl_assert(SSL_CONNECTION_IS_TLS13(s))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u16(pkt, s->version) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned char encodedPoint; size_t encoded_pt_len = 0; EVP_PKEY ckey = s->s3.peer_tmp, skey = NULL; const TLS_GROUP_INFO ginf = NULL; if (s->hello_retry_request == SSL_HRR_PENDING) { if (ckey != NULL) { /* Original key_share was acceptable so don't ask for another one / return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u16(pkt, s->s3.group_id) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } if (ckey == NULL) { / No key_share received from client - must be resuming / if (!s->hit \|\| !tls13_generate_handshake_secret(s, NULL, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_NOT_SENT; } if (s->hit && (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) == 0) { / * PSK ('hit') and explicitly not doing DHE. If the client sent the * DHE option, we take it by default, except if non-DHE would be * preferred by config, but this case would have been handled in * tls_parse_ctos_psk_kex_modes(). / return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u16(pkt, s->s3.group_id)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if ((ginf = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s), s->s3.group_id)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (!ginf->is_kem) { / Regular KEX / skey = ssl_generate_pkey(s, ckey); if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); return EXT_RETURN_FAIL; } / Generate encoding of server key / encoded_pt_len = EVP_PKEY_get1_encoded_public_key(skey, &encodedPoint); if (encoded_pt_len == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); EVP_PKEY_free(skey); return EXT_RETURN_FAIL; } if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_PKEY_free(skey); OPENSSL_free(encodedPoint); return EXT_RETURN_FAIL; } OPENSSL_free(encodedPoint); / * This causes the crypto state to be updated based on the derived keys / s->s3.tmp.pkey = skey; if (ssl_derive(s, skey, ckey, 1) == 0) { / SSLfatal() already called / return EXT_RETURN_FAIL; } } else { / KEM mode / unsigned char ct = NULL; size_t ctlen = 0; /* * This does not update the crypto state. * * The generated pms is stored in `s->s3.tmp.pms` to be later used via * ssl_gensecret(). / if (ssl_encapsulate(s, ckey, &ct, &ctlen, 0) == 0) { / SSLfatal() already called / return EXT_RETURN_FAIL; } if (ctlen == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); OPENSSL_free(ct); return EXT_RETURN_FAIL; } if (!WPACKET_sub_memcpy_u16(pkt, ct, ctlen) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); OPENSSL_free(ct); return EXT_RETURN_FAIL; } OPENSSL_free(ct); / * This causes the crypto state to be updated based on the generated pms / if (ssl_gensecret(s, s->s3.tmp.pms, s->s3.tmp.pmslen) == 0) { / SSLfatal() already called / return EXT_RETURN_FAIL; } } s->s3.did_kex = 1; return EXT_RETURN_SENT; #else return EXT_RETURN_FAIL; #endif } EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned char hashval1, hashval2, appcookie1, appcookie2, cookie; unsigned char hmac, hmac2; size_t startlen, ciphlen, totcookielen, hashlen, hmaclen, appcookielen; EVP_MD_CTX hctx; EVP_PKEY pkey; int ret = EXT_RETURN_FAIL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); SSL ssl = SSL_CONNECTION_GET_SSL(s); if ((s->s3.flags & TLS1_FLAGS_STATELESS) == 0) return EXT_RETURN_NOT_SENT; if (sctx->gen_stateless_cookie_cb == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_COOKIE_CALLBACK_SET); return EXT_RETURN_FAIL; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_get_total_written(pkt, &startlen) \|\| !WPACKET_reserve_bytes(pkt, MAX_COOKIE_SIZE, &cookie) \|\| !WPACKET_put_bytes_u16(pkt, COOKIE_STATE_FORMAT_VERSION) \|\| !WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION) \|\| !WPACKET_put_bytes_u16(pkt, s->s3.group_id) \|\| !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt, &ciphlen) / Is there a key_share extension present in this HRR? / \|\| !WPACKET_put_bytes_u8(pkt, s->s3.peer_tmp == NULL) \|\| !WPACKET_put_bytes_u64(pkt, time(NULL)) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &hashval1)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } / * Get the hash of the initial ClientHello. ssl_handshake_hash() operates * on raw buffers, so we first reserve sufficient bytes (above) and then * subsequently allocate them (below) / if (!ssl3_digest_cached_records(s, 0) \|\| !ssl_handshake_hash(s, hashval1, EVP_MAX_MD_SIZE, &hashlen)) { / SSLfatal() already called / return EXT_RETURN_FAIL; } if (!WPACKET_allocate_bytes(pkt, hashlen, &hashval2) \|\| !ossl_assert(hashval1 == hashval2) \|\| !WPACKET_close(pkt) \|\| !WPACKET_start_sub_packet_u8(pkt) \|\| !WPACKET_reserve_bytes(pkt, SSL_COOKIE_LENGTH, &appcookie1)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } / Generate the application cookie / if (sctx->gen_stateless_cookie_cb(ssl, appcookie1, &appcookielen) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COOKIE_GEN_CALLBACK_FAILURE); return EXT_RETURN_FAIL; } if (!WPACKET_allocate_bytes(pkt, appcookielen, &appcookie2) \|\| !ossl_assert(appcookie1 == appcookie2) \|\| !WPACKET_close(pkt) \|\| !WPACKET_get_total_written(pkt, &totcookielen) \|\| !WPACKET_reserve_bytes(pkt, SHA256_DIGEST_LENGTH, &hmac)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } hmaclen = SHA256_DIGEST_LENGTH; totcookielen -= startlen; if (!ossl_assert(totcookielen <= MAX_COOKIE_SIZE - SHA256_DIGEST_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } / HMAC the cookie / hctx = EVP_MD_CTX_create(); pkey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC", sctx->propq, s->session_ctx->ext.cookie_hmac_key, sizeof(s->session_ctx->ext.cookie_hmac_key)); if (hctx == NULL \|\| pkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", sctx->libctx, sctx->propq, pkey, NULL) <= 0 \|\| EVP_DigestSign(hctx, hmac, &hmaclen, cookie, totcookielen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!ossl_assert(totcookielen + hmaclen <= MAX_COOKIE_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!WPACKET_allocate_bytes(pkt, hmaclen, &hmac2) \|\| !ossl_assert(hmac == hmac2) \|\| !ossl_assert(cookie == hmac - totcookielen) \|\| !WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ret = EXT_RETURN_SENT; err: EVP_MD_CTX_free(hctx); EVP_PKEY_free(pkey); return ret; #else return EXT_RETURN_FAIL; #endif } EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { const unsigned char cryptopro_ext[36] = { 0xfd, 0xe8, /* 65000 / 0x00, 0x20, / 32 bytes length / 0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17 }; if (((s->s3.tmp.new_cipher->id & 0xFFFF) != 0x80 && (s->s3.tmp.new_cipher->id & 0xFFFF) != 0x81) \|\| (SSL_get_options(SSL_CONNECTION_GET_SSL(s)) & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) { if (s->max_early_data == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u32(pkt, s->max_early_data) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (!s->hit) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u16(pkt, s->ext.tick_identity) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (sc->ext.client_cert_type_ctos == OSSL_CERT_TYPE_CTOS_ERROR && (send_certificate_request(sc) \|\| sc->post_handshake_auth == SSL_PHA_EXT_RECEIVED)) { /* Did not receive an acceptable cert type - and doing client auth / SSLfatal(sc, SSL_AD_UNSUPPORTED_CERTIFICATE, SSL_R_BAD_EXTENSION); return EXT_RETURN_FAIL; } if (sc->ext.client_cert_type == TLSEXT_cert_type_x509) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; return EXT_RETURN_NOT_SENT; } / * Note: only supposed to send this if we are going to do a cert request, * but TLSv1.3 could do a PHA request if the client supports it / if ((!send_certificate_request(sc) && sc->post_handshake_auth != SSL_PHA_EXT_RECEIVED) \|\| sc->ext.client_cert_type_ctos != OSSL_CERT_TYPE_CTOS_GOOD \|\| sc->client_cert_type == NULL) { / if we don't send it, reset to TLSEXT_cert_type_x509 / sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.client_cert_type = TLSEXT_cert_type_x509; return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_client_cert_type) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u8(pkt, sc->ext.client_cert_type) \|\| !WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } / One of \|pref\|, \|other\| is configured and the values are sanitized / static int reconcile_cert_type(const unsigned char pref, size_t pref_len, const unsigned char other, size_t other_len, uint8_t chosen_cert_type) { size_t i; for (i = 0; i < pref_len; i++) { if (memchr(other, pref[i], other_len) != NULL) { chosen_cert_type = pref[i]; return OSSL_CERT_TYPE_CTOS_GOOD; } } return OSSL_CERT_TYPE_CTOS_ERROR; } int tls_parse_ctos_client_cert_type(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET supported_cert_types; const unsigned char data; size_t len; / Ignore the extension / if (sc->client_cert_type == NULL) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.client_cert_type = TLSEXT_cert_type_x509; return 1; } if (!PACKET_as_length_prefixed_1(pkt, &supported_cert_types)) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_ERROR; SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if ((len = PACKET_remaining(&supported_cert_types)) == 0) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_ERROR; SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_get_bytes(&supported_cert_types, &data, len)) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_ERROR; SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / client_cert_type: client (peer) has priority / sc->ext.client_cert_type_ctos = reconcile_cert_type(data, len, sc->client_cert_type, sc->client_cert_type_len, &sc->ext.client_cert_type); / Ignore the error until sending - so we can check cert auth/ return 1; } EXT_RETURN tls_construct_stoc_server_cert_type(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (sc->ext.server_cert_type == TLSEXT_cert_type_x509) { sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; return EXT_RETURN_NOT_SENT; } if (sc->ext.server_cert_type_ctos != OSSL_CERT_TYPE_CTOS_GOOD \|\| sc->server_cert_type == NULL) { /* if we don't send it, reset to TLSEXT_cert_type_x509 / sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.server_cert_type = TLSEXT_cert_type_x509; return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_cert_type) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u8(pkt, sc->ext.server_cert_type) \|\| !WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } int tls_parse_ctos_server_cert_type(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET supported_cert_types; const unsigned char data; size_t len; / Ignore the extension / if (sc->server_cert_type == NULL) { sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.server_cert_type = TLSEXT_cert_type_x509; return 1; } if (!PACKET_as_length_prefixed_1(pkt, &supported_cert_types)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if ((len = PACKET_remaining(&supported_cert_types)) == 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_get_bytes(&supported_cert_types, &data, len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / server_cert_type: server (this) has priority / sc->ext.server_cert_type_ctos = reconcile_cert_type(sc->server_cert_type, sc->server_cert_type_len, data, len, &sc->ext.server_cert_type); if (sc->ext.server_cert_type_ctos == OSSL_CERT_TYPE_CTOS_GOOD) return 1; / Did not receive an acceptable cert type */ SSLfatal(sc, SSL_AD_UNSUPPORTED_CERTIFICATE, SSL_R_BAD_EXTENSION); return 0; }
./openssl/ssl/statem/statem_local.h	/* * Copyright 2015-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / /**************************************************************************** * * * The following definitions are PRIVATE to the state machine. They should * * NOT be used outside of the state machine. * * * ****************************************************************************/ / Max message length definitions / / The spec allows for a longer length than this, but we limit it / #define HELLO_VERIFY_REQUEST_MAX_LENGTH 258 #define END_OF_EARLY_DATA_MAX_LENGTH 0 #define HELLO_RETRY_REQUEST_MAX_LENGTH 20000 #define ENCRYPTED_EXTENSIONS_MAX_LENGTH 20000 #define SESSION_TICKET_MAX_LENGTH_TLS13 131338 #define SESSION_TICKET_MAX_LENGTH_TLS12 65541 #define SERVER_KEY_EXCH_MAX_LENGTH 102400 #define SERVER_HELLO_DONE_MAX_LENGTH 0 #define KEY_UPDATE_MAX_LENGTH 1 #define CCS_MAX_LENGTH 1 / Max ServerHello size permitted by RFC 8446 / #define SERVER_HELLO_MAX_LENGTH 65607 / Max CertificateVerify size permitted by RFC 8446 / #define CERTIFICATE_VERIFY_MAX_LENGTH 65539 / Max should actually be 36 but we are generous / #define FINISHED_MAX_LENGTH 64 / Dummy message type / #define SSL3_MT_DUMMY -1 / Invalid extension ID for non-supported extensions / #define TLSEXT_TYPE_invalid 0x10000 #define TLSEXT_TYPE_out_of_range 0x10001 unsigned int ossl_get_extension_type(size_t idx); extern const unsigned char hrrrandom[]; / Message processing return codes / typedef enum { / Something bad happened / MSG_PROCESS_ERROR, / We've finished reading - swap to writing / MSG_PROCESS_FINISHED_READING, / * We've completed the main processing of this message but there is some * post processing to be done. / MSG_PROCESS_CONTINUE_PROCESSING, / We've finished this message - read the next message / MSG_PROCESS_CONTINUE_READING } MSG_PROCESS_RETURN; typedef CON_FUNC_RETURN (confunc_f) (SSL_CONNECTION s, WPACKET pkt); int ssl3_take_mac(SSL_CONNECTION s); int check_in_list(SSL_CONNECTION s, uint16_t group_id, const uint16_t groups, size_t num_groups, int checkallow); int create_synthetic_message_hash(SSL_CONNECTION s, const unsigned char hashval, size_t hashlen, const unsigned char hrr, size_t hrrlen); int parse_ca_names(SSL_CONNECTION s, PACKET pkt); const STACK_OF(X509_NAME) get_ca_names(SSL_CONNECTION s); int construct_ca_names(SSL_CONNECTION s, const STACK_OF(X509_NAME) ca_sk, WPACKET pkt); size_t construct_key_exchange_tbs(SSL_CONNECTION s, unsigned char *ptbs, const void param, size_t paramlen); /* * TLS/DTLS client state machine functions / int ossl_statem_client_read_transition(SSL_CONNECTION s, int mt); WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION s); WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION s, WORK_STATE wst); WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION s, WORK_STATE wst); int ossl_statem_client_construct_message(SSL_CONNECTION s, confunc_f confunc, int mt); size_t ossl_statem_client_max_message_size(SSL_CONNECTION s); MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION s, PACKET pkt); WORK_STATE ossl_statem_client_post_process_message(SSL_CONNECTION s, WORK_STATE wst); /* * TLS/DTLS server state machine functions / int ossl_statem_server_read_transition(SSL_CONNECTION s, int mt); WRITE_TRAN ossl_statem_server_write_transition(SSL_CONNECTION s); WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION s, WORK_STATE wst); WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION s, WORK_STATE wst); int ossl_statem_server_construct_message(SSL_CONNECTION s, confunc_f confunc,int mt); size_t ossl_statem_server_max_message_size(SSL_CONNECTION s); MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION s, PACKET pkt); WORK_STATE ossl_statem_server_post_process_message(SSL_CONNECTION s, WORK_STATE wst); /* Functions for getting new message data / __owur int tls_get_message_header(SSL_CONNECTION s, int mt); __owur int tls_get_message_body(SSL_CONNECTION s, size_t len); __owur int dtls_get_message(SSL_CONNECTION s, int mt); __owur int dtls_get_message_body(SSL_CONNECTION s, size_t len); / Message construction and processing functions / __owur int tls_process_initial_server_flight(SSL_CONNECTION s); __owur MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION s, PACKET pkt); __owur MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION s, PACKET pkt); __owur CON_FUNC_RETURN tls_construct_change_cipher_spec(SSL_CONNECTION s, WPACKET pkt); __owur CON_FUNC_RETURN dtls_construct_change_cipher_spec(SSL_CONNECTION s, WPACKET pkt); __owur CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION s, WPACKET pkt); __owur CON_FUNC_RETURN tls_construct_key_update(SSL_CONNECTION s, WPACKET pkt); __owur MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION s, PACKET pkt); __owur WORK_STATE tls_finish_handshake(SSL_CONNECTION s, WORK_STATE wst, int clearbufs, int stop); __owur WORK_STATE dtls_wait_for_dry(SSL_CONNECTION s); #ifndef OPENSSL_NO_COMP_ALG __owur MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION sc, PACKET pkt, PACKET tmppkt, BUF_MEM buf); #endif /* some client-only functions / __owur CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION s, WPACKET pkt); __owur MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION s, PACKET pkt); __owur MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION s, PACKET pkt); __owur MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION s, PACKET pkt); __owur int tls_process_cert_status_body(SSL_CONNECTION s, PACKET pkt); __owur MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION s, PACKET pkt); __owur MSG_PROCESS_RETURN tls_process_server_done(SSL_CONNECTION s, PACKET pkt); __owur CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION s, WPACKET pkt); __owur WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION s, WORK_STATE wst); __owur CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION s, WPACKET pkt); #ifndef OPENSSL_NO_COMP_ALG __owur CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION sc, WPACKET pkt); #endif __owur int ssl_do_client_cert_cb(SSL_CONNECTION s, X509 px509, EVP_PKEY ppkey); __owur CON_FUNC_RETURN tls_construct_client_key_exchange(SSL_CONNECTION s, WPACKET pkt); __owur int tls_client_key_exchange_post_work(SSL_CONNECTION s); __owur int tls_construct_cert_status_body(SSL_CONNECTION s, WPACKET pkt); __owur CON_FUNC_RETURN tls_construct_cert_status(SSL_CONNECTION s, WPACKET pkt); __owur MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION s, PACKET pkt); __owur MSG_PROCESS_RETURN tls_process_server_rpk(SSL_CONNECTION sc, PACKET pkt); __owur MSG_PROCESS_RETURN tls_process_client_rpk(SSL_CONNECTION sc, PACKET pkt); __owur unsigned long tls_output_rpk(SSL_CONNECTION sc, WPACKET pkt, CERT_PKEY cpk); __owur int tls_process_rpk(SSL_CONNECTION s, PACKET pkt, EVP_PKEY peer_rpk); __owur MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION s, PACKET pkt); __owur WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION s, WORK_STATE wst); #ifndef OPENSSL_NO_COMP_ALG __owur MSG_PROCESS_RETURN tls_process_server_compressed_certificate(SSL_CONNECTION sc, PACKET pkt); #endif __owur int ssl3_check_cert_and_algorithm(SSL_CONNECTION s); #ifndef OPENSSL_NO_NEXTPROTONEG __owur CON_FUNC_RETURN tls_construct_next_proto(SSL_CONNECTION s, WPACKET pkt); #endif __owur MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION s, PACKET pkt); __owur MSG_PROCESS_RETURN dtls_process_hello_verify(SSL_CONNECTION s, PACKET pkt); __owur CON_FUNC_RETURN tls_construct_end_of_early_data(SSL_CONNECTION s, WPACKET pkt); / some server-only functions / __owur MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION s, PACKET pkt); __owur WORK_STATE tls_post_process_client_hello(SSL_CONNECTION s, WORK_STATE wst); __owur CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION s, WPACKET pkt); __owur CON_FUNC_RETURN dtls_construct_hello_verify_request(SSL_CONNECTION s, WPACKET pkt); __owur CON_FUNC_RETURN tls_construct_server_certificate(SSL_CONNECTION s, WPACKET pkt); #ifndef OPENSSL_NO_COMP_ALG __owur CON_FUNC_RETURN tls_construct_server_compressed_certificate(SSL_CONNECTION sc, WPACKET pkt); #endif __owur CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION s, WPACKET pkt); __owur CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION s, WPACKET pkt); __owur CON_FUNC_RETURN tls_construct_server_done(SSL_CONNECTION s, WPACKET pkt); __owur MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION s, PACKET pkt); #ifndef OPENSSL_NO_COMP_ALG __owur MSG_PROCESS_RETURN tls_process_client_compressed_certificate(SSL_CONNECTION sc, PACKET pkt); #endif __owur MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION s, PACKET pkt); __owur WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION s, WORK_STATE wst); __owur MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION s, PACKET pkt); #ifndef OPENSSL_NO_NEXTPROTONEG __owur MSG_PROCESS_RETURN tls_process_next_proto(SSL_CONNECTION s, PACKET pkt); #endif __owur CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION s, WPACKET pkt); MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION s, PACKET pkt); #ifndef OPENSSL_NO_GOST / These functions are used in GOST18 CKE, both for client and server / int ossl_gost18_cke_cipher_nid(const SSL_CONNECTION s); int ossl_gost_ukm(const SSL_CONNECTION s, unsigned char dgst_buf); #endif /* Extension processing / typedef enum ext_return_en { EXT_RETURN_FAIL, EXT_RETURN_SENT, EXT_RETURN_NOT_SENT } EXT_RETURN; __owur int tls_validate_all_contexts(SSL_CONNECTION s, unsigned int thisctx, RAW_EXTENSION exts); __owur int extension_is_relevant(SSL_CONNECTION s, unsigned int extctx, unsigned int thisctx); __owur int tls_collect_extensions(SSL_CONNECTION s, PACKET packet, unsigned int context, RAW_EXTENSION *res, size_t len, int init); __owur int tls_parse_extension(SSL_CONNECTION s, TLSEXT_INDEX idx, int context, RAW_EXTENSION exts, X509 x, size_t chainidx); __owur int tls_parse_all_extensions(SSL_CONNECTION s, int context, RAW_EXTENSION exts, X509 x, size_t chainidx, int fin); __owur int should_add_extension(SSL_CONNECTION s, unsigned int extctx, unsigned int thisctx, int max_version); __owur int tls_construct_extensions(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); __owur int tls_psk_do_binder(SSL_CONNECTION s, const EVP_MD md, const unsigned char msgstart, size_t binderoffset, const unsigned char binderin, unsigned char binderout, SSL_SESSION sess, int sign, int external); /* Server Extension processing / int tls_parse_ctos_renegotiate(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_server_name(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_SRP int tls_parse_ctos_srp(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif int tls_parse_ctos_early_data(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_supported_groups(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidxl); int tls_parse_ctos_session_ticket(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_sig_algs(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_OCSP int tls_parse_ctos_status_request(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif #ifndef OPENSSL_NO_NEXTPROTONEG int tls_parse_ctos_npn(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif int tls_parse_ctos_alpn(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_SRTP int tls_parse_ctos_use_srtp(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif int tls_parse_ctos_etm(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_key_share(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_cookie(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_ems(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_psk(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION , PACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_OCSP EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif #ifndef OPENSSL_NO_NEXTPROTONEG EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_SRTP EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); /* * Not in public headers as this is not an official extension. Only used when * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set. / #define TLSEXT_TYPE_cryptopro_bug 0xfde8 EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); / Client Extension processing / EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_SRP EXT_RETURN tls_construct_ctos_srp(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_OCSP EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif #ifndef OPENSSL_NO_NEXTPROTONEG EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_SRTP EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_CT EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_renegotiate(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_server_name(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_early_data(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_session_ticket(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_OCSP int tls_parse_stoc_status_request(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif #ifndef OPENSSL_NO_CT int tls_parse_stoc_sct(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif #ifndef OPENSSL_NO_NEXTPROTONEG int tls_parse_stoc_npn(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif int tls_parse_stoc_alpn(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_SRTP int tls_parse_stoc_use_srtp(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #endif int tls_parse_stoc_etm(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_ems(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_supported_versions(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_key_share(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_cookie(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_psk(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_handle_alpn(SSL_CONNECTION s); int tls13_save_handshake_digest_for_pha(SSL_CONNECTION s); int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION s); __owur EVP_PKEY* tls_get_peer_pkey(const SSL_CONNECTION sc); / RFC7250 / EXT_RETURN tls_construct_ctos_client_cert_type(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_client_cert_type(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_client_cert_type(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_ctos_server_cert_type(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN tls_construct_stoc_server_cert_type(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_ctos_server_cert_type(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx); int tls_parse_stoc_server_cert_type(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 *x, size_t chainidx);
./openssl/ssl/statem/extensions_cust.c	/* * Copyright 2014-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / Custom extension utility functions / #include <openssl/ct.h> #include "../ssl_local.h" #include "internal/cryptlib.h" #include "statem_local.h" typedef struct { void add_arg; custom_ext_add_cb add_cb; custom_ext_free_cb free_cb; } custom_ext_add_cb_wrap; typedef struct { void parse_arg; custom_ext_parse_cb parse_cb; } custom_ext_parse_cb_wrap; / * Provide thin wrapper callbacks which convert new style arguments to old style / static int custom_ext_add_old_cb_wrap(SSL s, unsigned int ext_type, unsigned int context, const unsigned char *out, size_t outlen, X509 x, size_t chainidx, int al, void add_arg) { custom_ext_add_cb_wrap add_cb_wrap = (custom_ext_add_cb_wrap )add_arg; if (add_cb_wrap->add_cb == NULL) return 1; return add_cb_wrap->add_cb(s, ext_type, out, outlen, al, add_cb_wrap->add_arg); } static void custom_ext_free_old_cb_wrap(SSL s, unsigned int ext_type, unsigned int context, const unsigned char out, void add_arg) { custom_ext_add_cb_wrap add_cb_wrap = (custom_ext_add_cb_wrap )add_arg; if (add_cb_wrap->free_cb == NULL) return; add_cb_wrap->free_cb(s, ext_type, out, add_cb_wrap->add_arg); } static int custom_ext_parse_old_cb_wrap(SSL s, unsigned int ext_type, unsigned int context, const unsigned char in, size_t inlen, X509 x, size_t chainidx, int al, void parse_arg) { custom_ext_parse_cb_wrap parse_cb_wrap = (custom_ext_parse_cb_wrap )parse_arg; if (parse_cb_wrap->parse_cb == NULL) return 1; return parse_cb_wrap->parse_cb(s, ext_type, in, inlen, al, parse_cb_wrap->parse_arg); } / * Find a custom extension from the list. The \|role\| param is there to * support the legacy API where custom extensions for client and server could * be set independently on the same SSL_CTX. It is set to ENDPOINT_SERVER if we * are trying to find a method relevant to the server, ENDPOINT_CLIENT for the * client, or ENDPOINT_BOTH for either / custom_ext_method custom_ext_find(const custom_ext_methods exts, ENDPOINT role, unsigned int ext_type, size_t idx) { size_t i; custom_ext_method meth = exts->meths; for (i = 0; i < exts->meths_count; i++, meth++) { if (ext_type == meth->ext_type && (role == ENDPOINT_BOTH \|\| role == meth->role \|\| meth->role == ENDPOINT_BOTH)) { if (idx != NULL) idx = i; return meth; } } return NULL; } /* * Initialise custom extensions flags to indicate neither sent nor received. / void custom_ext_init(custom_ext_methods exts) { size_t i; custom_ext_method meth = exts->meths; for (i = 0; i < exts->meths_count; i++, meth++) meth->ext_flags = 0; } / Pass received custom extension data to the application for parsing. / int custom_ext_parse(SSL_CONNECTION s, unsigned int context, unsigned int ext_type, const unsigned char ext_data, size_t ext_size, X509 x, size_t chainidx) { int al = 0; custom_ext_methods exts = &s->cert->custext; custom_ext_method meth; ENDPOINT role = ENDPOINT_BOTH; if ((context & (SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO)) != 0) role = s->server ? ENDPOINT_SERVER : ENDPOINT_CLIENT; meth = custom_ext_find(exts, role, ext_type, NULL); /* If not found return success / if (!meth) return 1; / Check if extension is defined for our protocol. If not, skip / if (!extension_is_relevant(s, meth->context, context)) return 1; if ((context & (SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_SERVER_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS)) != 0) { / * If it's ServerHello or EncryptedExtensions we can't have any * extensions not sent in ClientHello. / if ((meth->ext_flags & SSL_EXT_FLAG_SENT) == 0) { SSLfatal(s, TLS1_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } } / * Extensions received in the ClientHello or CertificateRequest are marked * with the SSL_EXT_FLAG_RECEIVED. This is so we know to add the equivalent * extensions in the response messages / if ((context & (SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST)) != 0) meth->ext_flags \|= SSL_EXT_FLAG_RECEIVED; / If no parse function set return success / if (meth->parse_cb == NULL) return 1; if (meth->parse_cb(SSL_CONNECTION_GET_SSL(s), ext_type, context, ext_data, ext_size, x, chainidx, &al, meth->parse_arg) <= 0) { SSLfatal(s, al, SSL_R_BAD_EXTENSION); return 0; } return 1; } / * Request custom extension data from the application and add to the return * buffer. / int custom_ext_add(SSL_CONNECTION s, int context, WPACKET pkt, X509 x, size_t chainidx, int maxversion) { custom_ext_methods exts = &s->cert->custext; custom_ext_method meth; size_t i; int al; int for_comp = (context & SSL_EXT_TLS1_3_CERTIFICATE_COMPRESSION) != 0; for (i = 0; i < exts->meths_count; i++) { const unsigned char out = NULL; size_t outlen = 0; meth = exts->meths + i; if (!should_add_extension(s, meth->context, context, maxversion)) continue; if ((context & (SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_SERVER_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS \| SSL_EXT_TLS1_3_CERTIFICATE \| SSL_EXT_TLS1_3_RAW_PUBLIC_KEY \| SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST)) != 0) { / Only send extensions present in ClientHello/CertificateRequest / if (!(meth->ext_flags & SSL_EXT_FLAG_RECEIVED)) continue; } / * We skip it if the callback is absent - except for a ClientHello where * we add an empty extension. / if ((context & SSL_EXT_CLIENT_HELLO) == 0 && meth->add_cb == NULL) continue; if (meth->add_cb != NULL) { int cb_retval = meth->add_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context, &out, &outlen, x, chainidx, &al, meth->add_arg); if (cb_retval < 0) { if (!for_comp) SSLfatal(s, al, SSL_R_CALLBACK_FAILED); return 0; / error / } if (cb_retval == 0) continue; / skip this extension / } if (!WPACKET_put_bytes_u16(pkt, meth->ext_type) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| (outlen > 0 && !WPACKET_memcpy(pkt, out, outlen)) \|\| !WPACKET_close(pkt)) { if (meth->free_cb != NULL) meth->free_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context, out, meth->add_arg); if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((context & SSL_EXT_CLIENT_HELLO) != 0) { / * We can't send duplicates: code logic should prevent this. / if (!ossl_assert((meth->ext_flags & SSL_EXT_FLAG_SENT) == 0)) { if (meth->free_cb != NULL) meth->free_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context, out, meth->add_arg); if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / * Indicate extension has been sent: this is both a sanity check to * ensure we don't send duplicate extensions and indicates that it * is not an error if the extension is present in ServerHello. / meth->ext_flags \|= SSL_EXT_FLAG_SENT; } if (meth->free_cb != NULL) meth->free_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context, out, meth->add_arg); } return 1; } / Copy the flags from src to dst for any extensions that exist in both / int custom_exts_copy_flags(custom_ext_methods dst, const custom_ext_methods src) { size_t i; custom_ext_method methsrc = src->meths; for (i = 0; i < src->meths_count; i++, methsrc++) { custom_ext_method methdst = custom_ext_find(dst, methsrc->role, methsrc->ext_type, NULL); if (methdst == NULL) continue; methdst->ext_flags = methsrc->ext_flags; } return 1; } / Copy table of custom extensions / int custom_exts_copy(custom_ext_methods dst, const custom_ext_methods src) { size_t i; int err = 0; if (src->meths_count > 0) { dst->meths = OPENSSL_memdup(src->meths, sizeof(src->meths) * src->meths_count); if (dst->meths == NULL) return 0; dst->meths_count = src->meths_count; for (i = 0; i < src->meths_count; i++) { custom_ext_method methsrc = src->meths + i; custom_ext_method methdst = dst->meths + i; if (methsrc->add_cb != custom_ext_add_old_cb_wrap) continue; /* * We have found an old style API wrapper. We need to copy the * arguments too. / if (err) { methdst->add_arg = NULL; methdst->parse_arg = NULL; continue; } methdst->add_arg = OPENSSL_memdup(methsrc->add_arg, sizeof(custom_ext_add_cb_wrap)); methdst->parse_arg = OPENSSL_memdup(methsrc->parse_arg, sizeof(custom_ext_parse_cb_wrap)); if (methdst->add_arg == NULL \|\| methdst->parse_arg == NULL) err = 1; } } if (err) { custom_exts_free(dst); return 0; } return 1; } void custom_exts_free(custom_ext_methods exts) { size_t i; custom_ext_method meth; for (i = 0, meth = exts->meths; i < exts->meths_count; i++, meth++) { if (meth->add_cb != custom_ext_add_old_cb_wrap) continue; / Old style API wrapper. Need to free the arguments too / OPENSSL_free(meth->add_arg); OPENSSL_free(meth->parse_arg); } OPENSSL_free(exts->meths); exts->meths = NULL; exts->meths_count = 0; } / Return true if a client custom extension exists, false otherwise / int SSL_CTX_has_client_custom_ext(const SSL_CTX ctx, unsigned int ext_type) { return custom_ext_find(&ctx->cert->custext, ENDPOINT_CLIENT, ext_type, NULL) != NULL; } int ossl_tls_add_custom_ext_intern(SSL_CTX ctx, custom_ext_methods exts, ENDPOINT role, unsigned int ext_type, unsigned int context, SSL_custom_ext_add_cb_ex add_cb, SSL_custom_ext_free_cb_ex free_cb, void add_arg, SSL_custom_ext_parse_cb_ex parse_cb, void parse_arg) { custom_ext_method meth, tmp; /* * Check application error: if add_cb is not set free_cb will never be * called. / if (add_cb == NULL && free_cb != NULL) return 0; if (exts == NULL) exts = &ctx->cert->custext; #ifndef OPENSSL_NO_CT / * We don't want applications registering callbacks for SCT extensions * whilst simultaneously using the built-in SCT validation features, as * these two things may not play well together. / if (ext_type == TLSEXT_TYPE_signed_certificate_timestamp && (context & SSL_EXT_CLIENT_HELLO) != 0 && ctx != NULL && SSL_CTX_ct_is_enabled(ctx)) return 0; #endif / * Don't add if extension supported internally, but make exception * for extension types that previously were not supported, but now are. / if (SSL_extension_supported(ext_type) && ext_type != TLSEXT_TYPE_signed_certificate_timestamp) return 0; / Extension type must fit in 16 bits / if (ext_type > 0xffff) return 0; / Search for duplicate / if (custom_ext_find(exts, role, ext_type, NULL)) return 0; tmp = OPENSSL_realloc(exts->meths, (exts->meths_count + 1) sizeof(custom_ext_method)); if (tmp == NULL) return 0; exts->meths = tmp; meth = exts->meths + exts->meths_count; memset(meth, 0, sizeof(meth)); meth->role = role; meth->context = context; meth->parse_cb = parse_cb; meth->add_cb = add_cb; meth->free_cb = free_cb; meth->ext_type = ext_type; meth->add_arg = add_arg; meth->parse_arg = parse_arg; exts->meths_count++; return 1; } static int add_old_custom_ext(SSL_CTX ctx, ENDPOINT role, unsigned int ext_type, unsigned int context, custom_ext_add_cb add_cb, custom_ext_free_cb free_cb, void add_arg, custom_ext_parse_cb parse_cb, void parse_arg) { custom_ext_add_cb_wrap add_cb_wrap = OPENSSL_malloc(sizeof(add_cb_wrap)); custom_ext_parse_cb_wrap parse_cb_wrap = OPENSSL_malloc(sizeof(parse_cb_wrap)); int ret; if (add_cb_wrap == NULL \|\| parse_cb_wrap == NULL) { OPENSSL_free(add_cb_wrap); OPENSSL_free(parse_cb_wrap); return 0; } add_cb_wrap->add_arg = add_arg; add_cb_wrap->add_cb = add_cb; add_cb_wrap->free_cb = free_cb; parse_cb_wrap->parse_arg = parse_arg; parse_cb_wrap->parse_cb = parse_cb; ret = ossl_tls_add_custom_ext_intern(ctx, NULL, role, ext_type, context, custom_ext_add_old_cb_wrap, custom_ext_free_old_cb_wrap, add_cb_wrap, custom_ext_parse_old_cb_wrap, parse_cb_wrap); if (!ret) { OPENSSL_free(add_cb_wrap); OPENSSL_free(parse_cb_wrap); } return ret; } /* Application level functions to add the old custom extension callbacks / int SSL_CTX_add_client_custom_ext(SSL_CTX ctx, unsigned int ext_type, custom_ext_add_cb add_cb, custom_ext_free_cb free_cb, void add_arg, custom_ext_parse_cb parse_cb, void parse_arg) { return add_old_custom_ext(ctx, ENDPOINT_CLIENT, ext_type, SSL_EXT_TLS1_2_AND_BELOW_ONLY \| SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_IGNORE_ON_RESUMPTION, add_cb, free_cb, add_arg, parse_cb, parse_arg); } int SSL_CTX_add_server_custom_ext(SSL_CTX ctx, unsigned int ext_type, custom_ext_add_cb add_cb, custom_ext_free_cb free_cb, void add_arg, custom_ext_parse_cb parse_cb, void parse_arg) { return add_old_custom_ext(ctx, ENDPOINT_SERVER, ext_type, SSL_EXT_TLS1_2_AND_BELOW_ONLY \| SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_IGNORE_ON_RESUMPTION, add_cb, free_cb, add_arg, parse_cb, parse_arg); } int SSL_CTX_add_custom_ext(SSL_CTX ctx, unsigned int ext_type, unsigned int context, SSL_custom_ext_add_cb_ex add_cb, SSL_custom_ext_free_cb_ex free_cb, void add_arg, SSL_custom_ext_parse_cb_ex parse_cb, void parse_arg) { return ossl_tls_add_custom_ext_intern(ctx, NULL, ENDPOINT_BOTH, ext_type, context, add_cb, free_cb, add_arg, parse_cb, parse_arg); } int SSL_extension_supported(unsigned int ext_type) { switch (ext_type) { /* Internally supported extensions. */ case TLSEXT_TYPE_application_layer_protocol_negotiation: case TLSEXT_TYPE_ec_point_formats: case TLSEXT_TYPE_supported_groups: case TLSEXT_TYPE_key_share: #ifndef OPENSSL_NO_NEXTPROTONEG case TLSEXT_TYPE_next_proto_neg: #endif case TLSEXT_TYPE_padding: case TLSEXT_TYPE_renegotiate: case TLSEXT_TYPE_max_fragment_length: case TLSEXT_TYPE_server_name: case TLSEXT_TYPE_session_ticket: case TLSEXT_TYPE_signature_algorithms: #ifndef OPENSSL_NO_SRP case TLSEXT_TYPE_srp: #endif #ifndef OPENSSL_NO_OCSP case TLSEXT_TYPE_status_request: #endif #ifndef OPENSSL_NO_CT case TLSEXT_TYPE_signed_certificate_timestamp: #endif #ifndef OPENSSL_NO_SRTP case TLSEXT_TYPE_use_srtp: #endif case TLSEXT_TYPE_encrypt_then_mac: case TLSEXT_TYPE_supported_versions: case TLSEXT_TYPE_extended_master_secret: case TLSEXT_TYPE_psk_kex_modes: case TLSEXT_TYPE_cookie: case TLSEXT_TYPE_early_data: case TLSEXT_TYPE_certificate_authorities: case TLSEXT_TYPE_psk: case TLSEXT_TYPE_post_handshake_auth: case TLSEXT_TYPE_compress_certificate: case TLSEXT_TYPE_client_cert_type: case TLSEXT_TYPE_server_cert_type: return 1; default: return 0; } }
./openssl/ssl/statem/statem.c	/* * Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #if defined(__TANDEM) && defined(_SPT_MODEL_) # include <spthread.h> # include <spt_extensions.h> / timeval / #endif #include "internal/cryptlib.h" #include <openssl/rand.h> #include "../ssl_local.h" #include "statem_local.h" #include <assert.h> / * This file implements the SSL/TLS/DTLS state machines. * * There are two primary state machines: * * 1) Message flow state machine * 2) Handshake state machine * * The Message flow state machine controls the reading and sending of messages * including handling of non-blocking IO events, flushing of the underlying * write BIO, handling unexpected messages, etc. It is itself broken into two * separate sub-state machines which control reading and writing respectively. * * The Handshake state machine keeps track of the current SSL/TLS handshake * state. Transitions of the handshake state are the result of events that * occur within the Message flow state machine. * * Overall it looks like this: * * --------------------------------------------- ------------------- * \| \| \| \| * \| Message flow state machine \| \| \| * \| \| \| \| * \| -------------------- -------------------- \| Transition \| Handshake state \| * \| \| MSG_FLOW_READING \| \| MSG_FLOW_WRITING \| \| Event \| machine \| * \| \| sub-state \| \| sub-state \| \|----------->\| \| * \| \| machine for \| \| machine for \| \| \| \| * \| \| reading messages \| \| writing messages \| \| \| \| * \| -------------------- -------------------- \| \| \| * \| \| \| \| * --------------------------------------------- ------------------- * / / Sub state machine return values / typedef enum { / Something bad happened or NBIO / SUB_STATE_ERROR, / Sub state finished go to the next sub state / SUB_STATE_FINISHED, / Sub state finished and handshake was completed / SUB_STATE_END_HANDSHAKE } SUB_STATE_RETURN; static int state_machine(SSL_CONNECTION s, int server); static void init_read_state_machine(SSL_CONNECTION s); static SUB_STATE_RETURN read_state_machine(SSL_CONNECTION s); static void init_write_state_machine(SSL_CONNECTION s); static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION s); OSSL_HANDSHAKE_STATE SSL_get_state(const SSL ssl) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return TLS_ST_BEFORE; return sc->statem.hand_state; } int SSL_in_init(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->statem.in_init; } int SSL_is_init_finished(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return !(sc->statem.in_init) && (sc->statem.hand_state == TLS_ST_OK); } int SSL_in_before(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; /* * Historically being "in before" meant before anything had happened. In the * current code though we remain in the "before" state for a while after we * have started the handshake process (e.g. as a server waiting for the * first message to arrive). There "in before" is taken to mean "in before" * and not started any handshake process yet. / return (sc->statem.hand_state == TLS_ST_BEFORE) && (sc->statem.state == MSG_FLOW_UNINITED); } OSSL_HANDSHAKE_STATE ossl_statem_get_state(SSL_CONNECTION s) { return s != NULL ? s->statem.hand_state : TLS_ST_BEFORE; } /* * Clear the state machine state and reset back to MSG_FLOW_UNINITED / void ossl_statem_clear(SSL_CONNECTION s) { s->statem.state = MSG_FLOW_UNINITED; s->statem.hand_state = TLS_ST_BEFORE; ossl_statem_set_in_init(s, 1); s->statem.no_cert_verify = 0; } /* * Set the state machine up ready for a renegotiation handshake / void ossl_statem_set_renegotiate(SSL_CONNECTION s) { ossl_statem_set_in_init(s, 1); s->statem.request_state = TLS_ST_SW_HELLO_REQ; } void ossl_statem_send_fatal(SSL_CONNECTION s, int al) { / We shouldn't call SSLfatal() twice. Once is enough / if (s->statem.in_init && s->statem.state == MSG_FLOW_ERROR) return; ossl_statem_set_in_init(s, 1); s->statem.state = MSG_FLOW_ERROR; if (al != SSL_AD_NO_ALERT) ssl3_send_alert(s, SSL3_AL_FATAL, al); } / * Error reporting building block that's used instead of ERR_set_error(). * In addition to what ERR_set_error() does, this puts the state machine * into an error state and sends an alert if appropriate. * This is a permanent error for the current connection. / void ossl_statem_fatal(SSL_CONNECTION s, int al, int reason, const char fmt, ...) { va_list args; va_start(args, fmt); ERR_vset_error(ERR_LIB_SSL, reason, fmt, args); va_end(args); ossl_statem_send_fatal(s, al); } / * This macro should only be called if we are already expecting to be in * a fatal error state. We verify that we are, and set it if not (this would * indicate a bug). / #define check_fatal(s) \ do { \ if (!ossl_assert((s)->statem.in_init \ && (s)->statem.state == MSG_FLOW_ERROR)) \ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_FATAL); \ } while (0) / * Discover whether the current connection is in the error state. * * Valid return values are: * 1: Yes * 0: No / int ossl_statem_in_error(const SSL_CONNECTION s) { if (s->statem.state == MSG_FLOW_ERROR) return 1; return 0; } void ossl_statem_set_in_init(SSL_CONNECTION s, int init) { s->statem.in_init = init; if (s->rlayer.rrlmethod != NULL && s->rlayer.rrlmethod->set_in_init != NULL) s->rlayer.rrlmethod->set_in_init(s->rlayer.rrl, init); } int ossl_statem_get_in_handshake(SSL_CONNECTION s) { return s->statem.in_handshake; } void ossl_statem_set_in_handshake(SSL_CONNECTION s, int inhand) { if (inhand) s->statem.in_handshake++; else s->statem.in_handshake--; } / Are we in a sensible state to skip over unreadable early data? / int ossl_statem_skip_early_data(SSL_CONNECTION s) { if (s->ext.early_data != SSL_EARLY_DATA_REJECTED) return 0; if (!s->server \|\| s->statem.hand_state != TLS_ST_EARLY_DATA \|\| s->hello_retry_request == SSL_HRR_COMPLETE) return 0; return 1; } /* * Called when we are in SSL_read(), SSL_write(), or SSL_accept() * /SSL_connect()/SSL_do_handshake(). Used to test whether we are in an early * data state and whether we should attempt to move the handshake on if so. * \|sending\| is 1 if we are attempting to send data (SSL_write()), 0 if we are attempting to read data (SSL_read()), or -1 if we are in SSL_do_handshake() or similar. / void ossl_statem_check_finish_init(SSL_CONNECTION s, int sending) { if (sending == -1) { if (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END \|\| s->statem.hand_state == TLS_ST_EARLY_DATA) { ossl_statem_set_in_init(s, 1); if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY) { /* * SSL_connect() or SSL_do_handshake() has been called directly. * We don't allow any more writing of early data. / s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING; } } } else if (!s->server) { if ((sending && (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END \|\| s->statem.hand_state == TLS_ST_EARLY_DATA) && s->early_data_state != SSL_EARLY_DATA_WRITING) \|\| (!sending && s->statem.hand_state == TLS_ST_EARLY_DATA)) { ossl_statem_set_in_init(s, 1); / * SSL_write() has been called directly. We don't allow any more * writing of early data. / if (sending && s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY) s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING; } } else { if (s->early_data_state == SSL_EARLY_DATA_FINISHED_READING && s->statem.hand_state == TLS_ST_EARLY_DATA) ossl_statem_set_in_init(s, 1); } } void ossl_statem_set_hello_verify_done(SSL_CONNECTION s) { s->statem.state = MSG_FLOW_UNINITED; ossl_statem_set_in_init(s, 1); /* * This will get reset (briefly) back to TLS_ST_BEFORE when we enter * state_machine() because \|state\| is MSG_FLOW_UNINITED, but until then any * calls to SSL_in_before() will return false. Also calls to * SSL_state_string() and SSL_state_string_long() will return something * sensible. / s->statem.hand_state = TLS_ST_SR_CLNT_HELLO; } int ossl_statem_connect(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; return state_machine(sc, 0); } int ossl_statem_accept(SSL s) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; return state_machine(sc, 1); } typedef void (info_cb) (const SSL , int, int); static info_cb get_callback(SSL_CONNECTION s) { SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (s->info_callback != NULL) return s->info_callback; else if (sctx->info_callback != NULL) return sctx->info_callback; return NULL; } / * The main message flow state machine. We start in the MSG_FLOW_UNINITED or * MSG_FLOW_FINISHED state and finish in MSG_FLOW_FINISHED. Valid states and * transitions are as follows: * * MSG_FLOW_UNINITED MSG_FLOW_FINISHED * \| \| * +-----------------------+ * v * MSG_FLOW_WRITING <---> MSG_FLOW_READING * \| * V * MSG_FLOW_FINISHED * \| * V * [SUCCESS] * * We may exit at any point due to an error or NBIO event. If an NBIO event * occurs then we restart at the point we left off when we are recalled. * MSG_FLOW_WRITING and MSG_FLOW_READING have sub-state machines associated with them. * * In addition to the above there is also the MSG_FLOW_ERROR state. We can move * into that state at any point in the event that an irrecoverable error occurs. * * Valid return values are: * 1: Success * <=0: NBIO or error / static int state_machine(SSL_CONNECTION s, int server) { BUF_MEM buf = NULL; void (cb) (const SSL ssl, int type, int val) = NULL; OSSL_STATEM st = &s->statem; int ret = -1; int ssret; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (st->state == MSG_FLOW_ERROR) { / Shouldn't have been called if we're already in the error state / return -1; } ERR_clear_error(); clear_sys_error(); cb = get_callback(s); st->in_handshake++; if (!SSL_in_init(ssl) \|\| SSL_in_before(ssl)) { / * If we are stateless then we already called SSL_clear() - don't do * it again and clear the STATELESS flag itself. / if ((s->s3.flags & TLS1_FLAGS_STATELESS) == 0 && !SSL_clear(ssl)) return -1; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) { / * Notify SCTP BIO socket to enter handshake mode and prevent stream * identifier other than 0. / BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE, st->in_handshake, NULL); } #endif / Initialise state machine / if (st->state == MSG_FLOW_UNINITED \|\| st->state == MSG_FLOW_FINISHED) { if (st->state == MSG_FLOW_UNINITED) { st->hand_state = TLS_ST_BEFORE; st->request_state = TLS_ST_BEFORE; } s->server = server; if (cb != NULL) { if (SSL_IS_FIRST_HANDSHAKE(s) \|\| !SSL_CONNECTION_IS_TLS13(s)) cb(ssl, SSL_CB_HANDSHAKE_START, 1); } / * Fatal errors in this block don't send an alert because we have * failed to even initialise properly. Sending an alert is probably * doomed to failure. / if (SSL_CONNECTION_IS_DTLS(s)) { if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00) && (server \|\| (s->version & 0xff00) != (DTLS1_BAD_VER & 0xff00))) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } } else { if ((s->version >> 8) != SSL3_VERSION_MAJOR) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } } if (!ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL)) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } if (s->init_buf == NULL) { if ((buf = BUF_MEM_new()) == NULL) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } s->init_buf = buf; buf = NULL; } s->init_num = 0; / * Should have been reset by tls_process_finished, too. / s->s3.change_cipher_spec = 0; / * Ok, we now need to push on a buffering BIO ...but not with * SCTP / #ifndef OPENSSL_NO_SCTP if (!SSL_CONNECTION_IS_DTLS(s) \|\| !BIO_dgram_is_sctp(SSL_get_wbio(ssl))) #endif if (!ssl_init_wbio_buffer(s)) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } if ((SSL_in_before(ssl)) \|\| s->renegotiate) { if (!tls_setup_handshake(s)) { / SSLfatal() already called / goto end; } if (SSL_IS_FIRST_HANDSHAKE(s)) st->read_state_first_init = 1; } st->state = MSG_FLOW_WRITING; init_write_state_machine(s); } while (st->state != MSG_FLOW_FINISHED) { if (st->state == MSG_FLOW_READING) { ssret = read_state_machine(s); if (ssret == SUB_STATE_FINISHED) { st->state = MSG_FLOW_WRITING; init_write_state_machine(s); } else { / NBIO or error / goto end; } } else if (st->state == MSG_FLOW_WRITING) { ssret = write_state_machine(s); if (ssret == SUB_STATE_FINISHED) { st->state = MSG_FLOW_READING; init_read_state_machine(s); } else if (ssret == SUB_STATE_END_HANDSHAKE) { st->state = MSG_FLOW_FINISHED; } else { / NBIO or error / goto end; } } else { / Error / check_fatal(s); ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); goto end; } } ret = 1; end: st->in_handshake--; #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) { / * Notify SCTP BIO socket to leave handshake mode and allow stream * identifier other than 0. / BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE, st->in_handshake, NULL); } #endif BUF_MEM_free(buf); if (cb != NULL) { if (server) cb(ssl, SSL_CB_ACCEPT_EXIT, ret); else cb(ssl, SSL_CB_CONNECT_EXIT, ret); } return ret; } / * Initialise the MSG_FLOW_READING sub-state machine / static void init_read_state_machine(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; st->read_state = READ_STATE_HEADER; } static int grow_init_buf(SSL_CONNECTION s, size_t size) { size_t msg_offset = (char )s->init_msg - s->init_buf->data; if (!BUF_MEM_grow_clean(s->init_buf, (int)size)) return 0; if (size < msg_offset) return 0; s->init_msg = s->init_buf->data + msg_offset; return 1; } / * This function implements the sub-state machine when the message flow is in * MSG_FLOW_READING. The valid sub-states and transitions are: * * READ_STATE_HEADER <--+<-------------+ * \| \| \| * v \| \| * READ_STATE_BODY -----+-->READ_STATE_POST_PROCESS * \| \| * +----------------------------+ * v * [SUB_STATE_FINISHED] * * READ_STATE_HEADER has the responsibility for reading in the message header * and transitioning the state of the handshake state machine. * * READ_STATE_BODY reads in the rest of the message and then subsequently * processes it. * * READ_STATE_POST_PROCESS is an optional step that may occur if some post * processing activity performed on the message may block. * * Any of the above states could result in an NBIO event occurring in which case * control returns to the calling application. When this function is recalled we * will resume in the same state where we left off. / static SUB_STATE_RETURN read_state_machine(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; int ret, mt; size_t len = 0; int (transition) (SSL_CONNECTION s, int mt); PACKET pkt; MSG_PROCESS_RETURN(process_message) (SSL_CONNECTION s, PACKET pkt); WORK_STATE(post_process_message) (SSL_CONNECTION s, WORK_STATE wst); size_t (max_message_size) (SSL_CONNECTION s); void (cb) (const SSL ssl, int type, int val) = NULL; SSL ssl = SSL_CONNECTION_GET_SSL(s); cb = get_callback(s); if (s->server) { transition = ossl_statem_server_read_transition; process_message = ossl_statem_server_process_message; max_message_size = ossl_statem_server_max_message_size; post_process_message = ossl_statem_server_post_process_message; } else { transition = ossl_statem_client_read_transition; process_message = ossl_statem_client_process_message; max_message_size = ossl_statem_client_max_message_size; post_process_message = ossl_statem_client_post_process_message; } if (st->read_state_first_init) { s->first_packet = 1; st->read_state_first_init = 0; } while (1) { switch (st->read_state) { case READ_STATE_HEADER: / Get the state the peer wants to move to / if (SSL_CONNECTION_IS_DTLS(s)) { / * In DTLS we get the whole message in one go - header and body / ret = dtls_get_message(s, &mt); } else { ret = tls_get_message_header(s, &mt); } if (ret == 0) { / Could be non-blocking IO / return SUB_STATE_ERROR; } if (cb != NULL) { / Notify callback of an impending state change / if (s->server) cb(ssl, SSL_CB_ACCEPT_LOOP, 1); else cb(ssl, SSL_CB_CONNECT_LOOP, 1); } / * Validate that we are allowed to move to the new state and move * to that state if so / if (!transition(s, mt)) return SUB_STATE_ERROR; if (s->s3.tmp.message_size > max_message_size(s)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE); return SUB_STATE_ERROR; } / dtls_get_message already did this / if (!SSL_CONNECTION_IS_DTLS(s) && s->s3.tmp.message_size > 0 && !grow_init_buf(s, s->s3.tmp.message_size + SSL3_HM_HEADER_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BUF_LIB); return SUB_STATE_ERROR; } st->read_state = READ_STATE_BODY; / Fall through / case READ_STATE_BODY: if (SSL_CONNECTION_IS_DTLS(s)) { / * Actually we already have the body, but we give DTLS the * opportunity to do any further processing. / ret = dtls_get_message_body(s, &len); } else { ret = tls_get_message_body(s, &len); } if (ret == 0) { / Could be non-blocking IO / return SUB_STATE_ERROR; } s->first_packet = 0; if (!PACKET_buf_init(&pkt, s->init_msg, len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } ret = process_message(s, &pkt); / Discard the packet data / s->init_num = 0; switch (ret) { case MSG_PROCESS_ERROR: check_fatal(s); return SUB_STATE_ERROR; case MSG_PROCESS_FINISHED_READING: if (SSL_CONNECTION_IS_DTLS(s)) { dtls1_stop_timer(s); } return SUB_STATE_FINISHED; case MSG_PROCESS_CONTINUE_PROCESSING: st->read_state = READ_STATE_POST_PROCESS; st->read_state_work = WORK_MORE_A; break; default: st->read_state = READ_STATE_HEADER; break; } break; case READ_STATE_POST_PROCESS: st->read_state_work = post_process_message(s, st->read_state_work); switch (st->read_state_work) { case WORK_ERROR: check_fatal(s); / Fall through / case WORK_MORE_A: case WORK_MORE_B: case WORK_MORE_C: return SUB_STATE_ERROR; case WORK_FINISHED_CONTINUE: st->read_state = READ_STATE_HEADER; break; case WORK_FINISHED_STOP: if (SSL_CONNECTION_IS_DTLS(s)) { dtls1_stop_timer(s); } return SUB_STATE_FINISHED; } break; default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } } } / * Send a previously constructed message to the peer. / static int statem_do_write(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; if (st->hand_state == TLS_ST_CW_CHANGE \|\| st->hand_state == TLS_ST_SW_CHANGE) { if (SSL_CONNECTION_IS_DTLS(s)) return dtls1_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC); else return ssl3_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC); } else { return ssl_do_write(s); } } / * Initialise the MSG_FLOW_WRITING sub-state machine / static void init_write_state_machine(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; st->write_state = WRITE_STATE_TRANSITION; } / * This function implements the sub-state machine when the message flow is in * MSG_FLOW_WRITING. The valid sub-states and transitions are: * * +-> WRITE_STATE_TRANSITION ------> [SUB_STATE_FINISHED] * \| \| * \| v * \| WRITE_STATE_PRE_WORK -----> [SUB_STATE_END_HANDSHAKE] * \| \| * \| v * \| WRITE_STATE_SEND * \| \| * \| v * \| WRITE_STATE_POST_WORK * \| \| * +-------------+ * * WRITE_STATE_TRANSITION transitions the state of the handshake state machine * WRITE_STATE_PRE_WORK performs any work necessary to prepare the later * sending of the message. This could result in an NBIO event occurring in * which case control returns to the calling application. When this function * is recalled we will resume in the same state where we left off. * * WRITE_STATE_SEND sends the message and performs any work to be done after * sending. * * WRITE_STATE_POST_WORK performs any work necessary after the sending of the * message has been completed. As for WRITE_STATE_PRE_WORK this could also * result in an NBIO event. / static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; int ret; WRITE_TRAN(transition) (SSL_CONNECTION s); WORK_STATE(pre_work) (SSL_CONNECTION s, WORK_STATE wst); WORK_STATE(post_work) (SSL_CONNECTION s, WORK_STATE wst); int (get_construct_message_f) (SSL_CONNECTION s, CON_FUNC_RETURN (confunc) (SSL_CONNECTION s, WPACKET pkt), int mt); void (cb) (const SSL ssl, int type, int val) = NULL; CON_FUNC_RETURN (confunc) (SSL_CONNECTION s, WPACKET pkt); int mt; WPACKET pkt; SSL ssl = SSL_CONNECTION_GET_SSL(s); cb = get_callback(s); if (s->server) { transition = ossl_statem_server_write_transition; pre_work = ossl_statem_server_pre_work; post_work = ossl_statem_server_post_work; get_construct_message_f = ossl_statem_server_construct_message; } else { transition = ossl_statem_client_write_transition; pre_work = ossl_statem_client_pre_work; post_work = ossl_statem_client_post_work; get_construct_message_f = ossl_statem_client_construct_message; } while (1) { switch (st->write_state) { case WRITE_STATE_TRANSITION: if (cb != NULL) { /* Notify callback of an impending state change / if (s->server) cb(ssl, SSL_CB_ACCEPT_LOOP, 1); else cb(ssl, SSL_CB_CONNECT_LOOP, 1); } switch (transition(s)) { case WRITE_TRAN_CONTINUE: st->write_state = WRITE_STATE_PRE_WORK; st->write_state_work = WORK_MORE_A; break; case WRITE_TRAN_FINISHED: return SUB_STATE_FINISHED; break; case WRITE_TRAN_ERROR: check_fatal(s); return SUB_STATE_ERROR; } break; case WRITE_STATE_PRE_WORK: switch (st->write_state_work = pre_work(s, st->write_state_work)) { case WORK_ERROR: check_fatal(s); / Fall through / case WORK_MORE_A: case WORK_MORE_B: case WORK_MORE_C: return SUB_STATE_ERROR; case WORK_FINISHED_CONTINUE: st->write_state = WRITE_STATE_SEND; break; case WORK_FINISHED_STOP: return SUB_STATE_END_HANDSHAKE; } if (!get_construct_message_f(s, &confunc, &mt)) { / SSLfatal() already called / return SUB_STATE_ERROR; } if (mt == SSL3_MT_DUMMY) { / Skip construction and sending. This isn't a "real" state / st->write_state = WRITE_STATE_POST_WORK; st->write_state_work = WORK_MORE_A; break; } if (!WPACKET_init(&pkt, s->init_buf) \|\| !ssl_set_handshake_header(s, &pkt, mt)) { WPACKET_cleanup(&pkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } if (confunc != NULL) { CON_FUNC_RETURN tmpret; tmpret = confunc(s, &pkt); if (tmpret == CON_FUNC_ERROR) { WPACKET_cleanup(&pkt); check_fatal(s); return SUB_STATE_ERROR; } else if (tmpret == CON_FUNC_DONT_SEND) { / * The construction function decided not to construct the * message after all and continue. Skip sending. / WPACKET_cleanup(&pkt); st->write_state = WRITE_STATE_POST_WORK; st->write_state_work = WORK_MORE_A; break; } / else success / } if (!ssl_close_construct_packet(s, &pkt, mt) \|\| !WPACKET_finish(&pkt)) { WPACKET_cleanup(&pkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } / Fall through / case WRITE_STATE_SEND: if (SSL_CONNECTION_IS_DTLS(s) && st->use_timer) { dtls1_start_timer(s); } ret = statem_do_write(s); if (ret <= 0) { return SUB_STATE_ERROR; } st->write_state = WRITE_STATE_POST_WORK; st->write_state_work = WORK_MORE_A; / Fall through / case WRITE_STATE_POST_WORK: switch (st->write_state_work = post_work(s, st->write_state_work)) { case WORK_ERROR: check_fatal(s); / Fall through / case WORK_MORE_A: case WORK_MORE_B: case WORK_MORE_C: return SUB_STATE_ERROR; case WORK_FINISHED_CONTINUE: st->write_state = WRITE_STATE_TRANSITION; break; case WORK_FINISHED_STOP: return SUB_STATE_END_HANDSHAKE; } break; default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } } } / * Flush the write BIO / int statem_flush(SSL_CONNECTION s) { s->rwstate = SSL_WRITING; if (BIO_flush(s->wbio) <= 0) { return 0; } s->rwstate = SSL_NOTHING; return 1; } /* * Called by the record layer to determine whether application data is * allowed to be received in the current handshake state or not. * * Return values are: * 1: Yes (application data allowed) * 0: No (application data not allowed) / int ossl_statem_app_data_allowed(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; if (st->state == MSG_FLOW_UNINITED) return 0; if (!s->s3.in_read_app_data \|\| (s->s3.total_renegotiations == 0)) return 0; if (s->server) { / * If we're a server and we haven't got as far as writing our * ServerHello yet then we allow app data / if (st->hand_state == TLS_ST_BEFORE \|\| st->hand_state == TLS_ST_SR_CLNT_HELLO) return 1; } else { / * If we're a client and we haven't read the ServerHello yet then we * allow app data / if (st->hand_state == TLS_ST_CW_CLNT_HELLO) return 1; } return 0; } / * This function returns 1 if TLS exporter is ready to export keying * material, or 0 if otherwise. / int ossl_statem_export_allowed(SSL_CONNECTION s) { return s->s3.previous_server_finished_len != 0 && s->statem.hand_state != TLS_ST_SW_FINISHED; } /* * Return 1 if early TLS exporter is ready to export keying material, * or 0 if otherwise. / int ossl_statem_export_early_allowed(SSL_CONNECTION s) { /* * The early exporter secret is only present on the server if we * have accepted early_data. It is present on the client as long * as we have sent early_data. */ return s->ext.early_data == SSL_EARLY_DATA_ACCEPTED \|\| (!s->server && s->ext.early_data != SSL_EARLY_DATA_NOT_SENT); }
./openssl/ssl/statem/extensions.c	/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #if defined(__TANDEM) && defined(_SPT_MODEL_) # include <spthread.h> # include <spt_extensions.h> / timeval / #endif #include <string.h> #include "internal/nelem.h" #include "internal/cryptlib.h" #include "../ssl_local.h" #include "statem_local.h" static int final_renegotiate(SSL_CONNECTION s, unsigned int context, int sent); static int init_server_name(SSL_CONNECTION s, unsigned int context); static int final_server_name(SSL_CONNECTION s, unsigned int context, int sent); static int final_ec_pt_formats(SSL_CONNECTION s, unsigned int context, int sent); static int init_session_ticket(SSL_CONNECTION s, unsigned int context); #ifndef OPENSSL_NO_OCSP static int init_status_request(SSL_CONNECTION s, unsigned int context); #endif #ifndef OPENSSL_NO_NEXTPROTONEG static int init_npn(SSL_CONNECTION s, unsigned int context); #endif static int init_alpn(SSL_CONNECTION s, unsigned int context); static int final_alpn(SSL_CONNECTION s, unsigned int context, int sent); static int init_sig_algs_cert(SSL_CONNECTION s, unsigned int context); static int init_sig_algs(SSL_CONNECTION s, unsigned int context); static int init_server_cert_type(SSL_CONNECTION sc, unsigned int context); static int init_client_cert_type(SSL_CONNECTION sc, unsigned int context); static int init_certificate_authorities(SSL_CONNECTION s, unsigned int context); static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); static int tls_parse_certificate_authorities(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); #ifndef OPENSSL_NO_SRP static int init_srp(SSL_CONNECTION s, unsigned int context); #endif static int init_ec_point_formats(SSL_CONNECTION s, unsigned int context); static int init_etm(SSL_CONNECTION s, unsigned int context); static int init_ems(SSL_CONNECTION s, unsigned int context); static int final_ems(SSL_CONNECTION s, unsigned int context, int sent); static int init_psk_kex_modes(SSL_CONNECTION s, unsigned int context); static int final_key_share(SSL_CONNECTION s, unsigned int context, int sent); #ifndef OPENSSL_NO_SRTP static int init_srtp(SSL_CONNECTION s, unsigned int context); #endif static int final_sig_algs(SSL_CONNECTION s, unsigned int context, int sent); static int final_early_data(SSL_CONNECTION s, unsigned int context, int sent); static int final_maxfragmentlen(SSL_CONNECTION s, unsigned int context, int sent); static int init_post_handshake_auth(SSL_CONNECTION s, unsigned int context); static int final_psk(SSL_CONNECTION s, unsigned int context, int sent); static int tls_init_compress_certificate(SSL_CONNECTION sc, unsigned int context); static EXT_RETURN tls_construct_compress_certificate(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); static int tls_parse_compress_certificate(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx); / Structure to define a built-in extension / typedef struct extensions_definition_st { / The defined type for the extension / unsigned int type; / * The context that this extension applies to, e.g. what messages and * protocol versions / unsigned int context; / * Initialise extension before parsing. Always called for relevant contexts * even if extension not present / int (init)(SSL_CONNECTION s, unsigned int context); / Parse extension sent from client to server / int (parse_ctos)(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); / Parse extension send from server to client / int (parse_stoc)(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx); / Construct extension sent from server to client / EXT_RETURN (construct_stoc)(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); / Construct extension sent from client to server / EXT_RETURN (construct_ctos)(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); / * Finalise extension after parsing. Always called where an extensions was * initialised even if the extension was not present. \|sent\| is set to 1 if * the extension was seen, or 0 otherwise. / int (final)(SSL_CONNECTION s, unsigned int context, int sent); } EXTENSION_DEFINITION; / * Definitions of all built-in extensions. NOTE: Changes in the number or order * of these extensions should be mirrored with equivalent changes to the * indexes ( TLSEXT_IDX_* ) defined in ssl_local.h. * Extensions should be added to test/ext_internal_test.c as well, as that * tests the ordering of the extensions. * * Each extension has an initialiser, a client and * server side parser and a finaliser. The initialiser is called (if the * extension is relevant to the given context) even if we did not see the * extension in the message that we received. The parser functions are only * called if we see the extension in the message. The finalisers are always * called if the initialiser was called. * There are also server and client side constructor functions which are always * called during message construction if the extension is relevant for the * given context. * The initialisation, parsing, finalisation and construction functions are * always called in the order defined in this list. Some extensions may depend * on others having been processed first, so the order of this list is * significant. * The extension context is defined by a series of flags which specify which * messages the extension is relevant to. These flags also specify whether the * extension is relevant to a particular protocol or protocol version. * * NOTE: WebSphere Application Server 7+ cannot handle empty extensions at * the end, keep these extensions before signature_algorithm. / #define INVALID_EXTENSION { TLSEXT_TYPE_invalid, 0, NULL, NULL, NULL, NULL, NULL, NULL } static const EXTENSION_DEFINITION ext_defs[] = { { TLSEXT_TYPE_renegotiate, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_SSL3_ALLOWED \| SSL_EXT_TLS1_2_AND_BELOW_ONLY, NULL, tls_parse_ctos_renegotiate, tls_parse_stoc_renegotiate, tls_construct_stoc_renegotiate, tls_construct_ctos_renegotiate, final_renegotiate }, { TLSEXT_TYPE_server_name, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, init_server_name, tls_parse_ctos_server_name, tls_parse_stoc_server_name, tls_construct_stoc_server_name, tls_construct_ctos_server_name, final_server_name }, { TLSEXT_TYPE_max_fragment_length, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, NULL, tls_parse_ctos_maxfragmentlen, tls_parse_stoc_maxfragmentlen, tls_construct_stoc_maxfragmentlen, tls_construct_ctos_maxfragmentlen, final_maxfragmentlen }, #ifndef OPENSSL_NO_SRP { TLSEXT_TYPE_srp, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_srp, tls_parse_ctos_srp, NULL, NULL, tls_construct_ctos_srp, NULL }, #else INVALID_EXTENSION, #endif { TLSEXT_TYPE_ec_point_formats, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_ec_point_formats, tls_parse_ctos_ec_pt_formats, tls_parse_stoc_ec_pt_formats, tls_construct_stoc_ec_pt_formats, tls_construct_ctos_ec_pt_formats, final_ec_pt_formats }, { / * "supported_groups" is spread across several specifications. * It was originally specified as "elliptic_curves" in RFC 4492, * and broadened to include named FFDH groups by RFC 7919. * Both RFCs 4492 and 7919 do not include a provision for the server * to indicate to the client the complete list of groups supported * by the server, with the server instead just indicating the * selected group for this connection in the ServerKeyExchange * message. TLS 1.3 adds a scheme for the server to indicate * to the client its list of supported groups in the * EncryptedExtensions message, but none of the relevant * specifications permit sending supported_groups in the ServerHello. * Nonetheless (possibly due to the close proximity to the * "ec_point_formats" extension, which is allowed in the ServerHello), * there are several servers that send this extension in the * ServerHello anyway. Up to and including the 1.1.0 release, * we did not check for the presence of nonpermitted extensions, * so to avoid a regression, we must permit this extension in the * TLS 1.2 ServerHello as well. * * Note that there is no tls_parse_stoc_supported_groups function, * so we do not perform any additional parsing, validation, or * processing on the server's group list -- this is just a minimal * change to preserve compatibility with these misbehaving servers. / TLSEXT_TYPE_supported_groups, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS \| SSL_EXT_TLS1_2_SERVER_HELLO, NULL, tls_parse_ctos_supported_groups, NULL, tls_construct_stoc_supported_groups, tls_construct_ctos_supported_groups, NULL }, { TLSEXT_TYPE_session_ticket, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_session_ticket, tls_parse_ctos_session_ticket, tls_parse_stoc_session_ticket, tls_construct_stoc_session_ticket, tls_construct_ctos_session_ticket, NULL }, #ifndef OPENSSL_NO_OCSP { TLSEXT_TYPE_status_request, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, init_status_request, tls_parse_ctos_status_request, tls_parse_stoc_status_request, tls_construct_stoc_status_request, tls_construct_ctos_status_request, NULL }, #else INVALID_EXTENSION, #endif #ifndef OPENSSL_NO_NEXTPROTONEG { TLSEXT_TYPE_next_proto_neg, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_npn, tls_parse_ctos_npn, tls_parse_stoc_npn, tls_construct_stoc_next_proto_neg, tls_construct_ctos_npn, NULL }, #else INVALID_EXTENSION, #endif { / * Must appear in this list after server_name so that finalisation * happens after server_name callbacks / TLSEXT_TYPE_application_layer_protocol_negotiation, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, init_alpn, tls_parse_ctos_alpn, tls_parse_stoc_alpn, tls_construct_stoc_alpn, tls_construct_ctos_alpn, final_alpn }, #ifndef OPENSSL_NO_SRTP { TLSEXT_TYPE_use_srtp, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS \| SSL_EXT_DTLS_ONLY, init_srtp, tls_parse_ctos_use_srtp, tls_parse_stoc_use_srtp, tls_construct_stoc_use_srtp, tls_construct_ctos_use_srtp, NULL }, #else INVALID_EXTENSION, #endif { TLSEXT_TYPE_encrypt_then_mac, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_etm, tls_parse_ctos_etm, tls_parse_stoc_etm, tls_construct_stoc_etm, tls_construct_ctos_etm, NULL }, #ifndef OPENSSL_NO_CT { TLSEXT_TYPE_signed_certificate_timestamp, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, NULL, / * No server side support for this, but can be provided by a custom * extension. This is an exception to the rule that custom extensions * cannot override built in ones. / NULL, tls_parse_stoc_sct, NULL, tls_construct_ctos_sct, NULL }, #else INVALID_EXTENSION, #endif { TLSEXT_TYPE_extended_master_secret, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_ems, tls_parse_ctos_ems, tls_parse_stoc_ems, tls_construct_stoc_ems, tls_construct_ctos_ems, final_ems }, { TLSEXT_TYPE_signature_algorithms_cert, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, init_sig_algs_cert, tls_parse_ctos_sig_algs_cert, tls_parse_ctos_sig_algs_cert, / We do not generate signature_algorithms_cert at present. / NULL, NULL, NULL }, { TLSEXT_TYPE_post_handshake_auth, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_ONLY, init_post_handshake_auth, tls_parse_ctos_post_handshake_auth, NULL, NULL, tls_construct_ctos_post_handshake_auth, NULL, }, { TLSEXT_TYPE_client_cert_type, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS \| SSL_EXT_TLS1_2_SERVER_HELLO, init_client_cert_type, tls_parse_ctos_client_cert_type, tls_parse_stoc_client_cert_type, tls_construct_stoc_client_cert_type, tls_construct_ctos_client_cert_type, NULL }, { TLSEXT_TYPE_server_cert_type, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS \| SSL_EXT_TLS1_2_SERVER_HELLO, init_server_cert_type, tls_parse_ctos_server_cert_type, tls_parse_stoc_server_cert_type, tls_construct_stoc_server_cert_type, tls_construct_ctos_server_cert_type, NULL }, { TLSEXT_TYPE_signature_algorithms, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, init_sig_algs, tls_parse_ctos_sig_algs, tls_parse_ctos_sig_algs, tls_construct_ctos_sig_algs, tls_construct_ctos_sig_algs, final_sig_algs }, { TLSEXT_TYPE_supported_versions, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_SERVER_HELLO \| SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST \| SSL_EXT_TLS_IMPLEMENTATION_ONLY, NULL, / Processed inline as part of version selection / NULL, tls_parse_stoc_supported_versions, tls_construct_stoc_supported_versions, tls_construct_ctos_supported_versions, NULL }, { TLSEXT_TYPE_psk_kex_modes, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS_IMPLEMENTATION_ONLY \| SSL_EXT_TLS1_3_ONLY, init_psk_kex_modes, tls_parse_ctos_psk_kex_modes, NULL, NULL, tls_construct_ctos_psk_kex_modes, NULL }, { / * Must be in this list after supported_groups. We need that to have * been parsed before we do this one. / TLSEXT_TYPE_key_share, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_SERVER_HELLO \| SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST \| SSL_EXT_TLS_IMPLEMENTATION_ONLY \| SSL_EXT_TLS1_3_ONLY, NULL, tls_parse_ctos_key_share, tls_parse_stoc_key_share, tls_construct_stoc_key_share, tls_construct_ctos_key_share, final_key_share }, { / Must be after key_share / TLSEXT_TYPE_cookie, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST \| SSL_EXT_TLS_IMPLEMENTATION_ONLY \| SSL_EXT_TLS1_3_ONLY, NULL, tls_parse_ctos_cookie, tls_parse_stoc_cookie, tls_construct_stoc_cookie, tls_construct_ctos_cookie, NULL }, { / * Special unsolicited ServerHello extension only used when * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set. We allow it in a ClientHello but * ignore it. / TLSEXT_TYPE_cryptopro_bug, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_2_AND_BELOW_ONLY, NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL }, { TLSEXT_TYPE_compress_certificate, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST \| SSL_EXT_TLS_IMPLEMENTATION_ONLY \| SSL_EXT_TLS1_3_ONLY, tls_init_compress_certificate, tls_parse_compress_certificate, tls_parse_compress_certificate, tls_construct_compress_certificate, tls_construct_compress_certificate, NULL }, { TLSEXT_TYPE_early_data, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS \| SSL_EXT_TLS1_3_NEW_SESSION_TICKET \| SSL_EXT_TLS1_3_ONLY, NULL, tls_parse_ctos_early_data, tls_parse_stoc_early_data, tls_construct_stoc_early_data, tls_construct_ctos_early_data, final_early_data }, { TLSEXT_TYPE_certificate_authorities, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST \| SSL_EXT_TLS1_3_ONLY, init_certificate_authorities, tls_parse_certificate_authorities, tls_parse_certificate_authorities, tls_construct_certificate_authorities, tls_construct_certificate_authorities, NULL, }, { / Must be immediately before pre_shared_key / TLSEXT_TYPE_padding, SSL_EXT_CLIENT_HELLO, NULL, / We send this, but don't read it / NULL, NULL, NULL, tls_construct_ctos_padding, NULL }, { / Required by the TLSv1.3 spec to always be the last extension / TLSEXT_TYPE_psk, SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_SERVER_HELLO \| SSL_EXT_TLS_IMPLEMENTATION_ONLY \| SSL_EXT_TLS1_3_ONLY, NULL, tls_parse_ctos_psk, tls_parse_stoc_psk, tls_construct_stoc_psk, tls_construct_ctos_psk, final_psk } }; / Returns a TLSEXT_TYPE for the given index / unsigned int ossl_get_extension_type(size_t idx) { size_t num_exts = OSSL_NELEM(ext_defs); if (idx >= num_exts) return TLSEXT_TYPE_out_of_range; return ext_defs[idx].type; } / Check whether an extension's context matches the current context / static int validate_context(SSL_CONNECTION s, unsigned int extctx, unsigned int thisctx) { /* Check we're allowed to use this extension in this context / if ((thisctx & extctx) == 0) return 0; if (SSL_CONNECTION_IS_DTLS(s)) { if ((extctx & SSL_EXT_TLS_ONLY) != 0) return 0; } else if ((extctx & SSL_EXT_DTLS_ONLY) != 0) { return 0; } return 1; } int tls_validate_all_contexts(SSL_CONNECTION s, unsigned int thisctx, RAW_EXTENSION exts) { size_t i, num_exts, builtin_num = OSSL_NELEM(ext_defs), offset; RAW_EXTENSION thisext; unsigned int context; ENDPOINT role = ENDPOINT_BOTH; if ((thisctx & SSL_EXT_CLIENT_HELLO) != 0) role = ENDPOINT_SERVER; else if ((thisctx & SSL_EXT_TLS1_2_SERVER_HELLO) != 0) role = ENDPOINT_CLIENT; /* Calculate the number of extensions in the extensions list / num_exts = builtin_num + s->cert->custext.meths_count; for (thisext = exts, i = 0; i < num_exts; i++, thisext++) { if (!thisext->present) continue; if (i < builtin_num) { context = ext_defs[i].context; } else { custom_ext_method meth = NULL; meth = custom_ext_find(&s->cert->custext, role, thisext->type, &offset); if (!ossl_assert(meth != NULL)) return 0; context = meth->context; } if (!validate_context(s, context, thisctx)) return 0; } return 1; } /* * Verify whether we are allowed to use the extension \|type\| in the current * \|context\|. Returns 1 to indicate the extension is allowed or unknown or 0 to * indicate the extension is not allowed. If returning 1 then \|found\| is set to the definition for the extension we found. / static int verify_extension(SSL_CONNECTION s, unsigned int context, unsigned int type, custom_ext_methods meths, RAW_EXTENSION rawexlist, RAW_EXTENSION *found) { size_t i; size_t builtin_num = OSSL_NELEM(ext_defs); const EXTENSION_DEFINITION thisext; for (i = 0, thisext = ext_defs; i < builtin_num; i++, thisext++) { if (type == thisext->type) { if (!validate_context(s, thisext->context, context)) return 0; found = &rawexlist[i]; return 1; } } / Check the custom extensions / if (meths != NULL) { size_t offset = 0; ENDPOINT role = ENDPOINT_BOTH; custom_ext_method meth = NULL; if ((context & SSL_EXT_CLIENT_HELLO) != 0) role = ENDPOINT_SERVER; else if ((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0) role = ENDPOINT_CLIENT; meth = custom_ext_find(meths, role, type, &offset); if (meth != NULL) { if (!validate_context(s, meth->context, context)) return 0; found = &rawexlist[offset + builtin_num]; return 1; } } / Unknown extension. We allow it / found = NULL; return 1; } /* * Check whether the context defined for an extension \|extctx\| means whether * the extension is relevant for the current context \|thisctx\| or not. Returns * 1 if the extension is relevant for this context, and 0 otherwise / int extension_is_relevant(SSL_CONNECTION s, unsigned int extctx, unsigned int thisctx) { int is_tls13; /* * For HRR we haven't selected the version yet but we know it will be * TLSv1.3 / if ((thisctx & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) is_tls13 = 1; else is_tls13 = SSL_CONNECTION_IS_TLS13(s); if ((SSL_CONNECTION_IS_DTLS(s) && (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0) \|\| (s->version == SSL3_VERSION && (extctx & SSL_EXT_SSL3_ALLOWED) == 0) / * Note that SSL_IS_TLS13() means "TLS 1.3 has been negotiated", * which is never true when generating the ClientHello. * However, version negotiation has occurred by the time the * ClientHello extensions are being parsed. * Be careful to allow TLS 1.3-only extensions when generating * the ClientHello. / \|\| (is_tls13 && (extctx & SSL_EXT_TLS1_2_AND_BELOW_ONLY) != 0) \|\| (!is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0 && (thisctx & SSL_EXT_CLIENT_HELLO) == 0) \|\| (s->server && !is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0) \|\| (s->hit && (extctx & SSL_EXT_IGNORE_ON_RESUMPTION) != 0)) return 0; return 1; } / * Gather a list of all the extensions from the data in \|packet]. \|context\| * tells us which message this extension is for. The raw extension data is * stored in \|res\| on success. We don't actually process the content of the extensions yet, except to check their types. This function also runs the * initialiser functions for all known extensions if \|init\| is nonzero (whether * we have collected them or not). If successful the caller is responsible for * freeing the contents of \|res\|. * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be * more than one extension of the same type in a ClientHello or ServerHello. * This function returns 1 if all extensions are unique and we have parsed their * types, and 0 if the extensions contain duplicates, could not be successfully * found, or an internal error occurred. We only check duplicates for * extensions that we know about. We ignore others. / int tls_collect_extensions(SSL_CONNECTION s, PACKET packet, unsigned int context, RAW_EXTENSION res, size_t len, int init) { PACKET extensions = packet; size_t i = 0; size_t num_exts; custom_ext_methods exts = &s->cert->custext; RAW_EXTENSION raw_extensions = NULL; const EXTENSION_DEFINITION thisexd; res = NULL; / * Initialise server side custom extensions. Client side is done during * construction of extensions for the ClientHello. / if ((context & SSL_EXT_CLIENT_HELLO) != 0) custom_ext_init(&s->cert->custext); num_exts = OSSL_NELEM(ext_defs) + (exts != NULL ? exts->meths_count : 0); raw_extensions = OPENSSL_zalloc(num_exts sizeof(raw_extensions)); if (raw_extensions == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } i = 0; while (PACKET_remaining(&extensions) > 0) { unsigned int type, idx; PACKET extension; RAW_EXTENSION thisex; if (!PACKET_get_net_2(&extensions, &type) \|\| !PACKET_get_length_prefixed_2(&extensions, &extension)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); goto err; } /* * Verify this extension is allowed. We only check duplicates for * extensions that we recognise. We also have a special case for the * PSK extension, which must be the last one in the ClientHello. / if (!verify_extension(s, context, type, exts, raw_extensions, &thisex) \|\| (thisex != NULL && thisex->present == 1) \|\| (type == TLSEXT_TYPE_psk && (context & SSL_EXT_CLIENT_HELLO) != 0 && PACKET_remaining(&extensions) != 0)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); goto err; } idx = thisex - raw_extensions; /- * Check that we requested this extension (if appropriate). Requests can * be sent in the ClientHello and CertificateRequest. Unsolicited * extensions can be sent in the NewSessionTicket. We only do this for * the built-in extensions. Custom extensions have a different but * similar check elsewhere. * Special cases: * - The HRR cookie extension is unsolicited * - The renegotiate extension is unsolicited (the client signals * support via an SCSV) * - The signed_certificate_timestamp extension can be provided by a * custom extension or by the built-in version. We let the extension * itself handle unsolicited response checks. / if (idx < OSSL_NELEM(ext_defs) && (context & (SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST \| SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) == 0 && type != TLSEXT_TYPE_cookie && type != TLSEXT_TYPE_renegotiate && type != TLSEXT_TYPE_signed_certificate_timestamp && (s->ext.extflags[idx] & SSL_EXT_FLAG_SENT) == 0 #ifndef OPENSSL_NO_GOST && !((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0 && type == TLSEXT_TYPE_cryptopro_bug) #endif ) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_UNSOLICITED_EXTENSION); goto err; } if (thisex != NULL) { thisex->data = extension; thisex->present = 1; thisex->type = type; thisex->received_order = i++; if (s->ext.debug_cb) s->ext.debug_cb(SSL_CONNECTION_GET_SSL(s), !s->server, thisex->type, PACKET_data(&thisex->data), PACKET_remaining(&thisex->data), s->ext.debug_arg); } } if (init) { / * Initialise all known extensions relevant to this context, * whether we have found them or not / for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs); i++, thisexd++) { if (thisexd->init != NULL && (thisexd->context & context) != 0 && extension_is_relevant(s, thisexd->context, context) && !thisexd->init(s, context)) { / SSLfatal() already called / goto err; } } } res = raw_extensions; if (len != NULL) len = num_exts; return 1; err: OPENSSL_free(raw_extensions); return 0; } / * Runs the parser for a given extension with index \|idx\|. \|exts\| contains the * list of all parsed extensions previously collected by * tls_collect_extensions(). The parser is only run if it is applicable for the * given \|context\| and the parser has not already been run. If this is for a * Certificate message, then we also provide the parser with the relevant * Certificate \|x\| and its position in the \|chainidx\| with 0 being the first * Certificate. Returns 1 on success or 0 on failure. If an extension is not * present this counted as success. / int tls_parse_extension(SSL_CONNECTION s, TLSEXT_INDEX idx, int context, RAW_EXTENSION exts, X509 x, size_t chainidx) { RAW_EXTENSION currext = &exts[idx]; int (parser)(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) = NULL; / Skip if the extension is not present / if (!currext->present) return 1; / Skip if we've already parsed this extension / if (currext->parsed) return 1; currext->parsed = 1; if (idx < OSSL_NELEM(ext_defs)) { / We are handling a built-in extension / const EXTENSION_DEFINITION extdef = &ext_defs[idx]; /* Check if extension is defined for our protocol. If not, skip / if (!extension_is_relevant(s, extdef->context, context)) return 1; parser = s->server ? extdef->parse_ctos : extdef->parse_stoc; if (parser != NULL) return parser(s, &currext->data, context, x, chainidx); / * If the parser is NULL we fall through to the custom extension * processing / } / Parse custom extensions / return custom_ext_parse(s, context, currext->type, PACKET_data(&currext->data), PACKET_remaining(&currext->data), x, chainidx); } / * Parse all remaining extensions that have not yet been parsed. Also calls the * finalisation for all extensions at the end if \|fin\| is nonzero, whether we * collected them or not. Returns 1 for success or 0 for failure. If we are * working on a Certificate message then we also pass the Certificate \|x\| and * its position in the \|chainidx\|, with 0 being the first certificate. / int tls_parse_all_extensions(SSL_CONNECTION s, int context, RAW_EXTENSION exts, X509 x, size_t chainidx, int fin) { size_t i, numexts = OSSL_NELEM(ext_defs); const EXTENSION_DEFINITION thisexd; / Calculate the number of extensions in the extensions list / numexts += s->cert->custext.meths_count; / Parse each extension in turn / for (i = 0; i < numexts; i++) { if (!tls_parse_extension(s, i, context, exts, x, chainidx)) { / SSLfatal() already called / return 0; } } if (fin) { / * Finalise all known extensions relevant to this context, * whether we have found them or not / for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) { if (thisexd->final != NULL && (thisexd->context & context) != 0 && !thisexd->final(s, context, exts[i].present)) { / SSLfatal() already called / return 0; } } } return 1; } int should_add_extension(SSL_CONNECTION s, unsigned int extctx, unsigned int thisctx, int max_version) { /* Skip if not relevant for our context / if ((extctx & thisctx) == 0) return 0; / Check if this extension is defined for our protocol. If not, skip / if (!extension_is_relevant(s, extctx, thisctx) \|\| ((extctx & SSL_EXT_TLS1_3_ONLY) != 0 && (thisctx & SSL_EXT_CLIENT_HELLO) != 0 && (SSL_CONNECTION_IS_DTLS(s) \|\| max_version < TLS1_3_VERSION))) return 0; return 1; } / * Construct all the extensions relevant to the current \|context\| and write * them to \|pkt\|. If this is an extension for a Certificate in a Certificate * message, then \|x\| will be set to the Certificate we are handling, and * \|chainidx\| will indicate the position in the chainidx we are processing (with * 0 being the first in the chain). Returns 1 on success or 0 on failure. On a * failure construction stops at the first extension to fail to construct. / int tls_construct_extensions(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { size_t i; int min_version, max_version = 0, reason; const EXTENSION_DEFINITION thisexd; int for_comp = (context & SSL_EXT_TLS1_3_CERTIFICATE_COMPRESSION) != 0; if (!WPACKET_start_sub_packet_u16(pkt) / * If extensions are of zero length then we don't even add the * extensions length bytes to a ClientHello/ServerHello * (for non-TLSv1.3). / \|\| ((context & (SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_2_SERVER_HELLO)) != 0 && !WPACKET_set_flags(pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((context & SSL_EXT_CLIENT_HELLO) != 0) { reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); if (reason != 0) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); return 0; } } / Add custom extensions first / if ((context & SSL_EXT_CLIENT_HELLO) != 0) { / On the server side with initialise during ClientHello parsing / custom_ext_init(&s->cert->custext); } if (!custom_ext_add(s, context, pkt, x, chainidx, max_version)) { / SSLfatal() already called / return 0; } for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) { EXT_RETURN (construct)(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx); EXT_RETURN ret; / Skip if not relevant for our context / if (!should_add_extension(s, thisexd->context, context, max_version)) continue; construct = s->server ? thisexd->construct_stoc : thisexd->construct_ctos; if (construct == NULL) continue; ret = construct(s, pkt, context, x, chainidx); if (ret == EXT_RETURN_FAIL) { / SSLfatal() already called / return 0; } if (ret == EXT_RETURN_SENT && (context & (SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_CERTIFICATE_REQUEST \| SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) != 0) s->ext.extflags[i] \|= SSL_EXT_FLAG_SENT; } if (!WPACKET_close(pkt)) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } / * Built in extension finalisation and initialisation functions. All initialise * or finalise the associated extension type for the given \|context\|. For * finalisers \|sent\| is set to 1 if we saw the extension during parsing, and 0 * otherwise. These functions return 1 on success or 0 on failure. / static int final_renegotiate(SSL_CONNECTION s, unsigned int context, int sent) { if (!s->server) { /* * Check if we can connect to a server that doesn't support safe * renegotiation / if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT) && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) && !sent) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED); return 0; } return 1; } / Need RI if renegotiating / if (s->renegotiate && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) && !sent) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED); return 0; } return 1; } static ossl_inline void ssl_tsan_decr(const SSL_CTX ctx, TSAN_QUALIFIER int stat) { if (ssl_tsan_lock(ctx)) { tsan_decr(stat); ssl_tsan_unlock(ctx); } } static int init_server_name(SSL_CONNECTION s, unsigned int context) { if (s->server) { s->servername_done = 0; OPENSSL_free(s->ext.hostname); s->ext.hostname = NULL; } return 1; } static int final_server_name(SSL_CONNECTION s, unsigned int context, int sent) { int ret = SSL_TLSEXT_ERR_NOACK; int altmp = SSL_AD_UNRECOGNIZED_NAME; SSL ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); int was_ticket = (SSL_get_options(ssl) & SSL_OP_NO_TICKET) == 0; if (!ossl_assert(sctx != NULL) \|\| !ossl_assert(s->session_ctx != NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (sctx->ext.servername_cb != NULL) ret = sctx->ext.servername_cb(ssl, &altmp, sctx->ext.servername_arg); else if (s->session_ctx->ext.servername_cb != NULL) ret = s->session_ctx->ext.servername_cb(ssl, &altmp, s->session_ctx->ext.servername_arg); / * For servers, propagate the SNI hostname from the temporary * storage in the SSL to the persistent SSL_SESSION, now that we * know we accepted it. * Clients make this copy when parsing the server's response to * the extension, which is when they find out that the negotiation * was successful. / if (s->server) { if (sent && ret == SSL_TLSEXT_ERR_OK && !s->hit) { / Only store the hostname in the session if we accepted it. / OPENSSL_free(s->session->ext.hostname); s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname); if (s->session->ext.hostname == NULL && s->ext.hostname != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); } } } / * If we switched contexts (whether here or in the client_hello callback), * move the sess_accept increment from the session_ctx to the new * context, to avoid the confusing situation of having sess_accept_good * exceed sess_accept (zero) for the new context. / if (SSL_IS_FIRST_HANDSHAKE(s) && sctx != s->session_ctx && s->hello_retry_request == SSL_HRR_NONE) { ssl_tsan_counter(sctx, &sctx->stats.sess_accept); ssl_tsan_decr(s->session_ctx, &s->session_ctx->stats.sess_accept); } / * If we're expecting to send a ticket, and tickets were previously enabled, * and now tickets are disabled, then turn off expected ticket. * Also, if this is not a resumption, create a new session ID / if (ret == SSL_TLSEXT_ERR_OK && s->ext.ticket_expected && was_ticket && (SSL_get_options(ssl) & SSL_OP_NO_TICKET) != 0) { s->ext.ticket_expected = 0; if (!s->hit) { SSL_SESSION ss = SSL_get_session(ssl); if (ss != NULL) { OPENSSL_free(ss->ext.tick); ss->ext.tick = NULL; ss->ext.ticklen = 0; ss->ext.tick_lifetime_hint = 0; ss->ext.tick_age_add = 0; if (!ssl_generate_session_id(s, ss)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } else { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } switch (ret) { case SSL_TLSEXT_ERR_ALERT_FATAL: SSLfatal(s, altmp, SSL_R_CALLBACK_FAILED); return 0; case SSL_TLSEXT_ERR_ALERT_WARNING: /* TLSv1.3 doesn't have warning alerts so we suppress this / if (!SSL_CONNECTION_IS_TLS13(s)) ssl3_send_alert(s, SSL3_AL_WARNING, altmp); s->servername_done = 0; return 1; case SSL_TLSEXT_ERR_NOACK: s->servername_done = 0; return 1; default: return 1; } } static int final_ec_pt_formats(SSL_CONNECTION s, unsigned int context, int sent) { unsigned long alg_k, alg_a; if (s->server) return 1; alg_k = s->s3.tmp.new_cipher->algorithm_mkey; alg_a = s->s3.tmp.new_cipher->algorithm_auth; /* * If we are client and using an elliptic curve cryptography cipher * suite, then if server returns an EC point formats lists extension it * must contain uncompressed. / if (s->ext.ecpointformats != NULL && s->ext.ecpointformats_len > 0 && s->ext.peer_ecpointformats != NULL && s->ext.peer_ecpointformats_len > 0 && ((alg_k & SSL_kECDHE) \|\| (alg_a & SSL_aECDSA))) { / we are using an ECC cipher / size_t i; unsigned char list = s->ext.peer_ecpointformats; for (i = 0; i < s->ext.peer_ecpointformats_len; i++) { if (list++ == TLSEXT_ECPOINTFORMAT_uncompressed) break; } if (i == s->ext.peer_ecpointformats_len) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST); return 0; } } return 1; } static int init_session_ticket(SSL_CONNECTION s, unsigned int context) { if (!s->server) s->ext.ticket_expected = 0; return 1; } #ifndef OPENSSL_NO_OCSP static int init_status_request(SSL_CONNECTION s, unsigned int context) { if (s->server) { s->ext.status_type = TLSEXT_STATUSTYPE_nothing; } else { / * Ensure we get sensible values passed to tlsext_status_cb in the event * that we don't receive a status message / OPENSSL_free(s->ext.ocsp.resp); s->ext.ocsp.resp = NULL; s->ext.ocsp.resp_len = 0; } return 1; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG static int init_npn(SSL_CONNECTION s, unsigned int context) { s->s3.npn_seen = 0; return 1; } #endif static int init_alpn(SSL_CONNECTION s, unsigned int context) { OPENSSL_free(s->s3.alpn_selected); s->s3.alpn_selected = NULL; s->s3.alpn_selected_len = 0; if (s->server) { OPENSSL_free(s->s3.alpn_proposed); s->s3.alpn_proposed = NULL; s->s3.alpn_proposed_len = 0; } return 1; } static int final_alpn(SSL_CONNECTION s, unsigned int context, int sent) { if (!s->server && !sent && s->session->ext.alpn_selected != NULL) s->ext.early_data_ok = 0; if (!s->server \|\| !SSL_CONNECTION_IS_TLS13(s)) return 1; /* * Call alpn_select callback if needed. Has to be done after SNI and * cipher negotiation (HTTP/2 restricts permitted ciphers). In TLSv1.3 * we also have to do this before we decide whether to accept early_data. * In TLSv1.3 we've already negotiated our cipher so we do this call now. * For < TLSv1.3 we defer it until after cipher negotiation. * * On failure SSLfatal() already called. / return tls_handle_alpn(s); } static int init_sig_algs(SSL_CONNECTION s, unsigned int context) { /* Clear any signature algorithms extension received / OPENSSL_free(s->s3.tmp.peer_sigalgs); s->s3.tmp.peer_sigalgs = NULL; s->s3.tmp.peer_sigalgslen = 0; return 1; } static int init_sig_algs_cert(SSL_CONNECTION s, ossl_unused unsigned int context) { /* Clear any signature algorithms extension received / OPENSSL_free(s->s3.tmp.peer_cert_sigalgs); s->s3.tmp.peer_cert_sigalgs = NULL; s->s3.tmp.peer_cert_sigalgslen = 0; return 1; } #ifndef OPENSSL_NO_SRP static int init_srp(SSL_CONNECTION s, unsigned int context) { OPENSSL_free(s->srp_ctx.login); s->srp_ctx.login = NULL; return 1; } #endif static int init_ec_point_formats(SSL_CONNECTION s, unsigned int context) { OPENSSL_free(s->ext.peer_ecpointformats); s->ext.peer_ecpointformats = NULL; s->ext.peer_ecpointformats_len = 0; return 1; } static int init_etm(SSL_CONNECTION s, unsigned int context) { s->ext.use_etm = 0; return 1; } static int init_ems(SSL_CONNECTION s, unsigned int context) { if (s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) { s->s3.flags &= ~TLS1_FLAGS_RECEIVED_EXTMS; s->s3.flags \|= TLS1_FLAGS_REQUIRED_EXTMS; } return 1; } static int final_ems(SSL_CONNECTION s, unsigned int context, int sent) { /* * Check extended master secret extension is not dropped on * renegotiation. / if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) && (s->s3.flags & TLS1_FLAGS_REQUIRED_EXTMS)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_EXTMS); return 0; } if (!s->server && s->hit) { / * Check extended master secret extension is consistent with * original session. / if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) != !(s->session->flags & SSL_SESS_FLAG_EXTMS)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_EXTMS); return 0; } } return 1; } static int init_certificate_authorities(SSL_CONNECTION s, unsigned int context) { sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free); s->s3.tmp.peer_ca_names = NULL; return 1; } static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { const STACK_OF(X509_NAME) ca_sk = get_ca_names(s); if (ca_sk == NULL \|\| sk_X509_NAME_num(ca_sk) == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_certificate_authorities) \|\| !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (!construct_ca_names(s, ca_sk, pkt)) { /* SSLfatal() already called / return EXT_RETURN_FAIL; } if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } static int tls_parse_certificate_authorities(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (!parse_ca_names(s, pkt)) return 0; if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } return 1; } #ifndef OPENSSL_NO_SRTP static int init_srtp(SSL_CONNECTION s, unsigned int context) { if (s->server) s->srtp_profile = NULL; return 1; } #endif static int final_sig_algs(SSL_CONNECTION s, unsigned int context, int sent) { if (!sent && SSL_CONNECTION_IS_TLS13(s) && !s->hit) { SSLfatal(s, TLS13_AD_MISSING_EXTENSION, SSL_R_MISSING_SIGALGS_EXTENSION); return 0; } return 1; } static int final_key_share(SSL_CONNECTION s, unsigned int context, int sent) { #if !defined(OPENSSL_NO_TLS1_3) if (!SSL_CONNECTION_IS_TLS13(s)) return 1; / Nothing to do for key_share in an HRR / if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) return 1; / * If * we are a client * AND * we have no key_share * AND * (we are not resuming * OR the kex_mode doesn't allow non key_share resumes) * THEN * fail; / if (!s->server && !sent && (!s->hit \|\| (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0)) { / Nothing left we can do - just fail / SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_R_NO_SUITABLE_KEY_SHARE); return 0; } / * IF * we are a server * THEN * IF * we have a suitable key_share * THEN * IF * we are stateless AND we have no cookie * THEN * send a HelloRetryRequest * ELSE * IF * we didn't already send a HelloRetryRequest * AND * the client sent a key_share extension * AND * (we are not resuming * OR the kex_mode allows key_share resumes) * AND * a shared group exists * THEN * send a HelloRetryRequest * ELSE IF * we are not resuming * OR * the kex_mode doesn't allow non key_share resumes * THEN * fail * ELSE IF * we are stateless AND we have no cookie * THEN * send a HelloRetryRequest / if (s->server) { if (s->s3.peer_tmp != NULL) { / We have a suitable key_share / if ((s->s3.flags & TLS1_FLAGS_STATELESS) != 0 && !s->ext.cookieok) { if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) { / * If we are stateless then we wouldn't know about any * previously sent HRR - so how can this be anything other * than 0? / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->hello_retry_request = SSL_HRR_PENDING; return 1; } } else { / No suitable key_share / if (s->hello_retry_request == SSL_HRR_NONE && sent && (!s->hit \|\| (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) != 0)) { const uint16_t pgroups, clntgroups; size_t num_groups, clnt_num_groups, i; unsigned int group_id = 0; / Check if a shared group exists / / Get the clients list of supported groups. / tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups); tls1_get_supported_groups(s, &pgroups, &num_groups); / * Find the first group we allow that is also in client's list / for (i = 0; i < num_groups; i++) { group_id = pgroups[i]; if (check_in_list(s, group_id, clntgroups, clnt_num_groups, 1) && tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED) && tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION, 0, NULL)) break; } if (i < num_groups) { / A shared group exists so send a HelloRetryRequest / s->s3.group_id = group_id; s->hello_retry_request = SSL_HRR_PENDING; return 1; } } if (!s->hit \|\| (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) { / Nothing left we can do - just fail / SSLfatal(s, sent ? SSL_AD_HANDSHAKE_FAILURE : SSL_AD_MISSING_EXTENSION, SSL_R_NO_SUITABLE_KEY_SHARE); return 0; } if ((s->s3.flags & TLS1_FLAGS_STATELESS) != 0 && !s->ext.cookieok) { if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) { / * If we are stateless then we wouldn't know about any * previously sent HRR - so how can this be anything other * than 0? / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->hello_retry_request = SSL_HRR_PENDING; return 1; } } / * We have a key_share so don't send any more HelloRetryRequest * messages / if (s->hello_retry_request == SSL_HRR_PENDING) s->hello_retry_request = SSL_HRR_COMPLETE; } else { / * For a client side resumption with no key_share we need to generate * the handshake secret (otherwise this is done during key_share * processing). / if (!sent && !tls13_generate_handshake_secret(s, NULL, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } #endif / !defined(OPENSSL_NO_TLS1_3) / return 1; } static int init_psk_kex_modes(SSL_CONNECTION s, unsigned int context) { s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_NONE; return 1; } int tls_psk_do_binder(SSL_CONNECTION s, const EVP_MD md, const unsigned char msgstart, size_t binderoffset, const unsigned char binderin, unsigned char binderout, SSL_SESSION sess, int sign, int external) { EVP_PKEY mackey = NULL; EVP_MD_CTX mctx = NULL; unsigned char hash[EVP_MAX_MD_SIZE], binderkey[EVP_MAX_MD_SIZE]; unsigned char finishedkey[EVP_MAX_MD_SIZE], tmpbinder[EVP_MAX_MD_SIZE]; unsigned char early_secret; / ASCII: "res binder", in hex for EBCDIC compatibility / static const unsigned char resumption_label[] = "\x72\x65\x73\x20\x62\x69\x6E\x64\x65\x72"; / ASCII: "ext binder", in hex for EBCDIC compatibility / static const unsigned char external_label[] = "\x65\x78\x74\x20\x62\x69\x6E\x64\x65\x72"; const unsigned char label; size_t bindersize, labelsize, hashsize; int hashsizei = EVP_MD_get_size(md); int ret = -1; int usepskfored = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); / Ensure cast to size_t is safe / if (!ossl_assert(hashsizei >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hashsize = (size_t)hashsizei; if (external && s->early_data_state == SSL_EARLY_DATA_CONNECTING && s->session->ext.max_early_data == 0 && sess->ext.max_early_data > 0) usepskfored = 1; if (external) { label = external_label; labelsize = sizeof(external_label) - 1; } else { label = resumption_label; labelsize = sizeof(resumption_label) - 1; } / * Generate the early_secret. On the server side we've selected a PSK to * resume with (internal or external) so we always do this. On the client * side we do this for a non-external (i.e. resumption) PSK or external PSK * that will be used for early_data so that it is in place for sending early * data. For client side external PSK not being used for early_data we * generate it but store it away for later use. / if (s->server \|\| !external \|\| usepskfored) early_secret = (unsigned char )s->early_secret; else early_secret = (unsigned char )sess->early_secret; if (!tls13_generate_secret(s, md, NULL, sess->master_key, sess->master_key_length, early_secret)) { / SSLfatal() already called / goto err; } / * Create the handshake hash for the binder key...the messages so far are * empty! / mctx = EVP_MD_CTX_new(); if (mctx == NULL \|\| EVP_DigestInit_ex(mctx, md, NULL) <= 0 \|\| EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Generate the binder key / if (!tls13_hkdf_expand(s, md, early_secret, label, labelsize, hash, hashsize, binderkey, hashsize, 1)) { / SSLfatal() already called / goto err; } / Generate the finished key / if (!tls13_derive_finishedkey(s, md, binderkey, finishedkey, hashsize)) { / SSLfatal() already called / goto err; } if (EVP_DigestInit_ex(mctx, md, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / * Get a hash of the ClientHello up to the start of the binders. If we are * following a HelloRetryRequest then this includes the hash of the first * ClientHello and the HelloRetryRequest itself. / if (s->hello_retry_request == SSL_HRR_PENDING) { size_t hdatalen; long hdatalen_l; void hdata; hdatalen = hdatalen_l = BIO_get_mem_data(s->s3.handshake_buffer, &hdata); if (hdatalen_l <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_LENGTH); goto err; } /* * For servers the handshake buffer data will include the second * ClientHello - which we don't want - so we need to take that bit off. / if (s->server) { PACKET hashprefix, msg; / Find how many bytes are left after the first two messages / if (!PACKET_buf_init(&hashprefix, hdata, hdatalen) \|\| !PACKET_forward(&hashprefix, 1) \|\| !PACKET_get_length_prefixed_3(&hashprefix, &msg) \|\| !PACKET_forward(&hashprefix, 1) \|\| !PACKET_get_length_prefixed_3(&hashprefix, &msg)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hdatalen -= PACKET_remaining(&hashprefix); } if (EVP_DigestUpdate(mctx, hdata, hdatalen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (EVP_DigestUpdate(mctx, msgstart, binderoffset) <= 0 \|\| EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } mackey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC", sctx->propq, finishedkey, hashsize); if (mackey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!sign) binderout = tmpbinder; bindersize = hashsize; if (EVP_DigestSignInit_ex(mctx, NULL, EVP_MD_get0_name(md), sctx->libctx, sctx->propq, mackey, NULL) <= 0 \|\| EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0 \|\| EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0 \|\| bindersize != hashsize) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (sign) { ret = 1; } else { / HMAC keys can't do EVP_DigestVerify* - use CRYPTO_memcmp instead / ret = (CRYPTO_memcmp(binderin, binderout, hashsize) == 0); if (!ret) SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BINDER_DOES_NOT_VERIFY); } err: OPENSSL_cleanse(binderkey, sizeof(binderkey)); OPENSSL_cleanse(finishedkey, sizeof(finishedkey)); EVP_PKEY_free(mackey); EVP_MD_CTX_free(mctx); return ret; } static int final_early_data(SSL_CONNECTION s, unsigned int context, int sent) { if (!sent) return 1; if (!s->server) { if (context == SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS && sent && !s->ext.early_data_ok) { /* * If we get here then the server accepted our early_data but we * later realised that it shouldn't have done (e.g. inconsistent * ALPN) / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EARLY_DATA); return 0; } return 1; } if (s->max_early_data == 0 \|\| !s->hit \|\| s->early_data_state != SSL_EARLY_DATA_ACCEPTING \|\| !s->ext.early_data_ok \|\| s->hello_retry_request != SSL_HRR_NONE \|\| (s->allow_early_data_cb != NULL && !s->allow_early_data_cb(SSL_CONNECTION_GET_SSL(s), s->allow_early_data_cb_data))) { s->ext.early_data = SSL_EARLY_DATA_REJECTED; } else { s->ext.early_data = SSL_EARLY_DATA_ACCEPTED; if (!tls13_change_cipher_state(s, SSL3_CC_EARLY \| SSL3_CHANGE_CIPHER_SERVER_READ)) { / SSLfatal() already called / return 0; } } return 1; } static int final_maxfragmentlen(SSL_CONNECTION s, unsigned int context, int sent) { /* * Session resumption on server-side with MFL extension active * BUT MFL extension packet was not resent (i.e. sent == 0) / if (s->server && s->hit && USE_MAX_FRAGMENT_LENGTH_EXT(s->session) && !sent ) { SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } if (s->session && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)) { s->rlayer.rrlmethod->set_max_frag_len(s->rlayer.rrl, GET_MAX_FRAGMENT_LENGTH(s->session)); s->rlayer.wrlmethod->set_max_frag_len(s->rlayer.wrl, ssl_get_max_send_fragment(s)); } return 1; } static int init_post_handshake_auth(SSL_CONNECTION s, ossl_unused unsigned int context) { s->post_handshake_auth = SSL_PHA_NONE; return 1; } /* * If clients offer "pre_shared_key" without a "psk_key_exchange_modes" * extension, servers MUST abort the handshake. / static int final_psk(SSL_CONNECTION s, unsigned int context, int sent) { if (s->server && sent && s->clienthello != NULL && !s->clienthello->pre_proc_exts[TLSEXT_IDX_psk_kex_modes].present) { SSLfatal(s, TLS13_AD_MISSING_EXTENSION, SSL_R_MISSING_PSK_KEX_MODES_EXTENSION); return 0; } return 1; } static int tls_init_compress_certificate(SSL_CONNECTION sc, unsigned int context) { memset(sc->ext.compress_certificate_from_peer, 0, sizeof(sc->ext.compress_certificate_from_peer)); return 1; } / The order these are put into the packet imply a preference order: [brotli, zlib, zstd] / static EXT_RETURN tls_construct_compress_certificate(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_COMP_ALG int i; if (!ossl_comp_has_alg(0)) return EXT_RETURN_NOT_SENT; /* Server: Don't attempt to compress a non-X509 (i.e. an RPK) / if (sc->server && sc->ext.server_cert_type != TLSEXT_cert_type_x509) { sc->cert_comp_prefs[0] = TLSEXT_comp_cert_none; return EXT_RETURN_NOT_SENT; } / Client: If we sent a client cert-type extension, don't indicate compression / if (!sc->server && sc->ext.client_cert_type_ctos) { sc->cert_comp_prefs[0] = TLSEXT_comp_cert_none; return EXT_RETURN_NOT_SENT; } / Do not indicate we support receiving compressed certificates / if ((sc->options & SSL_OP_NO_RX_CERTIFICATE_COMPRESSION) != 0) return EXT_RETURN_NOT_SENT; if (sc->cert_comp_prefs[0] == TLSEXT_comp_cert_none) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_compress_certificate) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u8(pkt)) goto err; for (i = 0; sc->cert_comp_prefs[i] != TLSEXT_comp_cert_none; i++) { if (!WPACKET_put_bytes_u16(pkt, sc->cert_comp_prefs[i])) goto err; } if (!WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) goto err; sc->ext.compress_certificate_sent = 1; return EXT_RETURN_SENT; err: SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; #else return EXT_RETURN_NOT_SENT; #endif } #ifndef OPENSSL_NO_COMP_ALG static int tls_comp_in_pref(SSL_CONNECTION sc, int alg) { int i; /* ossl_comp_has_alg() considers 0 as "any" / if (alg == 0) return 0; / Make sure algorithm is enabled / if (!ossl_comp_has_alg(alg)) return 0; / If no preferences are set, it's ok / if (sc->cert_comp_prefs[0] == TLSEXT_comp_cert_none) return 1; / Find the algorithm / for (i = 0; i < TLSEXT_comp_cert_limit; i++) if (sc->cert_comp_prefs[i] == alg) return 1; return 0; } #endif int tls_parse_compress_certificate(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_COMP_ALG PACKET supported_comp_algs; unsigned int comp; int already_set[TLSEXT_comp_cert_limit]; int j = 0; /* If no algorithms are available, ignore the extension / if (!ossl_comp_has_alg(0)) return 1; / Don't attempt to compress a non-X509 (i.e. an RPK) / if (sc->server && sc->ext.server_cert_type != TLSEXT_cert_type_x509) return 1; if (!sc->server && sc->ext.client_cert_type != TLSEXT_cert_type_x509) return 1; / Ignore the extension and don't send compressed certificates / if ((sc->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0) return 1; if (!PACKET_as_length_prefixed_1(pkt, &supported_comp_algs) \|\| PACKET_remaining(&supported_comp_algs) == 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } memset(already_set, 0, sizeof(already_set)); / * The preference array has real values, so take a look at each * value coming in, and make sure it's in our preference list * The array is 0 (i.e. "none") terminated * The preference list only contains supported algorithms / while (PACKET_get_net_2(&supported_comp_algs, &comp)) { if (tls_comp_in_pref(sc, comp) && !already_set[comp]) { sc->ext.compress_certificate_from_peer[j++] = comp; already_set[comp] = 1; } } #endif return 1; } static int init_server_cert_type(SSL_CONNECTION sc, unsigned int context) { /* Only reset when parsing client hello / if (sc->server) { sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.server_cert_type = TLSEXT_cert_type_x509; } return 1; } static int init_client_cert_type(SSL_CONNECTION sc, unsigned int context) { /* Only reset when parsing client hello */ if (sc->server) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.client_cert_type = TLSEXT_cert_type_x509; } return 1; }
./openssl/ssl/statem/statem_lib.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <limits.h> #include <string.h> #include <stdio.h> #include "../ssl_local.h" #include "statem_local.h" #include "internal/cryptlib.h" #include <openssl/buffer.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/rsa.h> #include <openssl/x509.h> #include <openssl/trace.h> #include <openssl/encoder.h> / * Map error codes to TLS/SSL alart types. / typedef struct x509err2alert_st { int x509err; int alert; } X509ERR2ALERT; / Fixed value used in the ServerHello random field to identify an HRR / const unsigned char hrrrandom[] = { 0xcf, 0x21, 0xad, 0x74, 0xe5, 0x9a, 0x61, 0x11, 0xbe, 0x1d, 0x8c, 0x02, 0x1e, 0x65, 0xb8, 0x91, 0xc2, 0xa2, 0x11, 0x16, 0x7a, 0xbb, 0x8c, 0x5e, 0x07, 0x9e, 0x09, 0xe2, 0xc8, 0xa8, 0x33, 0x9c }; int ossl_statem_set_mutator(SSL s, ossl_statem_mutate_handshake_cb mutate_handshake_cb, ossl_statem_finish_mutate_handshake_cb finish_mutate_handshake_cb, void mutatearg) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->statem.mutate_handshake_cb = mutate_handshake_cb; sc->statem.mutatearg = mutatearg; sc->statem.finish_mutate_handshake_cb = finish_mutate_handshake_cb; return 1; } /* * send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or * SSL3_RT_CHANGE_CIPHER_SPEC) / int ssl3_do_write(SSL_CONNECTION s, uint8_t type) { int ret; size_t written = 0; SSL ssl = SSL_CONNECTION_GET_SSL(s); / * If we're running the test suite then we may need to mutate the message * we've been asked to write. Does not happen in normal operation. / if (s->statem.mutate_handshake_cb != NULL && !s->statem.write_in_progress && type == SSL3_RT_HANDSHAKE && s->init_num >= SSL3_HM_HEADER_LENGTH) { unsigned char msg; size_t msglen; if (!s->statem.mutate_handshake_cb((unsigned char )s->init_buf->data, s->init_num, &msg, &msglen, s->statem.mutatearg)) return -1; if (msglen < SSL3_HM_HEADER_LENGTH \|\| !BUF_MEM_grow(s->init_buf, msglen)) return -1; memcpy(s->init_buf->data, msg, msglen); s->init_num = msglen; s->init_msg = s->init_buf->data + SSL3_HM_HEADER_LENGTH; s->statem.finish_mutate_handshake_cb(s->statem.mutatearg); s->statem.write_in_progress = 1; } ret = ssl3_write_bytes(ssl, type, &s->init_buf->data[s->init_off], s->init_num, &written); if (ret <= 0) return -1; if (type == SSL3_RT_HANDSHAKE) / * should not be done for 'Hello Request's, but in that case we'll * ignore the result anyway * TLS1.3 KeyUpdate and NewSessionTicket do not need to be added / if (!SSL_CONNECTION_IS_TLS13(s) \|\| (s->statem.hand_state != TLS_ST_SW_SESSION_TICKET && s->statem.hand_state != TLS_ST_CW_KEY_UPDATE && s->statem.hand_state != TLS_ST_SW_KEY_UPDATE)) if (!ssl3_finish_mac(s, (unsigned char )&s->init_buf->data[s->init_off], written)) return -1; if (written == s->init_num) { s->statem.write_in_progress = 0; if (s->msg_callback) s->msg_callback(1, s->version, type, s->init_buf->data, (size_t)(s->init_off + s->init_num), ssl, s->msg_callback_arg); return 1; } s->init_off += written; s->init_num -= written; return 0; } int tls_close_construct_packet(SSL_CONNECTION s, WPACKET pkt, int htype) { size_t msglen; if ((htype != SSL3_MT_CHANGE_CIPHER_SPEC && !WPACKET_close(pkt)) \|\| !WPACKET_get_length(pkt, &msglen) \|\| msglen > INT_MAX) return 0; s->init_num = (int)msglen; s->init_off = 0; return 1; } int tls_setup_handshake(SSL_CONNECTION s) { int ver_min, ver_max, ok; SSL ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (!ssl3_init_finished_mac(s)) { / SSLfatal() already called / return 0; } / Reset any extension flags / memset(s->ext.extflags, 0, sizeof(s->ext.extflags)); if (ssl_get_min_max_version(s, &ver_min, &ver_max, NULL) != 0) { SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_NO_PROTOCOLS_AVAILABLE); return 0; } / Sanity check that we have MD5-SHA1 if we need it / if (sctx->ssl_digest_methods[SSL_MD_MD5_SHA1_IDX] == NULL) { int negotiated_minversion; int md5sha1_needed_maxversion = SSL_CONNECTION_IS_DTLS(s) ? DTLS1_VERSION : TLS1_1_VERSION; / We don't have MD5-SHA1 - do we need it? / if (ssl_version_cmp(s, ver_max, md5sha1_needed_maxversion) <= 0) { SSLfatal_data(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM, "The max supported SSL/TLS version needs the" " MD5-SHA1 digest but it is not available" " in the loaded providers. Use (D)TLSv1.2 or" " above, or load different providers"); return 0; } ok = 1; / Don't allow TLSv1.1 or below to be negotiated / negotiated_minversion = SSL_CONNECTION_IS_DTLS(s) ? DTLS1_2_VERSION : TLS1_2_VERSION; if (ssl_version_cmp(s, ver_min, negotiated_minversion) < 0) ok = SSL_set_min_proto_version(ssl, negotiated_minversion); if (!ok) { / Shouldn't happen / SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR); return 0; } } ok = 0; if (s->server) { STACK_OF(SSL_CIPHER) ciphers = SSL_get_ciphers(ssl); int i; /* * Sanity check that the maximum version we accept has ciphers * enabled. For clients we do this check during construction of the * ClientHello. / for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) { const SSL_CIPHER c = sk_SSL_CIPHER_value(ciphers, i); int cipher_minprotover = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls; int cipher_maxprotover = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls; if (ssl_version_cmp(s, ver_max, cipher_minprotover) >= 0 && ssl_version_cmp(s, ver_max, cipher_maxprotover) <= 0) { ok = 1; break; } } if (!ok) { SSLfatal_data(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_CIPHERS_AVAILABLE, "No ciphers enabled for max supported " "SSL/TLS version"); return 0; } if (SSL_IS_FIRST_HANDSHAKE(s)) { /* N.B. s->session_ctx == s->ctx here / ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_accept); } else { / N.B. s->ctx may not equal s->session_ctx / ssl_tsan_counter(sctx, &sctx->stats.sess_accept_renegotiate); s->s3.tmp.cert_request = 0; } } else { if (SSL_IS_FIRST_HANDSHAKE(s)) ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_connect); else ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_connect_renegotiate); / mark client_random uninitialized / memset(s->s3.client_random, 0, sizeof(s->s3.client_random)); s->hit = 0; s->s3.tmp.cert_req = 0; if (SSL_CONNECTION_IS_DTLS(s)) s->statem.use_timer = 1; } return 1; } / * Size of the to-be-signed TLS13 data, without the hash size itself: * 64 bytes of value 32, 33 context bytes, 1 byte separator / #define TLS13_TBS_START_SIZE 64 #define TLS13_TBS_PREAMBLE_SIZE (TLS13_TBS_START_SIZE + 33 + 1) static int get_cert_verify_tbs_data(SSL_CONNECTION s, unsigned char tls13tbs, void hdata, size_t hdatalen) { /* ASCII: "TLS 1.3, server CertificateVerify", in hex for EBCDIC compatibility / static const char servercontext[] = "\x54\x4c\x53\x20\x31\x2e\x33\x2c\x20\x73\x65\x72" "\x76\x65\x72\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x56\x65\x72\x69\x66\x79"; / ASCII: "TLS 1.3, client CertificateVerify", in hex for EBCDIC compatibility / static const char clientcontext[] = "\x54\x4c\x53\x20\x31\x2e\x33\x2c\x20\x63\x6c\x69" "\x65\x6e\x74\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x56\x65\x72\x69\x66\x79"; if (SSL_CONNECTION_IS_TLS13(s)) { size_t hashlen; / Set the first 64 bytes of to-be-signed data to octet 32 / memset(tls13tbs, 32, TLS13_TBS_START_SIZE); / This copies the 33 bytes of context plus the 0 separator byte / if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY \|\| s->statem.hand_state == TLS_ST_SW_CERT_VRFY) strcpy((char )tls13tbs + TLS13_TBS_START_SIZE, servercontext); else strcpy((char )tls13tbs + TLS13_TBS_START_SIZE, clientcontext); / * If we're currently reading then we need to use the saved handshake * hash value. We can't use the current handshake hash state because * that includes the CertVerify itself. / if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY \|\| s->statem.hand_state == TLS_ST_SR_CERT_VRFY) { memcpy(tls13tbs + TLS13_TBS_PREAMBLE_SIZE, s->cert_verify_hash, s->cert_verify_hash_len); hashlen = s->cert_verify_hash_len; } else if (!ssl_handshake_hash(s, tls13tbs + TLS13_TBS_PREAMBLE_SIZE, EVP_MAX_MD_SIZE, &hashlen)) { / SSLfatal() already called / return 0; } hdata = tls13tbs; hdatalen = TLS13_TBS_PREAMBLE_SIZE + hashlen; } else { size_t retlen; long retlen_l; retlen = retlen_l = BIO_get_mem_data(s->s3.handshake_buffer, hdata); if (retlen_l <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } hdatalen = retlen; } return 1; } CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION s, WPACKET pkt) { EVP_PKEY pkey = NULL; const EVP_MD md = NULL; EVP_MD_CTX mctx = NULL; EVP_PKEY_CTX pctx = NULL; size_t hdatalen = 0, siglen = 0; void hdata; unsigned char sig = NULL; unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE]; const SIGALG_LOOKUP lu = s->s3.tmp.sigalg; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (lu == NULL \|\| s->s3.tmp.cert == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pkey = s->s3.tmp.cert->privatekey; if (pkey == NULL \|\| !tls1_lookup_md(sctx, lu, &md)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } mctx = EVP_MD_CTX_new(); if (mctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } /* Get the data to be signed / if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) { / SSLfatal() already called / goto err; } if (SSL_USE_SIGALGS(s) && !WPACKET_put_bytes_u16(pkt, lu->sigalg)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (EVP_DigestSignInit_ex(mctx, &pctx, md == NULL ? NULL : EVP_MD_get0_name(md), sctx->libctx, sctx->propq, pkey, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (lu->sig == EVP_PKEY_RSA_PSS) { if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0 \|\| EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } if (s->version == SSL3_VERSION) { / * Here we use EVP_DigestSignUpdate followed by EVP_DigestSignFinal * in order to add the EVP_CTRL_SSL3_MASTER_SECRET call between them. / if (EVP_DigestSignUpdate(mctx, hdata, hdatalen) <= 0 \|\| EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET, (int)s->session->master_key_length, s->session->master_key) <= 0 \|\| EVP_DigestSignFinal(mctx, NULL, &siglen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } sig = OPENSSL_malloc(siglen); if (sig == NULL \|\| EVP_DigestSignFinal(mctx, sig, &siglen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } else { / * Here we must use EVP_DigestSign() because Ed25519/Ed448 does not * support streaming via EVP_DigestSignUpdate/EVP_DigestSignFinal / if (EVP_DigestSign(mctx, NULL, &siglen, hdata, hdatalen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } sig = OPENSSL_malloc(siglen); if (sig == NULL \|\| EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } #ifndef OPENSSL_NO_GOST { int pktype = lu->sig; if (pktype == NID_id_GostR3410_2001 \|\| pktype == NID_id_GostR3410_2012_256 \|\| pktype == NID_id_GostR3410_2012_512) BUF_reverse(sig, NULL, siglen); } #endif if (!WPACKET_sub_memcpy_u16(pkt, sig, siglen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Digest cached records and discard handshake buffer / if (!ssl3_digest_cached_records(s, 0)) { / SSLfatal() already called / goto err; } OPENSSL_free(sig); EVP_MD_CTX_free(mctx); return CON_FUNC_SUCCESS; err: OPENSSL_free(sig); EVP_MD_CTX_free(mctx); return CON_FUNC_ERROR; } MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION s, PACKET pkt) { EVP_PKEY pkey = NULL; const unsigned char data; #ifndef OPENSSL_NO_GOST unsigned char gost_data = NULL; #endif MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; int j; unsigned int len; const EVP_MD md = NULL; size_t hdatalen = 0; void hdata; unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE]; EVP_MD_CTX mctx = EVP_MD_CTX_new(); EVP_PKEY_CTX pctx = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (mctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } pkey = tls_get_peer_pkey(s); if (pkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (ssl_cert_lookup_by_pkey(pkey, NULL, sctx) == NULL) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE); goto err; } if (SSL_USE_SIGALGS(s)) { unsigned int sigalg; if (!PACKET_get_net_2(pkt, &sigalg)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_PACKET); goto err; } if (tls12_check_peer_sigalg(s, sigalg, pkey) <= 0) { / SSLfatal() already called / goto err; } } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED); goto err; } if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (SSL_USE_SIGALGS(s)) OSSL_TRACE1(TLS, "USING TLSv1.2 HASH %s\n", md == NULL ? "n/a" : EVP_MD_get0_name(md)); / Check for broken implementations of GOST ciphersuites / / * If key is GOST and len is exactly 64 or 128, it is signature without * length field (CryptoPro implementations at least till TLS 1.2) / #ifndef OPENSSL_NO_GOST if (!SSL_USE_SIGALGS(s) && ((PACKET_remaining(pkt) == 64 && (EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2001 \|\| EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2012_256)) \|\| (PACKET_remaining(pkt) == 128 && EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2012_512))) { len = PACKET_remaining(pkt); } else #endif if (!PACKET_get_net_2(pkt, &len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_get_bytes(pkt, &data, len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) { / SSLfatal() already called / goto err; } OSSL_TRACE1(TLS, "Using client verify alg %s\n", md == NULL ? "n/a" : EVP_MD_get0_name(md)); if (EVP_DigestVerifyInit_ex(mctx, &pctx, md == NULL ? NULL : EVP_MD_get0_name(md), sctx->libctx, sctx->propq, pkey, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } #ifndef OPENSSL_NO_GOST { int pktype = EVP_PKEY_get_id(pkey); if (pktype == NID_id_GostR3410_2001 \|\| pktype == NID_id_GostR3410_2012_256 \|\| pktype == NID_id_GostR3410_2012_512) { if ((gost_data = OPENSSL_malloc(len)) == NULL) goto err; BUF_reverse(gost_data, data, len); data = gost_data; } } #endif if (SSL_USE_PSS(s)) { if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0 \|\| EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } if (s->version == SSL3_VERSION) { if (EVP_DigestVerifyUpdate(mctx, hdata, hdatalen) <= 0 \|\| EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET, (int)s->session->master_key_length, s->session->master_key) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_DigestVerifyFinal(mctx, data, len) <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BAD_SIGNATURE); goto err; } } else { j = EVP_DigestVerify(mctx, data, len, hdata, hdatalen); #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION / Ignore bad signatures when fuzzing / if (SSL_IS_QUIC_HANDSHAKE(s)) j = 1; #endif if (j <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BAD_SIGNATURE); goto err; } } / * In TLSv1.3 on the client side we make sure we prepare the client * certificate after the CertVerify instead of when we get the * CertificateRequest. This is because in TLSv1.3 the CertificateRequest * comes before the Certificate message. In TLSv1.2 it comes after. We * want to make sure that SSL_get1_peer_certificate() will return the actual * server certificate from the client_cert_cb callback. / if (!s->server && SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.cert_req == 1) ret = MSG_PROCESS_CONTINUE_PROCESSING; else ret = MSG_PROCESS_CONTINUE_READING; err: BIO_free(s->s3.handshake_buffer); s->s3.handshake_buffer = NULL; EVP_MD_CTX_free(mctx); #ifndef OPENSSL_NO_GOST OPENSSL_free(gost_data); #endif return ret; } CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION s, WPACKET pkt) { size_t finish_md_len; const char sender; size_t slen; SSL ssl = SSL_CONNECTION_GET_SSL(s); / This is a real handshake so make sure we clean it up at the end / if (!s->server && s->post_handshake_auth != SSL_PHA_REQUESTED) s->statem.cleanuphand = 1; / * If we attempted to write early data or we're in middlebox compat mode * then we deferred changing the handshake write keys to the last possible * moment. If we didn't already do this when we sent the client certificate * then we need to do it now. / if (SSL_CONNECTION_IS_TLS13(s) && !s->server && (s->early_data_state != SSL_EARLY_DATA_NONE \|\| (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) && s->s3.tmp.cert_req == 0 && (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE \| SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {; / SSLfatal() already called / return CON_FUNC_ERROR; } if (s->server) { sender = ssl->method->ssl3_enc->server_finished_label; slen = ssl->method->ssl3_enc->server_finished_label_len; } else { sender = ssl->method->ssl3_enc->client_finished_label; slen = ssl->method->ssl3_enc->client_finished_label_len; } finish_md_len = ssl->method->ssl3_enc->final_finish_mac(s, sender, slen, s->s3.tmp.finish_md); if (finish_md_len == 0) { / SSLfatal() already called / return CON_FUNC_ERROR; } s->s3.tmp.finish_md_len = finish_md_len; if (!WPACKET_memcpy(pkt, s->s3.tmp.finish_md, finish_md_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / * Log the master secret, if logging is enabled. We don't log it for * TLSv1.3: there's a different key schedule for that. / if (!SSL_CONNECTION_IS_TLS13(s) && !ssl_log_secret(s, MASTER_SECRET_LABEL, s->session->master_key, s->session->master_key_length)) { / SSLfatal() already called / return CON_FUNC_ERROR; } / * Copy the finished so we can use it for renegotiation checks / if (!ossl_assert(finish_md_len <= EVP_MAX_MD_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (!s->server) { memcpy(s->s3.previous_client_finished, s->s3.tmp.finish_md, finish_md_len); s->s3.previous_client_finished_len = finish_md_len; } else { memcpy(s->s3.previous_server_finished, s->s3.tmp.finish_md, finish_md_len); s->s3.previous_server_finished_len = finish_md_len; } return CON_FUNC_SUCCESS; } CON_FUNC_RETURN tls_construct_key_update(SSL_CONNECTION s, WPACKET pkt) { if (!WPACKET_put_bytes_u8(pkt, s->key_update)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } s->key_update = SSL_KEY_UPDATE_NONE; return CON_FUNC_SUCCESS; } MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION s, PACKET pkt) { unsigned int updatetype; / * A KeyUpdate message signals a key change so the end of the message must * be on a record boundary. / if (RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); return MSG_PROCESS_ERROR; } if (!PACKET_get_1(pkt, &updatetype) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_KEY_UPDATE); return MSG_PROCESS_ERROR; } / * There are only two defined key update types. Fail if we get a value we * didn't recognise. / if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED && updatetype != SSL_KEY_UPDATE_REQUESTED) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_UPDATE); return MSG_PROCESS_ERROR; } / * If we get a request for us to update our sending keys too then, we need * to additionally send a KeyUpdate message. However that message should * not also request an update (otherwise we get into an infinite loop). / if (updatetype == SSL_KEY_UPDATE_REQUESTED) s->key_update = SSL_KEY_UPDATE_NOT_REQUESTED; if (!tls13_update_key(s, 0)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } return MSG_PROCESS_FINISHED_READING; } / * ssl3_take_mac calculates the Finished MAC for the handshakes messages seen * to far. / int ssl3_take_mac(SSL_CONNECTION s) { const char sender; size_t slen; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (!s->server) { sender = ssl->method->ssl3_enc->server_finished_label; slen = ssl->method->ssl3_enc->server_finished_label_len; } else { sender = ssl->method->ssl3_enc->client_finished_label; slen = ssl->method->ssl3_enc->client_finished_label_len; } s->s3.tmp.peer_finish_md_len = ssl->method->ssl3_enc->final_finish_mac(s, sender, slen, s->s3.tmp.peer_finish_md); if (s->s3.tmp.peer_finish_md_len == 0) { /* SSLfatal() already called / return 0; } return 1; } MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION s, PACKET pkt) { size_t remain; remain = PACKET_remaining(pkt); / * 'Change Cipher Spec' is just a single byte, which should already have * been consumed by ssl_get_message() so there should be no bytes left, * unless we're using DTLS1_BAD_VER, which has an extra 2 bytes / if (SSL_CONNECTION_IS_DTLS(s)) { if ((s->version == DTLS1_BAD_VER && remain != DTLS1_CCS_HEADER_LENGTH + 1) \|\| (s->version != DTLS1_BAD_VER && remain != DTLS1_CCS_HEADER_LENGTH - 1)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_CHANGE_CIPHER_SPEC); return MSG_PROCESS_ERROR; } } else { if (remain != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_CHANGE_CIPHER_SPEC); return MSG_PROCESS_ERROR; } } / Check we have a cipher to change to / if (s->s3.tmp.new_cipher == NULL) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY); return MSG_PROCESS_ERROR; } s->s3.change_cipher_spec = 1; if (!ssl3_do_change_cipher_spec(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } if (SSL_CONNECTION_IS_DTLS(s)) { if (s->version == DTLS1_BAD_VER) s->d1->handshake_read_seq++; #ifndef OPENSSL_NO_SCTP / * Remember that a CCS has been received, so that an old key of * SCTP-Auth can be deleted when a CCS is sent. Will be ignored if no * SCTP is used / BIO_ctrl(SSL_get_wbio(SSL_CONNECTION_GET_SSL(s)), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL); #endif } return MSG_PROCESS_CONTINUE_READING; } MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION s, PACKET pkt) { size_t md_len; SSL ssl = SSL_CONNECTION_GET_SSL(s); int was_first = SSL_IS_FIRST_HANDSHAKE(s); int ok; /* This is a real handshake so make sure we clean it up at the end / if (s->server) { / * To get this far we must have read encrypted data from the client. We * no longer tolerate unencrypted alerts. This is ignored if less than * TLSv1.3 / if (s->rlayer.rrlmethod->set_plain_alerts != NULL) s->rlayer.rrlmethod->set_plain_alerts(s->rlayer.rrl, 0); if (s->post_handshake_auth != SSL_PHA_REQUESTED) s->statem.cleanuphand = 1; if (SSL_CONNECTION_IS_TLS13(s) && !tls13_save_handshake_digest_for_pha(s)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } } / * In TLSv1.3 a Finished message signals a key change so the end of the * message must be on a record boundary. / if (SSL_CONNECTION_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); return MSG_PROCESS_ERROR; } / If this occurs, we have missed a message / if (!SSL_CONNECTION_IS_TLS13(s) && !s->s3.change_cipher_spec) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_GOT_A_FIN_BEFORE_A_CCS); return MSG_PROCESS_ERROR; } s->s3.change_cipher_spec = 0; md_len = s->s3.tmp.peer_finish_md_len; if (md_len != PACKET_remaining(pkt)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_DIGEST_LENGTH); return MSG_PROCESS_ERROR; } ok = CRYPTO_memcmp(PACKET_data(pkt), s->s3.tmp.peer_finish_md, md_len); #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if (ok != 0) { if ((PACKET_data(pkt)[0] ^ s->s3.tmp.peer_finish_md[0]) != 0xFF) { ok = 0; } } #endif if (ok != 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DIGEST_CHECK_FAILED); return MSG_PROCESS_ERROR; } / * Copy the finished so we can use it for renegotiation checks / if (!ossl_assert(md_len <= EVP_MAX_MD_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } if (s->server) { memcpy(s->s3.previous_client_finished, s->s3.tmp.peer_finish_md, md_len); s->s3.previous_client_finished_len = md_len; } else { memcpy(s->s3.previous_server_finished, s->s3.tmp.peer_finish_md, md_len); s->s3.previous_server_finished_len = md_len; } / * In TLS1.3 we also have to change cipher state and do any final processing * of the initial server flight (if we are a client) / if (SSL_CONNECTION_IS_TLS13(s)) { if (s->server) { if (s->post_handshake_auth != SSL_PHA_REQUESTED && !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION \| SSL3_CHANGE_CIPHER_SERVER_READ)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } } else { / TLS 1.3 gets the secret size from the handshake md / size_t dummy; if (!ssl->method->ssl3_enc->generate_master_secret(s, s->master_secret, s->handshake_secret, 0, &dummy)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION \| SSL3_CHANGE_CIPHER_CLIENT_READ)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } if (!tls_process_initial_server_flight(s)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } } } if (was_first && !SSL_IS_FIRST_HANDSHAKE(s) && s->rlayer.rrlmethod->set_first_handshake != NULL) s->rlayer.rrlmethod->set_first_handshake(s->rlayer.rrl, 0); return MSG_PROCESS_FINISHED_READING; } CON_FUNC_RETURN tls_construct_change_cipher_spec(SSL_CONNECTION s, WPACKET pkt) { if (!WPACKET_put_bytes_u8(pkt, SSL3_MT_CCS)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } / Add a certificate to the WPACKET / static int ssl_add_cert_to_wpacket(SSL_CONNECTION s, WPACKET pkt, X509 x, int chain, int for_comp) { int len; unsigned char outbytes; int context = SSL_EXT_TLS1_3_CERTIFICATE; if (for_comp) context \|= SSL_EXT_TLS1_3_CERTIFICATE_COMPRESSION; len = i2d_X509(x, NULL); if (len < 0) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BUF_LIB); return 0; } if (!WPACKET_sub_allocate_bytes_u24(pkt, len, &outbytes) \|\| i2d_X509(x, &outbytes) != len) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((SSL_CONNECTION_IS_TLS13(s) \|\| for_comp) && !tls_construct_extensions(s, pkt, context, x, chain)) { / SSLfatal() already called / return 0; } return 1; } / Add certificate chain to provided WPACKET / static int ssl_add_cert_chain(SSL_CONNECTION s, WPACKET pkt, CERT_PKEY cpk, int for_comp) { int i, chain_count; X509 x; STACK_OF(X509) extra_certs; STACK_OF(X509) chain = NULL; X509_STORE chain_store; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (cpk == NULL \|\| cpk->x509 == NULL) return 1; x = cpk->x509; / * If we have a certificate specific chain use it, else use parent ctx. / if (cpk->chain != NULL) extra_certs = cpk->chain; else extra_certs = sctx->extra_certs; if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) \|\| extra_certs) chain_store = NULL; else if (s->cert->chain_store) chain_store = s->cert->chain_store; else chain_store = sctx->cert_store; if (chain_store != NULL) { X509_STORE_CTX xs_ctx = X509_STORE_CTX_new_ex(sctx->libctx, sctx->propq); if (xs_ctx == NULL) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_X509_LIB); return 0; } if (!X509_STORE_CTX_init(xs_ctx, chain_store, x, NULL)) { X509_STORE_CTX_free(xs_ctx); if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_X509_LIB); return 0; } /* * It is valid for the chain not to be complete (because normally we * don't include the root cert in the chain). Therefore we deliberately * ignore the error return from this call. We're not actually verifying * the cert - we're just building as much of the chain as we can / (void)X509_verify_cert(xs_ctx); / Don't leave errors in the queue / ERR_clear_error(); chain = X509_STORE_CTX_get0_chain(xs_ctx); i = ssl_security_cert_chain(s, chain, NULL, 0); if (i != 1) { #if 0 / Dummy error calls so mkerr generates them / ERR_raise(ERR_LIB_SSL, SSL_R_EE_KEY_TOO_SMALL); ERR_raise(ERR_LIB_SSL, SSL_R_CA_KEY_TOO_SMALL); ERR_raise(ERR_LIB_SSL, SSL_R_CA_MD_TOO_WEAK); #endif X509_STORE_CTX_free(xs_ctx); if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, i); return 0; } chain_count = sk_X509_num(chain); for (i = 0; i < chain_count; i++) { x = sk_X509_value(chain, i); if (!ssl_add_cert_to_wpacket(s, pkt, x, i, for_comp)) { / SSLfatal() already called / X509_STORE_CTX_free(xs_ctx); return 0; } } X509_STORE_CTX_free(xs_ctx); } else { i = ssl_security_cert_chain(s, extra_certs, x, 0); if (i != 1) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, i); return 0; } if (!ssl_add_cert_to_wpacket(s, pkt, x, 0, for_comp)) { / SSLfatal() already called / return 0; } for (i = 0; i < sk_X509_num(extra_certs); i++) { x = sk_X509_value(extra_certs, i); if (!ssl_add_cert_to_wpacket(s, pkt, x, i + 1, for_comp)) { / SSLfatal() already called / return 0; } } } return 1; } EVP_PKEY tls_get_peer_pkey(const SSL_CONNECTION sc) { if (sc->session->peer_rpk != NULL) return sc->session->peer_rpk; if (sc->session->peer != NULL) return X509_get0_pubkey(sc->session->peer); return NULL; } int tls_process_rpk(SSL_CONNECTION sc, PACKET pkt, EVP_PKEY peer_rpk) { EVP_PKEY pkey = NULL; int ret = 0; RAW_EXTENSION rawexts = NULL; PACKET extensions; PACKET context; unsigned long cert_len = 0, spki_len = 0; const unsigned char spki, spkistart; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(sc); /- ---------------------------- * TLS 1.3 Certificate message: * ---------------------------- * https://datatracker.ietf.org/doc/html/rfc8446#section-4.4.2 * * enum { * X509(0), * RawPublicKey(2), * (255) * } CertificateType; * * struct { * select (certificate_type) { * case RawPublicKey: * // From RFC 7250 ASN.1_subjectPublicKeyInfo * opaque ASN1_subjectPublicKeyInfo<1..2^24-1>; * * case X509: * opaque cert_data<1..2^24-1>; * }; * Extension extensions<0..2^16-1>; * } CertificateEntry; * * struct { * opaque certificate_request_context<0..2^8-1>; * CertificateEntry certificate_list<0..2^24-1>; * } Certificate; * * The client MUST send a Certificate message if and only if the server * has requested client authentication via a CertificateRequest message * (Section 4.3.2). If the server requests client authentication but no * suitable certificate is available, the client MUST send a Certificate * message containing no certificates (i.e., with the "certificate_list" * field having length 0). * * ---------------------------- * TLS 1.2 Certificate message: * ---------------------------- * https://datatracker.ietf.org/doc/html/rfc7250#section-3 * * opaque ASN.1Cert<1..2^24-1>; * * struct { * select(certificate_type){ * * // certificate type defined in this document. * case RawPublicKey: * opaque ASN.1_subjectPublicKeyInfo<1..2^24-1>; * * // X.509 certificate defined in RFC 5246 * case X.509: * ASN.1Cert certificate_list<0..2^24-1>; * * // Additional certificate type based on * // "TLS Certificate Types" subregistry * }; * } Certificate; * * ------------- * Consequently: * ------------- * After the (TLS 1.3 only) context octet string (1 byte length + data) the * Certificate message has a 3-byte length that is zero in the client to * server message when the client has no RPK to send. In that case, there * are no (TLS 1.3 only) per-certificate extensions either, because the * [CertificateEntry] list is empty. * * In the server to client direction, or when the client had an RPK to send, * the TLS 1.3 message just prepends the length of the RPK+extensions, * while TLS <= 1.2 sends just the RPK (octet-string). * * The context must be zero-length in the server to client direction, and * must match the value recorded in the certificate request in the client * to server direction. / if (SSL_CONNECTION_IS_TLS13(sc)) { if (!PACKET_get_length_prefixed_1(pkt, &context)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } if (sc->server) { if (sc->pha_context == NULL) { if (PACKET_remaining(&context) != 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } } else { if (!PACKET_equal(&context, sc->pha_context, sc->pha_context_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } } } else { if (PACKET_remaining(&context) != 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } } } if (!PACKET_get_net_3(pkt, &cert_len) \|\| PACKET_remaining(pkt) != cert_len) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } / * The list length may be zero when there is no RPK. In the case of TLS * 1.2 this is actually the RPK length, which cannot be zero as specified, * but that breaks the ability of the client to decline client auth. We * overload the 0 RPK length to mean "no RPK". This interpretation is * also used some other (reference?) implementations, but is not supported * by the verbatim RFC7250 text. / if (cert_len == 0) return 1; if (SSL_CONNECTION_IS_TLS13(sc)) { / * With TLS 1.3, a non-empty explicit-length RPK octet-string followed * by a possibly empty extension block. / if (!PACKET_get_net_3(pkt, &spki_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (spki_len == 0) { / empty RPK / SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_EMPTY_RAW_PUBLIC_KEY); goto err; } } else { spki_len = cert_len; } if (!PACKET_get_bytes(pkt, &spki, spki_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } spkistart = spki; if ((pkey = d2i_PUBKEY_ex(NULL, &spki, spki_len, sctx->libctx, sctx->propq)) == NULL \|\| spki != (spkistart + spki_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (EVP_PKEY_missing_parameters(pkey)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS); goto err; } / Process the Extensions block / if (SSL_CONNECTION_IS_TLS13(sc)) { if (PACKET_remaining(pkt) != (cert_len - 3 - spki_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); goto err; } if (!PACKET_as_length_prefixed_2(pkt, &extensions) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!tls_collect_extensions(sc, &extensions, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY, &rawexts, NULL, 1)) { / SSLfatal already called / goto err; } / chain index is always zero and fin always 1 for RPK / if (!tls_parse_all_extensions(sc, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY, rawexts, NULL, 0, 1)) { / SSLfatal already called / goto err; } } ret = 1; if (peer_rpk != NULL) { peer_rpk = pkey; pkey = NULL; } err: OPENSSL_free(rawexts); EVP_PKEY_free(pkey); return ret; } unsigned long tls_output_rpk(SSL_CONNECTION sc, WPACKET pkt, CERT_PKEY cpk) { int pdata_len = 0; unsigned char pdata = NULL; X509_PUBKEY xpk = NULL; unsigned long ret = 0; X509 x509 = NULL; if (cpk != NULL && cpk->x509 != NULL) { x509 = cpk->x509; /* Get the RPK from the certificate / xpk = X509_get_X509_PUBKEY(cpk->x509); if (xpk == NULL) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pdata_len = i2d_X509_PUBKEY(xpk, &pdata); } else if (cpk != NULL && cpk->privatekey != NULL) { / Get the RPK from the private key / pdata_len = i2d_PUBKEY(cpk->privatekey, &pdata); } else { / The server RPK is not optional / if (sc->server) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / The client can send a zero length certificate list / if (!WPACKET_sub_memcpy_u24(pkt, pdata, pdata_len)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } return 1; } if (pdata_len <= 0) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / * TLSv1.2 is _just_ the raw public key * TLSv1.3 includes extensions, so there's a length wrapper / if (SSL_CONNECTION_IS_TLS13(sc)) { if (!WPACKET_start_sub_packet_u24(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (!WPACKET_sub_memcpy_u24(pkt, pdata, pdata_len)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (SSL_CONNECTION_IS_TLS13(sc)) { / * Only send extensions relevant to raw public keys. Until such * extensions are defined, this will be an empty set of extensions. * \|x509\| may be NULL, which raw public-key extensions need to handle. / if (!tls_construct_extensions(sc, pkt, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY, x509, 0)) { / SSLfatal() already called / goto err; } if (!WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } ret = 1; err: OPENSSL_free(pdata); return ret; } unsigned long ssl3_output_cert_chain(SSL_CONNECTION s, WPACKET pkt, CERT_PKEY cpk, int for_comp) { if (!WPACKET_start_sub_packet_u24(pkt)) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!ssl_add_cert_chain(s, pkt, cpk, for_comp)) return 0; if (!WPACKET_close(pkt)) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } /* * Tidy up after the end of a handshake. In the case of SCTP this may result * in NBIO events. If \|clearbufs\| is set then init_buf and the wbio buffer is * freed up as well. / WORK_STATE tls_finish_handshake(SSL_CONNECTION s, ossl_unused WORK_STATE wst, int clearbufs, int stop) { void (cb) (const SSL ssl, int type, int val) = NULL; int cleanuphand = s->statem.cleanuphand; SSL ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (clearbufs) { if (!SSL_CONNECTION_IS_DTLS(s) #ifndef OPENSSL_NO_SCTP /* * RFC6083: SCTP provides a reliable and in-sequence transport service for DTLS * messages that require it. Therefore, DTLS procedures for retransmissions * MUST NOT be used. * Hence the init_buf can be cleared when DTLS over SCTP as transport is used. / \|\| BIO_dgram_is_sctp(SSL_get_wbio(ssl)) #endif ) { / * We don't do this in DTLS over UDP because we may still need the init_buf * in case there are any unexpected retransmits / BUF_MEM_free(s->init_buf); s->init_buf = NULL; } if (!ssl_free_wbio_buffer(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } s->init_num = 0; } if (SSL_CONNECTION_IS_TLS13(s) && !s->server && s->post_handshake_auth == SSL_PHA_REQUESTED) s->post_handshake_auth = SSL_PHA_EXT_SENT; / * Only set if there was a Finished message and this isn't after a TLSv1.3 * post handshake exchange / if (cleanuphand) { / skipped if we just sent a HelloRequest / s->renegotiate = 0; s->new_session = 0; s->statem.cleanuphand = 0; s->ext.ticket_expected = 0; ssl3_cleanup_key_block(s); if (s->server) { / * In TLSv1.3 we update the cache as part of constructing the * NewSessionTicket / if (!SSL_CONNECTION_IS_TLS13(s)) ssl_update_cache(s, SSL_SESS_CACHE_SERVER); / N.B. s->ctx may not equal s->session_ctx / ssl_tsan_counter(sctx, &sctx->stats.sess_accept_good); s->handshake_func = ossl_statem_accept; } else { if (SSL_CONNECTION_IS_TLS13(s)) { / * We encourage applications to only use TLSv1.3 tickets once, * so we remove this one from the cache. / if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) != 0) SSL_CTX_remove_session(s->session_ctx, s->session); } else { / * In TLSv1.3 we update the cache as part of processing the * NewSessionTicket / ssl_update_cache(s, SSL_SESS_CACHE_CLIENT); } if (s->hit) ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_hit); s->handshake_func = ossl_statem_connect; ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_connect_good); } if (SSL_CONNECTION_IS_DTLS(s)) { / done with handshaking / s->d1->handshake_read_seq = 0; s->d1->handshake_write_seq = 0; s->d1->next_handshake_write_seq = 0; dtls1_clear_received_buffer(s); } } if (s->info_callback != NULL) cb = s->info_callback; else if (sctx->info_callback != NULL) cb = sctx->info_callback; / The callback may expect us to not be in init at handshake done / ossl_statem_set_in_init(s, 0); if (cb != NULL) { if (cleanuphand \|\| !SSL_CONNECTION_IS_TLS13(s) \|\| SSL_IS_FIRST_HANDSHAKE(s)) cb(ssl, SSL_CB_HANDSHAKE_DONE, 1); } if (!stop) { / If we've got more work to do we go back into init / ossl_statem_set_in_init(s, 1); return WORK_FINISHED_CONTINUE; } return WORK_FINISHED_STOP; } int tls_get_message_header(SSL_CONNECTION s, int mt) { / s->init_num < SSL3_HM_HEADER_LENGTH / int skip_message, i; uint8_t recvd_type; unsigned char p; size_t l, readbytes; SSL ssl = SSL_CONNECTION_GET_SSL(s); p = (unsigned char )s->init_buf->data; do { while (s->init_num < SSL3_HM_HEADER_LENGTH) { i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, &recvd_type, &p[s->init_num], SSL3_HM_HEADER_LENGTH - s->init_num, 0, &readbytes); if (i <= 0) { s->rwstate = SSL_READING; return 0; } if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) { /* * A ChangeCipherSpec must be a single byte and may not occur * in the middle of a handshake message. / if (s->init_num != 0 \|\| readbytes != 1 \|\| p[0] != SSL3_MT_CCS) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_CHANGE_CIPHER_SPEC); return 0; } if (s->statem.hand_state == TLS_ST_BEFORE && (s->s3.flags & TLS1_FLAGS_STATELESS) != 0) { / * We are stateless and we received a CCS. Probably this is * from a client between the first and second ClientHellos. * We should ignore this, but return an error because we do * not return success until we see the second ClientHello * with a valid cookie. / return 0; } s->s3.tmp.message_type = mt = SSL3_MT_CHANGE_CIPHER_SPEC; s->init_num = readbytes - 1; s->init_msg = s->init_buf->data; s->s3.tmp.message_size = readbytes; return 1; } else if (recvd_type != SSL3_RT_HANDSHAKE) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY); return 0; } s->init_num += readbytes; } skip_message = 0; if (!s->server) if (s->statem.hand_state != TLS_ST_OK && p[0] == SSL3_MT_HELLO_REQUEST) /* * The server may always send 'Hello Request' messages -- * we are doing a handshake anyway now, so ignore them if * their format is correct. Does not count for 'Finished' * MAC. / if (p[1] == 0 && p[2] == 0 && p[3] == 0) { s->init_num = 0; skip_message = 1; if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, p, SSL3_HM_HEADER_LENGTH, ssl, s->msg_callback_arg); } } while (skip_message); / s->init_num == SSL3_HM_HEADER_LENGTH / mt = p; s->s3.tmp.message_type = (p++); if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) { /* * Only happens with SSLv3+ in an SSLv2 backward compatible * ClientHello * * Total message size is the remaining record bytes to read * plus the SSL3_HM_HEADER_LENGTH bytes that we already read / l = s->rlayer.tlsrecs[0].length + SSL3_HM_HEADER_LENGTH; s->s3.tmp.message_size = l; s->init_msg = s->init_buf->data; s->init_num = SSL3_HM_HEADER_LENGTH; } else { n2l3(p, l); / BUF_MEM_grow takes an 'int' parameter / if (l > (INT_MAX - SSL3_HM_HEADER_LENGTH)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE); return 0; } s->s3.tmp.message_size = l; s->init_msg = s->init_buf->data + SSL3_HM_HEADER_LENGTH; s->init_num = 0; } return 1; } int tls_get_message_body(SSL_CONNECTION s, size_t len) { size_t n, readbytes; unsigned char p; int i; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->s3.tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC) { / We've already read everything in / len = (unsigned long)s->init_num; return 1; } p = s->init_msg; n = s->s3.tmp.message_size - s->init_num; while (n > 0) { i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, &p[s->init_num], n, 0, &readbytes); if (i <= 0) { s->rwstate = SSL_READING; len = 0; return 0; } s->init_num += readbytes; n -= readbytes; } / * If receiving Finished, record MAC of prior handshake messages for * Finished verification. / if ((s->init_buf->data) == SSL3_MT_FINISHED && !ssl3_take_mac(s)) { /* SSLfatal() already called / len = 0; return 0; } /* Feed this message into MAC computation. / if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) { if (!ssl3_finish_mac(s, (unsigned char )s->init_buf->data, s->init_num)) { /* SSLfatal() already called / len = 0; return 0; } if (s->msg_callback) s->msg_callback(0, SSL2_VERSION, 0, s->init_buf->data, (size_t)s->init_num, ssl, s->msg_callback_arg); } else { /* * We defer feeding in the HRR until later. We'll do it as part of * processing the message * The TLsv1.3 handshake transcript stops at the ClientFinished * message. / #define SERVER_HELLO_RANDOM_OFFSET (SSL3_HM_HEADER_LENGTH + 2) / KeyUpdate and NewSessionTicket do not need to be added / if (!SSL_CONNECTION_IS_TLS13(s) \|\| (s->s3.tmp.message_type != SSL3_MT_NEWSESSION_TICKET && s->s3.tmp.message_type != SSL3_MT_KEY_UPDATE)) { if (s->s3.tmp.message_type != SSL3_MT_SERVER_HELLO \|\| s->init_num < SERVER_HELLO_RANDOM_OFFSET + SSL3_RANDOM_SIZE \|\| memcmp(hrrrandom, s->init_buf->data + SERVER_HELLO_RANDOM_OFFSET, SSL3_RANDOM_SIZE) != 0) { if (!ssl3_finish_mac(s, (unsigned char )s->init_buf->data, s->init_num + SSL3_HM_HEADER_LENGTH)) { /* SSLfatal() already called / len = 0; return 0; } } } if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data, (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, ssl, s->msg_callback_arg); } len = s->init_num; return 1; } static const X509ERR2ALERT x509table[] = { {X509_V_ERR_APPLICATION_VERIFICATION, SSL_AD_HANDSHAKE_FAILURE}, {X509_V_ERR_CA_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_EC_KEY_EXPLICIT_PARAMS, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CA_MD_TOO_WEAK, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CERT_CHAIN_TOO_LONG, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_CERT_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED}, {X509_V_ERR_CERT_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CERT_REJECTED, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CERT_REVOKED, SSL_AD_CERTIFICATE_REVOKED}, {X509_V_ERR_CERT_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR}, {X509_V_ERR_CERT_UNTRUSTED, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CRL_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED}, {X509_V_ERR_CRL_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CRL_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR}, {X509_V_ERR_DANE_NO_MATCH, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_EE_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_EMAIL_MISMATCH, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_HOSTNAME_MISMATCH, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_INVALID_CA, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_INVALID_CALL, SSL_AD_INTERNAL_ERROR}, {X509_V_ERR_INVALID_PURPOSE, SSL_AD_UNSUPPORTED_CERTIFICATE}, {X509_V_ERR_IP_ADDRESS_MISMATCH, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_OUT_OF_MEM, SSL_AD_INTERNAL_ERROR}, {X509_V_ERR_PATH_LENGTH_EXCEEDED, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_STORE_LOOKUP, SSL_AD_INTERNAL_ERROR}, {X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_UNABLE_TO_GET_CRL, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNSPECIFIED, SSL_AD_INTERNAL_ERROR}, / Last entry; return this if we don't find the value above. / {X509_V_OK, SSL_AD_CERTIFICATE_UNKNOWN} }; int ssl_x509err2alert(int x509err) { const X509ERR2ALERT tp; for (tp = x509table; tp->x509err != X509_V_OK; ++tp) if (tp->x509err == x509err) break; return tp->alert; } int ssl_allow_compression(SSL_CONNECTION s) { if (s->options & SSL_OP_NO_COMPRESSION) return 0; return ssl_security(s, SSL_SECOP_COMPRESSION, 0, 0, NULL); } / * SSL/TLS/DTLS version comparison * * Returns * 0 if versiona is equal to versionb * 1 if versiona is greater than versionb * -1 if versiona is less than versionb / int ssl_version_cmp(const SSL_CONNECTION s, int versiona, int versionb) { int dtls = SSL_CONNECTION_IS_DTLS(s); if (versiona == versionb) return 0; if (!dtls) return versiona < versionb ? -1 : 1; return DTLS_VERSION_LT(versiona, versionb) ? -1 : 1; } typedef struct { int version; const SSL_METHOD (cmeth) (void); const SSL_METHOD (smeth) (void); } version_info; #if TLS_MAX_VERSION_INTERNAL != TLS1_3_VERSION # error Code needs update for TLS_method() support beyond TLS1_3_VERSION. #endif /* Must be in order high to low / static const version_info tls_version_table[] = { #ifndef OPENSSL_NO_TLS1_3 {TLS1_3_VERSION, tlsv1_3_client_method, tlsv1_3_server_method}, #else {TLS1_3_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_TLS1_2 {TLS1_2_VERSION, tlsv1_2_client_method, tlsv1_2_server_method}, #else {TLS1_2_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_TLS1_1 {TLS1_1_VERSION, tlsv1_1_client_method, tlsv1_1_server_method}, #else {TLS1_1_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_TLS1 {TLS1_VERSION, tlsv1_client_method, tlsv1_server_method}, #else {TLS1_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_SSL3 {SSL3_VERSION, sslv3_client_method, sslv3_server_method}, #else {SSL3_VERSION, NULL, NULL}, #endif {0, NULL, NULL}, }; #if DTLS_MAX_VERSION_INTERNAL != DTLS1_2_VERSION # error Code needs update for DTLS_method() support beyond DTLS1_2_VERSION. #endif / Must be in order high to low / static const version_info dtls_version_table[] = { #ifndef OPENSSL_NO_DTLS1_2 {DTLS1_2_VERSION, dtlsv1_2_client_method, dtlsv1_2_server_method}, #else {DTLS1_2_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_DTLS1 {DTLS1_VERSION, dtlsv1_client_method, dtlsv1_server_method}, {DTLS1_BAD_VER, dtls_bad_ver_client_method, NULL}, #else {DTLS1_VERSION, NULL, NULL}, {DTLS1_BAD_VER, NULL, NULL}, #endif {0, NULL, NULL}, }; / * ssl_method_error - Check whether an SSL_METHOD is enabled. * * @s: The SSL handle for the candidate method * @method: the intended method. * * Returns 0 on success, or an SSL error reason on failure. / static int ssl_method_error(const SSL_CONNECTION s, const SSL_METHOD method) { int version = method->version; if ((s->min_proto_version != 0 && ssl_version_cmp(s, version, s->min_proto_version) < 0) \|\| ssl_security(s, SSL_SECOP_VERSION, 0, version, NULL) == 0) return SSL_R_VERSION_TOO_LOW; if (s->max_proto_version != 0 && ssl_version_cmp(s, version, s->max_proto_version) > 0) return SSL_R_VERSION_TOO_HIGH; if ((s->options & method->mask) != 0) return SSL_R_UNSUPPORTED_PROTOCOL; if ((method->flags & SSL_METHOD_NO_SUITEB) != 0 && tls1_suiteb(s)) return SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE; return 0; } / * Only called by servers. Returns 1 if the server has a TLSv1.3 capable * certificate type, or has PSK or a certificate callback configured, or has * a servername callback configure. Otherwise returns 0. / static int is_tls13_capable(const SSL_CONNECTION s) { size_t i; int curve; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (!ossl_assert(sctx != NULL) \|\| !ossl_assert(s->session_ctx != NULL)) return 0; / * A servername callback can change the available certs, so if a servername * cb is set then we just assume TLSv1.3 will be ok / if (sctx->ext.servername_cb != NULL \|\| s->session_ctx->ext.servername_cb != NULL) return 1; #ifndef OPENSSL_NO_PSK if (s->psk_server_callback != NULL) return 1; #endif if (s->psk_find_session_cb != NULL \|\| s->cert->cert_cb != NULL) return 1; / All provider-based sig algs are required to support at least TLS1.3 / for (i = 0; i < s->ssl_pkey_num; i++) { / Skip over certs disallowed for TLSv1.3 / switch (i) { case SSL_PKEY_DSA_SIGN: case SSL_PKEY_GOST01: case SSL_PKEY_GOST12_256: case SSL_PKEY_GOST12_512: continue; default: break; } if (!ssl_has_cert(s, i)) continue; if (i != SSL_PKEY_ECC) return 1; / * Prior to TLSv1.3 sig algs allowed any curve to be used. TLSv1.3 is * more restrictive so check that our sig algs are consistent with this * EC cert. See section 4.2.3 of RFC8446. / curve = ssl_get_EC_curve_nid(s->cert->pkeys[SSL_PKEY_ECC].privatekey); if (tls_check_sigalg_curve(s, curve)) return 1; } return 0; } / * ssl_version_supported - Check that the specified `version` is supported by * `SSL ` instance * @s: The SSL handle for the candidate method * @version: Protocol version to test against * * Returns 1 when supported, otherwise 0 / int ssl_version_supported(const SSL_CONNECTION s, int version, const SSL_METHOD *meth) { const version_info vent; const version_info table; switch (SSL_CONNECTION_GET_SSL(s)->method->version) { default: / Version should match method version for non-ANY method / return ssl_version_cmp(s, version, s->version) == 0; case TLS_ANY_VERSION: table = tls_version_table; break; case DTLS_ANY_VERSION: table = dtls_version_table; break; } for (vent = table; vent->version != 0 && ssl_version_cmp(s, version, vent->version) <= 0; ++vent) { if (vent->cmeth != NULL && ssl_version_cmp(s, version, vent->version) == 0 && ssl_method_error(s, vent->cmeth()) == 0 && (!s->server \|\| version != TLS1_3_VERSION \|\| is_tls13_capable(s))) { if (meth != NULL) meth = vent->cmeth(); return 1; } } return 0; } /* * ssl_check_version_downgrade - In response to RFC7507 SCSV version * fallback indication from a client check whether we're using the highest * supported protocol version. * * @s server SSL handle. * * Returns 1 when using the highest enabled version, 0 otherwise. / int ssl_check_version_downgrade(SSL_CONNECTION s) { const version_info vent; const version_info table; SSL ssl = SSL_CONNECTION_GET_SSL(s); / * Check that the current protocol is the highest enabled version * (according to ssl->defltmethod, as version negotiation may have changed * s->method). / if (s->version == ssl->defltmeth->version) return 1; / * Apparently we're using a version-flexible SSL_METHOD (not at its * highest protocol version). / if (ssl->defltmeth->version == TLS_method()->version) table = tls_version_table; else if (ssl->defltmeth->version == DTLS_method()->version) table = dtls_version_table; else { / Unexpected state; fail closed. / return 0; } for (vent = table; vent->version != 0; ++vent) { if (vent->smeth != NULL && ssl_method_error(s, vent->smeth()) == 0) return s->version == vent->version; } return 0; } / * ssl_set_version_bound - set an upper or lower bound on the supported (D)TLS * protocols, provided the initial (D)TLS method is version-flexible. This * function sanity-checks the proposed value and makes sure the method is * version-flexible, then sets the limit if all is well. * * @method_version: The version of the current SSL_METHOD. * @version: the intended limit. * @bound: pointer to limit to be updated. * * Returns 1 on success, 0 on failure. / int ssl_set_version_bound(int method_version, int version, int bound) { int valid_tls; int valid_dtls; if (version == 0) { bound = version; return 1; } valid_tls = version >= SSL3_VERSION && version <= TLS_MAX_VERSION_INTERNAL; valid_dtls = / We support client side pre-standardisation version of DTLS / (version == DTLS1_BAD_VER) \|\| (DTLS_VERSION_LE(version, DTLS_MAX_VERSION_INTERNAL) && DTLS_VERSION_GE(version, DTLS1_VERSION)); if (!valid_tls && !valid_dtls) return 0; /- * Restrict TLS methods to TLS protocol versions. * Restrict DTLS methods to DTLS protocol versions. * Note, DTLS version numbers are decreasing, use comparison macros. * * Note that for both lower-bounds we use explicit versions, not * (D)TLS_MIN_VERSION. This is because we don't want to break user * configurations. If the MIN (supported) version ever rises, the user's * "floor" remains valid even if no longer available. We don't expect the * MAX ceiling to ever get lower, so making that variable makes sense. * * We ignore attempts to set bounds on version-inflexible methods, * returning success. / switch (method_version) { default: break; case TLS_ANY_VERSION: if (valid_tls) bound = version; break; case DTLS_ANY_VERSION: if (valid_dtls) bound = version; break; } return 1; } static void check_for_downgrade(SSL_CONNECTION s, int vers, DOWNGRADE dgrd) { if (vers == TLS1_2_VERSION && ssl_version_supported(s, TLS1_3_VERSION, NULL)) { dgrd = DOWNGRADE_TO_1_2; } else if (!SSL_CONNECTION_IS_DTLS(s) && vers < TLS1_2_VERSION /* * We need to ensure that a server that disables TLSv1.2 * (creating a hole between TLSv1.3 and TLSv1.1) can still * complete handshakes with clients that support TLSv1.2 and * below. Therefore we do not enable the sentinel if TLSv1.3 is * enabled and TLSv1.2 is not. / && ssl_version_supported(s, TLS1_2_VERSION, NULL)) { dgrd = DOWNGRADE_TO_1_1; } else { dgrd = DOWNGRADE_NONE; } } / * ssl_choose_server_version - Choose server (D)TLS version. Called when the * client HELLO is received to select the final server protocol version and * the version specific method. * * @s: server SSL handle. * * Returns 0 on success or an SSL error reason number on failure. / int ssl_choose_server_version(SSL_CONNECTION s, CLIENTHELLO_MSG hello, DOWNGRADE dgrd) { /- With version-flexible methods we have an initial state with: * * s->method->version == (D)TLS_ANY_VERSION, * s->version == (D)TLS_MAX_VERSION_INTERNAL. * * So we detect version-flexible methods via the method version, not the * handle version. / SSL ssl = SSL_CONNECTION_GET_SSL(s); int server_version = ssl->method->version; int client_version = hello->legacy_version; const version_info vent; const version_info table; int disabled = 0; RAW_EXTENSION suppversions; s->client_version = client_version; switch (server_version) { default: if (!SSL_CONNECTION_IS_TLS13(s)) { if (ssl_version_cmp(s, client_version, s->version) < 0) return SSL_R_WRONG_SSL_VERSION; dgrd = DOWNGRADE_NONE; /* * If this SSL handle is not from a version flexible method we don't * (and never did) check min/max FIPS or Suite B constraints. Hope * that's OK. It is up to the caller to not choose fixed protocol * versions they don't want. If not, then easy to fix, just return * ssl_method_error(s, s->method) / return 0; } / * Fall through if we are TLSv1.3 already (this means we must be after * a HelloRetryRequest / / fall thru / case TLS_ANY_VERSION: table = tls_version_table; break; case DTLS_ANY_VERSION: table = dtls_version_table; break; } suppversions = &hello->pre_proc_exts[TLSEXT_IDX_supported_versions]; / If we did an HRR then supported versions is mandatory / if (!suppversions->present && s->hello_retry_request != SSL_HRR_NONE) return SSL_R_UNSUPPORTED_PROTOCOL; if (suppversions->present && !SSL_CONNECTION_IS_DTLS(s)) { unsigned int candidate_vers = 0; unsigned int best_vers = 0; const SSL_METHOD best_method = NULL; PACKET versionslist; suppversions->parsed = 1; if (!PACKET_as_length_prefixed_1(&suppversions->data, &versionslist)) { /* Trailing or invalid data? / return SSL_R_LENGTH_MISMATCH; } / * The TLSv1.3 spec says the client MUST set this to TLS1_2_VERSION. * The spec only requires servers to check that it isn't SSLv3: * "Any endpoint receiving a Hello message with * ClientHello.legacy_version or ServerHello.legacy_version set to * 0x0300 MUST abort the handshake with a "protocol_version" alert." * We are slightly stricter and require that it isn't SSLv3 or lower. * We tolerate TLSv1 and TLSv1.1. / if (client_version <= SSL3_VERSION) return SSL_R_BAD_LEGACY_VERSION; while (PACKET_get_net_2(&versionslist, &candidate_vers)) { if (ssl_version_cmp(s, candidate_vers, best_vers) <= 0) continue; if (ssl_version_supported(s, candidate_vers, &best_method)) best_vers = candidate_vers; } if (PACKET_remaining(&versionslist) != 0) { / Trailing data? / return SSL_R_LENGTH_MISMATCH; } if (best_vers > 0) { if (s->hello_retry_request != SSL_HRR_NONE) { / * This is after a HelloRetryRequest so we better check that we * negotiated TLSv1.3 / if (best_vers != TLS1_3_VERSION) return SSL_R_UNSUPPORTED_PROTOCOL; return 0; } check_for_downgrade(s, best_vers, dgrd); s->version = best_vers; ssl->method = best_method; if (!ssl_set_record_protocol_version(s, best_vers)) return ERR_R_INTERNAL_ERROR; return 0; } return SSL_R_UNSUPPORTED_PROTOCOL; } / * If the supported versions extension isn't present, then the highest * version we can negotiate is TLSv1.2 / if (ssl_version_cmp(s, client_version, TLS1_3_VERSION) >= 0) client_version = TLS1_2_VERSION; / * No supported versions extension, so we just use the version supplied in * the ClientHello. / for (vent = table; vent->version != 0; ++vent) { const SSL_METHOD method; if (vent->smeth == NULL \|\| ssl_version_cmp(s, client_version, vent->version) < 0) continue; method = vent->smeth(); if (ssl_method_error(s, method) == 0) { check_for_downgrade(s, vent->version, dgrd); s->version = vent->version; ssl->method = method; if (!ssl_set_record_protocol_version(s, s->version)) return ERR_R_INTERNAL_ERROR; return 0; } disabled = 1; } return disabled ? SSL_R_UNSUPPORTED_PROTOCOL : SSL_R_VERSION_TOO_LOW; } /* * ssl_choose_client_version - Choose client (D)TLS version. Called when the * server HELLO is received to select the final client protocol version and * the version specific method. * * @s: client SSL handle. * @version: The proposed version from the server's HELLO. * @extensions: The extensions received * * Returns 1 on success or 0 on error. / int ssl_choose_client_version(SSL_CONNECTION s, int version, RAW_EXTENSION extensions) { const version_info vent; const version_info table; int ret, ver_min, ver_max, real_max, origv; SSL ssl = SSL_CONNECTION_GET_SSL(s); origv = s->version; s->version = version; /* This will overwrite s->version if the extension is present / if (!tls_parse_extension(s, TLSEXT_IDX_supported_versions, SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_SERVER_HELLO, extensions, NULL, 0)) { s->version = origv; return 0; } if (s->hello_retry_request != SSL_HRR_NONE && s->version != TLS1_3_VERSION) { s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_SSL_VERSION); return 0; } switch (ssl->method->version) { default: if (s->version != ssl->method->version) { s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_SSL_VERSION); return 0; } / * If this SSL handle is not from a version flexible method we don't * (and never did) check min/max, FIPS or Suite B constraints. Hope * that's OK. It is up to the caller to not choose fixed protocol * versions they don't want. If not, then easy to fix, just return * ssl_method_error(s, s->method) / if (!ssl_set_record_protocol_version(s, s->version)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; case TLS_ANY_VERSION: table = tls_version_table; break; case DTLS_ANY_VERSION: table = dtls_version_table; break; } ret = ssl_get_min_max_version(s, &ver_min, &ver_max, &real_max); if (ret != 0) { s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, ret); return 0; } if (ssl_version_cmp(s, s->version, ver_min) < 0 \|\| ssl_version_cmp(s, s->version, ver_max) > 0) { s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_UNSUPPORTED_PROTOCOL); return 0; } if ((s->mode & SSL_MODE_SEND_FALLBACK_SCSV) == 0) real_max = ver_max; / Check for downgrades / if (s->version == TLS1_2_VERSION && real_max > s->version) { if (memcmp(tls12downgrade, s->s3.server_random + SSL3_RANDOM_SIZE - sizeof(tls12downgrade), sizeof(tls12downgrade)) == 0) { s->version = origv; SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INAPPROPRIATE_FALLBACK); return 0; } } else if (!SSL_CONNECTION_IS_DTLS(s) && s->version < TLS1_2_VERSION && real_max > s->version) { if (memcmp(tls11downgrade, s->s3.server_random + SSL3_RANDOM_SIZE - sizeof(tls11downgrade), sizeof(tls11downgrade)) == 0) { s->version = origv; SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INAPPROPRIATE_FALLBACK); return 0; } } for (vent = table; vent->version != 0; ++vent) { if (vent->cmeth == NULL \|\| s->version != vent->version) continue; ssl->method = vent->cmeth(); if (!ssl_set_record_protocol_version(s, s->version)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_UNSUPPORTED_PROTOCOL); return 0; } / * ssl_get_min_max_version - get minimum and maximum protocol version * @s: The SSL connection * @min_version: The minimum supported version * @max_version: The maximum supported version * @real_max: The highest version below the lowest compile time version hole * where that hole lies above at least one run-time enabled * protocol. * * Work out what version we should be using for the initial ClientHello if the * version is initially (D)TLS_ANY_VERSION. We apply any explicit SSL_OP_NO_xxx * options, the MinProtocol and MaxProtocol configuration commands, any Suite B * constraints and any floor imposed by the security level here, * so we don't advertise the wrong protocol version to only reject the outcome later. * * Computing the right floor matters. If, e.g., TLS 1.0 and 1.2 are enabled, * TLS 1.1 is disabled, but the security level, Suite-B and/or MinProtocol * only allow TLS 1.2, we want to advertise TLS1.2, not TLS1. * * Returns 0 on success or an SSL error reason number on failure. On failure * min_version and max_version will also be set to 0. / int ssl_get_min_max_version(const SSL_CONNECTION s, int min_version, int max_version, int real_max) { int version, tmp_real_max; int hole; const SSL_METHOD method; const version_info table; const version_info vent; const SSL ssl = SSL_CONNECTION_GET_SSL(s); switch (ssl->method->version) { default: / * If this SSL handle is not from a version flexible method we don't * (and never did) check min/max FIPS or Suite B constraints. Hope * that's OK. It is up to the caller to not choose fixed protocol * versions they don't want. If not, then easy to fix, just return * ssl_method_error(s, s->method) / min_version = max_version = s->version; / * Providing a real_max only makes sense where we're using a version * flexible method. / if (!ossl_assert(real_max == NULL)) return ERR_R_INTERNAL_ERROR; return 0; case TLS_ANY_VERSION: table = tls_version_table; break; case DTLS_ANY_VERSION: table = dtls_version_table; break; } / * SSL_OP_NO_X disables all protocols above X if there are some protocols * below X enabled. This is required in order to maintain the "version * capability" vector contiguous. Any versions with a NULL client method * (protocol version client is disabled at compile-time) is also a "hole". * * Our initial state is hole == 1, version == 0. That is, versions above * the first version in the method table are disabled (a "hole" above * the valid protocol entries) and we don't have a selected version yet. * * Whenever "hole == 1", and we hit an enabled method, its version becomes * the selected version. We're no longer in a hole, so "hole" becomes 0. * * If "hole == 0" and we hit an enabled method, we support a contiguous * range of at least two methods. If we hit a disabled method, * then hole becomes true again, but nothing else changes yet, * because all the remaining methods may be disabled too. * If we again hit an enabled method after the new hole, it becomes * selected, as we start from scratch. / min_version = version = 0; hole = 1; if (real_max != NULL) real_max = 0; tmp_real_max = 0; for (vent = table; vent->version != 0; ++vent) { / * A table entry with a NULL client method is still a hole in the * "version capability" vector. / if (vent->cmeth == NULL) { hole = 1; tmp_real_max = 0; continue; } method = vent->cmeth(); if (hole == 1 && tmp_real_max == 0) tmp_real_max = vent->version; if (ssl_method_error(s, method) != 0) { hole = 1; } else if (!hole) { min_version = method->version; } else { if (real_max != NULL && tmp_real_max != 0) real_max = tmp_real_max; version = method->version; min_version = version; hole = 0; } } max_version = version; / Fail if everything is disabled / if (version == 0) return SSL_R_NO_PROTOCOLS_AVAILABLE; return 0; } / * ssl_set_client_hello_version - Work out what version we should be using for * the initial ClientHello.legacy_version field. * * @s: client SSL handle. * * Returns 0 on success or an SSL error reason number on failure. / int ssl_set_client_hello_version(SSL_CONNECTION s) { int ver_min, ver_max, ret; /* * In a renegotiation we always send the same client_version that we sent * last time, regardless of which version we eventually negotiated. / if (!SSL_IS_FIRST_HANDSHAKE(s)) return 0; ret = ssl_get_min_max_version(s, &ver_min, &ver_max, NULL); if (ret != 0) return ret; s->version = ver_max; if (SSL_CONNECTION_IS_DTLS(s)) { if (ver_max == DTLS1_BAD_VER) { / * Even though this is technically before version negotiation, * because we have asked for DTLS1_BAD_VER we will never negotiate * anything else, and this has impacts on the record layer for when * we read the ServerHello. So we need to tell the record layer * about this immediately. / if (!ssl_set_record_protocol_version(s, ver_max)) return 0; } } else if (ver_max > TLS1_2_VERSION) { / TLS1.3 always uses TLS1.2 in the legacy_version field / ver_max = TLS1_2_VERSION; } s->client_version = ver_max; return 0; } / * Checks a list of \|groups\| to determine if the \|group_id\| is in it. If it is * and \|checkallow\| is 1 then additionally check if the group is allowed to be * used. Returns 1 if the group is in the list (and allowed if \|checkallow\| is * 1) or 0 otherwise. / int check_in_list(SSL_CONNECTION s, uint16_t group_id, const uint16_t groups, size_t num_groups, int checkallow) { size_t i; if (groups == NULL \|\| num_groups == 0) return 0; for (i = 0; i < num_groups; i++) { uint16_t group = groups[i]; if (group_id == group && (!checkallow \|\| tls_group_allowed(s, group, SSL_SECOP_CURVE_CHECK))) { return 1; } } return 0; } / Replace ClientHello1 in the transcript hash with a synthetic message / int create_synthetic_message_hash(SSL_CONNECTION s, const unsigned char hashval, size_t hashlen, const unsigned char hrr, size_t hrrlen) { unsigned char hashvaltmp[EVP_MAX_MD_SIZE]; unsigned char msghdr[SSL3_HM_HEADER_LENGTH]; memset(msghdr, 0, sizeof(msghdr)); if (hashval == NULL) { hashval = hashvaltmp; hashlen = 0; /* Get the hash of the initial ClientHello / if (!ssl3_digest_cached_records(s, 0) \|\| !ssl_handshake_hash(s, hashvaltmp, sizeof(hashvaltmp), &hashlen)) { / SSLfatal() already called / return 0; } } / Reinitialise the transcript hash / if (!ssl3_init_finished_mac(s)) { / SSLfatal() already called / return 0; } / Inject the synthetic message_hash message / msghdr[0] = SSL3_MT_MESSAGE_HASH; msghdr[SSL3_HM_HEADER_LENGTH - 1] = (unsigned char)hashlen; if (!ssl3_finish_mac(s, msghdr, SSL3_HM_HEADER_LENGTH) \|\| !ssl3_finish_mac(s, hashval, hashlen)) { / SSLfatal() already called / return 0; } / * Now re-inject the HRR and current message if appropriate (we just deleted * it when we reinitialised the transcript hash above). Only necessary after * receiving a ClientHello2 with a cookie. / if (hrr != NULL && (!ssl3_finish_mac(s, hrr, hrrlen) \|\| !ssl3_finish_mac(s, (unsigned char )s->init_buf->data, s->s3.tmp.message_size + SSL3_HM_HEADER_LENGTH))) { /* SSLfatal() already called / return 0; } return 1; } static int ca_dn_cmp(const X509_NAME const a, const X509_NAME const b) { return X509_NAME_cmp(a, b); } int parse_ca_names(SSL_CONNECTION s, PACKET pkt) { STACK_OF(X509_NAME) ca_sk = sk_X509_NAME_new(ca_dn_cmp); X509_NAME xn = NULL; PACKET cadns; if (ca_sk == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } / get the CA RDNs / if (!PACKET_get_length_prefixed_2(pkt, &cadns)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } while (PACKET_remaining(&cadns)) { const unsigned char namestart, namebytes; unsigned int name_len; if (!PACKET_get_net_2(&cadns, &name_len) \|\| !PACKET_get_bytes(&cadns, &namebytes, name_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } namestart = namebytes; if ((xn = d2i_X509_NAME(NULL, &namebytes, name_len)) == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_ASN1_LIB); goto err; } if (namebytes != (namestart + name_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CA_DN_LENGTH_MISMATCH); goto err; } if (!sk_X509_NAME_push(ca_sk, xn)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } xn = NULL; } sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free); s->s3.tmp.peer_ca_names = ca_sk; return 1; err: sk_X509_NAME_pop_free(ca_sk, X509_NAME_free); X509_NAME_free(xn); return 0; } const STACK_OF(X509_NAME) get_ca_names(SSL_CONNECTION s) { const STACK_OF(X509_NAME) ca_sk = NULL; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->server) { ca_sk = SSL_get_client_CA_list(ssl); if (ca_sk != NULL && sk_X509_NAME_num(ca_sk) == 0) ca_sk = NULL; } if (ca_sk == NULL) ca_sk = SSL_get0_CA_list(ssl); return ca_sk; } int construct_ca_names(SSL_CONNECTION s, const STACK_OF(X509_NAME) ca_sk, WPACKET pkt) { /* Start sub-packet for client CA list / if (!WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((ca_sk != NULL) && !(s->options & SSL_OP_DISABLE_TLSEXT_CA_NAMES)) { int i; for (i = 0; i < sk_X509_NAME_num(ca_sk); i++) { unsigned char namebytes; X509_NAME name = sk_X509_NAME_value(ca_sk, i); int namelen; if (name == NULL \|\| (namelen = i2d_X509_NAME(name, NULL)) < 0 \|\| !WPACKET_sub_allocate_bytes_u16(pkt, namelen, &namebytes) \|\| i2d_X509_NAME(name, &namebytes) != namelen) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } / Create a buffer containing data to be signed for server key exchange / size_t construct_key_exchange_tbs(SSL_CONNECTION s, unsigned char *ptbs, const void param, size_t paramlen) { size_t tbslen = 2 * SSL3_RANDOM_SIZE + paramlen; unsigned char tbs = OPENSSL_malloc(tbslen); if (tbs == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } memcpy(tbs, s->s3.client_random, SSL3_RANDOM_SIZE); memcpy(tbs + SSL3_RANDOM_SIZE, s->s3.server_random, SSL3_RANDOM_SIZE); memcpy(tbs + SSL3_RANDOM_SIZE 2, param, paramlen); ptbs = tbs; return tbslen; } / * Saves the current handshake digest for Post-Handshake Auth, * Done after ClientFinished is processed, done exactly once / int tls13_save_handshake_digest_for_pha(SSL_CONNECTION s) { if (s->pha_dgst == NULL) { if (!ssl3_digest_cached_records(s, 1)) /* SSLfatal() already called / return 0; s->pha_dgst = EVP_MD_CTX_new(); if (s->pha_dgst == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!EVP_MD_CTX_copy_ex(s->pha_dgst, s->s3.handshake_dgst)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_MD_CTX_free(s->pha_dgst); s->pha_dgst = NULL; return 0; } } return 1; } / * Restores the Post-Handshake Auth handshake digest * Done just before sending/processing the Cert Request / int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION s) { if (s->pha_dgst == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!EVP_MD_CTX_copy_ex(s->s3.handshake_dgst, s->pha_dgst)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } #ifndef OPENSSL_NO_COMP_ALG MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION sc, PACKET pkt, PACKET tmppkt, BUF_MEM buf) { MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; int comp_alg; COMP_METHOD method = NULL; COMP_CTX comp = NULL; size_t expected_length; size_t comp_length; int i; int found = 0; if (buf == NULL) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!PACKET_get_net_2(pkt, (unsigned int)&comp_alg)) { SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, ERR_R_INTERNAL_ERROR); goto err; } / If we have a prefs list, make sure the algorithm is in it / if (sc->cert_comp_prefs[0] != TLSEXT_comp_cert_none) { for (i = 0; sc->cert_comp_prefs[i] != TLSEXT_comp_cert_none; i++) { if (sc->cert_comp_prefs[i] == comp_alg) { found = 1; break; } } if (!found) { SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_COMPRESSION_ALGORITHM); goto err; } } if (!ossl_comp_has_alg(comp_alg)) { SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_COMPRESSION_ALGORITHM); goto err; } switch (comp_alg) { case TLSEXT_comp_cert_zlib: method = COMP_zlib_oneshot(); break; case TLSEXT_comp_cert_brotli: method = COMP_brotli_oneshot(); break; case TLSEXT_comp_cert_zstd: method = COMP_zstd_oneshot(); break; default: SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_COMPRESSION_ALGORITHM); goto err; } if ((comp = COMP_CTX_new(method)) == NULL \|\| !PACKET_get_net_3_len(pkt, &expected_length) \|\| !PACKET_get_net_3_len(pkt, &comp_length) \|\| PACKET_remaining(pkt) != comp_length \|\| !BUF_MEM_grow(buf, expected_length) \|\| !PACKET_buf_init(tmppkt, (unsigned char )buf->data, expected_length) \|\| COMP_expand_block(comp, (unsigned char )buf->data, expected_length, (unsigned char)PACKET_data(pkt), comp_length) != (int)expected_length) { SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_DECOMPRESSION); goto err; } ret = MSG_PROCESS_CONTINUE_PROCESSING; err: COMP_CTX_free(comp); return ret; } #endif
./openssl/ssl/statem/statem_dtls.c	/* * Copyright 2005-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <assert.h> #include <limits.h> #include <string.h> #include <stdio.h> #include "../ssl_local.h" #include "statem_local.h" #include "internal/cryptlib.h" #include <openssl/buffer.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/x509.h> #define RSMBLY_BITMASK_SIZE(msg_len) (((msg_len) + 7) / 8) #define RSMBLY_BITMASK_MARK(bitmask, start, end) { \ if ((end) - (start) <= 8) { \ long ii; \ for (ii = (start); ii < (end); ii++) bitmask[((ii) >> 3)] \|= (1 << ((ii) & 7)); \ } else { \ long ii; \ bitmask[((start) >> 3)] \|= bitmask_start_values[((start) & 7)]; \ for (ii = (((start) >> 3) + 1); ii < ((((end) - 1)) >> 3); ii++) bitmask[ii] = 0xff; \ bitmask[(((end) - 1) >> 3)] \|= bitmask_end_values[((end) & 7)]; \ } } #define RSMBLY_BITMASK_IS_COMPLETE(bitmask, msg_len, is_complete) { \ long ii; \ is_complete = 1; \ if (bitmask[(((msg_len) - 1) >> 3)] != bitmask_end_values[((msg_len) & 7)]) is_complete = 0; \ if (is_complete) for (ii = (((msg_len) - 1) >> 3) - 1; ii >= 0 ; ii--) \ if (bitmask[ii] != 0xff) { is_complete = 0; break; } } static const unsigned char bitmask_start_values[] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 }; static const unsigned char bitmask_end_values[] = { 0xff, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f }; static void dtls1_fix_message_header(SSL_CONNECTION s, size_t frag_off, size_t frag_len); static unsigned char dtls1_write_message_header(SSL_CONNECTION s, unsigned char p); static void dtls1_set_message_header_int(SSL_CONNECTION s, unsigned char mt, size_t len, unsigned short seq_num, size_t frag_off, size_t frag_len); static int dtls_get_reassembled_message(SSL_CONNECTION s, int errtype, size_t len); static hm_fragment dtls1_hm_fragment_new(size_t frag_len, int reassembly) { hm_fragment frag = NULL; unsigned char buf = NULL; unsigned char bitmask = NULL; if ((frag = OPENSSL_zalloc(sizeof(frag))) == NULL) return NULL; if (frag_len) { if ((buf = OPENSSL_malloc(frag_len)) == NULL) { OPENSSL_free(frag); return NULL; } } /* zero length fragment gets zero frag->fragment / frag->fragment = buf; / Initialize reassembly bitmask if necessary / if (reassembly) { bitmask = OPENSSL_zalloc(RSMBLY_BITMASK_SIZE(frag_len)); if (bitmask == NULL) { OPENSSL_free(buf); OPENSSL_free(frag); return NULL; } } frag->reassembly = bitmask; return frag; } void dtls1_hm_fragment_free(hm_fragment frag) { if (!frag) return; OPENSSL_free(frag->fragment); OPENSSL_free(frag->reassembly); OPENSSL_free(frag); } /* * send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or * SSL3_RT_CHANGE_CIPHER_SPEC) / int dtls1_do_write(SSL_CONNECTION s, uint8_t type) { int ret; size_t written; size_t curr_mtu; int retry = 1; size_t len, frag_off, overhead, used_len; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (!dtls1_query_mtu(s)) return -1; if (s->d1->mtu < dtls1_min_mtu(s)) / should have something reasonable now / return -1; if (s->init_off == 0 && type == SSL3_RT_HANDSHAKE) { if (!ossl_assert(s->init_num == s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH)) return -1; } overhead = s->rlayer.wrlmethod->get_max_record_overhead(s->rlayer.wrl); frag_off = 0; s->rwstate = SSL_NOTHING; / s->init_num shouldn't ever be < 0...but just in case / while (s->init_num > 0) { if (type == SSL3_RT_HANDSHAKE && s->init_off != 0) { / We must be writing a fragment other than the first one / if (frag_off > 0) { / This is the first attempt at writing out this fragment / if (s->init_off <= DTLS1_HM_HEADER_LENGTH) { / * Each fragment that was already sent must at least have * contained the message header plus one other byte. * Therefore \|init_off\| must have progressed by at least * \|DTLS1_HM_HEADER_LENGTH + 1\| bytes. If not something went * wrong. / return -1; } / * Adjust \|init_off\| and \|init_num\| to allow room for a new * message header for this fragment. / s->init_off -= DTLS1_HM_HEADER_LENGTH; s->init_num += DTLS1_HM_HEADER_LENGTH; } else { / * We must have been called again after a retry so use the * fragment offset from our last attempt. We do not need * to adjust \|init_off\| and \|init_num\| as above, because * that should already have been done before the retry. / frag_off = s->d1->w_msg_hdr.frag_off; } } used_len = BIO_wpending(s->wbio) + overhead; if (s->d1->mtu > used_len) curr_mtu = s->d1->mtu - used_len; else curr_mtu = 0; if (curr_mtu <= DTLS1_HM_HEADER_LENGTH) { / * grr.. we could get an error if MTU picked was wrong / ret = BIO_flush(s->wbio); if (ret <= 0) { s->rwstate = SSL_WRITING; return ret; } if (s->d1->mtu > overhead + DTLS1_HM_HEADER_LENGTH) { curr_mtu = s->d1->mtu - overhead; } else { / Shouldn't happen / return -1; } } / * We just checked that s->init_num > 0 so this cast should be safe / if (((unsigned int)s->init_num) > curr_mtu) len = curr_mtu; else len = s->init_num; if (len > ssl_get_max_send_fragment(s)) len = ssl_get_max_send_fragment(s); / * XDTLS: this function is too long. split out the CCS part / if (type == SSL3_RT_HANDSHAKE) { if (len < DTLS1_HM_HEADER_LENGTH) { / * len is so small that we really can't do anything sensible * so fail / return -1; } dtls1_fix_message_header(s, frag_off, len - DTLS1_HM_HEADER_LENGTH); dtls1_write_message_header(s, (unsigned char )&s->init_buf-> data[s->init_off]); } ret = dtls1_write_bytes(s, type, &s->init_buf->data[s->init_off], len, &written); if (ret <= 0) { /* * might need to update MTU here, but we don't know which * previous packet caused the failure -- so can't really * retransmit anything. continue as if everything is fine and * wait for an alert to handle the retransmit / if (retry && BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_MTU_EXCEEDED, 0, NULL) > 0) { if (!(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) { if (!dtls1_query_mtu(s)) return -1; / Have one more go / retry = 0; } else return -1; } else { return -1; } } else { / * bad if this assert fails, only part of the handshake message * got sent. but why would this happen? / if (!ossl_assert(len == written)) return -1; / * We should not exceed the MTU size. If compression is in use * then the max record overhead calculation is unreliable so we do * not check in that case. We use assert rather than ossl_assert * because in a production build, if this assert were ever to fail, * then the best thing to do is probably carry on regardless. / assert(s->s3.tmp.new_compression != NULL \|\| BIO_wpending(s->wbio) <= (int)s->d1->mtu); if (type == SSL3_RT_HANDSHAKE && !s->d1->retransmitting) { / * should not be done for 'Hello Request's, but in that case * we'll ignore the result anyway / unsigned char p = (unsigned char )&s->init_buf->data[s->init_off]; const struct hm_header_st msg_hdr = &s->d1->w_msg_hdr; size_t xlen; if (frag_off == 0 && s->version != DTLS1_BAD_VER) { /* * reconstruct message header is if it is being sent in * single fragment / p++ = msg_hdr->type; l2n3(msg_hdr->msg_len, p); s2n(msg_hdr->seq, p); l2n3(0, p); l2n3(msg_hdr->msg_len, p); p -= DTLS1_HM_HEADER_LENGTH; xlen = written; } else { p += DTLS1_HM_HEADER_LENGTH; xlen = written - DTLS1_HM_HEADER_LENGTH; } if (!ssl3_finish_mac(s, p, xlen)) return -1; } if (written == s->init_num) { if (s->msg_callback) s->msg_callback(1, s->version, type, s->init_buf->data, (size_t)(s->init_off + s->init_num), ssl, s->msg_callback_arg); s->init_off = 0; /* done writing this message / s->init_num = 0; return 1; } s->init_off += written; s->init_num -= written; written -= DTLS1_HM_HEADER_LENGTH; frag_off += written; / * We save the fragment offset for the next fragment so we have it * available in case of an IO retry. We don't know the length of the * next fragment yet so just set that to 0 for now. It will be * updated again later. / dtls1_fix_message_header(s, frag_off, 0); } } return 0; } int dtls_get_message(SSL_CONNECTION s, int mt) { struct hm_header_st msg_hdr; unsigned char p; size_t msg_len; size_t tmplen; int errtype; msg_hdr = &s->d1->r_msg_hdr; memset(msg_hdr, 0, sizeof(msg_hdr)); again: if (!dtls_get_reassembled_message(s, &errtype, &tmplen)) { if (errtype == DTLS1_HM_BAD_FRAGMENT \|\| errtype == DTLS1_HM_FRAGMENT_RETRY) { /* bad fragment received / goto again; } return 0; } mt = s->s3.tmp.message_type; p = (unsigned char )s->init_buf->data; if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { if (s->msg_callback) { s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, p, 1, SSL_CONNECTION_GET_SSL(s), s->msg_callback_arg); } /* * This isn't a real handshake message so skip the processing below. / return 1; } msg_len = msg_hdr->msg_len; / reconstruct message header / (p++) = msg_hdr->type; l2n3(msg_len, p); s2n(msg_hdr->seq, p); l2n3(0, p); l2n3(msg_len, p); memset(msg_hdr, 0, sizeof(msg_hdr)); s->d1->handshake_read_seq++; s->init_msg = s->init_buf->data + DTLS1_HM_HEADER_LENGTH; return 1; } / * Actually we already have the message body - but this is an opportunity for * DTLS to do any further processing it wants at the same point that TLS would * be asked for the message body. / int dtls_get_message_body(SSL_CONNECTION s, size_t len) { unsigned char msg = (unsigned char )s->init_buf->data; size_t msg_len = s->init_num + DTLS1_HM_HEADER_LENGTH; if (s->s3.tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC) { / Nothing to be done / goto end; } / * If receiving Finished, record MAC of prior handshake messages for * Finished verification. / if ((s->init_buf->data) == SSL3_MT_FINISHED && !ssl3_take_mac(s)) { /* SSLfatal() already called / return 0; } if (s->version == DTLS1_BAD_VER) { msg += DTLS1_HM_HEADER_LENGTH; msg_len -= DTLS1_HM_HEADER_LENGTH; } if (!ssl3_finish_mac(s, msg, msg_len)) return 0; if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data, s->init_num + DTLS1_HM_HEADER_LENGTH, SSL_CONNECTION_GET_SSL(s), s->msg_callback_arg); end: len = s->init_num; return 1; } /* * dtls1_max_handshake_message_len returns the maximum number of bytes * permitted in a DTLS handshake message for \|s\|. The minimum is 16KB, but * may be greater if the maximum certificate list size requires it. / static size_t dtls1_max_handshake_message_len(const SSL_CONNECTION s) { size_t max_len = DTLS1_HM_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH; if (max_len < s->max_cert_list) return s->max_cert_list; return max_len; } static int dtls1_preprocess_fragment(SSL_CONNECTION s, struct hm_header_st msg_hdr) { size_t frag_off, frag_len, msg_len; msg_len = msg_hdr->msg_len; frag_off = msg_hdr->frag_off; frag_len = msg_hdr->frag_len; /* sanity checking / if ((frag_off + frag_len) > msg_len \|\| msg_len > dtls1_max_handshake_message_len(s)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE); return 0; } if (s->d1->r_msg_hdr.frag_off == 0) { / first fragment / / * msg_len is limited to 2^24, but is effectively checked against * dtls_max_handshake_message_len(s) above / if (!BUF_MEM_grow_clean(s->init_buf, msg_len + DTLS1_HM_HEADER_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BUF_LIB); return 0; } s->s3.tmp.message_size = msg_len; s->d1->r_msg_hdr.msg_len = msg_len; s->s3.tmp.message_type = msg_hdr->type; s->d1->r_msg_hdr.type = msg_hdr->type; s->d1->r_msg_hdr.seq = msg_hdr->seq; } else if (msg_len != s->d1->r_msg_hdr.msg_len) { / * They must be playing with us! BTW, failure to enforce upper limit * would open possibility for buffer overrun. / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE); return 0; } return 1; } / * Returns 1 if there is a buffered fragment available, 0 if not, or -1 on a * fatal error. / static int dtls1_retrieve_buffered_fragment(SSL_CONNECTION s, size_t len) { /- * (0) check whether the desired fragment is available * if so: * (1) copy over the fragment to s->init_buf->data[] * (2) update s->init_num / pitem item; piterator iter; hm_fragment frag; int ret; int chretran = 0; iter = pqueue_iterator(s->d1->buffered_messages); do { item = pqueue_next(&iter); if (item == NULL) return 0; frag = (hm_fragment )item->data; if (frag->msg_header.seq < s->d1->handshake_read_seq) { pitem next; hm_fragment nextfrag; if (!s->server \|\| frag->msg_header.seq != 0 \|\| s->d1->handshake_read_seq != 1 \|\| s->statem.hand_state != DTLS_ST_SW_HELLO_VERIFY_REQUEST) { /* * This is a stale message that has been buffered so clear it. * It is safe to pop this message from the queue even though * we have an active iterator / pqueue_pop(s->d1->buffered_messages); dtls1_hm_fragment_free(frag); pitem_free(item); item = NULL; frag = NULL; } else { / * We have fragments for a ClientHello without a cookie, * even though we have sent a HelloVerifyRequest. It is possible * that the HelloVerifyRequest got lost and this is a * retransmission of the original ClientHello / next = pqueue_next(&iter); if (next != NULL) { nextfrag = (hm_fragment )next->data; if (nextfrag->msg_header.seq == s->d1->handshake_read_seq) { /* * We have fragments for both a ClientHello without * cookie and one with. Ditch the one without. / pqueue_pop(s->d1->buffered_messages); dtls1_hm_fragment_free(frag); pitem_free(item); item = next; frag = nextfrag; } else { chretran = 1; } } else { chretran = 1; } } } } while (item == NULL); / Don't return if reassembly still in progress / if (frag->reassembly != NULL) return 0; if (s->d1->handshake_read_seq == frag->msg_header.seq \|\| chretran) { size_t frag_len = frag->msg_header.frag_len; pqueue_pop(s->d1->buffered_messages); / Calls SSLfatal() as required / ret = dtls1_preprocess_fragment(s, &frag->msg_header); if (ret && frag->msg_header.frag_len > 0) { unsigned char p = (unsigned char )s->init_buf->data + DTLS1_HM_HEADER_LENGTH; memcpy(&p[frag->msg_header.frag_off], frag->fragment, frag->msg_header.frag_len); } dtls1_hm_fragment_free(frag); pitem_free(item); if (ret) { if (chretran) { / * We got a new ClientHello with a message sequence of 0. * Reset the read/write sequences back to the beginning. * We process it like this is the first time we've seen a * ClientHello from the client. / s->d1->handshake_read_seq = 0; s->d1->next_handshake_write_seq = 0; } len = frag_len; return 1; } /* Fatal error / s->init_num = 0; return -1; } else { return 0; } } static int dtls1_reassemble_fragment(SSL_CONNECTION s, const struct hm_header_st msg_hdr) { hm_fragment frag = NULL; pitem item = NULL; int i = -1, is_complete; unsigned char seq64be[8]; size_t frag_len = msg_hdr->frag_len; size_t readbytes; SSL ssl = SSL_CONNECTION_GET_SSL(s); if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len \|\| msg_hdr->msg_len > dtls1_max_handshake_message_len(s)) goto err; if (frag_len == 0) { return DTLS1_HM_FRAGMENT_RETRY; } /* Try to find item in queue / memset(seq64be, 0, sizeof(seq64be)); seq64be[6] = (unsigned char)(msg_hdr->seq >> 8); seq64be[7] = (unsigned char)msg_hdr->seq; item = pqueue_find(s->d1->buffered_messages, seq64be); if (item == NULL) { frag = dtls1_hm_fragment_new(msg_hdr->msg_len, 1); if (frag == NULL) goto err; memcpy(&(frag->msg_header), msg_hdr, sizeof(msg_hdr)); frag->msg_header.frag_len = frag->msg_header.msg_len; frag->msg_header.frag_off = 0; } else { frag = (hm_fragment )item->data; if (frag->msg_header.msg_len != msg_hdr->msg_len) { item = NULL; frag = NULL; goto err; } } / * If message is already reassembled, this must be a retransmit and can * be dropped. In this case item != NULL and so frag does not need to be * freed. / if (frag->reassembly == NULL) { unsigned char devnull[256]; while (frag_len) { i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, devnull, frag_len > sizeof(devnull) ? sizeof(devnull) : frag_len, 0, &readbytes); if (i <= 0) goto err; frag_len -= readbytes; } return DTLS1_HM_FRAGMENT_RETRY; } / read the body of the fragment (header has already been read / i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, frag->fragment + msg_hdr->frag_off, frag_len, 0, &readbytes); if (i <= 0 \|\| readbytes != frag_len) i = -1; if (i <= 0) goto err; RSMBLY_BITMASK_MARK(frag->reassembly, (long)msg_hdr->frag_off, (long)(msg_hdr->frag_off + frag_len)); if (!ossl_assert(msg_hdr->msg_len > 0)) goto err; RSMBLY_BITMASK_IS_COMPLETE(frag->reassembly, (long)msg_hdr->msg_len, is_complete); if (is_complete) { OPENSSL_free(frag->reassembly); frag->reassembly = NULL; } if (item == NULL) { item = pitem_new(seq64be, frag); if (item == NULL) { i = -1; goto err; } item = pqueue_insert(s->d1->buffered_messages, item); / * pqueue_insert fails iff a duplicate item is inserted. However, * \|item\| cannot be a duplicate. If it were, \|pqueue_find\|, above, * would have returned it and control would never have reached this * branch. / if (!ossl_assert(item != NULL)) goto err; } return DTLS1_HM_FRAGMENT_RETRY; err: if (item == NULL) dtls1_hm_fragment_free(frag); return -1; } static int dtls1_process_out_of_seq_message(SSL_CONNECTION s, const struct hm_header_st msg_hdr) { int i = -1; hm_fragment frag = NULL; pitem item = NULL; unsigned char seq64be[8]; size_t frag_len = msg_hdr->frag_len; size_t readbytes; SSL ssl = SSL_CONNECTION_GET_SSL(s); if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len) goto err; /* Try to find item in queue, to prevent duplicate entries / memset(seq64be, 0, sizeof(seq64be)); seq64be[6] = (unsigned char)(msg_hdr->seq >> 8); seq64be[7] = (unsigned char)msg_hdr->seq; item = pqueue_find(s->d1->buffered_messages, seq64be); / * If we already have an entry and this one is a fragment, don't discard * it and rather try to reassemble it. / if (item != NULL && frag_len != msg_hdr->msg_len) item = NULL; / * Discard the message if sequence number was already there, is too far * in the future, already in the queue or if we received a FINISHED * before the SERVER_HELLO, which then must be a stale retransmit. / if (msg_hdr->seq <= s->d1->handshake_read_seq \|\| msg_hdr->seq > s->d1->handshake_read_seq + 10 \|\| item != NULL \|\| (s->d1->handshake_read_seq == 0 && msg_hdr->type == SSL3_MT_FINISHED)) { unsigned char devnull[256]; while (frag_len) { i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, devnull, frag_len > sizeof(devnull) ? sizeof(devnull) : frag_len, 0, &readbytes); if (i <= 0) goto err; frag_len -= readbytes; } } else { if (frag_len != msg_hdr->msg_len) { return dtls1_reassemble_fragment(s, msg_hdr); } if (frag_len > dtls1_max_handshake_message_len(s)) goto err; frag = dtls1_hm_fragment_new(frag_len, 0); if (frag == NULL) goto err; memcpy(&(frag->msg_header), msg_hdr, sizeof(msg_hdr)); if (frag_len) { /* * read the body of the fragment (header has already been read / i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, frag->fragment, frag_len, 0, &readbytes); if (i<=0 \|\| readbytes != frag_len) i = -1; if (i <= 0) goto err; } item = pitem_new(seq64be, frag); if (item == NULL) goto err; item = pqueue_insert(s->d1->buffered_messages, item); / * pqueue_insert fails iff a duplicate item is inserted. However, * \|item\| cannot be a duplicate. If it were, \|pqueue_find\|, above, * would have returned it. Then, either \|frag_len\| != * \|msg_hdr->msg_len\| in which case \|item\| is set to NULL and it will * have been processed with \|dtls1_reassemble_fragment\|, above, or * the record will have been discarded. / if (!ossl_assert(item != NULL)) goto err; } return DTLS1_HM_FRAGMENT_RETRY; err: if (item == NULL) dtls1_hm_fragment_free(frag); return 0; } static int dtls_get_reassembled_message(SSL_CONNECTION s, int errtype, size_t len) { unsigned char wire[DTLS1_HM_HEADER_LENGTH]; size_t mlen, frag_off, frag_len; int i, ret; uint8_t recvd_type; struct hm_header_st msg_hdr; size_t readbytes; SSL ssl = SSL_CONNECTION_GET_SSL(s); int chretran = 0; errtype = 0; redo: /* see if we have the required fragment already / ret = dtls1_retrieve_buffered_fragment(s, &frag_len); if (ret < 0) { / SSLfatal() already called / return 0; } if (ret > 0) { s->init_num = frag_len; len = frag_len; return 1; } /* read handshake message header / i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, &recvd_type, wire, DTLS1_HM_HEADER_LENGTH, 0, &readbytes); if (i <= 0) { / nbio, or an error / s->rwstate = SSL_READING; len = 0; return 0; } if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) { if (wire[0] != SSL3_MT_CCS) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_CHANGE_CIPHER_SPEC); goto f_err; } memcpy(s->init_buf->data, wire, readbytes); s->init_num = readbytes - 1; s->init_msg = s->init_buf->data + 1; s->s3.tmp.message_type = SSL3_MT_CHANGE_CIPHER_SPEC; s->s3.tmp.message_size = readbytes - 1; len = readbytes - 1; return 1; } / Handshake fails if message header is incomplete / if (readbytes != DTLS1_HM_HEADER_LENGTH) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto f_err; } / parse the message fragment header / dtls1_get_message_header(wire, &msg_hdr); mlen = msg_hdr.msg_len; frag_off = msg_hdr.frag_off; frag_len = msg_hdr.frag_len; / * We must have at least frag_len bytes left in the record to be read. * Fragments must not span records. / if (frag_len > s->rlayer.tlsrecs[s->rlayer.curr_rec].length) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_LENGTH); goto f_err; } / * if this is a future (or stale) message it gets buffered * (or dropped)--no further processing at this time * While listening, we accept seq 1 (ClientHello with cookie) * although we're still expecting seq 0 (ClientHello) / if (msg_hdr.seq != s->d1->handshake_read_seq) { if (!s->server \|\| msg_hdr.seq != 0 \|\| s->d1->handshake_read_seq != 1 \|\| wire[0] != SSL3_MT_CLIENT_HELLO \|\| s->statem.hand_state != DTLS_ST_SW_HELLO_VERIFY_REQUEST) { errtype = dtls1_process_out_of_seq_message(s, &msg_hdr); return 0; } /* * We received a ClientHello and sent back a HelloVerifyRequest. We * now seem to have received a retransmitted initial ClientHello. That * is allowed (possibly our HelloVerifyRequest got lost). / chretran = 1; } if (frag_len && frag_len < mlen) { errtype = dtls1_reassemble_fragment(s, &msg_hdr); return 0; } if (!s->server && s->d1->r_msg_hdr.frag_off == 0 && s->statem.hand_state != TLS_ST_OK && wire[0] == SSL3_MT_HELLO_REQUEST) { /* * The server may always send 'Hello Request' messages -- we are * doing a handshake anyway now, so ignore them if their format is * correct. Does not count for 'Finished' MAC. / if (wire[1] == 0 && wire[2] == 0 && wire[3] == 0) { if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, wire, DTLS1_HM_HEADER_LENGTH, ssl, s->msg_callback_arg); s->init_num = 0; goto redo; } else { / Incorrectly formatted Hello request / SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto f_err; } } if (!dtls1_preprocess_fragment(s, &msg_hdr)) { / SSLfatal() already called / goto f_err; } if (frag_len > 0) { unsigned char p = (unsigned char )s->init_buf->data + DTLS1_HM_HEADER_LENGTH; i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, &p[frag_off], frag_len, 0, &readbytes); / * This shouldn't ever fail due to NBIO because we already checked * that we have enough data in the record / if (i <= 0) { s->rwstate = SSL_READING; len = 0; return 0; } } else { readbytes = 0; } /* * XDTLS: an incorrectly formatted fragment should cause the handshake * to fail / if (readbytes != frag_len) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_LENGTH); goto f_err; } if (chretran) { / * We got a new ClientHello with a message sequence of 0. * Reset the read/write sequences back to the beginning. * We process it like this is the first time we've seen a ClientHello * from the client. / s->d1->handshake_read_seq = 0; s->d1->next_handshake_write_seq = 0; } / * Note that s->init_num is not used as current offset in * s->init_buf->data, but as a counter summing up fragments' lengths: as * soon as they sum up to handshake packet length, we assume we have got * all the fragments. / len = s->init_num = frag_len; return 1; f_err: s->init_num = 0; len = 0; return 0; } /- * for these 2 messages, we need to * ssl->session->read_sym_enc assign * ssl->session->read_compression assign * ssl->session->read_hash assign / CON_FUNC_RETURN dtls_construct_change_cipher_spec(SSL_CONNECTION s, WPACKET pkt) { if (s->version == DTLS1_BAD_VER) { s->d1->next_handshake_write_seq++; if (!WPACKET_put_bytes_u16(pkt, s->d1->handshake_write_seq)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } return CON_FUNC_SUCCESS; } #ifndef OPENSSL_NO_SCTP / * Wait for a dry event. Should only be called at a point in the handshake * where we are not expecting any data from the peer except an alert. / WORK_STATE dtls_wait_for_dry(SSL_CONNECTION s) { int ret, errtype; size_t len; SSL ssl = SSL_CONNECTION_GET_SSL(s); / read app data until dry event / ret = BIO_dgram_sctp_wait_for_dry(SSL_get_wbio(ssl)); if (ret < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } if (ret == 0) { / * We're not expecting any more messages from the peer at this point - * but we could get an alert. If an alert is waiting then we will never * return successfully. Therefore we attempt to read a message. This * should never succeed but will process any waiting alerts. / if (dtls_get_reassembled_message(s, &errtype, &len)) { / The call succeeded! This should never happen / SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); return WORK_ERROR; } s->s3.in_read_app_data = 2; s->rwstate = SSL_READING; BIO_clear_retry_flags(SSL_get_rbio(ssl)); BIO_set_retry_read(SSL_get_rbio(ssl)); return WORK_MORE_A; } return WORK_FINISHED_CONTINUE; } #endif int dtls1_read_failed(SSL_CONNECTION s, int code) { SSL ssl = SSL_CONNECTION_GET_SSL(s); if (code > 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!dtls1_is_timer_expired(s) \|\| ossl_statem_in_error(s)) { / * not a timeout, none of our business, let higher layers handle * this. in fact it's probably an error / return code; } / done, no need to send a retransmit / if (!SSL_in_init(ssl)) { BIO_set_flags(SSL_get_rbio(ssl), BIO_FLAGS_READ); return code; } return dtls1_handle_timeout(s); } int dtls1_get_queue_priority(unsigned short seq, int is_ccs) { / * The index of the retransmission queue actually is the message sequence * number, since the queue only contains messages of a single handshake. * However, the ChangeCipherSpec has no message sequence number and so * using only the sequence will result in the CCS and Finished having the * same index. To prevent this, the sequence number is multiplied by 2. * In case of a CCS 1 is subtracted. This does not only differ CSS and * Finished, it also maintains the order of the index (important for * priority queues) and fits in the unsigned short variable. / return seq 2 - is_ccs; } int dtls1_retransmit_buffered_messages(SSL_CONNECTION s) { pqueue sent = s->d1->sent_messages; piterator iter; pitem item; hm_fragment frag; int found = 0; iter = pqueue_iterator(sent); for (item = pqueue_next(&iter); item != NULL; item = pqueue_next(&iter)) { frag = (hm_fragment )item->data; if (dtls1_retransmit_message(s, (unsigned short) dtls1_get_queue_priority (frag->msg_header.seq, frag->msg_header.is_ccs), &found) <= 0) return -1; } return 1; } int dtls1_buffer_message(SSL_CONNECTION s, int is_ccs) { pitem item; hm_fragment frag; unsigned char seq64be[8]; /* * this function is called immediately after a message has been * serialized / if (!ossl_assert(s->init_off == 0)) return 0; frag = dtls1_hm_fragment_new(s->init_num, 0); if (frag == NULL) return 0; memcpy(frag->fragment, s->init_buf->data, s->init_num); if (is_ccs) { / For DTLS1_BAD_VER the header length is non-standard / if (!ossl_assert(s->d1->w_msg_hdr.msg_len + ((s->version == DTLS1_BAD_VER) ? 3 : DTLS1_CCS_HEADER_LENGTH) == (unsigned int)s->init_num)) { dtls1_hm_fragment_free(frag); return 0; } } else { if (!ossl_assert(s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH == (unsigned int)s->init_num)) { dtls1_hm_fragment_free(frag); return 0; } } frag->msg_header.msg_len = s->d1->w_msg_hdr.msg_len; frag->msg_header.seq = s->d1->w_msg_hdr.seq; frag->msg_header.type = s->d1->w_msg_hdr.type; frag->msg_header.frag_off = 0; frag->msg_header.frag_len = s->d1->w_msg_hdr.msg_len; frag->msg_header.is_ccs = is_ccs; / save current state / frag->msg_header.saved_retransmit_state.wrlmethod = s->rlayer.wrlmethod; frag->msg_header.saved_retransmit_state.wrl = s->rlayer.wrl; memset(seq64be, 0, sizeof(seq64be)); seq64be[6] = (unsigned char)(dtls1_get_queue_priority(frag->msg_header.seq, frag->msg_header.is_ccs) >> 8); seq64be[7] = (unsigned char)(dtls1_get_queue_priority(frag->msg_header.seq, frag->msg_header.is_ccs)); item = pitem_new(seq64be, frag); if (item == NULL) { dtls1_hm_fragment_free(frag); return 0; } pqueue_insert(s->d1->sent_messages, item); return 1; } int dtls1_retransmit_message(SSL_CONNECTION s, unsigned short seq, int found) { int ret; / XDTLS: for now assuming that read/writes are blocking / pitem item; hm_fragment frag; unsigned long header_length; unsigned char seq64be[8]; struct dtls1_retransmit_state saved_state; / XDTLS: the requested message ought to be found, otherwise error / memset(seq64be, 0, sizeof(seq64be)); seq64be[6] = (unsigned char)(seq >> 8); seq64be[7] = (unsigned char)seq; item = pqueue_find(s->d1->sent_messages, seq64be); if (item == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); found = 0; return 0; } found = 1; frag = (hm_fragment )item->data; if (frag->msg_header.is_ccs) header_length = DTLS1_CCS_HEADER_LENGTH; else header_length = DTLS1_HM_HEADER_LENGTH; memcpy(s->init_buf->data, frag->fragment, frag->msg_header.msg_len + header_length); s->init_num = frag->msg_header.msg_len + header_length; dtls1_set_message_header_int(s, frag->msg_header.type, frag->msg_header.msg_len, frag->msg_header.seq, 0, frag->msg_header.frag_len); /* save current state / saved_state.wrlmethod = s->rlayer.wrlmethod; saved_state.wrl = s->rlayer.wrl; s->d1->retransmitting = 1; / restore state in which the message was originally sent / s->rlayer.wrlmethod = frag->msg_header.saved_retransmit_state.wrlmethod; s->rlayer.wrl = frag->msg_header.saved_retransmit_state.wrl; / * The old wrl may be still pointing at an old BIO. Update it to what we're * using now. / s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio); ret = dtls1_do_write(s, frag->msg_header.is_ccs ? SSL3_RT_CHANGE_CIPHER_SPEC : SSL3_RT_HANDSHAKE); / restore current state / s->rlayer.wrlmethod = saved_state.wrlmethod; s->rlayer.wrl = saved_state.wrl; s->d1->retransmitting = 0; (void)BIO_flush(s->wbio); return ret; } void dtls1_set_message_header(SSL_CONNECTION s, unsigned char mt, size_t len, size_t frag_off, size_t frag_len) { if (frag_off == 0) { s->d1->handshake_write_seq = s->d1->next_handshake_write_seq; s->d1->next_handshake_write_seq++; } dtls1_set_message_header_int(s, mt, len, s->d1->handshake_write_seq, frag_off, frag_len); } /* don't actually do the writing, wait till the MTU has been retrieved / static void dtls1_set_message_header_int(SSL_CONNECTION s, unsigned char mt, size_t len, unsigned short seq_num, size_t frag_off, size_t frag_len) { struct hm_header_st msg_hdr = &s->d1->w_msg_hdr; msg_hdr->type = mt; msg_hdr->msg_len = len; msg_hdr->seq = seq_num; msg_hdr->frag_off = frag_off; msg_hdr->frag_len = frag_len; } static void dtls1_fix_message_header(SSL_CONNECTION s, size_t frag_off, size_t frag_len) { struct hm_header_st msg_hdr = &s->d1->w_msg_hdr; msg_hdr->frag_off = frag_off; msg_hdr->frag_len = frag_len; } static unsigned char dtls1_write_message_header(SSL_CONNECTION s, unsigned char p) { struct hm_header_st msg_hdr = &s->d1->w_msg_hdr; p++ = msg_hdr->type; l2n3(msg_hdr->msg_len, p); s2n(msg_hdr->seq, p); l2n3(msg_hdr->frag_off, p); l2n3(msg_hdr->frag_len, p); return p; } void dtls1_get_message_header(const unsigned char data, struct hm_header_st msg_hdr) { memset(msg_hdr, 0, sizeof(msg_hdr)); msg_hdr->type = (data++); n2l3(data, msg_hdr->msg_len); n2s(data, msg_hdr->seq); n2l3(data, msg_hdr->frag_off); n2l3(data, msg_hdr->frag_len); } int dtls1_set_handshake_header(SSL_CONNECTION s, WPACKET pkt, int htype) { unsigned char header; if (htype == SSL3_MT_CHANGE_CIPHER_SPEC) { s->d1->handshake_write_seq = s->d1->next_handshake_write_seq; dtls1_set_message_header_int(s, SSL3_MT_CCS, 0, s->d1->handshake_write_seq, 0, 0); if (!WPACKET_put_bytes_u8(pkt, SSL3_MT_CCS)) return 0; } else { dtls1_set_message_header(s, htype, 0, 0, 0); / * We allocate space at the start for the message header. This gets * filled in later / if (!WPACKET_allocate_bytes(pkt, DTLS1_HM_HEADER_LENGTH, &header) \|\| !WPACKET_start_sub_packet(pkt)) return 0; } return 1; } int dtls1_close_construct_packet(SSL_CONNECTION s, WPACKET pkt, int htype) { size_t msglen; if ((htype != SSL3_MT_CHANGE_CIPHER_SPEC && !WPACKET_close(pkt)) \|\| !WPACKET_get_length(pkt, &msglen) \|\| msglen > INT_MAX) return 0; if (htype != SSL3_MT_CHANGE_CIPHER_SPEC) { s->d1->w_msg_hdr.msg_len = msglen - DTLS1_HM_HEADER_LENGTH; s->d1->w_msg_hdr.frag_len = msglen - DTLS1_HM_HEADER_LENGTH; } s->init_num = (int)msglen; s->init_off = 0; if (htype != DTLS1_MT_HELLO_VERIFY_REQUEST) { / Buffer the message to handle re-xmits */ if (!dtls1_buffer_message(s, htype == SSL3_MT_CHANGE_CIPHER_SPEC ? 1 : 0)) return 0; } return 1; }
./openssl/ssl/statem/statem_srvr.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include "../ssl_local.h" #include "statem_local.h" #include "internal/constant_time.h" #include "internal/cryptlib.h" #include <openssl/buffer.h> #include <openssl/rand.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/x509.h> #include <openssl/dh.h> #include <openssl/rsa.h> #include <openssl/bn.h> #include <openssl/md5.h> #include <openssl/trace.h> #include <openssl/core_names.h> #include <openssl/asn1t.h> #include <openssl/comp.h> #define TICKET_NONCE_SIZE 8 typedef struct { ASN1_TYPE kxBlob; ASN1_TYPE opaqueBlob; } GOST_KX_MESSAGE; DECLARE_ASN1_FUNCTIONS(GOST_KX_MESSAGE) ASN1_SEQUENCE(GOST_KX_MESSAGE) = { ASN1_SIMPLE(GOST_KX_MESSAGE, kxBlob, ASN1_ANY), ASN1_OPT(GOST_KX_MESSAGE, opaqueBlob, ASN1_ANY), } ASN1_SEQUENCE_END(GOST_KX_MESSAGE) IMPLEMENT_ASN1_FUNCTIONS(GOST_KX_MESSAGE) static CON_FUNC_RETURN tls_construct_encrypted_extensions(SSL_CONNECTION s, WPACKET pkt); static ossl_inline int received_client_cert(const SSL_CONNECTION sc) { return sc->session->peer_rpk != NULL \|\| sc->session->peer != NULL; } /* * ossl_statem_server13_read_transition() encapsulates the logic for the allowed * handshake state transitions when a TLSv1.3 server is reading messages from * the client. The message type that the client has sent is provided in \|mt\|. * The current state is in \|s->statem.hand_state\|. * * Return values are 1 for success (transition allowed) and 0 on error * (transition not allowed) / static int ossl_statem_server13_read_transition(SSL_CONNECTION s, int mt) { OSSL_STATEM st = &s->statem; / * Note: There is no case for TLS_ST_BEFORE because at that stage we have * not negotiated TLSv1.3 yet, so that case is handled by * ossl_statem_server_read_transition() / switch (st->hand_state) { default: break; case TLS_ST_EARLY_DATA: if (s->hello_retry_request == SSL_HRR_PENDING) { if (mt == SSL3_MT_CLIENT_HELLO) { st->hand_state = TLS_ST_SR_CLNT_HELLO; return 1; } break; } else if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) { if (mt == SSL3_MT_END_OF_EARLY_DATA) { st->hand_state = TLS_ST_SR_END_OF_EARLY_DATA; return 1; } break; } / Fall through / case TLS_ST_SR_END_OF_EARLY_DATA: case TLS_ST_SW_FINISHED: if (s->s3.tmp.cert_request) { if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_SR_CERT; return 1; } #ifndef OPENSSL_NO_COMP_ALG if (mt == SSL3_MT_COMPRESSED_CERTIFICATE && s->ext.compress_certificate_sent) { st->hand_state = TLS_ST_SR_COMP_CERT; return 1; } #endif } else { if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } } break; case TLS_ST_SR_COMP_CERT: case TLS_ST_SR_CERT: if (!received_client_cert(s)) { if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } } else { if (mt == SSL3_MT_CERTIFICATE_VERIFY) { st->hand_state = TLS_ST_SR_CERT_VRFY; return 1; } } break; case TLS_ST_SR_CERT_VRFY: if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } break; case TLS_ST_OK: / * Its never ok to start processing handshake messages in the middle of * early data (i.e. before we've received the end of early data alert) / if (s->early_data_state == SSL_EARLY_DATA_READING) break; if (s->post_handshake_auth == SSL_PHA_REQUESTED) { if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_SR_CERT; return 1; } #ifndef OPENSSL_NO_COMP_ALG if (mt == SSL3_MT_COMPRESSED_CERTIFICATE && s->ext.compress_certificate_sent) { st->hand_state = TLS_ST_SR_COMP_CERT; return 1; } #endif } if (mt == SSL3_MT_KEY_UPDATE && !SSL_IS_QUIC_HANDSHAKE(s)) { st->hand_state = TLS_ST_SR_KEY_UPDATE; return 1; } break; } / No valid transition found / return 0; } / * ossl_statem_server_read_transition() encapsulates the logic for the allowed * handshake state transitions when the server is reading messages from the * client. The message type that the client has sent is provided in \|mt\|. The * current state is in \|s->statem.hand_state\|. * * Return values are 1 for success (transition allowed) and 0 on error * (transition not allowed) / int ossl_statem_server_read_transition(SSL_CONNECTION s, int mt) { OSSL_STATEM st = &s->statem; if (SSL_CONNECTION_IS_TLS13(s)) { if (!ossl_statem_server13_read_transition(s, mt)) goto err; return 1; } switch (st->hand_state) { default: break; case TLS_ST_BEFORE: case TLS_ST_OK: case DTLS_ST_SW_HELLO_VERIFY_REQUEST: if (mt == SSL3_MT_CLIENT_HELLO) { st->hand_state = TLS_ST_SR_CLNT_HELLO; return 1; } break; case TLS_ST_SW_SRVR_DONE: / * If we get a CKE message after a ServerDone then either * 1) We didn't request a Certificate * OR * 2) If we did request one then * a) We allow no Certificate to be returned * AND * b) We are running SSL3 (in TLS1.0+ the client must return a 0 * list if we requested a certificate) / if (mt == SSL3_MT_CLIENT_KEY_EXCHANGE) { if (s->s3.tmp.cert_request) { if (s->version == SSL3_VERSION) { if ((s->verify_mode & SSL_VERIFY_PEER) && (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) { / * This isn't an unexpected message as such - we're just * not going to accept it because we require a client * cert. / SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE); return 0; } st->hand_state = TLS_ST_SR_KEY_EXCH; return 1; } } else { st->hand_state = TLS_ST_SR_KEY_EXCH; return 1; } } else if (s->s3.tmp.cert_request) { if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_SR_CERT; return 1; } } break; case TLS_ST_SR_CERT: if (mt == SSL3_MT_CLIENT_KEY_EXCHANGE) { st->hand_state = TLS_ST_SR_KEY_EXCH; return 1; } break; case TLS_ST_SR_KEY_EXCH: / * We should only process a CertificateVerify message if we have * received a Certificate from the client. If so then \|s->session->peer\| * will be non NULL. In some instances a CertificateVerify message is * not required even if the peer has sent a Certificate (e.g. such as in * the case of static DH). In that case \|st->no_cert_verify\| should be * set. / if (!received_client_cert(s) \|\| st->no_cert_verify) { if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { / * For the ECDH ciphersuites when the client sends its ECDH * pub key in a certificate, the CertificateVerify message is * not sent. Also for GOST ciphersuites when the client uses * its key from the certificate for key exchange. / st->hand_state = TLS_ST_SR_CHANGE; return 1; } } else { if (mt == SSL3_MT_CERTIFICATE_VERIFY) { st->hand_state = TLS_ST_SR_CERT_VRFY; return 1; } } break; case TLS_ST_SR_CERT_VRFY: if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_SR_CHANGE; return 1; } break; case TLS_ST_SR_CHANGE: #ifndef OPENSSL_NO_NEXTPROTONEG if (s->s3.npn_seen) { if (mt == SSL3_MT_NEXT_PROTO) { st->hand_state = TLS_ST_SR_NEXT_PROTO; return 1; } } else { #endif if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } #ifndef OPENSSL_NO_NEXTPROTONEG } #endif break; #ifndef OPENSSL_NO_NEXTPROTONEG case TLS_ST_SR_NEXT_PROTO: if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } break; #endif case TLS_ST_SW_FINISHED: if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_SR_CHANGE; return 1; } break; } err: / No valid transition found / if (SSL_CONNECTION_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) { BIO rbio; /* * CCS messages don't have a message sequence number so this is probably * because of an out-of-order CCS. We'll just drop it. / s->init_num = 0; s->rwstate = SSL_READING; rbio = SSL_get_rbio(SSL_CONNECTION_GET_SSL(s)); BIO_clear_retry_flags(rbio); BIO_set_retry_read(rbio); return 0; } SSLfatal(s, SSL3_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); return 0; } / * Should we send a ServerKeyExchange message? * * Valid return values are: * 1: Yes * 0: No / static int send_server_key_exchange(SSL_CONNECTION s) { unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey; /* * only send a ServerKeyExchange if DH or fortezza but we have a * sign only certificate PSK: may send PSK identity hints For * ECC ciphersuites, we send a serverKeyExchange message only if * the cipher suite is either ECDH-anon or ECDHE. In other cases, * the server certificate contains the server's public key for * key exchange. / if (alg_k & (SSL_kDHE \| SSL_kECDHE) / * PSK: send ServerKeyExchange if PSK identity hint if * provided / #ifndef OPENSSL_NO_PSK / Only send SKE if we have identity hint for plain PSK / \|\| ((alg_k & (SSL_kPSK \| SSL_kRSAPSK)) && s->cert->psk_identity_hint) / For other PSK always send SKE / \|\| (alg_k & (SSL_PSK & (SSL_kDHEPSK \| SSL_kECDHEPSK))) #endif #ifndef OPENSSL_NO_SRP / SRP: send ServerKeyExchange / \|\| (alg_k & SSL_kSRP) #endif ) { return 1; } return 0; } / * Used to determine if we should send a CompressedCertificate message * * Returns the algorithm to use, TLSEXT_comp_cert_none means no compression / static int get_compressed_certificate_alg(SSL_CONNECTION sc) { #ifndef OPENSSL_NO_COMP_ALG int alg = sc->ext.compress_certificate_from_peer; if (sc->s3.tmp.cert == NULL) return TLSEXT_comp_cert_none; for (; alg != TLSEXT_comp_cert_none; alg++) { if (sc->s3.tmp.cert->comp_cert[alg] != NULL) return alg; } #endif return TLSEXT_comp_cert_none; } /* * Should we send a CertificateRequest message? * * Valid return values are: * 1: Yes * 0: No / int send_certificate_request(SSL_CONNECTION s) { if ( /* don't request cert unless asked for it: / s->verify_mode & SSL_VERIFY_PEER / * don't request if post-handshake-only unless doing * post-handshake in TLSv1.3: / && (!SSL_CONNECTION_IS_TLS13(s) \|\| !(s->verify_mode & SSL_VERIFY_POST_HANDSHAKE) \|\| s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) / * if SSL_VERIFY_CLIENT_ONCE is set, don't request cert * a second time: / && (s->certreqs_sent < 1 \|\| !(s->verify_mode & SSL_VERIFY_CLIENT_ONCE)) / * never request cert in anonymous ciphersuites (see * section "Certificate request" in SSL 3 drafts and in * RFC 2246): / && (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL) / * ... except when the application insists on * verification (against the specs, but statem_clnt.c accepts * this for SSL 3) / \|\| (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) / don't request certificate for SRP auth / && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aSRP) / * With normal PSK Certificates and Certificate Requests * are omitted / && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aPSK)) { return 1; } return 0; } static int do_compressed_cert(SSL_CONNECTION sc) { /* If we negotiated RPK, we won't attempt to compress it / return sc->ext.server_cert_type == TLSEXT_cert_type_x509 && get_compressed_certificate_alg(sc) != TLSEXT_comp_cert_none; } / * ossl_statem_server13_write_transition() works out what handshake state to * move to next when a TLSv1.3 server is writing messages to be sent to the * client. / static WRITE_TRAN ossl_statem_server13_write_transition(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; / * No case for TLS_ST_BEFORE, because at that stage we have not negotiated * TLSv1.3 yet, so that is handled by ossl_statem_server_write_transition() / switch (st->hand_state) { default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; case TLS_ST_OK: if (s->key_update != SSL_KEY_UPDATE_NONE) { st->hand_state = TLS_ST_SW_KEY_UPDATE; return WRITE_TRAN_CONTINUE; } if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) { st->hand_state = TLS_ST_SW_CERT_REQ; return WRITE_TRAN_CONTINUE; } if (s->ext.extra_tickets_expected > 0) { st->hand_state = TLS_ST_SW_SESSION_TICKET; return WRITE_TRAN_CONTINUE; } / Try to read from the client instead / return WRITE_TRAN_FINISHED; case TLS_ST_SR_CLNT_HELLO: st->hand_state = TLS_ST_SW_SRVR_HELLO; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_SRVR_HELLO: if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0 && s->hello_retry_request != SSL_HRR_COMPLETE) st->hand_state = TLS_ST_SW_CHANGE; else if (s->hello_retry_request == SSL_HRR_PENDING) st->hand_state = TLS_ST_EARLY_DATA; else st->hand_state = TLS_ST_SW_ENCRYPTED_EXTENSIONS; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CHANGE: if (s->hello_retry_request == SSL_HRR_PENDING) st->hand_state = TLS_ST_EARLY_DATA; else st->hand_state = TLS_ST_SW_ENCRYPTED_EXTENSIONS; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: if (s->hit) st->hand_state = TLS_ST_SW_FINISHED; else if (send_certificate_request(s)) st->hand_state = TLS_ST_SW_CERT_REQ; else if (do_compressed_cert(s)) st->hand_state = TLS_ST_SW_COMP_CERT; else st->hand_state = TLS_ST_SW_CERT; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CERT_REQ: if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) { s->post_handshake_auth = SSL_PHA_REQUESTED; st->hand_state = TLS_ST_OK; } else if (do_compressed_cert(s)) { st->hand_state = TLS_ST_SW_COMP_CERT; } else { st->hand_state = TLS_ST_SW_CERT; } return WRITE_TRAN_CONTINUE; case TLS_ST_SW_COMP_CERT: case TLS_ST_SW_CERT: st->hand_state = TLS_ST_SW_CERT_VRFY; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CERT_VRFY: st->hand_state = TLS_ST_SW_FINISHED; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_FINISHED: st->hand_state = TLS_ST_EARLY_DATA; s->ts_msg_write = ossl_time_now(); return WRITE_TRAN_CONTINUE; case TLS_ST_EARLY_DATA: return WRITE_TRAN_FINISHED; case TLS_ST_SR_FINISHED: s->ts_msg_read = ossl_time_now(); / * Technically we have finished the handshake at this point, but we're * going to remain "in_init" for now and write out any session tickets * immediately. / if (s->post_handshake_auth == SSL_PHA_REQUESTED) { s->post_handshake_auth = SSL_PHA_EXT_RECEIVED; } else if (!s->ext.ticket_expected) { / * If we're not going to renew the ticket then we just finish the * handshake at this point. / st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } if (s->num_tickets > s->sent_tickets) st->hand_state = TLS_ST_SW_SESSION_TICKET; else st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_SR_KEY_UPDATE: case TLS_ST_SW_KEY_UPDATE: st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_SESSION_TICKET: / In a resumption we only ever send a maximum of one new ticket. * Following an initial handshake we send the number of tickets we have * been configured for. / if (!SSL_IS_FIRST_HANDSHAKE(s) && s->ext.extra_tickets_expected > 0) { return WRITE_TRAN_CONTINUE; } else if (s->hit \|\| s->num_tickets <= s->sent_tickets) { / We've written enough tickets out. / st->hand_state = TLS_ST_OK; } return WRITE_TRAN_CONTINUE; } } / * ossl_statem_server_write_transition() works out what handshake state to move * to next when the server is writing messages to be sent to the client. / WRITE_TRAN ossl_statem_server_write_transition(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; / * Note that before the ClientHello we don't know what version we are going * to negotiate yet, so we don't take this branch until later / if (SSL_CONNECTION_IS_TLS13(s)) return ossl_statem_server13_write_transition(s); switch (st->hand_state) { default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; case TLS_ST_OK: if (st->request_state == TLS_ST_SW_HELLO_REQ) { / We must be trying to renegotiate / st->hand_state = TLS_ST_SW_HELLO_REQ; st->request_state = TLS_ST_BEFORE; return WRITE_TRAN_CONTINUE; } / Must be an incoming ClientHello / if (!tls_setup_handshake(s)) { / SSLfatal() already called / return WRITE_TRAN_ERROR; } / Fall through / case TLS_ST_BEFORE: / Just go straight to trying to read from the client / return WRITE_TRAN_FINISHED; case TLS_ST_SW_HELLO_REQ: st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_SR_CLNT_HELLO: if (SSL_CONNECTION_IS_DTLS(s) && !s->d1->cookie_verified && (SSL_get_options(SSL_CONNECTION_GET_SSL(s)) & SSL_OP_COOKIE_EXCHANGE)) { st->hand_state = DTLS_ST_SW_HELLO_VERIFY_REQUEST; } else if (s->renegotiate == 0 && !SSL_IS_FIRST_HANDSHAKE(s)) { / We must have rejected the renegotiation / st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } else { st->hand_state = TLS_ST_SW_SRVR_HELLO; } return WRITE_TRAN_CONTINUE; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: return WRITE_TRAN_FINISHED; case TLS_ST_SW_SRVR_HELLO: if (s->hit) { if (s->ext.ticket_expected) st->hand_state = TLS_ST_SW_SESSION_TICKET; else st->hand_state = TLS_ST_SW_CHANGE; } else { / Check if it is anon DH or anon ECDH, / / normal PSK or SRP / if (!(s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL \| SSL_aSRP \| SSL_aPSK))) { st->hand_state = TLS_ST_SW_CERT; } else if (send_server_key_exchange(s)) { st->hand_state = TLS_ST_SW_KEY_EXCH; } else if (send_certificate_request(s)) { st->hand_state = TLS_ST_SW_CERT_REQ; } else { st->hand_state = TLS_ST_SW_SRVR_DONE; } } return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CERT: if (s->ext.status_expected) { st->hand_state = TLS_ST_SW_CERT_STATUS; return WRITE_TRAN_CONTINUE; } / Fall through / case TLS_ST_SW_CERT_STATUS: if (send_server_key_exchange(s)) { st->hand_state = TLS_ST_SW_KEY_EXCH; return WRITE_TRAN_CONTINUE; } / Fall through / case TLS_ST_SW_KEY_EXCH: if (send_certificate_request(s)) { st->hand_state = TLS_ST_SW_CERT_REQ; return WRITE_TRAN_CONTINUE; } / Fall through / case TLS_ST_SW_CERT_REQ: st->hand_state = TLS_ST_SW_SRVR_DONE; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_SRVR_DONE: s->ts_msg_write = ossl_time_now(); return WRITE_TRAN_FINISHED; case TLS_ST_SR_FINISHED: s->ts_msg_read = ossl_time_now(); if (s->hit) { st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } else if (s->ext.ticket_expected) { st->hand_state = TLS_ST_SW_SESSION_TICKET; } else { st->hand_state = TLS_ST_SW_CHANGE; } return WRITE_TRAN_CONTINUE; case TLS_ST_SW_SESSION_TICKET: st->hand_state = TLS_ST_SW_CHANGE; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CHANGE: st->hand_state = TLS_ST_SW_FINISHED; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_FINISHED: if (s->hit) { return WRITE_TRAN_FINISHED; } st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } } / * Perform any pre work that needs to be done prior to sending a message from * the server to the client. / WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION s, WORK_STATE wst) { OSSL_STATEM st = &s->statem; SSL ssl = SSL_CONNECTION_GET_SSL(s); switch (st->hand_state) { default: /* No pre work to be done / break; case TLS_ST_SW_HELLO_REQ: s->shutdown = 0; if (SSL_CONNECTION_IS_DTLS(s)) dtls1_clear_sent_buffer(s); break; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: s->shutdown = 0; if (SSL_CONNECTION_IS_DTLS(s)) { dtls1_clear_sent_buffer(s); / We don't buffer this message so don't use the timer / st->use_timer = 0; } break; case TLS_ST_SW_SRVR_HELLO: if (SSL_CONNECTION_IS_DTLS(s)) { / * Messages we write from now on should be buffered and * retransmitted if necessary, so we need to use the timer now / st->use_timer = 1; } break; case TLS_ST_SW_SRVR_DONE: #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) { / Calls SSLfatal() as required / return dtls_wait_for_dry(s); } #endif return WORK_FINISHED_CONTINUE; case TLS_ST_SW_SESSION_TICKET: if (SSL_CONNECTION_IS_TLS13(s) && s->sent_tickets == 0 && s->ext.extra_tickets_expected == 0) { / * Actually this is the end of the handshake, but we're going * straight into writing the session ticket out. So we finish off * the handshake, but keep the various buffers active. * * Calls SSLfatal as required. / return tls_finish_handshake(s, wst, 0, 0); } if (SSL_CONNECTION_IS_DTLS(s)) { / * We're into the last flight. We don't retransmit the last flight * unless we need to, so we don't use the timer / st->use_timer = 0; } break; case TLS_ST_SW_CHANGE: if (SSL_CONNECTION_IS_TLS13(s)) break; / Writes to s->session are only safe for initial handshakes / if (s->session->cipher == NULL) { s->session->cipher = s->s3.tmp.new_cipher; } else if (s->session->cipher != s->s3.tmp.new_cipher) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } if (!ssl->method->ssl3_enc->setup_key_block(s)) { / SSLfatal() already called / return WORK_ERROR; } if (SSL_CONNECTION_IS_DTLS(s)) { / * We're into the last flight. We don't retransmit the last flight * unless we need to, so we don't use the timer. This might have * already been set to 0 if we sent a NewSessionTicket message, * but we'll set it again here in case we didn't. / st->use_timer = 0; } return WORK_FINISHED_CONTINUE; case TLS_ST_EARLY_DATA: if (s->early_data_state != SSL_EARLY_DATA_ACCEPTING && (s->s3.flags & TLS1_FLAGS_STATELESS) == 0) return WORK_FINISHED_CONTINUE; / Fall through / case TLS_ST_OK: / Calls SSLfatal() as required / return tls_finish_handshake(s, wst, 1, 1); } return WORK_FINISHED_CONTINUE; } static ossl_inline int conn_is_closed(void) { switch (get_last_sys_error()) { #if defined(EPIPE) case EPIPE: return 1; #endif #if defined(ECONNRESET) case ECONNRESET: return 1; #endif #if defined(WSAECONNRESET) case WSAECONNRESET: return 1; #endif default: return 0; } } / * Perform any work that needs to be done after sending a message from the * server to the client. / WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION s, WORK_STATE wst) { OSSL_STATEM st = &s->statem; SSL ssl = SSL_CONNECTION_GET_SSL(s); s->init_num = 0; switch (st->hand_state) { default: /* No post work to be done / break; case TLS_ST_SW_HELLO_REQ: if (statem_flush(s) != 1) return WORK_MORE_A; if (!ssl3_init_finished_mac(s)) { / SSLfatal() already called / return WORK_ERROR; } break; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: if (statem_flush(s) != 1) return WORK_MORE_A; / HelloVerifyRequest resets Finished MAC / if (s->version != DTLS1_BAD_VER && !ssl3_init_finished_mac(s)) { / SSLfatal() already called / return WORK_ERROR; } / * The next message should be another ClientHello which we need to * treat like it was the first packet / s->first_packet = 1; break; case TLS_ST_SW_SRVR_HELLO: if (SSL_CONNECTION_IS_TLS13(s) && s->hello_retry_request == SSL_HRR_PENDING) { if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0 && statem_flush(s) != 1) return WORK_MORE_A; break; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && s->hit) { unsigned char sctpauthkey[64]; char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)]; size_t labellen; / * Add new shared key for SCTP-Auth, will be ignored if no * SCTP used. / memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL, sizeof(DTLS1_SCTP_AUTH_LABEL)); / Don't include the terminating zero. / labellen = sizeof(labelbuffer) - 1; if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG) labellen += 1; if (SSL_export_keying_material(ssl, sctpauthkey, sizeof(sctpauthkey), labelbuffer, labellen, NULL, 0, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY, sizeof(sctpauthkey), sctpauthkey); } #endif if (!SSL_CONNECTION_IS_TLS13(s) \|\| ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0 && s->hello_retry_request != SSL_HRR_COMPLETE)) break; / Fall through / case TLS_ST_SW_CHANGE: if (s->hello_retry_request == SSL_HRR_PENDING) { if (!statem_flush(s)) return WORK_MORE_A; break; } if (SSL_CONNECTION_IS_TLS13(s)) { if (!ssl->method->ssl3_enc->setup_key_block(s) \|\| !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE \| SSL3_CHANGE_CIPHER_SERVER_WRITE)) { / SSLfatal() already called / return WORK_ERROR; } if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED && !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE \|SSL3_CHANGE_CIPHER_SERVER_READ)) { / SSLfatal() already called / return WORK_ERROR; } / * We don't yet know whether the next record we are going to receive * is an unencrypted alert, an encrypted alert, or an encrypted * handshake message. We temporarily tolerate unencrypted alerts. / if (s->rlayer.rrlmethod->set_plain_alerts != NULL) s->rlayer.rrlmethod->set_plain_alerts(s->rlayer.rrl, 1); break; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && !s->hit) { / * Change to new shared key of SCTP-Auth, will be ignored if * no SCTP used. / BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL); } #endif if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CHANGE_CIPHER_SERVER_WRITE)) { / SSLfatal() already called / return WORK_ERROR; } break; case TLS_ST_SW_SRVR_DONE: if (statem_flush(s) != 1) return WORK_MORE_A; break; case TLS_ST_SW_FINISHED: if (statem_flush(s) != 1) return WORK_MORE_A; #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && s->hit) { / * Change to new shared key of SCTP-Auth, will be ignored if * no SCTP used. / BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL); } #endif if (SSL_CONNECTION_IS_TLS13(s)) { / TLS 1.3 gets the secret size from the handshake md / size_t dummy; if (!ssl->method->ssl3_enc->generate_master_secret(s, s->master_secret, s->handshake_secret, 0, &dummy) \|\| !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION \| SSL3_CHANGE_CIPHER_SERVER_WRITE)) / SSLfatal() already called / return WORK_ERROR; } break; case TLS_ST_SW_CERT_REQ: if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) { if (statem_flush(s) != 1) return WORK_MORE_A; } else { if (!SSL_CONNECTION_IS_TLS13(s) \|\| (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0) s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none; } break; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: if (!s->hit && !send_certificate_request(s)) { if (!SSL_CONNECTION_IS_TLS13(s) \|\| (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0) s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none; } break; case TLS_ST_SW_KEY_UPDATE: if (statem_flush(s) != 1) return WORK_MORE_A; if (!tls13_update_key(s, 1)) { / SSLfatal() already called / return WORK_ERROR; } break; case TLS_ST_SW_SESSION_TICKET: clear_sys_error(); if (SSL_CONNECTION_IS_TLS13(s) && statem_flush(s) != 1) { if (SSL_get_error(ssl, 0) == SSL_ERROR_SYSCALL && conn_is_closed()) { / * We ignore connection closed errors in TLSv1.3 when sending a * NewSessionTicket and behave as if we were successful. This is * so that we are still able to read data sent to us by a client * that closes soon after the end of the handshake without * waiting to read our post-handshake NewSessionTickets. / s->rwstate = SSL_NOTHING; break; } return WORK_MORE_A; } break; } return WORK_FINISHED_CONTINUE; } / * Get the message construction function and message type for sending from the * server * * Valid return values are: * 1: Success * 0: Error / int ossl_statem_server_construct_message(SSL_CONNECTION s, confunc_f confunc, int mt) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_STATE); return 0; case TLS_ST_SW_CHANGE: if (SSL_CONNECTION_IS_DTLS(s)) confunc = dtls_construct_change_cipher_spec; else confunc = tls_construct_change_cipher_spec; mt = SSL3_MT_CHANGE_CIPHER_SPEC; break; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: confunc = dtls_construct_hello_verify_request; mt = DTLS1_MT_HELLO_VERIFY_REQUEST; break; case TLS_ST_SW_HELLO_REQ: /* No construction function needed / confunc = NULL; mt = SSL3_MT_HELLO_REQUEST; break; case TLS_ST_SW_SRVR_HELLO: confunc = tls_construct_server_hello; mt = SSL3_MT_SERVER_HELLO; break; case TLS_ST_SW_CERT: confunc = tls_construct_server_certificate; mt = SSL3_MT_CERTIFICATE; break; #ifndef OPENSSL_NO_COMP_ALG case TLS_ST_SW_COMP_CERT: confunc = tls_construct_server_compressed_certificate; mt = SSL3_MT_COMPRESSED_CERTIFICATE; break; #endif case TLS_ST_SW_CERT_VRFY: confunc = tls_construct_cert_verify; mt = SSL3_MT_CERTIFICATE_VERIFY; break; case TLS_ST_SW_KEY_EXCH: confunc = tls_construct_server_key_exchange; mt = SSL3_MT_SERVER_KEY_EXCHANGE; break; case TLS_ST_SW_CERT_REQ: confunc = tls_construct_certificate_request; mt = SSL3_MT_CERTIFICATE_REQUEST; break; case TLS_ST_SW_SRVR_DONE: confunc = tls_construct_server_done; mt = SSL3_MT_SERVER_DONE; break; case TLS_ST_SW_SESSION_TICKET: confunc = tls_construct_new_session_ticket; mt = SSL3_MT_NEWSESSION_TICKET; break; case TLS_ST_SW_CERT_STATUS: confunc = tls_construct_cert_status; mt = SSL3_MT_CERTIFICATE_STATUS; break; case TLS_ST_SW_FINISHED: confunc = tls_construct_finished; mt = SSL3_MT_FINISHED; break; case TLS_ST_EARLY_DATA: confunc = NULL; mt = SSL3_MT_DUMMY; break; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: confunc = tls_construct_encrypted_extensions; mt = SSL3_MT_ENCRYPTED_EXTENSIONS; break; case TLS_ST_SW_KEY_UPDATE: confunc = tls_construct_key_update; mt = SSL3_MT_KEY_UPDATE; break; } return 1; } / * Maximum size (excluding the Handshake header) of a ClientHello message, * calculated as follows: * * 2 + # client_version * 32 + # only valid length for random * 1 + # length of session_id * 32 + # maximum size for session_id * 2 + # length of cipher suites * 2^16-2 + # maximum length of cipher suites array * 1 + # length of compression_methods * 2^8-1 + # maximum length of compression methods * 2 + # length of extensions * 2^16-1 # maximum length of extensions / #define CLIENT_HELLO_MAX_LENGTH 131396 #define CLIENT_KEY_EXCH_MAX_LENGTH 2048 #define NEXT_PROTO_MAX_LENGTH 514 / * Returns the maximum allowed length for the current message that we are * reading. Excludes the message header. / size_t ossl_statem_server_max_message_size(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: / Shouldn't happen / return 0; case TLS_ST_SR_CLNT_HELLO: return CLIENT_HELLO_MAX_LENGTH; case TLS_ST_SR_END_OF_EARLY_DATA: return END_OF_EARLY_DATA_MAX_LENGTH; case TLS_ST_SR_COMP_CERT: case TLS_ST_SR_CERT: return s->max_cert_list; case TLS_ST_SR_KEY_EXCH: return CLIENT_KEY_EXCH_MAX_LENGTH; case TLS_ST_SR_CERT_VRFY: return CERTIFICATE_VERIFY_MAX_LENGTH; #ifndef OPENSSL_NO_NEXTPROTONEG case TLS_ST_SR_NEXT_PROTO: return NEXT_PROTO_MAX_LENGTH; #endif case TLS_ST_SR_CHANGE: return CCS_MAX_LENGTH; case TLS_ST_SR_FINISHED: return FINISHED_MAX_LENGTH; case TLS_ST_SR_KEY_UPDATE: return KEY_UPDATE_MAX_LENGTH; } } / * Process a message that the server has received from the client. / MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION s, PACKET pkt) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; case TLS_ST_SR_CLNT_HELLO: return tls_process_client_hello(s, pkt); case TLS_ST_SR_END_OF_EARLY_DATA: return tls_process_end_of_early_data(s, pkt); case TLS_ST_SR_CERT: return tls_process_client_certificate(s, pkt); #ifndef OPENSSL_NO_COMP_ALG case TLS_ST_SR_COMP_CERT: return tls_process_client_compressed_certificate(s, pkt); #endif case TLS_ST_SR_KEY_EXCH: return tls_process_client_key_exchange(s, pkt); case TLS_ST_SR_CERT_VRFY: return tls_process_cert_verify(s, pkt); #ifndef OPENSSL_NO_NEXTPROTONEG case TLS_ST_SR_NEXT_PROTO: return tls_process_next_proto(s, pkt); #endif case TLS_ST_SR_CHANGE: return tls_process_change_cipher_spec(s, pkt); case TLS_ST_SR_FINISHED: return tls_process_finished(s, pkt); case TLS_ST_SR_KEY_UPDATE: return tls_process_key_update(s, pkt); } } / * Perform any further processing required following the receipt of a message * from the client / WORK_STATE ossl_statem_server_post_process_message(SSL_CONNECTION s, WORK_STATE wst) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; case TLS_ST_SR_CLNT_HELLO: return tls_post_process_client_hello(s, wst); case TLS_ST_SR_KEY_EXCH: return tls_post_process_client_key_exchange(s, wst); } } #ifndef OPENSSL_NO_SRP / Returns 1 on success, 0 for retryable error, -1 for fatal error / static int ssl_check_srp_ext_ClientHello(SSL_CONNECTION s) { int ret; int al = SSL_AD_UNRECOGNIZED_NAME; if ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) && (s->srp_ctx.TLS_ext_srp_username_callback != NULL)) { if (s->srp_ctx.login == NULL) { /* * RFC 5054 says SHOULD reject, we do so if There is no srp * login name / SSLfatal(s, SSL_AD_UNKNOWN_PSK_IDENTITY, SSL_R_PSK_IDENTITY_NOT_FOUND); return -1; } else { ret = ssl_srp_server_param_with_username_intern(s, &al); if (ret < 0) return 0; if (ret == SSL3_AL_FATAL) { SSLfatal(s, al, al == SSL_AD_UNKNOWN_PSK_IDENTITY ? SSL_R_PSK_IDENTITY_NOT_FOUND : SSL_R_CLIENTHELLO_TLSEXT); return -1; } } } return 1; } #endif int dtls_raw_hello_verify_request(WPACKET pkt, unsigned char cookie, size_t cookie_len) { / Always use DTLS 1.0 version: see RFC 6347 / if (!WPACKET_put_bytes_u16(pkt, DTLS1_VERSION) \|\| !WPACKET_sub_memcpy_u8(pkt, cookie, cookie_len)) return 0; return 1; } CON_FUNC_RETURN dtls_construct_hello_verify_request(SSL_CONNECTION s, WPACKET pkt) { unsigned int cookie_leni; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (sctx->app_gen_cookie_cb == NULL \|\| sctx->app_gen_cookie_cb(SSL_CONNECTION_GET_SSL(s), s->d1->cookie, &cookie_leni) == 0 \|\| cookie_leni > DTLS1_COOKIE_LENGTH) { SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_COOKIE_GEN_CALLBACK_FAILURE); return CON_FUNC_ERROR; } s->d1->cookie_len = cookie_leni; if (!dtls_raw_hello_verify_request(pkt, s->d1->cookie, s->d1->cookie_len)) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } /- ssl_check_for_safari attempts to fingerprint Safari using OS X * SecureTransport using the TLS extension block in \|hello\|. * Safari, since 10.6, sends exactly these extensions, in this order: * SNI, * elliptic_curves * ec_point_formats * signature_algorithms (for TLSv1.2 only) * * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8, * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them. * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from * 10.8..10.8.3 (which don't work). / static void ssl_check_for_safari(SSL_CONNECTION s, const CLIENTHELLO_MSG hello) { static const unsigned char kSafariExtensionsBlock[] = { 0x00, 0x0a, / elliptic_curves extension / 0x00, 0x08, / 8 bytes / 0x00, 0x06, / 6 bytes of curve ids / 0x00, 0x17, / P-256 / 0x00, 0x18, / P-384 / 0x00, 0x19, / P-521 / 0x00, 0x0b, / ec_point_formats / 0x00, 0x02, / 2 bytes / 0x01, / 1 point format / 0x00, / uncompressed / / The following is only present in TLS 1.2 / 0x00, 0x0d, / signature_algorithms / 0x00, 0x0c, / 12 bytes / 0x00, 0x0a, / 10 bytes / 0x05, 0x01, / SHA-384/RSA / 0x04, 0x01, / SHA-256/RSA / 0x02, 0x01, / SHA-1/RSA / 0x04, 0x03, / SHA-256/ECDSA / 0x02, 0x03, / SHA-1/ECDSA / }; / Length of the common prefix (first two extensions). / static const size_t kSafariCommonExtensionsLength = 18; unsigned int type; PACKET sni, tmppkt; size_t ext_len; tmppkt = hello->extensions; if (!PACKET_forward(&tmppkt, 2) \|\| !PACKET_get_net_2(&tmppkt, &type) \|\| !PACKET_get_length_prefixed_2(&tmppkt, &sni)) { return; } if (type != TLSEXT_TYPE_server_name) return; ext_len = TLS1_get_client_version( SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION ? sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength; s->s3.is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock, ext_len); } #define RENEG_OPTIONS_OK(options) \ ((options & SSL_OP_NO_RENEGOTIATION) == 0 \ && (options & SSL_OP_ALLOW_CLIENT_RENEGOTIATION) != 0) MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION s, PACKET pkt) { / \|cookie\| will only be initialized for DTLS. / PACKET session_id, compression, extensions, cookie; static const unsigned char null_compression = 0; CLIENTHELLO_MSG clienthello = NULL; /* Check if this is actually an unexpected renegotiation ClientHello / if (s->renegotiate == 0 && !SSL_IS_FIRST_HANDSHAKE(s)) { if (!ossl_assert(!SSL_CONNECTION_IS_TLS13(s))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!RENEG_OPTIONS_OK(s->options) \|\| (!s->s3.send_connection_binding && (s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) == 0)) { ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION); return MSG_PROCESS_FINISHED_READING; } s->renegotiate = 1; s->new_session = 1; } clienthello = OPENSSL_zalloc(sizeof(clienthello)); if (clienthello == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* * First, parse the raw ClientHello data into the CLIENTHELLO_MSG structure. / clienthello->isv2 = RECORD_LAYER_is_sslv2_record(&s->rlayer); PACKET_null_init(&cookie); if (clienthello->isv2) { unsigned int mt; if (!SSL_IS_FIRST_HANDSHAKE(s) \|\| s->hello_retry_request != SSL_HRR_NONE) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto err; } /- * An SSLv3/TLSv1 backwards-compatible CLIENT-HELLO in an SSLv2 * header is sent directly on the wire, not wrapped as a TLS * record. Our record layer just processes the message length and passes * the rest right through. Its format is: * Byte Content * 0-1 msg_length - decoded by the record layer * 2 msg_type - s->init_msg points here * 3-4 version * 5-6 cipher_spec_length * 7-8 session_id_length * 9-10 challenge_length * ... ... / if (!PACKET_get_1(pkt, &mt) \|\| mt != SSL2_MT_CLIENT_HELLO) { / * Should never happen. We should have tested this in the record * layer in order to have determined that this is a SSLv2 record * in the first place / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (!PACKET_get_net_2(pkt, &clienthello->legacy_version)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); goto err; } / Parse the message and load client random. / if (clienthello->isv2) { / * Handle an SSLv2 backwards compatible ClientHello * Note, this is only for SSLv3+ using the backward compatible format. * Real SSLv2 is not supported, and is rejected below. / unsigned int ciphersuite_len, session_id_len, challenge_len; PACKET challenge; if (!PACKET_get_net_2(pkt, &ciphersuite_len) \|\| !PACKET_get_net_2(pkt, &session_id_len) \|\| !PACKET_get_net_2(pkt, &challenge_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RECORD_LENGTH_MISMATCH); goto err; } if (session_id_len > SSL_MAX_SSL_SESSION_ID_LENGTH) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_get_sub_packet(pkt, &clienthello->ciphersuites, ciphersuite_len) \|\| !PACKET_copy_bytes(pkt, clienthello->session_id, session_id_len) \|\| !PACKET_get_sub_packet(pkt, &challenge, challenge_len) / No extensions. / \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RECORD_LENGTH_MISMATCH); goto err; } clienthello->session_id_len = session_id_len; / Load the client random and compression list. We use SSL3_RANDOM_SIZE * here rather than sizeof(clienthello->random) because that is the limit * for SSLv3 and it is fixed. It won't change even if * sizeof(clienthello->random) does. / challenge_len = challenge_len > SSL3_RANDOM_SIZE ? SSL3_RANDOM_SIZE : challenge_len; memset(clienthello->random, 0, SSL3_RANDOM_SIZE); if (!PACKET_copy_bytes(&challenge, clienthello->random + SSL3_RANDOM_SIZE - challenge_len, challenge_len) / Advertise only null compression. / \|\| !PACKET_buf_init(&compression, &null_compression, 1)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } PACKET_null_init(&clienthello->extensions); } else { / Regular ClientHello. / if (!PACKET_copy_bytes(pkt, clienthello->random, SSL3_RANDOM_SIZE) \|\| !PACKET_get_length_prefixed_1(pkt, &session_id) \|\| !PACKET_copy_all(&session_id, clienthello->session_id, SSL_MAX_SSL_SESSION_ID_LENGTH, &clienthello->session_id_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (SSL_CONNECTION_IS_DTLS(s)) { if (!PACKET_get_length_prefixed_1(pkt, &cookie)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_copy_all(&cookie, clienthello->dtls_cookie, DTLS1_COOKIE_LENGTH, &clienthello->dtls_cookie_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / * If we require cookies and this ClientHello doesn't contain one, * just return since we do not want to allocate any memory yet. * So check cookie length... / if (SSL_get_options(SSL_CONNECTION_GET_SSL(s)) & SSL_OP_COOKIE_EXCHANGE) { if (clienthello->dtls_cookie_len == 0) { OPENSSL_free(clienthello); return MSG_PROCESS_FINISHED_READING; } } } if (!PACKET_get_length_prefixed_2(pkt, &clienthello->ciphersuites)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_get_length_prefixed_1(pkt, &compression)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } / Could be empty. / if (PACKET_remaining(pkt) == 0) { PACKET_null_init(&clienthello->extensions); } else { if (!PACKET_get_length_prefixed_2(pkt, &clienthello->extensions) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } } } if (!PACKET_copy_all(&compression, clienthello->compressions, MAX_COMPRESSIONS_SIZE, &clienthello->compressions_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Preserve the raw extensions PACKET for later use / extensions = clienthello->extensions; if (!tls_collect_extensions(s, &extensions, SSL_EXT_CLIENT_HELLO, &clienthello->pre_proc_exts, &clienthello->pre_proc_exts_len, 1)) { / SSLfatal already been called / goto err; } s->clienthello = clienthello; return MSG_PROCESS_CONTINUE_PROCESSING; err: if (clienthello != NULL) OPENSSL_free(clienthello->pre_proc_exts); OPENSSL_free(clienthello); return MSG_PROCESS_ERROR; } static int tls_early_post_process_client_hello(SSL_CONNECTION s) { unsigned int j; int i, al = SSL_AD_INTERNAL_ERROR; int protverr; size_t loop; unsigned long id; #ifndef OPENSSL_NO_COMP SSL_COMP comp = NULL; #endif const SSL_CIPHER c; STACK_OF(SSL_CIPHER) ciphers = NULL; STACK_OF(SSL_CIPHER) scsvs = NULL; CLIENTHELLO_MSG clienthello = s->clienthello; DOWNGRADE dgrd = DOWNGRADE_NONE; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); SSL ssl = SSL_CONNECTION_GET_SSL(s); / Finished parsing the ClientHello, now we can start processing it / / Give the ClientHello callback a crack at things / if (sctx->client_hello_cb != NULL) { / A failure in the ClientHello callback terminates the connection. / switch (sctx->client_hello_cb(ssl, &al, sctx->client_hello_cb_arg)) { case SSL_CLIENT_HELLO_SUCCESS: break; case SSL_CLIENT_HELLO_RETRY: s->rwstate = SSL_CLIENT_HELLO_CB; return -1; case SSL_CLIENT_HELLO_ERROR: default: SSLfatal(s, al, SSL_R_CALLBACK_FAILED); goto err; } } / Set up the client_random / memcpy(s->s3.client_random, clienthello->random, SSL3_RANDOM_SIZE); / Choose the version / if (clienthello->isv2) { if (clienthello->legacy_version == SSL2_VERSION \|\| (clienthello->legacy_version & 0xff00) != (SSL3_VERSION_MAJOR << 8)) { / * This is real SSLv2 or something completely unknown. We don't * support it. / SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_UNKNOWN_PROTOCOL); goto err; } / SSLv3/TLS / s->client_version = clienthello->legacy_version; } / Choose the server SSL/TLS/DTLS version. / protverr = ssl_choose_server_version(s, clienthello, &dgrd); if (protverr) { if (SSL_IS_FIRST_HANDSHAKE(s)) { / like ssl3_get_record, send alert using remote version number / s->version = s->client_version = clienthello->legacy_version; } SSLfatal(s, SSL_AD_PROTOCOL_VERSION, protverr); goto err; } / TLSv1.3 specifies that a ClientHello must end on a record boundary / if (SSL_CONNECTION_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); goto err; } if (SSL_CONNECTION_IS_DTLS(s)) { / Empty cookie was already handled above by returning early. / if (SSL_get_options(ssl) & SSL_OP_COOKIE_EXCHANGE) { if (sctx->app_verify_cookie_cb != NULL) { if (sctx->app_verify_cookie_cb(ssl, clienthello->dtls_cookie, clienthello->dtls_cookie_len) == 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_COOKIE_MISMATCH); goto err; / else cookie verification succeeded / } / default verification / } else if (s->d1->cookie_len != clienthello->dtls_cookie_len \|\| memcmp(clienthello->dtls_cookie, s->d1->cookie, s->d1->cookie_len) != 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_COOKIE_MISMATCH); goto err; } s->d1->cookie_verified = 1; } } s->hit = 0; if (!ssl_cache_cipherlist(s, &clienthello->ciphersuites, clienthello->isv2) \|\| !ossl_bytes_to_cipher_list(s, &clienthello->ciphersuites, &ciphers, &scsvs, clienthello->isv2, 1)) { / SSLfatal() already called / goto err; } s->s3.send_connection_binding = 0; / Check what signalling cipher-suite values were received. / if (scsvs != NULL) { for (i = 0; i < sk_SSL_CIPHER_num(scsvs); i++) { c = sk_SSL_CIPHER_value(scsvs, i); if (SSL_CIPHER_get_id(c) == SSL3_CK_SCSV) { if (s->renegotiate) { / SCSV is fatal if renegotiating / SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING); goto err; } s->s3.send_connection_binding = 1; } else if (SSL_CIPHER_get_id(c) == SSL3_CK_FALLBACK_SCSV && !ssl_check_version_downgrade(s)) { / * This SCSV indicates that the client previously tried * a higher version. We should fail if the current version * is an unexpected downgrade, as that indicates that the first * connection may have been tampered with in order to trigger * an insecure downgrade. / SSLfatal(s, SSL_AD_INAPPROPRIATE_FALLBACK, SSL_R_INAPPROPRIATE_FALLBACK); goto err; } } } / For TLSv1.3 we must select the ciphersuite before session resumption / if (SSL_CONNECTION_IS_TLS13(s)) { const SSL_CIPHER cipher = ssl3_choose_cipher(s, ciphers, SSL_get_ciphers(ssl)); if (cipher == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER); goto err; } if (s->hello_retry_request == SSL_HRR_PENDING && (s->s3.tmp.new_cipher == NULL \|\| s->s3.tmp.new_cipher->id != cipher->id)) { /* * A previous HRR picked a different ciphersuite to the one we * just selected. Something must have changed. / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_CIPHER); goto err; } s->s3.tmp.new_cipher = cipher; } / We need to do this before getting the session / if (!tls_parse_extension(s, TLSEXT_IDX_extended_master_secret, SSL_EXT_CLIENT_HELLO, clienthello->pre_proc_exts, NULL, 0)) { / SSLfatal() already called / goto err; } / * We don't allow resumption in a backwards compatible ClientHello. * In TLS1.1+, session_id MUST be empty. * * Versions before 0.9.7 always allow clients to resume sessions in * renegotiation. 0.9.7 and later allow this by default, but optionally * ignore resumption requests with flag * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather * than a change to default behavior so that applications relying on * this for security won't even compile against older library versions). * 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to * request renegotiation but not a new session (s->new_session remains * unset): for servers, this essentially just means that the * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be * ignored. / if (clienthello->isv2 \|\| (s->new_session && (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) { if (!ssl_get_new_session(s, 1)) { / SSLfatal() already called / goto err; } } else { i = ssl_get_prev_session(s, clienthello); if (i == 1) { / previous session / s->hit = 1; } else if (i == -1) { / SSLfatal() already called / goto err; } else { / i == 0 / if (!ssl_get_new_session(s, 1)) { / SSLfatal() already called / goto err; } } } if (SSL_CONNECTION_IS_TLS13(s)) { memcpy(s->tmp_session_id, s->clienthello->session_id, s->clienthello->session_id_len); s->tmp_session_id_len = s->clienthello->session_id_len; } / * If it is a hit, check that the cipher is in the list. In TLSv1.3 we check * ciphersuite compatibility with the session as part of resumption. / if (!SSL_CONNECTION_IS_TLS13(s) && s->hit) { j = 0; id = s->session->cipher->id; OSSL_TRACE_BEGIN(TLS_CIPHER) { BIO_printf(trc_out, "client sent %d ciphers\n", sk_SSL_CIPHER_num(ciphers)); } for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) { c = sk_SSL_CIPHER_value(ciphers, i); if (trc_out != NULL) BIO_printf(trc_out, "client [%2d of %2d]:%s\n", i, sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c)); if (c->id == id) { j = 1; break; } } if (j == 0) { / * we need to have the cipher in the cipher list if we are asked * to reuse it / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_REQUIRED_CIPHER_MISSING); OSSL_TRACE_CANCEL(TLS_CIPHER); goto err; } OSSL_TRACE_END(TLS_CIPHER); } for (loop = 0; loop < clienthello->compressions_len; loop++) { if (clienthello->compressions[loop] == 0) break; } if (loop >= clienthello->compressions_len) { / no compress / SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_NO_COMPRESSION_SPECIFIED); goto err; } if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG) ssl_check_for_safari(s, clienthello); / TLS extensions / if (!tls_parse_all_extensions(s, SSL_EXT_CLIENT_HELLO, clienthello->pre_proc_exts, NULL, 0, 1)) { / SSLfatal() already called / goto err; } / * Check if we want to use external pre-shared secret for this handshake * for not reused session only. We need to generate server_random before * calling tls_session_secret_cb in order to allow SessionTicket * processing to use it in key derivation. / { unsigned char pos; pos = s->s3.server_random; if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE, dgrd) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (!s->hit && s->version >= TLS1_VERSION && !SSL_CONNECTION_IS_TLS13(s) && !SSL_CONNECTION_IS_DTLS(s) && s->ext.session_secret_cb != NULL) { const SSL_CIPHER pref_cipher = NULL; / * s->session->master_key_length is a size_t, but this is an int for * backwards compat reasons / int master_key_length; master_key_length = sizeof(s->session->master_key); if (s->ext.session_secret_cb(ssl, s->session->master_key, &master_key_length, ciphers, &pref_cipher, s->ext.session_secret_cb_arg) && master_key_length > 0) { s->session->master_key_length = master_key_length; s->hit = 1; s->peer_ciphers = ciphers; s->session->verify_result = X509_V_OK; ciphers = NULL; / check if some cipher was preferred by call back / if (pref_cipher == NULL) pref_cipher = ssl3_choose_cipher(s, s->peer_ciphers, SSL_get_ciphers(ssl)); if (pref_cipher == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER); goto err; } s->session->cipher = pref_cipher; sk_SSL_CIPHER_free(s->cipher_list); s->cipher_list = sk_SSL_CIPHER_dup(s->peer_ciphers); sk_SSL_CIPHER_free(s->cipher_list_by_id); s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->peer_ciphers); } } / * Worst case, we will use the NULL compression, but if we have other * options, we will now look for them. We have complen-1 compression * algorithms from the client, starting at q. / s->s3.tmp.new_compression = NULL; if (SSL_CONNECTION_IS_TLS13(s)) { / * We already checked above that the NULL compression method appears in * the list. Now we check there aren't any others (which is illegal in * a TLSv1.3 ClientHello. / if (clienthello->compressions_len != 1) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_COMPRESSION_ALGORITHM); goto err; } } #ifndef OPENSSL_NO_COMP / This only happens if we have a cache hit / else if (s->session->compress_meth != 0) { int m, comp_id = s->session->compress_meth; unsigned int k; / Perform sanity checks on resumed compression algorithm / / Can't disable compression / if (!ssl_allow_compression(s)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_COMPRESSION); goto err; } / Look for resumed compression method / for (m = 0; m < sk_SSL_COMP_num(sctx->comp_methods); m++) { comp = sk_SSL_COMP_value(sctx->comp_methods, m); if (comp_id == comp->id) { s->s3.tmp.new_compression = comp; break; } } if (s->s3.tmp.new_compression == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INVALID_COMPRESSION_ALGORITHM); goto err; } / Look for resumed method in compression list / for (k = 0; k < clienthello->compressions_len; k++) { if (clienthello->compressions[k] == comp_id) break; } if (k >= clienthello->compressions_len) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING); goto err; } } else if (s->hit) { comp = NULL; } else if (ssl_allow_compression(s) && sctx->comp_methods) { / See if we have a match / int m, nn, v, done = 0; unsigned int o; nn = sk_SSL_COMP_num(sctx->comp_methods); for (m = 0; m < nn; m++) { comp = sk_SSL_COMP_value(sctx->comp_methods, m); v = comp->id; for (o = 0; o < clienthello->compressions_len; o++) { if (v == clienthello->compressions[o]) { done = 1; break; } } if (done) break; } if (done) s->s3.tmp.new_compression = comp; else comp = NULL; } #else / * If compression is disabled we'd better not try to resume a session * using compression. / if (s->session->compress_meth != 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_COMPRESSION); goto err; } #endif / * Given s->peer_ciphers and SSL_get_ciphers, we must pick a cipher / if (!s->hit \|\| SSL_CONNECTION_IS_TLS13(s)) { sk_SSL_CIPHER_free(s->peer_ciphers); s->peer_ciphers = ciphers; if (ciphers == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ciphers = NULL; } if (!s->hit) { #ifdef OPENSSL_NO_COMP s->session->compress_meth = 0; #else s->session->compress_meth = (comp == NULL) ? 0 : comp->id; #endif if (!tls1_set_server_sigalgs(s)) { / SSLfatal() already called / goto err; } } sk_SSL_CIPHER_free(ciphers); sk_SSL_CIPHER_free(scsvs); OPENSSL_free(clienthello->pre_proc_exts); OPENSSL_free(s->clienthello); s->clienthello = NULL; return 1; err: sk_SSL_CIPHER_free(ciphers); sk_SSL_CIPHER_free(scsvs); OPENSSL_free(clienthello->pre_proc_exts); OPENSSL_free(s->clienthello); s->clienthello = NULL; return 0; } / * Call the status request callback if needed. Upon success, returns 1. * Upon failure, returns 0. / static int tls_handle_status_request(SSL_CONNECTION s) { SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); s->ext.status_expected = 0; / * If status request then ask callback what to do. Note: this must be * called after servername callbacks in case the certificate has changed, * and must be called after the cipher has been chosen because this may * influence which certificate is sent / if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing && sctx != NULL && sctx->ext.status_cb != NULL) { int ret; / If no certificate can't return certificate status / if (s->s3.tmp.cert != NULL) { / * Set current certificate to one we will use so SSL_get_certificate * et al can pick it up. / s->cert->key = s->s3.tmp.cert; ret = sctx->ext.status_cb(SSL_CONNECTION_GET_SSL(s), sctx->ext.status_arg); switch (ret) { / We don't want to send a status request response / case SSL_TLSEXT_ERR_NOACK: s->ext.status_expected = 0; break; / status request response should be sent / case SSL_TLSEXT_ERR_OK: if (s->ext.ocsp.resp) s->ext.status_expected = 1; break; / something bad happened / case SSL_TLSEXT_ERR_ALERT_FATAL: default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CLIENTHELLO_TLSEXT); return 0; } } } return 1; } / * Call the alpn_select callback if needed. Upon success, returns 1. * Upon failure, returns 0. / int tls_handle_alpn(SSL_CONNECTION s) { const unsigned char selected = NULL; unsigned char selected_len = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (sctx->ext.alpn_select_cb != NULL && s->s3.alpn_proposed != NULL) { int r = sctx->ext.alpn_select_cb(SSL_CONNECTION_GET_SSL(s), &selected, &selected_len, s->s3.alpn_proposed, (unsigned int)s->s3.alpn_proposed_len, sctx->ext.alpn_select_cb_arg); if (r == SSL_TLSEXT_ERR_OK) { OPENSSL_free(s->s3.alpn_selected); s->s3.alpn_selected = OPENSSL_memdup(selected, selected_len); if (s->s3.alpn_selected == NULL) { s->s3.alpn_selected_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->s3.alpn_selected_len = selected_len; #ifndef OPENSSL_NO_NEXTPROTONEG /* ALPN takes precedence over NPN. / s->s3.npn_seen = 0; #endif / Check ALPN is consistent with session / if (s->session->ext.alpn_selected == NULL \|\| selected_len != s->session->ext.alpn_selected_len \|\| memcmp(selected, s->session->ext.alpn_selected, selected_len) != 0) { / Not consistent so can't be used for early_data / s->ext.early_data_ok = 0; if (!s->hit) { / * This is a new session and so alpn_selected should have * been initialised to NULL. We should update it with the * selected ALPN. / if (!ossl_assert(s->session->ext.alpn_selected == NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.alpn_selected = OPENSSL_memdup(selected, selected_len); if (s->session->ext.alpn_selected == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.alpn_selected_len = selected_len; } } return 1; } else if (r != SSL_TLSEXT_ERR_NOACK) { SSLfatal(s, SSL_AD_NO_APPLICATION_PROTOCOL, SSL_R_NO_APPLICATION_PROTOCOL); return 0; } / * If r == SSL_TLSEXT_ERR_NOACK then behave as if no callback was * present. / } / Check ALPN is consistent with session / if (s->session->ext.alpn_selected != NULL) { / Not consistent so can't be used for early_data / s->ext.early_data_ok = 0; } return 1; } WORK_STATE tls_post_process_client_hello(SSL_CONNECTION s, WORK_STATE wst) { const SSL_CIPHER cipher; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (wst == WORK_MORE_A) { int rv = tls_early_post_process_client_hello(s); if (rv == 0) { /* SSLfatal() was already called / goto err; } if (rv < 0) return WORK_MORE_A; wst = WORK_MORE_B; } if (wst == WORK_MORE_B) { if (!s->hit \|\| SSL_CONNECTION_IS_TLS13(s)) { / Let cert callback update server certificates if required / if (!s->hit && s->cert->cert_cb != NULL) { int rv = s->cert->cert_cb(ssl, s->cert->cert_cb_arg); if (rv == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CERT_CB_ERROR); goto err; } if (rv < 0) { s->rwstate = SSL_X509_LOOKUP; return WORK_MORE_B; } s->rwstate = SSL_NOTHING; } / In TLSv1.3 we selected the ciphersuite before resumption / if (!SSL_CONNECTION_IS_TLS13(s)) { cipher = ssl3_choose_cipher(s, s->peer_ciphers, SSL_get_ciphers(ssl)); if (cipher == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER); goto err; } s->s3.tmp.new_cipher = cipher; } if (!s->hit) { if (!tls_choose_sigalg(s, 1)) { / SSLfatal already called / goto err; } / check whether we should disable session resumption / if (s->not_resumable_session_cb != NULL) s->session->not_resumable = s->not_resumable_session_cb(ssl, ((s->s3.tmp.new_cipher->algorithm_mkey & (SSL_kDHE \| SSL_kECDHE)) != 0)); if (s->session->not_resumable) / do not send a session ticket / s->ext.ticket_expected = 0; } } else { / Session-id reuse / s->s3.tmp.new_cipher = s->session->cipher; } /- * we now have the following setup. * client_random * cipher_list - our preferred list of ciphers * ciphers - the client's preferred list of ciphers * compression - basically ignored right now * ssl version is set - sslv3 * s->session - The ssl session has been setup. * s->hit - session reuse flag * s->s3.tmp.new_cipher - the new cipher to use. / / * Call status_request callback if needed. Has to be done after the * certificate callbacks etc above. / if (!tls_handle_status_request(s)) { / SSLfatal() already called / goto err; } / * Call alpn_select callback if needed. Has to be done after SNI and * cipher negotiation (HTTP/2 restricts permitted ciphers). In TLSv1.3 * we already did this because cipher negotiation happens earlier, and * we must handle ALPN before we decide whether to accept early_data. / if (!SSL_CONNECTION_IS_TLS13(s) && !tls_handle_alpn(s)) { / SSLfatal() already called / goto err; } wst = WORK_MORE_C; } #ifndef OPENSSL_NO_SRP if (wst == WORK_MORE_C) { int ret; if ((ret = ssl_check_srp_ext_ClientHello(s)) == 0) { / * callback indicates further work to be done / s->rwstate = SSL_X509_LOOKUP; return WORK_MORE_C; } if (ret < 0) { / SSLfatal() already called / goto err; } } #endif return WORK_FINISHED_STOP; err: return WORK_ERROR; } CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION s, WPACKET pkt) { int compm; size_t sl, len; int version; unsigned char session_id; int usetls13 = SSL_CONNECTION_IS_TLS13(s) \|\| s->hello_retry_request == SSL_HRR_PENDING; version = usetls13 ? TLS1_2_VERSION : s->version; if (!WPACKET_put_bytes_u16(pkt, version) /* * Random stuff. Filling of the server_random takes place in * tls_process_client_hello() / \|\| !WPACKET_memcpy(pkt, s->hello_retry_request == SSL_HRR_PENDING ? hrrrandom : s->s3.server_random, SSL3_RANDOM_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /- * There are several cases for the session ID to send * back in the server hello: * - For session reuse from the session cache, * we send back the old session ID. * - If stateless session reuse (using a session ticket) * is successful, we send back the client's "session ID" * (which doesn't actually identify the session). * - If it is a new session, we send back the new * session ID. * - However, if we want the new session to be single-use, * we send back a 0-length session ID. * - In TLSv1.3 we echo back the session id sent to us by the client * regardless * s->hit is non-zero in either case of session reuse, * so the following won't overwrite an ID that we're supposed * to send back. / if (s->session->not_resumable \|\| (!(SSL_CONNECTION_GET_CTX(s)->session_cache_mode & SSL_SESS_CACHE_SERVER) && !s->hit)) s->session->session_id_length = 0; if (usetls13) { sl = s->tmp_session_id_len; session_id = s->tmp_session_id; } else { sl = s->session->session_id_length; session_id = s->session->session_id; } if (sl > sizeof(s->session->session_id)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / set up the compression method / #ifdef OPENSSL_NO_COMP compm = 0; #else if (usetls13 \|\| s->s3.tmp.new_compression == NULL) compm = 0; else compm = s->s3.tmp.new_compression->id; #endif if (!WPACKET_sub_memcpy_u8(pkt, session_id, sl) \|\| !SSL_CONNECTION_GET_SSL(s)->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt, &len) \|\| !WPACKET_put_bytes_u8(pkt, compm)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (!tls_construct_extensions(s, pkt, s->hello_retry_request == SSL_HRR_PENDING ? SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST : (SSL_CONNECTION_IS_TLS13(s) ? SSL_EXT_TLS1_3_SERVER_HELLO : SSL_EXT_TLS1_2_SERVER_HELLO), NULL, 0)) { / SSLfatal() already called / return CON_FUNC_ERROR; } if (s->hello_retry_request == SSL_HRR_PENDING) { / Ditch the session. We'll create a new one next time around / SSL_SESSION_free(s->session); s->session = NULL; s->hit = 0; / * Re-initialise the Transcript Hash. We're going to prepopulate it with * a synthetic message_hash in place of ClientHello1. / if (!create_synthetic_message_hash(s, NULL, 0, NULL, 0)) { / SSLfatal() already called / return CON_FUNC_ERROR; } } else if (!(s->verify_mode & SSL_VERIFY_PEER) && !ssl3_digest_cached_records(s, 0)) { / SSLfatal() already called /; return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } CON_FUNC_RETURN tls_construct_server_done(SSL_CONNECTION s, WPACKET pkt) { if (!s->s3.tmp.cert_request) { if (!ssl3_digest_cached_records(s, 0)) { / SSLfatal() already called / return CON_FUNC_ERROR; } } return CON_FUNC_SUCCESS; } CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION s, WPACKET pkt) { EVP_PKEY pkdh = NULL; unsigned char encodedPoint = NULL; size_t encodedlen = 0; int curve_id = 0; const SIGALG_LOOKUP lu = s->s3.tmp.sigalg; int i; unsigned long type; BIGNUM r[4]; EVP_MD_CTX md_ctx = EVP_MD_CTX_new(); EVP_PKEY_CTX pctx = NULL; size_t paramlen, paramoffset; int freer = 0; CON_FUNC_RETURN ret = CON_FUNC_ERROR; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (!WPACKET_get_total_written(pkt, &paramoffset)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (md_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } type = s->s3.tmp.new_cipher->algorithm_mkey; r[0] = r[1] = r[2] = r[3] = NULL; #ifndef OPENSSL_NO_PSK /* Plain PSK or RSAPSK nothing to do / if (type & (SSL_kPSK \| SSL_kRSAPSK)) { } else #endif / !OPENSSL_NO_PSK / if (type & (SSL_kDHE \| SSL_kDHEPSK)) { CERT cert = s->cert; EVP_PKEY pkdhp = NULL; if (s->cert->dh_tmp_auto) { pkdh = ssl_get_auto_dh(s); if (pkdh == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pkdhp = pkdh; } else { pkdhp = cert->dh_tmp; } #if !defined(OPENSSL_NO_DEPRECATED_3_0) if ((pkdhp == NULL) && (s->cert->dh_tmp_cb != NULL)) { pkdh = ssl_dh_to_pkey(s->cert->dh_tmp_cb(SSL_CONNECTION_GET_SSL(s), 0, 1024)); if (pkdh == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pkdhp = pkdh; } #endif if (pkdhp == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_TMP_DH_KEY); goto err; } if (!ssl_security(s, SSL_SECOP_TMP_DH, EVP_PKEY_get_security_bits(pkdhp), 0, pkdhp)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DH_KEY_TOO_SMALL); goto err; } if (s->s3.tmp.pkey != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } s->s3.tmp.pkey = ssl_generate_pkey(s, pkdhp); if (s->s3.tmp.pkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } EVP_PKEY_free(pkdh); pkdh = NULL; / These BIGNUMs need to be freed when we're finished / freer = 1; if (!EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_FFC_P, &r[0]) \|\| !EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_FFC_G, &r[1]) \|\| !EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_PUB_KEY, &r[2])) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } else if (type & (SSL_kECDHE \| SSL_kECDHEPSK)) { if (s->s3.tmp.pkey != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Get NID of appropriate shared curve / curve_id = tls1_shared_group(s, -2); if (curve_id == 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNSUPPORTED_ELLIPTIC_CURVE); goto err; } / Cache the group used in the SSL_SESSION / s->session->kex_group = curve_id; / Generate a new key for this curve / s->s3.tmp.pkey = ssl_generate_pkey_group(s, curve_id); if (s->s3.tmp.pkey == NULL) { / SSLfatal() already called / goto err; } / Encode the public key. / encodedlen = EVP_PKEY_get1_encoded_public_key(s->s3.tmp.pkey, &encodedPoint); if (encodedlen == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); goto err; } / * We'll generate the serverKeyExchange message explicitly so we * can set these to NULLs / r[0] = NULL; r[1] = NULL; r[2] = NULL; r[3] = NULL; } else #ifndef OPENSSL_NO_SRP if (type & SSL_kSRP) { if ((s->srp_ctx.N == NULL) \|\| (s->srp_ctx.g == NULL) \|\| (s->srp_ctx.s == NULL) \|\| (s->srp_ctx.B == NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_SRP_PARAM); goto err; } r[0] = s->srp_ctx.N; r[1] = s->srp_ctx.g; r[2] = s->srp_ctx.s; r[3] = s->srp_ctx.B; } else #endif { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE); goto err; } if (((s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL \| SSL_aSRP)) != 0) \|\| ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK)) != 0) { lu = NULL; } else if (lu == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR); goto err; } #ifndef OPENSSL_NO_PSK if (type & SSL_PSK) { size_t len = (s->cert->psk_identity_hint == NULL) ? 0 : strlen(s->cert->psk_identity_hint); / * It should not happen that len > PSK_MAX_IDENTITY_LEN - we already * checked this when we set the identity hint - but just in case / if (len > PSK_MAX_IDENTITY_LEN \|\| !WPACKET_sub_memcpy_u16(pkt, s->cert->psk_identity_hint, len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } #endif for (i = 0; i < 4 && r[i] != NULL; i++) { unsigned char binval; int res; #ifndef OPENSSL_NO_SRP if ((i == 2) && (type & SSL_kSRP)) { res = WPACKET_start_sub_packet_u8(pkt); } else #endif res = WPACKET_start_sub_packet_u16(pkt); if (!res) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /- for interoperability with some versions of the Microsoft TLS * stack, we need to zero pad the DHE pub key to the same length * as the prime / if ((i == 2) && (type & (SSL_kDHE \| SSL_kDHEPSK))) { size_t len = BN_num_bytes(r[0]) - BN_num_bytes(r[2]); if (len > 0) { if (!WPACKET_allocate_bytes(pkt, len, &binval)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } memset(binval, 0, len); } } if (!WPACKET_allocate_bytes(pkt, BN_num_bytes(r[i]), &binval) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } BN_bn2bin(r[i], binval); } if (type & (SSL_kECDHE \| SSL_kECDHEPSK)) { / * We only support named (not generic) curves. In this situation, the * ServerKeyExchange message has: [1 byte CurveType], [2 byte CurveName] * [1 byte length of encoded point], followed by the actual encoded * point itself / if (!WPACKET_put_bytes_u8(pkt, NAMED_CURVE_TYPE) \|\| !WPACKET_put_bytes_u8(pkt, 0) \|\| !WPACKET_put_bytes_u8(pkt, curve_id) \|\| !WPACKET_sub_memcpy_u8(pkt, encodedPoint, encodedlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } OPENSSL_free(encodedPoint); encodedPoint = NULL; } / not anonymous / if (lu != NULL) { EVP_PKEY pkey = s->s3.tmp.cert->privatekey; const EVP_MD md; unsigned char sigbytes1, sigbytes2, tbs; size_t siglen = 0, tbslen; if (pkey == NULL \|\| !tls1_lookup_md(sctx, lu, &md)) { /* Should never happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Get length of the parameters we have written above / if (!WPACKET_get_length(pkt, &paramlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / send signature algorithm / if (SSL_USE_SIGALGS(s) && !WPACKET_put_bytes_u16(pkt, lu->sigalg)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (EVP_DigestSignInit_ex(md_ctx, &pctx, md == NULL ? NULL : EVP_MD_get0_name(md), sctx->libctx, sctx->propq, pkey, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (lu->sig == EVP_PKEY_RSA_PSS) { if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0 \|\| EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } tbslen = construct_key_exchange_tbs(s, &tbs, s->init_buf->data + paramoffset, paramlen); if (tbslen == 0) { / SSLfatal() already called / goto err; } if (EVP_DigestSign(md_ctx, NULL, &siglen, tbs, tbslen) <=0 \|\| !WPACKET_sub_reserve_bytes_u16(pkt, siglen, &sigbytes1) \|\| EVP_DigestSign(md_ctx, sigbytes1, &siglen, tbs, tbslen) <= 0 \|\| !WPACKET_sub_allocate_bytes_u16(pkt, siglen, &sigbytes2) \|\| sigbytes1 != sigbytes2) { OPENSSL_free(tbs); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } OPENSSL_free(tbs); } ret = CON_FUNC_SUCCESS; err: EVP_PKEY_free(pkdh); OPENSSL_free(encodedPoint); EVP_MD_CTX_free(md_ctx); if (freer) { BN_free(r[0]); BN_free(r[1]); BN_free(r[2]); BN_free(r[3]); } return ret; } CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION s, WPACKET pkt) { if (SSL_CONNECTION_IS_TLS13(s)) { / Send random context when doing post-handshake auth / if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) { OPENSSL_free(s->pha_context); s->pha_context_len = 32; if ((s->pha_context = OPENSSL_malloc(s->pha_context_len)) == NULL) { s->pha_context_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, s->pha_context, s->pha_context_len, 0) <= 0 \|\| !WPACKET_sub_memcpy_u8(pkt, s->pha_context, s->pha_context_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / reset the handshake hash back to just after the ClientFinished / if (!tls13_restore_handshake_digest_for_pha(s)) { / SSLfatal() already called / return CON_FUNC_ERROR; } } else { if (!WPACKET_put_bytes_u8(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } if (!tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, NULL, 0)) { / SSLfatal() already called / return CON_FUNC_ERROR; } goto done; } / get the list of acceptable cert types / if (!WPACKET_start_sub_packet_u8(pkt) \|\| !ssl3_get_req_cert_type(s, pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (SSL_USE_SIGALGS(s)) { const uint16_t psigs; size_t nl = tls12_get_psigalgs(s, 1, &psigs); if (!WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH) \|\| !tls12_copy_sigalgs(s, pkt, psigs, nl) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } if (!construct_ca_names(s, get_ca_names(s), pkt)) { /* SSLfatal() already called / return CON_FUNC_ERROR; } done: s->certreqs_sent++; s->s3.tmp.cert_request = 1; return CON_FUNC_SUCCESS; } static int tls_process_cke_psk_preamble(SSL_CONNECTION s, PACKET pkt) { #ifndef OPENSSL_NO_PSK unsigned char psk[PSK_MAX_PSK_LEN]; size_t psklen; PACKET psk_identity; if (!PACKET_get_length_prefixed_2(pkt, &psk_identity)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (PACKET_remaining(&psk_identity) > PSK_MAX_IDENTITY_LEN) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } if (s->psk_server_callback == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_PSK_NO_SERVER_CB); return 0; } if (!PACKET_strndup(&psk_identity, &s->session->psk_identity)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } psklen = s->psk_server_callback(SSL_CONNECTION_GET_SSL(s), s->session->psk_identity, psk, sizeof(psk)); if (psklen > PSK_MAX_PSK_LEN) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } else if (psklen == 0) { / * PSK related to the given identity not found / SSLfatal(s, SSL_AD_UNKNOWN_PSK_IDENTITY, SSL_R_PSK_IDENTITY_NOT_FOUND); return 0; } OPENSSL_free(s->s3.tmp.psk); s->s3.tmp.psk = OPENSSL_memdup(psk, psklen); OPENSSL_cleanse(psk, psklen); if (s->s3.tmp.psk == NULL) { s->s3.tmp.psklen = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } s->s3.tmp.psklen = psklen; return 1; #else / Should never happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_cke_rsa(SSL_CONNECTION s, PACKET pkt) { size_t outlen; PACKET enc_premaster; EVP_PKEY rsa = NULL; unsigned char rsa_decrypt = NULL; int ret = 0; EVP_PKEY_CTX ctx = NULL; OSSL_PARAM params[3], p = params; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); rsa = s->cert->pkeys[SSL_PKEY_RSA].privatekey; if (rsa == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_RSA_CERTIFICATE); return 0; } /* SSLv3 and pre-standard DTLS omit the length bytes. / if (s->version == SSL3_VERSION \|\| s->version == DTLS1_BAD_VER) { enc_premaster = pkt; } else { if (!PACKET_get_length_prefixed_2(pkt, &enc_premaster) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } } outlen = SSL_MAX_MASTER_KEY_LENGTH; rsa_decrypt = OPENSSL_malloc(outlen); if (rsa_decrypt == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, rsa, sctx->propq); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } /* * We must not leak whether a decryption failure occurs because of * Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see RFC 2246, * section 7.4.7.1). We use the special padding type * RSA_PKCS1_WITH_TLS_PADDING to do that. It will automatically decrypt the * RSA, check the padding and check that the client version is as expected * in the premaster secret. If any of that fails then the function appears * to return successfully but with a random result. The call below could * still fail if the input is publicly invalid. * See https://tools.ietf.org/html/rfc5246#section-7.4.7.1 / if (EVP_PKEY_decrypt_init(ctx) <= 0 \|\| EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_WITH_TLS_PADDING) <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } p++ = OSSL_PARAM_construct_uint(OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION, (unsigned int )&s->client_version); if ((s->options & SSL_OP_TLS_ROLLBACK_BUG) != 0) p++ = OSSL_PARAM_construct_uint( OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION, (unsigned int )&s->version); p++ = OSSL_PARAM_construct_end(); if (!EVP_PKEY_CTX_set_params(ctx, params) \|\| EVP_PKEY_decrypt(ctx, rsa_decrypt, &outlen, PACKET_data(&enc_premaster), PACKET_remaining(&enc_premaster)) <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } /* * This test should never fail (otherwise we should have failed above) but * we double check anyway. / if (outlen != SSL_MAX_MASTER_KEY_LENGTH) { OPENSSL_cleanse(rsa_decrypt, SSL_MAX_MASTER_KEY_LENGTH); SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } / Also cleanses rsa_decrypt (on success or failure) / if (!ssl_generate_master_secret(s, rsa_decrypt, outlen, 0)) { / SSLfatal() already called / goto err; } ret = 1; err: OPENSSL_free(rsa_decrypt); EVP_PKEY_CTX_free(ctx); return ret; } static int tls_process_cke_dhe(SSL_CONNECTION s, PACKET pkt) { EVP_PKEY skey = NULL; unsigned int i; const unsigned char data; EVP_PKEY ckey = NULL; int ret = 0; if (!PACKET_get_net_2(pkt, &i) \|\| PACKET_remaining(pkt) != i) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG); goto err; } skey = s->s3.tmp.pkey; if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_TMP_DH_KEY); goto err; } if (PACKET_remaining(pkt) == 0L) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_MISSING_TMP_DH_KEY); goto err; } if (!PACKET_get_bytes(pkt, &data, i)) { /* We already checked we have enough data / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ckey = EVP_PKEY_new(); if (ckey == NULL \|\| EVP_PKEY_copy_parameters(ckey, skey) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COPY_PARAMETERS_FAILED); goto err; } if (!EVP_PKEY_set1_encoded_public_key(ckey, data, i)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (ssl_derive(s, skey, ckey, 1) == 0) { / SSLfatal() already called / goto err; } ret = 1; EVP_PKEY_free(s->s3.tmp.pkey); s->s3.tmp.pkey = NULL; err: EVP_PKEY_free(ckey); return ret; } static int tls_process_cke_ecdhe(SSL_CONNECTION s, PACKET pkt) { EVP_PKEY skey = s->s3.tmp.pkey; EVP_PKEY ckey = NULL; int ret = 0; if (PACKET_remaining(pkt) == 0L) { / We don't support ECDH client auth / SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_MISSING_TMP_ECDH_KEY); goto err; } else { unsigned int i; const unsigned char data; /* * Get client's public key from encoded point in the * ClientKeyExchange message. / / Get encoded point length / if (!PACKET_get_1(pkt, &i) \|\| !PACKET_get_bytes(pkt, &data, i) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_TMP_ECDH_KEY); goto err; } ckey = EVP_PKEY_new(); if (ckey == NULL \|\| EVP_PKEY_copy_parameters(ckey, skey) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COPY_PARAMETERS_FAILED); goto err; } if (EVP_PKEY_set1_encoded_public_key(ckey, data, i) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); goto err; } } if (ssl_derive(s, skey, ckey, 1) == 0) { / SSLfatal() already called / goto err; } ret = 1; EVP_PKEY_free(s->s3.tmp.pkey); s->s3.tmp.pkey = NULL; err: EVP_PKEY_free(ckey); return ret; } static int tls_process_cke_srp(SSL_CONNECTION s, PACKET pkt) { #ifndef OPENSSL_NO_SRP unsigned int i; const unsigned char data; if (!PACKET_get_net_2(pkt, &i) \|\| !PACKET_get_bytes(pkt, &data, i)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRP_A_LENGTH); return 0; } if ((s->srp_ctx.A = BN_bin2bn(data, i, NULL)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB); return 0; } if (BN_ucmp(s->srp_ctx.A, s->srp_ctx.N) >= 0 \|\| BN_is_zero(s->srp_ctx.A)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_SRP_PARAMETERS); return 0; } OPENSSL_free(s->session->srp_username); s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login); if (s->session->srp_username == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } if (!srp_generate_server_master_secret(s)) { /* SSLfatal() already called / return 0; } return 1; #else / Should never happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_cke_gost(SSL_CONNECTION s, PACKET pkt) { #ifndef OPENSSL_NO_GOST EVP_PKEY_CTX pkey_ctx; EVP_PKEY client_pub_pkey = NULL, pk = NULL; unsigned char premaster_secret[32]; const unsigned char start; size_t outlen = sizeof(premaster_secret), inlen; unsigned long alg_a; GOST_KX_MESSAGE pKX = NULL; const unsigned char ptr; int ret = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); /* Get our certificate private key / alg_a = s->s3.tmp.new_cipher->algorithm_auth; if (alg_a & SSL_aGOST12) { / * New GOST ciphersuites have SSL_aGOST01 bit too / pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey; if (pk == NULL) { pk = s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey; } if (pk == NULL) { pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey; } } else if (alg_a & SSL_aGOST01) { pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey; } pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pk, sctx->propq); if (pkey_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / * If client certificate is present and is of the same type, maybe * use it for key exchange. Don't mind errors from * EVP_PKEY_derive_set_peer, because it is completely valid to use a * client certificate for authorization only. / client_pub_pkey = tls_get_peer_pkey(s); if (client_pub_pkey) { if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0) ERR_clear_error(); } ptr = PACKET_data(pkt); / Some implementations provide extra data in the opaqueBlob * We have nothing to do with this blob so we just skip it / pKX = d2i_GOST_KX_MESSAGE(NULL, &ptr, PACKET_remaining(pkt)); if (pKX == NULL \|\| pKX->kxBlob == NULL \|\| ASN1_TYPE_get(pKX->kxBlob) != V_ASN1_SEQUENCE) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } if (!PACKET_forward(pkt, ptr - PACKET_data(pkt))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } inlen = pKX->kxBlob->value.sequence->length; start = pKX->kxBlob->value.sequence->data; if (EVP_PKEY_decrypt(pkey_ctx, premaster_secret, &outlen, start, inlen) <= 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } / Generate master secret / if (!ssl_generate_master_secret(s, premaster_secret, outlen, 0)) { / SSLfatal() already called / goto err; } / Check if pubkey from client certificate was used / if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0) s->statem.no_cert_verify = 1; ret = 1; err: EVP_PKEY_CTX_free(pkey_ctx); GOST_KX_MESSAGE_free(pKX); return ret; #else / Should never happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_cke_gost18(SSL_CONNECTION s, PACKET pkt) { #ifndef OPENSSL_NO_GOST unsigned char rnd_dgst[32]; EVP_PKEY_CTX pkey_ctx = NULL; EVP_PKEY pk = NULL; unsigned char premaster_secret[32]; const unsigned char start = NULL; size_t outlen = sizeof(premaster_secret), inlen = 0; int ret = 0; int cipher_nid = ossl_gost18_cke_cipher_nid(s); SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (cipher_nid == NID_undef) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (ossl_gost_ukm(s, rnd_dgst) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Get our certificate private key / pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey != NULL ? s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey : s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey; if (pk == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_STATE); goto err; } pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pk, sctx->propq); if (pkey_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Reuse EVP_PKEY_CTRL_SET_IV, make choice in engine code depending on size / if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_DECRYPT, EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_DECRYPT, EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } inlen = PACKET_remaining(pkt); start = PACKET_data(pkt); if (EVP_PKEY_decrypt(pkey_ctx, premaster_secret, &outlen, start, inlen) <= 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } / Generate master secret / if (!ssl_generate_master_secret(s, premaster_secret, outlen, 0)) { / SSLfatal() already called / goto err; } ret = 1; err: EVP_PKEY_CTX_free(pkey_ctx); return ret; #else / Should never happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION s, PACKET pkt) { unsigned long alg_k; alg_k = s->s3.tmp.new_cipher->algorithm_mkey; / For PSK parse and retrieve identity, obtain PSK key / if ((alg_k & SSL_PSK) && !tls_process_cke_psk_preamble(s, pkt)) { / SSLfatal() already called / goto err; } if (alg_k & SSL_kPSK) { / Identity extracted earlier: should be nothing left / if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } / PSK handled by ssl_generate_master_secret / if (!ssl_generate_master_secret(s, NULL, 0, 0)) { / SSLfatal() already called / goto err; } } else if (alg_k & (SSL_kRSA \| SSL_kRSAPSK)) { if (!tls_process_cke_rsa(s, pkt)) { / SSLfatal() already called / goto err; } } else if (alg_k & (SSL_kDHE \| SSL_kDHEPSK)) { if (!tls_process_cke_dhe(s, pkt)) { / SSLfatal() already called / goto err; } } else if (alg_k & (SSL_kECDHE \| SSL_kECDHEPSK)) { if (!tls_process_cke_ecdhe(s, pkt)) { / SSLfatal() already called / goto err; } } else if (alg_k & SSL_kSRP) { if (!tls_process_cke_srp(s, pkt)) { / SSLfatal() already called / goto err; } } else if (alg_k & SSL_kGOST) { if (!tls_process_cke_gost(s, pkt)) { / SSLfatal() already called / goto err; } } else if (alg_k & SSL_kGOST18) { if (!tls_process_cke_gost18(s, pkt)) { / SSLfatal() already called / goto err; } } else { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNKNOWN_CIPHER_TYPE); goto err; } return MSG_PROCESS_CONTINUE_PROCESSING; err: #ifndef OPENSSL_NO_PSK OPENSSL_clear_free(s->s3.tmp.psk, s->s3.tmp.psklen); s->s3.tmp.psk = NULL; s->s3.tmp.psklen = 0; #endif return MSG_PROCESS_ERROR; } WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION s, WORK_STATE wst) { #ifndef OPENSSL_NO_SCTP if (wst == WORK_MORE_A) { if (SSL_CONNECTION_IS_DTLS(s)) { unsigned char sctpauthkey[64]; char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)]; size_t labellen; /* * Add new shared key for SCTP-Auth, will be ignored if no SCTP * used. / memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL, sizeof(DTLS1_SCTP_AUTH_LABEL)); / Don't include the terminating zero. / labellen = sizeof(labelbuffer) - 1; if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG) labellen += 1; if (SSL_export_keying_material(SSL_CONNECTION_GET_SSL(s), sctpauthkey, sizeof(sctpauthkey), labelbuffer, labellen, NULL, 0, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } BIO_ctrl(s->wbio, BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY, sizeof(sctpauthkey), sctpauthkey); } } #endif if (s->statem.no_cert_verify \|\| !received_client_cert(s)) { / * No certificate verify or no peer certificate so we no longer need * the handshake_buffer / if (!ssl3_digest_cached_records(s, 0)) { / SSLfatal() already called / return WORK_ERROR; } return WORK_FINISHED_CONTINUE; } else { if (!s->s3.handshake_buffer) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } / * For sigalgs freeze the handshake buffer. If we support * extms we've done this already so this is a no-op / if (!ssl3_digest_cached_records(s, 1)) { / SSLfatal() already called / return WORK_ERROR; } } return WORK_FINISHED_CONTINUE; } MSG_PROCESS_RETURN tls_process_client_rpk(SSL_CONNECTION sc, PACKET pkt) { MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; SSL_SESSION new_sess = NULL; EVP_PKEY peer_rpk = NULL; if (!tls_process_rpk(sc, pkt, &peer_rpk)) { / SSLfatal already called / goto err; } if (peer_rpk == NULL) { if ((sc->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) && (sc->verify_mode & SSL_VERIFY_PEER)) { SSLfatal(sc, SSL_AD_CERTIFICATE_REQUIRED, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE); goto err; } } else { if (ssl_verify_rpk(sc, peer_rpk) <= 0) { SSLfatal(sc, ssl_x509err2alert(sc->verify_result), SSL_R_CERTIFICATE_VERIFY_FAILED); goto err; } } / * Sessions must be immutable once they go into the session cache. Otherwise * we can get multi-thread problems. Therefore we don't "update" sessions, * we replace them with a duplicate. Here, we need to do this every time * a new RPK (or certificate) is received via post-handshake authentication, * as the session may have already gone into the session cache. / if (sc->post_handshake_auth == SSL_PHA_REQUESTED) { if ((new_sess = ssl_session_dup(sc->session, 0)) == NULL) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE); goto err; } SSL_SESSION_free(sc->session); sc->session = new_sess; } / Ensure there is no peer/peer_chain / X509_free(sc->session->peer); sc->session->peer = NULL; sk_X509_pop_free(sc->session->peer_chain, X509_free); sc->session->peer_chain = NULL; / Save RPK / EVP_PKEY_free(sc->session->peer_rpk); sc->session->peer_rpk = peer_rpk; peer_rpk = NULL; sc->session->verify_result = sc->verify_result; / * Freeze the handshake buffer. For <TLS1.3 we do this after the CKE * message / if (SSL_CONNECTION_IS_TLS13(sc)) { if (!ssl3_digest_cached_records(sc, 1)) { / SSLfatal() already called / goto err; } / Save the current hash state for when we receive the CertificateVerify / if (!ssl_handshake_hash(sc, sc->cert_verify_hash, sizeof(sc->cert_verify_hash), &sc->cert_verify_hash_len)) { / SSLfatal() already called /; goto err; } / resend session tickets / sc->sent_tickets = 0; } ret = MSG_PROCESS_CONTINUE_READING; err: EVP_PKEY_free(peer_rpk); return ret; } MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION s, PACKET pkt) { int i; MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; X509 x = NULL; unsigned long l; const unsigned char certstart, certbytes; STACK_OF(X509) sk = NULL; PACKET spkt, context; size_t chainidx; SSL_SESSION new_sess = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); / * To get this far we must have read encrypted data from the client. We no * longer tolerate unencrypted alerts. This is ignored if less than TLSv1.3 / if (s->rlayer.rrlmethod->set_plain_alerts != NULL) s->rlayer.rrlmethod->set_plain_alerts(s->rlayer.rrl, 0); if (s->ext.client_cert_type == TLSEXT_cert_type_rpk) return tls_process_client_rpk(s, pkt); if (s->ext.client_cert_type != TLSEXT_cert_type_x509) { SSLfatal(s, SSL_AD_UNSUPPORTED_CERTIFICATE, SSL_R_UNKNOWN_CERTIFICATE_TYPE); goto err; } if ((sk = sk_X509_new_null()) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (SSL_CONNECTION_IS_TLS13(s) && (!PACKET_get_length_prefixed_1(pkt, &context) \|\| (s->pha_context == NULL && PACKET_remaining(&context) != 0) \|\| (s->pha_context != NULL && !PACKET_equal(&context, s->pha_context, s->pha_context_len)))) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } if (!PACKET_get_length_prefixed_3(pkt, &spkt) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } for (chainidx = 0; PACKET_remaining(&spkt) > 0; chainidx++) { if (!PACKET_get_net_3(&spkt, &l) \|\| !PACKET_get_bytes(&spkt, &certbytes, l)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH); goto err; } certstart = certbytes; x = X509_new_ex(sctx->libctx, sctx->propq); if (x == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_X509_LIB); goto err; } if (d2i_X509(&x, (const unsigned char )&certbytes, l) == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_ASN1_LIB); goto err; } if (certbytes != (certstart + l)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH); goto err; } if (SSL_CONNECTION_IS_TLS13(s)) { RAW_EXTENSION rawexts = NULL; PACKET extensions; if (!PACKET_get_length_prefixed_2(&spkt, &extensions)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); goto err; } if (!tls_collect_extensions(s, &extensions, SSL_EXT_TLS1_3_CERTIFICATE, &rawexts, NULL, chainidx == 0) \|\| !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE, rawexts, x, chainidx, PACKET_remaining(&spkt) == 0)) { OPENSSL_free(rawexts); goto err; } OPENSSL_free(rawexts); } if (!sk_X509_push(sk, x)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } x = NULL; } if (sk_X509_num(sk) <= 0) { /* TLS does not mind 0 certs returned / if (s->version == SSL3_VERSION) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_CERTIFICATES_RETURNED); goto err; } / Fail for TLS only if we required a certificate / else if ((s->verify_mode & SSL_VERIFY_PEER) && (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) { SSLfatal(s, SSL_AD_CERTIFICATE_REQUIRED, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE); goto err; } / No client certificate so digest cached records / if (s->s3.handshake_buffer && !ssl3_digest_cached_records(s, 0)) { / SSLfatal() already called / goto err; } } else { EVP_PKEY pkey; i = ssl_verify_cert_chain(s, sk); if (i <= 0) { SSLfatal(s, ssl_x509err2alert(s->verify_result), SSL_R_CERTIFICATE_VERIFY_FAILED); goto err; } pkey = X509_get0_pubkey(sk_X509_value(sk, 0)); if (pkey == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNKNOWN_CERTIFICATE_TYPE); goto err; } } /* * Sessions must be immutable once they go into the session cache. Otherwise * we can get multi-thread problems. Therefore we don't "update" sessions, * we replace them with a duplicate. Here, we need to do this every time * a new certificate is received via post-handshake authentication, as the * session may have already gone into the session cache. / if (s->post_handshake_auth == SSL_PHA_REQUESTED) { if ((new_sess = ssl_session_dup(s->session, 0)) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); goto err; } SSL_SESSION_free(s->session); s->session = new_sess; } X509_free(s->session->peer); s->session->peer = sk_X509_shift(sk); s->session->verify_result = s->verify_result; OSSL_STACK_OF_X509_free(s->session->peer_chain); s->session->peer_chain = sk; sk = NULL; / Ensure there is no RPK / EVP_PKEY_free(s->session->peer_rpk); s->session->peer_rpk = NULL; / * Freeze the handshake buffer. For <TLS1.3 we do this after the CKE * message / if (SSL_CONNECTION_IS_TLS13(s) && !ssl3_digest_cached_records(s, 1)) { / SSLfatal() already called / goto err; } / * Inconsistency alert: cert_chain does not include the peer's own * certificate, while we do include it in statem_clnt.c / / Save the current hash state for when we receive the CertificateVerify / if (SSL_CONNECTION_IS_TLS13(s)) { if (!ssl_handshake_hash(s, s->cert_verify_hash, sizeof(s->cert_verify_hash), &s->cert_verify_hash_len)) { / SSLfatal() already called / goto err; } / Resend session tickets / s->sent_tickets = 0; } ret = MSG_PROCESS_CONTINUE_READING; err: X509_free(x); OSSL_STACK_OF_X509_free(sk); return ret; } #ifndef OPENSSL_NO_COMP_ALG MSG_PROCESS_RETURN tls_process_client_compressed_certificate(SSL_CONNECTION sc, PACKET pkt) { MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; PACKET tmppkt; BUF_MEM buf = BUF_MEM_new(); if (tls13_process_compressed_certificate(sc, pkt, &tmppkt, buf) != MSG_PROCESS_ERROR) ret = tls_process_client_certificate(sc, &tmppkt); BUF_MEM_free(buf); return ret; } #endif CON_FUNC_RETURN tls_construct_server_certificate(SSL_CONNECTION s, WPACKET pkt) { CERT_PKEY cpk = s->s3.tmp.cert; if (cpk == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / * In TLSv1.3 the certificate chain is always preceded by a 0 length context * for the server Certificate message / if (SSL_CONNECTION_IS_TLS13(s) && !WPACKET_put_bytes_u8(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } switch (s->ext.server_cert_type) { case TLSEXT_cert_type_rpk: if (!tls_output_rpk(s, pkt, cpk)) { / SSLfatal() already called / return 0; } break; case TLSEXT_cert_type_x509: if (!ssl3_output_cert_chain(s, pkt, cpk, 0)) { / SSLfatal() already called / return 0; } break; default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return CON_FUNC_SUCCESS; } #ifndef OPENSSL_NO_COMP_ALG CON_FUNC_RETURN tls_construct_server_compressed_certificate(SSL_CONNECTION sc, WPACKET pkt) { int alg = get_compressed_certificate_alg(sc); OSSL_COMP_CERT cc = sc->s3.tmp.cert->comp_cert[alg]; if (!ossl_assert(cc != NULL)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * Server can't compress on-demand * Use pre-compressed certificate / if (!WPACKET_put_bytes_u16(pkt, alg) \|\| !WPACKET_put_bytes_u24(pkt, cc->orig_len) \|\| !WPACKET_start_sub_packet_u24(pkt) \|\| !WPACKET_memcpy(pkt, cc->data, cc->len) \|\| !WPACKET_close(pkt)) return 0; sc->s3.tmp.cert->cert_comp_used++; return 1; } #endif static int create_ticket_prequel(SSL_CONNECTION s, WPACKET pkt, uint32_t age_add, unsigned char tick_nonce) { uint32_t timeout = (uint32_t)ossl_time2seconds(s->session->timeout); /* * Ticket lifetime hint: * In TLSv1.3 we reset the "time" field above, and always specify the * timeout, limited to a 1 week period per RFC8446. * For TLSv1.2 this is advisory only and we leave this unspecified for * resumed session (for simplicity). / #define ONE_WEEK_SEC (7 24 * 60 * 60) if (SSL_CONNECTION_IS_TLS13(s)) { if (ossl_time_compare(s->session->timeout, ossl_seconds2time(ONE_WEEK_SEC)) > 0) timeout = ONE_WEEK_SEC; } else if (s->hit) timeout = 0; if (!WPACKET_put_bytes_u32(pkt, timeout)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (SSL_CONNECTION_IS_TLS13(s)) { if (!WPACKET_put_bytes_u32(pkt, age_add) \|\| !WPACKET_sub_memcpy_u8(pkt, tick_nonce, TICKET_NONCE_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } /* Start the sub-packet for the actual ticket data / if (!WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION s, WPACKET pkt, uint32_t age_add, unsigned char tick_nonce) { unsigned char senc = NULL; EVP_CIPHER_CTX ctx = NULL; SSL_HMAC hctx = NULL; unsigned char p, encdata1, encdata2, macdata1, macdata2; const unsigned char const_p; int len, slen_full, slen, lenfinal; SSL_SESSION sess; size_t hlen; SSL_CTX tctx = s->session_ctx; unsigned char iv[EVP_MAX_IV_LENGTH]; unsigned char key_name[TLSEXT_KEYNAME_LENGTH]; int iv_len; CON_FUNC_RETURN ok = CON_FUNC_ERROR; size_t macoffset, macendoffset; SSL ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); / get session encoding length / slen_full = i2d_SSL_SESSION(s->session, NULL); / * Some length values are 16 bits, so forget it if session is too * long / if (slen_full == 0 \|\| slen_full > 0xFF00) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } senc = OPENSSL_malloc(slen_full); if (senc == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } hctx = ssl_hmac_new(tctx); if (hctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); goto err; } p = senc; if (!i2d_SSL_SESSION(s->session, &p)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / * create a fresh copy (not shared with other threads) to clean up / const_p = senc; sess = d2i_SSL_SESSION_ex(NULL, &const_p, slen_full, sctx->libctx, sctx->propq); if (sess == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } slen = i2d_SSL_SESSION(sess, NULL); if (slen == 0 \|\| slen > slen_full) { / shouldn't ever happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); SSL_SESSION_free(sess); goto err; } p = senc; if (!i2d_SSL_SESSION(sess, &p)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); SSL_SESSION_free(sess); goto err; } SSL_SESSION_free(sess); / * Initialize HMAC and cipher contexts. If callback present it does * all the work otherwise use generated values from parent ctx. / #ifndef OPENSSL_NO_DEPRECATED_3_0 if (tctx->ext.ticket_key_evp_cb != NULL \|\| tctx->ext.ticket_key_cb != NULL) #else if (tctx->ext.ticket_key_evp_cb != NULL) #endif { int ret = 0; if (tctx->ext.ticket_key_evp_cb != NULL) ret = tctx->ext.ticket_key_evp_cb(ssl, key_name, iv, ctx, ssl_hmac_get0_EVP_MAC_CTX(hctx), 1); #ifndef OPENSSL_NO_DEPRECATED_3_0 else if (tctx->ext.ticket_key_cb != NULL) / if 0 is returned, write an empty ticket / ret = tctx->ext.ticket_key_cb(ssl, key_name, iv, ctx, ssl_hmac_get0_HMAC_CTX(hctx), 1); #endif if (ret == 0) { / * In TLSv1.2 we construct a 0 length ticket. In TLSv1.3 a 0 * length ticket is not allowed so we abort construction of the * ticket / if (SSL_CONNECTION_IS_TLS13(s)) { ok = CON_FUNC_DONT_SEND; goto err; } / Put timeout and length / if (!WPACKET_put_bytes_u32(pkt, 0) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } OPENSSL_free(senc); EVP_CIPHER_CTX_free(ctx); ssl_hmac_free(hctx); return CON_FUNC_SUCCESS; } if (ret < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED); goto err; } iv_len = EVP_CIPHER_CTX_get_iv_length(ctx); if (iv_len < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } else { EVP_CIPHER cipher = EVP_CIPHER_fetch(sctx->libctx, "AES-256-CBC", sctx->propq); if (cipher == NULL) { /* Error is already recorded / SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); goto err; } iv_len = EVP_CIPHER_get_iv_length(cipher); if (iv_len < 0 \|\| RAND_bytes_ex(sctx->libctx, iv, iv_len, 0) <= 0 \|\| !EVP_EncryptInit_ex(ctx, cipher, NULL, tctx->ext.secure->tick_aes_key, iv) \|\| !ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key, sizeof(tctx->ext.secure->tick_hmac_key), "SHA256")) { EVP_CIPHER_free(cipher); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } EVP_CIPHER_free(cipher); memcpy(key_name, tctx->ext.tick_key_name, sizeof(tctx->ext.tick_key_name)); } if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) { / SSLfatal() already called / goto err; } if (!WPACKET_get_total_written(pkt, &macoffset) / Output key name / \|\| !WPACKET_memcpy(pkt, key_name, sizeof(key_name)) / output IV / \|\| !WPACKET_memcpy(pkt, iv, iv_len) \|\| !WPACKET_reserve_bytes(pkt, slen + EVP_MAX_BLOCK_LENGTH, &encdata1) / Encrypt session data / \|\| !EVP_EncryptUpdate(ctx, encdata1, &len, senc, slen) \|\| !WPACKET_allocate_bytes(pkt, len, &encdata2) \|\| encdata1 != encdata2 \|\| !EVP_EncryptFinal(ctx, encdata1 + len, &lenfinal) \|\| !WPACKET_allocate_bytes(pkt, lenfinal, &encdata2) \|\| encdata1 + len != encdata2 \|\| len + lenfinal > slen + EVP_MAX_BLOCK_LENGTH \|\| !WPACKET_get_total_written(pkt, &macendoffset) \|\| !ssl_hmac_update(hctx, (unsigned char )s->init_buf->data + macoffset, macendoffset - macoffset) \|\| !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &macdata1) \|\| !ssl_hmac_final(hctx, macdata1, &hlen, EVP_MAX_MD_SIZE) \|\| hlen > EVP_MAX_MD_SIZE \|\| !WPACKET_allocate_bytes(pkt, hlen, &macdata2) \|\| macdata1 != macdata2) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Close the sub-packet created by create_ticket_prequel() / if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ok = CON_FUNC_SUCCESS; err: OPENSSL_free(senc); EVP_CIPHER_CTX_free(ctx); ssl_hmac_free(hctx); return ok; } static int construct_stateful_ticket(SSL_CONNECTION s, WPACKET pkt, uint32_t age_add, unsigned char tick_nonce) { if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) { /* SSLfatal() already called / return 0; } if (!WPACKET_memcpy(pkt, s->session->session_id, s->session->session_id_length) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } static void tls_update_ticket_counts(SSL_CONNECTION s) { /* * Increment both \|sent_tickets\| and \|next_ticket_nonce\|. \|sent_tickets\| * gets reset to 0 if we send more tickets following a post-handshake * auth, but \|next_ticket_nonce\| does not. If we're sending extra * tickets, decrement the count of pending extra tickets. / s->sent_tickets++; s->next_ticket_nonce++; if (s->ext.extra_tickets_expected > 0) s->ext.extra_tickets_expected--; } CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION s, WPACKET pkt) { SSL_CTX tctx = s->session_ctx; unsigned char tick_nonce[TICKET_NONCE_SIZE]; union { unsigned char age_add_c[sizeof(uint32_t)]; uint32_t age_add; } age_add_u; CON_FUNC_RETURN ret = CON_FUNC_ERROR; age_add_u.age_add = 0; if (SSL_CONNECTION_IS_TLS13(s)) { size_t i, hashlen; uint64_t nonce; static const unsigned char nonce_label[] = "resumption"; const EVP_MD md = ssl_handshake_md(s); int hashleni = EVP_MD_get_size(md); / Ensure cast to size_t is safe / if (!ossl_assert(hashleni >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hashlen = (size_t)hashleni; / * If we already sent one NewSessionTicket, or we resumed then * s->session may already be in a cache and so we must not modify it. * Instead we need to take a copy of it and modify that. / if (s->sent_tickets != 0 \|\| s->hit) { SSL_SESSION new_sess = ssl_session_dup(s->session, 0); if (new_sess == NULL) { /* SSLfatal already called / goto err; } SSL_SESSION_free(s->session); s->session = new_sess; } if (!ssl_generate_session_id(s, s->session)) { / SSLfatal() already called / goto err; } if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, age_add_u.age_add_c, sizeof(age_add_u), 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } s->session->ext.tick_age_add = age_add_u.age_add; nonce = s->next_ticket_nonce; for (i = TICKET_NONCE_SIZE; i > 0; i--) { tick_nonce[i - 1] = (unsigned char)(nonce & 0xff); nonce >>= 8; } if (!tls13_hkdf_expand(s, md, s->resumption_master_secret, nonce_label, sizeof(nonce_label) - 1, tick_nonce, TICKET_NONCE_SIZE, s->session->master_key, hashlen, 1)) { / SSLfatal() already called / goto err; } s->session->master_key_length = hashlen; s->session->time = ossl_time_now(); ssl_session_calculate_timeout(s->session); if (s->s3.alpn_selected != NULL) { OPENSSL_free(s->session->ext.alpn_selected); s->session->ext.alpn_selected = OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len); if (s->session->ext.alpn_selected == NULL) { s->session->ext.alpn_selected_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } s->session->ext.alpn_selected_len = s->s3.alpn_selected_len; } s->session->ext.max_early_data = s->max_early_data; } if (tctx->generate_ticket_cb != NULL && tctx->generate_ticket_cb(SSL_CONNECTION_GET_SSL(s), tctx->ticket_cb_data) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / * If we are using anti-replay protection then we behave as if * SSL_OP_NO_TICKET is set - we are caching tickets anyway so there * is no point in using full stateless tickets. / if (SSL_CONNECTION_IS_TLS13(s) && ((s->options & SSL_OP_NO_TICKET) != 0 \|\| (s->max_early_data > 0 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0))) { if (!construct_stateful_ticket(s, pkt, age_add_u.age_add, tick_nonce)) { / SSLfatal() already called / goto err; } } else { CON_FUNC_RETURN tmpret; tmpret = construct_stateless_ticket(s, pkt, age_add_u.age_add, tick_nonce); if (tmpret != CON_FUNC_SUCCESS) { if (tmpret == CON_FUNC_DONT_SEND) { / Non-fatal. Abort construction but continue / ret = CON_FUNC_DONT_SEND; / We count this as a success so update the counts anwyay / tls_update_ticket_counts(s); } / else SSLfatal() already called / goto err; } } if (SSL_CONNECTION_IS_TLS13(s)) { if (!tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_NEW_SESSION_TICKET, NULL, 0)) { / SSLfatal() already called / goto err; } tls_update_ticket_counts(s); ssl_update_cache(s, SSL_SESS_CACHE_SERVER); } ret = CON_FUNC_SUCCESS; err: return ret; } / * In TLSv1.3 this is called from the extensions code, otherwise it is used to * create a separate message. Returns 1 on success or 0 on failure. / int tls_construct_cert_status_body(SSL_CONNECTION s, WPACKET pkt) { if (!WPACKET_put_bytes_u8(pkt, s->ext.status_type) \|\| !WPACKET_sub_memcpy_u24(pkt, s->ext.ocsp.resp, s->ext.ocsp.resp_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } CON_FUNC_RETURN tls_construct_cert_status(SSL_CONNECTION s, WPACKET pkt) { if (!tls_construct_cert_status_body(s, pkt)) { / SSLfatal() already called / return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } #ifndef OPENSSL_NO_NEXTPROTONEG / * tls_process_next_proto reads a Next Protocol Negotiation handshake message. * It sets the next_proto member in s if found / MSG_PROCESS_RETURN tls_process_next_proto(SSL_CONNECTION s, PACKET pkt) { PACKET next_proto, padding; size_t next_proto_len; /- * The payload looks like: * uint8 proto_len; * uint8 proto[proto_len]; * uint8 padding_len; * uint8 padding[padding_len]; / if (!PACKET_get_length_prefixed_1(pkt, &next_proto) \|\| !PACKET_get_length_prefixed_1(pkt, &padding) \|\| PACKET_remaining(pkt) > 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if (!PACKET_memdup(&next_proto, &s->ext.npn, &next_proto_len)) { s->ext.npn_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } s->ext.npn_len = (unsigned char)next_proto_len; return MSG_PROCESS_CONTINUE_READING; } #endif static CON_FUNC_RETURN tls_construct_encrypted_extensions(SSL_CONNECTION s, WPACKET pkt) { if (!tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, NULL, 0)) { / SSLfatal() already called / return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION s, PACKET pkt) { if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if (s->early_data_state != SSL_EARLY_DATA_READING && s->early_data_state != SSL_EARLY_DATA_READ_RETRY) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } / * EndOfEarlyData signals a key change so the end of the message must be on * a record boundary. / if (RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); return MSG_PROCESS_ERROR; } s->early_data_state = SSL_EARLY_DATA_FINISHED_READING; if (!SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE \| SSL3_CHANGE_CIPHER_SERVER_READ)) { / SSLfatal() already called */ return MSG_PROCESS_ERROR; } return MSG_PROCESS_CONTINUE_READING; }
./openssl/ssl/statem/statem_clnt.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <time.h> #include <assert.h> #include "../ssl_local.h" #include "statem_local.h" #include <openssl/buffer.h> #include <openssl/rand.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/md5.h> #include <openssl/dh.h> #include <openssl/rsa.h> #include <openssl/bn.h> #include <openssl/engine.h> #include <openssl/trace.h> #include <openssl/core_names.h> #include <openssl/param_build.h> #include "internal/cryptlib.h" static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION s, PACKET pkt); static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION s, PACKET pkt); static ossl_inline int cert_req_allowed(SSL_CONNECTION s); static int key_exchange_expected(SSL_CONNECTION s); static int ssl_cipher_list_to_bytes(SSL_CONNECTION s, STACK_OF(SSL_CIPHER) sk, WPACKET pkt); static ossl_inline int received_server_cert(SSL_CONNECTION sc) { return sc->session->peer_rpk != NULL \|\| sc->session->peer != NULL; } / * Is a CertificateRequest message allowed at the moment or not? * * Return values are: * 1: Yes * 0: No / static ossl_inline int cert_req_allowed(SSL_CONNECTION s) { /* TLS does not like anon-DH with client cert / if ((s->version > SSL3_VERSION && (s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL)) \|\| (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aSRP \| SSL_aPSK))) return 0; return 1; } / * Should we expect the ServerKeyExchange message or not? * * Return values are: * 1: Yes * 0: No / static int key_exchange_expected(SSL_CONNECTION s) { long alg_k = s->s3.tmp.new_cipher->algorithm_mkey; /* * Can't skip server key exchange if this is an ephemeral * ciphersuite or for SRP / if (alg_k & (SSL_kDHE \| SSL_kECDHE \| SSL_kDHEPSK \| SSL_kECDHEPSK \| SSL_kSRP)) { return 1; } return 0; } / * ossl_statem_client_read_transition() encapsulates the logic for the allowed * handshake state transitions when a TLS1.3 client is reading messages from the * server. The message type that the server has sent is provided in \|mt\|. The * current state is in \|s->statem.hand_state\|. * * Return values are 1 for success (transition allowed) and 0 on error * (transition not allowed) / static int ossl_statem_client13_read_transition(SSL_CONNECTION s, int mt) { OSSL_STATEM st = &s->statem; / * Note: There is no case for TLS_ST_CW_CLNT_HELLO, because we haven't * yet negotiated TLSv1.3 at that point so that is handled by * ossl_statem_client_read_transition() / switch (st->hand_state) { default: break; case TLS_ST_CW_CLNT_HELLO: / * This must a ClientHello following a HelloRetryRequest, so the only * thing we can get now is a ServerHello. / if (mt == SSL3_MT_SERVER_HELLO) { st->hand_state = TLS_ST_CR_SRVR_HELLO; return 1; } break; case TLS_ST_CR_SRVR_HELLO: if (mt == SSL3_MT_ENCRYPTED_EXTENSIONS) { st->hand_state = TLS_ST_CR_ENCRYPTED_EXTENSIONS; return 1; } break; case TLS_ST_CR_ENCRYPTED_EXTENSIONS: if (s->hit) { if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_CR_FINISHED; return 1; } } else { if (mt == SSL3_MT_CERTIFICATE_REQUEST) { st->hand_state = TLS_ST_CR_CERT_REQ; return 1; } if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_CR_CERT; return 1; } #ifndef OPENSSL_NO_COMP_ALG if (mt == SSL3_MT_COMPRESSED_CERTIFICATE && s->ext.compress_certificate_sent) { st->hand_state = TLS_ST_CR_COMP_CERT; return 1; } #endif } break; case TLS_ST_CR_CERT_REQ: if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_CR_CERT; return 1; } #ifndef OPENSSL_NO_COMP_ALG if (mt == SSL3_MT_COMPRESSED_CERTIFICATE && s->ext.compress_certificate_sent) { st->hand_state = TLS_ST_CR_COMP_CERT; return 1; } #endif break; case TLS_ST_CR_CERT: case TLS_ST_CR_COMP_CERT: if (mt == SSL3_MT_CERTIFICATE_VERIFY) { st->hand_state = TLS_ST_CR_CERT_VRFY; return 1; } break; case TLS_ST_CR_CERT_VRFY: if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_CR_FINISHED; return 1; } break; case TLS_ST_OK: if (mt == SSL3_MT_NEWSESSION_TICKET) { st->hand_state = TLS_ST_CR_SESSION_TICKET; return 1; } if (mt == SSL3_MT_KEY_UPDATE && !SSL_IS_QUIC_HANDSHAKE(s)) { st->hand_state = TLS_ST_CR_KEY_UPDATE; return 1; } if (mt == SSL3_MT_CERTIFICATE_REQUEST) { #if DTLS_MAX_VERSION_INTERNAL != DTLS1_2_VERSION / Restore digest for PHA before adding message./ # error Internal DTLS version error #endif if (!SSL_CONNECTION_IS_DTLS(s) && s->post_handshake_auth == SSL_PHA_EXT_SENT) { s->post_handshake_auth = SSL_PHA_REQUESTED; / * In TLS, this is called before the message is added to the * digest. In DTLS, this is expected to be called after adding * to the digest. Either move the digest restore, or add the * message here after the swap, or do it after the clientFinished? / if (!tls13_restore_handshake_digest_for_pha(s)) { / SSLfatal() already called / return 0; } st->hand_state = TLS_ST_CR_CERT_REQ; return 1; } } break; } / No valid transition found / return 0; } / * ossl_statem_client_read_transition() encapsulates the logic for the allowed * handshake state transitions when the client is reading messages from the * server. The message type that the server has sent is provided in \|mt\|. The * current state is in \|s->statem.hand_state\|. * * Return values are 1 for success (transition allowed) and 0 on error * (transition not allowed) / int ossl_statem_client_read_transition(SSL_CONNECTION s, int mt) { OSSL_STATEM st = &s->statem; int ske_expected; / * Note that after writing the first ClientHello we don't know what version * we are going to negotiate yet, so we don't take this branch until later. / if (SSL_CONNECTION_IS_TLS13(s)) { if (!ossl_statem_client13_read_transition(s, mt)) goto err; return 1; } switch (st->hand_state) { default: break; case TLS_ST_CW_CLNT_HELLO: if (mt == SSL3_MT_SERVER_HELLO) { st->hand_state = TLS_ST_CR_SRVR_HELLO; return 1; } if (SSL_CONNECTION_IS_DTLS(s)) { if (mt == DTLS1_MT_HELLO_VERIFY_REQUEST) { st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST; return 1; } } break; case TLS_ST_EARLY_DATA: / * We've not actually selected TLSv1.3 yet, but we have sent early * data. The only thing allowed now is a ServerHello or a * HelloRetryRequest. / if (mt == SSL3_MT_SERVER_HELLO) { st->hand_state = TLS_ST_CR_SRVR_HELLO; return 1; } break; case TLS_ST_CR_SRVR_HELLO: if (s->hit) { if (s->ext.ticket_expected) { if (mt == SSL3_MT_NEWSESSION_TICKET) { st->hand_state = TLS_ST_CR_SESSION_TICKET; return 1; } } else if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_CR_CHANGE; return 1; } } else { if (SSL_CONNECTION_IS_DTLS(s) && mt == DTLS1_MT_HELLO_VERIFY_REQUEST) { st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST; return 1; } else if (s->version >= TLS1_VERSION && s->ext.session_secret_cb != NULL && s->session->ext.tick != NULL && mt == SSL3_MT_CHANGE_CIPHER_SPEC) { / * Normally, we can tell if the server is resuming the session * from the session ID. EAP-FAST (RFC 4851), however, relies on * the next server message after the ServerHello to determine if * the server is resuming. / s->hit = 1; st->hand_state = TLS_ST_CR_CHANGE; return 1; } else if (!(s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL \| SSL_aSRP \| SSL_aPSK))) { if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_CR_CERT; return 1; } } else { ske_expected = key_exchange_expected(s); / SKE is optional for some PSK ciphersuites / if (ske_expected \|\| ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK) && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) { if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) { st->hand_state = TLS_ST_CR_KEY_EXCH; return 1; } } else if (mt == SSL3_MT_CERTIFICATE_REQUEST && cert_req_allowed(s)) { st->hand_state = TLS_ST_CR_CERT_REQ; return 1; } else if (mt == SSL3_MT_SERVER_DONE) { st->hand_state = TLS_ST_CR_SRVR_DONE; return 1; } } } break; case TLS_ST_CR_CERT: case TLS_ST_CR_COMP_CERT: / * The CertificateStatus message is optional even if * \|ext.status_expected\| is set / if (s->ext.status_expected && mt == SSL3_MT_CERTIFICATE_STATUS) { st->hand_state = TLS_ST_CR_CERT_STATUS; return 1; } / Fall through / case TLS_ST_CR_CERT_STATUS: ske_expected = key_exchange_expected(s); / SKE is optional for some PSK ciphersuites / if (ske_expected \|\| ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK) && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) { if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) { st->hand_state = TLS_ST_CR_KEY_EXCH; return 1; } goto err; } / Fall through / case TLS_ST_CR_KEY_EXCH: if (mt == SSL3_MT_CERTIFICATE_REQUEST) { if (cert_req_allowed(s)) { st->hand_state = TLS_ST_CR_CERT_REQ; return 1; } goto err; } / Fall through / case TLS_ST_CR_CERT_REQ: if (mt == SSL3_MT_SERVER_DONE) { st->hand_state = TLS_ST_CR_SRVR_DONE; return 1; } break; case TLS_ST_CW_FINISHED: if (s->ext.ticket_expected) { if (mt == SSL3_MT_NEWSESSION_TICKET) { st->hand_state = TLS_ST_CR_SESSION_TICKET; return 1; } } else if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_CR_CHANGE; return 1; } break; case TLS_ST_CR_SESSION_TICKET: if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_CR_CHANGE; return 1; } break; case TLS_ST_CR_CHANGE: if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_CR_FINISHED; return 1; } break; case TLS_ST_OK: if (mt == SSL3_MT_HELLO_REQUEST) { st->hand_state = TLS_ST_CR_HELLO_REQ; return 1; } break; } err: / No valid transition found / if (SSL_CONNECTION_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) { BIO rbio; /* * CCS messages don't have a message sequence number so this is probably * because of an out-of-order CCS. We'll just drop it. / s->init_num = 0; s->rwstate = SSL_READING; rbio = SSL_get_rbio(SSL_CONNECTION_GET_SSL(s)); BIO_clear_retry_flags(rbio); BIO_set_retry_read(rbio); return 0; } SSLfatal(s, SSL3_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); return 0; } static int do_compressed_cert(SSL_CONNECTION sc) { /* If we negotiated RPK, we won't try to compress it / return sc->ext.client_cert_type == TLSEXT_cert_type_x509 && sc->ext.compress_certificate_from_peer[0] != TLSEXT_comp_cert_none; } / * ossl_statem_client13_write_transition() works out what handshake state to * move to next when the TLSv1.3 client is writing messages to be sent to the * server. / static WRITE_TRAN ossl_statem_client13_write_transition(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; / * Note: There are no cases for TLS_ST_BEFORE because we haven't negotiated * TLSv1.3 yet at that point. They are handled by * ossl_statem_client_write_transition(). / switch (st->hand_state) { default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; case TLS_ST_CR_CERT_REQ: if (s->post_handshake_auth == SSL_PHA_REQUESTED) { if (do_compressed_cert(s)) st->hand_state = TLS_ST_CW_COMP_CERT; else st->hand_state = TLS_ST_CW_CERT; return WRITE_TRAN_CONTINUE; } / * We should only get here if we received a CertificateRequest after * we already sent close_notify / if (!ossl_assert((s->shutdown & SSL_SENT_SHUTDOWN) != 0)) { / Shouldn't happen - same as default case / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; } st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_CR_FINISHED: if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY \|\| s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING) st->hand_state = TLS_ST_PENDING_EARLY_DATA_END; else if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0 && s->hello_retry_request == SSL_HRR_NONE) st->hand_state = TLS_ST_CW_CHANGE; else if (s->s3.tmp.cert_req == 0) st->hand_state = TLS_ST_CW_FINISHED; else if (do_compressed_cert(s)) st->hand_state = TLS_ST_CW_COMP_CERT; else st->hand_state = TLS_ST_CW_CERT; s->ts_msg_read = ossl_time_now(); return WRITE_TRAN_CONTINUE; case TLS_ST_PENDING_EARLY_DATA_END: if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) { st->hand_state = TLS_ST_CW_END_OF_EARLY_DATA; return WRITE_TRAN_CONTINUE; } / Fall through / case TLS_ST_CW_END_OF_EARLY_DATA: case TLS_ST_CW_CHANGE: if (s->s3.tmp.cert_req == 0) st->hand_state = TLS_ST_CW_FINISHED; else if (do_compressed_cert(s)) st->hand_state = TLS_ST_CW_COMP_CERT; else st->hand_state = TLS_ST_CW_CERT; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_COMP_CERT: case TLS_ST_CW_CERT: / If a non-empty Certificate we also send CertificateVerify / st->hand_state = (s->s3.tmp.cert_req == 1) ? TLS_ST_CW_CERT_VRFY : TLS_ST_CW_FINISHED; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CERT_VRFY: st->hand_state = TLS_ST_CW_FINISHED; return WRITE_TRAN_CONTINUE; case TLS_ST_CR_KEY_UPDATE: case TLS_ST_CW_KEY_UPDATE: case TLS_ST_CR_SESSION_TICKET: case TLS_ST_CW_FINISHED: st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_OK: if (s->key_update != SSL_KEY_UPDATE_NONE) { st->hand_state = TLS_ST_CW_KEY_UPDATE; return WRITE_TRAN_CONTINUE; } / Try to read from the server instead / return WRITE_TRAN_FINISHED; } } / * ossl_statem_client_write_transition() works out what handshake state to * move to next when the client is writing messages to be sent to the server. / WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; / * Note that immediately before/after a ClientHello we don't know what * version we are going to negotiate yet, so we don't take this branch until * later / if (SSL_CONNECTION_IS_TLS13(s)) return ossl_statem_client13_write_transition(s); switch (st->hand_state) { default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; case TLS_ST_OK: if (!s->renegotiate) { / * We haven't requested a renegotiation ourselves so we must have * received a message from the server. Better read it. / return WRITE_TRAN_FINISHED; } / Renegotiation / / fall thru / case TLS_ST_BEFORE: st->hand_state = TLS_ST_CW_CLNT_HELLO; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CLNT_HELLO: if (s->early_data_state == SSL_EARLY_DATA_CONNECTING) { / * We are assuming this is a TLSv1.3 connection, although we haven't * actually selected a version yet. / if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) st->hand_state = TLS_ST_CW_CHANGE; else st->hand_state = TLS_ST_EARLY_DATA; return WRITE_TRAN_CONTINUE; } / * No transition at the end of writing because we don't know what * we will be sent / s->ts_msg_write = ossl_time_now(); return WRITE_TRAN_FINISHED; case TLS_ST_CR_SRVR_HELLO: / * We only get here in TLSv1.3. We just received an HRR, so issue a * CCS unless middlebox compat mode is off, or we already issued one * because we did early data. / if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0 && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) st->hand_state = TLS_ST_CW_CHANGE; else st->hand_state = TLS_ST_CW_CLNT_HELLO; return WRITE_TRAN_CONTINUE; case TLS_ST_EARLY_DATA: s->ts_msg_write = ossl_time_now(); return WRITE_TRAN_FINISHED; case DTLS_ST_CR_HELLO_VERIFY_REQUEST: st->hand_state = TLS_ST_CW_CLNT_HELLO; return WRITE_TRAN_CONTINUE; case TLS_ST_CR_SRVR_DONE: s->ts_msg_read = ossl_time_now(); if (s->s3.tmp.cert_req) st->hand_state = TLS_ST_CW_CERT; else st->hand_state = TLS_ST_CW_KEY_EXCH; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CERT: st->hand_state = TLS_ST_CW_KEY_EXCH; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_KEY_EXCH: / * For TLS, cert_req is set to 2, so a cert chain of nothing is * sent, but no verify packet is sent / / * XXX: For now, we do not support client authentication in ECDH * cipher suites with ECDH (rather than ECDSA) certificates. We * need to skip the certificate verify message when client's * ECDH public key is sent inside the client certificate. / if (s->s3.tmp.cert_req == 1) { st->hand_state = TLS_ST_CW_CERT_VRFY; } else { st->hand_state = TLS_ST_CW_CHANGE; } if (s->s3.flags & TLS1_FLAGS_SKIP_CERT_VERIFY) { st->hand_state = TLS_ST_CW_CHANGE; } return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CERT_VRFY: st->hand_state = TLS_ST_CW_CHANGE; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CHANGE: if (s->hello_retry_request == SSL_HRR_PENDING) { st->hand_state = TLS_ST_CW_CLNT_HELLO; } else if (s->early_data_state == SSL_EARLY_DATA_CONNECTING) { st->hand_state = TLS_ST_EARLY_DATA; } else { #if defined(OPENSSL_NO_NEXTPROTONEG) st->hand_state = TLS_ST_CW_FINISHED; #else if (!SSL_CONNECTION_IS_DTLS(s) && s->s3.npn_seen) st->hand_state = TLS_ST_CW_NEXT_PROTO; else st->hand_state = TLS_ST_CW_FINISHED; #endif } return WRITE_TRAN_CONTINUE; #if !defined(OPENSSL_NO_NEXTPROTONEG) case TLS_ST_CW_NEXT_PROTO: st->hand_state = TLS_ST_CW_FINISHED; return WRITE_TRAN_CONTINUE; #endif case TLS_ST_CW_FINISHED: if (s->hit) { st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } else { return WRITE_TRAN_FINISHED; } case TLS_ST_CR_FINISHED: if (s->hit) { st->hand_state = TLS_ST_CW_CHANGE; return WRITE_TRAN_CONTINUE; } else { st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } case TLS_ST_CR_HELLO_REQ: / * If we can renegotiate now then do so, otherwise wait for a more * convenient time. / if (ssl3_renegotiate_check(SSL_CONNECTION_GET_SSL(s), 1)) { if (!tls_setup_handshake(s)) { / SSLfatal() already called / return WRITE_TRAN_ERROR; } st->hand_state = TLS_ST_CW_CLNT_HELLO; return WRITE_TRAN_CONTINUE; } st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } } / * Perform any pre work that needs to be done prior to sending a message from * the client to the server. / WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION s, WORK_STATE wst) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: / No pre work to be done / break; case TLS_ST_CW_CLNT_HELLO: s->shutdown = 0; if (SSL_CONNECTION_IS_DTLS(s)) { / every DTLS ClientHello resets Finished MAC / if (!ssl3_init_finished_mac(s)) { / SSLfatal() already called / return WORK_ERROR; } } else if (s->ext.early_data == SSL_EARLY_DATA_REJECTED) { / * This must be a second ClientHello after an HRR following an * earlier rejected attempt to send early data. Since we were * previously encrypting the early data we now need to reset the * write record layer in order to write in plaintext again. / if (!ssl_set_new_record_layer(s, TLS_ANY_VERSION, OSSL_RECORD_DIRECTION_WRITE, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL)) { / SSLfatal already called / return WORK_ERROR; } } break; case TLS_ST_CW_CHANGE: if (SSL_CONNECTION_IS_DTLS(s)) { if (s->hit) { / * We're into the last flight so we don't retransmit these * messages unless we need to. / st->use_timer = 0; } #ifndef OPENSSL_NO_SCTP if (BIO_dgram_is_sctp(SSL_get_wbio(SSL_CONNECTION_GET_SSL(s)))) { / Calls SSLfatal() as required / return dtls_wait_for_dry(s); } #endif } break; case TLS_ST_PENDING_EARLY_DATA_END: / * If we've been called by SSL_do_handshake()/SSL_write(), or we did not * attempt to write early data before calling SSL_read() then we press * on with the handshake. Otherwise we pause here. / if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING \|\| s->early_data_state == SSL_EARLY_DATA_NONE) return WORK_FINISHED_CONTINUE; / Fall through / case TLS_ST_EARLY_DATA: return tls_finish_handshake(s, wst, 0, 1); case TLS_ST_OK: / Calls SSLfatal() as required / return tls_finish_handshake(s, wst, 1, 1); } return WORK_FINISHED_CONTINUE; } / * Perform any work that needs to be done after sending a message from the * client to the server. / WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION s, WORK_STATE wst) { OSSL_STATEM st = &s->statem; SSL ssl = SSL_CONNECTION_GET_SSL(s); s->init_num = 0; switch (st->hand_state) { default: /* No post work to be done / break; case TLS_ST_CW_CLNT_HELLO: if (s->early_data_state == SSL_EARLY_DATA_CONNECTING && s->max_early_data > 0) { / * We haven't selected TLSv1.3 yet so we don't call the change * cipher state function associated with the SSL_METHOD. Instead * we call tls13_change_cipher_state() directly. / if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0) { if (!tls13_change_cipher_state(s, SSL3_CC_EARLY \| SSL3_CHANGE_CIPHER_CLIENT_WRITE)) { / SSLfatal() already called / return WORK_ERROR; } } / else we're in compat mode so we delay flushing until after CCS / } else if (!statem_flush(s)) { return WORK_MORE_A; } if (SSL_CONNECTION_IS_DTLS(s)) { / Treat the next message as the first packet / s->first_packet = 1; } break; case TLS_ST_CW_KEY_EXCH: if (tls_client_key_exchange_post_work(s) == 0) { / SSLfatal() already called / return WORK_ERROR; } break; case TLS_ST_CW_CHANGE: if (SSL_CONNECTION_IS_TLS13(s) \|\| s->hello_retry_request == SSL_HRR_PENDING) break; if (s->early_data_state == SSL_EARLY_DATA_CONNECTING && s->max_early_data > 0) { / * We haven't selected TLSv1.3 yet so we don't call the change * cipher state function associated with the SSL_METHOD. Instead * we call tls13_change_cipher_state() directly. / if (!tls13_change_cipher_state(s, SSL3_CC_EARLY \| SSL3_CHANGE_CIPHER_CLIENT_WRITE)) return WORK_ERROR; break; } s->session->cipher = s->s3.tmp.new_cipher; #ifdef OPENSSL_NO_COMP s->session->compress_meth = 0; #else if (s->s3.tmp.new_compression == NULL) s->session->compress_meth = 0; else s->session->compress_meth = s->s3.tmp.new_compression->id; #endif if (!ssl->method->ssl3_enc->setup_key_block(s)) { / SSLfatal() already called / return WORK_ERROR; } if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CHANGE_CIPHER_CLIENT_WRITE)) { / SSLfatal() already called / return WORK_ERROR; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && s->hit) { / * Change to new shared key of SCTP-Auth, will be ignored if * no SCTP used. / BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL); } #endif break; case TLS_ST_CW_FINISHED: #ifndef OPENSSL_NO_SCTP if (wst == WORK_MORE_A && SSL_CONNECTION_IS_DTLS(s) && s->hit == 0) { / * Change to new shared key of SCTP-Auth, will be ignored if * no SCTP used. / BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL); } #endif if (statem_flush(s) != 1) return WORK_MORE_B; if (SSL_CONNECTION_IS_TLS13(s)) { if (!tls13_save_handshake_digest_for_pha(s)) { / SSLfatal() already called / return WORK_ERROR; } if (s->post_handshake_auth != SSL_PHA_REQUESTED) { if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION \| SSL3_CHANGE_CIPHER_CLIENT_WRITE)) { / SSLfatal() already called / return WORK_ERROR; } } } break; case TLS_ST_CW_KEY_UPDATE: if (statem_flush(s) != 1) return WORK_MORE_A; if (!tls13_update_key(s, 1)) { / SSLfatal() already called / return WORK_ERROR; } break; } return WORK_FINISHED_CONTINUE; } / * Get the message construction function and message type for sending from the * client * * Valid return values are: * 1: Success * 0: Error / int ossl_statem_client_construct_message(SSL_CONNECTION s, confunc_f confunc, int mt) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_STATE); return 0; case TLS_ST_CW_CHANGE: if (SSL_CONNECTION_IS_DTLS(s)) confunc = dtls_construct_change_cipher_spec; else confunc = tls_construct_change_cipher_spec; mt = SSL3_MT_CHANGE_CIPHER_SPEC; break; case TLS_ST_CW_CLNT_HELLO: confunc = tls_construct_client_hello; mt = SSL3_MT_CLIENT_HELLO; break; case TLS_ST_CW_END_OF_EARLY_DATA: confunc = tls_construct_end_of_early_data; mt = SSL3_MT_END_OF_EARLY_DATA; break; case TLS_ST_PENDING_EARLY_DATA_END: confunc = NULL; mt = SSL3_MT_DUMMY; break; case TLS_ST_CW_CERT: confunc = tls_construct_client_certificate; mt = SSL3_MT_CERTIFICATE; break; #ifndef OPENSSL_NO_COMP_ALG case TLS_ST_CW_COMP_CERT: confunc = tls_construct_client_compressed_certificate; mt = SSL3_MT_COMPRESSED_CERTIFICATE; break; #endif case TLS_ST_CW_KEY_EXCH: confunc = tls_construct_client_key_exchange; mt = SSL3_MT_CLIENT_KEY_EXCHANGE; break; case TLS_ST_CW_CERT_VRFY: confunc = tls_construct_cert_verify; mt = SSL3_MT_CERTIFICATE_VERIFY; break; #if !defined(OPENSSL_NO_NEXTPROTONEG) case TLS_ST_CW_NEXT_PROTO: confunc = tls_construct_next_proto; mt = SSL3_MT_NEXT_PROTO; break; #endif case TLS_ST_CW_FINISHED: confunc = tls_construct_finished; mt = SSL3_MT_FINISHED; break; case TLS_ST_CW_KEY_UPDATE: confunc = tls_construct_key_update; mt = SSL3_MT_KEY_UPDATE; break; } return 1; } /* * Returns the maximum allowed length for the current message that we are * reading. Excludes the message header. / size_t ossl_statem_client_max_message_size(SSL_CONNECTION s) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: / Shouldn't happen / return 0; case TLS_ST_CR_SRVR_HELLO: return SERVER_HELLO_MAX_LENGTH; case DTLS_ST_CR_HELLO_VERIFY_REQUEST: return HELLO_VERIFY_REQUEST_MAX_LENGTH; case TLS_ST_CR_COMP_CERT: case TLS_ST_CR_CERT: return s->max_cert_list; case TLS_ST_CR_CERT_VRFY: return CERTIFICATE_VERIFY_MAX_LENGTH; case TLS_ST_CR_CERT_STATUS: return SSL3_RT_MAX_PLAIN_LENGTH; case TLS_ST_CR_KEY_EXCH: return SERVER_KEY_EXCH_MAX_LENGTH; case TLS_ST_CR_CERT_REQ: / * Set to s->max_cert_list for compatibility with previous releases. In * practice these messages can get quite long if servers are configured * to provide a long list of acceptable CAs / return s->max_cert_list; case TLS_ST_CR_SRVR_DONE: return SERVER_HELLO_DONE_MAX_LENGTH; case TLS_ST_CR_CHANGE: if (s->version == DTLS1_BAD_VER) return 3; return CCS_MAX_LENGTH; case TLS_ST_CR_SESSION_TICKET: return (SSL_CONNECTION_IS_TLS13(s)) ? SESSION_TICKET_MAX_LENGTH_TLS13 : SESSION_TICKET_MAX_LENGTH_TLS12; case TLS_ST_CR_FINISHED: return FINISHED_MAX_LENGTH; case TLS_ST_CR_ENCRYPTED_EXTENSIONS: return ENCRYPTED_EXTENSIONS_MAX_LENGTH; case TLS_ST_CR_KEY_UPDATE: return KEY_UPDATE_MAX_LENGTH; } } / * Process a message that the client has received from the server. / MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION s, PACKET pkt) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; case TLS_ST_CR_SRVR_HELLO: return tls_process_server_hello(s, pkt); case DTLS_ST_CR_HELLO_VERIFY_REQUEST: return dtls_process_hello_verify(s, pkt); case TLS_ST_CR_CERT: return tls_process_server_certificate(s, pkt); #ifndef OPENSSL_NO_COMP_ALG case TLS_ST_CR_COMP_CERT: return tls_process_server_compressed_certificate(s, pkt); #endif case TLS_ST_CR_CERT_VRFY: return tls_process_cert_verify(s, pkt); case TLS_ST_CR_CERT_STATUS: return tls_process_cert_status(s, pkt); case TLS_ST_CR_KEY_EXCH: return tls_process_key_exchange(s, pkt); case TLS_ST_CR_CERT_REQ: return tls_process_certificate_request(s, pkt); case TLS_ST_CR_SRVR_DONE: return tls_process_server_done(s, pkt); case TLS_ST_CR_CHANGE: return tls_process_change_cipher_spec(s, pkt); case TLS_ST_CR_SESSION_TICKET: return tls_process_new_session_ticket(s, pkt); case TLS_ST_CR_FINISHED: return tls_process_finished(s, pkt); case TLS_ST_CR_HELLO_REQ: return tls_process_hello_req(s, pkt); case TLS_ST_CR_ENCRYPTED_EXTENSIONS: return tls_process_encrypted_extensions(s, pkt); case TLS_ST_CR_KEY_UPDATE: return tls_process_key_update(s, pkt); } } / * Perform any further processing required following the receipt of a message * from the server / WORK_STATE ossl_statem_client_post_process_message(SSL_CONNECTION s, WORK_STATE wst) { OSSL_STATEM st = &s->statem; switch (st->hand_state) { default: / Shouldn't happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; case TLS_ST_CR_CERT: case TLS_ST_CR_COMP_CERT: return tls_post_process_server_certificate(s, wst); case TLS_ST_CR_CERT_VRFY: case TLS_ST_CR_CERT_REQ: return tls_prepare_client_certificate(s, wst); } } CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION s, WPACKET pkt) { unsigned char p; size_t sess_id_len; int i, protverr; #ifndef OPENSSL_NO_COMP SSL_COMP comp; #endif SSL_SESSION sess = s->session; unsigned char session_id; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); /* Work out what SSL/TLS/DTLS version to use / protverr = ssl_set_client_hello_version(s); if (protverr != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, protverr); return CON_FUNC_ERROR; } if (sess == NULL \|\| !ssl_version_supported(s, sess->ssl_version, NULL) \|\| !SSL_SESSION_is_resumable(sess)) { if (s->hello_retry_request == SSL_HRR_NONE && !ssl_get_new_session(s, 0)) { / SSLfatal() already called / return CON_FUNC_ERROR; } } / else use the pre-loaded session / p = s->s3.client_random; / * for DTLS if client_random is initialized, reuse it, we are * required to use same upon reply to HelloVerify / if (SSL_CONNECTION_IS_DTLS(s)) { size_t idx; i = 1; for (idx = 0; idx < sizeof(s->s3.client_random); idx++) { if (p[idx]) { i = 0; break; } } } else { i = (s->hello_retry_request == SSL_HRR_NONE); } if (i && ssl_fill_hello_random(s, 0, p, sizeof(s->s3.client_random), DOWNGRADE_NONE) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /- * version indicates the negotiated version: for example from * an SSLv2/v3 compatible client hello). The client_version * field is the maximum version we permit and it is also * used in RSA encrypted premaster secrets. Some servers can * choke if we initially report a higher version then * renegotiate to a lower one in the premaster secret. This * didn't happen with TLS 1.0 as most servers supported it * but it can with TLS 1.1 or later if the server only supports * 1.0. * * Possible scenario with previous logic: * 1. Client hello indicates TLS 1.2 * 2. Server hello says TLS 1.0 * 3. RSA encrypted premaster secret uses 1.2. * 4. Handshake proceeds using TLS 1.0. * 5. Server sends hello request to renegotiate. * 6. Client hello indicates TLS v1.0 as we now * know that is maximum server supports. * 7. Server chokes on RSA encrypted premaster secret * containing version 1.0. * * For interoperability it should be OK to always use the * maximum version we support in client hello and then rely * on the checking of version to ensure the servers isn't * being inconsistent: for example initially negotiating with * TLS 1.0 and renegotiating with TLS 1.2. We do this by using * client_version in client hello and not resetting it to * the negotiated version. * * For TLS 1.3 we always set the ClientHello version to 1.2 and rely on the * supported_versions extension for the real supported versions. / if (!WPACKET_put_bytes_u16(pkt, s->client_version) \|\| !WPACKET_memcpy(pkt, s->s3.client_random, SSL3_RANDOM_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / Session ID / session_id = s->session->session_id; if (s->new_session \|\| s->session->ssl_version == TLS1_3_VERSION) { if (s->version == TLS1_3_VERSION && (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) { sess_id_len = sizeof(s->tmp_session_id); s->tmp_session_id_len = sess_id_len; session_id = s->tmp_session_id; if (s->hello_retry_request == SSL_HRR_NONE && RAND_bytes_ex(sctx->libctx, s->tmp_session_id, sess_id_len, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } else { sess_id_len = 0; } } else { assert(s->session->session_id_length <= sizeof(s->session->session_id)); sess_id_len = s->session->session_id_length; if (s->version == TLS1_3_VERSION) { s->tmp_session_id_len = sess_id_len; memcpy(s->tmp_session_id, s->session->session_id, sess_id_len); } } if (!WPACKET_start_sub_packet_u8(pkt) \|\| (sess_id_len != 0 && !WPACKET_memcpy(pkt, session_id, sess_id_len)) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / cookie stuff for DTLS / if (SSL_CONNECTION_IS_DTLS(s)) { if (s->d1->cookie_len > sizeof(s->d1->cookie) \|\| !WPACKET_sub_memcpy_u8(pkt, s->d1->cookie, s->d1->cookie_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } / Ciphers supported / if (!WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(SSL_CONNECTION_GET_SSL(s)), pkt)) { / SSLfatal() already called / return CON_FUNC_ERROR; } if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / COMPRESSION / if (!WPACKET_start_sub_packet_u8(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } #ifndef OPENSSL_NO_COMP if (ssl_allow_compression(s) && sctx->comp_methods && (SSL_CONNECTION_IS_DTLS(s) \|\| s->s3.tmp.max_ver < TLS1_3_VERSION)) { int compnum = sk_SSL_COMP_num(sctx->comp_methods); for (i = 0; i < compnum; i++) { comp = sk_SSL_COMP_value(sctx->comp_methods, i); if (!WPACKET_put_bytes_u8(pkt, comp->id)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } } #endif / Add the NULL method / if (!WPACKET_put_bytes_u8(pkt, 0) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / TLS extensions / if (!tls_construct_extensions(s, pkt, SSL_EXT_CLIENT_HELLO, NULL, 0)) { / SSLfatal() already called / return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } MSG_PROCESS_RETURN dtls_process_hello_verify(SSL_CONNECTION s, PACKET pkt) { size_t cookie_len; PACKET cookiepkt; if (!PACKET_forward(pkt, 2) \|\| !PACKET_get_length_prefixed_1(pkt, &cookiepkt)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } cookie_len = PACKET_remaining(&cookiepkt); if (cookie_len > sizeof(s->d1->cookie)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_LENGTH_TOO_LONG); return MSG_PROCESS_ERROR; } if (!PACKET_copy_bytes(&cookiepkt, s->d1->cookie, cookie_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } s->d1->cookie_len = cookie_len; return MSG_PROCESS_FINISHED_READING; } static int set_client_ciphersuite(SSL_CONNECTION s, const unsigned char cipherchars) { STACK_OF(SSL_CIPHER) sk; const SSL_CIPHER c; int i; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); c = ssl_get_cipher_by_char(s, cipherchars, 0); if (c == NULL) { /* unknown cipher / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CIPHER_RETURNED); return 0; } / * If it is a disabled cipher we either didn't send it in client hello, * or it's not allowed for the selected protocol. So we return an error. / if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_CHECK, 1)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CIPHER_RETURNED); return 0; } sk = ssl_get_ciphers_by_id(s); i = sk_SSL_CIPHER_find(sk, c); if (i < 0) { / we did not say we would use this cipher / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CIPHER_RETURNED); return 0; } if (SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.new_cipher != NULL && s->s3.tmp.new_cipher->id != c->id) { / ServerHello selected a different ciphersuite to that in the HRR / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CIPHER_RETURNED); return 0; } / * Depending on the session caching (internal/external), the cipher * and/or cipher_id values may not be set. Make sure that cipher_id is * set and use it for comparison. / if (s->session->cipher != NULL) s->session->cipher_id = s->session->cipher->id; if (s->hit && (s->session->cipher_id != c->id)) { if (SSL_CONNECTION_IS_TLS13(s)) { const EVP_MD md = ssl_md(sctx, c->algorithm2); if (!ossl_assert(s->session->cipher != NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * In TLSv1.3 it is valid for the server to select a different * ciphersuite as long as the hash is the same. / if (md == NULL \|\| md != ssl_md(sctx, s->session->cipher->algorithm2)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED); return 0; } } else { / * Prior to TLSv1.3 resuming a session always meant using the same * ciphersuite. / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED); return 0; } } s->s3.tmp.new_cipher = c; return 1; } MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION s, PACKET pkt) { PACKET session_id, extpkt; size_t session_id_len; const unsigned char cipherchars; int hrr = 0; unsigned int compression; unsigned int sversion; unsigned int context; RAW_EXTENSION extensions = NULL; SSL ssl = SSL_CONNECTION_GET_SSL(s); #ifndef OPENSSL_NO_COMP SSL_COMP comp; #endif if (!PACKET_get_net_2(pkt, &sversion)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } / load the server random / if (s->version == TLS1_3_VERSION && sversion == TLS1_2_VERSION && PACKET_remaining(pkt) >= SSL3_RANDOM_SIZE && memcmp(hrrrandom, PACKET_data(pkt), SSL3_RANDOM_SIZE) == 0) { if (s->hello_retry_request != SSL_HRR_NONE) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto err; } s->hello_retry_request = SSL_HRR_PENDING; / Tell the record layer that we know we're going to get TLSv1.3 / if (!ssl_set_record_protocol_version(s, s->version)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hrr = 1; if (!PACKET_forward(pkt, SSL3_RANDOM_SIZE)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } } else { if (!PACKET_copy_bytes(pkt, s->s3.server_random, SSL3_RANDOM_SIZE)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } } / Get the session-id. / if (!PACKET_get_length_prefixed_1(pkt, &session_id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } session_id_len = PACKET_remaining(&session_id); if (session_id_len > sizeof(s->session->session_id) \|\| session_id_len > SSL3_SESSION_ID_SIZE) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_SESSION_ID_TOO_LONG); goto err; } if (!PACKET_get_bytes(pkt, &cipherchars, TLS_CIPHER_LEN)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_get_1(pkt, &compression)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } / TLS extensions / if (PACKET_remaining(pkt) == 0 && !hrr) { PACKET_null_init(&extpkt); } else if (!PACKET_as_length_prefixed_2(pkt, &extpkt) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); goto err; } if (!hrr) { if (!tls_collect_extensions(s, &extpkt, SSL_EXT_TLS1_2_SERVER_HELLO \| SSL_EXT_TLS1_3_SERVER_HELLO, &extensions, NULL, 1)) { / SSLfatal() already called / goto err; } if (!ssl_choose_client_version(s, sversion, extensions)) { / SSLfatal() already called / goto err; } } if (SSL_CONNECTION_IS_TLS13(s) \|\| hrr) { if (compression != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_COMPRESSION_ALGORITHM); goto err; } if (session_id_len != s->tmp_session_id_len \|\| memcmp(PACKET_data(&session_id), s->tmp_session_id, session_id_len) != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_SESSION_ID); goto err; } } if (hrr) { if (!set_client_ciphersuite(s, cipherchars)) { / SSLfatal() already called / goto err; } return tls_process_as_hello_retry_request(s, &extpkt); } / * Now we have chosen the version we need to check again that the extensions * are appropriate for this version. / context = SSL_CONNECTION_IS_TLS13(s) ? SSL_EXT_TLS1_3_SERVER_HELLO : SSL_EXT_TLS1_2_SERVER_HELLO; if (!tls_validate_all_contexts(s, context, extensions)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); goto err; } s->hit = 0; if (SSL_CONNECTION_IS_TLS13(s)) { / * In TLSv1.3 a ServerHello message signals a key change so the end of * the message must be on a record boundary. / if (RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); goto err; } / This will set s->hit if we are resuming / if (!tls_parse_extension(s, TLSEXT_IDX_psk, SSL_EXT_TLS1_3_SERVER_HELLO, extensions, NULL, 0)) { / SSLfatal() already called / goto err; } } else { / * Check if we can resume the session based on external pre-shared * secret. EAP-FAST (RFC 4851) supports two types of session resumption. * Resumption based on server-side state works with session IDs. * Resumption based on pre-shared Protected Access Credentials (PACs) * works by overriding the SessionTicket extension at the application * layer, and does not send a session ID. (We do not know whether * EAP-FAST servers would honour the session ID.) Therefore, the session * ID alone is not a reliable indicator of session resumption, so we * first check if we can resume, and later peek at the next handshake * message to see if the server wants to resume. / if (s->version >= TLS1_VERSION && s->ext.session_secret_cb != NULL && s->session->ext.tick) { const SSL_CIPHER pref_cipher = NULL; /* * s->session->master_key_length is a size_t, but this is an int for * backwards compat reasons / int master_key_length; master_key_length = sizeof(s->session->master_key); if (s->ext.session_secret_cb(ssl, s->session->master_key, &master_key_length, NULL, &pref_cipher, s->ext.session_secret_cb_arg) && master_key_length > 0) { s->session->master_key_length = master_key_length; s->session->cipher = pref_cipher ? pref_cipher : ssl_get_cipher_by_char(s, cipherchars, 0); } else { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (session_id_len != 0 && session_id_len == s->session->session_id_length && memcmp(PACKET_data(&session_id), s->session->session_id, session_id_len) == 0) s->hit = 1; } if (s->hit) { if (s->sid_ctx_length != s->session->sid_ctx_length \|\| memcmp(s->session->sid_ctx, s->sid_ctx, s->sid_ctx_length)) { / actually a client application bug / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT); goto err; } } else { / * If we were trying for session-id reuse but the server * didn't resume, make a new SSL_SESSION. * In the case of EAP-FAST and PAC, we do not send a session ID, * so the PAC-based session secret is always preserved. It'll be * overwritten if the server refuses resumption. / if (s->session->session_id_length > 0) { ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_miss); if (!ssl_get_new_session(s, 0)) { / SSLfatal() already called / goto err; } } s->session->ssl_version = s->version; / * In TLSv1.2 and below we save the session id we were sent so we can * resume it later. In TLSv1.3 the session id we were sent is just an * echo of what we originally sent in the ClientHello and should not be * used for resumption. / if (!SSL_CONNECTION_IS_TLS13(s)) { s->session->session_id_length = session_id_len; / session_id_len could be 0 / if (session_id_len > 0) memcpy(s->session->session_id, PACKET_data(&session_id), session_id_len); } } / Session version and negotiated protocol version should match / if (s->version != s->session->ssl_version) { SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_SSL_SESSION_VERSION_MISMATCH); goto err; } / * Now that we know the version, update the check to see if it's an allowed * version. / s->s3.tmp.min_ver = s->version; s->s3.tmp.max_ver = s->version; if (!set_client_ciphersuite(s, cipherchars)) { / SSLfatal() already called / goto err; } #ifdef OPENSSL_NO_COMP if (compression != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM); goto err; } / * If compression is disabled we'd better not try to resume a session * using compression. / if (s->session->compress_meth != 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_COMPRESSION); goto err; } #else if (s->hit && compression != s->session->compress_meth) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED); goto err; } if (compression == 0) comp = NULL; else if (!ssl_allow_compression(s)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COMPRESSION_DISABLED); goto err; } else { comp = ssl3_comp_find(SSL_CONNECTION_GET_CTX(s)->comp_methods, compression); } if (compression != 0 && comp == NULL) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM); goto err; } else { s->s3.tmp.new_compression = comp; } #endif if (!tls_parse_all_extensions(s, context, extensions, NULL, 0, 1)) { / SSLfatal() already called / goto err; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && s->hit) { unsigned char sctpauthkey[64]; char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)]; size_t labellen; / * Add new shared key for SCTP-Auth, will be ignored if * no SCTP used. / memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL, sizeof(DTLS1_SCTP_AUTH_LABEL)); / Don't include the terminating zero. / labellen = sizeof(labelbuffer) - 1; if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG) labellen += 1; if (SSL_export_keying_material(ssl, sctpauthkey, sizeof(sctpauthkey), labelbuffer, labellen, NULL, 0, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY, sizeof(sctpauthkey), sctpauthkey); } #endif / * In TLSv1.3 we have some post-processing to change cipher state, otherwise * we're done with this message / if (SSL_CONNECTION_IS_TLS13(s)) { if (!ssl->method->ssl3_enc->setup_key_block(s) \|\| !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE \| SSL3_CHANGE_CIPHER_CLIENT_READ)) { / SSLfatal() already called / goto err; } / * If we're not doing early-data and we're not going to send a dummy CCS * (i.e. no middlebox compat mode) then we can change the write keys * immediately. Otherwise we have to defer this until after all possible * early data is written. We could just always defer until the last * moment except QUIC needs it done at the same time as the read keys * are changed. Since QUIC doesn't do TLS early data or need middlebox * compat this doesn't cause a problem. / if (s->early_data_state == SSL_EARLY_DATA_NONE && (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0 && !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE \| SSL3_CHANGE_CIPHER_CLIENT_WRITE)) { / SSLfatal() already called / goto err; } } OPENSSL_free(extensions); return MSG_PROCESS_CONTINUE_READING; err: OPENSSL_free(extensions); return MSG_PROCESS_ERROR; } static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION s, PACKET extpkt) { RAW_EXTENSION extensions = NULL; /* * If we were sending early_data then any alerts should not be sent using * the old wrlmethod. / if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING && !ssl_set_new_record_layer(s, TLS_ANY_VERSION, OSSL_RECORD_DIRECTION_WRITE, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL)) { / SSLfatal already called / goto err; } / We are definitely going to be using TLSv1.3 / s->rlayer.wrlmethod->set_protocol_version(s->rlayer.wrl, TLS1_3_VERSION); if (!tls_collect_extensions(s, extpkt, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST, &extensions, NULL, 1) \|\| !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST, extensions, NULL, 0, 1)) { / SSLfatal() already called / goto err; } OPENSSL_free(extensions); extensions = NULL; if (s->ext.tls13_cookie_len == 0 && s->s3.tmp.pkey != NULL) { / * We didn't receive a cookie or a new key_share so the next * ClientHello will not change / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CHANGE_FOLLOWING_HRR); goto err; } / * Re-initialise the Transcript Hash. We're going to prepopulate it with * a synthetic message_hash in place of ClientHello1. / if (!create_synthetic_message_hash(s, NULL, 0, NULL, 0)) { / SSLfatal() already called / goto err; } / * Add this message to the Transcript Hash. Normally this is done * automatically prior to the message processing stage. However due to the * need to create the synthetic message hash, we defer that step until now * for HRR messages. / if (!ssl3_finish_mac(s, (unsigned char )s->init_buf->data, s->init_num + SSL3_HM_HEADER_LENGTH)) { /* SSLfatal() already called / goto err; } return MSG_PROCESS_FINISHED_READING; err: OPENSSL_free(extensions); return MSG_PROCESS_ERROR; } MSG_PROCESS_RETURN tls_process_server_rpk(SSL_CONNECTION sc, PACKET pkt) { EVP_PKEY peer_rpk; if (!tls_process_rpk(sc, pkt, &peer_rpk)) { /* SSLfatal() already called / return MSG_PROCESS_ERROR; } if (peer_rpk == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_CERTIFICATE); return MSG_PROCESS_ERROR; } EVP_PKEY_free(sc->session->peer_rpk); sc->session->peer_rpk = peer_rpk; return MSG_PROCESS_CONTINUE_PROCESSING; } static WORK_STATE tls_post_process_server_rpk(SSL_CONNECTION sc, WORK_STATE wst) { size_t certidx; const SSL_CERT_LOOKUP clu; if (sc->session->peer_rpk == NULL) { SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_RAW_PUBLIC_KEY); return WORK_ERROR; } if (sc->rwstate == SSL_RETRY_VERIFY) sc->rwstate = SSL_NOTHING; if (ssl_verify_rpk(sc, sc->session->peer_rpk) > 0 && sc->rwstate == SSL_RETRY_VERIFY) return WORK_MORE_A; if ((clu = ssl_cert_lookup_by_pkey(sc->session->peer_rpk, &certidx, SSL_CONNECTION_GET_CTX(sc))) == NULL) { SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CERTIFICATE_TYPE); return WORK_ERROR; } / * Check certificate type is consistent with ciphersuite. For TLS 1.3 * skip check since TLS 1.3 ciphersuites can be used with any certificate * type. / if (!SSL_CONNECTION_IS_TLS13(sc)) { if ((clu->amask & sc->s3.tmp.new_cipher->algorithm_auth) == 0) { SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_RPK_TYPE); return WORK_ERROR; } } / Ensure there is no peer/peer_chain / X509_free(sc->session->peer); sc->session->peer = NULL; sk_X509_pop_free(sc->session->peer_chain, X509_free); sc->session->peer_chain = NULL; sc->session->verify_result = sc->verify_result; / Save the current hash state for when we receive the CertificateVerify / if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_handshake_hash(sc, sc->cert_verify_hash, sizeof(sc->cert_verify_hash), &sc->cert_verify_hash_len)) { / SSLfatal() already called / return WORK_ERROR; } return WORK_FINISHED_CONTINUE; } / prepare server cert verification by setting s->session->peer_chain from pkt / MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION s, PACKET pkt) { unsigned long cert_list_len, cert_len; X509 x = NULL; const unsigned char certstart, certbytes; size_t chainidx; unsigned int context = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (s->ext.server_cert_type == TLSEXT_cert_type_rpk) return tls_process_server_rpk(s, pkt); if (s->ext.server_cert_type != TLSEXT_cert_type_x509) { SSLfatal(s, SSL_AD_UNSUPPORTED_CERTIFICATE, SSL_R_UNKNOWN_CERTIFICATE_TYPE); goto err; } if ((s->session->peer_chain = sk_X509_new_null()) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if ((SSL_CONNECTION_IS_TLS13(s) && !PACKET_get_1(pkt, &context)) \|\| context != 0 \|\| !PACKET_get_net_3(pkt, &cert_list_len) \|\| PACKET_remaining(pkt) != cert_list_len \|\| PACKET_remaining(pkt) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } for (chainidx = 0; PACKET_remaining(pkt); chainidx++) { if (!PACKET_get_net_3(pkt, &cert_len) \|\| !PACKET_get_bytes(pkt, &certbytes, cert_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH); goto err; } certstart = certbytes; x = X509_new_ex(sctx->libctx, sctx->propq); if (x == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_ASN1_LIB); goto err; } if (d2i_X509(&x, (const unsigned char )&certbytes, cert_len) == NULL) { SSLfatal(s, SSL_AD_BAD_CERTIFICATE, ERR_R_ASN1_LIB); goto err; } if (certbytes != (certstart + cert_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH); goto err; } if (SSL_CONNECTION_IS_TLS13(s)) { RAW_EXTENSION rawexts = NULL; PACKET extensions; if (!PACKET_get_length_prefixed_2(pkt, &extensions)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); goto err; } if (!tls_collect_extensions(s, &extensions, SSL_EXT_TLS1_3_CERTIFICATE, &rawexts, NULL, chainidx == 0) \|\| !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE, rawexts, x, chainidx, PACKET_remaining(pkt) == 0)) { OPENSSL_free(rawexts); /* SSLfatal already called / goto err; } OPENSSL_free(rawexts); } if (!sk_X509_push(s->session->peer_chain, x)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } x = NULL; } return MSG_PROCESS_CONTINUE_PROCESSING; err: X509_free(x); OSSL_STACK_OF_X509_free(s->session->peer_chain); s->session->peer_chain = NULL; return MSG_PROCESS_ERROR; } / * Verify the s->session->peer_chain and check server cert type. * On success set s->session->peer and s->session->verify_result. * Else the peer certificate verification callback may request retry. / WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION s, WORK_STATE wst) { X509 x; EVP_PKEY pkey = NULL; const SSL_CERT_LOOKUP clu; size_t certidx; int i; if (s->ext.server_cert_type == TLSEXT_cert_type_rpk) return tls_post_process_server_rpk(s, wst); if (s->rwstate == SSL_RETRY_VERIFY) s->rwstate = SSL_NOTHING; i = ssl_verify_cert_chain(s, s->session->peer_chain); if (i > 0 && s->rwstate == SSL_RETRY_VERIFY) { return WORK_MORE_A; } / * The documented interface is that SSL_VERIFY_PEER should be set in order * for client side verification of the server certificate to take place. * However, historically the code has only checked that any flag is set * to cause server verification to take place. Use of the other flags makes * no sense in client mode. An attempt to clean up the semantics was * reverted because at least one application only set * SSL_VERIFY_FAIL_IF_NO_PEER_CERT. Prior to the clean up this still caused * server verification to take place, after the clean up it silently did * nothing. SSL_CTX_set_verify()/SSL_set_verify() cannot validate the flags * sent to them because they are void functions. Therefore, we now use the * (less clean) historic behaviour of performing validation if any flag is * set. The documented interface remains the same. / if (s->verify_mode != SSL_VERIFY_NONE && i <= 0) { SSLfatal(s, ssl_x509err2alert(s->verify_result), SSL_R_CERTIFICATE_VERIFY_FAILED); return WORK_ERROR; } ERR_clear_error(); / but we keep s->verify_result / / * Inconsistency alert: cert_chain does include the peer's certificate, * which we don't include in statem_srvr.c / x = sk_X509_value(s->session->peer_chain, 0); pkey = X509_get0_pubkey(x); if (pkey == NULL \|\| EVP_PKEY_missing_parameters(pkey)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS); return WORK_ERROR; } if ((clu = ssl_cert_lookup_by_pkey(pkey, &certidx, SSL_CONNECTION_GET_CTX(s))) == NULL) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CERTIFICATE_TYPE); return WORK_ERROR; } / * Check certificate type is consistent with ciphersuite. For TLS 1.3 * skip check since TLS 1.3 ciphersuites can be used with any certificate * type. / if (!SSL_CONNECTION_IS_TLS13(s)) { if ((clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CERTIFICATE_TYPE); return WORK_ERROR; } } X509_free(s->session->peer); X509_up_ref(x); s->session->peer = x; s->session->verify_result = s->verify_result; / Ensure there is no RPK / EVP_PKEY_free(s->session->peer_rpk); s->session->peer_rpk = NULL; / Save the current hash state for when we receive the CertificateVerify / if (SSL_CONNECTION_IS_TLS13(s) && !ssl_handshake_hash(s, s->cert_verify_hash, sizeof(s->cert_verify_hash), &s->cert_verify_hash_len)) { / SSLfatal() already called /; return WORK_ERROR; } return WORK_FINISHED_CONTINUE; } #ifndef OPENSSL_NO_COMP_ALG MSG_PROCESS_RETURN tls_process_server_compressed_certificate(SSL_CONNECTION sc, PACKET pkt) { MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; PACKET tmppkt; BUF_MEM buf = BUF_MEM_new(); if (tls13_process_compressed_certificate(sc, pkt, &tmppkt, buf) != MSG_PROCESS_ERROR) ret = tls_process_server_certificate(sc, &tmppkt); BUF_MEM_free(buf); return ret; } #endif static int tls_process_ske_psk_preamble(SSL_CONNECTION s, PACKET pkt) { #ifndef OPENSSL_NO_PSK PACKET psk_identity_hint; /* PSK ciphersuites are preceded by an identity hint / if (!PACKET_get_length_prefixed_2(pkt, &psk_identity_hint)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } / * Store PSK identity hint for later use, hint is used in * tls_construct_client_key_exchange. Assume that the maximum length of * a PSK identity hint can be as long as the maximum length of a PSK * identity. / if (PACKET_remaining(&psk_identity_hint) > PSK_MAX_IDENTITY_LEN) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } if (PACKET_remaining(&psk_identity_hint) == 0) { OPENSSL_free(s->session->psk_identity_hint); s->session->psk_identity_hint = NULL; } else if (!PACKET_strndup(&psk_identity_hint, &s->session->psk_identity_hint)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_ske_srp(SSL_CONNECTION s, PACKET pkt, EVP_PKEY pkey) { #ifndef OPENSSL_NO_SRP PACKET prime, generator, salt, server_pub; if (!PACKET_get_length_prefixed_2(pkt, &prime) \|\| !PACKET_get_length_prefixed_2(pkt, &generator) \|\| !PACKET_get_length_prefixed_1(pkt, &salt) \|\| !PACKET_get_length_prefixed_2(pkt, &server_pub)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if ((s->srp_ctx.N = BN_bin2bn(PACKET_data(&prime), (int)PACKET_remaining(&prime), NULL)) == NULL \|\| (s->srp_ctx.g = BN_bin2bn(PACKET_data(&generator), (int)PACKET_remaining(&generator), NULL)) == NULL \|\| (s->srp_ctx.s = BN_bin2bn(PACKET_data(&salt), (int)PACKET_remaining(&salt), NULL)) == NULL \|\| (s->srp_ctx.B = BN_bin2bn(PACKET_data(&server_pub), (int)PACKET_remaining(&server_pub), NULL)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB); return 0; } if (!srp_verify_server_param(s)) { / SSLfatal() already called / return 0; } / We must check if there is a certificate / if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aRSA \| SSL_aDSS)) pkey = tls_get_peer_pkey(s); return 1; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_ske_dhe(SSL_CONNECTION s, PACKET pkt, EVP_PKEY *pkey) { PACKET prime, generator, pub_key; EVP_PKEY peer_tmp = NULL; BIGNUM p = NULL, g = NULL, bnpub_key = NULL; EVP_PKEY_CTX pctx = NULL; OSSL_PARAM params = NULL; OSSL_PARAM_BLD tmpl = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); int ret = 0; if (!PACKET_get_length_prefixed_2(pkt, &prime) \|\| !PACKET_get_length_prefixed_2(pkt, &generator) \|\| !PACKET_get_length_prefixed_2(pkt, &pub_key)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } p = BN_bin2bn(PACKET_data(&prime), (int)PACKET_remaining(&prime), NULL); g = BN_bin2bn(PACKET_data(&generator), (int)PACKET_remaining(&generator), NULL); bnpub_key = BN_bin2bn(PACKET_data(&pub_key), (int)PACKET_remaining(&pub_key), NULL); if (p == NULL \|\| g == NULL \|\| bnpub_key == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB); goto err; } tmpl = OSSL_PARAM_BLD_new(); if (tmpl == NULL \|\| !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p) \|\| !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_G, g) \|\| !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_PUB_KEY, bnpub_key) \|\| (params = OSSL_PARAM_BLD_to_param(tmpl)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, "DH", sctx->propq); if (pctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (EVP_PKEY_fromdata_init(pctx) <= 0 \|\| EVP_PKEY_fromdata(pctx, &peer_tmp, EVP_PKEY_KEYPAIR, params) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_DH_VALUE); goto err; } EVP_PKEY_CTX_free(pctx); pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, peer_tmp, sctx->propq); if (pctx == NULL / * EVP_PKEY_param_check() will verify that the DH params are using * a safe prime. In this context, because we're using ephemeral DH, * we're ok with it not being a safe prime. * EVP_PKEY_param_check_quick() skips the safe prime check. / \|\| EVP_PKEY_param_check_quick(pctx) != 1 \|\| EVP_PKEY_public_check(pctx) != 1) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DH_VALUE); goto err; } if (!ssl_security(s, SSL_SECOP_TMP_DH, EVP_PKEY_get_security_bits(peer_tmp), 0, peer_tmp)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DH_KEY_TOO_SMALL); goto err; } s->s3.peer_tmp = peer_tmp; peer_tmp = NULL; / * FIXME: This makes assumptions about which ciphersuites come with * public keys. We should have a less ad-hoc way of doing this / if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aRSA \| SSL_aDSS)) pkey = tls_get_peer_pkey(s); /* else anonymous DH, so no certificate or pkey. / ret = 1; err: OSSL_PARAM_BLD_free(tmpl); OSSL_PARAM_free(params); EVP_PKEY_free(peer_tmp); EVP_PKEY_CTX_free(pctx); BN_free(p); BN_free(g); BN_free(bnpub_key); return ret; } static int tls_process_ske_ecdhe(SSL_CONNECTION s, PACKET pkt, EVP_PKEY pkey) { PACKET encoded_pt; unsigned int curve_type, curve_id; / * Extract elliptic curve parameters and the server's ephemeral ECDH * public key. We only support named (not generic) curves and * ECParameters in this case is just three bytes. / if (!PACKET_get_1(pkt, &curve_type) \|\| !PACKET_get_net_2(pkt, &curve_id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); return 0; } / * Check curve is named curve type and one of our preferences, if not * server has sent an invalid curve. / if (curve_type != NAMED_CURVE_TYPE \|\| !tls1_check_group_id(s, curve_id, 1)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE); return 0; } if ((s->s3.peer_tmp = ssl_generate_param_group(s, curve_id)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS); return 0; } if (!PACKET_get_length_prefixed_1(pkt, &encoded_pt)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (EVP_PKEY_set1_encoded_public_key(s->s3.peer_tmp, PACKET_data(&encoded_pt), PACKET_remaining(&encoded_pt)) <= 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT); return 0; } / * The ECC/TLS specification does not mention the use of DSA to sign * ECParameters in the server key exchange message. We do support RSA * and ECDSA. / if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aECDSA) pkey = tls_get_peer_pkey(s); else if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aRSA) pkey = tls_get_peer_pkey(s); / else anonymous ECDH, so no certificate or pkey. / / Cache the agreed upon group in the SSL_SESSION / s->session->kex_group = curve_id; return 1; } MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION s, PACKET pkt) { long alg_k; EVP_PKEY pkey = NULL; EVP_MD_CTX md_ctx = NULL; EVP_PKEY_CTX pctx = NULL; PACKET save_param_start, signature; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); alg_k = s->s3.tmp.new_cipher->algorithm_mkey; save_param_start = pkt; EVP_PKEY_free(s->s3.peer_tmp); s->s3.peer_tmp = NULL; if (alg_k & SSL_PSK) { if (!tls_process_ske_psk_preamble(s, pkt)) { /* SSLfatal() already called / goto err; } } / Nothing else to do for plain PSK or RSAPSK / if (alg_k & (SSL_kPSK \| SSL_kRSAPSK)) { } else if (alg_k & SSL_kSRP) { if (!tls_process_ske_srp(s, pkt, &pkey)) { / SSLfatal() already called / goto err; } } else if (alg_k & (SSL_kDHE \| SSL_kDHEPSK)) { if (!tls_process_ske_dhe(s, pkt, &pkey)) { / SSLfatal() already called / goto err; } } else if (alg_k & (SSL_kECDHE \| SSL_kECDHEPSK)) { if (!tls_process_ske_ecdhe(s, pkt, &pkey)) { / SSLfatal() already called / goto err; } } else if (alg_k) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto err; } / if it was signed, check the signature / if (pkey != NULL) { PACKET params; const EVP_MD md = NULL; unsigned char tbs; size_t tbslen; int rv; / * \|pkt\| now points to the beginning of the signature, so the difference * equals the length of the parameters. / if (!PACKET_get_sub_packet(&save_param_start, &params, PACKET_remaining(&save_param_start) - PACKET_remaining(pkt))) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (SSL_USE_SIGALGS(s)) { unsigned int sigalg; if (!PACKET_get_net_2(pkt, &sigalg)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); goto err; } if (tls12_check_peer_sigalg(s, sigalg, pkey) <=0) { / SSLfatal() already called / goto err; } } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED); goto err; } if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM); goto err; } if (SSL_USE_SIGALGS(s)) OSSL_TRACE1(TLS, "USING TLSv1.2 HASH %s\n", md == NULL ? "n/a" : EVP_MD_get0_name(md)); if (!PACKET_get_length_prefixed_2(pkt, &signature) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } md_ctx = EVP_MD_CTX_new(); if (md_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_DigestVerifyInit_ex(md_ctx, &pctx, md == NULL ? NULL : EVP_MD_get0_name(md), sctx->libctx, sctx->propq, pkey, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (SSL_USE_PSS(s)) { if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0 \|\| EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } tbslen = construct_key_exchange_tbs(s, &tbs, PACKET_data(&params), PACKET_remaining(&params)); if (tbslen == 0) { / SSLfatal() already called / goto err; } rv = EVP_DigestVerify(md_ctx, PACKET_data(&signature), PACKET_remaining(&signature), tbs, tbslen); OPENSSL_free(tbs); if (rv <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BAD_SIGNATURE); goto err; } EVP_MD_CTX_free(md_ctx); md_ctx = NULL; } else { / aNULL, aSRP or PSK do not need public keys / if (!(s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL \| SSL_aSRP)) && !(alg_k & SSL_PSK)) { / Might be wrong key type, check it / if (ssl3_check_cert_and_algorithm(s)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_DATA); } / else this shouldn't happen, SSLfatal() already called / goto err; } / still data left over / if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_EXTRA_DATA_IN_MESSAGE); goto err; } } return MSG_PROCESS_CONTINUE_READING; err: EVP_MD_CTX_free(md_ctx); return MSG_PROCESS_ERROR; } MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION s, PACKET pkt) { / Clear certificate validity flags / if (s->s3.tmp.valid_flags != NULL) memset(s->s3.tmp.valid_flags, 0, s->ssl_pkey_num sizeof(uint32_t)); else s->s3.tmp.valid_flags = OPENSSL_zalloc(s->ssl_pkey_num * sizeof(uint32_t)); /* Give up for good if allocation didn't work / if (s->s3.tmp.valid_flags == NULL) return 0; if (SSL_CONNECTION_IS_TLS13(s)) { PACKET reqctx, extensions; RAW_EXTENSION rawexts = NULL; if ((s->shutdown & SSL_SENT_SHUTDOWN) != 0) { /* * We already sent close_notify. This can only happen in TLSv1.3 * post-handshake messages. We can't reasonably respond to this, so * we just ignore it / return MSG_PROCESS_FINISHED_READING; } / Free and zero certificate types: it is not present in TLS 1.3 / OPENSSL_free(s->s3.tmp.ctype); s->s3.tmp.ctype = NULL; s->s3.tmp.ctype_len = 0; OPENSSL_free(s->pha_context); s->pha_context = NULL; s->pha_context_len = 0; if (!PACKET_get_length_prefixed_1(pkt, &reqctx) \|\| !PACKET_memdup(&reqctx, &s->pha_context, &s->pha_context_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if (!PACKET_get_length_prefixed_2(pkt, &extensions)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); return MSG_PROCESS_ERROR; } if (!tls_collect_extensions(s, &extensions, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, &rawexts, NULL, 1) \|\| !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, rawexts, NULL, 0, 1)) { / SSLfatal() already called / OPENSSL_free(rawexts); return MSG_PROCESS_ERROR; } OPENSSL_free(rawexts); if (!tls1_process_sigalgs(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_LENGTH); return MSG_PROCESS_ERROR; } } else { PACKET ctypes; / get the certificate types / if (!PACKET_get_length_prefixed_1(pkt, &ctypes)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if (!PACKET_memdup(&ctypes, &s->s3.tmp.ctype, &s->s3.tmp.ctype_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } if (SSL_USE_SIGALGS(s)) { PACKET sigalgs; if (!PACKET_get_length_prefixed_2(pkt, &sigalgs)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } / * Despite this being for certificates, preserve compatibility * with pre-TLS 1.3 and use the regular sigalgs field. / if (!tls1_save_sigalgs(s, &sigalgs, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SIGNATURE_ALGORITHMS_ERROR); return MSG_PROCESS_ERROR; } if (!tls1_process_sigalgs(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); return MSG_PROCESS_ERROR; } } / get the CA RDNs / if (!parse_ca_names(s, pkt)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } } if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } / we should setup a certificate to return.... / s->s3.tmp.cert_req = 1; / * In TLSv1.3 we don't prepare the client certificate yet. We wait until * after the CertificateVerify message has been received. This is because * in TLSv1.3 the CertificateRequest arrives before the Certificate message * but in TLSv1.2 it is the other way around. We want to make sure that * SSL_get1_peer_certificate() returns something sensible in * client_cert_cb. / if (SSL_CONNECTION_IS_TLS13(s) && s->post_handshake_auth != SSL_PHA_REQUESTED) return MSG_PROCESS_CONTINUE_READING; return MSG_PROCESS_CONTINUE_PROCESSING; } MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION s, PACKET pkt) { unsigned int ticklen; unsigned long ticket_lifetime_hint, age_add = 0; unsigned int sess_len; RAW_EXTENSION exts = NULL; PACKET nonce; EVP_MD sha256 = NULL; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); PACKET_null_init(&nonce); if (!PACKET_get_net_4(pkt, &ticket_lifetime_hint) \|\| (SSL_CONNECTION_IS_TLS13(s) && (!PACKET_get_net_4(pkt, &age_add) \|\| !PACKET_get_length_prefixed_1(pkt, &nonce))) \|\| !PACKET_get_net_2(pkt, &ticklen) \|\| (SSL_CONNECTION_IS_TLS13(s) ? (ticklen == 0 \|\| PACKET_remaining(pkt) < ticklen) : PACKET_remaining(pkt) != ticklen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } /* * Server is allowed to change its mind (in <=TLSv1.2) and send an empty * ticket. We already checked this TLSv1.3 case above, so it should never * be 0 here in that instance / if (ticklen == 0) return MSG_PROCESS_CONTINUE_READING; / * Sessions must be immutable once they go into the session cache. Otherwise * we can get multi-thread problems. Therefore we don't "update" sessions, * we replace them with a duplicate. In TLSv1.3 we need to do this every * time a NewSessionTicket arrives because those messages arrive * post-handshake and the session may have already gone into the session * cache. / if (SSL_CONNECTION_IS_TLS13(s) \|\| s->session->session_id_length > 0) { SSL_SESSION new_sess; /* * We reused an existing session, so we need to replace it with a new * one / if ((new_sess = ssl_session_dup(s->session, 0)) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); goto err; } if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) != 0 && !SSL_CONNECTION_IS_TLS13(s)) { / * In TLSv1.2 and below the arrival of a new tickets signals that * any old ticket we were using is now out of date, so we remove the * old session from the cache. We carry on if this fails / SSL_CTX_remove_session(s->session_ctx, s->session); } SSL_SESSION_free(s->session); s->session = new_sess; } s->session->time = ossl_time_now(); ssl_session_calculate_timeout(s->session); OPENSSL_free(s->session->ext.tick); s->session->ext.tick = NULL; s->session->ext.ticklen = 0; s->session->ext.tick = OPENSSL_malloc(ticklen); if (s->session->ext.tick == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (!PACKET_copy_bytes(pkt, s->session->ext.tick, ticklen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } s->session->ext.tick_lifetime_hint = ticket_lifetime_hint; s->session->ext.tick_age_add = age_add; s->session->ext.ticklen = ticklen; if (SSL_CONNECTION_IS_TLS13(s)) { PACKET extpkt; if (!PACKET_as_length_prefixed_2(pkt, &extpkt) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!tls_collect_extensions(s, &extpkt, SSL_EXT_TLS1_3_NEW_SESSION_TICKET, &exts, NULL, 1) \|\| !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_NEW_SESSION_TICKET, exts, NULL, 0, 1)) { / SSLfatal() already called / goto err; } } / * There are two ways to detect a resumed ticket session. One is to set * an appropriate session ID and then the server must return a match in * ServerHello. This allows the normal client session ID matching to work * and we know much earlier that the ticket has been accepted. The * other way is to set zero length session ID when the ticket is * presented and rely on the handshake to determine session resumption. * We choose the former approach because this fits in with assumptions * elsewhere in OpenSSL. The session ID is set to the SHA256 hash of the * ticket. / sha256 = EVP_MD_fetch(sctx->libctx, "SHA2-256", sctx->propq); if (sha256 == NULL) { / Error is already recorded / SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); goto err; } / * We use sess_len here because EVP_Digest expects an int * but s->session->session_id_length is a size_t / if (!EVP_Digest(s->session->ext.tick, ticklen, s->session->session_id, &sess_len, sha256, NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } EVP_MD_free(sha256); sha256 = NULL; s->session->session_id_length = sess_len; s->session->not_resumable = 0; / This is a standalone message in TLSv1.3, so there is no more to read / if (SSL_CONNECTION_IS_TLS13(s)) { const EVP_MD md = ssl_handshake_md(s); int hashleni = EVP_MD_get_size(md); size_t hashlen; static const unsigned char nonce_label[] = "resumption"; /* Ensure cast to size_t is safe / if (!ossl_assert(hashleni >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hashlen = (size_t)hashleni; if (!tls13_hkdf_expand(s, md, s->resumption_master_secret, nonce_label, sizeof(nonce_label) - 1, PACKET_data(&nonce), PACKET_remaining(&nonce), s->session->master_key, hashlen, 1)) { / SSLfatal() already called / goto err; } s->session->master_key_length = hashlen; OPENSSL_free(exts); ssl_update_cache(s, SSL_SESS_CACHE_CLIENT); return MSG_PROCESS_FINISHED_READING; } return MSG_PROCESS_CONTINUE_READING; err: EVP_MD_free(sha256); OPENSSL_free(exts); return MSG_PROCESS_ERROR; } / * In TLSv1.3 this is called from the extensions code, otherwise it is used to * parse a separate message. Returns 1 on success or 0 on failure / int tls_process_cert_status_body(SSL_CONNECTION s, PACKET pkt) { size_t resplen; unsigned int type; if (!PACKET_get_1(pkt, &type) \|\| type != TLSEXT_STATUSTYPE_ocsp) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_UNSUPPORTED_STATUS_TYPE); return 0; } if (!PACKET_get_net_3_len(pkt, &resplen) \|\| PACKET_remaining(pkt) != resplen) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } s->ext.ocsp.resp = OPENSSL_malloc(resplen); if (s->ext.ocsp.resp == NULL) { s->ext.ocsp.resp_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } s->ext.ocsp.resp_len = resplen; if (!PACKET_copy_bytes(pkt, s->ext.ocsp.resp, resplen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } return 1; } MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION s, PACKET pkt) { if (!tls_process_cert_status_body(s, pkt)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } return MSG_PROCESS_CONTINUE_READING; } / * Perform miscellaneous checks and processing after we have received the * server's initial flight. In TLS1.3 this is after the Server Finished message. * In <=TLS1.2 this is after the ServerDone message. Returns 1 on success or 0 * on failure. / int tls_process_initial_server_flight(SSL_CONNECTION s) { SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); / * at this point we check that we have the required stuff from * the server / if (!ssl3_check_cert_and_algorithm(s)) { / SSLfatal() already called / return 0; } / * Call the ocsp status callback if needed. The \|ext.ocsp.resp\| and * \|ext.ocsp.resp_len\| values will be set if we actually received a status * message, or NULL and -1 otherwise / if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing && sctx->ext.status_cb != NULL) { int ret = sctx->ext.status_cb(SSL_CONNECTION_GET_SSL(s), sctx->ext.status_arg); if (ret == 0) { SSLfatal(s, SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE, SSL_R_INVALID_STATUS_RESPONSE); return 0; } if (ret < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_OCSP_CALLBACK_FAILURE); return 0; } } #ifndef OPENSSL_NO_CT if (s->ct_validation_callback != NULL) { / Note we validate the SCTs whether or not we abort on error / if (!ssl_validate_ct(s) && (s->verify_mode & SSL_VERIFY_PEER)) { / SSLfatal() already called / return 0; } } #endif return 1; } MSG_PROCESS_RETURN tls_process_server_done(SSL_CONNECTION s, PACKET pkt) { if (PACKET_remaining(pkt) > 0) { / should contain no data / SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } #ifndef OPENSSL_NO_SRP if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) { if (ssl_srp_calc_a_param_intern(s) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SRP_A_CALC); return MSG_PROCESS_ERROR; } } #endif if (!tls_process_initial_server_flight(s)) { / SSLfatal() already called / return MSG_PROCESS_ERROR; } return MSG_PROCESS_FINISHED_READING; } static int tls_construct_cke_psk_preamble(SSL_CONNECTION s, WPACKET pkt) { #ifndef OPENSSL_NO_PSK int ret = 0; / * The callback needs PSK_MAX_IDENTITY_LEN + 1 bytes to return a * \0-terminated identity. The last byte is for us for simulating * strnlen. / char identity[PSK_MAX_IDENTITY_LEN + 1]; size_t identitylen = 0; unsigned char psk[PSK_MAX_PSK_LEN]; unsigned char tmppsk = NULL; char tmpidentity = NULL; size_t psklen = 0; if (s->psk_client_callback == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_PSK_NO_CLIENT_CB); goto err; } memset(identity, 0, sizeof(identity)); psklen = s->psk_client_callback(SSL_CONNECTION_GET_SSL(s), s->session->psk_identity_hint, identity, sizeof(identity) - 1, psk, sizeof(psk)); if (psklen > PSK_MAX_PSK_LEN) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR); psklen = PSK_MAX_PSK_LEN; / Avoid overrunning the array on cleanse / goto err; } else if (psklen == 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_PSK_IDENTITY_NOT_FOUND); goto err; } identitylen = strlen(identity); if (identitylen > PSK_MAX_IDENTITY_LEN) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } tmppsk = OPENSSL_memdup(psk, psklen); tmpidentity = OPENSSL_strdup(identity); if (tmppsk == NULL \|\| tmpidentity == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } OPENSSL_free(s->s3.tmp.psk); s->s3.tmp.psk = tmppsk; s->s3.tmp.psklen = psklen; tmppsk = NULL; OPENSSL_free(s->session->psk_identity); s->session->psk_identity = tmpidentity; tmpidentity = NULL; if (!WPACKET_sub_memcpy_u16(pkt, identity, identitylen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ret = 1; err: OPENSSL_cleanse(psk, psklen); OPENSSL_cleanse(identity, sizeof(identity)); OPENSSL_clear_free(tmppsk, psklen); OPENSSL_clear_free(tmpidentity, identitylen); return ret; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_construct_cke_rsa(SSL_CONNECTION s, WPACKET pkt) { unsigned char encdata = NULL; EVP_PKEY pkey = NULL; EVP_PKEY_CTX pctx = NULL; size_t enclen; unsigned char pms = NULL; size_t pmslen = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (!received_server_cert(s)) { /* * We should always have a server certificate with SSL_kRSA. / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((pkey = tls_get_peer_pkey(s)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!EVP_PKEY_is_a(pkey, "RSA")) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pmslen = SSL_MAX_MASTER_KEY_LENGTH; pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } pms[0] = s->client_version >> 8; pms[1] = s->client_version & 0xff; if (RAND_bytes_ex(sctx->libctx, pms + 2, pmslen - 2, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_RAND_LIB); goto err; } / Fix buf for TLS and beyond / if (s->version > SSL3_VERSION && !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pkey, sctx->propq); if (pctx == NULL \|\| EVP_PKEY_encrypt_init(pctx) <= 0 \|\| EVP_PKEY_encrypt(pctx, NULL, &enclen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (!WPACKET_allocate_bytes(pkt, enclen, &encdata) \|\| EVP_PKEY_encrypt(pctx, encdata, &enclen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_RSA_ENCRYPT); goto err; } EVP_PKEY_CTX_free(pctx); pctx = NULL; / Fix buf for TLS and beyond / if (s->version > SSL3_VERSION && !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Log the premaster secret, if logging is enabled. / if (!ssl_log_rsa_client_key_exchange(s, encdata, enclen, pms, pmslen)) { / SSLfatal() already called / goto err; } s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; return 1; err: OPENSSL_clear_free(pms, pmslen); EVP_PKEY_CTX_free(pctx); return 0; } static int tls_construct_cke_dhe(SSL_CONNECTION s, WPACKET pkt) { EVP_PKEY ckey = NULL, skey = NULL; unsigned char keybytes = NULL; int prime_len; unsigned char encoded_pub = NULL; size_t encoded_pub_len, pad_len; int ret = 0; skey = s->s3.peer_tmp; if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ckey = ssl_generate_pkey(s, skey); if (ckey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (ssl_derive(s, ckey, skey, 0) == 0) { / SSLfatal() already called / goto err; } / send off the data / / Generate encoding of server key / encoded_pub_len = EVP_PKEY_get1_encoded_public_key(ckey, &encoded_pub); if (encoded_pub_len == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_PKEY_free(ckey); return EXT_RETURN_FAIL; } / * For interoperability with some versions of the Microsoft TLS * stack, we need to zero pad the DHE pub key to the same length * as the prime. / prime_len = EVP_PKEY_get_size(ckey); pad_len = prime_len - encoded_pub_len; if (pad_len > 0) { if (!WPACKET_sub_allocate_bytes_u16(pkt, pad_len, &keybytes)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } memset(keybytes, 0, pad_len); } if (!WPACKET_sub_memcpy_u16(pkt, encoded_pub, encoded_pub_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ret = 1; err: OPENSSL_free(encoded_pub); EVP_PKEY_free(ckey); return ret; } static int tls_construct_cke_ecdhe(SSL_CONNECTION s, WPACKET pkt) { unsigned char encodedPoint = NULL; size_t encoded_pt_len = 0; EVP_PKEY ckey = NULL, skey = NULL; int ret = 0; skey = s->s3.peer_tmp; if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } ckey = ssl_generate_pkey(s, skey); if (ckey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); goto err; } if (ssl_derive(s, ckey, skey, 0) == 0) { /* SSLfatal() already called / goto err; } / Generate encoding of client key / encoded_pt_len = EVP_PKEY_get1_encoded_public_key(ckey, &encodedPoint); if (encoded_pt_len == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); goto err; } if (!WPACKET_sub_memcpy_u8(pkt, encodedPoint, encoded_pt_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ret = 1; err: OPENSSL_free(encodedPoint); EVP_PKEY_free(ckey); return ret; } static int tls_construct_cke_gost(SSL_CONNECTION s, WPACKET pkt) { #ifndef OPENSSL_NO_GOST / GOST key exchange message creation / EVP_PKEY_CTX pkey_ctx = NULL; EVP_PKEY pkey = NULL; size_t msglen; unsigned int md_len; unsigned char shared_ukm[32], tmp[256]; EVP_MD_CTX ukm_hash = NULL; int dgst_nid = NID_id_GostR3411_94; unsigned char pms = NULL; size_t pmslen = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if ((s->s3.tmp.new_cipher->algorithm_auth & SSL_aGOST12) != 0) dgst_nid = NID_id_GostR3411_2012_256; /* * Get server certificate PKEY and create ctx from it / if ((pkey = tls_get_peer_pkey(s)) == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER); return 0; } pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pkey, sctx->propq); if (pkey_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } / * If we have send a certificate, and certificate key * parameters match those of server certificate, use * certificate key for key exchange / / Otherwise, generate ephemeral key pair / pmslen = 32; pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0 / Generate session key / \|\| RAND_bytes_ex(sctx->libctx, pms, pmslen, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; }; / * Compute shared IV and store it in algorithm-specific context * data / ukm_hash = EVP_MD_CTX_new(); if (ukm_hash == NULL \|\| EVP_DigestInit(ukm_hash, EVP_get_digestbynid(dgst_nid)) <= 0 \|\| EVP_DigestUpdate(ukm_hash, s->s3.client_random, SSL3_RANDOM_SIZE) <= 0 \|\| EVP_DigestUpdate(ukm_hash, s->s3.server_random, SSL3_RANDOM_SIZE) <= 0 \|\| EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } EVP_MD_CTX_free(ukm_hash); ukm_hash = NULL; if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT, EVP_PKEY_CTRL_SET_IV, 8, shared_ukm) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } / Make GOST keytransport blob message / / * Encapsulate it into sequence / msglen = 255; if (EVP_PKEY_encrypt(pkey_ctx, tmp, &msglen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } if (!WPACKET_put_bytes_u8(pkt, V_ASN1_SEQUENCE \| V_ASN1_CONSTRUCTED) \|\| (msglen >= 0x80 && !WPACKET_put_bytes_u8(pkt, 0x81)) \|\| !WPACKET_sub_memcpy_u8(pkt, tmp, msglen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } EVP_PKEY_CTX_free(pkey_ctx); s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; return 1; err: EVP_PKEY_CTX_free(pkey_ctx); OPENSSL_clear_free(pms, pmslen); EVP_MD_CTX_free(ukm_hash); return 0; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } #ifndef OPENSSL_NO_GOST int ossl_gost18_cke_cipher_nid(const SSL_CONNECTION s) { if ((s->s3.tmp.new_cipher->algorithm_enc & SSL_MAGMA) != 0) return NID_magma_ctr; else if ((s->s3.tmp.new_cipher->algorithm_enc & SSL_KUZNYECHIK) != 0) return NID_kuznyechik_ctr; return NID_undef; } int ossl_gost_ukm(const SSL_CONNECTION s, unsigned char dgst_buf) { EVP_MD_CTX hash = NULL; unsigned int md_len; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); const EVP_MD md = ssl_evp_md_fetch(sctx->libctx, NID_id_GostR3411_2012_256, sctx->propq); if (md == NULL) return 0; if ((hash = EVP_MD_CTX_new()) == NULL \|\| EVP_DigestInit(hash, md) <= 0 \|\| EVP_DigestUpdate(hash, s->s3.client_random, SSL3_RANDOM_SIZE) <= 0 \|\| EVP_DigestUpdate(hash, s->s3.server_random, SSL3_RANDOM_SIZE) <= 0 \|\| EVP_DigestFinal_ex(hash, dgst_buf, &md_len) <= 0) { EVP_MD_CTX_free(hash); ssl_evp_md_free(md); return 0; } EVP_MD_CTX_free(hash); ssl_evp_md_free(md); return 1; } #endif static int tls_construct_cke_gost18(SSL_CONNECTION s, WPACKET pkt) { #ifndef OPENSSL_NO_GOST / GOST 2018 key exchange message creation / unsigned char rnd_dgst[32]; unsigned char encdata = NULL; EVP_PKEY_CTX pkey_ctx = NULL; EVP_PKEY pkey; unsigned char pms = NULL; size_t pmslen = 0; size_t msglen; int cipher_nid = ossl_gost18_cke_cipher_nid(s); SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); if (cipher_nid == NID_undef) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (ossl_gost_ukm(s, rnd_dgst) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Pre-master secret - random bytes / pmslen = 32; pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (RAND_bytes_ex(sctx->libctx, pms, pmslen, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / Get server certificate PKEY and create ctx from it / if ((pkey = tls_get_peer_pkey(s)) == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER); goto err; } pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pkey, sctx->propq); if (pkey_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; }; / Reuse EVP_PKEY_CTRL_SET_IV, make choice in engine code / if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT, EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT, EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } if (EVP_PKEY_encrypt(pkey_ctx, NULL, &msglen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (!WPACKET_allocate_bytes(pkt, msglen, &encdata) \|\| EVP_PKEY_encrypt(pkey_ctx, encdata, &msglen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } EVP_PKEY_CTX_free(pkey_ctx); pkey_ctx = NULL; s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; return 1; err: EVP_PKEY_CTX_free(pkey_ctx); OPENSSL_clear_free(pms, pmslen); return 0; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_construct_cke_srp(SSL_CONNECTION s, WPACKET pkt) { #ifndef OPENSSL_NO_SRP unsigned char abytes = NULL; if (s->srp_ctx.A == NULL \|\| !WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(s->srp_ctx.A), &abytes)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } BN_bn2bin(s->srp_ctx.A, abytes); OPENSSL_free(s->session->srp_username); s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login); if (s->session->srp_username == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } return 1; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } CON_FUNC_RETURN tls_construct_client_key_exchange(SSL_CONNECTION s, WPACKET pkt) { unsigned long alg_k; alg_k = s->s3.tmp.new_cipher->algorithm_mkey; /* * All of the construct functions below call SSLfatal() if necessary so * no need to do so here. / if ((alg_k & SSL_PSK) && !tls_construct_cke_psk_preamble(s, pkt)) goto err; if (alg_k & (SSL_kRSA \| SSL_kRSAPSK)) { if (!tls_construct_cke_rsa(s, pkt)) goto err; } else if (alg_k & (SSL_kDHE \| SSL_kDHEPSK)) { if (!tls_construct_cke_dhe(s, pkt)) goto err; } else if (alg_k & (SSL_kECDHE \| SSL_kECDHEPSK)) { if (!tls_construct_cke_ecdhe(s, pkt)) goto err; } else if (alg_k & SSL_kGOST) { if (!tls_construct_cke_gost(s, pkt)) goto err; } else if (alg_k & SSL_kGOST18) { if (!tls_construct_cke_gost18(s, pkt)) goto err; } else if (alg_k & SSL_kSRP) { if (!tls_construct_cke_srp(s, pkt)) goto err; } else if (!(alg_k & SSL_kPSK)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } return CON_FUNC_SUCCESS; err: OPENSSL_clear_free(s->s3.tmp.pms, s->s3.tmp.pmslen); s->s3.tmp.pms = NULL; s->s3.tmp.pmslen = 0; #ifndef OPENSSL_NO_PSK OPENSSL_clear_free(s->s3.tmp.psk, s->s3.tmp.psklen); s->s3.tmp.psk = NULL; s->s3.tmp.psklen = 0; #endif return CON_FUNC_ERROR; } int tls_client_key_exchange_post_work(SSL_CONNECTION s) { unsigned char pms = NULL; size_t pmslen = 0; pms = s->s3.tmp.pms; pmslen = s->s3.tmp.pmslen; #ifndef OPENSSL_NO_SRP / Check for SRP / if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) { if (!srp_generate_client_master_secret(s)) { / SSLfatal() already called / goto err; } return 1; } #endif if (pms == NULL && !(s->s3.tmp.new_cipher->algorithm_mkey & SSL_kPSK)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if (!ssl_generate_master_secret(s, pms, pmslen, 1)) { / SSLfatal() already called / / ssl_generate_master_secret frees the pms even on error / pms = NULL; pmslen = 0; goto err; } pms = NULL; pmslen = 0; #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s)) { unsigned char sctpauthkey[64]; char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)]; size_t labellen; SSL ssl = SSL_CONNECTION_GET_SSL(s); /* * Add new shared key for SCTP-Auth, will be ignored if no SCTP * used. / memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL, sizeof(DTLS1_SCTP_AUTH_LABEL)); / Don't include the terminating zero. / labellen = sizeof(labelbuffer) - 1; if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG) labellen += 1; if (SSL_export_keying_material(ssl, sctpauthkey, sizeof(sctpauthkey), labelbuffer, labellen, NULL, 0, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY, sizeof(sctpauthkey), sctpauthkey); } #endif return 1; err: OPENSSL_clear_free(pms, pmslen); s->s3.tmp.pms = NULL; s->s3.tmp.pmslen = 0; return 0; } / * Check a certificate can be used for client authentication. Currently check * cert exists, if we have a suitable digest for TLS 1.2 if static DH client * certificates can be used and optionally checks suitability for Suite B. / static int ssl3_check_client_certificate(SSL_CONNECTION s) { /* If no suitable signature algorithm can't use certificate / if (!tls_choose_sigalg(s, 0) \|\| s->s3.tmp.sigalg == NULL) return 0; / * If strict mode check suitability of chain before using it. This also * adjusts suite B digest if necessary. / if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT && !tls1_check_chain(s, NULL, NULL, NULL, -2)) return 0; return 1; } WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION s, WORK_STATE wst) { X509 x509 = NULL; EVP_PKEY pkey = NULL; int i; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (wst == WORK_MORE_A) { / Let cert callback update client certificates if required / if (s->cert->cert_cb) { i = s->cert->cert_cb(ssl, s->cert->cert_cb_arg); if (i < 0) { s->rwstate = SSL_X509_LOOKUP; return WORK_MORE_A; } if (i == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED); return WORK_ERROR; } s->rwstate = SSL_NOTHING; } if (ssl3_check_client_certificate(s)) { if (s->post_handshake_auth == SSL_PHA_REQUESTED) { return WORK_FINISHED_STOP; } return WORK_FINISHED_CONTINUE; } / Fall through to WORK_MORE_B / wst = WORK_MORE_B; } / We need to get a client cert / if (wst == WORK_MORE_B) { / * If we get an error, we need to ssl->rwstate=SSL_X509_LOOKUP; * return(-1); We then get retied later / i = ssl_do_client_cert_cb(s, &x509, &pkey); if (i < 0) { s->rwstate = SSL_X509_LOOKUP; return WORK_MORE_B; } s->rwstate = SSL_NOTHING; if ((i == 1) && (pkey != NULL) && (x509 != NULL)) { if (!SSL_use_certificate(ssl, x509) \|\| !SSL_use_PrivateKey(ssl, pkey)) i = 0; } else if (i == 1) { i = 0; ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA_RETURNED_BY_CALLBACK); } X509_free(x509); EVP_PKEY_free(pkey); if (i && !ssl3_check_client_certificate(s)) i = 0; if (i == 0) { if (s->version == SSL3_VERSION) { s->s3.tmp.cert_req = 0; ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_CERTIFICATE); return WORK_FINISHED_CONTINUE; } else { s->s3.tmp.cert_req = 2; s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none; if (!ssl3_digest_cached_records(s, 0)) { / SSLfatal() already called / return WORK_ERROR; } } } if (!SSL_CONNECTION_IS_TLS13(s) \|\| (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0) s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none; if (s->post_handshake_auth == SSL_PHA_REQUESTED) return WORK_FINISHED_STOP; return WORK_FINISHED_CONTINUE; } / Shouldn't ever get here / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION s, WPACKET pkt) { CERT_PKEY cpk = NULL; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (SSL_CONNECTION_IS_TLS13(s)) { if (s->pha_context == NULL) { / no context available, add 0-length context / if (!WPACKET_put_bytes_u8(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } else if (!WPACKET_sub_memcpy_u8(pkt, s->pha_context, s->pha_context_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } if (s->s3.tmp.cert_req != 2) cpk = s->cert->key; switch (s->ext.client_cert_type) { case TLSEXT_cert_type_rpk: if (!tls_output_rpk(s, pkt, cpk)) { / SSLfatal() already called / return CON_FUNC_ERROR; } break; case TLSEXT_cert_type_x509: if (!ssl3_output_cert_chain(s, pkt, cpk, 0)) { / SSLfatal() already called / return CON_FUNC_ERROR; } break; default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } / * If we attempted to write early data or we're in middlebox compat mode * then we deferred changing the handshake write keys to the last possible * moment. We need to do it now. / if (SSL_CONNECTION_IS_TLS13(s) && SSL_IS_FIRST_HANDSHAKE(s) && (s->early_data_state != SSL_EARLY_DATA_NONE \|\| (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) && (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE \| SSL3_CHANGE_CIPHER_CLIENT_WRITE))) { / * This is a fatal error, which leaves enc_write_ctx in an inconsistent * state and thus ssl3_send_alert may crash. / SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_CANNOT_CHANGE_CIPHER); return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } #ifndef OPENSSL_NO_COMP_ALG CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION sc, WPACKET pkt) { SSL ssl = SSL_CONNECTION_GET_SSL(sc); WPACKET tmppkt; BUF_MEM buf = NULL; size_t length; size_t max_length; COMP_METHOD method; COMP_CTX comp = NULL; int comp_len; int ret = 0; int alg = sc->ext.compress_certificate_from_peer[0]; / Note that sc->s3.tmp.cert_req == 2 is checked in write transition / if ((buf = BUF_MEM_new()) == NULL \|\| !WPACKET_init(&tmppkt, buf)) goto err; / Use the \|tmppkt\| for the to-be-compressed data / if (sc->pha_context == NULL) { / no context available, add 0-length context / if (!WPACKET_put_bytes_u8(&tmppkt, 0)) goto err; } else if (!WPACKET_sub_memcpy_u8(&tmppkt, sc->pha_context, sc->pha_context_len)) goto err; if (!ssl3_output_cert_chain(sc, &tmppkt, sc->cert->key, 0)) { / SSLfatal() already called / goto out; } / continue with the real \|pkt\| / if (!WPACKET_put_bytes_u16(pkt, alg) \|\| !WPACKET_get_total_written(&tmppkt, &length) \|\| !WPACKET_put_bytes_u24(pkt, length)) goto err; switch (alg) { case TLSEXT_comp_cert_zlib: method = COMP_zlib_oneshot(); break; case TLSEXT_comp_cert_brotli: method = COMP_brotli_oneshot(); break; case TLSEXT_comp_cert_zstd: method = COMP_zstd_oneshot(); break; default: goto err; } max_length = ossl_calculate_comp_expansion(alg, length); if ((comp = COMP_CTX_new(method)) == NULL \|\| !WPACKET_start_sub_packet_u24(pkt) \|\| !WPACKET_reserve_bytes(pkt, max_length, NULL)) goto err; comp_len = COMP_compress_block(comp, WPACKET_get_curr(pkt), max_length, (unsigned char )buf->data, length); if (comp_len <= 0) goto err; if (!WPACKET_allocate_bytes(pkt, comp_len, NULL) \|\| !WPACKET_close(pkt)) goto err; /* * If we attempted to write early data or we're in middlebox compat mode * then we deferred changing the handshake write keys to the last possible * moment. We need to do it now. / if (SSL_IS_FIRST_HANDSHAKE(sc) && (sc->early_data_state != SSL_EARLY_DATA_NONE \|\| (sc->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) && (!ssl->method->ssl3_enc->change_cipher_state(sc, SSL3_CC_HANDSHAKE \| SSL3_CHANGE_CIPHER_CLIENT_WRITE))) { / * This is a fatal error, which leaves sc->enc_write_ctx in an * inconsistent state and thus ssl3_send_alert may crash. / SSLfatal(sc, SSL_AD_NO_ALERT, SSL_R_CANNOT_CHANGE_CIPHER); goto out; } ret = 1; goto out; err: SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); out: if (buf != NULL) { / If \|buf\| is NULL, then \|tmppkt\| could not have been initialized / WPACKET_cleanup(&tmppkt); } BUF_MEM_free(buf); COMP_CTX_free(comp); return ret; } #endif int ssl3_check_cert_and_algorithm(SSL_CONNECTION s) { const SSL_CERT_LOOKUP clu; size_t idx; long alg_k, alg_a; EVP_PKEY pkey; alg_k = s->s3.tmp.new_cipher->algorithm_mkey; alg_a = s->s3.tmp.new_cipher->algorithm_auth; /* we don't have a certificate / if (!(alg_a & SSL_aCERT)) return 1; / This is the passed certificate / pkey = tls_get_peer_pkey(s); clu = ssl_cert_lookup_by_pkey(pkey, &idx, SSL_CONNECTION_GET_CTX(s)); / Check certificate is recognised and suitable for cipher / if (clu == NULL \|\| (alg_a & clu->amask) == 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_MISSING_SIGNING_CERT); return 0; } if (alg_k & (SSL_kRSA \| SSL_kRSAPSK) && idx != SSL_PKEY_RSA) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_MISSING_RSA_ENCRYPTING_CERT); return 0; } if ((alg_k & SSL_kDHE) && (s->s3.peer_tmp == NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / Early out to skip the checks below / if (s->session->peer_rpk != NULL) return 1; if (clu->amask & SSL_aECDSA) { if (ssl_check_srvr_ecc_cert_and_alg(s->session->peer, s)) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_ECC_CERT); return 0; } return 1; } #ifndef OPENSSL_NO_NEXTPROTONEG CON_FUNC_RETURN tls_construct_next_proto(SSL_CONNECTION s, WPACKET pkt) { size_t len, padding_len; unsigned char padding = NULL; len = s->ext.npn_len; padding_len = 32 - ((len + 2) % 32); if (!WPACKET_sub_memcpy_u8(pkt, s->ext.npn, len) \|\| !WPACKET_sub_allocate_bytes_u8(pkt, padding_len, &padding)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } memset(padding, 0, padding_len); return CON_FUNC_SUCCESS; } #endif MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION s, PACKET pkt) { SSL ssl = SSL_CONNECTION_GET_SSL(s); if (PACKET_remaining(pkt) > 0) { / should contain no data / SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if ((s->options & SSL_OP_NO_RENEGOTIATION)) { ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION); return MSG_PROCESS_FINISHED_READING; } / * This is a historical discrepancy (not in the RFC) maintained for * compatibility reasons. If a TLS client receives a HelloRequest it will * attempt an abbreviated handshake. However if a DTLS client receives a * HelloRequest it will do a full handshake. Either behaviour is reasonable * but doing one for TLS and another for DTLS is odd. / if (SSL_CONNECTION_IS_DTLS(s)) SSL_renegotiate(ssl); else SSL_renegotiate_abbreviated(ssl); return MSG_PROCESS_FINISHED_READING; } static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION s, PACKET pkt) { PACKET extensions; RAW_EXTENSION rawexts = NULL; if (!PACKET_as_length_prefixed_2(pkt, &extensions) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!tls_collect_extensions(s, &extensions, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, &rawexts, NULL, 1) \|\| !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, rawexts, NULL, 0, 1)) { /* SSLfatal() already called / goto err; } OPENSSL_free(rawexts); return MSG_PROCESS_CONTINUE_READING; err: OPENSSL_free(rawexts); return MSG_PROCESS_ERROR; } int ssl_do_client_cert_cb(SSL_CONNECTION s, X509 px509, EVP_PKEY ppkey) { int i = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); #ifndef OPENSSL_NO_ENGINE if (sctx->client_cert_engine) { i = tls_engine_load_ssl_client_cert(s, px509, ppkey); if (i != 0) return i; } #endif if (sctx->client_cert_cb) i = sctx->client_cert_cb(SSL_CONNECTION_GET_SSL(s), px509, ppkey); return i; } int ssl_cipher_list_to_bytes(SSL_CONNECTION s, STACK_OF(SSL_CIPHER) sk, WPACKET pkt) { int i; size_t totlen = 0, len, maxlen, maxverok = 0; int empty_reneg_info_scsv = !s->renegotiate && (SSL_CONNECTION_IS_DTLS(s) \|\| s->min_proto_version < TLS1_3_VERSION); SSL ssl = SSL_CONNECTION_GET_SSL(s); / Set disabled masks for this session / if (!ssl_set_client_disabled(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_PROTOCOLS_AVAILABLE); return 0; } if (sk == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH # if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6 # error Max cipher length too short # endif / * Some servers hang if client hello > 256 bytes as hack workaround * chop number of supported ciphers to keep it well below this if we * use TLS v1.2 / if (TLS1_get_version(ssl) >= TLS1_2_VERSION) maxlen = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1; else #endif / Maximum length that can be stored in 2 bytes. Length must be even / maxlen = 0xfffe; if (empty_reneg_info_scsv) maxlen -= 2; if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) maxlen -= 2; for (i = 0; i < sk_SSL_CIPHER_num(sk) && totlen < maxlen; i++) { const SSL_CIPHER c; c = sk_SSL_CIPHER_value(sk, i); /* Skip disabled ciphers / if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) continue; if (!ssl->method->put_cipher_by_char(c, pkt, &len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / Sanity check that the maximum version we offer has ciphers enabled / if (!maxverok) { int minproto = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls; int maxproto = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls; if (ssl_version_cmp(s, maxproto, s->s3.tmp.max_ver) >= 0 && ssl_version_cmp(s, minproto, s->s3.tmp.max_ver) <= 0) maxverok = 1; } totlen += len; } if (totlen == 0 \|\| !maxverok) { const char maxvertext = !maxverok ? "No ciphers enabled for max supported SSL/TLS version" : NULL; SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_CIPHERS_AVAILABLE, maxvertext); return 0; } if (totlen != 0) { if (empty_reneg_info_scsv) { static const SSL_CIPHER scsv = { 0, NULL, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) { static const SSL_CIPHER scsv = { 0, NULL, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } return 1; } CON_FUNC_RETURN tls_construct_end_of_early_data(SSL_CONNECTION s, WPACKET pkt) { if (s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return CON_FUNC_ERROR; } s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING; return CON_FUNC_SUCCESS; }
./openssl/ssl/statem/extensions_clnt.c	/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/ocsp.h> #include "../ssl_local.h" #include "internal/cryptlib.h" #include "statem_local.h" EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { /* Add RI if renegotiating / if (!s->renegotiate) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_sub_memcpy_u8(pkt, s->s3.previous_client_finished, s->s3.previous_client_finished_len) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->ext.hostname == NULL) return EXT_RETURN_NOT_SENT; /* Add TLS extension servername to the Client Hello message / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name) / Sub-packet for server_name extension / \|\| !WPACKET_start_sub_packet_u16(pkt) / Sub-packet for servername list (always 1 hostname)/ \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name) \|\| !WPACKET_sub_memcpy_u16(pkt, s->ext.hostname, strlen(s->ext.hostname)) \|\| !WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } / Push a Max Fragment Len extension into ClientHello / EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->ext.max_fragment_len_mode == TLSEXT_max_fragment_length_DISABLED) return EXT_RETURN_NOT_SENT; /* Add Max Fragment Length extension if client enabled it. / /- * 4 bytes for this extension type and extension length * 1 byte for the Max Fragment Length code value. / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length) / Sub-packet for Max Fragment Length extension (1 byte) / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u8(pkt, s->ext.max_fragment_len_mode) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_SRP EXT_RETURN tls_construct_ctos_srp(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { /* Add SRP username if there is one / if (s->srp_ctx.login == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp) / Sub-packet for SRP extension / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u8(pkt) / login must not be zero...internal error if so / \|\| !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH) \|\| !WPACKET_memcpy(pkt, s->srp_ctx.login, strlen(s->srp_ctx.login)) \|\| !WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif static int use_ecc(SSL_CONNECTION s, int min_version, int max_version) { int i, end, ret = 0; unsigned long alg_k, alg_a; STACK_OF(SSL_CIPHER) cipher_stack = NULL; const uint16_t pgroups = NULL; size_t num_groups, j; SSL ssl = SSL_CONNECTION_GET_SSL(s); / See if we support any ECC ciphersuites / if (s->version == SSL3_VERSION) return 0; cipher_stack = SSL_get1_supported_ciphers(ssl); end = sk_SSL_CIPHER_num(cipher_stack); for (i = 0; i < end; i++) { const SSL_CIPHER c = sk_SSL_CIPHER_value(cipher_stack, i); alg_k = c->algorithm_mkey; alg_a = c->algorithm_auth; if ((alg_k & (SSL_kECDHE \| SSL_kECDHEPSK)) \|\| (alg_a & SSL_aECDSA) \|\| c->min_tls >= TLS1_3_VERSION) { ret = 1; break; } } sk_SSL_CIPHER_free(cipher_stack); if (!ret) return 0; /* Check we have at least one EC supported group / tls1_get_supported_groups(s, &pgroups, &num_groups); for (j = 0; j < num_groups; j++) { uint16_t ctmp = pgroups[j]; if (tls_valid_group(s, ctmp, min_version, max_version, 1, NULL) && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) return 1; } return 0; } EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { const unsigned char pformats; size_t num_formats; int reason, min_version, max_version; reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); if (reason != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); return EXT_RETURN_FAIL; } if (!use_ecc(s, min_version, max_version)) return EXT_RETURN_NOT_SENT; / Add TLS extension ECPointFormats to the ClientHello message / tls1_get_formatlist(s, &pformats, &num_formats); if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats) / Sub-packet for formats extension / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { const uint16_t pgroups = NULL; size_t num_groups = 0, i, tls13added = 0, added = 0; int min_version, max_version, reason; reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); if (reason != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); return EXT_RETURN_FAIL; } / * We only support EC groups in TLSv1.2 or below, and in DTLS. Therefore * if we don't have EC support then we don't send this extension. / if (!use_ecc(s, min_version, max_version) && (SSL_CONNECTION_IS_DTLS(s) \|\| max_version < TLS1_3_VERSION)) return EXT_RETURN_NOT_SENT; / * Add TLS extension supported_groups to the ClientHello message / tls1_get_supported_groups(s, &pgroups, &num_groups); if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups) / Sub-packet for supported_groups extension / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } / Copy group ID if supported / for (i = 0; i < num_groups; i++) { uint16_t ctmp = pgroups[i]; int okfortls13; if (tls_valid_group(s, ctmp, min_version, max_version, 0, &okfortls13) && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) { if (!WPACKET_put_bytes_u16(pkt, ctmp)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (okfortls13 && max_version == TLS1_3_VERSION) tls13added++; added++; } } if (!WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { if (added == 0) SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_GROUPS, "No groups enabled for max supported SSL/TLS version"); else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (tls13added == 0 && max_version == TLS1_3_VERSION) { SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_GROUPS, "No groups enabled for max supported SSL/TLS version"); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { size_t ticklen; if (!tls_use_ticket(s)) return EXT_RETURN_NOT_SENT; if (!s->new_session && s->session != NULL && s->session->ext.tick != NULL && s->session->ssl_version != TLS1_3_VERSION) { ticklen = s->session->ext.ticklen; } else if (s->session && s->ext.session_ticket != NULL && s->ext.session_ticket->data != NULL) { ticklen = s->ext.session_ticket->length; s->session->ext.tick = OPENSSL_malloc(ticklen); if (s->session->ext.tick == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } memcpy(s->session->ext.tick, s->ext.session_ticket->data, ticklen); s->session->ext.ticklen = ticklen; } else { ticklen = 0; } if (ticklen == 0 && s->ext.session_ticket != NULL && s->ext.session_ticket->data == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket) \|\| !WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, ticklen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { size_t salglen; const uint16_t salg; if (!SSL_CLIENT_USE_SIGALGS(s)) return EXT_RETURN_NOT_SENT; salglen = tls12_get_psigalgs(s, 1, &salg); if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms) /* Sub-packet for sig-algs extension / \|\| !WPACKET_start_sub_packet_u16(pkt) / Sub-packet for the actual list / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !tls12_copy_sigalgs(s, pkt, salg, salglen) \|\| !WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_OCSP EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { int i; /* This extension isn't defined for client Certificates / if (x != NULL) return EXT_RETURN_NOT_SENT; if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request) / Sub-packet for status request extension / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp) / Sub-packet for the ids / \|\| !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } for (i = 0; i < sk_OCSP_RESPID_num(s->ext.ocsp.ids); i++) { unsigned char idbytes; OCSP_RESPID id = sk_OCSP_RESPID_value(s->ext.ocsp.ids, i); int idlen = i2d_OCSP_RESPID(id, NULL); if (idlen <= 0 / Sub-packet for an individual id / \|\| !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes) \|\| i2d_OCSP_RESPID(id, &idbytes) != idlen) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (!WPACKET_close(pkt) \|\| !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (s->ext.ocsp.exts) { unsigned char extbytes; int extlen = i2d_X509_EXTENSIONS(s->ext.ocsp.exts, NULL); if (extlen < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes) \|\| i2d_X509_EXTENSIONS(s->ext.ocsp.exts, &extbytes) != extlen) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (!WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (SSL_CONNECTION_GET_CTX(s)->ext.npn_select_cb == NULL \|\| !SSL_IS_FIRST_HANDSHAKE(s)) return EXT_RETURN_NOT_SENT; / * The client advertises an empty extension to indicate its support * for Next Protocol Negotiation / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { s->s3.alpn_sent = 0; if (s->ext.alpn == NULL \|\| !SSL_IS_FIRST_HANDSHAKE(s)) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_application_layer_protocol_negotiation) /* Sub-packet ALPN extension / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_sub_memcpy_u16(pkt, s->ext.alpn, s->ext.alpn_len) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->s3.alpn_sent = 1; return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_SRTP EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { SSL ssl = SSL_CONNECTION_GET_SSL(s); STACK_OF(SRTP_PROTECTION_PROFILE) clnt = SSL_get_srtp_profiles(ssl); int i, end; if (clnt == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp) /* Sub-packet for SRTP extension / \|\| !WPACKET_start_sub_packet_u16(pkt) / Sub-packet for the protection profile list / \|\| !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } end = sk_SRTP_PROTECTION_PROFILE_num(clnt); for (i = 0; i < end; i++) { const SRTP_PROTECTION_PROFILE prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i); if (prof == NULL \|\| !WPACKET_put_bytes_u16(pkt, prof->id)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (!WPACKET_close(pkt) /* Add an empty use_mki value / \|\| !WPACKET_put_bytes_u8(pkt, 0) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_CT EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->ct_validation_callback == NULL) return EXT_RETURN_NOT_SENT; / Not defined for client Certificates / if (x != NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret) \|\| !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { int currv, min_version, max_version, reason; reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); if (reason != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); return EXT_RETURN_FAIL; } / * Don't include this if we can't negotiate TLSv1.3. We can do a straight * comparison here because we will never be called in DTLS. / if (max_version < TLS1_3_VERSION) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u8(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } for (currv = max_version; currv >= min_version; currv--) { if (!WPACKET_put_bytes_u16(pkt, currv)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (!WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } / * Construct a psk_kex_modes extension. / EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 int nodhe = s->options & SSL_OP_ALLOW_NO_DHE_KEX; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk_kex_modes) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u8(pkt) \|\| !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE_DHE) \|\| (nodhe && !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE)) \|\| !WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_KE_DHE; if (nodhe) s->ext.psk_kex_mode \|= TLSEXT_KEX_MODE_FLAG_KE; #endif return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_TLS1_3 static int add_key_share(SSL_CONNECTION s, WPACKET pkt, unsigned int curve_id) { unsigned char encoded_point = NULL; EVP_PKEY key_share_key = NULL; size_t encodedlen; if (s->s3.tmp.pkey != NULL) { if (!ossl_assert(s->hello_retry_request == SSL_HRR_PENDING)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * Could happen if we got an HRR that wasn't requesting a new key_share / key_share_key = s->s3.tmp.pkey; } else { key_share_key = ssl_generate_pkey_group(s, curve_id); if (key_share_key == NULL) { / SSLfatal() already called / return 0; } } / Encode the public key. / encodedlen = EVP_PKEY_get1_encoded_public_key(key_share_key, &encoded_point); if (encodedlen == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); goto err; } / Create KeyShareEntry / if (!WPACKET_put_bytes_u16(pkt, curve_id) \|\| !WPACKET_sub_memcpy_u16(pkt, encoded_point, encodedlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } / * When changing to send more than one key_share we're * going to need to be able to save more than one EVP_PKEY. For now * we reuse the existing tmp.pkey / s->s3.tmp.pkey = key_share_key; s->s3.group_id = curve_id; OPENSSL_free(encoded_point); return 1; err: if (s->s3.tmp.pkey == NULL) EVP_PKEY_free(key_share_key); OPENSSL_free(encoded_point); return 0; } #endif EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 size_t i, num_groups = 0; const uint16_t pgroups = NULL; uint16_t curve_id = 0; / key_share extension / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share) / Extension data sub-packet / \|\| !WPACKET_start_sub_packet_u16(pkt) / KeyShare list sub-packet / \|\| !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } tls1_get_supported_groups(s, &pgroups, &num_groups); / * Make the number of key_shares sent configurable. For * now, we just send one / if (s->s3.group_id != 0) { curve_id = s->s3.group_id; } else { for (i = 0; i < num_groups; i++) { if (!tls_group_allowed(s, pgroups[i], SSL_SECOP_CURVE_SUPPORTED)) continue; if (!tls_valid_group(s, pgroups[i], TLS1_3_VERSION, TLS1_3_VERSION, 0, NULL)) continue; curve_id = pgroups[i]; break; } } if (curve_id == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_KEY_SHARE); return EXT_RETURN_FAIL; } if (!add_key_share(s, pkt, curve_id)) { / SSLfatal() already called / return EXT_RETURN_FAIL; } if (!WPACKET_close(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; #else return EXT_RETURN_NOT_SENT; #endif } EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { EXT_RETURN ret = EXT_RETURN_FAIL; /* Should only be set if we've had an HRR / if (s->ext.tls13_cookie_len == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie) / Extension data sub-packet / \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_sub_memcpy_u16(pkt, s->ext.tls13_cookie, s->ext.tls13_cookie_len) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto end; } ret = EXT_RETURN_SENT; end: OPENSSL_free(s->ext.tls13_cookie); s->ext.tls13_cookie = NULL; s->ext.tls13_cookie_len = 0; return ret; } EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_PSK char identity[PSK_MAX_IDENTITY_LEN + 1]; #endif /* OPENSSL_NO_PSK / const unsigned char id = NULL; size_t idlen = 0; SSL_SESSION psksess = NULL; SSL_SESSION edsess = NULL; const EVP_MD handmd = NULL; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->hello_retry_request == SSL_HRR_PENDING) handmd = ssl_handshake_md(s); if (s->psk_use_session_cb != NULL && (!s->psk_use_session_cb(ssl, handmd, &id, &idlen, &psksess) \|\| (psksess != NULL && psksess->ssl_version != TLS1_3_VERSION))) { SSL_SESSION_free(psksess); SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); return EXT_RETURN_FAIL; } #ifndef OPENSSL_NO_PSK if (psksess == NULL && s->psk_client_callback != NULL) { unsigned char psk[PSK_MAX_PSK_LEN]; size_t psklen = 0; memset(identity, 0, sizeof(identity)); psklen = s->psk_client_callback(ssl, NULL, identity, sizeof(identity) - 1, psk, sizeof(psk)); if (psklen > PSK_MAX_PSK_LEN) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } else if (psklen > 0) { const unsigned char tls13_aes128gcmsha256_id[] = { 0x13, 0x01 }; const SSL_CIPHER cipher; idlen = strlen(identity); if (idlen > PSK_MAX_IDENTITY_LEN) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } id = (unsigned char )identity; /* * We found a PSK using an old style callback. We don't know * the digest so we default to SHA256 as per the TLSv1.3 spec / cipher = SSL_CIPHER_find(ssl, tls13_aes128gcmsha256_id); if (cipher == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } psksess = SSL_SESSION_new(); if (psksess == NULL \|\| !SSL_SESSION_set1_master_key(psksess, psk, psklen) \|\| !SSL_SESSION_set_cipher(psksess, cipher) \|\| !SSL_SESSION_set_protocol_version(psksess, TLS1_3_VERSION)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); OPENSSL_cleanse(psk, psklen); return EXT_RETURN_FAIL; } OPENSSL_cleanse(psk, psklen); } } #endif / OPENSSL_NO_PSK / SSL_SESSION_free(s->psksession); s->psksession = psksess; if (psksess != NULL) { OPENSSL_free(s->psksession_id); s->psksession_id = OPENSSL_memdup(id, idlen); if (s->psksession_id == NULL) { s->psksession_id_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->psksession_id_len = idlen; } if (s->early_data_state != SSL_EARLY_DATA_CONNECTING \|\| (s->session->ext.max_early_data == 0 && (psksess == NULL \|\| psksess->ext.max_early_data == 0))) { s->max_early_data = 0; return EXT_RETURN_NOT_SENT; } edsess = s->session->ext.max_early_data != 0 ? s->session : psksess; s->max_early_data = edsess->ext.max_early_data; if (edsess->ext.hostname != NULL) { if (s->ext.hostname == NULL \|\| (s->ext.hostname != NULL && strcmp(s->ext.hostname, edsess->ext.hostname) != 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_INCONSISTENT_EARLY_DATA_SNI); return EXT_RETURN_FAIL; } } if ((s->ext.alpn == NULL && edsess->ext.alpn_selected != NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_INCONSISTENT_EARLY_DATA_ALPN); return EXT_RETURN_FAIL; } / * Verify that we are offering an ALPN protocol consistent with the early * data. / if (edsess->ext.alpn_selected != NULL) { PACKET prots, alpnpkt; int found = 0; if (!PACKET_buf_init(&prots, s->ext.alpn, s->ext.alpn_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } while (PACKET_get_length_prefixed_1(&prots, &alpnpkt)) { if (PACKET_equal(&alpnpkt, edsess->ext.alpn_selected, edsess->ext.alpn_selected_len)) { found = 1; break; } } if (!found) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_INCONSISTENT_EARLY_DATA_ALPN); return EXT_RETURN_FAIL; } } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } / * We set this to rejected here. Later, if the server acknowledges the * extension, we set it to accepted. / s->ext.early_data = SSL_EARLY_DATA_REJECTED; s->ext.early_data_ok = 1; return EXT_RETURN_SENT; } #define F5_WORKAROUND_MIN_MSG_LEN 0xff #define F5_WORKAROUND_MAX_MSG_LEN 0x200 / * PSK pre binder overhead = * 2 bytes for TLSEXT_TYPE_psk * 2 bytes for extension length * 2 bytes for identities list length * 2 bytes for identity length * 4 bytes for obfuscated_ticket_age * 2 bytes for binder list length * 1 byte for binder length * The above excludes the number of bytes for the identity itself and the * subsequent binder bytes / #define PSK_PRE_BINDER_OVERHEAD (2 + 2 + 2 + 2 + 4 + 2 + 1) EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned char padbytes; size_t hlen; if ((s->options & SSL_OP_TLSEXT_PADDING) == 0) return EXT_RETURN_NOT_SENT; / * Add padding to workaround bugs in F5 terminators. See RFC7685. * This code calculates the length of all extensions added so far but * excludes the PSK extension (because that MUST be written last). Therefore * this extension MUST always appear second to last. / if (!WPACKET_get_total_written(pkt, &hlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } / * If we're going to send a PSK then that will be written out after this * extension, so we need to calculate how long it is going to be. / if (s->session->ssl_version == TLS1_3_VERSION && s->session->ext.ticklen != 0 && s->session->cipher != NULL) { const EVP_MD md = ssl_md(SSL_CONNECTION_GET_CTX(s), s->session->cipher->algorithm2); if (md != NULL) { /* * Add the fixed PSK overhead, the identity length and the binder * length. / hlen += PSK_PRE_BINDER_OVERHEAD + s->session->ext.ticklen + EVP_MD_get_size(md); } } if (hlen > F5_WORKAROUND_MIN_MSG_LEN && hlen < F5_WORKAROUND_MAX_MSG_LEN) { / Calculate the amount of padding we need to add / hlen = F5_WORKAROUND_MAX_MSG_LEN - hlen; / * Take off the size of extension header itself (2 bytes for type and * 2 bytes for length bytes), but ensure that the extension is at least * 1 byte long so as not to have an empty extension last (WebSphere 7.x, * 8.x are intolerant of that condition) / if (hlen > 4) hlen -= 4; else hlen = 1; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding) \|\| !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } memset(padbytes, 0, hlen); } return EXT_RETURN_SENT; } / * Construct the pre_shared_key extension / EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION s, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 uint32_t agesec, agems = 0; size_t reshashsize = 0, pskhashsize = 0, binderoffset, msglen; unsigned char resbinder = NULL, pskbinder = NULL, msgstart = NULL; const EVP_MD handmd = NULL, mdres = NULL, mdpsk = NULL; int dores = 0; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); OSSL_TIME t; s->ext.tick_identity = 0; / * Note: At this stage of the code we only support adding a single * resumption PSK. If we add support for multiple PSKs then the length * calculations in the padding extension will need to be adjusted. / / * If this is an incompatible or new session then we have nothing to resume * so don't add this extension. / if (s->session->ssl_version != TLS1_3_VERSION \|\| (s->session->ext.ticklen == 0 && s->psksession == NULL)) return EXT_RETURN_NOT_SENT; if (s->hello_retry_request == SSL_HRR_PENDING) handmd = ssl_handshake_md(s); if (s->session->ext.ticklen != 0) { / Get the digest associated with the ciphersuite in the session / if (s->session->cipher == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } mdres = ssl_md(sctx, s->session->cipher->algorithm2); if (mdres == NULL) { / * Don't recognize this cipher so we can't use the session. * Ignore it / goto dopsksess; } if (s->hello_retry_request == SSL_HRR_PENDING && mdres != handmd) { / * Selected ciphersuite hash does not match the hash for the session * so we can't use it. / goto dopsksess; } / * Technically the C standard just says time() returns a time_t and says * nothing about the encoding of that type. In practice most * implementations follow POSIX which holds it as an integral type in * seconds since epoch. We've already made the assumption that we can do * this in multiple places in the code, so portability shouldn't be an * issue. / t = ossl_time_subtract(ossl_time_now(), s->session->time); agesec = (uint32_t)ossl_time2seconds(t); / * We calculate the age in seconds but the server may work in ms. Due to * rounding errors we could overestimate the age by up to 1s. It is * better to underestimate it. Otherwise, if the RTT is very short, when * the server calculates the age reported by the client it could be * bigger than the age calculated on the server - which should never * happen. / if (agesec > 0) agesec--; if (s->session->ext.tick_lifetime_hint < agesec) { / Ticket is too old. Ignore it. / goto dopsksess; } / * Calculate age in ms. We're just doing it to nearest second. Should be * good enough. / agems = agesec (uint32_t)1000; if (agesec != 0 && agems / (uint32_t)1000 != agesec) { /* * Overflow. Shouldn't happen unless this is a really old session. * If so we just ignore it. / goto dopsksess; } / * Obfuscate the age. Overflow here is fine, this addition is supposed * to be mod 2^32. / agems += s->session->ext.tick_age_add; reshashsize = EVP_MD_get_size(mdres); s->ext.tick_identity++; dores = 1; } dopsksess: if (!dores && s->psksession == NULL) return EXT_RETURN_NOT_SENT; if (s->psksession != NULL) { mdpsk = ssl_md(sctx, s->psksession->cipher->algorithm2); if (mdpsk == NULL) { / * Don't recognize this cipher so we can't use the session. * If this happens it's an application bug. / SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); return EXT_RETURN_FAIL; } if (s->hello_retry_request == SSL_HRR_PENDING && mdpsk != handmd) { / * Selected ciphersuite hash does not match the hash for the PSK * session. This is an application bug. / SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); return EXT_RETURN_FAIL; } pskhashsize = EVP_MD_get_size(mdpsk); } / Create the extension, but skip over the binder for now / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (dores) { if (!WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, s->session->ext.ticklen) \|\| !WPACKET_put_bytes_u32(pkt, agems)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (s->psksession != NULL) { if (!WPACKET_sub_memcpy_u16(pkt, s->psksession_id, s->psksession_id_len) \|\| !WPACKET_put_bytes_u32(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->ext.tick_identity++; } if (!WPACKET_close(pkt) \|\| !WPACKET_get_total_written(pkt, &binderoffset) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| (dores && !WPACKET_sub_allocate_bytes_u8(pkt, reshashsize, &resbinder)) \|\| (s->psksession != NULL && !WPACKET_sub_allocate_bytes_u8(pkt, pskhashsize, &pskbinder)) \|\| !WPACKET_close(pkt) \|\| !WPACKET_close(pkt) \|\| !WPACKET_get_total_written(pkt, &msglen) / * We need to fill in all the sub-packet lengths now so we can * calculate the HMAC of the message up to the binders / \|\| !WPACKET_fill_lengths(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } msgstart = WPACKET_get_curr(pkt) - msglen; if (dores && tls_psk_do_binder(s, mdres, msgstart, binderoffset, NULL, resbinder, s->session, 1, 0) != 1) { / SSLfatal() already called / return EXT_RETURN_FAIL; } if (s->psksession != NULL && tls_psk_do_binder(s, mdpsk, msgstart, binderoffset, NULL, pskbinder, s->psksession, 1, 1) != 1) { / SSLfatal() already called / return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; #else return EXT_RETURN_NOT_SENT; #endif } EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION s, WPACKET pkt, ossl_unused unsigned int context, ossl_unused X509 x, ossl_unused size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 if (!s->pha_enabled) return EXT_RETURN_NOT_SENT; /* construct extension - 0 length, no contents / if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_post_handshake_auth) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->post_handshake_auth = SSL_PHA_EXT_SENT; return EXT_RETURN_SENT; #else return EXT_RETURN_NOT_SENT; #endif } / * Parse the server's renegotiation binding and abort if it's not right / int tls_parse_stoc_renegotiate(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { size_t expected_len = s->s3.previous_client_finished_len + s->s3.previous_server_finished_len; size_t ilen; const unsigned char data; / Check for logic errors / if (!ossl_assert(expected_len == 0 \|\| s->s3.previous_client_finished_len != 0) \|\| !ossl_assert(expected_len == 0 \|\| s->s3.previous_server_finished_len != 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / Parse the length byte / if (!PACKET_get_1_len(pkt, &ilen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RENEGOTIATION_ENCODING_ERR); return 0; } / Consistency check / if (PACKET_remaining(pkt) != ilen) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RENEGOTIATION_ENCODING_ERR); return 0; } / Check that the extension matches / if (ilen != expected_len) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); return 0; } if (!PACKET_get_bytes(pkt, &data, s->s3.previous_client_finished_len) \|\| memcmp(data, s->s3.previous_client_finished, s->s3.previous_client_finished_len) != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); return 0; } if (!PACKET_get_bytes(pkt, &data, s->s3.previous_server_finished_len) \|\| memcmp(data, s->s3.previous_server_finished, s->s3.previous_server_finished_len) != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); return 0; } s->s3.send_connection_binding = 1; return 1; } / Parse the server's max fragment len extension packet / int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned int value; if (PACKET_remaining(pkt) != 1 \|\| !PACKET_get_1(pkt, &value)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* \|value\| should contains a valid max-fragment-length code. / if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } / Must be the same value as client-configured one who was sent to server / /- * RFC 6066: if a client receives a maximum fragment length negotiation * response that differs from the length it requested, ... * It must abort with SSL_AD_ILLEGAL_PARAMETER alert / if (value != s->ext.max_fragment_len_mode) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } / * Maximum Fragment Length Negotiation succeeded. * The negotiated Maximum Fragment Length is binding now. / s->session->ext.max_fragment_len_mode = value; return 1; } int tls_parse_stoc_server_name(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->ext.hostname == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (PACKET_remaining(pkt) > 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit) { if (s->session->ext.hostname != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname); if (s->session->ext.hostname == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { size_t ecpointformats_len; PACKET ecptformatlist; if (!PACKET_as_length_prefixed_1(pkt, &ecptformatlist)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit) { ecpointformats_len = PACKET_remaining(&ecptformatlist); if (ecpointformats_len == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); return 0; } s->ext.peer_ecpointformats_len = 0; OPENSSL_free(s->ext.peer_ecpointformats); s->ext.peer_ecpointformats = OPENSSL_malloc(ecpointformats_len); if (s->ext.peer_ecpointformats == NULL) { s->ext.peer_ecpointformats_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->ext.peer_ecpointformats_len = ecpointformats_len; if (!PACKET_copy_bytes(&ecptformatlist, s->ext.peer_ecpointformats, ecpointformats_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_parse_stoc_session_ticket(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->ext.session_ticket_cb != NULL && !s->ext.session_ticket_cb(ssl, PACKET_data(pkt), PACKET_remaining(pkt), s->ext.session_ticket_cb_arg)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION); return 0; } if (!tls_use_ticket(s)) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } if (PACKET_remaining(pkt) > 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } s->ext.ticket_expected = 1; return 1; } #ifndef OPENSSL_NO_OCSP int tls_parse_stoc_status_request(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) { /* We ignore this if the server sends a CertificateRequest / return 1; } / * MUST only be sent if we've requested a status * request message. In TLS <= 1.2 it must also be empty. / if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } if (!SSL_CONNECTION_IS_TLS13(s) && PACKET_remaining(pkt) > 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (SSL_CONNECTION_IS_TLS13(s)) { / We only know how to handle this if it's for the first Certificate in * the chain. We ignore any other responses. / if (chainidx != 0) return 1; / SSLfatal() already called / return tls_process_cert_status_body(s, pkt); } / Set flag to expect CertificateStatus message / s->ext.status_expected = 1; return 1; } #endif #ifndef OPENSSL_NO_CT int tls_parse_stoc_sct(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) { /* We ignore this if the server sends it in a CertificateRequest / return 1; } / * Only take it if we asked for it - i.e if there is no CT validation * callback set, then a custom extension MAY be processing it, so we * need to let control continue to flow to that. / if (s->ct_validation_callback != NULL) { size_t size = PACKET_remaining(pkt); / Simply copy it off for later processing / OPENSSL_free(s->ext.scts); s->ext.scts = NULL; s->ext.scts_len = (uint16_t)size; if (size > 0) { s->ext.scts = OPENSSL_malloc(size); if (s->ext.scts == NULL) { s->ext.scts_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } if (!PACKET_copy_bytes(pkt, s->ext.scts, size)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } else { ENDPOINT role = (context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0 ? ENDPOINT_CLIENT : ENDPOINT_BOTH; / * If we didn't ask for it then there must be a custom extension, * otherwise this is unsolicited. / if (custom_ext_find(&s->cert->custext, role, TLSEXT_TYPE_signed_certificate_timestamp, NULL) == NULL) { SSLfatal(s, TLS1_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } if (!custom_ext_parse(s, context, TLSEXT_TYPE_signed_certificate_timestamp, PACKET_data(pkt), PACKET_remaining(pkt), x, chainidx)) { / SSLfatal already called / return 0; } } return 1; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG / * ssl_next_proto_validate validates a Next Protocol Negotiation block. No * elements of zero length are allowed and the set of elements must exactly * fill the length of the block. Returns 1 on success or 0 on failure. / static int ssl_next_proto_validate(SSL_CONNECTION s, PACKET pkt) { PACKET tmp_protocol; while (PACKET_remaining(pkt)) { if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol) \|\| PACKET_remaining(&tmp_protocol) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } } return 1; } int tls_parse_stoc_npn(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned char selected; unsigned char selected_len; PACKET tmppkt; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); /* Check if we are in a renegotiation. If so ignore this extension / if (!SSL_IS_FIRST_HANDSHAKE(s)) return 1; / We must have requested it. / if (sctx->ext.npn_select_cb == NULL) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } / The data must be valid / tmppkt = pkt; if (!ssl_next_proto_validate(s, &tmppkt)) { /* SSLfatal() already called / return 0; } if (sctx->ext.npn_select_cb(SSL_CONNECTION_GET_SSL(s), &selected, &selected_len, PACKET_data(pkt), PACKET_remaining(pkt), sctx->ext.npn_select_cb_arg) != SSL_TLSEXT_ERR_OK) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION); return 0; } / * Could be non-NULL if server has sent multiple NPN extensions in * a single Serverhello / OPENSSL_free(s->ext.npn); s->ext.npn = OPENSSL_malloc(selected_len); if (s->ext.npn == NULL) { s->ext.npn_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } memcpy(s->ext.npn, selected, selected_len); s->ext.npn_len = selected_len; s->s3.npn_seen = 1; return 1; } #endif int tls_parse_stoc_alpn(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { size_t len; /* We must have requested it. / if (!s->s3.alpn_sent) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } /- * The extension data consists of: * uint16 list_length * uint8 proto_length; * uint8 proto[proto_length]; / if (!PACKET_get_net_2_len(pkt, &len) \|\| PACKET_remaining(pkt) != len \|\| !PACKET_get_1_len(pkt, &len) \|\| PACKET_remaining(pkt) != len) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } OPENSSL_free(s->s3.alpn_selected); s->s3.alpn_selected = OPENSSL_malloc(len); if (s->s3.alpn_selected == NULL) { s->s3.alpn_selected_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!PACKET_copy_bytes(pkt, s->s3.alpn_selected, len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } s->s3.alpn_selected_len = len; if (s->session->ext.alpn_selected == NULL \|\| s->session->ext.alpn_selected_len != len \|\| memcmp(s->session->ext.alpn_selected, s->s3.alpn_selected, len) != 0) { / ALPN not consistent with the old session so cannot use early_data / s->ext.early_data_ok = 0; } if (!s->hit) { / * This is a new session and so alpn_selected should have been * initialised to NULL. We should update it with the selected ALPN. / if (!ossl_assert(s->session->ext.alpn_selected == NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.alpn_selected = OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len); if (s->session->ext.alpn_selected == NULL) { s->session->ext.alpn_selected_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.alpn_selected_len = s->s3.alpn_selected_len; } return 1; } #ifndef OPENSSL_NO_SRTP int tls_parse_stoc_use_srtp(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned int id, ct, mki; int i; STACK_OF(SRTP_PROTECTION_PROFILE) clnt; SRTP_PROTECTION_PROFILE prof; if (!PACKET_get_net_2(pkt, &ct) \|\| ct != 2 \|\| !PACKET_get_net_2(pkt, &id) \|\| !PACKET_get_1(pkt, &mki) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } if (mki != 0) { /* Must be no MKI, since we never offer one / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_SRTP_MKI_VALUE); return 0; } / Throw an error if the server gave us an unsolicited extension / clnt = SSL_get_srtp_profiles(SSL_CONNECTION_GET_SSL(s)); if (clnt == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_NO_SRTP_PROFILES); return 0; } / * Check to see if the server gave us something we support (and * presumably offered) / for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(clnt); i++) { prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i); if (prof->id == id) { s->srtp_profile = prof; return 1; } } SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } #endif int tls_parse_stoc_etm(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { /* Ignore if inappropriate ciphersuite / if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) && s->s3.tmp.new_cipher->algorithm_mac != SSL_AEAD && s->s3.tmp.new_cipher->algorithm_enc != SSL_RC4 && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT12 && s->s3.tmp.new_cipher->algorithm_enc != SSL_MAGMA && s->s3.tmp.new_cipher->algorithm_enc != SSL_KUZNYECHIK) s->ext.use_etm = 1; return 1; } int tls_parse_stoc_ems(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET) return 1; s->s3.flags \|= TLS1_FLAGS_RECEIVED_EXTMS; if (!s->hit) s->session->flags \|= SSL_SESS_FLAG_EXTMS; return 1; } int tls_parse_stoc_supported_versions(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned int version; if (!PACKET_get_net_2(pkt, &version) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } / * The only protocol version we support which is valid in this extension in * a ServerHello is TLSv1.3 therefore we shouldn't be getting anything else. / if (version != TLS1_3_VERSION) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_PROTOCOL_VERSION_NUMBER); return 0; } / We ignore this extension for HRRs except to sanity check it / if (context == SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) return 1; / We just set it here. We validate it in ssl_choose_client_version / s->version = version; if (!ssl_set_record_protocol_version(s, version)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int tls_parse_stoc_key_share(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned int group_id; PACKET encoded_pt; EVP_PKEY ckey = s->s3.tmp.pkey, skey = NULL; const TLS_GROUP_INFO ginf = NULL; / Sanity check / if (ckey == NULL \|\| s->s3.peer_tmp != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!PACKET_get_net_2(pkt, &group_id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) { const uint16_t pgroups = NULL; size_t i, num_groups; if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } /* * It is an error if the HelloRetryRequest wants a key_share that we * already sent in the first ClientHello / if (group_id == s->s3.group_id) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } / Validate the selected group is one we support / tls1_get_supported_groups(s, &pgroups, &num_groups); for (i = 0; i < num_groups; i++) { if (group_id == pgroups[i]) break; } if (i >= num_groups \|\| !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED) \|\| !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION, 0, NULL)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } s->s3.group_id = group_id; EVP_PKEY_free(s->s3.tmp.pkey); s->s3.tmp.pkey = NULL; return 1; } if (group_id != s->s3.group_id) { / * This isn't for the group that we sent in the original * key_share! / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } / Retain this group in the SSL_SESSION / if (!s->hit) { s->session->kex_group = group_id; } else if (group_id != s->session->kex_group) { / * If this is a resumption but changed what group was used, we need * to record the new group in the session, but the session is not * a new session and could be in use by other threads. So, make * a copy of the session to record the new information so that it's * useful for any sessions resumed from tickets issued on this * connection. / SSL_SESSION new_sess; if ((new_sess = ssl_session_dup(s->session, 0)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); return 0; } SSL_SESSION_free(s->session); s->session = new_sess; s->session->kex_group = group_id; } if ((ginf = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s), group_id)) == NULL) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } if (!PACKET_as_length_prefixed_2(pkt, &encoded_pt) \|\| PACKET_remaining(&encoded_pt) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (!ginf->is_kem) { /* Regular KEX / skey = EVP_PKEY_new(); if (skey == NULL \|\| EVP_PKEY_copy_parameters(skey, ckey) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COPY_PARAMETERS_FAILED); EVP_PKEY_free(skey); return 0; } if (tls13_set_encoded_pub_key(skey, PACKET_data(&encoded_pt), PACKET_remaining(&encoded_pt)) <= 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT); EVP_PKEY_free(skey); return 0; } if (ssl_derive(s, ckey, skey, 1) == 0) { / SSLfatal() already called / EVP_PKEY_free(skey); return 0; } s->s3.peer_tmp = skey; } else { / KEM Mode / const unsigned char ct = PACKET_data(&encoded_pt); size_t ctlen = PACKET_remaining(&encoded_pt); if (ssl_decapsulate(s, ckey, ct, ctlen, 1) == 0) { /* SSLfatal() already called / return 0; } } s->s3.did_kex = 1; #endif return 1; } int tls_parse_stoc_cookie(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { PACKET cookie; if (!PACKET_as_length_prefixed_2(pkt, &cookie) \|\| !PACKET_memdup(&cookie, &s->ext.tls13_cookie, &s->ext.tls13_cookie_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } return 1; } int tls_parse_stoc_early_data(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) { unsigned long max_early_data; if (!PACKET_get_net_4(pkt, &max_early_data) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_INVALID_MAX_EARLY_DATA); return 0; } s->session->ext.max_early_data = max_early_data; if (SSL_IS_QUIC_HANDSHAKE(s) && max_early_data != 0xffffffff) { / * QUIC allows missing max_early_data, or a max_early_data value * of 0xffffffff. Missing max_early_data is stored in the session * as 0. This is indistinguishable in OpenSSL from a present * max_early_data value that was 0. In order that later checks for * invalid max_early_data correctly treat as an error the case where * max_early_data is present and it is 0, we store any invalid * value in the same (non-zero) way. Otherwise we would have to * introduce a new flag just for this. / s->session->ext.max_early_data = 1; SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_MAX_EARLY_DATA); return 0; } return 1; } if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->ext.early_data_ok \|\| !s->hit) { / * If we get here then we didn't send early data, or we didn't resume * using the first identity, or the SNI/ALPN is not consistent so the * server should not be accepting it. / SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); return 0; } s->ext.early_data = SSL_EARLY_DATA_ACCEPTED; return 1; } int tls_parse_stoc_psk(SSL_CONNECTION s, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned int identity; if (!PACKET_get_net_2(pkt, &identity) \|\| PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (identity >= (unsigned int)s->ext.tick_identity) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_PSK_IDENTITY); return 0; } /* * Session resumption tickets are always sent before PSK tickets. If the * ticket index is 0 then it must be for a session resumption ticket if we * sent two tickets, or if we didn't send a PSK ticket. / if (identity == 0 && (s->psksession == NULL \|\| s->ext.tick_identity == 2)) { s->hit = 1; SSL_SESSION_free(s->psksession); s->psksession = NULL; return 1; } if (s->psksession == NULL) { / Should never happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / * If we used the external PSK for sending early_data then s->early_secret * is already set up, so don't overwrite it. Otherwise we copy the * early_secret across that we generated earlier. / if ((s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) \|\| s->session->ext.max_early_data > 0 \|\| s->psksession->ext.max_early_data == 0) memcpy(s->early_secret, s->psksession->early_secret, EVP_MAX_MD_SIZE); SSL_SESSION_free(s->session); s->session = s->psksession; s->psksession = NULL; s->hit = 1; / Early data is only allowed if we used the first ticket / if (identity != 0) s->ext.early_data_ok = 0; #endif return 1; } EXT_RETURN tls_construct_ctos_client_cert_type(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; if (sc->client_cert_type == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_client_cert_type) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_sub_memcpy_u8(pkt, sc->client_cert_type, sc->client_cert_type_len) \|\| !WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_GOOD; return EXT_RETURN_SENT; } int tls_parse_stoc_client_cert_type(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned int type; if (PACKET_remaining(pkt) != 1) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_get_1(pkt, &type)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / We did not send/ask for this / if (!ossl_assert(sc->ext.client_cert_type_ctos == OSSL_CERT_TYPE_CTOS_GOOD)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / We don't have this enabled / if (sc->client_cert_type == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / Given back a value we didn't configure / if (memchr(sc->client_cert_type, type, sc->client_cert_type_len) == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_VALUE); return 0; } sc->ext.client_cert_type = type; return 1; } EXT_RETURN tls_construct_ctos_server_cert_type(SSL_CONNECTION sc, WPACKET pkt, unsigned int context, X509 x, size_t chainidx) { sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; if (sc->server_cert_type == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_cert_type) \|\| !WPACKET_start_sub_packet_u16(pkt) \|\| !WPACKET_sub_memcpy_u8(pkt, sc->server_cert_type, sc->server_cert_type_len) \|\| !WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_GOOD; return EXT_RETURN_SENT; } int tls_parse_stoc_server_cert_type(SSL_CONNECTION sc, PACKET pkt, unsigned int context, X509 x, size_t chainidx) { unsigned int type; if (PACKET_remaining(pkt) != 1) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_get_1(pkt, &type)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / We did not send/ask for this / if (!ossl_assert(sc->ext.server_cert_type_ctos == OSSL_CERT_TYPE_CTOS_GOOD)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / We don't have this enabled / if (sc->server_cert_type == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } / Given back a value we didn't configure */ if (memchr(sc->server_cert_type, type, sc->server_cert_type_len) == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_VALUE); return 0; } sc->ext.server_cert_type = type; return 1; }
./openssl/ssl/record/rec_layer_d1.c	/* * Copyright 2005-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <errno.h> #include "../ssl_local.h" #include <openssl/evp.h> #include <openssl/buffer.h> #include "record_local.h" #include "internal/packet.h" #include "internal/cryptlib.h" int DTLS_RECORD_LAYER_new(RECORD_LAYER rl) { DTLS_RECORD_LAYER d; if ((d = OPENSSL_malloc(sizeof(d))) == NULL) return 0; rl->d = d; d->buffered_app_data.q = pqueue_new(); if (d->buffered_app_data.q == NULL) { OPENSSL_free(d); rl->d = NULL; return 0; } return 1; } void DTLS_RECORD_LAYER_free(RECORD_LAYER rl) { if (rl->d == NULL) return; DTLS_RECORD_LAYER_clear(rl); pqueue_free(rl->d->buffered_app_data.q); OPENSSL_free(rl->d); rl->d = NULL; } void DTLS_RECORD_LAYER_clear(RECORD_LAYER rl) { DTLS_RECORD_LAYER d; pitem item = NULL; TLS_RECORD rec; pqueue buffered_app_data; d = rl->d; while ((item = pqueue_pop(d->buffered_app_data.q)) != NULL) { rec = (TLS_RECORD )item->data; if (rl->s->options & SSL_OP_CLEANSE_PLAINTEXT) OPENSSL_cleanse(rec->allocdata, rec->length); OPENSSL_free(rec->allocdata); OPENSSL_free(item->data); pitem_free(item); } buffered_app_data = d->buffered_app_data.q; memset(d, 0, sizeof(d)); d->buffered_app_data.q = buffered_app_data; } static int dtls_buffer_record(SSL_CONNECTION s, TLS_RECORD rec) { TLS_RECORD rdata; pitem item; record_pqueue queue = &(s->rlayer.d->buffered_app_data); / Limit the size of the queue to prevent DOS attacks / if (pqueue_size(queue->q) >= 100) return 0; / We don't buffer partially read records / if (!ossl_assert(rec->off == 0)) return -1; rdata = OPENSSL_malloc(sizeof(rdata)); item = pitem_new(rec->seq_num, rdata); if (rdata == NULL \|\| item == NULL) { OPENSSL_free(rdata); pitem_free(item); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } rdata = rec; /* * We will release the record from the record layer soon, so we take a copy * now. Copying data isn't good - but this should be infrequent so we * accept it here. / rdata->data = rdata->allocdata = OPENSSL_memdup(rec->data, rec->length); if (rdata->data == NULL) { OPENSSL_free(rdata); pitem_free(item); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return -1; } / * We use a NULL rechandle to indicate that the data field has been * allocated by us. / rdata->rechandle = NULL; item->data = rdata; #ifndef OPENSSL_NO_SCTP / Store bio_dgram_sctp_rcvinfo struct / if (BIO_dgram_is_sctp(s->rbio) && (ossl_statem_get_state(s) == TLS_ST_SR_FINISHED \|\| ossl_statem_get_state(s) == TLS_ST_CR_FINISHED)) { BIO_ctrl(s->rbio, BIO_CTRL_DGRAM_SCTP_GET_RCVINFO, sizeof(rdata->recordinfo), &rdata->recordinfo); } #endif if (pqueue_insert(queue->q, item) == NULL) { / Must be a duplicate so ignore it / OPENSSL_free(rdata->allocdata); OPENSSL_free(rdata); pitem_free(item); } return 1; } / Unbuffer a previously buffered TLS_RECORD structure if any / static void dtls_unbuffer_record(SSL_CONNECTION s) { TLS_RECORD rdata; pitem item; /* If we already have records to handle then do nothing / if (s->rlayer.curr_rec < s->rlayer.num_recs) return; item = pqueue_pop(s->rlayer.d->buffered_app_data.q); if (item != NULL) { rdata = (TLS_RECORD )item->data; s->rlayer.tlsrecs[0] = rdata; s->rlayer.num_recs = 1; s->rlayer.curr_rec = 0; #ifndef OPENSSL_NO_SCTP / Restore bio_dgram_sctp_rcvinfo struct / if (BIO_dgram_is_sctp(s->rbio)) { BIO_ctrl(s->rbio, BIO_CTRL_DGRAM_SCTP_SET_RCVINFO, sizeof(rdata->recordinfo), &rdata->recordinfo); } #endif OPENSSL_free(item->data); pitem_free(item); } } /- * Return up to 'len' payload bytes received in 'type' records. * 'type' is one of the following: * * - SSL3_RT_HANDSHAKE * - SSL3_RT_APPLICATION_DATA (when ssl3_read calls us) * - 0 (during a shutdown, no data has to be returned) * * If we don't have stored data to work from, read a SSL/TLS record first * (possibly multiple records if we still don't have anything to return). * * This function must handle any surprises the peer may have for us, such as * Alert records (e.g. close_notify) or renegotiation requests. ChangeCipherSpec * messages are treated as if they were handshake messages if the \|recd_type\| * argument is non NULL. * Also if record payloads contain fragments too small to process, we store * them until there is enough for the respective protocol (the record protocol * may use arbitrary fragmentation and even interleaving): * Change cipher spec protocol * just 1 byte needed, no need for keeping anything stored * Alert protocol * 2 bytes needed (AlertLevel, AlertDescription) * Handshake protocol * 4 bytes needed (HandshakeType, uint24 length) -- we just have * to detect unexpected Client Hello and Hello Request messages * here, anything else is handled by higher layers * Application data protocol * none of our business / int dtls1_read_bytes(SSL s, uint8_t type, uint8_t recvd_type, unsigned char buf, size_t len, int peek, size_t readbytes) { int i, j, ret; size_t n; TLS_RECORD rr; void (cb) (const SSL ssl, int type2, int val) = NULL; SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; if ((type && (type != SSL3_RT_APPLICATION_DATA) && (type != SSL3_RT_HANDSHAKE)) \|\| (peek && (type != SSL3_RT_APPLICATION_DATA))) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } if (!ossl_statem_get_in_handshake(sc) && SSL_in_init(s)) { / type == SSL3_RT_APPLICATION_DATA / i = sc->handshake_func(s); / SSLfatal() already called if appropriate / if (i < 0) return i; if (i == 0) return -1; } start: sc->rwstate = SSL_NOTHING; / * We are not handshaking and have no data yet, so process data buffered * during the last handshake in advance, if any. / if (SSL_is_init_finished(s)) dtls_unbuffer_record(sc); / Check for timeout / if (dtls1_handle_timeout(sc) > 0) { goto start; } else if (ossl_statem_in_error(sc)) { / dtls1_handle_timeout() has failed with a fatal error / return -1; } / get new packet if necessary / if (sc->rlayer.curr_rec >= sc->rlayer.num_recs) { sc->rlayer.curr_rec = sc->rlayer.num_recs = 0; do { rr = &sc->rlayer.tlsrecs[sc->rlayer.num_recs]; ret = HANDLE_RLAYER_READ_RETURN(sc, sc->rlayer.rrlmethod->read_record(sc->rlayer.rrl, &rr->rechandle, &rr->version, &rr->type, &rr->data, &rr->length, &rr->epoch, rr->seq_num)); if (ret <= 0) { ret = dtls1_read_failed(sc, ret); / * Anything other than a timeout is an error. SSLfatal() already * called if appropriate. / if (ret <= 0) return ret; else goto start; } rr->off = 0; sc->rlayer.num_recs++; } while (sc->rlayer.rrlmethod->processed_read_pending(sc->rlayer.rrl) && sc->rlayer.num_recs < SSL_MAX_PIPELINES); } rr = &sc->rlayer.tlsrecs[sc->rlayer.curr_rec]; / * Reset the count of consecutive warning alerts if we've got a non-empty * record that isn't an alert. / if (rr->type != SSL3_RT_ALERT && rr->length != 0) sc->rlayer.alert_count = 0; / we now have a packet which can be read and processed / if (sc->s3.change_cipher_spec / set when we receive ChangeCipherSpec, * reset by ssl3_get_finished / && (rr->type != SSL3_RT_HANDSHAKE)) { / * We now have application data between CCS and Finished. Most likely * the packets were reordered on their way, so buffer the application * data for later processing rather than dropping the connection. / if (dtls_buffer_record(sc, rr) < 0) { / SSLfatal() already called / return -1; } if (!ssl_release_record(sc, rr, 0)) return -1; goto start; } / * If the other end has shut down, throw anything we read away (even in * 'peek' mode) / if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) { if (!ssl_release_record(sc, rr, 0)) return -1; sc->rwstate = SSL_NOTHING; return 0; } if (type == rr->type \|\| (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC && type == SSL3_RT_HANDSHAKE && recvd_type != NULL)) { / * SSL3_RT_APPLICATION_DATA or * SSL3_RT_HANDSHAKE or * SSL3_RT_CHANGE_CIPHER_SPEC / / * make sure that we are not getting application data when we are * doing a handshake for the first time / if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) && (SSL_IS_FIRST_HANDSHAKE(sc))) { SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_APP_DATA_IN_HANDSHAKE); return -1; } if (recvd_type != NULL) recvd_type = rr->type; if (len == 0) { /* * Release a zero length record. This ensures multiple calls to * SSL_read() with a zero length buffer will eventually cause * SSL_pending() to report data as being available. / if (rr->length == 0 && !ssl_release_record(sc, rr, 0)) return -1; return 0; } if (len > rr->length) n = rr->length; else n = len; memcpy(buf, &(rr->data[rr->off]), n); if (peek) { if (rr->length == 0 && !ssl_release_record(sc, rr, 0)) return -1; } else { if (!ssl_release_record(sc, rr, n)) return -1; } #ifndef OPENSSL_NO_SCTP / * We might had to delay a close_notify alert because of reordered * app data. If there was an alert and there is no message to read * anymore, finally set shutdown. / if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && sc->d1->shutdown_received && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) <= 0) { sc->shutdown \|= SSL_RECEIVED_SHUTDOWN; return 0; } #endif readbytes = n; return 1; } /* * If we get here, then type != rr->type; if we have a handshake message, * then it was unexpected (Hello Request or Client Hello). / if (rr->type == SSL3_RT_ALERT) { unsigned int alert_level, alert_descr; const unsigned char alert_bytes = rr->data + rr->off; PACKET alert; if (!PACKET_buf_init(&alert, alert_bytes, rr->length) \|\| !PACKET_get_1(&alert, &alert_level) \|\| !PACKET_get_1(&alert, &alert_descr) \|\| PACKET_remaining(&alert) != 0) { SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT); return -1; } if (sc->msg_callback) sc->msg_callback(0, sc->version, SSL3_RT_ALERT, alert_bytes, 2, s, sc->msg_callback_arg); if (sc->info_callback != NULL) cb = sc->info_callback; else if (s->ctx->info_callback != NULL) cb = s->ctx->info_callback; if (cb != NULL) { j = (alert_level << 8) \| alert_descr; cb(s, SSL_CB_READ_ALERT, j); } if (alert_level == SSL3_AL_WARNING) { sc->s3.warn_alert = alert_descr; if (!ssl_release_record(sc, rr, 0)) return -1; sc->rlayer.alert_count++; if (sc->rlayer.alert_count == MAX_WARN_ALERT_COUNT) { SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MANY_WARN_ALERTS); return -1; } if (alert_descr == SSL_AD_CLOSE_NOTIFY) { #ifndef OPENSSL_NO_SCTP /* * With SCTP and streams the socket may deliver app data * after a close_notify alert. We have to check this first so * that nothing gets discarded. / if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) > 0) { sc->d1->shutdown_received = 1; sc->rwstate = SSL_READING; BIO_clear_retry_flags(SSL_get_rbio(s)); BIO_set_retry_read(SSL_get_rbio(s)); return -1; } #endif sc->shutdown \|= SSL_RECEIVED_SHUTDOWN; return 0; } } else if (alert_level == SSL3_AL_FATAL) { sc->rwstate = SSL_NOTHING; sc->s3.fatal_alert = alert_descr; SSLfatal_data(sc, SSL_AD_NO_ALERT, SSL_AD_REASON_OFFSET + alert_descr, "SSL alert number %d", alert_descr); sc->shutdown \|= SSL_RECEIVED_SHUTDOWN; if (!ssl_release_record(sc, rr, 0)) return -1; SSL_CTX_remove_session(sc->session_ctx, sc->session); return 0; } else { SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_ALERT_TYPE); return -1; } goto start; } if (sc->shutdown & SSL_SENT_SHUTDOWN) { / but we have not received a * shutdown / sc->rwstate = SSL_NOTHING; if (!ssl_release_record(sc, rr, 0)) return -1; return 0; } if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) { / * We can't process a CCS now, because previous handshake messages * are still missing, so just drop it. / if (!ssl_release_record(sc, rr, 0)) return -1; goto start; } / * Unexpected handshake message (Client Hello, or protocol violation) / if (rr->type == SSL3_RT_HANDSHAKE && !ossl_statem_get_in_handshake(sc)) { struct hm_header_st msg_hdr; / * This may just be a stale retransmit. Also sanity check that we have * at least enough record bytes for a message header / if (rr->epoch != sc->rlayer.d->r_epoch \|\| rr->length < DTLS1_HM_HEADER_LENGTH) { if (!ssl_release_record(sc, rr, 0)) return -1; goto start; } dtls1_get_message_header(rr->data, &msg_hdr); / * If we are server, we may have a repeated FINISHED of the client * here, then retransmit our CCS and FINISHED. / if (msg_hdr.type == SSL3_MT_FINISHED) { if (dtls1_check_timeout_num(sc) < 0) { / SSLfatal) already called / return -1; } if (dtls1_retransmit_buffered_messages(sc) <= 0) { / Fail if we encountered a fatal error / if (ossl_statem_in_error(sc)) return -1; } if (!ssl_release_record(sc, rr, 0)) return -1; if (!(sc->mode & SSL_MODE_AUTO_RETRY)) { if (!sc->rlayer.rrlmethod->unprocessed_read_pending(sc->rlayer.rrl)) { / no read-ahead left? / BIO bio; sc->rwstate = SSL_READING; bio = SSL_get_rbio(s); BIO_clear_retry_flags(bio); BIO_set_retry_read(bio); return -1; } } goto start; } /* * To get here we must be trying to read app data but found handshake * data. But if we're trying to read app data, and we're not in init * (which is tested for at the top of this function) then init must be * finished / if (!ossl_assert(SSL_is_init_finished(s))) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } / We found handshake data, so we're going back into init / ossl_statem_set_in_init(sc, 1); i = sc->handshake_func(s); / SSLfatal() called if appropriate / if (i < 0) return i; if (i == 0) return -1; if (!(sc->mode & SSL_MODE_AUTO_RETRY)) { if (!sc->rlayer.rrlmethod->unprocessed_read_pending(sc->rlayer.rrl)) { / no read-ahead left? / BIO bio; /* * In the case where we try to read application data, but we * trigger an SSL handshake, we return -1 with the retry * option set. Otherwise renegotiation may cause nasty * problems in the blocking world / sc->rwstate = SSL_READING; bio = SSL_get_rbio(s); BIO_clear_retry_flags(bio); BIO_set_retry_read(bio); return -1; } } goto start; } switch (rr->type) { default: SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD); return -1; case SSL3_RT_CHANGE_CIPHER_SPEC: case SSL3_RT_ALERT: case SSL3_RT_HANDSHAKE: / * we already handled all of these, with the possible exception of * SSL3_RT_HANDSHAKE when ossl_statem_get_in_handshake(s) is true, but * that should not happen when type != rr->type / SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, ERR_R_INTERNAL_ERROR); return -1; case SSL3_RT_APPLICATION_DATA: / * At this point, we were expecting handshake data, but have * application data. If the library was running inside ssl3_read() * (i.e. in_read_app_data is set) and it makes sense to read * application data at this point (session renegotiation not yet * started), we will indulge it. / if (sc->s3.in_read_app_data && (sc->s3.total_renegotiations != 0) && ossl_statem_app_data_allowed(sc)) { sc->s3.in_read_app_data = 2; return -1; } else { SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD); return -1; } } / not reached / } / * Call this to write data in records of type 'type' It will return <= 0 if * not all data has been sent or non-blocking IO. / int dtls1_write_bytes(SSL_CONNECTION s, uint8_t type, const void buf, size_t len, size_t written) { int i; if (!ossl_assert(len <= SSL3_RT_MAX_PLAIN_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } s->rwstate = SSL_NOTHING; i = do_dtls1_write(s, type, buf, len, written); return i; } int do_dtls1_write(SSL_CONNECTION sc, uint8_t type, const unsigned char buf, size_t len, size_t written) { int i; OSSL_RECORD_TEMPLATE tmpl; SSL s = SSL_CONNECTION_GET_SSL(sc); int ret; /* If we have an alert to send, lets send it / if (sc->s3.alert_dispatch > 0) { i = s->method->ssl_dispatch_alert(s); if (i <= 0) return i; / if it went, fall through and send more stuff / } if (len == 0) return 0; if (len > ssl_get_max_send_fragment(sc)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE); return 0; } tmpl.type = type; / * Special case: for hello verify request, client version 1.0 and we * haven't decided which version to use yet send back using version 1.0 * header: otherwise some clients will ignore it. / if (s->method->version == DTLS_ANY_VERSION && sc->max_proto_version != DTLS1_BAD_VER) tmpl.version = DTLS1_VERSION; else tmpl.version = sc->version; tmpl.buf = buf; tmpl.buflen = len; ret = HANDLE_RLAYER_WRITE_RETURN(sc, sc->rlayer.wrlmethod->write_records(sc->rlayer.wrl, &tmpl, 1)); if (ret > 0) written = (int)len; return ret; } void dtls1_increment_epoch(SSL_CONNECTION s, int rw) { if (rw & SSL3_CC_READ) { s->rlayer.d->r_epoch++; / * We must not use any buffered messages received from the previous * epoch / dtls1_clear_received_buffer(s); } else { s->rlayer.d->w_epoch++; } } uint16_t dtls1_get_epoch(SSL_CONNECTION s, int rw) { uint16_t epoch; if (rw & SSL3_CC_READ) epoch = s->rlayer.d->r_epoch; else epoch = s->rlayer.d->w_epoch; return epoch; }
./openssl/ssl/record/record_local.h	/* * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / /**************************************************************************** * * * The following macros/functions are PRIVATE to the record layer. They * * should NOT be used outside of the record layer. * * * *****************************************************************************/ #define MAX_WARN_ALERT_COUNT 5
./openssl/ssl/record/rec_layer_s3.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <stdio.h> #include <limits.h> #include <errno.h> #include <assert.h> #include "../ssl_local.h" #include "../quic/quic_local.h" #include <openssl/evp.h> #include <openssl/buffer.h> #include <openssl/rand.h> #include <openssl/core_names.h> #include "record_local.h" #include "internal/packet.h" void RECORD_LAYER_init(RECORD_LAYER rl, SSL_CONNECTION s) { rl->s = s; } void RECORD_LAYER_clear(RECORD_LAYER rl) { rl->wnum = 0; memset(rl->handshake_fragment, 0, sizeof(rl->handshake_fragment)); rl->handshake_fragment_len = 0; rl->wpend_tot = 0; rl->wpend_type = 0; rl->wpend_buf = NULL; if (rl->rrlmethod != NULL) rl->rrlmethod->free(rl->rrl); /* Ignore return value / if (rl->wrlmethod != NULL) rl->wrlmethod->free(rl->wrl); / Ignore return value / BIO_free(rl->rrlnext); rl->rrlmethod = NULL; rl->wrlmethod = NULL; rl->rrlnext = NULL; rl->rrl = NULL; rl->wrl = NULL; if (rl->d) DTLS_RECORD_LAYER_clear(rl); } / Checks if we have unprocessed read ahead data pending / int RECORD_LAYER_read_pending(const RECORD_LAYER rl) { return rl->rrlmethod->unprocessed_read_pending(rl->rrl); } /* Checks if we have decrypted unread record data pending / int RECORD_LAYER_processed_read_pending(const RECORD_LAYER rl) { return (rl->curr_rec < rl->num_recs) \|\| rl->rrlmethod->processed_read_pending(rl->rrl); } int RECORD_LAYER_write_pending(const RECORD_LAYER rl) { return rl->wpend_tot > 0; } static uint32_t ossl_get_max_early_data(SSL_CONNECTION s) { uint32_t max_early_data; SSL_SESSION sess = s->session; / * If we are a client then we always use the max_early_data from the * session/psksession. Otherwise we go with the lowest out of the max early * data set in the session and the configured max_early_data. / if (!s->server && sess->ext.max_early_data == 0) { if (!ossl_assert(s->psksession != NULL && s->psksession->ext.max_early_data > 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } sess = s->psksession; } if (!s->server) max_early_data = sess->ext.max_early_data; else if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED) max_early_data = s->recv_max_early_data; else max_early_data = s->recv_max_early_data < sess->ext.max_early_data ? s->recv_max_early_data : sess->ext.max_early_data; return max_early_data; } static int ossl_early_data_count_ok(SSL_CONNECTION s, size_t length, size_t overhead, int send) { uint32_t max_early_data; max_early_data = ossl_get_max_early_data(s); if (max_early_data == 0) { SSLfatal(s, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MUCH_EARLY_DATA); return 0; } /* If we are dealing with ciphertext we need to allow for the overhead / max_early_data += overhead; if (s->early_data_count + length > max_early_data) { SSLfatal(s, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MUCH_EARLY_DATA); return 0; } s->early_data_count += length; return 1; } size_t ssl3_pending(const SSL s) { size_t i, num = 0; const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; if (SSL_CONNECTION_IS_DTLS(sc)) { TLS_RECORD rdata; pitem item, iter; iter = pqueue_iterator(sc->rlayer.d->buffered_app_data.q); while ((item = pqueue_next(&iter)) != NULL) { rdata = item->data; num += rdata->length; } } for (i = 0; i < sc->rlayer.num_recs; i++) { if (sc->rlayer.tlsrecs[i].type != SSL3_RT_APPLICATION_DATA) return num; num += sc->rlayer.tlsrecs[i].length; } num += sc->rlayer.rrlmethod->app_data_pending(sc->rlayer.rrl); return num; } void SSL_CTX_set_default_read_buffer_len(SSL_CTX ctx, size_t len) { ctx->default_read_buf_len = len; } void SSL_set_default_read_buffer_len(SSL s, size_t len) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL \|\| IS_QUIC(s)) return; sc->rlayer.default_read_buf_len = len; } const char SSL_rstate_string_long(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); const char lng; if (sc == NULL) return NULL; if (sc->rlayer.rrlmethod == NULL \|\| sc->rlayer.rrl == NULL) return "unknown"; sc->rlayer.rrlmethod->get_state(sc->rlayer.rrl, NULL, &lng); return lng; } const char SSL_rstate_string(const SSL s) { const SSL_CONNECTION sc = SSL_CONNECTION_FROM_CONST_SSL(s); const char shrt; if (sc == NULL) return NULL; if (sc->rlayer.rrlmethod == NULL \|\| sc->rlayer.rrl == NULL) return "unknown"; sc->rlayer.rrlmethod->get_state(sc->rlayer.rrl, &shrt, NULL); return shrt; } static int tls_write_check_pending(SSL_CONNECTION s, uint8_t type, const unsigned char buf, size_t len) { if (s->rlayer.wpend_tot == 0) return 0; / We have pending data, so do some sanity checks / if ((s->rlayer.wpend_tot > len) \|\| (!(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER) && (s->rlayer.wpend_buf != buf)) \|\| (s->rlayer.wpend_type != type)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_WRITE_RETRY); return -1; } return 1; } / * Call this to write data in records of type 'type' It will return <= 0 if * not all data has been sent or non-blocking IO. / int ssl3_write_bytes(SSL ssl, uint8_t type, const void buf_, size_t len, size_t written) { const unsigned char buf = buf_; size_t tot; size_t n, max_send_fragment, split_send_fragment, maxpipes; int i; SSL_CONNECTION s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); OSSL_RECORD_TEMPLATE tmpls[SSL_MAX_PIPELINES]; unsigned int recversion; if (s == NULL) return -1; s->rwstate = SSL_NOTHING; tot = s->rlayer.wnum; /* * ensure that if we end up with a smaller value of data to write out * than the original len from a write which didn't complete for * non-blocking I/O and also somehow ended up avoiding the check for * this in tls_write_check_pending/SSL_R_BAD_WRITE_RETRY as it must never be * possible to end up with (len-tot) as a large number that will then * promptly send beyond the end of the users buffer ... so we trap and * report the error in a way the user will notice / if ((len < s->rlayer.wnum) \|\| ((s->rlayer.wpend_tot != 0) && (len < (s->rlayer.wnum + s->rlayer.wpend_tot)))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_LENGTH); return -1; } if (s->early_data_state == SSL_EARLY_DATA_WRITING && !ossl_early_data_count_ok(s, len, 0, 1)) { / SSLfatal() already called / return -1; } s->rlayer.wnum = 0; / * If we are supposed to be sending a KeyUpdate or NewSessionTicket then go * into init unless we have writes pending - in which case we should finish * doing that first. / if (s->rlayer.wpend_tot == 0 && (s->key_update != SSL_KEY_UPDATE_NONE \|\| s->ext.extra_tickets_expected > 0)) ossl_statem_set_in_init(s, 1); / * When writing early data on the server side we could be "in_init" in * between receiving the EoED and the CF - but we don't want to handle those * messages yet. / if (SSL_in_init(ssl) && !ossl_statem_get_in_handshake(s) && s->early_data_state != SSL_EARLY_DATA_UNAUTH_WRITING) { i = s->handshake_func(ssl); / SSLfatal() already called / if (i < 0) return i; if (i == 0) { return -1; } } i = tls_write_check_pending(s, type, buf, len); if (i < 0) { / SSLfatal() already called / return i; } else if (i > 0) { / Retry needed / i = HANDLE_RLAYER_WRITE_RETURN(s, s->rlayer.wrlmethod->retry_write_records(s->rlayer.wrl)); if (i <= 0) { s->rlayer.wnum = tot; return i; } tot += s->rlayer.wpend_tot; s->rlayer.wpend_tot = 0; } / else no retry required / if (tot == 0) { / * We've not previously sent any data for this write so memorize * arguments so that we can detect bad write retries later / s->rlayer.wpend_tot = 0; s->rlayer.wpend_type = type; s->rlayer.wpend_buf = buf; } if (tot == len) { / done? / written = tot; return 1; } /* If we have an alert to send, lets send it / if (s->s3.alert_dispatch > 0) { i = ssl->method->ssl_dispatch_alert(ssl); if (i <= 0) { / SSLfatal() already called if appropriate / s->rlayer.wnum = tot; return i; } / if it went, fall through and send more stuff / } n = (len - tot); max_send_fragment = ssl_get_max_send_fragment(s); split_send_fragment = ssl_get_split_send_fragment(s); if (max_send_fragment == 0 \|\| split_send_fragment == 0 \|\| split_send_fragment > max_send_fragment) { / * We should have prevented this when we set/get the split and max send * fragments so we shouldn't get here / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } / * Some servers hang if initial client hello is larger than 256 bytes * and record version number > TLS 1.0 / recversion = (s->version == TLS1_3_VERSION) ? TLS1_2_VERSION : s->version; if (SSL_get_state(ssl) == TLS_ST_CW_CLNT_HELLO && !s->renegotiate && TLS1_get_version(ssl) > TLS1_VERSION && s->hello_retry_request == SSL_HRR_NONE) recversion = TLS1_VERSION; for (;;) { size_t tmppipelen, remain; size_t j, lensofar = 0; / * Ask the record layer how it would like to split the amount of data * that we have, and how many of those records it would like in one go. / maxpipes = s->rlayer.wrlmethod->get_max_records(s->rlayer.wrl, type, n, max_send_fragment, &split_send_fragment); / * If max_pipelines is 0 then this means "undefined" and we default to * whatever the record layer wants to do. Otherwise we use the smallest * value from the number requested by the record layer, and max number * configured by the user. / if (s->max_pipelines > 0 && maxpipes > s->max_pipelines) maxpipes = s->max_pipelines; if (maxpipes > SSL_MAX_PIPELINES) maxpipes = SSL_MAX_PIPELINES; if (split_send_fragment > max_send_fragment) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } if (n / maxpipes >= split_send_fragment) { / * We have enough data to completely fill all available * pipelines / for (j = 0; j < maxpipes; j++) { tmpls[j].type = type; tmpls[j].version = recversion; tmpls[j].buf = &(buf[tot]) + (j split_send_fragment); tmpls[j].buflen = split_send_fragment; } /* Remember how much data we are going to be sending / s->rlayer.wpend_tot = maxpipes split_send_fragment; } else { /* We can partially fill all available pipelines / tmppipelen = n / maxpipes; remain = n % maxpipes; / * If there is a remainder we add an extra byte to the first few * pipelines / if (remain > 0) tmppipelen++; for (j = 0; j < maxpipes; j++) { tmpls[j].type = type; tmpls[j].version = recversion; tmpls[j].buf = &(buf[tot]) + lensofar; tmpls[j].buflen = tmppipelen; lensofar += tmppipelen; if (j + 1 == remain) tmppipelen--; } / Remember how much data we are going to be sending / s->rlayer.wpend_tot = n; } i = HANDLE_RLAYER_WRITE_RETURN(s, s->rlayer.wrlmethod->write_records(s->rlayer.wrl, tmpls, maxpipes)); if (i <= 0) { / SSLfatal() already called if appropriate / s->rlayer.wnum = tot; return i; } if (s->rlayer.wpend_tot == n \|\| (type == SSL3_RT_APPLICATION_DATA && (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE) != 0)) { written = tot + s->rlayer.wpend_tot; s->rlayer.wpend_tot = 0; return 1; } n -= s->rlayer.wpend_tot; tot += s->rlayer.wpend_tot; } } int ossl_tls_handle_rlayer_return(SSL_CONNECTION s, int writing, int ret, char file, int line) { SSL ssl = SSL_CONNECTION_GET_SSL(s); if (ret == OSSL_RECORD_RETURN_RETRY) { s->rwstate = writing ? SSL_WRITING : SSL_READING; ret = -1; } else { s->rwstate = SSL_NOTHING; if (ret == OSSL_RECORD_RETURN_EOF) { if (writing) { / * This shouldn't happen with a writing operation. We treat it * as fatal. / ERR_new(); ERR_set_debug(file, line, 0); ossl_statem_fatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR, NULL); ret = OSSL_RECORD_RETURN_FATAL; } else if ((s->options & SSL_OP_IGNORE_UNEXPECTED_EOF) != 0) { SSL_set_shutdown(ssl, SSL_RECEIVED_SHUTDOWN); s->s3.warn_alert = SSL_AD_CLOSE_NOTIFY; } else { ERR_new(); ERR_set_debug(file, line, 0); / * This reason code is part of the API and may be used by * applications for control flow decisions. / ossl_statem_fatal(s, SSL_AD_DECODE_ERROR, SSL_R_UNEXPECTED_EOF_WHILE_READING, NULL); } } else if (ret == OSSL_RECORD_RETURN_FATAL) { int al = s->rlayer.rrlmethod->get_alert_code(s->rlayer.rrl); if (al != SSL_AD_NO_ALERT) { ERR_new(); ERR_set_debug(file, line, 0); ossl_statem_fatal(s, al, SSL_R_RECORD_LAYER_FAILURE, NULL); } / * else some failure but there is no alert code. We don't log an * error for this. The record layer should have logged an error * already or, if not, its due to some sys call error which will be * reported via SSL_ERROR_SYSCALL and errno. / } / * The record layer distinguishes the cases of EOF, non-fatal * err and retry. Upper layers do not. * If we got a retry or success then ret is already correct, otherwise we need to convert the return value. / if (ret == OSSL_RECORD_RETURN_NON_FATAL_ERR \|\| ret == OSSL_RECORD_RETURN_EOF) ret = 0; else if (ret < OSSL_RECORD_RETURN_NON_FATAL_ERR) ret = -1; } return ret; } int ssl_release_record(SSL_CONNECTION s, TLS_RECORD rr, size_t length) { assert(rr->length >= length); if (rr->rechandle != NULL) { if (length == 0) length = rr->length; / The record layer allocated the buffers for this record / if (HANDLE_RLAYER_READ_RETURN(s, s->rlayer.rrlmethod->release_record(s->rlayer.rrl, rr->rechandle, length)) <= 0) { / RLAYER_fatal already called / return 0; } if (length == rr->length) s->rlayer.curr_rec++; } else if (length == 0 \|\| length == rr->length) { / We allocated the buffers for this record (only happens with DTLS) / OPENSSL_free(rr->allocdata); rr->allocdata = NULL; } rr->length -= length; if (rr->length > 0) rr->off += length; else rr->off = 0; return 1; } /- * Return up to 'len' payload bytes received in 'type' records. * 'type' is one of the following: * * - SSL3_RT_HANDSHAKE (when tls_get_message_header and tls_get_message_body * call us) * - SSL3_RT_APPLICATION_DATA (when ssl3_read calls us) * - 0 (during a shutdown, no data has to be returned) * * If we don't have stored data to work from, read a SSL/TLS record first * (possibly multiple records if we still don't have anything to return). * * This function must handle any surprises the peer may have for us, such as * Alert records (e.g. close_notify) or renegotiation requests. ChangeCipherSpec * messages are treated as if they were handshake messages if the \|recvd_type\| * argument is non NULL. * Also if record payloads contain fragments too small to process, we store * them until there is enough for the respective protocol (the record protocol * may use arbitrary fragmentation and even interleaving): * Change cipher spec protocol * just 1 byte needed, no need for keeping anything stored * Alert protocol * 2 bytes needed (AlertLevel, AlertDescription) * Handshake protocol * 4 bytes needed (HandshakeType, uint24 length) -- we just have * to detect unexpected Client Hello and Hello Request messages * here, anything else is handled by higher layers * Application data protocol * none of our business / int ssl3_read_bytes(SSL ssl, uint8_t type, uint8_t recvd_type, unsigned char buf, size_t len, int peek, size_t readbytes) { int i, j, ret; size_t n, curr_rec, totalbytes; TLS_RECORD rr; void (cb) (const SSL ssl, int type2, int val) = NULL; int is_tls13; SSL_CONNECTION s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); is_tls13 = SSL_CONNECTION_IS_TLS13(s); if ((type != 0 && (type != SSL3_RT_APPLICATION_DATA) && (type != SSL3_RT_HANDSHAKE)) \|\| (peek && (type != SSL3_RT_APPLICATION_DATA))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } if ((type == SSL3_RT_HANDSHAKE) && (s->rlayer.handshake_fragment_len > 0)) / (partially) satisfy request from storage / { unsigned char src = s->rlayer.handshake_fragment; unsigned char dst = buf; unsigned int k; / peek == 0 / n = 0; while ((len > 0) && (s->rlayer.handshake_fragment_len > 0)) { dst++ = src++; len--; s->rlayer.handshake_fragment_len--; n++; } / move any remaining fragment bytes: / for (k = 0; k < s->rlayer.handshake_fragment_len; k++) s->rlayer.handshake_fragment[k] = src++; if (recvd_type != NULL) recvd_type = SSL3_RT_HANDSHAKE; readbytes = n; return 1; } /* * Now s->rlayer.handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. / if (!ossl_statem_get_in_handshake(s) && SSL_in_init(ssl)) { / type == SSL3_RT_APPLICATION_DATA / i = s->handshake_func(ssl); / SSLfatal() already called / if (i < 0) return i; if (i == 0) return -1; } start: s->rwstate = SSL_NOTHING; /- * For each record 'i' up to \|num_recs] * rr[i].type - is the type of record * rr[i].data, - data * rr[i].off, - offset into 'data' for next read * rr[i].length, - number of bytes. / / get new records if necessary / if (s->rlayer.curr_rec >= s->rlayer.num_recs) { s->rlayer.curr_rec = s->rlayer.num_recs = 0; do { rr = &s->rlayer.tlsrecs[s->rlayer.num_recs]; ret = HANDLE_RLAYER_READ_RETURN(s, s->rlayer.rrlmethod->read_record(s->rlayer.rrl, &rr->rechandle, &rr->version, &rr->type, &rr->data, &rr->length, NULL, NULL)); if (ret <= 0) { / SSLfatal() already called if appropriate / return ret; } rr->off = 0; s->rlayer.num_recs++; } while (s->rlayer.rrlmethod->processed_read_pending(s->rlayer.rrl) && s->rlayer.num_recs < SSL_MAX_PIPELINES); } rr = &s->rlayer.tlsrecs[s->rlayer.curr_rec]; if (s->rlayer.handshake_fragment_len > 0 && rr->type != SSL3_RT_HANDSHAKE && SSL_CONNECTION_IS_TLS13(s)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA); return -1; } / * Reset the count of consecutive warning alerts if we've got a non-empty * record that isn't an alert. / if (rr->type != SSL3_RT_ALERT && rr->length != 0) s->rlayer.alert_count = 0; / we now have a packet which can be read and processed / if (s->s3.change_cipher_spec / set when we receive ChangeCipherSpec, * reset by ssl3_get_finished / && (rr->type != SSL3_RT_HANDSHAKE)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED); return -1; } / * If the other end has shut down, throw anything we read away (even in * 'peek' mode) / if (s->shutdown & SSL_RECEIVED_SHUTDOWN) { s->rlayer.curr_rec++; s->rwstate = SSL_NOTHING; return 0; } if (type == rr->type \|\| (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC && type == SSL3_RT_HANDSHAKE && recvd_type != NULL && !is_tls13)) { / * SSL3_RT_APPLICATION_DATA or * SSL3_RT_HANDSHAKE or * SSL3_RT_CHANGE_CIPHER_SPEC / / * make sure that we are not getting application data when we are * doing a handshake for the first time / if (SSL_in_init(ssl) && type == SSL3_RT_APPLICATION_DATA && SSL_IS_FIRST_HANDSHAKE(s)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_APP_DATA_IN_HANDSHAKE); return -1; } if (type == SSL3_RT_HANDSHAKE && rr->type == SSL3_RT_CHANGE_CIPHER_SPEC && s->rlayer.handshake_fragment_len > 0) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY); return -1; } if (recvd_type != NULL) recvd_type = rr->type; if (len == 0) { /* * Skip a zero length record. This ensures multiple calls to * SSL_read() with a zero length buffer will eventually cause * SSL_pending() to report data as being available. / if (rr->length == 0 && !ssl_release_record(s, rr, 0)) return -1; return 0; } totalbytes = 0; curr_rec = s->rlayer.curr_rec; do { if (len - totalbytes > rr->length) n = rr->length; else n = len - totalbytes; memcpy(buf, &(rr->data[rr->off]), n); buf += n; if (peek) { / Mark any zero length record as consumed CVE-2016-6305 / if (rr->length == 0 && !ssl_release_record(s, rr, 0)) return -1; } else { if (!ssl_release_record(s, rr, n)) return -1; } if (rr->length == 0 \|\| (peek && n == rr->length)) { rr++; curr_rec++; } totalbytes += n; } while (type == SSL3_RT_APPLICATION_DATA && curr_rec < s->rlayer.num_recs && totalbytes < len); if (totalbytes == 0) { / We must have read empty records. Get more data / goto start; } readbytes = totalbytes; return 1; } /* * If we get here, then type != rr->type; if we have a handshake message, * then it was unexpected (Hello Request or Client Hello) or invalid (we * were actually expecting a CCS). / / * Lets just double check that we've not got an SSLv2 record / if (rr->version == SSL2_VERSION) { / * Should never happen. ssl3_get_record() should only give us an SSLv2 * record back if this is the first packet and we are looking for an * initial ClientHello. Therefore \|type\| should always be equal to * \|rr->type\|. If not then something has gone horribly wrong / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } if (ssl->method->version == TLS_ANY_VERSION && (s->server \|\| rr->type != SSL3_RT_ALERT)) { / * If we've got this far and still haven't decided on what version * we're using then this must be a client side alert we're dealing * with. We shouldn't be receiving anything other than a ClientHello * if we are a server. / s->version = rr->version; SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); return -1; } /- * s->rlayer.handshake_fragment_len == 4 iff rr->type == SSL3_RT_HANDSHAKE; * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) / if (rr->type == SSL3_RT_ALERT) { unsigned int alert_level, alert_descr; const unsigned char alert_bytes = rr->data + rr->off; PACKET alert; if (!PACKET_buf_init(&alert, alert_bytes, rr->length) \|\| !PACKET_get_1(&alert, &alert_level) \|\| !PACKET_get_1(&alert, &alert_descr) \|\| PACKET_remaining(&alert) != 0) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT); return -1; } if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_ALERT, alert_bytes, 2, ssl, s->msg_callback_arg); if (s->info_callback != NULL) cb = s->info_callback; else if (ssl->ctx->info_callback != NULL) cb = ssl->ctx->info_callback; if (cb != NULL) { j = (alert_level << 8) \| alert_descr; cb(ssl, SSL_CB_READ_ALERT, j); } if ((!is_tls13 && alert_level == SSL3_AL_WARNING) \|\| (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED)) { s->s3.warn_alert = alert_descr; if (!ssl_release_record(s, rr, 0)) return -1; s->rlayer.alert_count++; if (s->rlayer.alert_count == MAX_WARN_ALERT_COUNT) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MANY_WARN_ALERTS); return -1; } } /* * Apart from close_notify the only other warning alert in TLSv1.3 * is user_cancelled - which we just ignore. / if (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED) { goto start; } else if (alert_descr == SSL_AD_CLOSE_NOTIFY && (is_tls13 \|\| alert_level == SSL3_AL_WARNING)) { s->shutdown \|= SSL_RECEIVED_SHUTDOWN; return 0; } else if (alert_level == SSL3_AL_FATAL \|\| is_tls13) { s->rwstate = SSL_NOTHING; s->s3.fatal_alert = alert_descr; SSLfatal_data(s, SSL_AD_NO_ALERT, SSL_AD_REASON_OFFSET + alert_descr, "SSL alert number %d", alert_descr); s->shutdown \|= SSL_RECEIVED_SHUTDOWN; if (!ssl_release_record(s, rr, 0)) return -1; SSL_CTX_remove_session(s->session_ctx, s->session); return 0; } else if (alert_descr == SSL_AD_NO_RENEGOTIATION) { / * This is a warning but we receive it if we requested * renegotiation and the peer denied it. Terminate with a fatal * alert because if application tried to renegotiate it * presumably had a good reason and expects it to succeed. In * future we might have a renegotiation where we don't care if * the peer refused it where we carry on. / SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_RENEGOTIATION); return -1; } else if (alert_level == SSL3_AL_WARNING) { / We ignore any other warning alert in TLSv1.2 and below / goto start; } SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_ALERT_TYPE); return -1; } if ((s->shutdown & SSL_SENT_SHUTDOWN) != 0) { if (rr->type == SSL3_RT_HANDSHAKE) { BIO rbio; /* * We ignore any handshake messages sent to us unless they are * TLSv1.3 in which case we want to process them. For all other * handshake messages we can't do anything reasonable with them * because we are unable to write any response due to having already * sent close_notify. / if (!SSL_CONNECTION_IS_TLS13(s)) { if (!ssl_release_record(s, rr, 0)) return -1; if ((s->mode & SSL_MODE_AUTO_RETRY) != 0) goto start; s->rwstate = SSL_READING; rbio = SSL_get_rbio(ssl); BIO_clear_retry_flags(rbio); BIO_set_retry_read(rbio); return -1; } } else { / * The peer is continuing to send application data, but we have * already sent close_notify. If this was expected we should have * been called via SSL_read() and this would have been handled * above. * No alert sent because we already sent close_notify / if (!ssl_release_record(s, rr, 0)) return -1; SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY); return -1; } } / * For handshake data we have 'fragment' storage, so fill that so that we * can process the header at a fixed place. This is done after the * "SHUTDOWN" code above to avoid filling the fragment storage with data * that we're just going to discard. / if (rr->type == SSL3_RT_HANDSHAKE) { size_t dest_maxlen = sizeof(s->rlayer.handshake_fragment); unsigned char dest = s->rlayer.handshake_fragment; size_t dest_len = &s->rlayer.handshake_fragment_len; n = dest_maxlen - dest_len; /* available space in 'dest' / if (rr->length < n) n = rr->length; / available bytes / / now move 'n' bytes: / if (n > 0) { memcpy(dest + dest_len, rr->data + rr->off, n); dest_len += n; } / * We release the number of bytes consumed, or the whole record if it * is zero length / if ((n > 0 \|\| rr->length == 0) && !ssl_release_record(s, rr, n)) return -1; if (dest_len < dest_maxlen) goto start; /* fragment was too small / } if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY); return -1; } / * Unexpected handshake message (ClientHello, NewSessionTicket (TLS1.3) or * protocol violation) / if ((s->rlayer.handshake_fragment_len >= 4) && !ossl_statem_get_in_handshake(s)) { int ined = (s->early_data_state == SSL_EARLY_DATA_READING); / We found handshake data, so we're going back into init / ossl_statem_set_in_init(s, 1); i = s->handshake_func(ssl); / SSLfatal() already called if appropriate / if (i < 0) return i; if (i == 0) { return -1; } / * If we were actually trying to read early data and we found a * handshake message, then we don't want to continue to try and read * the application data any more. It won't be "early" now. / if (ined) return -1; if (!(s->mode & SSL_MODE_AUTO_RETRY)) { if (!RECORD_LAYER_read_pending(&s->rlayer)) { BIO bio; /* * In the case where we try to read application data, but we * trigger an SSL handshake, we return -1 with the retry * option set. Otherwise renegotiation may cause nasty * problems in the blocking world / s->rwstate = SSL_READING; bio = SSL_get_rbio(ssl); BIO_clear_retry_flags(bio); BIO_set_retry_read(bio); return -1; } } goto start; } switch (rr->type) { default: / * TLS 1.0 and 1.1 say you SHOULD ignore unrecognised record types, but * TLS 1.2 says you MUST send an unexpected message alert. We use the * TLS 1.2 behaviour for all protocol versions to prevent issues where * no progress is being made and the peer continually sends unrecognised * record types, using up resources processing them. / SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD); return -1; case SSL3_RT_CHANGE_CIPHER_SPEC: case SSL3_RT_ALERT: case SSL3_RT_HANDSHAKE: / * we already handled all of these, with the possible exception of * SSL3_RT_HANDSHAKE when ossl_statem_get_in_handshake(s) is true, but * that should not happen when type != rr->type / SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, ERR_R_INTERNAL_ERROR); return -1; case SSL3_RT_APPLICATION_DATA: / * At this point, we were expecting handshake data, but have * application data. If the library was running inside ssl3_read() * (i.e. in_read_app_data is set) and it makes sense to read * application data at this point (session renegotiation not yet * started), we will indulge it. / if (ossl_statem_app_data_allowed(s)) { s->s3.in_read_app_data = 2; return -1; } else if (ossl_statem_skip_early_data(s)) { / * This can happen after a client sends a CH followed by early_data, * but the server responds with a HelloRetryRequest. The server * reads the next record from the client expecting to find a * plaintext ClientHello but gets a record which appears to be * application data. The trial decrypt "works" because null * decryption was applied. We just skip it and move on to the next * record. / if (!ossl_early_data_count_ok(s, rr->length, EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) { / SSLfatal() already called / return -1; } if (!ssl_release_record(s, rr, 0)) return -1; goto start; } else { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD); return -1; } } } / * Returns true if the current rrec was sent in SSLv2 backwards compatible * format and false otherwise. / int RECORD_LAYER_is_sslv2_record(RECORD_LAYER rl) { if (SSL_CONNECTION_IS_DTLS(rl->s)) return 0; return rl->tlsrecs[0].version == SSL2_VERSION; } static OSSL_FUNC_rlayer_msg_callback_fn rlayer_msg_callback_wrapper; static void rlayer_msg_callback_wrapper(int write_p, int version, int content_type, const void buf, size_t len, void cbarg) { SSL_CONNECTION s = cbarg; SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->msg_callback != NULL) s->msg_callback(write_p, version, content_type, buf, len, ssl, s->msg_callback_arg); } static OSSL_FUNC_rlayer_security_fn rlayer_security_wrapper; static int rlayer_security_wrapper(void cbarg, int op, int bits, int nid, void other) { SSL_CONNECTION s = cbarg; return ssl_security(s, op, bits, nid, other); } static OSSL_FUNC_rlayer_padding_fn rlayer_padding_wrapper; static size_t rlayer_padding_wrapper(void cbarg, int type, size_t len) { SSL_CONNECTION s = cbarg; SSL ssl = SSL_CONNECTION_GET_SSL(s); return s->rlayer.record_padding_cb(ssl, type, len, s->rlayer.record_padding_arg); } static const OSSL_DISPATCH rlayer_dispatch[] = { { OSSL_FUNC_RLAYER_SKIP_EARLY_DATA, (void ()(void))ossl_statem_skip_early_data }, { OSSL_FUNC_RLAYER_MSG_CALLBACK, (void ()(void))rlayer_msg_callback_wrapper }, { OSSL_FUNC_RLAYER_SECURITY, (void ()(void))rlayer_security_wrapper }, { OSSL_FUNC_RLAYER_PADDING, (void ()(void))rlayer_padding_wrapper }, OSSL_DISPATCH_END }; void ossl_ssl_set_custom_record_layer(SSL_CONNECTION s, const OSSL_RECORD_METHOD meth, void rlarg) { s->rlayer.custom_rlmethod = meth; s->rlayer.rlarg = rlarg; } static const OSSL_RECORD_METHOD ssl_select_next_record_layer(SSL_CONNECTION s, int direction, int level) { if (s->rlayer.custom_rlmethod != NULL) return s->rlayer.custom_rlmethod; if (level == OSSL_RECORD_PROTECTION_LEVEL_NONE) { if (SSL_CONNECTION_IS_DTLS(s)) return &ossl_dtls_record_method; return &ossl_tls_record_method; } #ifndef OPENSSL_NO_KTLS / KTLS does not support renegotiation / if (level == OSSL_RECORD_PROTECTION_LEVEL_APPLICATION && (s->options & SSL_OP_ENABLE_KTLS) != 0 && (SSL_CONNECTION_IS_TLS13(s) \|\| SSL_IS_FIRST_HANDSHAKE(s))) return &ossl_ktls_record_method; #endif / Default to the current OSSL_RECORD_METHOD / return direction == OSSL_RECORD_DIRECTION_READ ? s->rlayer.rrlmethod : s->rlayer.wrlmethod; } static int ssl_post_record_layer_select(SSL_CONNECTION s, int direction) { const OSSL_RECORD_METHOD thismethod; OSSL_RECORD_LAYER thisrl; if (direction == OSSL_RECORD_DIRECTION_READ) { thismethod = s->rlayer.rrlmethod; thisrl = s->rlayer.rrl; } else { thismethod = s->rlayer.wrlmethod; thisrl = s->rlayer.wrl; } #ifndef OPENSSL_NO_KTLS { SSL ssl = SSL_CONNECTION_GET_SSL(s); if (s->rlayer.rrlmethod == &ossl_ktls_record_method) { / KTLS does not support renegotiation so disallow it / SSL_set_options(ssl, SSL_OP_NO_RENEGOTIATION); } } #endif if (SSL_IS_FIRST_HANDSHAKE(s) && thismethod->set_first_handshake != NULL) thismethod->set_first_handshake(thisrl, 1); if (s->max_pipelines != 0 && thismethod->set_max_pipelines != NULL) thismethod->set_max_pipelines(thisrl, s->max_pipelines); return 1; } int ssl_set_new_record_layer(SSL_CONNECTION s, int version, int direction, int level, unsigned char secret, size_t secretlen, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, const SSL_COMP comp, const EVP_MD kdfdigest) { OSSL_PARAM options[5], opts = options; OSSL_PARAM settings[6], set = settings; const OSSL_RECORD_METHOD thismethod; OSSL_RECORD_LAYER thisrl, newrl = NULL; BIO thisbio; SSL_CTX sctx = SSL_CONNECTION_GET_CTX(s); const OSSL_RECORD_METHOD meth; int use_etm, stream_mac = 0, tlstree = 0; unsigned int maxfrag = (direction == OSSL_RECORD_DIRECTION_WRITE) ? ssl_get_max_send_fragment(s) : SSL3_RT_MAX_PLAIN_LENGTH; int use_early_data = 0; uint32_t max_early_data; COMP_METHOD compm = (comp == NULL) ? NULL : comp->method; meth = ssl_select_next_record_layer(s, direction, level); if (direction == OSSL_RECORD_DIRECTION_READ) { thismethod = &s->rlayer.rrlmethod; thisrl = &s->rlayer.rrl; thisbio = s->rbio; } else { thismethod = &s->rlayer.wrlmethod; thisrl = &s->rlayer.wrl; thisbio = s->wbio; } if (meth == NULL) meth = thismethod; if (!ossl_assert(meth != NULL)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } /* Parameters that may be supported by a record layer if passed / opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS, &s->options); opts++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE, &s->mode); if (direction == OSSL_RECORD_DIRECTION_READ) { opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN, &s->rlayer.default_read_buf_len); opts++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD, &s->rlayer.read_ahead); } else { opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING, &s->rlayer.block_padding); } opts = OSSL_PARAM_construct_end(); / Parameters that must be supported by a record layer if passed / if (direction == OSSL_RECORD_DIRECTION_READ) { use_etm = SSL_READ_ETM(s) ? 1 : 0; if ((s->mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM) != 0) stream_mac = 1; if ((s->mac_flags & SSL_MAC_FLAG_READ_MAC_TLSTREE) != 0) tlstree = 1; } else { use_etm = SSL_WRITE_ETM(s) ? 1 : 0; if ((s->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM) != 0) stream_mac = 1; if ((s->mac_flags & SSL_MAC_FLAG_WRITE_MAC_TLSTREE) != 0) tlstree = 1; } if (use_etm) set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM, &use_etm); if (stream_mac) set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC, &stream_mac); if (tlstree) set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE, &tlstree); /* * We only need to do this for the read side. The write side should already * have the correct value due to the ssl_get_max_send_fragment() call above / if (direction == OSSL_RECORD_DIRECTION_READ && s->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)) maxfrag = GET_MAX_FRAGMENT_LENGTH(s->session); if (maxfrag != SSL3_RT_MAX_PLAIN_LENGTH) set++ = OSSL_PARAM_construct_uint(OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN, &maxfrag); /* * The record layer must check the amount of early data sent or received * using the early keys. A server also needs to worry about rejected early * data that might arrive when the handshake keys are in force. / if (s->server && direction == OSSL_RECORD_DIRECTION_READ) { use_early_data = (level == OSSL_RECORD_PROTECTION_LEVEL_EARLY \|\| level == OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE); } else if (!s->server && direction == OSSL_RECORD_DIRECTION_WRITE) { use_early_data = (level == OSSL_RECORD_PROTECTION_LEVEL_EARLY); } if (use_early_data) { max_early_data = ossl_get_max_early_data(s); if (max_early_data != 0) set++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA, &max_early_data); } set = OSSL_PARAM_construct_end(); for (;;) { int rlret; BIO prev = NULL; BIO next = NULL; unsigned int epoch = 0; OSSL_DISPATCH rlayer_dispatch_tmp[OSSL_NELEM(rlayer_dispatch)]; size_t i, j; if (direction == OSSL_RECORD_DIRECTION_READ) { prev = s->rlayer.rrlnext; if (SSL_CONNECTION_IS_DTLS(s) && level != OSSL_RECORD_PROTECTION_LEVEL_NONE) epoch = dtls1_get_epoch(s, SSL3_CC_READ); / new epoch / #ifndef OPENSSL_NO_DGRAM if (SSL_CONNECTION_IS_DTLS(s)) next = BIO_new(BIO_s_dgram_mem()); else #endif next = BIO_new(BIO_s_mem()); if (next == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->rlayer.rrlnext = next; } else { if (SSL_CONNECTION_IS_DTLS(s) && level != OSSL_RECORD_PROTECTION_LEVEL_NONE) epoch = dtls1_get_epoch(s, SSL3_CC_WRITE); / new epoch / } / * Create a copy of the dispatch array, missing out wrappers for * callbacks that we don't need. / for (i = 0, j = 0; i < OSSL_NELEM(rlayer_dispatch); i++) { switch (rlayer_dispatch[i].function_id) { case OSSL_FUNC_RLAYER_MSG_CALLBACK: if (s->msg_callback == NULL) continue; break; case OSSL_FUNC_RLAYER_PADDING: if (s->rlayer.record_padding_cb == NULL) continue; break; default: break; } rlayer_dispatch_tmp[j++] = rlayer_dispatch[i]; } rlret = meth->new_record_layer(sctx->libctx, sctx->propq, version, s->server, direction, level, epoch, secret, secretlen, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, compm, kdfdigest, prev, thisbio, next, NULL, NULL, settings, options, rlayer_dispatch_tmp, s, s->rlayer.rlarg, &newrl); BIO_free(prev); switch (rlret) { case OSSL_RECORD_RETURN_FATAL: SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_RECORD_LAYER_FAILURE); return 0; case OSSL_RECORD_RETURN_NON_FATAL_ERR: if (thismethod != meth && thismethod != NULL) { / * We tried a new record layer method, but it didn't work out, * so we fallback to the original method and try again / meth = thismethod; continue; } SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_RECORD_LAYER); return 0; case OSSL_RECORD_RETURN_SUCCESS: break; default: /* Should not happen / SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } break; } / * Free the old record layer if we have one except in the case of DTLS when * writing and there are still buffered sent messages in our queue. In that * case the record layer is still referenced by those buffered messages for * potential retransmit. Only when those buffered messages get freed do we * free the record layer object (see dtls1_hm_fragment_free) / if (!SSL_CONNECTION_IS_DTLS(s) \|\| direction == OSSL_RECORD_DIRECTION_READ \|\| pqueue_peek(s->d1->sent_messages) == NULL) { if (thismethod != NULL && !(thismethod)->free(thisrl)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } thisrl = newrl; thismethod = meth; return ssl_post_record_layer_select(s, direction); } int ssl_set_record_protocol_version(SSL_CONNECTION *s, int vers) { if (!ossl_assert(s->rlayer.rrlmethod != NULL) \|\| !ossl_assert(s->rlayer.wrlmethod != NULL)) return 0; s->rlayer.rrlmethod->set_protocol_version(s->rlayer.rrl, s->version); s->rlayer.wrlmethod->set_protocol_version(s->rlayer.wrl, s->version); return 1; }
./openssl/ssl/record/record.h	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/core_dispatch.h> #include "internal/recordmethod.h" /**************************************************************************** * * * These structures should be considered PRIVATE to the record layer. No * * non-record layer code should be using these structures in any way. * * * ****************************************************************************/ #define SEQ_NUM_SIZE 8 typedef struct tls_record_st { void rechandle; int version; uint8_t type; /* The data buffer containing bytes from the record / const unsigned char data; /* * Buffer that we allocated to store data. If non NULL always the same as * data (but non-const) / unsigned char allocdata; /* Number of remaining to be read in the data buffer / size_t length; / Offset into the data buffer where to start reading / size_t off; / epoch number. DTLS only / uint16_t epoch; / sequence number. DTLS only / unsigned char seq_num[SEQ_NUM_SIZE]; #ifndef OPENSSL_NO_SCTP struct bio_dgram_sctp_rcvinfo recordinfo; #endif } TLS_RECORD; typedef struct record_pqueue_st { uint16_t epoch; struct pqueue_st q; } record_pqueue; typedef struct dtls_record_layer_st { /* * The current data and handshake epoch. This is initially * undefined, and starts at zero once the initial handshake is * completed / uint16_t r_epoch; uint16_t w_epoch; / * Buffered application records. Only for records between CCS and * Finished to prevent either protocol violation or unnecessary message * loss. / record_pqueue buffered_app_data; } DTLS_RECORD_LAYER; /**************************************************************************** * * * This structure should be considered "opaque" to anything outside of the * * record layer. No non-record layer code should be accessing the members of * * this structure. * * * ****************************************************************************/ typedef struct record_layer_st { / The parent SSL_CONNECTION structure / SSL_CONNECTION s; /* Custom record layer: always selected if set / const OSSL_RECORD_METHOD custom_rlmethod; /* Record layer specific argument / void rlarg; /* Method to use for the read record layer/ const OSSL_RECORD_METHOD rrlmethod; /* Method to use for the write record layer/ const OSSL_RECORD_METHOD wrlmethod; /* The read record layer object itself / OSSL_RECORD_LAYER rrl; /* The write record layer object itself / OSSL_RECORD_LAYER wrl; /* BIO to store data destined for the next read record layer epoch / BIO rrlnext; /* Default read buffer length to be passed to the record layer / size_t default_read_buf_len; / * Read as many input bytes as possible (for * non-blocking reads) / int read_ahead; / number of bytes sent so far / size_t wnum; unsigned char handshake_fragment[4]; size_t handshake_fragment_len; / partial write - check the numbers match / / number bytes written / size_t wpend_tot; uint8_t wpend_type; const unsigned char wpend_buf; /* Count of the number of consecutive warning alerts received / unsigned int alert_count; DTLS_RECORD_LAYER d; /* TLS1.3 padding callback / size_t (record_padding_cb)(SSL s, int type, size_t len, void arg); void record_padding_arg; size_t block_padding; / How many records we have read from the record layer / size_t num_recs; / The next record from the record layer that we need to process / size_t curr_rec; / Record layer data to be processed / TLS_RECORD tlsrecs[SSL_MAX_PIPELINES]; } RECORD_LAYER; /**************************************************************************** * * * The following macros/functions represent the libssl internal API to the * * record layer. Any libssl code may call these functions/macros * * * ****************************************************************************/ #define RECORD_LAYER_set_read_ahead(rl, ra) ((rl)->read_ahead = (ra)) #define RECORD_LAYER_get_read_ahead(rl) ((rl)->read_ahead) void RECORD_LAYER_init(RECORD_LAYER rl, SSL_CONNECTION s); void RECORD_LAYER_clear(RECORD_LAYER rl); int RECORD_LAYER_read_pending(const RECORD_LAYER rl); int RECORD_LAYER_processed_read_pending(const RECORD_LAYER rl); int RECORD_LAYER_write_pending(const RECORD_LAYER rl); int RECORD_LAYER_is_sslv2_record(RECORD_LAYER rl); __owur size_t ssl3_pending(const SSL s); __owur int ssl3_write_bytes(SSL s, uint8_t type, const void buf, size_t len, size_t written); __owur int ssl3_read_bytes(SSL s, uint8_t type, uint8_t recvd_type, unsigned char buf, size_t len, int peek, size_t readbytes); int DTLS_RECORD_LAYER_new(RECORD_LAYER rl); void DTLS_RECORD_LAYER_free(RECORD_LAYER rl); void DTLS_RECORD_LAYER_clear(RECORD_LAYER rl); __owur int dtls1_read_bytes(SSL s, uint8_t type, uint8_t recvd_type, unsigned char buf, size_t len, int peek, size_t readbytes); __owur int dtls1_write_bytes(SSL_CONNECTION s, uint8_t type, const void buf, size_t len, size_t written); int do_dtls1_write(SSL_CONNECTION s, uint8_t type, const unsigned char buf, size_t len, size_t written); void dtls1_increment_epoch(SSL_CONNECTION s, int rw); uint16_t dtls1_get_epoch(SSL_CONNECTION s, int rw); int ssl_release_record(SSL_CONNECTION s, TLS_RECORD rr, size_t length); # define HANDLE_RLAYER_READ_RETURN(s, ret) \ ossl_tls_handle_rlayer_return(s, 0, ret, OPENSSL_FILE, OPENSSL_LINE) # define HANDLE_RLAYER_WRITE_RETURN(s, ret) \ ossl_tls_handle_rlayer_return(s, 1, ret, OPENSSL_FILE, OPENSSL_LINE) int ossl_tls_handle_rlayer_return(SSL_CONNECTION s, int writing, int ret, char file, int line); int ssl_set_new_record_layer(SSL_CONNECTION s, int version, int direction, int level, unsigned char secret, size_t secretlen, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, const SSL_COMP comp, const EVP_MD kdfdigest); int ssl_set_record_protocol_version(SSL_CONNECTION s, int vers); # define OSSL_FUNC_RLAYER_SKIP_EARLY_DATA 1 OSSL_CORE_MAKE_FUNC(int, rlayer_skip_early_data, (void cbarg)) # define OSSL_FUNC_RLAYER_MSG_CALLBACK 2 OSSL_CORE_MAKE_FUNC(void, rlayer_msg_callback, (int write_p, int version, int content_type, const void buf, size_t len, void cbarg)) # define OSSL_FUNC_RLAYER_SECURITY 3 OSSL_CORE_MAKE_FUNC(int, rlayer_security, (void cbarg, int op, int bits, int nid, void other)) # define OSSL_FUNC_RLAYER_PADDING 4 OSSL_CORE_MAKE_FUNC(size_t, rlayer_padding, (void *cbarg, int type, size_t len))
./openssl/ssl/record/methods/ktls_meth.c	/* * Copyright 2018-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/evp.h> #include <openssl/core_names.h> #include <openssl/rand.h> #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" #include "internal/ktls.h" static struct record_functions_st ossl_ktls_funcs; #if defined(__FreeBSD__) # include "crypto/cryptodev.h" /- * Check if a given cipher is supported by the KTLS interface. * The kernel might still fail the setsockopt() if no suitable * provider is found, but this checks if the socket option * supports the cipher suite used at all. / static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER rl, const EVP_CIPHER c, const EVP_MD md, size_t taglen) { switch (rl->version) { case TLS1_VERSION: case TLS1_1_VERSION: case TLS1_2_VERSION: #ifdef OPENSSL_KTLS_TLS13 case TLS1_3_VERSION: #endif break; default: return 0; } if (EVP_CIPHER_is_a(c, "AES-128-GCM") \|\| EVP_CIPHER_is_a(c, "AES-256-GCM") # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 \|\| EVP_CIPHER_is_a(c, "CHACHA20-POLY1305") # endif ) return 1; if (!EVP_CIPHER_is_a(c, "AES-128-CBC") && !EVP_CIPHER_is_a(c, "AES-256-CBC")) return 0; if (rl->use_etm) return 0; if (md == NULL) return 0; if (EVP_MD_is_a(md, "SHA1") \|\| EVP_MD_is_a(md, "SHA2-256") \|\| EVP_MD_is_a(md, "SHA2-384")) return 1; return 0; } /* Function to configure kernel TLS structure / static int ktls_configure_crypto(OSSL_LIB_CTX libctx, int version, const EVP_CIPHER c, EVP_MD md, void rl_sequence, ktls_crypto_info_t crypto_info, int is_tx, unsigned char iv, size_t ivlen, unsigned char key, size_t keylen, unsigned char mac_key, size_t mac_secret_size) { memset(crypto_info, 0, sizeof(crypto_info)); if (EVP_CIPHER_is_a(c, "AES-128-GCM") \|\| EVP_CIPHER_is_a(c, "AES-256-GCM")) { crypto_info->cipher_algorithm = CRYPTO_AES_NIST_GCM_16; crypto_info->iv_len = ivlen; } else # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 if (EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")) { crypto_info->cipher_algorithm = CRYPTO_CHACHA20_POLY1305; crypto_info->iv_len = ivlen; } else # endif if (EVP_CIPHER_is_a(c, "AES-128-CBC") \|\| EVP_CIPHER_is_a(c, "AES-256-CBC")) { if (md == NULL) return 0; if (EVP_MD_is_a(md, "SHA1")) crypto_info->auth_algorithm = CRYPTO_SHA1_HMAC; else if (EVP_MD_is_a(md, "SHA2-256")) crypto_info->auth_algorithm = CRYPTO_SHA2_256_HMAC; else if (EVP_MD_is_a(md, "SHA2-384")) crypto_info->auth_algorithm = CRYPTO_SHA2_384_HMAC; else return 0; crypto_info->cipher_algorithm = CRYPTO_AES_CBC; crypto_info->iv_len = ivlen; crypto_info->auth_key = mac_key; crypto_info->auth_key_len = mac_secret_size; } else { return 0; } crypto_info->cipher_key = key; crypto_info->cipher_key_len = keylen; crypto_info->iv = iv; crypto_info->tls_vmajor = (version >> 8) & 0x000000ff; crypto_info->tls_vminor = (version & 0x000000ff); # ifdef TCP_RXTLS_ENABLE memcpy(crypto_info->rec_seq, rl_sequence, sizeof(crypto_info->rec_seq)); # else if (!is_tx) return 0; # endif return 1; }; #endif /* __FreeBSD__ / #if defined(OPENSSL_SYS_LINUX) / Function to check supported ciphers in Linux / static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER rl, const EVP_CIPHER c, const EVP_MD md, size_t taglen) { switch (rl->version) { case TLS1_2_VERSION: #ifdef OPENSSL_KTLS_TLS13 case TLS1_3_VERSION: #endif break; default: return 0; } /* * Check that cipher is AES_GCM_128, AES_GCM_256, AES_CCM_128 * or Chacha20-Poly1305 / # ifdef OPENSSL_KTLS_AES_CCM_128 if (EVP_CIPHER_is_a(c, "AES-128-CCM")) { if (taglen != EVP_CCM_TLS_TAG_LEN) return 0; return 1; } else # endif if (0 # ifdef OPENSSL_KTLS_AES_GCM_128 \|\| EVP_CIPHER_is_a(c, "AES-128-GCM") # endif # ifdef OPENSSL_KTLS_AES_GCM_256 \|\| EVP_CIPHER_is_a(c, "AES-256-GCM") # endif # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 \|\| EVP_CIPHER_is_a(c, "ChaCha20-Poly1305") # endif ) { return 1; } return 0; } / Function to configure kernel TLS structure / static int ktls_configure_crypto(OSSL_LIB_CTX libctx, int version, const EVP_CIPHER c, const EVP_MD md, void rl_sequence, ktls_crypto_info_t crypto_info, int is_tx, unsigned char iv, size_t ivlen, unsigned char key, size_t keylen, unsigned char mac_key, size_t mac_secret_size) { unsigned char geniv[EVP_GCM_TLS_EXPLICIT_IV_LEN]; unsigned char eiv = NULL; # ifdef OPENSSL_NO_KTLS_RX if (!is_tx) return 0; # endif if (EVP_CIPHER_get_mode(c) == EVP_CIPH_GCM_MODE \|\| EVP_CIPHER_get_mode(c) == EVP_CIPH_CCM_MODE) { if (!ossl_assert(EVP_GCM_TLS_FIXED_IV_LEN == EVP_CCM_TLS_FIXED_IV_LEN) \|\| !ossl_assert(EVP_GCM_TLS_EXPLICIT_IV_LEN == EVP_CCM_TLS_EXPLICIT_IV_LEN)) return 0; if (version == TLS1_2_VERSION) { if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN)) return 0; if (is_tx) { if (RAND_bytes_ex(libctx, geniv, EVP_GCM_TLS_EXPLICIT_IV_LEN, 0) <= 0) return 0; } else { memset(geniv, 0, EVP_GCM_TLS_EXPLICIT_IV_LEN); } eiv = geniv; } else { if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN + EVP_GCM_TLS_EXPLICIT_IV_LEN)) return 0; eiv = iv + TLS_CIPHER_AES_GCM_128_SALT_SIZE; } } memset(crypto_info, 0, sizeof(crypto_info)); switch (EVP_CIPHER_get_nid(c)) { # ifdef OPENSSL_KTLS_AES_GCM_128 case NID_aes_128_gcm: if (!ossl_assert(TLS_CIPHER_AES_GCM_128_SALT_SIZE == EVP_GCM_TLS_FIXED_IV_LEN) \|\| !ossl_assert(TLS_CIPHER_AES_GCM_128_IV_SIZE == EVP_GCM_TLS_EXPLICIT_IV_LEN)) return 0; crypto_info->gcm128.info.cipher_type = TLS_CIPHER_AES_GCM_128; crypto_info->gcm128.info.version = version; crypto_info->tls_crypto_info_len = sizeof(crypto_info->gcm128); memcpy(crypto_info->gcm128.iv, eiv, TLS_CIPHER_AES_GCM_128_IV_SIZE); memcpy(crypto_info->gcm128.salt, iv, TLS_CIPHER_AES_GCM_128_SALT_SIZE); memcpy(crypto_info->gcm128.key, key, keylen); memcpy(crypto_info->gcm128.rec_seq, rl_sequence, TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE); return 1; # endif # ifdef OPENSSL_KTLS_AES_GCM_256 case NID_aes_256_gcm: if (!ossl_assert(TLS_CIPHER_AES_GCM_256_SALT_SIZE == EVP_GCM_TLS_FIXED_IV_LEN) \|\| !ossl_assert(TLS_CIPHER_AES_GCM_256_IV_SIZE == EVP_GCM_TLS_EXPLICIT_IV_LEN)) return 0; crypto_info->gcm256.info.cipher_type = TLS_CIPHER_AES_GCM_256; crypto_info->gcm256.info.version = version; crypto_info->tls_crypto_info_len = sizeof(crypto_info->gcm256); memcpy(crypto_info->gcm256.iv, eiv, TLS_CIPHER_AES_GCM_256_IV_SIZE); memcpy(crypto_info->gcm256.salt, iv, TLS_CIPHER_AES_GCM_256_SALT_SIZE); memcpy(crypto_info->gcm256.key, key, keylen); memcpy(crypto_info->gcm256.rec_seq, rl_sequence, TLS_CIPHER_AES_GCM_256_REC_SEQ_SIZE); return 1; # endif # ifdef OPENSSL_KTLS_AES_CCM_128 case NID_aes_128_ccm: if (!ossl_assert(TLS_CIPHER_AES_CCM_128_SALT_SIZE == EVP_CCM_TLS_FIXED_IV_LEN) \|\| !ossl_assert(TLS_CIPHER_AES_CCM_128_IV_SIZE == EVP_CCM_TLS_EXPLICIT_IV_LEN)) return 0; crypto_info->ccm128.info.cipher_type = TLS_CIPHER_AES_CCM_128; crypto_info->ccm128.info.version = version; crypto_info->tls_crypto_info_len = sizeof(crypto_info->ccm128); memcpy(crypto_info->ccm128.iv, eiv, TLS_CIPHER_AES_CCM_128_IV_SIZE); memcpy(crypto_info->ccm128.salt, iv, TLS_CIPHER_AES_CCM_128_SALT_SIZE); memcpy(crypto_info->ccm128.key, key, keylen); memcpy(crypto_info->ccm128.rec_seq, rl_sequence, TLS_CIPHER_AES_CCM_128_REC_SEQ_SIZE); return 1; # endif # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 case NID_chacha20_poly1305: if (!ossl_assert(ivlen == TLS_CIPHER_CHACHA20_POLY1305_IV_SIZE)) return 0; crypto_info->chacha20poly1305.info.cipher_type = TLS_CIPHER_CHACHA20_POLY1305; crypto_info->chacha20poly1305.info.version = version; crypto_info->tls_crypto_info_len = sizeof(crypto_info->chacha20poly1305); memcpy(crypto_info->chacha20poly1305.iv, iv, ivlen); memcpy(crypto_info->chacha20poly1305.key, key, keylen); memcpy(crypto_info->chacha20poly1305.rec_seq, rl_sequence, TLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZE); return 1; # endif default: return 0; } } #endif / OPENSSL_SYS_LINUX / static int ktls_set_crypto_state(OSSL_RECORD_LAYER rl, int level, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp) { ktls_crypto_info_t crypto_info; /* * Check if we are suitable for KTLS. If not suitable we return * OSSL_RECORD_RETURN_NON_FATAL_ERR so that other record layers can be tried * instead / if (comp != NULL) return OSSL_RECORD_RETURN_NON_FATAL_ERR; / ktls supports only the maximum fragment size / if (rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH) return OSSL_RECORD_RETURN_NON_FATAL_ERR; / check that cipher is supported / if (!ktls_int_check_supported_cipher(rl, ciph, md, taglen)) return OSSL_RECORD_RETURN_NON_FATAL_ERR; / All future data will get encrypted by ktls. Flush the BIO or skip ktls / if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) { if (BIO_flush(rl->bio) <= 0) return OSSL_RECORD_RETURN_NON_FATAL_ERR; / KTLS does not support record padding / if (rl->padding != NULL \|\| rl->block_padding > 0) return OSSL_RECORD_RETURN_NON_FATAL_ERR; } if (!ktls_configure_crypto(rl->libctx, rl->version, ciph, md, rl->sequence, &crypto_info, rl->direction == OSSL_RECORD_DIRECTION_WRITE, iv, ivlen, key, keylen, mackey, mackeylen)) return OSSL_RECORD_RETURN_NON_FATAL_ERR; if (!BIO_set_ktls(rl->bio, &crypto_info, rl->direction)) return OSSL_RECORD_RETURN_NON_FATAL_ERR; if (rl->direction == OSSL_RECORD_DIRECTION_WRITE && (rl->options & SSL_OP_ENABLE_KTLS_TX_ZEROCOPY_SENDFILE) != 0) / Ignore errors. The application opts in to using the zerocopy * optimization. If the running kernel doesn't support it, just * continue without the optimization. / BIO_set_ktls_tx_zerocopy_sendfile(rl->bio); return OSSL_RECORD_RETURN_SUCCESS; } static int ktls_read_n(OSSL_RECORD_LAYER rl, size_t n, size_t max, int extend, int clearold, size_t readbytes) { int ret; ret = tls_default_read_n(rl, n, max, extend, clearold, readbytes); if (ret < OSSL_RECORD_RETURN_RETRY) { switch (errno) { case EBADMSG: RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); break; case EMSGSIZE: RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_PACKET_LENGTH_TOO_LONG); break; case EINVAL: RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); break; default: break; } } return ret; } static int ktls_cipher(OSSL_RECORD_LAYER rl, TLS_RL_RECORD inrecs, size_t n_recs, int sending, SSL_MAC_BUF mac, size_t macsize) { return 1; } static int ktls_validate_record_header(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { if (rec->rec_version != TLS1_2_VERSION) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_WRONG_VERSION_NUMBER); return 0; } return 1; } static int ktls_post_process_record(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { if (rl->version == TLS1_3_VERSION) return tls13_common_post_process_record(rl, rec); return 1; } static int ktls_new_record_layer(OSSL_LIB_CTX libctx, const char propq, int vers, int role, int direction, int level, uint16_t epoch, unsigned char secret, size_t secretlen, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp, const EVP_MD kdfdigest, BIO prev, BIO transport, BIO next, BIO_ADDR local, BIO_ADDR peer, const OSSL_PARAM settings, const OSSL_PARAM options, const OSSL_DISPATCH fns, void cbarg, void rlarg, OSSL_RECORD_LAYER *retrl) { int ret; ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp, prev, transport, next, local, peer, settings, options, fns, cbarg, retrl); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; (retrl)->funcs = &ossl_ktls_funcs; ret = (retrl)->funcs->set_crypto_state(retrl, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp); if (ret != OSSL_RECORD_RETURN_SUCCESS) { OPENSSL_free(retrl); retrl = NULL; } else { /* * With KTLS we always try and read as much as possible and fill the * buffer / (retrl)->read_ahead = 1; } return ret; } static int ktls_allocate_write_buffers(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, size_t prefix) { if (!ossl_assert(numtempl == 1)) return 0; / * We just use the end application buffer in the case of KTLS, so nothing * to do. We pretend we set up one buffer. / rl->numwpipes = 1; return 1; } static int ktls_initialise_write_packets(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, OSSL_RECORD_TEMPLATE prefixtempl, WPACKET pkt, TLS_BUFFER bufs, size_t wpinited) { TLS_BUFFER wb; /* * We just use the application buffer directly and don't use any WPACKET * structures / wb = &bufs[0]; wb->type = templates[0].type; / * ktls doesn't modify the buffer, but to avoid a warning we need * to discard the const qualifier. * This doesn't leak memory because the buffers have never been allocated * with KTLS / TLS_BUFFER_set_buf(wb, (unsigned char )templates[0].buf); TLS_BUFFER_set_offset(wb, 0); TLS_BUFFER_set_app_buffer(wb, 1); return 1; } static int ktls_prepare_record_header(OSSL_RECORD_LAYER rl, WPACKET thispkt, OSSL_RECORD_TEMPLATE templ, uint8_t rectype, unsigned char recdata) { / The kernel writes the record header, so nothing to do / recdata = NULL; return 1; } static int ktls_prepare_for_encryption(OSSL_RECORD_LAYER rl, size_t mac_size, WPACKET thispkt, TLS_RL_RECORD thiswr) { / No encryption, so nothing to do / return 1; } static int ktls_post_encryption_processing(OSSL_RECORD_LAYER rl, size_t mac_size, OSSL_RECORD_TEMPLATE templ, WPACKET thispkt, TLS_RL_RECORD thiswr) { / The kernel does anything that is needed, so nothing to do here / return 1; } static int ktls_prepare_write_bio(OSSL_RECORD_LAYER rl, int type) { /* * To prevent coalescing of control and data messages, * such as in buffer_write, we flush the BIO / if (type != SSL3_RT_APPLICATION_DATA) { int ret, i = BIO_flush(rl->bio); if (i <= 0) { if (BIO_should_retry(rl->bio)) ret = OSSL_RECORD_RETURN_RETRY; else ret = OSSL_RECORD_RETURN_FATAL; return ret; } BIO_set_ktls_ctrl_msg(rl->bio, type); } return OSSL_RECORD_RETURN_SUCCESS; } static int ktls_alloc_buffers(OSSL_RECORD_LAYER rl) { /* We use the application buffer directly for writing / if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) return 1; return tls_alloc_buffers(rl); } static int ktls_free_buffers(OSSL_RECORD_LAYER rl) { /* We use the application buffer directly for writing */ if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) return 1; return tls_free_buffers(rl); } static struct record_functions_st ossl_ktls_funcs = { ktls_set_crypto_state, ktls_cipher, NULL, tls_default_set_protocol_version, ktls_read_n, tls_get_more_records, ktls_validate_record_header, ktls_post_process_record, tls_get_max_records_default, tls_write_records_default, ktls_allocate_write_buffers, ktls_initialise_write_packets, NULL, ktls_prepare_record_header, NULL, ktls_prepare_for_encryption, ktls_post_encryption_processing, ktls_prepare_write_bio }; const OSSL_RECORD_METHOD ossl_ktls_record_method = { ktls_new_record_layer, tls_free, tls_unprocessed_read_pending, tls_processed_read_pending, tls_app_data_pending, tls_get_max_records, tls_write_records, tls_retry_write_records, tls_read_record, tls_release_record, tls_get_alert_code, tls_set1_bio, tls_set_protocol_version, tls_set_plain_alerts, tls_set_first_handshake, tls_set_max_pipelines, NULL, tls_get_state, tls_set_options, tls_get_compression, tls_set_max_frag_len, NULL, tls_increment_sequence_ctr, ktls_alloc_buffers, ktls_free_buffers };
./openssl/ssl/record/methods/tls_common.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <assert.h> #include <openssl/bio.h> #include <openssl/ssl.h> #include <openssl/err.h> #include <openssl/core_names.h> #include <openssl/comp.h> #include <openssl/ssl.h> #include "internal/e_os.h" #include "internal/packet.h" #include "internal/ssl3_cbc.h" #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" static void tls_int_free(OSSL_RECORD_LAYER rl); void ossl_tls_buffer_release(TLS_BUFFER b) { OPENSSL_free(b->buf); b->buf = NULL; } static void TLS_RL_RECORD_release(TLS_RL_RECORD r, size_t num_recs) { size_t i; for (i = 0; i < num_recs; i++) { OPENSSL_free(r[i].comp); r[i].comp = NULL; } } void ossl_tls_rl_record_set_seq_num(TLS_RL_RECORD r, const unsigned char seq_num) { memcpy(r->seq_num, seq_num, SEQ_NUM_SIZE); } void ossl_rlayer_fatal(OSSL_RECORD_LAYER rl, int al, int reason, const char fmt, ...) { va_list args; va_start(args, fmt); ERR_vset_error(ERR_LIB_SSL, reason, fmt, args); va_end(args); rl->alert = al; } int ossl_set_tls_provider_parameters(OSSL_RECORD_LAYER rl, EVP_CIPHER_CTX ctx, const EVP_CIPHER ciph, const EVP_MD md) { /* * Provided cipher, the TLS padding/MAC removal is performed provider * side so we need to tell the ctx about our TLS version and mac size / OSSL_PARAM params[3], pprm = params; size_t macsize = 0; int imacsize = -1; if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) == 0 && !rl->use_etm) imacsize = EVP_MD_get_size(md); if (imacsize >= 0) macsize = (size_t)imacsize; pprm++ = OSSL_PARAM_construct_int(OSSL_CIPHER_PARAM_TLS_VERSION, &rl->version); pprm++ = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, &macsize); pprm = OSSL_PARAM_construct_end(); if (!EVP_CIPHER_CTX_set_params(ctx, params)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } return 1; } / * ssl3_cbc_record_digest_supported returns 1 iff \|ctx\| uses a hash function * which ssl3_cbc_digest_record supports. / char ssl3_cbc_record_digest_supported(const EVP_MD_CTX ctx) { switch (EVP_MD_CTX_get_type(ctx)) { case NID_md5: case NID_sha1: case NID_sha224: case NID_sha256: case NID_sha384: case NID_sha512: return 1; default: return 0; } } #ifndef OPENSSL_NO_COMP static int tls_allow_compression(OSSL_RECORD_LAYER rl) { if (rl->options & SSL_OP_NO_COMPRESSION) return 0; return rl->security == NULL \|\| rl->security(rl->cbarg, SSL_SECOP_COMPRESSION, 0, 0, NULL); } #endif static void tls_release_write_buffer_int(OSSL_RECORD_LAYER rl, size_t start) { TLS_BUFFER wb; size_t pipes; pipes = rl->numwpipes; while (pipes > start) { wb = &rl->wbuf[pipes - 1]; if (TLS_BUFFER_is_app_buffer(wb)) TLS_BUFFER_set_app_buffer(wb, 0); else OPENSSL_free(wb->buf); wb->buf = NULL; pipes--; } } int tls_setup_write_buffer(OSSL_RECORD_LAYER rl, size_t numwpipes, size_t firstlen, size_t nextlen) { unsigned char p; size_t align = 0, headerlen; TLS_BUFFER wb; size_t currpipe; size_t defltlen = 0; size_t contenttypelen = 0; if (firstlen == 0 \|\| (numwpipes > 1 && nextlen == 0)) { if (rl->isdtls) headerlen = DTLS1_RT_HEADER_LENGTH + 1; else headerlen = SSL3_RT_HEADER_LENGTH; /* TLSv1.3 adds an extra content type byte after payload data / if (rl->version == TLS1_3_VERSION) contenttypelen = 1; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = SSL3_ALIGN_PAYLOAD - 1; #endif defltlen = align + headerlen + rl->eivlen + rl->max_frag_len + contenttypelen + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD; #ifndef OPENSSL_NO_COMP if (tls_allow_compression(rl)) defltlen += SSL3_RT_MAX_COMPRESSED_OVERHEAD; #endif / * We don't need to add eivlen here since empty fragments only occur * when we don't have an explicit IV. The contenttype byte will also * always be 0 in these protocol versions / if ((rl->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) == 0) defltlen += headerlen + align + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD; } wb = rl->wbuf; for (currpipe = 0; currpipe < numwpipes; currpipe++) { TLS_BUFFER thiswb = &wb[currpipe]; size_t len = (currpipe == 0) ? firstlen : nextlen; if (len == 0) len = defltlen; if (thiswb->len != len) { OPENSSL_free(thiswb->buf); thiswb->buf = NULL; /* force reallocation / } p = thiswb->buf; if (p == NULL) { p = OPENSSL_malloc(len); if (p == NULL) { if (rl->numwpipes < currpipe) rl->numwpipes = currpipe; / * We've got a malloc failure, and we're still initialising * buffers. We assume we're so doomed that we won't even be able * to send an alert. / RLAYERfatal(rl, SSL_AD_NO_ALERT, ERR_R_CRYPTO_LIB); return 0; } } memset(thiswb, 0, sizeof(TLS_BUFFER)); thiswb->buf = p; thiswb->len = len; } / Free any previously allocated buffers that we are no longer using / tls_release_write_buffer_int(rl, currpipe); rl->numwpipes = numwpipes; return 1; } static void tls_release_write_buffer(OSSL_RECORD_LAYER rl) { tls_release_write_buffer_int(rl, 0); rl->numwpipes = 0; } int tls_setup_read_buffer(OSSL_RECORD_LAYER rl) { unsigned char p; size_t len, align = 0, headerlen; TLS_BUFFER b; b = &rl->rbuf; if (rl->isdtls) headerlen = DTLS1_RT_HEADER_LENGTH; else headerlen = SSL3_RT_HEADER_LENGTH; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (-SSL3_RT_HEADER_LENGTH) & (SSL3_ALIGN_PAYLOAD - 1); #endif if (b->buf == NULL) { len = rl->max_frag_len + SSL3_RT_MAX_ENCRYPTED_OVERHEAD + headerlen + align; #ifndef OPENSSL_NO_COMP if (tls_allow_compression(rl)) len += SSL3_RT_MAX_COMPRESSED_OVERHEAD; #endif / Ensure our buffer is large enough to support all our pipelines / if (rl->max_pipelines > 1) len = rl->max_pipelines; if (b->default_len > len) len = b->default_len; if ((p = OPENSSL_malloc(len)) == NULL) { /* * We've got a malloc failure, and we're still initialising buffers. * We assume we're so doomed that we won't even be able to send an * alert. / RLAYERfatal(rl, SSL_AD_NO_ALERT, ERR_R_CRYPTO_LIB); return 0; } b->buf = p; b->len = len; } return 1; } static int tls_release_read_buffer(OSSL_RECORD_LAYER rl) { TLS_BUFFER b; b = &rl->rbuf; if ((rl->options & SSL_OP_CLEANSE_PLAINTEXT) != 0) OPENSSL_cleanse(b->buf, b->len); OPENSSL_free(b->buf); b->buf = NULL; return 1; } / * Return values are as per SSL_read() / int tls_default_read_n(OSSL_RECORD_LAYER rl, size_t n, size_t max, int extend, int clearold, size_t readbytes) { / * If extend == 0, obtain new n-byte packet; if extend == 1, increase * packet by another n bytes. The packet will be in the sub-array of * rl->rbuf.buf specified by rl->packet and rl->packet_length. (If * rl->read_ahead is set, 'max' bytes may be stored in rbuf [plus * rl->packet_length bytes if extend == 1].) if clearold == 1, move the * packet to the start of the buffer; if clearold == 0 then leave any old * packets where they were / size_t len, left, align = 0; unsigned char pkt; TLS_BUFFER rb; if (n == 0) return OSSL_RECORD_RETURN_NON_FATAL_ERR; rb = &rl->rbuf; left = rb->left; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (size_t)rb->buf + SSL3_RT_HEADER_LENGTH; align = SSL3_ALIGN_PAYLOAD - 1 - ((align - 1) % SSL3_ALIGN_PAYLOAD); #endif if (!extend) { / start with empty packet ... / if (left == 0) rb->offset = align; rl->packet = rb->buf + rb->offset; rl->packet_length = 0; / ... now we can act as if 'extend' was set / } len = rl->packet_length; pkt = rb->buf + align; / * Move any available bytes to front of buffer: 'len' bytes already * pointed to by 'packet', 'left' extra ones at the end / if (rl->packet != pkt && clearold == 1) { memmove(pkt, rl->packet, len + left); rl->packet = pkt; rb->offset = len + align; } / * For DTLS/UDP reads should not span multiple packets because the read * operation returns the whole packet at once (as long as it fits into * the buffer). / if (rl->isdtls) { if (left == 0 && extend) { / * We received a record with a header but no body data. This will * get dumped. / return OSSL_RECORD_RETURN_NON_FATAL_ERR; } if (left > 0 && n > left) n = left; } / if there is enough in the buffer from a previous read, take some / if (left >= n) { rl->packet_length += n; rb->left = left - n; rb->offset += n; readbytes = n; return OSSL_RECORD_RETURN_SUCCESS; } /* else we need to read more data / if (n > rb->len - rb->offset) { / does not happen / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } / We always act like read_ahead is set for DTLS / if (!rl->read_ahead && !rl->isdtls) { / ignore max parameter / max = n; } else { if (max < n) max = n; if (max > rb->len - rb->offset) max = rb->len - rb->offset; } while (left < n) { size_t bioread = 0; int ret; BIO bio = rl->prev != NULL ? rl->prev : rl->bio; /* * Now we have len+left bytes at the front of rl->rbuf.buf and * need to read in more until we have len + n (up to len + max if * possible) / clear_sys_error(); if (bio != NULL) { ret = BIO_read(bio, pkt + len + left, max - left); if (ret > 0) { bioread = ret; ret = OSSL_RECORD_RETURN_SUCCESS; } else if (BIO_should_retry(bio)) { if (rl->prev != NULL) { / * We were reading from the previous epoch. Now there is no * more data, so swap to the actual transport BIO / BIO_free(rl->prev); rl->prev = NULL; continue; } ret = OSSL_RECORD_RETURN_RETRY; } else if (BIO_eof(bio)) { ret = OSSL_RECORD_RETURN_EOF; } else { ret = OSSL_RECORD_RETURN_FATAL; } } else { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_READ_BIO_NOT_SET); ret = OSSL_RECORD_RETURN_FATAL; } if (ret <= OSSL_RECORD_RETURN_RETRY) { rb->left = left; if ((rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0 && !rl->isdtls) if (len + left == 0) tls_release_read_buffer(rl); return ret; } left += bioread; / * reads should never span multiple packets for DTLS because the * underlying transport protocol is message oriented as opposed to * byte oriented as in the TLS case. / if (rl->isdtls) { if (n > left) n = left; / makes the while condition false / } } / done reading, now the book-keeping / rb->offset += n; rb->left = left - n; rl->packet_length += n; readbytes = n; return OSSL_RECORD_RETURN_SUCCESS; } /* * Peeks ahead into "read_ahead" data to see if we have a whole record waiting * for us in the buffer. / static int tls_record_app_data_waiting(OSSL_RECORD_LAYER rl) { TLS_BUFFER rbuf; size_t left, len; unsigned char p; rbuf = &rl->rbuf; p = TLS_BUFFER_get_buf(rbuf); if (p == NULL) return 0; left = TLS_BUFFER_get_left(rbuf); if (left < SSL3_RT_HEADER_LENGTH) return 0; p += TLS_BUFFER_get_offset(rbuf); /* * We only check the type and record length, we will sanity check version * etc later / if (p != SSL3_RT_APPLICATION_DATA) return 0; p += 3; n2s(p, len); if (left < SSL3_RT_HEADER_LENGTH + len) return 0; return 1; } static int rlayer_early_data_count_ok(OSSL_RECORD_LAYER rl, size_t length, size_t overhead, int send) { uint32_t max_early_data = rl->max_early_data; if (max_early_data == 0) { RLAYERfatal(rl, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MUCH_EARLY_DATA); return 0; } / If we are dealing with ciphertext we need to allow for the overhead / max_early_data += overhead; if (rl->early_data_count + length > max_early_data) { RLAYERfatal(rl, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MUCH_EARLY_DATA); return 0; } rl->early_data_count += length; return 1; } / * MAX_EMPTY_RECORDS defines the number of consecutive, empty records that * will be processed per call to tls_get_more_records. Without this limit an * attacker could send empty records at a faster rate than we can process and * cause tls_get_more_records to loop forever. / #define MAX_EMPTY_RECORDS 32 #define SSL2_RT_HEADER_LENGTH 2 /- * Call this to buffer new input records in rl->rrec. * It will return a OSSL_RECORD_RETURN_* value. * When it finishes successfully (OSSL_RECORD_RETURN_SUCCESS), \|rl->num_recs\| * records have been decoded. For each record 'i': * rrec[i].type - is the type of record * rrec[i].data, - data * rrec[i].length, - number of bytes * Multiple records will only be returned if the record types are all * SSL3_RT_APPLICATION_DATA. The number of records returned will always be <= * \|max_pipelines\| / int tls_get_more_records(OSSL_RECORD_LAYER rl) { int enc_err, rret; int i; size_t more, n; TLS_RL_RECORD rr, thisrr; TLS_BUFFER rbuf; unsigned char p; unsigned char md[EVP_MAX_MD_SIZE]; unsigned int version; size_t mac_size = 0; int imac_size; size_t num_recs = 0, max_recs, j; PACKET pkt, sslv2pkt; SSL_MAC_BUF macbufs = NULL; int ret = OSSL_RECORD_RETURN_FATAL; rr = rl->rrec; rbuf = &rl->rbuf; if (rbuf->buf == NULL) { if (!tls_setup_read_buffer(rl)) { / RLAYERfatal() already called / return OSSL_RECORD_RETURN_FATAL; } } max_recs = rl->max_pipelines; if (max_recs == 0) max_recs = 1; do { thisrr = &rr[num_recs]; / check if we have the header / if ((rl->rstate != SSL_ST_READ_BODY) \|\| (rl->packet_length < SSL3_RT_HEADER_LENGTH)) { size_t sslv2len; unsigned int type; rret = rl->funcs->read_n(rl, SSL3_RT_HEADER_LENGTH, TLS_BUFFER_get_len(rbuf), 0, num_recs == 0 ? 1 : 0, &n); if (rret < OSSL_RECORD_RETURN_SUCCESS) return rret; / error or non-blocking / rl->rstate = SSL_ST_READ_BODY; p = rl->packet; if (!PACKET_buf_init(&pkt, p, rl->packet_length)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } sslv2pkt = pkt; if (!PACKET_get_net_2_len(&sslv2pkt, &sslv2len) \|\| !PACKET_get_1(&sslv2pkt, &type)) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } / * The first record received by the server may be a V2ClientHello. / if (rl->role == OSSL_RECORD_ROLE_SERVER && rl->is_first_record && (sslv2len & 0x8000) != 0 && (type == SSL2_MT_CLIENT_HELLO)) { / * SSLv2 style record * * \|num_recs\| here will actually always be 0 because * \|num_recs > 0\| only ever occurs when we are processing * multiple app data records - which we know isn't the case here * because it is an SSLv2ClientHello. We keep it using * \|num_recs\| for the sake of consistency / thisrr->type = SSL3_RT_HANDSHAKE; thisrr->rec_version = SSL2_VERSION; thisrr->length = sslv2len & 0x7fff; if (thisrr->length > TLS_BUFFER_get_len(rbuf) - SSL2_RT_HEADER_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_PACKET_LENGTH_TOO_LONG); return OSSL_RECORD_RETURN_FATAL; } } else { / SSLv3+ style record / / Pull apart the header into the TLS_RL_RECORD / if (!PACKET_get_1(&pkt, &type) \|\| !PACKET_get_net_2(&pkt, &version) \|\| !PACKET_get_net_2_len(&pkt, &thisrr->length)) { if (rl->msg_callback != NULL) rl->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, rl->cbarg); RLAYERfatal(rl, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } thisrr->type = type; thisrr->rec_version = version; / * When we call validate_record_header() only records actually * received in SSLv2 format should have the record version set * to SSL2_VERSION. This way validate_record_header() can know * what format the record was in based on the version. / if (thisrr->rec_version == SSL2_VERSION) { RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); return OSSL_RECORD_RETURN_FATAL; } if (rl->msg_callback != NULL) rl->msg_callback(0, version, SSL3_RT_HEADER, p, 5, rl->cbarg); if (thisrr->length > TLS_BUFFER_get_len(rbuf) - SSL3_RT_HEADER_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_PACKET_LENGTH_TOO_LONG); return OSSL_RECORD_RETURN_FATAL; } } if (!rl->funcs->validate_record_header(rl, thisrr)) { / RLAYERfatal already called / return OSSL_RECORD_RETURN_FATAL; } / now rl->rstate == SSL_ST_READ_BODY / } / * rl->rstate == SSL_ST_READ_BODY, get and decode the data. Calculate * how much more data we need to read for the rest of the record / if (thisrr->rec_version == SSL2_VERSION) { more = thisrr->length + SSL2_RT_HEADER_LENGTH - SSL3_RT_HEADER_LENGTH; } else { more = thisrr->length; } if (more > 0) { / now rl->packet_length == SSL3_RT_HEADER_LENGTH / rret = rl->funcs->read_n(rl, more, more, 1, 0, &n); if (rret < OSSL_RECORD_RETURN_SUCCESS) return rret; / error or non-blocking io / } / set state for later operations / rl->rstate = SSL_ST_READ_HEADER; / * At this point, rl->packet_length == SSL3_RT_HEADER_LENGTH * + thisrr->length, or rl->packet_length == SSL2_RT_HEADER_LENGTH * + thisrr->length and we have that many bytes in rl->packet / if (thisrr->rec_version == SSL2_VERSION) thisrr->input = &(rl->packet[SSL2_RT_HEADER_LENGTH]); else thisrr->input = &(rl->packet[SSL3_RT_HEADER_LENGTH]); / * ok, we can now read from 'rl->packet' data into 'thisrr'. * thisrr->input points at thisrr->length bytes, which need to be copied * into thisrr->data by either the decryption or by the decompression. * When the data is 'copied' into the thisrr->data buffer, * thisrr->input will be updated to point at the new buffer / / * We now have - encrypted [ MAC [ compressed [ plain ] ] ] * thisrr->length bytes of encrypted compressed stuff. / / decrypt in place in 'thisrr->input' / thisrr->data = thisrr->input; thisrr->orig_len = thisrr->length; num_recs++; / we have pulled in a full packet so zero things / rl->packet_length = 0; rl->is_first_record = 0; } while (num_recs < max_recs && thisrr->type == SSL3_RT_APPLICATION_DATA && RLAYER_USE_EXPLICIT_IV(rl) && rl->enc_ctx != NULL && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx)) & EVP_CIPH_FLAG_PIPELINE) != 0 && tls_record_app_data_waiting(rl)); if (num_recs == 1 && thisrr->type == SSL3_RT_CHANGE_CIPHER_SPEC / The following can happen in tlsany_meth after HRR / && rl->version == TLS1_3_VERSION && rl->is_first_handshake) { / * CCS messages must be exactly 1 byte long, containing the value 0x01 / if (thisrr->length != 1 \|\| thisrr->data[0] != 0x01) { RLAYERfatal(rl, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_CCS_MESSAGE); return OSSL_RECORD_RETURN_FATAL; } / * CCS messages are ignored in TLSv1.3. We treat it like an empty * handshake record / thisrr->type = SSL3_RT_HANDSHAKE; if (++(rl->empty_record_count) > MAX_EMPTY_RECORDS) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_CCS_MESSAGE); return OSSL_RECORD_RETURN_FATAL; } rl->num_recs = 0; rl->curr_rec = 0; rl->num_released = 0; return OSSL_RECORD_RETURN_SUCCESS; } if (rl->md_ctx != NULL) { const EVP_MD tmpmd = EVP_MD_CTX_get0_md(rl->md_ctx); if (tmpmd != NULL) { imac_size = EVP_MD_get_size(tmpmd); if (!ossl_assert(imac_size >= 0 && imac_size <= EVP_MAX_MD_SIZE)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return OSSL_RECORD_RETURN_FATAL; } mac_size = (size_t)imac_size; } } /* * If in encrypt-then-mac mode calculate mac from encrypted record. All * the details below are public so no timing details can leak. / if (rl->use_etm && rl->md_ctx != NULL) { unsigned char mac; for (j = 0; j < num_recs; j++) { thisrr = &rr[j]; if (thisrr->length < mac_size) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); return OSSL_RECORD_RETURN_FATAL; } thisrr->length -= mac_size; mac = thisrr->data + thisrr->length; i = rl->funcs->mac(rl, thisrr, md, 0 /* not send /); if (i == 0 \|\| CRYPTO_memcmp(md, mac, mac_size) != 0) { RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); return OSSL_RECORD_RETURN_FATAL; } } / * We've handled the mac now - there is no MAC inside the encrypted * record / mac_size = 0; } if (mac_size > 0) { macbufs = OPENSSL_zalloc(sizeof(macbufs) * num_recs); if (macbufs == NULL) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return OSSL_RECORD_RETURN_FATAL; } } ERR_set_mark(); enc_err = rl->funcs->cipher(rl, rr, num_recs, 0, macbufs, mac_size); /- enc_err is: * 0: if the record is publicly invalid, or an internal error, or AEAD * decryption failed, or ETM decryption failed. * 1: Success or MTE decryption failed (MAC will be randomised) / if (enc_err == 0) { if (rl->alert != SSL_AD_NO_ALERT) { / RLAYERfatal() already got called / ERR_clear_last_mark(); goto end; } if (num_recs == 1 && rl->skip_early_data != NULL && rl->skip_early_data(rl->cbarg)) { / * Valid early_data that we cannot decrypt will fail here. We treat * it like an empty record. / / * Remove any errors from the stack. Decryption failures are normal * behaviour. / ERR_pop_to_mark(); thisrr = &rr[0]; if (!rlayer_early_data_count_ok(rl, thisrr->length, EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) { / RLAYERfatal() already called / goto end; } thisrr->length = 0; rl->num_recs = 0; rl->curr_rec = 0; rl->num_released = 0; / Reset the read sequence / memset(rl->sequence, 0, sizeof(rl->sequence)); ret = 1; goto end; } ERR_clear_last_mark(); RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); goto end; } else { ERR_clear_last_mark(); } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "dec %lu\n", (unsigned long)rr[0].length); BIO_dump_indent(trc_out, rr[0].data, rr[0].length, 4); } OSSL_TRACE_END(TLS); / r->length is now the compressed data plus mac / if (rl->enc_ctx != NULL && !rl->use_etm && EVP_MD_CTX_get0_md(rl->md_ctx) != NULL) { for (j = 0; j < num_recs; j++) { SSL_MAC_BUF thismb = &macbufs[j]; thisrr = &rr[j]; i = rl->funcs->mac(rl, thisrr, md, 0 /* not send /); if (i == 0 \|\| thismb == NULL \|\| thismb->mac == NULL \|\| CRYPTO_memcmp(md, thismb->mac, (size_t)mac_size) != 0) enc_err = 0; if (thisrr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size) enc_err = 0; #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if (enc_err == 0 && mac_size > 0 && thismb != NULL && thismb->mac != NULL && (md[0] ^ thismb->mac[0]) != 0xFF) { enc_err = 1; } #endif } } if (enc_err == 0) { if (rl->alert != SSL_AD_NO_ALERT) { / We already called RLAYERfatal() / goto end; } / * A separate 'decryption_failed' alert was introduced with TLS 1.0, * SSL 3.0 only has 'bad_record_mac'. But unless a decryption * failure is directly visible from the ciphertext anyway, we should * not reveal which kind of error occurred -- this might become * visible to an attacker (e.g. via a logfile) / RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); goto end; } for (j = 0; j < num_recs; j++) { thisrr = &rr[j]; if (!rl->funcs->post_process_record(rl, thisrr)) { / RLAYERfatal already called / goto end; } / * Record overflow checking (e.g. checking if * thisrr->length > SSL3_RT_MAX_PLAIN_LENGTH) is the responsibility of * the post_process_record() function above. However we check here if * the received packet overflows the current Max Fragment Length setting * if there is one. * Note: rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH and KTLS are * mutually exclusive. Also note that with KTLS thisrr->length can * be > SSL3_RT_MAX_PLAIN_LENGTH (and rl->max_frag_len must be ignored) / if (rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH && thisrr->length > rl->max_frag_len) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); goto end; } thisrr->off = 0; /- * So at this point the following is true * thisrr->type is the type of record * thisrr->length == number of bytes in record * thisrr->off == offset to first valid byte * thisrr->data == where to take bytes from, increment after use :-). / / just read a 0 length packet / if (thisrr->length == 0) { if (++(rl->empty_record_count) > MAX_EMPTY_RECORDS) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_RECORD_TOO_SMALL); goto end; } } else { rl->empty_record_count = 0; } } if (rl->level == OSSL_RECORD_PROTECTION_LEVEL_EARLY) { thisrr = &rr[0]; if (thisrr->type == SSL3_RT_APPLICATION_DATA && !rlayer_early_data_count_ok(rl, thisrr->length, 0, 0)) { / RLAYERfatal already called / goto end; } } rl->num_recs = num_recs; rl->curr_rec = 0; rl->num_released = 0; ret = OSSL_RECORD_RETURN_SUCCESS; end: if (macbufs != NULL) { for (j = 0; j < num_recs; j++) { if (macbufs[j].alloced) OPENSSL_free(macbufs[j].mac); } OPENSSL_free(macbufs); } return ret; } / Shared by ssl3_meth and tls1_meth / int tls_default_validate_record_header(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { size_t len = SSL3_RT_MAX_ENCRYPTED_LENGTH; if (rec->rec_version != rl->version) { RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); return 0; } #ifndef OPENSSL_NO_COMP / * If OPENSSL_NO_COMP is defined then SSL3_RT_MAX_ENCRYPTED_LENGTH * does not include the compression overhead anyway. / if (rl->compctx == NULL) len -= SSL3_RT_MAX_COMPRESSED_OVERHEAD; #endif if (rec->length > len) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_ENCRYPTED_LENGTH_TOO_LONG); return 0; } return 1; } int tls_do_compress(OSSL_RECORD_LAYER rl, TLS_RL_RECORD wr) { #ifndef OPENSSL_NO_COMP int i; i = COMP_compress_block(rl->compctx, wr->data, (int)(wr->length + SSL3_RT_MAX_COMPRESSED_OVERHEAD), wr->input, (int)wr->length); if (i < 0) return 0; wr->length = i; wr->input = wr->data; return 1; #else return 0; #endif } int tls_do_uncompress(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { #ifndef OPENSSL_NO_COMP int i; if (rec->comp == NULL) { rec->comp = (unsigned char ) OPENSSL_malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH); } if (rec->comp == NULL) return 0; i = COMP_expand_block(rl->compctx, rec->comp, SSL3_RT_MAX_PLAIN_LENGTH, rec->data, (int)rec->length); if (i < 0) return 0; else rec->length = i; rec->data = rec->comp; return 1; #else return 0; #endif } /* Shared by tlsany_meth, ssl3_meth and tls1_meth / int tls_default_post_process_record(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { if (rl->compctx != NULL) { if (rec->length > SSL3_RT_MAX_COMPRESSED_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_COMPRESSED_LENGTH_TOO_LONG); return 0; } if (!tls_do_uncompress(rl, rec)) { RLAYERfatal(rl, SSL_AD_DECOMPRESSION_FAILURE, SSL_R_BAD_DECOMPRESSION); return 0; } } if (rec->length > SSL3_RT_MAX_PLAIN_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } return 1; } / Shared by tls13_meth and ktls_meth / int tls13_common_post_process_record(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { if (rec->type != SSL3_RT_APPLICATION_DATA && rec->type != SSL3_RT_ALERT && rec->type != SSL3_RT_HANDSHAKE) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_RECORD_TYPE); return 0; } if (rl->msg_callback != NULL) rl->msg_callback(0, rl->version, SSL3_RT_INNER_CONTENT_TYPE, &rec->type, 1, rl->cbarg); / * TLSv1.3 alert and handshake records are required to be non-zero in * length. / if ((rec->type == SSL3_RT_HANDSHAKE \|\| rec->type == SSL3_RT_ALERT) && rec->length == 0) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_LENGTH); return 0; } return 1; } int tls_read_record(OSSL_RECORD_LAYER rl, void *rechandle, int rversion, uint8_t type, const unsigned char data, size_t datalen, uint16_t epoch, unsigned char seq_num) { TLS_RL_RECORD rec; / * tls_get_more_records() can return success without actually reading * anything useful (i.e. if empty records are read). We loop here until * we have something useful. tls_get_more_records() will eventually fail if * too many sequential empty records are read. / while (rl->curr_rec >= rl->num_recs) { int ret; if (rl->num_released != rl->num_recs) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_RECORDS_NOT_RELEASED); return OSSL_RECORD_RETURN_FATAL; } ret = rl->funcs->get_more_records(rl); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; } / * We have now got rl->num_recs records buffered in rl->rrec. rl->curr_rec * points to the next one to read. / rec = &rl->rrec[rl->curr_rec++]; rechandle = rec; rversion = rec->rec_version; type = rec->type; data = rec->data + rec->off; datalen = rec->length; if (rl->isdtls) { epoch = rec->epoch; memcpy(seq_num, rec->seq_num, sizeof(rec->seq_num)); } return OSSL_RECORD_RETURN_SUCCESS; } int tls_release_record(OSSL_RECORD_LAYER rl, void rechandle, size_t length) { TLS_RL_RECORD rec = &rl->rrec[rl->num_released]; if (!ossl_assert(rl->num_released < rl->curr_rec) \|\| !ossl_assert(rechandle == rec)) { /* Should not happen / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_INVALID_RECORD); return OSSL_RECORD_RETURN_FATAL; } if (rec->length < length) { / Should not happen / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } if ((rl->options & SSL_OP_CLEANSE_PLAINTEXT) != 0) OPENSSL_cleanse(rec->data + rec->off, length); rec->off += length; rec->length -= length; if (rec->length > 0) return OSSL_RECORD_RETURN_SUCCESS; rl->num_released++; if (rl->curr_rec == rl->num_released && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0 && TLS_BUFFER_get_left(&rl->rbuf) == 0) tls_release_read_buffer(rl); return OSSL_RECORD_RETURN_SUCCESS; } int tls_set_options(OSSL_RECORD_LAYER rl, const OSSL_PARAM options) { const OSSL_PARAM p; p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS); if (p != NULL && !OSSL_PARAM_get_uint64(p, &rl->options)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE); if (p != NULL && !OSSL_PARAM_get_uint32(p, &rl->mode)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } if (rl->direction == OSSL_RECORD_DIRECTION_READ) { p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN); if (p != NULL && !OSSL_PARAM_get_size_t(p, &rl->rbuf.default_len)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } } else { p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING); if (p != NULL && !OSSL_PARAM_get_size_t(p, &rl->block_padding)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } } if (rl->level == OSSL_RECORD_PROTECTION_LEVEL_APPLICATION) { /* * We ignore any read_ahead setting prior to the application protection * level. Otherwise we may read ahead data in a lower protection level * that is destined for a higher protection level. To simplify the logic * we don't support that at this stage. / p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD); if (p != NULL && !OSSL_PARAM_get_int(p, &rl->read_ahead)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } } return 1; } int tls_int_new_record_layer(OSSL_LIB_CTX libctx, const char propq, int vers, int role, int direction, int level, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp, BIO prev, BIO transport, BIO next, BIO_ADDR local, BIO_ADDR peer, const OSSL_PARAM settings, const OSSL_PARAM options, const OSSL_DISPATCH fns, void cbarg, OSSL_RECORD_LAYER *retrl) { OSSL_RECORD_LAYER rl = OPENSSL_zalloc(sizeof(rl)); const OSSL_PARAM p; retrl = NULL; if (rl == NULL) return OSSL_RECORD_RETURN_FATAL; / * Default the value for max_frag_len. This may be overridden by the * settings / rl->max_frag_len = SSL3_RT_MAX_PLAIN_LENGTH; / Loop through all the settings since they must all be understood / if (settings != NULL) { for (p = settings; p->key != NULL; p++) { if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM) == 0) { if (!OSSL_PARAM_get_int(p, &rl->use_etm)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN) == 0) { if (!OSSL_PARAM_get_uint(p, &rl->max_frag_len)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA) == 0) { if (!OSSL_PARAM_get_uint32(p, &rl->max_early_data)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC) == 0) { if (!OSSL_PARAM_get_int(p, &rl->stream_mac)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE) == 0) { if (!OSSL_PARAM_get_int(p, &rl->tlstree)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_MANDATORY_PARAMETER); goto err; } } } rl->libctx = libctx; rl->propq = propq; rl->version = vers; rl->role = role; rl->direction = direction; rl->level = level; rl->taglen = taglen; rl->md = md; rl->alert = SSL_AD_NO_ALERT; rl->rstate = SSL_ST_READ_HEADER; if (level == OSSL_RECORD_PROTECTION_LEVEL_NONE) rl->is_first_record = 1; if (!tls_set1_bio(rl, transport)) goto err; if (prev != NULL && !BIO_up_ref(prev)) goto err; rl->prev = prev; if (next != NULL && !BIO_up_ref(next)) goto err; rl->next = next; rl->cbarg = cbarg; if (fns != NULL) { for (; fns->function_id != 0; fns++) { switch (fns->function_id) { case OSSL_FUNC_RLAYER_SKIP_EARLY_DATA: rl->skip_early_data = OSSL_FUNC_rlayer_skip_early_data(fns); break; case OSSL_FUNC_RLAYER_MSG_CALLBACK: rl->msg_callback = OSSL_FUNC_rlayer_msg_callback(fns); break; case OSSL_FUNC_RLAYER_SECURITY: rl->security = OSSL_FUNC_rlayer_security(fns); break; case OSSL_FUNC_RLAYER_PADDING: rl->padding = OSSL_FUNC_rlayer_padding(fns); default: / Just ignore anything we don't understand / break; } } } if (!tls_set_options(rl, options)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } if ((rl->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) == 0 && rl->version <= TLS1_VERSION && !EVP_CIPHER_is_a(ciph, "NULL") && !EVP_CIPHER_is_a(ciph, "RC4")) { / * Enable vulnerability countermeasure for CBC ciphers with known-IV * problem (http://www.openssl.org/~bodo/tls-cbc.txt) / rl->need_empty_fragments = 1; } retrl = rl; return OSSL_RECORD_RETURN_SUCCESS; err: tls_int_free(rl); return OSSL_RECORD_RETURN_FATAL; } static int tls_new_record_layer(OSSL_LIB_CTX libctx, const char propq, int vers, int role, int direction, int level, uint16_t epoch, unsigned char secret, size_t secretlen, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp, const EVP_MD kdfdigest, BIO prev, BIO transport, BIO next, BIO_ADDR local, BIO_ADDR peer, const OSSL_PARAM settings, const OSSL_PARAM options, const OSSL_DISPATCH fns, void cbarg, void rlarg, OSSL_RECORD_LAYER *retrl) { int ret; ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp, prev, transport, next, local, peer, settings, options, fns, cbarg, retrl); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; switch (vers) { case TLS_ANY_VERSION: (retrl)->funcs = &tls_any_funcs; break; case TLS1_3_VERSION: (retrl)->funcs = &tls_1_3_funcs; break; case TLS1_2_VERSION: case TLS1_1_VERSION: case TLS1_VERSION: (retrl)->funcs = &tls_1_funcs; break; case SSL3_VERSION: (retrl)->funcs = &ssl_3_0_funcs; break; default: / Should not happen / ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); ret = OSSL_RECORD_RETURN_FATAL; goto err; } ret = (retrl)->funcs->set_crypto_state(retrl, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp); err: if (ret != OSSL_RECORD_RETURN_SUCCESS) { tls_int_free(retrl); retrl = NULL; } return ret; } static void tls_int_free(OSSL_RECORD_LAYER rl) { BIO_free(rl->prev); BIO_free(rl->bio); BIO_free(rl->next); ossl_tls_buffer_release(&rl->rbuf); tls_release_write_buffer(rl); EVP_CIPHER_CTX_free(rl->enc_ctx); EVP_MD_CTX_free(rl->md_ctx); #ifndef OPENSSL_NO_COMP COMP_CTX_free(rl->compctx); #endif if (rl->version == SSL3_VERSION) OPENSSL_cleanse(rl->mac_secret, sizeof(rl->mac_secret)); TLS_RL_RECORD_release(rl->rrec, SSL_MAX_PIPELINES); OPENSSL_free(rl); } int tls_free(OSSL_RECORD_LAYER rl) { TLS_BUFFER rbuf; size_t left, written; int ret = 1; if (rl == NULL) return 1; rbuf = &rl->rbuf; left = TLS_BUFFER_get_left(rbuf); if (left > 0) { /* * This record layer is closing but we still have data left in our * buffer. It must be destined for the next epoch - so push it there. / ret = BIO_write_ex(rl->next, rbuf->buf + rbuf->offset, left, &written); } tls_int_free(rl); return ret; } int tls_unprocessed_read_pending(OSSL_RECORD_LAYER rl) { return TLS_BUFFER_get_left(&rl->rbuf) != 0; } int tls_processed_read_pending(OSSL_RECORD_LAYER rl) { return rl->curr_rec < rl->num_recs; } size_t tls_app_data_pending(OSSL_RECORD_LAYER rl) { size_t i; size_t num = 0; for (i = rl->curr_rec; i < rl->num_recs; i++) { if (rl->rrec[i].type != SSL3_RT_APPLICATION_DATA) return num; num += rl->rrec[i].length; } return num; } size_t tls_get_max_records_default(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t maxfrag, size_t preffrag) { /* * If we have a pipeline capable cipher, and we have been configured to use * it, then return the preferred number of pipelines. / if (rl->max_pipelines > 0 && rl->enc_ctx != NULL && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx)) & EVP_CIPH_FLAG_PIPELINE) != 0 && RLAYER_USE_EXPLICIT_IV(rl)) { size_t pipes; if (len == 0) return 1; pipes = ((len - 1) / preffrag) + 1; return (pipes < rl->max_pipelines) ? pipes : rl->max_pipelines; } return 1; } size_t tls_get_max_records(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t maxfrag, size_t preffrag) { return rl->funcs->get_max_records(rl, type, len, maxfrag, preffrag); } int tls_allocate_write_buffers_default(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, size_t prefix) { if (!tls_setup_write_buffer(rl, numtempl, 0, 0)) { / RLAYERfatal() already called / return 0; } return 1; } int tls_initialise_write_packets_default(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, OSSL_RECORD_TEMPLATE prefixtempl, WPACKET pkt, TLS_BUFFER bufs, size_t wpinited) { WPACKET thispkt; size_t j, align; TLS_BUFFER wb; for (j = 0; j < numtempl; j++) { thispkt = &pkt[j]; wb = &bufs[j]; wb->type = templates[j].type; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (size_t)TLS_BUFFER_get_buf(wb); align += rl->isdtls ? DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH; align = SSL3_ALIGN_PAYLOAD - 1 - ((align - 1) % SSL3_ALIGN_PAYLOAD); #endif TLS_BUFFER_set_offset(wb, align); if (!WPACKET_init_static_len(thispkt, TLS_BUFFER_get_buf(wb), TLS_BUFFER_get_len(wb), 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } (wpinited)++; if (!WPACKET_allocate_bytes(thispkt, align, NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_prepare_record_header_default(OSSL_RECORD_LAYER rl, WPACKET thispkt, OSSL_RECORD_TEMPLATE templ, uint8_t rectype, unsigned char recdata) { size_t maxcomplen; recdata = NULL; maxcomplen = templ->buflen; if (rl->compctx != NULL) maxcomplen += SSL3_RT_MAX_COMPRESSED_OVERHEAD; if (!WPACKET_put_bytes_u8(thispkt, rectype) \|\| !WPACKET_put_bytes_u16(thispkt, templ->version) \|\| !WPACKET_start_sub_packet_u16(thispkt) \|\| (rl->eivlen > 0 && !WPACKET_allocate_bytes(thispkt, rl->eivlen, NULL)) \|\| (maxcomplen > 0 && !WPACKET_reserve_bytes(thispkt, maxcomplen, recdata))) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER rl, size_t mac_size, WPACKET thispkt, TLS_RL_RECORD thiswr) { size_t len; unsigned char recordstart; /* * we should still have the output to thiswr->data and the input from * wr->input. Length should be thiswr->length. thiswr->data still points * in the wb->buf / if (!rl->use_etm && mac_size != 0) { unsigned char mac; if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac) \|\| !rl->funcs->mac(rl, thiswr, mac, 1)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } /* * Reserve some bytes for any growth that may occur during encryption. If * we are adding the MAC independently of the cipher algorithm, then the * max encrypted overhead does not need to include an allocation for that * MAC / if (!WPACKET_reserve_bytes(thispkt, SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD - mac_size, NULL) / * We also need next the amount of bytes written to this * sub-packet / \|\| !WPACKET_get_length(thispkt, &len)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / Get a pointer to the start of this record excluding header / recordstart = WPACKET_get_curr(thispkt) - len; TLS_RL_RECORD_set_data(thiswr, recordstart); TLS_RL_RECORD_reset_input(thiswr); TLS_RL_RECORD_set_length(thiswr, len); return 1; } int tls_post_encryption_processing_default(OSSL_RECORD_LAYER rl, size_t mac_size, OSSL_RECORD_TEMPLATE thistempl, WPACKET thispkt, TLS_RL_RECORD thiswr) { size_t origlen, len; size_t headerlen = rl->isdtls ? DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH; / Allocate bytes for the encryption overhead / if (!WPACKET_get_length(thispkt, &origlen) / Check we allowed enough room for the encryption growth / \|\| !ossl_assert(origlen + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD - mac_size >= thiswr->length) / Encryption should never shrink the data! / \|\| origlen > thiswr->length \|\| (thiswr->length > origlen && !WPACKET_allocate_bytes(thispkt, thiswr->length - origlen, NULL))) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (rl->use_etm && mac_size != 0) { unsigned char mac; if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac) \|\| !rl->funcs->mac(rl, thiswr, mac, 1)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } TLS_RL_RECORD_add_length(thiswr, mac_size); } if (!WPACKET_get_length(thispkt, &len) \|\| !WPACKET_close(thispkt)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (rl->msg_callback != NULL) { unsigned char recordstart; recordstart = WPACKET_get_curr(thispkt) - len - headerlen; rl->msg_callback(1, thiswr->rec_version, SSL3_RT_HEADER, recordstart, headerlen, rl->cbarg); if (rl->version == TLS1_3_VERSION && rl->enc_ctx != NULL) { unsigned char ctype = thistempl->type; rl->msg_callback(1, thiswr->rec_version, SSL3_RT_INNER_CONTENT_TYPE, &ctype, 1, rl->cbarg); } } if (!WPACKET_finish(thispkt)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } TLS_RL_RECORD_add_length(thiswr, headerlen); return 1; } int tls_write_records_default(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl) { WPACKET pkt[SSL_MAX_PIPELINES + 1]; TLS_RL_RECORD wr[SSL_MAX_PIPELINES + 1]; WPACKET thispkt; TLS_RL_RECORD thiswr; int mac_size = 0, ret = 0; size_t wpinited = 0; size_t j, prefix = 0; OSSL_RECORD_TEMPLATE prefixtempl; OSSL_RECORD_TEMPLATE thistempl; if (rl->md_ctx != NULL && EVP_MD_CTX_get0_md(rl->md_ctx) != NULL) { mac_size = EVP_MD_CTX_get_size(rl->md_ctx); if (mac_size < 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (!rl->funcs->allocate_write_buffers(rl, templates, numtempl, &prefix)) { /* RLAYERfatal() already called / goto err; } if (!rl->funcs->initialise_write_packets(rl, templates, numtempl, &prefixtempl, pkt, rl->wbuf, &wpinited)) { / RLAYERfatal() already called / goto err; } / Clear our TLS_RL_RECORD structures / memset(wr, 0, sizeof(wr)); for (j = 0; j < numtempl + prefix; j++) { unsigned char compressdata = NULL; uint8_t rectype; thispkt = &pkt[j]; thiswr = &wr[j]; thistempl = (j < prefix) ? &prefixtempl : &templates[j - prefix]; /* * Default to the record type as specified in the template unless the * protocol implementation says differently. / if (rl->funcs->get_record_type != NULL) rectype = rl->funcs->get_record_type(rl, thistempl); else rectype = thistempl->type; TLS_RL_RECORD_set_type(thiswr, rectype); TLS_RL_RECORD_set_rec_version(thiswr, thistempl->version); if (!rl->funcs->prepare_record_header(rl, thispkt, thistempl, rectype, &compressdata)) { / RLAYERfatal() already called / goto err; } / lets setup the record stuff. / TLS_RL_RECORD_set_data(thiswr, compressdata); TLS_RL_RECORD_set_length(thiswr, thistempl->buflen); TLS_RL_RECORD_set_input(thiswr, (unsigned char )thistempl->buf); /* * we now 'read' from thiswr->input, thiswr->length bytes into * thiswr->data / / first we compress / if (rl->compctx != NULL) { if (!tls_do_compress(rl, thiswr) \|\| !WPACKET_allocate_bytes(thispkt, thiswr->length, NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_COMPRESSION_FAILURE); goto err; } } else if (compressdata != NULL) { if (!WPACKET_memcpy(thispkt, thiswr->input, thiswr->length)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } TLS_RL_RECORD_reset_input(&wr[j]); } if (rl->funcs->add_record_padding != NULL && !rl->funcs->add_record_padding(rl, thistempl, thispkt, thiswr)) { / RLAYERfatal() already called / goto err; } if (!rl->funcs->prepare_for_encryption(rl, mac_size, thispkt, thiswr)) { / RLAYERfatal() already called / goto err; } } if (prefix) { if (rl->funcs->cipher(rl, wr, 1, 1, NULL, mac_size) < 1) { if (rl->alert == SSL_AD_NO_ALERT) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); } goto err; } } if (rl->funcs->cipher(rl, wr + prefix, numtempl, 1, NULL, mac_size) < 1) { if (rl->alert == SSL_AD_NO_ALERT) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); } goto err; } for (j = 0; j < numtempl + prefix; j++) { thispkt = &pkt[j]; thiswr = &wr[j]; thistempl = (j < prefix) ? &prefixtempl : &templates[j - prefix]; if (!rl->funcs->post_encryption_processing(rl, mac_size, thistempl, thispkt, thiswr)) { / RLAYERfatal() already called / goto err; } / now let's set up wb / TLS_BUFFER_set_left(&rl->wbuf[j], TLS_RL_RECORD_get_length(thiswr)); } ret = 1; err: for (j = 0; j < wpinited; j++) WPACKET_cleanup(&pkt[j]); return ret; } int tls_write_records(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl) { / Check we don't have pending data waiting to write / if (!ossl_assert(rl->nextwbuf >= rl->numwpipes \|\| TLS_BUFFER_get_left(&rl->wbuf[rl->nextwbuf]) == 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return OSSL_RECORD_RETURN_FATAL; } if (!rl->funcs->write_records(rl, templates, numtempl)) { / RLAYERfatal already called / return OSSL_RECORD_RETURN_FATAL; } rl->nextwbuf = 0; / we now just need to write the buffers / return tls_retry_write_records(rl); } int tls_retry_write_records(OSSL_RECORD_LAYER rl) { int i, ret; TLS_BUFFER thiswb; size_t tmpwrit = 0; if (rl->nextwbuf >= rl->numwpipes) return OSSL_RECORD_RETURN_SUCCESS; for (;;) { thiswb = &rl->wbuf[rl->nextwbuf]; clear_sys_error(); if (rl->bio != NULL) { if (rl->funcs->prepare_write_bio != NULL) { ret = rl->funcs->prepare_write_bio(rl, thiswb->type); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; } i = BIO_write(rl->bio, (char ) &(TLS_BUFFER_get_buf(thiswb) [TLS_BUFFER_get_offset(thiswb)]), (unsigned int)TLS_BUFFER_get_left(thiswb)); if (i >= 0) { tmpwrit = i; if (i == 0 && BIO_should_retry(rl->bio)) ret = OSSL_RECORD_RETURN_RETRY; else ret = OSSL_RECORD_RETURN_SUCCESS; } else { if (BIO_should_retry(rl->bio)) ret = OSSL_RECORD_RETURN_RETRY; else ret = OSSL_RECORD_RETURN_FATAL; } } else { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_BIO_NOT_SET); ret = OSSL_RECORD_RETURN_FATAL; i = -1; } /* * When an empty fragment is sent on a connection using KTLS, * it is sent as a write of zero bytes. If this zero byte * write succeeds, i will be 0 rather than a non-zero value. * Treat i == 0 as success rather than an error for zero byte * writes to permit this case. / if (i >= 0 && tmpwrit == TLS_BUFFER_get_left(thiswb)) { TLS_BUFFER_set_left(thiswb, 0); TLS_BUFFER_add_offset(thiswb, tmpwrit); if (++(rl->nextwbuf) < rl->numwpipes) continue; if (rl->nextwbuf == rl->numwpipes && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0) tls_release_write_buffer(rl); return OSSL_RECORD_RETURN_SUCCESS; } else if (i <= 0) { if (rl->isdtls) { / * For DTLS, just drop it. That's kind of the whole point in * using a datagram service / TLS_BUFFER_set_left(thiswb, 0); if (++(rl->nextwbuf) == rl->numwpipes && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0) tls_release_write_buffer(rl); } return ret; } TLS_BUFFER_add_offset(thiswb, tmpwrit); TLS_BUFFER_sub_left(thiswb, tmpwrit); } } int tls_get_alert_code(OSSL_RECORD_LAYER rl) { return rl->alert; } int tls_set1_bio(OSSL_RECORD_LAYER rl, BIO bio) { if (bio != NULL && !BIO_up_ref(bio)) return 0; BIO_free(rl->bio); rl->bio = bio; return 1; } /* Shared by most methods except tlsany_meth / int tls_default_set_protocol_version(OSSL_RECORD_LAYER rl, int version) { if (rl->version != version) return 0; return 1; } int tls_set_protocol_version(OSSL_RECORD_LAYER rl, int version) { return rl->funcs->set_protocol_version(rl, version); } void tls_set_plain_alerts(OSSL_RECORD_LAYER rl, int allow) { rl->allow_plain_alerts = allow; } void tls_set_first_handshake(OSSL_RECORD_LAYER rl, int first) { rl->is_first_handshake = first; } void tls_set_max_pipelines(OSSL_RECORD_LAYER rl, size_t max_pipelines) { rl->max_pipelines = max_pipelines; if (max_pipelines > 1) rl->read_ahead = 1; } void tls_get_state(OSSL_RECORD_LAYER rl, const char shortstr, const char longstr) { const char shrt, lng; switch (rl->rstate) { case SSL_ST_READ_HEADER: shrt = "RH"; lng = "read header"; break; case SSL_ST_READ_BODY: shrt = "RB"; lng = "read body"; break; default: shrt = lng = "unknown"; break; } if (shortstr != NULL) shortstr = shrt; if (longstr != NULL) longstr = lng; } const COMP_METHOD tls_get_compression(OSSL_RECORD_LAYER rl) { #ifndef OPENSSL_NO_COMP return (rl->compctx == NULL) ? NULL : COMP_CTX_get_method(rl->compctx); #else return NULL; #endif } void tls_set_max_frag_len(OSSL_RECORD_LAYER rl, size_t max_frag_len) { rl->max_frag_len = max_frag_len; /* * We don't need to adjust buffer sizes. Write buffer sizes are * automatically checked anyway. We should only be changing the read buffer * size during the handshake, so we will create a new buffer when we create * the new record layer. We can't change the existing buffer because it may * already have data in it. / } int tls_increment_sequence_ctr(OSSL_RECORD_LAYER rl) { int i; /* Increment the sequence counter / for (i = SEQ_NUM_SIZE; i > 0; i--) { ++(rl->sequence[i - 1]); if (rl->sequence[i - 1] != 0) break; } if (i == 0) { / Sequence has wrapped / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_SEQUENCE_CTR_WRAPPED); return 0; } return 1; } int tls_alloc_buffers(OSSL_RECORD_LAYER rl) { if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) { /* If we have a pending write then buffers are already allocated / if (rl->nextwbuf < rl->numwpipes) return 1; / * We assume 1 pipe with default sized buffer. If what we need ends up * being a different size to that then it will be reallocated on demand. * If we need more than 1 pipe then that will also be allocated on * demand / if (!tls_setup_write_buffer(rl, 1, 0, 0)) return 0; / * Normally when we allocate write buffers we immediately write * something into it. In this case we're not doing that so mark the * buffer as empty. / TLS_BUFFER_set_left(&rl->wbuf[0], 0); return 1; } / Read direction / / If we have pending data to be read then buffers are already allocated / if (rl->curr_rec < rl->num_recs \|\| TLS_BUFFER_get_left(&rl->rbuf) != 0) return 1; return tls_setup_read_buffer(rl); } int tls_free_buffers(OSSL_RECORD_LAYER rl) { if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) { if (rl->nextwbuf < rl->numwpipes) { /* * We may have pending data. If we've just got one empty buffer * allocated then it has probably just been alloc'd via * tls_alloc_buffers, and it is fine to free it. Otherwise this * looks like real pending data and it is an error. / if (rl->nextwbuf != 0 \|\| rl->numwpipes != 1 \|\| TLS_BUFFER_get_left(&rl->wbuf[0]) != 0) return 0; } tls_release_write_buffer(rl); return 1; } / Read direction / / If we have pending data to be read then fail */ if (rl->curr_rec < rl->num_recs \|\| TLS_BUFFER_get_left(&rl->rbuf) != 0) return 0; return tls_release_read_buffer(rl); } const OSSL_RECORD_METHOD ossl_tls_record_method = { tls_new_record_layer, tls_free, tls_unprocessed_read_pending, tls_processed_read_pending, tls_app_data_pending, tls_get_max_records, tls_write_records, tls_retry_write_records, tls_read_record, tls_release_record, tls_get_alert_code, tls_set1_bio, tls_set_protocol_version, tls_set_plain_alerts, tls_set_first_handshake, tls_set_max_pipelines, NULL, tls_get_state, tls_set_options, tls_get_compression, tls_set_max_frag_len, NULL, tls_increment_sequence_ctr, tls_alloc_buffers, tls_free_buffers };
./openssl/ssl/record/methods/ssl3_cbc.c	/* * Copyright 2012-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / / * This file has no dependencies on the rest of libssl because it is shared * with the providers. It contains functions for low level MAC calculations. * Responsibility for this lies with the HMAC implementation in the * providers. However there are legacy code paths in libssl which also need to * do this. In time those legacy code paths can be removed and this file can be * moved out of libssl. / / * MD5 and SHA-1 low level APIs are deprecated for public use, but still ok for * internal use. / #include "internal/deprecated.h" #include <openssl/evp.h> #ifndef FIPS_MODULE # include <openssl/md5.h> #endif #include <openssl/sha.h> #include "internal/ssl3_cbc.h" #include "internal/constant_time.h" #include "internal/cryptlib.h" / * MAX_HASH_BIT_COUNT_BYTES is the maximum number of bytes in the hash's * length field. (SHA-384/512 have 128-bit length.) / #define MAX_HASH_BIT_COUNT_BYTES 16 / * MAX_HASH_BLOCK_SIZE is the maximum hash block size that we'll support. * Currently SHA-384/512 has a 128-byte block size and that's the largest * supported by TLS.) / #define MAX_HASH_BLOCK_SIZE 128 #ifndef FIPS_MODULE / * u32toLE serializes an unsigned, 32-bit number (n) as four bytes at (p) in * little-endian order. The value of p is advanced by four. / # define u32toLE(n, p) \ (((p)++) = (unsigned char)(n ), \ ((p)++) = (unsigned char)(n >> 8), \ ((p)++) = (unsigned char)(n >> 16), \ ((p)++) = (unsigned char)(n >> 24)) / * These functions serialize the state of a hash and thus perform the * standard "final" operation without adding the padding and length that such * a function typically does. / static void tls1_md5_final_raw(void ctx, unsigned char md_out) { MD5_CTX md5 = ctx; u32toLE(md5->A, md_out); u32toLE(md5->B, md_out); u32toLE(md5->C, md_out); u32toLE(md5->D, md_out); } #endif /* FIPS_MODULE / static void tls1_sha1_final_raw(void ctx, unsigned char md_out) { SHA_CTX sha1 = ctx; l2n(sha1->h0, md_out); l2n(sha1->h1, md_out); l2n(sha1->h2, md_out); l2n(sha1->h3, md_out); l2n(sha1->h4, md_out); } static void tls1_sha256_final_raw(void ctx, unsigned char md_out) { SHA256_CTX sha256 = ctx; unsigned i; for (i = 0; i < 8; i++) l2n(sha256->h[i], md_out); } static void tls1_sha512_final_raw(void ctx, unsigned char md_out) { SHA512_CTX sha512 = ctx; unsigned i; for (i = 0; i < 8; i++) l2n8(sha512->h[i], md_out); } #undef LARGEST_DIGEST_CTX #define LARGEST_DIGEST_CTX SHA512_CTX /- ssl3_cbc_digest_record computes the MAC of a decrypted, padded SSLv3/TLS * record. * * ctx: the EVP_MD_CTX from which we take the hash function. * ssl3_cbc_record_digest_supported must return true for this EVP_MD_CTX. * md_out: the digest output. At most EVP_MAX_MD_SIZE bytes will be written. * md_out_size: if non-NULL, the number of output bytes is written here. * header: the 13-byte, TLS record header. * data: the record data itself, less any preceding explicit IV. * data_size: the secret, reported length of the data once the MAC and padding * has been removed. * data_plus_mac_plus_padding_size: the public length of the whole * record, including MAC and padding. * is_sslv3: non-zero if we are to use SSLv3. Otherwise, TLS. * * On entry: we know that data is data_plus_mac_plus_padding_size in length * Returns 1 on success or 0 on error / int ssl3_cbc_digest_record(const EVP_MD md, unsigned char md_out, size_t md_out_size, const unsigned char header, const unsigned char data, size_t data_size, size_t data_plus_mac_plus_padding_size, const unsigned char mac_secret, size_t mac_secret_length, char is_sslv3) { union { OSSL_UNION_ALIGN; unsigned char c[sizeof(LARGEST_DIGEST_CTX)]; } md_state; void (md_final_raw) (void ctx, unsigned char md_out); void (md_transform) (void ctx, const unsigned char block); size_t md_size, md_block_size = 64; size_t sslv3_pad_length = 40, header_length, variance_blocks, len, max_mac_bytes, num_blocks, num_starting_blocks, k, mac_end_offset, c, index_a, index_b; size_t bits; / at most 18 bits / unsigned char length_bytes[MAX_HASH_BIT_COUNT_BYTES]; / hmac_pad is the masked HMAC key. / unsigned char hmac_pad[MAX_HASH_BLOCK_SIZE]; unsigned char first_block[MAX_HASH_BLOCK_SIZE]; unsigned char mac_out[EVP_MAX_MD_SIZE]; size_t i, j; unsigned md_out_size_u; EVP_MD_CTX md_ctx = NULL; /* * mdLengthSize is the number of bytes in the length field that * terminates * the hash. / size_t md_length_size = 8; char length_is_big_endian = 1; int ret = 0; / * This is a, hopefully redundant, check that allows us to forget about * many possible overflows later in this function. / if (!ossl_assert(data_plus_mac_plus_padding_size < 1024 1024)) return 0; if (EVP_MD_is_a(md, "MD5")) { #ifdef FIPS_MODULE return 0; #else if (MD5_Init((MD5_CTX )md_state.c) <= 0) return 0; md_final_raw = tls1_md5_final_raw; md_transform = (void ()(void ctx, const unsigned char block))MD5_Transform; md_size = 16; sslv3_pad_length = 48; length_is_big_endian = 0; #endif } else if (EVP_MD_is_a(md, "SHA1")) { if (SHA1_Init((SHA_CTX )md_state.c) <= 0) return 0; md_final_raw = tls1_sha1_final_raw; md_transform = (void ()(void ctx, const unsigned char block))SHA1_Transform; md_size = 20; } else if (EVP_MD_is_a(md, "SHA2-224")) { if (SHA224_Init((SHA256_CTX )md_state.c) <= 0) return 0; md_final_raw = tls1_sha256_final_raw; md_transform = (void ()(void ctx, const unsigned char block))SHA256_Transform; md_size = 224 / 8; } else if (EVP_MD_is_a(md, "SHA2-256")) { if (SHA256_Init((SHA256_CTX )md_state.c) <= 0) return 0; md_final_raw = tls1_sha256_final_raw; md_transform = (void ()(void ctx, const unsigned char block))SHA256_Transform; md_size = 32; } else if (EVP_MD_is_a(md, "SHA2-384")) { if (SHA384_Init((SHA512_CTX )md_state.c) <= 0) return 0; md_final_raw = tls1_sha512_final_raw; md_transform = (void ()(void ctx, const unsigned char block))SHA512_Transform; md_size = 384 / 8; md_block_size = 128; md_length_size = 16; } else if (EVP_MD_is_a(md, "SHA2-512")) { if (SHA512_Init((SHA512_CTX )md_state.c) <= 0) return 0; md_final_raw = tls1_sha512_final_raw; md_transform = (void ()(void ctx, const unsigned char block))SHA512_Transform; md_size = 64; md_block_size = 128; md_length_size = 16; } else { /* * ssl3_cbc_record_digest_supported should have been called first to * check that the hash function is supported. / if (md_out_size != NULL) md_out_size = 0; return ossl_assert(0); } if (!ossl_assert(md_length_size <= MAX_HASH_BIT_COUNT_BYTES) \|\| !ossl_assert(md_block_size <= MAX_HASH_BLOCK_SIZE) \|\| !ossl_assert(md_size <= EVP_MAX_MD_SIZE)) return 0; header_length = 13; if (is_sslv3) { header_length = mac_secret_length + sslv3_pad_length + 8 /* sequence number / + 1 / record type / + 2; / record length / } / * variance_blocks is the number of blocks of the hash that we have to * calculate in constant time because they could be altered by the * padding value. In SSLv3, the padding must be minimal so the end of * the plaintext varies by, at most, 15+20 = 35 bytes. (We conservatively * assume that the MAC size varies from 0..20 bytes.) In case the 9 bytes * of hash termination (0x80 + 64-bit length) don't fit in the final * block, we say that the final two blocks can vary based on the padding. * TLSv1 has MACs up to 48 bytes long (SHA-384) and the padding is not * required to be minimal. Therefore we say that the final \|variance_blocks\| * blocks can * vary based on the padding. Later in the function, if the message is * short and there obviously cannot be this many blocks then * variance_blocks can be reduced. / variance_blocks = is_sslv3 ? 2 : (((255 + 1 + md_size + md_block_size - 1) / md_block_size) + 1); / * From now on we're dealing with the MAC, which conceptually has 13 * bytes of `header' before the start of the data (TLS) or 71/75 bytes * (SSLv3) / len = data_plus_mac_plus_padding_size + header_length; / * max_mac_bytes contains the maximum bytes of bytes in the MAC, * including * \|header\|, assuming that there's no padding. / max_mac_bytes = len - md_size - 1; / num_blocks is the maximum number of hash blocks. / num_blocks = (max_mac_bytes + 1 + md_length_size + md_block_size - 1) / md_block_size; / * In order to calculate the MAC in constant time we have to handle the * final blocks specially because the padding value could cause the end * to appear somewhere in the final \|variance_blocks\| blocks and we can't * leak where. However, \|num_starting_blocks\| worth of data can be hashed * right away because no padding value can affect whether they are * plaintext. / num_starting_blocks = 0; / * k is the starting byte offset into the conceptual header\|\|data where * we start processing. / k = 0; / * mac_end_offset is the index just past the end of the data to be MACed. / mac_end_offset = data_size + header_length; / * c is the index of the 0x80 byte in the final hash block that contains * application data. / c = mac_end_offset % md_block_size; / * index_a is the hash block number that contains the 0x80 terminating * value. / index_a = mac_end_offset / md_block_size; / * index_b is the hash block number that contains the 64-bit hash length, * in bits. / index_b = (mac_end_offset + md_length_size) / md_block_size; / * bits is the hash-length in bits. It includes the additional hash block * for the masked HMAC key, or whole of \|header\| in the case of SSLv3. / / * For SSLv3, if we're going to have any starting blocks then we need at * least two because the header is larger than a single block. / if (num_blocks > variance_blocks + (is_sslv3 ? 1 : 0)) { num_starting_blocks = num_blocks - variance_blocks; k = md_block_size num_starting_blocks; } bits = 8 * mac_end_offset; if (!is_sslv3) { /* * Compute the initial HMAC block. For SSLv3, the padding and secret * bytes are included in \|header\| because they take more than a * single block. / bits += 8 md_block_size; memset(hmac_pad, 0, md_block_size); if (!ossl_assert(mac_secret_length <= sizeof(hmac_pad))) return 0; memcpy(hmac_pad, mac_secret, mac_secret_length); for (i = 0; i < md_block_size; i++) hmac_pad[i] ^= 0x36; md_transform(md_state.c, hmac_pad); } if (length_is_big_endian) { memset(length_bytes, 0, md_length_size - 4); length_bytes[md_length_size - 4] = (unsigned char)(bits >> 24); length_bytes[md_length_size - 3] = (unsigned char)(bits >> 16); length_bytes[md_length_size - 2] = (unsigned char)(bits >> 8); length_bytes[md_length_size - 1] = (unsigned char)bits; } else { memset(length_bytes, 0, md_length_size); length_bytes[md_length_size - 5] = (unsigned char)(bits >> 24); length_bytes[md_length_size - 6] = (unsigned char)(bits >> 16); length_bytes[md_length_size - 7] = (unsigned char)(bits >> 8); length_bytes[md_length_size - 8] = (unsigned char)bits; } if (k > 0) { if (is_sslv3) { size_t overhang; /* * The SSLv3 header is larger than a single block. overhang is * the number of bytes beyond a single block that the header * consumes: either 7 bytes (SHA1) or 11 bytes (MD5). There are no * ciphersuites in SSLv3 that are not SHA1 or MD5 based and * therefore we can be confident that the header_length will be * greater than \|md_block_size\|. However we add a sanity check just * in case / if (header_length <= md_block_size) { / Should never happen / return 0; } overhang = header_length - md_block_size; md_transform(md_state.c, header); memcpy(first_block, header + md_block_size, overhang); memcpy(first_block + overhang, data, md_block_size - overhang); md_transform(md_state.c, first_block); for (i = 1; i < k / md_block_size - 1; i++) md_transform(md_state.c, data + md_block_size i - overhang); } else { /* k is a multiple of md_block_size. / memcpy(first_block, header, 13); memcpy(first_block + 13, data, md_block_size - 13); md_transform(md_state.c, first_block); for (i = 1; i < k / md_block_size; i++) md_transform(md_state.c, data + md_block_size i - 13); } } memset(mac_out, 0, sizeof(mac_out)); /* * We now process the final hash blocks. For each block, we construct it * in constant time. If the \|i==index_a\| then we'll include the 0x80 * bytes and zero pad etc. For each block we selectively copy it, in * constant time, to \|mac_out\|. / for (i = num_starting_blocks; i <= num_starting_blocks + variance_blocks; i++) { unsigned char block[MAX_HASH_BLOCK_SIZE]; unsigned char is_block_a = constant_time_eq_8_s(i, index_a); unsigned char is_block_b = constant_time_eq_8_s(i, index_b); for (j = 0; j < md_block_size; j++) { unsigned char b = 0, is_past_c, is_past_cp1; if (k < header_length) b = header[k]; else if (k < data_plus_mac_plus_padding_size + header_length) b = data[k - header_length]; k++; is_past_c = is_block_a & constant_time_ge_8_s(j, c); is_past_cp1 = is_block_a & constant_time_ge_8_s(j, c + 1); / * If this is the block containing the end of the application * data, and we are at the offset for the 0x80 value, then * overwrite b with 0x80. / b = constant_time_select_8(is_past_c, 0x80, b); / * If this block contains the end of the application data * and we're past the 0x80 value then just write zero. / b = b & ~is_past_cp1; / * If this is index_b (the final block), but not index_a (the end * of the data), then the 64-bit length didn't fit into index_a * and we're having to add an extra block of zeros. / b &= ~is_block_b \| is_block_a; / * The final bytes of one of the blocks contains the length. / if (j >= md_block_size - md_length_size) { / If this is index_b, write a length byte. / b = constant_time_select_8(is_block_b, length_bytes[j - (md_block_size - md_length_size)], b); } block[j] = b; } md_transform(md_state.c, block); md_final_raw(md_state.c, block); / If this is index_b, copy the hash value to \|mac_out\|. / for (j = 0; j < md_size; j++) mac_out[j] \|= block[j] & is_block_b; } md_ctx = EVP_MD_CTX_new(); if (md_ctx == NULL) goto err; if (EVP_DigestInit_ex(md_ctx, md, NULL / engine /) <= 0) goto err; if (is_sslv3) { / We repurpose \|hmac_pad\| to contain the SSLv3 pad2 block. / memset(hmac_pad, 0x5c, sslv3_pad_length); if (EVP_DigestUpdate(md_ctx, mac_secret, mac_secret_length) <= 0 \|\| EVP_DigestUpdate(md_ctx, hmac_pad, sslv3_pad_length) <= 0 \|\| EVP_DigestUpdate(md_ctx, mac_out, md_size) <= 0) goto err; } else { / Complete the HMAC in the standard manner. / for (i = 0; i < md_block_size; i++) hmac_pad[i] ^= 0x6a; if (EVP_DigestUpdate(md_ctx, hmac_pad, md_block_size) <= 0 \|\| EVP_DigestUpdate(md_ctx, mac_out, md_size) <= 0) goto err; } ret = EVP_DigestFinal(md_ctx, md_out, &md_out_size_u); if (ret && md_out_size) md_out_size = md_out_size_u; ret = 1; err: EVP_MD_CTX_free(md_ctx); return ret; }
./openssl/ssl/record/methods/tlsany_meth.c	/* * Copyright 2022 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/evp.h> #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" #define MIN_SSL2_RECORD_LEN 9 static int tls_any_set_crypto_state(OSSL_RECORD_LAYER rl, int level, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp) { if (level != OSSL_RECORD_PROTECTION_LEVEL_NONE) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } /* No crypto protection at the "NONE" level so nothing to be done / return OSSL_RECORD_RETURN_SUCCESS; } static int tls_any_cipher(OSSL_RECORD_LAYER rl, TLS_RL_RECORD recs, size_t n_recs, int sending, SSL_MAC_BUF macs, size_t macsize) { return 1; } static int tls_validate_record_header(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { if (rec->rec_version == SSL2_VERSION) { /* SSLv2 format ClientHello / if (!ossl_assert(rl->version == TLS_ANY_VERSION)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (rec->length < MIN_SSL2_RECORD_LEN) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); return 0; } } else { if (rl->version == TLS_ANY_VERSION) { if ((rec->rec_version >> 8) != SSL3_VERSION_MAJOR) { if (rl->is_first_record) { unsigned char p; /* * Go back to start of packet, look at the five bytes that * we have. / p = rl->packet; if (HAS_PREFIX((char )p, "GET ") \|\| HAS_PREFIX((char )p, "POST ") \|\| HAS_PREFIX((char )p, "HEAD ") \|\| HAS_PREFIX((char )p, "PUT ")) { RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_HTTP_REQUEST); return 0; } else if (HAS_PREFIX((char )p, "CONNE")) { RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_HTTPS_PROXY_REQUEST); return 0; } /* Doesn't look like TLS - don't send an alert / RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_WRONG_VERSION_NUMBER); return 0; } else { RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); return 0; } } } else if (rl->version == TLS1_3_VERSION) { / * In this case we know we are going to negotiate TLSv1.3, but we've * had an HRR, so we haven't actually done so yet. In TLSv1.3 we * must ignore the legacy record version in plaintext records. / } else if (rec->rec_version != rl->version) { if ((rl->version & 0xFF00) == (rec->rec_version & 0xFF00)) { if (rec->type == SSL3_RT_ALERT) { / * The record is using an incorrect version number, * but what we've got appears to be an alert. We * haven't read the body yet to check whether its a * fatal or not - but chances are it is. We probably * shouldn't send a fatal alert back. We'll just * end. / RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_WRONG_VERSION_NUMBER); return 0; } / Send back error using their minor version number / rl->version = (unsigned short)rec->rec_version; } RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); return 0; } } if (rec->length > SSL3_RT_MAX_PLAIN_LENGTH) { / * We use SSL_R_DATA_LENGTH_TOO_LONG instead of * SSL_R_ENCRYPTED_LENGTH_TOO_LONG here because we are the "any" method * and we know that we are dealing with plaintext data / RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } return 1; } static int tls_any_set_protocol_version(OSSL_RECORD_LAYER rl, int vers) { if (rl->version != TLS_ANY_VERSION && rl->version != vers) return 0; rl->version = vers; return 1; } static int tls_any_prepare_for_encryption(OSSL_RECORD_LAYER rl, size_t mac_size, WPACKET thispkt, TLS_RL_RECORD thiswr) { / No encryption, so nothing to do / return 1; } struct record_functions_st tls_any_funcs = { tls_any_set_crypto_state, tls_any_cipher, NULL, tls_any_set_protocol_version, tls_default_read_n, tls_get_more_records, tls_validate_record_header, tls_default_post_process_record, tls_get_max_records_default, tls_write_records_default, tls_allocate_write_buffers_default, tls_initialise_write_packets_default, NULL, tls_prepare_record_header_default, NULL, tls_any_prepare_for_encryption, tls_post_encryption_processing_default, NULL }; static int dtls_any_set_protocol_version(OSSL_RECORD_LAYER rl, int vers) { if (rl->version != DTLS_ANY_VERSION && rl->version != vers) return 0; rl->version = vers; return 1; } struct record_functions_st dtls_any_funcs = { tls_any_set_crypto_state, tls_any_cipher, NULL, dtls_any_set_protocol_version, tls_default_read_n, dtls_get_more_records, NULL, NULL, NULL, tls_write_records_default, tls_allocate_write_buffers_default, tls_initialise_write_packets_default, NULL, dtls_prepare_record_header, NULL, tls_prepare_for_encryption_default, dtls_post_encryption_processing, NULL };
./openssl/ssl/record/methods/tls13_meth.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/evp.h> #include <openssl/core_names.h> #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" static int tls13_set_crypto_state(OSSL_RECORD_LAYER rl, int level, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp) { EVP_CIPHER_CTX ciph_ctx; int mode; int enc = (rl->direction == OSSL_RECORD_DIRECTION_WRITE) ? 1 : 0; if (ivlen > sizeof(rl->iv)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } memcpy(rl->iv, iv, ivlen); ciph_ctx = rl->enc_ctx = EVP_CIPHER_CTX_new(); if (ciph_ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } mode = EVP_CIPHER_get_mode(ciph); if (EVP_CipherInit_ex(ciph_ctx, ciph, NULL, NULL, NULL, enc) <= 0 \|\| EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_IVLEN, ivlen, NULL) <= 0 \|\| (mode == EVP_CIPH_CCM_MODE && EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_TAG, taglen, NULL) <= 0) \|\| EVP_CipherInit_ex(ciph_ctx, NULL, NULL, key, NULL, enc) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } return OSSL_RECORD_RETURN_SUCCESS; } static int tls13_cipher(OSSL_RECORD_LAYER rl, TLS_RL_RECORD recs, size_t n_recs, int sending, SSL_MAC_BUF mac, size_t macsize) { EVP_CIPHER_CTX ctx; unsigned char iv[EVP_MAX_IV_LENGTH], recheader[SSL3_RT_HEADER_LENGTH]; size_t ivlen, offset, loop, hdrlen; unsigned char staticiv; unsigned char seq = rl->sequence; int lenu, lenf; TLS_RL_RECORD rec = &recs[0]; WPACKET wpkt; const EVP_CIPHER cipher; int mode; if (n_recs != 1) { / Should not happen / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } ctx = rl->enc_ctx; staticiv = rl->iv; cipher = EVP_CIPHER_CTX_get0_cipher(ctx); if (cipher == NULL) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } mode = EVP_CIPHER_get_mode(cipher); / * If we're sending an alert and ctx != NULL then we must be forcing * plaintext alerts. If we're reading and ctx != NULL then we allow * plaintext alerts at certain points in the handshake. If we've got this * far then we have already validated that a plaintext alert is ok here. / if (ctx == NULL \|\| rec->type == SSL3_RT_ALERT) { memmove(rec->data, rec->input, rec->length); rec->input = rec->data; return 1; } ivlen = EVP_CIPHER_CTX_get_iv_length(ctx); if (!sending) { / * Take off tag. There must be at least one byte of content type as * well as the tag / if (rec->length < rl->taglen + 1) return 0; rec->length -= rl->taglen; } / Set up IV / if (ivlen < SEQ_NUM_SIZE) { / Should not happen / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } offset = ivlen - SEQ_NUM_SIZE; memcpy(iv, staticiv, offset); for (loop = 0; loop < SEQ_NUM_SIZE; loop++) iv[offset + loop] = staticiv[offset + loop] ^ seq[loop]; if (!tls_increment_sequence_ctr(rl)) { / RLAYERfatal already called / return 0; } if (EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, sending) <= 0 \|\| (!sending && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, rl->taglen, rec->data + rec->length) <= 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / Set up the AAD / if (!WPACKET_init_static_len(&wpkt, recheader, sizeof(recheader), 0) \|\| !WPACKET_put_bytes_u8(&wpkt, rec->type) \|\| !WPACKET_put_bytes_u16(&wpkt, rec->rec_version) \|\| !WPACKET_put_bytes_u16(&wpkt, rec->length + rl->taglen) \|\| !WPACKET_get_total_written(&wpkt, &hdrlen) \|\| hdrlen != SSL3_RT_HEADER_LENGTH \|\| !WPACKET_finish(&wpkt)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); WPACKET_cleanup(&wpkt); return 0; } / * For CCM we must explicitly set the total plaintext length before we add * any AAD. / if ((mode == EVP_CIPH_CCM_MODE && EVP_CipherUpdate(ctx, NULL, &lenu, NULL, (unsigned int)rec->length) <= 0) \|\| EVP_CipherUpdate(ctx, NULL, &lenu, recheader, sizeof(recheader)) <= 0 \|\| EVP_CipherUpdate(ctx, rec->data, &lenu, rec->input, (unsigned int)rec->length) <= 0 \|\| EVP_CipherFinal_ex(ctx, rec->data + lenu, &lenf) <= 0 \|\| (size_t)(lenu + lenf) != rec->length) { return 0; } if (sending) { / Add the tag / if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, rl->taglen, rec->data + rec->length) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } rec->length += rl->taglen; } return 1; } static int tls13_validate_record_header(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { if (rec->type != SSL3_RT_APPLICATION_DATA && (rec->type != SSL3_RT_CHANGE_CIPHER_SPEC \|\| !rl->is_first_handshake) && (rec->type != SSL3_RT_ALERT \|\| !rl->allow_plain_alerts)) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_RECORD_TYPE); return 0; } if (rec->rec_version != TLS1_2_VERSION) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_WRONG_VERSION_NUMBER); return 0; } if (rec->length > SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_ENCRYPTED_LENGTH_TOO_LONG); return 0; } return 1; } static int tls13_post_process_record(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec) { / Skip this if we've received a plaintext alert / if (rec->type != SSL3_RT_ALERT) { size_t end; if (rec->length == 0 \|\| rec->type != SSL3_RT_APPLICATION_DATA) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_RECORD_TYPE); return 0; } / Strip trailing padding / for (end = rec->length - 1; end > 0 && rec->data[end] == 0; end--) continue; rec->length = end; rec->type = rec->data[end]; } if (rec->length > SSL3_RT_MAX_PLAIN_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } if (!tls13_common_post_process_record(rl, rec)) { / RLAYERfatal already called / return 0; } return 1; } static uint8_t tls13_get_record_type(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE template) { if (rl->allow_plain_alerts && template->type == SSL3_RT_ALERT) return SSL3_RT_ALERT; / * Aside from the above case we always use the application data record type * when encrypting in TLSv1.3. The "inner" record type encodes the "real" * record type from the template. / return SSL3_RT_APPLICATION_DATA; } static int tls13_add_record_padding(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE thistempl, WPACKET thispkt, TLS_RL_RECORD thiswr) { size_t rlen; / Nothing to be done in the case of a plaintext alert / if (rl->allow_plain_alerts && thistempl->type != SSL3_RT_ALERT) return 1; if (!WPACKET_put_bytes_u8(thispkt, thistempl->type)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } TLS_RL_RECORD_add_length(thiswr, 1); / Add TLS1.3 padding / rlen = TLS_RL_RECORD_get_length(thiswr); if (rlen < rl->max_frag_len) { size_t padding = 0; size_t max_padding = rl->max_frag_len - rlen; if (rl->padding != NULL) { padding = rl->padding(rl->cbarg, thistempl->type, rlen); } else if (rl->block_padding > 0) { size_t mask = rl->block_padding - 1; size_t remainder; / optimize for power of 2 / if ((rl->block_padding & mask) == 0) remainder = rlen & mask; else remainder = rlen % rl->block_padding; / don't want to add a block of padding if we don't have to / if (remainder == 0) padding = 0; else padding = rl->block_padding - remainder; } if (padding > 0) { / do not allow the record to exceed max plaintext length */ if (padding > max_padding) padding = max_padding; if (!WPACKET_memset(thispkt, 0, padding)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } TLS_RL_RECORD_add_length(thiswr, padding); } } return 1; } struct record_functions_st tls_1_3_funcs = { tls13_set_crypto_state, tls13_cipher, NULL, tls_default_set_protocol_version, tls_default_read_n, tls_get_more_records, tls13_validate_record_header, tls13_post_process_record, tls_get_max_records_default, tls_write_records_default, tls_allocate_write_buffers_default, tls_initialise_write_packets_default, tls13_get_record_type, tls_prepare_record_header_default, tls13_add_record_padding, tls_prepare_for_encryption_default, tls_post_encryption_processing_default, NULL };
./openssl/ssl/record/methods/tls1_meth.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/evp.h> #include <openssl/core_names.h> #include <openssl/rand.h> #include <openssl/ssl.h> #include "internal/ssl3_cbc.h" #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" static int tls1_set_crypto_state(OSSL_RECORD_LAYER rl, int level, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp) { EVP_CIPHER_CTX ciph_ctx; EVP_PKEY mac_key; int enc = (rl->direction == OSSL_RECORD_DIRECTION_WRITE) ? 1 : 0; if (level != OSSL_RECORD_PROTECTION_LEVEL_APPLICATION) return OSSL_RECORD_RETURN_FATAL; if ((rl->enc_ctx = EVP_CIPHER_CTX_new()) == NULL) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return OSSL_RECORD_RETURN_FATAL; } ciph_ctx = rl->enc_ctx; rl->md_ctx = EVP_MD_CTX_new(); if (rl->md_ctx == NULL) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } #ifndef OPENSSL_NO_COMP if (comp != NULL) { rl->compctx = COMP_CTX_new(comp); if (rl->compctx == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_COMPRESSION_LIBRARY_ERROR); return OSSL_RECORD_RETURN_FATAL; } } #endif /* * If we have an AEAD Cipher, then there is no separate MAC, so we can skip * setting up the MAC key. / if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) == 0) { if (mactype == EVP_PKEY_HMAC) { mac_key = EVP_PKEY_new_raw_private_key_ex(rl->libctx, "HMAC", rl->propq, mackey, mackeylen); } else { / * If its not HMAC then the only other types of MAC we support are * the GOST MACs, so we need to use the old style way of creating * a MAC key. / mac_key = EVP_PKEY_new_mac_key(mactype, NULL, mackey, (int)mackeylen); } if (mac_key == NULL \|\| EVP_DigestSignInit_ex(rl->md_ctx, NULL, EVP_MD_get0_name(md), rl->libctx, rl->propq, mac_key, NULL) <= 0) { EVP_PKEY_free(mac_key); ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } EVP_PKEY_free(mac_key); } if (EVP_CIPHER_get_mode(ciph) == EVP_CIPH_GCM_MODE) { if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, key, NULL, enc) \|\| EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_GCM_SET_IV_FIXED, (int)ivlen, iv) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } } else if (EVP_CIPHER_get_mode(ciph) == EVP_CIPH_CCM_MODE) { if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, NULL, NULL, enc) \|\| EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_IVLEN, 12, NULL) <= 0 \|\| EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_TAG, (int)taglen, NULL) <= 0 \|\| EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_CCM_SET_IV_FIXED, (int)ivlen, iv) <= 0 \|\| !EVP_CipherInit_ex(ciph_ctx, NULL, NULL, key, NULL, enc)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } } else { if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, key, iv, enc)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } } / Needed for "composite" AEADs, such as RC4-HMAC-MD5 / if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0 && mackeylen != 0 && EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_MAC_KEY, (int)mackeylen, mackey) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } / * The cipher we actually ended up using in the EVP_CIPHER_CTX may be * different to that in ciph if we have an ENGINE in use / if (EVP_CIPHER_get0_provider(EVP_CIPHER_CTX_get0_cipher(ciph_ctx)) != NULL && !ossl_set_tls_provider_parameters(rl, ciph_ctx, ciph, md)) { / ERR_raise already called / return OSSL_RECORD_RETURN_FATAL; } / Calculate the explicit IV length / if (RLAYER_USE_EXPLICIT_IV(rl)) { int mode = EVP_CIPHER_CTX_get_mode(ciph_ctx); int eivlen = 0; if (mode == EVP_CIPH_CBC_MODE) { eivlen = EVP_CIPHER_CTX_get_iv_length(ciph_ctx); if (eivlen < 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); return OSSL_RECORD_RETURN_FATAL; } if (eivlen <= 1) eivlen = 0; } else if (mode == EVP_CIPH_GCM_MODE) { / Need explicit part of IV for GCM mode / eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN; } else if (mode == EVP_CIPH_CCM_MODE) { eivlen = EVP_CCM_TLS_EXPLICIT_IV_LEN; } rl->eivlen = (size_t)eivlen; } return OSSL_RECORD_RETURN_SUCCESS; } #define MAX_PADDING 256 /- * tls1_cipher encrypts/decrypts \|n_recs\| in \|recs\|. Calls RLAYERfatal on * internal error, but not otherwise. It is the responsibility of the caller to * report a bad_record_mac - if appropriate (DTLS just drops the record). * * Returns: * 0: if the record is publicly invalid, or an internal error, or AEAD * decryption failed, or Encrypt-then-mac decryption failed. * 1: Success or Mac-then-encrypt decryption failed (MAC will be randomised) / static int tls1_cipher(OSSL_RECORD_LAYER rl, TLS_RL_RECORD recs, size_t n_recs, int sending, SSL_MAC_BUF macs, size_t macsize) { EVP_CIPHER_CTX ds; size_t reclen[SSL_MAX_PIPELINES]; unsigned char buf[SSL_MAX_PIPELINES][EVP_AEAD_TLS1_AAD_LEN]; unsigned char data[SSL_MAX_PIPELINES]; int pad = 0, tmpr, provided; size_t bs, ctr, padnum, loop; unsigned char padval; const EVP_CIPHER enc; if (n_recs == 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (EVP_MD_CTX_get0_md(rl->md_ctx)) { int n = EVP_MD_CTX_get_size(rl->md_ctx); if (!ossl_assert(n >= 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } ds = rl->enc_ctx; if (!ossl_assert(rl->enc_ctx != NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } enc = EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx); if (sending) { int ivlen; / For TLSv1.1 and later explicit IV / if (RLAYER_USE_EXPLICIT_IV(rl) && EVP_CIPHER_get_mode(enc) == EVP_CIPH_CBC_MODE) ivlen = EVP_CIPHER_get_iv_length(enc); else ivlen = 0; if (ivlen > 1) { for (ctr = 0; ctr < n_recs; ctr++) { if (recs[ctr].data != recs[ctr].input) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } else if (RAND_bytes_ex(rl->libctx, recs[ctr].input, ivlen, 0) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } } if (!ossl_assert(enc != NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } provided = (EVP_CIPHER_get0_provider(enc) != NULL); bs = EVP_CIPHER_get_block_size(EVP_CIPHER_CTX_get0_cipher(ds)); if (n_recs > 1) { if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds)) & EVP_CIPH_FLAG_PIPELINE) == 0) { / * We shouldn't have been called with pipeline data if the * cipher doesn't support pipelining / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_PIPELINE_FAILURE); return 0; } } for (ctr = 0; ctr < n_recs; ctr++) { reclen[ctr] = recs[ctr].length; if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds)) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0) { unsigned char seq; seq = rl->sequence; if (rl->isdtls) { unsigned char dtlsseq[8], p = dtlsseq; s2n(rl->epoch, p); memcpy(p, &seq[2], 6); memcpy(buf[ctr], dtlsseq, 8); } else { memcpy(buf[ctr], seq, 8); if (!tls_increment_sequence_ctr(rl)) { / RLAYERfatal already called / return 0; } } buf[ctr][8] = recs[ctr].type; buf[ctr][9] = (unsigned char)(rl->version >> 8); buf[ctr][10] = (unsigned char)(rl->version); buf[ctr][11] = (unsigned char)(recs[ctr].length >> 8); buf[ctr][12] = (unsigned char)(recs[ctr].length & 0xff); pad = EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_AEAD_TLS1_AAD, EVP_AEAD_TLS1_AAD_LEN, buf[ctr]); if (pad <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (sending) { reclen[ctr] += pad; recs[ctr].length += pad; } } else if ((bs != 1) && sending && !provided) { / * We only do this for legacy ciphers. Provided ciphers add the * padding on the provider side. / padnum = bs - (reclen[ctr] % bs); / Add weird padding of up to 256 bytes / if (padnum > MAX_PADDING) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } / we need to add 'padnum' padding bytes of value padval / padval = (unsigned char)(padnum - 1); for (loop = reclen[ctr]; loop < reclen[ctr] + padnum; loop++) recs[ctr].input[loop] = padval; reclen[ctr] += padnum; recs[ctr].length += padnum; } if (!sending) { if (reclen[ctr] == 0 \|\| reclen[ctr] % bs != 0) { / Publicly invalid / return 0; } } } if (n_recs > 1) { / Set the output buffers / for (ctr = 0; ctr < n_recs; ctr++) data[ctr] = recs[ctr].data; if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS, (int)n_recs, data) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_PIPELINE_FAILURE); return 0; } / Set the input buffers / for (ctr = 0; ctr < n_recs; ctr++) data[ctr] = recs[ctr].input; if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_BUFS, (int)n_recs, data) <= 0 \|\| EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_LENS, (int)n_recs, reclen) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_PIPELINE_FAILURE); return 0; } } if (!rl->isdtls && rl->tlstree) { int decrement_seq = 0; / * When sending, seq is incremented after MAC calculation. * So if we are in ETM mode, we use seq 'as is' in the ctrl-function. * Otherwise we have to decrease it in the implementation / if (sending && !rl->use_etm) decrement_seq = 1; if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_TLSTREE, decrement_seq, rl->sequence) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } if (provided) { int outlen; / Provided cipher - we do not support pipelining on this path / if (n_recs > 1) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!EVP_CipherUpdate(ds, recs[0].data, &outlen, recs[0].input, (unsigned int)reclen[0])) return 0; recs[0].length = outlen; / * The length returned from EVP_CipherUpdate above is the actual * payload length. We need to adjust the data/input ptr to skip over * any explicit IV / if (!sending) { if (EVP_CIPHER_get_mode(enc) == EVP_CIPH_GCM_MODE) { recs[0].data += EVP_GCM_TLS_EXPLICIT_IV_LEN; recs[0].input += EVP_GCM_TLS_EXPLICIT_IV_LEN; } else if (EVP_CIPHER_get_mode(enc) == EVP_CIPH_CCM_MODE) { recs[0].data += EVP_CCM_TLS_EXPLICIT_IV_LEN; recs[0].input += EVP_CCM_TLS_EXPLICIT_IV_LEN; } else if (bs != 1 && RLAYER_USE_EXPLICIT_IV(rl)) { recs[0].data += bs; recs[0].input += bs; recs[0].orig_len -= bs; } / Now get a pointer to the MAC (if applicable) / if (macs != NULL) { OSSL_PARAM params[2], p = params; /* Get the MAC / macs[0].alloced = 0; p++ = OSSL_PARAM_construct_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, (void *)&macs[0].mac, macsize); p = OSSL_PARAM_construct_end(); if (!EVP_CIPHER_CTX_get_params(ds, params)) { /* Shouldn't normally happen / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } } else { / Legacy cipher / tmpr = EVP_Cipher(ds, recs[0].data, recs[0].input, (unsigned int)reclen[0]); if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds)) & EVP_CIPH_FLAG_CUSTOM_CIPHER) != 0 ? (tmpr < 0) : (tmpr == 0)) { / AEAD can fail to verify MAC / return 0; } if (!sending) { for (ctr = 0; ctr < n_recs; ctr++) { / Adjust the record to remove the explicit IV/MAC/Tag / if (EVP_CIPHER_get_mode(enc) == EVP_CIPH_GCM_MODE) { recs[ctr].data += EVP_GCM_TLS_EXPLICIT_IV_LEN; recs[ctr].input += EVP_GCM_TLS_EXPLICIT_IV_LEN; recs[ctr].length -= EVP_GCM_TLS_EXPLICIT_IV_LEN; } else if (EVP_CIPHER_get_mode(enc) == EVP_CIPH_CCM_MODE) { recs[ctr].data += EVP_CCM_TLS_EXPLICIT_IV_LEN; recs[ctr].input += EVP_CCM_TLS_EXPLICIT_IV_LEN; recs[ctr].length -= EVP_CCM_TLS_EXPLICIT_IV_LEN; } else if (bs != 1 && RLAYER_USE_EXPLICIT_IV(rl)) { if (recs[ctr].length < bs) return 0; recs[ctr].data += bs; recs[ctr].input += bs; recs[ctr].length -= bs; recs[ctr].orig_len -= bs; } / * If using Mac-then-encrypt, then this will succeed but * with a random MAC if padding is invalid / if (!tls1_cbc_remove_padding_and_mac(&recs[ctr].length, recs[ctr].orig_len, recs[ctr].data, (macs != NULL) ? &macs[ctr].mac : NULL, (macs != NULL) ? &macs[ctr].alloced : NULL, bs, pad ? (size_t)pad : macsize, (EVP_CIPHER_get_flags(enc) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0, rl->libctx)) return 0; } } } return 1; } static int tls1_mac(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec, unsigned char md, int sending) { unsigned char seq = rl->sequence; EVP_MD_CTX hash; size_t md_size; EVP_MD_CTX hmac = NULL, mac_ctx; unsigned char header[13]; int t; int ret = 0; hash = rl->md_ctx; t = EVP_MD_CTX_get_size(hash); if (!ossl_assert(t >= 0)) return 0; md_size = t; if (rl->stream_mac) { mac_ctx = hash; } else { hmac = EVP_MD_CTX_new(); if (hmac == NULL \|\| !EVP_MD_CTX_copy(hmac, hash)) { goto end; } mac_ctx = hmac; } if (!rl->isdtls && rl->tlstree && EVP_MD_CTX_ctrl(mac_ctx, EVP_MD_CTRL_TLSTREE, 0, seq) <= 0) goto end; if (rl->isdtls) { unsigned char dtlsseq[8], p = dtlsseq; s2n(rl->epoch, p); memcpy(p, &seq[2], 6); memcpy(header, dtlsseq, 8); } else { memcpy(header, seq, 8); } header[8] = rec->type; header[9] = (unsigned char)(rl->version >> 8); header[10] = (unsigned char)(rl->version); header[11] = (unsigned char)(rec->length >> 8); header[12] = (unsigned char)(rec->length & 0xff); if (!sending && !rl->use_etm && EVP_CIPHER_CTX_get_mode(rl->enc_ctx) == EVP_CIPH_CBC_MODE && ssl3_cbc_record_digest_supported(mac_ctx)) { OSSL_PARAM tls_hmac_params[2], p = tls_hmac_params; p++ = OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_TLS_DATA_SIZE, &rec->orig_len); p++ = OSSL_PARAM_construct_end(); if (!EVP_PKEY_CTX_set_params(EVP_MD_CTX_get_pkey_ctx(mac_ctx), tls_hmac_params)) goto end; } if (EVP_DigestSignUpdate(mac_ctx, header, sizeof(header)) <= 0 \|\| EVP_DigestSignUpdate(mac_ctx, rec->input, rec->length) <= 0 \|\| EVP_DigestSignFinal(mac_ctx, md, &md_size) <= 0) goto end; OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "seq:\n"); BIO_dump_indent(trc_out, seq, 8, 4); BIO_printf(trc_out, "rec:\n"); BIO_dump_indent(trc_out, rec->data, rec->length, 4); } OSSL_TRACE_END(TLS); if (!rl->isdtls && !tls_increment_sequence_ctr(rl)) { /* RLAYERfatal already called / goto end; } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "md:\n"); BIO_dump_indent(trc_out, md, md_size, 4); } OSSL_TRACE_END(TLS); ret = 1; end: EVP_MD_CTX_free(hmac); return ret; } #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 # ifndef OPENSSL_NO_COMP # define MAX_PREFIX_LEN ((SSL3_ALIGN_PAYLOAD - 1) \ + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ + SSL3_RT_HEADER_LENGTH \ + SSL3_RT_MAX_COMPRESSED_OVERHEAD) # else # define MAX_PREFIX_LEN ((SSL3_ALIGN_PAYLOAD - 1) \ + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ + SSL3_RT_HEADER_LENGTH) # endif / OPENSSL_NO_COMP / #else # ifndef OPENSSL_NO_COMP # define MAX_PREFIX_LEN (SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ + SSL3_RT_HEADER_LENGTH \ + SSL3_RT_MAX_COMPRESSED_OVERHEAD) # else # define MAX_PREFIX_LEN (SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ + SSL3_RT_HEADER_LENGTH) # endif / OPENSSL_NO_COMP / #endif / This function is also used by the SSLv3 implementation / int tls1_allocate_write_buffers(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, size_t prefix) { /* Do we need to add an empty record prefix? / prefix = rl->need_empty_fragments && templates[0].type == SSL3_RT_APPLICATION_DATA; /* * In the prefix case we can allocate a much smaller buffer. Otherwise we * just allocate the default buffer size / if (!tls_setup_write_buffer(rl, numtempl + prefix, prefix ? MAX_PREFIX_LEN : 0, 0)) { / RLAYERfatal() already called / return 0; } return 1; } / This function is also used by the SSLv3 implementation / int tls1_initialise_write_packets(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, OSSL_RECORD_TEMPLATE prefixtempl, WPACKET pkt, TLS_BUFFER bufs, size_t wpinited) { size_t align = 0; TLS_BUFFER wb; size_t prefix; /* Do we need to add an empty record prefix? / prefix = rl->need_empty_fragments && templates[0].type == SSL3_RT_APPLICATION_DATA; if (prefix) { / * countermeasure against known-IV weakness in CBC ciphersuites (see * http://www.openssl.org/~bodo/tls-cbc.txt) / prefixtempl->buf = NULL; prefixtempl->version = templates[0].version; prefixtempl->buflen = 0; prefixtempl->type = SSL3_RT_APPLICATION_DATA; wb = &bufs[0]; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (size_t)TLS_BUFFER_get_buf(wb) + SSL3_RT_HEADER_LENGTH; align = SSL3_ALIGN_PAYLOAD - 1 - ((align - 1) % SSL3_ALIGN_PAYLOAD); #endif TLS_BUFFER_set_offset(wb, align); if (!WPACKET_init_static_len(&pkt[0], TLS_BUFFER_get_buf(wb), TLS_BUFFER_get_len(wb), 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } wpinited = 1; if (!WPACKET_allocate_bytes(&pkt[0], align, NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return tls_initialise_write_packets_default(rl, templates, numtempl, NULL, pkt + prefix, bufs + prefix, wpinited); } /* TLSv1.0, TLSv1.1 and TLSv1.2 all use the same funcs / struct record_functions_st tls_1_funcs = { tls1_set_crypto_state, tls1_cipher, tls1_mac, tls_default_set_protocol_version, tls_default_read_n, tls_get_more_records, tls_default_validate_record_header, tls_default_post_process_record, tls_get_max_records_multiblock, tls_write_records_multiblock, / Defined in tls_multib.c / tls1_allocate_write_buffers, tls1_initialise_write_packets, NULL, tls_prepare_record_header_default, NULL, tls_prepare_for_encryption_default, tls_post_encryption_processing_default, NULL }; struct record_functions_st dtls_1_funcs = { tls1_set_crypto_state, tls1_cipher, tls1_mac, tls_default_set_protocol_version, tls_default_read_n, dtls_get_more_records, NULL, NULL, NULL, tls_write_records_default, / * Don't use tls1_allocate_write_buffers since that handles empty fragment * records which aren't needed in DTLS. We just use the default allocation * instead. / tls_allocate_write_buffers_default, / Don't use tls1_initialise_write_packets for same reason as above */ tls_initialise_write_packets_default, NULL, dtls_prepare_record_header, NULL, tls_prepare_for_encryption_default, dtls_post_encryption_processing, NULL };
./openssl/ssl/record/methods/recmethod_local.h	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/bio.h> #include <openssl/ssl.h> #include <openssl/err.h> #include "../../ssl_local.h" #include "../record_local.h" typedef struct dtls_bitmap_st { / Track 64 packets / uint64_t map; / Max record number seen so far, 64-bit value in big-endian encoding / unsigned char max_seq_num[SEQ_NUM_SIZE]; } DTLS_BITMAP; typedef struct ssl_mac_buf_st { unsigned char mac; int alloced; } SSL_MAC_BUF; typedef struct tls_buffer_st { /* at least SSL3_RT_MAX_PACKET_SIZE bytes / unsigned char buf; /* default buffer size (or 0 if no default set) / size_t default_len; / buffer size / size_t len; / where to 'copy from' / size_t offset; / how many bytes left / size_t left; / 'buf' is from application for KTLS / int app_buffer; / The type of data stored in this buffer. Only used for writing / int type; } TLS_BUFFER; typedef struct tls_rl_record_st { / Record layer version / / r / int rec_version; / type of record / / r / int type; / How many bytes available / / rw / size_t length; / * How many bytes were available before padding was removed? This is used * to implement the MAC check in constant time for CBC records. / / rw / size_t orig_len; / read/write offset into 'buf' / / r / size_t off; / pointer to the record data / / rw / unsigned char data; /* where the decode bytes are / / rw / unsigned char input; /* only used with decompression - malloc()ed / / r / unsigned char comp; /* epoch number, needed by DTLS1 / / r / uint16_t epoch; / sequence number, needed by DTLS1 / / r / unsigned char seq_num[SEQ_NUM_SIZE]; } TLS_RL_RECORD; / Macros/functions provided by the TLS_RL_RECORD component / #define TLS_RL_RECORD_set_type(r, t) ((r)->type = (t)) #define TLS_RL_RECORD_set_rec_version(r, v) ((r)->rec_version = (v)) #define TLS_RL_RECORD_get_length(r) ((r)->length) #define TLS_RL_RECORD_set_length(r, l) ((r)->length = (l)) #define TLS_RL_RECORD_add_length(r, l) ((r)->length += (l)) #define TLS_RL_RECORD_set_data(r, d) ((r)->data = (d)) #define TLS_RL_RECORD_set_input(r, i) ((r)->input = (i)) #define TLS_RL_RECORD_reset_input(r) ((r)->input = (r)->data) / Protocol version specific function pointers / struct record_functions_st { / * Returns either OSSL_RECORD_RETURN_SUCCESS, OSSL_RECORD_RETURN_FATAL or * OSSL_RECORD_RETURN_NON_FATAL_ERR if we can keep trying to find an * alternative record layer. / int (set_crypto_state)(OSSL_RECORD_LAYER rl, int level, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp); / * Returns: * 0: if the record is publicly invalid, or an internal error, or AEAD * decryption failed, or EtM decryption failed. * 1: Success or MtE decryption failed (MAC will be randomised) / int (cipher)(OSSL_RECORD_LAYER rl, TLS_RL_RECORD recs, size_t n_recs, int sending, SSL_MAC_BUF macs, size_t macsize); / Returns 1 for success or 0 for error / int (mac)(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec, unsigned char md, int sending); / Return 1 for success or 0 for error / int (set_protocol_version)(OSSL_RECORD_LAYER rl, int version); / Read related functions / int (read_n)(OSSL_RECORD_LAYER rl, size_t n, size_t max, int extend, int clearold, size_t readbytes); int (get_more_records)(OSSL_RECORD_LAYER rl); /* Return 1 for success or 0 for error / int (validate_record_header)(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec); /* Return 1 for success or 0 for error / int (post_process_record)(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec); /* Write related functions / size_t (get_max_records)(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t maxfrag, size_t preffrag); /* Return 1 for success or 0 for error / int (write_records)(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl); /* Allocate the rl->wbuf buffers. Return 1 for success or 0 for error / int (allocate_write_buffers)(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, size_t prefix); / * Initialise the packets in the \|pkt\| array using the buffers in \|rl->wbuf\|. * Some protocol versions may use the space in \|prefixtempl\| to add * an artificial template in front of the \|templates\| array and hence may * initialise 1 more WPACKET than there are templates. \|wpinited\| returns the number of WPACKETs in \|pkt\| that were successfully * initialised. This must be 0 on entry and will be filled in even on error. / int (initialise_write_packets)(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, OSSL_RECORD_TEMPLATE prefixtempl, WPACKET pkt, TLS_BUFFER bufs, size_t wpinited); /* Get the actual record type to be used for a given template / uint8_t (get_record_type)(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE template); /* Write the record header data to the WPACKET / int (prepare_record_header)(OSSL_RECORD_LAYER rl, WPACKET thispkt, OSSL_RECORD_TEMPLATE templ, uint8_t rectype, unsigned char recdata); int (add_record_padding)(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE thistempl, WPACKET thispkt, TLS_RL_RECORD thiswr); /* * This applies any mac that might be necessary, ensures that we have enough * space in the WPACKET to perform the encryption and sets up the * TLS_RL_RECORD ready for that encryption. / int (prepare_for_encryption)(OSSL_RECORD_LAYER rl, size_t mac_size, WPACKET thispkt, TLS_RL_RECORD thiswr); / * Any updates required to the record after encryption has been applied. For * example, adding a MAC if using encrypt-then-mac / int (post_encryption_processing)(OSSL_RECORD_LAYER rl, size_t mac_size, OSSL_RECORD_TEMPLATE thistempl, WPACKET thispkt, TLS_RL_RECORD thiswr); /* * Some record layer implementations need to do some custom preparation of * the BIO before we write to it. KTLS does this to prevent coalescing of * control and data messages. / int (prepare_write_bio)(OSSL_RECORD_LAYER rl, int type); }; struct ossl_record_layer_st { OSSL_LIB_CTX libctx; const char propq; int isdtls; int version; int role; int direction; int level; const EVP_MD md; /* DTLS only / uint16_t epoch; / * A BIO containing any data read in the previous epoch that was destined * for this epoch / BIO prev; /* The transport BIO / BIO bio; /* * A BIO where we will send any data read by us that is destined for the * next epoch. / BIO next; /* Types match the equivalent fields in the SSL object / uint64_t options; uint32_t mode; / write IO goes into here / TLS_BUFFER wbuf[SSL_MAX_PIPELINES + 1]; / Next wbuf with pending data still to write / size_t nextwbuf; / How many pipelines can be used to write data / size_t numwpipes; / read IO goes into here / TLS_BUFFER rbuf; / each decoded record goes in here / TLS_RL_RECORD rrec[SSL_MAX_PIPELINES]; / How many records have we got available in the rrec buffer / size_t num_recs; / The record number in the rrec buffer that can be read next / size_t curr_rec; / The number of records that have been released via tls_release_record / size_t num_released; / where we are when reading / int rstate; / used internally to point at a raw packet / unsigned char packet; size_t packet_length; /* Sequence number for the next record / unsigned char sequence[SEQ_NUM_SIZE]; / Alert code to be used if an error occurs / int alert; / * Read as many input bytes as possible (for non-blocking reads) / int read_ahead; / The number of consecutive empty records we have received / size_t empty_record_count; / * Do we need to send a prefix empty record before application data as a * countermeasure against known-IV weakness (necessary for SSLv3 and * TLSv1.0) / int need_empty_fragments; / cryptographic state / EVP_CIPHER_CTX enc_ctx; /* Explicit IV length / size_t eivlen; / used for mac generation / EVP_MD_CTX md_ctx; /* compress/uncompress / COMP_CTX compctx; /* Set to 1 if this is the first handshake. 0 otherwise / int is_first_handshake; / * The smaller of the configured and negotiated maximum fragment length * or SSL3_RT_MAX_PLAIN_LENGTH if none / unsigned int max_frag_len; / The maximum amount of early data we can receive/send / uint32_t max_early_data; / The amount of early data that we have sent/received / size_t early_data_count; / TLSv1.3 record padding / size_t block_padding; / Only used by SSLv3 / unsigned char mac_secret[EVP_MAX_MD_SIZE]; / TLSv1.0/TLSv1.1/TLSv1.2 / int use_etm; / Flags for GOST ciphers / int stream_mac; int tlstree; / TLSv1.3 fields / / static IV / unsigned char iv[EVP_MAX_IV_LENGTH]; int allow_plain_alerts; / TLS "any" fields / / Set to true if this is the first record in a connection / unsigned int is_first_record; size_t taglen; / DTLS received handshake records (processed and unprocessed) / record_pqueue unprocessed_rcds; record_pqueue processed_rcds; / records being received in the current epoch / DTLS_BITMAP bitmap; / renegotiation starts a new set of sequence numbers / DTLS_BITMAP next_bitmap; / * Whether we are currently in a handshake or not. Only maintained for DTLS / int in_init; / Callbacks / void cbarg; OSSL_FUNC_rlayer_skip_early_data_fn skip_early_data; OSSL_FUNC_rlayer_msg_callback_fn msg_callback; OSSL_FUNC_rlayer_security_fn security; OSSL_FUNC_rlayer_padding_fn padding; size_t max_pipelines; /* Function pointers for version specific functions / struct record_functions_st funcs; }; typedef struct dtls_rlayer_record_data_st { unsigned char packet; size_t packet_length; TLS_BUFFER rbuf; TLS_RL_RECORD rrec; } DTLS_RLAYER_RECORD_DATA; extern struct record_functions_st ssl_3_0_funcs; extern struct record_functions_st tls_1_funcs; extern struct record_functions_st tls_1_3_funcs; extern struct record_functions_st tls_any_funcs; extern struct record_functions_st dtls_1_funcs; extern struct record_functions_st dtls_any_funcs; void ossl_rlayer_fatal(OSSL_RECORD_LAYER rl, int al, int reason, const char fmt, ...); #define RLAYERfatal(rl, al, r) RLAYERfatal_data((rl), (al), (r), NULL) #define RLAYERfatal_data \ (ERR_new(), \ ERR_set_debug(OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC), \ ossl_rlayer_fatal) #define RLAYER_USE_EXPLICIT_IV(rl) ((rl)->version == TLS1_1_VERSION \ \|\| (rl)->version == TLS1_2_VERSION \ \|\| (rl)->isdtls) void ossl_tls_rl_record_set_seq_num(TLS_RL_RECORD r, const unsigned char seq_num); int ossl_set_tls_provider_parameters(OSSL_RECORD_LAYER rl, EVP_CIPHER_CTX ctx, const EVP_CIPHER ciph, const EVP_MD md); int tls_increment_sequence_ctr(OSSL_RECORD_LAYER rl); int tls_alloc_buffers(OSSL_RECORD_LAYER rl); int tls_free_buffers(OSSL_RECORD_LAYER rl); int tls_default_read_n(OSSL_RECORD_LAYER rl, size_t n, size_t max, int extend, int clearold, size_t readbytes); int tls_get_more_records(OSSL_RECORD_LAYER rl); int dtls_get_more_records(OSSL_RECORD_LAYER rl); int dtls_prepare_record_header(OSSL_RECORD_LAYER rl, WPACKET thispkt, OSSL_RECORD_TEMPLATE templ, uint8_t rectype, unsigned char recdata); int dtls_post_encryption_processing(OSSL_RECORD_LAYER rl, size_t mac_size, OSSL_RECORD_TEMPLATE thistempl, WPACKET thispkt, TLS_RL_RECORD thiswr); int tls_default_set_protocol_version(OSSL_RECORD_LAYER rl, int version); int tls_default_validate_record_header(OSSL_RECORD_LAYER rl, TLS_RL_RECORD re); int tls_do_compress(OSSL_RECORD_LAYER rl, TLS_RL_RECORD wr); int tls_do_uncompress(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec); int tls_default_post_process_record(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec); int tls13_common_post_process_record(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec); int tls_int_new_record_layer(OSSL_LIB_CTX libctx, const char propq, int vers, int role, int direction, int level, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp, BIO prev, BIO transport, BIO next, BIO_ADDR local, BIO_ADDR peer, const OSSL_PARAM settings, const OSSL_PARAM options, const OSSL_DISPATCH fns, void cbarg, OSSL_RECORD_LAYER retrl); int tls_free(OSSL_RECORD_LAYER rl); int tls_unprocessed_read_pending(OSSL_RECORD_LAYER rl); int tls_processed_read_pending(OSSL_RECORD_LAYER rl); size_t tls_app_data_pending(OSSL_RECORD_LAYER rl); size_t tls_get_max_records(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t maxfrag, size_t preffrag); int tls_write_records(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl); int tls_retry_write_records(OSSL_RECORD_LAYER rl); int tls_get_alert_code(OSSL_RECORD_LAYER rl); int tls_set1_bio(OSSL_RECORD_LAYER rl, BIO bio); int tls_read_record(OSSL_RECORD_LAYER rl, void *rechandle, int rversion, uint8_t type, const unsigned char data, size_t datalen, uint16_t epoch, unsigned char seq_num); int tls_release_record(OSSL_RECORD_LAYER rl, void rechandle, size_t length); int tls_default_set_protocol_version(OSSL_RECORD_LAYER rl, int version); int tls_set_protocol_version(OSSL_RECORD_LAYER rl, int version); void tls_set_plain_alerts(OSSL_RECORD_LAYER rl, int allow); void tls_set_first_handshake(OSSL_RECORD_LAYER rl, int first); void tls_set_max_pipelines(OSSL_RECORD_LAYER rl, size_t max_pipelines); void tls_get_state(OSSL_RECORD_LAYER rl, const char shortstr, const char longstr); int tls_set_options(OSSL_RECORD_LAYER rl, const OSSL_PARAM options); const COMP_METHOD tls_get_compression(OSSL_RECORD_LAYER rl); void tls_set_max_frag_len(OSSL_RECORD_LAYER rl, size_t max_frag_len); int tls_setup_read_buffer(OSSL_RECORD_LAYER rl); int tls_setup_write_buffer(OSSL_RECORD_LAYER rl, size_t numwpipes, size_t firstlen, size_t nextlen); int tls_write_records_multiblock(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl); size_t tls_get_max_records_default(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t maxfrag, size_t preffrag); size_t tls_get_max_records_multiblock(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t maxfrag, size_t preffrag); int tls_allocate_write_buffers_default(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, size_t prefix); int tls_initialise_write_packets_default(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, OSSL_RECORD_TEMPLATE prefixtempl, WPACKET pkt, TLS_BUFFER bufs, size_t wpinited); int tls1_allocate_write_buffers(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, size_t prefix); int tls1_initialise_write_packets(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl, OSSL_RECORD_TEMPLATE prefixtempl, WPACKET pkt, TLS_BUFFER bufs, size_t wpinited); int tls_prepare_record_header_default(OSSL_RECORD_LAYER rl, WPACKET thispkt, OSSL_RECORD_TEMPLATE templ, uint8_t rectype, unsigned char *recdata); int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER rl, size_t mac_size, WPACKET thispkt, TLS_RL_RECORD thiswr); int tls_post_encryption_processing_default(OSSL_RECORD_LAYER rl, size_t mac_size, OSSL_RECORD_TEMPLATE thistempl, WPACKET thispkt, TLS_RL_RECORD thiswr); int tls_write_records_default(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl); /* Macros/functions provided by the TLS_BUFFER component / #define TLS_BUFFER_get_buf(b) ((b)->buf) #define TLS_BUFFER_set_buf(b, n) ((b)->buf = (n)) #define TLS_BUFFER_get_len(b) ((b)->len) #define TLS_BUFFER_get_left(b) ((b)->left) #define TLS_BUFFER_set_left(b, l) ((b)->left = (l)) #define TLS_BUFFER_sub_left(b, l) ((b)->left -= (l)) #define TLS_BUFFER_get_offset(b) ((b)->offset) #define TLS_BUFFER_set_offset(b, o) ((b)->offset = (o)) #define TLS_BUFFER_add_offset(b, o) ((b)->offset += (o)) #define TLS_BUFFER_set_app_buffer(b, l) ((b)->app_buffer = (l)) #define TLS_BUFFER_is_app_buffer(b) ((b)->app_buffer) void ossl_tls_buffer_release(TLS_BUFFER b);
./openssl/ssl/record/methods/tls_multib.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" #if defined(OPENSSL_SMALL_FOOTPRINT) \ \|\| !(defined(AES_ASM) && (defined(__x86_64) \ \|\| defined(__x86_64__) \ \|\| defined(_M_AMD64) \ \|\| defined(_M_X64))) # undef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK # define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0 #endif static int tls_is_multiblock_capable(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t fraglen) { #if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK if (type == SSL3_RT_APPLICATION_DATA && len >= 4 * fraglen && rl->compctx == NULL && rl->msg_callback == NULL && !rl->use_etm && RLAYER_USE_EXPLICIT_IV(rl) && !BIO_get_ktls_send(rl->bio) && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx)) & EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK) != 0) return 1; #endif return 0; } size_t tls_get_max_records_multiblock(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t maxfrag, size_t preffrag) { if (tls_is_multiblock_capable(rl, type, len, preffrag)) { / minimize address aliasing conflicts / if ((preffrag & 0xfff) == 0) preffrag -= 512; if (len >= 8 (preffrag)) return 8; return 4; } return tls_get_max_records_default(rl, type, len, maxfrag, preffrag); } / * Write records using the multiblock method. * * Returns 1 on success, 0 if multiblock isn't suitable (non-fatal error), or * -1 on fatal error. / static int tls_write_records_multiblock_int(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl) { #if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK size_t i; size_t totlen; TLS_BUFFER wb; unsigned char aad[13]; EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param; size_t packlen; int packleni; if (numtempl != 4 && numtempl != 8) return 0; /* * Check templates have contiguous buffers and are all the same type and * length / for (i = 1; i < numtempl; i++) { if (templates[i - 1].type != templates[i].type \|\| templates[i - 1].buflen != templates[i].buflen \|\| templates[i - 1].buf + templates[i - 1].buflen != templates[i].buf) return 0; } totlen = templates[0].buflen numtempl; if (!tls_is_multiblock_capable(rl, templates[0].type, totlen, templates[0].buflen)) return 0; /* * If we get this far, then multiblock is suitable * Depending on platform multi-block can deliver several times * better performance. Downside is that it has to allocate * jumbo buffer to accommodate up to 8 records, but the * compromise is considered worthy. / / * Allocate jumbo buffer. This will get freed next time we do a non * multiblock write in the call to tls_setup_write_buffer() - the different * buffer sizes will be spotted and the buffer reallocated. / packlen = EVP_CIPHER_CTX_ctrl(rl->enc_ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE, (int)templates[0].buflen, NULL); packlen = numtempl; if (!tls_setup_write_buffer(rl, 1, packlen, packlen)) { /* RLAYERfatal() already called / return -1; } wb = &rl->wbuf[0]; mb_param.interleave = numtempl; memcpy(aad, rl->sequence, 8); aad[8] = templates[0].type; aad[9] = (unsigned char)(templates[0].version >> 8); aad[10] = (unsigned char)(templates[0].version); aad[11] = 0; aad[12] = 0; mb_param.out = NULL; mb_param.inp = aad; mb_param.len = totlen; packleni = EVP_CIPHER_CTX_ctrl(rl->enc_ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD, sizeof(mb_param), &mb_param); packlen = (size_t)packleni; if (packleni <= 0 \|\| packlen > wb->len) { / never happens / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } mb_param.out = wb->buf; mb_param.inp = templates[0].buf; mb_param.len = totlen; if (EVP_CIPHER_CTX_ctrl(rl->enc_ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT, sizeof(mb_param), &mb_param) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } rl->sequence[7] += mb_param.interleave; if (rl->sequence[7] < mb_param.interleave) { int j = 6; while (j >= 0 && (++rl->sequence[j--]) == 0) ; } wb->offset = 0; wb->left = packlen; return 1; #else / !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK / return 0; #endif } int tls_write_records_multiblock(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE templates, size_t numtempl) { int ret; ret = tls_write_records_multiblock_int(rl, templates, numtempl); if (ret < 0) { / RLAYERfatal already called / return 0; } if (ret == 0) { / Multiblock wasn't suitable so just do a standard write / if (!tls_write_records_default(rl, templates, numtempl)) { / RLAYERfatal already called */ return 0; } } return 1; }
./openssl/ssl/record/methods/tls_pad.c	/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/rand.h> #include <openssl/evp.h> #include "internal/constant_time.h" #include "internal/cryptlib.h" #include "internal/ssl3_cbc.h" / * This file has no dependencies on the rest of libssl because it is shared * with the providers. It contains functions for low level CBC TLS padding * removal. Responsibility for this lies with the cipher implementations in the * providers. However there are legacy code paths in libssl which also need to * do this. In time those legacy code paths can be removed and this file can be * moved out of libssl. / static int ssl3_cbc_copy_mac(size_t reclen, size_t origreclen, unsigned char recdata, unsigned char mac, int alloced, size_t block_size, size_t mac_size, size_t good, OSSL_LIB_CTX libctx); /- * ssl3_cbc_remove_padding removes padding from the decrypted, SSLv3, CBC * record in \|recdata\| by updating \|reclen\| in constant time. It also extracts * the MAC from the underlying record and places a pointer to it in \|mac\|. The * MAC data can either be newly allocated memory, or a pointer inside the * \|recdata\| buffer. If allocated then \|alloced\| is set to 1, otherwise it is set to 0. * * origreclen: the original record length before any changes were made * block_size: the block size of the cipher used to encrypt the record. * mac_size: the size of the MAC to be extracted * aead: 1 if an AEAD cipher is in use, or 0 otherwise * returns: * 0: if the record is publicly invalid. * 1: if the record is publicly valid. If the padding removal fails then the * MAC returned is random. / int ssl3_cbc_remove_padding_and_mac(size_t reclen, size_t origreclen, unsigned char recdata, unsigned char mac, int alloced, size_t block_size, size_t mac_size, OSSL_LIB_CTX libctx) { size_t padding_length; size_t good; const size_t overhead = 1 / padding length byte / + mac_size; / * These lengths are all public so we can test them in non-constant time. / if (overhead > reclen) return 0; padding_length = recdata[reclen - 1]; good = constant_time_ge_s(reclen, padding_length + overhead); /* SSLv3 requires that the padding is minimal. / good &= constant_time_ge_s(block_size, padding_length + 1); reclen -= good & (padding_length + 1); return ssl3_cbc_copy_mac(reclen, origreclen, recdata, mac, alloced, block_size, mac_size, good, libctx); } /- tls1_cbc_remove_padding_and_mac removes padding from the decrypted, TLS, CBC * record in \|recdata\| by updating \|reclen\| in constant time. It also extracts * the MAC from the underlying record and places a pointer to it in \|mac\|. The * MAC data can either be newly allocated memory, or a pointer inside the * \|recdata\| buffer. If allocated then \|alloced\| is set to 1, otherwise it is set to 0. * * origreclen: the original record length before any changes were made * block_size: the block size of the cipher used to encrypt the record. * mac_size: the size of the MAC to be extracted * aead: 1 if an AEAD cipher is in use, or 0 otherwise * returns: * 0: if the record is publicly invalid. * 1: if the record is publicly valid. If the padding removal fails then the * MAC returned is random. / int tls1_cbc_remove_padding_and_mac(size_t reclen, size_t origreclen, unsigned char recdata, unsigned char mac, int alloced, size_t block_size, size_t mac_size, int aead, OSSL_LIB_CTX libctx) { size_t good = -1; size_t padding_length, to_check, i; size_t overhead = ((block_size == 1) ? 0 : 1) / padding length byte / + mac_size; / * These lengths are all public so we can test them in non-constant * time. / if (overhead > reclen) return 0; if (block_size != 1) { padding_length = recdata[reclen - 1]; if (aead) { / padding is already verified and we don't need to check the MAC / reclen -= padding_length + 1 + mac_size; return 1; } good = constant_time_ge_s(reclen, overhead + padding_length); / * The padding consists of a length byte at the end of the record and * then that many bytes of padding, all with the same value as the * length byte. Thus, with the length byte included, there are i+1 bytes * of padding. We can't check just \|padding_length+1\| bytes because that * leaks decrypted information. Therefore we always have to check the * maximum amount of padding possible. (Again, the length of the record * is public information so we can use it.) / to_check = 256; / maximum amount of padding, inc length byte. / if (to_check > reclen) to_check = reclen; for (i = 0; i < to_check; i++) { unsigned char mask = constant_time_ge_8_s(padding_length, i); unsigned char b = recdata[reclen - 1 - i]; /* * The final \|padding_length+1\| bytes should all have the value * \|padding_length\|. Therefore the XOR should be zero. / good &= ~(mask & (padding_length ^ b)); } / * If any of the final \|padding_length+1\| bytes had the wrong value, one * or more of the lower eight bits of \|good\| will be cleared. / good = constant_time_eq_s(0xff, good & 0xff); reclen -= good & (padding_length + 1); } return ssl3_cbc_copy_mac(reclen, origreclen, recdata, mac, alloced, block_size, mac_size, good, libctx); } /- ssl3_cbc_copy_mac copies \|md_size\| bytes from the end of the record in * \|recdata\| to \|mac\| in constant time (independent of the concrete value of the record length \|reclen\|, which may vary within a 256-byte window). * * On entry: * origreclen >= mac_size * mac_size <= EVP_MAX_MD_SIZE * * If CBC_MAC_ROTATE_IN_PLACE is defined then the rotation is performed with * variable accesses in a 64-byte-aligned buffer. Assuming that this fits into * a single or pair of cache-lines, then the variable memory accesses don't * actually affect the timing. CPUs with smaller cache-lines [if any] are * not multi-core and are not considered vulnerable to cache-timing attacks. / #define CBC_MAC_ROTATE_IN_PLACE static int ssl3_cbc_copy_mac(size_t reclen, size_t origreclen, unsigned char recdata, unsigned char mac, int alloced, size_t block_size, size_t mac_size, size_t good, OSSL_LIB_CTX libctx) { #if defined(CBC_MAC_ROTATE_IN_PLACE) unsigned char rotated_mac_buf[64 + EVP_MAX_MD_SIZE]; unsigned char rotated_mac; char aux1, aux2, aux3, mask; #else unsigned char rotated_mac[EVP_MAX_MD_SIZE]; #endif unsigned char randmac[EVP_MAX_MD_SIZE]; unsigned char out; / * mac_end is the index of \|recdata\| just after the end of the MAC. / size_t mac_end = reclen; size_t mac_start = mac_end - mac_size; size_t in_mac; /* * scan_start contains the number of bytes that we can ignore because the * MAC's position can only vary by 255 bytes. / size_t scan_start = 0; size_t i, j; size_t rotate_offset; if (!ossl_assert(origreclen >= mac_size && mac_size <= EVP_MAX_MD_SIZE)) return 0; / If no MAC then nothing to be done / if (mac_size == 0) { / No MAC so we can do this in non-constant time / if (good == 0) return 0; return 1; } reclen -= mac_size; if (block_size == 1) { /* There's no padding so the position of the MAC is fixed / if (mac != NULL) mac = &recdata[reclen]; if (alloced != NULL) alloced = 0; return 1; } /* Create the random MAC we will emit if padding is bad / if (RAND_bytes_ex(libctx, randmac, mac_size, 0) <= 0) return 0; if (!ossl_assert(mac != NULL && alloced != NULL)) return 0; mac = out = OPENSSL_malloc(mac_size); if (mac == NULL) return 0; alloced = 1; #if defined(CBC_MAC_ROTATE_IN_PLACE) rotated_mac = rotated_mac_buf + ((0 - (size_t)rotated_mac_buf) & 63); #endif /* This information is public so it's safe to branch based on it. / if (origreclen > mac_size + 255 + 1) scan_start = origreclen - (mac_size + 255 + 1); in_mac = 0; rotate_offset = 0; memset(rotated_mac, 0, mac_size); for (i = scan_start, j = 0; i < origreclen; i++) { size_t mac_started = constant_time_eq_s(i, mac_start); size_t mac_ended = constant_time_lt_s(i, mac_end); unsigned char b = recdata[i]; in_mac \|= mac_started; in_mac &= mac_ended; rotate_offset \|= j & mac_started; rotated_mac[j++] \|= b & in_mac; j &= constant_time_lt_s(j, mac_size); } / Now rotate the MAC / #if defined(CBC_MAC_ROTATE_IN_PLACE) j = 0; for (i = 0; i < mac_size; i++) { / * in case cache-line is 32 bytes, * load from both lines and select appropriately / aux1 = rotated_mac[rotate_offset & ~32]; aux2 = rotated_mac[rotate_offset \| 32]; mask = constant_time_eq_8(rotate_offset & ~32, rotate_offset); aux3 = constant_time_select_8(mask, aux1, aux2); rotate_offset++; / If the padding wasn't good we emit a random MAC / out[j++] = constant_time_select_8((unsigned char)(good & 0xff), aux3, randmac[i]); rotate_offset &= constant_time_lt_s(rotate_offset, mac_size); } #else memset(out, 0, mac_size); rotate_offset = mac_size - rotate_offset; rotate_offset &= constant_time_lt_s(rotate_offset, mac_size); for (i = 0; i < mac_size; i++) { for (j = 0; j < mac_size; j++) out[j] \|= rotated_mac[i] & constant_time_eq_8_s(j, rotate_offset); rotate_offset++; rotate_offset &= constant_time_lt_s(rotate_offset, mac_size); / If the padding wasn't good we emit a random MAC */ out[i] = constant_time_select_8((unsigned char)(good & 0xff), out[i], randmac[i]); } #endif return 1; }
./openssl/ssl/record/methods/ssl3_meth.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/evp.h> #include <openssl/core_names.h> #include "internal/ssl3_cbc.h" #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" static int ssl3_set_crypto_state(OSSL_RECORD_LAYER rl, int level, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp) { EVP_CIPHER_CTX ciph_ctx; int enc = (rl->direction == OSSL_RECORD_DIRECTION_WRITE) ? 1 : 0; if (md == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } if ((rl->enc_ctx = EVP_CIPHER_CTX_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } ciph_ctx = rl->enc_ctx; rl->md_ctx = EVP_MD_CTX_new(); if (rl->md_ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } if ((md != NULL && EVP_DigestInit_ex(rl->md_ctx, md, NULL) <= 0)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } #ifndef OPENSSL_NO_COMP if (comp != NULL) { rl->compctx = COMP_CTX_new(comp); if (rl->compctx == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_COMPRESSION_LIBRARY_ERROR); return OSSL_RECORD_RETURN_FATAL; } } #endif if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, key, iv, enc)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } / * The cipher we actually ended up using in the EVP_CIPHER_CTX may be * different to that in ciph if we have an ENGINE in use / if (EVP_CIPHER_get0_provider(EVP_CIPHER_CTX_get0_cipher(ciph_ctx)) != NULL && !ossl_set_tls_provider_parameters(rl, ciph_ctx, ciph, md)) { / ERR_raise already called / return OSSL_RECORD_RETURN_FATAL; } if (mackeylen > sizeof(rl->mac_secret)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } memcpy(rl->mac_secret, mackey, mackeylen); return OSSL_RECORD_RETURN_SUCCESS; } / * ssl3_cipher encrypts/decrypts \|n_recs\| records in \|inrecs\|. Calls RLAYERfatal * on internal error, but not otherwise. It is the responsibility of the caller * to report a bad_record_mac * * Returns: * 0: if the record is publicly invalid, or an internal error * 1: Success or Mac-then-encrypt decryption failed (MAC will be randomised) / static int ssl3_cipher(OSSL_RECORD_LAYER rl, TLS_RL_RECORD inrecs, size_t n_recs, int sending, SSL_MAC_BUF mac, size_t macsize) { TLS_RL_RECORD rec; EVP_CIPHER_CTX ds; size_t l, i; size_t bs; const EVP_CIPHER enc; int provided; rec = inrecs; / * We shouldn't ever be called with more than one record in the SSLv3 case / if (n_recs != 1) return 0; ds = rl->enc_ctx; if (ds == NULL \|\| (enc = EVP_CIPHER_CTX_get0_cipher(ds)) == NULL) return 0; provided = (EVP_CIPHER_get0_provider(enc) != NULL); l = rec->length; bs = EVP_CIPHER_CTX_get_block_size(ds); / COMPRESS / if ((bs != 1) && sending && !provided) { / * We only do this for legacy ciphers. Provided ciphers add the * padding on the provider side. / i = bs - (l % bs); / we need to add 'i-1' padding bytes / l += i; / * the last of these zero bytes will be overwritten with the * padding length. / memset(&rec->input[rec->length], 0, i); rec->length += i; rec->input[l - 1] = (unsigned char)(i - 1); } if (!sending) { if (l == 0 \|\| l % bs != 0) { / Publicly invalid / return 0; } / otherwise, rec->length >= bs / } if (provided) { int outlen; if (!EVP_CipherUpdate(ds, rec->data, &outlen, rec->input, (unsigned int)l)) return 0; rec->length = outlen; if (!sending && mac != NULL) { / Now get a pointer to the MAC / OSSL_PARAM params[2], p = params; /* Get the MAC / mac->alloced = 0; p++ = OSSL_PARAM_construct_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, (void *)&mac->mac, macsize); p = OSSL_PARAM_construct_end(); if (!EVP_CIPHER_CTX_get_params(ds, params)) { /* Shouldn't normally happen / RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } else { if (EVP_Cipher(ds, rec->data, rec->input, (unsigned int)l) < 1) { / Shouldn't happen / RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, ERR_R_INTERNAL_ERROR); return 0; } if (!sending) return ssl3_cbc_remove_padding_and_mac(&rec->length, rec->orig_len, rec->data, (mac != NULL) ? &mac->mac : NULL, (mac != NULL) ? &mac->alloced : NULL, bs, macsize, rl->libctx); } return 1; } static const unsigned char ssl3_pad_1[48] = { 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36 }; static const unsigned char ssl3_pad_2[48] = { 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c }; static int ssl3_mac(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rec, unsigned char md, int sending) { unsigned char mac_sec, seq = rl->sequence; const EVP_MD_CTX hash; unsigned char p, rec_char; size_t md_size; size_t npad; int t; mac_sec = &(rl->mac_secret[0]); hash = rl->md_ctx; t = EVP_MD_CTX_get_size(hash); if (t <= 0) return 0; md_size = t; npad = (48 / md_size) * md_size; if (!sending && EVP_CIPHER_CTX_get_mode(rl->enc_ctx) == EVP_CIPH_CBC_MODE && ssl3_cbc_record_digest_supported(hash)) { #ifdef OPENSSL_NO_DEPRECATED_3_0 return 0; #else /* * This is a CBC-encrypted record. We must avoid leaking any * timing-side channel information about how many blocks of data we * are hashing because that gives an attacker a timing-oracle. / /- * npad is, at most, 48 bytes and that's with MD5: * 16 + 48 + 8 (sequence bytes) + 1 + 2 = 75. * * With SHA-1 (the largest hash speced for SSLv3) the hash size * goes up 4, but npad goes down by 8, resulting in a smaller * total size. / unsigned char header[75]; size_t j = 0; memcpy(header + j, mac_sec, md_size); j += md_size; memcpy(header + j, ssl3_pad_1, npad); j += npad; memcpy(header + j, seq, 8); j += 8; header[j++] = rec->type; header[j++] = (unsigned char)(rec->length >> 8); header[j++] = (unsigned char)(rec->length & 0xff); / Final param == is SSLv3 / if (ssl3_cbc_digest_record(EVP_MD_CTX_get0_md(hash), md, &md_size, header, rec->input, rec->length, rec->orig_len, mac_sec, md_size, 1) <= 0) return 0; #endif } else { unsigned int md_size_u; / Chop the digest off the end :-) / EVP_MD_CTX md_ctx = EVP_MD_CTX_new(); if (md_ctx == NULL) return 0; rec_char = rec->type; p = md; s2n(rec->length, p); if (EVP_MD_CTX_copy_ex(md_ctx, hash) <= 0 \|\| EVP_DigestUpdate(md_ctx, mac_sec, md_size) <= 0 \|\| EVP_DigestUpdate(md_ctx, ssl3_pad_1, npad) <= 0 \|\| EVP_DigestUpdate(md_ctx, seq, 8) <= 0 \|\| EVP_DigestUpdate(md_ctx, &rec_char, 1) <= 0 \|\| EVP_DigestUpdate(md_ctx, md, 2) <= 0 \|\| EVP_DigestUpdate(md_ctx, rec->input, rec->length) <= 0 \|\| EVP_DigestFinal_ex(md_ctx, md, NULL) <= 0 \|\| EVP_MD_CTX_copy_ex(md_ctx, hash) <= 0 \|\| EVP_DigestUpdate(md_ctx, mac_sec, md_size) <= 0 \|\| EVP_DigestUpdate(md_ctx, ssl3_pad_2, npad) <= 0 \|\| EVP_DigestUpdate(md_ctx, md, md_size) <= 0 \|\| EVP_DigestFinal_ex(md_ctx, md, &md_size_u) <= 0) { EVP_MD_CTX_free(md_ctx); return 0; } EVP_MD_CTX_free(md_ctx); } if (!tls_increment_sequence_ctr(rl)) return 0; return 1; } struct record_functions_st ssl_3_0_funcs = { ssl3_set_crypto_state, ssl3_cipher, ssl3_mac, tls_default_set_protocol_version, tls_default_read_n, tls_get_more_records, tls_default_validate_record_header, tls_default_post_process_record, tls_get_max_records_default, tls_write_records_default, /* These 2 functions are defined in tls1_meth.c */ tls1_allocate_write_buffers, tls1_initialise_write_packets, NULL, tls_prepare_record_header_default, NULL, tls_prepare_for_encryption_default, tls_post_encryption_processing_default, NULL };
./openssl/ssl/record/methods/dtls_meth.c	/* * Copyright 2018-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <assert.h> #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" / mod 128 saturating subtract of two 64-bit values in big-endian order / static int satsub64be(const unsigned char v1, const unsigned char v2) { int64_t ret; uint64_t l1, l2; n2l8(v1, l1); n2l8(v2, l2); ret = l1 - l2; / We do not permit wrap-around / if (l1 > l2 && ret < 0) return 128; else if (l2 > l1 && ret > 0) return -128; if (ret > 128) return 128; else if (ret < -128) return -128; else return (int)ret; } static int dtls_record_replay_check(OSSL_RECORD_LAYER rl, DTLS_BITMAP bitmap) { int cmp; unsigned int shift; const unsigned char seq = rl->sequence; cmp = satsub64be(seq, bitmap->max_seq_num); if (cmp > 0) { ossl_tls_rl_record_set_seq_num(&rl->rrec[0], seq); return 1; /* this record in new / } shift = -cmp; if (shift >= sizeof(bitmap->map) 8) return 0; /* stale, outside the window / else if (bitmap->map & ((uint64_t)1 << shift)) return 0; / record previously received / ossl_tls_rl_record_set_seq_num(&rl->rrec[0], seq); return 1; } static void dtls_record_bitmap_update(OSSL_RECORD_LAYER rl, DTLS_BITMAP bitmap) { int cmp; unsigned int shift; const unsigned char seq = rl->sequence; cmp = satsub64be(seq, bitmap->max_seq_num); if (cmp > 0) { shift = cmp; if (shift < sizeof(bitmap->map) * 8) bitmap->map <<= shift, bitmap->map \|= 1UL; else bitmap->map = 1UL; memcpy(bitmap->max_seq_num, seq, SEQ_NUM_SIZE); } else { shift = -cmp; if (shift < sizeof(bitmap->map) * 8) bitmap->map \|= (uint64_t)1 << shift; } } static DTLS_BITMAP dtls_get_bitmap(OSSL_RECORD_LAYER rl, TLS_RL_RECORD rr, unsigned int is_next_epoch) { is_next_epoch = 0; / In current epoch, accept HM, CCS, DATA, & ALERT / if (rr->epoch == rl->epoch) return &rl->bitmap; / * We can only handle messages from the next epoch if we have already * processed all of the unprocessed records from the previous epoch / else if (rr->epoch == (unsigned long)(rl->epoch + 1) && rl->unprocessed_rcds.epoch != rl->epoch) { is_next_epoch = 1; return &rl->next_bitmap; } return NULL; } static void dtls_set_in_init(OSSL_RECORD_LAYER rl, int in_init) { rl->in_init = in_init; } static int dtls_process_record(OSSL_RECORD_LAYER rl, DTLS_BITMAP bitmap) { int i; int enc_err; TLS_RL_RECORD rr; int imac_size; size_t mac_size = 0; unsigned char md[EVP_MAX_MD_SIZE]; SSL_MAC_BUF macbuf = { NULL, 0 }; int ret = 0; rr = &rl->rrec[0]; /* * At this point, rl->packet_length == DTLS1_RT_HEADER_LENGTH + rr->length, * and we have that many bytes in rl->packet / rr->input = &(rl->packet[DTLS1_RT_HEADER_LENGTH]); / * ok, we can now read from 'rl->packet' data into 'rr'. rr->input * points at rr->length bytes, which need to be copied into rr->data by * either the decryption or by the decompression. When the data is 'copied' * into the rr->data buffer, rr->input will be pointed at the new buffer / / * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length * bytes of encrypted compressed stuff. / / check is not needed I believe / if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_ENCRYPTED_LENGTH_TOO_LONG); return 0; } / decrypt in place in 'rr->input' / rr->data = rr->input; rr->orig_len = rr->length; if (rl->md_ctx != NULL) { const EVP_MD tmpmd = EVP_MD_CTX_get0_md(rl->md_ctx); if (tmpmd != NULL) { imac_size = EVP_MD_get_size(tmpmd); if (!ossl_assert(imac_size >= 0 && imac_size <= EVP_MAX_MD_SIZE)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } mac_size = (size_t)imac_size; } } if (rl->use_etm && rl->md_ctx != NULL) { unsigned char mac; if (rr->orig_len < mac_size) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); return 0; } rr->length -= mac_size; mac = rr->data + rr->length; i = rl->funcs->mac(rl, rr, md, 0 / not send /); if (i == 0 \|\| CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) { RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); return 0; } / * We've handled the mac now - there is no MAC inside the encrypted * record / mac_size = 0; } / * Set a mark around the packet decryption attempt. This is DTLS, so * bad packets are just ignored, and we don't want to leave stray * errors in the queue from processing bogus junk that we ignored. / ERR_set_mark(); enc_err = rl->funcs->cipher(rl, rr, 1, 0, &macbuf, mac_size); /- * enc_err is: * 0: if the record is publicly invalid, or an internal error, or AEAD * decryption failed, or ETM decryption failed. * 1: Success or MTE decryption failed (MAC will be randomised) / if (enc_err == 0) { ERR_pop_to_mark(); if (rl->alert != SSL_AD_NO_ALERT) { / RLAYERfatal() already called / goto end; } / For DTLS we simply ignore bad packets. / rr->length = 0; rl->packet_length = 0; goto end; } ERR_clear_last_mark(); OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "dec %zd\n", rr->length); BIO_dump_indent(trc_out, rr->data, rr->length, 4); } OSSL_TRACE_END(TLS); / r->length is now the compressed data plus mac / if (!rl->use_etm && (rl->enc_ctx != NULL) && (EVP_MD_CTX_get0_md(rl->md_ctx) != NULL)) { / rl->md_ctx != NULL => mac_size != -1 / i = rl->funcs->mac(rl, rr, md, 0 / not send /); if (i == 0 \|\| macbuf.mac == NULL \|\| CRYPTO_memcmp(md, macbuf.mac, mac_size) != 0) enc_err = 0; if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size) enc_err = 0; } if (enc_err == 0) { / decryption failed, silently discard message / rr->length = 0; rl->packet_length = 0; goto end; } / r->length is now just compressed / if (rl->compctx != NULL) { if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_COMPRESSED_LENGTH_TOO_LONG); goto end; } if (!tls_do_uncompress(rl, rr)) { RLAYERfatal(rl, SSL_AD_DECOMPRESSION_FAILURE, SSL_R_BAD_DECOMPRESSION); goto end; } } / * Check if the received packet overflows the current Max Fragment * Length setting. / if (rr->length > rl->max_frag_len) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); goto end; } rr->off = 0; /- * So at this point the following is true * ssl->s3.rrec.type is the type of record * ssl->s3.rrec.length == number of bytes in record * ssl->s3.rrec.off == offset to first valid byte * ssl->s3.rrec.data == where to take bytes from, increment * after use :-). / / we have pulled in a full packet so zero things / rl->packet_length = 0; / Mark receipt of record. / dtls_record_bitmap_update(rl, bitmap); ret = 1; end: if (macbuf.alloced) OPENSSL_free(macbuf.mac); return ret; } static int dtls_rlayer_buffer_record(OSSL_RECORD_LAYER rl, record_pqueue queue, unsigned char priority) { DTLS_RLAYER_RECORD_DATA rdata; pitem item; /* Limit the size of the queue to prevent DOS attacks / if (pqueue_size(queue->q) >= 100) return 0; rdata = OPENSSL_malloc(sizeof(rdata)); item = pitem_new(priority, rdata); if (rdata == NULL \|\| item == NULL) { OPENSSL_free(rdata); pitem_free(item); RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } rdata->packet = rl->packet; rdata->packet_length = rl->packet_length; memcpy(&(rdata->rbuf), &rl->rbuf, sizeof(TLS_BUFFER)); memcpy(&(rdata->rrec), &rl->rrec[0], sizeof(TLS_RL_RECORD)); item->data = rdata; rl->packet = NULL; rl->packet_length = 0; memset(&rl->rbuf, 0, sizeof(TLS_BUFFER)); memset(&rl->rrec[0], 0, sizeof(rl->rrec[0])); if (!tls_setup_read_buffer(rl)) { /* RLAYERfatal() already called / OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(rdata); pitem_free(item); return -1; } if (pqueue_insert(queue->q, item) == NULL) { / Must be a duplicate so ignore it / OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(rdata); pitem_free(item); } return 1; } / copy buffered record into OSSL_RECORD_LAYER structure / static int dtls_copy_rlayer_record(OSSL_RECORD_LAYER rl, pitem item) { DTLS_RLAYER_RECORD_DATA rdata; rdata = (DTLS_RLAYER_RECORD_DATA )item->data; ossl_tls_buffer_release(&rl->rbuf); rl->packet = rdata->packet; rl->packet_length = rdata->packet_length; memcpy(&rl->rbuf, &(rdata->rbuf), sizeof(TLS_BUFFER)); memcpy(&rl->rrec[0], &(rdata->rrec), sizeof(TLS_RL_RECORD)); / Set proper sequence number for mac calculation / memcpy(&(rl->sequence[2]), &(rdata->packet[5]), 6); return 1; } static int dtls_retrieve_rlayer_buffered_record(OSSL_RECORD_LAYER rl, record_pqueue queue) { pitem item; item = pqueue_pop(queue->q); if (item) { dtls_copy_rlayer_record(rl, item); OPENSSL_free(item->data); pitem_free(item); return 1; } return 0; } /- Call this to get a new input record. * It will return <= 0 if more data is needed, normally due to an error * or non-blocking IO. * When it finishes, one packet has been decoded and can be found in * ssl->s3.rrec.type - is the type of record * ssl->s3.rrec.data - data * ssl->s3.rrec.length - number of bytes / int dtls_get_more_records(OSSL_RECORD_LAYER rl) { int ssl_major, ssl_minor; int rret; size_t more, n; TLS_RL_RECORD rr; unsigned char p = NULL; DTLS_BITMAP bitmap; unsigned int is_next_epoch; rl->num_recs = 0; rl->curr_rec = 0; rl->num_released = 0; rr = rl->rrec; if (rl->rbuf.buf == NULL) { if (!tls_setup_read_buffer(rl)) { / RLAYERfatal() already called / return OSSL_RECORD_RETURN_FATAL; } } again: / if we're renegotiating, then there may be buffered records / if (dtls_retrieve_rlayer_buffered_record(rl, &rl->processed_rcds)) { rl->num_recs = 1; return OSSL_RECORD_RETURN_SUCCESS; } / get something from the wire / / check if we have the header / if ((rl->rstate != SSL_ST_READ_BODY) \|\| (rl->packet_length < DTLS1_RT_HEADER_LENGTH)) { rret = rl->funcs->read_n(rl, DTLS1_RT_HEADER_LENGTH, TLS_BUFFER_get_len(&rl->rbuf), 0, 1, &n); / read timeout is handled by dtls1_read_bytes / if (rret < OSSL_RECORD_RETURN_SUCCESS) { / RLAYERfatal() already called if appropriate / return rret; / error or non-blocking / } / this packet contained a partial record, dump it / if (rl->packet_length != DTLS1_RT_HEADER_LENGTH) { rl->packet_length = 0; goto again; } rl->rstate = SSL_ST_READ_BODY; p = rl->packet; / Pull apart the header into the DTLS1_RECORD / rr->type = (p++); ssl_major = (p++); ssl_minor = (p++); rr->rec_version = (ssl_major << 8) \| ssl_minor; /* sequence number is 64 bits, with top 2 bytes = epoch / n2s(p, rr->epoch); memcpy(&(rl->sequence[2]), p, 6); p += 6; n2s(p, rr->length); if (rl->msg_callback != NULL) rl->msg_callback(0, rr->rec_version, SSL3_RT_HEADER, rl->packet, DTLS1_RT_HEADER_LENGTH, rl->cbarg); / * Lets check the version. We tolerate alerts that don't have the exact * version number (e.g. because of protocol version errors) / if (!rl->is_first_record && rr->type != SSL3_RT_ALERT) { if (rr->rec_version != rl->version) { / unexpected version, silently discard / rr->length = 0; rl->packet_length = 0; goto again; } } if (ssl_major != (rl->version == DTLS_ANY_VERSION ? DTLS1_VERSION_MAJOR : rl->version >> 8)) { / wrong version, silently discard record / rr->length = 0; rl->packet_length = 0; goto again; } if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) { / record too long, silently discard it / rr->length = 0; rl->packet_length = 0; goto again; } / * If received packet overflows maximum possible fragment length then * silently discard it / if (rr->length > rl->max_frag_len + SSL3_RT_MAX_ENCRYPTED_OVERHEAD) { / record too long, silently discard it / rr->length = 0; rl->packet_length = 0; goto again; } / now rl->rstate == SSL_ST_READ_BODY / } / rl->rstate == SSL_ST_READ_BODY, get and decode the data / if (rr->length > rl->packet_length - DTLS1_RT_HEADER_LENGTH) { / now rl->packet_length == DTLS1_RT_HEADER_LENGTH / more = rr->length; rret = rl->funcs->read_n(rl, more, more, 1, 1, &n); / this packet contained a partial record, dump it / if (rret < OSSL_RECORD_RETURN_SUCCESS \|\| n != more) { if (rl->alert != SSL_AD_NO_ALERT) { / read_n() called RLAYERfatal() / return OSSL_RECORD_RETURN_FATAL; } rr->length = 0; rl->packet_length = 0; goto again; } / * now n == rr->length, * and rl->packet_length == DTLS1_RT_HEADER_LENGTH + rr->length / } / set state for later operations / rl->rstate = SSL_ST_READ_HEADER; / match epochs. NULL means the packet is dropped on the floor / bitmap = dtls_get_bitmap(rl, rr, &is_next_epoch); if (bitmap == NULL) { rr->length = 0; rl->packet_length = 0; / dump this record / goto again; / get another record / } #ifndef OPENSSL_NO_SCTP / Only do replay check if no SCTP bio / if (!BIO_dgram_is_sctp(rl->bio)) { #endif / Check whether this is a repeat, or aged record. / if (!dtls_record_replay_check(rl, bitmap)) { rr->length = 0; rl->packet_length = 0; / dump this record / goto again; / get another record / } #ifndef OPENSSL_NO_SCTP } #endif / just read a 0 length packet / if (rr->length == 0) goto again; / * If this record is from the next epoch (either HM or ALERT), and a * handshake is currently in progress, buffer it since it cannot be * processed at this time. / if (is_next_epoch) { if (rl->in_init) { if (dtls_rlayer_buffer_record(rl, &(rl->unprocessed_rcds), rr->seq_num) < 0) { / RLAYERfatal() already called / return OSSL_RECORD_RETURN_FATAL; } } rr->length = 0; rl->packet_length = 0; goto again; } if (!dtls_process_record(rl, bitmap)) { if (rl->alert != SSL_AD_NO_ALERT) { / dtls_process_record() called RLAYERfatal / return OSSL_RECORD_RETURN_FATAL; } rr->length = 0; rl->packet_length = 0; / dump this record / goto again; / get another record / } if (rl->funcs->post_process_record && !rl->funcs->post_process_record(rl, rr)) { / RLAYERfatal already called / return OSSL_RECORD_RETURN_FATAL; } rl->num_recs = 1; return OSSL_RECORD_RETURN_SUCCESS; } static int dtls_free(OSSL_RECORD_LAYER rl) { TLS_BUFFER rbuf; size_t left, written; pitem item; DTLS_RLAYER_RECORD_DATA rdata; int ret = 1; rbuf = &rl->rbuf; left = rbuf->left; if (left > 0) { / * This record layer is closing but we still have data left in our * buffer. It must be destined for the next epoch - so push it there. / ret = BIO_write_ex(rl->next, rbuf->buf + rbuf->offset, left, &written); rbuf->left = 0; } if (rl->unprocessed_rcds.q != NULL) { while ((item = pqueue_pop(rl->unprocessed_rcds.q)) != NULL) { rdata = (DTLS_RLAYER_RECORD_DATA )item->data; /* Push to the next record layer / ret &= BIO_write_ex(rl->next, rdata->packet, rdata->packet_length, &written); OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(item->data); pitem_free(item); } pqueue_free(rl->unprocessed_rcds.q); } if (rl->processed_rcds.q != NULL) { while ((item = pqueue_pop(rl->processed_rcds.q)) != NULL) { rdata = (DTLS_RLAYER_RECORD_DATA )item->data; OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(item->data); pitem_free(item); } pqueue_free(rl->processed_rcds.q); } return tls_free(rl) && ret; } static int dtls_new_record_layer(OSSL_LIB_CTX libctx, const char propq, int vers, int role, int direction, int level, uint16_t epoch, unsigned char secret, size_t secretlen, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp, const EVP_MD kdfdigest, BIO prev, BIO transport, BIO next, BIO_ADDR local, BIO_ADDR peer, const OSSL_PARAM settings, const OSSL_PARAM options, const OSSL_DISPATCH fns, void cbarg, void rlarg, OSSL_RECORD_LAYER *retrl) { int ret; ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp, prev, transport, next, local, peer, settings, options, fns, cbarg, retrl); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; (retrl)->unprocessed_rcds.q = pqueue_new(); (retrl)->processed_rcds.q = pqueue_new(); if ((retrl)->unprocessed_rcds.q == NULL \|\| (retrl)->processed_rcds.q == NULL) { dtls_free(retrl); retrl = NULL; ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); return OSSL_RECORD_RETURN_FATAL; } (retrl)->unprocessed_rcds.epoch = epoch + 1; (retrl)->processed_rcds.epoch = epoch; (retrl)->isdtls = 1; (retrl)->epoch = epoch; (retrl)->in_init = 1; switch (vers) { case DTLS_ANY_VERSION: (retrl)->funcs = &dtls_any_funcs; break; case DTLS1_2_VERSION: case DTLS1_VERSION: case DTLS1_BAD_VER: (retrl)->funcs = &dtls_1_funcs; break; default: /* Should not happen / ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); ret = OSSL_RECORD_RETURN_FATAL; goto err; } ret = (retrl)->funcs->set_crypto_state(retrl, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp); err: if (ret != OSSL_RECORD_RETURN_SUCCESS) { dtls_free(retrl); retrl = NULL; } return ret; } int dtls_prepare_record_header(OSSL_RECORD_LAYER rl, WPACKET thispkt, OSSL_RECORD_TEMPLATE templ, uint8_t rectype, unsigned char *recdata) { size_t maxcomplen; recdata = NULL; maxcomplen = templ->buflen; if (rl->compctx != NULL) maxcomplen += SSL3_RT_MAX_COMPRESSED_OVERHEAD; if (!WPACKET_put_bytes_u8(thispkt, rectype) \|\| !WPACKET_put_bytes_u16(thispkt, templ->version) \|\| !WPACKET_put_bytes_u16(thispkt, rl->epoch) \|\| !WPACKET_memcpy(thispkt, &(rl->sequence[2]), 6) \|\| !WPACKET_start_sub_packet_u16(thispkt) \|\| (rl->eivlen > 0 && !WPACKET_allocate_bytes(thispkt, rl->eivlen, NULL)) \|\| (maxcomplen > 0 && !WPACKET_reserve_bytes(thispkt, maxcomplen, recdata))) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int dtls_post_encryption_processing(OSSL_RECORD_LAYER rl, size_t mac_size, OSSL_RECORD_TEMPLATE thistempl, WPACKET thispkt, TLS_RL_RECORD thiswr) { if (!tls_post_encryption_processing_default(rl, mac_size, thistempl, thispkt, thiswr)) { /* RLAYERfatal() already called / return 0; } return tls_increment_sequence_ctr(rl); } static size_t dtls_get_max_record_overhead(OSSL_RECORD_LAYER rl) { size_t blocksize = 0; if (rl->enc_ctx != NULL && (EVP_CIPHER_CTX_get_mode(rl->enc_ctx) == EVP_CIPH_CBC_MODE)) blocksize = EVP_CIPHER_CTX_get_block_size(rl->enc_ctx); /* * If we have a cipher in place then the tag is mandatory. If the cipher is * CBC mode then an explicit IV is also mandatory. If we know the digest, * then we check it is consistent with the taglen. In the case of stitched * ciphers or AEAD ciphers we don't now the digest (or there isn't one) so * we just trust that the taglen is correct. / assert(rl->enc_ctx == NULL \|\| ((blocksize == 0 \|\| rl->eivlen > 0) && rl->taglen > 0)); assert(rl->md == NULL \|\| (int)rl->taglen == EVP_MD_size(rl->md)); / * Record overhead consists of the record header, the explicit IV, any * expansion due to cbc padding, and the mac/tag len. There could be * further expansion due to compression - but we don't know what this will * be without knowing the length of the data. However when this function is * called we don't know what the length will be yet - so this is a catch-22. * We could use SSL_3_RT_MAX_COMPRESSED_OVERHEAD which is an upper limit * for the maximum record size. But this value is larger than our fallback * MTU size - so isn't very helpful. We just ignore potential expansion * due to compression. */ return DTLS1_RT_HEADER_LENGTH + rl->eivlen + blocksize + rl->taglen; } const OSSL_RECORD_METHOD ossl_dtls_record_method = { dtls_new_record_layer, dtls_free, tls_unprocessed_read_pending, tls_processed_read_pending, tls_app_data_pending, tls_get_max_records, tls_write_records, tls_retry_write_records, tls_read_record, tls_release_record, tls_get_alert_code, tls_set1_bio, tls_set_protocol_version, NULL, tls_set_first_handshake, tls_set_max_pipelines, dtls_set_in_init, tls_get_state, tls_set_options, tls_get_compression, tls_set_max_frag_len, dtls_get_max_record_overhead, tls_increment_sequence_ctr, tls_alloc_buffers, tls_free_buffers };
./openssl/ssl/quic/quic_rx_depack.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/packet_quic.h" #include "internal/nelem.h" #include "internal/quic_wire.h" #include "internal/quic_record_rx.h" #include "internal/quic_ackm.h" #include "internal/quic_rx_depack.h" #include "internal/quic_error.h" #include "internal/quic_fc.h" #include "internal/quic_channel.h" #include "internal/sockets.h" #include "quic_local.h" #include "quic_channel_local.h" #include "../ssl_local.h" / * Helper functions to process different frame types. * * Typically, those that are ACK eliciting will take an OSSL_ACKM_RX_PKT * pointer argument, the few that aren't ACK eliciting will not. This makes * them a verifiable pattern against tables where this is specified. / static int depack_do_implicit_stream_create(QUIC_CHANNEL ch, uint64_t stream_id, uint64_t frame_type, QUIC_STREAM *result); static int depack_do_frame_padding(PACKET pkt) { /* We ignore this frame / ossl_quic_wire_decode_padding(pkt); return 1; } static int depack_do_frame_ping(PACKET pkt, QUIC_CHANNEL ch, uint32_t enc_level, OSSL_ACKM_RX_PKT ackm_data) { /* We ignore this frame, apart from eliciting an ACK / if (!ossl_quic_wire_decode_frame_ping(pkt)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_PING, "decode error"); return 0; } ossl_quic_tx_packetiser_schedule_ack_eliciting(ch->txp, enc_level); return 1; } static int depack_do_frame_ack(PACKET pkt, QUIC_CHANNEL ch, int packet_space, OSSL_TIME received, uint64_t frame_type, OSSL_QRX_PKT qpacket) { OSSL_QUIC_FRAME_ACK ack; OSSL_QUIC_ACK_RANGE p; uint64_t total_ranges = 0; uint32_t ack_delay_exp = ch->rx_ack_delay_exp; if (!ossl_quic_wire_peek_frame_ack_num_ranges(pkt, &total_ranges) / In case sizeof(uint64_t) > sizeof(size_t) / \|\| total_ranges > SIZE_MAX / sizeof(OSSL_QUIC_ACK_RANGE)) goto malformed; if (ch->num_ack_range_scratch < (size_t)total_ranges) { if ((p = OPENSSL_realloc(ch->ack_range_scratch, sizeof(OSSL_QUIC_ACK_RANGE) (size_t)total_ranges)) == NULL) goto malformed; ch->ack_range_scratch = p; ch->num_ack_range_scratch = (size_t)total_ranges; } ack.ack_ranges = ch->ack_range_scratch; ack.num_ack_ranges = (size_t)total_ranges; if (!ossl_quic_wire_decode_frame_ack(pkt, ack_delay_exp, &ack, NULL)) goto malformed; if (qpacket->hdr->type == QUIC_PKT_TYPE_1RTT && (qpacket->key_epoch < ossl_qrx_get_key_epoch(ch->qrx) \|\| ch->rxku_expected) && ack.ack_ranges[0].end >= ch->txku_pn) { /* * RFC 9001 s. 6.2: An endpoint that receives an acknowledgment that is * carried in a packet protected with old keys where any acknowledged * packet was protected with newer keys MAY treat that as a connection * error of type KEY_UPDATE_ERROR. * * Two cases to handle here: * * - We did spontaneous TXKU, the peer has responded in kind and we * have detected RXKU; !ch->rxku_expected, but then it sent a packet * with old keys acknowledging a packet in the new key epoch. * * This also covers the case where we got RXKU and triggered * solicited TXKU, and then for some reason the peer sent an ACK of * a PN in our new TX key epoch with old keys. * * - We did spontaneous TXKU; ch->txku_pn is the starting PN of our * new TX key epoch; the peer has not initiated a solicited TXKU in * response (so we have not detected RXKU); in this case the RX key * epoch has not incremented and ch->rxku_expected is still 1. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_KEY_UPDATE_ERROR, frame_type, "acked packet which initiated a " "key update without a " "corresponding key update"); return 0; } if (!ossl_ackm_on_rx_ack_frame(ch->ackm, &ack, packet_space, received)) goto malformed; ++ch->diag_num_rx_ack; return 1; malformed: ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } static int depack_do_frame_reset_stream(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { OSSL_QUIC_FRAME_RESET_STREAM frame_data; QUIC_STREAM stream = NULL; uint64_t fce; if (!ossl_quic_wire_decode_frame_reset_stream(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, "decode error"); return 0; } if (!depack_do_implicit_stream_create(ch, frame_data.stream_id, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, &stream)) return 0; / error already raised for us / if (stream == NULL) return 1; / old deleted stream, not a protocol violation, ignore / if (!ossl_quic_stream_has_recv(stream)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, "RESET_STREAM frame for " "TX only stream"); return 0; } / * The final size field of the RESET_STREAM frame must be used to determine * how much flow control credit the aborted stream was considered to have * consumed. * * We also need to ensure that if we already have a final size for the * stream, the RESET_STREAM frame's Final Size field matches this; we SHOULD * terminate the connection otherwise (RFC 9000 s. 4.5). The RXFC takes care * of this for us. / if (!ossl_quic_rxfc_on_rx_stream_frame(&stream->rxfc, frame_data.final_size, /is_fin=/1)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, "internal error (flow control)"); return 0; } / Has a flow control error occurred? / fce = ossl_quic_rxfc_get_error(&stream->rxfc, 0); if (fce != QUIC_ERR_NO_ERROR) { ossl_quic_channel_raise_protocol_error(ch, fce, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, "flow control violation"); return 0; } / * Depending on the receive part state this is handled either as a reset * transition or a no-op (e.g. if a reset has already been received before, * or the application already retired a FIN). Best effort - there are no * protocol error conditions we need to check for here. / ossl_quic_stream_map_notify_reset_recv_part(&ch->qsm, stream, frame_data.app_error_code, frame_data.final_size); ossl_quic_stream_map_update_state(&ch->qsm, stream); return 1; } static int depack_do_frame_stop_sending(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { OSSL_QUIC_FRAME_STOP_SENDING frame_data; QUIC_STREAM stream = NULL; if (!ossl_quic_wire_decode_frame_stop_sending(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, "decode error"); return 0; } if (!depack_do_implicit_stream_create(ch, frame_data.stream_id, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, &stream)) return 0; / error already raised for us / if (stream == NULL) return 1; / old deleted stream, not a protocol violation, ignore / if (!ossl_quic_stream_has_send(stream)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, "STOP_SENDING frame for " "RX only stream"); return 0; } stream->peer_stop_sending = 1; stream->peer_stop_sending_aec = frame_data.app_error_code; / * RFC 9000 s. 3.5: Receiving a STOP_SENDING frame means we must respond in * turn with a RESET_STREAM frame for the same part of the stream. The other * part is unaffected. / ossl_quic_stream_map_reset_stream_send_part(&ch->qsm, stream, frame_data.app_error_code); return 1; } static int depack_do_frame_crypto(PACKET pkt, QUIC_CHANNEL ch, OSSL_QRX_PKT parent_pkt, OSSL_ACKM_RX_PKT ackm_data, uint64_t datalen) { OSSL_QUIC_FRAME_CRYPTO f; QUIC_RSTREAM rstream; QUIC_RXFC rxfc; datalen = 0; if (!ossl_quic_wire_decode_frame_crypto(pkt, 0, &f)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_CRYPTO, "decode error"); return 0; } if (f.len == 0) return 1; / nothing to do / rstream = ch->crypto_recv[ackm_data->pkt_space]; if (!ossl_assert(rstream != NULL)) / * This should not happen; we should only have a NULL stream here if * the EL has been discarded, and if the EL has been discarded we * shouldn't be here. / return 0; rxfc = &ch->crypto_rxfc[ackm_data->pkt_space]; if (!ossl_quic_rxfc_on_rx_stream_frame(rxfc, f.offset + f.len, /is_fin=/0)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_CRYPTO, "internal error (crypto RXFC)"); return 0; } if (ossl_quic_rxfc_get_error(rxfc, 0) != QUIC_ERR_NO_ERROR) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CRYPTO_BUFFER_EXCEEDED, OSSL_QUIC_FRAME_TYPE_CRYPTO, "exceeded maximum crypto buffer"); return 0; } if (!ossl_quic_rstream_queue_data(rstream, parent_pkt, f.offset, f.data, f.len, 0)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_CRYPTO, "internal error (rstream queue)"); return 0; } ch->did_crypto_frame = 1; datalen = f.len; return 1; } static int depack_do_frame_new_token(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { const uint8_t token; size_t token_len; if (!ossl_quic_wire_decode_frame_new_token(pkt, &token, &token_len)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, "decode error"); return 0; } if (token_len == 0) { /* * RFC 9000 s. 19.7: "A client MUST treat receipt of a NEW_TOKEN frame * with an empty Token field as a connection error of type * FRAME_ENCODING_ERROR." / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, "zero-length NEW_TOKEN"); return 0; } / TODO(QUIC FUTURE): ADD CODE to send \|token\| to the session manager / return 1; } / * Returns 1 if no protocol violation has occurred. In this case result will be non-NULL unless this is an old deleted stream and we should ignore the frame * causing this function to be called. Returns 0 on protocol violation. / static int depack_do_implicit_stream_create(QUIC_CHANNEL ch, uint64_t stream_id, uint64_t frame_type, QUIC_STREAM *result) { QUIC_STREAM stream; uint64_t peer_role, stream_ordinal; uint64_t p_next_ordinal_local, p_next_ordinal_remote; QUIC_RXFC max_streams_fc; int is_uni, is_remote_init; stream = ossl_quic_stream_map_get_by_id(&ch->qsm, stream_id); if (stream != NULL) { result = stream; return 1; } /* * If we do not yet have a stream with the given ID, there are three * possibilities: * * (a) The stream ID is for a remotely-created stream and the peer * is creating a stream. * * (b) The stream ID is for a locally-created stream which has * previously been deleted. * * (c) The stream ID is for a locally-created stream which does * not exist yet. This is a protocol violation and we must * terminate the connection in this case. * * We distinguish between (b) and (c) using the stream ID allocator * variable. Since stream ordinals are allocated monotonically, we * simply determine if the stream ordinal is in the future. / peer_role = ch->is_server ? QUIC_STREAM_INITIATOR_CLIENT : QUIC_STREAM_INITIATOR_SERVER; is_remote_init = ((stream_id & QUIC_STREAM_INITIATOR_MASK) == peer_role); is_uni = ((stream_id & QUIC_STREAM_DIR_MASK) == QUIC_STREAM_DIR_UNI); stream_ordinal = stream_id >> 2; if (is_remote_init) { / * Peer-created stream which does not yet exist. Create it. QUIC stream * ordinals within a given stream type MUST be used in sequence and * receiving a STREAM frame for ordinal n must implicitly create streams * with ordinals [0, n) within that stream type even if no explicit * STREAM frames are received for those ordinals. / p_next_ordinal_remote = is_uni ? &ch->next_remote_stream_ordinal_uni : &ch->next_remote_stream_ordinal_bidi; / Check this isn't violating stream count flow control. / max_streams_fc = is_uni ? &ch->max_streams_uni_rxfc : &ch->max_streams_bidi_rxfc; if (!ossl_quic_rxfc_on_rx_stream_frame(max_streams_fc, stream_ordinal + 1, /is_fin=/0)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (stream count RXFC)"); return 0; } if (ossl_quic_rxfc_get_error(max_streams_fc, 0) != QUIC_ERR_NO_ERROR) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_LIMIT_ERROR, frame_type, "exceeded maximum allowed streams"); return 0; } / * Create the named stream and any streams coming before it yet to be * created. / while (p_next_ordinal_remote <= stream_ordinal) { uint64_t cur_stream_id = (p_next_ordinal_remote << 2) \| (stream_id & (QUIC_STREAM_DIR_MASK \| QUIC_STREAM_INITIATOR_MASK)); stream = ossl_quic_channel_new_stream_remote(ch, cur_stream_id); if (stream == NULL) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (stream allocation)"); return 0; } ++p_next_ordinal_remote; } result = stream; } else { / Locally-created stream which does not yet exist. / p_next_ordinal_local = is_uni ? &ch->next_local_stream_ordinal_uni : &ch->next_local_stream_ordinal_bidi; if (stream_ordinal >= p_next_ordinal_local) { /* * We never created this stream yet, this is a protocol * violation. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, frame_type, "STREAM frame for nonexistent " "stream"); return 0; } / * Otherwise this is for an old locally-initiated stream which we * have subsequently deleted. Ignore the data; it may simply be a * retransmission. We already take care of notifying the peer of the * termination of the stream during the stream deletion lifecycle. / result = NULL; } return 1; } static int depack_do_frame_stream(PACKET pkt, QUIC_CHANNEL ch, OSSL_QRX_PKT parent_pkt, OSSL_ACKM_RX_PKT ackm_data, uint64_t frame_type, uint64_t datalen) { OSSL_QUIC_FRAME_STREAM frame_data; QUIC_STREAM stream; uint64_t fce; size_t rs_avail; int rs_fin = 0; datalen = 0; if (!ossl_quic_wire_decode_frame_stream(pkt, 0, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } if (!depack_do_implicit_stream_create(ch, frame_data.stream_id, frame_type, &stream)) return 0; / protocol error raised by above call / if (stream == NULL) / * Data for old stream which is not a protocol violation but should be * ignored, so stop here. / return 1; if (!ossl_quic_stream_has_recv(stream)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, frame_type, "STREAM frame for TX only " "stream"); return 0; } / Notify stream flow controller. / if (!ossl_quic_rxfc_on_rx_stream_frame(&stream->rxfc, frame_data.offset + frame_data.len, frame_data.is_fin)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (flow control)"); return 0; } / Has a flow control error occurred? / fce = ossl_quic_rxfc_get_error(&stream->rxfc, 0); if (fce != QUIC_ERR_NO_ERROR) { ossl_quic_channel_raise_protocol_error(ch, fce, frame_type, "flow control violation"); return 0; } switch (stream->recv_state) { case QUIC_RSTREAM_STATE_RECV: case QUIC_RSTREAM_STATE_SIZE_KNOWN: / * It only makes sense to process incoming STREAM frames in these * states. / break; case QUIC_RSTREAM_STATE_DATA_RECVD: case QUIC_RSTREAM_STATE_DATA_READ: case QUIC_RSTREAM_STATE_RESET_RECVD: case QUIC_RSTREAM_STATE_RESET_READ: default: / * We have no use for STREAM frames once the receive part reaches any of * these states, so just ignore. / return 1; } / If we are in RECV, auto-transition to SIZE_KNOWN on FIN. / if (frame_data.is_fin && !ossl_quic_stream_recv_get_final_size(stream, NULL)) { / State was already checked above, so can't fail. / ossl_quic_stream_map_notify_size_known_recv_part(&ch->qsm, stream, frame_data.offset + frame_data.len); } / * If we requested STOP_SENDING do not bother buffering the data. Note that * this must happen after RXFC checks above as even if we sent STOP_SENDING * we must still enforce correct flow control (RFC 9000 s. 3.5). / if (stream->stop_sending) return 1; / not an error - packet reordering, etc. / / * The receive stream buffer may or may not choose to consume the data * without copying by reffing the OSSL_QRX_PKT. In this case * ossl_qrx_pkt_release() will be eventually called when the data is no * longer needed. * * It is OK for the peer to send us a zero-length non-FIN STREAM frame, * which is a no-op, aside from the fact that it ensures the stream exists. * In this case we have nothing to report to the receive buffer. / if ((frame_data.len > 0 \|\| frame_data.is_fin) && !ossl_quic_rstream_queue_data(stream->rstream, parent_pkt, frame_data.offset, frame_data.data, frame_data.len, frame_data.is_fin)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (rstream queue)"); return 0; } / * rs_fin will be 1 only if we can read all data up to and including the FIN * without any gaps before it; this implies we have received all data. Avoid * calling ossl_quic_rstream_available() where it is not necessary as it is * more expensive. / if (stream->recv_state == QUIC_RSTREAM_STATE_SIZE_KNOWN && !ossl_quic_rstream_available(stream->rstream, &rs_avail, &rs_fin)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (rstream available)"); return 0; } if (rs_fin) ossl_quic_stream_map_notify_totally_received(&ch->qsm, stream); datalen = frame_data.len; return 1; } static void update_streams(QUIC_STREAM s, void arg) { QUIC_CHANNEL ch = arg; ossl_quic_stream_map_update_state(&ch->qsm, s); } static void update_streams_bidi(QUIC_STREAM s, void arg) { QUIC_CHANNEL ch = arg; if (!ossl_quic_stream_is_bidi(s)) return; ossl_quic_stream_map_update_state(&ch->qsm, s); } static void update_streams_uni(QUIC_STREAM s, void arg) { QUIC_CHANNEL ch = arg; if (ossl_quic_stream_is_bidi(s)) return; ossl_quic_stream_map_update_state(&ch->qsm, s); } static int depack_do_frame_max_data(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { uint64_t max_data = 0; if (!ossl_quic_wire_decode_frame_max_data(pkt, &max_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_MAX_DATA, "decode error"); return 0; } ossl_quic_txfc_bump_cwm(&ch->conn_txfc, max_data); ossl_quic_stream_map_visit(&ch->qsm, update_streams, ch); return 1; } static int depack_do_frame_max_stream_data(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { uint64_t stream_id = 0; uint64_t max_stream_data = 0; QUIC_STREAM stream; if (!ossl_quic_wire_decode_frame_max_stream_data(pkt, &stream_id, &max_stream_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, "decode error"); return 0; } if (!depack_do_implicit_stream_create(ch, stream_id, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, &stream)) return 0; /* error already raised for us / if (stream == NULL) return 1; / old deleted stream, not a protocol violation, ignore / if (!ossl_quic_stream_has_send(stream)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, "MAX_STREAM_DATA for TX only " "stream"); return 0; } ossl_quic_txfc_bump_cwm(&stream->txfc, max_stream_data); ossl_quic_stream_map_update_state(&ch->qsm, stream); return 1; } static int depack_do_frame_max_streams(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data, uint64_t frame_type) { uint64_t max_streams = 0; if (!ossl_quic_wire_decode_frame_max_streams(pkt, &max_streams)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } if (max_streams > (((uint64_t)1) << 60)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "invalid max streams value"); return 0; } switch (frame_type) { case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI: if (max_streams > ch->max_local_streams_bidi) ch->max_local_streams_bidi = max_streams; /* Some streams may now be able to send. / ossl_quic_stream_map_visit(&ch->qsm, update_streams_bidi, ch); break; case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI: if (max_streams > ch->max_local_streams_uni) ch->max_local_streams_uni = max_streams; / Some streams may now be able to send. / ossl_quic_stream_map_visit(&ch->qsm, update_streams_uni, ch); break; default: ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } return 1; } static int depack_do_frame_data_blocked(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { uint64_t max_data = 0; if (!ossl_quic_wire_decode_frame_data_blocked(pkt, &max_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED, "decode error"); return 0; } /* No-op - informative/debugging frame. / return 1; } static int depack_do_frame_stream_data_blocked(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { uint64_t stream_id = 0; uint64_t max_data = 0; QUIC_STREAM stream; if (!ossl_quic_wire_decode_frame_stream_data_blocked(pkt, &stream_id, &max_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, "decode error"); return 0; } / * This is an informative/debugging frame, so we don't have to do anything, * but it does trigger stream creation. / if (!depack_do_implicit_stream_create(ch, stream_id, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, &stream)) return 0; / error already raised for us / if (stream == NULL) return 1; / old deleted stream, not a protocol violation, ignore / if (!ossl_quic_stream_has_recv(stream)) { / * RFC 9000 s. 19.14: "An endpoint that receives a STREAM_DATA_BLOCKED * frame for a send-only stream MUST terminate the connection with error * STREAM_STATE_ERROR." / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, "STREAM_DATA_BLOCKED frame for " "TX only stream"); return 0; } / No-op - informative/debugging frame. / return 1; } static int depack_do_frame_streams_blocked(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data, uint64_t frame_type) { uint64_t max_data = 0; if (!ossl_quic_wire_decode_frame_streams_blocked(pkt, &max_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } if (max_data > (((uint64_t)1) << 60)) { /* * RFC 9000 s. 19.14: "This value cannot exceed 2*60, as it is not possible to encode stream IDs larger than 2*62 - 1. Receipt of a frame that encodes a larger stream ID MUST be treated as a connection * error of type STREAM_LIMIT_ERROR or FRAME_ENCODING_ERROR." / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_LIMIT_ERROR, frame_type, "invalid stream count limit"); return 0; } / No-op - informative/debugging frame. / return 1; } static int depack_do_frame_new_conn_id(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { OSSL_QUIC_FRAME_NEW_CONN_ID frame_data; if (!ossl_quic_wire_decode_frame_new_conn_id(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "decode error"); return 0; } ossl_quic_channel_on_new_conn_id(ch, &frame_data); return 1; } static int depack_do_frame_retire_conn_id(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { uint64_t seq_num; if (!ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, "decode error"); return 0; } / * RFC 9000 s. 19.16: "An endpoint cannot send this frame if it was provided * with a zero-length connection ID by its peer. An endpoint that provides a * zero-length connection ID MUST treat receipt of a RETIRE_CONNECTION_ID * frame as a connection error of type PROTOCOL_VIOLATION." * * Since we always use a zero-length SCID as a client, there is no case * where it is valid for a server to send this. Our server support is * currently non-conformant and for internal testing use; simply handle it * as a no-op in this case. * * TODO(QUIC SERVER): Revise and implement correctly for server support. / if (!ch->is_server) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, "conn has zero-length CID"); return 0; } return 1; } static void free_path_response(unsigned char buf, size_t buf_len, void arg) { OPENSSL_free(buf); } static int depack_do_frame_path_challenge(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { uint64_t frame_data = 0; unsigned char encoded = NULL; size_t encoded_len; WPACKET wpkt; if (!ossl_quic_wire_decode_frame_path_challenge(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE, "decode error"); return 0; } / * RFC 9000 s. 8.2.2: On receiving a PATH_CHALLENGE frame, an endpoint MUST * respond by echoing the data contained in the PATH_CHALLENGE frame in a * PATH_RESPONSE frame. * * TODO(QUIC FUTURE): We should try to avoid allocation here in the future. / encoded_len = sizeof(uint64_t) + 1; if ((encoded = OPENSSL_malloc(encoded_len)) == NULL) goto err; if (!WPACKET_init_static_len(&wpkt, encoded, encoded_len, 0)) goto err; if (!ossl_quic_wire_encode_frame_path_response(&wpkt, frame_data)) { WPACKET_cleanup(&wpkt); goto err; } WPACKET_finish(&wpkt); if (!ossl_quic_cfq_add_frame(ch->cfq, 0, QUIC_PN_SPACE_APP, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE, QUIC_CFQ_ITEM_FLAG_UNRELIABLE, encoded, encoded_len, free_path_response, NULL)) goto err; return 1; err: OPENSSL_free(encoded); ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE, "internal error"); return 0; } static int depack_do_frame_path_response(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { uint64_t frame_data = 0; if (!ossl_quic_wire_decode_frame_path_response(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE, "decode error"); return 0; } /* TODO(QUIC MULTIPATH): ADD CODE to send \|frame_data\| to the ch manager / return 1; } static int depack_do_frame_conn_close(PACKET pkt, QUIC_CHANNEL ch, uint64_t frame_type) { OSSL_QUIC_FRAME_CONN_CLOSE frame_data; if (!ossl_quic_wire_decode_frame_conn_close(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } ossl_quic_channel_on_remote_conn_close(ch, &frame_data); return 1; } static int depack_do_frame_handshake_done(PACKET pkt, QUIC_CHANNEL ch, OSSL_ACKM_RX_PKT ackm_data) { if (!ossl_quic_wire_decode_frame_handshake_done(pkt)) { /* This can fail only with an internal error. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, "internal error (decode frame handshake done)"); return 0; } ossl_quic_channel_on_handshake_confirmed(ch); return 1; } / Main frame processor / static int depack_process_frames(QUIC_CHANNEL ch, PACKET pkt, OSSL_QRX_PKT parent_pkt, uint32_t enc_level, OSSL_TIME received, OSSL_ACKM_RX_PKT ackm_data) { uint32_t pkt_type = parent_pkt->hdr->type; uint32_t packet_space = ossl_quic_enc_level_to_pn_space(enc_level); if (PACKET_remaining(pkt) == 0) { / * RFC 9000 s. 12.4: An endpoint MUST treat receipt of a packet * containing no frames as a connection error of type * PROTOCOL_VIOLATION. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "empty packet payload"); return 0; } while (PACKET_remaining(pkt) > 0) { int was_minimal; uint64_t frame_type; const unsigned char sof = NULL; uint64_t datalen = 0; if (ch->msg_callback != NULL) sof = PACKET_data(pkt); if (!ossl_quic_wire_peek_frame_header(pkt, &frame_type, &was_minimal)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "malformed frame header"); return 0; } if (!was_minimal) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "non-minimal frame type encoding"); return 0; } /* * There are only a few frame types which are not ACK-eliciting. Handle * these centrally to make error handling cases more resilient, as we * should tell the ACKM about an ACK-eliciting frame even if it was not * successfully handled. / switch (frame_type) { case OSSL_QUIC_FRAME_TYPE_PADDING: case OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN: case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN: case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT: case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP: break; default: ackm_data->is_ack_eliciting = 1; break; } switch (frame_type) { case OSSL_QUIC_FRAME_TYPE_PING: / Allowed in all packet types / if (!depack_do_frame_ping(pkt, ch, enc_level, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_PADDING: / Allowed in all packet types / if (!depack_do_frame_padding(pkt)) return 0; break; case OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN: case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN: / ACK frames are valid everywhere except in 0RTT packets / if (pkt_type == QUIC_PKT_TYPE_0RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "ACK not valid in 0-RTT"); return 0; } if (!depack_do_frame_ack(pkt, ch, packet_space, received, frame_type, parent_pkt)) return 0; break; case OSSL_QUIC_FRAME_TYPE_RESET_STREAM: / RESET_STREAM frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "RESET_STREAM not valid in " "INITIAL/HANDSHAKE"); return 0; } if (!depack_do_frame_reset_stream(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_STOP_SENDING: / STOP_SENDING frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "STOP_SENDING not valid in " "INITIAL/HANDSHAKE"); return 0; } if (!depack_do_frame_stop_sending(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_CRYPTO: / CRYPTO frames are valid everywhere except in 0RTT packets / if (pkt_type == QUIC_PKT_TYPE_0RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "CRYPTO frame not valid in 0-RTT"); return 0; } if (!depack_do_frame_crypto(pkt, ch, parent_pkt, ackm_data, &datalen)) return 0; break; case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN: / NEW_TOKEN frames are valid in 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "NEW_TOKEN valid only in 1-RTT"); return 0; } if (!depack_do_frame_new_token(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_STREAM: case OSSL_QUIC_FRAME_TYPE_STREAM_FIN: case OSSL_QUIC_FRAME_TYPE_STREAM_LEN: case OSSL_QUIC_FRAME_TYPE_STREAM_LEN_FIN: case OSSL_QUIC_FRAME_TYPE_STREAM_OFF: case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_FIN: case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN: case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN_FIN: / STREAM frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "STREAM valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_stream(pkt, ch, parent_pkt, ackm_data, frame_type, &datalen)) return 0; break; case OSSL_QUIC_FRAME_TYPE_MAX_DATA: / MAX_DATA frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "MAX_DATA valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_max_data(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA: / MAX_STREAM_DATA frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "MAX_STREAM_DATA valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_max_stream_data(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI: case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI: / MAX_STREAMS frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "MAX_STREAMS valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_max_streams(pkt, ch, ackm_data, frame_type)) return 0; break; case OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED: / DATA_BLOCKED frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "DATA_BLOCKED valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_data_blocked(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED: / STREAM_DATA_BLOCKED frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "STREAM_DATA_BLOCKED valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_stream_data_blocked(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI: case OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI: / STREAMS_BLOCKED frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "STREAMS valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_streams_blocked(pkt, ch, ackm_data, frame_type)) return 0; break; case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID: / NEW_CONN_ID frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "NEW_CONN_ID valid only in 0/1-RTT"); } if (!depack_do_frame_new_conn_id(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID: / RETIRE_CONN_ID frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "RETIRE_CONN_ID valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_retire_conn_id(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE: / PATH_CHALLENGE frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "PATH_CHALLENGE valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_path_challenge(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE: / PATH_RESPONSE frames are valid in 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "PATH_CHALLENGE valid only in 1-RTT"); return 0; } if (!depack_do_frame_path_response(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP: / CONN_CLOSE_APP frames are valid in 0RTT and 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "CONN_CLOSE (APP) valid only in 0/1-RTT"); return 0; } / FALLTHRU / case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT: / CONN_CLOSE_TRANSPORT frames are valid in all packets / if (!depack_do_frame_conn_close(pkt, ch, frame_type)) return 0; break; case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE: / HANDSHAKE_DONE frames are valid in 1RTT packets / if (pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "HANDSHAKE_DONE valid only in 1-RTT"); return 0; } if (!depack_do_frame_handshake_done(pkt, ch, ackm_data)) return 0; break; default: / Unknown frame type / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "Unknown frame type received"); return 0; } if (ch->msg_callback != NULL) { int ctype = SSL3_RT_QUIC_FRAME_FULL; size_t framelen = PACKET_data(pkt) - sof; if (frame_type == OSSL_QUIC_FRAME_TYPE_PADDING) { ctype = SSL3_RT_QUIC_FRAME_PADDING; } else if (OSSL_QUIC_FRAME_TYPE_IS_STREAM(frame_type) \|\| frame_type == OSSL_QUIC_FRAME_TYPE_CRYPTO) { ctype = SSL3_RT_QUIC_FRAME_HEADER; framelen -= (size_t)datalen; } ch->msg_callback(0, OSSL_QUIC1_VERSION, ctype, sof, framelen, ch->msg_callback_ssl, ch->msg_callback_arg); } } return 1; } QUIC_NEEDS_LOCK int ossl_quic_handle_frames(QUIC_CHANNEL ch, OSSL_QRX_PKT qpacket) { PACKET pkt; OSSL_ACKM_RX_PKT ackm_data; uint32_t enc_level; / * ok has three states: * -1 error with ackm_data uninitialized * 0 error with ackm_data initialized * 1 success (ackm_data initialized) / int ok = -1; / Assume the worst / if (ch == NULL) goto end; ch->did_crypto_frame = 0; / Initialize \|ackm_data\| (and reinitialize \|ok\|)/ memset(&ackm_data, 0, sizeof(ackm_data)); / * ASSUMPTION: All packets that aren't special case have a * packet number. / ackm_data.pkt_num = qpacket->pn; ackm_data.time = qpacket->time; enc_level = ossl_quic_pkt_type_to_enc_level(qpacket->hdr->type); if (enc_level >= QUIC_ENC_LEVEL_NUM) / * Retry and Version Negotiation packets should not be passed to this * function. / goto end; ok = 0; / Still assume the worst / ackm_data.pkt_space = ossl_quic_enc_level_to_pn_space(enc_level); / Now that special cases are out of the way, parse frames / if (!PACKET_buf_init(&pkt, qpacket->hdr->data, qpacket->hdr->len) \|\| !depack_process_frames(ch, &pkt, qpacket, enc_level, qpacket->time, &ackm_data)) goto end; ok = 1; end: / * ASSUMPTION: If this function is called at all, \|qpacket\| is * a legitimate packet, even if its contents aren't. * Therefore, we call ossl_ackm_on_rx_packet() unconditionally, as long as * \|ackm_data\| has at least been initialized. */ if (ok >= 0) ossl_ackm_on_rx_packet(ch->ackm, &ackm_data); return ok > 0; }
./openssl/ssl/quic/quic_engine_local.h	/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #ifndef OSSL_QUIC_ENGINE_LOCAL_H # define OSSL_QUIC_ENGINE_LOCAL_H # include "internal/quic_engine.h" # include "internal/quic_reactor.h" # ifndef OPENSSL_NO_QUIC / * QUIC Engine Structure * ===================== * * QUIC engine internals. It is intended that only the QUIC_ENGINE, QUIC_PORT * and QUIC_CHANNEL implementations be allowed to access this structure * directly. * * Other components should not include this header. / DECLARE_LIST_OF(port, QUIC_PORT); struct quic_engine_st { / All objects in a QUIC event domain share the same (libctx, propq). / OSSL_LIB_CTX libctx; const char propq; / * Master synchronisation mutex for the entire QUIC event domain. Used for * thread assisted mode synchronisation. We don't own this; the instantiator * of the engine passes it to us and is responsible for freeing it after * engine destruction. / CRYPTO_MUTEX mutex; /* Callback used to get the current time. / OSSL_TIME (now_cb)(void arg); void now_cb_arg; /* Asynchronous I/O reactor. / QUIC_REACTOR rtor; / List of all child ports. / OSSL_LIST(port) port_list; / Inhibit tick for testing purposes? */ unsigned int inhibit_tick : 1; }; # endif #endif
./openssl/ssl/quic/quic_txpim.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_txpim.h" #include <stdlib.h> typedef struct quic_txpim_pkt_ex_st QUIC_TXPIM_PKT_EX; struct quic_txpim_pkt_ex_st { QUIC_TXPIM_PKT public; QUIC_TXPIM_PKT_EX prev, next; QUIC_TXPIM_CHUNK chunks; size_t num_chunks, alloc_chunks; unsigned int chunks_need_sort : 1; }; typedef struct quic_txpim_pkt_ex_list { QUIC_TXPIM_PKT_EX head, tail; } QUIC_TXPIM_PKT_EX_LIST; struct quic_txpim_st { QUIC_TXPIM_PKT_EX_LIST free_list; size_t in_use; }; #define MAX_ALLOC_CHUNKS 512 QUIC_TXPIM ossl_quic_txpim_new(void) { QUIC_TXPIM txpim = OPENSSL_zalloc(sizeof(txpim)); if (txpim == NULL) return NULL; return txpim; } static void free_list(QUIC_TXPIM_PKT_EX_LIST l) { QUIC_TXPIM_PKT_EX n, nnext; for (n = l->head; n != NULL; n = nnext) { nnext = n->next; OPENSSL_free(n->chunks); OPENSSL_free(n); } l->head = l->tail = NULL; } void ossl_quic_txpim_free(QUIC_TXPIM txpim) { if (txpim == NULL) return; assert(txpim->in_use == 0); free_list(&txpim->free_list); OPENSSL_free(txpim); } static void list_remove(QUIC_TXPIM_PKT_EX_LIST l, QUIC_TXPIM_PKT_EX n) { if (l->head == n) l->head = n->next; if (l->tail == n) l->tail = n->prev; if (n->prev != NULL) n->prev->next = n->next; if (n->next != NULL) n->next->prev = n->prev; n->prev = n->next = NULL; } static void list_insert_tail(QUIC_TXPIM_PKT_EX_LIST l, QUIC_TXPIM_PKT_EX n) { n->prev = l->tail; n->next = NULL; l->tail = n; if (n->prev != NULL) n->prev->next = n; if (l->head == NULL) l->head = n; } static QUIC_TXPIM_PKT_EX txpim_get_free(QUIC_TXPIM txpim) { QUIC_TXPIM_PKT_EX ex = txpim->free_list.head; if (ex != NULL) return ex; ex = OPENSSL_zalloc(sizeof(ex)); if (ex == NULL) return NULL; list_insert_tail(&txpim->free_list, ex); return ex; } static void txpim_clear(QUIC_TXPIM_PKT_EX ex) { memset(&ex->public.ackm_pkt, 0, sizeof(ex->public.ackm_pkt)); ossl_quic_txpim_pkt_clear_chunks(&ex->public); ex->public.retx_head = NULL; ex->public.fifd = NULL; ex->public.had_handshake_done_frame = 0; ex->public.had_max_data_frame = 0; ex->public.had_max_streams_bidi_frame = 0; ex->public.had_max_streams_uni_frame = 0; ex->public.had_ack_frame = 0; ex->public.had_conn_close = 0; } QUIC_TXPIM_PKT ossl_quic_txpim_pkt_alloc(QUIC_TXPIM txpim) { QUIC_TXPIM_PKT_EX ex = txpim_get_free(txpim); if (ex == NULL) return NULL; txpim_clear(ex); list_remove(&txpim->free_list, ex); ++txpim->in_use; return &ex->public; } void ossl_quic_txpim_pkt_release(QUIC_TXPIM txpim, QUIC_TXPIM_PKT fpkt) { QUIC_TXPIM_PKT_EX ex = (QUIC_TXPIM_PKT_EX )fpkt; assert(txpim->in_use > 0); --txpim->in_use; list_insert_tail(&txpim->free_list, ex); } void ossl_quic_txpim_pkt_add_cfq_item(QUIC_TXPIM_PKT fpkt, QUIC_CFQ_ITEM item) { item->pkt_next = fpkt->retx_head; item->pkt_prev = NULL; fpkt->retx_head = item; } void ossl_quic_txpim_pkt_clear_chunks(QUIC_TXPIM_PKT fpkt) { QUIC_TXPIM_PKT_EX ex = (QUIC_TXPIM_PKT_EX )fpkt; ex->num_chunks = 0; } int ossl_quic_txpim_pkt_append_chunk(QUIC_TXPIM_PKT fpkt, const QUIC_TXPIM_CHUNK chunk) { QUIC_TXPIM_PKT_EX ex = (QUIC_TXPIM_PKT_EX )fpkt; QUIC_TXPIM_CHUNK new_chunk; size_t new_alloc_chunks = ex->alloc_chunks; if (ex->num_chunks == ex->alloc_chunks) { new_alloc_chunks = (ex->alloc_chunks == 0) ? 4 : ex->alloc_chunks 8 / 5; if (new_alloc_chunks > MAX_ALLOC_CHUNKS) new_alloc_chunks = MAX_ALLOC_CHUNKS; if (ex->num_chunks == new_alloc_chunks) return 0; new_chunk = OPENSSL_realloc(ex->chunks, new_alloc_chunks * sizeof(QUIC_TXPIM_CHUNK)); if (new_chunk == NULL) return 0; ex->chunks = new_chunk; ex->alloc_chunks = new_alloc_chunks; } ex->chunks[ex->num_chunks++] = chunk; ex->chunks_need_sort = 1; return 1; } static int compare(const void a, const void b) { const QUIC_TXPIM_CHUNK ac = a, bc = b; if (ac->stream_id < bc->stream_id) return -1; else if (ac->stream_id > bc->stream_id) return 1; if (ac->start < bc->start) return -1; else if (ac->start > bc->start) return 1; return 0; } const QUIC_TXPIM_CHUNK ossl_quic_txpim_pkt_get_chunks(const QUIC_TXPIM_PKT fpkt) { QUIC_TXPIM_PKT_EX ex = (QUIC_TXPIM_PKT_EX )fpkt; if (ex->chunks_need_sort) { / * List of chunks will generally be very small so there is no issue * simply sorting here. / qsort(ex->chunks, ex->num_chunks, sizeof(QUIC_TXPIM_CHUNK), compare); ex->chunks_need_sort = 0; } return ex->chunks; } size_t ossl_quic_txpim_pkt_get_num_chunks(const QUIC_TXPIM_PKT fpkt) { QUIC_TXPIM_PKT_EX ex = (QUIC_TXPIM_PKT_EX )fpkt; return ex->num_chunks; } size_t ossl_quic_txpim_get_in_use(const QUIC_TXPIM *txpim) { return txpim->in_use; }
./openssl/ssl/quic/quic_method.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/macros.h> #include <openssl/objects.h> #include "quic_local.h" IMPLEMENT_quic_meth_func(OSSL_QUIC_ANY_VERSION, OSSL_QUIC_client_method, ssl_undefined_function, ossl_quic_connect, ssl3_undef_enc_method) IMPLEMENT_quic_meth_func(OSSL_QUIC_ANY_VERSION, OSSL_QUIC_client_thread_method, ssl_undefined_function, ossl_quic_connect, ssl3_undef_enc_method)
./openssl/ssl/quic/quic_channel.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/rand.h> #include <openssl/err.h> #include "internal/quic_channel.h" #include "internal/quic_error.h" #include "internal/quic_rx_depack.h" #include "internal/quic_lcidm.h" #include "internal/quic_srtm.h" #include "../ssl_local.h" #include "quic_channel_local.h" #include "quic_port_local.h" #include "quic_engine_local.h" / * NOTE: While this channel implementation currently has basic server support, * this functionality has been implemented for internal testing purposes and is * not suitable for network use. In particular, it does not implement address * validation, anti-amplification or retry logic. * * TODO(QUIC SERVER): Implement address validation and anti-amplification * TODO(QUIC SERVER): Implement retry logic / #define INIT_CRYPTO_RECV_BUF_LEN 16384 #define INIT_CRYPTO_SEND_BUF_LEN 16384 #define INIT_APP_BUF_LEN 8192 / * Interval before we force a PING to ensure NATs don't timeout. This is based * on the lowest commonly seen value of 30 seconds as cited in RFC 9000 s. * 10.1.2. / #define MAX_NAT_INTERVAL (ossl_ms2time(25000)) / * Our maximum ACK delay on the TX side. This is up to us to choose. Note that * this could differ from QUIC_DEFAULT_MAX_DELAY in future as that is a protocol * value which determines the value of the maximum ACK delay if the * max_ack_delay transport parameter is not set. / #define DEFAULT_MAX_ACK_DELAY QUIC_DEFAULT_MAX_ACK_DELAY DEFINE_LIST_OF_IMPL(ch, QUIC_CHANNEL); static void ch_save_err_state(QUIC_CHANNEL ch); static int ch_rx(QUIC_CHANNEL ch, int channel_only); static int ch_tx(QUIC_CHANNEL ch); static int ch_tick_tls(QUIC_CHANNEL ch, int channel_only); static void ch_rx_handle_packet(QUIC_CHANNEL ch, int channel_only); static OSSL_TIME ch_determine_next_tick_deadline(QUIC_CHANNEL ch); static int ch_retry(QUIC_CHANNEL ch, const unsigned char retry_token, size_t retry_token_len, const QUIC_CONN_ID retry_scid); static void ch_cleanup(QUIC_CHANNEL ch); static int ch_generate_transport_params(QUIC_CHANNEL ch); static int ch_on_transport_params(const unsigned char params, size_t params_len, void arg); static int ch_on_handshake_alert(void arg, unsigned char alert_code); static int ch_on_handshake_complete(void arg); static int ch_on_handshake_yield_secret(uint32_t enc_level, int direction, uint32_t suite_id, EVP_MD md, const unsigned char secret, size_t secret_len, void arg); static int ch_on_crypto_recv_record(const unsigned char buf, size_t bytes_read, void arg); static int ch_on_crypto_release_record(size_t bytes_read, void arg); static int crypto_ensure_empty(QUIC_RSTREAM rstream); static int ch_on_crypto_send(const unsigned char buf, size_t buf_len, size_t consumed, void arg); static OSSL_TIME get_time(void arg); static uint64_t get_stream_limit(int uni, void arg); static int rx_late_validate(QUIC_PN pn, int pn_space, void arg); static void rxku_detected(QUIC_PN pn, void arg); static int ch_retry(QUIC_CHANNEL ch, const unsigned char retry_token, size_t retry_token_len, const QUIC_CONN_ID retry_scid); static void ch_update_idle(QUIC_CHANNEL ch); static int ch_discard_el(QUIC_CHANNEL ch, uint32_t enc_level); static void ch_on_idle_timeout(QUIC_CHANNEL ch); static void ch_update_idle(QUIC_CHANNEL ch); static void ch_update_ping_deadline(QUIC_CHANNEL ch); static void ch_on_terminating_timeout(QUIC_CHANNEL ch); static void ch_start_terminating(QUIC_CHANNEL ch, const QUIC_TERMINATE_CAUSE tcause, int force_immediate); static void ch_on_txp_ack_tx(const OSSL_QUIC_FRAME_ACK ack, uint32_t pn_space, void arg); static void ch_rx_handle_version_neg(QUIC_CHANNEL ch, OSSL_QRX_PKT pkt); static void ch_raise_version_neg_failure(QUIC_CHANNEL ch); DEFINE_LHASH_OF_EX(QUIC_SRT_ELEM); /* * QUIC Channel Initialization and Teardown * ======================================== / #define DEFAULT_INIT_CONN_RXFC_WND (768 1024) #define DEFAULT_CONN_RXFC_MAX_WND_MUL 20 #define DEFAULT_INIT_STREAM_RXFC_WND (512 * 1024) #define DEFAULT_STREAM_RXFC_MAX_WND_MUL 12 #define DEFAULT_INIT_CONN_MAX_STREAMS 100 static int ch_init(QUIC_CHANNEL ch) { OSSL_QUIC_TX_PACKETISER_ARGS txp_args = {0}; OSSL_QTX_ARGS qtx_args = {0}; OSSL_QRX_ARGS qrx_args = {0}; QUIC_TLS_ARGS tls_args = {0}; uint32_t pn_space; size_t rx_short_dcid_len; size_t tx_init_dcid_len; if (ch->port == NULL \|\| ch->lcidm == NULL \|\| ch->srtm == NULL) goto err; rx_short_dcid_len = ossl_quic_port_get_rx_short_dcid_len(ch->port); tx_init_dcid_len = ossl_quic_port_get_tx_init_dcid_len(ch->port); / For clients, generate our initial DCID. / if (!ch->is_server && !ossl_quic_gen_rand_conn_id(ch->port->engine->libctx, tx_init_dcid_len, &ch->init_dcid)) goto err; / We plug in a network write BIO to the QTX later when we get one. / qtx_args.libctx = ch->port->engine->libctx; qtx_args.mdpl = QUIC_MIN_INITIAL_DGRAM_LEN; ch->rx_max_udp_payload_size = qtx_args.mdpl; ch->ping_deadline = ossl_time_infinite(); ch->qtx = ossl_qtx_new(&qtx_args); if (ch->qtx == NULL) goto err; ch->txpim = ossl_quic_txpim_new(); if (ch->txpim == NULL) goto err; ch->cfq = ossl_quic_cfq_new(); if (ch->cfq == NULL) goto err; if (!ossl_quic_txfc_init(&ch->conn_txfc, NULL)) goto err; / * Note: The TP we transmit governs what the peer can transmit and thus * applies to the RXFC. / ch->tx_init_max_stream_data_bidi_local = DEFAULT_INIT_STREAM_RXFC_WND; ch->tx_init_max_stream_data_bidi_remote = DEFAULT_INIT_STREAM_RXFC_WND; ch->tx_init_max_stream_data_uni = DEFAULT_INIT_STREAM_RXFC_WND; if (!ossl_quic_rxfc_init(&ch->conn_rxfc, NULL, DEFAULT_INIT_CONN_RXFC_WND, DEFAULT_CONN_RXFC_MAX_WND_MUL DEFAULT_INIT_CONN_RXFC_WND, get_time, ch)) goto err; for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) if (!ossl_quic_rxfc_init_standalone(&ch->crypto_rxfc[pn_space], INIT_CRYPTO_RECV_BUF_LEN, get_time, ch)) goto err; if (!ossl_quic_rxfc_init_standalone(&ch->max_streams_bidi_rxfc, DEFAULT_INIT_CONN_MAX_STREAMS, get_time, ch)) goto err; if (!ossl_quic_rxfc_init_standalone(&ch->max_streams_uni_rxfc, DEFAULT_INIT_CONN_MAX_STREAMS, get_time, ch)) goto err; if (!ossl_statm_init(&ch->statm)) goto err; ch->have_statm = 1; ch->cc_method = &ossl_cc_newreno_method; if ((ch->cc_data = ch->cc_method->new(get_time, ch)) == NULL) goto err; if ((ch->ackm = ossl_ackm_new(get_time, ch, &ch->statm, ch->cc_method, ch->cc_data)) == NULL) goto err; if (!ossl_quic_stream_map_init(&ch->qsm, get_stream_limit, ch, &ch->max_streams_bidi_rxfc, &ch->max_streams_uni_rxfc, ch->is_server)) goto err; ch->have_qsm = 1; if (!ch->is_server && !ossl_quic_lcidm_generate_initial(ch->lcidm, ch, &txp_args.cur_scid)) goto err; /* We use a zero-length SCID. / txp_args.cur_dcid = ch->init_dcid; txp_args.ack_delay_exponent = 3; txp_args.qtx = ch->qtx; txp_args.txpim = ch->txpim; txp_args.cfq = ch->cfq; txp_args.ackm = ch->ackm; txp_args.qsm = &ch->qsm; txp_args.conn_txfc = &ch->conn_txfc; txp_args.conn_rxfc = &ch->conn_rxfc; txp_args.max_streams_bidi_rxfc = &ch->max_streams_bidi_rxfc; txp_args.max_streams_uni_rxfc = &ch->max_streams_uni_rxfc; txp_args.cc_method = ch->cc_method; txp_args.cc_data = ch->cc_data; txp_args.now = get_time; txp_args.now_arg = ch; for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) { ch->crypto_send[pn_space] = ossl_quic_sstream_new(INIT_CRYPTO_SEND_BUF_LEN); if (ch->crypto_send[pn_space] == NULL) goto err; txp_args.crypto[pn_space] = ch->crypto_send[pn_space]; } ch->txp = ossl_quic_tx_packetiser_new(&txp_args); if (ch->txp == NULL) goto err; ossl_quic_tx_packetiser_set_ack_tx_cb(ch->txp, ch_on_txp_ack_tx, ch); qrx_args.libctx = ch->port->engine->libctx; qrx_args.demux = ch->port->demux; qrx_args.short_conn_id_len = rx_short_dcid_len; qrx_args.max_deferred = 32; if ((ch->qrx = ossl_qrx_new(&qrx_args)) == NULL) goto err; if (!ossl_qrx_set_late_validation_cb(ch->qrx, rx_late_validate, ch)) goto err; if (!ossl_qrx_set_key_update_cb(ch->qrx, rxku_detected, ch)) goto err; for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) { ch->crypto_recv[pn_space] = ossl_quic_rstream_new(NULL, NULL, 0); if (ch->crypto_recv[pn_space] == NULL) goto err; } / Plug in the TLS handshake layer. / tls_args.s = ch->tls; tls_args.crypto_send_cb = ch_on_crypto_send; tls_args.crypto_send_cb_arg = ch; tls_args.crypto_recv_rcd_cb = ch_on_crypto_recv_record; tls_args.crypto_recv_rcd_cb_arg = ch; tls_args.crypto_release_rcd_cb = ch_on_crypto_release_record; tls_args.crypto_release_rcd_cb_arg = ch; tls_args.yield_secret_cb = ch_on_handshake_yield_secret; tls_args.yield_secret_cb_arg = ch; tls_args.got_transport_params_cb = ch_on_transport_params; tls_args.got_transport_params_cb_arg= ch; tls_args.handshake_complete_cb = ch_on_handshake_complete; tls_args.handshake_complete_cb_arg = ch; tls_args.alert_cb = ch_on_handshake_alert; tls_args.alert_cb_arg = ch; tls_args.is_server = ch->is_server; if ((ch->qtls = ossl_quic_tls_new(&tls_args)) == NULL) goto err; ch->tx_max_ack_delay = DEFAULT_MAX_ACK_DELAY; ch->rx_max_ack_delay = QUIC_DEFAULT_MAX_ACK_DELAY; ch->rx_ack_delay_exp = QUIC_DEFAULT_ACK_DELAY_EXP; ch->rx_active_conn_id_limit = QUIC_MIN_ACTIVE_CONN_ID_LIMIT; ch->max_idle_timeout = QUIC_DEFAULT_IDLE_TIMEOUT; ch->tx_enc_level = QUIC_ENC_LEVEL_INITIAL; ch->rx_enc_level = QUIC_ENC_LEVEL_INITIAL; ch->txku_threshold_override = UINT64_MAX; ossl_ackm_set_tx_max_ack_delay(ch->ackm, ossl_ms2time(ch->tx_max_ack_delay)); ossl_ackm_set_rx_max_ack_delay(ch->ackm, ossl_ms2time(ch->rx_max_ack_delay)); / * Determine the QUIC Transport Parameters and serialize the transport * parameters block. (For servers, we do this later as we must defer * generation until we have received the client's transport parameters.) / if (!ch->is_server && !ch_generate_transport_params(ch)) goto err; ch_update_idle(ch); ossl_list_ch_insert_tail(&ch->port->channel_list, ch); ch->on_port_list = 1; return 1; err: ch_cleanup(ch); return 0; } static void ch_cleanup(QUIC_CHANNEL ch) { uint32_t pn_space; if (ch->ackm != NULL) for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) ossl_ackm_on_pkt_space_discarded(ch->ackm, pn_space); ossl_quic_lcidm_cull(ch->lcidm, ch); ossl_quic_srtm_cull(ch->srtm, ch); ossl_quic_tx_packetiser_free(ch->txp); ossl_quic_txpim_free(ch->txpim); ossl_quic_cfq_free(ch->cfq); ossl_qtx_free(ch->qtx); if (ch->cc_data != NULL) ch->cc_method->free(ch->cc_data); if (ch->have_statm) ossl_statm_destroy(&ch->statm); ossl_ackm_free(ch->ackm); if (ch->have_qsm) ossl_quic_stream_map_cleanup(&ch->qsm); for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) { ossl_quic_sstream_free(ch->crypto_send[pn_space]); ossl_quic_rstream_free(ch->crypto_recv[pn_space]); } ossl_qrx_pkt_release(ch->qrx_pkt); ch->qrx_pkt = NULL; ossl_quic_tls_free(ch->qtls); ossl_qrx_free(ch->qrx); OPENSSL_free(ch->local_transport_params); OPENSSL_free((char )ch->terminate_cause.reason); OSSL_ERR_STATE_free(ch->err_state); OPENSSL_free(ch->ack_range_scratch); if (ch->on_port_list) { ossl_list_ch_remove(&ch->port->channel_list, ch); ch->on_port_list = 0; } } QUIC_CHANNEL ossl_quic_channel_new(const QUIC_CHANNEL_ARGS args) { QUIC_CHANNEL ch = NULL; if ((ch = OPENSSL_zalloc(sizeof(ch))) == NULL) return NULL; ch->port = args->port; ch->is_server = args->is_server; ch->tls = args->tls; ch->lcidm = args->lcidm; ch->srtm = args->srtm; if (!ch_init(ch)) { OPENSSL_free(ch); return NULL; } return ch; } void ossl_quic_channel_free(QUIC_CHANNEL ch) { if (ch == NULL) return; ch_cleanup(ch); OPENSSL_free(ch); } /* Set mutator callbacks for test framework support / int ossl_quic_channel_set_mutator(QUIC_CHANNEL ch, ossl_mutate_packet_cb mutatecb, ossl_finish_mutate_cb finishmutatecb, void mutatearg) { if (ch->qtx == NULL) return 0; ossl_qtx_set_mutator(ch->qtx, mutatecb, finishmutatecb, mutatearg); return 1; } int ossl_quic_channel_get_peer_addr(QUIC_CHANNEL ch, BIO_ADDR peer_addr) { if (!ch->addressed_mode) return 0; peer_addr = ch->cur_peer_addr; return 1; } int ossl_quic_channel_set_peer_addr(QUIC_CHANNEL ch, const BIO_ADDR peer_addr) { if (ch->state != QUIC_CHANNEL_STATE_IDLE) return 0; if (peer_addr == NULL \|\| BIO_ADDR_family(peer_addr) == AF_UNSPEC) { BIO_ADDR_clear(&ch->cur_peer_addr); ch->addressed_mode = 0; return 1; } ch->cur_peer_addr = peer_addr; ch->addressed_mode = 1; return 1; } QUIC_REACTOR ossl_quic_channel_get_reactor(QUIC_CHANNEL ch) { return ossl_quic_port_get0_reactor(ch->port); } QUIC_STREAM_MAP ossl_quic_channel_get_qsm(QUIC_CHANNEL ch) { return &ch->qsm; } OSSL_STATM ossl_quic_channel_get_statm(QUIC_CHANNEL ch) { return &ch->statm; } QUIC_STREAM ossl_quic_channel_get_stream_by_id(QUIC_CHANNEL ch, uint64_t stream_id) { return ossl_quic_stream_map_get_by_id(&ch->qsm, stream_id); } int ossl_quic_channel_is_active(const QUIC_CHANNEL ch) { return ch != NULL && ch->state == QUIC_CHANNEL_STATE_ACTIVE; } int ossl_quic_channel_is_closing(const QUIC_CHANNEL ch) { return ch->state == QUIC_CHANNEL_STATE_TERMINATING_CLOSING; } static int ossl_quic_channel_is_draining(const QUIC_CHANNEL ch) { return ch->state == QUIC_CHANNEL_STATE_TERMINATING_DRAINING; } static int ossl_quic_channel_is_terminating(const QUIC_CHANNEL ch) { return ossl_quic_channel_is_closing(ch) \|\| ossl_quic_channel_is_draining(ch); } int ossl_quic_channel_is_terminated(const QUIC_CHANNEL ch) { return ch->state == QUIC_CHANNEL_STATE_TERMINATED; } int ossl_quic_channel_is_term_any(const QUIC_CHANNEL ch) { return ossl_quic_channel_is_terminating(ch) \|\| ossl_quic_channel_is_terminated(ch); } const QUIC_TERMINATE_CAUSE ossl_quic_channel_get_terminate_cause(const QUIC_CHANNEL ch) { return ossl_quic_channel_is_term_any(ch) ? &ch->terminate_cause : NULL; } int ossl_quic_channel_is_handshake_complete(const QUIC_CHANNEL ch) { return ch->handshake_complete; } int ossl_quic_channel_is_handshake_confirmed(const QUIC_CHANNEL ch) { return ch->handshake_confirmed; } QUIC_DEMUX ossl_quic_channel_get0_demux(QUIC_CHANNEL ch) { return ch->port->demux; } QUIC_PORT ossl_quic_channel_get0_port(QUIC_CHANNEL ch) { return ch->port; } QUIC_ENGINE ossl_quic_channel_get0_engine(QUIC_CHANNEL ch) { return ossl_quic_port_get0_engine(ch->port); } CRYPTO_MUTEX ossl_quic_channel_get_mutex(QUIC_CHANNEL ch) { return ossl_quic_port_get0_mutex(ch->port); } int ossl_quic_channel_has_pending(const QUIC_CHANNEL ch) { return ossl_quic_demux_has_pending(ch->port->demux) \|\| ossl_qrx_processed_read_pending(ch->qrx); } /* * QUIC Channel: Callbacks from Miscellaneous Subsidiary Components * ================================================================ / / Used by various components. / static OSSL_TIME get_time(void arg) { QUIC_CHANNEL ch = arg; return ossl_quic_port_get_time(ch->port); } / Used by QSM. / static uint64_t get_stream_limit(int uni, void arg) { QUIC_CHANNEL ch = arg; return uni ? ch->max_local_streams_uni : ch->max_local_streams_bidi; } / * Called by QRX to determine if a packet is potentially invalid before trying * to decrypt it. / static int rx_late_validate(QUIC_PN pn, int pn_space, void arg) { QUIC_CHANNEL ch = arg; / Potential duplicates should not be processed. / if (!ossl_ackm_is_rx_pn_processable(ch->ackm, pn, pn_space)) return 0; return 1; } / * Triggers a TXKU (whether spontaneous or solicited). Does not check whether * spontaneous TXKU is currently allowed. / QUIC_NEEDS_LOCK static void ch_trigger_txku(QUIC_CHANNEL ch) { uint64_t next_pn = ossl_quic_tx_packetiser_get_next_pn(ch->txp, QUIC_PN_SPACE_APP); if (!ossl_quic_pn_valid(next_pn) \|\| !ossl_qtx_trigger_key_update(ch->qtx)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "key update"); return; } ch->txku_in_progress = 1; ch->txku_pn = next_pn; ch->rxku_expected = ch->ku_locally_initiated; } QUIC_NEEDS_LOCK static int txku_in_progress(QUIC_CHANNEL ch) { if (ch->txku_in_progress && ossl_ackm_get_largest_acked(ch->ackm, QUIC_PN_SPACE_APP) >= ch->txku_pn) { OSSL_TIME pto = ossl_ackm_get_pto_duration(ch->ackm); / * RFC 9001 s. 6.5: Endpoints SHOULD wait three times the PTO before * initiating a key update after receiving an acknowledgment that * confirms that the previous key update was received. * * Note that by the above wording, this period starts from when we get * the ack for a TXKU-triggering packet, not when the TXKU is initiated. * So we defer TXKU cooldown deadline calculation to this point. / ch->txku_in_progress = 0; ch->txku_cooldown_deadline = ossl_time_add(get_time(ch), ossl_time_multiply(pto, 3)); } return ch->txku_in_progress; } QUIC_NEEDS_LOCK static int txku_allowed(QUIC_CHANNEL ch) { return ch->tx_enc_level == QUIC_ENC_LEVEL_1RTT /* Sanity check. / / Strict RFC 9001 criterion for TXKU. / && ch->handshake_confirmed && !txku_in_progress(ch); } QUIC_NEEDS_LOCK static int txku_recommendable(QUIC_CHANNEL ch) { if (!txku_allowed(ch)) return 0; return /* Recommended RFC 9001 criterion for TXKU. / ossl_time_compare(get_time(ch), ch->txku_cooldown_deadline) >= 0 / Some additional sensible criteria. / && !ch->rxku_in_progress && !ch->rxku_pending_confirm; } QUIC_NEEDS_LOCK static int txku_desirable(QUIC_CHANNEL ch) { uint64_t cur_pkt_count, max_pkt_count, thresh_pkt_count; const uint32_t enc_level = QUIC_ENC_LEVEL_1RTT; /* Check AEAD limit to determine if we should perform a spontaneous TXKU. / cur_pkt_count = ossl_qtx_get_cur_epoch_pkt_count(ch->qtx, enc_level); max_pkt_count = ossl_qtx_get_max_epoch_pkt_count(ch->qtx, enc_level); thresh_pkt_count = max_pkt_count / 2; if (ch->txku_threshold_override != UINT64_MAX) thresh_pkt_count = ch->txku_threshold_override; return cur_pkt_count >= thresh_pkt_count; } QUIC_NEEDS_LOCK static void ch_maybe_trigger_spontaneous_txku(QUIC_CHANNEL ch) { if (!txku_recommendable(ch) \|\| !txku_desirable(ch)) return; ch->ku_locally_initiated = 1; ch_trigger_txku(ch); } QUIC_NEEDS_LOCK static int rxku_allowed(QUIC_CHANNEL ch) { / * RFC 9001 s. 6.1: An endpoint MUST NOT initiate a key update prior to * having confirmed the handshake (Section 4.1.2). * * RFC 9001 s. 6.1: An endpoint MUST NOT initiate a subsequent key update * unless it has received an acknowledgment for a packet that was sent * protected with keys from the current key phase. * * RFC 9001 s. 6.2: If an endpoint detects a second update before it has * sent any packets with updated keys containing an acknowledgment for the * packet that initiated the key update, it indicates that its peer has * updated keys twice without awaiting confirmation. An endpoint MAY treat * such consecutive key updates as a connection error of type * KEY_UPDATE_ERROR. / return ch->handshake_confirmed && !ch->rxku_pending_confirm; } / * Called when the QRX detects a new RX key update event. / enum rxku_decision { DECISION_RXKU_ONLY, DECISION_PROTOCOL_VIOLATION, DECISION_SOLICITED_TXKU }; / Called when the QRX detects a key update has occurred. / QUIC_NEEDS_LOCK static void rxku_detected(QUIC_PN pn, void arg) { QUIC_CHANNEL ch = arg; enum rxku_decision decision; OSSL_TIME pto; / * Note: rxku_in_progress is always 0 here as an RXKU cannot be detected * when we are still in UPDATING or COOLDOWN (see quic_record_rx.h). / assert(!ch->rxku_in_progress); if (!rxku_allowed(ch)) / Is RXKU even allowed at this time? / decision = DECISION_PROTOCOL_VIOLATION; else if (ch->ku_locally_initiated) / * If this key update was locally initiated (meaning that this detected * RXKU event is a result of our own spontaneous TXKU), we do not * trigger another TXKU; after all, to do so would result in an infinite * ping-pong of key updates. We still process it as an RXKU. / decision = DECISION_RXKU_ONLY; else / * Otherwise, a peer triggering a KU means we have to trigger a KU also. / decision = DECISION_SOLICITED_TXKU; if (decision == DECISION_PROTOCOL_VIOLATION) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_KEY_UPDATE_ERROR, 0, "RX key update again too soon"); return; } pto = ossl_ackm_get_pto_duration(ch->ackm); ch->ku_locally_initiated = 0; ch->rxku_in_progress = 1; ch->rxku_pending_confirm = 1; ch->rxku_trigger_pn = pn; ch->rxku_update_end_deadline = ossl_time_add(get_time(ch), pto); ch->rxku_expected = 0; if (decision == DECISION_SOLICITED_TXKU) / NOT gated by usual txku_allowed() / ch_trigger_txku(ch); / * Ordinarily, we only generate ACK when some ACK-eliciting frame has been * received. In some cases, this may not occur for a long time, for example * if transmission of application data is going in only one direction and * nothing else is happening with the connection. However, since the peer * cannot initiate a subsequent (spontaneous) TXKU until its prior * (spontaneous or solicited) TXKU has completed - meaning that prior * TXKU's trigger packet (or subsequent packet) has been acknowledged, this * can lead to very long times before a TXKU is considered 'completed'. * Optimise this by forcing ACK generation after triggering TXKU. * (Basically, we consider a RXKU event something that is 'ACK-eliciting', * which it more or less should be; it is necessarily separate from ordinary * processing of ACK-eliciting frames as key update is not indicated via a * frame.) / ossl_quic_tx_packetiser_schedule_ack(ch->txp, QUIC_PN_SPACE_APP); } / Called per tick to handle RXKU timer events. / QUIC_NEEDS_LOCK static void ch_rxku_tick(QUIC_CHANNEL ch) { if (!ch->rxku_in_progress \|\| ossl_time_compare(get_time(ch), ch->rxku_update_end_deadline) < 0) return; ch->rxku_update_end_deadline = ossl_time_infinite(); ch->rxku_in_progress = 0; if (!ossl_qrx_key_update_timeout(ch->qrx, /normal=/1)) ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "RXKU cooldown internal error"); } QUIC_NEEDS_LOCK static void ch_on_txp_ack_tx(const OSSL_QUIC_FRAME_ACK ack, uint32_t pn_space, void arg) { QUIC_CHANNEL ch = arg; if (pn_space != QUIC_PN_SPACE_APP \|\| !ch->rxku_pending_confirm \|\| !ossl_quic_frame_ack_contains_pn(ack, ch->rxku_trigger_pn)) return; / * Defer clearing rxku_pending_confirm until TXP generate call returns * successfully. / ch->rxku_pending_confirm_done = 1; } / * QUIC Channel: Handshake Layer Event Handling * ============================================ / static int ch_on_crypto_send(const unsigned char buf, size_t buf_len, size_t consumed, void arg) { int ret; QUIC_CHANNEL ch = arg; uint32_t enc_level = ch->tx_enc_level; uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level); QUIC_SSTREAM sstream = ch->crypto_send[pn_space]; if (!ossl_assert(sstream != NULL)) return 0; ret = ossl_quic_sstream_append(sstream, buf, buf_len, consumed); return ret; } static int crypto_ensure_empty(QUIC_RSTREAM rstream) { size_t avail = 0; int is_fin = 0; if (rstream == NULL) return 1; if (!ossl_quic_rstream_available(rstream, &avail, &is_fin)) return 0; return avail == 0; } static int ch_on_crypto_recv_record(const unsigned char buf, size_t bytes_read, void arg) { QUIC_CHANNEL ch = arg; QUIC_RSTREAM rstream; int is_fin = 0; / crypto stream is never finished, so we don't use this / uint32_t i; / * After we move to a later EL we must not allow our peer to send any new * bytes in the crypto stream on a previous EL. Retransmissions of old bytes * are allowed. * * In practice we will only move to a new EL when we have consumed all bytes * which should be sent on the crypto stream at a previous EL. For example, * the Handshake EL should not be provisioned until we have completely * consumed a TLS 1.3 ServerHello. Thus when we provision an EL the output * of ossl_quic_rstream_available() should be 0 for all lower ELs. Thus if a * given EL is available we simply ensure we have not received any further * bytes at a lower EL. / for (i = QUIC_ENC_LEVEL_INITIAL; i < ch->rx_enc_level; ++i) if (i != QUIC_ENC_LEVEL_0RTT && !crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) { / Protocol violation (RFC 9001 s. 4.1.3) / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_CRYPTO, "crypto stream data in wrong EL"); return 0; } rstream = ch->crypto_recv[ossl_quic_enc_level_to_pn_space(ch->rx_enc_level)]; if (rstream == NULL) return 0; return ossl_quic_rstream_get_record(rstream, buf, bytes_read, &is_fin); } static int ch_on_crypto_release_record(size_t bytes_read, void arg) { QUIC_CHANNEL ch = arg; QUIC_RSTREAM rstream; OSSL_RTT_INFO rtt_info; uint32_t rx_pn_space = ossl_quic_enc_level_to_pn_space(ch->rx_enc_level); rstream = ch->crypto_recv[rx_pn_space]; if (rstream == NULL) return 0; ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(ch), &rtt_info); if (!ossl_quic_rxfc_on_retire(&ch->crypto_rxfc[rx_pn_space], bytes_read, rtt_info.smoothed_rtt)) return 0; return ossl_quic_rstream_release_record(rstream, bytes_read); } static int ch_on_handshake_yield_secret(uint32_t enc_level, int direction, uint32_t suite_id, EVP_MD md, const unsigned char secret, size_t secret_len, void arg) { QUIC_CHANNEL ch = arg; uint32_t i; if (enc_level < QUIC_ENC_LEVEL_HANDSHAKE \|\| enc_level >= QUIC_ENC_LEVEL_NUM) /* Invalid EL. / return 0; if (direction) { / TX / if (enc_level <= ch->tx_enc_level) / * Does not make sense for us to try and provision an EL we have already * attained. / return 0; if (!ossl_qtx_provide_secret(ch->qtx, enc_level, suite_id, md, secret, secret_len)) return 0; ch->tx_enc_level = enc_level; } else { / RX / if (enc_level <= ch->rx_enc_level) / * Does not make sense for us to try and provision an EL we have already * attained. / return 0; / * Ensure all crypto streams for previous ELs are now empty of available * data. / for (i = QUIC_ENC_LEVEL_INITIAL; i < enc_level; ++i) if (!crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) { / Protocol violation (RFC 9001 s. 4.1.3) / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_CRYPTO, "crypto stream data in wrong EL"); return 0; } if (!ossl_qrx_provide_secret(ch->qrx, enc_level, suite_id, md, secret, secret_len)) return 0; ch->have_new_rx_secret = 1; ch->rx_enc_level = enc_level; } return 1; } static int ch_on_handshake_complete(void arg) { QUIC_CHANNEL ch = arg; if (!ossl_assert(!ch->handshake_complete)) return 0; / this should not happen twice / if (!ossl_assert(ch->tx_enc_level == QUIC_ENC_LEVEL_1RTT)) return 0; if (!ch->got_remote_transport_params) { / * Was not a valid QUIC handshake if we did not get valid transport * params. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CRYPTO_MISSING_EXT, OSSL_QUIC_FRAME_TYPE_CRYPTO, "no transport parameters received"); return 0; } / Don't need transport parameters anymore. / OPENSSL_free(ch->local_transport_params); ch->local_transport_params = NULL; / Tell the QRX it can now process 1-RTT packets. / ossl_qrx_allow_1rtt_processing(ch->qrx); / Tell TXP the handshake is complete. / ossl_quic_tx_packetiser_notify_handshake_complete(ch->txp); ch->handshake_complete = 1; if (ch->is_server) { / * On the server, the handshake is confirmed as soon as it is complete. / ossl_quic_channel_on_handshake_confirmed(ch); ossl_quic_tx_packetiser_schedule_handshake_done(ch->txp); } return 1; } static int ch_on_handshake_alert(void arg, unsigned char alert_code) { QUIC_CHANNEL ch = arg; / * RFC 9001 s. 4.4: More specifically, servers MUST NOT send post-handshake * TLS CertificateRequest messages, and clients MUST treat receipt of such * messages as a connection error of type PROTOCOL_VIOLATION. / if (alert_code == SSL_AD_UNEXPECTED_MESSAGE && ch->handshake_complete && ossl_quic_tls_is_cert_request(ch->qtls)) ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "Post-handshake TLS " "CertificateRequest received"); / * RFC 9001 s. 4.6.1: Servers MUST NOT send the early_data extension with a * max_early_data_size field set to any value other than 0xffffffff. A * client MUST treat receipt of a NewSessionTicket that contains an * early_data extension with any other value as a connection error of type * PROTOCOL_VIOLATION. / else if (alert_code == SSL_AD_ILLEGAL_PARAMETER && ch->handshake_complete && ossl_quic_tls_has_bad_max_early_data(ch->qtls)) ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "Bad max_early_data received"); else ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CRYPTO_ERR_BEGIN + alert_code, 0, "handshake alert"); return 1; } / * QUIC Channel: Transport Parameter Handling * ========================================== / / * Called by handshake layer when we receive QUIC Transport Parameters from the * peer. Note that these are not authenticated until the handshake is marked * as complete. / #define TP_REASON_SERVER_ONLY(x) \ x " may not be sent by a client" #define TP_REASON_DUP(x) \ x " appears multiple times" #define TP_REASON_MALFORMED(x) \ x " is malformed" #define TP_REASON_EXPECTED_VALUE(x) \ x " does not match expected value" #define TP_REASON_NOT_RETRY(x) \ x " sent when not performing a retry" #define TP_REASON_REQUIRED(x) \ x " was not sent but is required" #define TP_REASON_INTERNAL_ERROR(x) \ x " encountered internal error" static void txfc_bump_cwm_bidi(QUIC_STREAM s, void arg) { if (!ossl_quic_stream_is_bidi(s) \|\| ossl_quic_stream_is_server_init(s)) return; ossl_quic_txfc_bump_cwm(&s->txfc, (uint64_t )arg); } static void txfc_bump_cwm_uni(QUIC_STREAM s, void arg) { if (ossl_quic_stream_is_bidi(s) \|\| ossl_quic_stream_is_server_init(s)) return; ossl_quic_txfc_bump_cwm(&s->txfc, (uint64_t )arg); } static void do_update(QUIC_STREAM s, void arg) { QUIC_CHANNEL ch = arg; ossl_quic_stream_map_update_state(&ch->qsm, s); } static int ch_on_transport_params(const unsigned char params, size_t params_len, void arg) { QUIC_CHANNEL ch = arg; PACKET pkt; uint64_t id, v; size_t len; const unsigned char body; int got_orig_dcid = 0; int got_initial_scid = 0; int got_retry_scid = 0; int got_initial_max_data = 0; int got_initial_max_stream_data_bidi_local = 0; int got_initial_max_stream_data_bidi_remote = 0; int got_initial_max_stream_data_uni = 0; int got_initial_max_streams_bidi = 0; int got_initial_max_streams_uni = 0; int got_stateless_reset_token = 0; int got_preferred_addr = 0; int got_ack_delay_exp = 0; int got_max_ack_delay = 0; int got_max_udp_payload_size = 0; int got_max_idle_timeout = 0; int got_active_conn_id_limit = 0; int got_disable_active_migration = 0; QUIC_CONN_ID cid; const char reason = "bad transport parameter"; if (ch->got_remote_transport_params) { reason = "multiple transport parameter extensions"; goto malformed; } if (!PACKET_buf_init(&pkt, params, params_len)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "internal error (packet buf init)"); return 0; } while (PACKET_remaining(&pkt) > 0) { if (!ossl_quic_wire_peek_transport_param(&pkt, &id)) goto malformed; switch (id) { case QUIC_TPARAM_ORIG_DCID: if (got_orig_dcid) { reason = TP_REASON_DUP("ORIG_DCID"); goto malformed; } if (ch->is_server) { reason = TP_REASON_SERVER_ONLY("ORIG_DCID"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_cid(&pkt, NULL, &cid)) { reason = TP_REASON_MALFORMED("ORIG_DCID"); goto malformed; } #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION / Must match our initial DCID. / if (!ossl_quic_conn_id_eq(&ch->init_dcid, &cid)) { reason = TP_REASON_EXPECTED_VALUE("ORIG_DCID"); goto malformed; } #endif got_orig_dcid = 1; break; case QUIC_TPARAM_RETRY_SCID: if (ch->is_server) { reason = TP_REASON_SERVER_ONLY("RETRY_SCID"); goto malformed; } if (got_retry_scid) { reason = TP_REASON_DUP("RETRY_SCID"); goto malformed; } if (!ch->doing_retry) { reason = TP_REASON_NOT_RETRY("RETRY_SCID"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_cid(&pkt, NULL, &cid)) { reason = TP_REASON_MALFORMED("RETRY_SCID"); goto malformed; } / Must match Retry packet SCID. / if (!ossl_quic_conn_id_eq(&ch->retry_scid, &cid)) { reason = TP_REASON_EXPECTED_VALUE("RETRY_SCID"); goto malformed; } got_retry_scid = 1; break; case QUIC_TPARAM_INITIAL_SCID: if (got_initial_scid) { / must not appear more than once / reason = TP_REASON_DUP("INITIAL_SCID"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_cid(&pkt, NULL, &cid)) { reason = TP_REASON_MALFORMED("INITIAL_SCID"); goto malformed; } / Must match SCID of first Initial packet from server. / if (!ossl_quic_conn_id_eq(&ch->init_scid, &cid)) { reason = TP_REASON_EXPECTED_VALUE("INITIAL_SCID"); goto malformed; } got_initial_scid = 1; break; case QUIC_TPARAM_INITIAL_MAX_DATA: if (got_initial_max_data) { / must not appear more than once / reason = TP_REASON_DUP("INITIAL_MAX_DATA"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_DATA"); goto malformed; } ossl_quic_txfc_bump_cwm(&ch->conn_txfc, v); got_initial_max_data = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL: if (got_initial_max_stream_data_bidi_local) { / must not appear more than once / reason = TP_REASON_DUP("INITIAL_MAX_STREAM_DATA_BIDI_LOCAL"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAM_DATA_BIDI_LOCAL"); goto malformed; } / * This is correct; the BIDI_LOCAL TP governs streams created by * the endpoint which sends the TP, i.e., our peer. / ch->rx_init_max_stream_data_bidi_remote = v; got_initial_max_stream_data_bidi_local = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE: if (got_initial_max_stream_data_bidi_remote) { / must not appear more than once / reason = TP_REASON_DUP("INITIAL_MAX_STREAM_DATA_BIDI_REMOTE"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAM_DATA_BIDI_REMOTE"); goto malformed; } / * This is correct; the BIDI_REMOTE TP governs streams created * by the endpoint which receives the TP, i.e., us. / ch->rx_init_max_stream_data_bidi_local = v; / Apply to all existing streams. / ossl_quic_stream_map_visit(&ch->qsm, txfc_bump_cwm_bidi, &v); got_initial_max_stream_data_bidi_remote = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_UNI: if (got_initial_max_stream_data_uni) { / must not appear more than once / reason = TP_REASON_DUP("INITIAL_MAX_STREAM_DATA_UNI"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAM_DATA_UNI"); goto malformed; } ch->rx_init_max_stream_data_uni = v; / Apply to all existing streams. / ossl_quic_stream_map_visit(&ch->qsm, txfc_bump_cwm_uni, &v); got_initial_max_stream_data_uni = 1; break; case QUIC_TPARAM_ACK_DELAY_EXP: if (got_ack_delay_exp) { / must not appear more than once / reason = TP_REASON_DUP("ACK_DELAY_EXP"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) \|\| v > QUIC_MAX_ACK_DELAY_EXP) { reason = TP_REASON_MALFORMED("ACK_DELAY_EXP"); goto malformed; } ch->rx_ack_delay_exp = (unsigned char)v; got_ack_delay_exp = 1; break; case QUIC_TPARAM_MAX_ACK_DELAY: if (got_max_ack_delay) { / must not appear more than once / reason = TP_REASON_DUP("MAX_ACK_DELAY"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) \|\| v >= (((uint64_t)1) << 14)) { reason = TP_REASON_MALFORMED("MAX_ACK_DELAY"); goto malformed; } ch->rx_max_ack_delay = v; ossl_ackm_set_rx_max_ack_delay(ch->ackm, ossl_ms2time(ch->rx_max_ack_delay)); got_max_ack_delay = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAMS_BIDI: if (got_initial_max_streams_bidi) { / must not appear more than once / reason = TP_REASON_DUP("INITIAL_MAX_STREAMS_BIDI"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) \|\| v > (((uint64_t)1) << 60)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAMS_BIDI"); goto malformed; } assert(ch->max_local_streams_bidi == 0); ch->max_local_streams_bidi = v; got_initial_max_streams_bidi = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAMS_UNI: if (got_initial_max_streams_uni) { / must not appear more than once / reason = TP_REASON_DUP("INITIAL_MAX_STREAMS_UNI"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) \|\| v > (((uint64_t)1) << 60)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAMS_UNI"); goto malformed; } assert(ch->max_local_streams_uni == 0); ch->max_local_streams_uni = v; got_initial_max_streams_uni = 1; break; case QUIC_TPARAM_MAX_IDLE_TIMEOUT: if (got_max_idle_timeout) { / must not appear more than once / reason = TP_REASON_DUP("MAX_IDLE_TIMEOUT"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("MAX_IDLE_TIMEOUT"); goto malformed; } if (v > 0 && v < ch->max_idle_timeout) ch->max_idle_timeout = v; ch_update_idle(ch); got_max_idle_timeout = 1; break; case QUIC_TPARAM_MAX_UDP_PAYLOAD_SIZE: if (got_max_udp_payload_size) { / must not appear more than once / reason = TP_REASON_DUP("MAX_UDP_PAYLOAD_SIZE"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) \|\| v < QUIC_MIN_INITIAL_DGRAM_LEN) { reason = TP_REASON_MALFORMED("MAX_UDP_PAYLOAD_SIZE"); goto malformed; } ch->rx_max_udp_payload_size = v; got_max_udp_payload_size = 1; break; case QUIC_TPARAM_ACTIVE_CONN_ID_LIMIT: if (got_active_conn_id_limit) { / must not appear more than once / reason = TP_REASON_DUP("ACTIVE_CONN_ID_LIMIT"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) \|\| v < QUIC_MIN_ACTIVE_CONN_ID_LIMIT) { reason = TP_REASON_MALFORMED("ACTIVE_CONN_ID_LIMIT"); goto malformed; } ch->rx_active_conn_id_limit = v; got_active_conn_id_limit = 1; break; case QUIC_TPARAM_STATELESS_RESET_TOKEN: if (got_stateless_reset_token) { reason = TP_REASON_DUP("STATELESS_RESET_TOKEN"); goto malformed; } / * We must ensure a client doesn't send them because we don't have * processing for them. * * TODO(QUIC SERVER): remove this restriction / if (ch->is_server) { reason = TP_REASON_SERVER_ONLY("STATELESS_RESET_TOKEN"); goto malformed; } body = ossl_quic_wire_decode_transport_param_bytes(&pkt, &id, &len); if (body == NULL \|\| len != QUIC_STATELESS_RESET_TOKEN_LEN) { reason = TP_REASON_MALFORMED("STATELESS_RESET_TOKEN"); goto malformed; } if (!ossl_quic_srtm_add(ch->srtm, ch, ch->cur_remote_seq_num, (const QUIC_STATELESS_RESET_TOKEN )body)) { reason = TP_REASON_INTERNAL_ERROR("STATELESS_RESET_TOKEN"); goto malformed; } got_stateless_reset_token = 1; break; case QUIC_TPARAM_PREFERRED_ADDR: { /* TODO(QUIC FUTURE): Handle preferred address. / QUIC_PREFERRED_ADDR pfa; if (got_preferred_addr) { reason = TP_REASON_DUP("PREFERRED_ADDR"); goto malformed; } / * RFC 9000 s. 18.2: "A server that chooses a zero-length * connection ID MUST NOT provide a preferred address. * Similarly, a server MUST NOT include a zero-length connection * ID in this transport parameter. A client MUST treat a * violation of these requirements as a connection error of type * TRANSPORT_PARAMETER_ERROR." / if (ch->is_server) { reason = TP_REASON_SERVER_ONLY("PREFERRED_ADDR"); goto malformed; } if (ch->cur_remote_dcid.id_len == 0) { reason = "PREFERRED_ADDR provided for zero-length CID"; goto malformed; } if (!ossl_quic_wire_decode_transport_param_preferred_addr(&pkt, &pfa)) { reason = TP_REASON_MALFORMED("PREFERRED_ADDR"); goto malformed; } if (pfa.cid.id_len == 0) { reason = "zero-length CID in PREFERRED_ADDR"; goto malformed; } got_preferred_addr = 1; } break; case QUIC_TPARAM_DISABLE_ACTIVE_MIGRATION: / We do not currently handle migration, so nothing to do. / if (got_disable_active_migration) { / must not appear more than once / reason = TP_REASON_DUP("DISABLE_ACTIVE_MIGRATION"); goto malformed; } body = ossl_quic_wire_decode_transport_param_bytes(&pkt, &id, &len); if (body == NULL \|\| len > 0) { reason = TP_REASON_MALFORMED("DISABLE_ACTIVE_MIGRATION"); goto malformed; } got_disable_active_migration = 1; break; default: / * Skip over and ignore. * * RFC 9000 s. 7.4: We SHOULD treat duplicated transport parameters * as a connection error, but we are not required to. Currently, * handle this programmatically by checking for duplicates in the * parameters that we recognise, as above, but don't bother * maintaining a list of duplicates for anything we don't recognise. / body = ossl_quic_wire_decode_transport_param_bytes(&pkt, &id, &len); if (body == NULL) goto malformed; break; } } if (!got_initial_scid) { reason = TP_REASON_REQUIRED("INITIAL_SCID"); goto malformed; } if (!ch->is_server) { if (!got_orig_dcid) { reason = TP_REASON_REQUIRED("ORIG_DCID"); goto malformed; } if (ch->doing_retry && !got_retry_scid) { reason = TP_REASON_REQUIRED("RETRY_SCID"); goto malformed; } } ch->got_remote_transport_params = 1; if (got_initial_max_data \|\| got_initial_max_stream_data_bidi_remote \|\| got_initial_max_streams_bidi \|\| got_initial_max_streams_uni) / * If FC credit was bumped, we may now be able to send. Update all * streams. / ossl_quic_stream_map_visit(&ch->qsm, do_update, ch); / If we are a server, we now generate our own transport parameters. / if (ch->is_server && !ch_generate_transport_params(ch)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "internal error"); return 0; } return 1; malformed: ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_TRANSPORT_PARAMETER_ERROR, 0, reason); return 0; } / * Called when we want to generate transport parameters. This is called * immediately at instantiation time for a client and after we receive the * client's transport parameters for a server. / static int ch_generate_transport_params(QUIC_CHANNEL ch) { int ok = 0; BUF_MEM buf_mem = NULL; WPACKET wpkt; int wpkt_valid = 0; size_t buf_len = 0; if (ch->local_transport_params != NULL) goto err; if ((buf_mem = BUF_MEM_new()) == NULL) goto err; if (!WPACKET_init(&wpkt, buf_mem)) goto err; wpkt_valid = 1; if (ossl_quic_wire_encode_transport_param_bytes(&wpkt, QUIC_TPARAM_DISABLE_ACTIVE_MIGRATION, NULL, 0) == NULL) goto err; if (ch->is_server) { if (!ossl_quic_wire_encode_transport_param_cid(&wpkt, QUIC_TPARAM_ORIG_DCID, &ch->init_dcid)) goto err; if (!ossl_quic_wire_encode_transport_param_cid(&wpkt, QUIC_TPARAM_INITIAL_SCID, &ch->cur_local_cid)) goto err; } else { / Client always uses an empty SCID. / if (ossl_quic_wire_encode_transport_param_bytes(&wpkt, QUIC_TPARAM_INITIAL_SCID, NULL, 0) == NULL) goto err; } if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_IDLE_TIMEOUT, ch->max_idle_timeout)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_UDP_PAYLOAD_SIZE, QUIC_MIN_INITIAL_DGRAM_LEN)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_ACTIVE_CONN_ID_LIMIT, QUIC_MIN_ACTIVE_CONN_ID_LIMIT)) goto err; if (ch->tx_max_ack_delay != QUIC_DEFAULT_MAX_ACK_DELAY && !ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_ACK_DELAY, ch->tx_max_ack_delay)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_DATA, ossl_quic_rxfc_get_cwm(&ch->conn_rxfc))) goto err; / Send the default CWM for a new RXFC. / if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL, ch->tx_init_max_stream_data_bidi_local)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE, ch->tx_init_max_stream_data_bidi_remote)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_UNI, ch->tx_init_max_stream_data_uni)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAMS_BIDI, ossl_quic_rxfc_get_cwm(&ch->max_streams_bidi_rxfc))) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAMS_UNI, ossl_quic_rxfc_get_cwm(&ch->max_streams_uni_rxfc))) goto err; if (!WPACKET_finish(&wpkt)) goto err; wpkt_valid = 0; if (!WPACKET_get_total_written(&wpkt, &buf_len)) goto err; ch->local_transport_params = (unsigned char )buf_mem->data; buf_mem->data = NULL; if (!ossl_quic_tls_set_transport_params(ch->qtls, ch->local_transport_params, buf_len)) goto err; ok = 1; err: if (wpkt_valid) WPACKET_cleanup(&wpkt); BUF_MEM_free(buf_mem); return ok; } /* * QUIC Channel: Ticker-Mutator * ============================ / / * The central ticker function called by the reactor. This does everything, or * at least everything network I/O related. Best effort - not allowed to fail * "loudly". / void ossl_quic_channel_subtick(QUIC_CHANNEL ch, QUIC_TICK_RESULT res, uint32_t flags) { OSSL_TIME now, deadline; int channel_only = (flags & QUIC_REACTOR_TICK_FLAG_CHANNEL_ONLY) != 0; / * When we tick the QUIC connection, we do everything we need to do * periodically. Network I/O handling will already have been performed * as necessary by the QUIC port. Thus, in order, we: * * - handle any packets the DEMUX has queued up for us; * - handle any timer events which are due to fire (ACKM, etc.); * - generate any packets which need to be sent; * - determine the time at which we should next be ticked. / / If we are in the TERMINATED state, there is nothing to do. / if (ossl_quic_channel_is_terminated(ch)) { res->net_read_desired = 0; res->net_write_desired = 0; res->tick_deadline = ossl_time_infinite(); return; } / * If we are in the TERMINATING state, check if the terminating timer has * expired. / if (ossl_quic_channel_is_terminating(ch)) { now = get_time(ch); if (ossl_time_compare(now, ch->terminate_deadline) >= 0) { ch_on_terminating_timeout(ch); res->net_read_desired = 0; res->net_write_desired = 0; res->tick_deadline = ossl_time_infinite(); return; / abort normal processing, nothing to do / } } if (!ch->port->engine->inhibit_tick) { / Handle RXKU timeouts. / ch_rxku_tick(ch); do { / Process queued incoming packets. / ch->did_tls_tick = 0; ch->have_new_rx_secret = 0; ch_rx(ch, channel_only); / * Allow the handshake layer to check for any new incoming data and * generate new outgoing data. / if (!ch->did_tls_tick) ch_tick_tls(ch, channel_only); / * If the handshake layer gave us a new secret, we need to do RX * again because packets that were not previously processable and * were deferred might now be processable. * * TODO(QUIC FUTURE): Consider handling this in the yield_secret callback. / } while (ch->have_new_rx_secret); } / * Handle any timer events which are due to fire; namely, the loss * detection deadline and the idle timeout. * * ACKM ACK generation deadline is polled by TXP, so we don't need to * handle it here. / now = get_time(ch); if (ossl_time_compare(now, ch->idle_deadline) >= 0) { / * Idle timeout differs from normal protocol violation because we do * not send a CONN_CLOSE frame; go straight to TERMINATED. / if (!ch->port->engine->inhibit_tick) ch_on_idle_timeout(ch); res->net_read_desired = 0; res->net_write_desired = 0; res->tick_deadline = ossl_time_infinite(); return; } if (!ch->port->engine->inhibit_tick) { deadline = ossl_ackm_get_loss_detection_deadline(ch->ackm); if (!ossl_time_is_zero(deadline) && ossl_time_compare(now, deadline) >= 0) ossl_ackm_on_timeout(ch->ackm); / If a ping is due, inform TXP. / if (ossl_time_compare(now, ch->ping_deadline) >= 0) { int pn_space = ossl_quic_enc_level_to_pn_space(ch->tx_enc_level); ossl_quic_tx_packetiser_schedule_ack_eliciting(ch->txp, pn_space); / * If we have no CC budget at this time we cannot process the above * PING request immediately. In any case we have scheduled the * request so bump the ping deadline. If we don't do this we will * busy-loop endlessly as the above deadline comparison condition * will still be met. / ch_update_ping_deadline(ch); } / Queue any data to be sent for transmission. / ch_tx(ch); / Do stream GC. / ossl_quic_stream_map_gc(&ch->qsm); } / Determine the time at which we should next be ticked. / res->tick_deadline = ch_determine_next_tick_deadline(ch); / * Always process network input unless we are now terminated. Although we * had not terminated at the beginning of this tick, network errors in * ch_tx() may have caused us to transition to the Terminated state. / res->net_read_desired = !ossl_quic_channel_is_terminated(ch); / We want to write to the network if we have any data in our TX queue. / res->net_write_desired = (!ossl_quic_channel_is_terminated(ch) && ossl_qtx_get_queue_len_datagrams(ch->qtx) > 0); } static int ch_tick_tls(QUIC_CHANNEL ch, int channel_only) { uint64_t error_code; const char error_msg; ERR_STATE error_state = NULL; if (channel_only) return 1; ch->did_tls_tick = 1; ossl_quic_tls_tick(ch->qtls); if (ossl_quic_tls_get_error(ch->qtls, &error_code, &error_msg, &error_state)) { ossl_quic_channel_raise_protocol_error_state(ch, error_code, 0, error_msg, error_state); return 0; } return 1; } /* Check incoming forged packet limit and terminate connection if needed. / static void ch_rx_check_forged_pkt_limit(QUIC_CHANNEL ch) { uint32_t enc_level; uint64_t limit = UINT64_MAX, l; for (enc_level = QUIC_ENC_LEVEL_INITIAL; enc_level < QUIC_ENC_LEVEL_NUM; ++enc_level) { /* * Different ELs can have different AEADs which can in turn impose * different limits, so use the lowest value of any currently valid EL. / if ((ch->el_discarded & (1U << enc_level)) != 0) continue; if (enc_level > ch->rx_enc_level) break; l = ossl_qrx_get_max_forged_pkt_count(ch->qrx, enc_level); if (l < limit) limit = l; } if (ossl_qrx_get_cur_forged_pkt_count(ch->qrx) < limit) return; ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_AEAD_LIMIT_REACHED, 0, "forgery limit"); } / Process queued incoming packets and handle frames, if any. / static int ch_rx(QUIC_CHANNEL ch, int channel_only) { int handled_any = 0; const int closing = ossl_quic_channel_is_closing(ch); if (!ch->is_server && !ch->have_sent_any_pkt) /* * We have not sent anything yet, therefore there is no need to check * for incoming data. / return 1; for (;;) { assert(ch->qrx_pkt == NULL); if (!ossl_qrx_read_pkt(ch->qrx, &ch->qrx_pkt)) break; / Track the amount of data received while in the closing state / if (closing) ossl_quic_tx_packetiser_record_received_closing_bytes( ch->txp, ch->qrx_pkt->hdr->len); if (!handled_any) { ch_update_idle(ch); ch_update_ping_deadline(ch); } ch_rx_handle_packet(ch, channel_only); / best effort / / * Regardless of the outcome of frame handling, unref the packet. * This will free the packet unless something added another * reference to it during frame processing. / ossl_qrx_pkt_release(ch->qrx_pkt); ch->qrx_pkt = NULL; ch->have_sent_ack_eliciting_since_rx = 0; handled_any = 1; } ch_rx_check_forged_pkt_limit(ch); / * When in TERMINATING - CLOSING, generate a CONN_CLOSE frame whenever we * process one or more incoming packets. / if (handled_any && closing) ch->conn_close_queued = 1; return 1; } static int bio_addr_eq(const BIO_ADDR a, const BIO_ADDR b) { if (BIO_ADDR_family(a) != BIO_ADDR_family(b)) return 0; switch (BIO_ADDR_family(a)) { case AF_INET: return !memcmp(&a->s_in.sin_addr, &b->s_in.sin_addr, sizeof(a->s_in.sin_addr)) && a->s_in.sin_port == b->s_in.sin_port; #if OPENSSL_USE_IPV6 case AF_INET6: return !memcmp(&a->s_in6.sin6_addr, &b->s_in6.sin6_addr, sizeof(a->s_in6.sin6_addr)) && a->s_in6.sin6_port == b->s_in6.sin6_port; #endif default: return 0; / not supported / } return 1; } / Handles the packet currently in ch->qrx_pkt->hdr. / static void ch_rx_handle_packet(QUIC_CHANNEL ch, int channel_only) { uint32_t enc_level; int old_have_processed_any_pkt = ch->have_processed_any_pkt; assert(ch->qrx_pkt != NULL); /* * RFC 9000 s. 10.2.1 Closing Connection State: * An endpoint that is closing is not required to process any * received frame. / if (!ossl_quic_channel_is_active(ch)) return; if (ossl_quic_pkt_type_is_encrypted(ch->qrx_pkt->hdr->type)) { if (!ch->have_received_enc_pkt) { ch->cur_remote_dcid = ch->init_scid = ch->qrx_pkt->hdr->src_conn_id; ch->have_received_enc_pkt = 1; / * We change to using the SCID in the first Initial packet as the * DCID. / ossl_quic_tx_packetiser_set_cur_dcid(ch->txp, &ch->init_scid); } enc_level = ossl_quic_pkt_type_to_enc_level(ch->qrx_pkt->hdr->type); if ((ch->el_discarded & (1U << enc_level)) != 0) / Do not process packets from ELs we have already discarded. / return; } / * RFC 9000 s. 9.6: "If a client receives packets from a new server address * when the client has not initiated a migration to that address, the client * SHOULD discard these packets." * * We need to be a bit careful here as due to the BIO abstraction layer an * application is liable to be weird and lie to us about peer addresses. * Only apply this check if we actually are using a real AF_INET or AF_INET6 * address. / if (!ch->is_server && ch->qrx_pkt->peer != NULL && ( BIO_ADDR_family(&ch->cur_peer_addr) == AF_INET #if OPENSSL_USE_IPV6 \|\| BIO_ADDR_family(&ch->cur_peer_addr) == AF_INET6 #endif ) && !bio_addr_eq(ch->qrx_pkt->peer, &ch->cur_peer_addr)) return; if (!ch->is_server && ch->have_received_enc_pkt && ossl_quic_pkt_type_has_scid(ch->qrx_pkt->hdr->type)) { / * RFC 9000 s. 7.2: "Once a client has received a valid Initial packet * from the server, it MUST discard any subsequent packet it receives on * that connection with a different SCID." / if (!ossl_quic_conn_id_eq(&ch->qrx_pkt->hdr->src_conn_id, &ch->init_scid)) return; } if (ossl_quic_pkt_type_has_version(ch->qrx_pkt->hdr->type) && ch->qrx_pkt->hdr->version != QUIC_VERSION_1) / * RFC 9000 s. 5.2.1: If a client receives a packet that uses a * different version than it initially selected, it MUST discard the * packet. We only ever use v1, so require it. / return; ch->have_processed_any_pkt = 1; / * RFC 9000 s. 17.2: "An endpoint MUST treat receipt of a packet that has a * non-zero value for [the reserved bits] after removing both packet and * header protection as a connection error of type PROTOCOL_VIOLATION." / if (ossl_quic_pkt_type_is_encrypted(ch->qrx_pkt->hdr->type) && ch->qrx_pkt->hdr->reserved != 0) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "packet header reserved bits"); return; } / Handle incoming packet. / switch (ch->qrx_pkt->hdr->type) { case QUIC_PKT_TYPE_RETRY: if (ch->doing_retry \|\| ch->is_server) / * It is not allowed to ask a client to do a retry more than * once. Clients may not send retries. / return; / * RFC 9000 s 17.2.5.2: After the client has received and processed an * Initial or Retry packet from the server, it MUST discard any * subsequent Retry packets that it receives. / if (ch->have_received_enc_pkt) return; if (ch->qrx_pkt->hdr->len <= QUIC_RETRY_INTEGRITY_TAG_LEN) / Packets with zero-length Retry Tokens are invalid. / return; / * TODO(QUIC FUTURE): Theoretically this should probably be in the QRX. * However because validation is dependent on context (namely the * client's initial DCID) we can't do this cleanly. In the future we * should probably add a callback to the QRX to let it call us (via * the DEMUX) and ask us about the correct original DCID, rather * than allow the QRX to emit a potentially malformed packet to the * upper layers. However, special casing this will do for now. / if (!ossl_quic_validate_retry_integrity_tag(ch->port->engine->libctx, ch->port->engine->propq, ch->qrx_pkt->hdr, &ch->init_dcid)) / Malformed retry packet, ignore. / return; if (!ch_retry(ch, ch->qrx_pkt->hdr->data, ch->qrx_pkt->hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN, &ch->qrx_pkt->hdr->src_conn_id)) ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "handling retry packet"); break; case QUIC_PKT_TYPE_0RTT: if (!ch->is_server) / Clients should never receive 0-RTT packets. / return; / * TODO(QUIC 0RTT): Implement 0-RTT on the server side. We currently * do not need to implement this as a client can only do 0-RTT if we * have given it permission to in a previous session. / break; case QUIC_PKT_TYPE_INITIAL: case QUIC_PKT_TYPE_HANDSHAKE: case QUIC_PKT_TYPE_1RTT: if (ch->is_server && ch->qrx_pkt->hdr->type == QUIC_PKT_TYPE_HANDSHAKE) / * We automatically drop INITIAL EL keys when first successfully * decrypting a HANDSHAKE packet, as per the RFC. / ch_discard_el(ch, QUIC_ENC_LEVEL_INITIAL); if (ch->rxku_in_progress && ch->qrx_pkt->hdr->type == QUIC_PKT_TYPE_1RTT && ch->qrx_pkt->pn >= ch->rxku_trigger_pn && ch->qrx_pkt->key_epoch < ossl_qrx_get_key_epoch(ch->qrx)) { / * RFC 9001 s. 6.4: Packets with higher packet numbers MUST be * protected with either the same or newer packet protection keys * than packets with lower packet numbers. An endpoint that * successfully removes protection with old keys when newer keys * were used for packets with lower packet numbers MUST treat this * as a connection error of type KEY_UPDATE_ERROR. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_KEY_UPDATE_ERROR, 0, "new packet with old keys"); break; } if (!ch->is_server && ch->qrx_pkt->hdr->type == QUIC_PKT_TYPE_INITIAL && ch->qrx_pkt->hdr->token_len > 0) { / * RFC 9000 s. 17.2.2: Clients that receive an Initial packet with a * non-zero Token Length field MUST either discard the packet or * generate a connection error of type PROTOCOL_VIOLATION. * * TODO(QUIC FUTURE): consider the implications of RFC 9000 s. 10.2.3 * Immediate Close during the Handshake: * However, at the cost of reducing feedback about * errors for legitimate peers, some forms of denial of * service can be made more difficult for an attacker * if endpoints discard illegal packets rather than * terminating a connection with CONNECTION_CLOSE. For * this reason, endpoints MAY discard packets rather * than immediately close if errors are detected in * packets that lack authentication. * I.e. should we drop this packet instead of closing the connection? / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "client received initial token"); break; } / This packet contains frames, pass to the RXDP. / ossl_quic_handle_frames(ch, ch->qrx_pkt); / best effort / if (ch->did_crypto_frame) ch_tick_tls(ch, channel_only); break; case QUIC_PKT_TYPE_VERSION_NEG: / * "A client MUST discard any Version Negotiation packet if it has * received and successfully processed any other packet." / if (!old_have_processed_any_pkt) ch_rx_handle_version_neg(ch, ch->qrx_pkt); break; default: assert(0); break; } } static void ch_rx_handle_version_neg(QUIC_CHANNEL ch, OSSL_QRX_PKT pkt) { / * We do not support version negotiation at this time. As per RFC 9000 s. * 6.2., we MUST abandon the connection attempt if we receive a Version * Negotiation packet, unless we have already successfully processed another * incoming packet, or the packet lists the QUIC version we want to use. / PACKET vpkt; unsigned long v; if (!PACKET_buf_init(&vpkt, pkt->hdr->data, pkt->hdr->len)) return; while (PACKET_remaining(&vpkt) > 0) { if (!PACKET_get_net_4(&vpkt, &v)) break; if ((uint32_t)v == QUIC_VERSION_1) return; } / No match, this is a failure case. / ch_raise_version_neg_failure(ch); } static void ch_raise_version_neg_failure(QUIC_CHANNEL ch) { QUIC_TERMINATE_CAUSE tcause = {0}; tcause.error_code = QUIC_ERR_CONNECTION_REFUSED; tcause.reason = "version negotiation failure"; tcause.reason_len = strlen(tcause.reason); /* * Skip TERMINATING state; this is not considered a protocol error and we do * not send CONNECTION_CLOSE. / ch_start_terminating(ch, &tcause, 1); } / Try to generate packets and if possible, flush them to the network. / static int ch_tx(QUIC_CHANNEL ch) { QUIC_TXP_STATUS status; int res; /* * RFC 9000 s. 10.2.2: Draining Connection State: * While otherwise identical to the closing state, an endpoint * in the draining state MUST NOT send any packets. * and: * An endpoint MUST NOT send further packets. / if (ossl_quic_channel_is_draining(ch)) return 0; if (ossl_quic_channel_is_closing(ch)) { / * While closing, only send CONN_CLOSE if we've received more traffic * from the peer. Once we tell the TXP to generate CONN_CLOSE, all * future calls to it generate CONN_CLOSE frames, so otherwise we would * just constantly generate CONN_CLOSE frames. * * Confirming to RFC 9000 s. 10.2.1 Closing Connection State: * An endpoint SHOULD limit the rate at which it generates * packets in the closing state. / if (!ch->conn_close_queued) return 0; ch->conn_close_queued = 0; } / Do TXKU if we need to. / ch_maybe_trigger_spontaneous_txku(ch); ch->rxku_pending_confirm_done = 0; / Loop until we stop generating packets to send / do { / * Send packet, if we need to. Best effort. The TXP consults the CC and * applies any limitations imposed by it, so we don't need to do it here. * * Best effort. In particular if TXP fails for some reason we should * still flush any queued packets which we already generated. / res = ossl_quic_tx_packetiser_generate(ch->txp, &status); if (status.sent_pkt > 0) { ch->have_sent_any_pkt = 1; / Packet(s) were sent / ch->port->have_sent_any_pkt = 1; / * RFC 9000 s. 10.1. 'An endpoint also restarts its idle timer when * sending an ack-eliciting packet if no other ack-eliciting packets * have been sent since last receiving and processing a packet.' / if (status.sent_ack_eliciting && !ch->have_sent_ack_eliciting_since_rx) { ch_update_idle(ch); ch->have_sent_ack_eliciting_since_rx = 1; } if (!ch->is_server && status.sent_handshake) / * RFC 9001 s. 4.9.1: A client MUST discard Initial keys when it * first sends a Handshake packet. / ch_discard_el(ch, QUIC_ENC_LEVEL_INITIAL); if (ch->rxku_pending_confirm_done) ch->rxku_pending_confirm = 0; ch_update_ping_deadline(ch); } if (!res) { / * One case where TXP can fail is if we reach a TX PN of 2*62 - 1. As per RFC 9000 s. 12.3, if this happens we MUST close the * connection without sending a CONNECTION_CLOSE frame. This is * actually handled as an emergent consequence of our design, as the * TX packetiser will never transmit another packet when the TX PN * reaches the limit. * * Calling the below function terminates the connection; its attempt * to schedule a CONNECTION_CLOSE frame will not actually cause a * packet to be transmitted for this reason. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "internal error (txp generate)"); break; } } while (status.sent_pkt > 0); / Flush packets to network. / switch (ossl_qtx_flush_net(ch->qtx)) { case QTX_FLUSH_NET_RES_OK: case QTX_FLUSH_NET_RES_TRANSIENT_FAIL: / Best effort, done for now. / break; case QTX_FLUSH_NET_RES_PERMANENT_FAIL: default: / Permanent underlying network BIO, start terminating. / ossl_quic_port_raise_net_error(ch->port, ch); break; } return 1; } / Determine next tick deadline. / static OSSL_TIME ch_determine_next_tick_deadline(QUIC_CHANNEL ch) { OSSL_TIME deadline; int i; if (ossl_quic_channel_is_terminated(ch)) return ossl_time_infinite(); deadline = ossl_ackm_get_loss_detection_deadline(ch->ackm); if (ossl_time_is_zero(deadline)) deadline = ossl_time_infinite(); /* * Check the ack deadline for all enc_levels that are actually provisioned. * ACKs aren't restricted by CC. / for (i = 0; i < QUIC_ENC_LEVEL_NUM; i++) { if (ossl_qtx_is_enc_level_provisioned(ch->qtx, i)) { deadline = ossl_time_min(deadline, ossl_ackm_get_ack_deadline(ch->ackm, ossl_quic_enc_level_to_pn_space(i))); } } / * When do we need to send an ACK-eliciting packet to reset the idle * deadline timer for the peer? / if (!ossl_time_is_infinite(ch->ping_deadline)) deadline = ossl_time_min(deadline, ch->ping_deadline); / Apply TXP wakeup deadline. / deadline = ossl_time_min(deadline, ossl_quic_tx_packetiser_get_deadline(ch->txp)); / Is the terminating timer armed? / if (ossl_quic_channel_is_terminating(ch)) deadline = ossl_time_min(deadline, ch->terminate_deadline); else if (!ossl_time_is_infinite(ch->idle_deadline)) deadline = ossl_time_min(deadline, ch->idle_deadline); / When does the RXKU process complete? / if (ch->rxku_in_progress) deadline = ossl_time_min(deadline, ch->rxku_update_end_deadline); return deadline; } / * QUIC Channel: Lifecycle Events * ============================== / int ossl_quic_channel_start(QUIC_CHANNEL ch) { if (ch->is_server) /* * This is not used by the server. The server moves to active * automatically on receiving an incoming connection. / return 0; if (ch->state != QUIC_CHANNEL_STATE_IDLE) / Calls to connect are idempotent / return 1; / Inform QTX of peer address. / if (!ossl_quic_tx_packetiser_set_peer(ch->txp, &ch->cur_peer_addr)) return 0; / Plug in secrets for the Initial EL. / if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx, ch->port->engine->propq, &ch->init_dcid, ch->is_server, ch->qrx, ch->qtx)) return 0; / Change state. / ch->state = QUIC_CHANNEL_STATE_ACTIVE; ch->doing_proactive_ver_neg = 0; / not currently supported / / Handshake layer: start (e.g. send CH). / if (!ch_tick_tls(ch, /channel_only=/0)) return 0; ossl_quic_reactor_tick(ossl_quic_port_get0_reactor(ch->port), 0); / best effort / return 1; } / Start a locally initiated connection shutdown. / void ossl_quic_channel_local_close(QUIC_CHANNEL ch, uint64_t app_error_code, const char app_reason) { QUIC_TERMINATE_CAUSE tcause = {0}; if (ossl_quic_channel_is_term_any(ch)) return; tcause.app = 1; tcause.error_code = app_error_code; tcause.reason = app_reason; tcause.reason_len = app_reason != NULL ? strlen(app_reason) : 0; ch_start_terminating(ch, &tcause, 0); } static void free_token(const unsigned char buf, size_t buf_len, void arg) { OPENSSL_free((unsigned char )buf); } /* Called when a server asks us to do a retry. / static int ch_retry(QUIC_CHANNEL ch, const unsigned char retry_token, size_t retry_token_len, const QUIC_CONN_ID retry_scid) { void buf; / * RFC 9000 s. 17.2.5.1: "A client MUST discard a Retry packet that contains * a SCID field that is identical to the DCID field of its initial packet." / if (ossl_quic_conn_id_eq(&ch->init_dcid, retry_scid)) return 1; / We change to using the SCID in the Retry packet as the DCID. / if (!ossl_quic_tx_packetiser_set_cur_dcid(ch->txp, retry_scid)) return 0; / * Now we retry. We will release the Retry packet immediately, so copy * the token. / if ((buf = OPENSSL_memdup(retry_token, retry_token_len)) == NULL) return 0; if (!ossl_quic_tx_packetiser_set_initial_token(ch->txp, buf, retry_token_len, free_token, NULL)) { / * This may fail if the token we receive is too big for us to ever be * able to transmit in an outgoing Initial packet. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INVALID_TOKEN, 0, "received oversize token"); OPENSSL_free(buf); return 0; } ch->retry_scid = retry_scid; ch->doing_retry = 1; /* * We need to stimulate the Initial EL to generate the first CRYPTO frame * again. We can do this most cleanly by simply forcing the ACKM to consider * the first Initial packet as lost, which it effectively was as the server * hasn't processed it. This also maintains the desired behaviour with e.g. * PNs not resetting and so on. * * The PN we used initially is always zero, because QUIC does not allow * repeated retries. / if (!ossl_ackm_mark_packet_pseudo_lost(ch->ackm, QUIC_PN_SPACE_INITIAL, /PN=/0)) return 0; / * Plug in new secrets for the Initial EL. This is the only time we change * the secrets for an EL after we already provisioned it. / if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx, ch->port->engine->propq, &ch->retry_scid, /is_server=/0, ch->qrx, ch->qtx)) return 0; return 1; } / Called when an EL is to be discarded. / static int ch_discard_el(QUIC_CHANNEL ch, uint32_t enc_level) { if (!ossl_assert(enc_level < QUIC_ENC_LEVEL_1RTT)) return 0; if ((ch->el_discarded & (1U << enc_level)) != 0) /* Already done. / return 1; / Best effort for all of these. / ossl_quic_tx_packetiser_discard_enc_level(ch->txp, enc_level); ossl_qrx_discard_enc_level(ch->qrx, enc_level); ossl_qtx_discard_enc_level(ch->qtx, enc_level); if (enc_level != QUIC_ENC_LEVEL_0RTT) { uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level); ossl_ackm_on_pkt_space_discarded(ch->ackm, pn_space); / We should still have crypto streams at this point. / if (!ossl_assert(ch->crypto_send[pn_space] != NULL) \|\| !ossl_assert(ch->crypto_recv[pn_space] != NULL)) return 0; / Get rid of the crypto stream state for the EL. / ossl_quic_sstream_free(ch->crypto_send[pn_space]); ch->crypto_send[pn_space] = NULL; ossl_quic_rstream_free(ch->crypto_recv[pn_space]); ch->crypto_recv[pn_space] = NULL; } ch->el_discarded \|= (1U << enc_level); return 1; } / Intended to be called by the RXDP. / int ossl_quic_channel_on_handshake_confirmed(QUIC_CHANNEL ch) { if (ch->handshake_confirmed) return 1; if (!ch->handshake_complete) { /* * Does not make sense for handshake to be confirmed before it is * completed. / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, "handshake cannot be confirmed " "before it is completed"); return 0; } ch_discard_el(ch, QUIC_ENC_LEVEL_HANDSHAKE); ch->handshake_confirmed = 1; ossl_ackm_on_handshake_confirmed(ch->ackm); return 1; } / * Master function used when we want to start tearing down a connection: * * - If the connection is still IDLE we can go straight to TERMINATED; * * - If we are already TERMINATED this is a no-op. * * - If we are TERMINATING - CLOSING and we have now got a CONNECTION_CLOSE * from the peer (tcause->remote == 1), we move to TERMINATING - DRAINING. * * - If we are TERMINATING - DRAINING, we remain here until the terminating * timer expires. * * - Otherwise, we are in ACTIVE and move to TERMINATING - CLOSING. * if we caused the termination (e.g. we have sent a CONNECTION_CLOSE). Note * that we are considered to have caused a termination if we sent the first * CONNECTION_CLOSE frame, even if it is caused by a peer protocol * violation. If the peer sent the first CONNECTION_CLOSE frame, we move to * TERMINATING - DRAINING. * * We record the termination cause structure passed on the first call only. * Any successive calls have their termination cause data discarded; * once we start sending a CONNECTION_CLOSE frame, we don't change the details * in it. * * This conforms to RFC 9000 s. 10.2.1: Closing Connection State: * To minimize the state that an endpoint maintains for a closing * connection, endpoints MAY send the exact same packet in response * to any received packet. * * We don't drop any connection state (specifically packet protection keys) * even though we are permitted to. This conforms to RFC 9000 s. 10.2.1: * Closing Connection State: * An endpoint MAY retain packet protection keys for incoming * packets to allow it to read and process a CONNECTION_CLOSE frame. * * Note that we do not conform to these two from the same section: * An endpoint's selected connection ID and the QUIC version * are sufficient information to identify packets for a closing * connection; the endpoint MAY discard all other connection state. * and: * An endpoint MAY drop packet protection keys when entering the * closing state and send a packet containing a CONNECTION_CLOSE * frame in response to any UDP datagram that is received. / static void copy_tcause(QUIC_TERMINATE_CAUSE dst, const QUIC_TERMINATE_CAUSE src) { dst->error_code = src->error_code; dst->frame_type = src->frame_type; dst->app = src->app; dst->remote = src->remote; dst->reason = NULL; dst->reason_len = 0; if (src->reason != NULL && src->reason_len > 0) { size_t l = src->reason_len; char r; if (l >= SIZE_MAX) --l; /* * If this fails, dst->reason becomes NULL and we simply do not use a * reason. This ensures termination is infallible. / dst->reason = r = OPENSSL_memdup(src->reason, l + 1); if (r == NULL) return; r[l] = '\0'; dst->reason_len = l; } } static void ch_start_terminating(QUIC_CHANNEL ch, const QUIC_TERMINATE_CAUSE tcause, int force_immediate) { / No point sending anything if we haven't sent anything yet. / if (!ch->have_sent_any_pkt) force_immediate = 1; switch (ch->state) { default: case QUIC_CHANNEL_STATE_IDLE: copy_tcause(&ch->terminate_cause, tcause); ch_on_terminating_timeout(ch); break; case QUIC_CHANNEL_STATE_ACTIVE: copy_tcause(&ch->terminate_cause, tcause); if (!force_immediate) { ch->state = tcause->remote ? QUIC_CHANNEL_STATE_TERMINATING_DRAINING : QUIC_CHANNEL_STATE_TERMINATING_CLOSING; / * RFC 9000 s. 10.2 Immediate Close * These states SHOULD persist for at least three times * the current PTO interval as defined in [QUIC-RECOVERY]. / ch->terminate_deadline = ossl_time_add(get_time(ch), ossl_time_multiply(ossl_ackm_get_pto_duration(ch->ackm), 3)); if (!tcause->remote) { OSSL_QUIC_FRAME_CONN_CLOSE f = {0}; / best effort / f.error_code = ch->terminate_cause.error_code; f.frame_type = ch->terminate_cause.frame_type; f.is_app = ch->terminate_cause.app; f.reason = (char )ch->terminate_cause.reason; f.reason_len = ch->terminate_cause.reason_len; ossl_quic_tx_packetiser_schedule_conn_close(ch->txp, &f); /* * RFC 9000 s. 10.2.2 Draining Connection State: * An endpoint that receives a CONNECTION_CLOSE frame MAY * send a single packet containing a CONNECTION_CLOSE * frame before entering the draining state, using a * NO_ERROR code if appropriate / ch->conn_close_queued = 1; } } else { ch_on_terminating_timeout(ch); } break; case QUIC_CHANNEL_STATE_TERMINATING_CLOSING: if (force_immediate) ch_on_terminating_timeout(ch); else if (tcause->remote) / * RFC 9000 s. 10.2.2 Draining Connection State: * An endpoint MAY enter the draining state from the * closing state if it receives a CONNECTION_CLOSE frame, * which indicates that the peer is also closing or draining. / ch->state = QUIC_CHANNEL_STATE_TERMINATING_DRAINING; break; case QUIC_CHANNEL_STATE_TERMINATING_DRAINING: / * Other than in the force-immediate case, we remain here until the * timeout expires. / if (force_immediate) ch_on_terminating_timeout(ch); break; case QUIC_CHANNEL_STATE_TERMINATED: / No-op. / break; } } / For RXDP use. / void ossl_quic_channel_on_remote_conn_close(QUIC_CHANNEL ch, OSSL_QUIC_FRAME_CONN_CLOSE f) { QUIC_TERMINATE_CAUSE tcause = {0}; if (!ossl_quic_channel_is_active(ch)) return; tcause.remote = 1; tcause.app = f->is_app; tcause.error_code = f->error_code; tcause.frame_type = f->frame_type; tcause.reason = f->reason; tcause.reason_len = f->reason_len; ch_start_terminating(ch, &tcause, 0); } static void free_frame_data(unsigned char buf, size_t buf_len, void arg) { OPENSSL_free(buf); } static int ch_enqueue_retire_conn_id(QUIC_CHANNEL ch, uint64_t seq_num) { BUF_MEM buf_mem = NULL; WPACKET wpkt; size_t l; ossl_quic_srtm_remove(ch->srtm, ch, seq_num); if ((buf_mem = BUF_MEM_new()) == NULL) goto err; if (!WPACKET_init(&wpkt, buf_mem)) goto err; if (!ossl_quic_wire_encode_frame_retire_conn_id(&wpkt, seq_num)) { WPACKET_cleanup(&wpkt); goto err; } WPACKET_finish(&wpkt); if (!WPACKET_get_total_written(&wpkt, &l)) goto err; if (ossl_quic_cfq_add_frame(ch->cfq, 1, QUIC_PN_SPACE_APP, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, 0, (unsigned char )buf_mem->data, l, free_frame_data, NULL) == NULL) goto err; buf_mem->data = NULL; BUF_MEM_free(buf_mem); return 1; err: ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "internal error enqueueing retire conn id"); BUF_MEM_free(buf_mem); return 0; } void ossl_quic_channel_on_new_conn_id(QUIC_CHANNEL ch, OSSL_QUIC_FRAME_NEW_CONN_ID f) { uint64_t new_remote_seq_num = ch->cur_remote_seq_num; uint64_t new_retire_prior_to = ch->cur_retire_prior_to; if (!ossl_quic_channel_is_active(ch)) return; /* We allow only two active connection ids; first check some constraints / if (ch->cur_remote_dcid.id_len == 0) { / Changing from 0 length connection id is disallowed / ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "zero length connection id in use"); return; } if (f->seq_num > new_remote_seq_num) new_remote_seq_num = f->seq_num; if (f->retire_prior_to > new_retire_prior_to) new_retire_prior_to = f->retire_prior_to; / * RFC 9000-5.1.1: An endpoint MUST NOT provide more connection IDs * than the peer's limit. * * After processing a NEW_CONNECTION_ID frame and adding and retiring * active connection IDs, if the number of active connection IDs exceeds * the value advertised in its active_connection_id_limit transport * parameter, an endpoint MUST close the connection with an error of * type CONNECTION_ID_LIMIT_ERROR. / if (new_remote_seq_num - new_retire_prior_to > 1) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CONNECTION_ID_LIMIT_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "active_connection_id limit violated"); return; } / * RFC 9000-5.1.1: An endpoint MAY send connection IDs that temporarily * exceed a peer's limit if the NEW_CONNECTION_ID frame also requires * the retirement of any excess, by including a sufficiently large * value in the Retire Prior To field. * * RFC 9000-5.1.2: An endpoint SHOULD allow for sending and tracking * a number of RETIRE_CONNECTION_ID frames of at least twice the value * of the active_connection_id_limit transport parameter. An endpoint * MUST NOT forget a connection ID without retiring it, though it MAY * choose to treat having connection IDs in need of retirement that * exceed this limit as a connection error of type CONNECTION_ID_LIMIT_ERROR. * * We are a little bit more liberal than the minimum mandated. / if (new_retire_prior_to - ch->cur_retire_prior_to > 10) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CONNECTION_ID_LIMIT_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "retiring connection id limit violated"); return; } if (new_remote_seq_num > ch->cur_remote_seq_num) { / Add new stateless reset token / if (!ossl_quic_srtm_add(ch->srtm, ch, new_remote_seq_num, &f->stateless_reset)) { ossl_quic_channel_raise_protocol_error( ch, QUIC_ERR_CONNECTION_ID_LIMIT_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "unable to store stateless reset token"); return; } ch->cur_remote_seq_num = new_remote_seq_num; ch->cur_remote_dcid = f->conn_id; ossl_quic_tx_packetiser_set_cur_dcid(ch->txp, &ch->cur_remote_dcid); } / * RFC 9000-5.1.2: Upon receipt of an increased Retire Prior To * field, the peer MUST stop using the corresponding connection IDs * and retire them with RETIRE_CONNECTION_ID frames before adding the * newly provided connection ID to the set of active connection IDs. / / * Note: RFC 9000 s. 19.15 says: * "An endpoint that receives a NEW_CONNECTION_ID frame with a sequence * number smaller than the Retire Prior To field of a previously received * NEW_CONNECTION_ID frame MUST send a corresponding * RETIRE_CONNECTION_ID frame that retires the newly received connection * ID, unless it has already done so for that sequence number." * * Since we currently always queue RETIRE_CONN_ID frames based on the Retire * Prior To field of a NEW_CONNECTION_ID frame immediately upon receiving * that NEW_CONNECTION_ID frame, by definition this will always be met. * This may change in future when we change our CID handling. / while (new_retire_prior_to > ch->cur_retire_prior_to) { if (!ch_enqueue_retire_conn_id(ch, ch->cur_retire_prior_to)) break; ++ch->cur_retire_prior_to; } } static void ch_save_err_state(QUIC_CHANNEL ch) { if (ch->err_state == NULL) ch->err_state = OSSL_ERR_STATE_new(); if (ch->err_state == NULL) return; OSSL_ERR_STATE_save(ch->err_state); } void ossl_quic_channel_inject(QUIC_CHANNEL ch, QUIC_URXE e) { ossl_qrx_inject_urxe(ch->qrx, e); } void ossl_quic_channel_on_stateless_reset(QUIC_CHANNEL ch) { QUIC_TERMINATE_CAUSE tcause = {0}; tcause.error_code = QUIC_ERR_NO_ERROR; tcause.remote = 1; ch_start_terminating(ch, &tcause, 0); } void ossl_quic_channel_raise_net_error(QUIC_CHANNEL ch) { QUIC_TERMINATE_CAUSE tcause = {0}; if (ch->net_error) return; ch->net_error = 1; tcause.error_code = QUIC_ERR_INTERNAL_ERROR; tcause.reason = "network BIO I/O error"; tcause.reason_len = strlen(tcause.reason); /* * Skip Terminating state and go directly to Terminated, no point trying to * send CONNECTION_CLOSE if we cannot communicate. / ch_start_terminating(ch, &tcause, 1); } int ossl_quic_channel_net_error(QUIC_CHANNEL ch) { return ch->net_error; } void ossl_quic_channel_restore_err_state(QUIC_CHANNEL ch) { if (ch == NULL) return; if (!ossl_quic_port_is_running(ch->port)) ossl_quic_port_restore_err_state(ch->port); else OSSL_ERR_STATE_restore(ch->err_state); } void ossl_quic_channel_raise_protocol_error_loc(QUIC_CHANNEL ch, uint64_t error_code, uint64_t frame_type, const char reason, ERR_STATE err_state, const char src_file, int src_line, const char src_func) { QUIC_TERMINATE_CAUSE tcause = {0}; int err_reason = error_code == QUIC_ERR_INTERNAL_ERROR ? ERR_R_INTERNAL_ERROR : SSL_R_QUIC_PROTOCOL_ERROR; const char err_str = ossl_quic_err_to_string(error_code); const char err_str_pfx = " (", err_str_sfx = ")"; const char ft_str = NULL; const char ft_str_pfx = " (", ft_str_sfx = ")"; if (ch->protocol_error) /* Only the first call to this function matters. / return; if (err_str == NULL) { err_str = ""; err_str_pfx = ""; err_str_sfx = ""; } / * If we were provided an underlying error state, restore it and then append * our ERR on top as a "cover letter" error. / if (err_state != NULL) OSSL_ERR_STATE_restore(err_state); if (frame_type != 0) { ft_str = ossl_quic_frame_type_to_string(frame_type); if (ft_str == NULL) { ft_str = ""; ft_str_pfx = ""; ft_str_sfx = ""; } ERR_raise_data(ERR_LIB_SSL, err_reason, "QUIC error code: 0x%llx%s%s%s " "(triggered by frame type: 0x%llx%s%s%s), reason: \"%s\"", (unsigned long long) error_code, err_str_pfx, err_str, err_str_sfx, (unsigned long long) frame_type, ft_str_pfx, ft_str, ft_str_sfx, reason); } else { ERR_raise_data(ERR_LIB_SSL, err_reason, "QUIC error code: 0x%llx%s%s%s, reason: \"%s\"", (unsigned long long) error_code, err_str_pfx, err_str, err_str_sfx, reason); } if (src_file != NULL) ERR_set_debug(src_file, src_line, src_func); ch_save_err_state(ch); tcause.error_code = error_code; tcause.frame_type = frame_type; tcause.reason = reason; tcause.reason_len = strlen(reason); ch->protocol_error = 1; ch_start_terminating(ch, &tcause, 0); } / * Called once the terminating timer expires, meaning we move from TERMINATING * to TERMINATED. / static void ch_on_terminating_timeout(QUIC_CHANNEL ch) { ch->state = QUIC_CHANNEL_STATE_TERMINATED; } /* * Determines the effective idle timeout duration. This is based on the idle * timeout values that we and our peer signalled in transport parameters * but have some limits applied. / static OSSL_TIME ch_get_effective_idle_timeout_duration(QUIC_CHANNEL ch) { OSSL_TIME pto; if (ch->max_idle_timeout == 0) return ossl_time_infinite(); /* * RFC 9000 s. 10.1: Idle Timeout * To avoid excessively small idle timeout periods, endpoints * MUST increase the idle timeout period to be at least three * times the current Probe Timeout (PTO). This allows for * multiple PTOs to expire, and therefore multiple probes to * be sent and lost, prior to idle timeout. / pto = ossl_ackm_get_pto_duration(ch->ackm); return ossl_time_max(ossl_ms2time(ch->max_idle_timeout), ossl_time_multiply(pto, 3)); } / * Updates our idle deadline. Called when an event happens which should bump the * idle timeout. / static void ch_update_idle(QUIC_CHANNEL ch) { ch->idle_deadline = ossl_time_add(get_time(ch), ch_get_effective_idle_timeout_duration(ch)); } /* * Updates our ping deadline, which determines when we next generate a ping if * we don't have any other ACK-eliciting frames to send. / static void ch_update_ping_deadline(QUIC_CHANNEL ch) { OSSL_TIME max_span, idle_duration; idle_duration = ch_get_effective_idle_timeout_duration(ch); if (ossl_time_is_infinite(idle_duration)) { ch->ping_deadline = ossl_time_infinite(); return; } /* * Maximum amount of time without traffic before we send a PING to keep * the connection open. Usually we use max_idle_timeout/2, but ensure * the period never exceeds the assumed NAT interval to ensure NAT * devices don't have their state time out (RFC 9000 s. 10.1.2). / max_span = ossl_time_divide(idle_duration, 2); max_span = ossl_time_min(max_span, MAX_NAT_INTERVAL); ch->ping_deadline = ossl_time_add(get_time(ch), max_span); } / Called when the idle timeout expires. / static void ch_on_idle_timeout(QUIC_CHANNEL ch) { /* * Idle timeout does not have an error code associated with it because a * CONN_CLOSE is never sent for it. We shouldn't use this data once we reach * TERMINATED anyway. / ch->terminate_cause.app = 0; ch->terminate_cause.error_code = UINT64_MAX; ch->terminate_cause.frame_type = 0; ch->state = QUIC_CHANNEL_STATE_TERMINATED; } / Called when we, as a server, get a new incoming connection. / int ossl_quic_channel_on_new_conn(QUIC_CHANNEL ch, const BIO_ADDR peer, const QUIC_CONN_ID peer_scid, const QUIC_CONN_ID peer_dcid) { if (!ossl_assert(ch->state == QUIC_CHANNEL_STATE_IDLE && ch->is_server)) return 0; / Generate an Initial LCID we will use for the connection. / if (!ossl_quic_lcidm_generate_initial(ch->lcidm, ch, &ch->cur_local_cid)) return 0; / Note our newly learnt peer address and CIDs. / ch->cur_peer_addr = peer; ch->init_dcid = peer_dcid; ch->cur_remote_dcid = peer_scid; /* Inform QTX of peer address. / if (!ossl_quic_tx_packetiser_set_peer(ch->txp, &ch->cur_peer_addr)) return 0; / Inform TXP of desired CIDs. / if (!ossl_quic_tx_packetiser_set_cur_dcid(ch->txp, &ch->cur_remote_dcid)) return 0; if (!ossl_quic_tx_packetiser_set_cur_scid(ch->txp, &ch->cur_local_cid)) return 0; / Plug in secrets for the Initial EL. / if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx, ch->port->engine->propq, &ch->init_dcid, /is_server=/1, ch->qrx, ch->qtx)) return 0; / Register the peer ODCID in the LCIDM. / if (!ossl_quic_lcidm_enrol_odcid(ch->lcidm, ch, &ch->init_dcid)) return 0; / Change state. / ch->state = QUIC_CHANNEL_STATE_ACTIVE; ch->doing_proactive_ver_neg = 0; / not currently supported / return 1; } SSL ossl_quic_channel_get0_ssl(QUIC_CHANNEL ch) { return ch->tls; } static int ch_init_new_stream(QUIC_CHANNEL ch, QUIC_STREAM qs, int can_send, int can_recv) { uint64_t rxfc_wnd; int server_init = ossl_quic_stream_is_server_init(qs); int local_init = (ch->is_server == server_init); int is_uni = !ossl_quic_stream_is_bidi(qs); if (can_send) if ((qs->sstream = ossl_quic_sstream_new(INIT_APP_BUF_LEN)) == NULL) goto err; if (can_recv) if ((qs->rstream = ossl_quic_rstream_new(NULL, NULL, 0)) == NULL) goto err; / TXFC / if (!ossl_quic_txfc_init(&qs->txfc, &ch->conn_txfc)) goto err; if (ch->got_remote_transport_params) { / * If we already got peer TPs we need to apply the initial CWM credit * now. If we didn't already get peer TPs this will be done * automatically for all extant streams when we do. / if (can_send) { uint64_t cwm; if (is_uni) cwm = ch->rx_init_max_stream_data_uni; else if (local_init) cwm = ch->rx_init_max_stream_data_bidi_local; else cwm = ch->rx_init_max_stream_data_bidi_remote; ossl_quic_txfc_bump_cwm(&qs->txfc, cwm); } } / RXFC / if (!can_recv) rxfc_wnd = 0; else if (is_uni) rxfc_wnd = ch->tx_init_max_stream_data_uni; else if (local_init) rxfc_wnd = ch->tx_init_max_stream_data_bidi_local; else rxfc_wnd = ch->tx_init_max_stream_data_bidi_remote; if (!ossl_quic_rxfc_init(&qs->rxfc, &ch->conn_rxfc, rxfc_wnd, DEFAULT_STREAM_RXFC_MAX_WND_MUL rxfc_wnd, get_time, ch)) goto err; return 1; err: ossl_quic_sstream_free(qs->sstream); qs->sstream = NULL; ossl_quic_rstream_free(qs->rstream); qs->rstream = NULL; return 0; } static uint64_t ch_get_local_stream_next_ordinal_ptr(QUIC_CHANNEL ch, int is_uni) { return is_uni ? &ch->next_local_stream_ordinal_uni : &ch->next_local_stream_ordinal_bidi; } int ossl_quic_channel_is_new_local_stream_admissible(QUIC_CHANNEL ch, int is_uni) { uint64_t p_next_ordinal = ch_get_local_stream_next_ordinal_ptr(ch, is_uni); return ossl_quic_stream_map_is_local_allowed_by_stream_limit(&ch->qsm, p_next_ordinal, is_uni); } QUIC_STREAM ossl_quic_channel_new_stream_local(QUIC_CHANNEL ch, int is_uni) { QUIC_STREAM qs; int type; uint64_t stream_id, p_next_ordinal; type = ch->is_server ? QUIC_STREAM_INITIATOR_SERVER : QUIC_STREAM_INITIATOR_CLIENT; p_next_ordinal = ch_get_local_stream_next_ordinal_ptr(ch, is_uni); if (is_uni) type \|= QUIC_STREAM_DIR_UNI; else type \|= QUIC_STREAM_DIR_BIDI; if (p_next_ordinal >= ((uint64_t)1) << 62) return NULL; stream_id = ((p_next_ordinal) << 2) \| type; if ((qs = ossl_quic_stream_map_alloc(&ch->qsm, stream_id, type)) == NULL) return NULL; / Locally-initiated stream, so we always want a send buffer. / if (!ch_init_new_stream(ch, qs, /can_send=/1, /can_recv=/!is_uni)) goto err; ++p_next_ordinal; return qs; err: ossl_quic_stream_map_release(&ch->qsm, qs); return NULL; } QUIC_STREAM ossl_quic_channel_new_stream_remote(QUIC_CHANNEL ch, uint64_t stream_id) { uint64_t peer_role; int is_uni; QUIC_STREAM qs; peer_role = ch->is_server ? QUIC_STREAM_INITIATOR_CLIENT : QUIC_STREAM_INITIATOR_SERVER; if ((stream_id & QUIC_STREAM_INITIATOR_MASK) != peer_role) return NULL; is_uni = ((stream_id & QUIC_STREAM_DIR_MASK) == QUIC_STREAM_DIR_UNI); qs = ossl_quic_stream_map_alloc(&ch->qsm, stream_id, stream_id & (QUIC_STREAM_INITIATOR_MASK \| QUIC_STREAM_DIR_MASK)); if (qs == NULL) return NULL; if (!ch_init_new_stream(ch, qs, /can_send=/!is_uni, /can_recv=/1)) goto err; if (ch->incoming_stream_auto_reject) ossl_quic_channel_reject_stream(ch, qs); else ossl_quic_stream_map_push_accept_queue(&ch->qsm, qs); return qs; err: ossl_quic_stream_map_release(&ch->qsm, qs); return NULL; } void ossl_quic_channel_set_incoming_stream_auto_reject(QUIC_CHANNEL ch, int enable, uint64_t aec) { ch->incoming_stream_auto_reject = (enable != 0); ch->incoming_stream_auto_reject_aec = aec; } void ossl_quic_channel_reject_stream(QUIC_CHANNEL ch, QUIC_STREAM qs) { ossl_quic_stream_map_stop_sending_recv_part(&ch->qsm, qs, ch->incoming_stream_auto_reject_aec); ossl_quic_stream_map_reset_stream_send_part(&ch->qsm, qs, ch->incoming_stream_auto_reject_aec); qs->deleted = 1; ossl_quic_stream_map_update_state(&ch->qsm, qs); } /* Replace local connection ID in TXP and DEMUX for testing purposes. / int ossl_quic_channel_replace_local_cid(QUIC_CHANNEL ch, const QUIC_CONN_ID conn_id) { / Remove the current LCID from the LCIDM. / if (!ossl_quic_lcidm_debug_remove(ch->lcidm, &ch->cur_local_cid)) return 0; ch->cur_local_cid = conn_id; /* Set in the TXP, used only for long header packets. / if (!ossl_quic_tx_packetiser_set_cur_scid(ch->txp, &ch->cur_local_cid)) return 0; / Add the new LCID to the LCIDM. / if (!ossl_quic_lcidm_debug_add(ch->lcidm, ch, &ch->cur_local_cid, 100)) return 0; return 1; } void ossl_quic_channel_set_msg_callback(QUIC_CHANNEL ch, ossl_msg_cb msg_callback, SSL msg_callback_ssl) { ch->msg_callback = msg_callback; ch->msg_callback_ssl = msg_callback_ssl; ossl_qtx_set_msg_callback(ch->qtx, msg_callback, msg_callback_ssl); ossl_quic_tx_packetiser_set_msg_callback(ch->txp, msg_callback, msg_callback_ssl); ossl_qrx_set_msg_callback(ch->qrx, msg_callback, msg_callback_ssl); } void ossl_quic_channel_set_msg_callback_arg(QUIC_CHANNEL ch, void msg_callback_arg) { ch->msg_callback_arg = msg_callback_arg; ossl_qtx_set_msg_callback_arg(ch->qtx, msg_callback_arg); ossl_quic_tx_packetiser_set_msg_callback_arg(ch->txp, msg_callback_arg); ossl_qrx_set_msg_callback_arg(ch->qrx, msg_callback_arg); } void ossl_quic_channel_set_txku_threshold_override(QUIC_CHANNEL ch, uint64_t tx_pkt_threshold) { ch->txku_threshold_override = tx_pkt_threshold; } uint64_t ossl_quic_channel_get_tx_key_epoch(QUIC_CHANNEL ch) { return ossl_qtx_get_key_epoch(ch->qtx); } uint64_t ossl_quic_channel_get_rx_key_epoch(QUIC_CHANNEL ch) { return ossl_qrx_get_key_epoch(ch->qrx); } int ossl_quic_channel_trigger_txku(QUIC_CHANNEL ch) { if (!txku_allowed(ch)) return 0; ch->ku_locally_initiated = 1; ch_trigger_txku(ch); return 1; } int ossl_quic_channel_ping(QUIC_CHANNEL ch) { int pn_space = ossl_quic_enc_level_to_pn_space(ch->tx_enc_level); ossl_quic_tx_packetiser_schedule_ack_eliciting(ch->txp, pn_space); return 1; } uint16_t ossl_quic_channel_get_diag_num_rx_ack(QUIC_CHANNEL ch) { return ch->diag_num_rx_ack; } void ossl_quic_channel_get_diag_local_cid(QUIC_CHANNEL ch, QUIC_CONN_ID cid) { cid = ch->cur_local_cid; }
./openssl/ssl/quic/quic_fifd.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_fifd.h" #include "internal/quic_wire.h" DEFINE_LIST_OF(tx_history, OSSL_ACKM_TX_PKT); int ossl_quic_fifd_init(QUIC_FIFD fifd, QUIC_CFQ cfq, OSSL_ACKM ackm, QUIC_TXPIM txpim, / stream_id is UINT64_MAX for the crypto stream / QUIC_SSTREAM (get_sstream_by_id)(uint64_t stream_id, uint32_t pn_space, void arg), void get_sstream_by_id_arg, / stream_id is UINT64_MAX if not applicable / void (regen_frame)(uint64_t frame_type, uint64_t stream_id, QUIC_TXPIM_PKT pkt, void arg), void regen_frame_arg, void (confirm_frame)(uint64_t frame_type, uint64_t stream_id, QUIC_TXPIM_PKT pkt, void arg), void confirm_frame_arg, void (sstream_updated)(uint64_t stream_id, void arg), void sstream_updated_arg) { if (cfq == NULL \|\| ackm == NULL \|\| txpim == NULL \|\| get_sstream_by_id == NULL \|\| regen_frame == NULL) return 0; fifd->cfq = cfq; fifd->ackm = ackm; fifd->txpim = txpim; fifd->get_sstream_by_id = get_sstream_by_id; fifd->get_sstream_by_id_arg = get_sstream_by_id_arg; fifd->regen_frame = regen_frame; fifd->regen_frame_arg = regen_frame_arg; fifd->confirm_frame = confirm_frame; fifd->confirm_frame_arg = confirm_frame_arg; fifd->sstream_updated = sstream_updated; fifd->sstream_updated_arg = sstream_updated_arg; return 1; } void ossl_quic_fifd_cleanup(QUIC_FIFD fifd) { / No-op. / } static void on_acked(void arg) { QUIC_TXPIM_PKT pkt = arg; QUIC_FIFD fifd = pkt->fifd; const QUIC_TXPIM_CHUNK chunks = ossl_quic_txpim_pkt_get_chunks(pkt); size_t i, num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt); QUIC_SSTREAM sstream; QUIC_CFQ_ITEM cfq_item, cfq_item_next; /* STREAM and CRYPTO stream chunks, FINs and stream FC frames / for (i = 0; i < num_chunks; ++i) { sstream = fifd->get_sstream_by_id(chunks[i].stream_id, pkt->ackm_pkt.pkt_space, fifd->get_sstream_by_id_arg); if (sstream == NULL) continue; if (chunks[i].end >= chunks[i].start) / coverity[check_return]: Best effort - we cannot fail here. / ossl_quic_sstream_mark_acked(sstream, chunks[i].start, chunks[i].end); if (chunks[i].has_fin && chunks[i].stream_id != UINT64_MAX) ossl_quic_sstream_mark_acked_fin(sstream); if (chunks[i].has_stop_sending && chunks[i].stream_id != UINT64_MAX) fifd->confirm_frame(OSSL_QUIC_FRAME_TYPE_STOP_SENDING, chunks[i].stream_id, pkt, fifd->confirm_frame_arg); if (chunks[i].has_reset_stream && chunks[i].stream_id != UINT64_MAX) fifd->confirm_frame(OSSL_QUIC_FRAME_TYPE_RESET_STREAM, chunks[i].stream_id, pkt, fifd->confirm_frame_arg); if (ossl_quic_sstream_is_totally_acked(sstream)) fifd->sstream_updated(chunks[i].stream_id, fifd->sstream_updated_arg); } / GCR / for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) { cfq_item_next = cfq_item->pkt_next; ossl_quic_cfq_release(fifd->cfq, cfq_item); } ossl_quic_txpim_pkt_release(fifd->txpim, pkt); } static void on_lost(void arg) { QUIC_TXPIM_PKT pkt = arg; QUIC_FIFD fifd = pkt->fifd; const QUIC_TXPIM_CHUNK chunks = ossl_quic_txpim_pkt_get_chunks(pkt); size_t i, num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt); QUIC_SSTREAM sstream; QUIC_CFQ_ITEM cfq_item, cfq_item_next; int sstream_updated; /* STREAM and CRYPTO stream chunks, FIN and stream FC frames / for (i = 0; i < num_chunks; ++i) { sstream = fifd->get_sstream_by_id(chunks[i].stream_id, pkt->ackm_pkt.pkt_space, fifd->get_sstream_by_id_arg); if (sstream == NULL) continue; sstream_updated = 0; if (chunks[i].end >= chunks[i].start) { / * Note: If the stream is being reset, we do not need to retransmit * old data as this is pointless. In this case this will be handled * by (sstream == NULL) above as the QSM will free the QUIC_SSTREAM * and our call to get_sstream_by_id above will return NULL. / ossl_quic_sstream_mark_lost(sstream, chunks[i].start, chunks[i].end); sstream_updated = 1; } if (chunks[i].has_fin && chunks[i].stream_id != UINT64_MAX) { ossl_quic_sstream_mark_lost_fin(sstream); sstream_updated = 1; } if (chunks[i].has_stop_sending && chunks[i].stream_id != UINT64_MAX) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_STOP_SENDING, chunks[i].stream_id, pkt, fifd->regen_frame_arg); if (chunks[i].has_reset_stream && chunks[i].stream_id != UINT64_MAX) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_RESET_STREAM, chunks[i].stream_id, pkt, fifd->regen_frame_arg); / * Inform caller that stream needs an FC frame. * * Note: We could track whether an FC frame was sent originally for the * stream to determine if it really needs to be regenerated or not. * However, if loss has occurred, it's probably better to ensure the * peer has up-to-date flow control data for the stream. Given that * these frames are extremely small, we may as well always send it when * handling loss. / fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, chunks[i].stream_id, pkt, fifd->regen_frame_arg); if (sstream_updated && chunks[i].stream_id != UINT64_MAX) fifd->sstream_updated(chunks[i].stream_id, fifd->sstream_updated_arg); } / GCR / for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) { cfq_item_next = cfq_item->pkt_next; ossl_quic_cfq_mark_lost(fifd->cfq, cfq_item, UINT32_MAX); } / Regenerate flag frames / if (pkt->had_handshake_done_frame) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, UINT64_MAX, pkt, fifd->regen_frame_arg); if (pkt->had_max_data_frame) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_DATA, UINT64_MAX, pkt, fifd->regen_frame_arg); if (pkt->had_max_streams_bidi_frame) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI, UINT64_MAX, pkt, fifd->regen_frame_arg); if (pkt->had_max_streams_uni_frame) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI, UINT64_MAX, pkt, fifd->regen_frame_arg); if (pkt->had_ack_frame) / * We always use the ACK_WITH_ECN frame type to represent the ACK frame * type in our callback; we assume it is the caller's job to decide * whether it wants to send ECN data or not. / fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN, UINT64_MAX, pkt, fifd->regen_frame_arg); ossl_quic_txpim_pkt_release(fifd->txpim, pkt); } static void on_discarded(void arg) { QUIC_TXPIM_PKT pkt = arg; QUIC_FIFD fifd = pkt->fifd; QUIC_CFQ_ITEM cfq_item, cfq_item_next; /* * Don't need to do anything to SSTREAMs for STREAM and CRYPTO streams, as * we assume caller will clean them up. / / GCR / for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) { cfq_item_next = cfq_item->pkt_next; ossl_quic_cfq_release(fifd->cfq, cfq_item); } ossl_quic_txpim_pkt_release(fifd->txpim, pkt); } int ossl_quic_fifd_pkt_commit(QUIC_FIFD fifd, QUIC_TXPIM_PKT pkt) { QUIC_CFQ_ITEM cfq_item; const QUIC_TXPIM_CHUNK chunks; size_t i, num_chunks; QUIC_SSTREAM sstream; pkt->fifd = fifd; pkt->ackm_pkt.on_lost = on_lost; pkt->ackm_pkt.on_acked = on_acked; pkt->ackm_pkt.on_discarded = on_discarded; pkt->ackm_pkt.cb_arg = pkt; ossl_list_tx_history_init_elem(&pkt->ackm_pkt); pkt->ackm_pkt.anext = pkt->ackm_pkt.lnext = NULL; /* * Mark the CFQ items which have been added to this packet as having been * transmitted. / for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item->pkt_next) ossl_quic_cfq_mark_tx(fifd->cfq, cfq_item); / * Mark the send stream chunks which have been added to the packet as having * been transmitted. / chunks = ossl_quic_txpim_pkt_get_chunks(pkt); num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt); for (i = 0; i < num_chunks; ++i) { sstream = fifd->get_sstream_by_id(chunks[i].stream_id, pkt->ackm_pkt.pkt_space, fifd->get_sstream_by_id_arg); if (sstream == NULL) continue; if (chunks[i].end >= chunks[i].start && !ossl_quic_sstream_mark_transmitted(sstream, chunks[i].start, chunks[i].end)) return 0; if (chunks[i].has_fin && !ossl_quic_sstream_mark_transmitted_fin(sstream, chunks[i].end + 1)) return 0; } / Inform the ACKM. */ return ossl_ackm_on_tx_packet(fifd->ackm, &pkt->ackm_pkt); }
./openssl/ssl/quic/quic_wire.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/macros.h> #include <openssl/objects.h> #include "internal/quic_ssl.h" #include "internal/quic_vlint.h" #include "internal/quic_wire.h" #include "internal/quic_error.h" OSSL_SAFE_MATH_UNSIGNED(uint64_t, uint64_t) int ossl_quic_frame_ack_contains_pn(const OSSL_QUIC_FRAME_ACK ack, QUIC_PN pn) { size_t i; for (i = 0; i < ack->num_ack_ranges; ++i) if (pn >= ack->ack_ranges[i].start && pn <= ack->ack_ranges[i].end) return 1; return 0; } /* * QUIC Wire Format Encoding * ========================= / int ossl_quic_wire_encode_padding(WPACKET pkt, size_t num_bytes) { /* * PADDING is frame type zero, which as a variable-length integer is * represented as a single zero byte. As an optimisation, just use memset. / return WPACKET_memset(pkt, 0, num_bytes); } static int encode_frame_hdr(WPACKET pkt, uint64_t frame_type) { return WPACKET_quic_write_vlint(pkt, frame_type); } int ossl_quic_wire_encode_frame_ping(WPACKET pkt) { return encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_PING); } int ossl_quic_wire_encode_frame_ack(WPACKET pkt, uint32_t ack_delay_exponent, const OSSL_QUIC_FRAME_ACK ack) { uint64_t frame_type = ack->ecn_present ? OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN : OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN; uint64_t largest_ackd, first_ack_range, ack_delay_enc; uint64_t i, num_ack_ranges = ack->num_ack_ranges; OSSL_TIME delay; if (num_ack_ranges == 0) return 0; delay = ossl_time_divide(ossl_time_divide(ack->delay_time, OSSL_TIME_US), (uint64_t)1 << ack_delay_exponent); ack_delay_enc = ossl_time2ticks(delay); largest_ackd = ack->ack_ranges[0].end; first_ack_range = ack->ack_ranges[0].end - ack->ack_ranges[0].start; if (!encode_frame_hdr(pkt, frame_type) \|\| !WPACKET_quic_write_vlint(pkt, largest_ackd) \|\| !WPACKET_quic_write_vlint(pkt, ack_delay_enc) \|\| !WPACKET_quic_write_vlint(pkt, num_ack_ranges - 1) \|\| !WPACKET_quic_write_vlint(pkt, first_ack_range)) return 0; for (i = 1; i < num_ack_ranges; ++i) { uint64_t gap, range_len; gap = ack->ack_ranges[i - 1].start - ack->ack_ranges[i].end - 2; range_len = ack->ack_ranges[i].end - ack->ack_ranges[i].start; if (!WPACKET_quic_write_vlint(pkt, gap) \|\| !WPACKET_quic_write_vlint(pkt, range_len)) return 0; } if (ack->ecn_present) if (!WPACKET_quic_write_vlint(pkt, ack->ect0) \|\| !WPACKET_quic_write_vlint(pkt, ack->ect1) \|\| !WPACKET_quic_write_vlint(pkt, ack->ecnce)) return 0; return 1; } int ossl_quic_wire_encode_frame_reset_stream(WPACKET pkt, const OSSL_QUIC_FRAME_RESET_STREAM f) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_RESET_STREAM) \|\| !WPACKET_quic_write_vlint(pkt, f->stream_id) \|\| !WPACKET_quic_write_vlint(pkt, f->app_error_code) \|\| !WPACKET_quic_write_vlint(pkt, f->final_size)) return 0; return 1; } int ossl_quic_wire_encode_frame_stop_sending(WPACKET pkt, const OSSL_QUIC_FRAME_STOP_SENDING f) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_STOP_SENDING) \|\| !WPACKET_quic_write_vlint(pkt, f->stream_id) \|\| !WPACKET_quic_write_vlint(pkt, f->app_error_code)) return 0; return 1; } int ossl_quic_wire_encode_frame_crypto_hdr(WPACKET pkt, const OSSL_QUIC_FRAME_CRYPTO f) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_CRYPTO) \|\| !WPACKET_quic_write_vlint(pkt, f->offset) \|\| !WPACKET_quic_write_vlint(pkt, f->len)) return 0; return 1; } size_t ossl_quic_wire_get_encoded_frame_len_crypto_hdr(const OSSL_QUIC_FRAME_CRYPTO f) { size_t a, b, c; a = ossl_quic_vlint_encode_len(OSSL_QUIC_FRAME_TYPE_CRYPTO); b = ossl_quic_vlint_encode_len(f->offset); c = ossl_quic_vlint_encode_len(f->len); if (a == 0 \|\| b == 0 \|\| c == 0) return 0; return a + b + c; } void ossl_quic_wire_encode_frame_crypto(WPACKET pkt, const OSSL_QUIC_FRAME_CRYPTO f) { unsigned char p = NULL; if (!ossl_quic_wire_encode_frame_crypto_hdr(pkt, f) \|\| f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? / \|\| !WPACKET_allocate_bytes(pkt, (size_t)f->len, &p)) return NULL; if (f->data != NULL) memcpy(p, f->data, (size_t)f->len); return p; } int ossl_quic_wire_encode_frame_new_token(WPACKET pkt, const unsigned char token, size_t token_len) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN) \|\| !WPACKET_quic_write_vlint(pkt, token_len) \|\| !WPACKET_memcpy(pkt, token, token_len)) return 0; return 1; } int ossl_quic_wire_encode_frame_stream_hdr(WPACKET pkt, const OSSL_QUIC_FRAME_STREAM f) { uint64_t frame_type = OSSL_QUIC_FRAME_TYPE_STREAM; if (f->offset != 0) frame_type \|= OSSL_QUIC_FRAME_FLAG_STREAM_OFF; if (f->has_explicit_len) frame_type \|= OSSL_QUIC_FRAME_FLAG_STREAM_LEN; if (f->is_fin) frame_type \|= OSSL_QUIC_FRAME_FLAG_STREAM_FIN; if (!encode_frame_hdr(pkt, frame_type) \|\| !WPACKET_quic_write_vlint(pkt, f->stream_id)) return 0; if (f->offset != 0 && !WPACKET_quic_write_vlint(pkt, f->offset)) return 0; if (f->has_explicit_len && !WPACKET_quic_write_vlint(pkt, f->len)) return 0; return 1; } size_t ossl_quic_wire_get_encoded_frame_len_stream_hdr(const OSSL_QUIC_FRAME_STREAM f) { size_t a, b, c, d; a = ossl_quic_vlint_encode_len(OSSL_QUIC_FRAME_TYPE_STREAM); b = ossl_quic_vlint_encode_len(f->stream_id); if (a == 0 \|\| b == 0) return 0; if (f->offset > 0) { c = ossl_quic_vlint_encode_len(f->offset); if (c == 0) return 0; } else { c = 0; } if (f->has_explicit_len) { d = ossl_quic_vlint_encode_len(f->len); if (d == 0) return 0; } else { d = 0; } return a + b + c + d; } void ossl_quic_wire_encode_frame_stream(WPACKET pkt, const OSSL_QUIC_FRAME_STREAM f) { unsigned char p = NULL; if (!ossl_quic_wire_encode_frame_stream_hdr(pkt, f) \|\| f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? /) return NULL; if (!WPACKET_allocate_bytes(pkt, (size_t)f->len, &p)) return NULL; if (f->data != NULL) memcpy(p, f->data, (size_t)f->len); return p; } int ossl_quic_wire_encode_frame_max_data(WPACKET pkt, uint64_t max_data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_MAX_DATA) \|\| !WPACKET_quic_write_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_encode_frame_max_stream_data(WPACKET pkt, uint64_t stream_id, uint64_t max_data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA) \|\| !WPACKET_quic_write_vlint(pkt, stream_id) \|\| !WPACKET_quic_write_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_encode_frame_max_streams(WPACKET pkt, char is_uni, uint64_t max_streams) { if (!encode_frame_hdr(pkt, is_uni ? OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI : OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI) \|\| !WPACKET_quic_write_vlint(pkt, max_streams)) return 0; return 1; } int ossl_quic_wire_encode_frame_data_blocked(WPACKET pkt, uint64_t max_data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED) \|\| !WPACKET_quic_write_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_encode_frame_stream_data_blocked(WPACKET pkt, uint64_t stream_id, uint64_t max_stream_data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED) \|\| !WPACKET_quic_write_vlint(pkt, stream_id) \|\| !WPACKET_quic_write_vlint(pkt, max_stream_data)) return 0; return 1; } int ossl_quic_wire_encode_frame_streams_blocked(WPACKET pkt, char is_uni, uint64_t max_streams) { if (!encode_frame_hdr(pkt, is_uni ? OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI : OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI) \|\| !WPACKET_quic_write_vlint(pkt, max_streams)) return 0; return 1; } int ossl_quic_wire_encode_frame_new_conn_id(WPACKET pkt, const OSSL_QUIC_FRAME_NEW_CONN_ID f) { if (f->conn_id.id_len < 1 \|\| f->conn_id.id_len > QUIC_MAX_CONN_ID_LEN) return 0; if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID) \|\| !WPACKET_quic_write_vlint(pkt, f->seq_num) \|\| !WPACKET_quic_write_vlint(pkt, f->retire_prior_to) \|\| !WPACKET_put_bytes_u8(pkt, f->conn_id.id_len) \|\| !WPACKET_memcpy(pkt, f->conn_id.id, f->conn_id.id_len) \|\| !WPACKET_memcpy(pkt, f->stateless_reset.token, sizeof(f->stateless_reset.token))) return 0; return 1; } int ossl_quic_wire_encode_frame_retire_conn_id(WPACKET pkt, uint64_t seq_num) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID) \|\| !WPACKET_quic_write_vlint(pkt, seq_num)) return 0; return 1; } int ossl_quic_wire_encode_frame_path_challenge(WPACKET pkt, uint64_t data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE) \|\| !WPACKET_put_bytes_u64(pkt, data)) return 0; return 1; } int ossl_quic_wire_encode_frame_path_response(WPACKET pkt, uint64_t data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE) \|\| !WPACKET_put_bytes_u64(pkt, data)) return 0; return 1; } int ossl_quic_wire_encode_frame_conn_close(WPACKET pkt, const OSSL_QUIC_FRAME_CONN_CLOSE f) { if (!encode_frame_hdr(pkt, f->is_app ? OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP : OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT) \|\| !WPACKET_quic_write_vlint(pkt, f->error_code)) return 0; /* * RFC 9000 s. 19.19: The application-specific variant of CONNECTION_CLOSE * (type 0x1d) does not include this field. / if (!f->is_app && !WPACKET_quic_write_vlint(pkt, f->frame_type)) return 0; if (!WPACKET_quic_write_vlint(pkt, f->reason_len) \|\| !WPACKET_memcpy(pkt, f->reason, f->reason_len)) return 0; return 1; } int ossl_quic_wire_encode_frame_handshake_done(WPACKET pkt) { return encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE); } unsigned char ossl_quic_wire_encode_transport_param_bytes(WPACKET pkt, uint64_t id, const unsigned char value, size_t value_len) { unsigned char b = NULL; if (!WPACKET_quic_write_vlint(pkt, id) \|\| !WPACKET_quic_write_vlint(pkt, value_len)) return NULL; if (value_len == 0) b = WPACKET_get_curr(pkt); else if (!WPACKET_allocate_bytes(pkt, value_len, (unsigned char *)&b)) return NULL; if (value != NULL) memcpy(b, value, value_len); return b; } int ossl_quic_wire_encode_transport_param_int(WPACKET pkt, uint64_t id, uint64_t value) { if (!WPACKET_quic_write_vlint(pkt, id) \|\| !WPACKET_quic_write_vlint(pkt, ossl_quic_vlint_encode_len(value)) \|\| !WPACKET_quic_write_vlint(pkt, value)) return 0; return 1; } int ossl_quic_wire_encode_transport_param_cid(WPACKET wpkt, uint64_t id, const QUIC_CONN_ID cid) { if (cid->id_len > QUIC_MAX_CONN_ID_LEN) return 0; if (ossl_quic_wire_encode_transport_param_bytes(wpkt, id, cid->id, cid->id_len) == NULL) return 0; return 1; } /* * QUIC Wire Format Decoding * ========================= / int ossl_quic_wire_peek_frame_header(PACKET pkt, uint64_t type, int was_minimal) { return PACKET_peek_quic_vlint_ex(pkt, type, was_minimal); } int ossl_quic_wire_skip_frame_header(PACKET pkt, uint64_t type) { return PACKET_get_quic_vlint(pkt, type); } static int expect_frame_header_mask(PACKET pkt, uint64_t expected_frame_type, uint64_t mask_bits, uint64_t actual_frame_type) { uint64_t actual_frame_type_; if (!ossl_quic_wire_skip_frame_header(pkt, &actual_frame_type_) \|\| (actual_frame_type_ & ~mask_bits) != expected_frame_type) return 0; if (actual_frame_type != NULL) actual_frame_type = actual_frame_type_; return 1; } static int expect_frame_header(PACKET pkt, uint64_t expected_frame_type) { uint64_t actual_frame_type; if (!ossl_quic_wire_skip_frame_header(pkt, &actual_frame_type) \|\| actual_frame_type != expected_frame_type) return 0; return 1; } int ossl_quic_wire_peek_frame_ack_num_ranges(const PACKET orig_pkt, uint64_t total_ranges) { PACKET pkt = orig_pkt; uint64_t ack_range_count, i; if (!expect_frame_header_mask(&pkt, OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN, 1, NULL) \|\| !PACKET_skip_quic_vlint(&pkt) \|\| !PACKET_skip_quic_vlint(&pkt) \|\| !PACKET_get_quic_vlint(&pkt, &ack_range_count)) return 0; / * Ensure the specified number of ack ranges listed in the ACK frame header * actually are available in the frame data. This naturally bounds the * number of ACK ranges which can be requested by the MDPL, and therefore by * the MTU. This ensures we do not allocate memory for an excessive number * of ACK ranges. / for (i = 0; i < ack_range_count; ++i) if (!PACKET_skip_quic_vlint(&pkt) \|\| !PACKET_skip_quic_vlint(&pkt)) return 0; / (cannot overflow because QUIC vlints can only encode up to 2*62-1) / total_ranges = ack_range_count + 1; return 1; } int ossl_quic_wire_decode_frame_ack(PACKET pkt, uint32_t ack_delay_exponent, OSSL_QUIC_FRAME_ACK ack, uint64_t total_ranges) { uint64_t frame_type, largest_ackd, ack_delay_raw; uint64_t ack_range_count, first_ack_range, start, end, i; /* This call matches both ACK_WITHOUT_ECN and ACK_WITH_ECN. / if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN, 1, &frame_type) \|\| !PACKET_get_quic_vlint(pkt, &largest_ackd) \|\| !PACKET_get_quic_vlint(pkt, &ack_delay_raw) \|\| !PACKET_get_quic_vlint(pkt, &ack_range_count) \|\| !PACKET_get_quic_vlint(pkt, &first_ack_range)) return 0; if (first_ack_range > largest_ackd) return 0; if (ack_range_count > SIZE_MAX / sizeof(uint64_t) > sizeof(size_t)? /) return 0; start = largest_ackd - first_ack_range; if (ack != NULL) { int err = 0; ack->delay_time = ossl_time_multiply(ossl_ticks2time(OSSL_TIME_US), safe_mul_uint64_t(ack_delay_raw, (uint64_t)1 << ack_delay_exponent, &err)); if (err) ack->delay_time = ossl_time_infinite(); if (ack->num_ack_ranges > 0) { ack->ack_ranges[0].end = largest_ackd; ack->ack_ranges[0].start = start; } } for (i = 0; i < ack_range_count; ++i) { uint64_t gap, len; if (!PACKET_get_quic_vlint(pkt, &gap) \|\| !PACKET_get_quic_vlint(pkt, &len)) return 0; end = start - gap - 2; if (start < gap + 2 \|\| len > end) return 0; if (ack != NULL && i + 1 < ack->num_ack_ranges) { ack->ack_ranges[i + 1].start = start = end - len; ack->ack_ranges[i + 1].end = end; } } if (ack != NULL && ack_range_count + 1 < ack->num_ack_ranges) ack->num_ack_ranges = (size_t)ack_range_count + 1; if (total_ranges != NULL) total_ranges = ack_range_count + 1; if (frame_type == OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN) { uint64_t ect0, ect1, ecnce; if (!PACKET_get_quic_vlint(pkt, &ect0) \|\| !PACKET_get_quic_vlint(pkt, &ect1) \|\| !PACKET_get_quic_vlint(pkt, &ecnce)) return 0; if (ack != NULL) { ack->ect0 = ect0; ack->ect1 = ect1; ack->ecnce = ecnce; ack->ecn_present = 1; } } else if (ack != NULL) { ack->ecn_present = 0; } return 1; } int ossl_quic_wire_decode_frame_reset_stream(PACKET pkt, OSSL_QUIC_FRAME_RESET_STREAM f) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_RESET_STREAM) \|\| !PACKET_get_quic_vlint(pkt, &f->stream_id) \|\| !PACKET_get_quic_vlint(pkt, &f->app_error_code) \|\| !PACKET_get_quic_vlint(pkt, &f->final_size)) return 0; return 1; } int ossl_quic_wire_decode_frame_stop_sending(PACKET pkt, OSSL_QUIC_FRAME_STOP_SENDING f) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_STOP_SENDING) \|\| !PACKET_get_quic_vlint(pkt, &f->stream_id) \|\| !PACKET_get_quic_vlint(pkt, &f->app_error_code)) return 0; return 1; } int ossl_quic_wire_decode_frame_crypto(PACKET pkt, int nodata, OSSL_QUIC_FRAME_CRYPTO f) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_CRYPTO) \|\| !PACKET_get_quic_vlint(pkt, &f->offset) \|\| !PACKET_get_quic_vlint(pkt, &f->len) \|\| f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? /) return 0; if (f->offset + f->len > (((uint64_t)1) << 62) - 1) / RFC 9000 s. 19.6 / return 0; if (nodata) { f->data = NULL; } else { if (PACKET_remaining(pkt) < f->len) return 0; f->data = PACKET_data(pkt); if (!PACKET_forward(pkt, (size_t)f->len)) return 0; } return 1; } int ossl_quic_wire_decode_frame_new_token(PACKET pkt, const unsigned char *token, size_t token_len) { uint64_t token_len_; if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN) \|\| !PACKET_get_quic_vlint(pkt, &token_len_)) return 0; if (token_len_ > SIZE_MAX) return 0; token = PACKET_data(pkt); token_len = (size_t)token_len_; if (!PACKET_forward(pkt, (size_t)token_len_)) return 0; return 1; } int ossl_quic_wire_decode_frame_stream(PACKET pkt, int nodata, OSSL_QUIC_FRAME_STREAM f) { uint64_t frame_type; /* This call matches all STREAM values (low 3 bits are masked). / if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_STREAM, OSSL_QUIC_FRAME_FLAG_STREAM_MASK, &frame_type) \|\| !PACKET_get_quic_vlint(pkt, &f->stream_id)) return 0; if ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_OFF) != 0) { if (!PACKET_get_quic_vlint(pkt, &f->offset)) return 0; } else { f->offset = 0; } f->has_explicit_len = ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_LEN) != 0); f->is_fin = ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_FIN) != 0); if (f->has_explicit_len) { if (!PACKET_get_quic_vlint(pkt, &f->len)) return 0; } else { if (nodata) f->len = 0; else f->len = PACKET_remaining(pkt); } / * RFC 9000 s. 19.8: "The largest offset delivered on a stream -- the sum of * the offset and data length -- cannot exceed 2*62 - 1, as it is not possible to provide flow control credit for that data." / if (f->offset + f->len > (((uint64_t)1) << 62) - 1) return 0; if (nodata) { f->data = NULL; } else { f->data = PACKET_data(pkt); if (f->len > SIZE_MAX / sizeof(uint64_t) > sizeof(size_t)? / \|\| !PACKET_forward(pkt, (size_t)f->len)) return 0; } return 1; } int ossl_quic_wire_decode_frame_max_data(PACKET pkt, uint64_t max_data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_MAX_DATA) \|\| !PACKET_get_quic_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_decode_frame_max_stream_data(PACKET pkt, uint64_t stream_id, uint64_t max_stream_data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA) \|\| !PACKET_get_quic_vlint(pkt, stream_id) \|\| !PACKET_get_quic_vlint(pkt, max_stream_data)) return 0; return 1; } int ossl_quic_wire_decode_frame_max_streams(PACKET pkt, uint64_t max_streams) { /* This call matches both MAX_STREAMS_BIDI and MAX_STREAMS_UNI. / if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI, 1, NULL) \|\| !PACKET_get_quic_vlint(pkt, max_streams)) return 0; return 1; } int ossl_quic_wire_decode_frame_data_blocked(PACKET pkt, uint64_t max_data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED) \|\| !PACKET_get_quic_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_decode_frame_stream_data_blocked(PACKET pkt, uint64_t stream_id, uint64_t max_stream_data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED) \|\| !PACKET_get_quic_vlint(pkt, stream_id) \|\| !PACKET_get_quic_vlint(pkt, max_stream_data)) return 0; return 1; } int ossl_quic_wire_decode_frame_streams_blocked(PACKET pkt, uint64_t max_streams) { /* This call matches both STREAMS_BLOCKED_BIDI and STREAMS_BLOCKED_UNI. / if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI, 1, NULL) \|\| !PACKET_get_quic_vlint(pkt, max_streams)) return 0; return 1; } int ossl_quic_wire_decode_frame_new_conn_id(PACKET pkt, OSSL_QUIC_FRAME_NEW_CONN_ID f) { unsigned int len; if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID) \|\| !PACKET_get_quic_vlint(pkt, &f->seq_num) \|\| !PACKET_get_quic_vlint(pkt, &f->retire_prior_to) \|\| f->seq_num < f->retire_prior_to \|\| !PACKET_get_1(pkt, &len) \|\| len < 1 \|\| len > QUIC_MAX_CONN_ID_LEN) return 0; f->conn_id.id_len = (unsigned char)len; if (!PACKET_copy_bytes(pkt, f->conn_id.id, len)) return 0; / Clear unused bytes to allow consistent memcmp. / if (len < QUIC_MAX_CONN_ID_LEN) memset(f->conn_id.id + len, 0, QUIC_MAX_CONN_ID_LEN - len); if (!PACKET_copy_bytes(pkt, f->stateless_reset.token, sizeof(f->stateless_reset.token))) return 0; return 1; } int ossl_quic_wire_decode_frame_retire_conn_id(PACKET pkt, uint64_t seq_num) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID) \|\| !PACKET_get_quic_vlint(pkt, seq_num)) return 0; return 1; } int ossl_quic_wire_decode_frame_path_challenge(PACKET pkt, uint64_t data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE) \|\| !PACKET_get_net_8(pkt, data)) return 0; return 1; } int ossl_quic_wire_decode_frame_path_response(PACKET pkt, uint64_t data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE) \|\| !PACKET_get_net_8(pkt, data)) return 0; return 1; } int ossl_quic_wire_decode_frame_conn_close(PACKET pkt, OSSL_QUIC_FRAME_CONN_CLOSE f) { uint64_t frame_type, reason_len; / This call matches both CONN_CLOSE_TRANSPORT and CONN_CLOSE_APP. / if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT, 1, &frame_type) \|\| !PACKET_get_quic_vlint(pkt, &f->error_code)) return 0; f->is_app = ((frame_type & 1) != 0); if (!f->is_app) { if (!PACKET_get_quic_vlint(pkt, &f->frame_type)) return 0; } else { f->frame_type = 0; } if (!PACKET_get_quic_vlint(pkt, &reason_len) \|\| reason_len > SIZE_MAX) return 0; if (!PACKET_get_bytes(pkt, (const unsigned char )&f->reason, (size_t)reason_len)) return 0; f->reason_len = (size_t)reason_len; return 1; } size_t ossl_quic_wire_decode_padding(PACKET pkt) { const unsigned char start = PACKET_data(pkt), end = PACKET_end(pkt), p = start; while (p < end && p == 0) ++p; if (!PACKET_forward(pkt, p - start)) return 0; return p - start; } int ossl_quic_wire_decode_frame_ping(PACKET pkt) { return expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_PING); } int ossl_quic_wire_decode_frame_handshake_done(PACKET pkt) { return expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE); } int ossl_quic_wire_peek_transport_param(PACKET pkt, uint64_t id) { return PACKET_peek_quic_vlint(pkt, id); } const unsigned char ossl_quic_wire_decode_transport_param_bytes(PACKET pkt, uint64_t id, size_t len) { uint64_t len_; const unsigned char b = NULL; uint64_t id_; if (!PACKET_get_quic_vlint(pkt, &id_) \|\| !PACKET_get_quic_vlint(pkt, &len_)) return NULL; if (len_ > SIZE_MAX \|\| !PACKET_get_bytes(pkt, (const unsigned char )&b, (size_t)len_)) return NULL; len = (size_t)len_; if (id != NULL) id = id_; return b; } int ossl_quic_wire_decode_transport_param_int(PACKET pkt, uint64_t id, uint64_t value) { PACKET sub; sub.curr = ossl_quic_wire_decode_transport_param_bytes(pkt, id, &sub.remaining); if (sub.curr == NULL) return 0; if (!PACKET_get_quic_vlint(&sub, value)) return 0; if (PACKET_remaining(&sub) > 0) return 0; return 1; } int ossl_quic_wire_decode_transport_param_cid(PACKET pkt, uint64_t id, QUIC_CONN_ID cid) { const unsigned char body; size_t len = 0; body = ossl_quic_wire_decode_transport_param_bytes(pkt, id, &len); if (body == NULL \|\| len > QUIC_MAX_CONN_ID_LEN) return 0; cid->id_len = (unsigned char)len; memcpy(cid->id, body, cid->id_len); return 1; } int ossl_quic_wire_decode_transport_param_preferred_addr(PACKET pkt, QUIC_PREFERRED_ADDR p) { const unsigned char body; uint64_t id; size_t len = 0; PACKET pkt2; unsigned int ipv4_port, ipv6_port, cidl; body = ossl_quic_wire_decode_transport_param_bytes(pkt, &id, &len); if (body == NULL \|\| len < QUIC_MIN_ENCODED_PREFERRED_ADDR_LEN \|\| len > QUIC_MAX_ENCODED_PREFERRED_ADDR_LEN \|\| id != QUIC_TPARAM_PREFERRED_ADDR) return 0; if (!PACKET_buf_init(&pkt2, body, len)) return 0; if (!PACKET_copy_bytes(&pkt2, p->ipv4, sizeof(p->ipv4)) \|\| !PACKET_get_net_2(&pkt2, &ipv4_port) \|\| !PACKET_copy_bytes(&pkt2, p->ipv6, sizeof(p->ipv6)) \|\| !PACKET_get_net_2(&pkt2, &ipv6_port) \|\| !PACKET_get_1(&pkt2, &cidl) \|\| cidl > QUIC_MAX_CONN_ID_LEN \|\| !PACKET_copy_bytes(&pkt2, p->cid.id, cidl) \|\| !PACKET_copy_bytes(&pkt2, p->stateless_reset.token, sizeof(p->stateless_reset.token))) return 0; p->ipv4_port = (uint16_t)ipv4_port; p->ipv6_port = (uint16_t)ipv6_port; p->cid.id_len = (unsigned char)cidl; return 1; } const char ossl_quic_frame_type_to_string(uint64_t frame_type) { switch (frame_type) { #define X(name) case OSSL_QUIC_FRAME_TYPE_##name: return #name; X(PADDING) X(PING) X(ACK_WITHOUT_ECN) X(ACK_WITH_ECN) X(RESET_STREAM) X(STOP_SENDING) X(CRYPTO) X(NEW_TOKEN) X(MAX_DATA) X(MAX_STREAM_DATA) X(MAX_STREAMS_BIDI) X(MAX_STREAMS_UNI) X(DATA_BLOCKED) X(STREAM_DATA_BLOCKED) X(STREAMS_BLOCKED_BIDI) X(STREAMS_BLOCKED_UNI) X(NEW_CONN_ID) X(RETIRE_CONN_ID) X(PATH_CHALLENGE) X(PATH_RESPONSE) X(CONN_CLOSE_TRANSPORT) X(CONN_CLOSE_APP) X(HANDSHAKE_DONE) X(STREAM) X(STREAM_FIN) X(STREAM_LEN) X(STREAM_LEN_FIN) X(STREAM_OFF) X(STREAM_OFF_FIN) X(STREAM_OFF_LEN) X(STREAM_OFF_LEN_FIN) #undef X default: return NULL; } } const char *ossl_quic_err_to_string(uint64_t error_code) { switch (error_code) { #define X(name) case QUIC_ERR_##name: return #name; X(NO_ERROR) X(INTERNAL_ERROR) X(CONNECTION_REFUSED) X(FLOW_CONTROL_ERROR) X(STREAM_LIMIT_ERROR) X(STREAM_STATE_ERROR) X(FINAL_SIZE_ERROR) X(FRAME_ENCODING_ERROR) X(TRANSPORT_PARAMETER_ERROR) X(CONNECTION_ID_LIMIT_ERROR) X(PROTOCOL_VIOLATION) X(INVALID_TOKEN) X(APPLICATION_ERROR) X(CRYPTO_BUFFER_EXCEEDED) X(KEY_UPDATE_ERROR) X(AEAD_LIMIT_REACHED) X(NO_VIABLE_PATH) #undef X default: return NULL; } }
./openssl/ssl/quic/quic_ackm.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_ackm.h" #include "internal/uint_set.h" #include "internal/common.h" #include <assert.h> DEFINE_LIST_OF(tx_history, OSSL_ACKM_TX_PKT); / * TX Packet History * ***************** * * The TX Packet History object tracks information about packets which have been * sent for which we later expect to receive an ACK. It is essentially a simple * database keeping a list of packet information structures in packet number * order which can also be looked up directly by packet number. * * We currently only allow packets to be appended to the list (i.e. the packet * numbers of the packets appended to the list must monotonically increase), as * we should not currently need more general functionality such as a sorted list * insert. / struct tx_pkt_history_st { / A linked list of all our packets. / OSSL_LIST(tx_history) packets; / * Mapping from packet numbers (uint64_t) to (OSSL_ACKM_TX_PKT ) * Invariant: A packet is in this map if and only if it is in the linked * list. / LHASH_OF(OSSL_ACKM_TX_PKT) map; /* * The lowest packet number which may currently be added to the history list * (inclusive). We do not allow packet numbers to be added to the history * list non-monotonically, so packet numbers must be greater than or equal * to this value. / uint64_t watermark; / * Packet number of the highest packet info structure we have yet appended * to the list. This is usually one less than watermark, except when we have * not added any packet yet. / uint64_t highest_sent; }; DEFINE_LHASH_OF_EX(OSSL_ACKM_TX_PKT); static unsigned long tx_pkt_info_hash(const OSSL_ACKM_TX_PKT pkt) { /* Using low bits of the packet number as the hash should be enough / return (unsigned long)pkt->pkt_num; } static int tx_pkt_info_compare(const OSSL_ACKM_TX_PKT a, const OSSL_ACKM_TX_PKT b) { if (a->pkt_num < b->pkt_num) return -1; if (a->pkt_num > b->pkt_num) return 1; return 0; } static int tx_pkt_history_init(struct tx_pkt_history_st h) { ossl_list_tx_history_init(&h->packets); h->watermark = 0; h->highest_sent = 0; h->map = lh_OSSL_ACKM_TX_PKT_new(tx_pkt_info_hash, tx_pkt_info_compare); if (h->map == NULL) return 0; return 1; } static void tx_pkt_history_destroy(struct tx_pkt_history_st h) { lh_OSSL_ACKM_TX_PKT_free(h->map); h->map = NULL; ossl_list_tx_history_init(&h->packets); } static int tx_pkt_history_add_actual(struct tx_pkt_history_st h, OSSL_ACKM_TX_PKT pkt) { OSSL_ACKM_TX_PKT existing; /* * There should not be any existing packet with this number * in our mapping. / existing = lh_OSSL_ACKM_TX_PKT_retrieve(h->map, pkt); if (!ossl_assert(existing == NULL)) return 0; / Should not already be in a list. / if (!ossl_assert(ossl_list_tx_history_next(pkt) == NULL && ossl_list_tx_history_prev(pkt) == NULL)) return 0; lh_OSSL_ACKM_TX_PKT_insert(h->map, pkt); ossl_list_tx_history_insert_tail(&h->packets, pkt); return 1; } / Adds a packet information structure to the history list. / static int tx_pkt_history_add(struct tx_pkt_history_st h, OSSL_ACKM_TX_PKT pkt) { if (!ossl_assert(pkt->pkt_num >= h->watermark)) return 0; if (tx_pkt_history_add_actual(h, pkt) < 1) return 0; h->watermark = pkt->pkt_num + 1; h->highest_sent = pkt->pkt_num; return 1; } / Retrieve a packet information structure by packet number. / static OSSL_ACKM_TX_PKT tx_pkt_history_by_pkt_num(struct tx_pkt_history_st h, uint64_t pkt_num) { OSSL_ACKM_TX_PKT key; key.pkt_num = pkt_num; return lh_OSSL_ACKM_TX_PKT_retrieve(h->map, &key); } / Remove a packet information structure from the history log. / static int tx_pkt_history_remove(struct tx_pkt_history_st h, uint64_t pkt_num) { OSSL_ACKM_TX_PKT key, pkt; key.pkt_num = pkt_num; pkt = tx_pkt_history_by_pkt_num(h, pkt_num); if (pkt == NULL) return 0; ossl_list_tx_history_remove(&h->packets, pkt); lh_OSSL_ACKM_TX_PKT_delete(h->map, &key); return 1; } / * RX Packet Number Tracking * ************************* * * Background. The RX side of the ACK manager must track packets we have * received for which we have to generate ACK frames. Broadly, this means we * store a set of packet numbers which we have received but which we do not know * for a fact that the transmitter knows we have received. * * This must handle various situations: * * 1. We receive a packet but have not sent an ACK yet, so the transmitter * does not know whether we have received it or not yet. * * 2. We receive a packet and send an ACK which is lost. We do not * immediately know that the ACK was lost and the transmitter does not know * that we have received the packet. * * 3. We receive a packet and send an ACK which is received by the * transmitter. The transmitter does not immediately respond with an ACK, * or responds with an ACK which is lost. The transmitter knows that we * have received the packet, but we do not know for sure that it knows, * because the ACK we sent could have been lost. * * 4. We receive a packet and send an ACK which is received by the * transmitter. The transmitter subsequently sends us an ACK which confirms * its receipt of the ACK we sent, and we successfully receive that ACK, so * we know that the transmitter knows, that we received the original * packet. * * Only when we reach case (4) are we relieved of any need to track a given * packet number we have received, because only in this case do we know for sure * that the peer knows we have received the packet. Having reached case (4) we * will never again need to generate an ACK containing the PN in question, but * until we reach that point, we must keep track of the PN as not having been * provably ACKed, as we may have to keep generating ACKs for the given PN not * just until the transmitter receives one, but until we know that it has * received one. This will be referred to herein as "provably ACKed". * * Duplicate handling. The above discusses the case where we have received a * packet with a given PN but are at best unsure whether the sender knows we * have received it or not. However, we must also handle the case where we have * yet to receive a packet with a given PN in the first place. The reason for * this is because of the requirement expressed by RFC 9000 s. 12.3: * * "A receiver MUST discard a newly unprotected packet unless it is certain * that it has not processed another packet with the same packet number from * the same packet number space." * * We must ensure we never process a duplicate PN. As such, each possible PN we * can receive must exist in one of the following logical states: * * - We have never processed this PN before * (so if we receive such a PN, it can be processed) * * - We have processed this PN but it has not yet been provably ACKed * (and should therefore be in any future ACK frame generated; * if we receive such a PN again, it must be ignored) * * - We have processed this PN and it has been provably ACKed * (if we receive such a PN again, it must be ignored) * * However, if we were to track this state for every PN ever used in the history * of a connection, the amount of state required would increase unboundedly as * the connection goes on (for example, we would have to store a set of every PN * ever received.) * * RFC 9000 s. 12.3 continues: * * "Endpoints that track all individual packets for the purposes of detecting * duplicates are at risk of accumulating excessive state. The data required * for detecting duplicates can be limited by maintaining a minimum packet * number below which all packets are immediately dropped." * * Moreover, RFC 9000 s. 13.2.3 states that: * * "A receiver MUST retain an ACK Range unless it can ensure that it will not * subsequently accept packets with numbers in that range. Maintaining a * minimum packet number that increases as ranges are discarded is one way to * achieve this with minimal state." * * This touches on a subtlety of the original requirement quoted above: the * receiver MUST discard a packet unless it is certain that it has not processed * another packet with the same PN. However, this does not forbid the receiver * from also discarding some PNs even though it has not yet processed them. In * other words, implementations must be conservative and err in the direction of * assuming a packet is a duplicate, but it is acceptable for this to come at * the cost of falsely identifying some packets as duplicates. * * This allows us to bound the amount of state we must keep, and we adopt the * suggested strategy quoted above to do so. We define a watermark PN below * which all PNs are in the same state. This watermark is only ever increased. * Thus the PNs the state for which needs to be explicitly tracked is limited to * only a small number of recent PNs, and all older PNs have an assumed state. * * Any given PN thus falls into one of the following states: * * - (A) The PN is above the watermark but we have not yet received it. * * If we receive such a PN, we should process it and record the PN as * received. * * - (B) The PN is above the watermark and we have received it. * * The PN should be included in any future ACK frame we generate. * If we receive such a PN again, we should ignore it. * * - (C) The PN is below the watermark. * * We do not know whether a packet with the given PN was received or * not. To be safe, if we receive such a packet, it is not processed. * * Note that state (C) corresponds to both "we have processed this PN and it has * been provably ACKed" logical state and a subset of the PNs in the "we have * never processed this PN before" logical state (namely all PNs which were lost * and never received, but which are not recent enough to be above the * watermark). The reason we can merge these states and avoid tracking states * for the PNs in this state is because the provably ACKed and never-received * states are functionally identical in terms of how we need to handle them: we * don't need to do anything for PNs in either of these states, so we don't have * to care about PNs in this state nor do we have to care about distinguishing * the two states for a given PN. * * Note that under this scheme provably ACKed PNs are by definition always below * the watermark; therefore, it follows that when a PN becomes provably ACKed, * the watermark must be immediately increased to exceed it (otherwise we would * keep reporting it in future ACK frames). * * This is in line with RFC 9000 s. 13.2.4's suggested strategy on when * to advance the watermark: * * "When a packet containing an ACK frame is sent, the Largest Acknowledged * field in that frame can be saved. When a packet containing an ACK frame is * acknowledged, the receiver can stop acknowledging packets less than or * equal to the Largest Acknowledged field in the sent ACK frame." * * This is where our scheme's false positives arise. When a packet containing an * ACK frame is itself ACK'd, PNs referenced in that ACK frame become provably * acked, and the watermark is bumped accordingly. However, the Largest * Acknowledged field does not imply that all lower PNs have been received, * because there may be gaps expressed in the ranges of PNs expressed by that * and previous ACK frames. Thus, some unreceived PNs may be moved below the * watermark, and we may subsequently reject those PNs as possibly being * duplicates even though we have not actually received those PNs. Since we bump * the watermark when a PN becomes provably ACKed, it follows that an unreceived * PN falls below the watermark (and thus becomes a false positive for the * purposes of duplicate detection) when a higher-numbered PN becomes provably * ACKed. * * Thus, when PN n becomes provably acked, any unreceived PNs in the range [0, * n) will no longer be processed. Although datagrams may be reordered in the * network, a PN we receive can only become provably ACKed after our own * subsequently generated ACK frame is sent in a future TX packet, and then we * receive another RX PN acknowledging that TX packet. This means that a given RX * PN can only become provably ACKed at least 1 RTT after it is received; it is * unlikely that any reordered datagrams will still be "in the network" (and not * lost) by this time. If this does occur for whatever reason and a late PN is * received, the packet will be discarded unprocessed and the PN is simply * handled as though lost (a "written off" PN). * * Data structure. Our state for the RX handling side of the ACK manager, as * discussed above, mainly comprises: * * a) a logical set of PNs, and * b) a monotonically increasing PN counter (the watermark). * * For (a), we define a data structure which stores a logical set of PNs, which * we use to keep track of which PNs we have received but which have not yet * been provably ACKed, and thus will later need to generate an ACK frame for. * * The correspondence with the logical states discussed above is as follows. A * PN is in state (C) if it is below the watermark; otherwise it is in state (B) * if it is in the logical set of PNs, and in state (A) otherwise. * * Note that PNs are only removed from the PN set (when they become provably * ACKed or written off) by virtue of advancement of the watermark. Removing PNs * from the PN set any other way would be ambiguous as it would be * indistinguishable from a PN we have not yet received and risk us processing a * duplicate packet. In other words, for a given PN: * * - State (A) can transition to state (B) or (C) * - State (B) can transition to state (C) only * - State (C) is the terminal state * * We can query the logical set data structure for PNs which have been received * but which have not been provably ACKed when we want to generate ACK frames. * Since ACK frames can be lost and/or we might not know that the peer has * successfully received them, we might generate multiple ACK frames covering a * given PN until that PN becomes provably ACKed and we finally remove it from * our set (by bumping the watermark) as no longer being our concern. * * The data structure used is the UINT_SET structure defined in uint_set.h, * which is used as a PN set. We use the following operations of the structure: * * Insert Range: Used when we receive a new PN. * * Remove Range: Used when bumping the watermark. * * Query: Used to determine if a PN is in the set. * * Possible duplicates. A PN is considered a possible duplicate when either: * * a) its PN is already in the PN set (i.e. has already been received), or * b) its PN is below the watermark (i.e. was provably ACKed or written off). * * A packet with a given PN is considered 'processable' when that PN is not * considered a possible duplicate (see ossl_ackm_is_rx_pn_processable). * * TX/RX interaction. The watermark is bumped whenever an RX packet becomes * provably ACKed. This occurs when an ACK frame is received by the TX side of * the ACK manager; thus, there is necessary interaction between the TX and RX * sides of the ACK manager. * * This is implemented as follows. When a packet is queued as sent in the TX * side of the ACK manager, it may optionally have a Largest Acked value set on * it. The user of the ACK manager should do this if the packet being * transmitted contains an ACK frame, by setting the field to the Largest Acked * field of that frame. Otherwise, this field should be set to QUIC_PN_INVALID. * When a TX packet is eventually acknowledged which has this field set, it is * used to update the state of the RX side of the ACK manager by bumping the * watermark accordingly. / struct rx_pkt_history_st { UINT_SET set; / * Invariant: PNs below this are not in the set. * Invariant: This is monotonic and only ever increases. / QUIC_PN watermark; }; static int rx_pkt_history_bump_watermark(struct rx_pkt_history_st h, QUIC_PN watermark); static void rx_pkt_history_init(struct rx_pkt_history_st h) { ossl_uint_set_init(&h->set); h->watermark = 0; } static void rx_pkt_history_destroy(struct rx_pkt_history_st h) { ossl_uint_set_destroy(&h->set); } /* * Limit the number of ACK ranges we store to prevent resource consumption DoS * attacks. / #define MAX_RX_ACK_RANGES 32 static void rx_pkt_history_trim_range_count(struct rx_pkt_history_st h) { QUIC_PN highest = QUIC_PN_INVALID; while (ossl_list_uint_set_num(&h->set) > MAX_RX_ACK_RANGES) { UINT_RANGE r = ossl_list_uint_set_head(&h->set)->range; highest = (highest == QUIC_PN_INVALID) ? r.end : ossl_quic_pn_max(highest, r.end); ossl_uint_set_remove(&h->set, &r); } /* * Bump watermark to cover all PNs we removed to avoid accidental * reprocessing of packets. / if (highest != QUIC_PN_INVALID) rx_pkt_history_bump_watermark(h, highest + 1); } static int rx_pkt_history_add_pn(struct rx_pkt_history_st h, QUIC_PN pn) { UINT_RANGE r; r.start = pn; r.end = pn; if (pn < h->watermark) return 1; /* consider this a success case / if (ossl_uint_set_insert(&h->set, &r) != 1) return 0; rx_pkt_history_trim_range_count(h); return 1; } static int rx_pkt_history_bump_watermark(struct rx_pkt_history_st h, QUIC_PN watermark) { UINT_RANGE r; if (watermark <= h->watermark) return 1; /* Remove existing PNs below the watermark. / r.start = 0; r.end = watermark - 1; if (ossl_uint_set_remove(&h->set, &r) != 1) return 0; h->watermark = watermark; return 1; } / * ACK Manager Implementation * ************************** * Implementation of the ACK manager proper. / / Constants used by the ACK manager; see RFC 9002. / #define K_GRANULARITY (1 OSSL_TIME_MS) #define K_PKT_THRESHOLD 3 #define K_TIME_THRESHOLD_NUM 9 #define K_TIME_THRESHOLD_DEN 8 /* The maximum number of times we allow PTO to be doubled. / #define MAX_PTO_COUNT 16 / Default maximum amount of time to leave an ACK-eliciting packet un-ACK'd. / #define DEFAULT_TX_MAX_ACK_DELAY ossl_ms2time(QUIC_DEFAULT_MAX_ACK_DELAY) struct ossl_ackm_st { / Our list of transmitted packets. Corresponds to RFC 9002 sent_packets. / struct tx_pkt_history_st tx_history[QUIC_PN_SPACE_NUM]; / Our list of received PNs which are not yet provably acked. / struct rx_pkt_history_st rx_history[QUIC_PN_SPACE_NUM]; / Polymorphic dependencies that we consume. / OSSL_TIME (now)(void arg); void now_arg; OSSL_STATM statm; const OSSL_CC_METHOD cc_method; OSSL_CC_DATA cc_data; / RFC 9002 variables. / uint32_t pto_count; QUIC_PN largest_acked_pkt[QUIC_PN_SPACE_NUM]; OSSL_TIME time_of_last_ack_eliciting_pkt[QUIC_PN_SPACE_NUM]; OSSL_TIME loss_time[QUIC_PN_SPACE_NUM]; OSSL_TIME loss_detection_deadline; / Lowest PN which is still not known to be ACKed. / QUIC_PN lowest_unacked_pkt[QUIC_PN_SPACE_NUM]; / Time at which we got our first RTT sample, or 0. / OSSL_TIME first_rtt_sample; / * A packet's num_bytes are added to this if it is inflight, * and removed again once ack'd/lost/discarded. / uint64_t bytes_in_flight; / * A packet's num_bytes are added to this if it is both inflight and * ack-eliciting, and removed again once ack'd/lost/discarded. / uint64_t ack_eliciting_bytes_in_flight[QUIC_PN_SPACE_NUM]; / Count of ECN-CE events. / uint64_t peer_ecnce[QUIC_PN_SPACE_NUM]; / Set to 1 when the handshake is confirmed. / char handshake_confirmed; / Set to 1 when the peer has completed address validation. / char peer_completed_addr_validation; / Set to 1 when a PN space has been discarded. / char discarded[QUIC_PN_SPACE_NUM]; / Set to 1 when we think an ACK frame should be generated. / char rx_ack_desired[QUIC_PN_SPACE_NUM]; / Set to 1 if an ACK frame has ever been generated. / char rx_ack_generated[QUIC_PN_SPACE_NUM]; / Probe request counts for reporting to the user. / OSSL_ACKM_PROBE_INFO pending_probe; / Generated ACK frames for each PN space. / OSSL_QUIC_FRAME_ACK ack[QUIC_PN_SPACE_NUM]; OSSL_QUIC_ACK_RANGE ack_ranges[QUIC_PN_SPACE_NUM][MAX_RX_ACK_RANGES]; / Other RX state. / / Largest PN we have RX'd. / QUIC_PN rx_largest_pn[QUIC_PN_SPACE_NUM]; / Time at which the PN in rx_largest_pn was RX'd. / OSSL_TIME rx_largest_time[QUIC_PN_SPACE_NUM]; / * ECN event counters. Each time we receive a packet with a given ECN label, * the corresponding ECN counter here is incremented. / uint64_t rx_ect0[QUIC_PN_SPACE_NUM]; uint64_t rx_ect1[QUIC_PN_SPACE_NUM]; uint64_t rx_ecnce[QUIC_PN_SPACE_NUM]; / * Number of ACK-eliciting packets since last ACK. We use this to defer * emitting ACK frames until a threshold number of ACK-eliciting packets * have been received. / uint32_t rx_ack_eliciting_pkts_since_last_ack[QUIC_PN_SPACE_NUM]; / * The ACK frame coalescing deadline at which we should flush any unsent ACK * frames. / OSSL_TIME rx_ack_flush_deadline[QUIC_PN_SPACE_NUM]; / * The RX maximum ACK delay (the maximum amount of time our peer might * wait to send us an ACK after receiving an ACK-eliciting packet). / OSSL_TIME rx_max_ack_delay; / * The TX maximum ACK delay (the maximum amount of time we allow ourselves * to wait before generating an ACK after receiving an ACK-eliciting * packet). / OSSL_TIME tx_max_ack_delay; / Callbacks for deadline updates. / void (loss_detection_deadline_cb)(OSSL_TIME deadline, void arg); void loss_detection_deadline_cb_arg; void (ack_deadline_cb)(OSSL_TIME deadline, int pkt_space, void arg); void ack_deadline_cb_arg; }; static ossl_inline uint32_t min_u32(uint32_t x, uint32_t y) { return x < y ? x : y; } / * Get TX history for a given packet number space. Must not have been * discarded. / static struct tx_pkt_history_st get_tx_history(OSSL_ACKM ackm, int pkt_space) { assert(!ackm->discarded[pkt_space]); return &ackm->tx_history[pkt_space]; } / * Get RX history for a given packet number space. Must not have been * discarded. / static struct rx_pkt_history_st get_rx_history(OSSL_ACKM ackm, int pkt_space) { assert(!ackm->discarded[pkt_space]); return &ackm->rx_history[pkt_space]; } / Does the newly-acknowledged list contain any ack-eliciting packet? / static int ack_includes_ack_eliciting(OSSL_ACKM_TX_PKT pkt) { for (; pkt != NULL; pkt = pkt->anext) if (pkt->is_ack_eliciting) return 1; return 0; } /* Return number of ACK-eliciting bytes in flight across all PN spaces. / static uint64_t ackm_ack_eliciting_bytes_in_flight(OSSL_ACKM ackm) { int i; uint64_t total = 0; for (i = 0; i < QUIC_PN_SPACE_NUM; ++i) total += ackm->ack_eliciting_bytes_in_flight[i]; return total; } /* Return 1 if the range contains the given PN. / static int range_contains(const OSSL_QUIC_ACK_RANGE range, QUIC_PN pn) { return pn >= range->start && pn <= range->end; } /* * Given a logical representation of an ACK frame 'ack', create a singly-linked * list of the newly ACK'd frames; that is, of frames which are matched by the * list of PN ranges contained in the ACK frame. The packet structures in the * list returned are removed from the TX history list. Returns a pointer to the * list head (or NULL) if empty. / static OSSL_ACKM_TX_PKT ackm_detect_and_remove_newly_acked_pkts(OSSL_ACKM ackm, const OSSL_QUIC_FRAME_ACK ack, int pkt_space) { OSSL_ACKM_TX_PKT acked_pkts = NULL, fixup = &acked_pkts, pkt, pprev; struct tx_pkt_history_st h; size_t ridx = 0; assert(ack->num_ack_ranges > 0); /* * Our history list is a list of packets sorted in ascending order * by packet number. * * ack->ack_ranges is a list of packet number ranges in descending order. * * Walk through our history list from the end in order to efficiently detect * membership in the specified ack ranges. As an optimization, we use our * hashtable to try and skip to the first matching packet. This may fail if * the ACK ranges given include nonexistent packets. / h = get_tx_history(ackm, pkt_space); pkt = tx_pkt_history_by_pkt_num(h, ack->ack_ranges[0].end); if (pkt == NULL) pkt = ossl_list_tx_history_tail(&h->packets); for (; pkt != NULL; pkt = pprev) { / * Save prev value as it will be zeroed if we remove the packet from the * history list below. / pprev = ossl_list_tx_history_prev(pkt); for (;; ++ridx) { if (ridx >= ack->num_ack_ranges) { / * We have exhausted all ranges so stop here, even if there are * more packets to look at. / goto stop; } if (range_contains(&ack->ack_ranges[ridx], pkt->pkt_num)) { / We have matched this range. / tx_pkt_history_remove(h, pkt->pkt_num); fixup = pkt; fixup = &pkt->anext; fixup = NULL; break; } else if (pkt->pkt_num > ack->ack_ranges[ridx].end) { / * We have not reached this range yet in our list, so do not * advance ridx. / break; } else { / * We have moved beyond this range, so advance to the next range * and try matching again. / assert(pkt->pkt_num < ack->ack_ranges[ridx].start); continue; } } } stop: return acked_pkts; } / * Create a singly-linked list of newly detected-lost packets in the given * packet number space. Returns the head of the list or NULL if no packets were * detected lost. The packets in the list are removed from the TX history list. / static OSSL_ACKM_TX_PKT ackm_detect_and_remove_lost_pkts(OSSL_ACKM ackm, int pkt_space) { OSSL_ACKM_TX_PKT lost_pkts = NULL, *fixup = &lost_pkts, pkt, pnext; OSSL_TIME loss_delay, lost_send_time, now; OSSL_RTT_INFO rtt; struct tx_pkt_history_st h; assert(ackm->largest_acked_pkt[pkt_space] != QUIC_PN_INVALID); ossl_statm_get_rtt_info(ackm->statm, &rtt); ackm->loss_time[pkt_space] = ossl_time_zero(); loss_delay = ossl_time_multiply(ossl_time_max(rtt.latest_rtt, rtt.smoothed_rtt), K_TIME_THRESHOLD_NUM); loss_delay = ossl_time_divide(loss_delay, K_TIME_THRESHOLD_DEN); /* Minimum time of K_GRANULARITY before packets are deemed lost. / loss_delay = ossl_time_max(loss_delay, ossl_ticks2time(K_GRANULARITY)); / Packets sent before this time are deemed lost. / now = ackm->now(ackm->now_arg); lost_send_time = ossl_time_subtract(now, loss_delay); h = get_tx_history(ackm, pkt_space); pkt = ossl_list_tx_history_head(&h->packets); for (; pkt != NULL; pkt = pnext) { assert(pkt_space == pkt->pkt_space); / * Save prev value as it will be zeroed if we remove the packet from the * history list below. / pnext = ossl_list_tx_history_next(pkt); if (pkt->pkt_num > ackm->largest_acked_pkt[pkt_space]) continue; / * Mark packet as lost, or set time when it should be marked. / if (ossl_time_compare(pkt->time, lost_send_time) <= 0 \|\| ackm->largest_acked_pkt[pkt_space] >= pkt->pkt_num + K_PKT_THRESHOLD) { tx_pkt_history_remove(h, pkt->pkt_num); fixup = pkt; fixup = &pkt->lnext; fixup = NULL; } else { if (ossl_time_is_zero(ackm->loss_time[pkt_space])) ackm->loss_time[pkt_space] = ossl_time_add(pkt->time, loss_delay); else ackm->loss_time[pkt_space] = ossl_time_min(ackm->loss_time[pkt_space], ossl_time_add(pkt->time, loss_delay)); } } return lost_pkts; } static OSSL_TIME ackm_get_loss_time_and_space(OSSL_ACKM ackm, int pspace) { OSSL_TIME time = ackm->loss_time[QUIC_PN_SPACE_INITIAL]; int i, space = QUIC_PN_SPACE_INITIAL; for (i = space + 1; i < QUIC_PN_SPACE_NUM; ++i) if (ossl_time_is_zero(time) \|\| ossl_time_compare(ackm->loss_time[i], time) == -1) { time = ackm->loss_time[i]; space = i; } pspace = space; return time; } static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM ackm, int space) { OSSL_RTT_INFO rtt; OSSL_TIME duration; OSSL_TIME pto_timeout = ossl_time_infinite(), t; int pto_space = QUIC_PN_SPACE_INITIAL, i; ossl_statm_get_rtt_info(ackm->statm, &rtt); duration = ossl_time_add(rtt.smoothed_rtt, ossl_time_max(ossl_time_multiply(rtt.rtt_variance, 4), ossl_ticks2time(K_GRANULARITY))); duration = ossl_time_multiply(duration, (uint64_t)1 << min_u32(ackm->pto_count, MAX_PTO_COUNT)); /* Anti-deadlock PTO starts from the current time. / if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0) { assert(!ackm->peer_completed_addr_validation); space = ackm->discarded[QUIC_PN_SPACE_INITIAL] ? QUIC_PN_SPACE_HANDSHAKE : QUIC_PN_SPACE_INITIAL; return ossl_time_add(ackm->now(ackm->now_arg), duration); } for (i = QUIC_PN_SPACE_INITIAL; i < QUIC_PN_SPACE_NUM; ++i) { if (ackm->ack_eliciting_bytes_in_flight[i] == 0) continue; if (i == QUIC_PN_SPACE_APP) { /* Skip application data until handshake confirmed. / if (!ackm->handshake_confirmed) break; / Include max_ack_delay and backoff for app data. / if (!ossl_time_is_infinite(ackm->rx_max_ack_delay)) { uint64_t factor = (uint64_t)1 << min_u32(ackm->pto_count, MAX_PTO_COUNT); duration = ossl_time_add(duration, ossl_time_multiply(ackm->rx_max_ack_delay, factor)); } } t = ossl_time_add(ackm->time_of_last_ack_eliciting_pkt[i], duration); if (ossl_time_compare(t, pto_timeout) < 0) { pto_timeout = t; pto_space = i; } } space = pto_space; return pto_timeout; } static void ackm_set_loss_detection_timer_actual(OSSL_ACKM ackm, OSSL_TIME deadline) { ackm->loss_detection_deadline = deadline; if (ackm->loss_detection_deadline_cb != NULL) ackm->loss_detection_deadline_cb(deadline, ackm->loss_detection_deadline_cb_arg); } static int ackm_set_loss_detection_timer(OSSL_ACKM ackm) { int space; OSSL_TIME earliest_loss_time, timeout; earliest_loss_time = ackm_get_loss_time_and_space(ackm, &space); if (!ossl_time_is_zero(earliest_loss_time)) { /* Time threshold loss detection. / ackm_set_loss_detection_timer_actual(ackm, earliest_loss_time); return 1; } if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0 && ackm->peer_completed_addr_validation) { / * Nothing to detect lost, so no timer is set. However, the client * needs to arm the timer if the server might be blocked by the * anti-amplification limit. / ackm_set_loss_detection_timer_actual(ackm, ossl_time_zero()); return 1; } timeout = ackm_get_pto_time_and_space(ackm, &space); ackm_set_loss_detection_timer_actual(ackm, timeout); return 1; } static int ackm_in_persistent_congestion(OSSL_ACKM ackm, const OSSL_ACKM_TX_PKT lpkt) { / TODO(QUIC FUTURE): Persistent congestion not currently implemented. / return 0; } static void ackm_on_pkts_lost(OSSL_ACKM ackm, int pkt_space, const OSSL_ACKM_TX_PKT lpkt, int pseudo) { const OSSL_ACKM_TX_PKT p, pnext; OSSL_RTT_INFO rtt; QUIC_PN largest_pn_lost = 0; OSSL_CC_LOSS_INFO loss_info = {0}; uint32_t flags = 0; for (p = lpkt; p != NULL; p = pnext) { pnext = p->lnext; if (p->is_inflight) { ackm->bytes_in_flight -= p->num_bytes; if (p->is_ack_eliciting) ackm->ack_eliciting_bytes_in_flight[p->pkt_space] -= p->num_bytes; if (p->pkt_num > largest_pn_lost) largest_pn_lost = p->pkt_num; if (!pseudo) { / * If this is pseudo-loss (e.g. during connection retry) we do not * inform the CC as it is not a real loss and not reflective of * network conditions. / loss_info.tx_time = p->time; loss_info.tx_size = p->num_bytes; ackm->cc_method->on_data_lost(ackm->cc_data, &loss_info); } } p->on_lost(p->cb_arg); } / * Persistent congestion can only be considered if we have gotten at least * one RTT sample. / ossl_statm_get_rtt_info(ackm->statm, &rtt); if (!ossl_time_is_zero(ackm->first_rtt_sample) && ackm_in_persistent_congestion(ackm, lpkt)) flags \|= OSSL_CC_LOST_FLAG_PERSISTENT_CONGESTION; ackm->cc_method->on_data_lost_finished(ackm->cc_data, flags); } static void ackm_on_pkts_acked(OSSL_ACKM ackm, const OSSL_ACKM_TX_PKT apkt) { const OSSL_ACKM_TX_PKT anext; QUIC_PN last_pn_acked = 0; OSSL_CC_ACK_INFO ainfo = {0}; for (; apkt != NULL; apkt = anext) { if (apkt->is_inflight) { ackm->bytes_in_flight -= apkt->num_bytes; if (apkt->is_ack_eliciting) ackm->ack_eliciting_bytes_in_flight[apkt->pkt_space] -= apkt->num_bytes; if (apkt->pkt_num > last_pn_acked) last_pn_acked = apkt->pkt_num; if (apkt->largest_acked != QUIC_PN_INVALID) /* * This can fail, but it is monotonic; worst case we try again * next time. / rx_pkt_history_bump_watermark(get_rx_history(ackm, apkt->pkt_space), apkt->largest_acked + 1); } ainfo.tx_time = apkt->time; ainfo.tx_size = apkt->num_bytes; anext = apkt->anext; apkt->on_acked(apkt->cb_arg); / may free apkt / if (apkt->is_inflight) ackm->cc_method->on_data_acked(ackm->cc_data, &ainfo); } } OSSL_ACKM ossl_ackm_new(OSSL_TIME (now)(void arg), void now_arg, OSSL_STATM statm, const OSSL_CC_METHOD cc_method, OSSL_CC_DATA cc_data) { OSSL_ACKM ackm; int i; ackm = OPENSSL_zalloc(sizeof(OSSL_ACKM)); if (ackm == NULL) return NULL; for (i = 0; i < (int)OSSL_NELEM(ackm->tx_history); ++i) { ackm->largest_acked_pkt[i] = QUIC_PN_INVALID; ackm->rx_ack_flush_deadline[i] = ossl_time_infinite(); if (tx_pkt_history_init(&ackm->tx_history[i]) < 1) goto err; } for (i = 0; i < (int)OSSL_NELEM(ackm->rx_history); ++i) rx_pkt_history_init(&ackm->rx_history[i]); ackm->now = now; ackm->now_arg = now_arg; ackm->statm = statm; ackm->cc_method = cc_method; ackm->cc_data = cc_data; ackm->rx_max_ack_delay = ossl_ms2time(QUIC_DEFAULT_MAX_ACK_DELAY); ackm->tx_max_ack_delay = DEFAULT_TX_MAX_ACK_DELAY; return ackm; err: while (--i >= 0) tx_pkt_history_destroy(&ackm->tx_history[i]); OPENSSL_free(ackm); return NULL; } void ossl_ackm_free(OSSL_ACKM ackm) { size_t i; if (ackm == NULL) return; for (i = 0; i < OSSL_NELEM(ackm->tx_history); ++i) if (!ackm->discarded[i]) { tx_pkt_history_destroy(&ackm->tx_history[i]); rx_pkt_history_destroy(&ackm->rx_history[i]); } OPENSSL_free(ackm); } int ossl_ackm_on_tx_packet(OSSL_ACKM ackm, OSSL_ACKM_TX_PKT pkt) { struct tx_pkt_history_st h = get_tx_history(ackm, pkt->pkt_space); / Time must be set and not move backwards. / if (ossl_time_is_zero(pkt->time) \|\| ossl_time_compare(ackm->time_of_last_ack_eliciting_pkt[pkt->pkt_space], pkt->time) > 0) return 0; / Must have non-zero number of bytes. / if (pkt->num_bytes == 0) return 0; / Does not make any sense for a non-in-flight packet to be ACK-eliciting. / if (!pkt->is_inflight && pkt->is_ack_eliciting) return 0; if (tx_pkt_history_add(h, pkt) == 0) return 0; if (pkt->is_inflight) { if (pkt->is_ack_eliciting) { ackm->time_of_last_ack_eliciting_pkt[pkt->pkt_space] = pkt->time; ackm->ack_eliciting_bytes_in_flight[pkt->pkt_space] += pkt->num_bytes; } ackm->bytes_in_flight += pkt->num_bytes; ackm_set_loss_detection_timer(ackm); ackm->cc_method->on_data_sent(ackm->cc_data, pkt->num_bytes); } return 1; } int ossl_ackm_on_rx_datagram(OSSL_ACKM ackm, size_t num_bytes) { /* No-op on the client. / return 1; } static void ackm_process_ecn(OSSL_ACKM ackm, const OSSL_QUIC_FRAME_ACK ack, int pkt_space) { struct tx_pkt_history_st h; OSSL_ACKM_TX_PKT pkt; OSSL_CC_ECN_INFO ecn_info = {0}; / * If the ECN-CE counter reported by the peer has increased, this could * be a new congestion event. / if (ack->ecnce > ackm->peer_ecnce[pkt_space]) { ackm->peer_ecnce[pkt_space] = ack->ecnce; h = get_tx_history(ackm, pkt_space); pkt = tx_pkt_history_by_pkt_num(h, ack->ack_ranges[0].end); if (pkt == NULL) return; ecn_info.largest_acked_time = pkt->time; ackm->cc_method->on_ecn(ackm->cc_data, &ecn_info); } } int ossl_ackm_on_rx_ack_frame(OSSL_ACKM ackm, const OSSL_QUIC_FRAME_ACK ack, int pkt_space, OSSL_TIME rx_time) { OSSL_ACKM_TX_PKT na_pkts, lost_pkts; int must_set_timer = 0; if (ackm->largest_acked_pkt[pkt_space] == QUIC_PN_INVALID) ackm->largest_acked_pkt[pkt_space] = ack->ack_ranges[0].end; else ackm->largest_acked_pkt[pkt_space] = ossl_quic_pn_max(ackm->largest_acked_pkt[pkt_space], ack->ack_ranges[0].end); / * If we get an ACK in the handshake space, address validation is completed. * Make sure we update the timer, even if no packets were ACK'd. / if (!ackm->peer_completed_addr_validation && pkt_space == QUIC_PN_SPACE_HANDSHAKE) { ackm->peer_completed_addr_validation = 1; must_set_timer = 1; } / * Find packets that are newly acknowledged and remove them from the list. / na_pkts = ackm_detect_and_remove_newly_acked_pkts(ackm, ack, pkt_space); if (na_pkts == NULL) { if (must_set_timer) ackm_set_loss_detection_timer(ackm); return 1; } / * Update the RTT if the largest acknowledged is newly acked and at least * one ACK-eliciting packet was newly acked. * * First packet in the list is always the one with the largest PN. / if (na_pkts->pkt_num == ack->ack_ranges[0].end && ack_includes_ack_eliciting(na_pkts)) { OSSL_TIME now = ackm->now(ackm->now_arg), ack_delay; if (ossl_time_is_zero(ackm->first_rtt_sample)) ackm->first_rtt_sample = now; / Enforce maximum ACK delay. / ack_delay = ack->delay_time; if (ackm->handshake_confirmed) ack_delay = ossl_time_min(ack_delay, ackm->rx_max_ack_delay); ossl_statm_update_rtt(ackm->statm, ack_delay, ossl_time_subtract(now, na_pkts->time)); } / * Process ECN information if present. * * We deliberately do most ECN processing in the ACKM rather than the * congestion controller to avoid having to give the congestion controller * access to ACKM internal state. / if (ack->ecn_present) ackm_process_ecn(ackm, ack, pkt_space); / Handle inferred loss. / lost_pkts = ackm_detect_and_remove_lost_pkts(ackm, pkt_space); if (lost_pkts != NULL) ackm_on_pkts_lost(ackm, pkt_space, lost_pkts, /pseudo=/0); ackm_on_pkts_acked(ackm, na_pkts); / * Reset pto_count unless the client is unsure if the server validated the * client's address. / if (ackm->peer_completed_addr_validation) ackm->pto_count = 0; ackm_set_loss_detection_timer(ackm); return 1; } int ossl_ackm_on_pkt_space_discarded(OSSL_ACKM ackm, int pkt_space) { OSSL_ACKM_TX_PKT pkt, pnext; uint64_t num_bytes_invalidated = 0; if (ackm->discarded[pkt_space]) return 0; if (pkt_space == QUIC_PN_SPACE_HANDSHAKE) ackm->peer_completed_addr_validation = 1; for (pkt = ossl_list_tx_history_head(&get_tx_history(ackm, pkt_space)->packets); pkt != NULL; pkt = pnext) { pnext = ossl_list_tx_history_next(pkt); if (pkt->is_inflight) { ackm->bytes_in_flight -= pkt->num_bytes; num_bytes_invalidated += pkt->num_bytes; } pkt->on_discarded(pkt->cb_arg); /* may free pkt / } tx_pkt_history_destroy(&ackm->tx_history[pkt_space]); rx_pkt_history_destroy(&ackm->rx_history[pkt_space]); if (num_bytes_invalidated > 0) ackm->cc_method->on_data_invalidated(ackm->cc_data, num_bytes_invalidated); ackm->time_of_last_ack_eliciting_pkt[pkt_space] = ossl_time_zero(); ackm->loss_time[pkt_space] = ossl_time_zero(); ackm->pto_count = 0; ackm->discarded[pkt_space] = 1; ackm->ack_eliciting_bytes_in_flight[pkt_space] = 0; ackm_set_loss_detection_timer(ackm); return 1; } int ossl_ackm_on_handshake_confirmed(OSSL_ACKM ackm) { ackm->handshake_confirmed = 1; ackm->peer_completed_addr_validation = 1; ackm_set_loss_detection_timer(ackm); return 1; } static void ackm_queue_probe_anti_deadlock_handshake(OSSL_ACKM ackm) { ++ackm->pending_probe.anti_deadlock_handshake; } static void ackm_queue_probe_anti_deadlock_initial(OSSL_ACKM ackm) { ++ackm->pending_probe.anti_deadlock_initial; } static void ackm_queue_probe(OSSL_ACKM ackm, int pkt_space) { / * TODO(QUIC FUTURE): We are allowed to send either one or two probe * packets here. * Determine a strategy for when we should send two probe packets. / ++ackm->pending_probe.pto[pkt_space]; } int ossl_ackm_on_timeout(OSSL_ACKM ackm) { int pkt_space; OSSL_TIME earliest_loss_time; OSSL_ACKM_TX_PKT lost_pkts; earliest_loss_time = ackm_get_loss_time_and_space(ackm, &pkt_space); if (!ossl_time_is_zero(earliest_loss_time)) { / Time threshold loss detection. / lost_pkts = ackm_detect_and_remove_lost_pkts(ackm, pkt_space); if (lost_pkts != NULL) ackm_on_pkts_lost(ackm, pkt_space, lost_pkts, /pseudo=/0); ackm_set_loss_detection_timer(ackm); return 1; } if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0) { assert(!ackm->peer_completed_addr_validation); / * Client sends an anti-deadlock packet: Initial is padded to earn more * anti-amplification credit. A handshake packet proves address * ownership. / if (ackm->discarded[QUIC_PN_SPACE_INITIAL]) ackm_queue_probe_anti_deadlock_handshake(ackm); else ackm_queue_probe_anti_deadlock_initial(ackm); } else { / * PTO. The user of the ACKM should send new data if available, else * retransmit old data, or if neither is available, send a single PING * frame. / ackm_get_pto_time_and_space(ackm, &pkt_space); ackm_queue_probe(ackm, pkt_space); } ++ackm->pto_count; ackm_set_loss_detection_timer(ackm); return 1; } OSSL_TIME ossl_ackm_get_loss_detection_deadline(OSSL_ACKM ackm) { return ackm->loss_detection_deadline; } OSSL_ACKM_PROBE_INFO ossl_ackm_get0_probe_request(OSSL_ACKM ackm) { return &ackm->pending_probe; } int ossl_ackm_get_largest_unacked(OSSL_ACKM ackm, int pkt_space, QUIC_PN pn) { struct tx_pkt_history_st h; OSSL_ACKM_TX_PKT p; h = get_tx_history(ackm, pkt_space); p = ossl_list_tx_history_tail(&h->packets); if (p != NULL) { pn = p->pkt_num; return 1; } return 0; } / Number of ACK-eliciting packets RX'd before we always emit an ACK. / #define PKTS_BEFORE_ACK 2 / * Return 1 if emission of an ACK frame is currently desired. * * This occurs when one or more of the following conditions occurs: * * - We have flagged that we want to send an ACK frame * (for example, due to the packet threshold count being exceeded), or * * - We have exceeded the ACK flush deadline, meaning that * we have received at least one ACK-eliciting packet, but held off on * sending an ACK frame immediately in the hope that more ACK-eliciting * packets might come in, but not enough did and we are now requesting * transmission of an ACK frame anyway. * / int ossl_ackm_is_ack_desired(OSSL_ACKM ackm, int pkt_space) { return ackm->rx_ack_desired[pkt_space] \|\| (!ossl_time_is_infinite(ackm->rx_ack_flush_deadline[pkt_space]) && ossl_time_compare(ackm->now(ackm->now_arg), ackm->rx_ack_flush_deadline[pkt_space]) >= 0); } /* * Returns 1 if an ACK frame matches a given packet number. / static int ack_contains(const OSSL_QUIC_FRAME_ACK ack, QUIC_PN pkt_num) { size_t i; for (i = 0; i < ack->num_ack_ranges; ++i) if (range_contains(&ack->ack_ranges[i], pkt_num)) return 1; return 0; } /* * Returns 1 iff a PN (which we have just received) was previously reported as * implied missing (by us, in an ACK frame we previously generated). / static int ackm_is_missing(OSSL_ACKM ackm, int pkt_space, QUIC_PN pkt_num) { /* * A PN is implied missing if it is not greater than the highest PN in our * generated ACK frame, but is not matched by the frame. / return ackm->ack[pkt_space].num_ack_ranges > 0 && pkt_num <= ackm->ack[pkt_space].ack_ranges[0].end && !ack_contains(&ackm->ack[pkt_space], pkt_num); } / * Returns 1 iff our RX of a PN newly establishes the implication of missing * packets. / static int ackm_has_newly_missing(OSSL_ACKM ackm, int pkt_space) { struct rx_pkt_history_st h; h = get_rx_history(ackm, pkt_space); if (ossl_list_uint_set_is_empty(&h->set)) return 0; / * The second condition here establishes that the highest PN range in our RX * history comprises only a single PN. If there is more than one, then this * function will have returned 1 during a previous call to * ossl_ackm_on_rx_packet assuming the third condition below was met. Thus * we only return 1 when the missing PN condition is newly established. * * The third condition here establishes that the highest PN range in our RX * history is beyond (and does not border) the highest PN we have yet * reported in any ACK frame. Thus there is a gap of at least one PN between * the PNs we have ACK'd previously and the PN we have just received. / return ackm->ack[pkt_space].num_ack_ranges > 0 && ossl_list_uint_set_tail(&h->set)->range.start == ossl_list_uint_set_tail(&h->set)->range.end && ossl_list_uint_set_tail(&h->set)->range.start > ackm->ack[pkt_space].ack_ranges[0].end + 1; } static void ackm_set_flush_deadline(OSSL_ACKM ackm, int pkt_space, OSSL_TIME deadline) { ackm->rx_ack_flush_deadline[pkt_space] = deadline; if (ackm->ack_deadline_cb != NULL) ackm->ack_deadline_cb(ossl_ackm_get_ack_deadline(ackm, pkt_space), pkt_space, ackm->ack_deadline_cb_arg); } /* Explicitly flags that we want to generate an ACK frame. / static void ackm_queue_ack(OSSL_ACKM ackm, int pkt_space) { ackm->rx_ack_desired[pkt_space] = 1; /* Cancel deadline. / ackm_set_flush_deadline(ackm, pkt_space, ossl_time_infinite()); } static void ackm_on_rx_ack_eliciting(OSSL_ACKM ackm, OSSL_TIME rx_time, int pkt_space, int was_missing) { OSSL_TIME tx_max_ack_delay; if (ackm->rx_ack_desired[pkt_space]) /* ACK generation already requested so nothing to do. / return; ++ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space]; if (!ackm->rx_ack_generated[pkt_space] \|\| was_missing \|\| ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space] >= PKTS_BEFORE_ACK \|\| ackm_has_newly_missing(ackm, pkt_space)) { / * Either: * * - We have never yet generated an ACK frame, meaning that this * is the first ever packet received, which we should always * acknowledge immediately, or * * - We previously reported the PN that we have just received as * missing in a previous ACK frame (meaning that we should report * the fact that we now have it to the peer immediately), or * * - We have exceeded the ACK-eliciting packet threshold count * for the purposes of ACK coalescing, so request transmission * of an ACK frame, or * * - The PN we just received and added to our PN RX history * newly implies one or more missing PNs, in which case we should * inform the peer by sending an ACK frame immediately. * * We do not test the ACK flush deadline here because it is tested * separately in ossl_ackm_is_ack_desired. / ackm_queue_ack(ackm, pkt_space); return; } / * Not emitting an ACK yet. * * Update the ACK flush deadline. * * RFC 9000 s. 13.2.1: "An endpoint MUST acknowledge all ack-eliciting * Initial and Handshake packets immediately"; don't delay ACK generation if * we are using the Initial or Handshake PN spaces. / tx_max_ack_delay = ackm->tx_max_ack_delay; if (pkt_space == QUIC_PN_SPACE_INITIAL \|\| pkt_space == QUIC_PN_SPACE_HANDSHAKE) tx_max_ack_delay = ossl_time_zero(); if (ossl_time_is_infinite(ackm->rx_ack_flush_deadline[pkt_space])) ackm_set_flush_deadline(ackm, pkt_space, ossl_time_add(rx_time, tx_max_ack_delay)); else ackm_set_flush_deadline(ackm, pkt_space, ossl_time_min(ackm->rx_ack_flush_deadline[pkt_space], ossl_time_add(rx_time, tx_max_ack_delay))); } int ossl_ackm_on_rx_packet(OSSL_ACKM ackm, const OSSL_ACKM_RX_PKT pkt) { struct rx_pkt_history_st h = get_rx_history(ackm, pkt->pkt_space); int was_missing; if (ossl_ackm_is_rx_pn_processable(ackm, pkt->pkt_num, pkt->pkt_space) != 1) /* PN has already been processed or written off, no-op. / return 1; / * Record the largest PN we have RX'd and the time we received it. * We use this to calculate the ACK delay field of ACK frames. / if (pkt->pkt_num > ackm->rx_largest_pn[pkt->pkt_space]) { ackm->rx_largest_pn[pkt->pkt_space] = pkt->pkt_num; ackm->rx_largest_time[pkt->pkt_space] = pkt->time; } / * If the PN we just received was previously implied missing by virtue of * being omitted from a previous ACK frame generated, we skip any packet * count thresholds or coalescing delays and emit a new ACK frame * immediately. / was_missing = ackm_is_missing(ackm, pkt->pkt_space, pkt->pkt_num); / * Add the packet number to our history list of PNs we have not yet provably * acked. / if (rx_pkt_history_add_pn(h, pkt->pkt_num) != 1) return 0; / * Receiving this packet may or may not cause us to emit an ACK frame. * We may not emit an ACK frame yet if we have not yet received a threshold * number of packets. / if (pkt->is_ack_eliciting) ackm_on_rx_ack_eliciting(ackm, pkt->time, pkt->pkt_space, was_missing); / Update the ECN counters according to which ECN signal we got, if any. / switch (pkt->ecn) { case OSSL_ACKM_ECN_ECT0: ++ackm->rx_ect0[pkt->pkt_space]; break; case OSSL_ACKM_ECN_ECT1: ++ackm->rx_ect1[pkt->pkt_space]; break; case OSSL_ACKM_ECN_ECNCE: ++ackm->rx_ecnce[pkt->pkt_space]; break; default: break; } return 1; } static void ackm_fill_rx_ack_ranges(OSSL_ACKM ackm, int pkt_space, OSSL_QUIC_FRAME_ACK ack) { struct rx_pkt_history_st h = get_rx_history(ackm, pkt_space); UINT_SET_ITEM x; size_t i = 0; / * Copy out ranges from the PN set, starting at the end, until we reach our * maximum number of ranges. / for (x = ossl_list_uint_set_tail(&h->set); x != NULL && i < OSSL_NELEM(ackm->ack_ranges); x = ossl_list_uint_set_prev(x), ++i) { ackm->ack_ranges[pkt_space][i].start = x->range.start; ackm->ack_ranges[pkt_space][i].end = x->range.end; } ack->ack_ranges = ackm->ack_ranges[pkt_space]; ack->num_ack_ranges = i; } const OSSL_QUIC_FRAME_ACK ossl_ackm_get_ack_frame(OSSL_ACKM ackm, int pkt_space) { OSSL_QUIC_FRAME_ACK ack = &ackm->ack[pkt_space]; OSSL_TIME now = ackm->now(ackm->now_arg); ackm_fill_rx_ack_ranges(ackm, pkt_space, ack); if (!ossl_time_is_zero(ackm->rx_largest_time[pkt_space]) && ossl_time_compare(now, ackm->rx_largest_time[pkt_space]) > 0 && pkt_space == QUIC_PN_SPACE_APP) ack->delay_time = ossl_time_subtract(now, ackm->rx_largest_time[pkt_space]); else ack->delay_time = ossl_time_zero(); ack->ect0 = ackm->rx_ect0[pkt_space]; ack->ect1 = ackm->rx_ect1[pkt_space]; ack->ecnce = ackm->rx_ecnce[pkt_space]; ack->ecn_present = 1; ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space] = 0; ackm->rx_ack_generated[pkt_space] = 1; ackm->rx_ack_desired[pkt_space] = 0; ackm_set_flush_deadline(ackm, pkt_space, ossl_time_infinite()); return ack; } OSSL_TIME ossl_ackm_get_ack_deadline(OSSL_ACKM ackm, int pkt_space) { if (ackm->rx_ack_desired[pkt_space]) / Already desired, deadline is now. / return ossl_time_zero(); return ackm->rx_ack_flush_deadline[pkt_space]; } int ossl_ackm_is_rx_pn_processable(OSSL_ACKM ackm, QUIC_PN pn, int pkt_space) { struct rx_pkt_history_st h = get_rx_history(ackm, pkt_space); return pn >= h->watermark && ossl_uint_set_query(&h->set, pn) == 0; } void ossl_ackm_set_loss_detection_deadline_callback(OSSL_ACKM ackm, void (fn)(OSSL_TIME deadline, void arg), void arg) { ackm->loss_detection_deadline_cb = fn; ackm->loss_detection_deadline_cb_arg = arg; } void ossl_ackm_set_ack_deadline_callback(OSSL_ACKM ackm, void (fn)(OSSL_TIME deadline, int pkt_space, void arg), void arg) { ackm->ack_deadline_cb = fn; ackm->ack_deadline_cb_arg = arg; } int ossl_ackm_mark_packet_pseudo_lost(OSSL_ACKM ackm, int pkt_space, QUIC_PN pn) { struct tx_pkt_history_st h = get_tx_history(ackm, pkt_space); OSSL_ACKM_TX_PKT pkt; pkt = tx_pkt_history_by_pkt_num(h, pn); if (pkt == NULL) return 0; tx_pkt_history_remove(h, pkt->pkt_num); pkt->lnext = NULL; ackm_on_pkts_lost(ackm, pkt_space, pkt, /pseudo=/1); return 1; } OSSL_TIME ossl_ackm_get_pto_duration(OSSL_ACKM ackm) { OSSL_TIME duration; OSSL_RTT_INFO rtt; ossl_statm_get_rtt_info(ackm->statm, &rtt); duration = ossl_time_add(rtt.smoothed_rtt, ossl_time_max(ossl_time_multiply(rtt.rtt_variance, 4), ossl_ticks2time(K_GRANULARITY))); if (!ossl_time_is_infinite(ackm->rx_max_ack_delay)) duration = ossl_time_add(duration, ackm->rx_max_ack_delay); return duration; } QUIC_PN ossl_ackm_get_largest_acked(OSSL_ACKM ackm, int pkt_space) { return ackm->largest_acked_pkt[pkt_space]; } void ossl_ackm_set_rx_max_ack_delay(OSSL_ACKM ackm, OSSL_TIME rx_max_ack_delay) { ackm->rx_max_ack_delay = rx_max_ack_delay; } void ossl_ackm_set_tx_max_ack_delay(OSSL_ACKM ackm, OSSL_TIME tx_max_ack_delay) { ackm->tx_max_ack_delay = tx_max_ack_delay; }
./openssl/ssl/quic/quic_srt_gen.c	/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_srt_gen.h" #include <openssl/core_names.h> #include <openssl/evp.h> struct quic_srt_gen_st { EVP_MAC mac; EVP_MAC_CTX mac_ctx; }; / * Simple HMAC-SHA256-based stateless reset token generator. / QUIC_SRT_GEN ossl_quic_srt_gen_new(OSSL_LIB_CTX libctx, const char propq, const unsigned char key, size_t key_len) { QUIC_SRT_GEN srt_gen; OSSL_PARAM params[3], p = params; if ((srt_gen = OPENSSL_zalloc(sizeof(srt_gen))) == NULL) return NULL; if ((srt_gen->mac = EVP_MAC_fetch(libctx, "HMAC", propq)) == NULL) goto err; if ((srt_gen->mac_ctx = EVP_MAC_CTX_new(srt_gen->mac)) == NULL) goto err; p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, "SHA256", 7); if (propq != NULL) p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_PROPERTIES, (char )propq, 0); p++ = OSSL_PARAM_construct_end(); if (!EVP_MAC_init(srt_gen->mac_ctx, key, key_len, params)) goto err; return srt_gen; err: ossl_quic_srt_gen_free(srt_gen); return NULL; } void ossl_quic_srt_gen_free(QUIC_SRT_GEN srt_gen) { if (srt_gen == NULL) return; EVP_MAC_CTX_free(srt_gen->mac_ctx); EVP_MAC_free(srt_gen->mac); OPENSSL_free(srt_gen); } int ossl_quic_srt_gen_calculate_token(QUIC_SRT_GEN srt_gen, const QUIC_CONN_ID dcid, QUIC_STATELESS_RESET_TOKEN token) { size_t outl = 0; unsigned char mac[SHA256_DIGEST_LENGTH]; if (!EVP_MAC_init(srt_gen->mac_ctx, NULL, 0, NULL)) return 0; if (!EVP_MAC_update(srt_gen->mac_ctx, (const unsigned char *)dcid->id, dcid->id_len)) return 0; if (!EVP_MAC_final(srt_gen->mac_ctx, mac, &outl, sizeof(mac)) \|\| outl != sizeof(mac)) return 0; assert(sizeof(mac) >= sizeof(token->token)); memcpy(token->token, mac, sizeof(token->token)); return 1; }
./openssl/ssl/quic/quic_rcidm.c	/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_rcidm.h" #include "internal/priority_queue.h" #include "internal/list.h" #include "internal/common.h" / * QUIC Remote Connection ID Manager * ================================= * * We can receive an arbitrary number of RCIDs via NCID frames. Periodically, we * may desire (for example for anti-connection fingerprinting reasons, etc.) * to switch to a new RCID according to some arbitrary policy such as the number * of packets we have sent. * * When we do this we should move to the next RCID in the sequence of received * RCIDs ordered by sequence number. For example, if a peer sends us three NCID * frames with sequence numbers 10, 11, 12, we should seek to consume these * RCIDs in order. * * However, due to the possibility of packet reordering in the network, NCID * frames might be received out of order. Thus if a peer sends us NCID frames * with sequence numbers 12, 10, 11, we should still consume the RCID with * sequence number 10 before consuming the RCIDs with sequence numbers 11 or 12. * * We use a priority queue for this purpose. / static void rcidm_update(QUIC_RCIDM rcidm); static void rcidm_set_preferred_rcid(QUIC_RCIDM rcidm, const QUIC_CONN_ID rcid); #define PACKETS_PER_RCID 10000 #define INITIAL_SEQ_NUM 0 #define PREF_ADDR_SEQ_NUM 1 /* * RCID * ==== * * The RCID structure is used to track RCIDs which have sequence numbers (i.e., * INITIAL, PREF_ADDR and NCID type RCIDs). The RCIDs without sequence numbers * (Initial ODCIDs and Retry ODCIDs), hereafter referred to as unnumbered RCIDs, * can logically be viewed as their own type of RCID but are tracked separately * as singletons without needing a discrete structure. * * At any given time an RCID object is in one of these states: * * * (start) * \| * [add] * \| * _____v_____ ___________ ____________ * \| \| \| \| \| \| * \| PENDING \| --[select]--> \| CURRENT \| --[retire]--> \| RETIRING \| * \|___________\| \|___________\| \|____________\| * \| * [pop] * \| * v * (fin) * * The transition through the states is monotonic and irreversible. * The RCID object is freed when it is popped. * * PENDING * Invariants: * rcid->state == RCID_STATE_PENDING; * rcid->pq_idx != SIZE_MAX (debug assert only); * the RCID is not the current RCID, rcidm->cur_rcid != rcid; * the RCID is in the priority queue; * the RCID is not in the retiring_list. * * CURRENT * Invariants: * rcid->state == RCID_STATE_CUR; * rcid->pq_idx == SIZE_MAX (debug assert only); * the RCID is the current RCID, rcidm->cur_rcid == rcid; * the RCID is not in the priority queue; * the RCID is not in the retiring_list. * * RETIRING * Invariants: * rcid->state == RCID_STATE_RETIRING; * rcid->pq_idx == SIZE_MAX (debug assert only); * the RCID is not the current RCID, rcidm->cur_rcid != rcid; * the RCID is not in the priority queue; * the RCID is in the retiring_list. * * Invariant: At most one RCID object is in the CURRENT state at any one time. * * (If no RCID object is in the CURRENT state, this means either * an unnumbered RCID is being used as the preferred RCID * or we currently have no preferred RCID.) * * All of the above states can be considered substates of the 'ACTIVE' state * for an RCID as specified in RFC 9000. A CID only ceases to be active * when we send a RETIRE_CONN_ID frame, which is the responsibility of the * user of the RCIDM and happens after the above state machine is terminated. / enum { RCID_STATE_PENDING, RCID_STATE_CUR, RCID_STATE_RETIRING }; enum { RCID_TYPE_INITIAL, / CID is from an peer INITIAL packet (seq 0) / RCID_TYPE_PREF_ADDR, / CID is from a preferred_address TPARAM (seq 1) / RCID_TYPE_NCID / CID is from a NCID frame / / * INITIAL_ODCID and RETRY_ODCID also conceptually exist but are tracked * separately. / }; typedef struct rcid_st { OSSL_LIST_MEMBER(retiring, struct rcid_st); / valid iff RETIRING / QUIC_CONN_ID cid; / The actual CID string for this RCID / uint64_t seq_num; size_t pq_idx; / Index of entry into priority queue / unsigned int state : 2; / RCID_STATE_* / unsigned int type : 2; / RCID_TYPE_* / } RCID; DEFINE_PRIORITY_QUEUE_OF(RCID); DEFINE_LIST_OF(retiring, RCID); / * RCID Manager * ============ * * The following "business logic" invariants also apply to the RCIDM * as a whole: * * Invariant: An RCID of INITIAL type has a sequence number of 0. * Invariant: An RCID of PREF_ADDR type has a sequence number of 1. * * Invariant: There is never more than one Initial ODCID * added throughout the lifetime of an RCIDM. * Invariant: There is never more than one Retry ODCID * added throughout the lifetime of an RCIDM. * Invariant: There is never more than one INITIAL RCID created * throughout the lifetime of an RCIDM. * Invariant: There is never more than one PREF_ADDR RCID created * throughout the lifetime of an RCIDM. * Invariant: No INITIAL or PREF_ADDR RCID may be added after * the handshake is completed. * / struct quic_rcidm_st { / * The current RCID we prefer to use (value undefined if * !have_preferred_rcid). * * This is preferentially set to a numbered RCID (represented by an RCID * object) if we have one (in which case preferred_rcid == cur_rcid->cid); * otherwise it is set to one of the unnumbered RCIDs (the Initial ODCID or * Retry ODCID) if available (and cur_rcid == NULL). / QUIC_CONN_ID preferred_rcid; / * These are initialized if the corresponding added_ flags are set. / QUIC_CONN_ID initial_odcid, retry_odcid; / * Total number of packets sent since we last made a packet count-based RCID * update decision. / uint64_t packets_sent; / Number of post-handshake RCID changes we have performed. / uint64_t num_changes; / * The Retire Prior To watermark value; max(retire_prior_to) of all received * NCID frames. / uint64_t retire_prior_to; / (SORT BY seq_num ASC) -> (RCID ) / PRIORITY_QUEUE_OF(RCID) rcids; / * Current RCID object we are using. This may differ from the first item in * the priority queue if we received NCID frames out of order. For example * if we get seq 5, switch to it immediately, then get seq 4, we want to * keep using seq 5 until we decide to roll again rather than immediately * switch to seq 4. Never points to an object on the retiring_list. / RCID cur_rcid; /* * When a RCID becomes pending-retirement, it is moved to the retiring_list, * then freed when it is popped from the retired queue. We use a list for * this rather than a priority queue as the order in which items are freed * does not matter. We always append to the tail of the list in order to * maintain the guarantee that the head (if present) only changes when a * caller calls pop(). / OSSL_LIST(retiring) retiring_list; / Number of entries on the retiring_list. / size_t num_retiring; / preferred_rcid has been changed? / unsigned int preferred_rcid_changed : 1; / Do we have any RCID we can use currently? / unsigned int have_preferred_rcid : 1; / QUIC handshake has been completed? / unsigned int handshake_complete : 1; / odcid was set (not necessarily still valid as a RCID)? / unsigned int added_initial_odcid : 1; / retry_odcid was set (not necessarily still valid as a RCID?) / unsigned int added_retry_odcid : 1; / An initial RCID was added as an RCID structure? / unsigned int added_initial_rcid : 1; / Has a RCID roll been manually requested? / unsigned int roll_requested : 1; }; / * Caller must periodically pop retired RCIDs and handle them. If the caller * fails to do so, fail safely rather than start exhibiting integer rollover. * Limit the total number of numbered RCIDs to an implausibly large but safe * value. / #define MAX_NUMBERED_RCIDS (SIZE_MAX / 2) static void rcidm_transition_rcid(QUIC_RCIDM rcidm, RCID rcid, unsigned int state); / Check invariants of an RCID / static void rcidm_check_rcid(QUIC_RCIDM rcidm, RCID rcid) { assert(rcid->state == RCID_STATE_PENDING \|\| rcid->state == RCID_STATE_CUR \|\| rcid->state == RCID_STATE_RETIRING); assert((rcid->state == RCID_STATE_PENDING) == (rcid->pq_idx != SIZE_MAX)); assert((rcid->state == RCID_STATE_CUR) == (rcidm->cur_rcid == rcid)); assert((ossl_list_retiring_next(rcid) != NULL \|\| ossl_list_retiring_prev(rcid) != NULL \|\| ossl_list_retiring_head(&rcidm->retiring_list) == rcid) == (rcid->state == RCID_STATE_RETIRING)); assert(rcid->type != RCID_TYPE_INITIAL \|\| rcid->seq_num == 0); assert(rcid->type != RCID_TYPE_PREF_ADDR \|\| rcid->seq_num == 1); assert(rcid->seq_num <= OSSL_QUIC_VLINT_MAX); assert(rcid->cid.id_len > 0 && rcid->cid.id_len <= QUIC_MAX_CONN_ID_LEN); assert(rcid->seq_num >= rcidm->retire_prior_to \|\| rcid->state == RCID_STATE_RETIRING); assert(rcidm->num_changes == 0 \|\| rcidm->handshake_complete); assert(rcid->state != RCID_STATE_RETIRING \|\| rcidm->num_retiring > 0); } static int rcid_cmp(const RCID a, const RCID b) { if (a->seq_num < b->seq_num) return -1; if (a->seq_num > b->seq_num) return 1; return 0; } QUIC_RCIDM ossl_quic_rcidm_new(const QUIC_CONN_ID initial_odcid) { QUIC_RCIDM rcidm; if ((rcidm = OPENSSL_zalloc(sizeof(rcidm))) == NULL) return NULL; if ((rcidm->rcids = ossl_pqueue_RCID_new(rcid_cmp)) == NULL) { OPENSSL_free(rcidm); return NULL; } if (initial_odcid != NULL) { rcidm->initial_odcid = initial_odcid; rcidm->added_initial_odcid = 1; } rcidm_update(rcidm); return rcidm; } void ossl_quic_rcidm_free(QUIC_RCIDM rcidm) { RCID rcid, rnext; if (rcidm == NULL) return; OPENSSL_free(rcidm->cur_rcid); while ((rcid = ossl_pqueue_RCID_pop(rcidm->rcids)) != NULL) OPENSSL_free(rcid); LIST_FOREACH_DELSAFE(rcid, rnext, retiring, &rcidm->retiring_list) OPENSSL_free(rcid); ossl_pqueue_RCID_free(rcidm->rcids); OPENSSL_free(rcidm); } static void rcidm_set_preferred_rcid(QUIC_RCIDM rcidm, const QUIC_CONN_ID rcid) { if (rcid == NULL) { rcidm->preferred_rcid_changed = 1; rcidm->have_preferred_rcid = 0; return; } if (ossl_quic_conn_id_eq(&rcidm->preferred_rcid, rcid)) return; rcidm->preferred_rcid = rcid; rcidm->preferred_rcid_changed = 1; rcidm->have_preferred_rcid = 1; } /* * RCID Lifecycle Management * ========================= / static RCID rcidm_create_rcid(QUIC_RCIDM rcidm, uint64_t seq_num, const QUIC_CONN_ID cid, unsigned int type) { RCID rcid; if (cid->id_len < 1 \|\| cid->id_len > QUIC_MAX_CONN_ID_LEN \|\| seq_num > OSSL_QUIC_VLINT_MAX \|\| ossl_pqueue_RCID_num(rcidm->rcids) + rcidm->num_retiring > MAX_NUMBERED_RCIDS) return NULL; if ((rcid = OPENSSL_zalloc(sizeof(rcid))) == NULL) return NULL; rcid->seq_num = seq_num; rcid->cid = cid; rcid->type = type; if (rcid->seq_num >= rcidm->retire_prior_to) { rcid->state = RCID_STATE_PENDING; if (!ossl_pqueue_RCID_push(rcidm->rcids, rcid, &rcid->pq_idx)) { OPENSSL_free(rcid); return NULL; } } else { / RCID is immediately retired upon creation. / rcid->state = RCID_STATE_RETIRING; rcid->pq_idx = SIZE_MAX; ossl_list_retiring_insert_tail(&rcidm->retiring_list, rcid); ++rcidm->num_retiring; } rcidm_check_rcid(rcidm, rcid); return rcid; } static void rcidm_transition_rcid(QUIC_RCIDM rcidm, RCID rcid, unsigned int state) { unsigned int old_state = rcid->state; assert(state >= old_state && state <= RCID_STATE_RETIRING); rcidm_check_rcid(rcidm, rcid); if (state == old_state) return; if (rcidm->cur_rcid != NULL && state == RCID_STATE_CUR) { rcidm_transition_rcid(rcidm, rcidm->cur_rcid, RCID_STATE_RETIRING); assert(rcidm->cur_rcid == NULL); } if (old_state == RCID_STATE_PENDING) { ossl_pqueue_RCID_remove(rcidm->rcids, rcid->pq_idx); rcid->pq_idx = SIZE_MAX; } rcid->state = state; if (state == RCID_STATE_CUR) { rcidm->cur_rcid = rcid; } else if (state == RCID_STATE_RETIRING) { if (old_state == RCID_STATE_CUR) rcidm->cur_rcid = NULL; ossl_list_retiring_insert_tail(&rcidm->retiring_list, rcid); ++rcidm->num_retiring; } rcidm_check_rcid(rcidm, rcid); } static void rcidm_free_rcid(QUIC_RCIDM rcidm, RCID rcid) { if (rcid == NULL) return; rcidm_check_rcid(rcidm, rcid); switch (rcid->state) { case RCID_STATE_PENDING: ossl_pqueue_RCID_remove(rcidm->rcids, rcid->pq_idx); break; case RCID_STATE_CUR: rcidm->cur_rcid = NULL; break; case RCID_STATE_RETIRING: ossl_list_retiring_remove(&rcidm->retiring_list, rcid); --rcidm->num_retiring; break; default: assert(0); break; } OPENSSL_free(rcid); } static void rcidm_handle_retire_prior_to(QUIC_RCIDM rcidm, uint64_t retire_prior_to) { RCID rcid; if (retire_prior_to <= rcidm->retire_prior_to) return; / * Retire the current RCID (if any) if it is affected. / if (rcidm->cur_rcid != NULL && rcidm->cur_rcid->seq_num < retire_prior_to) rcidm_transition_rcid(rcidm, rcidm->cur_rcid, RCID_STATE_RETIRING); / * Any other RCIDs needing retirement will be at the start of the priority * queue, so just stop once we see a higher sequence number exceeding the * threshold. / while ((rcid = ossl_pqueue_RCID_peek(rcidm->rcids)) != NULL && rcid->seq_num < retire_prior_to) rcidm_transition_rcid(rcidm, rcid, RCID_STATE_RETIRING); rcidm->retire_prior_to = retire_prior_to; } / * Decision Logic * ============== / static void rcidm_roll(QUIC_RCIDM rcidm) { RCID rcid; if ((rcid = ossl_pqueue_RCID_peek(rcidm->rcids)) == NULL) return; rcidm_transition_rcid(rcidm, rcid, RCID_STATE_CUR); ++rcidm->num_changes; rcidm->roll_requested = 0; if (rcidm->packets_sent >= PACKETS_PER_RCID) rcidm->packets_sent %= PACKETS_PER_RCID; else rcidm->packets_sent = 0; } static void rcidm_update(QUIC_RCIDM rcidm) { RCID rcid; / * If we have no current numbered RCID but have one or more pending, use it. / if (rcidm->cur_rcid == NULL && (rcid = ossl_pqueue_RCID_peek(rcidm->rcids)) != NULL) { rcidm_transition_rcid(rcidm, rcid, RCID_STATE_CUR); assert(rcidm->cur_rcid != NULL); } / Prefer use of any current numbered RCID we have, if possible. / if (rcidm->cur_rcid != NULL) { rcidm_check_rcid(rcidm, rcidm->cur_rcid); rcidm_set_preferred_rcid(rcidm, &rcidm->cur_rcid->cid); return; } / * If there are no RCIDs from NCID frames we can use, go through the various * kinds of bootstrapping RCIDs we can use in order of priority. / if (rcidm->added_retry_odcid && !rcidm->handshake_complete) { rcidm_set_preferred_rcid(rcidm, &rcidm->retry_odcid); return; } if (rcidm->added_initial_odcid && !rcidm->handshake_complete) { rcidm_set_preferred_rcid(rcidm, &rcidm->initial_odcid); return; } / We don't know of any usable RCIDs / rcidm_set_preferred_rcid(rcidm, NULL); } static int rcidm_should_roll(QUIC_RCIDM rcidm) { /* * Always switch as soon as possible if handshake completes; * and every n packets after handshake completes or the last roll; and * whenever manually requested. / return rcidm->handshake_complete && (rcidm->num_changes == 0 \|\| rcidm->packets_sent >= PACKETS_PER_RCID \|\| rcidm->roll_requested); } static void rcidm_tick(QUIC_RCIDM rcidm) { if (rcidm_should_roll(rcidm)) rcidm_roll(rcidm); rcidm_update(rcidm); } /* * Events * ====== / void ossl_quic_rcidm_on_handshake_complete(QUIC_RCIDM rcidm) { if (rcidm->handshake_complete) return; rcidm->handshake_complete = 1; rcidm_tick(rcidm); } void ossl_quic_rcidm_on_packet_sent(QUIC_RCIDM rcidm, uint64_t num_packets) { if (num_packets == 0) return; rcidm->packets_sent += num_packets; rcidm_tick(rcidm); } void ossl_quic_rcidm_request_roll(QUIC_RCIDM rcidm) { rcidm->roll_requested = 1; rcidm_tick(rcidm); } /* * Mutation Operations * =================== / int ossl_quic_rcidm_add_from_initial(QUIC_RCIDM rcidm, const QUIC_CONN_ID rcid) { RCID rcid_obj; if (rcidm->added_initial_rcid \|\| rcidm->handshake_complete) return 0; rcid_obj = rcidm_create_rcid(rcidm, INITIAL_SEQ_NUM, rcid, RCID_TYPE_INITIAL); if (rcid_obj == NULL) return 0; rcidm->added_initial_rcid = 1; rcidm_tick(rcidm); return 1; } int ossl_quic_rcidm_add_from_server_retry(QUIC_RCIDM rcidm, const QUIC_CONN_ID retry_odcid) { if (rcidm->added_retry_odcid \|\| rcidm->handshake_complete) return 0; rcidm->retry_odcid = retry_odcid; rcidm->added_retry_odcid = 1; rcidm_tick(rcidm); return 1; } int ossl_quic_rcidm_add_from_ncid(QUIC_RCIDM rcidm, const OSSL_QUIC_FRAME_NEW_CONN_ID ncid) { RCID rcid; rcid = rcidm_create_rcid(rcidm, ncid->seq_num, &ncid->conn_id, RCID_TYPE_NCID); if (rcid == NULL) return 0; rcidm_handle_retire_prior_to(rcidm, ncid->retire_prior_to); rcidm_tick(rcidm); return 1; } /* * Queries * ======= / static int rcidm_get_retire(QUIC_RCIDM rcidm, uint64_t seq_num, int peek) { RCID rcid = ossl_list_retiring_head(&rcidm->retiring_list); if (rcid == NULL) return 0; if (seq_num != NULL) seq_num = rcid->seq_num; if (!peek) rcidm_free_rcid(rcidm, rcid); return 1; } int ossl_quic_rcidm_pop_retire_seq_num(QUIC_RCIDM rcidm, uint64_t seq_num) { return rcidm_get_retire(rcidm, seq_num, /peek=/0); } int ossl_quic_rcidm_peek_retire_seq_num(QUIC_RCIDM rcidm, uint64_t seq_num) { return rcidm_get_retire(rcidm, seq_num, /peek=/1); } int ossl_quic_rcidm_get_preferred_tx_dcid(QUIC_RCIDM rcidm, QUIC_CONN_ID tx_dcid) { if (!rcidm->have_preferred_rcid) return 0; tx_dcid = rcidm->preferred_rcid; return 1; } int ossl_quic_rcidm_get_preferred_tx_dcid_changed(QUIC_RCIDM rcidm, int clear) { int r = rcidm->preferred_rcid_changed; if (clear) rcidm->preferred_rcid_changed = 0; return r; } size_t ossl_quic_rcidm_get_num_active(const QUIC_RCIDM rcidm) { return ossl_pqueue_RCID_num(rcidm->rcids) + (rcidm->cur_rcid != NULL ? 1 : 0) + ossl_quic_rcidm_get_num_retiring(rcidm); } size_t ossl_quic_rcidm_get_num_retiring(const QUIC_RCIDM *rcidm) { return rcidm->num_retiring; }
./openssl/ssl/quic/quic_sf_list.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/uint_set.h" #include "internal/common.h" #include "internal/quic_sf_list.h" struct stream_frame_st { struct stream_frame_st prev, next; UINT_RANGE range; OSSL_QRX_PKT pkt; const unsigned char data; }; static void stream_frame_free(SFRAME_LIST fl, STREAM_FRAME sf) { if (fl->cleanse && sf->data != NULL) OPENSSL_cleanse((unsigned char )sf->data, (size_t)(sf->range.end - sf->range.start)); ossl_qrx_pkt_release(sf->pkt); OPENSSL_free(sf); } static STREAM_FRAME stream_frame_new(UINT_RANGE range, OSSL_QRX_PKT pkt, const unsigned char data) { STREAM_FRAME sf = OPENSSL_zalloc(sizeof(sf)); if (sf == NULL) return NULL; if (pkt != NULL) ossl_qrx_pkt_up_ref(pkt); sf->range = range; sf->pkt = pkt; sf->data = data; return sf; } void ossl_sframe_list_init(SFRAME_LIST fl) { memset(fl, 0, sizeof(fl)); } void ossl_sframe_list_destroy(SFRAME_LIST fl) { STREAM_FRAME sf, next_frame; for (sf = fl->head; sf != NULL; sf = next_frame) { next_frame = sf->next; stream_frame_free(fl, sf); } } static int append_frame(SFRAME_LIST fl, UINT_RANGE range, OSSL_QRX_PKT pkt, const unsigned char data) { STREAM_FRAME new_frame; if ((new_frame = stream_frame_new(range, pkt, data)) == NULL) return 0; new_frame->prev = fl->tail; if (fl->tail != NULL) fl->tail->next = new_frame; fl->tail = new_frame; ++fl->num_frames; return 1; } int ossl_sframe_list_insert(SFRAME_LIST fl, UINT_RANGE range, OSSL_QRX_PKT pkt, const unsigned char data, int fin) { STREAM_FRAME sf, new_frame, prev_frame, next_frame; #ifndef NDEBUG uint64_t curr_end = fl->tail != NULL ? fl->tail->range.end : fl->offset; / This check for FINAL_SIZE_ERROR is handled by QUIC FC already / assert((!fin \|\| curr_end <= range->end) && (!fl->fin \|\| curr_end >= range->end)); #endif if (fl->offset >= range->end) goto end; / nothing there yet / if (fl->tail == NULL) { fl->tail = fl->head = stream_frame_new(range, pkt, data); if (fl->tail == NULL) return 0; ++fl->num_frames; goto end; } / optimize insertion at the end / if (fl->tail->range.start < range->start) { if (fl->tail->range.end >= range->end) goto end; if (!append_frame(fl, range, pkt, data)) return 0; goto end; } prev_frame = NULL; for (sf = fl->head; sf != NULL && sf->range.start < range->start; sf = sf->next) prev_frame = sf; if (!ossl_assert(sf != NULL)) / frame list invariant broken / return 0; if (prev_frame != NULL && prev_frame->range.end >= range->end) goto end; / * Now we must create a new frame although in the end we might drop it, * because we will be potentially dropping existing overlapping frames. / new_frame = stream_frame_new(range, pkt, data); if (new_frame == NULL) return 0; for (next_frame = sf; next_frame != NULL && next_frame->range.end <= range->end;) { STREAM_FRAME drop_frame = next_frame; next_frame = next_frame->next; if (next_frame != NULL) next_frame->prev = drop_frame->prev; if (prev_frame != NULL) prev_frame->next = drop_frame->next; if (fl->head == drop_frame) fl->head = next_frame; if (fl->tail == drop_frame) fl->tail = prev_frame; --fl->num_frames; stream_frame_free(fl, drop_frame); } if (next_frame != NULL) { /* check whether the new_frame is redundant because there is no gap / if (prev_frame != NULL && next_frame->range.start <= prev_frame->range.end) { stream_frame_free(fl, new_frame); goto end; } next_frame->prev = new_frame; } else { fl->tail = new_frame; } new_frame->next = next_frame; new_frame->prev = prev_frame; if (prev_frame != NULL) prev_frame->next = new_frame; else fl->head = new_frame; ++fl->num_frames; end: fl->fin = fin \|\| fl->fin; return 1; } int ossl_sframe_list_peek(const SFRAME_LIST fl, void *iter, UINT_RANGE range, const unsigned char *data, int fin) { STREAM_FRAME sf = iter; uint64_t start; if (sf == NULL) { start = fl->offset; sf = fl->head; } else { start = sf->range.end; sf = sf->next; } range->start = start; if (sf == NULL \|\| sf->range.start > start \|\| !ossl_assert(start < sf->range.end)) { range->end = start; data = NULL; iter = NULL; /* set fin only if we are at the end / fin = sf == NULL ? fl->fin : 0; return 0; } range->end = sf->range.end; if (sf->data != NULL) data = sf->data + (start - sf->range.start); else data = NULL; fin = sf->next == NULL ? fl->fin : 0; iter = sf; return 1; } int ossl_sframe_list_drop_frames(SFRAME_LIST fl, uint64_t limit) { STREAM_FRAME sf; /* offset cannot move back or past the data received / if (!ossl_assert(limit >= fl->offset) \|\| !ossl_assert(fl->tail == NULL \|\| limit <= fl->tail->range.end) \|\| !ossl_assert(fl->tail != NULL \|\| limit == fl->offset)) return 0; fl->offset = limit; for (sf = fl->head; sf != NULL && sf->range.end <= limit;) { STREAM_FRAME drop_frame = sf; sf = sf->next; --fl->num_frames; stream_frame_free(fl, drop_frame); } fl->head = sf; if (sf != NULL) sf->prev = NULL; else fl->tail = NULL; fl->head_locked = 0; return 1; } int ossl_sframe_list_lock_head(SFRAME_LIST fl, UINT_RANGE range, const unsigned char *data, int fin) { int ret; void iter = NULL; if (fl->head_locked) return 0; ret = ossl_sframe_list_peek(fl, &iter, range, data, fin); if (ret) fl->head_locked = 1; return ret; } int ossl_sframe_list_is_head_locked(SFRAME_LIST fl) { return fl->head_locked; } int ossl_sframe_list_move_data(SFRAME_LIST fl, sframe_list_write_at_cb write_at_cb, void cb_arg) { STREAM_FRAME sf = fl->head, prev_frame = NULL; uint64_t limit = fl->offset; if (sf == NULL) return 1; if (fl->head_locked) sf = sf->next; for (; sf != NULL; sf = sf->next) { size_t len; const unsigned char data = sf->data; if (limit < sf->range.start) limit = sf->range.start; if (data != NULL) { if (limit > sf->range.start) data += (size_t)(limit - sf->range.start); len = (size_t)(sf->range.end - limit); if (!write_at_cb(limit, data, len, cb_arg)) /* data did not fit / return 0; if (fl->cleanse) OPENSSL_cleanse((unsigned char )sf->data, (size_t)(sf->range.end - sf->range.start)); /* release the packet / sf->data = NULL; ossl_qrx_pkt_release(sf->pkt); sf->pkt = NULL; } limit = sf->range.end; / merge contiguous frames */ if (prev_frame != NULL && prev_frame->range.end >= sf->range.start) { prev_frame->range.end = sf->range.end; prev_frame->next = sf->next; if (sf->next != NULL) sf->next->prev = prev_frame; else fl->tail = prev_frame; --fl->num_frames; stream_frame_free(fl, sf); sf = prev_frame; continue; } prev_frame = sf; } return 1; }
./openssl/ssl/quic/cc_newreno.c	#include "internal/quic_cc.h" #include "internal/quic_types.h" #include "internal/safe_math.h" OSSL_SAFE_MATH_UNSIGNED(u64, uint64_t) typedef struct ossl_cc_newreno_st { /* Dependencies. / OSSL_TIME (now_cb)(void arg); void now_cb_arg; /* 'Constants' (which we allow to be configurable). / uint64_t k_init_wnd, k_min_wnd; uint32_t k_loss_reduction_factor_num, k_loss_reduction_factor_den; uint32_t persistent_cong_thresh; / State. / size_t max_dgram_size; uint64_t bytes_in_flight, cong_wnd, slow_start_thresh, bytes_acked; OSSL_TIME cong_recovery_start_time; / Unflushed state during multiple on-loss calls. / int processing_loss; / 1 if not flushed / OSSL_TIME tx_time_of_last_loss; / Diagnostic state. / int in_congestion_recovery; / Diagnostic output locations. / size_t p_diag_max_dgram_payload_len; uint64_t p_diag_cur_cwnd_size; uint64_t p_diag_min_cwnd_size; uint64_t p_diag_cur_bytes_in_flight; uint32_t p_diag_cur_state; } OSSL_CC_NEWRENO; #define MIN_MAX_INIT_WND_SIZE 14720 /* RFC 9002 s. 7.2 / / TODO(QUIC FUTURE): Pacing support. / static void newreno_set_max_dgram_size(OSSL_CC_NEWRENO nr, size_t max_dgram_size); static void newreno_update_diag(OSSL_CC_NEWRENO nr); static void newreno_reset(OSSL_CC_DATA cc); static OSSL_CC_DATA newreno_new(OSSL_TIME (now_cb)(void arg), void now_cb_arg) { OSSL_CC_NEWRENO nr; if ((nr = OPENSSL_zalloc(sizeof(nr))) == NULL) return NULL; nr->now_cb = now_cb; nr->now_cb_arg = now_cb_arg; newreno_set_max_dgram_size(nr, QUIC_MIN_INITIAL_DGRAM_LEN); newreno_reset((OSSL_CC_DATA )nr); return (OSSL_CC_DATA )nr; } static void newreno_free(OSSL_CC_DATA cc) { OPENSSL_free(cc); } static void newreno_set_max_dgram_size(OSSL_CC_NEWRENO nr, size_t max_dgram_size) { size_t max_init_wnd; int is_reduced = (max_dgram_size < nr->max_dgram_size); nr->max_dgram_size = max_dgram_size; max_init_wnd = 2 * max_dgram_size; if (max_init_wnd < MIN_MAX_INIT_WND_SIZE) max_init_wnd = MIN_MAX_INIT_WND_SIZE; nr->k_init_wnd = 10 * max_dgram_size; if (nr->k_init_wnd > max_init_wnd) nr->k_init_wnd = max_init_wnd; nr->k_min_wnd = 2 * max_dgram_size; if (is_reduced) nr->cong_wnd = nr->k_init_wnd; newreno_update_diag(nr); } static void newreno_reset(OSSL_CC_DATA cc) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; nr->k_loss_reduction_factor_num = 1; nr->k_loss_reduction_factor_den = 2; nr->persistent_cong_thresh = 3; nr->cong_wnd = nr->k_init_wnd; nr->bytes_in_flight = 0; nr->bytes_acked = 0; nr->slow_start_thresh = UINT64_MAX; nr->cong_recovery_start_time = ossl_time_zero(); nr->processing_loss = 0; nr->tx_time_of_last_loss = ossl_time_zero(); nr->in_congestion_recovery = 0; } static int newreno_set_input_params(OSSL_CC_DATA cc, const OSSL_PARAM params) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; const OSSL_PARAM p; size_t value; p = OSSL_PARAM_locate_const(params, OSSL_CC_OPTION_MAX_DGRAM_PAYLOAD_LEN); if (p != NULL) { if (!OSSL_PARAM_get_size_t(p, &value)) return 0; if (value < QUIC_MIN_INITIAL_DGRAM_LEN) return 0; newreno_set_max_dgram_size(nr, value); } return 1; } static int bind_diag(OSSL_PARAM params, const char param_name, size_t len, void *pp) { const OSSL_PARAM p = OSSL_PARAM_locate_const(params, param_name); pp = NULL; if (p == NULL) return 1; if (p->data_type != OSSL_PARAM_UNSIGNED_INTEGER \|\| p->data_size != len) return 0; pp = p->data; return 1; } static int newreno_bind_diagnostic(OSSL_CC_DATA cc, OSSL_PARAM params) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; size_t new_p_max_dgram_payload_len; uint64_t new_p_cur_cwnd_size; uint64_t new_p_min_cwnd_size; uint64_t new_p_cur_bytes_in_flight; uint32_t new_p_cur_state; if (!bind_diag(params, OSSL_CC_OPTION_MAX_DGRAM_PAYLOAD_LEN, sizeof(size_t), (void )&new_p_max_dgram_payload_len) \|\| !bind_diag(params, OSSL_CC_OPTION_CUR_CWND_SIZE, sizeof(uint64_t), (void )&new_p_cur_cwnd_size) \|\| !bind_diag(params, OSSL_CC_OPTION_MIN_CWND_SIZE, sizeof(uint64_t), (void )&new_p_min_cwnd_size) \|\| !bind_diag(params, OSSL_CC_OPTION_CUR_BYTES_IN_FLIGHT, sizeof(uint64_t), (void )&new_p_cur_bytes_in_flight) \|\| !bind_diag(params, OSSL_CC_OPTION_CUR_STATE, sizeof(uint32_t), (void )&new_p_cur_state)) return 0; if (new_p_max_dgram_payload_len != NULL) nr->p_diag_max_dgram_payload_len = new_p_max_dgram_payload_len; if (new_p_cur_cwnd_size != NULL) nr->p_diag_cur_cwnd_size = new_p_cur_cwnd_size; if (new_p_min_cwnd_size != NULL) nr->p_diag_min_cwnd_size = new_p_min_cwnd_size; if (new_p_cur_bytes_in_flight != NULL) nr->p_diag_cur_bytes_in_flight = new_p_cur_bytes_in_flight; if (new_p_cur_state != NULL) nr->p_diag_cur_state = new_p_cur_state; newreno_update_diag(nr); return 1; } static void unbind_diag(OSSL_PARAM params, const char param_name, void pp) { const OSSL_PARAM p = OSSL_PARAM_locate_const(params, param_name); if (p != NULL) pp = NULL; } static int newreno_unbind_diagnostic(OSSL_CC_DATA cc, OSSL_PARAM params) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; unbind_diag(params, OSSL_CC_OPTION_MAX_DGRAM_PAYLOAD_LEN, (void )&nr->p_diag_max_dgram_payload_len); unbind_diag(params, OSSL_CC_OPTION_CUR_CWND_SIZE, (void )&nr->p_diag_cur_cwnd_size); unbind_diag(params, OSSL_CC_OPTION_MIN_CWND_SIZE, (void )&nr->p_diag_min_cwnd_size); unbind_diag(params, OSSL_CC_OPTION_CUR_BYTES_IN_FLIGHT, (void )&nr->p_diag_cur_bytes_in_flight); unbind_diag(params, OSSL_CC_OPTION_CUR_STATE, (void )&nr->p_diag_cur_state); return 1; } static void newreno_update_diag(OSSL_CC_NEWRENO nr) { if (nr->p_diag_max_dgram_payload_len != NULL) nr->p_diag_max_dgram_payload_len = nr->max_dgram_size; if (nr->p_diag_cur_cwnd_size != NULL) nr->p_diag_cur_cwnd_size = nr->cong_wnd; if (nr->p_diag_min_cwnd_size != NULL) nr->p_diag_min_cwnd_size = nr->k_min_wnd; if (nr->p_diag_cur_bytes_in_flight != NULL) nr->p_diag_cur_bytes_in_flight = nr->bytes_in_flight; if (nr->p_diag_cur_state != NULL) { if (nr->in_congestion_recovery) nr->p_diag_cur_state = 'R'; else if (nr->cong_wnd < nr->slow_start_thresh) nr->p_diag_cur_state = 'S'; else nr->p_diag_cur_state = 'A'; } } static int newreno_in_cong_recovery(OSSL_CC_NEWRENO nr, OSSL_TIME tx_time) { return ossl_time_compare(tx_time, nr->cong_recovery_start_time) <= 0; } static void newreno_cong(OSSL_CC_NEWRENO nr, OSSL_TIME tx_time) { int err = 0; / No reaction if already in a recovery period. / if (newreno_in_cong_recovery(nr, tx_time)) return; / Start a new recovery period. / nr->in_congestion_recovery = 1; nr->cong_recovery_start_time = nr->now_cb(nr->now_cb_arg); / slow_start_thresh = cong_wnd * loss_reduction_factor / nr->slow_start_thresh = safe_muldiv_u64(nr->cong_wnd, nr->k_loss_reduction_factor_num, nr->k_loss_reduction_factor_den, &err); if (err) nr->slow_start_thresh = UINT64_MAX; nr->cong_wnd = nr->slow_start_thresh; if (nr->cong_wnd < nr->k_min_wnd) nr->cong_wnd = nr->k_min_wnd; } static void newreno_flush(OSSL_CC_NEWRENO nr, uint32_t flags) { if (!nr->processing_loss) return; newreno_cong(nr, nr->tx_time_of_last_loss); if ((flags & OSSL_CC_LOST_FLAG_PERSISTENT_CONGESTION) != 0) { nr->cong_wnd = nr->k_min_wnd; nr->cong_recovery_start_time = ossl_time_zero(); } nr->processing_loss = 0; newreno_update_diag(nr); } static uint64_t newreno_get_tx_allowance(OSSL_CC_DATA cc) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; if (nr->bytes_in_flight >= nr->cong_wnd) return 0; return nr->cong_wnd - nr->bytes_in_flight; } static OSSL_TIME newreno_get_wakeup_deadline(OSSL_CC_DATA cc) { if (newreno_get_tx_allowance(cc) > 0) { /* We have TX allowance now so wakeup immediately / return ossl_time_zero(); } else { / * The NewReno congestion controller does not vary its state in time, * only in response to stimulus. / return ossl_time_infinite(); } } static int newreno_on_data_sent(OSSL_CC_DATA cc, uint64_t num_bytes) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; nr->bytes_in_flight += num_bytes; newreno_update_diag(nr); return 1; } static int newreno_is_cong_limited(OSSL_CC_NEWRENO nr) { uint64_t wnd_rem; / We are congestion-limited if we are already at the congestion window. / if (nr->bytes_in_flight >= nr->cong_wnd) return 1; wnd_rem = nr->cong_wnd - nr->bytes_in_flight; / * Consider ourselves congestion-limited if less than three datagrams' worth * of congestion window remains to be spent, or if we are in slow start and * have consumed half of our window. / return (nr->cong_wnd < nr->slow_start_thresh && wnd_rem <= nr->cong_wnd / 2) \|\| wnd_rem <= 3 nr->max_dgram_size; } static int newreno_on_data_acked(OSSL_CC_DATA cc, const OSSL_CC_ACK_INFO info) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; /* * Packet has been acked. Firstly, remove it from the aggregate count of * bytes in flight. / nr->bytes_in_flight -= info->tx_size; / * We use acknowledgement of data as a signal that we are not at channel * capacity and that it may be reasonable to increase the congestion window. * However, acknowledgement is not a useful signal that there is further * capacity if we are not actually saturating the congestion window that we * already have (for example, if the application is not generating much data * or we are limited by flow control). Therefore, we only expand the * congestion window if we are consuming a significant fraction of the * congestion window. / if (!newreno_is_cong_limited(nr)) goto out; / * We can handle acknowledgement of a packet in one of three ways * depending on our current state: * * - Congestion Recovery: Do nothing. We don't start increasing * the congestion window in response to acknowledgements until * we are no longer in the Congestion Recovery state. * * - Slow Start: Increase the congestion window using the slow * start scale. * * - Congestion Avoidance: Increase the congestion window using * the congestion avoidance scale. / if (newreno_in_cong_recovery(nr, info->tx_time)) { / Congestion recovery, do nothing. / } else if (nr->cong_wnd < nr->slow_start_thresh) { / When this condition is true we are in the Slow Start state. / nr->cong_wnd += info->tx_size; nr->in_congestion_recovery = 0; } else { / Otherwise, we are in the Congestion Avoidance state. / nr->bytes_acked += info->tx_size; / * Avoid integer division as per RFC 9002 s. B.5. / RFC3465 s. 2.1. / if (nr->bytes_acked >= nr->cong_wnd) { nr->bytes_acked -= nr->cong_wnd; nr->cong_wnd += nr->max_dgram_size; } nr->in_congestion_recovery = 0; } out: newreno_update_diag(nr); return 1; } static int newreno_on_data_lost(OSSL_CC_DATA cc, const OSSL_CC_LOSS_INFO info) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; if (info->tx_size > nr->bytes_in_flight) return 0; nr->bytes_in_flight -= info->tx_size; if (!nr->processing_loss) { if (ossl_time_compare(info->tx_time, nr->tx_time_of_last_loss) <= 0) / * After triggering congestion due to a lost packet at time t, don't * trigger congestion again due to any subsequently detected lost * packet at a time s < t, as we've effectively already signalled * congestion on loss of that and subsequent packets. / goto out; nr->processing_loss = 1; / * Cancel any pending window increase in the Congestion Avoidance state. / nr->bytes_acked = 0; } nr->tx_time_of_last_loss = ossl_time_max(nr->tx_time_of_last_loss, info->tx_time); out: newreno_update_diag(nr); return 1; } static int newreno_on_data_lost_finished(OSSL_CC_DATA cc, uint32_t flags) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; newreno_flush(nr, flags); return 1; } static int newreno_on_data_invalidated(OSSL_CC_DATA cc, uint64_t num_bytes) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO )cc; nr->bytes_in_flight -= num_bytes; newreno_update_diag(nr); return 1; } static int newreno_on_ecn(OSSL_CC_DATA cc, const OSSL_CC_ECN_INFO info) { OSSL_CC_NEWRENO nr = (OSSL_CC_NEWRENO *)cc; nr->processing_loss = 1; nr->bytes_acked = 0; nr->tx_time_of_last_loss = info->largest_acked_time; newreno_flush(nr, 0); return 1; } const OSSL_CC_METHOD ossl_cc_newreno_method = { newreno_new, newreno_free, newreno_reset, newreno_set_input_params, newreno_bind_diagnostic, newreno_unbind_diagnostic, newreno_get_tx_allowance, newreno_get_wakeup_deadline, newreno_on_data_sent, newreno_on_data_acked, newreno_on_data_lost, newreno_on_data_lost_finished, newreno_on_data_invalidated, newreno_on_ecn, };
./openssl/ssl/quic/quic_demux.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_demux.h" #include "internal/quic_wire_pkt.h" #include "internal/common.h" #include <openssl/lhash.h> #include <openssl/err.h> #define URXE_DEMUX_STATE_FREE 0 / on urx_free list / #define URXE_DEMUX_STATE_PENDING 1 / on urx_pending list / #define URXE_DEMUX_STATE_ISSUED 2 / on neither list / #define DEMUX_MAX_MSGS_PER_CALL 32 #define DEMUX_DEFAULT_MTU 1500 struct quic_demux_st { / The underlying transport BIO with datagram semantics. / BIO net_bio; /* * QUIC short packets do not contain the length of the connection ID field, * therefore it must be known contextually. The demuxer requires connection * IDs of the same length to be used for all incoming packets. / size_t short_conn_id_len; / * Our current understanding of the upper bound on an incoming datagram size * in bytes. / size_t mtu; / Time retrieval callback. / OSSL_TIME (now)(void arg); void now_arg; /* The default packet handler, if any. / ossl_quic_demux_cb_fn default_cb; void default_cb_arg; / * List of URXEs which are not currently in use (i.e., not filled with * unconsumed data). These are moved to the pending list as they are filled. / QUIC_URXE_LIST urx_free; / * List of URXEs which are filled with received encrypted data. These are * removed from this list as we invoke the callbacks for each of them. They * are then not on any list managed by us; we forget about them until our * user calls ossl_quic_demux_release_urxe to return the URXE to us, at * which point we add it to the free list. / QUIC_URXE_LIST urx_pending; / Whether to use local address support. / char use_local_addr; }; QUIC_DEMUX ossl_quic_demux_new(BIO net_bio, size_t short_conn_id_len, OSSL_TIME (now)(void arg), void now_arg) { QUIC_DEMUX demux; demux = OPENSSL_zalloc(sizeof(QUIC_DEMUX)); if (demux == NULL) return NULL; demux->net_bio = net_bio; demux->short_conn_id_len = short_conn_id_len; / We update this if possible when we get a BIO. / demux->mtu = DEMUX_DEFAULT_MTU; demux->now = now; demux->now_arg = now_arg; if (net_bio != NULL && BIO_dgram_get_local_addr_cap(net_bio) && BIO_dgram_set_local_addr_enable(net_bio, 1)) demux->use_local_addr = 1; return demux; } static void demux_free_urxl(QUIC_URXE_LIST l) { QUIC_URXE e, enext; for (e = ossl_list_urxe_head(l); e != NULL; e = enext) { enext = ossl_list_urxe_next(e); ossl_list_urxe_remove(l, e); OPENSSL_free(e); } } void ossl_quic_demux_free(QUIC_DEMUX demux) { if (demux == NULL) return; / Free all URXEs we are holding. / demux_free_urxl(&demux->urx_free); demux_free_urxl(&demux->urx_pending); OPENSSL_free(demux); } void ossl_quic_demux_set_bio(QUIC_DEMUX demux, BIO net_bio) { unsigned int mtu; demux->net_bio = net_bio; if (net_bio != NULL) { / * Try to determine our MTU if possible. The BIO is not required to * support this, in which case we remain at the last known MTU, or our * initial default. / mtu = BIO_dgram_get_mtu(net_bio); if (mtu >= QUIC_MIN_INITIAL_DGRAM_LEN) ossl_quic_demux_set_mtu(demux, mtu); / best effort / } } int ossl_quic_demux_set_mtu(QUIC_DEMUX demux, unsigned int mtu) { if (mtu < QUIC_MIN_INITIAL_DGRAM_LEN) return 0; demux->mtu = mtu; return 1; } void ossl_quic_demux_set_default_handler(QUIC_DEMUX demux, ossl_quic_demux_cb_fn cb, void cb_arg) { demux->default_cb = cb; demux->default_cb_arg = cb_arg; } static QUIC_URXE demux_alloc_urxe(size_t alloc_len) { QUIC_URXE e; if (alloc_len >= SIZE_MAX - sizeof(QUIC_URXE)) return NULL; e = OPENSSL_malloc(sizeof(QUIC_URXE) + alloc_len); if (e == NULL) return NULL; ossl_list_urxe_init_elem(e); e->alloc_len = alloc_len; e->data_len = 0; return e; } static QUIC_URXE demux_resize_urxe(QUIC_DEMUX demux, QUIC_URXE e, size_t new_alloc_len) { QUIC_URXE e2, prev; if (!ossl_assert(e->demux_state == URXE_DEMUX_STATE_FREE)) /* Never attempt to resize a URXE which is not on the free list. / return NULL; prev = ossl_list_urxe_prev(e); ossl_list_urxe_remove(&demux->urx_free, e); e2 = OPENSSL_realloc(e, sizeof(QUIC_URXE) + new_alloc_len); if (e2 == NULL) { / Failed to resize, abort. / if (prev == NULL) ossl_list_urxe_insert_head(&demux->urx_free, e); else ossl_list_urxe_insert_after(&demux->urx_free, prev, e); return NULL; } if (prev == NULL) ossl_list_urxe_insert_head(&demux->urx_free, e2); else ossl_list_urxe_insert_after(&demux->urx_free, prev, e2); e2->alloc_len = new_alloc_len; return e2; } static QUIC_URXE demux_reserve_urxe(QUIC_DEMUX demux, QUIC_URXE e, size_t alloc_len) { return e->alloc_len < alloc_len ? demux_resize_urxe(demux, e, alloc_len) : e; } static int demux_ensure_free_urxe(QUIC_DEMUX demux, size_t min_num_free) { QUIC_URXE e; while (ossl_list_urxe_num(&demux->urx_free) < min_num_free) { e = demux_alloc_urxe(demux->mtu); if (e == NULL) return 0; ossl_list_urxe_insert_tail(&demux->urx_free, e); e->demux_state = URXE_DEMUX_STATE_FREE; } return 1; } /* * Receive datagrams from network, placing them into URXEs. * * Returns 1 on success or 0 on failure. * * Precondition: at least one URXE is free * Precondition: there are no pending URXEs / static int demux_recv(QUIC_DEMUX demux) { BIO_MSG msg[DEMUX_MAX_MSGS_PER_CALL]; size_t rd, i; QUIC_URXE urxe = ossl_list_urxe_head(&demux->urx_free), unext; OSSL_TIME now; /* This should never be called when we have any pending URXE. / assert(ossl_list_urxe_head(&demux->urx_pending) == NULL); assert(urxe->demux_state == URXE_DEMUX_STATE_FREE); if (demux->net_bio == NULL) / * If no BIO is plugged in, treat this as no datagram being available. / return QUIC_DEMUX_PUMP_RES_TRANSIENT_FAIL; / * Opportunistically receive as many messages as possible in a single * syscall, determined by how many free URXEs are available. / for (i = 0; i < (ossl_ssize_t)OSSL_NELEM(msg); ++i, urxe = ossl_list_urxe_next(urxe)) { if (urxe == NULL) { / We need at least one URXE to receive into. / if (!ossl_assert(i > 0)) return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; break; } / Ensure the URXE is big enough. / urxe = demux_reserve_urxe(demux, urxe, demux->mtu); if (urxe == NULL) / Allocation error, fail. / return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; / Ensure we zero any fields added to BIO_MSG at a later date. / memset(&msg[i], 0, sizeof(BIO_MSG)); msg[i].data = ossl_quic_urxe_data(urxe); msg[i].data_len = urxe->alloc_len; msg[i].peer = &urxe->peer; BIO_ADDR_clear(&urxe->peer); if (demux->use_local_addr) msg[i].local = &urxe->local; else BIO_ADDR_clear(&urxe->local); } ERR_set_mark(); if (!BIO_recvmmsg(demux->net_bio, msg, sizeof(BIO_MSG), i, 0, &rd)) { if (BIO_err_is_non_fatal(ERR_peek_last_error())) { / Transient error, clear the error and stop. / ERR_pop_to_mark(); return QUIC_DEMUX_PUMP_RES_TRANSIENT_FAIL; } else { / Non-transient error, do not clear the error. / ERR_clear_last_mark(); return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; } } ERR_clear_last_mark(); now = demux->now != NULL ? demux->now(demux->now_arg) : ossl_time_zero(); urxe = ossl_list_urxe_head(&demux->urx_free); for (i = 0; i < rd; ++i, urxe = unext) { unext = ossl_list_urxe_next(urxe); / Set URXE with actual length of received datagram. / urxe->data_len = msg[i].data_len; / Time we received datagram. / urxe->time = now; / Move from free list to pending list. / ossl_list_urxe_remove(&demux->urx_free, urxe); ossl_list_urxe_insert_tail(&demux->urx_pending, urxe); urxe->demux_state = URXE_DEMUX_STATE_PENDING; } return QUIC_DEMUX_PUMP_RES_OK; } / Extract destination connection ID from the first packet in a datagram. / static int demux_identify_conn_id(QUIC_DEMUX demux, QUIC_URXE e, QUIC_CONN_ID dst_conn_id) { return ossl_quic_wire_get_pkt_hdr_dst_conn_id(ossl_quic_urxe_data(e), e->data_len, demux->short_conn_id_len, dst_conn_id); } /* * Process a single pending URXE. * Returning 1 on success, 0 on failure. / static int demux_process_pending_urxe(QUIC_DEMUX demux, QUIC_URXE e) { QUIC_CONN_ID dst_conn_id; int dst_conn_id_ok = 0; / The next URXE we process should be at the head of the pending list. / if (!ossl_assert(e == ossl_list_urxe_head(&demux->urx_pending))) return 0; assert(e->demux_state == URXE_DEMUX_STATE_PENDING); / Determine the DCID of the first packet in the datagram. / dst_conn_id_ok = demux_identify_conn_id(demux, e, &dst_conn_id); ossl_list_urxe_remove(&demux->urx_pending, e); if (demux->default_cb != NULL) { / * Pass to default handler for routing. The URXE now belongs to the * callback. / e->demux_state = URXE_DEMUX_STATE_ISSUED; demux->default_cb(e, demux->default_cb_arg, dst_conn_id_ok ? &dst_conn_id : NULL); } else { / Discard. / ossl_list_urxe_insert_tail(&demux->urx_free, e); e->demux_state = URXE_DEMUX_STATE_FREE; } return 1; / keep processing pending URXEs / } / Process pending URXEs to generate callbacks. / static int demux_process_pending_urxl(QUIC_DEMUX demux) { QUIC_URXE e; int ret; while ((e = ossl_list_urxe_head(&demux->urx_pending)) != NULL) if ((ret = demux_process_pending_urxe(demux, e)) <= 0) return ret; return 1; } / * Drain the pending URXE list, processing any pending URXEs by making their * callbacks. If no URXEs are pending, a network read is attempted first. / int ossl_quic_demux_pump(QUIC_DEMUX demux) { int ret; if (ossl_list_urxe_head(&demux->urx_pending) == NULL) { ret = demux_ensure_free_urxe(demux, DEMUX_MAX_MSGS_PER_CALL); if (ret != 1) return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; ret = demux_recv(demux); if (ret != QUIC_DEMUX_PUMP_RES_OK) return ret; /* * If demux_recv returned successfully, we should always have something. / assert(ossl_list_urxe_head(&demux->urx_pending) != NULL); } if ((ret = demux_process_pending_urxl(demux)) <= 0) return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; return QUIC_DEMUX_PUMP_RES_OK; } / Artificially inject a packet into the demuxer for testing purposes. / int ossl_quic_demux_inject(QUIC_DEMUX demux, const unsigned char buf, size_t buf_len, const BIO_ADDR peer, const BIO_ADDR local) { int ret; QUIC_URXE urxe; ret = demux_ensure_free_urxe(demux, 1); if (ret != 1) return 0; urxe = ossl_list_urxe_head(&demux->urx_free); assert(urxe->demux_state == URXE_DEMUX_STATE_FREE); urxe = demux_reserve_urxe(demux, urxe, buf_len); if (urxe == NULL) return 0; memcpy(ossl_quic_urxe_data(urxe), buf, buf_len); urxe->data_len = buf_len; if (peer != NULL) urxe->peer = peer; else BIO_ADDR_clear(&urxe->peer); if (local != NULL) urxe->local = local; else BIO_ADDR_clear(&urxe->local); urxe->time = demux->now != NULL ? demux->now(demux->now_arg) : ossl_time_zero(); /* Move from free list to pending list. / ossl_list_urxe_remove(&demux->urx_free, urxe); ossl_list_urxe_insert_tail(&demux->urx_pending, urxe); urxe->demux_state = URXE_DEMUX_STATE_PENDING; return demux_process_pending_urxl(demux) > 0; } / Called by our user to return a URXE to the free list. / void ossl_quic_demux_release_urxe(QUIC_DEMUX demux, QUIC_URXE e) { assert(ossl_list_urxe_prev(e) == NULL && ossl_list_urxe_next(e) == NULL); assert(e->demux_state == URXE_DEMUX_STATE_ISSUED); ossl_list_urxe_insert_tail(&demux->urx_free, e); e->demux_state = URXE_DEMUX_STATE_FREE; } void ossl_quic_demux_reinject_urxe(QUIC_DEMUX demux, QUIC_URXE e) { assert(ossl_list_urxe_prev(e) == NULL && ossl_list_urxe_next(e) == NULL); assert(e->demux_state == URXE_DEMUX_STATE_ISSUED); ossl_list_urxe_insert_head(&demux->urx_pending, e); e->demux_state = URXE_DEMUX_STATE_PENDING; } int ossl_quic_demux_has_pending(const QUIC_DEMUX demux) { return ossl_list_urxe_head(&demux->urx_pending) != NULL; }
./openssl/ssl/quic/quic_record_util.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_record_util.h" #include "internal/quic_record_rx.h" #include "internal/quic_record_tx.h" #include "internal/quic_wire_pkt.h" #include "../ssl_local.h" #include <openssl/kdf.h> #include <openssl/core_names.h> / * QUIC Key Derivation Utilities * ============================= / int ossl_quic_hkdf_extract(OSSL_LIB_CTX libctx, const char propq, const EVP_MD md, const unsigned char salt, size_t salt_len, const unsigned char ikm, size_t ikm_len, unsigned char out, size_t out_len) { int ret = 0; EVP_KDF kdf = NULL; EVP_KDF_CTX kctx = NULL; OSSL_PARAM params[7], p = params; int mode = EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY; const char md_name; if ((md_name = EVP_MD_get0_name(md)) == NULL \|\| (kdf = EVP_KDF_fetch(libctx, OSSL_KDF_NAME_HKDF, propq)) == NULL \|\| (kctx = EVP_KDF_CTX_new(kdf)) == NULL) goto err; p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode); p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char )md_name, 0); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT, (unsigned char )salt, salt_len); p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, (unsigned char )ikm, ikm_len); p++ = OSSL_PARAM_construct_end(); ret = EVP_KDF_derive(kctx, out, out_len, params); err: EVP_KDF_CTX_free(kctx); EVP_KDF_free(kdf); return ret; } / Constants used for key derivation in QUIC v1. / static const unsigned char quic_client_in_label[] = { 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e / "client in" / }; static const unsigned char quic_server_in_label[] = { 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x69, 0x6e / "server in" / }; / Salt used to derive Initial packet protection keys (RFC 9001 Section 5.2). / static const unsigned char quic_v1_initial_salt[] = { 0x38, 0x76, 0x2c, 0xf7, 0xf5, 0x59, 0x34, 0xb3, 0x4d, 0x17, 0x9a, 0xe6, 0xa4, 0xc8, 0x0c, 0xad, 0xcc, 0xbb, 0x7f, 0x0a }; int ossl_quic_provide_initial_secret(OSSL_LIB_CTX libctx, const char propq, const QUIC_CONN_ID dst_conn_id, int is_server, struct ossl_qrx_st qrx, struct ossl_qtx_st qtx) { unsigned char initial_secret[32]; unsigned char client_initial_secret[32], server_initial_secret[32]; unsigned char rx_secret, tx_secret; EVP_MD sha256; if (qrx == NULL && qtx == NULL) return 1; / Initial encryption always uses SHA-256. / if ((sha256 = EVP_MD_fetch(libctx, "SHA256", propq)) == NULL) return 0; if (is_server) { rx_secret = client_initial_secret; tx_secret = server_initial_secret; } else { rx_secret = server_initial_secret; tx_secret = client_initial_secret; } / Derive initial secret from destination connection ID. / if (!ossl_quic_hkdf_extract(libctx, propq, sha256, quic_v1_initial_salt, sizeof(quic_v1_initial_salt), dst_conn_id->id, dst_conn_id->id_len, initial_secret, sizeof(initial_secret))) goto err; / Derive "client in" secret. / if (((qtx != NULL && tx_secret == client_initial_secret) \|\| (qrx != NULL && rx_secret == client_initial_secret)) && !tls13_hkdf_expand_ex(libctx, propq, sha256, initial_secret, quic_client_in_label, sizeof(quic_client_in_label), NULL, 0, client_initial_secret, sizeof(client_initial_secret), 1)) goto err; / Derive "server in" secret. / if (((qtx != NULL && tx_secret == server_initial_secret) \|\| (qrx != NULL && rx_secret == server_initial_secret)) && !tls13_hkdf_expand_ex(libctx, propq, sha256, initial_secret, quic_server_in_label, sizeof(quic_server_in_label), NULL, 0, server_initial_secret, sizeof(server_initial_secret), 1)) goto err; / Setup RX EL. Initial encryption always uses AES-128-GCM. / if (qrx != NULL && !ossl_qrx_provide_secret(qrx, QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, sha256, rx_secret, sizeof(server_initial_secret))) goto err; / * ossl_qrx_provide_secret takes ownership of our ref to SHA256, so if we * are initialising both sides, get a new ref for the following call for the * TX side. / if (qrx != NULL && qtx != NULL && !EVP_MD_up_ref(sha256)) { sha256 = NULL; goto err; } / Setup TX cipher. / if (qtx != NULL && !ossl_qtx_provide_secret(qtx, QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, sha256, tx_secret, sizeof(server_initial_secret))) goto err; return 1; err: EVP_MD_free(sha256); return 0; } / * QUIC Record Layer Ciphersuite Info * ================================== / struct suite_info { const char cipher_name, md_name; uint32_t secret_len, cipher_key_len, cipher_iv_len, cipher_tag_len; uint32_t hdr_prot_key_len, hdr_prot_cipher_id; uint64_t max_pkt, max_forged_pkt; }; static const struct suite_info suite_aes128gcm = { "AES-128-GCM", "SHA256", 32, 16, 12, 16, 16, QUIC_HDR_PROT_CIPHER_AES_128, ((uint64_t)1) << 23, / Limits as prescribed by RFC 9001 / ((uint64_t)1) << 52, }; static const struct suite_info suite_aes256gcm = { "AES-256-GCM", "SHA384", 48, 32, 12, 16, 32, QUIC_HDR_PROT_CIPHER_AES_256, ((uint64_t)1) << 23, / Limits as prescribed by RFC 9001 / ((uint64_t)1) << 52, }; static const struct suite_info suite_chacha20poly1305 = { "ChaCha20-Poly1305", "SHA256", 32, 32, 12, 16, 32, QUIC_HDR_PROT_CIPHER_CHACHA, / Do not use UINT64_MAX here as this represents an invalid value / UINT64_MAX - 1, / No applicable limit for this suite (RFC 9001) / ((uint64_t)1) << 36, / Limit as prescribed by RFC 9001 / }; static const struct suite_info get_suite(uint32_t suite_id) { switch (suite_id) { case QRL_SUITE_AES128GCM: return &suite_aes128gcm; case QRL_SUITE_AES256GCM: return &suite_aes256gcm; case QRL_SUITE_CHACHA20POLY1305: return &suite_chacha20poly1305; default: return NULL; } } const char ossl_qrl_get_suite_cipher_name(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->cipher_name : NULL; } const char ossl_qrl_get_suite_md_name(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->md_name : NULL; } uint32_t ossl_qrl_get_suite_secret_len(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->secret_len : 0; } uint32_t ossl_qrl_get_suite_cipher_key_len(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->cipher_key_len : 0; } uint32_t ossl_qrl_get_suite_cipher_iv_len(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->cipher_iv_len : 0; } uint32_t ossl_qrl_get_suite_cipher_tag_len(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->cipher_tag_len : 0; } uint32_t ossl_qrl_get_suite_hdr_prot_cipher_id(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->hdr_prot_cipher_id : 0; } uint32_t ossl_qrl_get_suite_hdr_prot_key_len(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->hdr_prot_key_len : 0; } uint64_t ossl_qrl_get_suite_max_pkt(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->max_pkt : UINT64_MAX; } uint64_t ossl_qrl_get_suite_max_forged_pkt(uint32_t suite_id) { const struct suite_info c = get_suite(suite_id); return c != NULL ? c->max_forged_pkt : UINT64_MAX; }
./openssl/ssl/quic/quic_tls.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/ssl.h> #include "internal/recordmethod.h" #include "internal/quic_tls.h" #include "../ssl_local.h" #include "internal/quic_error.h" #define QUIC_TLS_FATAL(rl, ad, err) \ do { \ if ((rl) != NULL) (rl)->alert = (ad); \ ERR_raise(ERR_LIB_SSL, (err)); \ if ((rl) != NULL) (rl)->qtls->inerror = 1; \ } while(0) struct quic_tls_st { QUIC_TLS_ARGS args; / * Transport parameters which client should send. Buffer lifetime must * exceed the lifetime of the QUIC_TLS object. / const unsigned char local_transport_params; size_t local_transport_params_len; ERR_STATE error_state; / * QUIC error code (usually in the TLS Alert-mapped CRYPTO_ERR range). Valid * only if inerror is 1. / uint64_t error_code; / * Error message with static storage duration. Valid only if inerror is 1. * Should be suitable for encapsulation in a CONNECTION_CLOSE frame. / const char error_msg; /* Whether our SSL object for TLS has been configured for use in QUIC / unsigned int configured : 1; / Set if we have hit any error state / unsigned int inerror : 1; / Set if the handshake has completed / unsigned int complete : 1; }; struct ossl_record_layer_st { QUIC_TLS qtls; /* Protection level / int level; / Only used for retry flags / BIO dummybio; /* Number of bytes written so far if we are part way through a write / size_t written; / If we are part way through a write, a copy of the template / OSSL_RECORD_TEMPLATE template; / * If we hit an error, what alert code should be used / int alert; / Amount of crypto stream data we read in the last call to quic_read_record / size_t recread; / Amount of crypto stream data read but not yet released / size_t recunreleased; / Callbacks / OSSL_FUNC_rlayer_msg_callback_fn msg_callback; void cbarg; }; static int quic_set1_bio(OSSL_RECORD_LAYER rl, BIO bio); static int quic_free(OSSL_RECORD_LAYER r); static int quic_new_record_layer(OSSL_LIB_CTX libctx, const char propq, int vers, int role, int direction, int level, uint16_t epoch, unsigned char secret, size_t secretlen, unsigned char key, size_t keylen, unsigned char iv, size_t ivlen, unsigned char mackey, size_t mackeylen, const EVP_CIPHER ciph, size_t taglen, int mactype, const EVP_MD md, COMP_METHOD comp, const EVP_MD kdfdigest, BIO prev, BIO transport, BIO next, BIO_ADDR local, BIO_ADDR peer, const OSSL_PARAM settings, const OSSL_PARAM options, const OSSL_DISPATCH fns, void cbarg, void rlarg, OSSL_RECORD_LAYER *retrl) { OSSL_RECORD_LAYER rl = OPENSSL_zalloc(sizeof(rl)); uint32_t enc_level; int qdir; uint32_t suite_id = 0; if (rl == NULL) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } rl->qtls = (QUIC_TLS )rlarg; rl->level = level; if (!quic_set1_bio(rl, transport)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } rl->cbarg = cbarg; retrl = rl; if (fns != NULL) { for (; fns->function_id != 0; fns++) { switch (fns->function_id) { break; case OSSL_FUNC_RLAYER_MSG_CALLBACK: rl->msg_callback = OSSL_FUNC_rlayer_msg_callback(fns); break; default: / Just ignore anything we don't understand / break; } } } switch (level) { case OSSL_RECORD_PROTECTION_LEVEL_NONE: return 1; case OSSL_RECORD_PROTECTION_LEVEL_EARLY: enc_level = QUIC_ENC_LEVEL_0RTT; break; case OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE: enc_level = QUIC_ENC_LEVEL_HANDSHAKE; break; case OSSL_RECORD_PROTECTION_LEVEL_APPLICATION: enc_level = QUIC_ENC_LEVEL_1RTT; break; default: QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (direction == OSSL_RECORD_DIRECTION_READ) qdir = 0; else qdir = 1; if (EVP_CIPHER_is_a(ciph, "AES-128-GCM")) { suite_id = QRL_SUITE_AES128GCM; } else if (EVP_CIPHER_is_a(ciph, "AES-256-GCM")) { suite_id = QRL_SUITE_AES256GCM; } else if (EVP_CIPHER_is_a(ciph, "CHACHA20-POLY1305")) { suite_id = QRL_SUITE_CHACHA20POLY1305; } else { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, SSL_R_UNKNOWN_CIPHER_TYPE); goto err; } / We pass a ref to the md in a successful yield_secret_cb call / / TODO(QUIC FUTURE): This cast is horrible. We should try and remove it / if (!EVP_MD_up_ref((EVP_MD )kdfdigest)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!rl->qtls->args.yield_secret_cb(enc_level, qdir, suite_id, (EVP_MD )kdfdigest, secret, secretlen, rl->qtls->args.yield_secret_cb_arg)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_MD_free((EVP_MD )kdfdigest); goto err; } return 1; err: retrl = NULL; quic_free(rl); return 0; } static int quic_free(OSSL_RECORD_LAYER rl) { if (rl == NULL) return 1; BIO_free(rl->dummybio); OPENSSL_free(rl); return 1; } static int quic_unprocessed_read_pending(OSSL_RECORD_LAYER rl) { / * Read ahead isn't really a thing for QUIC so we never have unprocessed * data pending / return 0; } static int quic_processed_read_pending(OSSL_RECORD_LAYER rl) { /* * This is currently only ever used by: * - SSL_has_pending() * - to check whether we have more records that we want to supply to the * upper layers * * We only ever supply 1 record at a time to the upper layers, and * SSL_has_pending() will go via the QUIC method not the TLS method so that * use case doesn't apply here. * Therefore we can ignore this for now and always return 0. We might * eventually want to change this to check in the receive buffers to see if * we have any more data pending. / return 0; } static size_t quic_get_max_records(OSSL_RECORD_LAYER rl, uint8_t type, size_t len, size_t maxfrag, size_t preffrag) { return 1; } static int quic_write_records(OSSL_RECORD_LAYER rl, OSSL_RECORD_TEMPLATE template, size_t numtempl) { size_t consumed; unsigned char alert; if (!ossl_assert(numtempl == 1)) { / How could this be? quic_get_max_records() always returns 1 / QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } BIO_clear_retry_flags(rl->dummybio); if (rl->msg_callback != NULL) { unsigned char dummyrec[SSL3_RT_HEADER_LENGTH]; / * For the purposes of the callback we "pretend" to be normal TLS, * and manufacture a dummy record header / dummyrec[0] = (rl->level == OSSL_RECORD_PROTECTION_LEVEL_NONE) ? template->type : SSL3_RT_APPLICATION_DATA; dummyrec[1] = (unsigned char)((template->version >> 8) & 0xff); dummyrec[2] = (unsigned char)(template->version & 0xff); / * We assume that buflen is always <= UINT16_MAX. Since this is * generated by libssl itself we actually expect it to never * exceed SSL3_RT_MAX_PLAIN_LENGTH - so it should be a safe * assumption / dummyrec[3] = (unsigned char)((template->buflen >> 8) & 0xff); dummyrec[4] = (unsigned char)(template->buflen & 0xff); rl->msg_callback(1, TLS1_3_VERSION, SSL3_RT_HEADER, dummyrec, SSL3_RT_HEADER_LENGTH, rl->cbarg); if (rl->level != OSSL_RECORD_PROTECTION_LEVEL_NONE) { rl->msg_callback(1, TLS1_3_VERSION, SSL3_RT_INNER_CONTENT_TYPE, &template->type, 1, rl->cbarg); } } switch (template->type) { case SSL3_RT_ALERT: if (template->buflen != 2) { / * We assume that libssl always sends both bytes of an alert to * us in one go, and never fragments it. If we ever get more * or less bytes than exactly 2 then this is very unexpected. / QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_VALUE); return OSSL_RECORD_RETURN_FATAL; } / * Byte 0 is the alert level (we ignore it) and byte 1 is the alert * description that we are actually interested in. / alert = template->buf[1]; if (!rl->qtls->args.alert_cb(rl->qtls->args.alert_cb_arg, alert)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } break; case SSL3_RT_HANDSHAKE: / * We expect this to only fail on some fatal error (e.g. malloc * failure) / if (!rl->qtls->args.crypto_send_cb(template->buf + rl->written, template->buflen - rl->written, &consumed, rl->qtls->args.crypto_send_cb_arg)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } / * We might have written less than we wanted to if we have filled the * send stream buffer. / if (consumed + rl->written != template->buflen) { if (!ossl_assert(consumed + rl->written < template->buflen)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } / * We've not written everything we wanted to. Take a copy of the * template, remember how much we wrote so far and signal a retry. * The buffer supplied in the template is guaranteed to be the same * on a retry for handshake data / rl->written += consumed; rl->template = template; BIO_set_retry_write(rl->dummybio); return OSSL_RECORD_RETURN_RETRY; } rl->written = 0; break; default: /* Anything else is unexpected and an error / QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } return OSSL_RECORD_RETURN_SUCCESS; } static int quic_retry_write_records(OSSL_RECORD_LAYER rl) { return quic_write_records(rl, &rl->template, 1); } static int quic_read_record(OSSL_RECORD_LAYER rl, void rechandle, int rversion, uint8_t type, const unsigned char data, size_t datalen, uint16_t epoch, unsigned char seq_num) { if (rl->recread != 0 \|\| rl->recunreleased != 0) return OSSL_RECORD_RETURN_FATAL; BIO_clear_retry_flags(rl->dummybio); if (!rl->qtls->args.crypto_recv_rcd_cb(data, datalen, rl->qtls->args.crypto_recv_rcd_cb_arg)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } if (datalen == 0) { BIO_set_retry_read(rl->dummybio); return OSSL_RECORD_RETURN_RETRY; } rechandle = rl; rversion = TLS1_3_VERSION; type = SSL3_RT_HANDSHAKE; rl->recread = rl->recunreleased = datalen; / epoch/seq_num are not relevant for TLS / if (rl->msg_callback != NULL) { unsigned char dummyrec[SSL3_RT_HEADER_LENGTH]; / * For the purposes of the callback we "pretend" to be normal TLS, * and manufacture a dummy record header / dummyrec[0] = (rl->level == OSSL_RECORD_PROTECTION_LEVEL_NONE) ? SSL3_RT_HANDSHAKE : SSL3_RT_APPLICATION_DATA; dummyrec[1] = (unsigned char)((TLS1_2_VERSION >> 8) & 0xff); dummyrec[2] = (unsigned char)(TLS1_2_VERSION & 0xff); / * datalen will always fit into 2 bytes because our original buffer size is less than that. / dummyrec[3] = (unsigned char)((datalen >> 8) & 0xff); dummyrec[4] = (unsigned char)(datalen & 0xff); rl->msg_callback(0, TLS1_3_VERSION, SSL3_RT_HEADER, dummyrec, SSL3_RT_HEADER_LENGTH, rl->cbarg); rl->msg_callback(0, TLS1_3_VERSION, SSL3_RT_INNER_CONTENT_TYPE, type, 1, rl->cbarg); } return OSSL_RECORD_RETURN_SUCCESS; } static int quic_release_record(OSSL_RECORD_LAYER rl, void rechandle, size_t length) { if (!ossl_assert(rl->recread > 0) \|\| !ossl_assert(rl->recunreleased <= rl->recread) \|\| !ossl_assert(rl == rechandle) \|\| !ossl_assert(length <= rl->recunreleased)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } rl->recunreleased -= length; if (rl->recunreleased > 0) return OSSL_RECORD_RETURN_SUCCESS; if (!rl->qtls->args.crypto_release_rcd_cb(rl->recread, rl->qtls->args.crypto_release_rcd_cb_arg)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } rl->recread = 0; return OSSL_RECORD_RETURN_SUCCESS; } static int quic_get_alert_code(OSSL_RECORD_LAYER rl) { return rl->alert; } static int quic_set_protocol_version(OSSL_RECORD_LAYER rl, int version) { / We only support TLSv1.3, so its bad if we negotiate anything else / if (!ossl_assert(version == TLS1_3_VERSION)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } static void quic_set_plain_alerts(OSSL_RECORD_LAYER rl, int allow) { /* We don't care / } static void quic_set_first_handshake(OSSL_RECORD_LAYER rl, int first) { /* We don't care / } static void quic_set_max_pipelines(OSSL_RECORD_LAYER rl, size_t max_pipelines) { /* We don't care / } static void quic_get_state(OSSL_RECORD_LAYER rl, const char shortstr, const char longstr) { /* * According to the docs, valid read state strings are: "RH"/"read header", * "RB"/"read body", and "unknown"/"unknown". We don't read records in quite * that way, so we report every "normal" state as "read header". In the * event of error then we report "unknown". / if (rl->qtls->inerror) { if (shortstr != NULL) shortstr = "unknown"; if (longstr != NULL) longstr = "unknown"; } else { if (shortstr != NULL) shortstr = "RH"; if (longstr != NULL) longstr = "read header"; } } static int quic_set_options(OSSL_RECORD_LAYER rl, const OSSL_PARAM options) { / * We don't support any options yet - but we might do at some point so * this could be useful. / return 1; } static const COMP_METHOD quic_get_compression(OSSL_RECORD_LAYER rl) { / We only support TLSv1.3 which doesn't have compression / return NULL; } static void quic_set_max_frag_len(OSSL_RECORD_LAYER rl, size_t max_frag_len) { /* This really doesn't make any sense for QUIC. Ignore it / } static int quic_alloc_buffers(OSSL_RECORD_LAYER rl) { /* * This is a hint only. We don't support it (yet), so just ignore the * request / return 1; } static int quic_free_buffers(OSSL_RECORD_LAYER rl) { /* * This is a hint only. We don't support it (yet), so just ignore the * request / return 1; } static int quic_set1_bio(OSSL_RECORD_LAYER rl, BIO bio) { if (bio != NULL && !BIO_up_ref(bio)) return 0; BIO_free(rl->dummybio); rl->dummybio = bio; return 1; } / * Never called functions * * Due to the way we are configured and used we never expect any of the next set * of functions to be called. Therefore we set them to always fail. / static size_t quic_app_data_pending(OSSL_RECORD_LAYER rl) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return (size_t)ossl_assert(0); } static size_t quic_get_max_record_overhead(OSSL_RECORD_LAYER rl) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return (size_t)ossl_assert(0); } static int quic_increment_sequence_ctr(OSSL_RECORD_LAYER rl) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return ossl_assert(0); } /* End of never called functions / static const OSSL_RECORD_METHOD quic_tls_record_method = { quic_new_record_layer, quic_free, quic_unprocessed_read_pending, quic_processed_read_pending, quic_app_data_pending, / Never called / quic_get_max_records, quic_write_records, quic_retry_write_records, quic_read_record, quic_release_record, quic_get_alert_code, quic_set1_bio, quic_set_protocol_version, quic_set_plain_alerts, quic_set_first_handshake, quic_set_max_pipelines, NULL, / set_in_init: Optional - we don't need it / quic_get_state, quic_set_options, quic_get_compression, quic_set_max_frag_len, quic_get_max_record_overhead, / Never called / quic_increment_sequence_ctr, / Never called / quic_alloc_buffers, quic_free_buffers }; static int add_transport_params_cb(SSL s, unsigned int ext_type, unsigned int context, const unsigned char *out, size_t outlen, X509 x, size_t chainidx, int al, void add_arg) { QUIC_TLS qtls = add_arg; out = qtls->local_transport_params; outlen = qtls->local_transport_params_len; return 1; } static void free_transport_params_cb(SSL s, unsigned int ext_type, unsigned int context, const unsigned char out, void add_arg) { } static int parse_transport_params_cb(SSL s, unsigned int ext_type, unsigned int context, const unsigned char in, size_t inlen, X509 x, size_t chainidx, int al, void parse_arg) { QUIC_TLS qtls = parse_arg; return qtls->args.got_transport_params_cb(in, inlen, qtls->args.got_transport_params_cb_arg); } QUIC_TLS ossl_quic_tls_new(const QUIC_TLS_ARGS args) { QUIC_TLS qtls; if (args->crypto_send_cb == NULL \|\| args->crypto_recv_rcd_cb == NULL \|\| args->crypto_release_rcd_cb == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return NULL; } qtls = OPENSSL_zalloc(sizeof(qtls)); if (qtls == NULL) return NULL; if ((qtls->error_state = OSSL_ERR_STATE_new()) == NULL) { OPENSSL_free(qtls); return NULL; } qtls->args = args; return qtls; } void ossl_quic_tls_free(QUIC_TLS qtls) { if (qtls == NULL) return; OSSL_ERR_STATE_free(qtls->error_state); OPENSSL_free(qtls); } static int raise_error(QUIC_TLS qtls, uint64_t error_code, const char error_msg, const char src_file, int src_line, const char src_func) { / * When QTLS fails, add a "cover letter" error with information, potentially * with any underlying libssl errors underneath it (but our cover error may * be the only error in some cases). Then capture this into an ERR_STATE so * we can report it later if need be when the QUIC_CHANNEL asks for it. / ERR_new(); ERR_set_debug(src_file, src_line, src_func); ERR_set_error(ERR_LIB_SSL, SSL_R_QUIC_HANDSHAKE_LAYER_ERROR, "handshake layer error, error code %llu (0x%llx) (\"%s\")", error_code, error_code, error_msg); OSSL_ERR_STATE_save_to_mark(qtls->error_state); / * We record the error information reported via the QUIC protocol * separately. / qtls->error_code = error_code; qtls->error_msg = error_msg; qtls->inerror = 1; ERR_pop_to_mark(); return 0; } #define RAISE_ERROR(qtls, error_code, error_msg) \ raise_error((qtls), (error_code), (error_msg), \ OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC) #define RAISE_INTERNAL_ERROR(qtls) \ RAISE_ERROR((qtls), QUIC_ERR_INTERNAL_ERROR, "internal error") int ossl_quic_tls_tick(QUIC_TLS qtls) { int ret, err; const unsigned char alpn; unsigned int alpnlen; if (qtls->inerror) return 0; / * SSL_get_error does not truly know what the cause of an SSL_read failure * is and to some extent guesses based on contextual information. In * particular, if there is _any_ ERR on the error stack, SSL_ERROR_SSL or * SSL_ERROR_SYSCALL will be returned no matter what and there is no * possibility of SSL_ERROR_WANT_READ/WRITE being returned, even if that was * the actual cause of the SSL_read() failure. * * This means that ordinarily, the below code might not work right if the * application has any ERR on the error stack. In order to make this code * perform correctly regardless of prior ERR state, we use a variant of * SSL_get_error() which ignores the error stack. However, some ERRs are * raised by SSL_read() and actually indicate that something has gone wrong * during the call to SSL_read(). We therefore adopt a strategy of marking * the ERR stack and seeing if any errors get appended during the call to * SSL_read(). If they are, we assume SSL_read() has raised an error and * that we should use normal SSL_get_error() handling. * * NOTE: Ensure all escape paths from this function call * ERR_clear_to_mark(). The RAISE macros handle this in failure cases. / ERR_set_mark(); if (!qtls->configured) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(qtls->args.s); SSL_CTX sctx = SSL_CONNECTION_GET_CTX(sc); BIO nullbio; /* * No matter how the user has configured us, there are certain * requirements for QUIC-TLS that we enforce / / ALPN is a requirement for QUIC and must be set / if (qtls->args.is_server) { if (sctx->ext.alpn_select_cb == NULL) return RAISE_INTERNAL_ERROR(qtls); } else { if (sc->ext.alpn == NULL \|\| sc->ext.alpn_len == 0) return RAISE_ERROR(qtls, QUIC_ERR_CRYPTO_NO_APP_PROTO, "ALPN must be configured when using QUIC"); } if (!SSL_set_min_proto_version(qtls->args.s, TLS1_3_VERSION)) return RAISE_INTERNAL_ERROR(qtls); SSL_clear_options(qtls->args.s, SSL_OP_ENABLE_MIDDLEBOX_COMPAT); ossl_ssl_set_custom_record_layer(sc, &quic_tls_record_method, qtls); if (!ossl_tls_add_custom_ext_intern(NULL, &sc->cert->custext, qtls->args.is_server ? ENDPOINT_SERVER : ENDPOINT_CLIENT, TLSEXT_TYPE_quic_transport_parameters, SSL_EXT_TLS1_3_ONLY \| SSL_EXT_CLIENT_HELLO \| SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, add_transport_params_cb, free_transport_params_cb, qtls, parse_transport_params_cb, qtls)) return RAISE_INTERNAL_ERROR(qtls); nullbio = BIO_new(BIO_s_null()); if (nullbio == NULL) return RAISE_INTERNAL_ERROR(qtls); / * Our custom record layer doesn't use the BIO - but libssl generally * expects one to be present. / SSL_set_bio(qtls->args.s, nullbio, nullbio); if (qtls->args.is_server) SSL_set_accept_state(qtls->args.s); else SSL_set_connect_state(qtls->args.s); qtls->configured = 1; } if (qtls->complete) / * There should never be app data to read, but calling SSL_read() will * ensure any post-handshake messages are processed. / ret = SSL_read(qtls->args.s, NULL, 0); else ret = SSL_do_handshake(qtls->args.s); if (ret <= 0) { err = ossl_ssl_get_error(qtls->args.s, ret, /check_err=/ERR_count_to_mark() > 0); switch (err) { case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_CLIENT_HELLO_CB: case SSL_ERROR_WANT_X509_LOOKUP: case SSL_ERROR_WANT_RETRY_VERIFY: ERR_pop_to_mark(); return 1; default: return RAISE_INTERNAL_ERROR(qtls); } } if (!qtls->complete) { / Validate that we have ALPN / SSL_get0_alpn_selected(qtls->args.s, &alpn, &alpnlen); if (alpn == NULL \|\| alpnlen == 0) return RAISE_ERROR(qtls, QUIC_ERR_CRYPTO_NO_APP_PROTO, "no application protocol negotiated"); qtls->complete = 1; ERR_pop_to_mark(); return qtls->args.handshake_complete_cb(qtls->args.handshake_complete_cb_arg); } ERR_pop_to_mark(); return 1; } int ossl_quic_tls_set_transport_params(QUIC_TLS qtls, const unsigned char transport_params, size_t transport_params_len) { qtls->local_transport_params = transport_params; qtls->local_transport_params_len = transport_params_len; return 1; } int ossl_quic_tls_get_error(QUIC_TLS qtls, uint64_t error_code, const char error_msg, ERR_STATE error_state) { if (qtls->inerror) { error_code = qtls->error_code; error_msg = qtls->error_msg; error_state = qtls->error_state; } return qtls->inerror; } /* * Returns true if the last handshake record message we processed was a * CertificateRequest / int ossl_quic_tls_is_cert_request(QUIC_TLS qtls) { SSL_CONNECTION sc = SSL_CONNECTION_FROM_SSL(qtls->args.s); return sc->s3.tmp.message_type == SSL3_MT_CERTIFICATE_REQUEST; } / * Returns true if the last session associated with the connection has an * invalid max_early_data value for QUIC. / int ossl_quic_tls_has_bad_max_early_data(QUIC_TLS qtls) { uint32_t max_early_data = SSL_get0_session(qtls->args.s)->ext.max_early_data; /* * If max_early_data was present we always ensure a non-zero value is * stored in the session for QUIC. Therefore if max_early_data == 0 here * we can be confident that it was not present in the NewSessionTicket */ return max_early_data != 0xffffffff && max_early_data != 0; }
./openssl/ssl/quic/quic_types.c	/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_types.h" #include <openssl/rand.h> #include <openssl/err.h> int ossl_quic_gen_rand_conn_id(OSSL_LIB_CTX libctx, size_t len, QUIC_CONN_ID cid) { if (len > QUIC_MAX_CONN_ID_LEN) return 0; cid->id_len = (unsigned char)len; if (RAND_bytes_ex(libctx, cid->id, len, len 8) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_RAND_LIB); cid->id_len = 0; return 0; } return 1; }
./openssl/ssl/quic/quic_srtm.c	/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_srtm.h" #include "internal/common.h" #include <openssl/lhash.h> #include <openssl/core_names.h> #include <openssl/rand.h> / * QUIC Stateless Reset Token Manager * ================================== / typedef struct srtm_item_st SRTM_ITEM; #define BLINDED_SRT_LEN 16 DEFINE_LHASH_OF_EX(SRTM_ITEM); / * The SRTM is implemented using two LHASH instances, one matching opaque pointers to * an item structure, and another matching a SRT-derived value to an item * structure. Multiple items with different seq_num values under a given opaque, * and duplicate SRTs, are handled using sorted singly-linked lists. * * The O(n) insert and lookup performance is tolerated on the basis that the * total number of entries for a given opaque (total number of extant CIDs for a * connection) should be quite small, and the QUIC protocol allows us to place a * hard limit on this via the active_connection_id_limit TPARAM. Thus there is * no risk of a large number of SRTs needing to be registered under a given * opaque. * * It is expected one SRTM will exist per QUIC_PORT and track all SRTs across * all connections for that QUIC_PORT. / struct srtm_item_st { SRTM_ITEM next_by_srt_blinded; /* SORT BY opaque DESC / SRTM_ITEM next_by_seq_num; /* SORT BY seq_num DESC / void opaque; /* \__ unique identity for item / uint64_t seq_num; / / / QUIC_STATELESS_RESET_TOKEN srt; unsigned char srt_blinded[BLINDED_SRT_LEN]; / H(srt) / #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION uint32_t debug_token; #endif }; struct quic_srtm_st { / Crypto context used to calculate blinded SRTs H(srt). / EVP_CIPHER_CTX blind_ctx; /* kept with key / LHASH_OF(SRTM_ITEM) items_fwd; /* (opaque) -> SRTM_ITEM / LHASH_OF(SRTM_ITEM) items_rev; /* (H(srt)) -> SRTM_ITEM / / * Monotonically transitions to 1 in event of allocation failure. The only * valid operation on such an object is to free it. / unsigned int alloc_failed : 1; }; static unsigned long items_fwd_hash(const SRTM_ITEM item) { return (unsigned long)(uintptr_t)item->opaque; } static int items_fwd_cmp(const SRTM_ITEM a, const SRTM_ITEM b) { return a->opaque != b->opaque; } static unsigned long items_rev_hash(const SRTM_ITEM item) { / * srt_blinded has already been through a crypto-grade hash function, so we * can just use bits from that. / unsigned long l; memcpy(&l, item->srt_blinded, sizeof(l)); return l; } static int items_rev_cmp(const SRTM_ITEM a, const SRTM_ITEM b) { / * We don't need to use CRYPTO_memcmp here as the relationship of * srt_blinded to srt is already cryptographically obfuscated. / return memcmp(a->srt_blinded, b->srt_blinded, sizeof(a->srt_blinded)); } static int srtm_check_lh(QUIC_SRTM srtm, LHASH_OF(SRTM_ITEM) lh) { if (lh_SRTM_ITEM_error(lh)) { srtm->alloc_failed = 1; return 0; } return 1; } QUIC_SRTM ossl_quic_srtm_new(OSSL_LIB_CTX libctx, const char propq) { QUIC_SRTM srtm = NULL; unsigned char key[16]; EVP_CIPHER ecb = NULL; if (RAND_priv_bytes_ex(libctx, key, sizeof(key), sizeof(key) * 8) != 1) goto err; if ((srtm = OPENSSL_zalloc(sizeof(srtm))) == NULL) return NULL; / Use AES-128-ECB as a permutation over 128-bit SRTs. / if ((ecb = EVP_CIPHER_fetch(libctx, "AES-128-ECB", propq)) == NULL) goto err; if ((srtm->blind_ctx = EVP_CIPHER_CTX_new()) == NULL) goto err; if (!EVP_EncryptInit_ex2(srtm->blind_ctx, ecb, key, NULL, NULL)) goto err; EVP_CIPHER_free(ecb); ecb = NULL; / Create mappings. / if ((srtm->items_fwd = lh_SRTM_ITEM_new(items_fwd_hash, items_fwd_cmp)) == NULL \|\| (srtm->items_rev = lh_SRTM_ITEM_new(items_rev_hash, items_rev_cmp)) == NULL) goto err; return srtm; err: / * No cleansing of key needed as blinding exists only for side channel * mitigation. / ossl_quic_srtm_free(srtm); EVP_CIPHER_free(ecb); return NULL; } static void srtm_free_each(SRTM_ITEM ihead) { SRTM_ITEM inext, item = ihead; for (item = item->next_by_seq_num; item != NULL; item = inext) { inext = item->next_by_seq_num; OPENSSL_free(item); } OPENSSL_free(ihead); } void ossl_quic_srtm_free(QUIC_SRTM srtm) { if (srtm == NULL) return; lh_SRTM_ITEM_free(srtm->items_rev); if (srtm->items_fwd != NULL) { lh_SRTM_ITEM_doall(srtm->items_fwd, srtm_free_each); lh_SRTM_ITEM_free(srtm->items_fwd); } EVP_CIPHER_CTX_free(srtm->blind_ctx); OPENSSL_free(srtm); } / * Find a SRTM_ITEM by (opaque, seq_num). Returns NULL if no match. * If head is non-NULL, writes the head of the relevant opaque list to head if there is one. * If prev is non-NULL, writes the previous node to prev or NULL if it is the first item. / static SRTM_ITEM srtm_find(QUIC_SRTM srtm, void opaque, uint64_t seq_num, SRTM_ITEM head_p, SRTM_ITEM prev_p) { SRTM_ITEM key, item = NULL, prev = NULL; key.opaque = opaque; item = lh_SRTM_ITEM_retrieve(srtm->items_fwd, &key); if (head_p != NULL) head_p = item; for (; item != NULL; prev = item, item = item->next_by_seq_num) if (item->seq_num == seq_num) { break; } else if (item->seq_num < seq_num) { / * List is sorted in descending order so there can't be any match * after this. / item = NULL; break; } if (prev_p != NULL) prev_p = prev; return item; } /* * Inserts a SRTM_ITEM into the singly-linked by-sequence-number linked list. * The new head pointer is written to new_head (which may or may not be unchanged). / static void sorted_insert_seq_num(SRTM_ITEM head, SRTM_ITEM item, SRTM_ITEM new_head) { uint64_t seq_num = item->seq_num; SRTM_ITEM cur = head, *fixup = new_head; new_head = head; while (cur != NULL && cur->seq_num > seq_num) { fixup = &cur->next_by_seq_num; cur = cur->next_by_seq_num; } item->next_by_seq_num = fixup; fixup = item; } /* * Inserts a SRTM_ITEM into the singly-linked by-SRT list. * The new head pointer is written to new_head (which may or may not be unchanged). / static void sorted_insert_srt(SRTM_ITEM head, SRTM_ITEM item, SRTM_ITEM new_head) { uintptr_t opaque = (uintptr_t)item->opaque; SRTM_ITEM cur = head, *fixup = new_head; new_head = head; while (cur != NULL && (uintptr_t)cur->opaque > opaque) { fixup = &cur->next_by_srt_blinded; cur = cur->next_by_srt_blinded; } item->next_by_srt_blinded = fixup; fixup = item; } /* * Computes the blinded SRT value used for internal lookup for side channel * mitigation purposes. We compute this once as a cached value when an SRTM_ITEM * is formed. / static int srtm_compute_blinded(QUIC_SRTM srtm, SRTM_ITEM item, const QUIC_STATELESS_RESET_TOKEN token) { int outl = 0; /* * We use AES-128-ECB as a permutation using a random key to facilitate * blinding for side-channel purposes. Encrypt the token as a single AES * block. / if (!EVP_EncryptUpdate(srtm->blind_ctx, item->srt_blinded, &outl, (const unsigned char )token, sizeof(token))) return 0; if (!ossl_assert(outl == sizeof(token))) return 0; return 1; } int ossl_quic_srtm_add(QUIC_SRTM srtm, void opaque, uint64_t seq_num, const QUIC_STATELESS_RESET_TOKEN token) { SRTM_ITEM item = NULL, head = NULL, new_head, r_item; if (srtm->alloc_failed) return 0; / (opaque, seq_num) duplicates not allowed / if ((item = srtm_find(srtm, opaque, seq_num, &head, NULL)) != NULL) return 0; if ((item = OPENSSL_zalloc(sizeof(item))) == NULL) return 0; item->opaque = opaque; item->seq_num = seq_num; item->srt = token; if (!srtm_compute_blinded(srtm, item, &item->srt)) { OPENSSL_free(item); return 0; } / Add to forward mapping. / if (head == NULL) { / First item under this opaque / lh_SRTM_ITEM_insert(srtm->items_fwd, item); if (!srtm_check_lh(srtm, srtm->items_fwd)) { OPENSSL_free(item); return 0; } } else { sorted_insert_seq_num(head, item, &new_head); if (new_head != head) { / head changed, update in lhash / lh_SRTM_ITEM_insert(srtm->items_fwd, new_head); if (!srtm_check_lh(srtm, srtm->items_fwd)) { OPENSSL_free(item); return 0; } } } / Add to reverse mapping. / r_item = lh_SRTM_ITEM_retrieve(srtm->items_rev, item); if (r_item == NULL) { / First item under this blinded SRT / lh_SRTM_ITEM_insert(srtm->items_rev, item); if (!srtm_check_lh(srtm, srtm->items_rev)) / * Can't free the item now as we would have to undo the insertion * into the forward mapping which would require an insert operation * to restore the previous value. which might also fail. However, * the item will be freed OK when we free the entire SRTM. / return 0; } else { sorted_insert_srt(r_item, item, &new_head); if (new_head != r_item) { / head changed, update in lhash / lh_SRTM_ITEM_insert(srtm->items_rev, new_head); if (!srtm_check_lh(srtm, srtm->items_rev)) / As above. / return 0; } } return 1; } / Remove item from reverse mapping. / static int srtm_remove_from_rev(QUIC_SRTM srtm, SRTM_ITEM item) { SRTM_ITEM rh_item; rh_item = lh_SRTM_ITEM_retrieve(srtm->items_rev, item); assert(rh_item != NULL); if (rh_item == item) { /* * Change lhash to point to item after this one, or remove the entry if * this is the last one. / if (item->next_by_srt_blinded != NULL) { lh_SRTM_ITEM_insert(srtm->items_rev, item->next_by_srt_blinded); if (!srtm_check_lh(srtm, srtm->items_rev)) return 0; } else { lh_SRTM_ITEM_delete(srtm->items_rev, item); } } else { / Find our entry in the SRT list / for (; rh_item->next_by_srt_blinded != item; rh_item = rh_item->next_by_srt_blinded); rh_item->next_by_srt_blinded = item->next_by_srt_blinded; } return 1; } int ossl_quic_srtm_remove(QUIC_SRTM srtm, void opaque, uint64_t seq_num) { SRTM_ITEM item, prev = NULL; if (srtm->alloc_failed) return 0; if ((item = srtm_find(srtm, opaque, seq_num, NULL, &prev)) == NULL) / No match / return 0; / Remove from forward mapping. / if (prev == NULL) { / * Change lhash to point to item after this one, or remove the entry if * this is the last one. / if (item->next_by_seq_num != NULL) { lh_SRTM_ITEM_insert(srtm->items_fwd, item->next_by_seq_num); if (!srtm_check_lh(srtm, srtm->items_fwd)) return 0; } else { lh_SRTM_ITEM_delete(srtm->items_fwd, item); } } else { prev->next_by_seq_num = item->next_by_seq_num; } / Remove from reverse mapping. / if (!srtm_remove_from_rev(srtm, item)) return 0; OPENSSL_free(item); return 1; } int ossl_quic_srtm_cull(QUIC_SRTM srtm, void opaque) { SRTM_ITEM key, item = NULL, inext, ihead; key.opaque = opaque; if (srtm->alloc_failed) return 0; if ((ihead = lh_SRTM_ITEM_retrieve(srtm->items_fwd, &key)) == NULL) return 1; /* nothing removed is a success condition / for (item = ihead; item != NULL; item = inext) { inext = item->next_by_seq_num; if (item != ihead) { srtm_remove_from_rev(srtm, item); OPENSSL_free(item); } } lh_SRTM_ITEM_delete(srtm->items_fwd, ihead); srtm_remove_from_rev(srtm, ihead); OPENSSL_free(ihead); return 1; } int ossl_quic_srtm_lookup(QUIC_SRTM srtm, const QUIC_STATELESS_RESET_TOKEN token, size_t idx, void opaque, uint64_t seq_num) { SRTM_ITEM key, item; if (srtm->alloc_failed) return 0; if (!srtm_compute_blinded(srtm, &key, token)) return 0; item = lh_SRTM_ITEM_retrieve(srtm->items_rev, &key); for (; idx > 0 && item != NULL; --idx, item = item->next_by_srt_blinded); if (item == NULL) return 0; if (opaque != NULL) opaque = item->opaque; if (seq_num != NULL) seq_num = item->seq_num; return 1; } #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION static uint32_t token_next = 0x5eadbeef; static size_t tokens_seen; struct check_args { uint32_t token; int mode; }; static void check_mark(SRTM_ITEM item, void arg) { struct check_args arg_ = arg; uint32_t token = arg_->token; uint64_t prev_seq_num = 0; void prev_opaque = NULL; int have_prev = 0; assert(item != NULL); while (item != NULL) { if (have_prev) { assert(!(item->opaque == prev_opaque && item->seq_num == prev_seq_num)); if (!arg_->mode) assert(item->opaque != prev_opaque \|\| item->seq_num < prev_seq_num); } ++tokens_seen; item->debug_token = token; prev_opaque = item->opaque; prev_seq_num = item->seq_num; have_prev = 1; if (arg_->mode) item = item->next_by_srt_blinded; else item = item->next_by_seq_num; } } static void check_count(SRTM_ITEM item, void arg) { struct check_args arg_ = arg; uint32_t token = arg_->token; assert(item != NULL); while (item != NULL) { ++tokens_seen; assert(item->debug_token == token); if (arg_->mode) item = item->next_by_seq_num; else item = item->next_by_srt_blinded; } } #endif void ossl_quic_srtm_check(const QUIC_SRTM *srtm) { #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION struct check_args args = {0}; size_t tokens_expected, tokens_expected_old; args.token = token_next; ++token_next; assert(srtm != NULL); assert(srtm->blind_ctx != NULL); assert(srtm->items_fwd != NULL); assert(srtm->items_rev != NULL); tokens_seen = 0; lh_SRTM_ITEM_doall_arg(srtm->items_fwd, check_mark, &args); tokens_expected = tokens_seen; tokens_seen = 0; lh_SRTM_ITEM_doall_arg(srtm->items_rev, check_count, &args); assert(tokens_seen == tokens_expected); tokens_expected_old = tokens_expected; args.token = token_next; ++token_next; args.mode = 1; tokens_seen = 0; lh_SRTM_ITEM_doall_arg(srtm->items_rev, check_mark, &args); tokens_expected = tokens_seen; tokens_seen = 0; lh_SRTM_ITEM_doall_arg(srtm->items_fwd, check_count, &args); assert(tokens_seen == tokens_expected); assert(tokens_seen == tokens_expected_old); #endif }
./openssl/ssl/quic/quic_rstream.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/err.h> #include "internal/common.h" #include "internal/time.h" #include "internal/quic_stream.h" #include "internal/quic_sf_list.h" #include "internal/ring_buf.h" struct quic_rstream_st { SFRAME_LIST fl; QUIC_RXFC rxfc; OSSL_STATM statm; UINT_RANGE head_range; struct ring_buf rbuf; }; QUIC_RSTREAM ossl_quic_rstream_new(QUIC_RXFC rxfc, OSSL_STATM statm, size_t rbuf_size) { QUIC_RSTREAM ret = OPENSSL_zalloc(sizeof(ret)); if (ret == NULL) return NULL; ring_buf_init(&ret->rbuf); if (!ring_buf_resize(&ret->rbuf, rbuf_size, 0)) { OPENSSL_free(ret); return NULL; } ossl_sframe_list_init(&ret->fl); ret->rxfc = rxfc; ret->statm = statm; return ret; } void ossl_quic_rstream_free(QUIC_RSTREAM qrs) { int cleanse; if (qrs == NULL) return; cleanse = qrs->fl.cleanse; ossl_sframe_list_destroy(&qrs->fl); ring_buf_destroy(&qrs->rbuf, cleanse); OPENSSL_free(qrs); } int ossl_quic_rstream_queue_data(QUIC_RSTREAM qrs, OSSL_QRX_PKT pkt, uint64_t offset, const unsigned char data, uint64_t data_len, int fin) { UINT_RANGE range; if ((data == NULL && data_len != 0) \|\| (data_len == 0 && fin == 0)) { /* empty frame allowed only at the end of the stream / ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } range.start = offset; range.end = offset + data_len; return ossl_sframe_list_insert(&qrs->fl, &range, pkt, data, fin); } static int read_internal(QUIC_RSTREAM qrs, unsigned char buf, size_t size, size_t readbytes, int fin, int drop) { void iter = NULL; UINT_RANGE range; const unsigned char data; uint64_t offset = 0; size_t readbytes_ = 0; int fin_ = 0, ret = 1; while (ossl_sframe_list_peek(&qrs->fl, &iter, &range, &data, &fin_)) { size_t l = (size_t)(range.end - range.start); if (l > size) { l = size; fin_ = 0; } offset = range.start + l; if (l == 0) break; if (data == NULL) { size_t max_len; data = ring_buf_get_ptr(&qrs->rbuf, range.start, &max_len); if (!ossl_assert(data != NULL)) return 0; if (max_len < l) { memcpy(buf, data, max_len); size -= max_len; buf += max_len; readbytes_ += max_len; l -= max_len; data = ring_buf_get_ptr(&qrs->rbuf, range.start + max_len, &max_len); if (!ossl_assert(data != NULL) \|\| !ossl_assert(max_len > l)) return 0; } } memcpy(buf, data, l); size -= l; buf += l; readbytes_ += l; if (size == 0) break; } if (drop && offset != 0) { ret = ossl_sframe_list_drop_frames(&qrs->fl, offset); ring_buf_cpop_range(&qrs->rbuf, 0, offset - 1, qrs->fl.cleanse); } if (ret) { readbytes = readbytes_; fin = fin_; } return ret; } static OSSL_TIME get_rtt(QUIC_RSTREAM qrs) { OSSL_TIME rtt; if (qrs->statm != NULL) { OSSL_RTT_INFO rtt_info; ossl_statm_get_rtt_info(qrs->statm, &rtt_info); rtt = rtt_info.smoothed_rtt; } else { rtt = ossl_time_zero(); } return rtt; } int ossl_quic_rstream_read(QUIC_RSTREAM qrs, unsigned char buf, size_t size, size_t readbytes, int fin) { OSSL_TIME rtt = get_rtt(qrs); if (!read_internal(qrs, buf, size, readbytes, fin, 1)) return 0; if (qrs->rxfc != NULL && !ossl_quic_rxfc_on_retire(qrs->rxfc, readbytes, rtt)) return 0; return 1; } int ossl_quic_rstream_peek(QUIC_RSTREAM qrs, unsigned char buf, size_t size, size_t readbytes, int fin) { return read_internal(qrs, buf, size, readbytes, fin, 0); } int ossl_quic_rstream_available(QUIC_RSTREAM qrs, size_t avail, int fin) { void iter = NULL; UINT_RANGE range; const unsigned char data; uint64_t avail_ = 0; while (ossl_sframe_list_peek(&qrs->fl, &iter, &range, &data, fin)) avail_ += range.end - range.start; #if SIZE_MAX < UINT64_MAX avail = avail_ > SIZE_MAX ? SIZE_MAX : (size_t)avail_; #else avail = (size_t)avail_; #endif return 1; } int ossl_quic_rstream_get_record(QUIC_RSTREAM qrs, const unsigned char record, size_t rec_len, int fin) { const unsigned char record_ = NULL; size_t rec_len_, max_len; if (!ossl_sframe_list_lock_head(&qrs->fl, &qrs->head_range, &record_, fin)) { /* No head frame to lock and return / record = NULL; rec_len = 0; return 1; } / if final empty frame, we drop it immediately / if (qrs->head_range.end == qrs->head_range.start) { if (!ossl_assert(fin)) return 0; if (!ossl_sframe_list_drop_frames(&qrs->fl, qrs->head_range.end)) return 0; } rec_len_ = (size_t)(qrs->head_range.end - qrs->head_range.start); if (record_ == NULL && rec_len_ != 0) { record_ = ring_buf_get_ptr(&qrs->rbuf, qrs->head_range.start, &max_len); if (!ossl_assert(record_ != NULL)) return 0; if (max_len < rec_len_) { rec_len_ = max_len; qrs->head_range.end = qrs->head_range.start + max_len; } } rec_len = rec_len_; record = record_; return 1; } int ossl_quic_rstream_release_record(QUIC_RSTREAM qrs, size_t read_len) { uint64_t offset; if (!ossl_sframe_list_is_head_locked(&qrs->fl)) return 0; if (read_len > qrs->head_range.end - qrs->head_range.start) { if (read_len != SIZE_MAX) return 0; offset = qrs->head_range.end; } else { offset = qrs->head_range.start + read_len; } if (!ossl_sframe_list_drop_frames(&qrs->fl, offset)) return 0; if (offset > 0) ring_buf_cpop_range(&qrs->rbuf, 0, offset - 1, qrs->fl.cleanse); if (qrs->rxfc != NULL) { OSSL_TIME rtt = get_rtt(qrs); if (!ossl_quic_rxfc_on_retire(qrs->rxfc, offset, rtt)) return 0; } return 1; } static int write_at_ring_buf_cb(uint64_t logical_offset, const unsigned char buf, size_t buf_len, void cb_arg) { struct ring_buf rbuf = cb_arg; return ring_buf_write_at(rbuf, logical_offset, buf, buf_len); } int ossl_quic_rstream_move_to_rbuf(QUIC_RSTREAM qrs) { if (ring_buf_avail(&qrs->rbuf) == 0) return 0; return ossl_sframe_list_move_data(&qrs->fl, write_at_ring_buf_cb, &qrs->rbuf); } int ossl_quic_rstream_resize_rbuf(QUIC_RSTREAM qrs, size_t rbuf_size) { if (ossl_sframe_list_is_head_locked(&qrs->fl)) return 0; if (!ring_buf_resize(&qrs->rbuf, rbuf_size, qrs->fl.cleanse)) return 0; return 1; } void ossl_quic_rstream_set_cleanse(QUIC_RSTREAM *qrs, int cleanse) { qrs->fl.cleanse = cleanse; }
./openssl/ssl/quic/quic_wire_pkt.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include <openssl/err.h> #include "internal/common.h" #include "internal/quic_wire_pkt.h" int ossl_quic_hdr_protector_init(QUIC_HDR_PROTECTOR hpr, OSSL_LIB_CTX libctx, const char propq, uint32_t cipher_id, const unsigned char quic_hp_key, size_t quic_hp_key_len) { const char cipher_name = NULL; switch (cipher_id) { case QUIC_HDR_PROT_CIPHER_AES_128: cipher_name = "AES-128-ECB"; break; case QUIC_HDR_PROT_CIPHER_AES_256: cipher_name = "AES-256-ECB"; break; case QUIC_HDR_PROT_CIPHER_CHACHA: cipher_name = "ChaCha20"; break; default: ERR_raise(ERR_LIB_SSL, ERR_R_UNSUPPORTED); return 0; } hpr->cipher_ctx = EVP_CIPHER_CTX_new(); if (hpr->cipher_ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } hpr->cipher = EVP_CIPHER_fetch(libctx, cipher_name, propq); if (hpr->cipher == NULL \|\| quic_hp_key_len != (size_t)EVP_CIPHER_get_key_length(hpr->cipher)) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } if (!EVP_CipherInit_ex(hpr->cipher_ctx, hpr->cipher, NULL, quic_hp_key, NULL, 1)) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } hpr->libctx = libctx; hpr->propq = propq; hpr->cipher_id = cipher_id; return 1; err: ossl_quic_hdr_protector_cleanup(hpr); return 0; } void ossl_quic_hdr_protector_cleanup(QUIC_HDR_PROTECTOR hpr) { EVP_CIPHER_CTX_free(hpr->cipher_ctx); hpr->cipher_ctx = NULL; EVP_CIPHER_free(hpr->cipher); hpr->cipher = NULL; } static int hdr_generate_mask(QUIC_HDR_PROTECTOR hpr, const unsigned char sample, size_t sample_len, unsigned char mask) { int l = 0; unsigned char dst[16]; static const unsigned char zeroes[5] = {0}; size_t i; if (hpr->cipher_id == QUIC_HDR_PROT_CIPHER_AES_128 \|\| hpr->cipher_id == QUIC_HDR_PROT_CIPHER_AES_256) { if (sample_len < 16) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); return 0; } if (!EVP_CipherInit_ex(hpr->cipher_ctx, NULL, NULL, NULL, NULL, 1) \|\| !EVP_CipherUpdate(hpr->cipher_ctx, dst, &l, sample, 16)) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } for (i = 0; i < 5; ++i) mask[i] = dst[i]; } else if (hpr->cipher_id == QUIC_HDR_PROT_CIPHER_CHACHA) { if (sample_len < 16) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); return 0; } if (!EVP_CipherInit_ex(hpr->cipher_ctx, NULL, NULL, NULL, sample, 1) \|\| !EVP_CipherUpdate(hpr->cipher_ctx, mask, &l, zeroes, sizeof(zeroes))) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } } else { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); assert(0); return 0; } #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION /* No matter what we did above we use the same mask in fuzzing mode / memset(mask, 0, 5); #endif return 1; } int ossl_quic_hdr_protector_decrypt(QUIC_HDR_PROTECTOR hpr, QUIC_PKT_HDR_PTRS ptrs) { return ossl_quic_hdr_protector_decrypt_fields(hpr, ptrs->raw_sample, ptrs->raw_sample_len, ptrs->raw_start, ptrs->raw_pn); } int ossl_quic_hdr_protector_decrypt_fields(QUIC_HDR_PROTECTOR hpr, const unsigned char sample, size_t sample_len, unsigned char first_byte, unsigned char pn_bytes) { unsigned char mask[5], pn_len, i; if (!hdr_generate_mask(hpr, sample, sample_len, mask)) return 0; first_byte ^= mask[0] & ((first_byte & 0x80) != 0 ? 0xf : 0x1f); pn_len = (first_byte & 0x3) + 1; for (i = 0; i < pn_len; ++i) pn_bytes[i] ^= mask[i + 1]; return 1; } int ossl_quic_hdr_protector_encrypt(QUIC_HDR_PROTECTOR hpr, QUIC_PKT_HDR_PTRS ptrs) { return ossl_quic_hdr_protector_encrypt_fields(hpr, ptrs->raw_sample, ptrs->raw_sample_len, ptrs->raw_start, ptrs->raw_pn); } int ossl_quic_hdr_protector_encrypt_fields(QUIC_HDR_PROTECTOR hpr, const unsigned char sample, size_t sample_len, unsigned char first_byte, unsigned char pn_bytes) { unsigned char mask[5], pn_len, i; if (!hdr_generate_mask(hpr, sample, sample_len, mask)) return 0; pn_len = (first_byte & 0x3) + 1; for (i = 0; i < pn_len; ++i) pn_bytes[i] ^= mask[i + 1]; first_byte ^= mask[0] & ((first_byte & 0x80) != 0 ? 0xf : 0x1f); return 1; } int ossl_quic_wire_decode_pkt_hdr(PACKET pkt, size_t short_conn_id_len, int partial, int nodata, QUIC_PKT_HDR hdr, QUIC_PKT_HDR_PTRS ptrs) { unsigned int b0; unsigned char pn = NULL; size_t l = PACKET_remaining(pkt); if (ptrs != NULL) { ptrs->raw_start = (unsigned char )PACKET_data(pkt); ptrs->raw_sample = NULL; ptrs->raw_sample_len = 0; ptrs->raw_pn = NULL; } if (l < QUIC_MIN_VALID_PKT_LEN \|\| !PACKET_get_1(pkt, &b0)) return 0; hdr->partial = partial; hdr->unused = 0; hdr->reserved = 0; if ((b0 & 0x80) == 0) { /* Short header. / if (short_conn_id_len > QUIC_MAX_CONN_ID_LEN) return 0; if ((b0 & 0x40) == 0 / fixed bit not set? / \|\| l < QUIC_MIN_VALID_PKT_LEN_CRYPTO) return 0; hdr->type = QUIC_PKT_TYPE_1RTT; hdr->fixed = 1; hdr->spin_bit = (b0 & 0x20) != 0; if (partial) { hdr->key_phase = 0; / protected, zero for now / hdr->pn_len = 0; / protected, zero for now / hdr->reserved = 0; / protected, zero for now / } else { hdr->key_phase = (b0 & 0x04) != 0; hdr->pn_len = (b0 & 0x03) + 1; hdr->reserved = (b0 & 0x18) >> 3; } / Copy destination connection ID field to header structure. / if (!PACKET_copy_bytes(pkt, hdr->dst_conn_id.id, short_conn_id_len)) return 0; hdr->dst_conn_id.id_len = (unsigned char)short_conn_id_len; / * Skip over the PN. If this is a partial decode, the PN length field * currently has header protection applied. Thus we do not know the * length of the PN but we are allowed to assume it is 4 bytes long at * this stage. / memset(hdr->pn, 0, sizeof(hdr->pn)); pn = (unsigned char )PACKET_data(pkt); if (partial) { if (!PACKET_forward(pkt, sizeof(hdr->pn))) return 0; } else { if (!PACKET_copy_bytes(pkt, hdr->pn, hdr->pn_len)) return 0; } /* Fields not used in short-header packets. / hdr->version = 0; hdr->src_conn_id.id_len = 0; hdr->token = NULL; hdr->token_len = 0; / * Short-header packets always come last in a datagram, the length * is the remainder of the buffer. / hdr->len = PACKET_remaining(pkt); hdr->data = PACKET_data(pkt); / * Skip over payload. Since this is a short header packet, which cannot * be followed by any other kind of packet, this advances us to the end * of the datagram. / if (!PACKET_forward(pkt, hdr->len)) return 0; } else { / Long header. / unsigned long version; unsigned int dst_conn_id_len, src_conn_id_len, raw_type; if (!PACKET_get_net_4(pkt, &version)) return 0; / * All QUIC packets must have the fixed bit set, except exceptionally * for Version Negotiation packets. / if (version != 0 && (b0 & 0x40) == 0) return 0; if (!PACKET_get_1(pkt, &dst_conn_id_len) \|\| dst_conn_id_len > QUIC_MAX_CONN_ID_LEN \|\| !PACKET_copy_bytes(pkt, hdr->dst_conn_id.id, dst_conn_id_len) \|\| !PACKET_get_1(pkt, &src_conn_id_len) \|\| src_conn_id_len > QUIC_MAX_CONN_ID_LEN \|\| !PACKET_copy_bytes(pkt, hdr->src_conn_id.id, src_conn_id_len)) return 0; hdr->version = (uint32_t)version; hdr->dst_conn_id.id_len = (unsigned char)dst_conn_id_len; hdr->src_conn_id.id_len = (unsigned char)src_conn_id_len; if (version == 0) { / * Version negotiation packet. Version negotiation packets are * identified by a version field of 0 and the type bits in the first * byte are ignored (they may take any value, and we ignore them). / hdr->type = QUIC_PKT_TYPE_VERSION_NEG; hdr->fixed = (b0 & 0x40) != 0; hdr->data = PACKET_data(pkt); hdr->len = PACKET_remaining(pkt); / * Version negotiation packets must contain an array of u32s, so it * is invalid for their payload length to not be divisible by 4. / if ((hdr->len % 4) != 0) return 0; / Version negotiation packets are always fully decoded. / hdr->partial = 0; / Fields not used in version negotiation packets. / hdr->pn_len = 0; hdr->spin_bit = 0; hdr->key_phase = 0; hdr->token = NULL; hdr->token_len = 0; memset(hdr->pn, 0, sizeof(hdr->pn)); if (!PACKET_forward(pkt, hdr->len)) return 0; } else if (version != QUIC_VERSION_1) { / Unknown version, do not decode. / return 0; } else { if (l < QUIC_MIN_VALID_PKT_LEN_CRYPTO) return 0; / Get long packet type and decode to QUIC_PKT_TYPE_. / raw_type = ((b0 >> 4) & 0x3); switch (raw_type) { case 0: hdr->type = QUIC_PKT_TYPE_INITIAL; break; case 1: hdr->type = QUIC_PKT_TYPE_0RTT; break; case 2: hdr->type = QUIC_PKT_TYPE_HANDSHAKE; break; case 3: hdr->type = QUIC_PKT_TYPE_RETRY; break; } hdr->pn_len = 0; hdr->fixed = 1; /* Fields not used in long-header packets. / hdr->spin_bit = 0; hdr->key_phase = 0; if (hdr->type == QUIC_PKT_TYPE_INITIAL) { / Initial packet. / uint64_t token_len; if (!PACKET_get_quic_vlint(pkt, &token_len) \|\| token_len > SIZE_MAX \|\| !PACKET_get_bytes(pkt, &hdr->token, (size_t)token_len)) return 0; hdr->token_len = (size_t)token_len; if (token_len == 0) hdr->token = NULL; } else { hdr->token = NULL; hdr->token_len = 0; } if (hdr->type == QUIC_PKT_TYPE_RETRY) { / Retry packet. / hdr->data = PACKET_data(pkt); hdr->len = PACKET_remaining(pkt); / Retry packets are always fully decoded. / hdr->partial = 0; / Unused bits in Retry header. / hdr->unused = b0 & 0x0f; / Fields not used in Retry packets. / memset(hdr->pn, 0, sizeof(hdr->pn)); if (!PACKET_forward(pkt, hdr->len)) return 0; } else { / Initial, 0-RTT or Handshake packet. / uint64_t len; hdr->pn_len = partial ? 0 : ((b0 & 0x03) + 1); hdr->reserved = partial ? 0 : ((b0 & 0x0C) >> 2); if (!PACKET_get_quic_vlint(pkt, &len) \|\| len < sizeof(hdr->pn)) return 0; if (!nodata && len > PACKET_remaining(pkt)) return 0; / * Skip over the PN. If this is a partial decode, the PN length * field currently has header protection applied. Thus we do not * know the length of the PN but we are allowed to assume it is * 4 bytes long at this stage. / pn = (unsigned char )PACKET_data(pkt); memset(hdr->pn, 0, sizeof(hdr->pn)); if (partial) { if (!PACKET_forward(pkt, sizeof(hdr->pn))) return 0; hdr->len = (size_t)(len - sizeof(hdr->pn)); } else { if (!PACKET_copy_bytes(pkt, hdr->pn, hdr->pn_len)) return 0; hdr->len = (size_t)(len - hdr->pn_len); } if (nodata) { hdr->data = NULL; } else { hdr->data = PACKET_data(pkt); /* Skip over packet body. / if (!PACKET_forward(pkt, hdr->len)) return 0; } } } } if (ptrs != NULL) { ptrs->raw_pn = pn; if (pn != NULL) { ptrs->raw_sample = pn + 4; ptrs->raw_sample_len = PACKET_end(pkt) - ptrs->raw_sample; } } return 1; } int ossl_quic_wire_encode_pkt_hdr(WPACKET pkt, size_t short_conn_id_len, const QUIC_PKT_HDR hdr, QUIC_PKT_HDR_PTRS ptrs) { unsigned char b0; size_t off_start, off_sample, off_pn; unsigned char start = WPACKET_get_curr(pkt); if (!WPACKET_get_total_written(pkt, &off_start)) return 0; if (ptrs != NULL) { / ptrs would not be stable on non-static WPACKET / if (!ossl_assert(pkt->staticbuf != NULL)) return 0; ptrs->raw_start = NULL; ptrs->raw_sample = NULL; ptrs->raw_sample_len = 0; ptrs->raw_pn = 0; } / Cannot serialize a partial header, or one whose DCID length is wrong. / if (hdr->partial \|\| (hdr->type == QUIC_PKT_TYPE_1RTT && hdr->dst_conn_id.id_len != short_conn_id_len)) return 0; if (hdr->type == QUIC_PKT_TYPE_1RTT) { / Short header. / / * Cannot serialize a header whose DCID length is wrong, or with an * invalid PN length. / if (hdr->dst_conn_id.id_len != short_conn_id_len \|\| short_conn_id_len > QUIC_MAX_CONN_ID_LEN \|\| hdr->pn_len < 1 \|\| hdr->pn_len > 4) return 0; b0 = (hdr->spin_bit << 5) \| (hdr->key_phase << 2) \| (hdr->pn_len - 1) \| (hdr->reserved << 3) \| 0x40; / fixed bit / if (!WPACKET_put_bytes_u8(pkt, b0) \|\| !WPACKET_memcpy(pkt, hdr->dst_conn_id.id, short_conn_id_len) \|\| !WPACKET_get_total_written(pkt, &off_pn) \|\| !WPACKET_memcpy(pkt, hdr->pn, hdr->pn_len)) return 0; } else { / Long header. / unsigned int raw_type; if (hdr->dst_conn_id.id_len > QUIC_MAX_CONN_ID_LEN \|\| hdr->src_conn_id.id_len > QUIC_MAX_CONN_ID_LEN) return 0; if (ossl_quic_pkt_type_has_pn(hdr->type) && (hdr->pn_len < 1 \|\| hdr->pn_len > 4)) return 0; switch (hdr->type) { case QUIC_PKT_TYPE_VERSION_NEG: if (hdr->version != 0) return 0; / Version negotiation packets use zero for the type bits / raw_type = 0; break; case QUIC_PKT_TYPE_INITIAL: raw_type = 0; break; case QUIC_PKT_TYPE_0RTT: raw_type = 1; break; case QUIC_PKT_TYPE_HANDSHAKE: raw_type = 2; break; case QUIC_PKT_TYPE_RETRY: raw_type = 3; break; default: return 0; } b0 = (raw_type << 4) \| 0x80; / long / if (hdr->type != QUIC_PKT_TYPE_VERSION_NEG \|\| hdr->fixed) b0 \|= 0x40; / fixed / if (ossl_quic_pkt_type_has_pn(hdr->type)) { b0 \|= hdr->pn_len - 1; b0 \|= (hdr->reserved << 2); } if (hdr->type == QUIC_PKT_TYPE_RETRY) b0 \|= hdr->unused; if (!WPACKET_put_bytes_u8(pkt, b0) \|\| !WPACKET_put_bytes_u32(pkt, hdr->version) \|\| !WPACKET_put_bytes_u8(pkt, hdr->dst_conn_id.id_len) \|\| !WPACKET_memcpy(pkt, hdr->dst_conn_id.id, hdr->dst_conn_id.id_len) \|\| !WPACKET_put_bytes_u8(pkt, hdr->src_conn_id.id_len) \|\| !WPACKET_memcpy(pkt, hdr->src_conn_id.id, hdr->src_conn_id.id_len)) return 0; if (hdr->type == QUIC_PKT_TYPE_VERSION_NEG \|\| hdr->type == QUIC_PKT_TYPE_RETRY) { if (hdr->len > 0 && !WPACKET_reserve_bytes(pkt, hdr->len, NULL)) return 0; return 1; } if (hdr->type == QUIC_PKT_TYPE_INITIAL) { if (!WPACKET_quic_write_vlint(pkt, hdr->token_len) \|\| !WPACKET_memcpy(pkt, hdr->token, hdr->token_len)) return 0; } if (!WPACKET_quic_write_vlint(pkt, hdr->len + hdr->pn_len) \|\| !WPACKET_get_total_written(pkt, &off_pn) \|\| !WPACKET_memcpy(pkt, hdr->pn, hdr->pn_len)) return 0; } if (hdr->len > 0 && !WPACKET_reserve_bytes(pkt, hdr->len, NULL)) return 0; off_sample = off_pn + 4; if (ptrs != NULL) { ptrs->raw_start = start; ptrs->raw_sample = start + (off_sample - off_start); ptrs->raw_sample_len = WPACKET_get_curr(pkt) + hdr->len - ptrs->raw_sample; ptrs->raw_pn = start + (off_pn - off_start); } return 1; } int ossl_quic_wire_get_encoded_pkt_hdr_len(size_t short_conn_id_len, const QUIC_PKT_HDR hdr) { size_t len = 0, enclen; /* Cannot serialize a partial header, or one whose DCID length is wrong. / if (hdr->partial \|\| (hdr->type == QUIC_PKT_TYPE_1RTT && hdr->dst_conn_id.id_len != short_conn_id_len)) return 0; if (hdr->type == QUIC_PKT_TYPE_1RTT) { / Short header. / / * Cannot serialize a header whose DCID length is wrong, or with an * invalid PN length. / if (hdr->dst_conn_id.id_len != short_conn_id_len \|\| short_conn_id_len > QUIC_MAX_CONN_ID_LEN \|\| hdr->pn_len < 1 \|\| hdr->pn_len > 4) return 0; return 1 + short_conn_id_len + hdr->pn_len; } else { / Long header. / if (hdr->dst_conn_id.id_len > QUIC_MAX_CONN_ID_LEN \|\| hdr->src_conn_id.id_len > QUIC_MAX_CONN_ID_LEN) return 0; len += 1 / Initial byte / + 4 / Version / + 1 + hdr->dst_conn_id.id_len / DCID Len, DCID / + 1 + hdr->src_conn_id.id_len / SCID Len, SCID / ; if (ossl_quic_pkt_type_has_pn(hdr->type)) { if (hdr->pn_len < 1 \|\| hdr->pn_len > 4) return 0; len += hdr->pn_len; } if (hdr->type == QUIC_PKT_TYPE_INITIAL) { enclen = ossl_quic_vlint_encode_len(hdr->token_len); if (!enclen) return 0; len += enclen + hdr->token_len; } if (!ossl_quic_pkt_type_must_be_last(hdr->type)) { enclen = ossl_quic_vlint_encode_len(hdr->len + hdr->pn_len); if (!enclen) return 0; len += enclen; } return len; } } int ossl_quic_wire_get_pkt_hdr_dst_conn_id(const unsigned char buf, size_t buf_len, size_t short_conn_id_len, QUIC_CONN_ID dst_conn_id) { unsigned char b0; size_t blen; if (buf_len < QUIC_MIN_VALID_PKT_LEN \|\| short_conn_id_len > QUIC_MAX_CONN_ID_LEN) return 0; b0 = buf[0]; if ((b0 & 0x80) != 0) { / * Long header. We need 6 bytes (initial byte, 4 version bytes, DCID * length byte to begin with). This is covered by the buf_len test * above. / / * If the version field is non-zero (meaning that this is not a Version * Negotiation packet), the fixed bit must be set. / if ((buf[1] \|\| buf[2] \|\| buf[3] \|\| buf[4]) && (b0 & 0x40) == 0) return 0; blen = (size_t)buf[5]; / DCID Length / if (blen > QUIC_MAX_CONN_ID_LEN \|\| buf_len < QUIC_MIN_VALID_PKT_LEN + blen) return 0; dst_conn_id->id_len = (unsigned char)blen; memcpy(dst_conn_id->id, buf + 6, blen); return 1; } else { / Short header. / if ((b0 & 0x40) == 0) / Fixed bit not set, not a valid QUIC packet header. / return 0; if (buf_len < QUIC_MIN_VALID_PKT_LEN_CRYPTO + short_conn_id_len) return 0; dst_conn_id->id_len = (unsigned char)short_conn_id_len; memcpy(dst_conn_id->id, buf + 1, short_conn_id_len); return 1; } } int ossl_quic_wire_decode_pkt_hdr_pn(const unsigned char enc_pn, size_t enc_pn_len, QUIC_PN largest_pn, QUIC_PN res_pn) { int64_t expected_pn, truncated_pn, candidate_pn, pn_win, pn_hwin, pn_mask; switch (enc_pn_len) { case 1: truncated_pn = enc_pn[0]; break; case 2: truncated_pn = ((QUIC_PN)enc_pn[0] << 8) \| (QUIC_PN)enc_pn[1]; break; case 3: truncated_pn = ((QUIC_PN)enc_pn[0] << 16) \| ((QUIC_PN)enc_pn[1] << 8) \| (QUIC_PN)enc_pn[2]; break; case 4: truncated_pn = ((QUIC_PN)enc_pn[0] << 24) \| ((QUIC_PN)enc_pn[1] << 16) \| ((QUIC_PN)enc_pn[2] << 8) \| (QUIC_PN)enc_pn[3]; break; default: return 0; } / Implemented as per RFC 9000 Section A.3. / expected_pn = largest_pn + 1; pn_win = ((int64_t)1) << (enc_pn_len 8); pn_hwin = pn_win / 2; pn_mask = pn_win - 1; candidate_pn = (expected_pn & ~pn_mask) \| truncated_pn; if (candidate_pn <= expected_pn - pn_hwin && candidate_pn < (((int64_t)1) << 62) - pn_win) res_pn = candidate_pn + pn_win; else if (candidate_pn > expected_pn + pn_hwin && candidate_pn >= pn_win) res_pn = candidate_pn - pn_win; else res_pn = candidate_pn; return 1; } / From RFC 9000 Section A.2. Simplified implementation. / int ossl_quic_wire_determine_pn_len(QUIC_PN pn, QUIC_PN largest_acked) { uint64_t num_unacked = (largest_acked == QUIC_PN_INVALID) ? pn + 1 : pn - largest_acked; / * num_unacked \in [ 0, 2** 7] -> 1 byte * num_unacked \in (2 7, 215] -> 2 bytes * num_unacked \in (215, 223] -> 3 bytes * num_unacked \in (2*23, ] -> 4 bytes / if (num_unacked <= (1U<<7)) return 1; if (num_unacked <= (1U<<15)) return 2; if (num_unacked <= (1U<<23)) return 3; return 4; } int ossl_quic_wire_encode_pkt_hdr_pn(QUIC_PN pn, unsigned char enc_pn, size_t enc_pn_len) { switch (enc_pn_len) { case 1: enc_pn[0] = (unsigned char)pn; break; case 2: enc_pn[1] = (unsigned char)pn; enc_pn[0] = (unsigned char)(pn >> 8); break; case 3: enc_pn[2] = (unsigned char)pn; enc_pn[1] = (unsigned char)(pn >> 8); enc_pn[0] = (unsigned char)(pn >> 16); break; case 4: enc_pn[3] = (unsigned char)pn; enc_pn[2] = (unsigned char)(pn >> 8); enc_pn[1] = (unsigned char)(pn >> 16); enc_pn[0] = (unsigned char)(pn >> 24); break; default: return 0; } return 1; } int ossl_quic_validate_retry_integrity_tag(OSSL_LIB_CTX libctx, const char propq, const QUIC_PKT_HDR hdr, const QUIC_CONN_ID client_initial_dcid) { unsigned char expected_tag[QUIC_RETRY_INTEGRITY_TAG_LEN]; const unsigned char actual_tag; if (hdr == NULL \|\| hdr->len < QUIC_RETRY_INTEGRITY_TAG_LEN) return 0; if (!ossl_quic_calculate_retry_integrity_tag(libctx, propq, hdr, client_initial_dcid, expected_tag)) return 0; actual_tag = hdr->data + hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN; return !CRYPTO_memcmp(expected_tag, actual_tag, QUIC_RETRY_INTEGRITY_TAG_LEN); } /* RFC 9001 s. 5.8 / static const unsigned char retry_integrity_key[] = { 0xbe, 0x0c, 0x69, 0x0b, 0x9f, 0x66, 0x57, 0x5a, 0x1d, 0x76, 0x6b, 0x54, 0xe3, 0x68, 0xc8, 0x4e }; static const unsigned char retry_integrity_nonce[] = { 0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb }; int ossl_quic_calculate_retry_integrity_tag(OSSL_LIB_CTX libctx, const char propq, const QUIC_PKT_HDR hdr, const QUIC_CONN_ID client_initial_dcid, unsigned char tag) { EVP_CIPHER cipher = NULL; EVP_CIPHER_CTX cctx = NULL; int ok = 0, l = 0, l2 = 0, wpkt_valid = 0; WPACKET wpkt; /* Worst case length of the Retry Psuedo-Packet header is 68 bytes. / unsigned char buf[128]; QUIC_PKT_HDR hdr2; size_t hdr_enc_len = 0; if (hdr->type != QUIC_PKT_TYPE_RETRY \|\| hdr->version == 0 \|\| hdr->len < QUIC_RETRY_INTEGRITY_TAG_LEN \|\| hdr->data == NULL \|\| client_initial_dcid == NULL \|\| tag == NULL \|\| client_initial_dcid->id_len > QUIC_MAX_CONN_ID_LEN) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } / * Do not reserve packet body in WPACKET. Retry packet header * does not contain a Length field so this does not affect * the serialized packet header. / hdr2 = hdr; hdr2.len = 0; /* Assemble retry psuedo-packet. / if (!WPACKET_init_static_len(&wpkt, buf, sizeof(buf), 0)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } wpkt_valid = 1; / Prepend original DCID to the packet. / if (!WPACKET_put_bytes_u8(&wpkt, client_initial_dcid->id_len) \|\| !WPACKET_memcpy(&wpkt, client_initial_dcid->id, client_initial_dcid->id_len)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } / Encode main retry header. / if (!ossl_quic_wire_encode_pkt_hdr(&wpkt, hdr2.dst_conn_id.id_len, &hdr2, NULL)) goto err; if (!WPACKET_get_total_written(&wpkt, &hdr_enc_len)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 0; } / Create and initialise cipher context. / / TODO(QUIC FUTURE): Cipher fetch caching. / if ((cipher = EVP_CIPHER_fetch(libctx, "AES-128-GCM", propq)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } if ((cctx = EVP_CIPHER_CTX_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } if (!EVP_CipherInit_ex(cctx, cipher, NULL, retry_integrity_key, retry_integrity_nonce, /enc=/1)) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } / Feed packet header as AAD data. / if (EVP_CipherUpdate(cctx, NULL, &l, buf, hdr_enc_len) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } / Feed packet body as AAD data. / if (EVP_CipherUpdate(cctx, NULL, &l, hdr->data, hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } / Finalise and get tag. */ if (EVP_CipherFinal_ex(cctx, NULL, &l2) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } if (EVP_CIPHER_CTX_ctrl(cctx, EVP_CTRL_AEAD_GET_TAG, QUIC_RETRY_INTEGRITY_TAG_LEN, tag) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } ok = 1; err: EVP_CIPHER_free(cipher); EVP_CIPHER_CTX_free(cctx); if (wpkt_valid) WPACKET_finish(&wpkt); return ok; }
./openssl/ssl/quic/quic_cfq.c	/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html / #include "internal/quic_cfq.h" #include "internal/numbers.h" typedef struct quic_cfq_item_ex_st QUIC_CFQ_ITEM_EX; struct quic_cfq_item_ex_st { QUIC_CFQ_ITEM public; QUIC_CFQ_ITEM_EX prev, next; unsigned char encoded; cfq_free_cb free_cb; void free_cb_arg; uint64_t frame_type; size_t encoded_len; uint32_t priority, pn_space, flags; int state; }; uint64_t ossl_quic_cfq_item_get_frame_type(const QUIC_CFQ_ITEM item) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; return ex->frame_type; } const unsigned char ossl_quic_cfq_item_get_encoded(const QUIC_CFQ_ITEM item) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; return ex->encoded; } size_t ossl_quic_cfq_item_get_encoded_len(const QUIC_CFQ_ITEM item) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; return ex->encoded_len; } int ossl_quic_cfq_item_get_state(const QUIC_CFQ_ITEM item) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; return ex->state; } uint32_t ossl_quic_cfq_item_get_pn_space(const QUIC_CFQ_ITEM item) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; return ex->pn_space; } int ossl_quic_cfq_item_is_unreliable(const QUIC_CFQ_ITEM item) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; return (ex->flags & QUIC_CFQ_ITEM_FLAG_UNRELIABLE) != 0; } typedef struct quic_cfq_item_list_st { QUIC_CFQ_ITEM_EX head, tail; } QUIC_CFQ_ITEM_LIST; struct quic_cfq_st { / * Invariant: A CFQ item is always in exactly one of these lists, never more * or less than one. * * Invariant: The list the CFQ item is determined exactly by the state field * of the item. / QUIC_CFQ_ITEM_LIST new_list, tx_list, free_list; }; static int compare(const QUIC_CFQ_ITEM_EX a, const QUIC_CFQ_ITEM_EX b) { if (a->pn_space < b->pn_space) return -1; else if (a->pn_space > b->pn_space) return 1; if (a->priority > b->priority) return -1; else if (a->priority < b->priority) return 1; return 0; } static void list_remove(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX n) { if (l->head == n) l->head = n->next; if (l->tail == n) l->tail = n->prev; if (n->prev != NULL) n->prev->next = n->next; if (n->next != NULL) n->next->prev = n->prev; n->prev = n->next = NULL; } static void list_insert_head(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX n) { n->next = l->head; n->prev = NULL; l->head = n; if (n->next != NULL) n->next->prev = n; if (l->tail == NULL) l->tail = n; } static void list_insert_tail(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX n) { n->prev = l->tail; n->next = NULL; l->tail = n; if (n->prev != NULL) n->prev->next = n; if (l->head == NULL) l->head = n; } static void list_insert_after(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX ref, QUIC_CFQ_ITEM_EX n) { n->prev = ref; n->next = ref->next; if (ref->next != NULL) ref->next->prev = n; ref->next = n; if (l->tail == ref) l->tail = n; } static void list_insert_sorted(QUIC_CFQ_ITEM_LIST l, QUIC_CFQ_ITEM_EX n, int (cmp)(const QUIC_CFQ_ITEM_EX a, const QUIC_CFQ_ITEM_EX b)) { QUIC_CFQ_ITEM_EX p = l->head, pprev = NULL; if (p == NULL) { l->head = l->tail = n; n->prev = n->next = NULL; return; } for (; p != NULL && cmp(p, n) < 0; pprev = p, p = p->next); if (p == NULL) list_insert_tail(l, n); else if (pprev == NULL) list_insert_head(l, n); else list_insert_after(l, pprev, n); } QUIC_CFQ ossl_quic_cfq_new(void) { QUIC_CFQ cfq = OPENSSL_zalloc(sizeof(cfq)); if (cfq == NULL) return NULL; return cfq; } static void clear_item(QUIC_CFQ_ITEM_EX item) { if (item->free_cb != NULL) { item->free_cb(item->encoded, item->encoded_len, item->free_cb_arg); item->free_cb = NULL; item->encoded = NULL; item->encoded_len = 0; } item->state = -1; } static void free_list_items(QUIC_CFQ_ITEM_LIST l) { QUIC_CFQ_ITEM_EX p, pnext; for (p = l->head; p != NULL; p = pnext) { pnext = p->next; clear_item(p); OPENSSL_free(p); } } void ossl_quic_cfq_free(QUIC_CFQ cfq) { if (cfq == NULL) return; free_list_items(&cfq->new_list); free_list_items(&cfq->tx_list); free_list_items(&cfq->free_list); OPENSSL_free(cfq); } static QUIC_CFQ_ITEM_EX cfq_get_free(QUIC_CFQ cfq) { QUIC_CFQ_ITEM_EX item = cfq->free_list.head; if (item != NULL) return item; item = OPENSSL_zalloc(sizeof(item)); if (item == NULL) return NULL; item->state = -1; list_insert_tail(&cfq->free_list, item); return item; } QUIC_CFQ_ITEM ossl_quic_cfq_add_frame(QUIC_CFQ cfq, uint32_t priority, uint32_t pn_space, uint64_t frame_type, uint32_t flags, const unsigned char encoded, size_t encoded_len, cfq_free_cb free_cb, void free_cb_arg) { QUIC_CFQ_ITEM_EX item = cfq_get_free(cfq); if (item == NULL) return NULL; item->priority = priority; item->frame_type = frame_type; item->pn_space = pn_space; item->encoded = (unsigned char )encoded; item->encoded_len = encoded_len; item->free_cb = free_cb; item->free_cb_arg = free_cb_arg; item->state = QUIC_CFQ_STATE_NEW; item->flags = flags; list_remove(&cfq->free_list, item); list_insert_sorted(&cfq->new_list, item, compare); return &item->public; } void ossl_quic_cfq_mark_tx(QUIC_CFQ cfq, QUIC_CFQ_ITEM item) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; switch (ex->state) { case QUIC_CFQ_STATE_NEW: list_remove(&cfq->new_list, ex); list_insert_tail(&cfq->tx_list, ex); ex->state = QUIC_CFQ_STATE_TX; break; case QUIC_CFQ_STATE_TX: break; /* nothing to do / default: assert(0); / invalid state (e.g. in free state) / break; } } void ossl_quic_cfq_mark_lost(QUIC_CFQ cfq, QUIC_CFQ_ITEM item, uint32_t priority) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; if (ossl_quic_cfq_item_is_unreliable(item)) { ossl_quic_cfq_release(cfq, item); return; } switch (ex->state) { case QUIC_CFQ_STATE_NEW: if (priority != UINT32_MAX && priority != ex->priority) { list_remove(&cfq->new_list, ex); ex->priority = priority; list_insert_sorted(&cfq->new_list, ex, compare); } break; / nothing to do / case QUIC_CFQ_STATE_TX: if (priority != UINT32_MAX) ex->priority = priority; list_remove(&cfq->tx_list, ex); list_insert_sorted(&cfq->new_list, ex, compare); ex->state = QUIC_CFQ_STATE_NEW; break; default: assert(0); / invalid state (e.g. in free state) / break; } } / * Releases a CFQ item. The item may be in either state (NEW or TX) prior to the * call. The QUIC_CFQ_ITEM pointer must not be used following this call. / void ossl_quic_cfq_release(QUIC_CFQ cfq, QUIC_CFQ_ITEM item) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; switch (ex->state) { case QUIC_CFQ_STATE_NEW: list_remove(&cfq->new_list, ex); list_insert_tail(&cfq->free_list, ex); clear_item(ex); break; case QUIC_CFQ_STATE_TX: list_remove(&cfq->tx_list, ex); list_insert_tail(&cfq->free_list, ex); clear_item(ex); break; default: assert(0); / invalid state (e.g. in free state) / break; } } QUIC_CFQ_ITEM ossl_quic_cfq_get_priority_head(const QUIC_CFQ cfq, uint32_t pn_space) { QUIC_CFQ_ITEM_EX item = cfq->new_list.head; for (; item != NULL && item->pn_space != pn_space; item = item->next); if (item == NULL) return NULL; return &item->public; } QUIC_CFQ_ITEM ossl_quic_cfq_item_get_priority_next(const QUIC_CFQ_ITEM item, uint32_t pn_space) { QUIC_CFQ_ITEM_EX ex = (QUIC_CFQ_ITEM_EX )item; if (ex == NULL) return NULL; ex = ex->next; for (; ex != NULL && ex->pn_space != pn_space; ex = ex->next); if (ex == NULL) return NULL; /* ubsan */ return &ex->public; }

./openssl/apps/lib/log.c

/* * Copyright 2020-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/trace.h> #include "apps.h" #include "log.h" static int verbosity = LOG_INFO; int log_set_verbosity(const char *prog, int level) { if (level < LOG_EMERG || level > LOG_TRACE) { trace_log_message(-1, prog, LOG_ERR, "Invalid verbosity level %d", level); return 0; } verbosity = level; return 1; } int log_get_verbosity(void) { return verbosity; } #ifdef HTTP_DAEMON static int print_syslog(const char *str, size_t len, void *levPtr) { int level = *(int *)levPtr; int ilen = len > MAXERRLEN ? MAXERRLEN : len; syslog(level, "%.*s", ilen, str); return ilen; } #endif static void log_with_prefix(const char *prog, const char *fmt, va_list ap) { char prefix[80]; BIO *bio, *pre = BIO_new(BIO_f_prefix()); (void)BIO_snprintf(prefix, sizeof(prefix), "%s: ", prog); (void)BIO_set_prefix(pre, prefix); bio = BIO_push(pre, bio_err); (void)BIO_vprintf(bio, fmt, ap); (void)BIO_printf(bio, "\n"); (void)BIO_flush(bio); (void)BIO_pop(pre); BIO_free(pre); } /* * Unfortunately, C before C99 does not define va_copy, so we must * check if it can be assumed to be present. We do that with an internal * antifeature macro. * C versions since C94 define __STDC_VERSION__, so it's enough to * check its existence and value. */ #undef OSSL_NO_C99 #if !defined(__STDC_VERSION__) || __STDC_VERSION__ + 0 < 199900L # define OSSL_NO_C99 #endif void trace_log_message(int category, const char *prog, int level, const char *fmt, ...) { va_list ap; va_start(ap, fmt); #ifdef OSSL_NO_C99 if (verbosity >= level) category = -1; /* disabling trace output in addition to logging */ #endif if (category >= 0 && OSSL_trace_enabled(category)) { BIO *out = OSSL_trace_begin(category); #ifndef OSSL_NO_C99 va_list ap_copy; va_copy(ap_copy, ap); (void)BIO_vprintf(out, fmt, ap_copy); va_end(ap_copy); #else (void)BIO_vprintf(out, fmt, ap); #endif (void)BIO_printf(out, "\n"); OSSL_trace_end(category, out); } if (verbosity < level) { va_end(ap); return; } #ifdef HTTP_DAEMON if (n_responders != 0) { vsyslog(level, fmt, ap); if (level <= LOG_ERR) ERR_print_errors_cb(print_syslog, &level); } else #endif log_with_prefix(prog, fmt, ap); va_end(ap); }

./openssl/apps/lib/http_server.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* Very basic HTTP server */ #if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS) /* * On VMS, you need to define this to get the declaration of fileno(). The * value 2 is to make sure no function defined in POSIX-2 is left undefined. */ # define _POSIX_C_SOURCE 2 #endif #include <ctype.h> #include "http_server.h" #include "internal/sockets.h" #include <openssl/err.h> #include <openssl/trace.h> #include <openssl/rand.h> #include "s_apps.h" #include "log.h" #if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_fork)> # endif #endif #define HTTP_PREFIX "HTTP/" #define HTTP_VERSION_PATT "1." /* allow 1.x */ #define HTTP_PREFIX_VERSION HTTP_PREFIX""HTTP_VERSION_PATT #define HTTP_1_0 HTTP_PREFIX_VERSION"0" /* "HTTP/1.0" */ #define HTTP_VERSION_STR " "HTTP_PREFIX_VERSION #define log_HTTP(prog, level, text) \ trace_log_message(OSSL_TRACE_CATEGORY_HTTP, prog, level, "%s", text) #define log_HTTP1(prog, level, fmt, arg) \ trace_log_message(OSSL_TRACE_CATEGORY_HTTP, prog, level, fmt, arg) #define log_HTTP2(prog, level, fmt, arg1, arg2) \ trace_log_message(OSSL_TRACE_CATEGORY_HTTP, prog, level, fmt, arg1, arg2) #define log_HTTP3(prog, level, fmt, a1, a2, a3) \ trace_log_message(OSSL_TRACE_CATEGORY_HTTP, prog, level, fmt, a1, a2, a3) #ifdef HTTP_DAEMON int n_responders = 0; /* run multiple responder processes, set by ocsp.c */ int acfd = (int)INVALID_SOCKET; void socket_timeout(int signum) { if (acfd != (int)INVALID_SOCKET) (void)shutdown(acfd, SHUT_RD); } static void killall(int ret, pid_t *kidpids) { int i; for (i = 0; i < n_responders; ++i) if (kidpids[i] != 0) (void)kill(kidpids[i], SIGTERM); OPENSSL_free(kidpids); OSSL_sleep(1000); exit(ret); } static int termsig = 0; static void noteterm(int sig) { termsig = sig; } /* * Loop spawning up to `multi` child processes, only child processes return * from this function. The parent process loops until receiving a termination * signal, kills extant children and exits without returning. */ void spawn_loop(const char *prog) { pid_t *kidpids = NULL; int status; int procs = 0; int i; openlog(prog, LOG_PID, LOG_DAEMON); if (setpgid(0, 0)) { log_HTTP1(prog, LOG_CRIT, "error detaching from parent process group: %s", strerror(errno)); exit(1); } kidpids = app_malloc(n_responders * sizeof(*kidpids), "child PID array"); for (i = 0; i < n_responders; ++i) kidpids[i] = 0; signal(SIGINT, noteterm); signal(SIGTERM, noteterm); while (termsig == 0) { pid_t fpid; /* * Wait for a child to replace when we're at the limit. * Slow down if a child exited abnormally or waitpid() < 0 */ while (termsig == 0 && procs >= n_responders) { if ((fpid = waitpid(-1, &status, 0)) > 0) { for (i = 0; i < procs; ++i) { if (kidpids[i] == fpid) { kidpids[i] = 0; --procs; break; } } if (i >= n_responders) { log_HTTP1(prog, LOG_CRIT, "internal error: no matching child slot for pid: %ld", (long)fpid); killall(1, kidpids); } if (status != 0) { if (WIFEXITED(status)) { log_HTTP2(prog, LOG_WARNING, "child process: %ld, exit status: %d", (long)fpid, WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { char *dumped = ""; # ifdef WCOREDUMP if (WCOREDUMP(status)) dumped = " (core dumped)"; # endif log_HTTP3(prog, LOG_WARNING, "child process: %ld, term signal %d%s", (long)fpid, WTERMSIG(status), dumped); } OSSL_sleep(1000); } break; } else if (errno != EINTR) { log_HTTP1(prog, LOG_CRIT, "waitpid() failed: %s", strerror(errno)); killall(1, kidpids); } } if (termsig) break; switch (fpid = fork()) { case -1: /* error */ /* System critically low on memory, pause and try again later */ OSSL_sleep(30000); break; case 0: /* child */ OPENSSL_free(kidpids); signal(SIGINT, SIG_DFL); signal(SIGTERM, SIG_DFL); if (termsig) _exit(0); if (RAND_poll() <= 0) { log_HTTP(prog, LOG_CRIT, "RAND_poll() failed"); _exit(1); } return; default: /* parent */ for (i = 0; i < n_responders; ++i) { if (kidpids[i] == 0) { kidpids[i] = fpid; procs++; break; } } if (i >= n_responders) { log_HTTP(prog, LOG_CRIT, "internal error: no free child slots"); killall(1, kidpids); } break; } } /* The loop above can only break on termsig */ log_HTTP1(prog, LOG_INFO, "terminating on signal: %d", termsig); killall(0, kidpids); } #endif #ifndef OPENSSL_NO_SOCK BIO *http_server_init(const char *prog, const char *port, int verb) { BIO *acbio = NULL, *bufbio; int asock; int port_num; char name[40]; snprintf(name, sizeof(name), "*:%s", port); /* port may be "0" */ if (verb >= 0 && !log_set_verbosity(prog, verb)) return NULL; bufbio = BIO_new(BIO_f_buffer()); if (bufbio == NULL) goto err; acbio = BIO_new(BIO_s_accept()); if (acbio == NULL || BIO_set_bind_mode(acbio, BIO_BIND_REUSEADDR) < 0 || BIO_set_accept_name(acbio, name) < 0) { log_HTTP(prog, LOG_ERR, "error setting up accept BIO"); goto err; } BIO_set_accept_bios(acbio, bufbio); bufbio = NULL; if (BIO_do_accept(acbio) <= 0) { log_HTTP1(prog, LOG_ERR, "error setting accept on port %s", port); goto err; } /* Report back what address and port are used */ BIO_get_fd(acbio, &asock); port_num = report_server_accept(bio_out, asock, 1, 1); if (port_num == 0) { log_HTTP(prog, LOG_ERR, "error printing ACCEPT string"); goto err; } return acbio; err: ERR_print_errors(bio_err); BIO_free_all(acbio); BIO_free(bufbio); return NULL; } /* * Decode %xx URL-decoding in-place. Ignores malformed sequences. */ static int urldecode(char *p) { unsigned char *out = (unsigned char *)p; unsigned char *save = out; for (; *p; p++) { if (*p != '%') { *out++ = *p; } else if (isxdigit(_UC(p[1])) && isxdigit(_UC(p[2]))) { /* Don't check, can't fail because of ixdigit() call. */ *out++ = (OPENSSL_hexchar2int(p[1]) << 4) | OPENSSL_hexchar2int(p[2]); p += 2; } else { return -1; } } *out = '\0'; return (int)(out - save); } /* if *pcbio != NULL, continue given connected session, else accept new */ /* if found_keep_alive != NULL, return this way connection persistence state */ int http_server_get_asn1_req(const ASN1_ITEM *it, ASN1_VALUE **preq, char **ppath, BIO **pcbio, BIO *acbio, int *found_keep_alive, const char *prog, int accept_get, int timeout) { BIO *cbio = *pcbio, *getbio = NULL, *b64 = NULL; int len; char reqbuf[2048], inbuf[2048]; char *meth, *url, *end; ASN1_VALUE *req; int ret = 0; *preq = NULL; if (ppath != NULL) *ppath = NULL; if (cbio == NULL) { char *port; get_sock_info_address(BIO_get_fd(acbio, NULL), NULL, &port); if (port == NULL) { log_HTTP(prog, LOG_ERR, "cannot get port listening on"); goto fatal; } log_HTTP1(prog, LOG_DEBUG, "awaiting new connection on port %s ...", port); OPENSSL_free(port); if (BIO_do_accept(acbio) <= 0) /* Connection loss before accept() is routine, ignore silently */ return ret; *pcbio = cbio = BIO_pop(acbio); } else { log_HTTP(prog, LOG_DEBUG, "awaiting next request ..."); } if (cbio == NULL) { /* Cannot call http_server_send_status(..., cbio, ...) */ ret = -1; goto out; } # ifdef HTTP_DAEMON if (timeout > 0) { (void)BIO_get_fd(cbio, &acfd); alarm(timeout); } # endif /* Read the request line. */ len = BIO_gets(cbio, reqbuf, sizeof(reqbuf)); if (len == 0) return ret; ret = 1; if (len < 0) { log_HTTP(prog, LOG_WARNING, "request line read error"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } if (((end = strchr(reqbuf, '\r')) != NULL && end[1] == '\n') || (end = strchr(reqbuf, '\n')) != NULL) *end = '\0'; if (log_get_verbosity() < LOG_TRACE) trace_log_message(-1, prog, LOG_INFO, "received request, 1st line: %s", reqbuf); log_HTTP(prog, LOG_TRACE, "received request header:"); log_HTTP1(prog, LOG_TRACE, "%s", reqbuf); if (end == NULL) { log_HTTP(prog, LOG_WARNING, "cannot parse HTTP header: missing end of line"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } url = meth = reqbuf; if ((accept_get && CHECK_AND_SKIP_PREFIX(url, "GET ")) || CHECK_AND_SKIP_PREFIX(url, "POST ")) { /* Expecting (GET|POST) {sp} /URL {sp} HTTP/1.x */ url[-1] = '\0'; while (*url == ' ') url++; if (*url != '/') { log_HTTP2(prog, LOG_WARNING, "invalid %s -- URL does not begin with '/': %s", meth, url); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } url++; /* Splice off the HTTP version identifier. */ for (end = url; *end != '\0'; end++) if (*end == ' ') break; if (!HAS_PREFIX(end, HTTP_VERSION_STR)) { log_HTTP2(prog, LOG_WARNING, "invalid %s -- bad HTTP/version string: %s", meth, end + 1); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } *end = '\0'; /* above HTTP 1.0, connection persistence is the default */ if (found_keep_alive != NULL) *found_keep_alive = end[sizeof(HTTP_VERSION_STR) - 1] > '0'; /*- * Skip "GET / HTTP..." requests often used by load-balancers. * 'url' was incremented above to point to the first byte *after* * the leading slash, so in case 'GET / ' it is now an empty string. */ if (strlen(meth) == 3 && url[0] == '\0') { (void)http_server_send_status(prog, cbio, 200, "OK"); goto out; } len = urldecode(url); if (len < 0) { log_HTTP2(prog, LOG_WARNING, "invalid %s request -- bad URL encoding: %s", meth, url); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } if (strlen(meth) == 3) { /* GET */ if ((getbio = BIO_new_mem_buf(url, len)) == NULL || (b64 = BIO_new(BIO_f_base64())) == NULL) { log_HTTP1(prog, LOG_ERR, "could not allocate base64 bio with size = %d", len); goto fatal; } BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); getbio = BIO_push(b64, getbio); } } else { log_HTTP2(prog, LOG_WARNING, "HTTP request does not begin with %sPOST: %s", accept_get ? "GET or " : "", reqbuf); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } /* chop any further/duplicate leading or trailing '/' */ while (*url == '/') url++; while (end >= url + 2 && end[-2] == '/' && end[-1] == '/') end--; *end = '\0'; /* Read and skip past the headers. */ for (;;) { char *key, *value; len = BIO_gets(cbio, inbuf, sizeof(inbuf)); if (len <= 0) { log_HTTP(prog, LOG_WARNING, "error reading HTTP header"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } if (((end = strchr(inbuf, '\r')) != NULL && end[1] == '\n') || (end = strchr(inbuf, '\n')) != NULL) *end = '\0'; log_HTTP1(prog, LOG_TRACE, "%s", *inbuf == '\0' ? " " /* workaround for "" getting ignored */ : inbuf); if (end == NULL) { log_HTTP(prog, LOG_WARNING, "error parsing HTTP header: missing end of line"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } if (inbuf[0] == '\0') break; key = inbuf; value = strchr(key, ':'); if (value == NULL) { log_HTTP(prog, LOG_WARNING, "error parsing HTTP header: missing ':'"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); goto out; } *(value++) = '\0'; while (*value == ' ') value++; /* https://tools.ietf.org/html/rfc7230#section-6.3 Persistence */ if (found_keep_alive != NULL && OPENSSL_strcasecmp(key, "Connection") == 0) { if (OPENSSL_strcasecmp(value, "keep-alive") == 0) *found_keep_alive = 1; else if (OPENSSL_strcasecmp(value, "close") == 0) *found_keep_alive = 0; } } # ifdef HTTP_DAEMON /* Clear alarm before we close the client socket */ alarm(0); timeout = 0; # endif /* Try to read and parse request */ req = ASN1_item_d2i_bio(it, getbio != NULL ? getbio : cbio, NULL); if (req == NULL) { log_HTTP(prog, LOG_WARNING, "error parsing DER-encoded request content"); (void)http_server_send_status(prog, cbio, 400, "Bad Request"); } else if (ppath != NULL && (*ppath = OPENSSL_strdup(url)) == NULL) { log_HTTP1(prog, LOG_ERR, "out of memory allocating %zu bytes", strlen(url) + 1); ASN1_item_free(req, it); goto fatal; } *preq = req; out: BIO_free_all(getbio); # ifdef HTTP_DAEMON if (timeout > 0) alarm(0); acfd = (int)INVALID_SOCKET; # endif return ret; fatal: (void)http_server_send_status(prog, cbio, 500, "Internal Server Error"); if (ppath != NULL) { OPENSSL_free(*ppath); *ppath = NULL; } BIO_free_all(cbio); *pcbio = NULL; ret = -1; goto out; } /* assumes that cbio does not do an encoding that changes the output length */ int http_server_send_asn1_resp(const char *prog, BIO *cbio, int keep_alive, const char *content_type, const ASN1_ITEM *it, const ASN1_VALUE *resp) { char buf[200], *p; int ret = BIO_snprintf(buf, sizeof(buf), HTTP_1_0" 200 OK\r\n%s" "Content-type: %s\r\n" "Content-Length: %d\r\n", keep_alive ? "Connection: keep-alive\r\n" : "", content_type, ASN1_item_i2d(resp, NULL, it)); if (ret < 0 || (size_t)ret >= sizeof(buf)) return 0; if (log_get_verbosity() < LOG_TRACE && (p = strchr(buf, '\r')) != NULL) trace_log_message(-1, prog, LOG_INFO, "sending response, 1st line: %.*s", (int)(p - buf), buf); log_HTTP1(prog, LOG_TRACE, "sending response header:\n%s", buf); ret = BIO_printf(cbio, "%s\r\n", buf) > 0 && ASN1_item_i2d_bio(it, cbio, resp) > 0; (void)BIO_flush(cbio); return ret; } int http_server_send_status(const char *prog, BIO *cbio, int status, const char *reason) { char buf[200]; int ret = BIO_snprintf(buf, sizeof(buf), HTTP_1_0" %d %s\r\n\r\n", /* This implicitly cancels keep-alive */ status, reason); if (ret < 0 || (size_t)ret >= sizeof(buf)) return 0; log_HTTP1(prog, LOG_TRACE, "sending response header:\n%s", buf); ret = BIO_printf(cbio, "%s\r\n", buf) > 0; (void)BIO_flush(cbio); return ret; } #endif

./openssl/apps/lib/opt.c

/* * Copyright 2015-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* * This file is also used by the test suite. Do not #include "apps.h". */ #include "opt.h" #include "fmt.h" #include "app_libctx.h" #include "internal/nelem.h" #include "internal/numbers.h" #include <string.h> #if !defined(OPENSSL_SYS_MSDOS) # include <unistd.h> #endif #include <stdlib.h> #include <errno.h> #include <ctype.h> #include <limits.h> #include <openssl/err.h> #include <openssl/bio.h> #include <openssl/x509v3.h> #define MAX_OPT_HELP_WIDTH 30 const char OPT_HELP_STR[] = "-H"; const char OPT_MORE_STR[] = "-M"; const char OPT_SECTION_STR[] = "-S"; const char OPT_PARAM_STR[] = "-P"; /* Our state */ static char **argv; static int argc; static int opt_index; static char *arg; static char *flag; static char *dunno; static const char *unknown_name; static const OPTIONS *unknown; static const OPTIONS *opts; static char prog[40]; /* * Return the simple name of the program; removing various platform gunk. */ #if defined(OPENSSL_SYS_WIN32) const char *opt_path_end(const char *filename) { const char *p; /* find the last '/', '\' or ':' */ for (p = filename + strlen(filename); --p > filename; ) if (*p == '/' || *p == '\\' || *p == ':') { p++; break; } return p; } char *opt_progname(const char *argv0) { size_t i, n; const char *p; char *q; p = opt_path_end(argv0); /* Strip off trailing nonsense. */ n = strlen(p); if (n > 4 && (strcmp(&p[n - 4], ".exe") == 0 || strcmp(&p[n - 4], ".EXE") == 0)) n -= 4; /* Copy over the name, in lowercase. */ if (n > sizeof(prog) - 1) n = sizeof(prog) - 1; for (q = prog, i = 0; i < n; i++, p++) *q++ = tolower((unsigned char)*p); *q = '\0'; return prog; } #elif defined(OPENSSL_SYS_VMS) const char *opt_path_end(const char *filename) { const char *p; /* Find last special character sys:[foo.bar]openssl */ for (p = filename + strlen(filename); --p > filename;) if (*p == ':' || *p == ']' || *p == '>') { p++; break; } return p; } char *opt_progname(const char *argv0) { const char *p, *q; /* Find last special character sys:[foo.bar]openssl */ p = opt_path_end(argv0); q = strrchr(p, '.'); if (prog != p) strncpy(prog, p, sizeof(prog) - 1); prog[sizeof(prog) - 1] = '\0'; if (q != NULL && q - p < sizeof(prog)) prog[q - p] = '\0'; return prog; } #else const char *opt_path_end(const char *filename) { const char *p; /* Could use strchr, but this is like the ones above. */ for (p = filename + strlen(filename); --p > filename;) if (*p == '/') { p++; break; } return p; } char *opt_progname(const char *argv0) { const char *p; p = opt_path_end(argv0); if (prog != p) strncpy(prog, p, sizeof(prog) - 1); prog[sizeof(prog) - 1] = '\0'; return prog; } #endif char *opt_appname(const char *argv0) { size_t len = strlen(prog); if (argv0 != NULL) BIO_snprintf(prog + len, sizeof(prog) - len - 1, " %s", argv0); return prog; } char *opt_getprog(void) { return prog; } /* Set up the arg parsing. */ char *opt_init(int ac, char **av, const OPTIONS *o) { /* Store state. */ argc = ac; argv = av; opt_begin(); opts = o; unknown = NULL; /* Make sure prog name is set for usage output */ (void)opt_progname(argv[0]); /* Check all options up until the PARAM marker (if present) */ for (; o->name != NULL && o->name != OPT_PARAM_STR; ++o) { #ifndef NDEBUG const OPTIONS *next; int duplicated, i; #endif if (o->name == OPT_HELP_STR || o->name == OPT_MORE_STR || o->name == OPT_SECTION_STR) continue; #ifndef NDEBUG i = o->valtype; /* Make sure options are legit. */ OPENSSL_assert(o->name[0] != '-'); if (o->valtype == '.') OPENSSL_assert(o->retval == OPT_PARAM); else OPENSSL_assert(o->retval == OPT_DUP || o->retval > OPT_PARAM); switch (i) { case 0: case '-': case '.': case '/': case '<': case '>': case 'E': case 'F': case 'M': case 'U': case 'f': case 'l': case 'n': case 'p': case 's': case 'u': case 'c': case ':': case 'N': case 'A': break; default: OPENSSL_assert(0); } /* Make sure there are no duplicates. */ for (next = o + 1; next->name; ++next) { /* * Some compilers inline strcmp and the assert string is too long. */ duplicated = next->retval != OPT_DUP && strcmp(o->name, next->name) == 0; if (duplicated) { opt_printf_stderr("%s: Internal error: duplicate option %s\n", prog, o->name); OPENSSL_assert(!duplicated); } } #endif if (o->name[0] == '\0') { OPENSSL_assert(unknown_name != NULL); OPENSSL_assert(unknown == NULL); unknown = o; OPENSSL_assert(unknown->valtype == 0 || unknown->valtype == '-'); } } return prog; } static OPT_PAIR formats[] = { {"pem", OPT_FMT_PEM}, {"der", OPT_FMT_DER}, {"b64", OPT_FMT_B64}, {"pkcs12", OPT_FMT_PKCS12}, {"smime", OPT_FMT_SMIME}, {"engine", OPT_FMT_ENGINE}, {"msblob", OPT_FMT_MSBLOB}, {"nss", OPT_FMT_NSS}, {"text", OPT_FMT_TEXT}, {"http", OPT_FMT_HTTP}, {"pvk", OPT_FMT_PVK}, {NULL} }; void opt_set_unknown_name(const char *name) { unknown_name = name; } /* Print an error message about a failed format parse. */ static int opt_format_error(const char *s, unsigned long flags) { OPT_PAIR *ap; opt_printf_stderr("%s: Bad format \"%s\"; must be one of: ", prog, s); for (ap = formats; ap->name; ap++) if (flags & ap->retval) opt_printf_stderr(" %s", ap->name); opt_printf_stderr("\n"); return 0; } /* Parse a format string, put it into *result; return 0 on failure, else 1. */ int opt_format(const char *s, unsigned long flags, int *result) { switch (*s) { default: opt_printf_stderr("%s: Bad format \"%s\"\n", prog, s); return 0; case 'B': case 'b': if (s[1] == '\0' || strcmp(s, "B64") == 0 || strcmp(s, "b64") == 0 || strcmp(s, "BASE64") == 0 || strcmp(s, "base64") == 0 ) { if ((flags & OPT_FMT_B64) == 0) return opt_format_error(s, flags); *result = FORMAT_BASE64; } else { return 0; } break; case 'D': case 'd': if ((flags & OPT_FMT_DER) == 0) return opt_format_error(s, flags); *result = FORMAT_ASN1; break; case 'T': case 't': if ((flags & OPT_FMT_TEXT) == 0) return opt_format_error(s, flags); *result = FORMAT_TEXT; break; case 'N': case 'n': if ((flags & OPT_FMT_NSS) == 0) return opt_format_error(s, flags); if (strcmp(s, "NSS") != 0 && strcmp(s, "nss") != 0) return opt_format_error(s, flags); *result = FORMAT_NSS; break; case 'S': case 's': if ((flags & OPT_FMT_SMIME) == 0) return opt_format_error(s, flags); *result = FORMAT_SMIME; break; case 'M': case 'm': if ((flags & OPT_FMT_MSBLOB) == 0) return opt_format_error(s, flags); *result = FORMAT_MSBLOB; break; case 'E': case 'e': if ((flags & OPT_FMT_ENGINE) == 0) return opt_format_error(s, flags); *result = FORMAT_ENGINE; break; case 'H': case 'h': if ((flags & OPT_FMT_HTTP) == 0) return opt_format_error(s, flags); *result = FORMAT_HTTP; break; case '1': if ((flags & OPT_FMT_PKCS12) == 0) return opt_format_error(s, flags); *result = FORMAT_PKCS12; break; case 'P': case 'p': if (s[1] == '\0' || strcmp(s, "PEM") == 0 || strcmp(s, "pem") == 0) { if ((flags & OPT_FMT_PEM) == 0) return opt_format_error(s, flags); *result = FORMAT_PEM; } else if (strcmp(s, "PVK") == 0 || strcmp(s, "pvk") == 0) { if ((flags & OPT_FMT_PVK) == 0) return opt_format_error(s, flags); *result = FORMAT_PVK; } else if (strcmp(s, "P12") == 0 || strcmp(s, "p12") == 0 || strcmp(s, "PKCS12") == 0 || strcmp(s, "pkcs12") == 0) { if ((flags & OPT_FMT_PKCS12) == 0) return opt_format_error(s, flags); *result = FORMAT_PKCS12; } else { opt_printf_stderr("%s: Bad format \"%s\"\n", prog, s); return 0; } break; } return 1; } /* Return string representing the given format. */ static const char *format2str(int format) { switch (format) { default: return "(undefined)"; case FORMAT_PEM: return "PEM"; case FORMAT_ASN1: return "DER"; case FORMAT_TEXT: return "TEXT"; case FORMAT_NSS: return "NSS"; case FORMAT_SMIME: return "SMIME"; case FORMAT_MSBLOB: return "MSBLOB"; case FORMAT_ENGINE: return "ENGINE"; case FORMAT_HTTP: return "HTTP"; case FORMAT_PKCS12: return "P12"; case FORMAT_PVK: return "PVK"; } } /* Print an error message about unsuitable/unsupported format requested. */ void print_format_error(int format, unsigned long flags) { (void)opt_format_error(format2str(format), flags); } /* * Parse a cipher name, put it in *cipherp after freeing what was there, if * cipherp is not NULL. Return 0 on failure, else 1. */ int opt_cipher_silent(const char *name, EVP_CIPHER **cipherp) { EVP_CIPHER *c; ERR_set_mark(); if ((c = EVP_CIPHER_fetch(app_get0_libctx(), name, app_get0_propq())) != NULL || (opt_legacy_okay() && (c = (EVP_CIPHER *)EVP_get_cipherbyname(name)) != NULL)) { ERR_pop_to_mark(); if (cipherp != NULL) { EVP_CIPHER_free(*cipherp); *cipherp = c; } else { EVP_CIPHER_free(c); } return 1; } ERR_clear_last_mark(); return 0; } int opt_cipher_any(const char *name, EVP_CIPHER **cipherp) { int ret; if (name == NULL) return 1; if ((ret = opt_cipher_silent(name, cipherp)) == 0) opt_printf_stderr("%s: Unknown option or cipher: %s\n", prog, name); return ret; } int opt_cipher(const char *name, EVP_CIPHER **cipherp) { int mode, ret = 0; unsigned long int flags; EVP_CIPHER *c = NULL; if (name == NULL) return 1; if (opt_cipher_any(name, &c)) { mode = EVP_CIPHER_get_mode(c); flags = EVP_CIPHER_get_flags(c); if (mode == EVP_CIPH_XTS_MODE) { opt_printf_stderr("%s XTS ciphers not supported\n", prog); } else if ((flags & EVP_CIPH_FLAG_AEAD_CIPHER) != 0) { opt_printf_stderr("%s: AEAD ciphers not supported\n", prog); } else { ret = 1; if (cipherp != NULL) *cipherp = c; } } return ret; } /* * Parse message digest name, put it in *EVP_MD; return 0 on failure, else 1. */ int opt_md_silent(const char *name, EVP_MD **mdp) { EVP_MD *md; ERR_set_mark(); if ((md = EVP_MD_fetch(app_get0_libctx(), name, app_get0_propq())) != NULL || (opt_legacy_okay() && (md = (EVP_MD *)EVP_get_digestbyname(name)) != NULL)) { ERR_pop_to_mark(); if (mdp != NULL) { EVP_MD_free(*mdp); *mdp = md; } else { EVP_MD_free(md); } return 1; } ERR_clear_last_mark(); return 0; } int opt_md(const char *name, EVP_MD **mdp) { int ret; if (name == NULL) return 1; if ((ret = opt_md_silent(name, mdp)) == 0) opt_printf_stderr("%s: Unknown option or message digest: %s\n", prog, name); return ret; } int opt_check_md(const char *name) { if (opt_md(name, NULL)) return 1; ERR_clear_error(); return 0; } /* Look through a list of name/value pairs. */ int opt_pair(const char *name, const OPT_PAIR* pairs, int *result) { const OPT_PAIR *pp; for (pp = pairs; pp->name; pp++) if (strcmp(pp->name, name) == 0) { *result = pp->retval; return 1; } opt_printf_stderr("%s: Value must be one of:\n", prog); for (pp = pairs; pp->name; pp++) opt_printf_stderr("\t%s\n", pp->name); return 0; } /* Look through a list of valid names */ int opt_string(const char *name, const char **options) { const char **p; for (p = options; *p != NULL; p++) if (strcmp(*p, name) == 0) return 1; opt_printf_stderr("%s: Value must be one of:\n", prog); for (p = options; *p != NULL; p++) opt_printf_stderr("\t%s\n", *p); return 0; } /* Parse an int, put it into *result; return 0 on failure, else 1. */ int opt_int(const char *value, int *result) { long l; if (!opt_long(value, &l)) return 0; *result = (int)l; if (*result != l) { opt_printf_stderr("%s: Value \"%s\" outside integer range\n", prog, value); return 0; } return 1; } /* Parse and return an integer, assuming range has been checked before. */ int opt_int_arg(void) { int result = -1; (void)opt_int(arg, &result); return result; } static void opt_number_error(const char *v) { size_t i = 0; struct strstr_pair_st { char *prefix; char *name; } b[] = { {"0x", "a hexadecimal"}, {"0X", "a hexadecimal"}, {"0", "an octal"} }; for (i = 0; i < OSSL_NELEM(b); i++) { if (strncmp(v, b[i].prefix, strlen(b[i].prefix)) == 0) { opt_printf_stderr("%s: Can't parse \"%s\" as %s number\n", prog, v, b[i].name); return; } } opt_printf_stderr("%s: Can't parse \"%s\" as a number\n", prog, v); return; } /* Parse a long, put it into *result; return 0 on failure, else 1. */ int opt_long(const char *value, long *result) { int oerrno = errno; long l; char *endp; errno = 0; l = strtol(value, &endp, 0); if (*endp || endp == value || ((l == LONG_MAX || l == LONG_MIN) && errno == ERANGE) || (l == 0 && errno != 0)) { opt_number_error(value); errno = oerrno; return 0; } *result = l; errno = oerrno; return 1; } #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L && \ defined(INTMAX_MAX) && defined(UINTMAX_MAX) && \ !defined(OPENSSL_NO_INTTYPES_H) /* Parse an intmax_t, put it into *result; return 0 on failure, else 1. */ int opt_intmax(const char *value, ossl_intmax_t *result) { int oerrno = errno; intmax_t m; char *endp; errno = 0; m = strtoimax(value, &endp, 0); if (*endp || endp == value || ((m == INTMAX_MAX || m == INTMAX_MIN) && errno == ERANGE) || (m == 0 && errno != 0)) { opt_number_error(value); errno = oerrno; return 0; } /* Ensure that the value in |m| is never too big for |*result| */ if (sizeof(m) > sizeof(*result) && (m < OSSL_INTMAX_MIN || m > OSSL_INTMAX_MAX)) { opt_number_error(value); return 0; } *result = (ossl_intmax_t)m; errno = oerrno; return 1; } /* Parse a uintmax_t, put it into *result; return 0 on failure, else 1. */ int opt_uintmax(const char *value, ossl_uintmax_t *result) { int oerrno = errno; uintmax_t m; char *endp; errno = 0; m = strtoumax(value, &endp, 0); if (*endp || endp == value || (m == UINTMAX_MAX && errno == ERANGE) || (m == 0 && errno != 0)) { opt_number_error(value); errno = oerrno; return 0; } /* Ensure that the value in |m| is never too big for |*result| */ if (sizeof(m) > sizeof(*result) && m > OSSL_UINTMAX_MAX) { opt_number_error(value); return 0; } *result = (ossl_intmax_t)m; errno = oerrno; return 1; } #else /* Fallback implementations based on long */ int opt_intmax(const char *value, ossl_intmax_t *result) { long m; int ret; if ((ret = opt_long(value, &m))) *result = m; return ret; } int opt_uintmax(const char *value, ossl_uintmax_t *result) { unsigned long m; int ret; if ((ret = opt_ulong(value, &m))) *result = m; return ret; } #endif /* * Parse an unsigned long, put it into *result; return 0 on failure, else 1. */ int opt_ulong(const char *value, unsigned long *result) { int oerrno = errno; char *endptr; unsigned long l; errno = 0; l = strtoul(value, &endptr, 0); if (*endptr || endptr == value || ((l == ULONG_MAX) && errno == ERANGE) || (l == 0 && errno != 0)) { opt_number_error(value); errno = oerrno; return 0; } *result = l; errno = oerrno; return 1; } /* * We pass opt as an int but cast it to "enum range" so that all the * items in the OPT_V_ENUM enumeration are caught; this makes -Wswitch * in gcc do the right thing. */ enum range { OPT_V_ENUM }; int opt_verify(int opt, X509_VERIFY_PARAM *vpm) { int i; ossl_intmax_t t = 0; ASN1_OBJECT *otmp; X509_PURPOSE *xptmp; const X509_VERIFY_PARAM *vtmp; OPENSSL_assert(vpm != NULL); OPENSSL_assert(opt > OPT_V__FIRST); OPENSSL_assert(opt < OPT_V__LAST); switch ((enum range)opt) { case OPT_V__FIRST: case OPT_V__LAST: return 0; case OPT_V_POLICY: otmp = OBJ_txt2obj(opt_arg(), 0); if (otmp == NULL) { opt_printf_stderr("%s: Invalid Policy %s\n", prog, opt_arg()); return 0; } if (!X509_VERIFY_PARAM_add0_policy(vpm, otmp)) { ASN1_OBJECT_free(otmp); opt_printf_stderr("%s: Internal error adding Policy %s\n", prog, opt_arg()); return 0; } break; case OPT_V_PURPOSE: /* purpose name -> purpose index */ i = X509_PURPOSE_get_by_sname(opt_arg()); if (i < 0) { opt_printf_stderr("%s: Invalid purpose %s\n", prog, opt_arg()); return 0; } /* purpose index -> purpose object */ xptmp = X509_PURPOSE_get0(i); /* purpose object -> purpose value */ i = X509_PURPOSE_get_id(xptmp); if (!X509_VERIFY_PARAM_set_purpose(vpm, i)) { opt_printf_stderr("%s: Internal error setting purpose %s\n", prog, opt_arg()); return 0; } break; case OPT_V_VERIFY_NAME: vtmp = X509_VERIFY_PARAM_lookup(opt_arg()); if (vtmp == NULL) { opt_printf_stderr("%s: Invalid verify name %s\n", prog, opt_arg()); return 0; } X509_VERIFY_PARAM_set1(vpm, vtmp); break; case OPT_V_VERIFY_DEPTH: i = atoi(opt_arg()); if (i >= 0) X509_VERIFY_PARAM_set_depth(vpm, i); break; case OPT_V_VERIFY_AUTH_LEVEL: i = atoi(opt_arg()); if (i >= 0) X509_VERIFY_PARAM_set_auth_level(vpm, i); break; case OPT_V_ATTIME: if (!opt_intmax(opt_arg(), &t)) return 0; if (t != (time_t)t) { opt_printf_stderr("%s: epoch time out of range %s\n", prog, opt_arg()); return 0; } X509_VERIFY_PARAM_set_time(vpm, (time_t)t); break; case OPT_V_VERIFY_HOSTNAME: if (!X509_VERIFY_PARAM_set1_host(vpm, opt_arg(), 0)) return 0; break; case OPT_V_VERIFY_EMAIL: if (!X509_VERIFY_PARAM_set1_email(vpm, opt_arg(), 0)) return 0; break; case OPT_V_VERIFY_IP: if (!X509_VERIFY_PARAM_set1_ip_asc(vpm, opt_arg())) return 0; break; case OPT_V_IGNORE_CRITICAL: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_IGNORE_CRITICAL); break; case OPT_V_ISSUER_CHECKS: /* NOP, deprecated */ break; case OPT_V_CRL_CHECK: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CRL_CHECK); break; case OPT_V_CRL_CHECK_ALL: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL); break; case OPT_V_POLICY_CHECK: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_POLICY_CHECK); break; case OPT_V_EXPLICIT_POLICY: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_EXPLICIT_POLICY); break; case OPT_V_INHIBIT_ANY: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_INHIBIT_ANY); break; case OPT_V_INHIBIT_MAP: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_INHIBIT_MAP); break; case OPT_V_X509_STRICT: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_X509_STRICT); break; case OPT_V_EXTENDED_CRL: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_EXTENDED_CRL_SUPPORT); break; case OPT_V_USE_DELTAS: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_USE_DELTAS); break; case OPT_V_POLICY_PRINT: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NOTIFY_POLICY); break; case OPT_V_CHECK_SS_SIG: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_CHECK_SS_SIGNATURE); break; case OPT_V_TRUSTED_FIRST: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_TRUSTED_FIRST); break; case OPT_V_SUITEB_128_ONLY: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_128_LOS_ONLY); break; case OPT_V_SUITEB_128: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_128_LOS); break; case OPT_V_SUITEB_192: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_SUITEB_192_LOS); break; case OPT_V_PARTIAL_CHAIN: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_PARTIAL_CHAIN); break; case OPT_V_NO_ALT_CHAINS: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NO_ALT_CHAINS); break; case OPT_V_NO_CHECK_TIME: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_NO_CHECK_TIME); break; case OPT_V_ALLOW_PROXY_CERTS: X509_VERIFY_PARAM_set_flags(vpm, X509_V_FLAG_ALLOW_PROXY_CERTS); break; } return 1; } void opt_begin(void) { opt_index = 1; arg = NULL; flag = NULL; } /* * Parse the next flag (and value if specified), return 0 if done, -1 on * error, otherwise the flag's retval. */ int opt_next(void) { char *p; const OPTIONS *o; int ival; long lval; unsigned long ulval; ossl_intmax_t imval; ossl_uintmax_t umval; /* Look at current arg; at end of the list? */ arg = NULL; p = argv[opt_index]; if (p == NULL) return 0; /* If word doesn't start with a -, we're done. */ if (*p != '-') return 0; /* Hit "--" ? We're done. */ opt_index++; if (strcmp(p, "--") == 0) return 0; /* Allow -nnn and --nnn */ if (*++p == '-') p++; flag = p - 1; /* If we have --flag=foo, snip it off */ if ((arg = strchr(p, '=')) != NULL) *arg++ = '\0'; for (o = opts; o->name; ++o) { /* If not this option, move on to the next one. */ if (!(strcmp(p, "h") == 0 && strcmp(o->name, "help") == 0) && strcmp(p, o->name) != 0) continue; /* If it doesn't take a value, make sure none was given. */ if (o->valtype == 0 || o->valtype == '-') { if (arg) { opt_printf_stderr("%s: Option -%s does not take a value\n", prog, p); return -1; } return o->retval; } /* Want a value; get the next param if =foo not used. */ if (arg == NULL) { if (argv[opt_index] == NULL) { opt_printf_stderr("%s: Option -%s needs a value\n", prog, o->name); return -1; } arg = argv[opt_index++]; } /* Syntax-check value. */ switch (o->valtype) { default: case 's': case ':': /* Just a string. */ break; case '.': /* Parameters */ break; case '/': if (opt_isdir(arg) > 0) break; opt_printf_stderr("%s: Not a directory: %s\n", prog, arg); return -1; case '<': /* Input file. */ break; case '>': /* Output file. */ break; case 'p': case 'n': case 'N': if (!opt_int(arg, &ival)) return -1; if (o->valtype == 'p' && ival <= 0) { opt_printf_stderr("%s: Non-positive number \"%s\" for option -%s\n", prog, arg, o->name); return -1; } if (o->valtype == 'N' && ival < 0) { opt_printf_stderr("%s: Negative number \"%s\" for option -%s\n", prog, arg, o->name); return -1; } break; case 'M': if (!opt_intmax(arg, &imval)) return -1; break; case 'U': if (!opt_uintmax(arg, &umval)) return -1; break; case 'l': if (!opt_long(arg, &lval)) return -1; break; case 'u': if (!opt_ulong(arg, &ulval)) return -1; break; case 'c': case 'E': case 'F': case 'f': case 'A': case 'a': if (opt_format(arg, o->valtype == 'c' ? OPT_FMT_PDS : o->valtype == 'E' ? OPT_FMT_PDE : o->valtype == 'F' ? OPT_FMT_PEMDER : o->valtype == 'A' ? OPT_FMT_ASN1 : OPT_FMT_ANY, &ival)) break; opt_printf_stderr("%s: Invalid format \"%s\" for option -%s\n", prog, arg, o->name); return -1; } /* Return the flag value. */ return o->retval; } if (unknown != NULL) { if (dunno != NULL) { opt_printf_stderr("%s: Multiple %s or unknown options: -%s and -%s\n", prog, unknown_name, dunno, p); return -1; } dunno = p; return unknown->retval; } opt_printf_stderr("%s: Unknown option: -%s\n", prog, p); return -1; } /* Return the most recent flag parameter. */ char *opt_arg(void) { return arg; } /* Return the most recent flag (option name including the preceding '-'). */ char *opt_flag(void) { return flag; } /* Return the unknown option. */ char *opt_unknown(void) { return dunno; } /* Reset the unknown option; needed by ocsp to allow multiple digest options. */ void reset_unknown(void) { dunno = NULL; } /* Return the rest of the arguments after parsing flags. */ char **opt_rest(void) { return &argv[opt_index]; } /* How many items in remaining args? */ int opt_num_rest(void) { int i = 0; char **pp; for (pp = opt_rest(); *pp; pp++, i++) continue; return i; } int opt_check_rest_arg(const char *expected) { char *opt = *opt_rest(); if (opt == NULL || *opt == '\0') { if (expected == NULL) return 1; opt_printf_stderr("%s: Missing argument: %s\n", prog, expected); return 0; } if (expected != NULL) { opt = argv[opt_index + 1]; if (opt == NULL || *opt == '\0') return 1; opt_printf_stderr("%s: Extra argument after %s: \"%s\"\n", prog, expected, opt); return 0; } if (opt_unknown() == NULL) opt_printf_stderr("%s: Extra option: \"%s\"\n", prog, opt); else opt_printf_stderr("%s: Extra (unknown) options: \"%s\" \"%s\"\n", prog, opt_unknown(), opt); return 0; } /* Return a string describing the parameter type. */ static const char *valtype2param(const OPTIONS *o) { switch (o->valtype) { case 0: case '-': return ""; case ':': return "uri"; case 's': return "val"; case '/': return "dir"; case '<': return "infile"; case '>': return "outfile"; case 'p': return "+int"; case 'n': return "int"; case 'l': return "long"; case 'u': return "ulong"; case 'E': return "PEM|DER|ENGINE"; case 'F': return "PEM|DER"; case 'f': return "format"; case 'M': return "intmax"; case 'N': return "nonneg"; case 'U': return "uintmax"; } return "parm"; } static void opt_print(const OPTIONS *o, int doingparams, int width) { const char* help; char start[80 + 1]; int linelen, printlen; /* Avoid OOB if width is beyond the buffer size of start */ if (width >= (int)sizeof(start)) width = (int)sizeof(start) - 1; help = o->helpstr ? o->helpstr : "(No additional info)"; if (o->name == OPT_HELP_STR) { opt_printf_stderr(help, prog); return; } else if (o->name == OPT_SECTION_STR) { opt_printf_stderr("\n"); opt_printf_stderr(help, prog); return; } else if (o->name == OPT_PARAM_STR) { opt_printf_stderr("\nParameters:\n"); return; } /* Pad out prefix */ memset(start, ' ', sizeof(start) - 1); start[sizeof(start) - 1] = '\0'; if (o->name == OPT_MORE_STR) { /* Continuation of previous line; pad and print. */ start[width] = '\0'; opt_printf_stderr("%s %s\n", start, help); return; } /* Build up the "-flag [param]" part. */ linelen = 0; printlen = opt_printf_stderr(" %s", !doingparams ? "-" : ""); linelen += (printlen > 0) ? printlen : MAX_OPT_HELP_WIDTH; printlen = opt_printf_stderr("%s" , o->name[0] ? o->name : "*"); linelen += (printlen > 0) ? printlen : MAX_OPT_HELP_WIDTH; if (o->valtype != '-') { printlen = opt_printf_stderr(" %s" , valtype2param(o)); linelen += (printlen > 0) ? printlen : MAX_OPT_HELP_WIDTH; } if (linelen >= MAX_OPT_HELP_WIDTH || linelen > width) { opt_printf_stderr("%s", "\n"); memset(start, ' ', sizeof(start)); linelen = 0; } width -= linelen; start[width] = '\0'; opt_printf_stderr("%s %s\n", start, help); } void opt_help(const OPTIONS *list) { const OPTIONS *o; int i, sawparams = 0, width = 5; int standard_prolog; /* Starts with its own help message? */ standard_prolog = list[0].name != OPT_HELP_STR; /* Find the widest help. */ for (o = list; o->name; o++) { if (o->name == OPT_MORE_STR) continue; i = 2 + (int)strlen(o->name); if (o->valtype != '-') i += 1 + strlen(valtype2param(o)); if (i > width) width = i; } if (width > MAX_OPT_HELP_WIDTH) width = MAX_OPT_HELP_WIDTH; if (standard_prolog) { opt_printf_stderr("Usage: %s [options]\n", prog); if (list[0].name != OPT_SECTION_STR) opt_printf_stderr("Valid options are:\n", prog); } /* Now let's print. */ for (o = list; o->name; o++) { if (o->name == OPT_PARAM_STR) sawparams = 1; opt_print(o, sawparams, width); } } /* opt_isdir section */ #ifdef _WIN32 # include <windows.h> int opt_isdir(const char *name) { DWORD attr; # if defined(UNICODE) || defined(_UNICODE) size_t i, len_0 = strlen(name) + 1; WCHAR tempname[MAX_PATH]; if (len_0 > MAX_PATH) return -1; # if !defined(_WIN32_WCE) || _WIN32_WCE>=101 if (!MultiByteToWideChar(CP_ACP, 0, name, len_0, tempname, MAX_PATH)) # endif for (i = 0; i < len_0; i++) tempname[i] = (WCHAR)name[i]; attr = GetFileAttributes(tempname); # else attr = GetFileAttributes(name); # endif if (attr == INVALID_FILE_ATTRIBUTES) return -1; return ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0); } #else # include <sys/stat.h> # ifndef S_ISDIR # if defined(_S_IFMT) && defined(_S_IFDIR) # define S_ISDIR(a) (((a) & _S_IFMT) == _S_IFDIR) # else # define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR) # endif # endif int opt_isdir(const char *name) { # if defined(S_ISDIR) struct stat st; if (stat(name, &st) == 0) return S_ISDIR(st.st_mode); else return -1; # else return -1; # endif } #endif

./openssl/apps/lib/s_cb.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* * callback functions used by s_client, s_server, and s_time, * as well as other common logic for those apps */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* for memcpy() and strcmp() */ #include "apps.h" #include <openssl/core_names.h> #include <openssl/params.h> #include <openssl/err.h> #include <openssl/rand.h> #include <openssl/x509.h> #include <openssl/ssl.h> #include <openssl/bn.h> #ifndef OPENSSL_NO_DH # include <openssl/dh.h> #endif #include "s_apps.h" #define COOKIE_SECRET_LENGTH 16 VERIFY_CB_ARGS verify_args = { -1, 0, X509_V_OK, 0 }; #ifndef OPENSSL_NO_SOCK static unsigned char cookie_secret[COOKIE_SECRET_LENGTH]; static int cookie_initialized = 0; #endif static BIO *bio_keylog = NULL; static const char *lookup(int val, const STRINT_PAIR* list, const char* def) { for ( ; list->name; ++list) if (list->retval == val) return list->name; return def; } int verify_callback(int ok, X509_STORE_CTX *ctx) { X509 *err_cert; int err, depth; err_cert = X509_STORE_CTX_get_current_cert(ctx); err = X509_STORE_CTX_get_error(ctx); depth = X509_STORE_CTX_get_error_depth(ctx); if (!verify_args.quiet || !ok) { BIO_printf(bio_err, "depth=%d ", depth); if (err_cert != NULL) { X509_NAME_print_ex(bio_err, X509_get_subject_name(err_cert), 0, get_nameopt()); BIO_puts(bio_err, "\n"); } else { BIO_puts(bio_err, "<no cert>\n"); } } if (!ok) { BIO_printf(bio_err, "verify error:num=%d:%s\n", err, X509_verify_cert_error_string(err)); if (verify_args.depth < 0 || verify_args.depth >= depth) { if (!verify_args.return_error) ok = 1; verify_args.error = err; } else { ok = 0; verify_args.error = X509_V_ERR_CERT_CHAIN_TOO_LONG; } } switch (err) { case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: if (err_cert != NULL) { BIO_puts(bio_err, "issuer= "); X509_NAME_print_ex(bio_err, X509_get_issuer_name(err_cert), 0, get_nameopt()); BIO_puts(bio_err, "\n"); } break; case X509_V_ERR_CERT_NOT_YET_VALID: case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: if (err_cert != NULL) { BIO_printf(bio_err, "notBefore="); ASN1_TIME_print(bio_err, X509_get0_notBefore(err_cert)); BIO_printf(bio_err, "\n"); } break; case X509_V_ERR_CERT_HAS_EXPIRED: case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: if (err_cert != NULL) { BIO_printf(bio_err, "notAfter="); ASN1_TIME_print(bio_err, X509_get0_notAfter(err_cert)); BIO_printf(bio_err, "\n"); } break; case X509_V_ERR_NO_EXPLICIT_POLICY: if (!verify_args.quiet) policies_print(ctx); break; } if (err == X509_V_OK && ok == 2 && !verify_args.quiet) policies_print(ctx); if (ok && !verify_args.quiet) BIO_printf(bio_err, "verify return:%d\n", ok); return ok; } int set_cert_stuff(SSL_CTX *ctx, char *cert_file, char *key_file) { if (cert_file != NULL) { if (SSL_CTX_use_certificate_file(ctx, cert_file, SSL_FILETYPE_PEM) <= 0) { BIO_printf(bio_err, "unable to get certificate from '%s'\n", cert_file); ERR_print_errors(bio_err); return 0; } if (key_file == NULL) key_file = cert_file; if (SSL_CTX_use_PrivateKey_file(ctx, key_file, SSL_FILETYPE_PEM) <= 0) { BIO_printf(bio_err, "unable to get private key from '%s'\n", key_file); ERR_print_errors(bio_err); return 0; } /* * If we are using DSA, we can copy the parameters from the private * key */ /* * Now we know that a key and cert have been set against the SSL * context */ if (!SSL_CTX_check_private_key(ctx)) { BIO_printf(bio_err, "Private key does not match the certificate public key\n"); return 0; } } return 1; } int set_cert_key_stuff(SSL_CTX *ctx, X509 *cert, EVP_PKEY *key, STACK_OF(X509) *chain, int build_chain) { int chflags = chain ? SSL_BUILD_CHAIN_FLAG_CHECK : 0; if (cert == NULL) return 1; if (SSL_CTX_use_certificate(ctx, cert) <= 0) { BIO_printf(bio_err, "error setting certificate\n"); ERR_print_errors(bio_err); return 0; } if (SSL_CTX_use_PrivateKey(ctx, key) <= 0) { BIO_printf(bio_err, "error setting private key\n"); ERR_print_errors(bio_err); return 0; } /* * Now we know that a key and cert have been set against the SSL context */ if (!SSL_CTX_check_private_key(ctx)) { BIO_printf(bio_err, "Private key does not match the certificate public key\n"); return 0; } if (chain && !SSL_CTX_set1_chain(ctx, chain)) { BIO_printf(bio_err, "error setting certificate chain\n"); ERR_print_errors(bio_err); return 0; } if (build_chain && !SSL_CTX_build_cert_chain(ctx, chflags)) { BIO_printf(bio_err, "error building certificate chain\n"); ERR_print_errors(bio_err); return 0; } return 1; } static STRINT_PAIR cert_type_list[] = { {"RSA sign", TLS_CT_RSA_SIGN}, {"DSA sign", TLS_CT_DSS_SIGN}, {"RSA fixed DH", TLS_CT_RSA_FIXED_DH}, {"DSS fixed DH", TLS_CT_DSS_FIXED_DH}, {"ECDSA sign", TLS_CT_ECDSA_SIGN}, {"RSA fixed ECDH", TLS_CT_RSA_FIXED_ECDH}, {"ECDSA fixed ECDH", TLS_CT_ECDSA_FIXED_ECDH}, {"GOST01 Sign", TLS_CT_GOST01_SIGN}, {"GOST12 Sign", TLS_CT_GOST12_IANA_SIGN}, {NULL} }; static void ssl_print_client_cert_types(BIO *bio, SSL *s) { const unsigned char *p; int i; int cert_type_num = SSL_get0_certificate_types(s, &p); if (!cert_type_num) return; BIO_puts(bio, "Client Certificate Types: "); for (i = 0; i < cert_type_num; i++) { unsigned char cert_type = p[i]; const char *cname = lookup((int)cert_type, cert_type_list, NULL); if (i) BIO_puts(bio, ", "); if (cname != NULL) BIO_puts(bio, cname); else BIO_printf(bio, "UNKNOWN (%d),", cert_type); } BIO_puts(bio, "\n"); } static const char *get_sigtype(int nid) { switch (nid) { case EVP_PKEY_RSA: return "RSA"; case EVP_PKEY_RSA_PSS: return "RSA-PSS"; case EVP_PKEY_DSA: return "DSA"; case EVP_PKEY_EC: return "ECDSA"; case NID_ED25519: return "Ed25519"; case NID_ED448: return "Ed448"; case NID_id_GostR3410_2001: return "gost2001"; case NID_id_GostR3410_2012_256: return "gost2012_256"; case NID_id_GostR3410_2012_512: return "gost2012_512"; default: /* Try to output provider-registered sig alg name */ return OBJ_nid2sn(nid); } } static int do_print_sigalgs(BIO *out, SSL *s, int shared) { int i, nsig, client; client = SSL_is_server(s) ? 0 : 1; if (shared) nsig = SSL_get_shared_sigalgs(s, 0, NULL, NULL, NULL, NULL, NULL); else nsig = SSL_get_sigalgs(s, -1, NULL, NULL, NULL, NULL, NULL); if (nsig == 0) return 1; if (shared) BIO_puts(out, "Shared "); if (client) BIO_puts(out, "Requested "); BIO_puts(out, "Signature Algorithms: "); for (i = 0; i < nsig; i++) { int hash_nid, sign_nid; unsigned char rhash, rsign; const char *sstr = NULL; if (shared) SSL_get_shared_sigalgs(s, i, &sign_nid, &hash_nid, NULL, &rsign, &rhash); else SSL_get_sigalgs(s, i, &sign_nid, &hash_nid, NULL, &rsign, &rhash); if (i) BIO_puts(out, ":"); sstr = get_sigtype(sign_nid); if (sstr) BIO_printf(out, "%s", sstr); else BIO_printf(out, "0x%02X", (int)rsign); if (hash_nid != NID_undef) BIO_printf(out, "+%s", OBJ_nid2sn(hash_nid)); else if (sstr == NULL) BIO_printf(out, "+0x%02X", (int)rhash); } BIO_puts(out, "\n"); return 1; } int ssl_print_sigalgs(BIO *out, SSL *s) { int nid; if (!SSL_is_server(s)) ssl_print_client_cert_types(out, s); do_print_sigalgs(out, s, 0); do_print_sigalgs(out, s, 1); if (SSL_get_peer_signature_nid(s, &nid) && nid != NID_undef) BIO_printf(out, "Peer signing digest: %s\n", OBJ_nid2sn(nid)); if (SSL_get_peer_signature_type_nid(s, &nid)) BIO_printf(out, "Peer signature type: %s\n", get_sigtype(nid)); return 1; } #ifndef OPENSSL_NO_EC int ssl_print_point_formats(BIO *out, SSL *s) { int i, nformats; const char *pformats; nformats = SSL_get0_ec_point_formats(s, &pformats); if (nformats <= 0) return 1; BIO_puts(out, "Supported Elliptic Curve Point Formats: "); for (i = 0; i < nformats; i++, pformats++) { if (i) BIO_puts(out, ":"); switch (*pformats) { case TLSEXT_ECPOINTFORMAT_uncompressed: BIO_puts(out, "uncompressed"); break; case TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime: BIO_puts(out, "ansiX962_compressed_prime"); break; case TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2: BIO_puts(out, "ansiX962_compressed_char2"); break; default: BIO_printf(out, "unknown(%d)", (int)*pformats); break; } } BIO_puts(out, "\n"); return 1; } int ssl_print_groups(BIO *out, SSL *s, int noshared) { int i, ngroups, *groups, nid; ngroups = SSL_get1_groups(s, NULL); if (ngroups <= 0) return 1; groups = app_malloc(ngroups * sizeof(int), "groups to print"); SSL_get1_groups(s, groups); BIO_puts(out, "Supported groups: "); for (i = 0; i < ngroups; i++) { if (i) BIO_puts(out, ":"); nid = groups[i]; BIO_printf(out, "%s", SSL_group_to_name(s, nid)); } OPENSSL_free(groups); if (noshared) { BIO_puts(out, "\n"); return 1; } BIO_puts(out, "\nShared groups: "); ngroups = SSL_get_shared_group(s, -1); for (i = 0; i < ngroups; i++) { if (i) BIO_puts(out, ":"); nid = SSL_get_shared_group(s, i); BIO_printf(out, "%s", SSL_group_to_name(s, nid)); } if (ngroups == 0) BIO_puts(out, "NONE"); BIO_puts(out, "\n"); return 1; } #endif int ssl_print_tmp_key(BIO *out, SSL *s) { EVP_PKEY *key; if (!SSL_get_peer_tmp_key(s, &key)) return 1; BIO_puts(out, "Server Temp Key: "); switch (EVP_PKEY_get_id(key)) { case EVP_PKEY_RSA: BIO_printf(out, "RSA, %d bits\n", EVP_PKEY_get_bits(key)); break; case EVP_PKEY_DH: BIO_printf(out, "DH, %d bits\n", EVP_PKEY_get_bits(key)); break; #ifndef OPENSSL_NO_EC case EVP_PKEY_EC: { char name[80]; size_t name_len; if (!EVP_PKEY_get_utf8_string_param(key, OSSL_PKEY_PARAM_GROUP_NAME, name, sizeof(name), &name_len)) strcpy(name, "?"); BIO_printf(out, "ECDH, %s, %d bits\n", name, EVP_PKEY_get_bits(key)); } break; #endif default: BIO_printf(out, "%s, %d bits\n", OBJ_nid2sn(EVP_PKEY_get_id(key)), EVP_PKEY_get_bits(key)); } EVP_PKEY_free(key); return 1; } long bio_dump_callback(BIO *bio, int cmd, const char *argp, size_t len, int argi, long argl, int ret, size_t *processed) { BIO *out; BIO_MMSG_CB_ARGS *mmsgargs; size_t i; out = (BIO *)BIO_get_callback_arg(bio); if (out == NULL) return ret; switch (cmd) { case (BIO_CB_READ | BIO_CB_RETURN): if (ret > 0 && processed != NULL) { BIO_printf(out, "read from %p [%p] (%zu bytes => %zu (0x%zX))\n", (void *)bio, (void *)argp, len, *processed, *processed); BIO_dump(out, argp, (int)*processed); } else { BIO_printf(out, "read from %p [%p] (%zu bytes => %d)\n", (void *)bio, (void *)argp, len, ret); } break; case (BIO_CB_WRITE | BIO_CB_RETURN): if (ret > 0 && processed != NULL) { BIO_printf(out, "write to %p [%p] (%zu bytes => %zu (0x%zX))\n", (void *)bio, (void *)argp, len, *processed, *processed); BIO_dump(out, argp, (int)*processed); } else { BIO_printf(out, "write to %p [%p] (%zu bytes => %d)\n", (void *)bio, (void *)argp, len, ret); } break; case (BIO_CB_RECVMMSG | BIO_CB_RETURN): mmsgargs = (BIO_MMSG_CB_ARGS *)argp; if (ret > 0) { for (i = 0; i < *(mmsgargs->msgs_processed); i++) { BIO_MSG *msg = (BIO_MSG *)((char *)mmsgargs->msg + (i * mmsgargs->stride)); BIO_printf(out, "read from %p [%p] (%zu bytes => %zu (0x%zX))\n", (void *)bio, (void *)msg->data, msg->data_len, msg->data_len, msg->data_len); BIO_dump(out, msg->data, msg->data_len); } } else if (mmsgargs->num_msg > 0) { BIO_MSG *msg = mmsgargs->msg; BIO_printf(out, "read from %p [%p] (%zu bytes => %d)\n", (void *)bio, (void *)msg->data, msg->data_len, ret); } break; case (BIO_CB_SENDMMSG | BIO_CB_RETURN): mmsgargs = (BIO_MMSG_CB_ARGS *)argp; if (ret > 0) { for (i = 0; i < *(mmsgargs->msgs_processed); i++) { BIO_MSG *msg = (BIO_MSG *)((char *)mmsgargs->msg + (i * mmsgargs->stride)); BIO_printf(out, "write to %p [%p] (%zu bytes => %zu (0x%zX))\n", (void *)bio, (void *)msg->data, msg->data_len, msg->data_len, msg->data_len); BIO_dump(out, msg->data, msg->data_len); } } else if (mmsgargs->num_msg > 0) { BIO_MSG *msg = mmsgargs->msg; BIO_printf(out, "write to %p [%p] (%zu bytes => %d)\n", (void *)bio, (void *)msg->data, msg->data_len, ret); } break; default: /* do nothing */ break; } return ret; } void apps_ssl_info_callback(const SSL *s, int where, int ret) { const char *str; int w; w = where & ~SSL_ST_MASK; if (w & SSL_ST_CONNECT) str = "SSL_connect"; else if (w & SSL_ST_ACCEPT) str = "SSL_accept"; else str = "undefined"; if (where & SSL_CB_LOOP) { BIO_printf(bio_err, "%s:%s\n", str, SSL_state_string_long(s)); } else if (where & SSL_CB_ALERT) { str = (where & SSL_CB_READ) ? "read" : "write"; BIO_printf(bio_err, "SSL3 alert %s:%s:%s\n", str, SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret)); } else if (where & SSL_CB_EXIT) { if (ret == 0) BIO_printf(bio_err, "%s:failed in %s\n", str, SSL_state_string_long(s)); else if (ret < 0) BIO_printf(bio_err, "%s:error in %s\n", str, SSL_state_string_long(s)); } } static STRINT_PAIR ssl_versions[] = { {"SSL 3.0", SSL3_VERSION}, {"TLS 1.0", TLS1_VERSION}, {"TLS 1.1", TLS1_1_VERSION}, {"TLS 1.2", TLS1_2_VERSION}, {"TLS 1.3", TLS1_3_VERSION}, {"DTLS 1.0", DTLS1_VERSION}, {"DTLS 1.0 (bad)", DTLS1_BAD_VER}, {NULL} }; static STRINT_PAIR alert_types[] = { {" close_notify", 0}, {" end_of_early_data", 1}, {" unexpected_message", 10}, {" bad_record_mac", 20}, {" decryption_failed", 21}, {" record_overflow", 22}, {" decompression_failure", 30}, {" handshake_failure", 40}, {" bad_certificate", 42}, {" unsupported_certificate", 43}, {" certificate_revoked", 44}, {" certificate_expired", 45}, {" certificate_unknown", 46}, {" illegal_parameter", 47}, {" unknown_ca", 48}, {" access_denied", 49}, {" decode_error", 50}, {" decrypt_error", 51}, {" export_restriction", 60}, {" protocol_version", 70}, {" insufficient_security", 71}, {" internal_error", 80}, {" inappropriate_fallback", 86}, {" user_canceled", 90}, {" no_renegotiation", 100}, {" missing_extension", 109}, {" unsupported_extension", 110}, {" certificate_unobtainable", 111}, {" unrecognized_name", 112}, {" bad_certificate_status_response", 113}, {" bad_certificate_hash_value", 114}, {" unknown_psk_identity", 115}, {" certificate_required", 116}, {NULL} }; static STRINT_PAIR handshakes[] = { {", HelloRequest", SSL3_MT_HELLO_REQUEST}, {", ClientHello", SSL3_MT_CLIENT_HELLO}, {", ServerHello", SSL3_MT_SERVER_HELLO}, {", HelloVerifyRequest", DTLS1_MT_HELLO_VERIFY_REQUEST}, {", NewSessionTicket", SSL3_MT_NEWSESSION_TICKET}, {", EndOfEarlyData", SSL3_MT_END_OF_EARLY_DATA}, {", EncryptedExtensions", SSL3_MT_ENCRYPTED_EXTENSIONS}, {", Certificate", SSL3_MT_CERTIFICATE}, {", ServerKeyExchange", SSL3_MT_SERVER_KEY_EXCHANGE}, {", CertificateRequest", SSL3_MT_CERTIFICATE_REQUEST}, {", ServerHelloDone", SSL3_MT_SERVER_DONE}, {", CertificateVerify", SSL3_MT_CERTIFICATE_VERIFY}, {", ClientKeyExchange", SSL3_MT_CLIENT_KEY_EXCHANGE}, {", Finished", SSL3_MT_FINISHED}, {", CertificateUrl", SSL3_MT_CERTIFICATE_URL}, {", CertificateStatus", SSL3_MT_CERTIFICATE_STATUS}, {", SupplementalData", SSL3_MT_SUPPLEMENTAL_DATA}, {", KeyUpdate", SSL3_MT_KEY_UPDATE}, {", CompressedCertificate", SSL3_MT_COMPRESSED_CERTIFICATE}, #ifndef OPENSSL_NO_NEXTPROTONEG {", NextProto", SSL3_MT_NEXT_PROTO}, #endif {", MessageHash", SSL3_MT_MESSAGE_HASH}, {NULL} }; void msg_cb(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg) { BIO *bio = arg; const char *str_write_p = write_p ? ">>>" : "<<<"; char tmpbuf[128]; const char *str_version, *str_content_type = "", *str_details1 = "", *str_details2 = ""; const unsigned char* bp = buf; if (version == SSL3_VERSION || version == TLS1_VERSION || version == TLS1_1_VERSION || version == TLS1_2_VERSION || version == TLS1_3_VERSION || version == DTLS1_VERSION || version == DTLS1_BAD_VER) { str_version = lookup(version, ssl_versions, "???"); switch (content_type) { case SSL3_RT_CHANGE_CIPHER_SPEC: /* type 20 */ str_content_type = ", ChangeCipherSpec"; break; case SSL3_RT_ALERT: /* type 21 */ str_content_type = ", Alert"; str_details1 = ", ???"; if (len == 2) { switch (bp[0]) { case 1: str_details1 = ", warning"; break; case 2: str_details1 = ", fatal"; break; } str_details2 = lookup((int)bp[1], alert_types, " ???"); } break; case SSL3_RT_HANDSHAKE: /* type 22 */ str_content_type = ", Handshake"; str_details1 = "???"; if (len > 0) str_details1 = lookup((int)bp[0], handshakes, "???"); break; case SSL3_RT_APPLICATION_DATA: /* type 23 */ str_content_type = ", ApplicationData"; break; case SSL3_RT_HEADER: /* type 256 */ str_content_type = ", RecordHeader"; break; case SSL3_RT_INNER_CONTENT_TYPE: /* type 257 */ str_content_type = ", InnerContent"; break; default: BIO_snprintf(tmpbuf, sizeof(tmpbuf)-1, ", Unknown (content_type=%d)", content_type); str_content_type = tmpbuf; } } else { BIO_snprintf(tmpbuf, sizeof(tmpbuf)-1, "Not TLS data or unknown version (version=%d, content_type=%d)", version, content_type); str_version = tmpbuf; } BIO_printf(bio, "%s %s%s [length %04lx]%s%s\n", str_write_p, str_version, str_content_type, (unsigned long)len, str_details1, str_details2); if (len > 0) { size_t num, i; BIO_printf(bio, " "); num = len; for (i = 0; i < num; i++) { if (i % 16 == 0 && i > 0) BIO_printf(bio, "\n "); BIO_printf(bio, " %02x", ((const unsigned char *)buf)[i]); } if (i < len) BIO_printf(bio, " ..."); BIO_printf(bio, "\n"); } (void)BIO_flush(bio); } static STRINT_PAIR tlsext_types[] = { {"server name", TLSEXT_TYPE_server_name}, {"max fragment length", TLSEXT_TYPE_max_fragment_length}, {"client certificate URL", TLSEXT_TYPE_client_certificate_url}, {"trusted CA keys", TLSEXT_TYPE_trusted_ca_keys}, {"truncated HMAC", TLSEXT_TYPE_truncated_hmac}, {"status request", TLSEXT_TYPE_status_request}, {"user mapping", TLSEXT_TYPE_user_mapping}, {"client authz", TLSEXT_TYPE_client_authz}, {"server authz", TLSEXT_TYPE_server_authz}, {"cert type", TLSEXT_TYPE_cert_type}, {"supported_groups", TLSEXT_TYPE_supported_groups}, {"EC point formats", TLSEXT_TYPE_ec_point_formats}, {"SRP", TLSEXT_TYPE_srp}, {"signature algorithms", TLSEXT_TYPE_signature_algorithms}, {"use SRTP", TLSEXT_TYPE_use_srtp}, {"session ticket", TLSEXT_TYPE_session_ticket}, {"renegotiation info", TLSEXT_TYPE_renegotiate}, {"signed certificate timestamps", TLSEXT_TYPE_signed_certificate_timestamp}, {"client cert type", TLSEXT_TYPE_client_cert_type}, {"server cert type", TLSEXT_TYPE_server_cert_type}, {"TLS padding", TLSEXT_TYPE_padding}, #ifdef TLSEXT_TYPE_next_proto_neg {"next protocol", TLSEXT_TYPE_next_proto_neg}, #endif #ifdef TLSEXT_TYPE_encrypt_then_mac {"encrypt-then-mac", TLSEXT_TYPE_encrypt_then_mac}, #endif #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation {"application layer protocol negotiation", TLSEXT_TYPE_application_layer_protocol_negotiation}, #endif #ifdef TLSEXT_TYPE_extended_master_secret {"extended master secret", TLSEXT_TYPE_extended_master_secret}, #endif {"compress certificate", TLSEXT_TYPE_compress_certificate}, {"key share", TLSEXT_TYPE_key_share}, {"supported versions", TLSEXT_TYPE_supported_versions}, {"psk", TLSEXT_TYPE_psk}, {"psk kex modes", TLSEXT_TYPE_psk_kex_modes}, {"certificate authorities", TLSEXT_TYPE_certificate_authorities}, {"post handshake auth", TLSEXT_TYPE_post_handshake_auth}, {NULL} }; /* from rfc8446 4.2.3. + gost (https://tools.ietf.org/id/draft-smyshlyaev-tls12-gost-suites-04.html) */ static STRINT_PAIR signature_tls13_scheme_list[] = { {"rsa_pkcs1_sha1", 0x0201 /* TLSEXT_SIGALG_rsa_pkcs1_sha1 */}, {"ecdsa_sha1", 0x0203 /* TLSEXT_SIGALG_ecdsa_sha1 */}, /* {"rsa_pkcs1_sha224", 0x0301 TLSEXT_SIGALG_rsa_pkcs1_sha224}, not in rfc8446 */ /* {"ecdsa_sha224", 0x0303 TLSEXT_SIGALG_ecdsa_sha224} not in rfc8446 */ {"rsa_pkcs1_sha256", 0x0401 /* TLSEXT_SIGALG_rsa_pkcs1_sha256 */}, {"ecdsa_secp256r1_sha256", 0x0403 /* TLSEXT_SIGALG_ecdsa_secp256r1_sha256 */}, {"rsa_pkcs1_sha384", 0x0501 /* TLSEXT_SIGALG_rsa_pkcs1_sha384 */}, {"ecdsa_secp384r1_sha384", 0x0503 /* TLSEXT_SIGALG_ecdsa_secp384r1_sha384 */}, {"rsa_pkcs1_sha512", 0x0601 /* TLSEXT_SIGALG_rsa_pkcs1_sha512 */}, {"ecdsa_secp521r1_sha512", 0x0603 /* TLSEXT_SIGALG_ecdsa_secp521r1_sha512 */}, {"rsa_pss_rsae_sha256", 0x0804 /* TLSEXT_SIGALG_rsa_pss_rsae_sha256 */}, {"rsa_pss_rsae_sha384", 0x0805 /* TLSEXT_SIGALG_rsa_pss_rsae_sha384 */}, {"rsa_pss_rsae_sha512", 0x0806 /* TLSEXT_SIGALG_rsa_pss_rsae_sha512 */}, {"ed25519", 0x0807 /* TLSEXT_SIGALG_ed25519 */}, {"ed448", 0x0808 /* TLSEXT_SIGALG_ed448 */}, {"rsa_pss_pss_sha256", 0x0809 /* TLSEXT_SIGALG_rsa_pss_pss_sha256 */}, {"rsa_pss_pss_sha384", 0x080a /* TLSEXT_SIGALG_rsa_pss_pss_sha384 */}, {"rsa_pss_pss_sha512", 0x080b /* TLSEXT_SIGALG_rsa_pss_pss_sha512 */}, {"gostr34102001", 0xeded /* TLSEXT_SIGALG_gostr34102001_gostr3411 */}, {"gostr34102012_256", 0xeeee /* TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256 */}, {"gostr34102012_512", 0xefef /* TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512 */}, {NULL} }; /* from rfc5246 7.4.1.4.1. */ static STRINT_PAIR signature_tls12_alg_list[] = { {"anonymous", TLSEXT_signature_anonymous /* 0 */}, {"RSA", TLSEXT_signature_rsa /* 1 */}, {"DSA", TLSEXT_signature_dsa /* 2 */}, {"ECDSA", TLSEXT_signature_ecdsa /* 3 */}, {NULL} }; /* from rfc5246 7.4.1.4.1. */ static STRINT_PAIR signature_tls12_hash_list[] = { {"none", TLSEXT_hash_none /* 0 */}, {"MD5", TLSEXT_hash_md5 /* 1 */}, {"SHA1", TLSEXT_hash_sha1 /* 2 */}, {"SHA224", TLSEXT_hash_sha224 /* 3 */}, {"SHA256", TLSEXT_hash_sha256 /* 4 */}, {"SHA384", TLSEXT_hash_sha384 /* 5 */}, {"SHA512", TLSEXT_hash_sha512 /* 6 */}, {NULL} }; void tlsext_cb(SSL *s, int client_server, int type, const unsigned char *data, int len, void *arg) { BIO *bio = arg; const char *extname = lookup(type, tlsext_types, "unknown"); BIO_printf(bio, "TLS %s extension \"%s\" (id=%d), len=%d\n", client_server ? "server" : "client", extname, type, len); BIO_dump(bio, (const char *)data, len); (void)BIO_flush(bio); } #ifndef OPENSSL_NO_SOCK int generate_stateless_cookie_callback(SSL *ssl, unsigned char *cookie, size_t *cookie_len) { unsigned char *buffer = NULL; size_t length = 0; unsigned short port; BIO_ADDR *lpeer = NULL, *peer = NULL; int res = 0; /* Initialize a random secret */ if (!cookie_initialized) { if (RAND_bytes(cookie_secret, COOKIE_SECRET_LENGTH) <= 0) { BIO_printf(bio_err, "error setting random cookie secret\n"); return 0; } cookie_initialized = 1; } if (SSL_is_dtls(ssl)) { lpeer = peer = BIO_ADDR_new(); if (peer == NULL) { BIO_printf(bio_err, "memory full\n"); return 0; } /* Read peer information */ (void)BIO_dgram_get_peer(SSL_get_rbio(ssl), peer); } else { peer = ourpeer; } /* Create buffer with peer's address and port */ if (!BIO_ADDR_rawaddress(peer, NULL, &length)) { BIO_printf(bio_err, "Failed getting peer address\n"); BIO_ADDR_free(lpeer); return 0; } OPENSSL_assert(length != 0); port = BIO_ADDR_rawport(peer); length += sizeof(port); buffer = app_malloc(length, "cookie generate buffer"); memcpy(buffer, &port, sizeof(port)); BIO_ADDR_rawaddress(peer, buffer + sizeof(port), NULL); if (EVP_Q_mac(NULL, "HMAC", NULL, "SHA1", NULL, cookie_secret, COOKIE_SECRET_LENGTH, buffer, length, cookie, DTLS1_COOKIE_LENGTH, cookie_len) == NULL) { BIO_printf(bio_err, "Error calculating HMAC-SHA1 of buffer with secret\n"); goto end; } res = 1; end: OPENSSL_free(buffer); BIO_ADDR_free(lpeer); return res; } int verify_stateless_cookie_callback(SSL *ssl, const unsigned char *cookie, size_t cookie_len) { unsigned char result[EVP_MAX_MD_SIZE]; size_t resultlength; /* Note: we check cookie_initialized because if it's not, * it cannot be valid */ if (cookie_initialized && generate_stateless_cookie_callback(ssl, result, &resultlength) && cookie_len == resultlength && memcmp(result, cookie, resultlength) == 0) return 1; return 0; } int generate_cookie_callback(SSL *ssl, unsigned char *cookie, unsigned int *cookie_len) { size_t temp = 0; int res = generate_stateless_cookie_callback(ssl, cookie, &temp); if (res != 0) *cookie_len = (unsigned int)temp; return res; } int verify_cookie_callback(SSL *ssl, const unsigned char *cookie, unsigned int cookie_len) { return verify_stateless_cookie_callback(ssl, cookie, cookie_len); } #endif /* * Example of extended certificate handling. Where the standard support of * one certificate per algorithm is not sufficient an application can decide * which certificate(s) to use at runtime based on whatever criteria it deems * appropriate. */ /* Linked list of certificates, keys and chains */ struct ssl_excert_st { int certform; const char *certfile; int keyform; const char *keyfile; const char *chainfile; X509 *cert; EVP_PKEY *key; STACK_OF(X509) *chain; int build_chain; struct ssl_excert_st *next, *prev; }; static STRINT_PAIR chain_flags[] = { {"Overall Validity", CERT_PKEY_VALID}, {"Sign with EE key", CERT_PKEY_SIGN}, {"EE signature", CERT_PKEY_EE_SIGNATURE}, {"CA signature", CERT_PKEY_CA_SIGNATURE}, {"EE key parameters", CERT_PKEY_EE_PARAM}, {"CA key parameters", CERT_PKEY_CA_PARAM}, {"Explicitly sign with EE key", CERT_PKEY_EXPLICIT_SIGN}, {"Issuer Name", CERT_PKEY_ISSUER_NAME}, {"Certificate Type", CERT_PKEY_CERT_TYPE}, {NULL} }; static void print_chain_flags(SSL *s, int flags) { STRINT_PAIR *pp; for (pp = chain_flags; pp->name; ++pp) BIO_printf(bio_err, "\t%s: %s\n", pp->name, (flags & pp->retval) ? "OK" : "NOT OK"); BIO_printf(bio_err, "\tSuite B: "); if (SSL_set_cert_flags(s, 0) & SSL_CERT_FLAG_SUITEB_128_LOS) BIO_puts(bio_err, flags & CERT_PKEY_SUITEB ? "OK\n" : "NOT OK\n"); else BIO_printf(bio_err, "not tested\n"); } /* * Very basic selection callback: just use any certificate chain reported as * valid. More sophisticated could prioritise according to local policy. */ static int set_cert_cb(SSL *ssl, void *arg) { int i, rv; SSL_EXCERT *exc = arg; #ifdef CERT_CB_TEST_RETRY static int retry_cnt; if (retry_cnt < 5) { retry_cnt++; BIO_printf(bio_err, "Certificate callback retry test: count %d\n", retry_cnt); return -1; } #endif SSL_certs_clear(ssl); if (exc == NULL) return 1; /* * Go to end of list and traverse backwards since we prepend newer * entries this retains the original order. */ while (exc->next != NULL) exc = exc->next; i = 0; while (exc != NULL) { i++; rv = SSL_check_chain(ssl, exc->cert, exc->key, exc->chain); BIO_printf(bio_err, "Checking cert chain %d:\nSubject: ", i); X509_NAME_print_ex(bio_err, X509_get_subject_name(exc->cert), 0, get_nameopt()); BIO_puts(bio_err, "\n"); print_chain_flags(ssl, rv); if (rv & CERT_PKEY_VALID) { if (!SSL_use_certificate(ssl, exc->cert) || !SSL_use_PrivateKey(ssl, exc->key)) { return 0; } /* * NB: we wouldn't normally do this as it is not efficient * building chains on each connection better to cache the chain * in advance. */ if (exc->build_chain) { if (!SSL_build_cert_chain(ssl, 0)) return 0; } else if (exc->chain != NULL) { if (!SSL_set1_chain(ssl, exc->chain)) return 0; } } exc = exc->prev; } return 1; } void ssl_ctx_set_excert(SSL_CTX *ctx, SSL_EXCERT *exc) { SSL_CTX_set_cert_cb(ctx, set_cert_cb, exc); } static int ssl_excert_prepend(SSL_EXCERT **pexc) { SSL_EXCERT *exc = app_malloc(sizeof(*exc), "prepend cert"); memset(exc, 0, sizeof(*exc)); exc->next = *pexc; *pexc = exc; if (exc->next) { exc->certform = exc->next->certform; exc->keyform = exc->next->keyform; exc->next->prev = exc; } else { exc->certform = FORMAT_PEM; exc->keyform = FORMAT_PEM; } return 1; } void ssl_excert_free(SSL_EXCERT *exc) { SSL_EXCERT *curr; if (exc == NULL) return; while (exc) { X509_free(exc->cert); EVP_PKEY_free(exc->key); OSSL_STACK_OF_X509_free(exc->chain); curr = exc; exc = exc->next; OPENSSL_free(curr); } } int load_excert(SSL_EXCERT **pexc) { SSL_EXCERT *exc = *pexc; if (exc == NULL) return 1; /* If nothing in list, free and set to NULL */ if (exc->certfile == NULL && exc->next == NULL) { ssl_excert_free(exc); *pexc = NULL; return 1; } for (; exc; exc = exc->next) { if (exc->certfile == NULL) { BIO_printf(bio_err, "Missing filename\n"); return 0; } exc->cert = load_cert(exc->certfile, exc->certform, "Server Certificate"); if (exc->cert == NULL) return 0; if (exc->keyfile != NULL) { exc->key = load_key(exc->keyfile, exc->keyform, 0, NULL, NULL, "server key"); } else { exc->key = load_key(exc->certfile, exc->certform, 0, NULL, NULL, "server key"); } if (exc->key == NULL) return 0; if (exc->chainfile != NULL) { if (!load_certs(exc->chainfile, 0, &exc->chain, NULL, "server chain")) return 0; } } return 1; } enum range { OPT_X_ENUM }; int args_excert(int opt, SSL_EXCERT **pexc) { SSL_EXCERT *exc = *pexc; assert(opt > OPT_X__FIRST); assert(opt < OPT_X__LAST); if (exc == NULL) { if (!ssl_excert_prepend(&exc)) { BIO_printf(bio_err, " %s: Error initialising xcert\n", opt_getprog()); goto err; } *pexc = exc; } switch ((enum range)opt) { case OPT_X__FIRST: case OPT_X__LAST: return 0; case OPT_X_CERT: if (exc->certfile != NULL && !ssl_excert_prepend(&exc)) { BIO_printf(bio_err, "%s: Error adding xcert\n", opt_getprog()); goto err; } *pexc = exc; exc->certfile = opt_arg(); break; case OPT_X_KEY: if (exc->keyfile != NULL) { BIO_printf(bio_err, "%s: Key already specified\n", opt_getprog()); goto err; } exc->keyfile = opt_arg(); break; case OPT_X_CHAIN: if (exc->chainfile != NULL) { BIO_printf(bio_err, "%s: Chain already specified\n", opt_getprog()); goto err; } exc->chainfile = opt_arg(); break; case OPT_X_CHAIN_BUILD: exc->build_chain = 1; break; case OPT_X_CERTFORM: if (!opt_format(opt_arg(), OPT_FMT_ANY, &exc->certform)) return 0; break; case OPT_X_KEYFORM: if (!opt_format(opt_arg(), OPT_FMT_ANY, &exc->keyform)) return 0; break; } return 1; err: ERR_print_errors(bio_err); ssl_excert_free(exc); *pexc = NULL; return 0; } static void print_raw_cipherlist(SSL *s) { const unsigned char *rlist; static const unsigned char scsv_id[] = { 0, 0xFF }; size_t i, rlistlen, num; if (!SSL_is_server(s)) return; num = SSL_get0_raw_cipherlist(s, NULL); OPENSSL_assert(num == 2); rlistlen = SSL_get0_raw_cipherlist(s, &rlist); BIO_puts(bio_err, "Client cipher list: "); for (i = 0; i < rlistlen; i += num, rlist += num) { const SSL_CIPHER *c = SSL_CIPHER_find(s, rlist); if (i) BIO_puts(bio_err, ":"); if (c != NULL) { BIO_puts(bio_err, SSL_CIPHER_get_name(c)); } else if (memcmp(rlist, scsv_id, num) == 0) { BIO_puts(bio_err, "SCSV"); } else { size_t j; BIO_puts(bio_err, "0x"); for (j = 0; j < num; j++) BIO_printf(bio_err, "%02X", rlist[j]); } } BIO_puts(bio_err, "\n"); } /* * Hex encoder for TLSA RRdata, not ':' delimited. */ static char *hexencode(const unsigned char *data, size_t len) { static const char *hex = "0123456789abcdef"; char *out; char *cp; size_t outlen = 2 * len + 1; int ilen = (int) outlen; if (outlen < len || ilen < 0 || outlen != (size_t)ilen) { BIO_printf(bio_err, "%s: %zu-byte buffer too large to hexencode\n", opt_getprog(), len); exit(1); } cp = out = app_malloc(ilen, "TLSA hex data buffer"); while (len-- > 0) { *cp++ = hex[(*data >> 4) & 0x0f]; *cp++ = hex[*data++ & 0x0f]; } *cp = '\0'; return out; } void print_verify_detail(SSL *s, BIO *bio) { int mdpth; EVP_PKEY *mspki = NULL; long verify_err = SSL_get_verify_result(s); if (verify_err == X509_V_OK) { const char *peername = SSL_get0_peername(s); BIO_printf(bio, "Verification: OK\n"); if (peername != NULL) BIO_printf(bio, "Verified peername: %s\n", peername); } else { const char *reason = X509_verify_cert_error_string(verify_err); BIO_printf(bio, "Verification error: %s\n", reason); } if ((mdpth = SSL_get0_dane_authority(s, NULL, &mspki)) >= 0) { uint8_t usage, selector, mtype; const unsigned char *data = NULL; size_t dlen = 0; char *hexdata; mdpth = SSL_get0_dane_tlsa(s, &usage, &selector, &mtype, &data, &dlen); /* * The TLSA data field can be quite long when it is a certificate, * public key or even a SHA2-512 digest. Because the initial octets of * ASN.1 certificates and public keys contain mostly boilerplate OIDs * and lengths, we show the last 12 bytes of the data instead, as these * are more likely to distinguish distinct TLSA records. */ #define TLSA_TAIL_SIZE 12 if (dlen > TLSA_TAIL_SIZE) hexdata = hexencode(data + dlen - TLSA_TAIL_SIZE, TLSA_TAIL_SIZE); else hexdata = hexencode(data, dlen); BIO_printf(bio, "DANE TLSA %d %d %d %s%s ", usage, selector, mtype, (dlen > TLSA_TAIL_SIZE) ? "..." : "", hexdata); if (SSL_get0_peer_rpk(s) == NULL) BIO_printf(bio, "%s certificate at depth %d\n", (mspki != NULL) ? "signed the peer" : mdpth ? "matched the TA" : "matched the EE", mdpth); else BIO_printf(bio, "matched the peer raw public key\n"); OPENSSL_free(hexdata); } } void print_ssl_summary(SSL *s) { const SSL_CIPHER *c; X509 *peer = SSL_get0_peer_certificate(s); EVP_PKEY *peer_rpk = SSL_get0_peer_rpk(s); int nid; BIO_printf(bio_err, "Protocol version: %s\n", SSL_get_version(s)); print_raw_cipherlist(s); c = SSL_get_current_cipher(s); BIO_printf(bio_err, "Ciphersuite: %s\n", SSL_CIPHER_get_name(c)); do_print_sigalgs(bio_err, s, 0); if (peer != NULL) { BIO_puts(bio_err, "Peer certificate: "); X509_NAME_print_ex(bio_err, X509_get_subject_name(peer), 0, get_nameopt()); BIO_puts(bio_err, "\n"); if (SSL_get_peer_signature_nid(s, &nid)) BIO_printf(bio_err, "Hash used: %s\n", OBJ_nid2sn(nid)); if (SSL_get_peer_signature_type_nid(s, &nid)) BIO_printf(bio_err, "Signature type: %s\n", get_sigtype(nid)); print_verify_detail(s, bio_err); } else if (peer_rpk != NULL) { BIO_printf(bio_err, "Peer used raw public key\n"); if (SSL_get_peer_signature_type_nid(s, &nid)) BIO_printf(bio_err, "Signature type: %s\n", get_sigtype(nid)); print_verify_detail(s, bio_err); } else { BIO_puts(bio_err, "No peer certificate or raw public key\n"); } #ifndef OPENSSL_NO_EC ssl_print_point_formats(bio_err, s); if (SSL_is_server(s)) ssl_print_groups(bio_err, s, 1); else ssl_print_tmp_key(bio_err, s); #else if (!SSL_is_server(s)) ssl_print_tmp_key(bio_err, s); #endif } int config_ctx(SSL_CONF_CTX *cctx, STACK_OF(OPENSSL_STRING) *str, SSL_CTX *ctx) { int i; SSL_CONF_CTX_set_ssl_ctx(cctx, ctx); for (i = 0; i < sk_OPENSSL_STRING_num(str); i += 2) { const char *flag = sk_OPENSSL_STRING_value(str, i); const char *arg = sk_OPENSSL_STRING_value(str, i + 1); if (SSL_CONF_cmd(cctx, flag, arg) <= 0) { BIO_printf(bio_err, "Call to SSL_CONF_cmd(%s, %s) failed\n", flag, arg == NULL ? "<NULL>" : arg); ERR_print_errors(bio_err); return 0; } } if (!SSL_CONF_CTX_finish(cctx)) { BIO_puts(bio_err, "Error finishing context\n"); ERR_print_errors(bio_err); return 0; } return 1; } static int add_crls_store(X509_STORE *st, STACK_OF(X509_CRL) *crls) { X509_CRL *crl; int i, ret = 1; for (i = 0; i < sk_X509_CRL_num(crls); i++) { crl = sk_X509_CRL_value(crls, i); if (!X509_STORE_add_crl(st, crl)) ret = 0; } return ret; } int ssl_ctx_add_crls(SSL_CTX *ctx, STACK_OF(X509_CRL) *crls, int crl_download) { X509_STORE *st; st = SSL_CTX_get_cert_store(ctx); add_crls_store(st, crls); if (crl_download) store_setup_crl_download(st); return 1; } int ssl_load_stores(SSL_CTX *ctx, const char *vfyCApath, const char *vfyCAfile, const char *vfyCAstore, const char *chCApath, const char *chCAfile, const char *chCAstore, STACK_OF(X509_CRL) *crls, int crl_download) { X509_STORE *vfy = NULL, *ch = NULL; int rv = 0; if (vfyCApath != NULL || vfyCAfile != NULL || vfyCAstore != NULL) { vfy = X509_STORE_new(); if (vfy == NULL) goto err; if (vfyCAfile != NULL && !X509_STORE_load_file(vfy, vfyCAfile)) goto err; if (vfyCApath != NULL && !X509_STORE_load_path(vfy, vfyCApath)) goto err; if (vfyCAstore != NULL && !X509_STORE_load_store(vfy, vfyCAstore)) goto err; add_crls_store(vfy, crls); SSL_CTX_set1_verify_cert_store(ctx, vfy); if (crl_download) store_setup_crl_download(vfy); } if (chCApath != NULL || chCAfile != NULL || chCAstore != NULL) { ch = X509_STORE_new(); if (ch == NULL) goto err; if (chCAfile != NULL && !X509_STORE_load_file(ch, chCAfile)) goto err; if (chCApath != NULL && !X509_STORE_load_path(ch, chCApath)) goto err; if (chCAstore != NULL && !X509_STORE_load_store(ch, chCAstore)) goto err; SSL_CTX_set1_chain_cert_store(ctx, ch); } rv = 1; err: X509_STORE_free(vfy); X509_STORE_free(ch); return rv; } /* Verbose print out of security callback */ typedef struct { BIO *out; int verbose; int (*old_cb) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex); } security_debug_ex; static STRINT_PAIR callback_types[] = { {"Supported Ciphersuite", SSL_SECOP_CIPHER_SUPPORTED}, {"Shared Ciphersuite", SSL_SECOP_CIPHER_SHARED}, {"Check Ciphersuite", SSL_SECOP_CIPHER_CHECK}, #ifndef OPENSSL_NO_DH {"Temp DH key bits", SSL_SECOP_TMP_DH}, #endif {"Supported Curve", SSL_SECOP_CURVE_SUPPORTED}, {"Shared Curve", SSL_SECOP_CURVE_SHARED}, {"Check Curve", SSL_SECOP_CURVE_CHECK}, {"Supported Signature Algorithm", SSL_SECOP_SIGALG_SUPPORTED}, {"Shared Signature Algorithm", SSL_SECOP_SIGALG_SHARED}, {"Check Signature Algorithm", SSL_SECOP_SIGALG_CHECK}, {"Signature Algorithm mask", SSL_SECOP_SIGALG_MASK}, {"Certificate chain EE key", SSL_SECOP_EE_KEY}, {"Certificate chain CA key", SSL_SECOP_CA_KEY}, {"Peer Chain EE key", SSL_SECOP_PEER_EE_KEY}, {"Peer Chain CA key", SSL_SECOP_PEER_CA_KEY}, {"Certificate chain CA digest", SSL_SECOP_CA_MD}, {"Peer chain CA digest", SSL_SECOP_PEER_CA_MD}, {"SSL compression", SSL_SECOP_COMPRESSION}, {"Session ticket", SSL_SECOP_TICKET}, {NULL} }; static int security_callback_debug(const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex) { security_debug_ex *sdb = ex; int rv, show_bits = 1, cert_md = 0; const char *nm; int show_nm; rv = sdb->old_cb(s, ctx, op, bits, nid, other, ex); if (rv == 1 && sdb->verbose < 2) return 1; BIO_puts(sdb->out, "Security callback: "); nm = lookup(op, callback_types, NULL); show_nm = nm != NULL; switch (op) { case SSL_SECOP_TICKET: case SSL_SECOP_COMPRESSION: show_bits = 0; show_nm = 0; break; case SSL_SECOP_VERSION: BIO_printf(sdb->out, "Version=%s", lookup(nid, ssl_versions, "???")); show_bits = 0; show_nm = 0; break; case SSL_SECOP_CA_MD: case SSL_SECOP_PEER_CA_MD: cert_md = 1; break; case SSL_SECOP_SIGALG_SUPPORTED: case SSL_SECOP_SIGALG_SHARED: case SSL_SECOP_SIGALG_CHECK: case SSL_SECOP_SIGALG_MASK: show_nm = 0; break; } if (show_nm) BIO_printf(sdb->out, "%s=", nm); switch (op & SSL_SECOP_OTHER_TYPE) { case SSL_SECOP_OTHER_CIPHER: BIO_puts(sdb->out, SSL_CIPHER_get_name(other)); break; #ifndef OPENSSL_NO_EC case SSL_SECOP_OTHER_CURVE: { const char *cname; cname = EC_curve_nid2nist(nid); if (cname == NULL) cname = OBJ_nid2sn(nid); BIO_puts(sdb->out, cname); } break; #endif case SSL_SECOP_OTHER_CERT: { if (cert_md) { int sig_nid = X509_get_signature_nid(other); BIO_puts(sdb->out, OBJ_nid2sn(sig_nid)); } else { EVP_PKEY *pkey = X509_get0_pubkey(other); if (pkey == NULL) { BIO_printf(sdb->out, "Public key missing"); } else { const char *algname = ""; EVP_PKEY_asn1_get0_info(NULL, NULL, NULL, NULL, &algname, EVP_PKEY_get0_asn1(pkey)); BIO_printf(sdb->out, "%s, bits=%d", algname, EVP_PKEY_get_bits(pkey)); } } break; } case SSL_SECOP_OTHER_SIGALG: { const unsigned char *salg = other; const char *sname = NULL; int raw_sig_code = (salg[0] << 8) + salg[1]; /* always big endian (msb, lsb) */ /* raw_sig_code: signature_scheme from tls1.3, or signature_and_hash from tls1.2 */ if (nm != NULL) BIO_printf(sdb->out, "%s", nm); else BIO_printf(sdb->out, "s_cb.c:security_callback_debug op=0x%x", op); sname = lookup(raw_sig_code, signature_tls13_scheme_list, NULL); if (sname != NULL) { BIO_printf(sdb->out, " scheme=%s", sname); } else { int alg_code = salg[1]; int hash_code = salg[0]; const char *alg_str = lookup(alg_code, signature_tls12_alg_list, NULL); const char *hash_str = lookup(hash_code, signature_tls12_hash_list, NULL); if (alg_str != NULL && hash_str != NULL) BIO_printf(sdb->out, " digest=%s, algorithm=%s", hash_str, alg_str); else BIO_printf(sdb->out, " scheme=unknown(0x%04x)", raw_sig_code); } } } if (show_bits) BIO_printf(sdb->out, ", security bits=%d", bits); BIO_printf(sdb->out, ": %s\n", rv ? "yes" : "no"); return rv; } void ssl_ctx_security_debug(SSL_CTX *ctx, int verbose) { static security_debug_ex sdb; sdb.out = bio_err; sdb.verbose = verbose; sdb.old_cb = SSL_CTX_get_security_callback(ctx); SSL_CTX_set_security_callback(ctx, security_callback_debug); SSL_CTX_set0_security_ex_data(ctx, &sdb); } static void keylog_callback(const SSL *ssl, const char *line) { if (bio_keylog == NULL) { BIO_printf(bio_err, "Keylog callback is invoked without valid file!\n"); return; } /* * There might be concurrent writers to the keylog file, so we must ensure * that the given line is written at once. */ BIO_printf(bio_keylog, "%s\n", line); (void)BIO_flush(bio_keylog); } int set_keylog_file(SSL_CTX *ctx, const char *keylog_file) { /* Close any open files */ BIO_free_all(bio_keylog); bio_keylog = NULL; if (ctx == NULL || keylog_file == NULL) { /* Keylogging is disabled, OK. */ return 0; } /* * Append rather than write in order to allow concurrent modification. * Furthermore, this preserves existing keylog files which is useful when * the tool is run multiple times. */ bio_keylog = BIO_new_file(keylog_file, "a"); if (bio_keylog == NULL) { BIO_printf(bio_err, "Error writing keylog file %s\n", keylog_file); return 1; } /* Write a header for seekable, empty files (this excludes pipes). */ if (BIO_tell(bio_keylog) == 0) { BIO_puts(bio_keylog, "# SSL/TLS secrets log file, generated by OpenSSL\n"); (void)BIO_flush(bio_keylog); } SSL_CTX_set_keylog_callback(ctx, keylog_callback); return 0; } void print_ca_names(BIO *bio, SSL *s) { const char *cs = SSL_is_server(s) ? "server" : "client"; const STACK_OF(X509_NAME) *sk = SSL_get0_peer_CA_list(s); int i; if (sk == NULL || sk_X509_NAME_num(sk) == 0) { if (!SSL_is_server(s)) BIO_printf(bio, "---\nNo %s certificate CA names sent\n", cs); return; } BIO_printf(bio, "---\nAcceptable %s certificate CA names\n", cs); for (i = 0; i < sk_X509_NAME_num(sk); i++) { X509_NAME_print_ex(bio, sk_X509_NAME_value(sk, i), 0, get_nameopt()); BIO_write(bio, "\n", 1); } } void ssl_print_secure_renegotiation_notes(BIO *bio, SSL *s) { if (SSL_VERSION_ALLOWS_RENEGOTIATION(s)) { BIO_printf(bio, "Secure Renegotiation IS%s supported\n", SSL_get_secure_renegotiation_support(s) ? "" : " NOT"); } else { BIO_printf(bio, "This TLS version forbids renegotiation.\n"); } } int progress_cb(EVP_PKEY_CTX *ctx) { BIO *b = EVP_PKEY_CTX_get_app_data(ctx); int p = EVP_PKEY_CTX_get_keygen_info(ctx, 0); static const char symbols[] = ".+*\n"; char c = (p >= 0 && (size_t)p <= sizeof(symbols) - 1) ? symbols[p] : '?'; BIO_write(b, &c, 1); (void)BIO_flush(b); return 1; }

./openssl/apps/lib/app_libctx.c

/* * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "app_libctx.h" #include "apps.h" static OSSL_LIB_CTX *app_libctx = NULL; static const char *app_propq = NULL; int app_set_propq(const char *arg) { app_propq = arg; return 1; } const char *app_get0_propq(void) { return app_propq; } OSSL_LIB_CTX *app_get0_libctx(void) { return app_libctx; } OSSL_LIB_CTX *app_create_libctx(void) { /* * Load the NULL provider into the default library context and create a * library context which will then be used for any OPT_PROV options. */ if (app_libctx == NULL) { if (!app_provider_load(NULL, "null")) { opt_printf_stderr("Failed to create null provider\n"); return NULL; } app_libctx = OSSL_LIB_CTX_new(); } if (app_libctx == NULL) opt_printf_stderr("Failed to create library context\n"); return app_libctx; }

./openssl/apps/lib/columns.c

/* * Copyright 2017-2019 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <string.h> #include "apps.h" #include "function.h" void calculate_columns(FUNCTION *functions, DISPLAY_COLUMNS *dc) { FUNCTION *f; int len, maxlen = 0; for (f = functions; f->name != NULL; ++f) if (f->type == FT_general || f->type == FT_md || f->type == FT_cipher) if ((len = strlen(f->name)) > maxlen) maxlen = len; dc->width = maxlen + 2; dc->columns = (80 - 1) / dc->width; }

./openssl/apps/lib/app_x509.c

/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <string.h> #include "apps.h" /* * X509_ctrl_str() is sorely lacking in libcrypto, but is still needed to * allow the application to process verification options in a manner similar * to signature or other options that pass through EVP_PKEY_CTX_ctrl_str(), * for uniformity. * * As soon as more stuff is added, the code will need serious rework. For * the moment, it only handles the FIPS 196 / SM2 distinguishing ID. */ #ifdef EVP_PKEY_CTRL_SET1_ID static ASN1_OCTET_STRING *mk_octet_string(void *value, size_t value_n) { ASN1_OCTET_STRING *v = ASN1_OCTET_STRING_new(); if (v == NULL) { BIO_printf(bio_err, "error: allocation failed\n"); } else if (!ASN1_OCTET_STRING_set(v, value, (int)value_n)) { ASN1_OCTET_STRING_free(v); v = NULL; } return v; } #endif static int x509_ctrl(void *object, int cmd, void *value, size_t value_n) { switch (cmd) { #ifdef EVP_PKEY_CTRL_SET1_ID case EVP_PKEY_CTRL_SET1_ID: { ASN1_OCTET_STRING *v = mk_octet_string(value, value_n); if (v == NULL) { BIO_printf(bio_err, "error: setting distinguishing ID in certificate failed\n"); return 0; } X509_set0_distinguishing_id(object, v); return 1; } #endif default: break; } return -2; /* typical EVP_PKEY return for "unsupported" */ } static int x509_req_ctrl(void *object, int cmd, void *value, size_t value_n) { switch (cmd) { #ifdef EVP_PKEY_CTRL_SET1_ID case EVP_PKEY_CTRL_SET1_ID: { ASN1_OCTET_STRING *v = mk_octet_string(value, value_n); if (v == NULL) { BIO_printf(bio_err, "error: setting distinguishing ID in certificate signing request failed\n"); return 0; } X509_REQ_set0_distinguishing_id(object, v); return 1; } #endif default: break; } return -2; /* typical EVP_PKEY return for "unsupported" */ } static int do_x509_ctrl_string(int (*ctrl)(void *object, int cmd, void *value, size_t value_n), void *object, const char *value) { int rv = 0; char *stmp, *vtmp = NULL; size_t vtmp_len = 0; int cmd = 0; /* Will get command values that make sense somehow */ stmp = OPENSSL_strdup(value); if (stmp == NULL) return -1; vtmp = strchr(stmp, ':'); if (vtmp != NULL) { *vtmp = 0; vtmp++; vtmp_len = strlen(vtmp); } if (strcmp(stmp, "distid") == 0) { #ifdef EVP_PKEY_CTRL_SET1_ID cmd = EVP_PKEY_CTRL_SET1_ID; /* ... except we put it in X509 */ #endif } else if (strcmp(stmp, "hexdistid") == 0) { if (vtmp != NULL) { void *hexid; long hexid_len = 0; hexid = OPENSSL_hexstr2buf((const char *)vtmp, &hexid_len); OPENSSL_free(stmp); stmp = vtmp = hexid; vtmp_len = (size_t)hexid_len; } #ifdef EVP_PKEY_CTRL_SET1_ID cmd = EVP_PKEY_CTRL_SET1_ID; /* ... except we put it in X509 */ #endif } rv = ctrl(object, cmd, vtmp, vtmp_len); OPENSSL_free(stmp); return rv; } int x509_ctrl_string(X509 *x, const char *value) { return do_x509_ctrl_string(x509_ctrl, x, value); } int x509_req_ctrl_string(X509_REQ *x, const char *value) { return do_x509_ctrl_string(x509_req_ctrl, x, value); }

./openssl/apps/lib/s_socket.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* socket-related functions used by s_client and s_server */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <signal.h> #include <openssl/opensslconf.h> /* * With IPv6, it looks like Digital has mixed up the proper order of * recursive header file inclusion, resulting in the compiler complaining * that u_int isn't defined, but only if _POSIX_C_SOURCE is defined, which is * needed to have fileno() declared correctly... So let's define u_int */ #if defined(OPENSSL_SYS_VMS_DECC) && !defined(__U_INT) # define __U_INT typedef unsigned int u_int; #endif #ifdef _WIN32 # include <process.h> /* MSVC renamed some POSIX functions to have an underscore prefix. */ # ifdef _MSC_VER # define getpid _getpid # endif #endif #ifndef OPENSSL_NO_SOCK # include "apps.h" # include "s_apps.h" # include "internal/sockets.h" # if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_read)> # endif # endif # include <openssl/bio.h> # include <openssl/err.h> /* Keep track of our peer's address for the cookie callback */ BIO_ADDR *ourpeer = NULL; /* * init_client - helper routine to set up socket communication * @sock: pointer to storage of resulting socket. * @host: the hostname or path (for AF_UNIX) to connect to. * @port: the port to connect to (ignored for AF_UNIX). * @bindhost: source host or path (for AF_UNIX). * @bindport: source port (ignored for AF_UNIX). * @family: desired socket family, may be AF_INET, AF_INET6, AF_UNIX or * AF_UNSPEC * @type: socket type, must be SOCK_STREAM or SOCK_DGRAM * @protocol: socket protocol, e.g. IPPROTO_TCP or IPPROTO_UDP (or 0 for any) * @tfo: flag to enable TCP Fast Open * @doconn: whether we should call BIO_connect() on the socket * @ba_ret: BIO_ADDR for the remote peer, to be freed by caller * * This will create a socket and use it to connect to a host:port, or if * family == AF_UNIX, to the path found in host. * * If the host has more than one address, it will try them one by one until * a successful connection is established. The resulting socket will be * found in *sock on success, it will be given INVALID_SOCKET otherwise. * * Returns 1 on success, 0 on failure. */ int init_client(int *sock, const char *host, const char *port, const char *bindhost, const char *bindport, int family, int type, int protocol, int tfo, int doconn, BIO_ADDR **ba_ret) { BIO_ADDRINFO *res = NULL; BIO_ADDRINFO *bindaddr = NULL; const BIO_ADDRINFO *ai = NULL; const BIO_ADDRINFO *bi = NULL; int found = 0; int ret; int options = 0; if (tfo && ba_ret != NULL) *ba_ret = NULL; if (BIO_sock_init() != 1) return 0; ret = BIO_lookup_ex(host, port, BIO_LOOKUP_CLIENT, family, type, protocol, &res); if (ret == 0) { ERR_print_errors(bio_err); return 0; } if (bindhost != NULL || bindport != NULL) { ret = BIO_lookup_ex(bindhost, bindport, BIO_LOOKUP_CLIENT, family, type, protocol, &bindaddr); if (ret == 0) { ERR_print_errors (bio_err); goto out; } } ret = 0; for (ai = res; ai != NULL; ai = BIO_ADDRINFO_next(ai)) { /* Admittedly, these checks are quite paranoid, we should not get * anything in the BIO_ADDRINFO chain that we haven't * asked for. */ OPENSSL_assert((family == AF_UNSPEC || family == BIO_ADDRINFO_family(ai)) && (type == 0 || type == BIO_ADDRINFO_socktype(ai)) && (protocol == 0 || protocol == BIO_ADDRINFO_protocol(ai))); if (bindaddr != NULL) { for (bi = bindaddr; bi != NULL; bi = BIO_ADDRINFO_next(bi)) { if (BIO_ADDRINFO_family(bi) == BIO_ADDRINFO_family(ai)) break; } if (bi == NULL) continue; ++found; } *sock = BIO_socket(BIO_ADDRINFO_family(ai), BIO_ADDRINFO_socktype(ai), BIO_ADDRINFO_protocol(ai), 0); if (*sock == INVALID_SOCKET) { /* Maybe the kernel doesn't support the socket family, even if * BIO_lookup() added it in the returned result... */ continue; } if (bi != NULL) { if (!BIO_bind(*sock, BIO_ADDRINFO_address(bi), BIO_SOCK_REUSEADDR)) { BIO_closesocket(*sock); *sock = INVALID_SOCKET; break; } } #ifndef OPENSSL_NO_SCTP if (protocol == IPPROTO_SCTP) { /* * For SCTP we have to set various options on the socket prior to * connecting. This is done automatically by BIO_new_dgram_sctp(). * We don't actually need the created BIO though so we free it again * immediately. */ BIO *tmpbio = BIO_new_dgram_sctp(*sock, BIO_NOCLOSE); if (tmpbio == NULL) { ERR_print_errors(bio_err); return 0; } BIO_free(tmpbio); } #endif if (BIO_ADDRINFO_protocol(ai) == IPPROTO_TCP) { options |= BIO_SOCK_NODELAY; if (tfo) options |= BIO_SOCK_TFO; } if (doconn && !BIO_connect(*sock, BIO_ADDRINFO_address(ai), options)) { BIO_closesocket(*sock); *sock = INVALID_SOCKET; continue; } /* Save the address */ if (tfo || !doconn) *ba_ret = BIO_ADDR_dup(BIO_ADDRINFO_address(ai)); /* Success, don't try any more addresses */ break; } if (*sock == INVALID_SOCKET) { if (bindaddr != NULL && !found) { BIO_printf(bio_err, "Can't bind %saddress for %s%s%s\n", #ifdef AF_INET6 BIO_ADDRINFO_family(res) == AF_INET6 ? "IPv6 " : #endif BIO_ADDRINFO_family(res) == AF_INET ? "IPv4 " : BIO_ADDRINFO_family(res) == AF_UNIX ? "unix " : "", bindhost != NULL ? bindhost : "", bindport != NULL ? ":" : "", bindport != NULL ? bindport : ""); ERR_clear_error(); ret = 0; } ERR_print_errors(bio_err); } else { char *hostname = NULL; hostname = BIO_ADDR_hostname_string(BIO_ADDRINFO_address(ai), 1); if (hostname != NULL) { BIO_printf(bio_err, "Connecting to %s\n", hostname); OPENSSL_free(hostname); } /* Remove any stale errors from previous connection attempts */ ERR_clear_error(); ret = 1; } out: if (bindaddr != NULL) { BIO_ADDRINFO_free (bindaddr); } BIO_ADDRINFO_free(res); return ret; } void get_sock_info_address(int asock, char **hostname, char **service) { union BIO_sock_info_u info; if (hostname != NULL) *hostname = NULL; if (service != NULL) *service = NULL; if ((info.addr = BIO_ADDR_new()) != NULL && BIO_sock_info(asock, BIO_SOCK_INFO_ADDRESS, &info)) { if (hostname != NULL) *hostname = BIO_ADDR_hostname_string(info.addr, 1); if (service != NULL) *service = BIO_ADDR_service_string(info.addr, 1); } BIO_ADDR_free(info.addr); } int report_server_accept(BIO *out, int asock, int with_address, int with_pid) { int success = 1; if (BIO_printf(out, "ACCEPT") <= 0) return 0; if (with_address) { char *hostname, *service; get_sock_info_address(asock, &hostname, &service); success = hostname != NULL && service != NULL; if (success) success = BIO_printf(out, strchr(hostname, ':') == NULL ? /* IPv4 */ " %s:%s" : /* IPv6 */ " [%s]:%s", hostname, service) > 0; else (void)BIO_printf(out, "unknown:error\n"); OPENSSL_free(hostname); OPENSSL_free(service); } if (with_pid) success *= BIO_printf(out, " PID=%d", getpid()) > 0; success *= BIO_printf(out, "\n") > 0; (void)BIO_flush(out); return success; } /* * do_server - helper routine to perform a server operation * @accept_sock: pointer to storage of resulting socket. * @host: the hostname or path (for AF_UNIX) to connect to. * @port: the port to connect to (ignored for AF_UNIX). * @family: desired socket family, may be AF_INET, AF_INET6, AF_UNIX or * AF_UNSPEC * @type: socket type, must be SOCK_STREAM or SOCK_DGRAM * @cb: pointer to a function that receives the accepted socket and * should perform the communication with the connecting client. * @context: pointer to memory that's passed verbatim to the cb function. * @naccept: number of times an incoming connect should be accepted. If -1, * unlimited number. * * This will create a socket and use it to listen to a host:port, or if * family == AF_UNIX, to the path found in host, then start accepting * incoming connections and run cb on the resulting socket. * * 0 on failure, something other on success. */ int do_server(int *accept_sock, const char *host, const char *port, int family, int type, int protocol, do_server_cb cb, unsigned char *context, int naccept, BIO *bio_s_out, int tfo) { int asock = 0; int sock; int i; BIO_ADDRINFO *res = NULL; const BIO_ADDRINFO *next; int sock_family, sock_type, sock_protocol, sock_port; const BIO_ADDR *sock_address; int sock_family_fallback = AF_UNSPEC; const BIO_ADDR *sock_address_fallback = NULL; int sock_options = BIO_SOCK_REUSEADDR; int ret = 0; if (BIO_sock_init() != 1) return 0; if (!BIO_lookup_ex(host, port, BIO_LOOKUP_SERVER, family, type, protocol, &res)) { ERR_print_errors(bio_err); return 0; } /* Admittedly, these checks are quite paranoid, we should not get * anything in the BIO_ADDRINFO chain that we haven't asked for */ OPENSSL_assert((family == AF_UNSPEC || family == BIO_ADDRINFO_family(res)) && (type == 0 || type == BIO_ADDRINFO_socktype(res)) && (protocol == 0 || protocol == BIO_ADDRINFO_protocol(res))); sock_family = BIO_ADDRINFO_family(res); sock_type = BIO_ADDRINFO_socktype(res); sock_protocol = BIO_ADDRINFO_protocol(res); sock_address = BIO_ADDRINFO_address(res); next = BIO_ADDRINFO_next(res); if (tfo && sock_type == SOCK_STREAM) sock_options |= BIO_SOCK_TFO; #ifdef AF_INET6 if (sock_family == AF_INET6) sock_options |= BIO_SOCK_V6_ONLY; if (next != NULL && BIO_ADDRINFO_socktype(next) == sock_type && BIO_ADDRINFO_protocol(next) == sock_protocol) { if (sock_family == AF_INET && BIO_ADDRINFO_family(next) == AF_INET6) { /* In case AF_INET6 is returned but not supported by the * kernel, retry with the first detected address family */ sock_family_fallback = sock_family; sock_address_fallback = sock_address; sock_family = AF_INET6; sock_address = BIO_ADDRINFO_address(next); } else if (sock_family == AF_INET6 && BIO_ADDRINFO_family(next) == AF_INET) { sock_options &= ~BIO_SOCK_V6_ONLY; } } #endif asock = BIO_socket(sock_family, sock_type, sock_protocol, 0); if (asock == INVALID_SOCKET && sock_family_fallback != AF_UNSPEC) { asock = BIO_socket(sock_family_fallback, sock_type, sock_protocol, 0); sock_address = sock_address_fallback; } if (asock == INVALID_SOCKET || !BIO_listen(asock, sock_address, sock_options)) { BIO_ADDRINFO_free(res); ERR_print_errors(bio_err); if (asock != INVALID_SOCKET) BIO_closesocket(asock); goto end; } #ifndef OPENSSL_NO_SCTP if (protocol == IPPROTO_SCTP) { /* * For SCTP we have to set various options on the socket prior to * accepting. This is done automatically by BIO_new_dgram_sctp(). * We don't actually need the created BIO though so we free it again * immediately. */ BIO *tmpbio = BIO_new_dgram_sctp(asock, BIO_NOCLOSE); if (tmpbio == NULL) { BIO_closesocket(asock); ERR_print_errors(bio_err); goto end; } BIO_free(tmpbio); } #endif sock_port = BIO_ADDR_rawport(sock_address); BIO_ADDRINFO_free(res); res = NULL; if (!report_server_accept(bio_s_out, asock, sock_port == 0, 0)) { BIO_closesocket(asock); ERR_print_errors(bio_err); goto end; } if (accept_sock != NULL) *accept_sock = asock; for (;;) { char sink[64]; struct timeval timeout; fd_set readfds; if (type == SOCK_STREAM) { BIO_ADDR_free(ourpeer); ourpeer = BIO_ADDR_new(); if (ourpeer == NULL) { BIO_closesocket(asock); ERR_print_errors(bio_err); goto end; } do { sock = BIO_accept_ex(asock, ourpeer, 0); } while (sock < 0 && BIO_sock_should_retry(sock)); if (sock < 0) { ERR_print_errors(bio_err); BIO_closesocket(asock); break; } BIO_set_tcp_ndelay(sock, 1); i = (*cb)(sock, type, protocol, context); /* * If we ended with an alert being sent, but still with data in the * network buffer to be read, then calling BIO_closesocket() will * result in a TCP-RST being sent. On some platforms (notably * Windows) then this will result in the peer immediately abandoning * the connection including any buffered alert data before it has * had a chance to be read. Shutting down the sending side first, * and then closing the socket sends TCP-FIN first followed by * TCP-RST. This seems to allow the peer to read the alert data. */ shutdown(sock, 1); /* SHUT_WR */ /* * We just said we have nothing else to say, but it doesn't mean * that the other side has nothing. It's even recommended to * consume incoming data. [In testing context this ensures that * alerts are passed on...] */ timeout.tv_sec = 0; timeout.tv_usec = 500000; /* some extreme round-trip */ do { FD_ZERO(&readfds); openssl_fdset(sock, &readfds); } while (select(sock + 1, &readfds, NULL, NULL, &timeout) > 0 && readsocket(sock, sink, sizeof(sink)) > 0); BIO_closesocket(sock); } else { i = (*cb)(asock, type, protocol, context); } if (naccept != -1) naccept--; if (i < 0 || naccept == 0) { BIO_closesocket(asock); ret = i; break; } } end: # ifdef AF_UNIX if (family == AF_UNIX) unlink(host); # endif BIO_ADDR_free(ourpeer); ourpeer = NULL; return ret; } void do_ssl_shutdown(SSL *ssl) { int ret; do { /* We only do unidirectional shutdown */ ret = SSL_shutdown(ssl); if (ret < 0) { switch (SSL_get_error(ssl, ret)) { case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_ASYNC: case SSL_ERROR_WANT_ASYNC_JOB: /* We just do busy waiting. Nothing clever */ continue; } ret = 0; } } while (ret < 0); } #endif /* OPENSSL_NO_SOCK */

./openssl/apps/lib/win32_init.c

/* * Copyright 2016-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <windows.h> #include <stdlib.h> #include <string.h> #include <malloc.h> #if defined(CP_UTF8) static UINT saved_cp; static int newargc; static char **newargv; static void cleanup(void) { int i; SetConsoleOutputCP(saved_cp); for (i = 0; i < newargc; i++) free(newargv[i]); free(newargv); } /* * Incrementally [re]allocate newargv and keep it NULL-terminated. */ static int validate_argv(int argc) { static int size = 0; if (argc >= size) { char **ptr; while (argc >= size) size += 64; ptr = realloc(newargv, size * sizeof(newargv[0])); if (ptr == NULL) return 0; (newargv = ptr)[argc] = NULL; } else { newargv[argc] = NULL; } return 1; } static int process_glob(WCHAR *wstr, int wlen) { int i, slash, udlen; WCHAR saved_char; WIN32_FIND_DATAW data; HANDLE h; /* * Note that we support wildcard characters only in filename part * of the path, and not in directories. Windows users are used to * this, that's why recursive glob processing is not implemented. */ /* * Start by looking for last slash or backslash, ... */ for (slash = 0, i = 0; i < wlen; i++) if (wstr[i] == L'/' || wstr[i] == L'\\') slash = i + 1; /* * ... then look for asterisk or question mark in the file name. */ for (i = slash; i < wlen; i++) if (wstr[i] == L'*' || wstr[i] == L'?') break; if (i == wlen) return 0; /* definitely not a glob */ saved_char = wstr[wlen]; wstr[wlen] = L'\0'; h = FindFirstFileW(wstr, &data); wstr[wlen] = saved_char; if (h == INVALID_HANDLE_VALUE) return 0; /* not a valid glob, just pass... */ if (slash) udlen = WideCharToMultiByte(CP_UTF8, 0, wstr, slash, NULL, 0, NULL, NULL); else udlen = 0; do { int uflen; char *arg; /* * skip over . and .. */ if (data.cFileName[0] == L'.') { if ((data.cFileName[1] == L'\0') || (data.cFileName[1] == L'.' && data.cFileName[2] == L'\0')) continue; } if (!validate_argv(newargc + 1)) break; /* * -1 below means "scan for trailing '\0' *and* count it", * so that |uflen| covers even trailing '\0'. */ uflen = WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1, NULL, 0, NULL, NULL); arg = malloc(udlen + uflen); if (arg == NULL) break; if (udlen) WideCharToMultiByte(CP_UTF8, 0, wstr, slash, arg, udlen, NULL, NULL); WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1, arg + udlen, uflen, NULL, NULL); newargv[newargc++] = arg; } while (FindNextFileW(h, &data)); CloseHandle(h); return 1; } void win32_utf8argv(int *argc, char **argv[]) { const WCHAR *wcmdline; WCHAR *warg, *wend, *p; int wlen, ulen, valid = 1; char *arg; if (GetEnvironmentVariableW(L"OPENSSL_WIN32_UTF8", NULL, 0) == 0) return; newargc = 0; newargv = NULL; if (!validate_argv(newargc)) return; wcmdline = GetCommandLineW(); if (wcmdline == NULL) return; /* * make a copy of the command line, since we might have to modify it... */ wlen = wcslen(wcmdline); p = _alloca((wlen + 1) * sizeof(WCHAR)); wcscpy(p, wcmdline); while (*p != L'\0') { int in_quote = 0; if (*p == L' ' || *p == L'\t') { p++; /* skip over whitespace */ continue; } /* * Note: because we may need to fiddle with the number of backslashes, * the argument string is copied into itself. This is safe because * the number of characters will never expand. */ warg = wend = p; while (*p != L'\0' && (in_quote || (*p != L' ' && *p != L'\t'))) { switch (*p) { case L'\\': /* * Microsoft documentation on how backslashes are treated * is: * * + Backslashes are interpreted literally, unless they * immediately precede a double quotation mark. * + If an even number of backslashes is followed by a double * quotation mark, one backslash is placed in the argv array * for every pair of backslashes, and the double quotation * mark is interpreted as a string delimiter. * + If an odd number of backslashes is followed by a double * quotation mark, one backslash is placed in the argv array * for every pair of backslashes, and the double quotation * mark is "escaped" by the remaining backslash, causing a * literal double quotation mark (") to be placed in argv. * * Ref: https://msdn.microsoft.com/en-us/library/17w5ykft.aspx * * Though referred page doesn't mention it, multiple qouble * quotes are also special. Pair of double quotes in quoted * string is counted as single double quote. */ { const WCHAR *q = p; int i; while (*p == L'\\') p++; if (*p == L'"') { int i; for (i = (p - q) / 2; i > 0; i--) *wend++ = L'\\'; /* * if odd amount of backslashes before the quote, * said quote is part of the argument, not a delimiter */ if ((p - q) % 2 == 1) *wend++ = *p++; } else { for (i = p - q; i > 0; i--) *wend++ = L'\\'; } } break; case L'"': /* * Without the preceding backslash (or when preceded with an * even number of backslashes), the double quote is a simple * string delimiter and just slightly change the parsing state */ if (in_quote && p[1] == L'"') *wend++ = *p++; else in_quote = !in_quote; p++; break; default: /* * Any other non-delimiter character is just taken verbatim */ *wend++ = *p++; } } wlen = wend - warg; if (wlen == 0 || !process_glob(warg, wlen)) { if (!validate_argv(newargc + 1)) { valid = 0; break; } ulen = 0; if (wlen > 0) { ulen = WideCharToMultiByte(CP_UTF8, 0, warg, wlen, NULL, 0, NULL, NULL); if (ulen <= 0) continue; } arg = malloc(ulen + 1); if (arg == NULL) { valid = 0; break; } if (wlen > 0) WideCharToMultiByte(CP_UTF8, 0, warg, wlen, arg, ulen, NULL, NULL); arg[ulen] = '\0'; newargv[newargc++] = arg; } } if (valid) { saved_cp = GetConsoleOutputCP(); SetConsoleOutputCP(CP_UTF8); *argc = newargc; *argv = newargv; atexit(cleanup); } else if (newargv != NULL) { int i; for (i = 0; i < newargc; i++) free(newargv[i]); free(newargv); newargc = 0; newargv = NULL; } return; } #else void win32_utf8argv(int *argc, char **argv[]) { return; } #endif

./openssl/apps/lib/vms_term_sock.c

/* * Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2016 VMS Software, Inc. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #ifdef __VMS # define OPENSSL_SYS_VMS # pragma message disable DOLLARID # include <openssl/opensslconf.h> # if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS) /* * On VMS, you need to define this to get the declaration of fileno(). The * value 2 is to make sure no function defined in POSIX-2 is left undefined. */ # define _POSIX_C_SOURCE 2 # endif # include <stdio.h> # undef _POSIX_C_SOURCE # include <sys/types.h> # include <sys/socket.h> # include <netinet/in.h> # include <inet.h> # include <unistd.h> # include <string.h> # include <errno.h> # include <starlet.h> # include <iodef.h> # ifdef __alpha # include <iosbdef.h> # else typedef struct _iosb { /* Copied from IOSBDEF.H for Alpha */ # pragma __nomember_alignment __union { __struct { unsigned short int iosb$w_status; /* Final I/O status */ __union { __struct { /* 16-bit byte count variant */ unsigned short int iosb$w_bcnt; /* 16-bit byte count */ __union { unsigned int iosb$l_dev_depend; /* 32-bit device dependent info */ unsigned int iosb$l_pid; /* 32-bit pid */ } iosb$r_l; } iosb$r_bcnt_16; __struct { /* 32-bit byte count variant */ unsigned int iosb$l_bcnt; /* 32-bit byte count (unaligned) */ unsigned short int iosb$w_dev_depend_high; /* 16-bit device dependent info */ } iosb$r_bcnt_32; } iosb$r_devdepend; } iosb$r_io_64; __struct { __union { unsigned int iosb$l_getxxi_status; /* Final GETxxI status */ unsigned int iosb$l_reg_status; /* Final $Registry status */ } iosb$r_l_status; unsigned int iosb$l_reserved; /* Reserved field */ } iosb$r_get_64; } iosb$r_io_get; } IOSB; # if !defined(__VAXC) # define iosb$w_status iosb$r_io_get.iosb$r_io_64.iosb$w_status # define iosb$w_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$w_bcnt # define iosb$r_l iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$r_l # define iosb$l_dev_depend iosb$r_l.iosb$l_dev_depend # define iosb$l_pid iosb$r_l.iosb$l_pid # define iosb$l_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$l_bcnt # define iosb$w_dev_depend_high iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$w_dev_depend_high # define iosb$l_getxxi_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_getxxi_status # define iosb$l_reg_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_reg_status # endif /* #if !defined(__VAXC) */ # endif /* End of IOSBDEF */ # include <efndef.h> # include <stdlib.h> # include <ssdef.h> # include <time.h> # include <stdarg.h> # include <descrip.h> # include "vms_term_sock.h" # ifdef __alpha static struct _iosb TerminalDeviceIosb; # else IOSB TerminalDeviceIosb; # endif static char TerminalDeviceBuff[255 + 2]; static int TerminalSocketPair[2] = {0, 0}; static unsigned short TerminalDeviceChan = 0; static int CreateSocketPair (int, int, int, int *); static void SocketPairTimeoutAst (int); static int TerminalDeviceAst (int); static void LogMessage (char *, ...); /* ** Socket Pair Timeout Value (must be 0-59 seconds) */ # define SOCKET_PAIR_TIMEOUT_VALUE 20 /* ** Socket Pair Timeout Block which is passed to timeout AST */ typedef struct _SocketPairTimeoutBlock { unsigned short SockChan1; unsigned short SockChan2; } SPTB; # ifdef TERM_SOCK_TEST /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ int main (int argc, char *argv[], char *envp[]) { char TermBuff[80]; int TermSock, status, len; LogMessage ("Enter 'q' or 'Q' to quit ..."); while (OPENSSL_strcasecmp (TermBuff, "Q")) { /* ** Create the terminal socket */ status = TerminalSocket (TERM_SOCK_CREATE, &TermSock); if (status != TERM_SOCK_SUCCESS) exit (1); /* ** Process the terminal input */ LogMessage ("Waiting on terminal I/O ...\n"); len = recv (TermSock, TermBuff, sizeof(TermBuff), 0) ; TermBuff[len] = '\0'; LogMessage ("Received terminal I/O [%s]", TermBuff); /* ** Delete the terminal socket */ status = TerminalSocket (TERM_SOCK_DELETE, &TermSock); if (status != TERM_SOCK_SUCCESS) exit (1); } return 1; } # endif /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ int TerminalSocket (int FunctionCode, int *ReturnSocket) { int status; $DESCRIPTOR (TerminalDeviceDesc, "SYS$COMMAND"); /* ** Process the requested function code */ switch (FunctionCode) { case TERM_SOCK_CREATE: /* ** Create a socket pair */ status = CreateSocketPair (AF_INET, SOCK_STREAM, 0, TerminalSocketPair); if (status == -1) { LogMessage ("TerminalSocket: CreateSocketPair () - %08X", status); if (TerminalSocketPair[0]) close (TerminalSocketPair[0]); if (TerminalSocketPair[1]) close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } /* ** Assign a channel to the terminal device */ status = sys$assign (&TerminalDeviceDesc, &TerminalDeviceChan, 0, 0, 0); if (! (status & 1)) { LogMessage ("TerminalSocket: SYS$ASSIGN () - %08X", status); close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } /* ** Queue an async IO to the terminal device */ status = sys$qio (EFN$C_ENF, TerminalDeviceChan, IO$_READVBLK, &TerminalDeviceIosb, TerminalDeviceAst, 0, TerminalDeviceBuff, sizeof(TerminalDeviceBuff) - 2, 0, 0, 0, 0); if (! (status & 1)) { LogMessage ("TerminalSocket: SYS$QIO () - %08X", status); close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } /* ** Return the input side of the socket pair */ *ReturnSocket = TerminalSocketPair[1]; break; case TERM_SOCK_DELETE: /* ** Cancel any pending IO on the terminal channel */ status = sys$cancel (TerminalDeviceChan); if (! (status & 1)) { LogMessage ("TerminalSocket: SYS$CANCEL () - %08X", status); close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } /* ** Deassign the terminal channel */ status = sys$dassgn (TerminalDeviceChan); if (! (status & 1)) { LogMessage ("TerminalSocket: SYS$DASSGN () - %08X", status); close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); return TERM_SOCK_FAILURE; } /* ** Close the terminal socket pair */ close (TerminalSocketPair[0]); close (TerminalSocketPair[1]); /* ** Return the initialized socket */ *ReturnSocket = 0; break; default: /* ** Invalid function code */ LogMessage ("TerminalSocket: Invalid Function Code - %d", FunctionCode); return TERM_SOCK_FAILURE; break; } /* ** Return success */ return TERM_SOCK_SUCCESS; } /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ static int CreateSocketPair (int SocketFamily, int SocketType, int SocketProtocol, int *SocketPair) { struct dsc$descriptor AscTimeDesc = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL}; static const char* LocalHostAddr = {"127.0.0.1"}; unsigned short TcpAcceptChan = 0, TcpDeviceChan = 0; unsigned long BinTimeBuff[2]; struct sockaddr_in sin; char AscTimeBuff[32]; short LocalHostPort; int status; unsigned int slen; # ifdef __alpha struct _iosb iosb; # else IOSB iosb; # endif int SockDesc1 = 0, SockDesc2 = 0; SPTB sptb; $DESCRIPTOR (TcpDeviceDesc, "TCPIP$DEVICE"); /* ** Create a socket */ SockDesc1 = socket (SocketFamily, SocketType, 0); if (SockDesc1 < 0) { LogMessage ("CreateSocketPair: socket () - %d", errno); return -1; } /* ** Initialize the socket information */ slen = sizeof(sin); memset ((char *) &sin, 0, slen); sin.sin_family = SocketFamily; sin.sin_addr.s_addr = inet_addr (LocalHostAddr); sin.sin_port = 0; /* ** Bind the socket to the local IP */ status = bind (SockDesc1, (struct sockaddr *) &sin, slen); if (status < 0) { LogMessage ("CreateSocketPair: bind () - %d", errno); close (SockDesc1); return -1; } /* ** Get the socket name so we can save the port number */ status = getsockname (SockDesc1, (struct sockaddr *) &sin, &slen); if (status < 0) { LogMessage ("CreateSocketPair: getsockname () - %d", errno); close (SockDesc1); return -1; } else LocalHostPort = sin.sin_port; /* ** Setup a listen for the socket */ listen (SockDesc1, 5); /* ** Get the binary (64-bit) time of the specified timeout value */ sprintf (AscTimeBuff, "0 0:0:%02d.00", SOCKET_PAIR_TIMEOUT_VALUE); AscTimeDesc.dsc$w_length = strlen (AscTimeBuff); AscTimeDesc.dsc$a_pointer = AscTimeBuff; status = sys$bintim (&AscTimeDesc, BinTimeBuff); if (! (status & 1)) { LogMessage ("CreateSocketPair: SYS$BINTIM () - %08X", status); close (SockDesc1); return -1; } /* ** Assign another channel to the TCP/IP device for the accept. ** This is the channel that ends up being connected to. */ status = sys$assign (&TcpDeviceDesc, &TcpDeviceChan, 0, 0, 0); if (! (status & 1)) { LogMessage ("CreateSocketPair: SYS$ASSIGN () - %08X", status); close (SockDesc1); return -1; } /* ** Get the channel of the first socket for the accept */ TcpAcceptChan = decc$get_sdc (SockDesc1); /* ** Perform the accept using $QIO so we can do this asynchronously */ status = sys$qio (EFN$C_ENF, TcpAcceptChan, IO$_ACCESS | IO$M_ACCEPT, &iosb, 0, 0, 0, 0, 0, &TcpDeviceChan, 0, 0); if (! (status & 1)) { LogMessage ("CreateSocketPair: SYS$QIO () - %08X", status); close (SockDesc1); sys$dassgn (TcpDeviceChan); return -1; } /* ** Create the second socket to do the connect */ SockDesc2 = socket (SocketFamily, SocketType, 0); if (SockDesc2 < 0) { LogMessage ("CreateSocketPair: socket () - %d", errno); sys$cancel (TcpAcceptChan); close (SockDesc1); sys$dassgn (TcpDeviceChan); return (-1) ; } /* ** Setup the Socket Pair Timeout Block */ sptb.SockChan1 = TcpAcceptChan; sptb.SockChan2 = decc$get_sdc (SockDesc2); /* ** Before we block on the connect, set a timer that can cancel I/O on our ** two sockets if it never connects. */ status = sys$setimr (EFN$C_ENF, BinTimeBuff, SocketPairTimeoutAst, &sptb, 0); if (! (status & 1)) { LogMessage ("CreateSocketPair: SYS$SETIMR () - %08X", status); sys$cancel (TcpAcceptChan); close (SockDesc1); close (SockDesc2); sys$dassgn (TcpDeviceChan); return -1; } /* ** Now issue the connect */ memset ((char *) &sin, 0, sizeof(sin)) ; sin.sin_family = SocketFamily; sin.sin_addr.s_addr = inet_addr (LocalHostAddr) ; sin.sin_port = LocalHostPort ; status = connect (SockDesc2, (struct sockaddr *) &sin, sizeof(sin)); if (status < 0) { LogMessage ("CreateSocketPair: connect () - %d", errno); sys$cantim (&sptb, 0); sys$cancel (TcpAcceptChan); close (SockDesc1); close (SockDesc2); sys$dassgn (TcpDeviceChan); return -1; } /* ** Wait for the asynch $QIO to finish. Note that if the I/O was aborted ** (SS$_ABORT), then we probably canceled it from the AST routine - so log ** a timeout. */ status = sys$synch (EFN$C_ENF, &iosb); if (! (iosb.iosb$w_status & 1)) { if (iosb.iosb$w_status == SS$_ABORT) LogMessage ("CreateSocketPair: SYS$QIO(iosb) timeout"); else { LogMessage ("CreateSocketPair: SYS$QIO(iosb) - %d", iosb.iosb$w_status); sys$cantim (&sptb, 0); } close (SockDesc1); close (SockDesc2); sys$dassgn (TcpDeviceChan); return -1; } /* ** Here we're successfully connected, so cancel the timer, convert the ** I/O channel to a socket fd, close the listener socket and return the ** connected pair. */ sys$cantim (&sptb, 0); close (SockDesc1) ; SocketPair[0] = SockDesc2 ; SocketPair[1] = socket_fd (TcpDeviceChan); return (0) ; } /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ static void SocketPairTimeoutAst (int astparm) { SPTB *sptb = (SPTB *) astparm; sys$cancel (sptb->SockChan2); /* Cancel the connect() */ sys$cancel (sptb->SockChan1); /* Cancel the accept() */ return; } /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ static int TerminalDeviceAst (int astparm) { int status; /* ** Terminate the terminal buffer */ TerminalDeviceBuff[TerminalDeviceIosb.iosb$w_bcnt] = '\0'; strcat (TerminalDeviceBuff, "\n"); /* ** Send the data read from the terminal device through the socket pair */ send (TerminalSocketPair[0], TerminalDeviceBuff, TerminalDeviceIosb.iosb$w_bcnt + 1, 0); /* ** Queue another async IO to the terminal device */ status = sys$qio (EFN$C_ENF, TerminalDeviceChan, IO$_READVBLK, &TerminalDeviceIosb, TerminalDeviceAst, 0, TerminalDeviceBuff, sizeof(TerminalDeviceBuff) - 1, 0, 0, 0, 0); /* ** Return status */ return status; } /*----------------------------------------------------------------------------*/ /* */ /*----------------------------------------------------------------------------*/ static void LogMessage (char *msg, ...) { char *Month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; static unsigned int pid = 0; va_list args; time_t CurTime; struct tm *LocTime; char MsgBuff[256]; /* ** Get the process pid */ if (pid == 0) pid = getpid (); /* ** Convert the current time into local time */ CurTime = time (NULL); LocTime = localtime (&CurTime); /* ** Format the message buffer */ sprintf (MsgBuff, "%02d-%s-%04d %02d:%02d:%02d [%08X] %s\n", LocTime->tm_mday, Month[LocTime->tm_mon], (LocTime->tm_year + 1900), LocTime->tm_hour, LocTime->tm_min, LocTime->tm_sec, pid, msg); /* ** Get any variable arguments and add them to the print of the message ** buffer */ va_start (args, msg); vfprintf (stderr, MsgBuff, args); va_end (args); /* ** Flush standard error output */ fsync (fileno (stderr)); return; } #endif

./openssl/apps/lib/apps.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS) /* * On VMS, you need to define this to get the declaration of fileno(). The * value 2 is to make sure no function defined in POSIX-2 is left undefined. */ # define _POSIX_C_SOURCE 2 #endif #ifndef OPENSSL_NO_ENGINE /* We need to use some deprecated APIs */ # define OPENSSL_SUPPRESS_DEPRECATED # include <openssl/engine.h> #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #ifndef OPENSSL_NO_POSIX_IO # include <sys/stat.h> # include <fcntl.h> #endif #include <ctype.h> #include <errno.h> #include <openssl/err.h> #include <openssl/x509.h> #include <openssl/x509v3.h> #include <openssl/http.h> #include <openssl/pem.h> #include <openssl/store.h> #include <openssl/pkcs12.h> #include <openssl/ui.h> #include <openssl/safestack.h> #include <openssl/rsa.h> #include <openssl/rand.h> #include <openssl/bn.h> #include <openssl/ssl.h> #include <openssl/core_names.h> #include "s_apps.h" #include "apps.h" #ifdef _WIN32 static int WIN32_rename(const char *from, const char *to); # define rename(from, to) WIN32_rename((from), (to)) #endif #if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MSDOS) # include <conio.h> #endif #if defined(OPENSSL_SYS_MSDOS) && !defined(_WIN32) || defined(__BORLANDC__) # define _kbhit kbhit #endif static BIO *bio_open_default_(const char *filename, char mode, int format, int quiet); #define PASS_SOURCE_SIZE_MAX 4 DEFINE_STACK_OF(CONF) typedef struct { const char *name; unsigned long flag; unsigned long mask; } NAME_EX_TBL; static int set_table_opts(unsigned long *flags, const char *arg, const NAME_EX_TBL *in_tbl); static int set_multi_opts(unsigned long *flags, const char *arg, const NAME_EX_TBL *in_tbl); int app_init(long mesgwin); int chopup_args(ARGS *arg, char *buf) { int quoted; char c = '\0', *p = NULL; arg->argc = 0; if (arg->size == 0) { arg->size = 20; arg->argv = app_malloc(sizeof(*arg->argv) * arg->size, "argv space"); } for (p = buf;;) { /* Skip whitespace. */ while (*p && isspace(_UC(*p))) p++; if (*p == '\0') break; /* The start of something good :-) */ if (arg->argc >= arg->size) { char **tmp; arg->size += 20; tmp = OPENSSL_realloc(arg->argv, sizeof(*arg->argv) * arg->size); if (tmp == NULL) return 0; arg->argv = tmp; } quoted = *p == '\'' || *p == '"'; if (quoted) c = *p++; arg->argv[arg->argc++] = p; /* now look for the end of this */ if (quoted) { while (*p && *p != c) p++; *p++ = '\0'; } else { while (*p && !isspace(_UC(*p))) p++; if (*p) *p++ = '\0'; } } arg->argv[arg->argc] = NULL; return 1; } #ifndef APP_INIT int app_init(long mesgwin) { return 1; } #endif int ctx_set_verify_locations(SSL_CTX *ctx, const char *CAfile, int noCAfile, const char *CApath, int noCApath, const char *CAstore, int noCAstore) { if (CAfile == NULL && CApath == NULL && CAstore == NULL) { if (!noCAfile && SSL_CTX_set_default_verify_file(ctx) <= 0) return 0; if (!noCApath && SSL_CTX_set_default_verify_dir(ctx) <= 0) return 0; if (!noCAstore && SSL_CTX_set_default_verify_store(ctx) <= 0) return 0; return 1; } if (CAfile != NULL && !SSL_CTX_load_verify_file(ctx, CAfile)) return 0; if (CApath != NULL && !SSL_CTX_load_verify_dir(ctx, CApath)) return 0; if (CAstore != NULL && !SSL_CTX_load_verify_store(ctx, CAstore)) return 0; return 1; } #ifndef OPENSSL_NO_CT int ctx_set_ctlog_list_file(SSL_CTX *ctx, const char *path) { if (path == NULL) return SSL_CTX_set_default_ctlog_list_file(ctx); return SSL_CTX_set_ctlog_list_file(ctx, path); } #endif static unsigned long nmflag = 0; static char nmflag_set = 0; int set_nameopt(const char *arg) { int ret = set_name_ex(&nmflag, arg); if (ret) nmflag_set = 1; return ret; } unsigned long get_nameopt(void) { return nmflag_set ? nmflag : XN_FLAG_SEP_CPLUS_SPC | ASN1_STRFLGS_UTF8_CONVERT; } void dump_cert_text(BIO *out, X509 *x) { print_name(out, "subject=", X509_get_subject_name(x)); print_name(out, "issuer=", X509_get_issuer_name(x)); } int wrap_password_callback(char *buf, int bufsiz, int verify, void *userdata) { return password_callback(buf, bufsiz, verify, (PW_CB_DATA *)userdata); } static char *app_get_pass(const char *arg, int keepbio); char *get_passwd(const char *pass, const char *desc) { char *result = NULL; if (desc == NULL) desc = "<unknown>"; if (!app_passwd(pass, NULL, &result, NULL)) BIO_printf(bio_err, "Error getting password for %s\n", desc); if (pass != NULL && result == NULL) { BIO_printf(bio_err, "Trying plain input string (better precede with 'pass:')\n"); result = OPENSSL_strdup(pass); if (result == NULL) BIO_printf(bio_err, "Out of memory getting password for %s\n", desc); } return result; } int app_passwd(const char *arg1, const char *arg2, char **pass1, char **pass2) { int same = arg1 != NULL && arg2 != NULL && strcmp(arg1, arg2) == 0; if (arg1 != NULL) { *pass1 = app_get_pass(arg1, same); if (*pass1 == NULL) return 0; } else if (pass1 != NULL) { *pass1 = NULL; } if (arg2 != NULL) { *pass2 = app_get_pass(arg2, same ? 2 : 0); if (*pass2 == NULL) return 0; } else if (pass2 != NULL) { *pass2 = NULL; } return 1; } static char *app_get_pass(const char *arg, int keepbio) { static BIO *pwdbio = NULL; char *tmp, tpass[APP_PASS_LEN]; int i; /* PASS_SOURCE_SIZE_MAX = max number of chars before ':' in below strings */ if (CHECK_AND_SKIP_PREFIX(arg, "pass:")) return OPENSSL_strdup(arg); if (CHECK_AND_SKIP_PREFIX(arg, "env:")) { tmp = getenv(arg); if (tmp == NULL) { BIO_printf(bio_err, "No environment variable %s\n", arg); return NULL; } return OPENSSL_strdup(tmp); } if (!keepbio || pwdbio == NULL) { if (CHECK_AND_SKIP_PREFIX(arg, "file:")) { pwdbio = BIO_new_file(arg, "r"); if (pwdbio == NULL) { BIO_printf(bio_err, "Can't open file %s\n", arg); return NULL; } #if !defined(_WIN32) /* * Under _WIN32, which covers even Win64 and CE, file * descriptors referenced by BIO_s_fd are not inherited * by child process and therefore below is not an option. * It could have been an option if bss_fd.c was operating * on real Windows descriptors, such as those obtained * with CreateFile. */ } else if (CHECK_AND_SKIP_PREFIX(arg, "fd:")) { BIO *btmp; i = atoi(arg); if (i >= 0) pwdbio = BIO_new_fd(i, BIO_NOCLOSE); if ((i < 0) || pwdbio == NULL) { BIO_printf(bio_err, "Can't access file descriptor %s\n", arg); return NULL; } /* * Can't do BIO_gets on an fd BIO so add a buffering BIO */ btmp = BIO_new(BIO_f_buffer()); if (btmp == NULL) { BIO_free_all(pwdbio); pwdbio = NULL; BIO_printf(bio_err, "Out of memory\n"); return NULL; } pwdbio = BIO_push(btmp, pwdbio); #endif } else if (strcmp(arg, "stdin") == 0) { unbuffer(stdin); pwdbio = dup_bio_in(FORMAT_TEXT); if (pwdbio == NULL) { BIO_printf(bio_err, "Can't open BIO for stdin\n"); return NULL; } } else { /* argument syntax error; do not reveal too much about arg */ tmp = strchr(arg, ':'); if (tmp == NULL || tmp - arg > PASS_SOURCE_SIZE_MAX) BIO_printf(bio_err, "Invalid password argument, missing ':' within the first %d chars\n", PASS_SOURCE_SIZE_MAX + 1); else BIO_printf(bio_err, "Invalid password argument, starting with \"%.*s\"\n", (int)(tmp - arg + 1), arg); return NULL; } } i = BIO_gets(pwdbio, tpass, APP_PASS_LEN); if (keepbio != 1) { BIO_free_all(pwdbio); pwdbio = NULL; } if (i <= 0) { BIO_printf(bio_err, "Error reading password from BIO\n"); return NULL; } tmp = strchr(tpass, '\n'); if (tmp != NULL) *tmp = 0; return OPENSSL_strdup(tpass); } char *app_conf_try_string(const CONF *conf, const char *group, const char *name) { char *res; ERR_set_mark(); res = NCONF_get_string(conf, group, name); if (res == NULL) ERR_pop_to_mark(); else ERR_clear_last_mark(); return res; } int app_conf_try_number(const CONF *conf, const char *group, const char *name, long *result) { int ok; ERR_set_mark(); ok = NCONF_get_number(conf, group, name, result); if (!ok) ERR_pop_to_mark(); else ERR_clear_last_mark(); return ok; } CONF *app_load_config_bio(BIO *in, const char *filename) { long errorline = -1; CONF *conf; int i; conf = NCONF_new_ex(app_get0_libctx(), NULL); i = NCONF_load_bio(conf, in, &errorline); if (i > 0) return conf; if (errorline <= 0) { BIO_printf(bio_err, "%s: Can't load ", opt_getprog()); } else { BIO_printf(bio_err, "%s: Error on line %ld of ", opt_getprog(), errorline); } if (filename != NULL) BIO_printf(bio_err, "config file \"%s\"\n", filename); else BIO_printf(bio_err, "config input"); NCONF_free(conf); return NULL; } CONF *app_load_config_verbose(const char *filename, int verbose) { if (verbose) { if (*filename == '\0') BIO_printf(bio_err, "No configuration used\n"); else BIO_printf(bio_err, "Using configuration from %s\n", filename); } return app_load_config_internal(filename, 0); } CONF *app_load_config_internal(const char *filename, int quiet) { BIO *in; CONF *conf; if (filename == NULL || *filename != '\0') { if ((in = bio_open_default_(filename, 'r', FORMAT_TEXT, quiet)) == NULL) return NULL; conf = app_load_config_bio(in, filename); BIO_free(in); } else { /* Return empty config if filename is empty string. */ conf = NCONF_new_ex(app_get0_libctx(), NULL); } return conf; } int app_load_modules(const CONF *config) { CONF *to_free = NULL; if (config == NULL) config = to_free = app_load_config_quiet(default_config_file); if (config == NULL) return 1; if (CONF_modules_load(config, NULL, 0) <= 0) { BIO_printf(bio_err, "Error configuring OpenSSL modules\n"); ERR_print_errors(bio_err); NCONF_free(to_free); return 0; } NCONF_free(to_free); return 1; } int add_oid_section(CONF *conf) { char *p; STACK_OF(CONF_VALUE) *sktmp; CONF_VALUE *cnf; int i; if ((p = app_conf_try_string(conf, NULL, "oid_section")) == NULL) return 1; if ((sktmp = NCONF_get_section(conf, p)) == NULL) { BIO_printf(bio_err, "problem loading oid section %s\n", p); return 0; } for (i = 0; i < sk_CONF_VALUE_num(sktmp); i++) { cnf = sk_CONF_VALUE_value(sktmp, i); if (OBJ_create(cnf->value, cnf->name, cnf->name) == NID_undef) { BIO_printf(bio_err, "problem creating object %s=%s\n", cnf->name, cnf->value); return 0; } } return 1; } CONF *app_load_config_modules(const char *configfile) { CONF *conf = NULL; if (configfile != NULL) { if ((conf = app_load_config_verbose(configfile, 1)) == NULL) return NULL; if (configfile != default_config_file && !app_load_modules(conf)) { NCONF_free(conf); conf = NULL; } } return conf; } #define IS_HTTP(uri) ((uri) != NULL && HAS_PREFIX(uri, OSSL_HTTP_PREFIX)) #define IS_HTTPS(uri) ((uri) != NULL && HAS_PREFIX(uri, OSSL_HTTPS_PREFIX)) X509 *load_cert_pass(const char *uri, int format, int maybe_stdin, const char *pass, const char *desc) { X509 *cert = NULL; if (desc == NULL) desc = "certificate"; if (IS_HTTPS(uri)) { BIO_printf(bio_err, "Loading %s over HTTPS is unsupported\n", desc); } else if (IS_HTTP(uri)) { cert = X509_load_http(uri, NULL, NULL, 0 /* timeout */); if (cert == NULL) { ERR_print_errors(bio_err); BIO_printf(bio_err, "Unable to load %s from %s\n", desc, uri); } } else { (void)load_key_certs_crls(uri, format, maybe_stdin, pass, desc, 0, NULL, NULL, NULL, &cert, NULL, NULL, NULL); } return cert; } X509_CRL *load_crl(const char *uri, int format, int maybe_stdin, const char *desc) { X509_CRL *crl = NULL; if (desc == NULL) desc = "CRL"; if (IS_HTTPS(uri)) { BIO_printf(bio_err, "Loading %s over HTTPS is unsupported\n", desc); } else if (IS_HTTP(uri)) { crl = X509_CRL_load_http(uri, NULL, NULL, 0 /* timeout */); if (crl == NULL) { ERR_print_errors(bio_err); BIO_printf(bio_err, "Unable to load %s from %s\n", desc, uri); } } else { (void)load_key_certs_crls(uri, format, maybe_stdin, NULL, desc, 0, NULL, NULL, NULL, NULL, NULL, &crl, NULL); } return crl; } /* Could be simplified if OSSL_STORE supported CSRs, see FR #15725 */ X509_REQ *load_csr(const char *file, int format, const char *desc) { X509_REQ *req = NULL; BIO *in; if (format == FORMAT_UNDEF) format = FORMAT_PEM; in = bio_open_default(file, 'r', format); if (in == NULL) goto end; if (format == FORMAT_ASN1) req = d2i_X509_REQ_bio(in, NULL); else if (format == FORMAT_PEM) req = PEM_read_bio_X509_REQ(in, NULL, NULL, NULL); else print_format_error(format, OPT_FMT_PEMDER); end: if (req == NULL) { ERR_print_errors(bio_err); if (desc != NULL) BIO_printf(bio_err, "Unable to load %s\n", desc); } BIO_free(in); return req; } /* Better extend OSSL_STORE to support CSRs, see FR #15725 */ X509_REQ *load_csr_autofmt(const char *infile, int format, STACK_OF(OPENSSL_STRING) *vfyopts, const char *desc) { X509_REQ *csr; if (format != FORMAT_UNDEF) { csr = load_csr(infile, format, desc); } else { /* try PEM, then DER */ BIO *bio_bak = bio_err; bio_err = NULL; /* do not show errors on more than one try */ csr = load_csr(infile, FORMAT_PEM, NULL /* desc */); bio_err = bio_bak; if (csr == NULL) { ERR_clear_error(); csr = load_csr(infile, FORMAT_ASN1, NULL /* desc */); } if (csr == NULL) { BIO_printf(bio_err, "error: unable to load %s from file '%s'\n", desc, infile); } } if (csr != NULL) { EVP_PKEY *pkey = X509_REQ_get0_pubkey(csr); int ret = do_X509_REQ_verify(csr, pkey, vfyopts); if (pkey == NULL || ret < 0) BIO_puts(bio_err, "Warning: error while verifying CSR self-signature\n"); else if (ret == 0) BIO_puts(bio_err, "Warning: CSR self-signature does not match the contents\n"); return csr; } return csr; } void cleanse(char *str) { if (str != NULL) OPENSSL_cleanse(str, strlen(str)); } void clear_free(char *str) { if (str != NULL) OPENSSL_clear_free(str, strlen(str)); } EVP_PKEY *load_key(const char *uri, int format, int may_stdin, const char *pass, ENGINE *e, const char *desc) { EVP_PKEY *pkey = NULL; char *allocated_uri = NULL; if (desc == NULL) desc = "private key"; if (format == FORMAT_ENGINE) uri = allocated_uri = make_engine_uri(e, uri, desc); (void)load_key_certs_crls(uri, format, may_stdin, pass, desc, 0, &pkey, NULL, NULL, NULL, NULL, NULL, NULL); OPENSSL_free(allocated_uri); return pkey; } /* first try reading public key, on failure resort to loading private key */ EVP_PKEY *load_pubkey(const char *uri, int format, int maybe_stdin, const char *pass, ENGINE *e, const char *desc) { EVP_PKEY *pkey = NULL; char *allocated_uri = NULL; if (desc == NULL) desc = "public key"; if (format == FORMAT_ENGINE) uri = allocated_uri = make_engine_uri(e, uri, desc); (void)load_key_certs_crls(uri, format, maybe_stdin, pass, desc, 1, NULL, &pkey, NULL, NULL, NULL, NULL, NULL); if (pkey == NULL) (void)load_key_certs_crls(uri, format, maybe_stdin, pass, desc, 0, &pkey, NULL, NULL, NULL, NULL, NULL, NULL); OPENSSL_free(allocated_uri); return pkey; } EVP_PKEY *load_keyparams_suppress(const char *uri, int format, int maybe_stdin, const char *keytype, const char *desc, int suppress_decode_errors) { EVP_PKEY *params = NULL; if (desc == NULL) desc = "key parameters"; (void)load_key_certs_crls(uri, format, maybe_stdin, NULL, desc, suppress_decode_errors, NULL, NULL, &params, NULL, NULL, NULL, NULL); if (params != NULL && keytype != NULL && !EVP_PKEY_is_a(params, keytype)) { ERR_print_errors(bio_err); BIO_printf(bio_err, "Unable to load %s from %s (unexpected parameters type)\n", desc, uri); EVP_PKEY_free(params); params = NULL; } return params; } EVP_PKEY *load_keyparams(const char *uri, int format, int maybe_stdin, const char *keytype, const char *desc) { return load_keyparams_suppress(uri, format, maybe_stdin, keytype, desc, 0); } void app_bail_out(char *fmt, ...) { va_list args; va_start(args, fmt); BIO_vprintf(bio_err, fmt, args); va_end(args); ERR_print_errors(bio_err); exit(EXIT_FAILURE); } void *app_malloc(size_t sz, const char *what) { void *vp = OPENSSL_malloc(sz); if (vp == NULL) app_bail_out("%s: Could not allocate %zu bytes for %s\n", opt_getprog(), sz, what); return vp; } char *next_item(char *opt) /* in list separated by comma and/or space */ { /* advance to separator (comma or whitespace), if any */ while (*opt != ',' && !isspace(_UC(*opt)) && *opt != '\0') opt++; if (*opt != '\0') { /* terminate current item */ *opt++ = '\0'; /* skip over any whitespace after separator */ while (isspace(_UC(*opt))) opt++; } return *opt == '\0' ? NULL : opt; /* NULL indicates end of input */ } static void warn_cert_msg(const char *uri, X509 *cert, const char *msg) { char *subj = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0); BIO_printf(bio_err, "Warning: certificate from '%s' with subject '%s' %s\n", uri, subj, msg); OPENSSL_free(subj); } static void warn_cert(const char *uri, X509 *cert, int warn_EE, X509_VERIFY_PARAM *vpm) { uint32_t ex_flags = X509_get_extension_flags(cert); int res = X509_cmp_timeframe(vpm, X509_get0_notBefore(cert), X509_get0_notAfter(cert)); if (res != 0) warn_cert_msg(uri, cert, res > 0 ? "has expired" : "not yet valid"); if (warn_EE && (ex_flags & EXFLAG_V1) == 0 && (ex_flags & EXFLAG_CA) == 0) warn_cert_msg(uri, cert, "is not a CA cert"); } static void warn_certs(const char *uri, STACK_OF(X509) *certs, int warn_EE, X509_VERIFY_PARAM *vpm) { int i; for (i = 0; i < sk_X509_num(certs); i++) warn_cert(uri, sk_X509_value(certs, i), warn_EE, vpm); } int load_cert_certs(const char *uri, X509 **pcert, STACK_OF(X509) **pcerts, int exclude_http, const char *pass, const char *desc, X509_VERIFY_PARAM *vpm) { int ret = 0; char *pass_string; if (desc == NULL) desc = pcerts == NULL ? "certificate" : "certificates"; if (exclude_http && (HAS_CASE_PREFIX(uri, "http://") || HAS_CASE_PREFIX(uri, "https://"))) { BIO_printf(bio_err, "error: HTTP retrieval not allowed for %s\n", desc); return ret; } pass_string = get_passwd(pass, desc); ret = load_key_certs_crls(uri, FORMAT_UNDEF, 0, pass_string, desc, 0, NULL, NULL, NULL, pcert, pcerts, NULL, NULL); clear_free(pass_string); if (ret) { if (pcert != NULL) warn_cert(uri, *pcert, 0, vpm); if (pcerts != NULL) warn_certs(uri, *pcerts, 1, vpm); } else { if (pcerts != NULL) { OSSL_STACK_OF_X509_free(*pcerts); *pcerts = NULL; } } return ret; } STACK_OF(X509) *load_certs_multifile(char *files, const char *pass, const char *desc, X509_VERIFY_PARAM *vpm) { STACK_OF(X509) *certs = NULL; STACK_OF(X509) *result = sk_X509_new_null(); if (files == NULL) goto err; if (result == NULL) goto oom; while (files != NULL) { char *next = next_item(files); if (!load_cert_certs(files, NULL, &certs, 0, pass, desc, vpm)) goto err; if (!X509_add_certs(result, certs, X509_ADD_FLAG_UP_REF | X509_ADD_FLAG_NO_DUP)) goto oom; OSSL_STACK_OF_X509_free(certs); certs = NULL; files = next; } return result; oom: BIO_printf(bio_err, "out of memory\n"); err: OSSL_STACK_OF_X509_free(certs); OSSL_STACK_OF_X509_free(result); return NULL; } static X509_STORE *sk_X509_to_store(X509_STORE *store /* may be NULL */, const STACK_OF(X509) *certs /* may NULL */) { int i; if (store == NULL) store = X509_STORE_new(); if (store == NULL) return NULL; for (i = 0; i < sk_X509_num(certs); i++) { if (!X509_STORE_add_cert(store, sk_X509_value(certs, i))) { X509_STORE_free(store); return NULL; } } return store; } /* * Create cert store structure with certificates read from given file(s). * Returns pointer to created X509_STORE on success, NULL on error. */ X509_STORE *load_certstore(char *input, const char *pass, const char *desc, X509_VERIFY_PARAM *vpm) { X509_STORE *store = NULL; STACK_OF(X509) *certs = NULL; while (input != NULL) { char *next = next_item(input); int ok; if (!load_cert_certs(input, NULL, &certs, 1, pass, desc, vpm)) { X509_STORE_free(store); return NULL; } ok = (store = sk_X509_to_store(store, certs)) != NULL; OSSL_STACK_OF_X509_free(certs); certs = NULL; if (!ok) return NULL; input = next; } return store; } /* * Initialize or extend, if *certs != NULL, a certificate stack. * The caller is responsible for freeing *certs if its value is left not NULL. */ int load_certs(const char *uri, int maybe_stdin, STACK_OF(X509) **certs, const char *pass, const char *desc) { int ret, was_NULL = *certs == NULL; if (desc == NULL) desc = "certificates"; ret = load_key_certs_crls(uri, FORMAT_UNDEF, maybe_stdin, pass, desc, 0, NULL, NULL, NULL, NULL, certs, NULL, NULL); if (!ret && was_NULL) { OSSL_STACK_OF_X509_free(*certs); *certs = NULL; } return ret; } /* * Initialize or extend, if *crls != NULL, a certificate stack. * The caller is responsible for freeing *crls if its value is left not NULL. */ int load_crls(const char *uri, STACK_OF(X509_CRL) **crls, const char *pass, const char *desc) { int ret, was_NULL = *crls == NULL; if (desc == NULL) desc = "CRLs"; ret = load_key_certs_crls(uri, FORMAT_UNDEF, 0, pass, desc, 0, NULL, NULL, NULL, NULL, NULL, NULL, crls); if (!ret && was_NULL) { sk_X509_CRL_pop_free(*crls, X509_CRL_free); *crls = NULL; } return ret; } static const char *format2string(int format) { switch (format) { case FORMAT_PEM: return "PEM"; case FORMAT_ASN1: return "DER"; } return NULL; } /* Set type expectation, but clear it if objects of different types expected. */ #define SET_EXPECT(val) \ (expect = expect < 0 ? (val) : (expect == (val) ? (val) : 0)) #define SET_EXPECT1(pvar, val) \ if ((pvar) != NULL) { \ *(pvar) = NULL; \ SET_EXPECT(val); \ } #define FAIL_NAME \ (ppkey != NULL ? "private key" : ppubkey != NULL ? "public key" : \ pparams != NULL ? "key parameters" : \ pcert != NULL ? "certificate" : pcerts != NULL ? "certificates" : \ pcrl != NULL ? "CRL" : pcrls != NULL ? "CRLs" : NULL) /* * Load those types of credentials for which the result pointer is not NULL. * Reads from stdio if uri is NULL and maybe_stdin is nonzero. * For non-NULL ppkey, pcert, and pcrl the first suitable value found is loaded. * If pcerts is non-NULL and *pcerts == NULL then a new cert list is allocated. * If pcerts is non-NULL then all available certificates are appended to *pcerts * except any certificate assigned to *pcert. * If pcrls is non-NULL and *pcrls == NULL then a new list of CRLs is allocated. * If pcrls is non-NULL then all available CRLs are appended to *pcerts * except any CRL assigned to *pcrl. * In any case (also on error) the caller is responsible for freeing all members * of *pcerts and *pcrls (as far as they are not NULL). */ int load_key_certs_crls(const char *uri, int format, int maybe_stdin, const char *pass, const char *desc, int quiet, EVP_PKEY **ppkey, EVP_PKEY **ppubkey, EVP_PKEY **pparams, X509 **pcert, STACK_OF(X509) **pcerts, X509_CRL **pcrl, STACK_OF(X509_CRL) **pcrls) { PW_CB_DATA uidata; OSSL_STORE_CTX *ctx = NULL; OSSL_LIB_CTX *libctx = app_get0_libctx(); const char *propq = app_get0_propq(); int ncerts = 0, ncrls = 0, expect = -1; const char *failed = FAIL_NAME; const char *input_type; OSSL_PARAM itp[2]; const OSSL_PARAM *params = NULL; if (failed == NULL) { if (!quiet) BIO_printf(bio_err, "Internal error: nothing to load from %s\n", uri != NULL ? uri : "<stdin>"); return 0; } ERR_set_mark(); SET_EXPECT1(ppkey, OSSL_STORE_INFO_PKEY); SET_EXPECT1(ppubkey, OSSL_STORE_INFO_PUBKEY); SET_EXPECT1(pparams, OSSL_STORE_INFO_PARAMS); SET_EXPECT1(pcert, OSSL_STORE_INFO_CERT); if (pcerts != NULL) { if (*pcerts == NULL && (*pcerts = sk_X509_new_null()) == NULL) { if (!quiet) BIO_printf(bio_err, "Out of memory loading"); goto end; } SET_EXPECT(OSSL_STORE_INFO_CERT); } SET_EXPECT1(pcrl, OSSL_STORE_INFO_CRL); if (pcrls != NULL) { if (*pcrls == NULL && (*pcrls = sk_X509_CRL_new_null()) == NULL) { if (!quiet) BIO_printf(bio_err, "Out of memory loading"); goto end; } SET_EXPECT(OSSL_STORE_INFO_CRL); } uidata.password = pass; uidata.prompt_info = uri; if ((input_type = format2string(format)) != NULL) { itp[0] = OSSL_PARAM_construct_utf8_string(OSSL_STORE_PARAM_INPUT_TYPE, (char *)input_type, 0); itp[1] = OSSL_PARAM_construct_end(); params = itp; } if (uri == NULL) { BIO *bio; if (!maybe_stdin) { if (!quiet) BIO_printf(bio_err, "No filename or uri specified for loading\n"); goto end; } uri = "<stdin>"; unbuffer(stdin); bio = BIO_new_fp(stdin, 0); if (bio != NULL) { ctx = OSSL_STORE_attach(bio, "file", libctx, propq, get_ui_method(), &uidata, params, NULL, NULL); BIO_free(bio); } } else { ctx = OSSL_STORE_open_ex(uri, libctx, propq, get_ui_method(), &uidata, params, NULL, NULL); } if (ctx == NULL) { if (!quiet) BIO_printf(bio_err, "Could not open file or uri for loading"); goto end; } if (expect > 0 && !OSSL_STORE_expect(ctx, expect)) { if (!quiet) BIO_printf(bio_err, "Internal error trying to load"); goto end; } failed = NULL; while ((ppkey != NULL || ppubkey != NULL || pparams != NULL || pcert != NULL || pcerts != NULL || pcrl != NULL || pcrls != NULL) && !OSSL_STORE_eof(ctx)) { OSSL_STORE_INFO *info = OSSL_STORE_load(ctx); int type, ok = 1; /* * This can happen (for example) if we attempt to load a file with * multiple different types of things in it - but the thing we just * tried to load wasn't one of the ones we wanted, e.g. if we're trying * to load a certificate but the file has both the private key and the * certificate in it. We just retry until eof. */ if (info == NULL) { continue; } type = OSSL_STORE_INFO_get_type(info); switch (type) { case OSSL_STORE_INFO_PKEY: if (ppkey != NULL) { ok = (*ppkey = OSSL_STORE_INFO_get1_PKEY(info)) != NULL; if (ok) ppkey = NULL; break; } /* * An EVP_PKEY with private parts also holds the public parts, * so if the caller asked for a public key, and we got a private * key, we can still pass it back. */ /* fall through */ case OSSL_STORE_INFO_PUBKEY: if (ppubkey != NULL) { ok = (*ppubkey = OSSL_STORE_INFO_get1_PUBKEY(info)) != NULL; if (ok) ppubkey = NULL; } break; case OSSL_STORE_INFO_PARAMS: if (pparams != NULL) { ok = (*pparams = OSSL_STORE_INFO_get1_PARAMS(info)) != NULL; if (ok) pparams = NULL; } break; case OSSL_STORE_INFO_CERT: if (pcert != NULL) { ok = (*pcert = OSSL_STORE_INFO_get1_CERT(info)) != NULL; if (ok) pcert = NULL; } else if (pcerts != NULL) { ok = X509_add_cert(*pcerts, OSSL_STORE_INFO_get1_CERT(info), X509_ADD_FLAG_DEFAULT); } ncerts += ok; break; case OSSL_STORE_INFO_CRL: if (pcrl != NULL) { ok = (*pcrl = OSSL_STORE_INFO_get1_CRL(info)) != NULL; if (ok) pcrl = NULL; } else if (pcrls != NULL) { ok = sk_X509_CRL_push(*pcrls, OSSL_STORE_INFO_get1_CRL(info)); } ncrls += ok; break; default: /* skip any other type */ break; } OSSL_STORE_INFO_free(info); if (!ok) { failed = OSSL_STORE_INFO_type_string(type); if (!quiet) BIO_printf(bio_err, "Error reading"); break; } } end: OSSL_STORE_close(ctx); if (ncerts > 0) pcerts = NULL; if (ncrls > 0) pcrls = NULL; if (failed == NULL) { failed = FAIL_NAME; if (failed != NULL && !quiet) BIO_printf(bio_err, "Could not find"); } if (failed != NULL && !quiet) { unsigned long err = ERR_peek_last_error(); if (desc != NULL && strstr(desc, failed) != NULL) { BIO_printf(bio_err, " %s", desc); } else { BIO_printf(bio_err, " %s", failed); if (desc != NULL) BIO_printf(bio_err, " of %s", desc); } if (uri != NULL) BIO_printf(bio_err, " from %s", uri); if (ERR_SYSTEM_ERROR(err)) { /* provide more readable diagnostic output */ BIO_printf(bio_err, ": %s", strerror(ERR_GET_REASON(err))); ERR_pop_to_mark(); ERR_set_mark(); } BIO_printf(bio_err, "\n"); ERR_print_errors(bio_err); } if (quiet || failed == NULL) /* clear any suppressed or spurious errors */ ERR_pop_to_mark(); else ERR_clear_last_mark(); return failed == NULL; } #define X509V3_EXT_UNKNOWN_MASK (0xfL << 16) #define X509V3_EXT_DEFAULT 0 /* Return error for unknown exts */ #define X509V3_EXT_ERROR_UNKNOWN (1L << 16) /* Print error for unknown exts */ #define X509V3_EXT_PARSE_UNKNOWN (2L << 16) /* ASN1 parse unknown extensions */ #define X509V3_EXT_DUMP_UNKNOWN (3L << 16) /* BIO_dump unknown extensions */ #define X509_FLAG_CA (X509_FLAG_NO_ISSUER | X509_FLAG_NO_PUBKEY | \ X509_FLAG_NO_HEADER | X509_FLAG_NO_VERSION) int set_cert_ex(unsigned long *flags, const char *arg) { static const NAME_EX_TBL cert_tbl[] = { {"compatible", X509_FLAG_COMPAT, 0xffffffffl}, {"ca_default", X509_FLAG_CA, 0xffffffffl}, {"no_header", X509_FLAG_NO_HEADER, 0}, {"no_version", X509_FLAG_NO_VERSION, 0}, {"no_serial", X509_FLAG_NO_SERIAL, 0}, {"no_signame", X509_FLAG_NO_SIGNAME, 0}, {"no_validity", X509_FLAG_NO_VALIDITY, 0}, {"no_subject", X509_FLAG_NO_SUBJECT, 0}, {"no_issuer", X509_FLAG_NO_ISSUER, 0}, {"no_pubkey", X509_FLAG_NO_PUBKEY, 0}, {"no_extensions", X509_FLAG_NO_EXTENSIONS, 0}, {"no_sigdump", X509_FLAG_NO_SIGDUMP, 0}, {"no_aux", X509_FLAG_NO_AUX, 0}, {"no_attributes", X509_FLAG_NO_ATTRIBUTES, 0}, {"ext_default", X509V3_EXT_DEFAULT, X509V3_EXT_UNKNOWN_MASK}, {"ext_error", X509V3_EXT_ERROR_UNKNOWN, X509V3_EXT_UNKNOWN_MASK}, {"ext_parse", X509V3_EXT_PARSE_UNKNOWN, X509V3_EXT_UNKNOWN_MASK}, {"ext_dump", X509V3_EXT_DUMP_UNKNOWN, X509V3_EXT_UNKNOWN_MASK}, {NULL, 0, 0} }; return set_multi_opts(flags, arg, cert_tbl); } int set_name_ex(unsigned long *flags, const char *arg) { static const NAME_EX_TBL ex_tbl[] = { {"esc_2253", ASN1_STRFLGS_ESC_2253, 0}, {"esc_2254", ASN1_STRFLGS_ESC_2254, 0}, {"esc_ctrl", ASN1_STRFLGS_ESC_CTRL, 0}, {"esc_msb", ASN1_STRFLGS_ESC_MSB, 0}, {"use_quote", ASN1_STRFLGS_ESC_QUOTE, 0}, {"utf8", ASN1_STRFLGS_UTF8_CONVERT, 0}, {"ignore_type", ASN1_STRFLGS_IGNORE_TYPE, 0}, {"show_type", ASN1_STRFLGS_SHOW_TYPE, 0}, {"dump_all", ASN1_STRFLGS_DUMP_ALL, 0}, {"dump_nostr", ASN1_STRFLGS_DUMP_UNKNOWN, 0}, {"dump_der", ASN1_STRFLGS_DUMP_DER, 0}, {"compat", XN_FLAG_COMPAT, 0xffffffffL}, {"sep_comma_plus", XN_FLAG_SEP_COMMA_PLUS, XN_FLAG_SEP_MASK}, {"sep_comma_plus_space", XN_FLAG_SEP_CPLUS_SPC, XN_FLAG_SEP_MASK}, {"sep_semi_plus_space", XN_FLAG_SEP_SPLUS_SPC, XN_FLAG_SEP_MASK}, {"sep_multiline", XN_FLAG_SEP_MULTILINE, XN_FLAG_SEP_MASK}, {"dn_rev", XN_FLAG_DN_REV, 0}, {"nofname", XN_FLAG_FN_NONE, XN_FLAG_FN_MASK}, {"sname", XN_FLAG_FN_SN, XN_FLAG_FN_MASK}, {"lname", XN_FLAG_FN_LN, XN_FLAG_FN_MASK}, {"align", XN_FLAG_FN_ALIGN, 0}, {"oid", XN_FLAG_FN_OID, XN_FLAG_FN_MASK}, {"space_eq", XN_FLAG_SPC_EQ, 0}, {"dump_unknown", XN_FLAG_DUMP_UNKNOWN_FIELDS, 0}, {"RFC2253", XN_FLAG_RFC2253, 0xffffffffL}, {"oneline", XN_FLAG_ONELINE, 0xffffffffL}, {"multiline", XN_FLAG_MULTILINE, 0xffffffffL}, {"ca_default", XN_FLAG_MULTILINE, 0xffffffffL}, {NULL, 0, 0} }; if (set_multi_opts(flags, arg, ex_tbl) == 0) return 0; if (*flags != XN_FLAG_COMPAT && (*flags & XN_FLAG_SEP_MASK) == 0) *flags |= XN_FLAG_SEP_CPLUS_SPC; return 1; } int set_dateopt(unsigned long *dateopt, const char *arg) { if (OPENSSL_strcasecmp(arg, "rfc_822") == 0) *dateopt = ASN1_DTFLGS_RFC822; else if (OPENSSL_strcasecmp(arg, "iso_8601") == 0) *dateopt = ASN1_DTFLGS_ISO8601; else return 0; return 1; } int set_ext_copy(int *copy_type, const char *arg) { if (OPENSSL_strcasecmp(arg, "none") == 0) *copy_type = EXT_COPY_NONE; else if (OPENSSL_strcasecmp(arg, "copy") == 0) *copy_type = EXT_COPY_ADD; else if (OPENSSL_strcasecmp(arg, "copyall") == 0) *copy_type = EXT_COPY_ALL; else return 0; return 1; } int copy_extensions(X509 *x, X509_REQ *req, int copy_type) { STACK_OF(X509_EXTENSION) *exts; int i, ret = 0; if (x == NULL || req == NULL) return 0; if (copy_type == EXT_COPY_NONE) return 1; exts = X509_REQ_get_extensions(req); for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) { X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i); ASN1_OBJECT *obj = X509_EXTENSION_get_object(ext); int idx = X509_get_ext_by_OBJ(x, obj, -1); /* Does extension exist in target? */ if (idx != -1) { /* If normal copy don't override existing extension */ if (copy_type == EXT_COPY_ADD) continue; /* Delete all extensions of same type */ do { X509_EXTENSION_free(X509_delete_ext(x, idx)); idx = X509_get_ext_by_OBJ(x, obj, -1); } while (idx != -1); } if (!X509_add_ext(x, ext, -1)) goto end; } ret = 1; end: sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free); return ret; } static int set_multi_opts(unsigned long *flags, const char *arg, const NAME_EX_TBL *in_tbl) { STACK_OF(CONF_VALUE) *vals; CONF_VALUE *val; int i, ret = 1; if (!arg) return 0; vals = X509V3_parse_list(arg); for (i = 0; i < sk_CONF_VALUE_num(vals); i++) { val = sk_CONF_VALUE_value(vals, i); if (!set_table_opts(flags, val->name, in_tbl)) ret = 0; } sk_CONF_VALUE_pop_free(vals, X509V3_conf_free); return ret; } static int set_table_opts(unsigned long *flags, const char *arg, const NAME_EX_TBL *in_tbl) { char c; const NAME_EX_TBL *ptbl; c = arg[0]; if (c == '-') { c = 0; arg++; } else if (c == '+') { c = 1; arg++; } else { c = 1; } for (ptbl = in_tbl; ptbl->name; ptbl++) { if (OPENSSL_strcasecmp(arg, ptbl->name) == 0) { *flags &= ~ptbl->mask; if (c) *flags |= ptbl->flag; else *flags &= ~ptbl->flag; return 1; } } return 0; } void print_name(BIO *out, const char *title, const X509_NAME *nm) { char *buf; char mline = 0; int indent = 0; unsigned long lflags = get_nameopt(); if (out == NULL) return; if (title != NULL) BIO_puts(out, title); if ((lflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) { mline = 1; indent = 4; } if (lflags == XN_FLAG_COMPAT) { buf = X509_NAME_oneline(nm, 0, 0); BIO_puts(out, buf); BIO_puts(out, "\n"); OPENSSL_free(buf); } else { if (mline) BIO_puts(out, "\n"); X509_NAME_print_ex(out, nm, indent, lflags); BIO_puts(out, "\n"); } } void print_bignum_var(BIO *out, const BIGNUM *in, const char *var, int len, unsigned char *buffer) { BIO_printf(out, " static unsigned char %s_%d[] = {", var, len); if (BN_is_zero(in)) { BIO_printf(out, "\n 0x00"); } else { int i, l; l = BN_bn2bin(in, buffer); for (i = 0; i < l; i++) { BIO_printf(out, (i % 10) == 0 ? "\n " : " "); if (i < l - 1) BIO_printf(out, "0x%02X,", buffer[i]); else BIO_printf(out, "0x%02X", buffer[i]); } } BIO_printf(out, "\n };\n"); } void print_array(BIO *out, const char *title, int len, const unsigned char *d) { int i; BIO_printf(out, "unsigned char %s[%d] = {", title, len); for (i = 0; i < len; i++) { if ((i % 10) == 0) BIO_printf(out, "\n "); if (i < len - 1) BIO_printf(out, "0x%02X, ", d[i]); else BIO_printf(out, "0x%02X", d[i]); } BIO_printf(out, "\n};\n"); } X509_STORE *setup_verify(const char *CAfile, int noCAfile, const char *CApath, int noCApath, const char *CAstore, int noCAstore) { X509_STORE *store = X509_STORE_new(); X509_LOOKUP *lookup; OSSL_LIB_CTX *libctx = app_get0_libctx(); const char *propq = app_get0_propq(); if (store == NULL) goto end; if (CAfile != NULL || !noCAfile) { lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file()); if (lookup == NULL) goto end; if (CAfile != NULL) { if (X509_LOOKUP_load_file_ex(lookup, CAfile, X509_FILETYPE_PEM, libctx, propq) <= 0) { ERR_clear_error(); if (X509_LOOKUP_load_file_ex(lookup, CAfile, X509_FILETYPE_ASN1, libctx, propq) <= 0) { BIO_printf(bio_err, "Error loading file %s\n", CAfile); goto end; } } } else { X509_LOOKUP_load_file_ex(lookup, NULL, X509_FILETYPE_DEFAULT, libctx, propq); } } if (CApath != NULL || !noCApath) { lookup = X509_STORE_add_lookup(store, X509_LOOKUP_hash_dir()); if (lookup == NULL) goto end; if (CApath != NULL) { if (X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM) <= 0) { BIO_printf(bio_err, "Error loading directory %s\n", CApath); goto end; } } else { X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT); } } if (CAstore != NULL || !noCAstore) { lookup = X509_STORE_add_lookup(store, X509_LOOKUP_store()); if (lookup == NULL) goto end; if (!X509_LOOKUP_add_store_ex(lookup, CAstore, libctx, propq)) { if (CAstore != NULL) BIO_printf(bio_err, "Error loading store URI %s\n", CAstore); goto end; } } ERR_clear_error(); return store; end: ERR_print_errors(bio_err); X509_STORE_free(store); return NULL; } static unsigned long index_serial_hash(const OPENSSL_CSTRING *a) { const char *n; n = a[DB_serial]; while (*n == '0') n++; return OPENSSL_LH_strhash(n); } static int index_serial_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b) { const char *aa, *bb; for (aa = a[DB_serial]; *aa == '0'; aa++) ; for (bb = b[DB_serial]; *bb == '0'; bb++) ; return strcmp(aa, bb); } static int index_name_qual(char **a) { return (a[0][0] == 'V'); } static unsigned long index_name_hash(const OPENSSL_CSTRING *a) { return OPENSSL_LH_strhash(a[DB_name]); } int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b) { return strcmp(a[DB_name], b[DB_name]); } static IMPLEMENT_LHASH_HASH_FN(index_serial, OPENSSL_CSTRING) static IMPLEMENT_LHASH_COMP_FN(index_serial, OPENSSL_CSTRING) static IMPLEMENT_LHASH_HASH_FN(index_name, OPENSSL_CSTRING) static IMPLEMENT_LHASH_COMP_FN(index_name, OPENSSL_CSTRING) #undef BSIZE #define BSIZE 256 BIGNUM *load_serial(const char *serialfile, int *exists, int create, ASN1_INTEGER **retai) { BIO *in = NULL; BIGNUM *ret = NULL; char buf[1024]; ASN1_INTEGER *ai = NULL; ai = ASN1_INTEGER_new(); if (ai == NULL) goto err; in = BIO_new_file(serialfile, "r"); if (exists != NULL) *exists = in != NULL; if (in == NULL) { if (!create) { perror(serialfile); goto err; } ERR_clear_error(); ret = BN_new(); if (ret == NULL) { BIO_printf(bio_err, "Out of memory\n"); } else if (!rand_serial(ret, ai)) { BIO_printf(bio_err, "Error creating random number to store in %s\n", serialfile); BN_free(ret); ret = NULL; } } else { if (!a2i_ASN1_INTEGER(in, ai, buf, 1024)) { BIO_printf(bio_err, "Unable to load number from %s\n", serialfile); goto err; } ret = ASN1_INTEGER_to_BN(ai, NULL); if (ret == NULL) { BIO_printf(bio_err, "Error converting number from bin to BIGNUM\n"); goto err; } } if (ret != NULL && retai != NULL) { *retai = ai; ai = NULL; } err: if (ret == NULL) ERR_print_errors(bio_err); BIO_free(in); ASN1_INTEGER_free(ai); return ret; } int save_serial(const char *serialfile, const char *suffix, const BIGNUM *serial, ASN1_INTEGER **retai) { char buf[1][BSIZE]; BIO *out = NULL; int ret = 0; ASN1_INTEGER *ai = NULL; int j; if (suffix == NULL) j = strlen(serialfile); else j = strlen(serialfile) + strlen(suffix) + 1; if (j >= BSIZE) { BIO_printf(bio_err, "File name too long\n"); goto err; } if (suffix == NULL) { OPENSSL_strlcpy(buf[0], serialfile, BSIZE); } else { #ifndef OPENSSL_SYS_VMS j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s.%s", serialfile, suffix); #else j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s-%s", serialfile, suffix); #endif } out = BIO_new_file(buf[0], "w"); if (out == NULL) { goto err; } if ((ai = BN_to_ASN1_INTEGER(serial, NULL)) == NULL) { BIO_printf(bio_err, "error converting serial to ASN.1 format\n"); goto err; } i2a_ASN1_INTEGER(out, ai); BIO_puts(out, "\n"); ret = 1; if (retai) { *retai = ai; ai = NULL; } err: if (!ret) ERR_print_errors(bio_err); BIO_free_all(out); ASN1_INTEGER_free(ai); return ret; } int rotate_serial(const char *serialfile, const char *new_suffix, const char *old_suffix) { char buf[2][BSIZE]; int i, j; i = strlen(serialfile) + strlen(old_suffix); j = strlen(serialfile) + strlen(new_suffix); if (i > j) j = i; if (j + 1 >= BSIZE) { BIO_printf(bio_err, "File name too long\n"); goto err; } #ifndef OPENSSL_SYS_VMS j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s.%s", serialfile, new_suffix); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s.%s", serialfile, old_suffix); #else j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s-%s", serialfile, new_suffix); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s-%s", serialfile, old_suffix); #endif if (rename(serialfile, buf[1]) < 0 && errno != ENOENT #ifdef ENOTDIR && errno != ENOTDIR #endif ) { BIO_printf(bio_err, "Unable to rename %s to %s\n", serialfile, buf[1]); perror("reason"); goto err; } if (rename(buf[0], serialfile) < 0) { BIO_printf(bio_err, "Unable to rename %s to %s\n", buf[0], serialfile); perror("reason"); rename(buf[1], serialfile); goto err; } return 1; err: ERR_print_errors(bio_err); return 0; } int rand_serial(BIGNUM *b, ASN1_INTEGER *ai) { BIGNUM *btmp; int ret = 0; btmp = b == NULL ? BN_new() : b; if (btmp == NULL) return 0; if (!BN_rand(btmp, SERIAL_RAND_BITS, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY)) goto error; if (ai && !BN_to_ASN1_INTEGER(btmp, ai)) goto error; ret = 1; error: if (btmp != b) BN_free(btmp); return ret; } CA_DB *load_index(const char *dbfile, DB_ATTR *db_attr) { CA_DB *retdb = NULL; TXT_DB *tmpdb = NULL; BIO *in; CONF *dbattr_conf = NULL; char buf[BSIZE]; #ifndef OPENSSL_NO_POSIX_IO FILE *dbfp; struct stat dbst; #endif in = BIO_new_file(dbfile, "r"); if (in == NULL) goto err; #ifndef OPENSSL_NO_POSIX_IO BIO_get_fp(in, &dbfp); if (fstat(fileno(dbfp), &dbst) == -1) { ERR_raise_data(ERR_LIB_SYS, errno, "calling fstat(%s)", dbfile); goto err; } #endif if ((tmpdb = TXT_DB_read(in, DB_NUMBER)) == NULL) goto err; #ifndef OPENSSL_SYS_VMS BIO_snprintf(buf, sizeof(buf), "%s.attr", dbfile); #else BIO_snprintf(buf, sizeof(buf), "%s-attr", dbfile); #endif dbattr_conf = app_load_config_quiet(buf); retdb = app_malloc(sizeof(*retdb), "new DB"); retdb->db = tmpdb; tmpdb = NULL; if (db_attr) retdb->attributes = *db_attr; else retdb->attributes.unique_subject = 1; if (dbattr_conf != NULL) { char *p = app_conf_try_string(dbattr_conf, NULL, "unique_subject"); if (p != NULL) retdb->attributes.unique_subject = parse_yesno(p, 1); } retdb->dbfname = OPENSSL_strdup(dbfile); #ifndef OPENSSL_NO_POSIX_IO retdb->dbst = dbst; #endif err: ERR_print_errors(bio_err); NCONF_free(dbattr_conf); TXT_DB_free(tmpdb); BIO_free_all(in); return retdb; } /* * Returns > 0 on success, <= 0 on error */ int index_index(CA_DB *db) { if (!TXT_DB_create_index(db->db, DB_serial, NULL, LHASH_HASH_FN(index_serial), LHASH_COMP_FN(index_serial))) { BIO_printf(bio_err, "Error creating serial number index:(%ld,%ld,%ld)\n", db->db->error, db->db->arg1, db->db->arg2); goto err; } if (db->attributes.unique_subject && !TXT_DB_create_index(db->db, DB_name, index_name_qual, LHASH_HASH_FN(index_name), LHASH_COMP_FN(index_name))) { BIO_printf(bio_err, "Error creating name index:(%ld,%ld,%ld)\n", db->db->error, db->db->arg1, db->db->arg2); goto err; } return 1; err: ERR_print_errors(bio_err); return 0; } int save_index(const char *dbfile, const char *suffix, CA_DB *db) { char buf[3][BSIZE]; BIO *out; int j; j = strlen(dbfile) + strlen(suffix); if (j + 6 >= BSIZE) { BIO_printf(bio_err, "File name too long\n"); goto err; } #ifndef OPENSSL_SYS_VMS j = BIO_snprintf(buf[2], sizeof(buf[2]), "%s.attr", dbfile); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s.attr.%s", dbfile, suffix); j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s.%s", dbfile, suffix); #else j = BIO_snprintf(buf[2], sizeof(buf[2]), "%s-attr", dbfile); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s-attr-%s", dbfile, suffix); j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s-%s", dbfile, suffix); #endif out = BIO_new_file(buf[0], "w"); if (out == NULL) { perror(dbfile); BIO_printf(bio_err, "Unable to open '%s'\n", dbfile); goto err; } j = TXT_DB_write(out, db->db); BIO_free(out); if (j <= 0) goto err; out = BIO_new_file(buf[1], "w"); if (out == NULL) { perror(buf[2]); BIO_printf(bio_err, "Unable to open '%s'\n", buf[2]); goto err; } BIO_printf(out, "unique_subject = %s\n", db->attributes.unique_subject ? "yes" : "no"); BIO_free(out); return 1; err: ERR_print_errors(bio_err); return 0; } int rotate_index(const char *dbfile, const char *new_suffix, const char *old_suffix) { char buf[5][BSIZE]; int i, j; i = strlen(dbfile) + strlen(old_suffix); j = strlen(dbfile) + strlen(new_suffix); if (i > j) j = i; if (j + 6 >= BSIZE) { BIO_printf(bio_err, "File name too long\n"); goto err; } #ifndef OPENSSL_SYS_VMS j = BIO_snprintf(buf[4], sizeof(buf[4]), "%s.attr", dbfile); j = BIO_snprintf(buf[3], sizeof(buf[3]), "%s.attr.%s", dbfile, old_suffix); j = BIO_snprintf(buf[2], sizeof(buf[2]), "%s.attr.%s", dbfile, new_suffix); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s.%s", dbfile, old_suffix); j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s.%s", dbfile, new_suffix); #else j = BIO_snprintf(buf[4], sizeof(buf[4]), "%s-attr", dbfile); j = BIO_snprintf(buf[3], sizeof(buf[3]), "%s-attr-%s", dbfile, old_suffix); j = BIO_snprintf(buf[2], sizeof(buf[2]), "%s-attr-%s", dbfile, new_suffix); j = BIO_snprintf(buf[1], sizeof(buf[1]), "%s-%s", dbfile, old_suffix); j = BIO_snprintf(buf[0], sizeof(buf[0]), "%s-%s", dbfile, new_suffix); #endif if (rename(dbfile, buf[1]) < 0 && errno != ENOENT #ifdef ENOTDIR && errno != ENOTDIR #endif ) { BIO_printf(bio_err, "Unable to rename %s to %s\n", dbfile, buf[1]); perror("reason"); goto err; } if (rename(buf[0], dbfile) < 0) { BIO_printf(bio_err, "Unable to rename %s to %s\n", buf[0], dbfile); perror("reason"); rename(buf[1], dbfile); goto err; } if (rename(buf[4], buf[3]) < 0 && errno != ENOENT #ifdef ENOTDIR && errno != ENOTDIR #endif ) { BIO_printf(bio_err, "Unable to rename %s to %s\n", buf[4], buf[3]); perror("reason"); rename(dbfile, buf[0]); rename(buf[1], dbfile); goto err; } if (rename(buf[2], buf[4]) < 0) { BIO_printf(bio_err, "Unable to rename %s to %s\n", buf[2], buf[4]); perror("reason"); rename(buf[3], buf[4]); rename(dbfile, buf[0]); rename(buf[1], dbfile); goto err; } return 1; err: ERR_print_errors(bio_err); return 0; } void free_index(CA_DB *db) { if (db) { TXT_DB_free(db->db); OPENSSL_free(db->dbfname); OPENSSL_free(db); } } int parse_yesno(const char *str, int def) { if (str) { switch (*str) { case 'f': /* false */ case 'F': /* FALSE */ case 'n': /* no */ case 'N': /* NO */ case '0': /* 0 */ return 0; case 't': /* true */ case 'T': /* TRUE */ case 'y': /* yes */ case 'Y': /* YES */ case '1': /* 1 */ return 1; } } return def; } /* * name is expected to be in the format /type0=value0/type1=value1/type2=... * where + can be used instead of / to form multi-valued RDNs if canmulti * and characters may be escaped by \ */ X509_NAME *parse_name(const char *cp, int chtype, int canmulti, const char *desc) { int nextismulti = 0; char *work; X509_NAME *n; if (*cp++ != '/') { BIO_printf(bio_err, "%s: %s name is expected to be in the format " "/type0=value0/type1=value1/type2=... where characters may " "be escaped by \\. This name is not in that format: '%s'\n", opt_getprog(), desc, --cp); return NULL; } n = X509_NAME_new(); if (n == NULL) { BIO_printf(bio_err, "%s: Out of memory\n", opt_getprog()); return NULL; } work = OPENSSL_strdup(cp); if (work == NULL) { BIO_printf(bio_err, "%s: Error copying %s name input\n", opt_getprog(), desc); goto err; } while (*cp != '\0') { char *bp = work; char *typestr = bp; unsigned char *valstr; int nid; int ismulti = nextismulti; nextismulti = 0; /* Collect the type */ while (*cp != '\0' && *cp != '=') *bp++ = *cp++; *bp++ = '\0'; if (*cp == '\0') { BIO_printf(bio_err, "%s: Missing '=' after RDN type string '%s' in %s name string\n", opt_getprog(), typestr, desc); goto err; } ++cp; /* Collect the value. */ valstr = (unsigned char *)bp; for (; *cp != '\0' && *cp != '/'; *bp++ = *cp++) { /* unescaped '+' symbol string signals further member of multiRDN */ if (canmulti && *cp == '+') { nextismulti = 1; break; } if (*cp == '\\' && *++cp == '\0') { BIO_printf(bio_err, "%s: Escape character at end of %s name string\n", opt_getprog(), desc); goto err; } } *bp++ = '\0'; /* If not at EOS (must be + or /), move forward. */ if (*cp != '\0') ++cp; /* Parse */ nid = OBJ_txt2nid(typestr); if (nid == NID_undef) { BIO_printf(bio_err, "%s warning: Skipping unknown %s name attribute \"%s\"\n", opt_getprog(), desc, typestr); if (ismulti) BIO_printf(bio_err, "%s hint: a '+' in a value string needs be escaped using '\\' else a new member of a multi-valued RDN is expected\n", opt_getprog()); continue; } if (*valstr == '\0') { BIO_printf(bio_err, "%s warning: No value provided for %s name attribute \"%s\", skipped\n", opt_getprog(), desc, typestr); continue; } if (!X509_NAME_add_entry_by_NID(n, nid, chtype, valstr, strlen((char *)valstr), -1, ismulti ? -1 : 0)) { ERR_print_errors(bio_err); BIO_printf(bio_err, "%s: Error adding %s name attribute \"/%s=%s\"\n", opt_getprog(), desc, typestr, valstr); goto err; } } OPENSSL_free(work); return n; err: X509_NAME_free(n); OPENSSL_free(work); return NULL; } /* * Read whole contents of a BIO into an allocated memory buffer and return * it. */ int bio_to_mem(unsigned char **out, int maxlen, BIO *in) { BIO *mem; int len, ret; unsigned char tbuf[1024]; mem = BIO_new(BIO_s_mem()); if (mem == NULL) return -1; for (;;) { if ((maxlen != -1) && maxlen < 1024) len = maxlen; else len = 1024; len = BIO_read(in, tbuf, len); if (len < 0) { BIO_free(mem); return -1; } if (len == 0) break; if (BIO_write(mem, tbuf, len) != len) { BIO_free(mem); return -1; } if (maxlen != -1) maxlen -= len; if (maxlen == 0) break; } ret = BIO_get_mem_data(mem, (char **)out); BIO_set_flags(mem, BIO_FLAGS_MEM_RDONLY); BIO_free(mem); return ret; } int pkey_ctrl_string(EVP_PKEY_CTX *ctx, const char *value) { int rv = 0; char *stmp, *vtmp = NULL; stmp = OPENSSL_strdup(value); if (stmp == NULL) return -1; vtmp = strchr(stmp, ':'); if (vtmp == NULL) goto err; *vtmp = 0; vtmp++; rv = EVP_PKEY_CTX_ctrl_str(ctx, stmp, vtmp); err: OPENSSL_free(stmp); return rv; } static void nodes_print(const char *name, STACK_OF(X509_POLICY_NODE) *nodes) { X509_POLICY_NODE *node; int i; BIO_printf(bio_err, "%s Policies:", name); if (nodes) { BIO_puts(bio_err, "\n"); for (i = 0; i < sk_X509_POLICY_NODE_num(nodes); i++) { node = sk_X509_POLICY_NODE_value(nodes, i); X509_POLICY_NODE_print(bio_err, node, 2); } } else { BIO_puts(bio_err, " <empty>\n"); } } void policies_print(X509_STORE_CTX *ctx) { X509_POLICY_TREE *tree; int explicit_policy; tree = X509_STORE_CTX_get0_policy_tree(ctx); explicit_policy = X509_STORE_CTX_get_explicit_policy(ctx); BIO_printf(bio_err, "Require explicit Policy: %s\n", explicit_policy ? "True" : "False"); nodes_print("Authority", X509_policy_tree_get0_policies(tree)); nodes_print("User", X509_policy_tree_get0_user_policies(tree)); } /*- * next_protos_parse parses a comma separated list of strings into a string * in a format suitable for passing to SSL_CTX_set_next_protos_advertised. * outlen: (output) set to the length of the resulting buffer on success. * err: (maybe NULL) on failure, an error message line is written to this BIO. * in: a NUL terminated string like "abc,def,ghi" * * returns: a malloc'd buffer or NULL on failure. */ unsigned char *next_protos_parse(size_t *outlen, const char *in) { size_t len; unsigned char *out; size_t i, start = 0; size_t skipped = 0; len = strlen(in); if (len == 0 || len >= 65535) return NULL; out = app_malloc(len + 1, "NPN buffer"); for (i = 0; i <= len; ++i) { if (i == len || in[i] == ',') { /* * Zero-length ALPN elements are invalid on the wire, we could be * strict and reject the entire string, but just ignoring extra * commas seems harmless and more friendly. * * Every comma we skip in this way puts the input buffer another * byte ahead of the output buffer, so all stores into the output * buffer need to be decremented by the number commas skipped. */ if (i == start) { ++start; ++skipped; continue; } if (i - start > 255) { OPENSSL_free(out); return NULL; } out[start - skipped] = (unsigned char)(i - start); start = i + 1; } else { out[i + 1 - skipped] = in[i]; } } if (len <= skipped) { OPENSSL_free(out); return NULL; } *outlen = len + 1 - skipped; return out; } int check_cert_attributes(BIO *bio, X509 *x, const char *checkhost, const char *checkemail, const char *checkip, int print) { int valid_host = 0; int valid_mail = 0; int valid_ip = 0; int ret = 1; if (x == NULL) return 0; if (checkhost != NULL) { valid_host = X509_check_host(x, checkhost, 0, 0, NULL); if (print) BIO_printf(bio, "Hostname %s does%s match certificate\n", checkhost, valid_host == 1 ? "" : " NOT"); ret = ret && valid_host; } if (checkemail != NULL) { valid_mail = X509_check_email(x, checkemail, 0, 0); if (print) BIO_printf(bio, "Email %s does%s match certificate\n", checkemail, valid_mail ? "" : " NOT"); ret = ret && valid_mail; } if (checkip != NULL) { valid_ip = X509_check_ip_asc(x, checkip, 0); if (print) BIO_printf(bio, "IP %s does%s match certificate\n", checkip, valid_ip ? "" : " NOT"); ret = ret && valid_ip; } return ret; } static int do_pkey_ctx_init(EVP_PKEY_CTX *pkctx, STACK_OF(OPENSSL_STRING) *opts) { int i; if (opts == NULL) return 1; for (i = 0; i < sk_OPENSSL_STRING_num(opts); i++) { char *opt = sk_OPENSSL_STRING_value(opts, i); if (pkey_ctrl_string(pkctx, opt) <= 0) { BIO_printf(bio_err, "parameter error \"%s\"\n", opt); ERR_print_errors(bio_err); return 0; } } return 1; } static int do_x509_init(X509 *x, STACK_OF(OPENSSL_STRING) *opts) { int i; if (opts == NULL) return 1; for (i = 0; i < sk_OPENSSL_STRING_num(opts); i++) { char *opt = sk_OPENSSL_STRING_value(opts, i); if (x509_ctrl_string(x, opt) <= 0) { BIO_printf(bio_err, "parameter error \"%s\"\n", opt); ERR_print_errors(bio_err); return 0; } } return 1; } static int do_x509_req_init(X509_REQ *x, STACK_OF(OPENSSL_STRING) *opts) { int i; if (opts == NULL) return 1; for (i = 0; i < sk_OPENSSL_STRING_num(opts); i++) { char *opt = sk_OPENSSL_STRING_value(opts, i); if (x509_req_ctrl_string(x, opt) <= 0) { BIO_printf(bio_err, "parameter error \"%s\"\n", opt); ERR_print_errors(bio_err); return 0; } } return 1; } static int do_sign_init(EVP_MD_CTX *ctx, EVP_PKEY *pkey, const char *md, STACK_OF(OPENSSL_STRING) *sigopts) { EVP_PKEY_CTX *pkctx = NULL; char def_md[80]; if (ctx == NULL) return 0; /* * EVP_PKEY_get_default_digest_name() returns 2 if the digest is mandatory * for this algorithm. */ if (EVP_PKEY_get_default_digest_name(pkey, def_md, sizeof(def_md)) == 2 && strcmp(def_md, "UNDEF") == 0) { /* The signing algorithm requires there to be no digest */ md = NULL; } return EVP_DigestSignInit_ex(ctx, &pkctx, md, app_get0_libctx(), app_get0_propq(), pkey, NULL) && do_pkey_ctx_init(pkctx, sigopts); } static int adapt_keyid_ext(X509 *cert, X509V3_CTX *ext_ctx, const char *name, const char *value, int add_default) { const STACK_OF(X509_EXTENSION) *exts = X509_get0_extensions(cert); X509_EXTENSION *new_ext = X509V3_EXT_nconf(NULL, ext_ctx, name, value); int idx, rv = 0; if (new_ext == NULL) return rv; idx = X509v3_get_ext_by_OBJ(exts, X509_EXTENSION_get_object(new_ext), -1); if (idx >= 0) { X509_EXTENSION *found_ext = X509v3_get_ext(exts, idx); ASN1_OCTET_STRING *encoded = X509_EXTENSION_get_data(found_ext); int disabled = ASN1_STRING_length(encoded) <= 2; /* indicating "none" */ if (disabled) { X509_delete_ext(cert, idx); X509_EXTENSION_free(found_ext); } /* else keep existing key identifier, which might be outdated */ rv = 1; } else { rv = !add_default || X509_add_ext(cert, new_ext, -1); } X509_EXTENSION_free(new_ext); return rv; } int cert_matches_key(const X509 *cert, const EVP_PKEY *pkey) { int match; ERR_set_mark(); match = X509_check_private_key(cert, pkey); ERR_pop_to_mark(); return match; } /* Ensure RFC 5280 compliance, adapt keyIDs as needed, and sign the cert info */ int do_X509_sign(X509 *cert, int force_v1, EVP_PKEY *pkey, const char *md, STACK_OF(OPENSSL_STRING) *sigopts, X509V3_CTX *ext_ctx) { EVP_MD_CTX *mctx = EVP_MD_CTX_new(); int self_sign; int rv = 0; if (!force_v1) { if (!X509_set_version(cert, X509_VERSION_3)) goto end; /* * Add default SKID before AKID such that AKID can make use of it * in case the certificate is self-signed */ /* Prevent X509_V_ERR_MISSING_SUBJECT_KEY_IDENTIFIER */ if (!adapt_keyid_ext(cert, ext_ctx, "subjectKeyIdentifier", "hash", 1)) goto end; /* Prevent X509_V_ERR_MISSING_AUTHORITY_KEY_IDENTIFIER */ self_sign = cert_matches_key(cert, pkey); if (!adapt_keyid_ext(cert, ext_ctx, "authorityKeyIdentifier", "keyid, issuer", !self_sign)) goto end; } /* May add further measures for ensuring RFC 5280 compliance, see #19805 */ if (mctx != NULL && do_sign_init(mctx, pkey, md, sigopts) > 0) rv = (X509_sign_ctx(cert, mctx) > 0); end: EVP_MD_CTX_free(mctx); return rv; } /* Sign the certificate request info */ int do_X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const char *md, STACK_OF(OPENSSL_STRING) *sigopts) { int rv = 0; EVP_MD_CTX *mctx = EVP_MD_CTX_new(); if (do_sign_init(mctx, pkey, md, sigopts) > 0) rv = (X509_REQ_sign_ctx(x, mctx) > 0); EVP_MD_CTX_free(mctx); return rv; } /* Sign the CRL info */ int do_X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const char *md, STACK_OF(OPENSSL_STRING) *sigopts) { int rv = 0; EVP_MD_CTX *mctx = EVP_MD_CTX_new(); if (do_sign_init(mctx, pkey, md, sigopts) > 0) rv = (X509_CRL_sign_ctx(x, mctx) > 0); EVP_MD_CTX_free(mctx); return rv; } /* * do_X509_verify returns 1 if the signature is valid, * 0 if the signature check fails, or -1 if error occurs. */ int do_X509_verify(X509 *x, EVP_PKEY *pkey, STACK_OF(OPENSSL_STRING) *vfyopts) { int rv = 0; if (do_x509_init(x, vfyopts) > 0) rv = X509_verify(x, pkey); else rv = -1; return rv; } /* * do_X509_REQ_verify returns 1 if the signature is valid, * 0 if the signature check fails, or -1 if error occurs. */ int do_X509_REQ_verify(X509_REQ *x, EVP_PKEY *pkey, STACK_OF(OPENSSL_STRING) *vfyopts) { int rv = 0; if (do_x509_req_init(x, vfyopts) > 0) rv = X509_REQ_verify_ex(x, pkey, app_get0_libctx(), app_get0_propq()); else rv = -1; return rv; } /* Get first http URL from a DIST_POINT structure */ static const char *get_dp_url(DIST_POINT *dp) { GENERAL_NAMES *gens; GENERAL_NAME *gen; int i, gtype; ASN1_STRING *uri; if (!dp->distpoint || dp->distpoint->type != 0) return NULL; gens = dp->distpoint->name.fullname; for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) { gen = sk_GENERAL_NAME_value(gens, i); uri = GENERAL_NAME_get0_value(gen, &gtype); if (gtype == GEN_URI && ASN1_STRING_length(uri) > 6) { const char *uptr = (const char *)ASN1_STRING_get0_data(uri); if (IS_HTTP(uptr)) /* can/should not use HTTPS here */ return uptr; } } return NULL; } /* * Look through a CRLDP structure and attempt to find an http URL to * downloads a CRL from. */ static X509_CRL *load_crl_crldp(STACK_OF(DIST_POINT) *crldp) { int i; const char *urlptr = NULL; for (i = 0; i < sk_DIST_POINT_num(crldp); i++) { DIST_POINT *dp = sk_DIST_POINT_value(crldp, i); urlptr = get_dp_url(dp); if (urlptr != NULL) return load_crl(urlptr, FORMAT_UNDEF, 0, "CRL via CDP"); } return NULL; } /* * Example of downloading CRLs from CRLDP: * not usable for real world as it always downloads and doesn't cache anything. */ static STACK_OF(X509_CRL) *crls_http_cb(const X509_STORE_CTX *ctx, const X509_NAME *nm) { X509 *x; STACK_OF(X509_CRL) *crls = NULL; X509_CRL *crl; STACK_OF(DIST_POINT) *crldp; crls = sk_X509_CRL_new_null(); if (!crls) return NULL; x = X509_STORE_CTX_get_current_cert(ctx); crldp = X509_get_ext_d2i(x, NID_crl_distribution_points, NULL, NULL); crl = load_crl_crldp(crldp); sk_DIST_POINT_pop_free(crldp, DIST_POINT_free); if (!crl) { sk_X509_CRL_free(crls); return NULL; } sk_X509_CRL_push(crls, crl); /* Try to download delta CRL */ crldp = X509_get_ext_d2i(x, NID_freshest_crl, NULL, NULL); crl = load_crl_crldp(crldp); sk_DIST_POINT_pop_free(crldp, DIST_POINT_free); if (crl) sk_X509_CRL_push(crls, crl); return crls; } void store_setup_crl_download(X509_STORE *st) { X509_STORE_set_lookup_crls_cb(st, crls_http_cb); } #if !defined(OPENSSL_NO_SOCK) && !defined(OPENSSL_NO_HTTP) static const char *tls_error_hint(void) { unsigned long err = ERR_peek_error(); if (ERR_GET_LIB(err) != ERR_LIB_SSL) err = ERR_peek_last_error(); if (ERR_GET_LIB(err) != ERR_LIB_SSL) return NULL; /* likely no TLS error */ switch (ERR_GET_REASON(err)) { case SSL_R_WRONG_VERSION_NUMBER: return "The server does not support (a suitable version of) TLS"; case SSL_R_UNKNOWN_PROTOCOL: return "The server does not support HTTPS"; case SSL_R_CERTIFICATE_VERIFY_FAILED: return "Cannot authenticate server via its TLS certificate, likely due to mismatch with our trusted TLS certs or missing revocation status"; case SSL_AD_REASON_OFFSET + TLS1_AD_UNKNOWN_CA: return "Server did not accept our TLS certificate, likely due to mismatch with server's trust anchor or missing revocation status"; case SSL_AD_REASON_OFFSET + SSL3_AD_HANDSHAKE_FAILURE: return "TLS handshake failure. Possibly the server requires our TLS certificate but did not receive it"; default: return NULL; /* no hint available for TLS error */ } } static BIO *http_tls_shutdown(BIO *bio) { if (bio != NULL) { BIO *cbio; const char *hint = tls_error_hint(); if (hint != NULL) BIO_printf(bio_err, "%s\n", hint); (void)ERR_set_mark(); BIO_ssl_shutdown(bio); cbio = BIO_pop(bio); /* connect+HTTP BIO */ BIO_free(bio); /* SSL BIO */ (void)ERR_pop_to_mark(); /* hide SSL_R_READ_BIO_NOT_SET etc. */ bio = cbio; } return bio; } /* HTTP callback function that supports TLS connection also via HTTPS proxy */ BIO *app_http_tls_cb(BIO *bio, void *arg, int connect, int detail) { APP_HTTP_TLS_INFO *info = (APP_HTTP_TLS_INFO *)arg; SSL_CTX *ssl_ctx = info->ssl_ctx; if (ssl_ctx == NULL) /* not using TLS */ return bio; if (connect) { SSL *ssl; BIO *sbio = NULL; X509_STORE *ts = SSL_CTX_get_cert_store(ssl_ctx); X509_VERIFY_PARAM *vpm = X509_STORE_get0_param(ts); const char *host = vpm == NULL ? NULL : X509_VERIFY_PARAM_get0_host(vpm, 0 /* first hostname */); /* adapt after fixing callback design flaw, see #17088 */ if ((info->use_proxy && !OSSL_HTTP_proxy_connect(bio, info->server, info->port, NULL, NULL, /* no proxy credentials */ info->timeout, bio_err, opt_getprog())) || (sbio = BIO_new(BIO_f_ssl())) == NULL) { return NULL; } if ((ssl = SSL_new(ssl_ctx)) == NULL) { BIO_free(sbio); return NULL; } if (vpm != NULL) SSL_set_tlsext_host_name(ssl, host /* may be NULL */); SSL_set_connect_state(ssl); BIO_set_ssl(sbio, ssl, BIO_CLOSE); bio = BIO_push(sbio, bio); } else { /* disconnect from TLS */ bio = http_tls_shutdown(bio); } return bio; } void APP_HTTP_TLS_INFO_free(APP_HTTP_TLS_INFO *info) { if (info != NULL) { SSL_CTX_free(info->ssl_ctx); OPENSSL_free(info); } } ASN1_VALUE *app_http_get_asn1(const char *url, const char *proxy, const char *no_proxy, SSL_CTX *ssl_ctx, const STACK_OF(CONF_VALUE) *headers, long timeout, const char *expected_content_type, const ASN1_ITEM *it) { APP_HTTP_TLS_INFO info; char *server; char *port; int use_ssl; BIO *mem; ASN1_VALUE *resp = NULL; if (url == NULL || it == NULL) { ERR_raise(ERR_LIB_HTTP, ERR_R_PASSED_NULL_PARAMETER); return NULL; } if (!OSSL_HTTP_parse_url(url, &use_ssl, NULL /* userinfo */, &server, &port, NULL /* port_num, */, NULL, NULL, NULL)) return NULL; if (use_ssl && ssl_ctx == NULL) { ERR_raise_data(ERR_LIB_HTTP, ERR_R_PASSED_NULL_PARAMETER, "missing SSL_CTX"); goto end; } if (!use_ssl && ssl_ctx != NULL) { ERR_raise_data(ERR_LIB_HTTP, ERR_R_PASSED_INVALID_ARGUMENT, "SSL_CTX given but use_ssl == 0"); goto end; } info.server = server; info.port = port; info.use_proxy = /* workaround for callback design flaw, see #17088 */ OSSL_HTTP_adapt_proxy(proxy, no_proxy, server, use_ssl) != NULL; info.timeout = timeout; info.ssl_ctx = ssl_ctx; mem = OSSL_HTTP_get(url, proxy, no_proxy, NULL /* bio */, NULL /* rbio */, app_http_tls_cb, &info, 0 /* buf_size */, headers, expected_content_type, 1 /* expect_asn1 */, OSSL_HTTP_DEFAULT_MAX_RESP_LEN, timeout); resp = ASN1_item_d2i_bio(it, mem, NULL); BIO_free(mem); end: OPENSSL_free(server); OPENSSL_free(port); return resp; } ASN1_VALUE *app_http_post_asn1(const char *host, const char *port, const char *path, const char *proxy, const char *no_proxy, SSL_CTX *ssl_ctx, const STACK_OF(CONF_VALUE) *headers, const char *content_type, ASN1_VALUE *req, const ASN1_ITEM *req_it, const char *expected_content_type, long timeout, const ASN1_ITEM *rsp_it) { int use_ssl = ssl_ctx != NULL; APP_HTTP_TLS_INFO info; BIO *rsp, *req_mem = ASN1_item_i2d_mem_bio(req_it, req); ASN1_VALUE *res; if (req_mem == NULL) return NULL; info.server = host; info.port = port; info.use_proxy = /* workaround for callback design flaw, see #17088 */ OSSL_HTTP_adapt_proxy(proxy, no_proxy, host, use_ssl) != NULL; info.timeout = timeout; info.ssl_ctx = ssl_ctx; rsp = OSSL_HTTP_transfer(NULL, host, port, path, use_ssl, proxy, no_proxy, NULL /* bio */, NULL /* rbio */, app_http_tls_cb, &info, 0 /* buf_size */, headers, content_type, req_mem, expected_content_type, 1 /* expect_asn1 */, OSSL_HTTP_DEFAULT_MAX_RESP_LEN, timeout, 0 /* keep_alive */); BIO_free(req_mem); res = ASN1_item_d2i_bio(rsp_it, rsp, NULL); BIO_free(rsp); return res; } #endif /* * Platform-specific sections */ #if defined(_WIN32) # ifdef fileno # undef fileno # define fileno(a) (int)_fileno(a) # endif # include <windows.h> # include <tchar.h> static int WIN32_rename(const char *from, const char *to) { TCHAR *tfrom = NULL, *tto; DWORD err; int ret = 0; if (sizeof(TCHAR) == 1) { tfrom = (TCHAR *)from; tto = (TCHAR *)to; } else { /* UNICODE path */ size_t i, flen = strlen(from) + 1, tlen = strlen(to) + 1; tfrom = malloc(sizeof(*tfrom) * (flen + tlen)); if (tfrom == NULL) goto err; tto = tfrom + flen; # if !defined(_WIN32_WCE) || _WIN32_WCE >= 101 if (!MultiByteToWideChar(CP_ACP, 0, from, flen, (WCHAR *)tfrom, flen)) # endif for (i = 0; i < flen; i++) tfrom[i] = (TCHAR)from[i]; # if !defined(_WIN32_WCE) || _WIN32_WCE >= 101 if (!MultiByteToWideChar(CP_ACP, 0, to, tlen, (WCHAR *)tto, tlen)) # endif for (i = 0; i < tlen; i++) tto[i] = (TCHAR)to[i]; } if (MoveFile(tfrom, tto)) goto ok; err = GetLastError(); if (err == ERROR_ALREADY_EXISTS || err == ERROR_FILE_EXISTS) { if (DeleteFile(tto) && MoveFile(tfrom, tto)) goto ok; err = GetLastError(); } if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND) errno = ENOENT; else if (err == ERROR_ACCESS_DENIED) errno = EACCES; else errno = EINVAL; /* we could map more codes... */ err: ret = -1; ok: if (tfrom != NULL && tfrom != (TCHAR *)from) free(tfrom); return ret; } #endif /* app_tminterval section */ #if defined(_WIN32) double app_tminterval(int stop, int usertime) { FILETIME now; double ret = 0; static ULARGE_INTEGER tmstart; static int warning = 1; int use_GetSystemTime = 1; # ifdef _WIN32_WINNT static HANDLE proc = NULL; if (proc == NULL) { if (check_winnt()) proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId()); if (proc == NULL) proc = (HANDLE) - 1; } if (usertime && proc != (HANDLE) - 1) { FILETIME junk; GetProcessTimes(proc, &junk, &junk, &junk, &now); use_GetSystemTime = 0; } # endif if (use_GetSystemTime) { SYSTEMTIME systime; if (usertime && warning) { BIO_printf(bio_err, "To get meaningful results, run " "this program on idle system.\n"); warning = 0; } GetSystemTime(&systime); SystemTimeToFileTime(&systime, &now); } if (stop == TM_START) { tmstart.u.LowPart = now.dwLowDateTime; tmstart.u.HighPart = now.dwHighDateTime; } else { ULARGE_INTEGER tmstop; tmstop.u.LowPart = now.dwLowDateTime; tmstop.u.HighPart = now.dwHighDateTime; ret = (__int64)(tmstop.QuadPart - tmstart.QuadPart) * 1e-7; } return ret; } #elif defined(OPENSSL_SYS_VXWORKS) # include <time.h> double app_tminterval(int stop, int usertime) { double ret = 0; # ifdef CLOCK_REALTIME static struct timespec tmstart; struct timespec now; # else static unsigned long tmstart; unsigned long now; # endif static int warning = 1; if (usertime && warning) { BIO_printf(bio_err, "To get meaningful results, run " "this program on idle system.\n"); warning = 0; } # ifdef CLOCK_REALTIME clock_gettime(CLOCK_REALTIME, &now); if (stop == TM_START) tmstart = now; else ret = ((now.tv_sec + now.tv_nsec * 1e-9) - (tmstart.tv_sec + tmstart.tv_nsec * 1e-9)); # else now = tickGet(); if (stop == TM_START) tmstart = now; else ret = (now - tmstart) / (double)sysClkRateGet(); # endif return ret; } #elif defined(_SC_CLK_TCK) /* by means of unistd.h */ # include <sys/times.h> double app_tminterval(int stop, int usertime) { double ret = 0; struct tms rus; clock_t now = times(&rus); static clock_t tmstart; if (usertime) now = rus.tms_utime; if (stop == TM_START) { tmstart = now; } else { long int tck = sysconf(_SC_CLK_TCK); ret = (now - tmstart) / (double)tck; } return ret; } #else # include <sys/time.h> # include <sys/resource.h> double app_tminterval(int stop, int usertime) { double ret = 0; struct rusage rus; struct timeval now; static struct timeval tmstart; if (usertime) getrusage(RUSAGE_SELF, &rus), now = rus.ru_utime; else gettimeofday(&now, NULL); if (stop == TM_START) tmstart = now; else ret = ((now.tv_sec + now.tv_usec * 1e-6) - (tmstart.tv_sec + tmstart.tv_usec * 1e-6)); return ret; } #endif int app_access(const char *name, int flag) { #ifdef _WIN32 return _access(name, flag); #else return access(name, flag); #endif } int app_isdir(const char *name) { return opt_isdir(name); } /* raw_read|write section */ #if defined(__VMS) # include "vms_term_sock.h" static int stdin_sock = -1; static void close_stdin_sock(void) { TerminalSocket(TERM_SOCK_DELETE, &stdin_sock); } int fileno_stdin(void) { if (stdin_sock == -1) { TerminalSocket(TERM_SOCK_CREATE, &stdin_sock); atexit(close_stdin_sock); } return stdin_sock; } #else int fileno_stdin(void) { return fileno(stdin); } #endif int fileno_stdout(void) { return fileno(stdout); } #if defined(_WIN32) && defined(STD_INPUT_HANDLE) int raw_read_stdin(void *buf, int siz) { DWORD n; if (ReadFile(GetStdHandle(STD_INPUT_HANDLE), buf, siz, &n, NULL)) return n; else return -1; } #elif defined(__VMS) # include <sys/socket.h> int raw_read_stdin(void *buf, int siz) { return recv(fileno_stdin(), buf, siz, 0); } #else # if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_read)> # endif # endif int raw_read_stdin(void *buf, int siz) { return read(fileno_stdin(), buf, siz); } #endif #if defined(_WIN32) && defined(STD_OUTPUT_HANDLE) int raw_write_stdout(const void *buf, int siz) { DWORD n; if (WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, siz, &n, NULL)) return n; else return -1; } #elif defined(OPENSSL_SYS_TANDEM) && defined(OPENSSL_THREADS) \ && defined(_SPT_MODEL_) # if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_write)> # endif # endif int raw_write_stdout(const void *buf, int siz) { return write(fileno(stdout), (void *)buf, siz); } #else # if defined(__TANDEM) # if defined(OPENSSL_TANDEM_FLOSS) # include <floss.h(floss_write)> # endif # endif int raw_write_stdout(const void *buf, int siz) { return write(fileno_stdout(), buf, siz); } #endif /* * Centralized handling of input and output files with format specification * The format is meant to show what the input and output is supposed to be, * and is therefore a show of intent more than anything else. However, it * does impact behavior on some platforms, such as differentiating between * text and binary input/output on non-Unix platforms */ BIO *dup_bio_in(int format) { return BIO_new_fp(stdin, BIO_NOCLOSE | (FMT_istext(format) ? BIO_FP_TEXT : 0)); } BIO *dup_bio_out(int format) { BIO *b = BIO_new_fp(stdout, BIO_NOCLOSE | (FMT_istext(format) ? BIO_FP_TEXT : 0)); void *prefix = NULL; if (b == NULL) return NULL; #ifdef OPENSSL_SYS_VMS if (FMT_istext(format)) b = BIO_push(BIO_new(BIO_f_linebuffer()), b); #endif if (FMT_istext(format) && (prefix = getenv("HARNESS_OSSL_PREFIX")) != NULL) { b = BIO_push(BIO_new(BIO_f_prefix()), b); BIO_set_prefix(b, prefix); } return b; } BIO *dup_bio_err(int format) { BIO *b = BIO_new_fp(stderr, BIO_NOCLOSE | (FMT_istext(format) ? BIO_FP_TEXT : 0)); #ifdef OPENSSL_SYS_VMS if (b != NULL && FMT_istext(format)) b = BIO_push(BIO_new(BIO_f_linebuffer()), b); #endif return b; } void unbuffer(FILE *fp) { /* * On VMS, setbuf() will only take 32-bit pointers, and a compilation * with /POINTER_SIZE=64 will give off a MAYLOSEDATA2 warning here. * However, we trust that the C RTL will never give us a FILE pointer * above the first 4 GB of memory, so we simply turn off the warning * temporarily. */ #if defined(OPENSSL_SYS_VMS) && defined(__DECC) # pragma environment save # pragma message disable maylosedata2 #endif setbuf(fp, NULL); #if defined(OPENSSL_SYS_VMS) && defined(__DECC) # pragma environment restore #endif } static const char *modestr(char mode, int format) { OPENSSL_assert(mode == 'a' || mode == 'r' || mode == 'w'); switch (mode) { case 'a': return FMT_istext(format) ? "a" : "ab"; case 'r': return FMT_istext(format) ? "r" : "rb"; case 'w': return FMT_istext(format) ? "w" : "wb"; } /* The assert above should make sure we never reach this point */ return NULL; } static const char *modeverb(char mode) { switch (mode) { case 'a': return "appending"; case 'r': return "reading"; case 'w': return "writing"; } return "(doing something)"; } /* * Open a file for writing, owner-read-only. */ BIO *bio_open_owner(const char *filename, int format, int private) { FILE *fp = NULL; BIO *b = NULL; int textmode, bflags; #ifndef OPENSSL_NO_POSIX_IO int fd = -1, mode; #endif if (!private || filename == NULL || strcmp(filename, "-") == 0) return bio_open_default(filename, 'w', format); textmode = FMT_istext(format); #ifndef OPENSSL_NO_POSIX_IO mode = O_WRONLY; # ifdef O_CREAT mode |= O_CREAT; # endif # ifdef O_TRUNC mode |= O_TRUNC; # endif if (!textmode) { # ifdef O_BINARY mode |= O_BINARY; # elif defined(_O_BINARY) mode |= _O_BINARY; # endif } # ifdef OPENSSL_SYS_VMS /* * VMS doesn't have O_BINARY, it just doesn't make sense. But, * it still needs to know that we're going binary, or fdopen() * will fail with "invalid argument"... so we tell VMS what the * context is. */ if (!textmode) fd = open(filename, mode, 0600, "ctx=bin"); else # endif fd = open(filename, mode, 0600); if (fd < 0) goto err; fp = fdopen(fd, modestr('w', format)); #else /* OPENSSL_NO_POSIX_IO */ /* Have stdio but not Posix IO, do the best we can */ fp = fopen(filename, modestr('w', format)); #endif /* OPENSSL_NO_POSIX_IO */ if (fp == NULL) goto err; bflags = BIO_CLOSE; if (textmode) bflags |= BIO_FP_TEXT; b = BIO_new_fp(fp, bflags); if (b != NULL) return b; err: BIO_printf(bio_err, "%s: Can't open \"%s\" for writing, %s\n", opt_getprog(), filename, strerror(errno)); ERR_print_errors(bio_err); /* If we have fp, then fdopen took over fd, so don't close both. */ if (fp != NULL) fclose(fp); #ifndef OPENSSL_NO_POSIX_IO else if (fd >= 0) close(fd); #endif return NULL; } static BIO *bio_open_default_(const char *filename, char mode, int format, int quiet) { BIO *ret; if (filename == NULL || strcmp(filename, "-") == 0) { ret = mode == 'r' ? dup_bio_in(format) : dup_bio_out(format); if (quiet) { ERR_clear_error(); return ret; } if (ret != NULL) return ret; BIO_printf(bio_err, "Can't open %s, %s\n", mode == 'r' ? "stdin" : "stdout", strerror(errno)); } else { ret = BIO_new_file(filename, modestr(mode, format)); if (quiet) { ERR_clear_error(); return ret; } if (ret != NULL) return ret; BIO_printf(bio_err, "Can't open \"%s\" for %s, %s\n", filename, modeverb(mode), strerror(errno)); } ERR_print_errors(bio_err); return NULL; } BIO *bio_open_default(const char *filename, char mode, int format) { return bio_open_default_(filename, mode, format, 0); } BIO *bio_open_default_quiet(const char *filename, char mode, int format) { return bio_open_default_(filename, mode, format, 1); } void wait_for_async(SSL *s) { /* On Windows select only works for sockets, so we simply don't wait */ #ifndef OPENSSL_SYS_WINDOWS int width = 0; fd_set asyncfds; OSSL_ASYNC_FD *fds; size_t numfds; size_t i; if (!SSL_get_all_async_fds(s, NULL, &numfds)) return; if (numfds == 0) return; fds = app_malloc(sizeof(OSSL_ASYNC_FD) * numfds, "allocate async fds"); if (!SSL_get_all_async_fds(s, fds, &numfds)) { OPENSSL_free(fds); return; } FD_ZERO(&asyncfds); for (i = 0; i < numfds; i++) { if (width <= (int)fds[i]) width = (int)fds[i] + 1; openssl_fdset((int)fds[i], &asyncfds); } select(width, (void *)&asyncfds, NULL, NULL, NULL); OPENSSL_free(fds); #endif } /* if OPENSSL_SYS_WINDOWS is defined then so is OPENSSL_SYS_MSDOS */ #if defined(OPENSSL_SYS_MSDOS) int has_stdin_waiting(void) { # if defined(OPENSSL_SYS_WINDOWS) HANDLE inhand = GetStdHandle(STD_INPUT_HANDLE); DWORD events = 0; INPUT_RECORD inputrec; DWORD insize = 1; BOOL peeked; if (inhand == INVALID_HANDLE_VALUE) { return 0; } peeked = PeekConsoleInput(inhand, &inputrec, insize, &events); if (!peeked) { /* Probably redirected input? _kbhit() does not work in this case */ if (!feof(stdin)) { return 1; } return 0; } # endif return _kbhit(); } #endif /* Corrupt a signature by modifying final byte */ void corrupt_signature(const ASN1_STRING *signature) { unsigned char *s = signature->data; s[signature->length - 1] ^= 0x1; } int set_cert_times(X509 *x, const char *startdate, const char *enddate, int days) { if (startdate == NULL || strcmp(startdate, "today") == 0) { if (X509_gmtime_adj(X509_getm_notBefore(x), 0) == NULL) return 0; } else { if (!ASN1_TIME_set_string_X509(X509_getm_notBefore(x), startdate)) return 0; } if (enddate == NULL) { if (X509_time_adj_ex(X509_getm_notAfter(x), days, 0, NULL) == NULL) return 0; } else if (!ASN1_TIME_set_string_X509(X509_getm_notAfter(x), enddate)) { return 0; } return 1; } int set_crl_lastupdate(X509_CRL *crl, const char *lastupdate) { int ret = 0; ASN1_TIME *tm = ASN1_TIME_new(); if (tm == NULL) goto end; if (lastupdate == NULL) { if (X509_gmtime_adj(tm, 0) == NULL) goto end; } else { if (!ASN1_TIME_set_string_X509(tm, lastupdate)) goto end; } if (!X509_CRL_set1_lastUpdate(crl, tm)) goto end; ret = 1; end: ASN1_TIME_free(tm); return ret; } int set_crl_nextupdate(X509_CRL *crl, const char *nextupdate, long days, long hours, long secs) { int ret = 0; ASN1_TIME *tm = ASN1_TIME_new(); if (tm == NULL) goto end; if (nextupdate == NULL) { if (X509_time_adj_ex(tm, days, hours * 60 * 60 + secs, NULL) == NULL) goto end; } else { if (!ASN1_TIME_set_string_X509(tm, nextupdate)) goto end; } if (!X509_CRL_set1_nextUpdate(crl, tm)) goto end; ret = 1; end: ASN1_TIME_free(tm); return ret; } void make_uppercase(char *string) { int i; for (i = 0; string[i] != '\0'; i++) string[i] = toupper((unsigned char)string[i]); } OSSL_PARAM *app_params_new_from_opts(STACK_OF(OPENSSL_STRING) *opts, const OSSL_PARAM *paramdefs) { OSSL_PARAM *params = NULL; size_t sz = (size_t)sk_OPENSSL_STRING_num(opts); size_t params_n; char *opt = "", *stmp, *vtmp = NULL; int found = 1; if (opts == NULL) return NULL; params = OPENSSL_zalloc(sizeof(OSSL_PARAM) * (sz + 1)); if (params == NULL) return NULL; for (params_n = 0; params_n < sz; params_n++) { opt = sk_OPENSSL_STRING_value(opts, (int)params_n); if ((stmp = OPENSSL_strdup(opt)) == NULL || (vtmp = strchr(stmp, ':')) == NULL) goto err; /* Replace ':' with 0 to terminate the string pointed to by stmp */ *vtmp = 0; /* Skip over the separator so that vmtp points to the value */ vtmp++; if (!OSSL_PARAM_allocate_from_text(&params[params_n], paramdefs, stmp, vtmp, strlen(vtmp), &found)) goto err; OPENSSL_free(stmp); } params[params_n] = OSSL_PARAM_construct_end(); return params; err: OPENSSL_free(stmp); BIO_printf(bio_err, "Parameter %s '%s'\n", found ? "error" : "unknown", opt); ERR_print_errors(bio_err); app_params_free(params); return NULL; } void app_params_free(OSSL_PARAM *params) { int i; if (params != NULL) { for (i = 0; params[i].key != NULL; ++i) OPENSSL_free(params[i].data); OPENSSL_free(params); } } EVP_PKEY *app_keygen(EVP_PKEY_CTX *ctx, const char *alg, int bits, int verbose) { EVP_PKEY *res = NULL; if (verbose && alg != NULL) { BIO_printf(bio_err, "Generating %s key", alg); if (bits > 0) BIO_printf(bio_err, " with %d bits\n", bits); else BIO_printf(bio_err, "\n"); } if (!RAND_status()) BIO_printf(bio_err, "Warning: generating random key material may take a long time\n" "if the system has a poor entropy source\n"); if (EVP_PKEY_keygen(ctx, &res) <= 0) BIO_printf(bio_err, "%s: Error generating %s key\n", opt_getprog(), alg != NULL ? alg : "asymmetric"); return res; } EVP_PKEY *app_paramgen(EVP_PKEY_CTX *ctx, const char *alg) { EVP_PKEY *res = NULL; if (!RAND_status()) BIO_printf(bio_err, "Warning: generating random key parameters may take a long time\n" "if the system has a poor entropy source\n"); if (EVP_PKEY_paramgen(ctx, &res) <= 0) BIO_printf(bio_err, "%s: Generating %s key parameters failed\n", opt_getprog(), alg != NULL ? alg : "asymmetric"); return res; } /* * Return non-zero if the legacy path is still an option. * This decision is based on the global command line operations and the * behaviour thus far. */ int opt_legacy_okay(void) { int provider_options = opt_provider_option_given(); int libctx = app_get0_libctx() != NULL || app_get0_propq() != NULL; /* * Having a provider option specified or a custom library context or * property query, is a sure sign we're not using legacy. */ if (provider_options || libctx) return 0; return 1; }

./openssl/apps/lib/app_rand.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "apps.h" #include <openssl/bio.h> #include <openssl/err.h> #include <openssl/rand.h> #include <openssl/conf.h> static char *save_rand_file; static STACK_OF(OPENSSL_STRING) *randfiles; void app_RAND_load_conf(CONF *c, const char *section) { const char *randfile = app_conf_try_string(c, section, "RANDFILE"); if (randfile == NULL) return; if (RAND_load_file(randfile, -1) < 0) { BIO_printf(bio_err, "Can't load %s into RNG\n", randfile); ERR_print_errors(bio_err); } if (save_rand_file == NULL) { save_rand_file = OPENSSL_strdup(randfile); /* If some internal memory errors have occurred */ if (save_rand_file == NULL) { BIO_printf(bio_err, "Can't duplicate %s\n", randfile); ERR_print_errors(bio_err); } } } static int loadfiles(char *name) { char *p; int last, ret = 1; for (;;) { last = 0; for (p = name; *p != '\0' && *p != LIST_SEPARATOR_CHAR; p++) continue; if (*p == '\0') last = 1; *p = '\0'; if (RAND_load_file(name, -1) < 0) { BIO_printf(bio_err, "Can't load %s into RNG\n", name); ERR_print_errors(bio_err); ret = 0; } if (last) break; name = p + 1; if (*name == '\0') break; } return ret; } int app_RAND_load(void) { char *p; int i, ret = 1; for (i = 0; i < sk_OPENSSL_STRING_num(randfiles); i++) { p = sk_OPENSSL_STRING_value(randfiles, i); if (!loadfiles(p)) ret = 0; } sk_OPENSSL_STRING_free(randfiles); return ret; } int app_RAND_write(void) { int ret = 1; if (save_rand_file == NULL) return 1; if (RAND_write_file(save_rand_file) == -1) { BIO_printf(bio_err, "Cannot write random bytes:\n"); ERR_print_errors(bio_err); ret = 0; } OPENSSL_free(save_rand_file); save_rand_file = NULL; return ret; } /* * See comments in opt_verify for explanation of this. */ enum r_range { OPT_R_ENUM }; int opt_rand(int opt) { switch ((enum r_range)opt) { case OPT_R__FIRST: case OPT_R__LAST: break; case OPT_R_RAND: if (randfiles == NULL && (randfiles = sk_OPENSSL_STRING_new_null()) == NULL) return 0; if (!sk_OPENSSL_STRING_push(randfiles, opt_arg())) return 0; break; case OPT_R_WRITERAND: OPENSSL_free(save_rand_file); save_rand_file = OPENSSL_strdup(opt_arg()); if (save_rand_file == NULL) return 0; break; } return 1; }

./openssl/apps/lib/apps_ui.c

/* * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <string.h> #include <openssl/err.h> #include <openssl/ui.h> #include "apps_ui.h" static UI_METHOD *ui_method = NULL; static const UI_METHOD *ui_base_method = NULL; static int ui_open(UI *ui) { int (*opener)(UI *ui) = UI_method_get_opener(ui_base_method); if (opener != NULL) return opener(ui); return 1; } static int ui_read(UI *ui, UI_STRING *uis) { int (*reader)(UI *ui, UI_STRING *uis) = NULL; if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD && UI_get0_user_data(ui)) { switch (UI_get_string_type(uis)) { case UIT_PROMPT: case UIT_VERIFY: { const char *password = ((PW_CB_DATA *)UI_get0_user_data(ui))->password; if (password != NULL) { UI_set_result(ui, uis, password); return 1; } } break; case UIT_NONE: case UIT_BOOLEAN: case UIT_INFO: case UIT_ERROR: break; } } reader = UI_method_get_reader(ui_base_method); if (reader != NULL) return reader(ui, uis); /* Default to the empty password if we've got nothing better */ UI_set_result(ui, uis, ""); return 1; } static int ui_write(UI *ui, UI_STRING *uis) { int (*writer)(UI *ui, UI_STRING *uis) = NULL; if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD && UI_get0_user_data(ui)) { switch (UI_get_string_type(uis)) { case UIT_PROMPT: case UIT_VERIFY: { const char *password = ((PW_CB_DATA *)UI_get0_user_data(ui))->password; if (password != NULL) return 1; } break; case UIT_NONE: case UIT_BOOLEAN: case UIT_INFO: case UIT_ERROR: break; } } writer = UI_method_get_writer(ui_base_method); if (writer != NULL) return writer(ui, uis); return 1; } static int ui_close(UI *ui) { int (*closer)(UI *ui) = UI_method_get_closer(ui_base_method); if (closer != NULL) return closer(ui); return 1; } /* object_name defaults to prompt_info from ui user data if present */ static char *ui_prompt_construct(UI *ui, const char *phrase_desc, const char *object_name) { PW_CB_DATA *cb_data = (PW_CB_DATA *)UI_get0_user_data(ui); if (phrase_desc == NULL) phrase_desc = "pass phrase"; if (object_name == NULL && cb_data != NULL) object_name = cb_data->prompt_info; return UI_construct_prompt(NULL, phrase_desc, object_name); } int set_base_ui_method(const UI_METHOD *ui_meth) { if (ui_meth == NULL) ui_meth = UI_null(); ui_base_method = ui_meth; return 1; } int setup_ui_method(void) { ui_base_method = UI_null(); #ifndef OPENSSL_NO_UI_CONSOLE ui_base_method = UI_OpenSSL(); #endif ui_method = UI_create_method("OpenSSL application user interface"); return ui_method != NULL && 0 == UI_method_set_opener(ui_method, ui_open) && 0 == UI_method_set_reader(ui_method, ui_read) && 0 == UI_method_set_writer(ui_method, ui_write) && 0 == UI_method_set_closer(ui_method, ui_close) && 0 == UI_method_set_prompt_constructor(ui_method, ui_prompt_construct); } void destroy_ui_method(void) { if (ui_method != NULL) { UI_destroy_method(ui_method); ui_method = NULL; } } const UI_METHOD *get_ui_method(void) { return ui_method; } static void *ui_malloc(int sz, const char *what) { void *vp = OPENSSL_malloc(sz); if (vp == NULL) { BIO_printf(bio_err, "Could not allocate %d bytes for %s\n", sz, what); ERR_print_errors(bio_err); exit(1); } return vp; } int password_callback(char *buf, int bufsiz, int verify, PW_CB_DATA *cb_data) { int res = 0; UI *ui; int ok = 0; char *buff = NULL; int ui_flags = 0; const char *prompt_info = NULL; char *prompt; if ((ui = UI_new_method(ui_method)) == NULL) return 0; if (cb_data != NULL && cb_data->prompt_info != NULL) prompt_info = cb_data->prompt_info; prompt = UI_construct_prompt(ui, "pass phrase", prompt_info); if (prompt == NULL) { BIO_printf(bio_err, "Out of memory\n"); UI_free(ui); return 0; } ui_flags |= UI_INPUT_FLAG_DEFAULT_PWD; UI_ctrl(ui, UI_CTRL_PRINT_ERRORS, 1, 0, 0); /* We know that there is no previous user data to return to us */ (void)UI_add_user_data(ui, cb_data); ok = UI_add_input_string(ui, prompt, ui_flags, buf, PW_MIN_LENGTH, bufsiz - 1); if (ok >= 0 && verify) { buff = ui_malloc(bufsiz, "password buffer"); ok = UI_add_verify_string(ui, prompt, ui_flags, buff, PW_MIN_LENGTH, bufsiz - 1, buf); } if (ok >= 0) do { ok = UI_process(ui); } while (ok < 0 && UI_ctrl(ui, UI_CTRL_IS_REDOABLE, 0, 0, 0)); OPENSSL_clear_free(buff, (unsigned int)bufsiz); if (ok >= 0) res = strlen(buf); if (ok == -1) { BIO_printf(bio_err, "User interface error\n"); ERR_print_errors(bio_err); OPENSSL_cleanse(buf, (unsigned int)bufsiz); res = 0; } if (ok == -2) { BIO_printf(bio_err, "aborted!\n"); OPENSSL_cleanse(buf, (unsigned int)bufsiz); res = 0; } UI_free(ui); OPENSSL_free(prompt); return res; }

./openssl/apps/lib/app_params.c

/* * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "apps.h" #include "app_params.h" static int describe_param_type(char *buf, size_t bufsz, const OSSL_PARAM *param) { const char *type_mod = ""; const char *type = NULL; int show_type_number = 0; int printed_len; switch (param->data_type) { case OSSL_PARAM_UNSIGNED_INTEGER: type_mod = "unsigned "; /* FALLTHRU */ case OSSL_PARAM_INTEGER: type = "integer"; break; case OSSL_PARAM_UTF8_PTR: type_mod = "pointer to a "; /* FALLTHRU */ case OSSL_PARAM_UTF8_STRING: type = "UTF8 encoded string"; break; case OSSL_PARAM_OCTET_PTR: type_mod = "pointer to an "; /* FALLTHRU */ case OSSL_PARAM_OCTET_STRING: type = "octet string"; break; default: type = "unknown type"; show_type_number = 1; break; } printed_len = BIO_snprintf(buf, bufsz, "%s: ", param->key); if (printed_len > 0) { buf += printed_len; bufsz -= printed_len; } printed_len = BIO_snprintf(buf, bufsz, "%s%s", type_mod, type); if (printed_len > 0) { buf += printed_len; bufsz -= printed_len; } if (show_type_number) { printed_len = BIO_snprintf(buf, bufsz, " [%d]", param->data_type); if (printed_len > 0) { buf += printed_len; bufsz -= printed_len; } } if (param->data_size == 0) printed_len = BIO_snprintf(buf, bufsz, " (arbitrary size)"); else printed_len = BIO_snprintf(buf, bufsz, " (max %zu bytes large)", param->data_size); if (printed_len > 0) { buf += printed_len; bufsz -= printed_len; } *buf = '\0'; return 1; } int print_param_types(const char *thing, const OSSL_PARAM *pdefs, int indent) { if (pdefs == NULL) { return 1; } else if (pdefs->key == NULL) { /* * An empty list? This shouldn't happen, but let's just make sure to * say something if there's a badly written provider... */ BIO_printf(bio_out, "%*sEmpty list of %s (!!!)\n", indent, "", thing); } else { BIO_printf(bio_out, "%*s%s:\n", indent, "", thing); for (; pdefs->key != NULL; pdefs++) { char buf[200]; /* This should be ample space */ describe_param_type(buf, sizeof(buf), pdefs); BIO_printf(bio_out, "%*s %s\n", indent, "", buf); } } return 1; } void print_param_value(const OSSL_PARAM *p, int indent) { int64_t i; uint64_t u; printf("%*s%s: ", indent, "", p->key); switch (p->data_type) { case OSSL_PARAM_UNSIGNED_INTEGER: if (OSSL_PARAM_get_uint64(p, &u)) BIO_printf(bio_out, "%llu\n", (unsigned long long int)u); else BIO_printf(bio_out, "error getting value\n"); break; case OSSL_PARAM_INTEGER: if (OSSL_PARAM_get_int64(p, &i)) BIO_printf(bio_out, "%lld\n", (long long int)i); else BIO_printf(bio_out, "error getting value\n"); break; case OSSL_PARAM_UTF8_PTR: BIO_printf(bio_out, "'%s'\n", *(char **)(p->data)); break; case OSSL_PARAM_UTF8_STRING: BIO_printf(bio_out, "'%s'\n", (char *)p->data); break; case OSSL_PARAM_OCTET_PTR: case OSSL_PARAM_OCTET_STRING: BIO_printf(bio_out, "<%zu bytes>\n", p->data_size); break; default: BIO_printf(bio_out, "unknown type (%u) of %zu bytes\n", p->data_type, p->data_size); break; } }

./openssl/apps/lib/fmt.c

/* * Copyright 2018-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "fmt.h" int FMT_istext(int format) { return (format & B_FORMAT_TEXT) == B_FORMAT_TEXT; }

./openssl/apps/lib/app_provider.c

/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "apps.h" #include <string.h> #include <openssl/err.h> #include <openssl/provider.h> #include <openssl/safestack.h> /* Non-zero if any of the provider options have been seen */ static int provider_option_given = 0; DEFINE_STACK_OF(OSSL_PROVIDER) /* * See comments in opt_verify for explanation of this. */ enum prov_range { OPT_PROV_ENUM }; static STACK_OF(OSSL_PROVIDER) *app_providers = NULL; static void provider_free(OSSL_PROVIDER *prov) { OSSL_PROVIDER_unload(prov); } int app_provider_load(OSSL_LIB_CTX *libctx, const char *provider_name) { OSSL_PROVIDER *prov; prov = OSSL_PROVIDER_load(libctx, provider_name); if (prov == NULL) { opt_printf_stderr("%s: unable to load provider %s\n" "Hint: use -provider-path option or OPENSSL_MODULES environment variable.\n", opt_getprog(), provider_name); ERR_print_errors(bio_err); return 0; } if (app_providers == NULL) app_providers = sk_OSSL_PROVIDER_new_null(); if (app_providers == NULL || !sk_OSSL_PROVIDER_push(app_providers, prov)) { app_providers_cleanup(); return 0; } return 1; } void app_providers_cleanup(void) { sk_OSSL_PROVIDER_pop_free(app_providers, provider_free); app_providers = NULL; } static int opt_provider_path(const char *path) { if (path != NULL && *path == '\0') path = NULL; return OSSL_PROVIDER_set_default_search_path(app_get0_libctx(), path); } int opt_provider(int opt) { const int given = provider_option_given; provider_option_given = 1; switch ((enum prov_range)opt) { case OPT_PROV__FIRST: case OPT_PROV__LAST: return 1; case OPT_PROV_PROVIDER: return app_provider_load(app_get0_libctx(), opt_arg()); case OPT_PROV_PROVIDER_PATH: return opt_provider_path(opt_arg()); case OPT_PROV_PROPQUERY: return app_set_propq(opt_arg()); } /* Should never get here but if we do, undo what we did earlier */ provider_option_given = given; return 0; } int opt_provider_option_given(void) { return provider_option_given; }

./openssl/ms/applink.c

/* * Copyright 2004-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #define APPLINK_STDIN 1 #define APPLINK_STDOUT 2 #define APPLINK_STDERR 3 #define APPLINK_FPRINTF 4 #define APPLINK_FGETS 5 #define APPLINK_FREAD 6 #define APPLINK_FWRITE 7 #define APPLINK_FSETMOD 8 #define APPLINK_FEOF 9 #define APPLINK_FCLOSE 10 /* should not be used */ #define APPLINK_FOPEN 11 /* solely for completeness */ #define APPLINK_FSEEK 12 #define APPLINK_FTELL 13 #define APPLINK_FFLUSH 14 #define APPLINK_FERROR 15 #define APPLINK_CLEARERR 16 #define APPLINK_FILENO 17 /* to be used with below */ #define APPLINK_OPEN 18 /* formally can't be used, as flags can vary */ #define APPLINK_READ 19 #define APPLINK_WRITE 20 #define APPLINK_LSEEK 21 #define APPLINK_CLOSE 22 #define APPLINK_MAX 22 /* always same as last macro */ #ifndef APPMACROS_ONLY /* * Normally, do not define APPLINK_NO_INCLUDES. Define it if you are using * symbol preprocessing and do not want the preprocessing to affect the * following included header files. You will need to put these * include lines somewhere in the file that is including applink.c. */ # ifndef APPLINK_NO_INCLUDES # include <stdio.h> # include <io.h> # include <fcntl.h> # endif # ifdef __BORLANDC__ /* _lseek in <io.h> is a function-like macro so we can't take its address */ # undef _lseek # define _lseek lseek # endif static void *app_stdin(void) { return stdin; } static void *app_stdout(void) { return stdout; } static void *app_stderr(void) { return stderr; } static int app_feof(FILE *fp) { return feof(fp); } static int app_ferror(FILE *fp) { return ferror(fp); } static void app_clearerr(FILE *fp) { clearerr(fp); } static int app_fileno(FILE *fp) { return _fileno(fp); } static int app_fsetmod(FILE *fp, char mod) { return _setmode(_fileno(fp), mod == 'b' ? _O_BINARY : _O_TEXT); } #ifdef __cplusplus extern "C" { #endif __declspec(dllexport) void ** # if defined(__BORLANDC__) /* * __stdcall appears to be the only way to get the name * decoration right with Borland C. Otherwise it works * purely incidentally, as we pass no parameters. */ __stdcall # else __cdecl # endif OPENSSL_Applink(void) { static int once = 1; static void *OPENSSL_ApplinkTable[APPLINK_MAX + 1] = { (void *)APPLINK_MAX }; if (once) { OPENSSL_ApplinkTable[APPLINK_STDIN] = app_stdin; OPENSSL_ApplinkTable[APPLINK_STDOUT] = app_stdout; OPENSSL_ApplinkTable[APPLINK_STDERR] = app_stderr; OPENSSL_ApplinkTable[APPLINK_FPRINTF] = fprintf; OPENSSL_ApplinkTable[APPLINK_FGETS] = fgets; OPENSSL_ApplinkTable[APPLINK_FREAD] = fread; OPENSSL_ApplinkTable[APPLINK_FWRITE] = fwrite; OPENSSL_ApplinkTable[APPLINK_FSETMOD] = app_fsetmod; OPENSSL_ApplinkTable[APPLINK_FEOF] = app_feof; OPENSSL_ApplinkTable[APPLINK_FCLOSE] = fclose; OPENSSL_ApplinkTable[APPLINK_FOPEN] = fopen; OPENSSL_ApplinkTable[APPLINK_FSEEK] = fseek; OPENSSL_ApplinkTable[APPLINK_FTELL] = ftell; OPENSSL_ApplinkTable[APPLINK_FFLUSH] = fflush; OPENSSL_ApplinkTable[APPLINK_FERROR] = app_ferror; OPENSSL_ApplinkTable[APPLINK_CLEARERR] = app_clearerr; OPENSSL_ApplinkTable[APPLINK_FILENO] = app_fileno; OPENSSL_ApplinkTable[APPLINK_OPEN] = _open; OPENSSL_ApplinkTable[APPLINK_READ] = _read; OPENSSL_ApplinkTable[APPLINK_WRITE] = _write; OPENSSL_ApplinkTable[APPLINK_LSEEK] = _lseek; OPENSSL_ApplinkTable[APPLINK_CLOSE] = _close; once = 0; } return OPENSSL_ApplinkTable; } #ifdef __cplusplus } #endif #endif

./openssl/ms/uplink.h

/* * Copyright 2004-2016 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #define APPMACROS_ONLY #include "applink.c" extern void *OPENSSL_UplinkTable[]; #define UP_stdin (*(void *(*)(void))OPENSSL_UplinkTable[APPLINK_STDIN])() #define UP_stdout (*(void *(*)(void))OPENSSL_UplinkTable[APPLINK_STDOUT])() #define UP_stderr (*(void *(*)(void))OPENSSL_UplinkTable[APPLINK_STDERR])() #define UP_fprintf (*(int (*)(void *,const char *,...))OPENSSL_UplinkTable[APPLINK_FPRINTF]) #define UP_fgets (*(char *(*)(char *,int,void *))OPENSSL_UplinkTable[APPLINK_FGETS]) #define UP_fread (*(size_t (*)(void *,size_t,size_t,void *))OPENSSL_UplinkTable[APPLINK_FREAD]) #define UP_fwrite (*(size_t (*)(const void *,size_t,size_t,void *))OPENSSL_UplinkTable[APPLINK_FWRITE]) #define UP_fsetmod (*(int (*)(void *,char))OPENSSL_UplinkTable[APPLINK_FSETMOD]) #define UP_feof (*(int (*)(void *))OPENSSL_UplinkTable[APPLINK_FEOF]) #define UP_fclose (*(int (*)(void *))OPENSSL_UplinkTable[APPLINK_FCLOSE]) #define UP_fopen (*(void *(*)(const char *,const char *))OPENSSL_UplinkTable[APPLINK_FOPEN]) #define UP_fseek (*(int (*)(void *,long,int))OPENSSL_UplinkTable[APPLINK_FSEEK]) #define UP_ftell (*(long (*)(void *))OPENSSL_UplinkTable[APPLINK_FTELL]) #define UP_fflush (*(int (*)(void *))OPENSSL_UplinkTable[APPLINK_FFLUSH]) #define UP_ferror (*(int (*)(void *))OPENSSL_UplinkTable[APPLINK_FERROR]) #define UP_clearerr (*(void (*)(void *))OPENSSL_UplinkTable[APPLINK_CLEARERR]) #define UP_fileno (*(int (*)(void *))OPENSSL_UplinkTable[APPLINK_FILENO]) #define UP_open (*(int (*)(const char *,int,...))OPENSSL_UplinkTable[APPLINK_OPEN]) #define UP_read (*(ossl_ssize_t (*)(int,void *,size_t))OPENSSL_UplinkTable[APPLINK_READ]) #define UP_write (*(ossl_ssize_t (*)(int,const void *,size_t))OPENSSL_UplinkTable[APPLINK_WRITE]) #define UP_lseek (*(long (*)(int,long,int))OPENSSL_UplinkTable[APPLINK_LSEEK]) #define UP_close (*(int (*)(int))OPENSSL_UplinkTable[APPLINK_CLOSE])

./openssl/ms/uplink.c

/* * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #if (defined(_WIN64) || defined(_WIN32_WCE)) && !defined(UNICODE) # define UNICODE #endif #if defined(UNICODE) && !defined(_UNICODE) # define _UNICODE #endif #if defined(_UNICODE) && !defined(UNICODE) # define UNICODE #endif #include <windows.h> #include <tchar.h> #include <stdio.h> #include "uplink.h" void OPENSSL_showfatal(const char *, ...); static TCHAR msg[128]; static void unimplemented(void) { OPENSSL_showfatal(sizeof(TCHAR) == sizeof(char) ? "%s\n" : "%S\n", msg); TerminateProcess(GetCurrentProcess(), 1); } void OPENSSL_Uplink(volatile void **table, int index) { static HMODULE volatile apphandle = NULL; static void **volatile applinktable = NULL; int len; void (*func) (void) = unimplemented; HANDLE h; void **p; /* * Note that the below code is not MT-safe in respect to msg buffer, but * what's the worst thing that can happen? Error message might be * misleading or corrupted. As error condition is fatal and should never * be risen, I accept the risk... */ /* * One can argue that I should have used InterlockedExchangePointer or * something to update static variables and table[]. Well, store * instructions are as atomic as they can get and assigned values are * effectively constant... So that volatile qualifier should be * sufficient [it prohibits compiler to reorder memory access * instructions]. */ do { len = _sntprintf(msg, sizeof(msg) / sizeof(TCHAR), _T("OPENSSL_Uplink(%p,%02X): "), table, index); _tcscpy(msg + len, _T("unimplemented function")); if ((h = apphandle) == NULL) { if ((h = GetModuleHandle(NULL)) == NULL) { apphandle = (HMODULE) - 1; _tcscpy(msg + len, _T("no host application")); break; } apphandle = h; } if ((h = apphandle) == (HMODULE) - 1) /* revalidate */ break; if (applinktable == NULL) { void **(*applink) (); applink = (void **(*)())GetProcAddress(h, "OPENSSL_Applink"); if (applink == NULL) { apphandle = (HMODULE) - 1; _tcscpy(msg + len, _T("no OPENSSL_Applink")); break; } p = (*applink) (); if (p == NULL) { apphandle = (HMODULE) - 1; _tcscpy(msg + len, _T("no ApplinkTable")); break; } applinktable = p; } else p = applinktable; if (index > (int)p[0]) break; if (p[index]) func = p[index]; } while (0); table[index] = func; } #if (defined(_MSC_VER) || defined(__BORLANDC__)) && defined(_M_IX86) # if defined(_MSC_VER) # define LAZY(i) \ __declspec(naked) static void lazy##i (void) { \ _asm push i \ _asm push OFFSET OPENSSL_UplinkTable \ _asm call OPENSSL_Uplink \ _asm add esp,8 \ _asm jmp OPENSSL_UplinkTable+4*i } # elif defined(__BORLANDC__) && defined(__clang__) void *OPENSSL_UplinkTable[26]; /* C++Builder requires declaration before use */ # define LAZY(i) \ __declspec(naked) static void lazy##i (void) { \ __asm__("pushl $" #i "; " \ "pushl %0; " \ "call %P1; " \ "addl $8, %%esp; " \ "jmp *%2 " \ : /* no outputs */ \ : "i" (OPENSSL_UplinkTable), \ "i" (OPENSSL_Uplink), \ "m" (OPENSSL_UplinkTable[i])); } # endif # if APPLINK_MAX>25 # error "Add more stubs..." # endif /* make some in advance... */ LAZY(1) LAZY(2) LAZY(3) LAZY(4) LAZY(5) LAZY(6) LAZY(7) LAZY(8) LAZY(9) LAZY(10) LAZY(11) LAZY(12) LAZY(13) LAZY(14) LAZY(15) LAZY(16) LAZY(17) LAZY(18) LAZY(19) LAZY(20) LAZY(21) LAZY(22) LAZY(23) LAZY(24) LAZY(25) void *OPENSSL_UplinkTable[] = { (void *)APPLINK_MAX, lazy1, lazy2, lazy3, lazy4, lazy5, lazy6, lazy7, lazy8, lazy9, lazy10, lazy11, lazy12, lazy13, lazy14, lazy15, lazy16, lazy17, lazy18, lazy19, lazy20, lazy21, lazy22, lazy23, lazy24, lazy25, }; #endif #ifdef SELFTEST main() { UP_fprintf(UP_stdout, "hello, world!\n"); } #endif

./openssl/ssl/t1_enc.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include "ssl_local.h" #include "record/record_local.h" #include "internal/ktls.h" #include "internal/cryptlib.h" #include <openssl/comp.h> #include <openssl/evp.h> #include <openssl/kdf.h> #include <openssl/rand.h> #include <openssl/obj_mac.h> #include <openssl/core_names.h> #include <openssl/trace.h> /* seed1 through seed5 are concatenated */ static int tls1_PRF(SSL_CONNECTION *s, const void *seed1, size_t seed1_len, const void *seed2, size_t seed2_len, const void *seed3, size_t seed3_len, const void *seed4, size_t seed4_len, const void *seed5, size_t seed5_len, const unsigned char *sec, size_t slen, unsigned char *out, size_t olen, int fatal) { const EVP_MD *md = ssl_prf_md(s); EVP_KDF *kdf; EVP_KDF_CTX *kctx = NULL; OSSL_PARAM params[8], *p = params; const char *mdname; if (md == NULL) { /* Should never happen */ if (fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); else ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } kdf = EVP_KDF_fetch(SSL_CONNECTION_GET_CTX(s)->libctx, OSSL_KDF_NAME_TLS1_PRF, SSL_CONNECTION_GET_CTX(s)->propq); if (kdf == NULL) goto err; kctx = EVP_KDF_CTX_new(kdf); EVP_KDF_free(kdf); if (kctx == NULL) goto err; mdname = EVP_MD_get0_name(md); *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char *)mdname, 0); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET, (unsigned char *)sec, (size_t)slen); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void *)seed1, (size_t)seed1_len); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void *)seed2, (size_t)seed2_len); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void *)seed3, (size_t)seed3_len); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void *)seed4, (size_t)seed4_len); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED, (void *)seed5, (size_t)seed5_len); *p = OSSL_PARAM_construct_end(); if (EVP_KDF_derive(kctx, out, olen, params)) { EVP_KDF_CTX_free(kctx); return 1; } err: if (fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); else ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); EVP_KDF_CTX_free(kctx); return 0; } static int tls1_generate_key_block(SSL_CONNECTION *s, unsigned char *km, size_t num) { int ret; /* Calls SSLfatal() as required */ ret = tls1_PRF(s, TLS_MD_KEY_EXPANSION_CONST, TLS_MD_KEY_EXPANSION_CONST_SIZE, s->s3.server_random, SSL3_RANDOM_SIZE, s->s3.client_random, SSL3_RANDOM_SIZE, NULL, 0, NULL, 0, s->session->master_key, s->session->master_key_length, km, num, 1); return ret; } static int tls_iv_length_within_key_block(const EVP_CIPHER *c) { /* If GCM/CCM mode only part of IV comes from PRF */ if (EVP_CIPHER_get_mode(c) == EVP_CIPH_GCM_MODE) return EVP_GCM_TLS_FIXED_IV_LEN; else if (EVP_CIPHER_get_mode(c) == EVP_CIPH_CCM_MODE) return EVP_CCM_TLS_FIXED_IV_LEN; else return EVP_CIPHER_get_iv_length(c); } int tls1_change_cipher_state(SSL_CONNECTION *s, int which) { unsigned char *p, *mac_secret; unsigned char *key, *iv; const EVP_CIPHER *c; const SSL_COMP *comp = NULL; const EVP_MD *m; int mac_type; size_t mac_secret_size; size_t n, i, j, k, cl; int iivlen; /* * Taglen is only relevant for CCM ciphersuites. Other ciphersuites * ignore this value so we can default it to 0. */ size_t taglen = 0; int direction; c = s->s3.tmp.new_sym_enc; m = s->s3.tmp.new_hash; mac_type = s->s3.tmp.new_mac_pkey_type; #ifndef OPENSSL_NO_COMP comp = s->s3.tmp.new_compression; #endif p = s->s3.tmp.key_block; i = mac_secret_size = s->s3.tmp.new_mac_secret_size; cl = EVP_CIPHER_get_key_length(c); j = cl; iivlen = tls_iv_length_within_key_block(c); if (iivlen < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } k = iivlen; if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) || (which == SSL3_CHANGE_CIPHER_SERVER_READ)) { mac_secret = &(p[0]); n = i + i; key = &(p[n]); n += j + j; iv = &(p[n]); n += k + k; } else { n = i; mac_secret = &(p[n]); n += i + j; key = &(p[n]); n += j + k; iv = &(p[n]); n += k; } if (n > s->s3.tmp.key_block_length) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } switch (EVP_CIPHER_get_mode(c)) { case EVP_CIPH_GCM_MODE: taglen = EVP_GCM_TLS_TAG_LEN; break; case EVP_CIPH_CCM_MODE: if ((s->s3.tmp.new_cipher->algorithm_enc & (SSL_AES128CCM8 | SSL_AES256CCM8)) != 0) taglen = EVP_CCM8_TLS_TAG_LEN; else taglen = EVP_CCM_TLS_TAG_LEN; break; default: if (EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")) { taglen = EVP_CHACHAPOLY_TLS_TAG_LEN; } else { /* MAC secret size corresponds to the MAC output size */ taglen = s->s3.tmp.new_mac_secret_size; } break; } if (which & SSL3_CC_READ) { if (s->ext.use_etm) s->s3.flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC_READ; else s->s3.flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC_READ; if (s->s3.tmp.new_cipher->algorithm2 & TLS1_STREAM_MAC) s->mac_flags |= SSL_MAC_FLAG_READ_MAC_STREAM; else s->mac_flags &= ~SSL_MAC_FLAG_READ_MAC_STREAM; if (s->s3.tmp.new_cipher->algorithm2 & TLS1_TLSTREE) s->mac_flags |= SSL_MAC_FLAG_READ_MAC_TLSTREE; else s->mac_flags &= ~SSL_MAC_FLAG_READ_MAC_TLSTREE; direction = OSSL_RECORD_DIRECTION_READ; } else { if (s->ext.use_etm) s->s3.flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE; else s->s3.flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE; if (s->s3.tmp.new_cipher->algorithm2 & TLS1_STREAM_MAC) s->mac_flags |= SSL_MAC_FLAG_WRITE_MAC_STREAM; else s->mac_flags &= ~SSL_MAC_FLAG_WRITE_MAC_STREAM; if (s->s3.tmp.new_cipher->algorithm2 & TLS1_TLSTREE) s->mac_flags |= SSL_MAC_FLAG_WRITE_MAC_TLSTREE; else s->mac_flags &= ~SSL_MAC_FLAG_WRITE_MAC_TLSTREE; direction = OSSL_RECORD_DIRECTION_WRITE; } if (SSL_CONNECTION_IS_DTLS(s)) dtls1_increment_epoch(s, which); if (!ssl_set_new_record_layer(s, s->version, direction, OSSL_RECORD_PROTECTION_LEVEL_APPLICATION, NULL, 0, key, cl, iv, (size_t)k, mac_secret, mac_secret_size, c, taglen, mac_type, m, comp, NULL)) { /* SSLfatal already called */ goto err; } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "which = %04X, key:\n", which); BIO_dump_indent(trc_out, key, EVP_CIPHER_get_key_length(c), 4); BIO_printf(trc_out, "iv:\n"); BIO_dump_indent(trc_out, iv, k, 4); } OSSL_TRACE_END(TLS); return 1; err: return 0; } int tls1_setup_key_block(SSL_CONNECTION *s) { unsigned char *p; const EVP_CIPHER *c; const EVP_MD *hash; SSL_COMP *comp; int mac_type = NID_undef; size_t num, mac_secret_size = 0; int ret = 0; int ivlen; if (s->s3.tmp.key_block_length != 0) return 1; if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash, &mac_type, &mac_secret_size, &comp, s->ext.use_etm)) { /* Error is already recorded */ SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); return 0; } ssl_evp_cipher_free(s->s3.tmp.new_sym_enc); s->s3.tmp.new_sym_enc = c; ssl_evp_md_free(s->s3.tmp.new_hash); s->s3.tmp.new_hash = hash; s->s3.tmp.new_mac_pkey_type = mac_type; s->s3.tmp.new_mac_secret_size = mac_secret_size; ivlen = tls_iv_length_within_key_block(c); if (ivlen < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } num = mac_secret_size + EVP_CIPHER_get_key_length(c) + ivlen; num *= 2; ssl3_cleanup_key_block(s); if ((p = OPENSSL_malloc(num)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } s->s3.tmp.key_block_length = num; s->s3.tmp.key_block = p; OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "key block length: %zu\n", num); BIO_printf(trc_out, "client random\n"); BIO_dump_indent(trc_out, s->s3.client_random, SSL3_RANDOM_SIZE, 4); BIO_printf(trc_out, "server random\n"); BIO_dump_indent(trc_out, s->s3.server_random, SSL3_RANDOM_SIZE, 4); BIO_printf(trc_out, "master key\n"); BIO_dump_indent(trc_out, s->session->master_key, s->session->master_key_length, 4); } OSSL_TRACE_END(TLS); if (!tls1_generate_key_block(s, p, num)) { /* SSLfatal() already called */ goto err; } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "key block\n"); BIO_dump_indent(trc_out, p, num, 4); } OSSL_TRACE_END(TLS); ret = 1; err: return ret; } size_t tls1_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen, unsigned char *out) { size_t hashlen; unsigned char hash[EVP_MAX_MD_SIZE]; size_t finished_size = TLS1_FINISH_MAC_LENGTH; if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kGOST18) finished_size = 32; if (!ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called */ return 0; } if (!ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) { /* SSLfatal() already called */ return 0; } if (!tls1_PRF(s, str, slen, hash, hashlen, NULL, 0, NULL, 0, NULL, 0, s->session->master_key, s->session->master_key_length, out, finished_size, 1)) { /* SSLfatal() already called */ return 0; } OPENSSL_cleanse(hash, hashlen); return finished_size; } int tls1_generate_master_secret(SSL_CONNECTION *s, unsigned char *out, unsigned char *p, size_t len, size_t *secret_size) { if (s->session->flags & SSL_SESS_FLAG_EXTMS) { unsigned char hash[EVP_MAX_MD_SIZE * 2]; size_t hashlen; /* * Digest cached records keeping record buffer (if present): this won't * affect client auth because we're freezing the buffer at the same * point (after client key exchange and before certificate verify) */ if (!ssl3_digest_cached_records(s, 1) || !ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) { /* SSLfatal() already called */ return 0; } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "Handshake hashes:\n"); BIO_dump(trc_out, (char *)hash, hashlen); } OSSL_TRACE_END(TLS); if (!tls1_PRF(s, TLS_MD_EXTENDED_MASTER_SECRET_CONST, TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE, hash, hashlen, NULL, 0, NULL, 0, NULL, 0, p, len, out, SSL3_MASTER_SECRET_SIZE, 1)) { /* SSLfatal() already called */ return 0; } OPENSSL_cleanse(hash, hashlen); } else { if (!tls1_PRF(s, TLS_MD_MASTER_SECRET_CONST, TLS_MD_MASTER_SECRET_CONST_SIZE, s->s3.client_random, SSL3_RANDOM_SIZE, NULL, 0, s->s3.server_random, SSL3_RANDOM_SIZE, NULL, 0, p, len, out, SSL3_MASTER_SECRET_SIZE, 1)) { /* SSLfatal() already called */ return 0; } } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "Premaster Secret:\n"); BIO_dump_indent(trc_out, p, len, 4); BIO_printf(trc_out, "Client Random:\n"); BIO_dump_indent(trc_out, s->s3.client_random, SSL3_RANDOM_SIZE, 4); BIO_printf(trc_out, "Server Random:\n"); BIO_dump_indent(trc_out, s->s3.server_random, SSL3_RANDOM_SIZE, 4); BIO_printf(trc_out, "Master Secret:\n"); BIO_dump_indent(trc_out, s->session->master_key, SSL3_MASTER_SECRET_SIZE, 4); } OSSL_TRACE_END(TLS); *secret_size = SSL3_MASTER_SECRET_SIZE; return 1; } int tls1_export_keying_material(SSL_CONNECTION *s, unsigned char *out, size_t olen, const char *label, size_t llen, const unsigned char *context, size_t contextlen, int use_context) { unsigned char *val = NULL; size_t vallen = 0, currentvalpos; int rv = 0; /* * RFC 5705 embeds context length as uint16; reject longer context * before proceeding. */ if (contextlen > 0xffff) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); return 0; } /* * construct PRF arguments we construct the PRF argument ourself rather * than passing separate values into the TLS PRF to ensure that the * concatenation of values does not create a prohibited label. */ vallen = llen + SSL3_RANDOM_SIZE * 2; if (use_context) { vallen += 2 + contextlen; } val = OPENSSL_malloc(vallen); if (val == NULL) goto ret; currentvalpos = 0; memcpy(val + currentvalpos, (unsigned char *)label, llen); currentvalpos += llen; memcpy(val + currentvalpos, s->s3.client_random, SSL3_RANDOM_SIZE); currentvalpos += SSL3_RANDOM_SIZE; memcpy(val + currentvalpos, s->s3.server_random, SSL3_RANDOM_SIZE); currentvalpos += SSL3_RANDOM_SIZE; if (use_context) { val[currentvalpos] = (contextlen >> 8) & 0xff; currentvalpos++; val[currentvalpos] = contextlen & 0xff; currentvalpos++; if ((contextlen > 0) || (context != NULL)) { memcpy(val + currentvalpos, context, contextlen); } } /* * disallow prohibited labels note that SSL3_RANDOM_SIZE > max(prohibited * label len) = 15, so size of val > max(prohibited label len) = 15 and * the comparisons won't have buffer overflow */ if (memcmp(val, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE) == 0) goto err1; if (memcmp(val, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE) == 0) goto err1; if (memcmp(val, TLS_MD_MASTER_SECRET_CONST, TLS_MD_MASTER_SECRET_CONST_SIZE) == 0) goto err1; if (memcmp(val, TLS_MD_EXTENDED_MASTER_SECRET_CONST, TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE) == 0) goto err1; if (memcmp(val, TLS_MD_KEY_EXPANSION_CONST, TLS_MD_KEY_EXPANSION_CONST_SIZE) == 0) goto err1; rv = tls1_PRF(s, val, vallen, NULL, 0, NULL, 0, NULL, 0, NULL, 0, s->session->master_key, s->session->master_key_length, out, olen, 0); goto ret; err1: ERR_raise(ERR_LIB_SSL, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL); ret: OPENSSL_clear_free(val, vallen); return rv; } int tls1_alert_code(int code) { switch (code) { case SSL_AD_CLOSE_NOTIFY: return SSL3_AD_CLOSE_NOTIFY; case SSL_AD_UNEXPECTED_MESSAGE: return SSL3_AD_UNEXPECTED_MESSAGE; case SSL_AD_BAD_RECORD_MAC: return SSL3_AD_BAD_RECORD_MAC; case SSL_AD_DECRYPTION_FAILED: return TLS1_AD_DECRYPTION_FAILED; case SSL_AD_RECORD_OVERFLOW: return TLS1_AD_RECORD_OVERFLOW; case SSL_AD_DECOMPRESSION_FAILURE: return SSL3_AD_DECOMPRESSION_FAILURE; case SSL_AD_HANDSHAKE_FAILURE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_NO_CERTIFICATE: return -1; case SSL_AD_BAD_CERTIFICATE: return SSL3_AD_BAD_CERTIFICATE; case SSL_AD_UNSUPPORTED_CERTIFICATE: return SSL3_AD_UNSUPPORTED_CERTIFICATE; case SSL_AD_CERTIFICATE_REVOKED: return SSL3_AD_CERTIFICATE_REVOKED; case SSL_AD_CERTIFICATE_EXPIRED: return SSL3_AD_CERTIFICATE_EXPIRED; case SSL_AD_CERTIFICATE_UNKNOWN: return SSL3_AD_CERTIFICATE_UNKNOWN; case SSL_AD_ILLEGAL_PARAMETER: return SSL3_AD_ILLEGAL_PARAMETER; case SSL_AD_UNKNOWN_CA: return TLS1_AD_UNKNOWN_CA; case SSL_AD_ACCESS_DENIED: return TLS1_AD_ACCESS_DENIED; case SSL_AD_DECODE_ERROR: return TLS1_AD_DECODE_ERROR; case SSL_AD_DECRYPT_ERROR: return TLS1_AD_DECRYPT_ERROR; case SSL_AD_EXPORT_RESTRICTION: return TLS1_AD_EXPORT_RESTRICTION; case SSL_AD_PROTOCOL_VERSION: return TLS1_AD_PROTOCOL_VERSION; case SSL_AD_INSUFFICIENT_SECURITY: return TLS1_AD_INSUFFICIENT_SECURITY; case SSL_AD_INTERNAL_ERROR: return TLS1_AD_INTERNAL_ERROR; case SSL_AD_USER_CANCELLED: return TLS1_AD_USER_CANCELLED; case SSL_AD_NO_RENEGOTIATION: return TLS1_AD_NO_RENEGOTIATION; case SSL_AD_UNSUPPORTED_EXTENSION: return TLS1_AD_UNSUPPORTED_EXTENSION; case SSL_AD_CERTIFICATE_UNOBTAINABLE: return TLS1_AD_CERTIFICATE_UNOBTAINABLE; case SSL_AD_UNRECOGNIZED_NAME: return TLS1_AD_UNRECOGNIZED_NAME; case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE; case SSL_AD_BAD_CERTIFICATE_HASH_VALUE: return TLS1_AD_BAD_CERTIFICATE_HASH_VALUE; case SSL_AD_UNKNOWN_PSK_IDENTITY: return TLS1_AD_UNKNOWN_PSK_IDENTITY; case SSL_AD_INAPPROPRIATE_FALLBACK: return TLS1_AD_INAPPROPRIATE_FALLBACK; case SSL_AD_NO_APPLICATION_PROTOCOL: return TLS1_AD_NO_APPLICATION_PROTOCOL; case SSL_AD_CERTIFICATE_REQUIRED: return SSL_AD_HANDSHAKE_FAILURE; case TLS13_AD_MISSING_EXTENSION: return SSL_AD_HANDSHAKE_FAILURE; default: return -1; } }

./openssl/ssl/ssl_init.c

/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/e_os.h" #include "internal/err.h" #include <openssl/crypto.h> #include <openssl/evp.h> #include <openssl/trace.h> #include "ssl_local.h" #include "sslerr.h" #include "internal/thread_once.h" static int stopped; static void ssl_library_stop(void); static CRYPTO_ONCE ssl_base = CRYPTO_ONCE_STATIC_INIT; static int ssl_base_inited = 0; DEFINE_RUN_ONCE_STATIC(ossl_init_ssl_base) { #ifndef OPENSSL_NO_COMP OSSL_TRACE(INIT, "ossl_init_ssl_base: " "SSL_COMP_get_compression_methods()\n"); /* * This will initialise the built-in compression algorithms. The value * returned is a STACK_OF(SSL_COMP), but that can be discarded safely */ SSL_COMP_get_compression_methods(); #endif ssl_sort_cipher_list(); OSSL_TRACE(INIT, "ossl_init_ssl_base: SSL_add_ssl_module()\n"); /* * We ignore an error return here. Not much we can do - but not that bad * either. We can still safely continue. */ OPENSSL_atexit(ssl_library_stop); ssl_base_inited = 1; return 1; } static CRYPTO_ONCE ssl_strings = CRYPTO_ONCE_STATIC_INIT; DEFINE_RUN_ONCE_STATIC(ossl_init_load_ssl_strings) { /* * OPENSSL_NO_AUTOERRINIT is provided here to prevent at compile time * pulling in all the error strings during static linking */ #if !defined(OPENSSL_NO_ERR) && !defined(OPENSSL_NO_AUTOERRINIT) OSSL_TRACE(INIT, "ossl_init_load_ssl_strings: ossl_err_load_SSL_strings()\n"); ossl_err_load_SSL_strings(); #endif return 1; } DEFINE_RUN_ONCE_STATIC_ALT(ossl_init_no_load_ssl_strings, ossl_init_load_ssl_strings) { /* Do nothing in this case */ return 1; } static void ssl_library_stop(void) { /* Might be explicitly called and also by atexit */ if (stopped) return; stopped = 1; if (ssl_base_inited) { #ifndef OPENSSL_NO_COMP OSSL_TRACE(INIT, "ssl_library_stop: " "ssl_comp_free_compression_methods_int()\n"); ssl_comp_free_compression_methods_int(); #endif } } /* * If this function is called with a non NULL settings value then it must be * called prior to any threads making calls to any OpenSSL functions, * i.e. passing a non-null settings value is assumed to be single-threaded. */ int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) { static int stoperrset = 0; if (stopped) { if (!stoperrset) { /* * We only ever set this once to avoid getting into an infinite * loop where the error system keeps trying to init and fails so * sets an error etc */ stoperrset = 1; ERR_raise(ERR_LIB_SSL, ERR_R_INIT_FAIL); } return 0; } opts |= OPENSSL_INIT_ADD_ALL_CIPHERS | OPENSSL_INIT_ADD_ALL_DIGESTS; #ifndef OPENSSL_NO_AUTOLOAD_CONFIG if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG) == 0) opts |= OPENSSL_INIT_LOAD_CONFIG; #endif if (!OPENSSL_init_crypto(opts, settings)) return 0; if (!RUN_ONCE(&ssl_base, ossl_init_ssl_base)) return 0; if ((opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS) && !RUN_ONCE_ALT(&ssl_strings, ossl_init_no_load_ssl_strings, ossl_init_load_ssl_strings)) return 0; if ((opts & OPENSSL_INIT_LOAD_SSL_STRINGS) && !RUN_ONCE(&ssl_strings, ossl_init_load_ssl_strings)) return 0; return 1; }

./openssl/ssl/ssl_rsa_legacy.c

/* * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* We need to use the deprecated RSA low level calls */ #define OPENSSL_SUPPRESS_DEPRECATED #include <openssl/err.h> #include <openssl/rsa.h> #include <openssl/ssl.h> int SSL_use_RSAPrivateKey(SSL *ssl, RSA *rsa) { EVP_PKEY *pkey; int ret; if (rsa == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } if ((pkey = EVP_PKEY_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } RSA_up_ref(rsa); if (EVP_PKEY_assign_RSA(pkey, rsa) <= 0) { RSA_free(rsa); EVP_PKEY_free(pkey); return 0; } ret = SSL_use_PrivateKey(ssl, pkey); EVP_PKEY_free(pkey); return ret; } int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type) { int j, ret = 0; BIO *in; RSA *rsa = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; rsa = d2i_RSAPrivateKey_bio(in, NULL); } else if (type == SSL_FILETYPE_PEM) { j = ERR_R_PEM_LIB; rsa = PEM_read_bio_RSAPrivateKey(in, NULL, SSL_get_default_passwd_cb(ssl), SSL_get_default_passwd_cb_userdata(ssl)); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (rsa == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_use_RSAPrivateKey(ssl, rsa); RSA_free(rsa); end: BIO_free(in); return ret; } int SSL_use_RSAPrivateKey_ASN1(SSL *ssl, const unsigned char *d, long len) { int ret; const unsigned char *p; RSA *rsa; p = d; if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_use_RSAPrivateKey(ssl, rsa); RSA_free(rsa); return ret; } int SSL_CTX_use_RSAPrivateKey(SSL_CTX *ctx, RSA *rsa) { int ret; EVP_PKEY *pkey; if (rsa == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } if ((pkey = EVP_PKEY_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } RSA_up_ref(rsa); if (EVP_PKEY_assign_RSA(pkey, rsa) <= 0) { RSA_free(rsa); EVP_PKEY_free(pkey); return 0; } ret = SSL_CTX_use_PrivateKey(ctx, pkey); EVP_PKEY_free(pkey); return ret; } int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type) { int j, ret = 0; BIO *in; RSA *rsa = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; rsa = d2i_RSAPrivateKey_bio(in, NULL); } else if (type == SSL_FILETYPE_PEM) { j = ERR_R_PEM_LIB; rsa = PEM_read_bio_RSAPrivateKey(in, NULL, SSL_CTX_get_default_passwd_cb(ctx), SSL_CTX_get_default_passwd_cb_userdata(ctx)); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (rsa == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa); RSA_free(rsa); end: BIO_free(in); return ret; } int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d, long len) { int ret; const unsigned char *p; RSA *rsa; p = d; if ((rsa = d2i_RSAPrivateKey(NULL, &p, (long)len)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa); RSA_free(rsa); return ret; }

./openssl/ssl/ssl_cert_table.h

/* * Copyright 2017-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* * Certificate table information. NB: table entries must match SSL_PKEY indices */ static const SSL_CERT_LOOKUP ssl_cert_info [] = { {EVP_PKEY_RSA, SSL_aRSA}, /* SSL_PKEY_RSA */ {EVP_PKEY_RSA_PSS, SSL_aRSA}, /* SSL_PKEY_RSA_PSS_SIGN */ {EVP_PKEY_DSA, SSL_aDSS}, /* SSL_PKEY_DSA_SIGN */ {EVP_PKEY_EC, SSL_aECDSA}, /* SSL_PKEY_ECC */ {NID_id_GostR3410_2001, SSL_aGOST01}, /* SSL_PKEY_GOST01 */ {NID_id_GostR3410_2012_256, SSL_aGOST12}, /* SSL_PKEY_GOST12_256 */ {NID_id_GostR3410_2012_512, SSL_aGOST12}, /* SSL_PKEY_GOST12_512 */ {EVP_PKEY_ED25519, SSL_aECDSA}, /* SSL_PKEY_ED25519 */ {EVP_PKEY_ED448, SSL_aECDSA} /* SSL_PKEY_ED448 */ };

./openssl/ssl/tls13_enc.c

/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdlib.h> #include "ssl_local.h" #include "internal/ktls.h" #include "record/record_local.h" #include "internal/cryptlib.h" #include <openssl/evp.h> #include <openssl/kdf.h> #include <openssl/core_names.h> #define TLS13_MAX_LABEL_LEN 249 /* ASCII: "tls13 ", in hex for EBCDIC compatibility */ static const unsigned char label_prefix[] = "\x74\x6C\x73\x31\x33\x20"; /* * Given a |secret|; a |label| of length |labellen|; and |data| of length * |datalen| (e.g. typically a hash of the handshake messages), derive a new * secret |outlen| bytes long and store it in the location pointed to be |out|. * The |data| value may be zero length. Any errors will be treated as fatal if * |fatal| is set. Returns 1 on success 0 on failure. * If |raise_error| is set, ERR_raise is called on failure. */ int tls13_hkdf_expand_ex(OSSL_LIB_CTX *libctx, const char *propq, const EVP_MD *md, const unsigned char *secret, const unsigned char *label, size_t labellen, const unsigned char *data, size_t datalen, unsigned char *out, size_t outlen, int raise_error) { EVP_KDF *kdf = EVP_KDF_fetch(libctx, OSSL_KDF_NAME_TLS1_3_KDF, propq); EVP_KDF_CTX *kctx; OSSL_PARAM params[7], *p = params; int mode = EVP_PKEY_HKDEF_MODE_EXPAND_ONLY; const char *mdname = EVP_MD_get0_name(md); int ret; size_t hashlen; kctx = EVP_KDF_CTX_new(kdf); EVP_KDF_free(kdf); if (kctx == NULL) return 0; if (labellen > TLS13_MAX_LABEL_LEN) { if (raise_error) /* * Probably we have been called from SSL_export_keying_material(), * or SSL_export_keying_material_early(). */ ERR_raise(ERR_LIB_SSL, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL); EVP_KDF_CTX_free(kctx); return 0; } if ((ret = EVP_MD_get_size(md)) <= 0) { EVP_KDF_CTX_free(kctx); if (raise_error) ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } hashlen = (size_t)ret; *p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode); *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char *)mdname, 0); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, (unsigned char *)secret, hashlen); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_PREFIX, (unsigned char *)label_prefix, sizeof(label_prefix) - 1); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_LABEL, (unsigned char *)label, labellen); if (data != NULL) *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_DATA, (unsigned char *)data, datalen); *p++ = OSSL_PARAM_construct_end(); ret = EVP_KDF_derive(kctx, out, outlen, params) <= 0; EVP_KDF_CTX_free(kctx); if (ret != 0) { if (raise_error) ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); } return ret == 0; } int tls13_hkdf_expand(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *secret, const unsigned char *label, size_t labellen, const unsigned char *data, size_t datalen, unsigned char *out, size_t outlen, int fatal) { int ret; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); ret = tls13_hkdf_expand_ex(sctx->libctx, sctx->propq, md, secret, label, labellen, data, datalen, out, outlen, !fatal); if (ret == 0 && fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return ret; } /* * Given a |secret| generate a |key| of length |keylen| bytes. Returns 1 on * success 0 on failure. */ int tls13_derive_key(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *secret, unsigned char *key, size_t keylen) { /* ASCII: "key", in hex for EBCDIC compatibility */ static const unsigned char keylabel[] = "\x6B\x65\x79"; return tls13_hkdf_expand(s, md, secret, keylabel, sizeof(keylabel) - 1, NULL, 0, key, keylen, 1); } /* * Given a |secret| generate an |iv| of length |ivlen| bytes. Returns 1 on * success 0 on failure. */ int tls13_derive_iv(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *secret, unsigned char *iv, size_t ivlen) { /* ASCII: "iv", in hex for EBCDIC compatibility */ static const unsigned char ivlabel[] = "\x69\x76"; return tls13_hkdf_expand(s, md, secret, ivlabel, sizeof(ivlabel) - 1, NULL, 0, iv, ivlen, 1); } int tls13_derive_finishedkey(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *secret, unsigned char *fin, size_t finlen) { /* ASCII: "finished", in hex for EBCDIC compatibility */ static const unsigned char finishedlabel[] = "\x66\x69\x6E\x69\x73\x68\x65\x64"; return tls13_hkdf_expand(s, md, secret, finishedlabel, sizeof(finishedlabel) - 1, NULL, 0, fin, finlen, 1); } /* * Given the previous secret |prevsecret| and a new input secret |insecret| of * length |insecretlen|, generate a new secret and store it in the location * pointed to by |outsecret|. Returns 1 on success 0 on failure. */ int tls13_generate_secret(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *prevsecret, const unsigned char *insecret, size_t insecretlen, unsigned char *outsecret) { size_t mdlen; int mdleni; int ret; EVP_KDF *kdf; EVP_KDF_CTX *kctx; OSSL_PARAM params[7], *p = params; int mode = EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY; const char *mdname = EVP_MD_get0_name(md); /* ASCII: "derived", in hex for EBCDIC compatibility */ static const char derived_secret_label[] = "\x64\x65\x72\x69\x76\x65\x64"; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); kdf = EVP_KDF_fetch(sctx->libctx, OSSL_KDF_NAME_TLS1_3_KDF, sctx->propq); kctx = EVP_KDF_CTX_new(kdf); EVP_KDF_free(kdf); if (kctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } mdleni = EVP_MD_get_size(md); /* Ensure cast to size_t is safe */ if (!ossl_assert(mdleni >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_KDF_CTX_free(kctx); return 0; } mdlen = (size_t)mdleni; *p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode); *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char *)mdname, 0); if (insecret != NULL) *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, (unsigned char *)insecret, insecretlen); if (prevsecret != NULL) *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT, (unsigned char *)prevsecret, mdlen); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_PREFIX, (unsigned char *)label_prefix, sizeof(label_prefix) - 1); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_LABEL, (unsigned char *)derived_secret_label, sizeof(derived_secret_label) - 1); *p++ = OSSL_PARAM_construct_end(); ret = EVP_KDF_derive(kctx, outsecret, mdlen, params) <= 0; if (ret != 0) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_KDF_CTX_free(kctx); return ret == 0; } /* * Given an input secret |insecret| of length |insecretlen| generate the * handshake secret. This requires the early secret to already have been * generated. Returns 1 on success 0 on failure. */ int tls13_generate_handshake_secret(SSL_CONNECTION *s, const unsigned char *insecret, size_t insecretlen) { /* Calls SSLfatal() if required */ return tls13_generate_secret(s, ssl_handshake_md(s), s->early_secret, insecret, insecretlen, (unsigned char *)&s->handshake_secret); } /* * Given the handshake secret |prev| of length |prevlen| generate the master * secret and store its length in |*secret_size|. Returns 1 on success 0 on * failure. */ int tls13_generate_master_secret(SSL_CONNECTION *s, unsigned char *out, unsigned char *prev, size_t prevlen, size_t *secret_size) { const EVP_MD *md = ssl_handshake_md(s); *secret_size = EVP_MD_get_size(md); /* Calls SSLfatal() if required */ return tls13_generate_secret(s, md, prev, NULL, 0, out); } /* * Generates the mac for the Finished message. Returns the length of the MAC or * 0 on error. */ size_t tls13_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen, unsigned char *out) { const EVP_MD *md = ssl_handshake_md(s); const char *mdname = EVP_MD_get0_name(md); unsigned char hash[EVP_MAX_MD_SIZE]; unsigned char finsecret[EVP_MAX_MD_SIZE]; unsigned char *key = NULL; size_t len = 0, hashlen; OSSL_PARAM params[2], *p = params; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (md == NULL) return 0; /* Safe to cast away const here since we're not "getting" any data */ if (sctx->propq != NULL) *p++ = OSSL_PARAM_construct_utf8_string(OSSL_ALG_PARAM_PROPERTIES, (char *)sctx->propq, 0); *p = OSSL_PARAM_construct_end(); if (!ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) { /* SSLfatal() already called */ goto err; } if (str == SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->server_finished_label) { key = s->server_finished_secret; } else if (SSL_IS_FIRST_HANDSHAKE(s)) { key = s->client_finished_secret; } else { if (!tls13_derive_finishedkey(s, md, s->client_app_traffic_secret, finsecret, hashlen)) goto err; key = finsecret; } if (!EVP_Q_mac(sctx->libctx, "HMAC", sctx->propq, mdname, params, key, hashlen, hash, hashlen, /* outsize as per sizeof(peer_finish_md) */ out, EVP_MAX_MD_SIZE * 2, &len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } err: OPENSSL_cleanse(finsecret, sizeof(finsecret)); return len; } /* * There isn't really a key block in TLSv1.3, but we still need this function * for initialising the cipher and hash. Returns 1 on success or 0 on failure. */ int tls13_setup_key_block(SSL_CONNECTION *s) { const EVP_CIPHER *c; const EVP_MD *hash; s->session->cipher = s->s3.tmp.new_cipher; if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash, NULL, NULL, NULL, 0)) { /* Error is already recorded */ SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); return 0; } ssl_evp_cipher_free(s->s3.tmp.new_sym_enc); s->s3.tmp.new_sym_enc = c; ssl_evp_md_free(s->s3.tmp.new_hash); s->s3.tmp.new_hash = hash; return 1; } static int derive_secret_key_and_iv(SSL_CONNECTION *s, const EVP_MD *md, const EVP_CIPHER *ciph, const unsigned char *insecret, const unsigned char *hash, const unsigned char *label, size_t labellen, unsigned char *secret, unsigned char *key, size_t *keylen, unsigned char *iv, size_t *ivlen, size_t *taglen) { int hashleni = EVP_MD_get_size(md); size_t hashlen; int mode; /* Ensure cast to size_t is safe */ if (!ossl_assert(hashleni >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } hashlen = (size_t)hashleni; if (!tls13_hkdf_expand(s, md, insecret, label, labellen, hash, hashlen, secret, hashlen, 1)) { /* SSLfatal() already called */ return 0; } *keylen = EVP_CIPHER_get_key_length(ciph); mode = EVP_CIPHER_get_mode(ciph); if (mode == EVP_CIPH_CCM_MODE) { uint32_t algenc; *ivlen = EVP_CCM_TLS_IV_LEN; if (s->s3.tmp.new_cipher != NULL) { algenc = s->s3.tmp.new_cipher->algorithm_enc; } else if (s->session->cipher != NULL) { /* We've not selected a cipher yet - we must be doing early data */ algenc = s->session->cipher->algorithm_enc; } else if (s->psksession != NULL && s->psksession->cipher != NULL) { /* We must be doing early data with out-of-band PSK */ algenc = s->psksession->cipher->algorithm_enc; } else { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } if (algenc & (SSL_AES128CCM8 | SSL_AES256CCM8)) *taglen = EVP_CCM8_TLS_TAG_LEN; else *taglen = EVP_CCM_TLS_TAG_LEN; } else { int iivlen; if (mode == EVP_CIPH_GCM_MODE) { *taglen = EVP_GCM_TLS_TAG_LEN; } else { /* CHACHA20P-POLY1305 */ *taglen = EVP_CHACHAPOLY_TLS_TAG_LEN; } iivlen = EVP_CIPHER_get_iv_length(ciph); if (iivlen < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } *ivlen = iivlen; } if (!tls13_derive_key(s, md, secret, key, *keylen) || !tls13_derive_iv(s, md, secret, iv, *ivlen)) { /* SSLfatal() already called */ return 0; } return 1; } int tls13_change_cipher_state(SSL_CONNECTION *s, int which) { /* ASCII: "c e traffic", in hex for EBCDIC compatibility */ static const unsigned char client_early_traffic[] = "\x63\x20\x65\x20\x74\x72\x61\x66\x66\x69\x63"; /* ASCII: "c hs traffic", in hex for EBCDIC compatibility */ static const unsigned char client_handshake_traffic[] = "\x63\x20\x68\x73\x20\x74\x72\x61\x66\x66\x69\x63"; /* ASCII: "c ap traffic", in hex for EBCDIC compatibility */ static const unsigned char client_application_traffic[] = "\x63\x20\x61\x70\x20\x74\x72\x61\x66\x66\x69\x63"; /* ASCII: "s hs traffic", in hex for EBCDIC compatibility */ static const unsigned char server_handshake_traffic[] = "\x73\x20\x68\x73\x20\x74\x72\x61\x66\x66\x69\x63"; /* ASCII: "s ap traffic", in hex for EBCDIC compatibility */ static const unsigned char server_application_traffic[] = "\x73\x20\x61\x70\x20\x74\x72\x61\x66\x66\x69\x63"; /* ASCII: "exp master", in hex for EBCDIC compatibility */ static const unsigned char exporter_master_secret[] = "\x65\x78\x70\x20\x6D\x61\x73\x74\x65\x72"; /* ASCII: "res master", in hex for EBCDIC compatibility */ static const unsigned char resumption_master_secret[] = "\x72\x65\x73\x20\x6D\x61\x73\x74\x65\x72"; /* ASCII: "e exp master", in hex for EBCDIC compatibility */ static const unsigned char early_exporter_master_secret[] = "\x65\x20\x65\x78\x70\x20\x6D\x61\x73\x74\x65\x72"; unsigned char iv[EVP_MAX_IV_LENGTH]; unsigned char key[EVP_MAX_KEY_LENGTH]; unsigned char secret[EVP_MAX_MD_SIZE]; unsigned char hashval[EVP_MAX_MD_SIZE]; unsigned char *hash = hashval; unsigned char *insecret; unsigned char *finsecret = NULL; const char *log_label = NULL; size_t finsecretlen = 0; const unsigned char *label; size_t labellen, hashlen = 0; int ret = 0; const EVP_MD *md = NULL; const EVP_CIPHER *cipher = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); size_t keylen, ivlen, taglen; int level; int direction = (which & SSL3_CC_READ) != 0 ? OSSL_RECORD_DIRECTION_READ : OSSL_RECORD_DIRECTION_WRITE; if (((which & SSL3_CC_CLIENT) && (which & SSL3_CC_WRITE)) || ((which & SSL3_CC_SERVER) && (which & SSL3_CC_READ))) { if (which & SSL3_CC_EARLY) { EVP_MD_CTX *mdctx = NULL; long handlen; void *hdata; unsigned int hashlenui; const SSL_CIPHER *sslcipher = SSL_SESSION_get0_cipher(s->session); insecret = s->early_secret; label = client_early_traffic; labellen = sizeof(client_early_traffic) - 1; log_label = CLIENT_EARLY_LABEL; handlen = BIO_get_mem_data(s->s3.handshake_buffer, &hdata); if (handlen <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_LENGTH); goto err; } if (s->early_data_state == SSL_EARLY_DATA_CONNECTING && s->max_early_data > 0 && s->session->ext.max_early_data == 0) { /* * If we are attempting to send early data, and we've decided to * actually do it but max_early_data in s->session is 0 then we * must be using an external PSK. */ if (!ossl_assert(s->psksession != NULL && s->max_early_data == s->psksession->ext.max_early_data)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } sslcipher = SSL_SESSION_get0_cipher(s->psksession); } if (sslcipher == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); goto err; } /* * We need to calculate the handshake digest using the digest from * the session. We haven't yet selected our ciphersuite so we can't * use ssl_handshake_md(). */ mdctx = EVP_MD_CTX_new(); if (mdctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } /* * This ups the ref count on cipher so we better make sure we free * it again */ if (!ssl_cipher_get_evp_cipher(sctx, sslcipher, &cipher)) { /* Error is already recorded */ SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); EVP_MD_CTX_free(mdctx); goto err; } md = ssl_md(sctx, sslcipher->algorithm2); if (md == NULL || !EVP_DigestInit_ex(mdctx, md, NULL) || !EVP_DigestUpdate(mdctx, hdata, handlen) || !EVP_DigestFinal_ex(mdctx, hashval, &hashlenui)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_MD_CTX_free(mdctx); goto err; } hashlen = hashlenui; EVP_MD_CTX_free(mdctx); if (!tls13_hkdf_expand(s, md, insecret, early_exporter_master_secret, sizeof(early_exporter_master_secret) - 1, hashval, hashlen, s->early_exporter_master_secret, hashlen, 1)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!ssl_log_secret(s, EARLY_EXPORTER_SECRET_LABEL, s->early_exporter_master_secret, hashlen)) { /* SSLfatal() already called */ goto err; } } else if (which & SSL3_CC_HANDSHAKE) { insecret = s->handshake_secret; finsecret = s->client_finished_secret; finsecretlen = EVP_MD_get_size(ssl_handshake_md(s)); label = client_handshake_traffic; labellen = sizeof(client_handshake_traffic) - 1; log_label = CLIENT_HANDSHAKE_LABEL; /* * The handshake hash used for the server read/client write handshake * traffic secret is the same as the hash for the server * write/client read handshake traffic secret. However, if we * processed early data then we delay changing the server * read/client write cipher state until later, and the handshake * hashes have moved on. Therefore we use the value saved earlier * when we did the server write/client read change cipher state. */ hash = s->handshake_traffic_hash; } else { insecret = s->master_secret; label = client_application_traffic; labellen = sizeof(client_application_traffic) - 1; log_label = CLIENT_APPLICATION_LABEL; /* * For this we only use the handshake hashes up until the server * Finished hash. We do not include the client's Finished, which is * what ssl_handshake_hash() would give us. Instead we use the * previously saved value. */ hash = s->server_finished_hash; } } else { /* Early data never applies to client-read/server-write */ if (which & SSL3_CC_HANDSHAKE) { insecret = s->handshake_secret; finsecret = s->server_finished_secret; finsecretlen = EVP_MD_get_size(ssl_handshake_md(s)); label = server_handshake_traffic; labellen = sizeof(server_handshake_traffic) - 1; log_label = SERVER_HANDSHAKE_LABEL; } else { insecret = s->master_secret; label = server_application_traffic; labellen = sizeof(server_application_traffic) - 1; log_label = SERVER_APPLICATION_LABEL; } } if (!(which & SSL3_CC_EARLY)) { md = ssl_handshake_md(s); cipher = s->s3.tmp.new_sym_enc; if (!ssl3_digest_cached_records(s, 1) || !ssl_handshake_hash(s, hashval, sizeof(hashval), &hashlen)) { /* SSLfatal() already called */; goto err; } } /* * Save the hash of handshakes up to now for use when we calculate the * client application traffic secret */ if (label == server_application_traffic) memcpy(s->server_finished_hash, hashval, hashlen); if (label == server_handshake_traffic) memcpy(s->handshake_traffic_hash, hashval, hashlen); if (label == client_application_traffic) { /* * We also create the resumption master secret, but this time use the * hash for the whole handshake including the Client Finished */ if (!tls13_hkdf_expand(s, ssl_handshake_md(s), insecret, resumption_master_secret, sizeof(resumption_master_secret) - 1, hashval, hashlen, s->resumption_master_secret, hashlen, 1)) { /* SSLfatal() already called */ goto err; } } /* check whether cipher is known */ if (!ossl_assert(cipher != NULL)) goto err; if (!derive_secret_key_and_iv(s, md, cipher, insecret, hash, label, labellen, secret, key, &keylen, iv, &ivlen, &taglen)) { /* SSLfatal() already called */ goto err; } if (label == server_application_traffic) { memcpy(s->server_app_traffic_secret, secret, hashlen); /* Now we create the exporter master secret */ if (!tls13_hkdf_expand(s, ssl_handshake_md(s), insecret, exporter_master_secret, sizeof(exporter_master_secret) - 1, hash, hashlen, s->exporter_master_secret, hashlen, 1)) { /* SSLfatal() already called */ goto err; } if (!ssl_log_secret(s, EXPORTER_SECRET_LABEL, s->exporter_master_secret, hashlen)) { /* SSLfatal() already called */ goto err; } } else if (label == client_application_traffic) memcpy(s->client_app_traffic_secret, secret, hashlen); if (!ssl_log_secret(s, log_label, secret, hashlen)) { /* SSLfatal() already called */ goto err; } if (finsecret != NULL && !tls13_derive_finishedkey(s, ssl_handshake_md(s), secret, finsecret, finsecretlen)) { /* SSLfatal() already called */ goto err; } if ((which & SSL3_CC_WRITE) != 0) { if (!s->server && label == client_early_traffic) s->rlayer.wrlmethod->set_plain_alerts(s->rlayer.wrl, 1); else s->rlayer.wrlmethod->set_plain_alerts(s->rlayer.wrl, 0); } level = (which & SSL3_CC_EARLY) != 0 ? OSSL_RECORD_PROTECTION_LEVEL_EARLY : ((which &SSL3_CC_HANDSHAKE) != 0 ? OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE : OSSL_RECORD_PROTECTION_LEVEL_APPLICATION); if (!ssl_set_new_record_layer(s, s->version, direction, level, secret, hashlen, key, keylen, iv, ivlen, NULL, 0, cipher, taglen, NID_undef, NULL, NULL, md)) { /* SSLfatal already called */ goto err; } ret = 1; err: if ((which & SSL3_CC_EARLY) != 0) { /* We up-refed this so now we need to down ref */ ssl_evp_cipher_free(cipher); } OPENSSL_cleanse(key, sizeof(key)); OPENSSL_cleanse(secret, sizeof(secret)); return ret; } int tls13_update_key(SSL_CONNECTION *s, int sending) { /* ASCII: "traffic upd", in hex for EBCDIC compatibility */ static const unsigned char application_traffic[] = "\x74\x72\x61\x66\x66\x69\x63\x20\x75\x70\x64"; const EVP_MD *md = ssl_handshake_md(s); size_t hashlen; unsigned char key[EVP_MAX_KEY_LENGTH]; unsigned char *insecret; unsigned char secret[EVP_MAX_MD_SIZE]; char *log_label; size_t keylen, ivlen, taglen; int ret = 0, l; int direction = sending ? OSSL_RECORD_DIRECTION_WRITE : OSSL_RECORD_DIRECTION_READ; unsigned char iv[EVP_MAX_IV_LENGTH]; if ((l = EVP_MD_get_size(md)) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } hashlen = (size_t)l; if (s->server == sending) insecret = s->server_app_traffic_secret; else insecret = s->client_app_traffic_secret; if (!derive_secret_key_and_iv(s, md, s->s3.tmp.new_sym_enc, insecret, NULL, application_traffic, sizeof(application_traffic) - 1, secret, key, &keylen, iv, &ivlen, &taglen)) { /* SSLfatal() already called */ goto err; } memcpy(insecret, secret, hashlen); if (!ssl_set_new_record_layer(s, s->version, direction, OSSL_RECORD_PROTECTION_LEVEL_APPLICATION, insecret, hashlen, key, keylen, iv, ivlen, NULL, 0, s->s3.tmp.new_sym_enc, taglen, NID_undef, NULL, NULL, md)) { /* SSLfatal already called */ goto err; } /* Call Key log on successful traffic secret update */ log_label = s->server == sending ? SERVER_APPLICATION_N_LABEL : CLIENT_APPLICATION_N_LABEL; if (!ssl_log_secret(s, log_label, secret, hashlen)) { /* SSLfatal() already called */ goto err; } ret = 1; err: OPENSSL_cleanse(key, sizeof(key)); OPENSSL_cleanse(secret, sizeof(secret)); return ret; } int tls13_alert_code(int code) { /* There are 2 additional alerts in TLSv1.3 compared to TLSv1.2 */ if (code == SSL_AD_MISSING_EXTENSION || code == SSL_AD_CERTIFICATE_REQUIRED) return code; return tls1_alert_code(code); } int tls13_export_keying_material(SSL_CONNECTION *s, unsigned char *out, size_t olen, const char *label, size_t llen, const unsigned char *context, size_t contextlen, int use_context) { unsigned char exportsecret[EVP_MAX_MD_SIZE]; /* ASCII: "exporter", in hex for EBCDIC compatibility */ static const unsigned char exporterlabel[] = "\x65\x78\x70\x6F\x72\x74\x65\x72"; unsigned char hash[EVP_MAX_MD_SIZE], data[EVP_MAX_MD_SIZE]; const EVP_MD *md = ssl_handshake_md(s); EVP_MD_CTX *ctx = EVP_MD_CTX_new(); unsigned int hashsize, datalen; int ret = 0; if (ctx == NULL || md == NULL || !ossl_statem_export_allowed(s)) goto err; if (!use_context) contextlen = 0; if (EVP_DigestInit_ex(ctx, md, NULL) <= 0 || EVP_DigestUpdate(ctx, context, contextlen) <= 0 || EVP_DigestFinal_ex(ctx, hash, &hashsize) <= 0 || EVP_DigestInit_ex(ctx, md, NULL) <= 0 || EVP_DigestFinal_ex(ctx, data, &datalen) <= 0 || !tls13_hkdf_expand(s, md, s->exporter_master_secret, (const unsigned char *)label, llen, data, datalen, exportsecret, hashsize, 0) || !tls13_hkdf_expand(s, md, exportsecret, exporterlabel, sizeof(exporterlabel) - 1, hash, hashsize, out, olen, 0)) goto err; ret = 1; err: EVP_MD_CTX_free(ctx); return ret; } int tls13_export_keying_material_early(SSL_CONNECTION *s, unsigned char *out, size_t olen, const char *label, size_t llen, const unsigned char *context, size_t contextlen) { /* ASCII: "exporter", in hex for EBCDIC compatibility */ static const unsigned char exporterlabel[] = "\x65\x78\x70\x6F\x72\x74\x65\x72"; unsigned char exportsecret[EVP_MAX_MD_SIZE]; unsigned char hash[EVP_MAX_MD_SIZE], data[EVP_MAX_MD_SIZE]; const EVP_MD *md; EVP_MD_CTX *ctx = EVP_MD_CTX_new(); unsigned int hashsize, datalen; int ret = 0; const SSL_CIPHER *sslcipher; if (ctx == NULL || !ossl_statem_export_early_allowed(s)) goto err; if (!s->server && s->max_early_data > 0 && s->session->ext.max_early_data == 0) sslcipher = SSL_SESSION_get0_cipher(s->psksession); else sslcipher = SSL_SESSION_get0_cipher(s->session); md = ssl_md(SSL_CONNECTION_GET_CTX(s), sslcipher->algorithm2); /* * Calculate the hash value and store it in |data|. The reason why * the empty string is used is that the definition of TLS-Exporter * is like so: * * TLS-Exporter(label, context_value, key_length) = * HKDF-Expand-Label(Derive-Secret(Secret, label, ""), * "exporter", Hash(context_value), key_length) * * Derive-Secret(Secret, Label, Messages) = * HKDF-Expand-Label(Secret, Label, * Transcript-Hash(Messages), Hash.length) * * Here Transcript-Hash is the cipher suite hash algorithm. */ if (md == NULL || EVP_DigestInit_ex(ctx, md, NULL) <= 0 || EVP_DigestUpdate(ctx, context, contextlen) <= 0 || EVP_DigestFinal_ex(ctx, hash, &hashsize) <= 0 || EVP_DigestInit_ex(ctx, md, NULL) <= 0 || EVP_DigestFinal_ex(ctx, data, &datalen) <= 0 || !tls13_hkdf_expand(s, md, s->early_exporter_master_secret, (const unsigned char *)label, llen, data, datalen, exportsecret, hashsize, 0) || !tls13_hkdf_expand(s, md, exportsecret, exporterlabel, sizeof(exporterlabel) - 1, hash, hashsize, out, olen, 0)) goto err; ret = 1; err: EVP_MD_CTX_free(ctx); return ret; }

./openssl/ssl/tls_depr.c

/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* We need to use some engine and HMAC deprecated APIs */ #define OPENSSL_SUPPRESS_DEPRECATED #include <openssl/engine.h> #include "ssl_local.h" /* * Engine APIs are only used to support applications that still use ENGINEs. * Once ENGINE is removed completely, all of this code can also be removed. */ #ifndef OPENSSL_NO_ENGINE void tls_engine_finish(ENGINE *e) { ENGINE_finish(e); } #endif const EVP_CIPHER *tls_get_cipher_from_engine(int nid) { const EVP_CIPHER *ret = NULL; #ifndef OPENSSL_NO_ENGINE ENGINE *eng; /* * If there is an Engine available for this cipher we use the "implicit" * form to ensure we use that engine later. */ eng = ENGINE_get_cipher_engine(nid); if (eng != NULL) { ret = ENGINE_get_cipher(eng, nid); ENGINE_finish(eng); } #endif return ret; } const EVP_MD *tls_get_digest_from_engine(int nid) { const EVP_MD *ret = NULL; #ifndef OPENSSL_NO_ENGINE ENGINE *eng; /* * If there is an Engine available for this digest we use the "implicit" * form to ensure we use that engine later. */ eng = ENGINE_get_digest_engine(nid); if (eng != NULL) { ret = ENGINE_get_digest(eng, nid); ENGINE_finish(eng); } #endif return ret; } #ifndef OPENSSL_NO_ENGINE int tls_engine_load_ssl_client_cert(SSL_CONNECTION *s, X509 **px509, EVP_PKEY **ppkey) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); return ENGINE_load_ssl_client_cert(SSL_CONNECTION_GET_CTX(s)->client_cert_engine, ssl, SSL_get_client_CA_list(ssl), px509, ppkey, NULL, NULL, NULL); } #endif #ifndef OPENSSL_NO_ENGINE int SSL_CTX_set_client_cert_engine(SSL_CTX *ctx, ENGINE *e) { if (!ENGINE_init(e)) { ERR_raise(ERR_LIB_SSL, ERR_R_ENGINE_LIB); return 0; } if (!ENGINE_get_ssl_client_cert_function(e)) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CLIENT_CERT_METHOD); ENGINE_finish(e); return 0; } ctx->client_cert_engine = e; return 1; } #endif /* * The HMAC APIs below are only used to support the deprecated public API * macro SSL_CTX_set_tlsext_ticket_key_cb(). The application supplied callback * takes an HMAC_CTX in its argument list. The preferred alternative is * SSL_CTX_set_tlsext_ticket_key_evp_cb(). Once * SSL_CTX_set_tlsext_ticket_key_cb() is removed, then all of this code can also * be removed. */ #ifndef OPENSSL_NO_DEPRECATED_3_0 int ssl_hmac_old_new(SSL_HMAC *ret) { ret->old_ctx = HMAC_CTX_new(); if (ret->old_ctx == NULL) return 0; return 1; } void ssl_hmac_old_free(SSL_HMAC *ctx) { HMAC_CTX_free(ctx->old_ctx); } int ssl_hmac_old_init(SSL_HMAC *ctx, void *key, size_t len, char *md) { return HMAC_Init_ex(ctx->old_ctx, key, len, EVP_get_digestbyname(md), NULL); } int ssl_hmac_old_update(SSL_HMAC *ctx, const unsigned char *data, size_t len) { return HMAC_Update(ctx->old_ctx, data, len); } int ssl_hmac_old_final(SSL_HMAC *ctx, unsigned char *md, size_t *len) { unsigned int l; if (HMAC_Final(ctx->old_ctx, md, &l) > 0) { if (len != NULL) *len = l; return 1; } return 0; } size_t ssl_hmac_old_size(const SSL_HMAC *ctx) { return HMAC_size(ctx->old_ctx); } HMAC_CTX *ssl_hmac_get0_HMAC_CTX(SSL_HMAC *ctx) { return ctx->old_ctx; } /* Some deprecated public APIs pass DH objects */ EVP_PKEY *ssl_dh_to_pkey(DH *dh) { # ifndef OPENSSL_NO_DH EVP_PKEY *ret; if (dh == NULL) return NULL; ret = EVP_PKEY_new(); if (EVP_PKEY_set1_DH(ret, dh) <= 0) { EVP_PKEY_free(ret); return NULL; } return ret; # else return NULL; # endif } /* Some deprecated public APIs pass EC_KEY objects */ int ssl_set_tmp_ecdh_groups(uint16_t **pext, size_t *pextlen, void *key) { # ifndef OPENSSL_NO_EC const EC_GROUP *group = EC_KEY_get0_group((const EC_KEY *)key); int nid; if (group == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_MISSING_PARAMETERS); return 0; } nid = EC_GROUP_get_curve_name(group); if (nid == NID_undef) return 0; return tls1_set_groups(pext, pextlen, &nid, 1); # else return 0; # endif } /* * Set the callback for generating temporary DH keys. * ctx: the SSL context. * dh: the callback */ # if !defined(OPENSSL_NO_DH) void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx, DH *(*dh) (SSL *ssl, int is_export, int keylength)) { SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh); } void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export, int keylength)) { SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh); } # endif #endif /* OPENSSL_NO_DEPRECATED */

./openssl/ssl/bio_ssl.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <openssl/crypto.h> #include "internal/bio.h" #include <openssl/err.h> #include "ssl_local.h" static int ssl_write(BIO *h, const char *buf, size_t size, size_t *written); static int ssl_read(BIO *b, char *buf, size_t size, size_t *readbytes); static int ssl_puts(BIO *h, const char *str); static long ssl_ctrl(BIO *h, int cmd, long arg1, void *arg2); static int ssl_new(BIO *h); static int ssl_free(BIO *data); static long ssl_callback_ctrl(BIO *h, int cmd, BIO_info_cb *fp); typedef struct bio_ssl_st { SSL *ssl; /* The ssl handle :-) */ /* * Re-negotiate every time the total number of bytes is this size * or when timeout expires. * There is no proper support for TLS-1.3 or QUIC yet. */ int num_renegotiates; unsigned long renegotiate_count; size_t byte_count; unsigned long renegotiate_timeout; unsigned long last_time; } BIO_SSL; static const BIO_METHOD methods_sslp = { BIO_TYPE_SSL, "ssl", ssl_write, NULL, /* ssl_write_old, */ ssl_read, NULL, /* ssl_read_old, */ ssl_puts, NULL, /* ssl_gets, */ ssl_ctrl, ssl_new, ssl_free, ssl_callback_ctrl, }; const BIO_METHOD *BIO_f_ssl(void) { return &methods_sslp; } static int ssl_new(BIO *bi) { BIO_SSL *bs = OPENSSL_zalloc(sizeof(*bs)); if (bs == NULL) return 0; BIO_set_init(bi, 0); BIO_set_data(bi, bs); /* Clear all flags */ BIO_clear_flags(bi, ~0); return 1; } static int ssl_free(BIO *a) { BIO_SSL *bs; if (a == NULL) return 0; bs = BIO_get_data(a); if (BIO_get_shutdown(a)) { if (bs->ssl != NULL) SSL_shutdown(bs->ssl); if (BIO_get_init(a)) SSL_free(bs->ssl); BIO_clear_flags(a, ~0); /* Clear all flags */ BIO_set_init(a, 0); } OPENSSL_free(bs); return 1; } static int ssl_read(BIO *b, char *buf, size_t size, size_t *readbytes) { int ret = 1; BIO_SSL *sb; SSL *ssl; int retry_reason = 0; int r = 0; if (buf == NULL) return 0; sb = BIO_get_data(b); ssl = sb->ssl; BIO_clear_retry_flags(b); ret = ssl_read_internal(ssl, buf, size, readbytes); switch (SSL_get_error(ssl, ret)) { case SSL_ERROR_NONE: if (sb->renegotiate_count > 0) { sb->byte_count += *readbytes; if (sb->byte_count > sb->renegotiate_count) { sb->byte_count = 0; sb->num_renegotiates++; SSL_renegotiate(ssl); r = 1; } } if ((sb->renegotiate_timeout > 0) && (!r)) { unsigned long tm; tm = (unsigned long)time(NULL); if (tm > sb->last_time + sb->renegotiate_timeout) { sb->last_time = tm; sb->num_renegotiates++; SSL_renegotiate(ssl); } } break; case SSL_ERROR_WANT_READ: BIO_set_retry_read(b); break; case SSL_ERROR_WANT_WRITE: BIO_set_retry_write(b); break; case SSL_ERROR_WANT_X509_LOOKUP: BIO_set_retry_special(b); retry_reason = BIO_RR_SSL_X509_LOOKUP; break; case SSL_ERROR_WANT_ACCEPT: BIO_set_retry_special(b); retry_reason = BIO_RR_ACCEPT; break; case SSL_ERROR_WANT_CONNECT: BIO_set_retry_special(b); retry_reason = BIO_RR_CONNECT; break; case SSL_ERROR_SYSCALL: case SSL_ERROR_SSL: case SSL_ERROR_ZERO_RETURN: default: break; } BIO_set_retry_reason(b, retry_reason); return ret; } static int ssl_write(BIO *b, const char *buf, size_t size, size_t *written) { int ret, r = 0; int retry_reason = 0; SSL *ssl; BIO_SSL *bs; if (buf == NULL) return 0; bs = BIO_get_data(b); ssl = bs->ssl; BIO_clear_retry_flags(b); ret = ssl_write_internal(ssl, buf, size, written); switch (SSL_get_error(ssl, ret)) { case SSL_ERROR_NONE: if (bs->renegotiate_count > 0) { bs->byte_count += *written; if (bs->byte_count > bs->renegotiate_count) { bs->byte_count = 0; bs->num_renegotiates++; SSL_renegotiate(ssl); r = 1; } } if ((bs->renegotiate_timeout > 0) && (!r)) { unsigned long tm; tm = (unsigned long)time(NULL); if (tm > bs->last_time + bs->renegotiate_timeout) { bs->last_time = tm; bs->num_renegotiates++; SSL_renegotiate(ssl); } } break; case SSL_ERROR_WANT_WRITE: BIO_set_retry_write(b); break; case SSL_ERROR_WANT_READ: BIO_set_retry_read(b); break; case SSL_ERROR_WANT_X509_LOOKUP: BIO_set_retry_special(b); retry_reason = BIO_RR_SSL_X509_LOOKUP; break; case SSL_ERROR_WANT_CONNECT: BIO_set_retry_special(b); retry_reason = BIO_RR_CONNECT; case SSL_ERROR_SYSCALL: case SSL_ERROR_SSL: default: break; } BIO_set_retry_reason(b, retry_reason); return ret; } static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr) { SSL **sslp, *ssl; BIO_SSL *bs, *dbs; BIO *dbio, *bio; long ret = 1; BIO *next; SSL_CONNECTION *sc = NULL; bs = BIO_get_data(b); next = BIO_next(b); ssl = bs->ssl; if (ssl == NULL && cmd != BIO_C_SET_SSL) return 0; switch (cmd) { case BIO_CTRL_RESET: /* TODO(QUIC FUTURE): Add support when SSL_clear() is supported */ if ((sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl)) == NULL) return 0; SSL_shutdown(ssl); if (sc->handshake_func == ssl->method->ssl_connect) SSL_set_connect_state(ssl); else if (sc->handshake_func == ssl->method->ssl_accept) SSL_set_accept_state(ssl); if (!SSL_clear(ssl)) { ret = 0; break; } if (next != NULL) ret = BIO_ctrl(next, cmd, num, ptr); else if (sc->rbio != NULL) ret = BIO_ctrl(sc->rbio, cmd, num, ptr); else ret = 1; break; case BIO_CTRL_INFO: ret = 0; break; case BIO_C_SSL_MODE: if (num) /* client mode */ SSL_set_connect_state(ssl); else SSL_set_accept_state(ssl); break; case BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT: ret = bs->renegotiate_timeout; if (num < 60) num = 5; bs->renegotiate_timeout = (unsigned long)num; bs->last_time = (unsigned long)time(NULL); break; case BIO_C_SET_SSL_RENEGOTIATE_BYTES: ret = bs->renegotiate_count; if ((long)num >= 512) bs->renegotiate_count = (unsigned long)num; break; case BIO_C_GET_SSL_NUM_RENEGOTIATES: ret = bs->num_renegotiates; break; case BIO_C_SET_SSL: if (ssl != NULL) { ssl_free(b); if (!ssl_new(b)) return 0; bs = BIO_get_data(b); } BIO_set_shutdown(b, num); ssl = (SSL *)ptr; bs->ssl = ssl; bio = SSL_get_rbio(ssl); if (bio != NULL) { if (next != NULL) BIO_push(bio, next); BIO_set_next(b, bio); BIO_up_ref(bio); } BIO_set_init(b, 1); break; case BIO_C_GET_SSL: if (ptr != NULL) { sslp = (SSL **)ptr; *sslp = ssl; } else ret = 0; break; case BIO_CTRL_GET_CLOSE: ret = BIO_get_shutdown(b); break; case BIO_CTRL_SET_CLOSE: BIO_set_shutdown(b, (int)num); break; case BIO_CTRL_WPENDING: ret = BIO_ctrl(SSL_get_wbio(ssl), cmd, num, ptr); break; case BIO_CTRL_PENDING: ret = SSL_pending(ssl); if (ret == 0) ret = BIO_pending(SSL_get_rbio(ssl)); break; case BIO_CTRL_FLUSH: BIO_clear_retry_flags(b); ret = BIO_ctrl(SSL_get_wbio(ssl), cmd, num, ptr); BIO_copy_next_retry(b); break; case BIO_CTRL_PUSH: if ((next != NULL) && (next != SSL_get_rbio(ssl))) { /* * We are going to pass ownership of next to the SSL object...but * we don't own a reference to pass yet - so up ref */ BIO_up_ref(next); SSL_set_bio(ssl, next, next); } break; case BIO_CTRL_POP: /* Only detach if we are the BIO explicitly being popped */ if (b == ptr) { /* This will clear the reference we obtained during push */ SSL_set_bio(ssl, NULL, NULL); } break; case BIO_C_DO_STATE_MACHINE: BIO_clear_retry_flags(b); BIO_set_retry_reason(b, 0); ret = (int)SSL_do_handshake(ssl); switch (SSL_get_error(ssl, (int)ret)) { case SSL_ERROR_WANT_READ: BIO_set_flags(b, BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY); break; case SSL_ERROR_WANT_WRITE: BIO_set_flags(b, BIO_FLAGS_WRITE | BIO_FLAGS_SHOULD_RETRY); break; case SSL_ERROR_WANT_CONNECT: BIO_set_flags(b, BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY); BIO_set_retry_reason(b, BIO_get_retry_reason(next)); break; case SSL_ERROR_WANT_X509_LOOKUP: BIO_set_retry_special(b); BIO_set_retry_reason(b, BIO_RR_SSL_X509_LOOKUP); break; default: break; } break; case BIO_CTRL_DUP: dbio = (BIO *)ptr; dbs = BIO_get_data(dbio); SSL_free(dbs->ssl); dbs->ssl = SSL_dup(ssl); dbs->num_renegotiates = bs->num_renegotiates; dbs->renegotiate_count = bs->renegotiate_count; dbs->byte_count = bs->byte_count; dbs->renegotiate_timeout = bs->renegotiate_timeout; dbs->last_time = bs->last_time; ret = (dbs->ssl != NULL); break; case BIO_C_GET_FD: ret = BIO_ctrl(SSL_get_rbio(ssl), cmd, num, ptr); break; case BIO_CTRL_SET_CALLBACK: ret = 0; /* use callback ctrl */ break; case BIO_CTRL_GET_RPOLL_DESCRIPTOR: if (!SSL_get_rpoll_descriptor(ssl, (BIO_POLL_DESCRIPTOR *)ptr)) ret = 0; break; case BIO_CTRL_GET_WPOLL_DESCRIPTOR: if (!SSL_get_wpoll_descriptor(ssl, (BIO_POLL_DESCRIPTOR *)ptr)) ret = 0; break; default: ret = BIO_ctrl(SSL_get_rbio(ssl), cmd, num, ptr); break; } return ret; } static long ssl_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp) { SSL *ssl; BIO_SSL *bs; long ret = 1; bs = BIO_get_data(b); ssl = bs->ssl; switch (cmd) { case BIO_CTRL_SET_CALLBACK: ret = BIO_callback_ctrl(SSL_get_rbio(ssl), cmd, fp); break; default: ret = 0; break; } return ret; } static int ssl_puts(BIO *bp, const char *str) { int n, ret; n = strlen(str); ret = BIO_write(bp, str, n); return ret; } BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx) { #ifndef OPENSSL_NO_SOCK BIO *ret = NULL, *buf = NULL, *ssl = NULL; # ifndef OPENSSL_NO_QUIC if (ctx != NULL && IS_QUIC_CTX(ctx)) /* Never use buffering for QUIC. */ return BIO_new_ssl_connect(ctx); # endif if ((buf = BIO_new(BIO_f_buffer())) == NULL) return NULL; if ((ssl = BIO_new_ssl_connect(ctx)) == NULL) goto err; if ((ret = BIO_push(buf, ssl)) == NULL) goto err; return ret; err: BIO_free(buf); BIO_free(ssl); #endif return NULL; } BIO *BIO_new_ssl_connect(SSL_CTX *ctx) { #ifndef OPENSSL_NO_SOCK BIO *ret = NULL, *con = NULL, *ssl = NULL; if ((con = BIO_new(BIO_s_connect())) == NULL) return NULL; # ifndef OPENSSL_NO_QUIC if (ctx != NULL && IS_QUIC_CTX(ctx)) if (!BIO_set_sock_type(con, SOCK_DGRAM)) goto err; #endif if ((ssl = BIO_new_ssl(ctx, 1)) == NULL) goto err; if ((ret = BIO_push(ssl, con)) == NULL) goto err; return ret; err: BIO_free(ssl); BIO_free(con); #endif return NULL; } BIO *BIO_new_ssl(SSL_CTX *ctx, int client) { BIO *ret; SSL *ssl; if ((ret = BIO_new(BIO_f_ssl())) == NULL) return NULL; if ((ssl = SSL_new(ctx)) == NULL) { BIO_free(ret); return NULL; } if (client) SSL_set_connect_state(ssl); else SSL_set_accept_state(ssl); BIO_set_ssl(ret, ssl, BIO_CLOSE); return ret; } int BIO_ssl_copy_session_id(BIO *t, BIO *f) { BIO_SSL *tdata, *fdata; t = BIO_find_type(t, BIO_TYPE_SSL); f = BIO_find_type(f, BIO_TYPE_SSL); if ((t == NULL) || (f == NULL)) return 0; tdata = BIO_get_data(t); fdata = BIO_get_data(f); if ((tdata->ssl == NULL) || (fdata->ssl == NULL)) return 0; if (!SSL_copy_session_id(tdata->ssl, (fdata->ssl))) return 0; return 1; } void BIO_ssl_shutdown(BIO *b) { BIO_SSL *bdata; for (; b != NULL; b = BIO_next(b)) { if (BIO_method_type(b) != BIO_TYPE_SSL) continue; bdata = BIO_get_data(b); if (bdata != NULL && bdata->ssl != NULL) SSL_shutdown(bdata->ssl); } }

./openssl/ssl/s3_msg.c

/* * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "ssl_local.h" int ssl3_do_change_cipher_spec(SSL_CONNECTION *s) { int i; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->server) i = SSL3_CHANGE_CIPHER_SERVER_READ; else i = SSL3_CHANGE_CIPHER_CLIENT_READ; if (s->s3.tmp.key_block == NULL) { if (s->session == NULL || s->session->master_key_length == 0) { /* might happen if dtls1_read_bytes() calls this */ ERR_raise(ERR_LIB_SSL, SSL_R_CCS_RECEIVED_EARLY); return 0; } s->session->cipher = s->s3.tmp.new_cipher; if (!ssl->method->ssl3_enc->setup_key_block(s)) { /* SSLfatal() already called */ return 0; } } if (!ssl->method->ssl3_enc->change_cipher_state(s, i)) { /* SSLfatal() already called */ return 0; } return 1; } int ssl3_send_alert(SSL_CONNECTION *s, int level, int desc) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* Map tls/ssl alert value to correct one */ if (SSL_CONNECTION_TREAT_AS_TLS13(s)) desc = tls13_alert_code(desc); else desc = ssl->method->ssl3_enc->alert_value(desc); if (s->version == SSL3_VERSION && desc == SSL_AD_PROTOCOL_VERSION) desc = SSL_AD_HANDSHAKE_FAILURE; /* SSL 3.0 does not have * protocol_version alerts */ if (desc < 0) return -1; if (s->shutdown & SSL_SENT_SHUTDOWN && desc != SSL_AD_CLOSE_NOTIFY) return -1; /* If a fatal one, remove from cache */ if ((level == SSL3_AL_FATAL) && (s->session != NULL)) SSL_CTX_remove_session(s->session_ctx, s->session); s->s3.alert_dispatch = SSL_ALERT_DISPATCH_PENDING; s->s3.send_alert[0] = level; s->s3.send_alert[1] = desc; if (!RECORD_LAYER_write_pending(&s->rlayer)) { /* data still being written out? */ return ssl->method->ssl_dispatch_alert(ssl); } /* * else data is still being written out, we will get written some time in * the future */ return -1; } int ssl3_dispatch_alert(SSL *s) { int i, j; void (*cb) (const SSL *ssl, int type, int val) = NULL; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); OSSL_RECORD_TEMPLATE templ; if (sc == NULL) return -1; if (sc->rlayer.wrlmethod == NULL) { /* No write record layer so we can't sent and alert. We just ignore it */ sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; return 1; } templ.type = SSL3_RT_ALERT; templ.version = (sc->version == TLS1_3_VERSION) ? TLS1_2_VERSION : sc->version; if (SSL_get_state(s) == TLS_ST_CW_CLNT_HELLO && !sc->renegotiate && TLS1_get_version(s) > TLS1_VERSION && sc->hello_retry_request == SSL_HRR_NONE) { templ.version = TLS1_VERSION; } templ.buf = &sc->s3.send_alert[0]; templ.buflen = 2; if (RECORD_LAYER_write_pending(&sc->rlayer)) { if (sc->s3.alert_dispatch != SSL_ALERT_DISPATCH_RETRY) { /* * We have a write pending but it wasn't from a previous call to * this function! Can we ever get here? Maybe via API misuse?? * Give up. */ sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; return -1; } /* Retry what we've already got pending */ i = HANDLE_RLAYER_WRITE_RETURN(sc, sc->rlayer.wrlmethod->retry_write_records(sc->rlayer.wrl)); if (i <= 0) { /* Could be NBIO. Keep alert_dispatch as SSL_ALERT_DISPATCH_RETRY */ return -1; } sc->rlayer.wpend_tot = 0; sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; return 1; } i = HANDLE_RLAYER_WRITE_RETURN(sc, sc->rlayer.wrlmethod->write_records(sc->rlayer.wrl, &templ, 1)); if (i <= 0) { sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_RETRY; sc->rlayer.wpend_tot = templ.buflen; sc->rlayer.wpend_type = templ.type; sc->rlayer.wpend_buf = templ.buf; } else { /* * Alert sent to BIO - now flush. If the message does not get sent due * to non-blocking IO, we will not worry too much. */ (void)BIO_flush(sc->wbio); sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; if (sc->msg_callback) sc->msg_callback(1, sc->version, SSL3_RT_ALERT, sc->s3.send_alert, 2, s, sc->msg_callback_arg); if (sc->info_callback != NULL) cb = sc->info_callback; else if (s->ctx->info_callback != NULL) cb = s->ctx->info_callback; if (cb != NULL) { j = (sc->s3.send_alert[0] << 8) | sc->s3.send_alert[1]; cb(s, SSL_CB_WRITE_ALERT, j); } } return i; }

./openssl/ssl/tls_srp.c

/* * Copyright 2004-2021 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2004, EdelKey Project. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html * * Originally written by Christophe Renou and Peter Sylvester, * for the EdelKey project. */ /* * We need to use the SRP deprecated APIs in order to implement the SSL SRP * APIs - which are themselves deprecated. */ #define OPENSSL_SUPPRESS_DEPRECATED #include <openssl/crypto.h> #include <openssl/rand.h> #include <openssl/err.h> #include "ssl_local.h" #ifndef OPENSSL_NO_SRP # include <openssl/srp.h> /* * The public API SSL_CTX_SRP_CTX_free() is deprecated so we use * ssl_ctx_srp_ctx_free_intern() internally. */ int ssl_ctx_srp_ctx_free_intern(SSL_CTX *ctx) { if (ctx == NULL) return 0; OPENSSL_free(ctx->srp_ctx.login); OPENSSL_free(ctx->srp_ctx.info); BN_free(ctx->srp_ctx.N); BN_free(ctx->srp_ctx.g); BN_free(ctx->srp_ctx.s); BN_free(ctx->srp_ctx.B); BN_free(ctx->srp_ctx.A); BN_free(ctx->srp_ctx.a); BN_free(ctx->srp_ctx.b); BN_free(ctx->srp_ctx.v); memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx)); ctx->srp_ctx.strength = SRP_MINIMAL_N; return 1; } int SSL_CTX_SRP_CTX_free(SSL_CTX *ctx) { return ssl_ctx_srp_ctx_free_intern(ctx); } /* * The public API SSL_SRP_CTX_free() is deprecated so we use * ssl_srp_ctx_free_intern() internally. */ int ssl_srp_ctx_free_intern(SSL_CONNECTION *s) { if (s == NULL) return 0; OPENSSL_free(s->srp_ctx.login); OPENSSL_free(s->srp_ctx.info); BN_free(s->srp_ctx.N); BN_free(s->srp_ctx.g); BN_free(s->srp_ctx.s); BN_free(s->srp_ctx.B); BN_free(s->srp_ctx.A); BN_free(s->srp_ctx.a); BN_free(s->srp_ctx.b); BN_free(s->srp_ctx.v); memset(&s->srp_ctx, 0, sizeof(s->srp_ctx)); s->srp_ctx.strength = SRP_MINIMAL_N; return 1; } int SSL_SRP_CTX_free(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); /* the call works with NULL sc */ return ssl_srp_ctx_free_intern(sc); } /* * The public API SSL_SRP_CTX_init() is deprecated so we use * ssl_srp_ctx_init_intern() internally. */ int ssl_srp_ctx_init_intern(SSL_CONNECTION *s) { SSL_CTX *ctx; if (s == NULL || (ctx = SSL_CONNECTION_GET_CTX(s)) == NULL) return 0; memset(&s->srp_ctx, 0, sizeof(s->srp_ctx)); s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg; /* set client Hello login callback */ s->srp_ctx.TLS_ext_srp_username_callback = ctx->srp_ctx.TLS_ext_srp_username_callback; /* set SRP N/g param callback for verification */ s->srp_ctx.SRP_verify_param_callback = ctx->srp_ctx.SRP_verify_param_callback; /* set SRP client passwd callback */ s->srp_ctx.SRP_give_srp_client_pwd_callback = ctx->srp_ctx.SRP_give_srp_client_pwd_callback; s->srp_ctx.strength = ctx->srp_ctx.strength; if (((ctx->srp_ctx.N != NULL) && ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) || ((ctx->srp_ctx.g != NULL) && ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) || ((ctx->srp_ctx.s != NULL) && ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) || ((ctx->srp_ctx.B != NULL) && ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) || ((ctx->srp_ctx.A != NULL) && ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) || ((ctx->srp_ctx.a != NULL) && ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) || ((ctx->srp_ctx.v != NULL) && ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) || ((ctx->srp_ctx.b != NULL) && ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL))) { ERR_raise(ERR_LIB_SSL, ERR_R_BN_LIB); goto err; } if ((ctx->srp_ctx.login != NULL) && ((s->srp_ctx.login = OPENSSL_strdup(ctx->srp_ctx.login)) == NULL)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); goto err; } if ((ctx->srp_ctx.info != NULL) && ((s->srp_ctx.info = OPENSSL_strdup(ctx->srp_ctx.info)) == NULL)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); goto err; } s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask; return 1; err: OPENSSL_free(s->srp_ctx.login); OPENSSL_free(s->srp_ctx.info); BN_free(s->srp_ctx.N); BN_free(s->srp_ctx.g); BN_free(s->srp_ctx.s); BN_free(s->srp_ctx.B); BN_free(s->srp_ctx.A); BN_free(s->srp_ctx.a); BN_free(s->srp_ctx.b); BN_free(s->srp_ctx.v); memset(&s->srp_ctx, 0, sizeof(s->srp_ctx)); return 0; } int SSL_SRP_CTX_init(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); /* the call works with NULL sc */ return ssl_srp_ctx_init_intern(sc); } /* * The public API SSL_CTX_SRP_CTX_init() is deprecated so we use * ssl_ctx_srp_ctx_init_intern() internally. */ int ssl_ctx_srp_ctx_init_intern(SSL_CTX *ctx) { if (ctx == NULL) return 0; memset(&ctx->srp_ctx, 0, sizeof(ctx->srp_ctx)); ctx->srp_ctx.strength = SRP_MINIMAL_N; return 1; } int SSL_CTX_SRP_CTX_init(SSL_CTX *ctx) { return ssl_ctx_srp_ctx_init_intern(ctx); } /* server side */ /* * The public API SSL_srp_server_param_with_username() is deprecated so we use * ssl_srp_server_param_with_username_intern() internally. */ int ssl_srp_server_param_with_username_intern(SSL_CONNECTION *s, int *ad) { unsigned char b[SSL_MAX_MASTER_KEY_LENGTH]; int al; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); *ad = SSL_AD_UNKNOWN_PSK_IDENTITY; if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) && ((al = s->srp_ctx.TLS_ext_srp_username_callback(SSL_CONNECTION_GET_SSL(s), ad, s->srp_ctx.SRP_cb_arg)) != SSL_ERROR_NONE)) return al; *ad = SSL_AD_INTERNAL_ERROR; if ((s->srp_ctx.N == NULL) || (s->srp_ctx.g == NULL) || (s->srp_ctx.s == NULL) || (s->srp_ctx.v == NULL)) return SSL3_AL_FATAL; if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, b, sizeof(b), 0) <= 0) return SSL3_AL_FATAL; s->srp_ctx.b = BN_bin2bn(b, sizeof(b), NULL); OPENSSL_cleanse(b, sizeof(b)); /* Calculate: B = (kv + g^b) % N */ return ((s->srp_ctx.B = SRP_Calc_B_ex(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g, s->srp_ctx.v, sctx->libctx, sctx->propq)) != NULL) ? SSL_ERROR_NONE : SSL3_AL_FATAL; } int SSL_srp_server_param_with_username(SSL *s, int *ad) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return SSL3_AL_FATAL; return ssl_srp_server_param_with_username_intern(sc, ad); } /* * If the server just has the raw password, make up a verifier entry on the * fly */ int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass, const char *grp) { SRP_gN *GN; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; GN = SRP_get_default_gN(grp); if (GN == NULL) return -1; sc->srp_ctx.N = BN_dup(GN->N); sc->srp_ctx.g = BN_dup(GN->g); BN_clear_free(sc->srp_ctx.v); sc->srp_ctx.v = NULL; BN_clear_free(sc->srp_ctx.s); sc->srp_ctx.s = NULL; if (!SRP_create_verifier_BN_ex(user, pass, &sc->srp_ctx.s, &sc->srp_ctx.v, sc->srp_ctx.N, sc->srp_ctx.g, s->ctx->libctx, s->ctx->propq)) return -1; return 1; } int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g, BIGNUM *sa, BIGNUM *v, char *info) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; if (N != NULL) { if (sc->srp_ctx.N != NULL) { if (!BN_copy(sc->srp_ctx.N, N)) { BN_free(sc->srp_ctx.N); sc->srp_ctx.N = NULL; } } else sc->srp_ctx.N = BN_dup(N); } if (g != NULL) { if (sc->srp_ctx.g != NULL) { if (!BN_copy(sc->srp_ctx.g, g)) { BN_free(sc->srp_ctx.g); sc->srp_ctx.g = NULL; } } else sc->srp_ctx.g = BN_dup(g); } if (sa != NULL) { if (sc->srp_ctx.s != NULL) { if (!BN_copy(sc->srp_ctx.s, sa)) { BN_free(sc->srp_ctx.s); sc->srp_ctx.s = NULL; } } else sc->srp_ctx.s = BN_dup(sa); } if (v != NULL) { if (sc->srp_ctx.v != NULL) { if (!BN_copy(sc->srp_ctx.v, v)) { BN_free(sc->srp_ctx.v); sc->srp_ctx.v = NULL; } } else sc->srp_ctx.v = BN_dup(v); } if (info != NULL) { if (sc->srp_ctx.info) OPENSSL_free(sc->srp_ctx.info); if ((sc->srp_ctx.info = OPENSSL_strdup(info)) == NULL) return -1; } if (!(sc->srp_ctx.N) || !(sc->srp_ctx.g) || !(sc->srp_ctx.s) || !(sc->srp_ctx.v)) return -1; return 1; } int srp_generate_server_master_secret(SSL_CONNECTION *s) { BIGNUM *K = NULL, *u = NULL; int ret = 0, tmp_len = 0; unsigned char *tmp = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (!SRP_Verify_A_mod_N(s->srp_ctx.A, s->srp_ctx.N)) goto err; if ((u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N, sctx->libctx, sctx->propq)) == NULL) goto err; if ((K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b, s->srp_ctx.N)) == NULL) goto err; tmp_len = BN_num_bytes(K); if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } BN_bn2bin(K, tmp); /* Calls SSLfatal() as required */ ret = ssl_generate_master_secret(s, tmp, tmp_len, 1); err: BN_clear_free(K); BN_clear_free(u); return ret; } /* client side */ int srp_generate_client_master_secret(SSL_CONNECTION *s) { BIGNUM *x = NULL, *u = NULL, *K = NULL; int ret = 0, tmp_len = 0; char *passwd = NULL; unsigned char *tmp = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* * Checks if b % n == 0 */ if (SRP_Verify_B_mod_N(s->srp_ctx.B, s->srp_ctx.N) == 0 || (u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N, sctx->libctx, sctx->propq)) == NULL || s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if ((passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(SSL_CONNECTION_GET_SSL(s), s->srp_ctx.SRP_cb_arg)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED); goto err; } if ((x = SRP_Calc_x_ex(s->srp_ctx.s, s->srp_ctx.login, passwd, sctx->libctx, sctx->propq)) == NULL || (K = SRP_Calc_client_key_ex(s->srp_ctx.N, s->srp_ctx.B, s->srp_ctx.g, x, s->srp_ctx.a, u, sctx->libctx, sctx->propq)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } tmp_len = BN_num_bytes(K); if ((tmp = OPENSSL_malloc(tmp_len)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } BN_bn2bin(K, tmp); /* Calls SSLfatal() as required */ ret = ssl_generate_master_secret(s, tmp, tmp_len, 1); err: BN_clear_free(K); BN_clear_free(x); if (passwd != NULL) OPENSSL_clear_free(passwd, strlen(passwd)); BN_clear_free(u); return ret; } int srp_verify_server_param(SSL_CONNECTION *s) { SRP_CTX *srp = &s->srp_ctx; /* * Sanity check parameters: we can quickly check B % N == 0 by checking B * != 0 since B < N */ if (BN_ucmp(srp->g, srp->N) >= 0 || BN_ucmp(srp->B, srp->N) >= 0 || BN_is_zero(srp->B)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DATA); return 0; } if (BN_num_bits(srp->N) < srp->strength) { SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_INSUFFICIENT_SECURITY); return 0; } if (srp->SRP_verify_param_callback) { if (srp->SRP_verify_param_callback(SSL_CONNECTION_GET_SSL(s), srp->SRP_cb_arg) <= 0) { SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_CALLBACK_FAILED); return 0; } } else if (!SRP_check_known_gN_param(srp->g, srp->N)) { SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_INSUFFICIENT_SECURITY); return 0; } return 1; } /* * The public API SRP_Calc_A_param() is deprecated so we use * ssl_srp_calc_a_param_intern() internally. */ int ssl_srp_calc_a_param_intern(SSL_CONNECTION *s) { unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH]; if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, rnd, sizeof(rnd), 0) <= 0) return 0; s->srp_ctx.a = BN_bin2bn(rnd, sizeof(rnd), s->srp_ctx.a); OPENSSL_cleanse(rnd, sizeof(rnd)); if (!(s->srp_ctx.A = SRP_Calc_A(s->srp_ctx.a, s->srp_ctx.N, s->srp_ctx.g))) return 0; return 1; } int SRP_Calc_A_param(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return ssl_srp_calc_a_param_intern(sc); } BIGNUM *SSL_get_srp_g(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->srp_ctx.g != NULL) return sc->srp_ctx.g; return s->ctx->srp_ctx.g; } BIGNUM *SSL_get_srp_N(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->srp_ctx.N != NULL) return sc->srp_ctx.N; return s->ctx->srp_ctx.N; } char *SSL_get_srp_username(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->srp_ctx.login != NULL) return sc->srp_ctx.login; return s->ctx->srp_ctx.login; } char *SSL_get_srp_userinfo(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->srp_ctx.info != NULL) return sc->srp_ctx.info; return s->ctx->srp_ctx.info; } # define tls1_ctx_ctrl ssl3_ctx_ctrl # define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name) { return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME, 0, name); } int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password) { return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD, 0, password); } int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength) { return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength, NULL); } int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx, int (*cb) (SSL *, void *)) { return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_VERIFY_PARAM_CB, (void (*)(void))cb); } int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg) { return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_SRP_ARG, 0, arg); } int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx, int (*cb) (SSL *, int *, void *)) { return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB, (void (*)(void))cb); } int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx, char *(*cb) (SSL *, void *)) { return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB, (void (*)(void))cb); } #endif

./openssl/ssl/ssl_ciph.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <ctype.h> #include <openssl/objects.h> #include <openssl/comp.h> #include <openssl/engine.h> #include <openssl/crypto.h> #include <openssl/conf.h> #include <openssl/trace.h> #include "internal/nelem.h" #include "ssl_local.h" #include "internal/thread_once.h" #include "internal/cryptlib.h" /* NB: make sure indices in these tables match values above */ typedef struct { uint32_t mask; int nid; } ssl_cipher_table; /* Table of NIDs for each cipher */ static const ssl_cipher_table ssl_cipher_table_cipher[SSL_ENC_NUM_IDX] = { {SSL_DES, NID_des_cbc}, /* SSL_ENC_DES_IDX 0 */ {SSL_3DES, NID_des_ede3_cbc}, /* SSL_ENC_3DES_IDX 1 */ {SSL_RC4, NID_rc4}, /* SSL_ENC_RC4_IDX 2 */ {SSL_RC2, NID_rc2_cbc}, /* SSL_ENC_RC2_IDX 3 */ {SSL_IDEA, NID_idea_cbc}, /* SSL_ENC_IDEA_IDX 4 */ {SSL_eNULL, NID_undef}, /* SSL_ENC_NULL_IDX 5 */ {SSL_AES128, NID_aes_128_cbc}, /* SSL_ENC_AES128_IDX 6 */ {SSL_AES256, NID_aes_256_cbc}, /* SSL_ENC_AES256_IDX 7 */ {SSL_CAMELLIA128, NID_camellia_128_cbc}, /* SSL_ENC_CAMELLIA128_IDX 8 */ {SSL_CAMELLIA256, NID_camellia_256_cbc}, /* SSL_ENC_CAMELLIA256_IDX 9 */ {SSL_eGOST2814789CNT, NID_gost89_cnt}, /* SSL_ENC_GOST89_IDX 10 */ {SSL_SEED, NID_seed_cbc}, /* SSL_ENC_SEED_IDX 11 */ {SSL_AES128GCM, NID_aes_128_gcm}, /* SSL_ENC_AES128GCM_IDX 12 */ {SSL_AES256GCM, NID_aes_256_gcm}, /* SSL_ENC_AES256GCM_IDX 13 */ {SSL_AES128CCM, NID_aes_128_ccm}, /* SSL_ENC_AES128CCM_IDX 14 */ {SSL_AES256CCM, NID_aes_256_ccm}, /* SSL_ENC_AES256CCM_IDX 15 */ {SSL_AES128CCM8, NID_aes_128_ccm}, /* SSL_ENC_AES128CCM8_IDX 16 */ {SSL_AES256CCM8, NID_aes_256_ccm}, /* SSL_ENC_AES256CCM8_IDX 17 */ {SSL_eGOST2814789CNT12, NID_gost89_cnt_12}, /* SSL_ENC_GOST8912_IDX 18 */ {SSL_CHACHA20POLY1305, NID_chacha20_poly1305}, /* SSL_ENC_CHACHA_IDX 19 */ {SSL_ARIA128GCM, NID_aria_128_gcm}, /* SSL_ENC_ARIA128GCM_IDX 20 */ {SSL_ARIA256GCM, NID_aria_256_gcm}, /* SSL_ENC_ARIA256GCM_IDX 21 */ {SSL_MAGMA, NID_magma_ctr_acpkm}, /* SSL_ENC_MAGMA_IDX */ {SSL_KUZNYECHIK, NID_kuznyechik_ctr_acpkm}, /* SSL_ENC_KUZNYECHIK_IDX */ }; #define SSL_COMP_NULL_IDX 0 #define SSL_COMP_ZLIB_IDX 1 #define SSL_COMP_NUM_IDX 2 static STACK_OF(SSL_COMP) *ssl_comp_methods = NULL; #ifndef OPENSSL_NO_COMP static CRYPTO_ONCE ssl_load_builtin_comp_once = CRYPTO_ONCE_STATIC_INIT; #endif /* NB: make sure indices in this table matches values above */ static const ssl_cipher_table ssl_cipher_table_mac[SSL_MD_NUM_IDX] = { {SSL_MD5, NID_md5}, /* SSL_MD_MD5_IDX 0 */ {SSL_SHA1, NID_sha1}, /* SSL_MD_SHA1_IDX 1 */ {SSL_GOST94, NID_id_GostR3411_94}, /* SSL_MD_GOST94_IDX 2 */ {SSL_GOST89MAC, NID_id_Gost28147_89_MAC}, /* SSL_MD_GOST89MAC_IDX 3 */ {SSL_SHA256, NID_sha256}, /* SSL_MD_SHA256_IDX 4 */ {SSL_SHA384, NID_sha384}, /* SSL_MD_SHA384_IDX 5 */ {SSL_GOST12_256, NID_id_GostR3411_2012_256}, /* SSL_MD_GOST12_256_IDX 6 */ {SSL_GOST89MAC12, NID_gost_mac_12}, /* SSL_MD_GOST89MAC12_IDX 7 */ {SSL_GOST12_512, NID_id_GostR3411_2012_512}, /* SSL_MD_GOST12_512_IDX 8 */ {0, NID_md5_sha1}, /* SSL_MD_MD5_SHA1_IDX 9 */ {0, NID_sha224}, /* SSL_MD_SHA224_IDX 10 */ {0, NID_sha512}, /* SSL_MD_SHA512_IDX 11 */ {SSL_MAGMAOMAC, NID_magma_mac}, /* sSL_MD_MAGMAOMAC_IDX */ {SSL_KUZNYECHIKOMAC, NID_kuznyechik_mac} /* SSL_MD_KUZNYECHIKOMAC_IDX */ }; /* *INDENT-OFF* */ static const ssl_cipher_table ssl_cipher_table_kx[] = { {SSL_kRSA, NID_kx_rsa}, {SSL_kECDHE, NID_kx_ecdhe}, {SSL_kDHE, NID_kx_dhe}, {SSL_kECDHEPSK, NID_kx_ecdhe_psk}, {SSL_kDHEPSK, NID_kx_dhe_psk}, {SSL_kRSAPSK, NID_kx_rsa_psk}, {SSL_kPSK, NID_kx_psk}, {SSL_kSRP, NID_kx_srp}, {SSL_kGOST, NID_kx_gost}, {SSL_kGOST18, NID_kx_gost18}, {SSL_kANY, NID_kx_any} }; static const ssl_cipher_table ssl_cipher_table_auth[] = { {SSL_aRSA, NID_auth_rsa}, {SSL_aECDSA, NID_auth_ecdsa}, {SSL_aPSK, NID_auth_psk}, {SSL_aDSS, NID_auth_dss}, {SSL_aGOST01, NID_auth_gost01}, {SSL_aGOST12, NID_auth_gost12}, {SSL_aSRP, NID_auth_srp}, {SSL_aNULL, NID_auth_null}, {SSL_aANY, NID_auth_any} }; /* *INDENT-ON* */ /* Utility function for table lookup */ static int ssl_cipher_info_find(const ssl_cipher_table *table, size_t table_cnt, uint32_t mask) { size_t i; for (i = 0; i < table_cnt; i++, table++) { if (table->mask == mask) return (int)i; } return -1; } #define ssl_cipher_info_lookup(table, x) \ ssl_cipher_info_find(table, OSSL_NELEM(table), x) /* * PKEY_TYPE for GOST89MAC is known in advance, but, because implementation * is engine-provided, we'll fill it only if corresponding EVP_PKEY_METHOD is * found */ static const int default_mac_pkey_id[SSL_MD_NUM_IDX] = { /* MD5, SHA, GOST94, MAC89 */ EVP_PKEY_HMAC, EVP_PKEY_HMAC, EVP_PKEY_HMAC, NID_undef, /* SHA256, SHA384, GOST2012_256, MAC89-12 */ EVP_PKEY_HMAC, EVP_PKEY_HMAC, EVP_PKEY_HMAC, NID_undef, /* GOST2012_512 */ EVP_PKEY_HMAC, /* MD5/SHA1, SHA224, SHA512, MAGMAOMAC, KUZNYECHIKOMAC */ NID_undef, NID_undef, NID_undef, NID_undef, NID_undef }; #define CIPHER_ADD 1 #define CIPHER_KILL 2 #define CIPHER_DEL 3 #define CIPHER_ORD 4 #define CIPHER_SPECIAL 5 /* * Bump the ciphers to the top of the list. * This rule isn't currently supported by the public cipherstring API. */ #define CIPHER_BUMP 6 typedef struct cipher_order_st { const SSL_CIPHER *cipher; int active; int dead; struct cipher_order_st *next, *prev; } CIPHER_ORDER; static const SSL_CIPHER cipher_aliases[] = { /* "ALL" doesn't include eNULL (must be specifically enabled) */ {0, SSL_TXT_ALL, NULL, 0, 0, 0, ~SSL_eNULL}, /* "COMPLEMENTOFALL" */ {0, SSL_TXT_CMPALL, NULL, 0, 0, 0, SSL_eNULL}, /* * "COMPLEMENTOFDEFAULT" (does *not* include ciphersuites not found in * ALL!) */ {0, SSL_TXT_CMPDEF, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_NOT_DEFAULT}, /* * key exchange aliases (some of those using only a single bit here * combine multiple key exchange algs according to the RFCs, e.g. kDHE * combines DHE_DSS and DHE_RSA) */ {0, SSL_TXT_kRSA, NULL, 0, SSL_kRSA}, {0, SSL_TXT_kEDH, NULL, 0, SSL_kDHE}, {0, SSL_TXT_kDHE, NULL, 0, SSL_kDHE}, {0, SSL_TXT_DH, NULL, 0, SSL_kDHE}, {0, SSL_TXT_kEECDH, NULL, 0, SSL_kECDHE}, {0, SSL_TXT_kECDHE, NULL, 0, SSL_kECDHE}, {0, SSL_TXT_ECDH, NULL, 0, SSL_kECDHE}, {0, SSL_TXT_kPSK, NULL, 0, SSL_kPSK}, {0, SSL_TXT_kRSAPSK, NULL, 0, SSL_kRSAPSK}, {0, SSL_TXT_kECDHEPSK, NULL, 0, SSL_kECDHEPSK}, {0, SSL_TXT_kDHEPSK, NULL, 0, SSL_kDHEPSK}, {0, SSL_TXT_kSRP, NULL, 0, SSL_kSRP}, {0, SSL_TXT_kGOST, NULL, 0, SSL_kGOST}, {0, SSL_TXT_kGOST18, NULL, 0, SSL_kGOST18}, /* server authentication aliases */ {0, SSL_TXT_aRSA, NULL, 0, 0, SSL_aRSA}, {0, SSL_TXT_aDSS, NULL, 0, 0, SSL_aDSS}, {0, SSL_TXT_DSS, NULL, 0, 0, SSL_aDSS}, {0, SSL_TXT_aNULL, NULL, 0, 0, SSL_aNULL}, {0, SSL_TXT_aECDSA, NULL, 0, 0, SSL_aECDSA}, {0, SSL_TXT_ECDSA, NULL, 0, 0, SSL_aECDSA}, {0, SSL_TXT_aPSK, NULL, 0, 0, SSL_aPSK}, {0, SSL_TXT_aGOST01, NULL, 0, 0, SSL_aGOST01}, {0, SSL_TXT_aGOST12, NULL, 0, 0, SSL_aGOST12}, {0, SSL_TXT_aGOST, NULL, 0, 0, SSL_aGOST01 | SSL_aGOST12}, {0, SSL_TXT_aSRP, NULL, 0, 0, SSL_aSRP}, /* aliases combining key exchange and server authentication */ {0, SSL_TXT_EDH, NULL, 0, SSL_kDHE, ~SSL_aNULL}, {0, SSL_TXT_DHE, NULL, 0, SSL_kDHE, ~SSL_aNULL}, {0, SSL_TXT_EECDH, NULL, 0, SSL_kECDHE, ~SSL_aNULL}, {0, SSL_TXT_ECDHE, NULL, 0, SSL_kECDHE, ~SSL_aNULL}, {0, SSL_TXT_NULL, NULL, 0, 0, 0, SSL_eNULL}, {0, SSL_TXT_RSA, NULL, 0, SSL_kRSA, SSL_aRSA}, {0, SSL_TXT_ADH, NULL, 0, SSL_kDHE, SSL_aNULL}, {0, SSL_TXT_AECDH, NULL, 0, SSL_kECDHE, SSL_aNULL}, {0, SSL_TXT_PSK, NULL, 0, SSL_PSK}, {0, SSL_TXT_SRP, NULL, 0, SSL_kSRP}, /* symmetric encryption aliases */ {0, SSL_TXT_3DES, NULL, 0, 0, 0, SSL_3DES}, {0, SSL_TXT_RC4, NULL, 0, 0, 0, SSL_RC4}, {0, SSL_TXT_RC2, NULL, 0, 0, 0, SSL_RC2}, {0, SSL_TXT_IDEA, NULL, 0, 0, 0, SSL_IDEA}, {0, SSL_TXT_SEED, NULL, 0, 0, 0, SSL_SEED}, {0, SSL_TXT_eNULL, NULL, 0, 0, 0, SSL_eNULL}, {0, SSL_TXT_GOST, NULL, 0, 0, 0, SSL_eGOST2814789CNT | SSL_eGOST2814789CNT12 | SSL_MAGMA | SSL_KUZNYECHIK}, {0, SSL_TXT_AES128, NULL, 0, 0, 0, SSL_AES128 | SSL_AES128GCM | SSL_AES128CCM | SSL_AES128CCM8}, {0, SSL_TXT_AES256, NULL, 0, 0, 0, SSL_AES256 | SSL_AES256GCM | SSL_AES256CCM | SSL_AES256CCM8}, {0, SSL_TXT_AES, NULL, 0, 0, 0, SSL_AES}, {0, SSL_TXT_AES_GCM, NULL, 0, 0, 0, SSL_AES128GCM | SSL_AES256GCM}, {0, SSL_TXT_AES_CCM, NULL, 0, 0, 0, SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8}, {0, SSL_TXT_AES_CCM_8, NULL, 0, 0, 0, SSL_AES128CCM8 | SSL_AES256CCM8}, {0, SSL_TXT_CAMELLIA128, NULL, 0, 0, 0, SSL_CAMELLIA128}, {0, SSL_TXT_CAMELLIA256, NULL, 0, 0, 0, SSL_CAMELLIA256}, {0, SSL_TXT_CAMELLIA, NULL, 0, 0, 0, SSL_CAMELLIA}, {0, SSL_TXT_CHACHA20, NULL, 0, 0, 0, SSL_CHACHA20}, {0, SSL_TXT_GOST2012_GOST8912_GOST8912, NULL, 0, 0, 0, SSL_eGOST2814789CNT12}, {0, SSL_TXT_ARIA, NULL, 0, 0, 0, SSL_ARIA}, {0, SSL_TXT_ARIA_GCM, NULL, 0, 0, 0, SSL_ARIA128GCM | SSL_ARIA256GCM}, {0, SSL_TXT_ARIA128, NULL, 0, 0, 0, SSL_ARIA128GCM}, {0, SSL_TXT_ARIA256, NULL, 0, 0, 0, SSL_ARIA256GCM}, {0, SSL_TXT_CBC, NULL, 0, 0, 0, SSL_CBC}, /* MAC aliases */ {0, SSL_TXT_MD5, NULL, 0, 0, 0, 0, SSL_MD5}, {0, SSL_TXT_SHA1, NULL, 0, 0, 0, 0, SSL_SHA1}, {0, SSL_TXT_SHA, NULL, 0, 0, 0, 0, SSL_SHA1}, {0, SSL_TXT_GOST94, NULL, 0, 0, 0, 0, SSL_GOST94}, {0, SSL_TXT_GOST89MAC, NULL, 0, 0, 0, 0, SSL_GOST89MAC | SSL_GOST89MAC12}, {0, SSL_TXT_SHA256, NULL, 0, 0, 0, 0, SSL_SHA256}, {0, SSL_TXT_SHA384, NULL, 0, 0, 0, 0, SSL_SHA384}, {0, SSL_TXT_GOST12, NULL, 0, 0, 0, 0, SSL_GOST12_256}, /* protocol version aliases */ {0, SSL_TXT_SSLV3, NULL, 0, 0, 0, 0, 0, SSL3_VERSION}, {0, SSL_TXT_TLSV1, NULL, 0, 0, 0, 0, 0, TLS1_VERSION}, {0, "TLSv1.0", NULL, 0, 0, 0, 0, 0, TLS1_VERSION}, {0, SSL_TXT_TLSV1_2, NULL, 0, 0, 0, 0, 0, TLS1_2_VERSION}, /* strength classes */ {0, SSL_TXT_LOW, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_LOW}, {0, SSL_TXT_MEDIUM, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_MEDIUM}, {0, SSL_TXT_HIGH, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_HIGH}, /* FIPS 140-2 approved ciphersuite */ {0, SSL_TXT_FIPS, NULL, 0, 0, 0, ~SSL_eNULL, 0, 0, 0, 0, 0, SSL_FIPS}, /* "EDH-" aliases to "DHE-" labels (for backward compatibility) */ {0, SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA, NULL, 0, SSL_kDHE, SSL_aDSS, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH | SSL_FIPS}, {0, SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA, NULL, 0, SSL_kDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH | SSL_FIPS}, }; /* * Search for public key algorithm with given name and return its pkey_id if * it is available. Otherwise return 0 */ #ifdef OPENSSL_NO_ENGINE static int get_optional_pkey_id(const char *pkey_name) { const EVP_PKEY_ASN1_METHOD *ameth; int pkey_id = 0; ameth = EVP_PKEY_asn1_find_str(NULL, pkey_name, -1); if (ameth && EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, ameth) > 0) return pkey_id; return 0; } #else static int get_optional_pkey_id(const char *pkey_name) { const EVP_PKEY_ASN1_METHOD *ameth; ENGINE *tmpeng = NULL; int pkey_id = 0; ameth = EVP_PKEY_asn1_find_str(&tmpeng, pkey_name, -1); if (ameth) { if (EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, ameth) <= 0) pkey_id = 0; } tls_engine_finish(tmpeng); return pkey_id; } #endif int ssl_load_ciphers(SSL_CTX *ctx) { size_t i; const ssl_cipher_table *t; EVP_KEYEXCH *kex = NULL; EVP_SIGNATURE *sig = NULL; ctx->disabled_enc_mask = 0; for (i = 0, t = ssl_cipher_table_cipher; i < SSL_ENC_NUM_IDX; i++, t++) { if (t->nid != NID_undef) { const EVP_CIPHER *cipher = ssl_evp_cipher_fetch(ctx->libctx, t->nid, ctx->propq); ctx->ssl_cipher_methods[i] = cipher; if (cipher == NULL) ctx->disabled_enc_mask |= t->mask; } } ctx->disabled_mac_mask = 0; for (i = 0, t = ssl_cipher_table_mac; i < SSL_MD_NUM_IDX; i++, t++) { const EVP_MD *md = ssl_evp_md_fetch(ctx->libctx, t->nid, ctx->propq); ctx->ssl_digest_methods[i] = md; if (md == NULL) { ctx->disabled_mac_mask |= t->mask; } else { int tmpsize = EVP_MD_get_size(md); if (!ossl_assert(tmpsize >= 0)) return 0; ctx->ssl_mac_secret_size[i] = tmpsize; } } ctx->disabled_mkey_mask = 0; ctx->disabled_auth_mask = 0; /* * We ignore any errors from the fetches below. They are expected to fail * if these algorithms are not available. */ ERR_set_mark(); sig = EVP_SIGNATURE_fetch(ctx->libctx, "DSA", ctx->propq); if (sig == NULL) ctx->disabled_auth_mask |= SSL_aDSS; else EVP_SIGNATURE_free(sig); kex = EVP_KEYEXCH_fetch(ctx->libctx, "DH", ctx->propq); if (kex == NULL) ctx->disabled_mkey_mask |= SSL_kDHE | SSL_kDHEPSK; else EVP_KEYEXCH_free(kex); kex = EVP_KEYEXCH_fetch(ctx->libctx, "ECDH", ctx->propq); if (kex == NULL) ctx->disabled_mkey_mask |= SSL_kECDHE | SSL_kECDHEPSK; else EVP_KEYEXCH_free(kex); sig = EVP_SIGNATURE_fetch(ctx->libctx, "ECDSA", ctx->propq); if (sig == NULL) ctx->disabled_auth_mask |= SSL_aECDSA; else EVP_SIGNATURE_free(sig); ERR_pop_to_mark(); #ifdef OPENSSL_NO_PSK ctx->disabled_mkey_mask |= SSL_PSK; ctx->disabled_auth_mask |= SSL_aPSK; #endif #ifdef OPENSSL_NO_SRP ctx->disabled_mkey_mask |= SSL_kSRP; #endif /* * Check for presence of GOST 34.10 algorithms, and if they are not * present, disable appropriate auth and key exchange */ memcpy(ctx->ssl_mac_pkey_id, default_mac_pkey_id, sizeof(ctx->ssl_mac_pkey_id)); ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX] = get_optional_pkey_id(SN_id_Gost28147_89_MAC); if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX]) ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC_IDX] = 32; else ctx->disabled_mac_mask |= SSL_GOST89MAC; ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX] = get_optional_pkey_id(SN_gost_mac_12); if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX]) ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC12_IDX] = 32; else ctx->disabled_mac_mask |= SSL_GOST89MAC12; ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX] = get_optional_pkey_id(SN_magma_mac); if (ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX]) ctx->ssl_mac_secret_size[SSL_MD_MAGMAOMAC_IDX] = 32; else ctx->disabled_mac_mask |= SSL_MAGMAOMAC; ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX] = get_optional_pkey_id(SN_kuznyechik_mac); if (ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX]) ctx->ssl_mac_secret_size[SSL_MD_KUZNYECHIKOMAC_IDX] = 32; else ctx->disabled_mac_mask |= SSL_KUZNYECHIKOMAC; if (!get_optional_pkey_id(SN_id_GostR3410_2001)) ctx->disabled_auth_mask |= SSL_aGOST01 | SSL_aGOST12; if (!get_optional_pkey_id(SN_id_GostR3410_2012_256)) ctx->disabled_auth_mask |= SSL_aGOST12; if (!get_optional_pkey_id(SN_id_GostR3410_2012_512)) ctx->disabled_auth_mask |= SSL_aGOST12; /* * Disable GOST key exchange if no GOST signature algs are available * */ if ((ctx->disabled_auth_mask & (SSL_aGOST01 | SSL_aGOST12)) == (SSL_aGOST01 | SSL_aGOST12)) ctx->disabled_mkey_mask |= SSL_kGOST; if ((ctx->disabled_auth_mask & SSL_aGOST12) == SSL_aGOST12) ctx->disabled_mkey_mask |= SSL_kGOST18; return 1; } #ifndef OPENSSL_NO_COMP static int sk_comp_cmp(const SSL_COMP *const *a, const SSL_COMP *const *b) { return ((*a)->id - (*b)->id); } DEFINE_RUN_ONCE_STATIC(do_load_builtin_compressions) { SSL_COMP *comp = NULL; COMP_METHOD *method = COMP_zlib(); ssl_comp_methods = sk_SSL_COMP_new(sk_comp_cmp); if (COMP_get_type(method) != NID_undef && ssl_comp_methods != NULL) { comp = OPENSSL_malloc(sizeof(*comp)); if (comp != NULL) { comp->method = method; comp->id = SSL_COMP_ZLIB_IDX; comp->name = COMP_get_name(method); if (!sk_SSL_COMP_push(ssl_comp_methods, comp)) OPENSSL_free(comp); sk_SSL_COMP_sort(ssl_comp_methods); } } return 1; } static int load_builtin_compressions(void) { return RUN_ONCE(&ssl_load_builtin_comp_once, do_load_builtin_compressions); } #endif int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc, const EVP_CIPHER **enc) { int i = ssl_cipher_info_lookup(ssl_cipher_table_cipher, sslc->algorithm_enc); if (i == -1) { *enc = NULL; } else { if (i == SSL_ENC_NULL_IDX) { /* * We assume we don't care about this coming from an ENGINE so * just do a normal EVP_CIPHER_fetch instead of * ssl_evp_cipher_fetch() */ *enc = EVP_CIPHER_fetch(ctx->libctx, "NULL", ctx->propq); if (*enc == NULL) return 0; } else { const EVP_CIPHER *cipher = ctx->ssl_cipher_methods[i]; if (cipher == NULL || !ssl_evp_cipher_up_ref(cipher)) return 0; *enc = ctx->ssl_cipher_methods[i]; } } return 1; } int ssl_cipher_get_evp(SSL_CTX *ctx, const SSL_SESSION *s, const EVP_CIPHER **enc, const EVP_MD **md, int *mac_pkey_type, size_t *mac_secret_size, SSL_COMP **comp, int use_etm) { int i; const SSL_CIPHER *c; c = s->cipher; if (c == NULL) return 0; if (comp != NULL) { SSL_COMP ctmp; #ifndef OPENSSL_NO_COMP if (!load_builtin_compressions()) { /* * Currently don't care, since a failure only means that * ssl_comp_methods is NULL, which is perfectly OK */ } #endif *comp = NULL; ctmp.id = s->compress_meth; if (ssl_comp_methods != NULL) { i = sk_SSL_COMP_find(ssl_comp_methods, &ctmp); if (i >= 0) *comp = sk_SSL_COMP_value(ssl_comp_methods, i); } /* If were only interested in comp then return success */ if ((enc == NULL) && (md == NULL)) return 1; } if ((enc == NULL) || (md == NULL)) return 0; if (!ssl_cipher_get_evp_cipher(ctx, c, enc)) return 0; i = ssl_cipher_info_lookup(ssl_cipher_table_mac, c->algorithm_mac); if (i == -1) { *md = NULL; if (mac_pkey_type != NULL) *mac_pkey_type = NID_undef; if (mac_secret_size != NULL) *mac_secret_size = 0; if (c->algorithm_mac == SSL_AEAD) mac_pkey_type = NULL; } else { const EVP_MD *digest = ctx->ssl_digest_methods[i]; if (digest == NULL || !ssl_evp_md_up_ref(digest)) { ssl_evp_cipher_free(*enc); return 0; } *md = digest; if (mac_pkey_type != NULL) *mac_pkey_type = ctx->ssl_mac_pkey_id[i]; if (mac_secret_size != NULL) *mac_secret_size = ctx->ssl_mac_secret_size[i]; } if ((*enc != NULL) && (*md != NULL || (EVP_CIPHER_get_flags(*enc) & EVP_CIPH_FLAG_AEAD_CIPHER)) && (!mac_pkey_type || *mac_pkey_type != NID_undef)) { const EVP_CIPHER *evp = NULL; if (use_etm || s->ssl_version >> 8 != TLS1_VERSION_MAJOR || s->ssl_version < TLS1_VERSION) return 1; if (c->algorithm_enc == SSL_RC4 && c->algorithm_mac == SSL_MD5) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_rc4_hmac_md5, ctx->propq); else if (c->algorithm_enc == SSL_AES128 && c->algorithm_mac == SSL_SHA1) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_aes_128_cbc_hmac_sha1, ctx->propq); else if (c->algorithm_enc == SSL_AES256 && c->algorithm_mac == SSL_SHA1) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_aes_256_cbc_hmac_sha1, ctx->propq); else if (c->algorithm_enc == SSL_AES128 && c->algorithm_mac == SSL_SHA256) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_aes_128_cbc_hmac_sha256, ctx->propq); else if (c->algorithm_enc == SSL_AES256 && c->algorithm_mac == SSL_SHA256) evp = ssl_evp_cipher_fetch(ctx->libctx, NID_aes_256_cbc_hmac_sha256, ctx->propq); if (evp != NULL) { ssl_evp_cipher_free(*enc); ssl_evp_md_free(*md); *enc = evp; *md = NULL; } return 1; } return 0; } const EVP_MD *ssl_md(SSL_CTX *ctx, int idx) { idx &= SSL_HANDSHAKE_MAC_MASK; if (idx < 0 || idx >= SSL_MD_NUM_IDX) return NULL; return ctx->ssl_digest_methods[idx]; } const EVP_MD *ssl_handshake_md(SSL_CONNECTION *s) { return ssl_md(SSL_CONNECTION_GET_CTX(s), ssl_get_algorithm2(s)); } const EVP_MD *ssl_prf_md(SSL_CONNECTION *s) { return ssl_md(SSL_CONNECTION_GET_CTX(s), ssl_get_algorithm2(s) >> TLS1_PRF_DGST_SHIFT); } #define ITEM_SEP(a) \ (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ',')) static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr, CIPHER_ORDER **tail) { if (curr == *tail) return; if (curr == *head) *head = curr->next; if (curr->prev != NULL) curr->prev->next = curr->next; if (curr->next != NULL) curr->next->prev = curr->prev; (*tail)->next = curr; curr->prev = *tail; curr->next = NULL; *tail = curr; } static void ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr, CIPHER_ORDER **tail) { if (curr == *head) return; if (curr == *tail) *tail = curr->prev; if (curr->next != NULL) curr->next->prev = curr->prev; if (curr->prev != NULL) curr->prev->next = curr->next; (*head)->prev = curr; curr->next = *head; curr->prev = NULL; *head = curr; } static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method, int num_of_ciphers, uint32_t disabled_mkey, uint32_t disabled_auth, uint32_t disabled_enc, uint32_t disabled_mac, CIPHER_ORDER *co_list, CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p) { int i, co_list_num; const SSL_CIPHER *c; /* * We have num_of_ciphers descriptions compiled in, depending on the * method selected (SSLv3, TLSv1 etc). * These will later be sorted in a linked list with at most num * entries. */ /* Get the initial list of ciphers */ co_list_num = 0; /* actual count of ciphers */ for (i = 0; i < num_of_ciphers; i++) { c = ssl_method->get_cipher(i); /* drop those that use any of that is not available */ if (c == NULL || !c->valid) continue; if ((c->algorithm_mkey & disabled_mkey) || (c->algorithm_auth & disabled_auth) || (c->algorithm_enc & disabled_enc) || (c->algorithm_mac & disabled_mac)) continue; if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) == 0) && c->min_tls == 0) continue; if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) != 0) && c->min_dtls == 0) continue; co_list[co_list_num].cipher = c; co_list[co_list_num].next = NULL; co_list[co_list_num].prev = NULL; co_list[co_list_num].active = 0; co_list_num++; } /* * Prepare linked list from list entries */ if (co_list_num > 0) { co_list[0].prev = NULL; if (co_list_num > 1) { co_list[0].next = &co_list[1]; for (i = 1; i < co_list_num - 1; i++) { co_list[i].prev = &co_list[i - 1]; co_list[i].next = &co_list[i + 1]; } co_list[co_list_num - 1].prev = &co_list[co_list_num - 2]; } co_list[co_list_num - 1].next = NULL; *head_p = &co_list[0]; *tail_p = &co_list[co_list_num - 1]; } } static void ssl_cipher_collect_aliases(const SSL_CIPHER **ca_list, int num_of_group_aliases, uint32_t disabled_mkey, uint32_t disabled_auth, uint32_t disabled_enc, uint32_t disabled_mac, CIPHER_ORDER *head) { CIPHER_ORDER *ciph_curr; const SSL_CIPHER **ca_curr; int i; uint32_t mask_mkey = ~disabled_mkey; uint32_t mask_auth = ~disabled_auth; uint32_t mask_enc = ~disabled_enc; uint32_t mask_mac = ~disabled_mac; /* * First, add the real ciphers as already collected */ ciph_curr = head; ca_curr = ca_list; while (ciph_curr != NULL) { *ca_curr = ciph_curr->cipher; ca_curr++; ciph_curr = ciph_curr->next; } /* * Now we add the available ones from the cipher_aliases[] table. * They represent either one or more algorithms, some of which * in any affected category must be supported (set in enabled_mask), * or represent a cipher strength value (will be added in any case because algorithms=0). */ for (i = 0; i < num_of_group_aliases; i++) { uint32_t algorithm_mkey = cipher_aliases[i].algorithm_mkey; uint32_t algorithm_auth = cipher_aliases[i].algorithm_auth; uint32_t algorithm_enc = cipher_aliases[i].algorithm_enc; uint32_t algorithm_mac = cipher_aliases[i].algorithm_mac; if (algorithm_mkey) if ((algorithm_mkey & mask_mkey) == 0) continue; if (algorithm_auth) if ((algorithm_auth & mask_auth) == 0) continue; if (algorithm_enc) if ((algorithm_enc & mask_enc) == 0) continue; if (algorithm_mac) if ((algorithm_mac & mask_mac) == 0) continue; *ca_curr = (SSL_CIPHER *)(cipher_aliases + i); ca_curr++; } *ca_curr = NULL; /* end of list */ } static void ssl_cipher_apply_rule(uint32_t cipher_id, uint32_t alg_mkey, uint32_t alg_auth, uint32_t alg_enc, uint32_t alg_mac, int min_tls, uint32_t algo_strength, int rule, int32_t strength_bits, CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p) { CIPHER_ORDER *head, *tail, *curr, *next, *last; const SSL_CIPHER *cp; int reverse = 0; OSSL_TRACE_BEGIN(TLS_CIPHER) { BIO_printf(trc_out, "Applying rule %d with %08x/%08x/%08x/%08x/%08x %08x (%d)\n", rule, (unsigned int)alg_mkey, (unsigned int)alg_auth, (unsigned int)alg_enc, (unsigned int)alg_mac, min_tls, (unsigned int)algo_strength, (int)strength_bits); } if (rule == CIPHER_DEL || rule == CIPHER_BUMP) reverse = 1; /* needed to maintain sorting between currently * deleted ciphers */ head = *head_p; tail = *tail_p; if (reverse) { next = tail; last = head; } else { next = head; last = tail; } curr = NULL; for (;;) { if (curr == last) break; curr = next; if (curr == NULL) break; next = reverse ? curr->prev : curr->next; cp = curr->cipher; /* * Selection criteria is either the value of strength_bits * or the algorithms used. */ if (strength_bits >= 0) { if (strength_bits != cp->strength_bits) continue; } else { if (trc_out != NULL) { BIO_printf(trc_out, "\nName: %s:" "\nAlgo = %08x/%08x/%08x/%08x/%08x Algo_strength = %08x\n", cp->name, (unsigned int)cp->algorithm_mkey, (unsigned int)cp->algorithm_auth, (unsigned int)cp->algorithm_enc, (unsigned int)cp->algorithm_mac, cp->min_tls, (unsigned int)cp->algo_strength); } if (cipher_id != 0 && (cipher_id != cp->id)) continue; if (alg_mkey && !(alg_mkey & cp->algorithm_mkey)) continue; if (alg_auth && !(alg_auth & cp->algorithm_auth)) continue; if (alg_enc && !(alg_enc & cp->algorithm_enc)) continue; if (alg_mac && !(alg_mac & cp->algorithm_mac)) continue; if (min_tls && (min_tls != cp->min_tls)) continue; if ((algo_strength & SSL_STRONG_MASK) && !(algo_strength & SSL_STRONG_MASK & cp->algo_strength)) continue; if ((algo_strength & SSL_DEFAULT_MASK) && !(algo_strength & SSL_DEFAULT_MASK & cp->algo_strength)) continue; } if (trc_out != NULL) BIO_printf(trc_out, "Action = %d\n", rule); /* add the cipher if it has not been added yet. */ if (rule == CIPHER_ADD) { /* reverse == 0 */ if (!curr->active) { ll_append_tail(&head, curr, &tail); curr->active = 1; } } /* Move the added cipher to this location */ else if (rule == CIPHER_ORD) { /* reverse == 0 */ if (curr->active) { ll_append_tail(&head, curr, &tail); } } else if (rule == CIPHER_DEL) { /* reverse == 1 */ if (curr->active) { /* * most recently deleted ciphersuites get best positions for * any future CIPHER_ADD (note that the CIPHER_DEL loop works * in reverse to maintain the order) */ ll_append_head(&head, curr, &tail); curr->active = 0; } } else if (rule == CIPHER_BUMP) { if (curr->active) ll_append_head(&head, curr, &tail); } else if (rule == CIPHER_KILL) { /* reverse == 0 */ if (head == curr) head = curr->next; else curr->prev->next = curr->next; if (tail == curr) tail = curr->prev; curr->active = 0; if (curr->next != NULL) curr->next->prev = curr->prev; if (curr->prev != NULL) curr->prev->next = curr->next; curr->next = NULL; curr->prev = NULL; } } *head_p = head; *tail_p = tail; OSSL_TRACE_END(TLS_CIPHER); } static int ssl_cipher_strength_sort(CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p) { int32_t max_strength_bits; int i, *number_uses; CIPHER_ORDER *curr; /* * This routine sorts the ciphers with descending strength. The sorting * must keep the pre-sorted sequence, so we apply the normal sorting * routine as '+' movement to the end of the list. */ max_strength_bits = 0; curr = *head_p; while (curr != NULL) { if (curr->active && (curr->cipher->strength_bits > max_strength_bits)) max_strength_bits = curr->cipher->strength_bits; curr = curr->next; } number_uses = OPENSSL_zalloc(sizeof(int) * (max_strength_bits + 1)); if (number_uses == NULL) return 0; /* * Now find the strength_bits values actually used */ curr = *head_p; while (curr != NULL) { if (curr->active) number_uses[curr->cipher->strength_bits]++; curr = curr->next; } /* * Go through the list of used strength_bits values in descending * order. */ for (i = max_strength_bits; i >= 0; i--) if (number_uses[i] > 0) ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ORD, i, head_p, tail_p); OPENSSL_free(number_uses); return 1; } static int ssl_cipher_process_rulestr(const char *rule_str, CIPHER_ORDER **head_p, CIPHER_ORDER **tail_p, const SSL_CIPHER **ca_list, CERT *c) { uint32_t alg_mkey, alg_auth, alg_enc, alg_mac, algo_strength; int min_tls; const char *l, *buf; int j, multi, found, rule, retval, ok, buflen; uint32_t cipher_id = 0; char ch; retval = 1; l = rule_str; for (;;) { ch = *l; if (ch == '\0') break; /* done */ if (ch == '-') { rule = CIPHER_DEL; l++; } else if (ch == '+') { rule = CIPHER_ORD; l++; } else if (ch == '!') { rule = CIPHER_KILL; l++; } else if (ch == '@') { rule = CIPHER_SPECIAL; l++; } else { rule = CIPHER_ADD; } if (ITEM_SEP(ch)) { l++; continue; } alg_mkey = 0; alg_auth = 0; alg_enc = 0; alg_mac = 0; min_tls = 0; algo_strength = 0; for (;;) { ch = *l; buf = l; buflen = 0; #ifndef CHARSET_EBCDIC while (((ch >= 'A') && (ch <= 'Z')) || ((ch >= '0') && (ch <= '9')) || ((ch >= 'a') && (ch <= 'z')) || (ch == '-') || (ch == '_') || (ch == '.') || (ch == '=')) #else while (isalnum((unsigned char)ch) || (ch == '-') || (ch == '_') || (ch == '.') || (ch == '=')) #endif { ch = *(++l); buflen++; } if (buflen == 0) { /* * We hit something we cannot deal with, * it is no command or separator nor * alphanumeric, so we call this an error. */ ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); return 0; } if (rule == CIPHER_SPECIAL) { found = 0; /* unused -- avoid compiler warning */ break; /* special treatment */ } /* check for multi-part specification */ if (ch == '+') { multi = 1; l++; } else { multi = 0; } /* * Now search for the cipher alias in the ca_list. Be careful * with the strncmp, because the "buflen" limitation * will make the rule "ADH:SOME" and the cipher * "ADH-MY-CIPHER" look like a match for buflen=3. * So additionally check whether the cipher name found * has the correct length. We can save a strlen() call: * just checking for the '\0' at the right place is * sufficient, we have to strncmp() anyway. (We cannot * use strcmp(), because buf is not '\0' terminated.) */ j = found = 0; cipher_id = 0; while (ca_list[j]) { if (strncmp(buf, ca_list[j]->name, buflen) == 0 && (ca_list[j]->name[buflen] == '\0')) { found = 1; break; } else if (ca_list[j]->stdname != NULL && strncmp(buf, ca_list[j]->stdname, buflen) == 0 && ca_list[j]->stdname[buflen] == '\0') { found = 1; break; } else j++; } if (!found) break; /* ignore this entry */ if (ca_list[j]->algorithm_mkey) { if (alg_mkey) { alg_mkey &= ca_list[j]->algorithm_mkey; if (!alg_mkey) { found = 0; break; } } else { alg_mkey = ca_list[j]->algorithm_mkey; } } if (ca_list[j]->algorithm_auth) { if (alg_auth) { alg_auth &= ca_list[j]->algorithm_auth; if (!alg_auth) { found = 0; break; } } else { alg_auth = ca_list[j]->algorithm_auth; } } if (ca_list[j]->algorithm_enc) { if (alg_enc) { alg_enc &= ca_list[j]->algorithm_enc; if (!alg_enc) { found = 0; break; } } else { alg_enc = ca_list[j]->algorithm_enc; } } if (ca_list[j]->algorithm_mac) { if (alg_mac) { alg_mac &= ca_list[j]->algorithm_mac; if (!alg_mac) { found = 0; break; } } else { alg_mac = ca_list[j]->algorithm_mac; } } if (ca_list[j]->algo_strength & SSL_STRONG_MASK) { if (algo_strength & SSL_STRONG_MASK) { algo_strength &= (ca_list[j]->algo_strength & SSL_STRONG_MASK) | ~SSL_STRONG_MASK; if (!(algo_strength & SSL_STRONG_MASK)) { found = 0; break; } } else { algo_strength = ca_list[j]->algo_strength & SSL_STRONG_MASK; } } if (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) { if (algo_strength & SSL_DEFAULT_MASK) { algo_strength &= (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) | ~SSL_DEFAULT_MASK; if (!(algo_strength & SSL_DEFAULT_MASK)) { found = 0; break; } } else { algo_strength |= ca_list[j]->algo_strength & SSL_DEFAULT_MASK; } } if (ca_list[j]->valid) { /* * explicit ciphersuite found; its protocol version does not * become part of the search pattern! */ cipher_id = ca_list[j]->id; } else { /* * not an explicit ciphersuite; only in this case, the * protocol version is considered part of the search pattern */ if (ca_list[j]->min_tls) { if (min_tls != 0 && min_tls != ca_list[j]->min_tls) { found = 0; break; } else { min_tls = ca_list[j]->min_tls; } } } if (!multi) break; } /* * Ok, we have the rule, now apply it */ if (rule == CIPHER_SPECIAL) { /* special command */ ok = 0; if ((buflen == 8) && HAS_PREFIX(buf, "STRENGTH")) { ok = ssl_cipher_strength_sort(head_p, tail_p); } else if (buflen == 10 && CHECK_AND_SKIP_PREFIX(buf, "SECLEVEL=")) { int level = *buf - '0'; if (level < 0 || level > 5) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); } else { c->sec_level = level; ok = 1; } } else { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_COMMAND); } if (ok == 0) retval = 0; /* * We do not support any "multi" options * together with "@", so throw away the * rest of the command, if any left, until * end or ':' is found. */ while ((*l != '\0') && !ITEM_SEP(*l)) l++; } else if (found) { ssl_cipher_apply_rule(cipher_id, alg_mkey, alg_auth, alg_enc, alg_mac, min_tls, algo_strength, rule, -1, head_p, tail_p); } else { while ((*l != '\0') && !ITEM_SEP(*l)) l++; } if (*l == '\0') break; /* done */ } return retval; } static int check_suiteb_cipher_list(const SSL_METHOD *meth, CERT *c, const char **prule_str) { unsigned int suiteb_flags = 0, suiteb_comb2 = 0; if (HAS_PREFIX(*prule_str, "SUITEB128ONLY")) { suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS_ONLY; } else if (HAS_PREFIX(*prule_str, "SUITEB128C2")) { suiteb_comb2 = 1; suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS; } else if (HAS_PREFIX(*prule_str, "SUITEB128")) { suiteb_flags = SSL_CERT_FLAG_SUITEB_128_LOS; } else if (HAS_PREFIX(*prule_str, "SUITEB192")) { suiteb_flags = SSL_CERT_FLAG_SUITEB_192_LOS; } if (suiteb_flags) { c->cert_flags &= ~SSL_CERT_FLAG_SUITEB_128_LOS; c->cert_flags |= suiteb_flags; } else { suiteb_flags = c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS; } if (!suiteb_flags) return 1; /* Check version: if TLS 1.2 ciphers allowed we can use Suite B */ if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS)) { ERR_raise(ERR_LIB_SSL, SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE); return 0; } switch (suiteb_flags) { case SSL_CERT_FLAG_SUITEB_128_LOS: if (suiteb_comb2) *prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384"; else *prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384"; break; case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY: *prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256"; break; case SSL_CERT_FLAG_SUITEB_192_LOS: *prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384"; break; } return 1; } static int ciphersuite_cb(const char *elem, int len, void *arg) { STACK_OF(SSL_CIPHER) *ciphersuites = (STACK_OF(SSL_CIPHER) *)arg; const SSL_CIPHER *cipher; /* Arbitrary sized temp buffer for the cipher name. Should be big enough */ char name[80]; if (len > (int)(sizeof(name) - 1)) /* Anyway return 1 so we can parse rest of the list */ return 1; memcpy(name, elem, len); name[len] = '\0'; cipher = ssl3_get_cipher_by_std_name(name); if (cipher == NULL) /* Ciphersuite not found but return 1 to parse rest of the list */ return 1; if (!sk_SSL_CIPHER_push(ciphersuites, cipher)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } return 1; } static __owur int set_ciphersuites(STACK_OF(SSL_CIPHER) **currciphers, const char *str) { STACK_OF(SSL_CIPHER) *newciphers = sk_SSL_CIPHER_new_null(); if (newciphers == NULL) return 0; /* Parse the list. We explicitly allow an empty list */ if (*str != '\0' && (CONF_parse_list(str, ':', 1, ciphersuite_cb, newciphers) <= 0 || sk_SSL_CIPHER_num(newciphers) == 0)) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH); sk_SSL_CIPHER_free(newciphers); return 0; } sk_SSL_CIPHER_free(*currciphers); *currciphers = newciphers; return 1; } static int update_cipher_list_by_id(STACK_OF(SSL_CIPHER) **cipher_list_by_id, STACK_OF(SSL_CIPHER) *cipherstack) { STACK_OF(SSL_CIPHER) *tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack); if (tmp_cipher_list == NULL) { return 0; } sk_SSL_CIPHER_free(*cipher_list_by_id); *cipher_list_by_id = tmp_cipher_list; (void)sk_SSL_CIPHER_set_cmp_func(*cipher_list_by_id, ssl_cipher_ptr_id_cmp); sk_SSL_CIPHER_sort(*cipher_list_by_id); return 1; } static int update_cipher_list(SSL_CTX *ctx, STACK_OF(SSL_CIPHER) **cipher_list, STACK_OF(SSL_CIPHER) **cipher_list_by_id, STACK_OF(SSL_CIPHER) *tls13_ciphersuites) { int i; STACK_OF(SSL_CIPHER) *tmp_cipher_list = sk_SSL_CIPHER_dup(*cipher_list); if (tmp_cipher_list == NULL) return 0; /* * Delete any existing TLSv1.3 ciphersuites. These are always first in the * list. */ while (sk_SSL_CIPHER_num(tmp_cipher_list) > 0 && sk_SSL_CIPHER_value(tmp_cipher_list, 0)->min_tls == TLS1_3_VERSION) (void)sk_SSL_CIPHER_delete(tmp_cipher_list, 0); /* Insert the new TLSv1.3 ciphersuites */ for (i = sk_SSL_CIPHER_num(tls13_ciphersuites) - 1; i >= 0; i--) { const SSL_CIPHER *sslc = sk_SSL_CIPHER_value(tls13_ciphersuites, i); /* Don't include any TLSv1.3 ciphersuites that are disabled */ if ((sslc->algorithm_enc & ctx->disabled_enc_mask) == 0 && (ssl_cipher_table_mac[sslc->algorithm2 & SSL_HANDSHAKE_MAC_MASK].mask & ctx->disabled_mac_mask) == 0) { sk_SSL_CIPHER_unshift(tmp_cipher_list, sslc); } } if (!update_cipher_list_by_id(cipher_list_by_id, tmp_cipher_list)) { sk_SSL_CIPHER_free(tmp_cipher_list); return 0; } sk_SSL_CIPHER_free(*cipher_list); *cipher_list = tmp_cipher_list; return 1; } int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str) { int ret = set_ciphersuites(&(ctx->tls13_ciphersuites), str); if (ret && ctx->cipher_list != NULL) return update_cipher_list(ctx, &ctx->cipher_list, &ctx->cipher_list_by_id, ctx->tls13_ciphersuites); return ret; } int SSL_set_ciphersuites(SSL *s, const char *str) { STACK_OF(SSL_CIPHER) *cipher_list; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); int ret; if (sc == NULL) return 0; ret = set_ciphersuites(&(sc->tls13_ciphersuites), str); if (sc->cipher_list == NULL) { if ((cipher_list = SSL_get_ciphers(s)) != NULL) sc->cipher_list = sk_SSL_CIPHER_dup(cipher_list); } if (ret && sc->cipher_list != NULL) return update_cipher_list(s->ctx, &sc->cipher_list, &sc->cipher_list_by_id, sc->tls13_ciphersuites); return ret; } STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx, STACK_OF(SSL_CIPHER) *tls13_ciphersuites, STACK_OF(SSL_CIPHER) **cipher_list, STACK_OF(SSL_CIPHER) **cipher_list_by_id, const char *rule_str, CERT *c) { int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases, i; uint32_t disabled_mkey, disabled_auth, disabled_enc, disabled_mac; STACK_OF(SSL_CIPHER) *cipherstack; const char *rule_p; CIPHER_ORDER *co_list = NULL, *head = NULL, *tail = NULL, *curr; const SSL_CIPHER **ca_list = NULL; const SSL_METHOD *ssl_method = ctx->method; /* * Return with error if nothing to do. */ if (rule_str == NULL || cipher_list == NULL || cipher_list_by_id == NULL) return NULL; if (!check_suiteb_cipher_list(ssl_method, c, &rule_str)) return NULL; /* * To reduce the work to do we only want to process the compiled * in algorithms, so we first get the mask of disabled ciphers. */ disabled_mkey = ctx->disabled_mkey_mask; disabled_auth = ctx->disabled_auth_mask; disabled_enc = ctx->disabled_enc_mask; disabled_mac = ctx->disabled_mac_mask; /* * Now we have to collect the available ciphers from the compiled * in ciphers. We cannot get more than the number compiled in, so * it is used for allocation. */ num_of_ciphers = ssl_method->num_ciphers(); if (num_of_ciphers > 0) { co_list = OPENSSL_malloc(sizeof(*co_list) * num_of_ciphers); if (co_list == NULL) return NULL; /* Failure */ } ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers, disabled_mkey, disabled_auth, disabled_enc, disabled_mac, co_list, &head, &tail); /* Now arrange all ciphers by preference. */ /* * Everything else being equal, prefer ephemeral ECDH over other key * exchange mechanisms. * For consistency, prefer ECDSA over RSA (though this only matters if the * server has both certificates, and is using the DEFAULT, or a client * preference). */ ssl_cipher_apply_rule(0, SSL_kECDHE, SSL_aECDSA, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail); /* Within each strength group, we prefer GCM over CHACHA... */ ssl_cipher_apply_rule(0, 0, 0, SSL_AESGCM, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); ssl_cipher_apply_rule(0, 0, 0, SSL_CHACHA20, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); /* * ...and generally, our preferred cipher is AES. * Note that AEADs will be bumped to take preference after sorting by * strength. */ ssl_cipher_apply_rule(0, 0, 0, SSL_AES ^ SSL_AESGCM, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); /* Temporarily enable everything else for sorting */ ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail); /* Low priority for MD5 */ ssl_cipher_apply_rule(0, 0, 0, 0, SSL_MD5, 0, 0, CIPHER_ORD, -1, &head, &tail); /* * Move anonymous ciphers to the end. Usually, these will remain * disabled. (For applications that allow them, they aren't too bad, but * we prefer authenticated ciphers.) */ ssl_cipher_apply_rule(0, 0, SSL_aNULL, 0, 0, 0, 0, CIPHER_ORD, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kRSA, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kPSK, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head, &tail); /* RC4 is sort-of broken -- move to the end */ ssl_cipher_apply_rule(0, 0, 0, SSL_RC4, 0, 0, 0, CIPHER_ORD, -1, &head, &tail); /* * Now sort by symmetric encryption strength. The above ordering remains * in force within each class */ if (!ssl_cipher_strength_sort(&head, &tail)) { OPENSSL_free(co_list); return NULL; } /* * Partially overrule strength sort to prefer TLS 1.2 ciphers/PRFs. */ ssl_cipher_apply_rule(0, 0, 0, 0, 0, TLS1_2_VERSION, 0, CIPHER_BUMP, -1, &head, &tail); /* * Irrespective of strength, enforce the following order: * (EC)DHE + AEAD > (EC)DHE > rest of AEAD > rest. * Within each group, ciphers remain sorted by strength and previous * preference, i.e., * 1) ECDHE > DHE * 2) GCM > CHACHA * 3) AES > rest * 4) TLS 1.2 > legacy * * Because we now bump ciphers to the top of the list, we proceed in * reverse order of preference. */ ssl_cipher_apply_rule(0, 0, 0, 0, SSL_AEAD, 0, 0, CIPHER_BUMP, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kDHE | SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_BUMP, -1, &head, &tail); ssl_cipher_apply_rule(0, SSL_kDHE | SSL_kECDHE, 0, 0, SSL_AEAD, 0, 0, CIPHER_BUMP, -1, &head, &tail); /* Now disable everything (maintaining the ordering!) */ ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail); /* * We also need cipher aliases for selecting based on the rule_str. * There might be two types of entries in the rule_str: 1) names * of ciphers themselves 2) aliases for groups of ciphers. * For 1) we need the available ciphers and for 2) the cipher * groups of cipher_aliases added together in one list (otherwise * we would be happy with just the cipher_aliases table). */ num_of_group_aliases = OSSL_NELEM(cipher_aliases); num_of_alias_max = num_of_ciphers + num_of_group_aliases + 1; ca_list = OPENSSL_malloc(sizeof(*ca_list) * num_of_alias_max); if (ca_list == NULL) { OPENSSL_free(co_list); return NULL; /* Failure */ } ssl_cipher_collect_aliases(ca_list, num_of_group_aliases, disabled_mkey, disabled_auth, disabled_enc, disabled_mac, head); /* * If the rule_string begins with DEFAULT, apply the default rule * before using the (possibly available) additional rules. */ ok = 1; rule_p = rule_str; if (HAS_PREFIX(rule_str, "DEFAULT")) { ok = ssl_cipher_process_rulestr(OSSL_default_cipher_list(), &head, &tail, ca_list, c); rule_p += 7; if (*rule_p == ':') rule_p++; } if (ok && (rule_p[0] != '\0')) ok = ssl_cipher_process_rulestr(rule_p, &head, &tail, ca_list, c); OPENSSL_free(ca_list); /* Not needed anymore */ if (!ok) { /* Rule processing failure */ OPENSSL_free(co_list); return NULL; } /* * Allocate new "cipherstack" for the result, return with error * if we cannot get one. */ if ((cipherstack = sk_SSL_CIPHER_new_null()) == NULL) { OPENSSL_free(co_list); return NULL; } /* Add TLSv1.3 ciphers first - we always prefer those if possible */ for (i = 0; i < sk_SSL_CIPHER_num(tls13_ciphersuites); i++) { const SSL_CIPHER *sslc = sk_SSL_CIPHER_value(tls13_ciphersuites, i); /* Don't include any TLSv1.3 ciphers that are disabled */ if ((sslc->algorithm_enc & disabled_enc) != 0 || (ssl_cipher_table_mac[sslc->algorithm2 & SSL_HANDSHAKE_MAC_MASK].mask & ctx->disabled_mac_mask) != 0) { sk_SSL_CIPHER_delete(tls13_ciphersuites, i); i--; continue; } if (!sk_SSL_CIPHER_push(cipherstack, sslc)) { OPENSSL_free(co_list); sk_SSL_CIPHER_free(cipherstack); return NULL; } } OSSL_TRACE_BEGIN(TLS_CIPHER) { BIO_printf(trc_out, "cipher selection:\n"); } /* * The cipher selection for the list is done. The ciphers are added * to the resulting precedence to the STACK_OF(SSL_CIPHER). */ for (curr = head; curr != NULL; curr = curr->next) { if (curr->active) { if (!sk_SSL_CIPHER_push(cipherstack, curr->cipher)) { OPENSSL_free(co_list); sk_SSL_CIPHER_free(cipherstack); OSSL_TRACE_CANCEL(TLS_CIPHER); return NULL; } if (trc_out != NULL) BIO_printf(trc_out, "<%s>\n", curr->cipher->name); } } OPENSSL_free(co_list); /* Not needed any longer */ OSSL_TRACE_END(TLS_CIPHER); if (!update_cipher_list_by_id(cipher_list_by_id, cipherstack)) { sk_SSL_CIPHER_free(cipherstack); return NULL; } sk_SSL_CIPHER_free(*cipher_list); *cipher_list = cipherstack; return cipherstack; } char *SSL_CIPHER_description(const SSL_CIPHER *cipher, char *buf, int len) { const char *ver; const char *kx, *au, *enc, *mac; uint32_t alg_mkey, alg_auth, alg_enc, alg_mac; static const char *format = "%-30s %-7s Kx=%-8s Au=%-5s Enc=%-22s Mac=%-4s\n"; if (buf == NULL) { len = 128; if ((buf = OPENSSL_malloc(len)) == NULL) return NULL; } else if (len < 128) { return NULL; } alg_mkey = cipher->algorithm_mkey; alg_auth = cipher->algorithm_auth; alg_enc = cipher->algorithm_enc; alg_mac = cipher->algorithm_mac; ver = ssl_protocol_to_string(cipher->min_tls); switch (alg_mkey) { case SSL_kRSA: kx = "RSA"; break; case SSL_kDHE: kx = "DH"; break; case SSL_kECDHE: kx = "ECDH"; break; case SSL_kPSK: kx = "PSK"; break; case SSL_kRSAPSK: kx = "RSAPSK"; break; case SSL_kECDHEPSK: kx = "ECDHEPSK"; break; case SSL_kDHEPSK: kx = "DHEPSK"; break; case SSL_kSRP: kx = "SRP"; break; case SSL_kGOST: kx = "GOST"; break; case SSL_kGOST18: kx = "GOST18"; break; case SSL_kANY: kx = "any"; break; default: kx = "unknown"; } switch (alg_auth) { case SSL_aRSA: au = "RSA"; break; case SSL_aDSS: au = "DSS"; break; case SSL_aNULL: au = "None"; break; case SSL_aECDSA: au = "ECDSA"; break; case SSL_aPSK: au = "PSK"; break; case SSL_aSRP: au = "SRP"; break; case SSL_aGOST01: au = "GOST01"; break; /* New GOST ciphersuites have both SSL_aGOST12 and SSL_aGOST01 bits */ case (SSL_aGOST12 | SSL_aGOST01): au = "GOST12"; break; case SSL_aANY: au = "any"; break; default: au = "unknown"; break; } switch (alg_enc) { case SSL_DES: enc = "DES(56)"; break; case SSL_3DES: enc = "3DES(168)"; break; case SSL_RC4: enc = "RC4(128)"; break; case SSL_RC2: enc = "RC2(128)"; break; case SSL_IDEA: enc = "IDEA(128)"; break; case SSL_eNULL: enc = "None"; break; case SSL_AES128: enc = "AES(128)"; break; case SSL_AES256: enc = "AES(256)"; break; case SSL_AES128GCM: enc = "AESGCM(128)"; break; case SSL_AES256GCM: enc = "AESGCM(256)"; break; case SSL_AES128CCM: enc = "AESCCM(128)"; break; case SSL_AES256CCM: enc = "AESCCM(256)"; break; case SSL_AES128CCM8: enc = "AESCCM8(128)"; break; case SSL_AES256CCM8: enc = "AESCCM8(256)"; break; case SSL_CAMELLIA128: enc = "Camellia(128)"; break; case SSL_CAMELLIA256: enc = "Camellia(256)"; break; case SSL_ARIA128GCM: enc = "ARIAGCM(128)"; break; case SSL_ARIA256GCM: enc = "ARIAGCM(256)"; break; case SSL_SEED: enc = "SEED(128)"; break; case SSL_eGOST2814789CNT: case SSL_eGOST2814789CNT12: enc = "GOST89(256)"; break; case SSL_MAGMA: enc = "MAGMA"; break; case SSL_KUZNYECHIK: enc = "KUZNYECHIK"; break; case SSL_CHACHA20POLY1305: enc = "CHACHA20/POLY1305(256)"; break; default: enc = "unknown"; break; } switch (alg_mac) { case SSL_MD5: mac = "MD5"; break; case SSL_SHA1: mac = "SHA1"; break; case SSL_SHA256: mac = "SHA256"; break; case SSL_SHA384: mac = "SHA384"; break; case SSL_AEAD: mac = "AEAD"; break; case SSL_GOST89MAC: case SSL_GOST89MAC12: mac = "GOST89"; break; case SSL_GOST94: mac = "GOST94"; break; case SSL_GOST12_256: case SSL_GOST12_512: mac = "GOST2012"; break; default: mac = "unknown"; break; } BIO_snprintf(buf, len, format, cipher->name, ver, kx, au, enc, mac); return buf; } const char *SSL_CIPHER_get_version(const SSL_CIPHER *c) { if (c == NULL) return "(NONE)"; /* * Backwards-compatibility crutch. In almost all contexts we report TLS * 1.0 as "TLSv1", but for ciphers we report "TLSv1.0". */ if (c->min_tls == TLS1_VERSION) return "TLSv1.0"; return ssl_protocol_to_string(c->min_tls); } /* return the actual cipher being used */ const char *SSL_CIPHER_get_name(const SSL_CIPHER *c) { if (c != NULL) return c->name; return "(NONE)"; } /* return the actual cipher being used in RFC standard name */ const char *SSL_CIPHER_standard_name(const SSL_CIPHER *c) { if (c != NULL) return c->stdname; return "(NONE)"; } /* return the OpenSSL name based on given RFC standard name */ const char *OPENSSL_cipher_name(const char *stdname) { const SSL_CIPHER *c; if (stdname == NULL) return "(NONE)"; c = ssl3_get_cipher_by_std_name(stdname); return SSL_CIPHER_get_name(c); } /* number of bits for symmetric cipher */ int SSL_CIPHER_get_bits(const SSL_CIPHER *c, int *alg_bits) { int ret = 0; if (c != NULL) { if (alg_bits != NULL) *alg_bits = (int)c->alg_bits; ret = (int)c->strength_bits; } return ret; } uint32_t SSL_CIPHER_get_id(const SSL_CIPHER *c) { return c->id; } uint16_t SSL_CIPHER_get_protocol_id(const SSL_CIPHER *c) { return c->id & 0xFFFF; } SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n) { SSL_COMP *ctmp; int i, nn; if ((n == 0) || (sk == NULL)) return NULL; nn = sk_SSL_COMP_num(sk); for (i = 0; i < nn; i++) { ctmp = sk_SSL_COMP_value(sk, i); if (ctmp->id == n) return ctmp; } return NULL; } #ifdef OPENSSL_NO_COMP STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void) { return NULL; } STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP) *meths) { return meths; } int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm) { return 1; } #else STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void) { load_builtin_compressions(); return ssl_comp_methods; } STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP) *meths) { STACK_OF(SSL_COMP) *old_meths = ssl_comp_methods; ssl_comp_methods = meths; return old_meths; } static void cmeth_free(SSL_COMP *cm) { OPENSSL_free(cm); } void ssl_comp_free_compression_methods_int(void) { STACK_OF(SSL_COMP) *old_meths = ssl_comp_methods; ssl_comp_methods = NULL; sk_SSL_COMP_pop_free(old_meths, cmeth_free); } int SSL_COMP_add_compression_method(int id, COMP_METHOD *cm) { SSL_COMP *comp; if (cm == NULL || COMP_get_type(cm) == NID_undef) return 1; /*- * According to draft-ietf-tls-compression-04.txt, the * compression number ranges should be the following: * * 0 to 63: methods defined by the IETF * 64 to 192: external party methods assigned by IANA * 193 to 255: reserved for private use */ if (id < 193 || id > 255) { ERR_raise(ERR_LIB_SSL, SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE); return 1; } comp = OPENSSL_malloc(sizeof(*comp)); if (comp == NULL) return 1; comp->id = id; comp->method = cm; load_builtin_compressions(); if (ssl_comp_methods && sk_SSL_COMP_find(ssl_comp_methods, comp) >= 0) { OPENSSL_free(comp); ERR_raise(ERR_LIB_SSL, SSL_R_DUPLICATE_COMPRESSION_ID); return 1; } if (ssl_comp_methods == NULL || !sk_SSL_COMP_push(ssl_comp_methods, comp)) { OPENSSL_free(comp); ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 1; } return 0; } #endif const char *SSL_COMP_get_name(const COMP_METHOD *comp) { #ifndef OPENSSL_NO_COMP return comp ? COMP_get_name(comp) : NULL; #else return NULL; #endif } const char *SSL_COMP_get0_name(const SSL_COMP *comp) { #ifndef OPENSSL_NO_COMP return comp->name; #else return NULL; #endif } int SSL_COMP_get_id(const SSL_COMP *comp) { #ifndef OPENSSL_NO_COMP return comp->id; #else return -1; #endif } const SSL_CIPHER *ssl_get_cipher_by_char(SSL_CONNECTION *s, const unsigned char *ptr, int all) { const SSL_CIPHER *c = SSL_CONNECTION_GET_SSL(s)->method->get_cipher_by_char(ptr); if (c == NULL || (!all && c->valid == 0)) return NULL; return c; } const SSL_CIPHER *SSL_CIPHER_find(SSL *ssl, const unsigned char *ptr) { return ssl->method->get_cipher_by_char(ptr); } int SSL_CIPHER_get_cipher_nid(const SSL_CIPHER *c) { int i; if (c == NULL) return NID_undef; i = ssl_cipher_info_lookup(ssl_cipher_table_cipher, c->algorithm_enc); if (i == -1) return NID_undef; return ssl_cipher_table_cipher[i].nid; } int SSL_CIPHER_get_digest_nid(const SSL_CIPHER *c) { int i = ssl_cipher_info_lookup(ssl_cipher_table_mac, c->algorithm_mac); if (i == -1) return NID_undef; return ssl_cipher_table_mac[i].nid; } int SSL_CIPHER_get_kx_nid(const SSL_CIPHER *c) { int i = ssl_cipher_info_lookup(ssl_cipher_table_kx, c->algorithm_mkey); if (i == -1) return NID_undef; return ssl_cipher_table_kx[i].nid; } int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c) { int i = ssl_cipher_info_lookup(ssl_cipher_table_auth, c->algorithm_auth); if (i == -1) return NID_undef; return ssl_cipher_table_auth[i].nid; } int ssl_get_md_idx(int md_nid) { int i; for(i = 0; i < SSL_MD_NUM_IDX; i++) { if (md_nid == ssl_cipher_table_mac[i].nid) return i; } return -1; } const EVP_MD *SSL_CIPHER_get_handshake_digest(const SSL_CIPHER *c) { int idx = c->algorithm2 & SSL_HANDSHAKE_MAC_MASK; if (idx < 0 || idx >= SSL_MD_NUM_IDX) return NULL; return EVP_get_digestbynid(ssl_cipher_table_mac[idx].nid); } int SSL_CIPHER_is_aead(const SSL_CIPHER *c) { return (c->algorithm_mac & SSL_AEAD) ? 1 : 0; } int ssl_cipher_get_overhead(const SSL_CIPHER *c, size_t *mac_overhead, size_t *int_overhead, size_t *blocksize, size_t *ext_overhead) { size_t mac = 0, in = 0, blk = 0, out = 0; /* Some hard-coded numbers for the CCM/Poly1305 MAC overhead * because there are no handy #defines for those. */ if (c->algorithm_enc & (SSL_AESGCM | SSL_ARIAGCM)) { out = EVP_GCM_TLS_EXPLICIT_IV_LEN + EVP_GCM_TLS_TAG_LEN; } else if (c->algorithm_enc & (SSL_AES128CCM | SSL_AES256CCM)) { out = EVP_CCM_TLS_EXPLICIT_IV_LEN + 16; } else if (c->algorithm_enc & (SSL_AES128CCM8 | SSL_AES256CCM8)) { out = EVP_CCM_TLS_EXPLICIT_IV_LEN + 8; } else if (c->algorithm_enc & SSL_CHACHA20POLY1305) { out = 16; } else if (c->algorithm_mac & SSL_AEAD) { /* We're supposed to have handled all the AEAD modes above */ return 0; } else { /* Non-AEAD modes. Calculate MAC/cipher overhead separately */ int digest_nid = SSL_CIPHER_get_digest_nid(c); const EVP_MD *e_md = EVP_get_digestbynid(digest_nid); if (e_md == NULL) return 0; mac = EVP_MD_get_size(e_md); if (c->algorithm_enc != SSL_eNULL) { int cipher_nid = SSL_CIPHER_get_cipher_nid(c); const EVP_CIPHER *e_ciph = EVP_get_cipherbynid(cipher_nid); /* If it wasn't AEAD or SSL_eNULL, we expect it to be a known CBC cipher. */ if (e_ciph == NULL || EVP_CIPHER_get_mode(e_ciph) != EVP_CIPH_CBC_MODE) return 0; in = 1; /* padding length byte */ out = EVP_CIPHER_get_iv_length(e_ciph); blk = EVP_CIPHER_get_block_size(e_ciph); } } *mac_overhead = mac; *int_overhead = in; *blocksize = blk; *ext_overhead = out; return 1; } int ssl_cert_is_disabled(SSL_CTX *ctx, size_t idx) { const SSL_CERT_LOOKUP *cl; /* A provider-loaded key type is always enabled */ if (idx >= SSL_PKEY_NUM) return 0; cl = ssl_cert_lookup_by_idx(idx, ctx); if (cl == NULL || (cl->amask & ctx->disabled_auth_mask) != 0) return 1; return 0; } /* * Default list of TLSv1.2 (and earlier) ciphers * SSL_DEFAULT_CIPHER_LIST deprecated in 3.0.0 * Update both macro and function simultaneously */ const char *OSSL_default_cipher_list(void) { return "ALL:!COMPLEMENTOFDEFAULT:!eNULL"; } /* * Default list of TLSv1.3 (and later) ciphers * TLS_DEFAULT_CIPHERSUITES deprecated in 3.0.0 * Update both macro and function simultaneously */ const char *OSSL_default_ciphersuites(void) { return "TLS_AES_256_GCM_SHA384:" "TLS_CHACHA20_POLY1305_SHA256:" "TLS_AES_128_GCM_SHA256"; }

./openssl/ssl/t1_trce.c

/* * Copyright 2012-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "ssl_local.h" #ifndef OPENSSL_NO_SSL_TRACE /* Packet trace support for OpenSSL */ #include "internal/nelem.h" typedef struct { int num; const char *name; } ssl_trace_tbl; # define ssl_trace_str(val, tbl) \ do_ssl_trace_str(val, tbl, OSSL_NELEM(tbl)) # define ssl_trace_list(bio, indent, msg, msglen, value, table) \ do_ssl_trace_list(bio, indent, msg, msglen, value, \ table, OSSL_NELEM(table)) static const char *do_ssl_trace_str(int val, const ssl_trace_tbl *tbl, size_t ntbl) { size_t i; for (i = 0; i < ntbl; i++, tbl++) { if (tbl->num == val) return tbl->name; } return "UNKNOWN"; } static int do_ssl_trace_list(BIO *bio, int indent, const unsigned char *msg, size_t msglen, size_t vlen, const ssl_trace_tbl *tbl, size_t ntbl) { int val; if (msglen % vlen) return 0; while (msglen) { val = msg[0]; if (vlen == 2) val = (val << 8) | msg[1]; BIO_indent(bio, indent, 80); BIO_printf(bio, "%s (%d)\n", do_ssl_trace_str(val, tbl, ntbl), val); msg += vlen; msglen -= vlen; } return 1; } /* Version number */ static const ssl_trace_tbl ssl_version_tbl[] = { {SSL3_VERSION, "SSL 3.0"}, {TLS1_VERSION, "TLS 1.0"}, {TLS1_1_VERSION, "TLS 1.1"}, {TLS1_2_VERSION, "TLS 1.2"}, {TLS1_3_VERSION, "TLS 1.3"}, {DTLS1_VERSION, "DTLS 1.0"}, {DTLS1_2_VERSION, "DTLS 1.2"}, {DTLS1_BAD_VER, "DTLS 1.0 (bad)"} }; static const ssl_trace_tbl ssl_content_tbl[] = { {SSL3_RT_CHANGE_CIPHER_SPEC, "ChangeCipherSpec"}, {SSL3_RT_ALERT, "Alert"}, {SSL3_RT_HANDSHAKE, "Handshake"}, {SSL3_RT_APPLICATION_DATA, "ApplicationData"}, }; /* Handshake types, sorted by ascending id */ static const ssl_trace_tbl ssl_handshake_tbl[] = { {SSL3_MT_HELLO_REQUEST, "HelloRequest"}, {SSL3_MT_CLIENT_HELLO, "ClientHello"}, {SSL3_MT_SERVER_HELLO, "ServerHello"}, {DTLS1_MT_HELLO_VERIFY_REQUEST, "HelloVerifyRequest"}, {SSL3_MT_NEWSESSION_TICKET, "NewSessionTicket"}, {SSL3_MT_END_OF_EARLY_DATA, "EndOfEarlyData"}, {SSL3_MT_ENCRYPTED_EXTENSIONS, "EncryptedExtensions"}, {SSL3_MT_CERTIFICATE, "Certificate"}, {SSL3_MT_SERVER_KEY_EXCHANGE, "ServerKeyExchange"}, {SSL3_MT_CERTIFICATE_REQUEST, "CertificateRequest"}, {SSL3_MT_SERVER_DONE, "ServerHelloDone"}, {SSL3_MT_CERTIFICATE_VERIFY, "CertificateVerify"}, {SSL3_MT_CLIENT_KEY_EXCHANGE, "ClientKeyExchange"}, {SSL3_MT_FINISHED, "Finished"}, {SSL3_MT_CERTIFICATE_URL, "CertificateUrl"}, {SSL3_MT_CERTIFICATE_STATUS, "CertificateStatus"}, {SSL3_MT_SUPPLEMENTAL_DATA, "SupplementalData"}, {SSL3_MT_KEY_UPDATE, "KeyUpdate"}, {SSL3_MT_COMPRESSED_CERTIFICATE, "CompressedCertificate"}, # ifndef OPENSSL_NO_NEXTPROTONEG {SSL3_MT_NEXT_PROTO, "NextProto"}, # endif {SSL3_MT_MESSAGE_HASH, "MessageHash"} }; /* Cipher suites */ static const ssl_trace_tbl ssl_ciphers_tbl[] = { {0x0000, "TLS_NULL_WITH_NULL_NULL"}, {0x0001, "TLS_RSA_WITH_NULL_MD5"}, {0x0002, "TLS_RSA_WITH_NULL_SHA"}, {0x0003, "TLS_RSA_EXPORT_WITH_RC4_40_MD5"}, {0x0004, "TLS_RSA_WITH_RC4_128_MD5"}, {0x0005, "TLS_RSA_WITH_RC4_128_SHA"}, {0x0006, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5"}, {0x0007, "TLS_RSA_WITH_IDEA_CBC_SHA"}, {0x0008, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA"}, {0x0009, "TLS_RSA_WITH_DES_CBC_SHA"}, {0x000A, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"}, {0x000B, "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA"}, {0x000C, "TLS_DH_DSS_WITH_DES_CBC_SHA"}, {0x000D, "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA"}, {0x000E, "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA"}, {0x000F, "TLS_DH_RSA_WITH_DES_CBC_SHA"}, {0x0010, "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA"}, {0x0011, "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA"}, {0x0012, "TLS_DHE_DSS_WITH_DES_CBC_SHA"}, {0x0013, "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"}, {0x0014, "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA"}, {0x0015, "TLS_DHE_RSA_WITH_DES_CBC_SHA"}, {0x0016, "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"}, {0x0017, "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5"}, {0x0018, "TLS_DH_anon_WITH_RC4_128_MD5"}, {0x0019, "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA"}, {0x001A, "TLS_DH_anon_WITH_DES_CBC_SHA"}, {0x001B, "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"}, {0x001D, "SSL_FORTEZZA_KEA_WITH_FORTEZZA_CBC_SHA"}, {0x001E, "SSL_FORTEZZA_KEA_WITH_RC4_128_SHA"}, {0x001F, "TLS_KRB5_WITH_3DES_EDE_CBC_SHA"}, {0x0020, "TLS_KRB5_WITH_RC4_128_SHA"}, {0x0021, "TLS_KRB5_WITH_IDEA_CBC_SHA"}, {0x0022, "TLS_KRB5_WITH_DES_CBC_MD5"}, {0x0023, "TLS_KRB5_WITH_3DES_EDE_CBC_MD5"}, {0x0024, "TLS_KRB5_WITH_RC4_128_MD5"}, {0x0025, "TLS_KRB5_WITH_IDEA_CBC_MD5"}, {0x0026, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA"}, {0x0027, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA"}, {0x0028, "TLS_KRB5_EXPORT_WITH_RC4_40_SHA"}, {0x0029, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5"}, {0x002A, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5"}, {0x002B, "TLS_KRB5_EXPORT_WITH_RC4_40_MD5"}, {0x002C, "TLS_PSK_WITH_NULL_SHA"}, {0x002D, "TLS_DHE_PSK_WITH_NULL_SHA"}, {0x002E, "TLS_RSA_PSK_WITH_NULL_SHA"}, {0x002F, "TLS_RSA_WITH_AES_128_CBC_SHA"}, {0x0030, "TLS_DH_DSS_WITH_AES_128_CBC_SHA"}, {0x0031, "TLS_DH_RSA_WITH_AES_128_CBC_SHA"}, {0x0032, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"}, {0x0033, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"}, {0x0034, "TLS_DH_anon_WITH_AES_128_CBC_SHA"}, {0x0035, "TLS_RSA_WITH_AES_256_CBC_SHA"}, {0x0036, "TLS_DH_DSS_WITH_AES_256_CBC_SHA"}, {0x0037, "TLS_DH_RSA_WITH_AES_256_CBC_SHA"}, {0x0038, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"}, {0x0039, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"}, {0x003A, "TLS_DH_anon_WITH_AES_256_CBC_SHA"}, {0x003B, "TLS_RSA_WITH_NULL_SHA256"}, {0x003C, "TLS_RSA_WITH_AES_128_CBC_SHA256"}, {0x003D, "TLS_RSA_WITH_AES_256_CBC_SHA256"}, {0x003E, "TLS_DH_DSS_WITH_AES_128_CBC_SHA256"}, {0x003F, "TLS_DH_RSA_WITH_AES_128_CBC_SHA256"}, {0x0040, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"}, {0x0041, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"}, {0x0042, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA"}, {0x0043, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA"}, {0x0044, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"}, {0x0045, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"}, {0x0046, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"}, {0x0067, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"}, {0x0068, "TLS_DH_DSS_WITH_AES_256_CBC_SHA256"}, {0x0069, "TLS_DH_RSA_WITH_AES_256_CBC_SHA256"}, {0x006A, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"}, {0x006B, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"}, {0x006C, "TLS_DH_anon_WITH_AES_128_CBC_SHA256"}, {0x006D, "TLS_DH_anon_WITH_AES_256_CBC_SHA256"}, {0x0081, "TLS_GOSTR341001_WITH_28147_CNT_IMIT"}, {0x0083, "TLS_GOSTR341001_WITH_NULL_GOSTR3411"}, {0x0084, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"}, {0x0085, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA"}, {0x0086, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA"}, {0x0087, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"}, {0x0088, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"}, {0x0089, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"}, {0x008A, "TLS_PSK_WITH_RC4_128_SHA"}, {0x008B, "TLS_PSK_WITH_3DES_EDE_CBC_SHA"}, {0x008C, "TLS_PSK_WITH_AES_128_CBC_SHA"}, {0x008D, "TLS_PSK_WITH_AES_256_CBC_SHA"}, {0x008E, "TLS_DHE_PSK_WITH_RC4_128_SHA"}, {0x008F, "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"}, {0x0090, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"}, {0x0091, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"}, {0x0092, "TLS_RSA_PSK_WITH_RC4_128_SHA"}, {0x0093, "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"}, {0x0094, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"}, {0x0095, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"}, {0x0096, "TLS_RSA_WITH_SEED_CBC_SHA"}, {0x0097, "TLS_DH_DSS_WITH_SEED_CBC_SHA"}, {0x0098, "TLS_DH_RSA_WITH_SEED_CBC_SHA"}, {0x0099, "TLS_DHE_DSS_WITH_SEED_CBC_SHA"}, {0x009A, "TLS_DHE_RSA_WITH_SEED_CBC_SHA"}, {0x009B, "TLS_DH_anon_WITH_SEED_CBC_SHA"}, {0x009C, "TLS_RSA_WITH_AES_128_GCM_SHA256"}, {0x009D, "TLS_RSA_WITH_AES_256_GCM_SHA384"}, {0x009E, "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"}, {0x009F, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"}, {0x00A0, "TLS_DH_RSA_WITH_AES_128_GCM_SHA256"}, {0x00A1, "TLS_DH_RSA_WITH_AES_256_GCM_SHA384"}, {0x00A2, "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"}, {0x00A3, "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"}, {0x00A4, "TLS_DH_DSS_WITH_AES_128_GCM_SHA256"}, {0x00A5, "TLS_DH_DSS_WITH_AES_256_GCM_SHA384"}, {0x00A6, "TLS_DH_anon_WITH_AES_128_GCM_SHA256"}, {0x00A7, "TLS_DH_anon_WITH_AES_256_GCM_SHA384"}, {0x00A8, "TLS_PSK_WITH_AES_128_GCM_SHA256"}, {0x00A9, "TLS_PSK_WITH_AES_256_GCM_SHA384"}, {0x00AA, "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"}, {0x00AB, "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"}, {0x00AC, "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"}, {0x00AD, "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"}, {0x00AE, "TLS_PSK_WITH_AES_128_CBC_SHA256"}, {0x00AF, "TLS_PSK_WITH_AES_256_CBC_SHA384"}, {0x00B0, "TLS_PSK_WITH_NULL_SHA256"}, {0x00B1, "TLS_PSK_WITH_NULL_SHA384"}, {0x00B2, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"}, {0x00B3, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"}, {0x00B4, "TLS_DHE_PSK_WITH_NULL_SHA256"}, {0x00B5, "TLS_DHE_PSK_WITH_NULL_SHA384"}, {0x00B6, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"}, {0x00B7, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"}, {0x00B8, "TLS_RSA_PSK_WITH_NULL_SHA256"}, {0x00B9, "TLS_RSA_PSK_WITH_NULL_SHA384"}, {0x00BA, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BB, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BC, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BD, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BE, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00BF, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"}, {0x00C0, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C1, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C2, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C3, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C4, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00C5, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"}, {0x00FF, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV"}, {0x5600, "TLS_FALLBACK_SCSV"}, {0xC001, "TLS_ECDH_ECDSA_WITH_NULL_SHA"}, {0xC002, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA"}, {0xC003, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA"}, {0xC004, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"}, {0xC005, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"}, {0xC006, "TLS_ECDHE_ECDSA_WITH_NULL_SHA"}, {0xC007, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"}, {0xC008, "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"}, {0xC009, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"}, {0xC00A, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"}, {0xC00B, "TLS_ECDH_RSA_WITH_NULL_SHA"}, {0xC00C, "TLS_ECDH_RSA_WITH_RC4_128_SHA"}, {0xC00D, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA"}, {0xC00E, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"}, {0xC00F, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"}, {0xC010, "TLS_ECDHE_RSA_WITH_NULL_SHA"}, {0xC011, "TLS_ECDHE_RSA_WITH_RC4_128_SHA"}, {0xC012, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"}, {0xC013, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"}, {0xC014, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"}, {0xC015, "TLS_ECDH_anon_WITH_NULL_SHA"}, {0xC016, "TLS_ECDH_anon_WITH_RC4_128_SHA"}, {0xC017, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"}, {0xC018, "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"}, {0xC019, "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"}, {0xC01A, "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"}, {0xC01B, "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"}, {0xC01C, "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"}, {0xC01D, "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"}, {0xC01E, "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"}, {0xC01F, "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"}, {0xC020, "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"}, {0xC021, "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"}, {0xC022, "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"}, {0xC023, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"}, {0xC024, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"}, {0xC025, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"}, {0xC026, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"}, {0xC027, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"}, {0xC028, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"}, {0xC029, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"}, {0xC02A, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"}, {0xC02B, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"}, {0xC02C, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"}, {0xC02D, "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"}, {0xC02E, "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"}, {0xC02F, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"}, {0xC030, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"}, {0xC031, "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"}, {0xC032, "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"}, {0xC033, "TLS_ECDHE_PSK_WITH_RC4_128_SHA"}, {0xC034, "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"}, {0xC035, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"}, {0xC036, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"}, {0xC037, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"}, {0xC038, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"}, {0xC039, "TLS_ECDHE_PSK_WITH_NULL_SHA"}, {0xC03A, "TLS_ECDHE_PSK_WITH_NULL_SHA256"}, {0xC03B, "TLS_ECDHE_PSK_WITH_NULL_SHA384"}, {0xC03C, "TLS_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC03D, "TLS_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC03E, "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256"}, {0xC03F, "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384"}, {0xC040, "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC041, "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC042, "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256"}, {0xC043, "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384"}, {0xC044, "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC045, "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC046, "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256"}, {0xC047, "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384"}, {0xC048, "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256"}, {0xC049, "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384"}, {0xC04A, "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256"}, {0xC04B, "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384"}, {0xC04C, "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC04D, "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC04E, "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256"}, {0xC04F, "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384"}, {0xC050, "TLS_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC051, "TLS_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC052, "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC053, "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC054, "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC055, "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC056, "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"}, {0xC057, "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"}, {0xC058, "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"}, {0xC059, "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"}, {0xC05A, "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"}, {0xC05B, "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"}, {0xC05C, "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"}, {0xC05D, "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"}, {0xC05E, "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"}, {0xC05F, "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"}, {0xC060, "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC061, "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC062, "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"}, {0xC063, "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"}, {0xC064, "TLS_PSK_WITH_ARIA_128_CBC_SHA256"}, {0xC065, "TLS_PSK_WITH_ARIA_256_CBC_SHA384"}, {0xC066, "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256"}, {0xC067, "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384"}, {0xC068, "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256"}, {0xC069, "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384"}, {0xC06A, "TLS_PSK_WITH_ARIA_128_GCM_SHA256"}, {0xC06B, "TLS_PSK_WITH_ARIA_256_GCM_SHA384"}, {0xC06C, "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"}, {0xC06D, "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"}, {0xC06E, "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"}, {0xC06F, "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"}, {0xC070, "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256"}, {0xC071, "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384"}, {0xC072, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC073, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC074, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC075, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC076, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC077, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC078, "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC079, "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC07A, "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC07B, "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC07C, "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC07D, "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC07E, "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC07F, "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC080, "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC081, "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC082, "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC083, "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC084, "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC085, "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC086, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC087, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC088, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC089, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC08A, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC08B, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC08C, "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC08D, "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC08E, "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC08F, "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC090, "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC091, "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC092, "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256"}, {0xC093, "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384"}, {0xC094, "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC095, "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC096, "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC097, "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC098, "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC099, "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC09A, "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"}, {0xC09B, "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"}, {0xC09C, "TLS_RSA_WITH_AES_128_CCM"}, {0xC09D, "TLS_RSA_WITH_AES_256_CCM"}, {0xC09E, "TLS_DHE_RSA_WITH_AES_128_CCM"}, {0xC09F, "TLS_DHE_RSA_WITH_AES_256_CCM"}, {0xC0A0, "TLS_RSA_WITH_AES_128_CCM_8"}, {0xC0A1, "TLS_RSA_WITH_AES_256_CCM_8"}, {0xC0A2, "TLS_DHE_RSA_WITH_AES_128_CCM_8"}, {0xC0A3, "TLS_DHE_RSA_WITH_AES_256_CCM_8"}, {0xC0A4, "TLS_PSK_WITH_AES_128_CCM"}, {0xC0A5, "TLS_PSK_WITH_AES_256_CCM"}, {0xC0A6, "TLS_DHE_PSK_WITH_AES_128_CCM"}, {0xC0A7, "TLS_DHE_PSK_WITH_AES_256_CCM"}, {0xC0A8, "TLS_PSK_WITH_AES_128_CCM_8"}, {0xC0A9, "TLS_PSK_WITH_AES_256_CCM_8"}, {0xC0AA, "TLS_PSK_DHE_WITH_AES_128_CCM_8"}, {0xC0AB, "TLS_PSK_DHE_WITH_AES_256_CCM_8"}, {0xC0AC, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"}, {0xC0AD, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"}, {0xC0AE, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"}, {0xC0AF, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"}, {0xC102, "IANA-GOST2012-GOST8912-GOST8912"}, {0xCCA8, "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCA9, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAA, "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAB, "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAC, "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAD, "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"}, {0xCCAE, "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"}, {0x1301, "TLS_AES_128_GCM_SHA256"}, {0x1302, "TLS_AES_256_GCM_SHA384"}, {0x1303, "TLS_CHACHA20_POLY1305_SHA256"}, {0x1304, "TLS_AES_128_CCM_SHA256"}, {0x1305, "TLS_AES_128_CCM_8_SHA256"}, {0xFEFE, "SSL_RSA_FIPS_WITH_DES_CBC_SHA"}, {0xFEFF, "SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA"}, {0xFF85, "LEGACY-GOST2012-GOST8912-GOST8912"}, {0xFF87, "GOST2012-NULL-GOST12"}, {0xC100, "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC"}, {0xC101, "GOST2012-MAGMA-MAGMAOMAC"}, {0xC102, "GOST2012-GOST8912-IANA"}, }; /* Compression methods */ static const ssl_trace_tbl ssl_comp_tbl[] = { {0x0000, "No Compression"}, {0x0001, "Zlib Compression"} }; /* Extensions sorted by ascending id */ static const ssl_trace_tbl ssl_exts_tbl[] = { {TLSEXT_TYPE_server_name, "server_name"}, {TLSEXT_TYPE_max_fragment_length, "max_fragment_length"}, {TLSEXT_TYPE_client_certificate_url, "client_certificate_url"}, {TLSEXT_TYPE_trusted_ca_keys, "trusted_ca_keys"}, {TLSEXT_TYPE_truncated_hmac, "truncated_hmac"}, {TLSEXT_TYPE_status_request, "status_request"}, {TLSEXT_TYPE_user_mapping, "user_mapping"}, {TLSEXT_TYPE_client_authz, "client_authz"}, {TLSEXT_TYPE_server_authz, "server_authz"}, {TLSEXT_TYPE_cert_type, "cert_type"}, {TLSEXT_TYPE_supported_groups, "supported_groups"}, {TLSEXT_TYPE_ec_point_formats, "ec_point_formats"}, {TLSEXT_TYPE_srp, "srp"}, {TLSEXT_TYPE_signature_algorithms, "signature_algorithms"}, {TLSEXT_TYPE_use_srtp, "use_srtp"}, {TLSEXT_TYPE_application_layer_protocol_negotiation, "application_layer_protocol_negotiation"}, {TLSEXT_TYPE_signed_certificate_timestamp, "signed_certificate_timestamps"}, {TLSEXT_TYPE_client_cert_type, "client_cert_type"}, {TLSEXT_TYPE_server_cert_type, "server_cert_type"}, {TLSEXT_TYPE_padding, "padding"}, {TLSEXT_TYPE_encrypt_then_mac, "encrypt_then_mac"}, {TLSEXT_TYPE_extended_master_secret, "extended_master_secret"}, {TLSEXT_TYPE_compress_certificate, "compress_certificate"}, {TLSEXT_TYPE_session_ticket, "session_ticket"}, {TLSEXT_TYPE_psk, "psk"}, {TLSEXT_TYPE_early_data, "early_data"}, {TLSEXT_TYPE_supported_versions, "supported_versions"}, {TLSEXT_TYPE_cookie, "cookie_ext"}, {TLSEXT_TYPE_psk_kex_modes, "psk_key_exchange_modes"}, {TLSEXT_TYPE_certificate_authorities, "certificate_authorities"}, {TLSEXT_TYPE_post_handshake_auth, "post_handshake_auth"}, {TLSEXT_TYPE_signature_algorithms_cert, "signature_algorithms_cert"}, {TLSEXT_TYPE_key_share, "key_share"}, {TLSEXT_TYPE_renegotiate, "renegotiate"}, # ifndef OPENSSL_NO_NEXTPROTONEG {TLSEXT_TYPE_next_proto_neg, "next_proto_neg"}, # endif }; static const ssl_trace_tbl ssl_groups_tbl[] = { {1, "sect163k1 (K-163)"}, {2, "sect163r1"}, {3, "sect163r2 (B-163)"}, {4, "sect193r1"}, {5, "sect193r2"}, {6, "sect233k1 (K-233)"}, {7, "sect233r1 (B-233)"}, {8, "sect239k1"}, {9, "sect283k1 (K-283)"}, {10, "sect283r1 (B-283)"}, {11, "sect409k1 (K-409)"}, {12, "sect409r1 (B-409)"}, {13, "sect571k1 (K-571)"}, {14, "sect571r1 (B-571)"}, {15, "secp160k1"}, {16, "secp160r1"}, {17, "secp160r2"}, {18, "secp192k1"}, {19, "secp192r1 (P-192)"}, {20, "secp224k1"}, {21, "secp224r1 (P-224)"}, {22, "secp256k1"}, {23, "secp256r1 (P-256)"}, {24, "secp384r1 (P-384)"}, {25, "secp521r1 (P-521)"}, {26, "brainpoolP256r1"}, {27, "brainpoolP384r1"}, {28, "brainpoolP512r1"}, {29, "ecdh_x25519"}, {30, "ecdh_x448"}, {31, "brainpoolP256r1tls13"}, {32, "brainpoolP384r1tls13"}, {33, "brainpoolP512r1tls13"}, {34, "GC256A"}, {35, "GC256B"}, {36, "GC256C"}, {37, "GC256D"}, {38, "GC512A"}, {39, "GC512B"}, {40, "GC512C"}, {256, "ffdhe2048"}, {257, "ffdhe3072"}, {258, "ffdhe4096"}, {259, "ffdhe6144"}, {260, "ffdhe8192"}, {25497, "X25519Kyber768Draft00"}, {25498, "SecP256r1Kyber768Draft00"}, {0xFF01, "arbitrary_explicit_prime_curves"}, {0xFF02, "arbitrary_explicit_char2_curves"} }; static const ssl_trace_tbl ssl_point_tbl[] = { {0, "uncompressed"}, {1, "ansiX962_compressed_prime"}, {2, "ansiX962_compressed_char2"} }; static const ssl_trace_tbl ssl_mfl_tbl[] = { {0, "disabled"}, {1, "max_fragment_length := 2^9 (512 bytes)"}, {2, "max_fragment_length := 2^10 (1024 bytes)"}, {3, "max_fragment_length := 2^11 (2048 bytes)"}, {4, "max_fragment_length := 2^12 (4096 bytes)"} }; static const ssl_trace_tbl ssl_sigalg_tbl[] = { {TLSEXT_SIGALG_ecdsa_secp256r1_sha256, "ecdsa_secp256r1_sha256"}, {TLSEXT_SIGALG_ecdsa_secp384r1_sha384, "ecdsa_secp384r1_sha384"}, {TLSEXT_SIGALG_ecdsa_secp521r1_sha512, "ecdsa_secp521r1_sha512"}, {TLSEXT_SIGALG_ecdsa_sha224, "ecdsa_sha224"}, {TLSEXT_SIGALG_ed25519, "ed25519"}, {TLSEXT_SIGALG_ed448, "ed448"}, {TLSEXT_SIGALG_ecdsa_sha1, "ecdsa_sha1"}, {TLSEXT_SIGALG_rsa_pss_rsae_sha256, "rsa_pss_rsae_sha256"}, {TLSEXT_SIGALG_rsa_pss_rsae_sha384, "rsa_pss_rsae_sha384"}, {TLSEXT_SIGALG_rsa_pss_rsae_sha512, "rsa_pss_rsae_sha512"}, {TLSEXT_SIGALG_rsa_pss_pss_sha256, "rsa_pss_pss_sha256"}, {TLSEXT_SIGALG_rsa_pss_pss_sha384, "rsa_pss_pss_sha384"}, {TLSEXT_SIGALG_rsa_pss_pss_sha512, "rsa_pss_pss_sha512"}, {TLSEXT_SIGALG_rsa_pkcs1_sha256, "rsa_pkcs1_sha256"}, {TLSEXT_SIGALG_rsa_pkcs1_sha384, "rsa_pkcs1_sha384"}, {TLSEXT_SIGALG_rsa_pkcs1_sha512, "rsa_pkcs1_sha512"}, {TLSEXT_SIGALG_rsa_pkcs1_sha224, "rsa_pkcs1_sha224"}, {TLSEXT_SIGALG_rsa_pkcs1_sha1, "rsa_pkcs1_sha1"}, {TLSEXT_SIGALG_dsa_sha256, "dsa_sha256"}, {TLSEXT_SIGALG_dsa_sha384, "dsa_sha384"}, {TLSEXT_SIGALG_dsa_sha512, "dsa_sha512"}, {TLSEXT_SIGALG_dsa_sha224, "dsa_sha224"}, {TLSEXT_SIGALG_dsa_sha1, "dsa_sha1"}, {TLSEXT_SIGALG_gostr34102012_256_intrinsic, "gost2012_256"}, {TLSEXT_SIGALG_gostr34102012_512_intrinsic, "gost2012_512"}, {TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, "gost2012_256"}, {TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, "gost2012_512"}, {TLSEXT_SIGALG_gostr34102001_gostr3411, "gost2001_gost94"}, {TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, "ecdsa_brainpoolP256r1_sha256"}, {TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, "ecdsa_brainpoolP384r1_sha384"}, {TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, "ecdsa_brainpoolP512r1_sha512"}, }; static const ssl_trace_tbl ssl_ctype_tbl[] = { {1, "rsa_sign"}, {2, "dss_sign"}, {3, "rsa_fixed_dh"}, {4, "dss_fixed_dh"}, {5, "rsa_ephemeral_dh"}, {6, "dss_ephemeral_dh"}, {20, "fortezza_dms"}, {64, "ecdsa_sign"}, {65, "rsa_fixed_ecdh"}, {66, "ecdsa_fixed_ecdh"}, {67, "gost_sign256"}, {68, "gost_sign512"}, }; static const ssl_trace_tbl ssl_psk_kex_modes_tbl[] = { {TLSEXT_KEX_MODE_KE, "psk_ke"}, {TLSEXT_KEX_MODE_KE_DHE, "psk_dhe_ke"} }; static const ssl_trace_tbl ssl_key_update_tbl[] = { {SSL_KEY_UPDATE_NOT_REQUESTED, "update_not_requested"}, {SSL_KEY_UPDATE_REQUESTED, "update_requested"} }; static const ssl_trace_tbl ssl_comp_cert_tbl[] = { {TLSEXT_comp_cert_none, "none"}, {TLSEXT_comp_cert_zlib, "zlib"}, {TLSEXT_comp_cert_brotli, "brotli"}, {TLSEXT_comp_cert_zstd, "zstd"} }; /* * "pgp" and "1609dot2" are defined in RFC7250, * although OpenSSL doesn't support them, it can * at least report them in traces */ static const ssl_trace_tbl ssl_cert_type_tbl[] = { {TLSEXT_cert_type_x509, "x509"}, {TLSEXT_cert_type_pgp, "pgp"}, {TLSEXT_cert_type_rpk, "rpk"}, {TLSEXT_cert_type_1609dot2, "1609dot2"} }; static void ssl_print_hex(BIO *bio, int indent, const char *name, const unsigned char *msg, size_t msglen) { size_t i; BIO_indent(bio, indent, 80); BIO_printf(bio, "%s (len=%d): ", name, (int)msglen); for (i = 0; i < msglen; i++) BIO_printf(bio, "%02X", msg[i]); BIO_puts(bio, "\n"); } static int ssl_print_hexbuf(BIO *bio, int indent, const char *name, size_t nlen, const unsigned char **pmsg, size_t *pmsglen) { size_t blen; const unsigned char *p = *pmsg; if (*pmsglen < nlen) return 0; blen = p[0]; if (nlen > 1) blen = (blen << 8) | p[1]; if (*pmsglen < nlen + blen) return 0; p += nlen; ssl_print_hex(bio, indent, name, p, blen); *pmsg += blen + nlen; *pmsglen -= blen + nlen; return 1; } static int ssl_print_version(BIO *bio, int indent, const char *name, const unsigned char **pmsg, size_t *pmsglen, unsigned int *version) { int vers; if (*pmsglen < 2) return 0; vers = ((*pmsg)[0] << 8) | (*pmsg)[1]; if (version != NULL) *version = vers; BIO_indent(bio, indent, 80); BIO_printf(bio, "%s=0x%x (%s)\n", name, vers, ssl_trace_str(vers, ssl_version_tbl)); *pmsg += 2; *pmsglen -= 2; return 1; } static int ssl_print_random(BIO *bio, int indent, const unsigned char **pmsg, size_t *pmsglen) { unsigned int tm; const unsigned char *p = *pmsg; if (*pmsglen < 32) return 0; tm = ((unsigned int)p[0] << 24) | ((unsigned int)p[1] << 16) | ((unsigned int)p[2] << 8) | (unsigned int)p[3]; p += 4; BIO_indent(bio, indent, 80); BIO_puts(bio, "Random:\n"); BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "gmt_unix_time=0x%08X\n", tm); ssl_print_hex(bio, indent + 2, "random_bytes", p, 28); *pmsg += 32; *pmsglen -= 32; return 1; } static int ssl_print_signature(BIO *bio, int indent, const SSL_CONNECTION *sc, const unsigned char **pmsg, size_t *pmsglen) { if (*pmsglen < 2) return 0; if (SSL_USE_SIGALGS(sc)) { const unsigned char *p = *pmsg; unsigned int sigalg = (p[0] << 8) | p[1]; BIO_indent(bio, indent, 80); BIO_printf(bio, "Signature Algorithm: %s (0x%04x)\n", ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); *pmsg += 2; *pmsglen -= 2; } return ssl_print_hexbuf(bio, indent, "Signature", 2, pmsg, pmsglen); } static int ssl_print_extension(BIO *bio, int indent, int server, unsigned char mt, int extype, const unsigned char *ext, size_t extlen) { size_t xlen, share_len; unsigned int sigalg; uint32_t max_early_data; BIO_indent(bio, indent, 80); BIO_printf(bio, "extension_type=%s(%d), length=%d\n", ssl_trace_str(extype, ssl_exts_tbl), extype, (int)extlen); switch (extype) { case TLSEXT_TYPE_compress_certificate: if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2, ssl_comp_cert_tbl); case TLSEXT_TYPE_max_fragment_length: if (extlen < 1) return 0; xlen = extlen; return ssl_trace_list(bio, indent + 2, ext, xlen, 1, ssl_mfl_tbl); case TLSEXT_TYPE_ec_point_formats: if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_point_tbl); case TLSEXT_TYPE_supported_groups: if (extlen < 2) return 0; xlen = (ext[0] << 8) | ext[1]; if (extlen != xlen + 2) return 0; return ssl_trace_list(bio, indent + 2, ext + 2, xlen, 2, ssl_groups_tbl); case TLSEXT_TYPE_application_layer_protocol_negotiation: if (extlen < 2) return 0; xlen = (ext[0] << 8) | ext[1]; if (extlen != xlen + 2) return 0; ext += 2; while (xlen > 0) { size_t plen = *ext++; if (plen + 1 > xlen) return 0; BIO_indent(bio, indent + 2, 80); BIO_write(bio, ext, plen); BIO_puts(bio, "\n"); ext += plen; xlen -= plen + 1; } return 1; case TLSEXT_TYPE_signature_algorithms: if (extlen < 2) return 0; xlen = (ext[0] << 8) | ext[1]; if (extlen != xlen + 2) return 0; if (xlen & 1) return 0; ext += 2; while (xlen > 0) { BIO_indent(bio, indent + 2, 80); sigalg = (ext[0] << 8) | ext[1]; BIO_printf(bio, "%s (0x%04x)\n", ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); xlen -= 2; ext += 2; } break; case TLSEXT_TYPE_renegotiate: if (extlen < 1) return 0; xlen = ext[0]; if (xlen + 1 != extlen) return 0; ext++; if (xlen) { if (server) { if (xlen & 1) return 0; xlen >>= 1; } ssl_print_hex(bio, indent + 4, "client_verify_data", ext, xlen); if (server) { ext += xlen; ssl_print_hex(bio, indent + 4, "server_verify_data", ext, xlen); } } else { BIO_indent(bio, indent + 4, 80); BIO_puts(bio, "<EMPTY>\n"); } break; case TLSEXT_TYPE_session_ticket: if (extlen != 0) ssl_print_hex(bio, indent + 4, "ticket", ext, extlen); break; case TLSEXT_TYPE_key_share: if (server && extlen == 2) { int group_id; /* We assume this is an HRR, otherwise this is an invalid key_share */ group_id = (ext[0] << 8) | ext[1]; BIO_indent(bio, indent + 4, 80); BIO_printf(bio, "NamedGroup: %s (%d)\n", ssl_trace_str(group_id, ssl_groups_tbl), group_id); break; } if (extlen < 2) return 0; if (server) { xlen = extlen; } else { xlen = (ext[0] << 8) | ext[1]; if (extlen != xlen + 2) return 0; ext += 2; } for (; xlen > 0; ext += share_len, xlen -= share_len) { int group_id; if (xlen < 4) return 0; group_id = (ext[0] << 8) | ext[1]; share_len = (ext[2] << 8) | ext[3]; ext += 4; xlen -= 4; if (xlen < share_len) return 0; BIO_indent(bio, indent + 4, 80); BIO_printf(bio, "NamedGroup: %s (%d)\n", ssl_trace_str(group_id, ssl_groups_tbl), group_id); ssl_print_hex(bio, indent + 4, "key_exchange: ", ext, share_len); } break; case TLSEXT_TYPE_supported_versions: if (server) { int version; if (extlen != 2) return 0; version = (ext[0] << 8) | ext[1]; BIO_indent(bio, indent + 4, 80); BIO_printf(bio, "%s (%d)\n", ssl_trace_str(version, ssl_version_tbl), version); break; } if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2, ssl_version_tbl); case TLSEXT_TYPE_psk_kex_modes: if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_psk_kex_modes_tbl); case TLSEXT_TYPE_early_data: if (mt != SSL3_MT_NEWSESSION_TICKET) break; if (extlen != 4) return 0; max_early_data = ((unsigned int)ext[0] << 24) | ((unsigned int)ext[1] << 16) | ((unsigned int)ext[2] << 8) | (unsigned int)ext[3]; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "max_early_data=%u\n", (unsigned int)max_early_data); break; case TLSEXT_TYPE_server_cert_type: case TLSEXT_TYPE_client_cert_type: if (server) { if (extlen != 1) return 0; return ssl_trace_list(bio, indent + 2, ext, 1, 1, ssl_cert_type_tbl); } if (extlen < 1) return 0; xlen = ext[0]; if (extlen != xlen + 1) return 0; return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1, ssl_cert_type_tbl); default: BIO_dump_indent(bio, (const char *)ext, extlen, indent + 2); } return 1; } static int ssl_print_extensions(BIO *bio, int indent, int server, unsigned char mt, const unsigned char **msgin, size_t *msginlen) { size_t extslen, msglen = *msginlen; const unsigned char *msg = *msgin; BIO_indent(bio, indent, 80); if (msglen == 0) { BIO_puts(bio, "No extensions\n"); return 1; } if (msglen < 2) return 0; extslen = (msg[0] << 8) | msg[1]; msglen -= 2; msg += 2; if (extslen == 0) { BIO_puts(bio, "No extensions\n"); *msgin = msg; *msginlen = msglen; return 1; } if (extslen > msglen) return 0; BIO_printf(bio, "extensions, length = %d\n", (int)extslen); msglen -= extslen; while (extslen > 0) { int extype; size_t extlen; if (extslen < 4) return 0; extype = (msg[0] << 8) | msg[1]; extlen = (msg[2] << 8) | msg[3]; if (extslen < extlen + 4) { BIO_printf(bio, "extensions, extype = %d, extlen = %d\n", extype, (int)extlen); BIO_dump_indent(bio, (const char *)msg, extslen, indent + 2); return 0; } msg += 4; if (!ssl_print_extension(bio, indent + 2, server, mt, extype, msg, extlen)) return 0; msg += extlen; extslen -= extlen + 4; } *msgin = msg; *msginlen = msglen; return 1; } static int ssl_print_client_hello(BIO *bio, const SSL_CONNECTION *sc, int indent, const unsigned char *msg, size_t msglen) { size_t len; unsigned int cs; if (!ssl_print_version(bio, indent, "client_version", &msg, &msglen, NULL)) return 0; if (!ssl_print_random(bio, indent, &msg, &msglen)) return 0; if (!ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen)) return 0; if (SSL_CONNECTION_IS_DTLS(sc)) { if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen)) return 0; } if (msglen < 2) return 0; len = (msg[0] << 8) | msg[1]; msg += 2; msglen -= 2; BIO_indent(bio, indent, 80); BIO_printf(bio, "cipher_suites (len=%d)\n", (int)len); if (msglen < len || len & 1) return 0; while (len > 0) { cs = (msg[0] << 8) | msg[1]; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "{0x%02X, 0x%02X} %s\n", msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl)); msg += 2; msglen -= 2; len -= 2; } if (msglen < 1) return 0; len = msg[0]; msg++; msglen--; if (msglen < len) return 0; BIO_indent(bio, indent, 80); BIO_printf(bio, "compression_methods (len=%d)\n", (int)len); while (len > 0) { BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "%s (0x%02X)\n", ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]); msg++; msglen--; len--; } if (!ssl_print_extensions(bio, indent, 0, SSL3_MT_CLIENT_HELLO, &msg, &msglen)) return 0; return 1; } static int dtls_print_hello_vfyrequest(BIO *bio, int indent, const unsigned char *msg, size_t msglen) { if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, NULL)) return 0; if (!ssl_print_hexbuf(bio, indent, "cookie", 1, &msg, &msglen)) return 0; return 1; } static int ssl_print_server_hello(BIO *bio, int indent, const unsigned char *msg, size_t msglen) { unsigned int cs; unsigned int vers; if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, &vers)) return 0; if (!ssl_print_random(bio, indent, &msg, &msglen)) return 0; if (vers != TLS1_3_VERSION && !ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen)) return 0; if (msglen < 2) return 0; cs = (msg[0] << 8) | msg[1]; BIO_indent(bio, indent, 80); BIO_printf(bio, "cipher_suite {0x%02X, 0x%02X} %s\n", msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl)); msg += 2; msglen -= 2; if (vers != TLS1_3_VERSION) { if (msglen < 1) return 0; BIO_indent(bio, indent, 80); BIO_printf(bio, "compression_method: %s (0x%02X)\n", ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]); msg++; msglen--; } if (!ssl_print_extensions(bio, indent, 1, SSL3_MT_SERVER_HELLO, &msg, &msglen)) return 0; return 1; } static int ssl_get_keyex(const char **pname, const SSL_CONNECTION *sc) { unsigned long alg_k = sc->s3.tmp.new_cipher->algorithm_mkey; if (alg_k & SSL_kRSA) { *pname = "rsa"; return SSL_kRSA; } if (alg_k & SSL_kDHE) { *pname = "DHE"; return SSL_kDHE; } if (alg_k & SSL_kECDHE) { *pname = "ECDHE"; return SSL_kECDHE; } if (alg_k & SSL_kPSK) { *pname = "PSK"; return SSL_kPSK; } if (alg_k & SSL_kRSAPSK) { *pname = "RSAPSK"; return SSL_kRSAPSK; } if (alg_k & SSL_kDHEPSK) { *pname = "DHEPSK"; return SSL_kDHEPSK; } if (alg_k & SSL_kECDHEPSK) { *pname = "ECDHEPSK"; return SSL_kECDHEPSK; } if (alg_k & SSL_kSRP) { *pname = "SRP"; return SSL_kSRP; } if (alg_k & SSL_kGOST) { *pname = "GOST"; return SSL_kGOST; } if (alg_k & SSL_kGOST18) { *pname = "GOST18"; return SSL_kGOST18; } *pname = "UNKNOWN"; return 0; } static int ssl_print_client_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc, const unsigned char *msg, size_t msglen) { const char *algname; int id = ssl_get_keyex(&algname, sc); BIO_indent(bio, indent, 80); BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname); if (id & SSL_PSK) { if (!ssl_print_hexbuf(bio, indent + 2, "psk_identity", 2, &msg, &msglen)) return 0; } switch (id) { case SSL_kRSA: case SSL_kRSAPSK: if (TLS1_get_version(SSL_CONNECTION_GET_SSL(sc)) == SSL3_VERSION) { ssl_print_hex(bio, indent + 2, "EncryptedPreMasterSecret", msg, msglen); } else { if (!ssl_print_hexbuf(bio, indent + 2, "EncryptedPreMasterSecret", 2, &msg, &msglen)) return 0; } break; case SSL_kDHE: case SSL_kDHEPSK: if (!ssl_print_hexbuf(bio, indent + 2, "dh_Yc", 2, &msg, &msglen)) return 0; break; case SSL_kECDHE: case SSL_kECDHEPSK: if (!ssl_print_hexbuf(bio, indent + 2, "ecdh_Yc", 1, &msg, &msglen)) return 0; break; case SSL_kGOST: ssl_print_hex(bio, indent + 2, "GostKeyTransportBlob", msg, msglen); msglen = 0; break; case SSL_kGOST18: ssl_print_hex(bio, indent + 2, "GOST-wrapped PreMasterSecret", msg, msglen); msglen = 0; break; } return !msglen; } static int ssl_print_server_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc, const unsigned char *msg, size_t msglen) { const char *algname; int id = ssl_get_keyex(&algname, sc); BIO_indent(bio, indent, 80); BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname); if (id & SSL_PSK) { if (!ssl_print_hexbuf(bio, indent + 2, "psk_identity_hint", 2, &msg, &msglen)) return 0; } switch (id) { case SSL_kRSA: if (!ssl_print_hexbuf(bio, indent + 2, "rsa_modulus", 2, &msg, &msglen)) return 0; if (!ssl_print_hexbuf(bio, indent + 2, "rsa_exponent", 2, &msg, &msglen)) return 0; break; case SSL_kDHE: case SSL_kDHEPSK: if (!ssl_print_hexbuf(bio, indent + 2, "dh_p", 2, &msg, &msglen)) return 0; if (!ssl_print_hexbuf(bio, indent + 2, "dh_g", 2, &msg, &msglen)) return 0; if (!ssl_print_hexbuf(bio, indent + 2, "dh_Ys", 2, &msg, &msglen)) return 0; break; case SSL_kECDHE: case SSL_kECDHEPSK: if (msglen < 1) return 0; BIO_indent(bio, indent + 2, 80); if (msg[0] == EXPLICIT_PRIME_CURVE_TYPE) BIO_puts(bio, "explicit_prime\n"); else if (msg[0] == EXPLICIT_CHAR2_CURVE_TYPE) BIO_puts(bio, "explicit_char2\n"); else if (msg[0] == NAMED_CURVE_TYPE) { int curve; if (msglen < 3) return 0; curve = (msg[1] << 8) | msg[2]; BIO_printf(bio, "named_curve: %s (%d)\n", ssl_trace_str(curve, ssl_groups_tbl), curve); msg += 3; msglen -= 3; if (!ssl_print_hexbuf(bio, indent + 2, "point", 1, &msg, &msglen)) return 0; } else { BIO_printf(bio, "UNKNOWN CURVE PARAMETER TYPE %d\n", msg[0]); return 0; } break; case SSL_kPSK: case SSL_kRSAPSK: break; } if (!(id & SSL_PSK)) ssl_print_signature(bio, indent, sc, &msg, &msglen); return !msglen; } static int ssl_print_certificate(BIO *bio, const SSL_CONNECTION *sc, int indent, const unsigned char **pmsg, size_t *pmsglen) { size_t msglen = *pmsglen; size_t clen; X509 *x; const unsigned char *p = *pmsg, *q; SSL_CTX *ctx = SSL_CONNECTION_GET_CTX(sc); if (msglen < 3) return 0; clen = (p[0] << 16) | (p[1] << 8) | p[2]; if (msglen < clen + 3) return 0; q = p + 3; BIO_indent(bio, indent, 80); BIO_printf(bio, "ASN.1Cert, length=%d", (int)clen); x = X509_new_ex(ctx->libctx, ctx->propq); if (x != NULL && d2i_X509(&x, &q, clen) == NULL) { X509_free(x); x = NULL; } if (x == NULL) BIO_puts(bio, "<UNPARSEABLE CERTIFICATE>\n"); else { BIO_puts(bio, "\n------details-----\n"); X509_print_ex(bio, x, XN_FLAG_ONELINE, 0); PEM_write_bio_X509(bio, x); /* Print certificate stuff */ BIO_puts(bio, "------------------\n"); X509_free(x); } if (q != p + 3 + clen) { BIO_puts(bio, "<TRAILING GARBAGE AFTER CERTIFICATE>\n"); } *pmsg += clen + 3; *pmsglen -= clen + 3; return 1; } static int ssl_print_raw_public_key(BIO *bio, const SSL *ssl, int server, int indent, const unsigned char **pmsg, size_t *pmsglen) { EVP_PKEY *pkey; size_t clen; const unsigned char *msg = *pmsg; size_t msglen = *pmsglen; if (msglen < 3) return 0; clen = (msg[0] << 16) | (msg[1] << 8) | msg[2]; if (msglen < clen + 3) return 0; msg += 3; BIO_indent(bio, indent, 80); BIO_printf(bio, "raw_public_key, length=%d\n", (int)clen); pkey = d2i_PUBKEY_ex(NULL, &msg, clen, ssl->ctx->libctx, ssl->ctx->propq); if (pkey == NULL) return 0; EVP_PKEY_print_public(bio, pkey, indent + 2, NULL); EVP_PKEY_free(pkey); *pmsg += clen + 3; *pmsglen -= clen + 3; return 1; } static int ssl_print_certificates(BIO *bio, const SSL_CONNECTION *sc, int server, int indent, const unsigned char *msg, size_t msglen) { size_t clen; if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_print_hexbuf(bio, indent, "context", 1, &msg, &msglen)) return 0; if (msglen < 3) return 0; clen = (msg[0] << 16) | (msg[1] << 8) | msg[2]; if (msglen != clen + 3) return 0; msg += 3; if ((server && sc->ext.server_cert_type == TLSEXT_cert_type_rpk) || (!server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk)) { if (!ssl_print_raw_public_key(bio, &sc->ssl, server, indent, &msg, &clen)) return 0; if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_print_extensions(bio, indent + 2, server, SSL3_MT_CERTIFICATE, &msg, &clen)) return 0; return 1; } BIO_indent(bio, indent, 80); BIO_printf(bio, "certificate_list, length=%d\n", (int)clen); while (clen > 0) { if (!ssl_print_certificate(bio, sc, indent + 2, &msg, &clen)) return 0; if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_print_extensions(bio, indent + 2, server, SSL3_MT_CERTIFICATE, &msg, &clen)) return 0; } return 1; } static int ssl_print_compressed_certificates(BIO *bio, const SSL_CONNECTION *sc, int server, int indent, const unsigned char *msg, size_t msglen) { size_t uclen; size_t clen; unsigned int alg; int ret = 1; #ifndef OPENSSL_NO_COMP_ALG COMP_METHOD *method; COMP_CTX *comp = NULL; unsigned char* ucdata = NULL; #endif if (msglen < 8) return 0; alg = (msg[0] << 8) | msg[1]; uclen = (msg[2] << 16) | (msg[3] << 8) | msg[4]; clen = (msg[5] << 16) | (msg[6] << 8) | msg[7]; if (msglen != clen + 8) return 0; msg += 8; BIO_indent(bio, indent, 80); BIO_printf(bio, "Compression type=%s (0x%04x)\n", ssl_trace_str(alg, ssl_comp_cert_tbl), alg); BIO_indent(bio, indent, 80); BIO_printf(bio, "Uncompressed length=%d\n", (int)uclen); BIO_indent(bio, indent, 80); if (clen > 0) BIO_printf(bio, "Compressed length=%d, Ratio=%f:1\n", (int)clen, (float)uclen / (float)clen); else BIO_printf(bio, "Compressed length=%d, Ratio=unknown\n", (int)clen); BIO_dump_indent(bio, (const char *)msg, clen, indent); #ifndef OPENSSL_NO_COMP_ALG if (!ossl_comp_has_alg(alg)) return 0; /* Check against certificate maximum size (coverity) */ if (uclen == 0 || uclen > 0xFFFFFF || (ucdata = OPENSSL_malloc(uclen)) == NULL) return 0; switch (alg) { case TLSEXT_comp_cert_zlib: method = COMP_zlib(); break; case TLSEXT_comp_cert_brotli: method = COMP_brotli_oneshot(); break; case TLSEXT_comp_cert_zstd: method = COMP_zstd_oneshot(); break; default: goto err; } if ((comp = COMP_CTX_new(method)) == NULL || COMP_expand_block(comp, ucdata, uclen, (unsigned char*)msg, clen) != (int)uclen) goto err; ret = ssl_print_certificates(bio, sc, server, indent, ucdata, uclen); err: COMP_CTX_free(comp); OPENSSL_free(ucdata); #endif return ret; } static int ssl_print_cert_request(BIO *bio, int indent, const SSL_CONNECTION *sc, const unsigned char *msg, size_t msglen) { size_t xlen; unsigned int sigalg; if (SSL_CONNECTION_IS_TLS13(sc)) { if (!ssl_print_hexbuf(bio, indent, "request_context", 1, &msg, &msglen)) return 0; if (!ssl_print_extensions(bio, indent, 1, SSL3_MT_CERTIFICATE_REQUEST, &msg, &msglen)) return 0; return 1; } else { if (msglen < 1) return 0; xlen = msg[0]; if (msglen < xlen + 1) return 0; msg++; BIO_indent(bio, indent, 80); BIO_printf(bio, "certificate_types (len=%d)\n", (int)xlen); if (!ssl_trace_list(bio, indent + 2, msg, xlen, 1, ssl_ctype_tbl)) return 0; msg += xlen; msglen -= xlen + 1; } if (SSL_USE_SIGALGS(sc)) { if (msglen < 2) return 0; xlen = (msg[0] << 8) | msg[1]; if (msglen < xlen + 2 || (xlen & 1)) return 0; msg += 2; msglen -= xlen + 2; BIO_indent(bio, indent, 80); BIO_printf(bio, "signature_algorithms (len=%d)\n", (int)xlen); while (xlen > 0) { BIO_indent(bio, indent + 2, 80); sigalg = (msg[0] << 8) | msg[1]; BIO_printf(bio, "%s (0x%04x)\n", ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg); xlen -= 2; msg += 2; } msg += xlen; } if (msglen < 2) return 0; xlen = (msg[0] << 8) | msg[1]; BIO_indent(bio, indent, 80); if (msglen < xlen + 2) return 0; msg += 2; msglen -= 2 + xlen; BIO_printf(bio, "certificate_authorities (len=%d)\n", (int)xlen); while (xlen > 0) { size_t dlen; X509_NAME *nm; const unsigned char *p; if (xlen < 2) return 0; dlen = (msg[0] << 8) | msg[1]; if (xlen < dlen + 2) return 0; msg += 2; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "DistinguishedName (len=%d): ", (int)dlen); p = msg; nm = d2i_X509_NAME(NULL, &p, dlen); if (!nm) { BIO_puts(bio, "<UNPARSEABLE DN>\n"); } else { X509_NAME_print_ex(bio, nm, 0, XN_FLAG_ONELINE); BIO_puts(bio, "\n"); X509_NAME_free(nm); } xlen -= dlen + 2; msg += dlen; } if (SSL_CONNECTION_IS_TLS13(sc)) { if (!ssl_print_hexbuf(bio, indent, "request_extensions", 2, &msg, &msglen)) return 0; } return msglen == 0; } static int ssl_print_ticket(BIO *bio, int indent, const SSL_CONNECTION *sc, const unsigned char *msg, size_t msglen) { unsigned int tick_life; if (msglen == 0) { BIO_indent(bio, indent + 2, 80); BIO_puts(bio, "No Ticket\n"); return 1; } if (msglen < 4) return 0; tick_life = ((unsigned int)msg[0] << 24) | ((unsigned int)msg[1] << 16) | ((unsigned int)msg[2] << 8) | (unsigned int)msg[3]; msglen -= 4; msg += 4; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "ticket_lifetime_hint=%u\n", tick_life); if (SSL_CONNECTION_IS_TLS13(sc)) { unsigned int ticket_age_add; if (msglen < 4) return 0; ticket_age_add = ((unsigned int)msg[0] << 24) | ((unsigned int)msg[1] << 16) | ((unsigned int)msg[2] << 8) | (unsigned int)msg[3]; msglen -= 4; msg += 4; BIO_indent(bio, indent + 2, 80); BIO_printf(bio, "ticket_age_add=%u\n", ticket_age_add); if (!ssl_print_hexbuf(bio, indent + 2, "ticket_nonce", 1, &msg, &msglen)) return 0; } if (!ssl_print_hexbuf(bio, indent + 2, "ticket", 2, &msg, &msglen)) return 0; if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_print_extensions(bio, indent + 2, 0, SSL3_MT_NEWSESSION_TICKET, &msg, &msglen)) return 0; if (msglen) return 0; return 1; } static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server, const unsigned char *msg, size_t msglen, int indent) { size_t hlen; unsigned char htype; if (msglen < 4) return 0; htype = msg[0]; hlen = (msg[1] << 16) | (msg[2] << 8) | msg[3]; BIO_indent(bio, indent, 80); BIO_printf(bio, "%s, Length=%d\n", ssl_trace_str(htype, ssl_handshake_tbl), (int)hlen); msg += 4; msglen -= 4; if (SSL_CONNECTION_IS_DTLS(sc)) { if (msglen < 8) return 0; BIO_indent(bio, indent, 80); BIO_printf(bio, "message_seq=%d, fragment_offset=%d, " "fragment_length=%d\n", (msg[0] << 8) | msg[1], (msg[2] << 16) | (msg[3] << 8) | msg[4], (msg[5] << 16) | (msg[6] << 8) | msg[7]); msg += 8; msglen -= 8; } if (msglen < hlen) return 0; switch (htype) { case SSL3_MT_CLIENT_HELLO: if (!ssl_print_client_hello(bio, sc, indent + 2, msg, msglen)) return 0; break; case DTLS1_MT_HELLO_VERIFY_REQUEST: if (!dtls_print_hello_vfyrequest(bio, indent + 2, msg, msglen)) return 0; break; case SSL3_MT_SERVER_HELLO: if (!ssl_print_server_hello(bio, indent + 2, msg, msglen)) return 0; break; case SSL3_MT_SERVER_KEY_EXCHANGE: if (!ssl_print_server_keyex(bio, indent + 2, sc, msg, msglen)) return 0; break; case SSL3_MT_CLIENT_KEY_EXCHANGE: if (!ssl_print_client_keyex(bio, indent + 2, sc, msg, msglen)) return 0; break; case SSL3_MT_CERTIFICATE: if (!ssl_print_certificates(bio, sc, server, indent + 2, msg, msglen)) return 0; break; case SSL3_MT_COMPRESSED_CERTIFICATE: if (!ssl_print_compressed_certificates(bio, sc, server, indent + 2, msg, msglen)) return 0; break; case SSL3_MT_CERTIFICATE_VERIFY: if (!ssl_print_signature(bio, indent + 2, sc, &msg, &msglen)) return 0; break; case SSL3_MT_CERTIFICATE_REQUEST: if (!ssl_print_cert_request(bio, indent + 2, sc, msg, msglen)) return 0; break; case SSL3_MT_FINISHED: ssl_print_hex(bio, indent + 2, "verify_data", msg, msglen); break; case SSL3_MT_SERVER_DONE: if (msglen != 0) ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen); break; case SSL3_MT_NEWSESSION_TICKET: if (!ssl_print_ticket(bio, indent + 2, sc, msg, msglen)) return 0; break; case SSL3_MT_ENCRYPTED_EXTENSIONS: if (!ssl_print_extensions(bio, indent + 2, 1, SSL3_MT_ENCRYPTED_EXTENSIONS, &msg, &msglen)) return 0; break; case SSL3_MT_KEY_UPDATE: if (msglen != 1) { ssl_print_hex(bio, indent + 2, "unexpected value", msg, msglen); return 0; } if (!ssl_trace_list(bio, indent + 2, msg, msglen, 1, ssl_key_update_tbl)) return 0; break; default: BIO_indent(bio, indent + 2, 80); BIO_puts(bio, "Unsupported, hex dump follows:\n"); BIO_dump_indent(bio, (const char *)msg, msglen, indent + 4); } return 1; } void SSL_trace(int write_p, int version, int content_type, const void *buf, size_t msglen, SSL *ssl, void *arg) { const unsigned char *msg = buf; BIO *bio = arg; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); #ifndef OPENSSL_NO_QUIC QUIC_CONNECTION *qc = QUIC_CONNECTION_FROM_SSL(ssl); if (qc != NULL) { if (ossl_quic_trace(write_p, version, content_type, buf, msglen, ssl, arg)) return; /* * Otherwise ossl_quic_trace didn't handle this content_type so we * fallback to standard TLS handling */ } #endif if (sc == NULL) return; switch (content_type) { case SSL3_RT_HEADER: { int hvers; /* avoid overlapping with length at the end of buffer */ if (msglen < (size_t)(SSL_CONNECTION_IS_DTLS(sc) ? DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH)) { BIO_puts(bio, write_p ? "Sent" : "Received"); ssl_print_hex(bio, 0, " too short message", msg, msglen); break; } hvers = msg[1] << 8 | msg[2]; BIO_puts(bio, write_p ? "Sent" : "Received"); BIO_printf(bio, " TLS Record\nHeader:\n Version = %s (0x%x)\n", ssl_trace_str(hvers, ssl_version_tbl), hvers); if (SSL_CONNECTION_IS_DTLS(sc)) { BIO_printf(bio, " epoch=%d, sequence_number=%04x%04x%04x\n", (msg[3] << 8 | msg[4]), (msg[5] << 8 | msg[6]), (msg[7] << 8 | msg[8]), (msg[9] << 8 | msg[10])); } BIO_printf(bio, " Content Type = %s (%d)\n Length = %d", ssl_trace_str(msg[0], ssl_content_tbl), msg[0], msg[msglen - 2] << 8 | msg[msglen - 1]); } break; case SSL3_RT_INNER_CONTENT_TYPE: BIO_printf(bio, " Inner Content Type = %s (%d)", ssl_trace_str(msg[0], ssl_content_tbl), msg[0]); break; case SSL3_RT_HANDSHAKE: if (!ssl_print_handshake(bio, sc, sc->server ? write_p : !write_p, msg, msglen, 4)) BIO_printf(bio, "Message length parse error!\n"); break; case SSL3_RT_CHANGE_CIPHER_SPEC: if (msglen == 1 && msg[0] == 1) BIO_puts(bio, " change_cipher_spec (1)\n"); else ssl_print_hex(bio, 4, "unknown value", msg, msglen); break; case SSL3_RT_ALERT: if (msglen != 2) BIO_puts(bio, " Illegal Alert Length\n"); else { BIO_printf(bio, " Level=%s(%d), description=%s(%d)\n", SSL_alert_type_string_long(msg[0] << 8), msg[0], SSL_alert_desc_string_long(msg[1]), msg[1]); } } BIO_puts(bio, "\n"); } #endif

./openssl/ssl/sslerr.h

/* * Generated by util/mkerr.pl DO NOT EDIT * Copyright 2020-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #ifndef OSSL_SSLERR_H # define OSSL_SSLERR_H # pragma once # include <openssl/opensslconf.h> # include <openssl/symhacks.h> # ifdef __cplusplus extern "C" { # endif int ossl_err_load_SSL_strings(void); # ifdef __cplusplus } # endif #endif

./openssl/ssl/d1_srtp.c

/* * Copyright 2011-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* * DTLS code by Eric Rescorla <ekr@rtfm.com> * * Copyright (C) 2006, Network Resonance, Inc. Copyright (C) 2011, RTFM, Inc. */ #include <stdio.h> #include <openssl/objects.h> #include "ssl_local.h" #include "quic/quic_local.h" #ifndef OPENSSL_NO_SRTP static SRTP_PROTECTION_PROFILE srtp_known_profiles[] = { { "SRTP_AES128_CM_SHA1_80", SRTP_AES128_CM_SHA1_80, }, { "SRTP_AES128_CM_SHA1_32", SRTP_AES128_CM_SHA1_32, }, { "SRTP_AEAD_AES_128_GCM", SRTP_AEAD_AES_128_GCM, }, { "SRTP_AEAD_AES_256_GCM", SRTP_AEAD_AES_256_GCM, }, { "SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM", SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM, }, { "SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM", SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM, }, { "SRTP_ARIA_128_CTR_HMAC_SHA1_80", SRTP_ARIA_128_CTR_HMAC_SHA1_80, }, { "SRTP_ARIA_128_CTR_HMAC_SHA1_32", SRTP_ARIA_128_CTR_HMAC_SHA1_32, }, { "SRTP_ARIA_256_CTR_HMAC_SHA1_80", SRTP_ARIA_256_CTR_HMAC_SHA1_80, }, { "SRTP_ARIA_256_CTR_HMAC_SHA1_32", SRTP_ARIA_256_CTR_HMAC_SHA1_32, }, { "SRTP_AEAD_ARIA_128_GCM", SRTP_AEAD_ARIA_128_GCM, }, { "SRTP_AEAD_ARIA_256_GCM", SRTP_AEAD_ARIA_256_GCM, }, {0} }; static int find_profile_by_name(char *profile_name, SRTP_PROTECTION_PROFILE **pptr, size_t len) { SRTP_PROTECTION_PROFILE *p; p = srtp_known_profiles; while (p->name) { if ((len == strlen(p->name)) && strncmp(p->name, profile_name, len) == 0) { *pptr = p; return 0; } p++; } return 1; } static int ssl_ctx_make_profiles(const char *profiles_string, STACK_OF(SRTP_PROTECTION_PROFILE) **out) { STACK_OF(SRTP_PROTECTION_PROFILE) *profiles; char *col; char *ptr = (char *)profiles_string; SRTP_PROTECTION_PROFILE *p; if ((profiles = sk_SRTP_PROTECTION_PROFILE_new_null()) == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES); return 1; } do { col = strchr(ptr, ':'); if (!find_profile_by_name(ptr, &p, col ? (size_t)(col - ptr) : strlen(ptr))) { if (sk_SRTP_PROTECTION_PROFILE_find(profiles, p) >= 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); goto err; } if (!sk_SRTP_PROTECTION_PROFILE_push(profiles, p)) { ERR_raise(ERR_LIB_SSL, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES); goto err; } } else { ERR_raise(ERR_LIB_SSL, SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE); goto err; } if (col) ptr = col + 1; } while (col); sk_SRTP_PROTECTION_PROFILE_free(*out); *out = profiles; return 0; err: sk_SRTP_PROTECTION_PROFILE_free(profiles); return 1; } int SSL_CTX_set_tlsext_use_srtp(SSL_CTX *ctx, const char *profiles) { if (IS_QUIC_METHOD(ctx->method)) return 1; return ssl_ctx_make_profiles(profiles, &ctx->srtp_profiles); } int SSL_set_tlsext_use_srtp(SSL *s, const char *profiles) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 1; return ssl_ctx_make_profiles(profiles, &sc->srtp_profiles); } STACK_OF(SRTP_PROTECTION_PROFILE) *SSL_get_srtp_profiles(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc != NULL) { if (sc->srtp_profiles != NULL) { return sc->srtp_profiles; } else if ((s->ctx != NULL) && (s->ctx->srtp_profiles != NULL)) { return s->ctx->srtp_profiles; } } return NULL; } SRTP_PROTECTION_PROFILE *SSL_get_selected_srtp_profile(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; return sc->srtp_profile; } #endif

./openssl/ssl/ssl_stat.c

/* * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include "ssl_local.h" const char *SSL_state_string_long(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL || ossl_statem_in_error(sc)) return "error"; switch (SSL_get_state(s)) { case TLS_ST_CR_CERT_STATUS: return "SSLv3/TLS read certificate status"; case TLS_ST_CW_NEXT_PROTO: return "SSLv3/TLS write next proto"; case TLS_ST_SR_NEXT_PROTO: return "SSLv3/TLS read next proto"; case TLS_ST_SW_CERT_STATUS: return "SSLv3/TLS write certificate status"; case TLS_ST_BEFORE: return "before SSL initialization"; case TLS_ST_OK: return "SSL negotiation finished successfully"; case TLS_ST_CW_CLNT_HELLO: return "SSLv3/TLS write client hello"; case TLS_ST_CR_SRVR_HELLO: return "SSLv3/TLS read server hello"; case TLS_ST_CR_CERT: return "SSLv3/TLS read server certificate"; case TLS_ST_CR_COMP_CERT: return "TLSv1.3 read server compressed certificate"; case TLS_ST_CR_KEY_EXCH: return "SSLv3/TLS read server key exchange"; case TLS_ST_CR_CERT_REQ: return "SSLv3/TLS read server certificate request"; case TLS_ST_CR_SESSION_TICKET: return "SSLv3/TLS read server session ticket"; case TLS_ST_CR_SRVR_DONE: return "SSLv3/TLS read server done"; case TLS_ST_CW_CERT: return "SSLv3/TLS write client certificate"; case TLS_ST_CW_COMP_CERT: return "TLSv1.3 write client compressed certificate"; case TLS_ST_CW_KEY_EXCH: return "SSLv3/TLS write client key exchange"; case TLS_ST_CW_CERT_VRFY: return "SSLv3/TLS write certificate verify"; case TLS_ST_CW_CHANGE: case TLS_ST_SW_CHANGE: return "SSLv3/TLS write change cipher spec"; case TLS_ST_CW_FINISHED: case TLS_ST_SW_FINISHED: return "SSLv3/TLS write finished"; case TLS_ST_CR_CHANGE: case TLS_ST_SR_CHANGE: return "SSLv3/TLS read change cipher spec"; case TLS_ST_CR_FINISHED: case TLS_ST_SR_FINISHED: return "SSLv3/TLS read finished"; case TLS_ST_SR_CLNT_HELLO: return "SSLv3/TLS read client hello"; case TLS_ST_SW_HELLO_REQ: return "SSLv3/TLS write hello request"; case TLS_ST_SW_SRVR_HELLO: return "SSLv3/TLS write server hello"; case TLS_ST_SW_CERT: return "SSLv3/TLS write certificate"; case TLS_ST_SW_COMP_CERT: return "TLSv1.3 write server compressed certificate"; case TLS_ST_SW_KEY_EXCH: return "SSLv3/TLS write key exchange"; case TLS_ST_SW_CERT_REQ: return "SSLv3/TLS write certificate request"; case TLS_ST_SW_SESSION_TICKET: return "SSLv3/TLS write session ticket"; case TLS_ST_SW_SRVR_DONE: return "SSLv3/TLS write server done"; case TLS_ST_SR_CERT: return "SSLv3/TLS read client certificate"; case TLS_ST_SR_COMP_CERT: return "TLSv1.3 read client compressed certificate"; case TLS_ST_SR_KEY_EXCH: return "SSLv3/TLS read client key exchange"; case TLS_ST_SR_CERT_VRFY: return "SSLv3/TLS read certificate verify"; case DTLS_ST_CR_HELLO_VERIFY_REQUEST: return "DTLS1 read hello verify request"; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: return "DTLS1 write hello verify request"; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: return "TLSv1.3 write encrypted extensions"; case TLS_ST_CR_ENCRYPTED_EXTENSIONS: return "TLSv1.3 read encrypted extensions"; case TLS_ST_CR_CERT_VRFY: return "TLSv1.3 read server certificate verify"; case TLS_ST_SW_CERT_VRFY: return "TLSv1.3 write server certificate verify"; case TLS_ST_CR_HELLO_REQ: return "SSLv3/TLS read hello request"; case TLS_ST_SW_KEY_UPDATE: return "TLSv1.3 write server key update"; case TLS_ST_CW_KEY_UPDATE: return "TLSv1.3 write client key update"; case TLS_ST_SR_KEY_UPDATE: return "TLSv1.3 read client key update"; case TLS_ST_CR_KEY_UPDATE: return "TLSv1.3 read server key update"; case TLS_ST_EARLY_DATA: return "TLSv1.3 early data"; case TLS_ST_PENDING_EARLY_DATA_END: return "TLSv1.3 pending early data end"; case TLS_ST_CW_END_OF_EARLY_DATA: return "TLSv1.3 write end of early data"; case TLS_ST_SR_END_OF_EARLY_DATA: return "TLSv1.3 read end of early data"; default: return "unknown state"; } } const char *SSL_state_string(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL || ossl_statem_in_error(sc)) return "SSLERR"; switch (SSL_get_state(s)) { case TLS_ST_SR_NEXT_PROTO: return "TRNP"; case TLS_ST_SW_SESSION_TICKET: return "TWST"; case TLS_ST_SW_CERT_STATUS: return "TWCS"; case TLS_ST_CR_CERT_STATUS: return "TRCS"; case TLS_ST_CR_SESSION_TICKET: return "TRST"; case TLS_ST_CW_NEXT_PROTO: return "TWNP"; case TLS_ST_BEFORE: return "PINIT"; case TLS_ST_OK: return "SSLOK"; case TLS_ST_CW_CLNT_HELLO: return "TWCH"; case TLS_ST_CR_SRVR_HELLO: return "TRSH"; case TLS_ST_CR_CERT: return "TRSC"; case TLS_ST_CR_COMP_CERT: return "TRSCC"; case TLS_ST_CR_KEY_EXCH: return "TRSKE"; case TLS_ST_CR_CERT_REQ: return "TRCR"; case TLS_ST_CR_SRVR_DONE: return "TRSD"; case TLS_ST_CW_CERT: return "TWCC"; case TLS_ST_CW_COMP_CERT: return "TWCCC"; case TLS_ST_CW_KEY_EXCH: return "TWCKE"; case TLS_ST_CW_CERT_VRFY: return "TWCV"; case TLS_ST_SW_CHANGE: case TLS_ST_CW_CHANGE: return "TWCCS"; case TLS_ST_SW_FINISHED: case TLS_ST_CW_FINISHED: return "TWFIN"; case TLS_ST_SR_CHANGE: case TLS_ST_CR_CHANGE: return "TRCCS"; case TLS_ST_SR_FINISHED: case TLS_ST_CR_FINISHED: return "TRFIN"; case TLS_ST_SW_HELLO_REQ: return "TWHR"; case TLS_ST_SR_CLNT_HELLO: return "TRCH"; case TLS_ST_SW_SRVR_HELLO: return "TWSH"; case TLS_ST_SW_CERT: return "TWSC"; case TLS_ST_SW_COMP_CERT: return "TWSCC"; case TLS_ST_SW_KEY_EXCH: return "TWSKE"; case TLS_ST_SW_CERT_REQ: return "TWCR"; case TLS_ST_SW_SRVR_DONE: return "TWSD"; case TLS_ST_SR_CERT: return "TRCC"; case TLS_ST_SR_COMP_CERT: return "TRCCC"; case TLS_ST_SR_KEY_EXCH: return "TRCKE"; case TLS_ST_SR_CERT_VRFY: return "TRCV"; case DTLS_ST_CR_HELLO_VERIFY_REQUEST: return "DRCHV"; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: return "DWCHV"; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: return "TWEE"; case TLS_ST_CR_ENCRYPTED_EXTENSIONS: return "TREE"; case TLS_ST_CR_CERT_VRFY: return "TRSCV"; case TLS_ST_SW_CERT_VRFY: return "TWSCV"; case TLS_ST_CR_HELLO_REQ: return "TRHR"; case TLS_ST_SW_KEY_UPDATE: return "TWSKU"; case TLS_ST_CW_KEY_UPDATE: return "TWCKU"; case TLS_ST_SR_KEY_UPDATE: return "TRCKU"; case TLS_ST_CR_KEY_UPDATE: return "TRSKU"; case TLS_ST_EARLY_DATA: return "TED"; case TLS_ST_PENDING_EARLY_DATA_END: return "TPEDE"; case TLS_ST_CW_END_OF_EARLY_DATA: return "TWEOED"; case TLS_ST_SR_END_OF_EARLY_DATA: return "TWEOED"; default: return "UNKWN"; } } const char *SSL_alert_type_string_long(int value) { switch (value >> 8) { case SSL3_AL_WARNING: return "warning"; case SSL3_AL_FATAL: return "fatal"; default: return "unknown"; } } const char *SSL_alert_type_string(int value) { switch (value >> 8) { case SSL3_AL_WARNING: return "W"; case SSL3_AL_FATAL: return "F"; default: return "U"; } } const char *SSL_alert_desc_string(int value) { switch (value & 0xff) { case SSL3_AD_CLOSE_NOTIFY: return "CN"; case SSL3_AD_UNEXPECTED_MESSAGE: return "UM"; case SSL3_AD_BAD_RECORD_MAC: return "BM"; case SSL3_AD_DECOMPRESSION_FAILURE: return "DF"; case SSL3_AD_HANDSHAKE_FAILURE: return "HF"; case SSL3_AD_NO_CERTIFICATE: return "NC"; case SSL3_AD_BAD_CERTIFICATE: return "BC"; case SSL3_AD_UNSUPPORTED_CERTIFICATE: return "UC"; case SSL3_AD_CERTIFICATE_REVOKED: return "CR"; case SSL3_AD_CERTIFICATE_EXPIRED: return "CE"; case SSL3_AD_CERTIFICATE_UNKNOWN: return "CU"; case SSL3_AD_ILLEGAL_PARAMETER: return "IP"; case TLS1_AD_DECRYPTION_FAILED: return "DC"; case TLS1_AD_RECORD_OVERFLOW: return "RO"; case TLS1_AD_UNKNOWN_CA: return "CA"; case TLS1_AD_ACCESS_DENIED: return "AD"; case TLS1_AD_DECODE_ERROR: return "DE"; case TLS1_AD_DECRYPT_ERROR: return "CY"; case TLS1_AD_EXPORT_RESTRICTION: return "ER"; case TLS1_AD_PROTOCOL_VERSION: return "PV"; case TLS1_AD_INSUFFICIENT_SECURITY: return "IS"; case TLS1_AD_INTERNAL_ERROR: return "IE"; case TLS1_AD_USER_CANCELLED: return "US"; case TLS1_AD_NO_RENEGOTIATION: return "NR"; case TLS1_AD_UNSUPPORTED_EXTENSION: return "UE"; case TLS1_AD_CERTIFICATE_UNOBTAINABLE: return "CO"; case TLS1_AD_UNRECOGNIZED_NAME: return "UN"; case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return "BR"; case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE: return "BH"; case TLS1_AD_UNKNOWN_PSK_IDENTITY: return "UP"; default: return "UK"; } } const char *SSL_alert_desc_string_long(int value) { switch (value & 0xff) { case SSL3_AD_CLOSE_NOTIFY: return "close notify"; case SSL3_AD_UNEXPECTED_MESSAGE: return "unexpected_message"; case SSL3_AD_BAD_RECORD_MAC: return "bad record mac"; case SSL3_AD_DECOMPRESSION_FAILURE: return "decompression failure"; case SSL3_AD_HANDSHAKE_FAILURE: return "handshake failure"; case SSL3_AD_NO_CERTIFICATE: return "no certificate"; case SSL3_AD_BAD_CERTIFICATE: return "bad certificate"; case SSL3_AD_UNSUPPORTED_CERTIFICATE: return "unsupported certificate"; case SSL3_AD_CERTIFICATE_REVOKED: return "certificate revoked"; case SSL3_AD_CERTIFICATE_EXPIRED: return "certificate expired"; case SSL3_AD_CERTIFICATE_UNKNOWN: return "certificate unknown"; case SSL3_AD_ILLEGAL_PARAMETER: return "illegal parameter"; case TLS1_AD_DECRYPTION_FAILED: return "decryption failed"; case TLS1_AD_RECORD_OVERFLOW: return "record overflow"; case TLS1_AD_UNKNOWN_CA: return "unknown CA"; case TLS1_AD_ACCESS_DENIED: return "access denied"; case TLS1_AD_DECODE_ERROR: return "decode error"; case TLS1_AD_DECRYPT_ERROR: return "decrypt error"; case TLS1_AD_EXPORT_RESTRICTION: return "export restriction"; case TLS1_AD_PROTOCOL_VERSION: return "protocol version"; case TLS1_AD_INSUFFICIENT_SECURITY: return "insufficient security"; case TLS1_AD_INTERNAL_ERROR: return "internal error"; case TLS1_AD_USER_CANCELLED: return "user canceled"; case TLS1_AD_NO_RENEGOTIATION: return "no renegotiation"; case TLS1_AD_UNSUPPORTED_EXTENSION: return "unsupported extension"; case TLS1_AD_CERTIFICATE_UNOBTAINABLE: return "certificate unobtainable"; case TLS1_AD_UNRECOGNIZED_NAME: return "unrecognized name"; case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return "bad certificate status response"; case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE: return "bad certificate hash value"; case TLS1_AD_UNKNOWN_PSK_IDENTITY: return "unknown PSK identity"; case TLS1_AD_NO_APPLICATION_PROTOCOL: return "no application protocol"; default: return "unknown"; } }

./openssl/ssl/ssl_err_legacy.c

/* * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* This is the C source file where we include this header directly */ #include <openssl/sslerr_legacy.h> #include "sslerr.h" #ifndef OPENSSL_NO_DEPRECATED_3_0 int ERR_load_SSL_strings(void) { return ossl_err_load_SSL_strings(); } #else NON_EMPTY_TRANSLATION_UNIT #endif

./openssl/ssl/t1_lib.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <stdlib.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/hmac.h> #include <openssl/core_names.h> #include <openssl/ocsp.h> #include <openssl/conf.h> #include <openssl/x509v3.h> #include <openssl/dh.h> #include <openssl/bn.h> #include <openssl/provider.h> #include <openssl/param_build.h> #include "internal/nelem.h" #include "internal/sizes.h" #include "internal/tlsgroups.h" #include "ssl_local.h" #include "quic/quic_local.h" #include <openssl/ct.h> static const SIGALG_LOOKUP *find_sig_alg(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pkey); static int tls12_sigalg_allowed(const SSL_CONNECTION *s, int op, const SIGALG_LOOKUP *lu); SSL3_ENC_METHOD const TLSv1_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, 0, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; SSL3_ENC_METHOD const TLSv1_1_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, SSL_ENC_FLAG_EXPLICIT_IV, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; SSL3_ENC_METHOD const TLSv1_2_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF | SSL_ENC_FLAG_TLS1_2_CIPHERS, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; SSL3_ENC_METHOD const TLSv1_3_enc_data = { tls13_setup_key_block, tls13_generate_master_secret, tls13_change_cipher_state, tls13_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls13_alert_code, tls13_export_keying_material, SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; OSSL_TIME tls1_default_timeout(void) { /* * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for * http, the cache would over fill */ return ossl_seconds2time(60 * 60 * 2); } int tls1_new(SSL *s) { if (!ssl3_new(s)) return 0; if (!s->method->ssl_clear(s)) return 0; return 1; } void tls1_free(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; OPENSSL_free(sc->ext.session_ticket); ssl3_free(s); } int tls1_clear(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (!ssl3_clear(s)) return 0; if (s->method->version == TLS_ANY_VERSION) sc->version = TLS_MAX_VERSION_INTERNAL; else sc->version = s->method->version; return 1; } /* Legacy NID to group_id mapping. Only works for groups we know about */ static const struct { int nid; uint16_t group_id; } nid_to_group[] = { {NID_sect163k1, OSSL_TLS_GROUP_ID_sect163k1}, {NID_sect163r1, OSSL_TLS_GROUP_ID_sect163r1}, {NID_sect163r2, OSSL_TLS_GROUP_ID_sect163r2}, {NID_sect193r1, OSSL_TLS_GROUP_ID_sect193r1}, {NID_sect193r2, OSSL_TLS_GROUP_ID_sect193r2}, {NID_sect233k1, OSSL_TLS_GROUP_ID_sect233k1}, {NID_sect233r1, OSSL_TLS_GROUP_ID_sect233r1}, {NID_sect239k1, OSSL_TLS_GROUP_ID_sect239k1}, {NID_sect283k1, OSSL_TLS_GROUP_ID_sect283k1}, {NID_sect283r1, OSSL_TLS_GROUP_ID_sect283r1}, {NID_sect409k1, OSSL_TLS_GROUP_ID_sect409k1}, {NID_sect409r1, OSSL_TLS_GROUP_ID_sect409r1}, {NID_sect571k1, OSSL_TLS_GROUP_ID_sect571k1}, {NID_sect571r1, OSSL_TLS_GROUP_ID_sect571r1}, {NID_secp160k1, OSSL_TLS_GROUP_ID_secp160k1}, {NID_secp160r1, OSSL_TLS_GROUP_ID_secp160r1}, {NID_secp160r2, OSSL_TLS_GROUP_ID_secp160r2}, {NID_secp192k1, OSSL_TLS_GROUP_ID_secp192k1}, {NID_X9_62_prime192v1, OSSL_TLS_GROUP_ID_secp192r1}, {NID_secp224k1, OSSL_TLS_GROUP_ID_secp224k1}, {NID_secp224r1, OSSL_TLS_GROUP_ID_secp224r1}, {NID_secp256k1, OSSL_TLS_GROUP_ID_secp256k1}, {NID_X9_62_prime256v1, OSSL_TLS_GROUP_ID_secp256r1}, {NID_secp384r1, OSSL_TLS_GROUP_ID_secp384r1}, {NID_secp521r1, OSSL_TLS_GROUP_ID_secp521r1}, {NID_brainpoolP256r1, OSSL_TLS_GROUP_ID_brainpoolP256r1}, {NID_brainpoolP384r1, OSSL_TLS_GROUP_ID_brainpoolP384r1}, {NID_brainpoolP512r1, OSSL_TLS_GROUP_ID_brainpoolP512r1}, {EVP_PKEY_X25519, OSSL_TLS_GROUP_ID_x25519}, {EVP_PKEY_X448, OSSL_TLS_GROUP_ID_x448}, {NID_brainpoolP256r1tls13, OSSL_TLS_GROUP_ID_brainpoolP256r1_tls13}, {NID_brainpoolP384r1tls13, OSSL_TLS_GROUP_ID_brainpoolP384r1_tls13}, {NID_brainpoolP512r1tls13, OSSL_TLS_GROUP_ID_brainpoolP512r1_tls13}, {NID_id_tc26_gost_3410_2012_256_paramSetA, OSSL_TLS_GROUP_ID_gc256A}, {NID_id_tc26_gost_3410_2012_256_paramSetB, OSSL_TLS_GROUP_ID_gc256B}, {NID_id_tc26_gost_3410_2012_256_paramSetC, OSSL_TLS_GROUP_ID_gc256C}, {NID_id_tc26_gost_3410_2012_256_paramSetD, OSSL_TLS_GROUP_ID_gc256D}, {NID_id_tc26_gost_3410_2012_512_paramSetA, OSSL_TLS_GROUP_ID_gc512A}, {NID_id_tc26_gost_3410_2012_512_paramSetB, OSSL_TLS_GROUP_ID_gc512B}, {NID_id_tc26_gost_3410_2012_512_paramSetC, OSSL_TLS_GROUP_ID_gc512C}, {NID_ffdhe2048, OSSL_TLS_GROUP_ID_ffdhe2048}, {NID_ffdhe3072, OSSL_TLS_GROUP_ID_ffdhe3072}, {NID_ffdhe4096, OSSL_TLS_GROUP_ID_ffdhe4096}, {NID_ffdhe6144, OSSL_TLS_GROUP_ID_ffdhe6144}, {NID_ffdhe8192, OSSL_TLS_GROUP_ID_ffdhe8192} }; static const unsigned char ecformats_default[] = { TLSEXT_ECPOINTFORMAT_uncompressed, TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime, TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2 }; /* The default curves */ static const uint16_t supported_groups_default[] = { OSSL_TLS_GROUP_ID_x25519, /* X25519 (29) */ OSSL_TLS_GROUP_ID_secp256r1, /* secp256r1 (23) */ OSSL_TLS_GROUP_ID_x448, /* X448 (30) */ OSSL_TLS_GROUP_ID_secp521r1, /* secp521r1 (25) */ OSSL_TLS_GROUP_ID_secp384r1, /* secp384r1 (24) */ OSSL_TLS_GROUP_ID_gc256A, /* GC256A (34) */ OSSL_TLS_GROUP_ID_gc256B, /* GC256B (35) */ OSSL_TLS_GROUP_ID_gc256C, /* GC256C (36) */ OSSL_TLS_GROUP_ID_gc256D, /* GC256D (37) */ OSSL_TLS_GROUP_ID_gc512A, /* GC512A (38) */ OSSL_TLS_GROUP_ID_gc512B, /* GC512B (39) */ OSSL_TLS_GROUP_ID_gc512C, /* GC512C (40) */ OSSL_TLS_GROUP_ID_ffdhe2048, /* ffdhe2048 (0x100) */ OSSL_TLS_GROUP_ID_ffdhe3072, /* ffdhe3072 (0x101) */ OSSL_TLS_GROUP_ID_ffdhe4096, /* ffdhe4096 (0x102) */ OSSL_TLS_GROUP_ID_ffdhe6144, /* ffdhe6144 (0x103) */ OSSL_TLS_GROUP_ID_ffdhe8192, /* ffdhe8192 (0x104) */ }; static const uint16_t suiteb_curves[] = { OSSL_TLS_GROUP_ID_secp256r1, OSSL_TLS_GROUP_ID_secp384r1, }; struct provider_ctx_data_st { SSL_CTX *ctx; OSSL_PROVIDER *provider; }; #define TLS_GROUP_LIST_MALLOC_BLOCK_SIZE 10 static OSSL_CALLBACK add_provider_groups; static int add_provider_groups(const OSSL_PARAM params[], void *data) { struct provider_ctx_data_st *pgd = data; SSL_CTX *ctx = pgd->ctx; OSSL_PROVIDER *provider = pgd->provider; const OSSL_PARAM *p; TLS_GROUP_INFO *ginf = NULL; EVP_KEYMGMT *keymgmt; unsigned int gid; unsigned int is_kem = 0; int ret = 0; if (ctx->group_list_max_len == ctx->group_list_len) { TLS_GROUP_INFO *tmp = NULL; if (ctx->group_list_max_len == 0) tmp = OPENSSL_malloc(sizeof(TLS_GROUP_INFO) * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE); else tmp = OPENSSL_realloc(ctx->group_list, (ctx->group_list_max_len + TLS_GROUP_LIST_MALLOC_BLOCK_SIZE) * sizeof(TLS_GROUP_INFO)); if (tmp == NULL) return 0; ctx->group_list = tmp; memset(tmp + ctx->group_list_max_len, 0, sizeof(TLS_GROUP_INFO) * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE); ctx->group_list_max_len += TLS_GROUP_LIST_MALLOC_BLOCK_SIZE; } ginf = &ctx->group_list[ctx->group_list_len]; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_NAME); if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->tlsname = OPENSSL_strdup(p->data); if (ginf->tlsname == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_NAME_INTERNAL); if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->realname = OPENSSL_strdup(p->data); if (ginf->realname == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_ID); if (p == NULL || !OSSL_PARAM_get_uint(p, &gid) || gid > UINT16_MAX) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->group_id = (uint16_t)gid; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_ALG); if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->algorithm = OPENSSL_strdup(p->data); if (ginf->algorithm == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_SECURITY_BITS); if (p == NULL || !OSSL_PARAM_get_uint(p, &ginf->secbits)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_IS_KEM); if (p != NULL && (!OSSL_PARAM_get_uint(p, &is_kem) || is_kem > 1)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } ginf->is_kem = 1 & is_kem; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MIN_TLS); if (p == NULL || !OSSL_PARAM_get_int(p, &ginf->mintls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MAX_TLS); if (p == NULL || !OSSL_PARAM_get_int(p, &ginf->maxtls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MIN_DTLS); if (p == NULL || !OSSL_PARAM_get_int(p, &ginf->mindtls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_GROUP_MAX_DTLS); if (p == NULL || !OSSL_PARAM_get_int(p, &ginf->maxdtls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } /* * Now check that the algorithm is actually usable for our property query * string. Regardless of the result we still return success because we have * successfully processed this group, even though we may decide not to use * it. */ ret = 1; ERR_set_mark(); keymgmt = EVP_KEYMGMT_fetch(ctx->libctx, ginf->algorithm, ctx->propq); if (keymgmt != NULL) { /* * We have successfully fetched the algorithm - however if the provider * doesn't match this one then we ignore it. * * Note: We're cheating a little here. Technically if the same algorithm * is available from more than one provider then it is undefined which * implementation you will get back. Theoretically this could be * different every time...we assume here that you'll always get the * same one back if you repeat the exact same fetch. Is this a reasonable * assumption to make (in which case perhaps we should document this * behaviour)? */ if (EVP_KEYMGMT_get0_provider(keymgmt) == provider) { /* We have a match - so we will use this group */ ctx->group_list_len++; ginf = NULL; } EVP_KEYMGMT_free(keymgmt); } ERR_pop_to_mark(); err: if (ginf != NULL) { OPENSSL_free(ginf->tlsname); OPENSSL_free(ginf->realname); OPENSSL_free(ginf->algorithm); ginf->algorithm = ginf->tlsname = ginf->realname = NULL; } return ret; } static int discover_provider_groups(OSSL_PROVIDER *provider, void *vctx) { struct provider_ctx_data_st pgd; pgd.ctx = vctx; pgd.provider = provider; return OSSL_PROVIDER_get_capabilities(provider, "TLS-GROUP", add_provider_groups, &pgd); } int ssl_load_groups(SSL_CTX *ctx) { size_t i, j, num_deflt_grps = 0; uint16_t tmp_supp_groups[OSSL_NELEM(supported_groups_default)]; if (!OSSL_PROVIDER_do_all(ctx->libctx, discover_provider_groups, ctx)) return 0; for (i = 0; i < OSSL_NELEM(supported_groups_default); i++) { for (j = 0; j < ctx->group_list_len; j++) { if (ctx->group_list[j].group_id == supported_groups_default[i]) { tmp_supp_groups[num_deflt_grps++] = ctx->group_list[j].group_id; break; } } } if (num_deflt_grps == 0) return 1; ctx->ext.supported_groups_default = OPENSSL_malloc(sizeof(uint16_t) * num_deflt_grps); if (ctx->ext.supported_groups_default == NULL) return 0; memcpy(ctx->ext.supported_groups_default, tmp_supp_groups, num_deflt_grps * sizeof(tmp_supp_groups[0])); ctx->ext.supported_groups_default_len = num_deflt_grps; return 1; } #define TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE 10 static OSSL_CALLBACK add_provider_sigalgs; static int add_provider_sigalgs(const OSSL_PARAM params[], void *data) { struct provider_ctx_data_st *pgd = data; SSL_CTX *ctx = pgd->ctx; OSSL_PROVIDER *provider = pgd->provider; const OSSL_PARAM *p; TLS_SIGALG_INFO *sinf = NULL; EVP_KEYMGMT *keymgmt; const char *keytype; unsigned int code_point = 0; int ret = 0; if (ctx->sigalg_list_max_len == ctx->sigalg_list_len) { TLS_SIGALG_INFO *tmp = NULL; if (ctx->sigalg_list_max_len == 0) tmp = OPENSSL_malloc(sizeof(TLS_SIGALG_INFO) * TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE); else tmp = OPENSSL_realloc(ctx->sigalg_list, (ctx->sigalg_list_max_len + TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE) * sizeof(TLS_SIGALG_INFO)); if (tmp == NULL) return 0; ctx->sigalg_list = tmp; memset(tmp + ctx->sigalg_list_max_len, 0, sizeof(TLS_SIGALG_INFO) * TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE); ctx->sigalg_list_max_len += TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE; } sinf = &ctx->sigalg_list[ctx->sigalg_list_len]; /* First, mandatory parameters */ p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_NAME); if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } OPENSSL_free(sinf->sigalg_name); sinf->sigalg_name = OPENSSL_strdup(p->data); if (sinf->sigalg_name == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_IANA_NAME); if (p == NULL || p->data_type != OSSL_PARAM_UTF8_STRING) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } OPENSSL_free(sinf->name); sinf->name = OPENSSL_strdup(p->data); if (sinf->name == NULL) goto err; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT); if (p == NULL || !OSSL_PARAM_get_uint(p, &code_point) || code_point > UINT16_MAX) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } sinf->code_point = (uint16_t)code_point; p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS); if (p == NULL || !OSSL_PARAM_get_uint(p, &sinf->secbits)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } /* Now, optional parameters */ p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_OID); if (p == NULL) { sinf->sigalg_oid = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->sigalg_oid); sinf->sigalg_oid = OPENSSL_strdup(p->data); if (sinf->sigalg_oid == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_SIG_NAME); if (p == NULL) { sinf->sig_name = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->sig_name); sinf->sig_name = OPENSSL_strdup(p->data); if (sinf->sig_name == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_SIG_OID); if (p == NULL) { sinf->sig_oid = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->sig_oid); sinf->sig_oid = OPENSSL_strdup(p->data); if (sinf->sig_oid == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_HASH_NAME); if (p == NULL) { sinf->hash_name = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->hash_name); sinf->hash_name = OPENSSL_strdup(p->data); if (sinf->hash_name == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_HASH_OID); if (p == NULL) { sinf->hash_oid = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->hash_oid); sinf->hash_oid = OPENSSL_strdup(p->data); if (sinf->hash_oid == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE); if (p == NULL) { sinf->keytype = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->keytype); sinf->keytype = OPENSSL_strdup(p->data); if (sinf->keytype == NULL) goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_KEYTYPE_OID); if (p == NULL) { sinf->keytype_oid = NULL; } else if (p->data_type != OSSL_PARAM_UTF8_STRING) { goto err; } else { OPENSSL_free(sinf->keytype_oid); sinf->keytype_oid = OPENSSL_strdup(p->data); if (sinf->keytype_oid == NULL) goto err; } /* The remaining parameters below are mandatory again */ p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_MIN_TLS); if (p == NULL || !OSSL_PARAM_get_int(p, &sinf->mintls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if ((sinf->mintls != 0) && (sinf->mintls != -1) && ((sinf->mintls < TLS1_3_VERSION))) { /* ignore this sigalg as this OpenSSL doesn't know how to handle it */ ret = 1; goto err; } p = OSSL_PARAM_locate_const(params, OSSL_CAPABILITY_TLS_SIGALG_MAX_TLS); if (p == NULL || !OSSL_PARAM_get_int(p, &sinf->maxtls)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if ((sinf->maxtls != 0) && (sinf->maxtls != -1) && ((sinf->maxtls < sinf->mintls))) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if ((sinf->maxtls != 0) && (sinf->maxtls != -1) && ((sinf->maxtls < TLS1_3_VERSION))) { /* ignore this sigalg as this OpenSSL doesn't know how to handle it */ ret = 1; goto err; } /* * Now check that the algorithm is actually usable for our property query * string. Regardless of the result we still return success because we have * successfully processed this signature, even though we may decide not to * use it. */ ret = 1; ERR_set_mark(); keytype = (sinf->keytype != NULL ? sinf->keytype : (sinf->sig_name != NULL ? sinf->sig_name : sinf->sigalg_name)); keymgmt = EVP_KEYMGMT_fetch(ctx->libctx, keytype, ctx->propq); if (keymgmt != NULL) { /* * We have successfully fetched the algorithm - however if the provider * doesn't match this one then we ignore it. * * Note: We're cheating a little here. Technically if the same algorithm * is available from more than one provider then it is undefined which * implementation you will get back. Theoretically this could be * different every time...we assume here that you'll always get the * same one back if you repeat the exact same fetch. Is this a reasonable * assumption to make (in which case perhaps we should document this * behaviour)? */ if (EVP_KEYMGMT_get0_provider(keymgmt) == provider) { /* * We have a match - so we could use this signature; * Check proper object registration first, though. * Don't care about return value as this may have been * done within providers or previous calls to * add_provider_sigalgs. */ OBJ_create(sinf->sigalg_oid, sinf->sigalg_name, NULL); /* sanity check: Without successful registration don't use alg */ if ((OBJ_txt2nid(sinf->sigalg_name) == NID_undef) || (OBJ_nid2obj(OBJ_txt2nid(sinf->sigalg_name)) == NULL)) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if (sinf->sig_name != NULL) OBJ_create(sinf->sig_oid, sinf->sig_name, NULL); if (sinf->keytype != NULL) OBJ_create(sinf->keytype_oid, sinf->keytype, NULL); if (sinf->hash_name != NULL) OBJ_create(sinf->hash_oid, sinf->hash_name, NULL); OBJ_add_sigid(OBJ_txt2nid(sinf->sigalg_name), (sinf->hash_name != NULL ? OBJ_txt2nid(sinf->hash_name) : NID_undef), OBJ_txt2nid(keytype)); ctx->sigalg_list_len++; sinf = NULL; } EVP_KEYMGMT_free(keymgmt); } ERR_pop_to_mark(); err: if (sinf != NULL) { OPENSSL_free(sinf->name); sinf->name = NULL; OPENSSL_free(sinf->sigalg_name); sinf->sigalg_name = NULL; OPENSSL_free(sinf->sigalg_oid); sinf->sigalg_oid = NULL; OPENSSL_free(sinf->sig_name); sinf->sig_name = NULL; OPENSSL_free(sinf->sig_oid); sinf->sig_oid = NULL; OPENSSL_free(sinf->hash_name); sinf->hash_name = NULL; OPENSSL_free(sinf->hash_oid); sinf->hash_oid = NULL; OPENSSL_free(sinf->keytype); sinf->keytype = NULL; OPENSSL_free(sinf->keytype_oid); sinf->keytype_oid = NULL; } return ret; } static int discover_provider_sigalgs(OSSL_PROVIDER *provider, void *vctx) { struct provider_ctx_data_st pgd; pgd.ctx = vctx; pgd.provider = provider; OSSL_PROVIDER_get_capabilities(provider, "TLS-SIGALG", add_provider_sigalgs, &pgd); /* * Always OK, even if provider doesn't support the capability: * Reconsider testing retval when legacy sigalgs are also loaded this way. */ return 1; } int ssl_load_sigalgs(SSL_CTX *ctx) { size_t i; SSL_CERT_LOOKUP lu; if (!OSSL_PROVIDER_do_all(ctx->libctx, discover_provider_sigalgs, ctx)) return 0; /* now populate ctx->ssl_cert_info */ if (ctx->sigalg_list_len > 0) { ctx->ssl_cert_info = OPENSSL_zalloc(sizeof(lu) * ctx->sigalg_list_len); if (ctx->ssl_cert_info == NULL) return 0; for(i = 0; i < ctx->sigalg_list_len; i++) { ctx->ssl_cert_info[i].nid = OBJ_txt2nid(ctx->sigalg_list[i].sigalg_name); ctx->ssl_cert_info[i].amask = SSL_aANY; } } /* * For now, leave it at this: legacy sigalgs stay in their own * data structures until "legacy cleanup" occurs. */ return 1; } static uint16_t tls1_group_name2id(SSL_CTX *ctx, const char *name) { size_t i; for (i = 0; i < ctx->group_list_len; i++) { if (strcmp(ctx->group_list[i].tlsname, name) == 0 || strcmp(ctx->group_list[i].realname, name) == 0) return ctx->group_list[i].group_id; } return 0; } const TLS_GROUP_INFO *tls1_group_id_lookup(SSL_CTX *ctx, uint16_t group_id) { size_t i; for (i = 0; i < ctx->group_list_len; i++) { if (ctx->group_list[i].group_id == group_id) return &ctx->group_list[i]; } return NULL; } const char *tls1_group_id2name(SSL_CTX *ctx, uint16_t group_id) { const TLS_GROUP_INFO *tls_group_info = tls1_group_id_lookup(ctx, group_id); if (tls_group_info == NULL) return NULL; return tls_group_info->tlsname; } int tls1_group_id2nid(uint16_t group_id, int include_unknown) { size_t i; if (group_id == 0) return NID_undef; /* * Return well known Group NIDs - for backwards compatibility. This won't * work for groups we don't know about. */ for (i = 0; i < OSSL_NELEM(nid_to_group); i++) { if (nid_to_group[i].group_id == group_id) return nid_to_group[i].nid; } if (!include_unknown) return NID_undef; return TLSEXT_nid_unknown | (int)group_id; } uint16_t tls1_nid2group_id(int nid) { size_t i; /* * Return well known Group ids - for backwards compatibility. This won't * work for groups we don't know about. */ for (i = 0; i < OSSL_NELEM(nid_to_group); i++) { if (nid_to_group[i].nid == nid) return nid_to_group[i].group_id; } return 0; } /* * Set *pgroups to the supported groups list and *pgroupslen to * the number of groups supported. */ void tls1_get_supported_groups(SSL_CONNECTION *s, const uint16_t **pgroups, size_t *pgroupslen) { SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* For Suite B mode only include P-256, P-384 */ switch (tls1_suiteb(s)) { case SSL_CERT_FLAG_SUITEB_128_LOS: *pgroups = suiteb_curves; *pgroupslen = OSSL_NELEM(suiteb_curves); break; case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY: *pgroups = suiteb_curves; *pgroupslen = 1; break; case SSL_CERT_FLAG_SUITEB_192_LOS: *pgroups = suiteb_curves + 1; *pgroupslen = 1; break; default: if (s->ext.supportedgroups == NULL) { *pgroups = sctx->ext.supported_groups_default; *pgroupslen = sctx->ext.supported_groups_default_len; } else { *pgroups = s->ext.supportedgroups; *pgroupslen = s->ext.supportedgroups_len; } break; } } int tls_valid_group(SSL_CONNECTION *s, uint16_t group_id, int minversion, int maxversion, int isec, int *okfortls13) { const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s), group_id); int ret; int group_minversion, group_maxversion; if (okfortls13 != NULL) *okfortls13 = 0; if (ginfo == NULL) return 0; group_minversion = SSL_CONNECTION_IS_DTLS(s) ? ginfo->mindtls : ginfo->mintls; group_maxversion = SSL_CONNECTION_IS_DTLS(s) ? ginfo->maxdtls : ginfo->maxtls; if (group_minversion < 0 || group_maxversion < 0) return 0; if (group_maxversion == 0) ret = 1; else ret = (ssl_version_cmp(s, minversion, group_maxversion) <= 0); if (group_minversion > 0) ret &= (ssl_version_cmp(s, maxversion, group_minversion) >= 0); if (!SSL_CONNECTION_IS_DTLS(s)) { if (ret && okfortls13 != NULL && maxversion == TLS1_3_VERSION) *okfortls13 = (group_maxversion == 0) || (group_maxversion >= TLS1_3_VERSION); } ret &= !isec || strcmp(ginfo->algorithm, "EC") == 0 || strcmp(ginfo->algorithm, "X25519") == 0 || strcmp(ginfo->algorithm, "X448") == 0; return ret; } /* See if group is allowed by security callback */ int tls_group_allowed(SSL_CONNECTION *s, uint16_t group, int op) { const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s), group); unsigned char gtmp[2]; if (ginfo == NULL) return 0; gtmp[0] = group >> 8; gtmp[1] = group & 0xff; return ssl_security(s, op, ginfo->secbits, tls1_group_id2nid(ginfo->group_id, 0), (void *)gtmp); } /* Return 1 if "id" is in "list" */ static int tls1_in_list(uint16_t id, const uint16_t *list, size_t listlen) { size_t i; for (i = 0; i < listlen; i++) if (list[i] == id) return 1; return 0; } /*- * For nmatch >= 0, return the id of the |nmatch|th shared group or 0 * if there is no match. * For nmatch == -1, return number of matches * For nmatch == -2, return the id of the group to use for * a tmp key, or 0 if there is no match. */ uint16_t tls1_shared_group(SSL_CONNECTION *s, int nmatch) { const uint16_t *pref, *supp; size_t num_pref, num_supp, i; int k; SSL_CTX *ctx = SSL_CONNECTION_GET_CTX(s); /* Can't do anything on client side */ if (s->server == 0) return 0; if (nmatch == -2) { if (tls1_suiteb(s)) { /* * For Suite B ciphersuite determines curve: we already know * these are acceptable due to previous checks. */ unsigned long cid = s->s3.tmp.new_cipher->id; if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) return OSSL_TLS_GROUP_ID_secp256r1; if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) return OSSL_TLS_GROUP_ID_secp384r1; /* Should never happen */ return 0; } /* If not Suite B just return first preference shared curve */ nmatch = 0; } /* * If server preference set, our groups are the preference order * otherwise peer decides. */ if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) { tls1_get_supported_groups(s, &pref, &num_pref); tls1_get_peer_groups(s, &supp, &num_supp); } else { tls1_get_peer_groups(s, &pref, &num_pref); tls1_get_supported_groups(s, &supp, &num_supp); } for (k = 0, i = 0; i < num_pref; i++) { uint16_t id = pref[i]; const TLS_GROUP_INFO *inf; int minversion, maxversion; if (!tls1_in_list(id, supp, num_supp) || !tls_group_allowed(s, id, SSL_SECOP_CURVE_SHARED)) continue; inf = tls1_group_id_lookup(ctx, id); if (!ossl_assert(inf != NULL)) return 0; minversion = SSL_CONNECTION_IS_DTLS(s) ? inf->mindtls : inf->mintls; maxversion = SSL_CONNECTION_IS_DTLS(s) ? inf->maxdtls : inf->maxtls; if (maxversion == -1) continue; if ((minversion != 0 && ssl_version_cmp(s, s->version, minversion) < 0) || (maxversion != 0 && ssl_version_cmp(s, s->version, maxversion) > 0)) continue; if (nmatch == k) return id; k++; } if (nmatch == -1) return k; /* Out of range (nmatch > k). */ return 0; } int tls1_set_groups(uint16_t **pext, size_t *pextlen, int *groups, size_t ngroups) { uint16_t *glist; size_t i; /* * Bitmap of groups included to detect duplicates: two variables are added * to detect duplicates as some values are more than 32. */ unsigned long *dup_list = NULL; unsigned long dup_list_egrp = 0; unsigned long dup_list_dhgrp = 0; if (ngroups == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); return 0; } if ((glist = OPENSSL_malloc(ngroups * sizeof(*glist))) == NULL) return 0; for (i = 0; i < ngroups; i++) { unsigned long idmask; uint16_t id; id = tls1_nid2group_id(groups[i]); if ((id & 0x00FF) >= (sizeof(unsigned long) * 8)) goto err; idmask = 1L << (id & 0x00FF); dup_list = (id < 0x100) ? &dup_list_egrp : &dup_list_dhgrp; if (!id || ((*dup_list) & idmask)) goto err; *dup_list |= idmask; glist[i] = id; } OPENSSL_free(*pext); *pext = glist; *pextlen = ngroups; return 1; err: OPENSSL_free(glist); return 0; } # define GROUPLIST_INCREMENT 40 # define GROUP_NAME_BUFFER_LENGTH 64 typedef struct { SSL_CTX *ctx; size_t gidcnt; size_t gidmax; uint16_t *gid_arr; } gid_cb_st; static int gid_cb(const char *elem, int len, void *arg) { gid_cb_st *garg = arg; size_t i; uint16_t gid = 0; char etmp[GROUP_NAME_BUFFER_LENGTH]; if (elem == NULL) return 0; if (garg->gidcnt == garg->gidmax) { uint16_t *tmp = OPENSSL_realloc(garg->gid_arr, garg->gidmax + GROUPLIST_INCREMENT); if (tmp == NULL) return 0; garg->gidmax += GROUPLIST_INCREMENT; garg->gid_arr = tmp; } if (len > (int)(sizeof(etmp) - 1)) return 0; memcpy(etmp, elem, len); etmp[len] = 0; gid = tls1_group_name2id(garg->ctx, etmp); if (gid == 0) { ERR_raise_data(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT, "group '%s' cannot be set", etmp); return 0; } for (i = 0; i < garg->gidcnt; i++) if (garg->gid_arr[i] == gid) return 0; garg->gid_arr[garg->gidcnt++] = gid; return 1; } /* Set groups based on a colon separated list */ int tls1_set_groups_list(SSL_CTX *ctx, uint16_t **pext, size_t *pextlen, const char *str) { gid_cb_st gcb; uint16_t *tmparr; int ret = 0; gcb.gidcnt = 0; gcb.gidmax = GROUPLIST_INCREMENT; gcb.gid_arr = OPENSSL_malloc(gcb.gidmax * sizeof(*gcb.gid_arr)); if (gcb.gid_arr == NULL) return 0; gcb.ctx = ctx; if (!CONF_parse_list(str, ':', 1, gid_cb, &gcb)) goto end; if (pext == NULL) { ret = 1; goto end; } /* * gid_cb ensurse there are no duplicates so we can just go ahead and set * the result */ tmparr = OPENSSL_memdup(gcb.gid_arr, gcb.gidcnt * sizeof(*tmparr)); if (tmparr == NULL) goto end; OPENSSL_free(*pext); *pext = tmparr; *pextlen = gcb.gidcnt; ret = 1; end: OPENSSL_free(gcb.gid_arr); return ret; } /* Check a group id matches preferences */ int tls1_check_group_id(SSL_CONNECTION *s, uint16_t group_id, int check_own_groups) { const uint16_t *groups; size_t groups_len; if (group_id == 0) return 0; /* Check for Suite B compliance */ if (tls1_suiteb(s) && s->s3.tmp.new_cipher != NULL) { unsigned long cid = s->s3.tmp.new_cipher->id; if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) { if (group_id != OSSL_TLS_GROUP_ID_secp256r1) return 0; } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) { if (group_id != OSSL_TLS_GROUP_ID_secp384r1) return 0; } else { /* Should never happen */ return 0; } } if (check_own_groups) { /* Check group is one of our preferences */ tls1_get_supported_groups(s, &groups, &groups_len); if (!tls1_in_list(group_id, groups, groups_len)) return 0; } if (!tls_group_allowed(s, group_id, SSL_SECOP_CURVE_CHECK)) return 0; /* For clients, nothing more to check */ if (!s->server) return 1; /* Check group is one of peers preferences */ tls1_get_peer_groups(s, &groups, &groups_len); /* * RFC 4492 does not require the supported elliptic curves extension * so if it is not sent we can just choose any curve. * It is invalid to send an empty list in the supported groups * extension, so groups_len == 0 always means no extension. */ if (groups_len == 0) return 1; return tls1_in_list(group_id, groups, groups_len); } void tls1_get_formatlist(SSL_CONNECTION *s, const unsigned char **pformats, size_t *num_formats) { /* * If we have a custom point format list use it otherwise use default */ if (s->ext.ecpointformats) { *pformats = s->ext.ecpointformats; *num_formats = s->ext.ecpointformats_len; } else { *pformats = ecformats_default; /* For Suite B we don't support char2 fields */ if (tls1_suiteb(s)) *num_formats = sizeof(ecformats_default) - 1; else *num_formats = sizeof(ecformats_default); } } /* Check a key is compatible with compression extension */ static int tls1_check_pkey_comp(SSL_CONNECTION *s, EVP_PKEY *pkey) { unsigned char comp_id; size_t i; int point_conv; /* If not an EC key nothing to check */ if (!EVP_PKEY_is_a(pkey, "EC")) return 1; /* Get required compression id */ point_conv = EVP_PKEY_get_ec_point_conv_form(pkey); if (point_conv == 0) return 0; if (point_conv == POINT_CONVERSION_UNCOMPRESSED) { comp_id = TLSEXT_ECPOINTFORMAT_uncompressed; } else if (SSL_CONNECTION_IS_TLS13(s)) { /* * ec_point_formats extension is not used in TLSv1.3 so we ignore * this check. */ return 1; } else { int field_type = EVP_PKEY_get_field_type(pkey); if (field_type == NID_X9_62_prime_field) comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime; else if (field_type == NID_X9_62_characteristic_two_field) comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2; else return 0; } /* * If point formats extension present check it, otherwise everything is * supported (see RFC4492). */ if (s->ext.peer_ecpointformats == NULL) return 1; for (i = 0; i < s->ext.peer_ecpointformats_len; i++) { if (s->ext.peer_ecpointformats[i] == comp_id) return 1; } return 0; } /* Return group id of a key */ static uint16_t tls1_get_group_id(EVP_PKEY *pkey) { int curve_nid = ssl_get_EC_curve_nid(pkey); if (curve_nid == NID_undef) return 0; return tls1_nid2group_id(curve_nid); } /* * Check cert parameters compatible with extensions: currently just checks EC * certificates have compatible curves and compression. */ static int tls1_check_cert_param(SSL_CONNECTION *s, X509 *x, int check_ee_md) { uint16_t group_id; EVP_PKEY *pkey; pkey = X509_get0_pubkey(x); if (pkey == NULL) return 0; /* If not EC nothing to do */ if (!EVP_PKEY_is_a(pkey, "EC")) return 1; /* Check compression */ if (!tls1_check_pkey_comp(s, pkey)) return 0; group_id = tls1_get_group_id(pkey); /* * For a server we allow the certificate to not be in our list of supported * groups. */ if (!tls1_check_group_id(s, group_id, !s->server)) return 0; /* * Special case for suite B. We *MUST* sign using SHA256+P-256 or * SHA384+P-384. */ if (check_ee_md && tls1_suiteb(s)) { int check_md; size_t i; /* Check to see we have necessary signing algorithm */ if (group_id == OSSL_TLS_GROUP_ID_secp256r1) check_md = NID_ecdsa_with_SHA256; else if (group_id == OSSL_TLS_GROUP_ID_secp384r1) check_md = NID_ecdsa_with_SHA384; else return 0; /* Should never happen */ for (i = 0; i < s->shared_sigalgslen; i++) { if (check_md == s->shared_sigalgs[i]->sigandhash) return 1; } return 0; } return 1; } /* * tls1_check_ec_tmp_key - Check EC temporary key compatibility * @s: SSL connection * @cid: Cipher ID we're considering using * * Checks that the kECDHE cipher suite we're considering using * is compatible with the client extensions. * * Returns 0 when the cipher can't be used or 1 when it can. */ int tls1_check_ec_tmp_key(SSL_CONNECTION *s, unsigned long cid) { /* If not Suite B just need a shared group */ if (!tls1_suiteb(s)) return tls1_shared_group(s, 0) != 0; /* * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other * curves permitted. */ if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) return tls1_check_group_id(s, OSSL_TLS_GROUP_ID_secp256r1, 1); if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) return tls1_check_group_id(s, OSSL_TLS_GROUP_ID_secp384r1, 1); return 0; } /* Default sigalg schemes */ static const uint16_t tls12_sigalgs[] = { TLSEXT_SIGALG_ecdsa_secp256r1_sha256, TLSEXT_SIGALG_ecdsa_secp384r1_sha384, TLSEXT_SIGALG_ecdsa_secp521r1_sha512, TLSEXT_SIGALG_ed25519, TLSEXT_SIGALG_ed448, TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, TLSEXT_SIGALG_rsa_pss_pss_sha256, TLSEXT_SIGALG_rsa_pss_pss_sha384, TLSEXT_SIGALG_rsa_pss_pss_sha512, TLSEXT_SIGALG_rsa_pss_rsae_sha256, TLSEXT_SIGALG_rsa_pss_rsae_sha384, TLSEXT_SIGALG_rsa_pss_rsae_sha512, TLSEXT_SIGALG_rsa_pkcs1_sha256, TLSEXT_SIGALG_rsa_pkcs1_sha384, TLSEXT_SIGALG_rsa_pkcs1_sha512, TLSEXT_SIGALG_ecdsa_sha224, TLSEXT_SIGALG_ecdsa_sha1, TLSEXT_SIGALG_rsa_pkcs1_sha224, TLSEXT_SIGALG_rsa_pkcs1_sha1, TLSEXT_SIGALG_dsa_sha224, TLSEXT_SIGALG_dsa_sha1, TLSEXT_SIGALG_dsa_sha256, TLSEXT_SIGALG_dsa_sha384, TLSEXT_SIGALG_dsa_sha512, #ifndef OPENSSL_NO_GOST TLSEXT_SIGALG_gostr34102012_256_intrinsic, TLSEXT_SIGALG_gostr34102012_512_intrinsic, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, TLSEXT_SIGALG_gostr34102001_gostr3411, #endif }; static const uint16_t suiteb_sigalgs[] = { TLSEXT_SIGALG_ecdsa_secp256r1_sha256, TLSEXT_SIGALG_ecdsa_secp384r1_sha384 }; static const SIGALG_LOOKUP sigalg_lookup_tbl[] = { {"ecdsa_secp256r1_sha256", TLSEXT_SIGALG_ecdsa_secp256r1_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA256, NID_X9_62_prime256v1, 1}, {"ecdsa_secp384r1_sha384", TLSEXT_SIGALG_ecdsa_secp384r1_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA384, NID_secp384r1, 1}, {"ecdsa_secp521r1_sha512", TLSEXT_SIGALG_ecdsa_secp521r1_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA512, NID_secp521r1, 1}, {"ed25519", TLSEXT_SIGALG_ed25519, NID_undef, -1, EVP_PKEY_ED25519, SSL_PKEY_ED25519, NID_undef, NID_undef, 1}, {"ed448", TLSEXT_SIGALG_ed448, NID_undef, -1, EVP_PKEY_ED448, SSL_PKEY_ED448, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_ecdsa_sha224, NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA224, NID_undef, 1}, {NULL, TLSEXT_SIGALG_ecdsa_sha1, NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA1, NID_undef, 1}, {"ecdsa_brainpoolP256r1_sha256", TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA256, NID_brainpoolP256r1, 1}, {"ecdsa_brainpoolP384r1_sha384", TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA384, NID_brainpoolP384r1, 1}, {"ecdsa_brainpoolP512r1_sha512", TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC, NID_ecdsa_with_SHA512, NID_brainpoolP512r1, 1}, {"rsa_pss_rsae_sha256", TLSEXT_SIGALG_rsa_pss_rsae_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA, NID_undef, NID_undef, 1}, {"rsa_pss_rsae_sha384", TLSEXT_SIGALG_rsa_pss_rsae_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA, NID_undef, NID_undef, 1}, {"rsa_pss_rsae_sha512", TLSEXT_SIGALG_rsa_pss_rsae_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA, NID_undef, NID_undef, 1}, {"rsa_pss_pss_sha256", TLSEXT_SIGALG_rsa_pss_pss_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN, NID_undef, NID_undef, 1}, {"rsa_pss_pss_sha384", TLSEXT_SIGALG_rsa_pss_pss_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN, NID_undef, NID_undef, 1}, {"rsa_pss_pss_sha512", TLSEXT_SIGALG_rsa_pss_pss_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN, NID_undef, NID_undef, 1}, {"rsa_pkcs1_sha256", TLSEXT_SIGALG_rsa_pkcs1_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha256WithRSAEncryption, NID_undef, 1}, {"rsa_pkcs1_sha384", TLSEXT_SIGALG_rsa_pkcs1_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha384WithRSAEncryption, NID_undef, 1}, {"rsa_pkcs1_sha512", TLSEXT_SIGALG_rsa_pkcs1_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha512WithRSAEncryption, NID_undef, 1}, {"rsa_pkcs1_sha224", TLSEXT_SIGALG_rsa_pkcs1_sha224, NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha224WithRSAEncryption, NID_undef, 1}, {"rsa_pkcs1_sha1", TLSEXT_SIGALG_rsa_pkcs1_sha1, NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_sha1WithRSAEncryption, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha256, NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_dsa_with_SHA256, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha384, NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha512, NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha224, NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_dsa_sha1, NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN, NID_dsaWithSHA1, NID_undef, 1}, #ifndef OPENSSL_NO_GOST {NULL, TLSEXT_SIGALG_gostr34102012_256_intrinsic, NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX, NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_gostr34102012_512_intrinsic, NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX, NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX, NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX, NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512, NID_undef, NID_undef, 1}, {NULL, TLSEXT_SIGALG_gostr34102001_gostr3411, NID_id_GostR3411_94, SSL_MD_GOST94_IDX, NID_id_GostR3410_2001, SSL_PKEY_GOST01, NID_undef, NID_undef, 1} #endif }; /* Legacy sigalgs for TLS < 1.2 RSA TLS signatures */ static const SIGALG_LOOKUP legacy_rsa_sigalg = { "rsa_pkcs1_md5_sha1", 0, NID_md5_sha1, SSL_MD_MD5_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA, NID_undef, NID_undef, 1 }; /* * Default signature algorithm values used if signature algorithms not present. * From RFC5246. Note: order must match certificate index order. */ static const uint16_t tls_default_sigalg[] = { TLSEXT_SIGALG_rsa_pkcs1_sha1, /* SSL_PKEY_RSA */ 0, /* SSL_PKEY_RSA_PSS_SIGN */ TLSEXT_SIGALG_dsa_sha1, /* SSL_PKEY_DSA_SIGN */ TLSEXT_SIGALG_ecdsa_sha1, /* SSL_PKEY_ECC */ TLSEXT_SIGALG_gostr34102001_gostr3411, /* SSL_PKEY_GOST01 */ TLSEXT_SIGALG_gostr34102012_256_intrinsic, /* SSL_PKEY_GOST12_256 */ TLSEXT_SIGALG_gostr34102012_512_intrinsic, /* SSL_PKEY_GOST12_512 */ 0, /* SSL_PKEY_ED25519 */ 0, /* SSL_PKEY_ED448 */ }; int ssl_setup_sigalgs(SSL_CTX *ctx) { size_t i, cache_idx, sigalgs_len; const SIGALG_LOOKUP *lu; SIGALG_LOOKUP *cache = NULL; uint16_t *tls12_sigalgs_list = NULL; EVP_PKEY *tmpkey = EVP_PKEY_new(); int ret = 0; if (ctx == NULL) goto err; sigalgs_len = OSSL_NELEM(sigalg_lookup_tbl) + ctx->sigalg_list_len; cache = OPENSSL_malloc(sizeof(const SIGALG_LOOKUP) * sigalgs_len); if (cache == NULL || tmpkey == NULL) goto err; tls12_sigalgs_list = OPENSSL_malloc(sizeof(uint16_t) * sigalgs_len); if (tls12_sigalgs_list == NULL) goto err; ERR_set_mark(); /* First fill cache and tls12_sigalgs list from legacy algorithm list */ for (i = 0, lu = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl); lu++, i++) { EVP_PKEY_CTX *pctx; cache[i] = *lu; tls12_sigalgs_list[i] = tls12_sigalgs[i]; /* * Check hash is available. * This test is not perfect. A provider could have support * for a signature scheme, but not a particular hash. However the hash * could be available from some other loaded provider. In that case it * could be that the signature is available, and the hash is available * independently - but not as a combination. We ignore this for now. */ if (lu->hash != NID_undef && ctx->ssl_digest_methods[lu->hash_idx] == NULL) { cache[i].enabled = 0; continue; } if (!EVP_PKEY_set_type(tmpkey, lu->sig)) { cache[i].enabled = 0; continue; } pctx = EVP_PKEY_CTX_new_from_pkey(ctx->libctx, tmpkey, ctx->propq); /* If unable to create pctx we assume the sig algorithm is unavailable */ if (pctx == NULL) cache[i].enabled = 0; EVP_PKEY_CTX_free(pctx); } /* Now complete cache and tls12_sigalgs list with provider sig information */ cache_idx = OSSL_NELEM(sigalg_lookup_tbl); for (i = 0; i < ctx->sigalg_list_len; i++) { TLS_SIGALG_INFO si = ctx->sigalg_list[i]; cache[cache_idx].name = si.name; cache[cache_idx].sigalg = si.code_point; tls12_sigalgs_list[cache_idx] = si.code_point; cache[cache_idx].hash = si.hash_name?OBJ_txt2nid(si.hash_name):NID_undef; cache[cache_idx].hash_idx = ssl_get_md_idx(cache[cache_idx].hash); cache[cache_idx].sig = OBJ_txt2nid(si.sigalg_name); cache[cache_idx].sig_idx = i + SSL_PKEY_NUM; cache[cache_idx].sigandhash = OBJ_txt2nid(si.sigalg_name); cache[cache_idx].curve = NID_undef; /* all provided sigalgs are enabled by load */ cache[cache_idx].enabled = 1; cache_idx++; } ERR_pop_to_mark(); ctx->sigalg_lookup_cache = cache; ctx->tls12_sigalgs = tls12_sigalgs_list; ctx->tls12_sigalgs_len = sigalgs_len; cache = NULL; tls12_sigalgs_list = NULL; ret = 1; err: OPENSSL_free(cache); OPENSSL_free(tls12_sigalgs_list); EVP_PKEY_free(tmpkey); return ret; } /* Lookup TLS signature algorithm */ static const SIGALG_LOOKUP *tls1_lookup_sigalg(const SSL_CONNECTION *s, uint16_t sigalg) { size_t i; const SIGALG_LOOKUP *lu; for (i = 0, lu = SSL_CONNECTION_GET_CTX(s)->sigalg_lookup_cache; i < SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs_len; lu++, i++) { if (lu->sigalg == sigalg) { if (!lu->enabled) return NULL; return lu; } } return NULL; } /* Lookup hash: return 0 if invalid or not enabled */ int tls1_lookup_md(SSL_CTX *ctx, const SIGALG_LOOKUP *lu, const EVP_MD **pmd) { const EVP_MD *md; if (lu == NULL) return 0; /* lu->hash == NID_undef means no associated digest */ if (lu->hash == NID_undef) { md = NULL; } else { md = ssl_md(ctx, lu->hash_idx); if (md == NULL) return 0; } if (pmd) *pmd = md; return 1; } /* * Check if key is large enough to generate RSA-PSS signature. * * The key must greater than or equal to 2 * hash length + 2. * SHA512 has a hash length of 64 bytes, which is incompatible * with a 128 byte (1024 bit) key. */ #define RSA_PSS_MINIMUM_KEY_SIZE(md) (2 * EVP_MD_get_size(md) + 2) static int rsa_pss_check_min_key_size(SSL_CTX *ctx, const EVP_PKEY *pkey, const SIGALG_LOOKUP *lu) { const EVP_MD *md; if (pkey == NULL) return 0; if (!tls1_lookup_md(ctx, lu, &md) || md == NULL) return 0; if (EVP_PKEY_get_size(pkey) < RSA_PSS_MINIMUM_KEY_SIZE(md)) return 0; return 1; } /* * Returns a signature algorithm when the peer did not send a list of supported * signature algorithms. The signature algorithm is fixed for the certificate * type. |idx| is a certificate type index (SSL_PKEY_*). When |idx| is -1 the * certificate type from |s| will be used. * Returns the signature algorithm to use, or NULL on error. */ static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL_CONNECTION *s, int idx) { if (idx == -1) { if (s->server) { size_t i; /* Work out index corresponding to ciphersuite */ for (i = 0; i < s->ssl_pkey_num; i++) { const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_idx(i, SSL_CONNECTION_GET_CTX(s)); if (clu == NULL) continue; if (clu->amask & s->s3.tmp.new_cipher->algorithm_auth) { idx = i; break; } } /* * Some GOST ciphersuites allow more than one signature algorithms * */ if (idx == SSL_PKEY_GOST01 && s->s3.tmp.new_cipher->algorithm_auth != SSL_aGOST01) { int real_idx; for (real_idx = SSL_PKEY_GOST12_512; real_idx >= SSL_PKEY_GOST01; real_idx--) { if (s->cert->pkeys[real_idx].privatekey != NULL) { idx = real_idx; break; } } } /* * As both SSL_PKEY_GOST12_512 and SSL_PKEY_GOST12_256 indices can be used * with new (aGOST12-only) ciphersuites, we should find out which one is available really. */ else if (idx == SSL_PKEY_GOST12_256) { int real_idx; for (real_idx = SSL_PKEY_GOST12_512; real_idx >= SSL_PKEY_GOST12_256; real_idx--) { if (s->cert->pkeys[real_idx].privatekey != NULL) { idx = real_idx; break; } } } } else { idx = s->cert->key - s->cert->pkeys; } } if (idx < 0 || idx >= (int)OSSL_NELEM(tls_default_sigalg)) return NULL; if (SSL_USE_SIGALGS(s) || idx != SSL_PKEY_RSA) { const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, tls_default_sigalg[idx]); if (lu == NULL) return NULL; if (!tls1_lookup_md(SSL_CONNECTION_GET_CTX(s), lu, NULL)) return NULL; if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, lu)) return NULL; return lu; } if (!tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, &legacy_rsa_sigalg)) return NULL; return &legacy_rsa_sigalg; } /* Set peer sigalg based key type */ int tls1_set_peer_legacy_sigalg(SSL_CONNECTION *s, const EVP_PKEY *pkey) { size_t idx; const SIGALG_LOOKUP *lu; if (ssl_cert_lookup_by_pkey(pkey, &idx, SSL_CONNECTION_GET_CTX(s)) == NULL) return 0; lu = tls1_get_legacy_sigalg(s, idx); if (lu == NULL) return 0; s->s3.tmp.peer_sigalg = lu; return 1; } size_t tls12_get_psigalgs(SSL_CONNECTION *s, int sent, const uint16_t **psigs) { /* * If Suite B mode use Suite B sigalgs only, ignore any other * preferences. */ switch (tls1_suiteb(s)) { case SSL_CERT_FLAG_SUITEB_128_LOS: *psigs = suiteb_sigalgs; return OSSL_NELEM(suiteb_sigalgs); case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY: *psigs = suiteb_sigalgs; return 1; case SSL_CERT_FLAG_SUITEB_192_LOS: *psigs = suiteb_sigalgs + 1; return 1; } /* * We use client_sigalgs (if not NULL) if we're a server * and sending a certificate request or if we're a client and * determining which shared algorithm to use. */ if ((s->server == sent) && s->cert->client_sigalgs != NULL) { *psigs = s->cert->client_sigalgs; return s->cert->client_sigalgslen; } else if (s->cert->conf_sigalgs) { *psigs = s->cert->conf_sigalgs; return s->cert->conf_sigalgslen; } else { *psigs = SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs; return SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs_len; } } /* * Called by servers only. Checks that we have a sig alg that supports the * specified EC curve. */ int tls_check_sigalg_curve(const SSL_CONNECTION *s, int curve) { const uint16_t *sigs; size_t siglen, i; if (s->cert->conf_sigalgs) { sigs = s->cert->conf_sigalgs; siglen = s->cert->conf_sigalgslen; } else { sigs = SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs; siglen = SSL_CONNECTION_GET_CTX(s)->tls12_sigalgs_len; } for (i = 0; i < siglen; i++) { const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, sigs[i]); if (lu == NULL) continue; if (lu->sig == EVP_PKEY_EC && lu->curve != NID_undef && curve == lu->curve) return 1; } return 0; } /* * Return the number of security bits for the signature algorithm, or 0 on * error. */ static int sigalg_security_bits(SSL_CTX *ctx, const SIGALG_LOOKUP *lu) { const EVP_MD *md = NULL; int secbits = 0; if (!tls1_lookup_md(ctx, lu, &md)) return 0; if (md != NULL) { int md_type = EVP_MD_get_type(md); /* Security bits: half digest bits */ secbits = EVP_MD_get_size(md) * 4; /* * SHA1 and MD5 are known to be broken. Reduce security bits so that * they're no longer accepted at security level 1. The real values don't * really matter as long as they're lower than 80, which is our * security level 1. * https://eprint.iacr.org/2020/014 puts a chosen-prefix attack for * SHA1 at 2^63.4 and MD5+SHA1 at 2^67.2 * https://documents.epfl.ch/users/l/le/lenstra/public/papers/lat.pdf * puts a chosen-prefix attack for MD5 at 2^39. */ if (md_type == NID_sha1) secbits = 64; else if (md_type == NID_md5_sha1) secbits = 67; else if (md_type == NID_md5) secbits = 39; } else { /* Values from https://tools.ietf.org/html/rfc8032#section-8.5 */ if (lu->sigalg == TLSEXT_SIGALG_ed25519) secbits = 128; else if (lu->sigalg == TLSEXT_SIGALG_ed448) secbits = 224; } /* * For provider-based sigalgs we have secbits information available * in the (provider-loaded) sigalg_list structure */ if ((secbits == 0) && (lu->sig_idx >= SSL_PKEY_NUM) && ((lu->sig_idx - SSL_PKEY_NUM) < (int)ctx->sigalg_list_len)) { secbits = ctx->sigalg_list[lu->sig_idx - SSL_PKEY_NUM].secbits; } return secbits; } /* * Check signature algorithm is consistent with sent supported signature * algorithms and if so set relevant digest and signature scheme in * s. */ int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t sig, EVP_PKEY *pkey) { const uint16_t *sent_sigs; const EVP_MD *md = NULL; char sigalgstr[2]; size_t sent_sigslen, i, cidx; int pkeyid = -1; const SIGALG_LOOKUP *lu; int secbits = 0; pkeyid = EVP_PKEY_get_id(pkey); if (SSL_CONNECTION_IS_TLS13(s)) { /* Disallow DSA for TLS 1.3 */ if (pkeyid == EVP_PKEY_DSA) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } /* Only allow PSS for TLS 1.3 */ if (pkeyid == EVP_PKEY_RSA) pkeyid = EVP_PKEY_RSA_PSS; } lu = tls1_lookup_sigalg(s, sig); /* if this sigalg is loaded, set so far unknown pkeyid to its sig NID */ if ((pkeyid == EVP_PKEY_KEYMGMT) && (lu != NULL)) pkeyid = lu->sig; /* Should never happen */ if (pkeyid == -1) return -1; /* * Check sigalgs is known. Disallow SHA1/SHA224 with TLS 1.3. Check key type * is consistent with signature: RSA keys can be used for RSA-PSS */ if (lu == NULL || (SSL_CONNECTION_IS_TLS13(s) && (lu->hash == NID_sha1 || lu->hash == NID_sha224)) || (pkeyid != lu->sig && (lu->sig != EVP_PKEY_RSA_PSS || pkeyid != EVP_PKEY_RSA))) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } /* Check the sigalg is consistent with the key OID */ if (!ssl_cert_lookup_by_nid( (pkeyid == EVP_PKEY_RSA_PSS) ? EVP_PKEY_get_id(pkey) : pkeyid, &cidx, SSL_CONNECTION_GET_CTX(s)) || lu->sig_idx != (int)cidx) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } if (pkeyid == EVP_PKEY_EC) { /* Check point compression is permitted */ if (!tls1_check_pkey_comp(s, pkey)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_ILLEGAL_POINT_COMPRESSION); return 0; } /* For TLS 1.3 or Suite B check curve matches signature algorithm */ if (SSL_CONNECTION_IS_TLS13(s) || tls1_suiteb(s)) { int curve = ssl_get_EC_curve_nid(pkey); if (lu->curve != NID_undef && curve != lu->curve) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE); return 0; } } if (!SSL_CONNECTION_IS_TLS13(s)) { /* Check curve matches extensions */ if (!tls1_check_group_id(s, tls1_get_group_id(pkey), 1)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE); return 0; } if (tls1_suiteb(s)) { /* Check sigalg matches a permissible Suite B value */ if (sig != TLSEXT_SIGALG_ecdsa_secp256r1_sha256 && sig != TLSEXT_SIGALG_ecdsa_secp384r1_sha384) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } } } } else if (tls1_suiteb(s)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } /* Check signature matches a type we sent */ sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs); for (i = 0; i < sent_sigslen; i++, sent_sigs++) { if (sig == *sent_sigs) break; } /* Allow fallback to SHA1 if not strict mode */ if (i == sent_sigslen && (lu->hash != NID_sha1 || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } if (!tls1_lookup_md(SSL_CONNECTION_GET_CTX(s), lu, &md)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNKNOWN_DIGEST); return 0; } /* * Make sure security callback allows algorithm. For historical * reasons we have to pass the sigalg as a two byte char array. */ sigalgstr[0] = (sig >> 8) & 0xff; sigalgstr[1] = sig & 0xff; secbits = sigalg_security_bits(SSL_CONNECTION_GET_CTX(s), lu); if (secbits == 0 || !ssl_security(s, SSL_SECOP_SIGALG_CHECK, secbits, md != NULL ? EVP_MD_get_type(md) : NID_undef, (void *)sigalgstr)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } /* Store the sigalg the peer uses */ s->s3.tmp.peer_sigalg = lu; return 1; } int SSL_get_peer_signature_type_nid(const SSL *s, int *pnid) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; if (sc->s3.tmp.peer_sigalg == NULL) return 0; *pnid = sc->s3.tmp.peer_sigalg->sig; return 1; } int SSL_get_signature_type_nid(const SSL *s, int *pnid) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; if (sc->s3.tmp.sigalg == NULL) return 0; *pnid = sc->s3.tmp.sigalg->sig; return 1; } /* * Set a mask of disabled algorithms: an algorithm is disabled if it isn't * supported, doesn't appear in supported signature algorithms, isn't supported * by the enabled protocol versions or by the security level. * * This function should only be used for checking which ciphers are supported * by the client. * * Call ssl_cipher_disabled() to check that it's enabled or not. */ int ssl_set_client_disabled(SSL_CONNECTION *s) { s->s3.tmp.mask_a = 0; s->s3.tmp.mask_k = 0; ssl_set_sig_mask(&s->s3.tmp.mask_a, s, SSL_SECOP_SIGALG_MASK); if (ssl_get_min_max_version(s, &s->s3.tmp.min_ver, &s->s3.tmp.max_ver, NULL) != 0) return 0; #ifndef OPENSSL_NO_PSK /* with PSK there must be client callback set */ if (!s->psk_client_callback) { s->s3.tmp.mask_a |= SSL_aPSK; s->s3.tmp.mask_k |= SSL_PSK; } #endif /* OPENSSL_NO_PSK */ #ifndef OPENSSL_NO_SRP if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) { s->s3.tmp.mask_a |= SSL_aSRP; s->s3.tmp.mask_k |= SSL_kSRP; } #endif return 1; } /* * ssl_cipher_disabled - check that a cipher is disabled or not * @s: SSL connection that you want to use the cipher on * @c: cipher to check * @op: Security check that you want to do * @ecdhe: If set to 1 then TLSv1 ECDHE ciphers are also allowed in SSLv3 * * Returns 1 when it's disabled, 0 when enabled. */ int ssl_cipher_disabled(const SSL_CONNECTION *s, const SSL_CIPHER *c, int op, int ecdhe) { int minversion = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls; int maxversion = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls; if (c->algorithm_mkey & s->s3.tmp.mask_k || c->algorithm_auth & s->s3.tmp.mask_a) return 1; if (s->s3.tmp.max_ver == 0) return 1; if (SSL_IS_QUIC_HANDSHAKE(s)) /* For QUIC, only allow these ciphersuites. */ switch (SSL_CIPHER_get_id(c)) { case TLS1_3_CK_AES_128_GCM_SHA256: case TLS1_3_CK_AES_256_GCM_SHA384: case TLS1_3_CK_CHACHA20_POLY1305_SHA256: break; default: return 1; } /* * For historical reasons we will allow ECHDE to be selected by a server * in SSLv3 if we are a client */ if (minversion == TLS1_VERSION && ecdhe && (c->algorithm_mkey & (SSL_kECDHE | SSL_kECDHEPSK)) != 0) minversion = SSL3_VERSION; if (ssl_version_cmp(s, minversion, s->s3.tmp.max_ver) > 0 || ssl_version_cmp(s, maxversion, s->s3.tmp.min_ver) < 0) return 1; return !ssl_security(s, op, c->strength_bits, 0, (void *)c); } int tls_use_ticket(SSL_CONNECTION *s) { if ((s->options & SSL_OP_NO_TICKET)) return 0; return ssl_security(s, SSL_SECOP_TICKET, 0, 0, NULL); } int tls1_set_server_sigalgs(SSL_CONNECTION *s) { size_t i; /* Clear any shared signature algorithms */ OPENSSL_free(s->shared_sigalgs); s->shared_sigalgs = NULL; s->shared_sigalgslen = 0; /* Clear certificate validity flags */ if (s->s3.tmp.valid_flags) memset(s->s3.tmp.valid_flags, 0, s->ssl_pkey_num * sizeof(uint32_t)); else s->s3.tmp.valid_flags = OPENSSL_zalloc(s->ssl_pkey_num * sizeof(uint32_t)); if (s->s3.tmp.valid_flags == NULL) return 0; /* * If peer sent no signature algorithms check to see if we support * the default algorithm for each certificate type */ if (s->s3.tmp.peer_cert_sigalgs == NULL && s->s3.tmp.peer_sigalgs == NULL) { const uint16_t *sent_sigs; size_t sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs); for (i = 0; i < s->ssl_pkey_num; i++) { const SIGALG_LOOKUP *lu = tls1_get_legacy_sigalg(s, i); size_t j; if (lu == NULL) continue; /* Check default matches a type we sent */ for (j = 0; j < sent_sigslen; j++) { if (lu->sigalg == sent_sigs[j]) { s->s3.tmp.valid_flags[i] = CERT_PKEY_SIGN; break; } } } return 1; } if (!tls1_process_sigalgs(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (s->shared_sigalgs != NULL) return 1; /* Fatal error if no shared signature algorithms */ SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS); return 0; } /*- * Gets the ticket information supplied by the client if any. * * hello: The parsed ClientHello data * ret: (output) on return, if a ticket was decrypted, then this is set to * point to the resulting session. */ SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello, SSL_SESSION **ret) { size_t size; RAW_EXTENSION *ticketext; *ret = NULL; s->ext.ticket_expected = 0; /* * If tickets disabled or not supported by the protocol version * (e.g. TLSv1.3) behave as if no ticket present to permit stateful * resumption. */ if (s->version <= SSL3_VERSION || !tls_use_ticket(s)) return SSL_TICKET_NONE; ticketext = &hello->pre_proc_exts[TLSEXT_IDX_session_ticket]; if (!ticketext->present) return SSL_TICKET_NONE; size = PACKET_remaining(&ticketext->data); return tls_decrypt_ticket(s, PACKET_data(&ticketext->data), size, hello->session_id, hello->session_id_len, ret); } /*- * tls_decrypt_ticket attempts to decrypt a session ticket. * * If s->tls_session_secret_cb is set and we're not doing TLSv1.3 then we are * expecting a pre-shared key ciphersuite, in which case we have no use for * session tickets and one will never be decrypted, nor will * s->ext.ticket_expected be set to 1. * * Side effects: * Sets s->ext.ticket_expected to 1 if the server will have to issue * a new session ticket to the client because the client indicated support * (and s->tls_session_secret_cb is NULL) but the client either doesn't have * a session ticket or we couldn't use the one it gave us, or if * s->ctx->ext.ticket_key_cb asked to renew the client's ticket. * Otherwise, s->ext.ticket_expected is set to 0. * * etick: points to the body of the session ticket extension. * eticklen: the length of the session tickets extension. * sess_id: points at the session ID. * sesslen: the length of the session ID. * psess: (output) on return, if a ticket was decrypted, then this is set to * point to the resulting session. */ SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s, const unsigned char *etick, size_t eticklen, const unsigned char *sess_id, size_t sesslen, SSL_SESSION **psess) { SSL_SESSION *sess = NULL; unsigned char *sdec; const unsigned char *p; int slen, ivlen, renew_ticket = 0, declen; SSL_TICKET_STATUS ret = SSL_TICKET_FATAL_ERR_OTHER; size_t mlen; unsigned char tick_hmac[EVP_MAX_MD_SIZE]; SSL_HMAC *hctx = NULL; EVP_CIPHER_CTX *ctx = NULL; SSL_CTX *tctx = s->session_ctx; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (eticklen == 0) { /* * The client will accept a ticket but doesn't currently have * one (TLSv1.2 and below), or treated as a fatal error in TLSv1.3 */ ret = SSL_TICKET_EMPTY; goto end; } if (!SSL_CONNECTION_IS_TLS13(s) && s->ext.session_secret_cb) { /* * Indicate that the ticket couldn't be decrypted rather than * generating the session from ticket now, trigger * abbreviated handshake based on external mechanism to * calculate the master secret later. */ ret = SSL_TICKET_NO_DECRYPT; goto end; } /* Need at least keyname + iv */ if (eticklen < TLSEXT_KEYNAME_LENGTH + EVP_MAX_IV_LENGTH) { ret = SSL_TICKET_NO_DECRYPT; goto end; } /* Initialize session ticket encryption and HMAC contexts */ hctx = ssl_hmac_new(tctx); if (hctx == NULL) { ret = SSL_TICKET_FATAL_ERR_MALLOC; goto end; } ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) { ret = SSL_TICKET_FATAL_ERR_MALLOC; goto end; } #ifndef OPENSSL_NO_DEPRECATED_3_0 if (tctx->ext.ticket_key_evp_cb != NULL || tctx->ext.ticket_key_cb != NULL) #else if (tctx->ext.ticket_key_evp_cb != NULL) #endif { unsigned char *nctick = (unsigned char *)etick; int rv = 0; if (tctx->ext.ticket_key_evp_cb != NULL) rv = tctx->ext.ticket_key_evp_cb(SSL_CONNECTION_GET_SSL(s), nctick, nctick + TLSEXT_KEYNAME_LENGTH, ctx, ssl_hmac_get0_EVP_MAC_CTX(hctx), 0); #ifndef OPENSSL_NO_DEPRECATED_3_0 else if (tctx->ext.ticket_key_cb != NULL) /* if 0 is returned, write an empty ticket */ rv = tctx->ext.ticket_key_cb(SSL_CONNECTION_GET_SSL(s), nctick, nctick + TLSEXT_KEYNAME_LENGTH, ctx, ssl_hmac_get0_HMAC_CTX(hctx), 0); #endif if (rv < 0) { ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } if (rv == 0) { ret = SSL_TICKET_NO_DECRYPT; goto end; } if (rv == 2) renew_ticket = 1; } else { EVP_CIPHER *aes256cbc = NULL; /* Check key name matches */ if (memcmp(etick, tctx->ext.tick_key_name, TLSEXT_KEYNAME_LENGTH) != 0) { ret = SSL_TICKET_NO_DECRYPT; goto end; } aes256cbc = EVP_CIPHER_fetch(sctx->libctx, "AES-256-CBC", sctx->propq); if (aes256cbc == NULL || ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key, sizeof(tctx->ext.secure->tick_hmac_key), "SHA256") <= 0 || EVP_DecryptInit_ex(ctx, aes256cbc, NULL, tctx->ext.secure->tick_aes_key, etick + TLSEXT_KEYNAME_LENGTH) <= 0) { EVP_CIPHER_free(aes256cbc); ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } EVP_CIPHER_free(aes256cbc); if (SSL_CONNECTION_IS_TLS13(s)) renew_ticket = 1; } /* * Attempt to process session ticket, first conduct sanity and integrity * checks on ticket. */ mlen = ssl_hmac_size(hctx); if (mlen == 0) { ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } ivlen = EVP_CIPHER_CTX_get_iv_length(ctx); if (ivlen < 0) { ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } /* Sanity check ticket length: must exceed keyname + IV + HMAC */ if (eticklen <= TLSEXT_KEYNAME_LENGTH + ivlen + mlen) { ret = SSL_TICKET_NO_DECRYPT; goto end; } eticklen -= mlen; /* Check HMAC of encrypted ticket */ if (ssl_hmac_update(hctx, etick, eticklen) <= 0 || ssl_hmac_final(hctx, tick_hmac, NULL, sizeof(tick_hmac)) <= 0) { ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen)) { ret = SSL_TICKET_NO_DECRYPT; goto end; } /* Attempt to decrypt session data */ /* Move p after IV to start of encrypted ticket, update length */ p = etick + TLSEXT_KEYNAME_LENGTH + ivlen; eticklen -= TLSEXT_KEYNAME_LENGTH + ivlen; sdec = OPENSSL_malloc(eticklen); if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p, (int)eticklen) <= 0) { OPENSSL_free(sdec); ret = SSL_TICKET_FATAL_ERR_OTHER; goto end; } if (EVP_DecryptFinal(ctx, sdec + slen, &declen) <= 0) { OPENSSL_free(sdec); ret = SSL_TICKET_NO_DECRYPT; goto end; } slen += declen; p = sdec; sess = d2i_SSL_SESSION_ex(NULL, &p, slen, sctx->libctx, sctx->propq); slen -= p - sdec; OPENSSL_free(sdec); if (sess) { /* Some additional consistency checks */ if (slen != 0) { SSL_SESSION_free(sess); sess = NULL; ret = SSL_TICKET_NO_DECRYPT; goto end; } /* * The session ID, if non-empty, is used by some clients to detect * that the ticket has been accepted. So we copy it to the session * structure. If it is empty set length to zero as required by * standard. */ if (sesslen) { memcpy(sess->session_id, sess_id, sesslen); sess->session_id_length = sesslen; } if (renew_ticket) ret = SSL_TICKET_SUCCESS_RENEW; else ret = SSL_TICKET_SUCCESS; goto end; } ERR_clear_error(); /* * For session parse failure, indicate that we need to send a new ticket. */ ret = SSL_TICKET_NO_DECRYPT; end: EVP_CIPHER_CTX_free(ctx); ssl_hmac_free(hctx); /* * If set, the decrypt_ticket_cb() is called unless a fatal error was * detected above. The callback is responsible for checking |ret| before it * performs any action */ if (s->session_ctx->decrypt_ticket_cb != NULL && (ret == SSL_TICKET_EMPTY || ret == SSL_TICKET_NO_DECRYPT || ret == SSL_TICKET_SUCCESS || ret == SSL_TICKET_SUCCESS_RENEW)) { size_t keyname_len = eticklen; int retcb; if (keyname_len > TLSEXT_KEYNAME_LENGTH) keyname_len = TLSEXT_KEYNAME_LENGTH; retcb = s->session_ctx->decrypt_ticket_cb(SSL_CONNECTION_GET_SSL(s), sess, etick, keyname_len, ret, s->session_ctx->ticket_cb_data); switch (retcb) { case SSL_TICKET_RETURN_ABORT: ret = SSL_TICKET_FATAL_ERR_OTHER; break; case SSL_TICKET_RETURN_IGNORE: ret = SSL_TICKET_NONE; SSL_SESSION_free(sess); sess = NULL; break; case SSL_TICKET_RETURN_IGNORE_RENEW: if (ret != SSL_TICKET_EMPTY && ret != SSL_TICKET_NO_DECRYPT) ret = SSL_TICKET_NO_DECRYPT; /* else the value of |ret| will already do the right thing */ SSL_SESSION_free(sess); sess = NULL; break; case SSL_TICKET_RETURN_USE: case SSL_TICKET_RETURN_USE_RENEW: if (ret != SSL_TICKET_SUCCESS && ret != SSL_TICKET_SUCCESS_RENEW) ret = SSL_TICKET_FATAL_ERR_OTHER; else if (retcb == SSL_TICKET_RETURN_USE) ret = SSL_TICKET_SUCCESS; else ret = SSL_TICKET_SUCCESS_RENEW; break; default: ret = SSL_TICKET_FATAL_ERR_OTHER; } } if (s->ext.session_secret_cb == NULL || SSL_CONNECTION_IS_TLS13(s)) { switch (ret) { case SSL_TICKET_NO_DECRYPT: case SSL_TICKET_SUCCESS_RENEW: case SSL_TICKET_EMPTY: s->ext.ticket_expected = 1; } } *psess = sess; return ret; } /* Check to see if a signature algorithm is allowed */ static int tls12_sigalg_allowed(const SSL_CONNECTION *s, int op, const SIGALG_LOOKUP *lu) { unsigned char sigalgstr[2]; int secbits; if (lu == NULL || !lu->enabled) return 0; /* DSA is not allowed in TLS 1.3 */ if (SSL_CONNECTION_IS_TLS13(s) && lu->sig == EVP_PKEY_DSA) return 0; /* * At some point we should fully axe DSA/etc. in ClientHello as per TLS 1.3 * spec */ if (!s->server && !SSL_CONNECTION_IS_DTLS(s) && s->s3.tmp.min_ver >= TLS1_3_VERSION && (lu->sig == EVP_PKEY_DSA || lu->hash_idx == SSL_MD_SHA1_IDX || lu->hash_idx == SSL_MD_MD5_IDX || lu->hash_idx == SSL_MD_SHA224_IDX)) return 0; /* See if public key algorithm allowed */ if (ssl_cert_is_disabled(SSL_CONNECTION_GET_CTX(s), lu->sig_idx)) return 0; if (lu->sig == NID_id_GostR3410_2012_256 || lu->sig == NID_id_GostR3410_2012_512 || lu->sig == NID_id_GostR3410_2001) { /* We never allow GOST sig algs on the server with TLSv1.3 */ if (s->server && SSL_CONNECTION_IS_TLS13(s)) return 0; if (!s->server && SSL_CONNECTION_GET_SSL(s)->method->version == TLS_ANY_VERSION && s->s3.tmp.max_ver >= TLS1_3_VERSION) { int i, num; STACK_OF(SSL_CIPHER) *sk; /* * We're a client that could negotiate TLSv1.3. We only allow GOST * sig algs if we could negotiate TLSv1.2 or below and we have GOST * ciphersuites enabled. */ if (s->s3.tmp.min_ver >= TLS1_3_VERSION) return 0; sk = SSL_get_ciphers(SSL_CONNECTION_GET_SSL(s)); num = sk != NULL ? sk_SSL_CIPHER_num(sk) : 0; for (i = 0; i < num; i++) { const SSL_CIPHER *c; c = sk_SSL_CIPHER_value(sk, i); /* Skip disabled ciphers */ if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) continue; if ((c->algorithm_mkey & (SSL_kGOST | SSL_kGOST18)) != 0) break; } if (i == num) return 0; } } /* Finally see if security callback allows it */ secbits = sigalg_security_bits(SSL_CONNECTION_GET_CTX(s), lu); sigalgstr[0] = (lu->sigalg >> 8) & 0xff; sigalgstr[1] = lu->sigalg & 0xff; return ssl_security(s, op, secbits, lu->hash, (void *)sigalgstr); } /* * Get a mask of disabled public key algorithms based on supported signature * algorithms. For example if no signature algorithm supports RSA then RSA is * disabled. */ void ssl_set_sig_mask(uint32_t *pmask_a, SSL_CONNECTION *s, int op) { const uint16_t *sigalgs; size_t i, sigalgslen; uint32_t disabled_mask = SSL_aRSA | SSL_aDSS | SSL_aECDSA; /* * Go through all signature algorithms seeing if we support any * in disabled_mask. */ sigalgslen = tls12_get_psigalgs(s, 1, &sigalgs); for (i = 0; i < sigalgslen; i++, sigalgs++) { const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, *sigalgs); const SSL_CERT_LOOKUP *clu; if (lu == NULL) continue; clu = ssl_cert_lookup_by_idx(lu->sig_idx, SSL_CONNECTION_GET_CTX(s)); if (clu == NULL) continue; /* If algorithm is disabled see if we can enable it */ if ((clu->amask & disabled_mask) != 0 && tls12_sigalg_allowed(s, op, lu)) disabled_mask &= ~clu->amask; } *pmask_a |= disabled_mask; } int tls12_copy_sigalgs(SSL_CONNECTION *s, WPACKET *pkt, const uint16_t *psig, size_t psiglen) { size_t i; int rv = 0; for (i = 0; i < psiglen; i++, psig++) { const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, *psig); if (lu == NULL || !tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SUPPORTED, lu)) continue; if (!WPACKET_put_bytes_u16(pkt, *psig)) return 0; /* * If TLS 1.3 must have at least one valid TLS 1.3 message * signing algorithm: i.e. neither RSA nor SHA1/SHA224 */ if (rv == 0 && (!SSL_CONNECTION_IS_TLS13(s) || (lu->sig != EVP_PKEY_RSA && lu->hash != NID_sha1 && lu->hash != NID_sha224))) rv = 1; } if (rv == 0) ERR_raise(ERR_LIB_SSL, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return rv; } /* Given preference and allowed sigalgs set shared sigalgs */ static size_t tls12_shared_sigalgs(SSL_CONNECTION *s, const SIGALG_LOOKUP **shsig, const uint16_t *pref, size_t preflen, const uint16_t *allow, size_t allowlen) { const uint16_t *ptmp, *atmp; size_t i, j, nmatch = 0; for (i = 0, ptmp = pref; i < preflen; i++, ptmp++) { const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, *ptmp); /* Skip disabled hashes or signature algorithms */ if (lu == NULL || !tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, lu)) continue; for (j = 0, atmp = allow; j < allowlen; j++, atmp++) { if (*ptmp == *atmp) { nmatch++; if (shsig) *shsig++ = lu; break; } } } return nmatch; } /* Set shared signature algorithms for SSL structures */ static int tls1_set_shared_sigalgs(SSL_CONNECTION *s) { const uint16_t *pref, *allow, *conf; size_t preflen, allowlen, conflen; size_t nmatch; const SIGALG_LOOKUP **salgs = NULL; CERT *c = s->cert; unsigned int is_suiteb = tls1_suiteb(s); OPENSSL_free(s->shared_sigalgs); s->shared_sigalgs = NULL; s->shared_sigalgslen = 0; /* If client use client signature algorithms if not NULL */ if (!s->server && c->client_sigalgs && !is_suiteb) { conf = c->client_sigalgs; conflen = c->client_sigalgslen; } else if (c->conf_sigalgs && !is_suiteb) { conf = c->conf_sigalgs; conflen = c->conf_sigalgslen; } else conflen = tls12_get_psigalgs(s, 0, &conf); if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE || is_suiteb) { pref = conf; preflen = conflen; allow = s->s3.tmp.peer_sigalgs; allowlen = s->s3.tmp.peer_sigalgslen; } else { allow = conf; allowlen = conflen; pref = s->s3.tmp.peer_sigalgs; preflen = s->s3.tmp.peer_sigalgslen; } nmatch = tls12_shared_sigalgs(s, NULL, pref, preflen, allow, allowlen); if (nmatch) { if ((salgs = OPENSSL_malloc(nmatch * sizeof(*salgs))) == NULL) return 0; nmatch = tls12_shared_sigalgs(s, salgs, pref, preflen, allow, allowlen); } else { salgs = NULL; } s->shared_sigalgs = salgs; s->shared_sigalgslen = nmatch; return 1; } int tls1_save_u16(PACKET *pkt, uint16_t **pdest, size_t *pdestlen) { unsigned int stmp; size_t size, i; uint16_t *buf; size = PACKET_remaining(pkt); /* Invalid data length */ if (size == 0 || (size & 1) != 0) return 0; size >>= 1; if ((buf = OPENSSL_malloc(size * sizeof(*buf))) == NULL) return 0; for (i = 0; i < size && PACKET_get_net_2(pkt, &stmp); i++) buf[i] = stmp; if (i != size) { OPENSSL_free(buf); return 0; } OPENSSL_free(*pdest); *pdest = buf; *pdestlen = size; return 1; } int tls1_save_sigalgs(SSL_CONNECTION *s, PACKET *pkt, int cert) { /* Extension ignored for inappropriate versions */ if (!SSL_USE_SIGALGS(s)) return 1; /* Should never happen */ if (s->cert == NULL) return 0; if (cert) return tls1_save_u16(pkt, &s->s3.tmp.peer_cert_sigalgs, &s->s3.tmp.peer_cert_sigalgslen); else return tls1_save_u16(pkt, &s->s3.tmp.peer_sigalgs, &s->s3.tmp.peer_sigalgslen); } /* Set preferred digest for each key type */ int tls1_process_sigalgs(SSL_CONNECTION *s) { size_t i; uint32_t *pvalid = s->s3.tmp.valid_flags; if (!tls1_set_shared_sigalgs(s)) return 0; for (i = 0; i < s->ssl_pkey_num; i++) pvalid[i] = 0; for (i = 0; i < s->shared_sigalgslen; i++) { const SIGALG_LOOKUP *sigptr = s->shared_sigalgs[i]; int idx = sigptr->sig_idx; /* Ignore PKCS1 based sig algs in TLSv1.3 */ if (SSL_CONNECTION_IS_TLS13(s) && sigptr->sig == EVP_PKEY_RSA) continue; /* If not disabled indicate we can explicitly sign */ if (pvalid[idx] == 0 && !ssl_cert_is_disabled(SSL_CONNECTION_GET_CTX(s), idx)) pvalid[idx] = CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN; } return 1; } int SSL_get_sigalgs(SSL *s, int idx, int *psign, int *phash, int *psignhash, unsigned char *rsig, unsigned char *rhash) { uint16_t *psig; size_t numsigalgs; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; psig = sc->s3.tmp.peer_sigalgs; numsigalgs = sc->s3.tmp.peer_sigalgslen; if (psig == NULL || numsigalgs > INT_MAX) return 0; if (idx >= 0) { const SIGALG_LOOKUP *lu; if (idx >= (int)numsigalgs) return 0; psig += idx; if (rhash != NULL) *rhash = (unsigned char)((*psig >> 8) & 0xff); if (rsig != NULL) *rsig = (unsigned char)(*psig & 0xff); lu = tls1_lookup_sigalg(sc, *psig); if (psign != NULL) *psign = lu != NULL ? lu->sig : NID_undef; if (phash != NULL) *phash = lu != NULL ? lu->hash : NID_undef; if (psignhash != NULL) *psignhash = lu != NULL ? lu->sigandhash : NID_undef; } return (int)numsigalgs; } int SSL_get_shared_sigalgs(SSL *s, int idx, int *psign, int *phash, int *psignhash, unsigned char *rsig, unsigned char *rhash) { const SIGALG_LOOKUP *shsigalgs; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->shared_sigalgs == NULL || idx < 0 || idx >= (int)sc->shared_sigalgslen || sc->shared_sigalgslen > INT_MAX) return 0; shsigalgs = sc->shared_sigalgs[idx]; if (phash != NULL) *phash = shsigalgs->hash; if (psign != NULL) *psign = shsigalgs->sig; if (psignhash != NULL) *psignhash = shsigalgs->sigandhash; if (rsig != NULL) *rsig = (unsigned char)(shsigalgs->sigalg & 0xff); if (rhash != NULL) *rhash = (unsigned char)((shsigalgs->sigalg >> 8) & 0xff); return (int)sc->shared_sigalgslen; } /* Maximum possible number of unique entries in sigalgs array */ #define TLS_MAX_SIGALGCNT (OSSL_NELEM(sigalg_lookup_tbl) * 2) typedef struct { size_t sigalgcnt; /* TLSEXT_SIGALG_XXX values */ uint16_t sigalgs[TLS_MAX_SIGALGCNT]; } sig_cb_st; static void get_sigorhash(int *psig, int *phash, const char *str) { if (strcmp(str, "RSA") == 0) { *psig = EVP_PKEY_RSA; } else if (strcmp(str, "RSA-PSS") == 0 || strcmp(str, "PSS") == 0) { *psig = EVP_PKEY_RSA_PSS; } else if (strcmp(str, "DSA") == 0) { *psig = EVP_PKEY_DSA; } else if (strcmp(str, "ECDSA") == 0) { *psig = EVP_PKEY_EC; } else { *phash = OBJ_sn2nid(str); if (*phash == NID_undef) *phash = OBJ_ln2nid(str); } } /* Maximum length of a signature algorithm string component */ #define TLS_MAX_SIGSTRING_LEN 40 static int sig_cb(const char *elem, int len, void *arg) { sig_cb_st *sarg = arg; size_t i; const SIGALG_LOOKUP *s; char etmp[TLS_MAX_SIGSTRING_LEN], *p; int sig_alg = NID_undef, hash_alg = NID_undef; if (elem == NULL) return 0; if (sarg->sigalgcnt == TLS_MAX_SIGALGCNT) return 0; if (len > (int)(sizeof(etmp) - 1)) return 0; memcpy(etmp, elem, len); etmp[len] = 0; p = strchr(etmp, '+'); /* * We only allow SignatureSchemes listed in the sigalg_lookup_tbl; * if there's no '+' in the provided name, look for the new-style combined * name. If not, match both sig+hash to find the needed SIGALG_LOOKUP. * Just sig+hash is not unique since TLS 1.3 adds rsa_pss_pss_* and * rsa_pss_rsae_* that differ only by public key OID; in such cases * we will pick the _rsae_ variant, by virtue of them appearing earlier * in the table. */ if (p == NULL) { for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl); i++, s++) { if (s->name != NULL && strcmp(etmp, s->name) == 0) { sarg->sigalgs[sarg->sigalgcnt++] = s->sigalg; break; } } if (i == OSSL_NELEM(sigalg_lookup_tbl)) return 0; } else { *p = 0; p++; if (*p == 0) return 0; get_sigorhash(&sig_alg, &hash_alg, etmp); get_sigorhash(&sig_alg, &hash_alg, p); if (sig_alg == NID_undef || hash_alg == NID_undef) return 0; for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl); i++, s++) { if (s->hash == hash_alg && s->sig == sig_alg) { sarg->sigalgs[sarg->sigalgcnt++] = s->sigalg; break; } } if (i == OSSL_NELEM(sigalg_lookup_tbl)) return 0; } /* Reject duplicates */ for (i = 0; i < sarg->sigalgcnt - 1; i++) { if (sarg->sigalgs[i] == sarg->sigalgs[sarg->sigalgcnt - 1]) { sarg->sigalgcnt--; return 0; } } return 1; } /* * Set supported signature algorithms based on a colon separated list of the * form sig+hash e.g. RSA+SHA512:DSA+SHA512 */ int tls1_set_sigalgs_list(CERT *c, const char *str, int client) { sig_cb_st sig; sig.sigalgcnt = 0; if (!CONF_parse_list(str, ':', 1, sig_cb, &sig)) return 0; if (c == NULL) return 1; return tls1_set_raw_sigalgs(c, sig.sigalgs, sig.sigalgcnt, client); } int tls1_set_raw_sigalgs(CERT *c, const uint16_t *psigs, size_t salglen, int client) { uint16_t *sigalgs; if ((sigalgs = OPENSSL_malloc(salglen * sizeof(*sigalgs))) == NULL) return 0; memcpy(sigalgs, psigs, salglen * sizeof(*sigalgs)); if (client) { OPENSSL_free(c->client_sigalgs); c->client_sigalgs = sigalgs; c->client_sigalgslen = salglen; } else { OPENSSL_free(c->conf_sigalgs); c->conf_sigalgs = sigalgs; c->conf_sigalgslen = salglen; } return 1; } int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client) { uint16_t *sigalgs, *sptr; size_t i; if (salglen & 1) return 0; if ((sigalgs = OPENSSL_malloc((salglen / 2) * sizeof(*sigalgs))) == NULL) return 0; for (i = 0, sptr = sigalgs; i < salglen; i += 2) { size_t j; const SIGALG_LOOKUP *curr; int md_id = *psig_nids++; int sig_id = *psig_nids++; for (j = 0, curr = sigalg_lookup_tbl; j < OSSL_NELEM(sigalg_lookup_tbl); j++, curr++) { if (curr->hash == md_id && curr->sig == sig_id) { *sptr++ = curr->sigalg; break; } } if (j == OSSL_NELEM(sigalg_lookup_tbl)) goto err; } if (client) { OPENSSL_free(c->client_sigalgs); c->client_sigalgs = sigalgs; c->client_sigalgslen = salglen / 2; } else { OPENSSL_free(c->conf_sigalgs); c->conf_sigalgs = sigalgs; c->conf_sigalgslen = salglen / 2; } return 1; err: OPENSSL_free(sigalgs); return 0; } static int tls1_check_sig_alg(SSL_CONNECTION *s, X509 *x, int default_nid) { int sig_nid, use_pc_sigalgs = 0; size_t i; const SIGALG_LOOKUP *sigalg; size_t sigalgslen; if (default_nid == -1) return 1; sig_nid = X509_get_signature_nid(x); if (default_nid) return sig_nid == default_nid ? 1 : 0; if (SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.peer_cert_sigalgs != NULL) { /* * If we're in TLSv1.3 then we only get here if we're checking the * chain. If the peer has specified peer_cert_sigalgs then we use them * otherwise we default to normal sigalgs. */ sigalgslen = s->s3.tmp.peer_cert_sigalgslen; use_pc_sigalgs = 1; } else { sigalgslen = s->shared_sigalgslen; } for (i = 0; i < sigalgslen; i++) { sigalg = use_pc_sigalgs ? tls1_lookup_sigalg(s, s->s3.tmp.peer_cert_sigalgs[i]) : s->shared_sigalgs[i]; if (sigalg != NULL && sig_nid == sigalg->sigandhash) return 1; } return 0; } /* Check to see if a certificate issuer name matches list of CA names */ static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x) { const X509_NAME *nm; int i; nm = X509_get_issuer_name(x); for (i = 0; i < sk_X509_NAME_num(names); i++) { if (!X509_NAME_cmp(nm, sk_X509_NAME_value(names, i))) return 1; } return 0; } /* * Check certificate chain is consistent with TLS extensions and is usable by * server. This servers two purposes: it allows users to check chains before * passing them to the server and it allows the server to check chains before * attempting to use them. */ /* Flags which need to be set for a certificate when strict mode not set */ #define CERT_PKEY_VALID_FLAGS \ (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM) /* Strict mode flags */ #define CERT_PKEY_STRICT_FLAGS \ (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \ | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE) int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain, int idx) { int i; int rv = 0; int check_flags = 0, strict_mode; CERT_PKEY *cpk = NULL; CERT *c = s->cert; uint32_t *pvalid; unsigned int suiteb_flags = tls1_suiteb(s); /* * Meaning of idx: * idx == -1 means SSL_check_chain() invocation * idx == -2 means checking client certificate chains * idx >= 0 means checking SSL_PKEY index * * For RPK, where there may be no cert, we ignore -1 */ if (idx != -1) { if (idx == -2) { cpk = c->key; idx = (int)(cpk - c->pkeys); } else cpk = c->pkeys + idx; pvalid = s->s3.tmp.valid_flags + idx; x = cpk->x509; pk = cpk->privatekey; chain = cpk->chain; strict_mode = c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT; if (tls12_rpk_and_privkey(s, idx)) { if (EVP_PKEY_is_a(pk, "EC") && !tls1_check_pkey_comp(s, pk)) return 0; *pvalid = rv = CERT_PKEY_RPK; return rv; } /* If no cert or key, forget it */ if (x == NULL || pk == NULL) goto end; } else { size_t certidx; if (x == NULL || pk == NULL) return 0; if (ssl_cert_lookup_by_pkey(pk, &certidx, SSL_CONNECTION_GET_CTX(s)) == NULL) return 0; idx = certidx; pvalid = s->s3.tmp.valid_flags + idx; if (c->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT) check_flags = CERT_PKEY_STRICT_FLAGS; else check_flags = CERT_PKEY_VALID_FLAGS; strict_mode = 1; } if (suiteb_flags) { int ok; if (check_flags) check_flags |= CERT_PKEY_SUITEB; ok = X509_chain_check_suiteb(NULL, x, chain, suiteb_flags); if (ok == X509_V_OK) rv |= CERT_PKEY_SUITEB; else if (!check_flags) goto end; } /* * Check all signature algorithms are consistent with signature * algorithms extension if TLS 1.2 or later and strict mode. */ if (TLS1_get_version(SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION && strict_mode) { int default_nid; int rsign = 0; if (s->s3.tmp.peer_cert_sigalgs != NULL || s->s3.tmp.peer_sigalgs != NULL) { default_nid = 0; /* If no sigalgs extension use defaults from RFC5246 */ } else { switch (idx) { case SSL_PKEY_RSA: rsign = EVP_PKEY_RSA; default_nid = NID_sha1WithRSAEncryption; break; case SSL_PKEY_DSA_SIGN: rsign = EVP_PKEY_DSA; default_nid = NID_dsaWithSHA1; break; case SSL_PKEY_ECC: rsign = EVP_PKEY_EC; default_nid = NID_ecdsa_with_SHA1; break; case SSL_PKEY_GOST01: rsign = NID_id_GostR3410_2001; default_nid = NID_id_GostR3411_94_with_GostR3410_2001; break; case SSL_PKEY_GOST12_256: rsign = NID_id_GostR3410_2012_256; default_nid = NID_id_tc26_signwithdigest_gost3410_2012_256; break; case SSL_PKEY_GOST12_512: rsign = NID_id_GostR3410_2012_512; default_nid = NID_id_tc26_signwithdigest_gost3410_2012_512; break; default: default_nid = -1; break; } } /* * If peer sent no signature algorithms extension and we have set * preferred signature algorithms check we support sha1. */ if (default_nid > 0 && c->conf_sigalgs) { size_t j; const uint16_t *p = c->conf_sigalgs; for (j = 0; j < c->conf_sigalgslen; j++, p++) { const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(s, *p); if (lu != NULL && lu->hash == NID_sha1 && lu->sig == rsign) break; } if (j == c->conf_sigalgslen) { if (check_flags) goto skip_sigs; else goto end; } } /* Check signature algorithm of each cert in chain */ if (SSL_CONNECTION_IS_TLS13(s)) { /* * We only get here if the application has called SSL_check_chain(), * so check_flags is always set. */ if (find_sig_alg(s, x, pk) != NULL) rv |= CERT_PKEY_EE_SIGNATURE; } else if (!tls1_check_sig_alg(s, x, default_nid)) { if (!check_flags) goto end; } else rv |= CERT_PKEY_EE_SIGNATURE; rv |= CERT_PKEY_CA_SIGNATURE; for (i = 0; i < sk_X509_num(chain); i++) { if (!tls1_check_sig_alg(s, sk_X509_value(chain, i), default_nid)) { if (check_flags) { rv &= ~CERT_PKEY_CA_SIGNATURE; break; } else goto end; } } } /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */ else if (check_flags) rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE; skip_sigs: /* Check cert parameters are consistent */ if (tls1_check_cert_param(s, x, 1)) rv |= CERT_PKEY_EE_PARAM; else if (!check_flags) goto end; if (!s->server) rv |= CERT_PKEY_CA_PARAM; /* In strict mode check rest of chain too */ else if (strict_mode) { rv |= CERT_PKEY_CA_PARAM; for (i = 0; i < sk_X509_num(chain); i++) { X509 *ca = sk_X509_value(chain, i); if (!tls1_check_cert_param(s, ca, 0)) { if (check_flags) { rv &= ~CERT_PKEY_CA_PARAM; break; } else goto end; } } } if (!s->server && strict_mode) { STACK_OF(X509_NAME) *ca_dn; int check_type = 0; if (EVP_PKEY_is_a(pk, "RSA")) check_type = TLS_CT_RSA_SIGN; else if (EVP_PKEY_is_a(pk, "DSA")) check_type = TLS_CT_DSS_SIGN; else if (EVP_PKEY_is_a(pk, "EC")) check_type = TLS_CT_ECDSA_SIGN; if (check_type) { const uint8_t *ctypes = s->s3.tmp.ctype; size_t j; for (j = 0; j < s->s3.tmp.ctype_len; j++, ctypes++) { if (*ctypes == check_type) { rv |= CERT_PKEY_CERT_TYPE; break; } } if (!(rv & CERT_PKEY_CERT_TYPE) && !check_flags) goto end; } else { rv |= CERT_PKEY_CERT_TYPE; } ca_dn = s->s3.tmp.peer_ca_names; if (ca_dn == NULL || sk_X509_NAME_num(ca_dn) == 0 || ssl_check_ca_name(ca_dn, x)) rv |= CERT_PKEY_ISSUER_NAME; else for (i = 0; i < sk_X509_num(chain); i++) { X509 *xtmp = sk_X509_value(chain, i); if (ssl_check_ca_name(ca_dn, xtmp)) { rv |= CERT_PKEY_ISSUER_NAME; break; } } if (!check_flags && !(rv & CERT_PKEY_ISSUER_NAME)) goto end; } else rv |= CERT_PKEY_ISSUER_NAME | CERT_PKEY_CERT_TYPE; if (!check_flags || (rv & check_flags) == check_flags) rv |= CERT_PKEY_VALID; end: if (TLS1_get_version(SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION) rv |= *pvalid & (CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN); else rv |= CERT_PKEY_SIGN | CERT_PKEY_EXPLICIT_SIGN; /* * When checking a CERT_PKEY structure all flags are irrelevant if the * chain is invalid. */ if (!check_flags) { if (rv & CERT_PKEY_VALID) { *pvalid = rv; } else { /* Preserve sign and explicit sign flag, clear rest */ *pvalid &= CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN; return 0; } } return rv; } /* Set validity of certificates in an SSL structure */ void tls1_set_cert_validity(SSL_CONNECTION *s) { tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_RSA_PSS_SIGN); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_DSA_SIGN); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ECC); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST01); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_256); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_GOST12_512); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ED25519); tls1_check_chain(s, NULL, NULL, NULL, SSL_PKEY_ED448); } /* User level utility function to check a chain is suitable */ int SSL_check_chain(SSL *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return tls1_check_chain(sc, x, pk, chain, -1); } EVP_PKEY *ssl_get_auto_dh(SSL_CONNECTION *s) { EVP_PKEY *dhp = NULL; BIGNUM *p; int dh_secbits = 80, sec_level_bits; EVP_PKEY_CTX *pctx = NULL; OSSL_PARAM_BLD *tmpl = NULL; OSSL_PARAM *params = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (s->cert->dh_tmp_auto != 2) { if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aPSK)) { if (s->s3.tmp.new_cipher->strength_bits == 256) dh_secbits = 128; else dh_secbits = 80; } else { if (s->s3.tmp.cert == NULL) return NULL; dh_secbits = EVP_PKEY_get_security_bits(s->s3.tmp.cert->privatekey); } } /* Do not pick a prime that is too weak for the current security level */ sec_level_bits = ssl_get_security_level_bits(SSL_CONNECTION_GET_SSL(s), NULL, NULL); if (dh_secbits < sec_level_bits) dh_secbits = sec_level_bits; if (dh_secbits >= 192) p = BN_get_rfc3526_prime_8192(NULL); else if (dh_secbits >= 152) p = BN_get_rfc3526_prime_4096(NULL); else if (dh_secbits >= 128) p = BN_get_rfc3526_prime_3072(NULL); else if (dh_secbits >= 112) p = BN_get_rfc3526_prime_2048(NULL); else p = BN_get_rfc2409_prime_1024(NULL); if (p == NULL) goto err; pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, "DH", sctx->propq); if (pctx == NULL || EVP_PKEY_fromdata_init(pctx) != 1) goto err; tmpl = OSSL_PARAM_BLD_new(); if (tmpl == NULL || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p) || !OSSL_PARAM_BLD_push_uint(tmpl, OSSL_PKEY_PARAM_FFC_G, 2)) goto err; params = OSSL_PARAM_BLD_to_param(tmpl); if (params == NULL || EVP_PKEY_fromdata(pctx, &dhp, EVP_PKEY_KEY_PARAMETERS, params) != 1) goto err; err: OSSL_PARAM_free(params); OSSL_PARAM_BLD_free(tmpl); EVP_PKEY_CTX_free(pctx); BN_free(p); return dhp; } static int ssl_security_cert_key(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int op) { int secbits = -1; EVP_PKEY *pkey = X509_get0_pubkey(x); if (pkey) { /* * If no parameters this will return -1 and fail using the default * security callback for any non-zero security level. This will * reject keys which omit parameters but this only affects DSA and * omission of parameters is never (?) done in practice. */ secbits = EVP_PKEY_get_security_bits(pkey); } if (s != NULL) return ssl_security(s, op, secbits, 0, x); else return ssl_ctx_security(ctx, op, secbits, 0, x); } static int ssl_security_cert_sig(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int op) { /* Lookup signature algorithm digest */ int secbits, nid, pknid; /* Don't check signature if self signed */ if ((X509_get_extension_flags(x) & EXFLAG_SS) != 0) return 1; if (!X509_get_signature_info(x, &nid, &pknid, &secbits, NULL)) secbits = -1; /* If digest NID not defined use signature NID */ if (nid == NID_undef) nid = pknid; if (s != NULL) return ssl_security(s, op, secbits, nid, x); else return ssl_ctx_security(ctx, op, secbits, nid, x); } int ssl_security_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee) { if (vfy) vfy = SSL_SECOP_PEER; if (is_ee) { if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_EE_KEY | vfy)) return SSL_R_EE_KEY_TOO_SMALL; } else { if (!ssl_security_cert_key(s, ctx, x, SSL_SECOP_CA_KEY | vfy)) return SSL_R_CA_KEY_TOO_SMALL; } if (!ssl_security_cert_sig(s, ctx, x, SSL_SECOP_CA_MD | vfy)) return SSL_R_CA_MD_TOO_WEAK; return 1; } /* * Check security of a chain, if |sk| includes the end entity certificate then * |x| is NULL. If |vfy| is 1 then we are verifying a peer chain and not sending * one to the peer. Return values: 1 if ok otherwise error code to use */ int ssl_security_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk, X509 *x, int vfy) { int rv, start_idx, i; if (x == NULL) { x = sk_X509_value(sk, 0); if (x == NULL) return ERR_R_INTERNAL_ERROR; start_idx = 1; } else start_idx = 0; rv = ssl_security_cert(s, NULL, x, vfy, 1); if (rv != 1) return rv; for (i = start_idx; i < sk_X509_num(sk); i++) { x = sk_X509_value(sk, i); rv = ssl_security_cert(s, NULL, x, vfy, 0); if (rv != 1) return rv; } return 1; } /* * For TLS 1.2 servers check if we have a certificate which can be used * with the signature algorithm "lu" and return index of certificate. */ static int tls12_get_cert_sigalg_idx(const SSL_CONNECTION *s, const SIGALG_LOOKUP *lu) { int sig_idx = lu->sig_idx; const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_idx(sig_idx, SSL_CONNECTION_GET_CTX(s)); /* If not recognised or not supported by cipher mask it is not suitable */ if (clu == NULL || (clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0 || (clu->nid == EVP_PKEY_RSA_PSS && (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kRSA) != 0)) return -1; /* If doing RPK, the CERT_PKEY won't be "valid" */ if (tls12_rpk_and_privkey(s, sig_idx)) return s->s3.tmp.valid_flags[sig_idx] & CERT_PKEY_RPK ? sig_idx : -1; return s->s3.tmp.valid_flags[sig_idx] & CERT_PKEY_VALID ? sig_idx : -1; } /* * Checks the given cert against signature_algorithm_cert restrictions sent by * the peer (if any) as well as whether the hash from the sigalg is usable with * the key. * Returns true if the cert is usable and false otherwise. */ static int check_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, X509 *x, EVP_PKEY *pkey) { const SIGALG_LOOKUP *lu; int mdnid, pknid, supported; size_t i; const char *mdname = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* * If the given EVP_PKEY cannot support signing with this digest, * the answer is simply 'no'. */ if (sig->hash != NID_undef) mdname = OBJ_nid2sn(sig->hash); supported = EVP_PKEY_digestsign_supports_digest(pkey, sctx->libctx, mdname, sctx->propq); if (supported <= 0) return 0; /* * The TLS 1.3 signature_algorithms_cert extension places restrictions * on the sigalg with which the certificate was signed (by its issuer). */ if (s->s3.tmp.peer_cert_sigalgs != NULL) { if (!X509_get_signature_info(x, &mdnid, &pknid, NULL, NULL)) return 0; for (i = 0; i < s->s3.tmp.peer_cert_sigalgslen; i++) { lu = tls1_lookup_sigalg(s, s->s3.tmp.peer_cert_sigalgs[i]); if (lu == NULL) continue; /* * This does not differentiate between the * rsa_pss_pss_* and rsa_pss_rsae_* schemes since we do not * have a chain here that lets us look at the key OID in the * signing certificate. */ if (mdnid == lu->hash && pknid == lu->sig) return 1; } return 0; } /* * Without signat_algorithms_cert, any certificate for which we have * a viable public key is permitted. */ return 1; } /* * Returns true if |s| has a usable certificate configured for use * with signature scheme |sig|. * "Usable" includes a check for presence as well as applying * the signature_algorithm_cert restrictions sent by the peer (if any). * Returns false if no usable certificate is found. */ static int has_usable_cert(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, int idx) { /* TLS 1.2 callers can override sig->sig_idx, but not TLS 1.3 callers. */ if (idx == -1) idx = sig->sig_idx; if (!ssl_has_cert(s, idx)) return 0; return check_cert_usable(s, sig, s->cert->pkeys[idx].x509, s->cert->pkeys[idx].privatekey); } /* * Returns true if the supplied cert |x| and key |pkey| is usable with the * specified signature scheme |sig|, or false otherwise. */ static int is_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, X509 *x, EVP_PKEY *pkey) { size_t idx; if (ssl_cert_lookup_by_pkey(pkey, &idx, SSL_CONNECTION_GET_CTX(s)) == NULL) return 0; /* Check the key is consistent with the sig alg */ if ((int)idx != sig->sig_idx) return 0; return check_cert_usable(s, sig, x, pkey); } /* * Find a signature scheme that works with the supplied certificate |x| and key * |pkey|. |x| and |pkey| may be NULL in which case we additionally look at our * available certs/keys to find one that works. */ static const SIGALG_LOOKUP *find_sig_alg(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pkey) { const SIGALG_LOOKUP *lu = NULL; size_t i; int curve = -1; EVP_PKEY *tmppkey; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* Look for a shared sigalgs matching possible certificates */ for (i = 0; i < s->shared_sigalgslen; i++) { lu = s->shared_sigalgs[i]; /* Skip SHA1, SHA224, DSA and RSA if not PSS */ if (lu->hash == NID_sha1 || lu->hash == NID_sha224 || lu->sig == EVP_PKEY_DSA || lu->sig == EVP_PKEY_RSA) continue; /* Check that we have a cert, and signature_algorithms_cert */ if (!tls1_lookup_md(sctx, lu, NULL)) continue; if ((pkey == NULL && !has_usable_cert(s, lu, -1)) || (pkey != NULL && !is_cert_usable(s, lu, x, pkey))) continue; tmppkey = (pkey != NULL) ? pkey : s->cert->pkeys[lu->sig_idx].privatekey; if (lu->sig == EVP_PKEY_EC) { if (curve == -1) curve = ssl_get_EC_curve_nid(tmppkey); if (lu->curve != NID_undef && curve != lu->curve) continue; } else if (lu->sig == EVP_PKEY_RSA_PSS) { /* validate that key is large enough for the signature algorithm */ if (!rsa_pss_check_min_key_size(sctx, tmppkey, lu)) continue; } break; } if (i == s->shared_sigalgslen) return NULL; return lu; } /* * Choose an appropriate signature algorithm based on available certificates * Sets chosen certificate and signature algorithm. * * For servers if we fail to find a required certificate it is a fatal error, * an appropriate error code is set and a TLS alert is sent. * * For clients fatalerrs is set to 0. If a certificate is not suitable it is not * a fatal error: we will either try another certificate or not present one * to the server. In this case no error is set. */ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs) { const SIGALG_LOOKUP *lu = NULL; int sig_idx = -1; s->s3.tmp.cert = NULL; s->s3.tmp.sigalg = NULL; if (SSL_CONNECTION_IS_TLS13(s)) { lu = find_sig_alg(s, NULL, NULL); if (lu == NULL) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } } else { /* If ciphersuite doesn't require a cert nothing to do */ if (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aCERT)) return 1; if (!s->server && !ssl_has_cert(s, s->cert->key - s->cert->pkeys)) return 1; if (SSL_USE_SIGALGS(s)) { size_t i; if (s->s3.tmp.peer_sigalgs != NULL) { int curve = -1; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* For Suite B need to match signature algorithm to curve */ if (tls1_suiteb(s)) curve = ssl_get_EC_curve_nid(s->cert->pkeys[SSL_PKEY_ECC] .privatekey); /* * Find highest preference signature algorithm matching * cert type */ for (i = 0; i < s->shared_sigalgslen; i++) { lu = s->shared_sigalgs[i]; if (s->server) { if ((sig_idx = tls12_get_cert_sigalg_idx(s, lu)) == -1) continue; } else { int cc_idx = s->cert->key - s->cert->pkeys; sig_idx = lu->sig_idx; if (cc_idx != sig_idx) continue; } /* Check that we have a cert, and sig_algs_cert */ if (!has_usable_cert(s, lu, sig_idx)) continue; if (lu->sig == EVP_PKEY_RSA_PSS) { /* validate that key is large enough for the signature algorithm */ EVP_PKEY *pkey = s->cert->pkeys[sig_idx].privatekey; if (!rsa_pss_check_min_key_size(sctx, pkey, lu)) continue; } if (curve == -1 || lu->curve == curve) break; } #ifndef OPENSSL_NO_GOST /* * Some Windows-based implementations do not send GOST algorithms indication * in supported_algorithms extension, so when we have GOST-based ciphersuite, * we have to assume GOST support. */ if (i == s->shared_sigalgslen && (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aGOST01 | SSL_aGOST12)) != 0) { if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } else { i = 0; sig_idx = lu->sig_idx; } } #endif if (i == s->shared_sigalgslen) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } } else { /* * If we have no sigalg use defaults */ const uint16_t *sent_sigs; size_t sent_sigslen; if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } /* Check signature matches a type we sent */ sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs); for (i = 0; i < sent_sigslen; i++, sent_sigs++) { if (lu->sigalg == *sent_sigs && has_usable_cert(s, lu, lu->sig_idx)) break; } if (i == sent_sigslen) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE); return 0; } } } else { if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) { if (!fatalerrs) return 1; SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM); return 0; } } } if (sig_idx == -1) sig_idx = lu->sig_idx; s->s3.tmp.cert = &s->cert->pkeys[sig_idx]; s->cert->key = s->s3.tmp.cert; s->s3.tmp.sigalg = lu; return 1; } int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX *ctx, uint8_t mode) { if (mode != TLSEXT_max_fragment_length_DISABLED && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } ctx->ext.max_fragment_len_mode = mode; return 1; } int SSL_set_tlsext_max_fragment_length(SSL *ssl, uint8_t mode) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL || (IS_QUIC(ssl) && mode != TLSEXT_max_fragment_length_DISABLED)) return 0; if (mode != TLSEXT_max_fragment_length_DISABLED && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } sc->ext.max_fragment_len_mode = mode; return 1; } uint8_t SSL_SESSION_get_max_fragment_length(const SSL_SESSION *session) { return session->ext.max_fragment_len_mode; } /* * Helper functions for HMAC access with legacy support included. */ SSL_HMAC *ssl_hmac_new(const SSL_CTX *ctx) { SSL_HMAC *ret = OPENSSL_zalloc(sizeof(*ret)); EVP_MAC *mac = NULL; if (ret == NULL) return NULL; #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->ext.ticket_key_evp_cb == NULL && ctx->ext.ticket_key_cb != NULL) { if (!ssl_hmac_old_new(ret)) goto err; return ret; } #endif mac = EVP_MAC_fetch(ctx->libctx, "HMAC", ctx->propq); if (mac == NULL || (ret->ctx = EVP_MAC_CTX_new(mac)) == NULL) goto err; EVP_MAC_free(mac); return ret; err: EVP_MAC_CTX_free(ret->ctx); EVP_MAC_free(mac); OPENSSL_free(ret); return NULL; } void ssl_hmac_free(SSL_HMAC *ctx) { if (ctx != NULL) { EVP_MAC_CTX_free(ctx->ctx); #ifndef OPENSSL_NO_DEPRECATED_3_0 ssl_hmac_old_free(ctx); #endif OPENSSL_free(ctx); } } EVP_MAC_CTX *ssl_hmac_get0_EVP_MAC_CTX(SSL_HMAC *ctx) { return ctx->ctx; } int ssl_hmac_init(SSL_HMAC *ctx, void *key, size_t len, char *md) { OSSL_PARAM params[2], *p = params; if (ctx->ctx != NULL) { *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, md, 0); *p = OSSL_PARAM_construct_end(); if (EVP_MAC_init(ctx->ctx, key, len, params)) return 1; } #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->old_ctx != NULL) return ssl_hmac_old_init(ctx, key, len, md); #endif return 0; } int ssl_hmac_update(SSL_HMAC *ctx, const unsigned char *data, size_t len) { if (ctx->ctx != NULL) return EVP_MAC_update(ctx->ctx, data, len); #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->old_ctx != NULL) return ssl_hmac_old_update(ctx, data, len); #endif return 0; } int ssl_hmac_final(SSL_HMAC *ctx, unsigned char *md, size_t *len, size_t max_size) { if (ctx->ctx != NULL) return EVP_MAC_final(ctx->ctx, md, len, max_size); #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->old_ctx != NULL) return ssl_hmac_old_final(ctx, md, len); #endif return 0; } size_t ssl_hmac_size(const SSL_HMAC *ctx) { if (ctx->ctx != NULL) return EVP_MAC_CTX_get_mac_size(ctx->ctx); #ifndef OPENSSL_NO_DEPRECATED_3_0 if (ctx->old_ctx != NULL) return ssl_hmac_old_size(ctx); #endif return 0; } int ssl_get_EC_curve_nid(const EVP_PKEY *pkey) { char gname[OSSL_MAX_NAME_SIZE]; if (EVP_PKEY_get_group_name(pkey, gname, sizeof(gname), NULL) > 0) return OBJ_txt2nid(gname); return NID_undef; } __owur int tls13_set_encoded_pub_key(EVP_PKEY *pkey, const unsigned char *enckey, size_t enckeylen) { if (EVP_PKEY_is_a(pkey, "DH")) { int bits = EVP_PKEY_get_bits(pkey); if (bits <= 0 || enckeylen != (size_t)bits / 8) /* the encoded key must be padded to the length of the p */ return 0; } else if (EVP_PKEY_is_a(pkey, "EC")) { if (enckeylen < 3 /* point format and at least 1 byte for x and y */ || enckey[0] != 0x04) return 0; } return EVP_PKEY_set1_encoded_public_key(pkey, enckey, enckeylen); }

./openssl/ssl/ssl_utst.c

/* * Copyright 2014-2016 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "ssl_local.h" #ifndef OPENSSL_NO_UNIT_TEST static const struct openssl_ssl_test_functions ssl_test_functions = { ssl_init_wbio_buffer, }; const struct openssl_ssl_test_functions *SSL_test_functions(void) { return &ssl_test_functions; } #endif

./openssl/ssl/ssl_sess.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #if defined(__TANDEM) && defined(_SPT_MODEL_) # include <spthread.h> # include <spt_extensions.h> /* timeval */ #endif #include <stdio.h> #include <openssl/rand.h> #include <openssl/engine.h> #include "internal/refcount.h" #include "internal/cryptlib.h" #include "ssl_local.h" #include "statem/statem_local.h" static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s); static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s); static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck); DEFINE_STACK_OF(SSL_SESSION) __owur static ossl_inline int sess_timedout(OSSL_TIME t, SSL_SESSION *ss) { return ossl_time_compare(t, ss->calc_timeout) > 0; } /* * Returns -1/0/+1 as other XXXcmp-type functions * Takes calculated timeout into consideration */ __owur static ossl_inline int timeoutcmp(SSL_SESSION *a, SSL_SESSION *b) { return ossl_time_compare(a->calc_timeout, b->calc_timeout); } /* * Calculates effective timeout * Locking must be done by the caller of this function */ void ssl_session_calculate_timeout(SSL_SESSION *ss) { ss->calc_timeout = ossl_time_add(ss->time, ss->timeout); } /* * SSL_get_session() and SSL_get1_session() are problematic in TLS1.3 because, * unlike in earlier protocol versions, the session ticket may not have been * sent yet even though a handshake has finished. The session ticket data could * come in sometime later...or even change if multiple session ticket messages * are sent from the server. The preferred way for applications to obtain * a resumable session is to use SSL_CTX_sess_set_new_cb(). */ SSL_SESSION *SSL_get_session(const SSL *ssl) /* aka SSL_get0_session; gets 0 objects, just returns a copy of the pointer */ { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return NULL; return sc->session; } SSL_SESSION *SSL_get1_session(SSL *ssl) /* variant of SSL_get_session: caller really gets something */ { SSL_SESSION *sess; /* * Need to lock this all up rather than just use CRYPTO_add so that * somebody doesn't free ssl->session between when we check it's non-null * and when we up the reference count. */ if (!CRYPTO_THREAD_read_lock(ssl->lock)) return NULL; sess = SSL_get_session(ssl); if (sess != NULL) SSL_SESSION_up_ref(sess); CRYPTO_THREAD_unlock(ssl->lock); return sess; } int SSL_SESSION_set_ex_data(SSL_SESSION *s, int idx, void *arg) { return CRYPTO_set_ex_data(&s->ex_data, idx, arg); } void *SSL_SESSION_get_ex_data(const SSL_SESSION *s, int idx) { return CRYPTO_get_ex_data(&s->ex_data, idx); } SSL_SESSION *SSL_SESSION_new(void) { SSL_SESSION *ss; if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL)) return NULL; ss = OPENSSL_zalloc(sizeof(*ss)); if (ss == NULL) return NULL; ss->verify_result = 1; /* avoid 0 (= X509_V_OK) just in case */ /* 5 minute timeout by default */ ss->timeout = ossl_seconds2time(60 * 5 + 4); ss->time = ossl_time_now(); ssl_session_calculate_timeout(ss); if (!CRYPTO_NEW_REF(&ss->references, 1)) { OPENSSL_free(ss); return NULL; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data)) { CRYPTO_FREE_REF(&ss->references); OPENSSL_free(ss); return NULL; } return ss; } SSL_SESSION *SSL_SESSION_dup(const SSL_SESSION *src) { return ssl_session_dup(src, 1); } /* * Create a new SSL_SESSION and duplicate the contents of |src| into it. If * ticket == 0 then no ticket information is duplicated, otherwise it is. */ SSL_SESSION *ssl_session_dup(const SSL_SESSION *src, int ticket) { SSL_SESSION *dest; dest = OPENSSL_malloc(sizeof(*dest)); if (dest == NULL) return NULL; memcpy(dest, src, sizeof(*dest)); /* * Set the various pointers to NULL so that we can call SSL_SESSION_free in * the case of an error whilst halfway through constructing dest */ #ifndef OPENSSL_NO_PSK dest->psk_identity_hint = NULL; dest->psk_identity = NULL; #endif dest->ext.hostname = NULL; dest->ext.tick = NULL; dest->ext.alpn_selected = NULL; #ifndef OPENSSL_NO_SRP dest->srp_username = NULL; #endif dest->peer_chain = NULL; dest->peer = NULL; dest->peer_rpk = NULL; dest->ticket_appdata = NULL; memset(&dest->ex_data, 0, sizeof(dest->ex_data)); /* As the copy is not in the cache, we remove the associated pointers */ dest->prev = NULL; dest->next = NULL; dest->owner = NULL; if (!CRYPTO_NEW_REF(&dest->references, 1)) { OPENSSL_free(dest); return NULL; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, dest, &dest->ex_data)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if (src->peer != NULL) { if (!X509_up_ref(src->peer)) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } dest->peer = src->peer; } if (src->peer_chain != NULL) { dest->peer_chain = X509_chain_up_ref(src->peer_chain); if (dest->peer_chain == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } } if (src->peer_rpk != NULL) { if (!EVP_PKEY_up_ref(src->peer_rpk)) goto err; dest->peer_rpk = src->peer_rpk; } #ifndef OPENSSL_NO_PSK if (src->psk_identity_hint) { dest->psk_identity_hint = OPENSSL_strdup(src->psk_identity_hint); if (dest->psk_identity_hint == NULL) goto err; } if (src->psk_identity) { dest->psk_identity = OPENSSL_strdup(src->psk_identity); if (dest->psk_identity == NULL) goto err; } #endif if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, &dest->ex_data, &src->ex_data)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if (src->ext.hostname) { dest->ext.hostname = OPENSSL_strdup(src->ext.hostname); if (dest->ext.hostname == NULL) goto err; } if (ticket != 0 && src->ext.tick != NULL) { dest->ext.tick = OPENSSL_memdup(src->ext.tick, src->ext.ticklen); if (dest->ext.tick == NULL) goto err; } else { dest->ext.tick_lifetime_hint = 0; dest->ext.ticklen = 0; } if (src->ext.alpn_selected != NULL) { dest->ext.alpn_selected = OPENSSL_memdup(src->ext.alpn_selected, src->ext.alpn_selected_len); if (dest->ext.alpn_selected == NULL) goto err; } #ifndef OPENSSL_NO_SRP if (src->srp_username) { dest->srp_username = OPENSSL_strdup(src->srp_username); if (dest->srp_username == NULL) goto err; } #endif if (src->ticket_appdata != NULL) { dest->ticket_appdata = OPENSSL_memdup(src->ticket_appdata, src->ticket_appdata_len); if (dest->ticket_appdata == NULL) goto err; } return dest; err: SSL_SESSION_free(dest); return NULL; } const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s, unsigned int *len) { if (len) *len = (unsigned int)s->session_id_length; return s->session_id; } const unsigned char *SSL_SESSION_get0_id_context(const SSL_SESSION *s, unsigned int *len) { if (len != NULL) *len = (unsigned int)s->sid_ctx_length; return s->sid_ctx; } unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s) { return s->compress_meth; } /* * SSLv3/TLSv1 has 32 bytes (256 bits) of session ID space. As such, filling * the ID with random junk repeatedly until we have no conflict is going to * complete in one iteration pretty much "most" of the time (btw: * understatement). So, if it takes us 10 iterations and we still can't avoid * a conflict - well that's a reasonable point to call it quits. Either the * RAND code is broken or someone is trying to open roughly very close to * 2^256 SSL sessions to our server. How you might store that many sessions * is perhaps a more interesting question ... */ #define MAX_SESS_ID_ATTEMPTS 10 static int def_generate_session_id(SSL *ssl, unsigned char *id, unsigned int *id_len) { unsigned int retry = 0; do { if (RAND_bytes_ex(ssl->ctx->libctx, id, *id_len, 0) <= 0) return 0; #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if (retry > 0) { id[0]++; } #endif } while (SSL_has_matching_session_id(ssl, id, *id_len) && (++retry < MAX_SESS_ID_ATTEMPTS)) ; if (retry < MAX_SESS_ID_ATTEMPTS) return 1; /* else - woops a session_id match */ /* * XXX We should also check the external cache -- but the probability of * a collision is negligible, and we could not prevent the concurrent * creation of sessions with identical IDs since we currently don't have * means to atomically check whether a session ID already exists and make * a reservation for it if it does not (this problem applies to the * internal cache as well). */ return 0; } int ssl_generate_session_id(SSL_CONNECTION *s, SSL_SESSION *ss) { unsigned int tmp; GEN_SESSION_CB cb = def_generate_session_id; SSL *ssl = SSL_CONNECTION_GET_SSL(s); switch (s->version) { case SSL3_VERSION: case TLS1_VERSION: case TLS1_1_VERSION: case TLS1_2_VERSION: case TLS1_3_VERSION: case DTLS1_BAD_VER: case DTLS1_VERSION: case DTLS1_2_VERSION: ss->session_id_length = SSL3_SSL_SESSION_ID_LENGTH; break; default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNSUPPORTED_SSL_VERSION); return 0; } /*- * If RFC5077 ticket, use empty session ID (as server). * Note that: * (a) ssl_get_prev_session() does lookahead into the * ClientHello extensions to find the session ticket. * When ssl_get_prev_session() fails, statem_srvr.c calls * ssl_get_new_session() in tls_process_client_hello(). * At that point, it has not yet parsed the extensions, * however, because of the lookahead, it already knows * whether a ticket is expected or not. * * (b) statem_clnt.c calls ssl_get_new_session() before parsing * ServerHello extensions, and before recording the session * ID received from the server, so this block is a noop. */ if (s->ext.ticket_expected) { ss->session_id_length = 0; return 1; } /* Choose which callback will set the session ID */ if (!CRYPTO_THREAD_read_lock(SSL_CONNECTION_GET_SSL(s)->lock)) return 0; if (!CRYPTO_THREAD_read_lock(s->session_ctx->lock)) { CRYPTO_THREAD_unlock(ssl->lock); SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED); return 0; } if (s->generate_session_id) cb = s->generate_session_id; else if (s->session_ctx->generate_session_id) cb = s->session_ctx->generate_session_id; CRYPTO_THREAD_unlock(s->session_ctx->lock); CRYPTO_THREAD_unlock(ssl->lock); /* Choose a session ID */ memset(ss->session_id, 0, ss->session_id_length); tmp = (int)ss->session_id_length; if (!cb(ssl, ss->session_id, &tmp)) { /* The callback failed */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SSL_SESSION_ID_CALLBACK_FAILED); return 0; } /* * Don't allow the callback to set the session length to zero. nor * set it higher than it was. */ if (tmp == 0 || tmp > ss->session_id_length) { /* The callback set an illegal length */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH); return 0; } ss->session_id_length = tmp; /* Finally, check for a conflict */ if (SSL_has_matching_session_id(ssl, ss->session_id, (unsigned int)ss->session_id_length)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SSL_SESSION_ID_CONFLICT); return 0; } return 1; } int ssl_get_new_session(SSL_CONNECTION *s, int session) { /* This gets used by clients and servers. */ SSL_SESSION *ss = NULL; if ((ss = SSL_SESSION_new()) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); return 0; } /* If the context has a default timeout, use it */ if (ossl_time_is_zero(s->session_ctx->session_timeout)) ss->timeout = SSL_CONNECTION_GET_SSL(s)->method->get_timeout(); else ss->timeout = s->session_ctx->session_timeout; ssl_session_calculate_timeout(ss); SSL_SESSION_free(s->session); s->session = NULL; if (session) { if (SSL_CONNECTION_IS_TLS13(s)) { /* * We generate the session id while constructing the * NewSessionTicket in TLSv1.3. */ ss->session_id_length = 0; } else if (!ssl_generate_session_id(s, ss)) { /* SSLfatal() already called */ SSL_SESSION_free(ss); return 0; } } else { ss->session_id_length = 0; } if (s->sid_ctx_length > sizeof(ss->sid_ctx)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); SSL_SESSION_free(ss); return 0; } memcpy(ss->sid_ctx, s->sid_ctx, s->sid_ctx_length); ss->sid_ctx_length = s->sid_ctx_length; s->session = ss; ss->ssl_version = s->version; ss->verify_result = X509_V_OK; /* If client supports extended master secret set it in session */ if (s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) ss->flags |= SSL_SESS_FLAG_EXTMS; return 1; } SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s, const unsigned char *sess_id, size_t sess_id_len) { SSL_SESSION *ret = NULL; if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP) == 0) { SSL_SESSION data; data.ssl_version = s->version; if (!ossl_assert(sess_id_len <= SSL_MAX_SSL_SESSION_ID_LENGTH)) return NULL; memcpy(data.session_id, sess_id, sess_id_len); data.session_id_length = sess_id_len; if (!CRYPTO_THREAD_read_lock(s->session_ctx->lock)) return NULL; ret = lh_SSL_SESSION_retrieve(s->session_ctx->sessions, &data); if (ret != NULL) { /* don't allow other threads to steal it: */ SSL_SESSION_up_ref(ret); } CRYPTO_THREAD_unlock(s->session_ctx->lock); if (ret == NULL) ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_miss); } if (ret == NULL && s->session_ctx->get_session_cb != NULL) { int copy = 1; ret = s->session_ctx->get_session_cb(SSL_CONNECTION_GET_SSL(s), sess_id, sess_id_len, &copy); if (ret != NULL) { ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_cb_hit); /* * Increment reference count now if the session callback asks us * to do so (note that if the session structures returned by the * callback are shared between threads, it must handle the * reference count itself [i.e. copy == 0], or things won't be * thread-safe). */ if (copy) SSL_SESSION_up_ref(ret); /* * Add the externally cached session to the internal cache as * well if and only if we are supposed to. */ if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0) { /* * Either return value of SSL_CTX_add_session should not * interrupt the session resumption process. The return * value is intentionally ignored. */ (void)SSL_CTX_add_session(s->session_ctx, ret); } } } return ret; } /*- * ssl_get_prev attempts to find an SSL_SESSION to be used to resume this * connection. It is only called by servers. * * hello: The parsed ClientHello data * * Returns: * -1: fatal error * 0: no session found * 1: a session may have been found. * * Side effects: * - If a session is found then s->session is pointed at it (after freeing an * existing session if need be) and s->verify_result is set from the session. * - Both for new and resumed sessions, s->ext.ticket_expected is set to 1 * if the server should issue a new session ticket (to 0 otherwise). */ int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello) { /* This is used only by servers. */ SSL_SESSION *ret = NULL; int fatal = 0; int try_session_cache = 0; SSL_TICKET_STATUS r; if (SSL_CONNECTION_IS_TLS13(s)) { /* * By default we will send a new ticket. This can be overridden in the * ticket processing. */ s->ext.ticket_expected = 1; if (!tls_parse_extension(s, TLSEXT_IDX_psk_kex_modes, SSL_EXT_CLIENT_HELLO, hello->pre_proc_exts, NULL, 0) || !tls_parse_extension(s, TLSEXT_IDX_psk, SSL_EXT_CLIENT_HELLO, hello->pre_proc_exts, NULL, 0)) return -1; ret = s->session; } else { /* sets s->ext.ticket_expected */ r = tls_get_ticket_from_client(s, hello, &ret); switch (r) { case SSL_TICKET_FATAL_ERR_MALLOC: case SSL_TICKET_FATAL_ERR_OTHER: fatal = 1; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; case SSL_TICKET_NONE: case SSL_TICKET_EMPTY: if (hello->session_id_len > 0) { try_session_cache = 1; ret = lookup_sess_in_cache(s, hello->session_id, hello->session_id_len); } break; case SSL_TICKET_NO_DECRYPT: case SSL_TICKET_SUCCESS: case SSL_TICKET_SUCCESS_RENEW: break; } } if (ret == NULL) goto err; /* Now ret is non-NULL and we own one of its reference counts. */ /* Check TLS version consistency */ if (ret->ssl_version != s->version) goto err; if (ret->sid_ctx_length != s->sid_ctx_length || memcmp(ret->sid_ctx, s->sid_ctx, ret->sid_ctx_length)) { /* * We have the session requested by the client, but we don't want to * use it in this context. */ goto err; /* treat like cache miss */ } if ((s->verify_mode & SSL_VERIFY_PEER) && s->sid_ctx_length == 0) { /* * We can't be sure if this session is being used out of context, * which is especially important for SSL_VERIFY_PEER. The application * should have used SSL[_CTX]_set_session_id_context. For this error * case, we generate an error instead of treating the event like a * cache miss (otherwise it would be easy for applications to * effectively disable the session cache by accident without anyone * noticing). */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED); fatal = 1; goto err; } if (sess_timedout(ossl_time_now(), ret)) { ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_timeout); if (try_session_cache) { /* session was from the cache, so remove it */ SSL_CTX_remove_session(s->session_ctx, ret); } goto err; } /* Check extended master secret extension consistency */ if (ret->flags & SSL_SESS_FLAG_EXTMS) { /* If old session includes extms, but new does not: abort handshake */ if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INCONSISTENT_EXTMS); fatal = 1; goto err; } } else if (s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) { /* If new session includes extms, but old does not: do not resume */ goto err; } if (!SSL_CONNECTION_IS_TLS13(s)) { /* We already did this for TLS1.3 */ SSL_SESSION_free(s->session); s->session = ret; } ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_hit); s->verify_result = s->session->verify_result; return 1; err: if (ret != NULL) { SSL_SESSION_free(ret); /* In TLSv1.3 s->session was already set to ret, so we NULL it out */ if (SSL_CONNECTION_IS_TLS13(s)) s->session = NULL; if (!try_session_cache) { /* * The session was from a ticket, so we should issue a ticket for * the new session */ s->ext.ticket_expected = 1; } } if (fatal) return -1; return 0; } int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c) { int ret = 0; SSL_SESSION *s; /* * add just 1 reference count for the SSL_CTX's session cache even though * it has two ways of access: each session is in a doubly linked list and * an lhash */ SSL_SESSION_up_ref(c); /* * if session c is in already in cache, we take back the increment later */ if (!CRYPTO_THREAD_write_lock(ctx->lock)) { SSL_SESSION_free(c); return 0; } s = lh_SSL_SESSION_insert(ctx->sessions, c); /* * s != NULL iff we already had a session with the given PID. In this * case, s == c should hold (then we did not really modify * ctx->sessions), or we're in trouble. */ if (s != NULL && s != c) { /* We *are* in trouble ... */ SSL_SESSION_list_remove(ctx, s); SSL_SESSION_free(s); /* * ... so pretend the other session did not exist in cache (we cannot * handle two SSL_SESSION structures with identical session ID in the * same cache, which could happen e.g. when two threads concurrently * obtain the same session from an external cache) */ s = NULL; } else if (s == NULL && lh_SSL_SESSION_retrieve(ctx->sessions, c) == NULL) { /* s == NULL can also mean OOM error in lh_SSL_SESSION_insert ... */ /* * ... so take back the extra reference and also don't add * the session to the SSL_SESSION_list at this time */ s = c; } /* Adjust last used time, and add back into the cache at the appropriate spot */ if (ctx->session_cache_mode & SSL_SESS_CACHE_UPDATE_TIME) { c->time = ossl_time_now(); ssl_session_calculate_timeout(c); } if (s == NULL) { /* * new cache entry -- remove old ones if cache has become too large * delete cache entry *before* add, so we don't remove the one we're adding! */ ret = 1; if (SSL_CTX_sess_get_cache_size(ctx) > 0) { while (SSL_CTX_sess_number(ctx) >= SSL_CTX_sess_get_cache_size(ctx)) { if (!remove_session_lock(ctx, ctx->session_cache_tail, 0)) break; else ssl_tsan_counter(ctx, &ctx->stats.sess_cache_full); } } } SSL_SESSION_list_add(ctx, c); if (s != NULL) { /* * existing cache entry -- decrement previously incremented reference * count because it already takes into account the cache */ SSL_SESSION_free(s); /* s == c */ ret = 0; } CRYPTO_THREAD_unlock(ctx->lock); return ret; } int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c) { return remove_session_lock(ctx, c, 1); } static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck) { SSL_SESSION *r; int ret = 0; if ((c != NULL) && (c->session_id_length != 0)) { if (lck) { if (!CRYPTO_THREAD_write_lock(ctx->lock)) return 0; } if ((r = lh_SSL_SESSION_retrieve(ctx->sessions, c)) != NULL) { ret = 1; r = lh_SSL_SESSION_delete(ctx->sessions, r); SSL_SESSION_list_remove(ctx, r); } c->not_resumable = 1; if (lck) CRYPTO_THREAD_unlock(ctx->lock); if (ctx->remove_session_cb != NULL) ctx->remove_session_cb(ctx, c); if (ret) SSL_SESSION_free(r); } return ret; } void SSL_SESSION_free(SSL_SESSION *ss) { int i; if (ss == NULL) return; CRYPTO_DOWN_REF(&ss->references, &i); REF_PRINT_COUNT("SSL_SESSION", ss); if (i > 0) return; REF_ASSERT_ISNT(i < 0); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_SESSION, ss, &ss->ex_data); OPENSSL_cleanse(ss->master_key, sizeof(ss->master_key)); OPENSSL_cleanse(ss->session_id, sizeof(ss->session_id)); X509_free(ss->peer); EVP_PKEY_free(ss->peer_rpk); OSSL_STACK_OF_X509_free(ss->peer_chain); OPENSSL_free(ss->ext.hostname); OPENSSL_free(ss->ext.tick); #ifndef OPENSSL_NO_PSK OPENSSL_free(ss->psk_identity_hint); OPENSSL_free(ss->psk_identity); #endif #ifndef OPENSSL_NO_SRP OPENSSL_free(ss->srp_username); #endif OPENSSL_free(ss->ext.alpn_selected); OPENSSL_free(ss->ticket_appdata); CRYPTO_FREE_REF(&ss->references); OPENSSL_clear_free(ss, sizeof(*ss)); } int SSL_SESSION_up_ref(SSL_SESSION *ss) { int i; if (CRYPTO_UP_REF(&ss->references, &i) <= 0) return 0; REF_PRINT_COUNT("SSL_SESSION", ss); REF_ASSERT_ISNT(i < 2); return ((i > 1) ? 1 : 0); } int SSL_set_session(SSL *s, SSL_SESSION *session) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; ssl_clear_bad_session(sc); if (s->defltmeth != s->method) { if (!SSL_set_ssl_method(s, s->defltmeth)) return 0; } if (session != NULL) { SSL_SESSION_up_ref(session); sc->verify_result = session->verify_result; } SSL_SESSION_free(sc->session); sc->session = session; return 1; } int SSL_SESSION_set1_id(SSL_SESSION *s, const unsigned char *sid, unsigned int sid_len) { if (sid_len > SSL_MAX_SSL_SESSION_ID_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_TOO_LONG); return 0; } s->session_id_length = sid_len; if (sid != s->session_id) memcpy(s->session_id, sid, sid_len); return 1; } long SSL_SESSION_set_timeout(SSL_SESSION *s, long t) { OSSL_TIME new_timeout = ossl_seconds2time(t); if (s == NULL || t < 0) return 0; if (s->owner != NULL) { if (!CRYPTO_THREAD_write_lock(s->owner->lock)) return 0; s->timeout = new_timeout; ssl_session_calculate_timeout(s); SSL_SESSION_list_add(s->owner, s); CRYPTO_THREAD_unlock(s->owner->lock); } else { s->timeout = new_timeout; ssl_session_calculate_timeout(s); } return 1; } long SSL_SESSION_get_timeout(const SSL_SESSION *s) { if (s == NULL) return 0; return (long)ossl_time_to_time_t(s->timeout); } long SSL_SESSION_get_time(const SSL_SESSION *s) { if (s == NULL) return 0; return (long)ossl_time_to_time_t(s->time); } long SSL_SESSION_set_time(SSL_SESSION *s, long t) { OSSL_TIME new_time = ossl_time_from_time_t((time_t)t); if (s == NULL) return 0; if (s->owner != NULL) { if (!CRYPTO_THREAD_write_lock(s->owner->lock)) return 0; s->time = new_time; ssl_session_calculate_timeout(s); SSL_SESSION_list_add(s->owner, s); CRYPTO_THREAD_unlock(s->owner->lock); } else { s->time = new_time; ssl_session_calculate_timeout(s); } return t; } int SSL_SESSION_get_protocol_version(const SSL_SESSION *s) { return s->ssl_version; } int SSL_SESSION_set_protocol_version(SSL_SESSION *s, int version) { s->ssl_version = version; return 1; } const SSL_CIPHER *SSL_SESSION_get0_cipher(const SSL_SESSION *s) { return s->cipher; } int SSL_SESSION_set_cipher(SSL_SESSION *s, const SSL_CIPHER *cipher) { s->cipher = cipher; return 1; } const char *SSL_SESSION_get0_hostname(const SSL_SESSION *s) { return s->ext.hostname; } int SSL_SESSION_set1_hostname(SSL_SESSION *s, const char *hostname) { OPENSSL_free(s->ext.hostname); if (hostname == NULL) { s->ext.hostname = NULL; return 1; } s->ext.hostname = OPENSSL_strdup(hostname); return s->ext.hostname != NULL; } int SSL_SESSION_has_ticket(const SSL_SESSION *s) { return (s->ext.ticklen > 0) ? 1 : 0; } unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION *s) { return s->ext.tick_lifetime_hint; } void SSL_SESSION_get0_ticket(const SSL_SESSION *s, const unsigned char **tick, size_t *len) { *len = s->ext.ticklen; if (tick != NULL) *tick = s->ext.tick; } uint32_t SSL_SESSION_get_max_early_data(const SSL_SESSION *s) { return s->ext.max_early_data; } int SSL_SESSION_set_max_early_data(SSL_SESSION *s, uint32_t max_early_data) { s->ext.max_early_data = max_early_data; return 1; } void SSL_SESSION_get0_alpn_selected(const SSL_SESSION *s, const unsigned char **alpn, size_t *len) { *alpn = s->ext.alpn_selected; *len = s->ext.alpn_selected_len; } int SSL_SESSION_set1_alpn_selected(SSL_SESSION *s, const unsigned char *alpn, size_t len) { OPENSSL_free(s->ext.alpn_selected); if (alpn == NULL || len == 0) { s->ext.alpn_selected = NULL; s->ext.alpn_selected_len = 0; return 1; } s->ext.alpn_selected = OPENSSL_memdup(alpn, len); if (s->ext.alpn_selected == NULL) { s->ext.alpn_selected_len = 0; return 0; } s->ext.alpn_selected_len = len; return 1; } X509 *SSL_SESSION_get0_peer(SSL_SESSION *s) { return s->peer; } EVP_PKEY *SSL_SESSION_get0_peer_rpk(SSL_SESSION *s) { return s->peer_rpk; } int SSL_SESSION_set1_id_context(SSL_SESSION *s, const unsigned char *sid_ctx, unsigned int sid_ctx_len) { if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG); return 0; } s->sid_ctx_length = sid_ctx_len; if (sid_ctx != s->sid_ctx) memcpy(s->sid_ctx, sid_ctx, sid_ctx_len); return 1; } int SSL_SESSION_is_resumable(const SSL_SESSION *s) { /* * In the case of EAP-FAST, we can have a pre-shared "ticket" without a * session ID. */ return !s->not_resumable && (s->session_id_length > 0 || s->ext.ticklen > 0); } long SSL_CTX_set_timeout(SSL_CTX *s, long t) { long l; if (s == NULL) return 0; l = (long)ossl_time2seconds(s->session_timeout); s->session_timeout = ossl_seconds2time(t); return l; } long SSL_CTX_get_timeout(const SSL_CTX *s) { if (s == NULL) return 0; return (long)ossl_time2seconds(s->session_timeout); } int SSL_set_session_secret_cb(SSL *s, tls_session_secret_cb_fn tls_session_secret_cb, void *arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->ext.session_secret_cb = tls_session_secret_cb; sc->ext.session_secret_cb_arg = arg; return 1; } int SSL_set_session_ticket_ext_cb(SSL *s, tls_session_ticket_ext_cb_fn cb, void *arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->ext.session_ticket_cb = cb; sc->ext.session_ticket_cb_arg = arg; return 1; } int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->version >= TLS1_VERSION) { OPENSSL_free(sc->ext.session_ticket); sc->ext.session_ticket = NULL; sc->ext.session_ticket = OPENSSL_malloc(sizeof(TLS_SESSION_TICKET_EXT) + ext_len); if (sc->ext.session_ticket == NULL) return 0; if (ext_data != NULL) { sc->ext.session_ticket->length = ext_len; sc->ext.session_ticket->data = sc->ext.session_ticket + 1; memcpy(sc->ext.session_ticket->data, ext_data, ext_len); } else { sc->ext.session_ticket->length = 0; sc->ext.session_ticket->data = NULL; } return 1; } return 0; } void SSL_CTX_flush_sessions(SSL_CTX *s, long t) { STACK_OF(SSL_SESSION) *sk; SSL_SESSION *current; unsigned long i; const OSSL_TIME timeout = ossl_time_from_time_t(t); if (!CRYPTO_THREAD_write_lock(s->lock)) return; sk = sk_SSL_SESSION_new_null(); i = lh_SSL_SESSION_get_down_load(s->sessions); lh_SSL_SESSION_set_down_load(s->sessions, 0); /* * Iterate over the list from the back (oldest), and stop * when a session can no longer be removed. * Add the session to a temporary list to be freed outside * the SSL_CTX lock. * But still do the remove_session_cb() within the lock. */ while (s->session_cache_tail != NULL) { current = s->session_cache_tail; if (t == 0 || sess_timedout(timeout, current)) { lh_SSL_SESSION_delete(s->sessions, current); SSL_SESSION_list_remove(s, current); current->not_resumable = 1; if (s->remove_session_cb != NULL) s->remove_session_cb(s, current); /* * Throw the session on a stack, it's entirely plausible * that while freeing outside the critical section, the * session could be re-added, so avoid using the next/prev * pointers. If the stack failed to create, or the session * couldn't be put on the stack, just free it here */ if (sk == NULL || !sk_SSL_SESSION_push(sk, current)) SSL_SESSION_free(current); } else { break; } } lh_SSL_SESSION_set_down_load(s->sessions, i); CRYPTO_THREAD_unlock(s->lock); sk_SSL_SESSION_pop_free(sk, SSL_SESSION_free); } int ssl_clear_bad_session(SSL_CONNECTION *s) { if ((s->session != NULL) && !(s->shutdown & SSL_SENT_SHUTDOWN) && !(SSL_in_init(SSL_CONNECTION_GET_SSL(s)) || SSL_in_before(SSL_CONNECTION_GET_SSL(s)))) { SSL_CTX_remove_session(s->session_ctx, s->session); return 1; } else return 0; } /* locked by SSL_CTX in the calling function */ static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s) { if ((s->next == NULL) || (s->prev == NULL)) return; if (s->next == (SSL_SESSION *)&(ctx->session_cache_tail)) { /* last element in list */ if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head)) { /* only one element in list */ ctx->session_cache_head = NULL; ctx->session_cache_tail = NULL; } else { ctx->session_cache_tail = s->prev; s->prev->next = (SSL_SESSION *)&(ctx->session_cache_tail); } } else { if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head)) { /* first element in list */ ctx->session_cache_head = s->next; s->next->prev = (SSL_SESSION *)&(ctx->session_cache_head); } else { /* middle of list */ s->next->prev = s->prev; s->prev->next = s->next; } } s->prev = s->next = NULL; s->owner = NULL; } static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s) { SSL_SESSION *next; if ((s->next != NULL) && (s->prev != NULL)) SSL_SESSION_list_remove(ctx, s); if (ctx->session_cache_head == NULL) { ctx->session_cache_head = s; ctx->session_cache_tail = s; s->prev = (SSL_SESSION *)&(ctx->session_cache_head); s->next = (SSL_SESSION *)&(ctx->session_cache_tail); } else { if (timeoutcmp(s, ctx->session_cache_head) >= 0) { /* * if we timeout after (or the same time as) the first * session, put us first - usual case */ s->next = ctx->session_cache_head; s->next->prev = s; s->prev = (SSL_SESSION *)&(ctx->session_cache_head); ctx->session_cache_head = s; } else if (timeoutcmp(s, ctx->session_cache_tail) < 0) { /* if we timeout before the last session, put us last */ s->prev = ctx->session_cache_tail; s->prev->next = s; s->next = (SSL_SESSION *)&(ctx->session_cache_tail); ctx->session_cache_tail = s; } else { /* * we timeout somewhere in-between - if there is only * one session in the cache it will be caught above */ next = ctx->session_cache_head->next; while (next != (SSL_SESSION*)&(ctx->session_cache_tail)) { if (timeoutcmp(s, next) >= 0) { s->next = next; s->prev = next->prev; next->prev->next = s; next->prev = s; break; } next = next->next; } } } s->owner = ctx; } void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx, int (*cb) (struct ssl_st *ssl, SSL_SESSION *sess)) { ctx->new_session_cb = cb; } int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (SSL *ssl, SSL_SESSION *sess) { return ctx->new_session_cb; } void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx, void (*cb) (SSL_CTX *ctx, SSL_SESSION *sess)) { ctx->remove_session_cb = cb; } void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (SSL_CTX *ctx, SSL_SESSION *sess) { return ctx->remove_session_cb; } void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx, SSL_SESSION *(*cb) (SSL *ssl, const unsigned char *data, int len, int *copy)) { ctx->get_session_cb = cb; } SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (SSL *ssl, const unsigned char *data, int len, int *copy) { return ctx->get_session_cb; } void SSL_CTX_set_info_callback(SSL_CTX *ctx, void (*cb) (const SSL *ssl, int type, int val)) { ctx->info_callback = cb; } void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type, int val) { return ctx->info_callback; } void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx, int (*cb) (SSL *ssl, X509 **x509, EVP_PKEY **pkey)) { ctx->client_cert_cb = cb; } int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509, EVP_PKEY **pkey) { return ctx->client_cert_cb; } void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx, int (*cb) (SSL *ssl, unsigned char *cookie, unsigned int *cookie_len)) { ctx->app_gen_cookie_cb = cb; } void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx, int (*cb) (SSL *ssl, const unsigned char *cookie, unsigned int cookie_len)) { ctx->app_verify_cookie_cb = cb; } int SSL_SESSION_set1_ticket_appdata(SSL_SESSION *ss, const void *data, size_t len) { OPENSSL_free(ss->ticket_appdata); ss->ticket_appdata_len = 0; if (data == NULL || len == 0) { ss->ticket_appdata = NULL; return 1; } ss->ticket_appdata = OPENSSL_memdup(data, len); if (ss->ticket_appdata != NULL) { ss->ticket_appdata_len = len; return 1; } return 0; } int SSL_SESSION_get0_ticket_appdata(SSL_SESSION *ss, void **data, size_t *len) { *data = ss->ticket_appdata; *len = ss->ticket_appdata_len; return 1; } void SSL_CTX_set_stateless_cookie_generate_cb( SSL_CTX *ctx, int (*cb) (SSL *ssl, unsigned char *cookie, size_t *cookie_len)) { ctx->gen_stateless_cookie_cb = cb; } void SSL_CTX_set_stateless_cookie_verify_cb( SSL_CTX *ctx, int (*cb) (SSL *ssl, const unsigned char *cookie, size_t cookie_len)) { ctx->verify_stateless_cookie_cb = cb; } IMPLEMENT_PEM_rw(SSL_SESSION, SSL_SESSION, PEM_STRING_SSL_SESSION, SSL_SESSION)

./openssl/ssl/ssl_local.h

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #ifndef OSSL_SSL_LOCAL_H # define OSSL_SSL_LOCAL_H # include "internal/e_os.h" /* struct timeval for DTLS */ # include <stdlib.h> # include <time.h> # include <errno.h> # include "internal/common.h" /* for HAS_PREFIX */ # include <openssl/buffer.h> # include <openssl/bio.h> # include <openssl/comp.h> # include <openssl/dsa.h> # include <openssl/err.h> # include <openssl/ssl.h> # include <openssl/async.h> # include <openssl/symhacks.h> # include <openssl/ct.h> # include "internal/recordmethod.h" # include "internal/statem.h" # include "internal/packet.h" # include "internal/dane.h" # include "internal/refcount.h" # include "internal/tsan_assist.h" # include "internal/bio.h" # include "internal/ktls.h" # include "internal/time.h" # include "internal/ssl.h" # include "record/record.h" # ifdef OPENSSL_BUILD_SHLIBSSL # undef OPENSSL_EXTERN # define OPENSSL_EXTERN OPENSSL_EXPORT # endif # define TLS_MAX_VERSION_INTERNAL TLS1_3_VERSION # define DTLS_MAX_VERSION_INTERNAL DTLS1_2_VERSION /* * DTLS version numbers are strange because they're inverted. Except for * DTLS1_BAD_VER, which should be considered "lower" than the rest. */ # define dtls_ver_ordinal(v1) (((v1) == DTLS1_BAD_VER) ? 0xff00 : (v1)) # define DTLS_VERSION_GT(v1, v2) (dtls_ver_ordinal(v1) < dtls_ver_ordinal(v2)) # define DTLS_VERSION_GE(v1, v2) (dtls_ver_ordinal(v1) <= dtls_ver_ordinal(v2)) # define DTLS_VERSION_LT(v1, v2) (dtls_ver_ordinal(v1) > dtls_ver_ordinal(v2)) # define DTLS_VERSION_LE(v1, v2) (dtls_ver_ordinal(v1) >= dtls_ver_ordinal(v2)) # define SSL_AD_NO_ALERT -1 /* * Define the Bitmasks for SSL_CIPHER.algorithms. * This bits are used packed as dense as possible. If new methods/ciphers * etc will be added, the bits a likely to change, so this information * is for internal library use only, even though SSL_CIPHER.algorithms * can be publicly accessed. * Use the according functions for cipher management instead. * * The bit mask handling in the selection and sorting scheme in * ssl_create_cipher_list() has only limited capabilities, reflecting * that the different entities within are mutually exclusive: * ONLY ONE BIT PER MASK CAN BE SET AT A TIME. */ /* Bits for algorithm_mkey (key exchange algorithm) */ /* RSA key exchange */ # define SSL_kRSA 0x00000001U /* tmp DH key no DH cert */ # define SSL_kDHE 0x00000002U /* synonym */ # define SSL_kEDH SSL_kDHE /* ephemeral ECDH */ # define SSL_kECDHE 0x00000004U /* synonym */ # define SSL_kEECDH SSL_kECDHE /* PSK */ # define SSL_kPSK 0x00000008U /* GOST key exchange */ # define SSL_kGOST 0x00000010U /* SRP */ # define SSL_kSRP 0x00000020U # define SSL_kRSAPSK 0x00000040U # define SSL_kECDHEPSK 0x00000080U # define SSL_kDHEPSK 0x00000100U /* GOST KDF key exchange, draft-smyshlyaev-tls12-gost-suites */ # define SSL_kGOST18 0x00000200U /* all PSK */ # define SSL_PSK (SSL_kPSK | SSL_kRSAPSK | SSL_kECDHEPSK | SSL_kDHEPSK) /* Any appropriate key exchange algorithm (for TLS 1.3 ciphersuites) */ # define SSL_kANY 0x00000000U /* Bits for algorithm_auth (server authentication) */ /* RSA auth */ # define SSL_aRSA 0x00000001U /* DSS auth */ # define SSL_aDSS 0x00000002U /* no auth (i.e. use ADH or AECDH) */ # define SSL_aNULL 0x00000004U /* ECDSA auth*/ # define SSL_aECDSA 0x00000008U /* PSK auth */ # define SSL_aPSK 0x00000010U /* GOST R 34.10-2001 signature auth */ # define SSL_aGOST01 0x00000020U /* SRP auth */ # define SSL_aSRP 0x00000040U /* GOST R 34.10-2012 signature auth */ # define SSL_aGOST12 0x00000080U /* Any appropriate signature auth (for TLS 1.3 ciphersuites) */ # define SSL_aANY 0x00000000U /* All bits requiring a certificate */ #define SSL_aCERT \ (SSL_aRSA | SSL_aDSS | SSL_aECDSA | SSL_aGOST01 | SSL_aGOST12) /* Bits for algorithm_enc (symmetric encryption) */ # define SSL_DES 0x00000001U # define SSL_3DES 0x00000002U # define SSL_RC4 0x00000004U # define SSL_RC2 0x00000008U # define SSL_IDEA 0x00000010U # define SSL_eNULL 0x00000020U # define SSL_AES128 0x00000040U # define SSL_AES256 0x00000080U # define SSL_CAMELLIA128 0x00000100U # define SSL_CAMELLIA256 0x00000200U # define SSL_eGOST2814789CNT 0x00000400U # define SSL_SEED 0x00000800U # define SSL_AES128GCM 0x00001000U # define SSL_AES256GCM 0x00002000U # define SSL_AES128CCM 0x00004000U # define SSL_AES256CCM 0x00008000U # define SSL_AES128CCM8 0x00010000U # define SSL_AES256CCM8 0x00020000U # define SSL_eGOST2814789CNT12 0x00040000U # define SSL_CHACHA20POLY1305 0x00080000U # define SSL_ARIA128GCM 0x00100000U # define SSL_ARIA256GCM 0x00200000U # define SSL_MAGMA 0x00400000U # define SSL_KUZNYECHIK 0x00800000U # define SSL_AESGCM (SSL_AES128GCM | SSL_AES256GCM) # define SSL_AESCCM (SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8) # define SSL_AES (SSL_AES128|SSL_AES256|SSL_AESGCM|SSL_AESCCM) # define SSL_CAMELLIA (SSL_CAMELLIA128|SSL_CAMELLIA256) # define SSL_CHACHA20 (SSL_CHACHA20POLY1305) # define SSL_ARIAGCM (SSL_ARIA128GCM | SSL_ARIA256GCM) # define SSL_ARIA (SSL_ARIAGCM) # define SSL_CBC (SSL_DES | SSL_3DES | SSL_RC2 | SSL_IDEA \ | SSL_AES128 | SSL_AES256 | SSL_CAMELLIA128 \ | SSL_CAMELLIA256 | SSL_SEED) /* Bits for algorithm_mac (symmetric authentication) */ # define SSL_MD5 0x00000001U # define SSL_SHA1 0x00000002U # define SSL_GOST94 0x00000004U # define SSL_GOST89MAC 0x00000008U # define SSL_SHA256 0x00000010U # define SSL_SHA384 0x00000020U /* Not a real MAC, just an indication it is part of cipher */ # define SSL_AEAD 0x00000040U # define SSL_GOST12_256 0x00000080U # define SSL_GOST89MAC12 0x00000100U # define SSL_GOST12_512 0x00000200U # define SSL_MAGMAOMAC 0x00000400U # define SSL_KUZNYECHIKOMAC 0x00000800U /* * When adding new digest in the ssl_ciph.c and increment SSL_MD_NUM_IDX make * sure to update this constant too */ # define SSL_MD_MD5_IDX 0 # define SSL_MD_SHA1_IDX 1 # define SSL_MD_GOST94_IDX 2 # define SSL_MD_GOST89MAC_IDX 3 # define SSL_MD_SHA256_IDX 4 # define SSL_MD_SHA384_IDX 5 # define SSL_MD_GOST12_256_IDX 6 # define SSL_MD_GOST89MAC12_IDX 7 # define SSL_MD_GOST12_512_IDX 8 # define SSL_MD_MD5_SHA1_IDX 9 # define SSL_MD_SHA224_IDX 10 # define SSL_MD_SHA512_IDX 11 # define SSL_MD_MAGMAOMAC_IDX 12 # define SSL_MD_KUZNYECHIKOMAC_IDX 13 # define SSL_MAX_DIGEST 14 #define SSL_MD_NUM_IDX SSL_MAX_DIGEST /* Bits for algorithm2 (handshake digests and other extra flags) */ /* Bits 0-7 are handshake MAC */ # define SSL_HANDSHAKE_MAC_MASK 0xFF # define SSL_HANDSHAKE_MAC_MD5_SHA1 SSL_MD_MD5_SHA1_IDX # define SSL_HANDSHAKE_MAC_SHA256 SSL_MD_SHA256_IDX # define SSL_HANDSHAKE_MAC_SHA384 SSL_MD_SHA384_IDX # define SSL_HANDSHAKE_MAC_GOST94 SSL_MD_GOST94_IDX # define SSL_HANDSHAKE_MAC_GOST12_256 SSL_MD_GOST12_256_IDX # define SSL_HANDSHAKE_MAC_GOST12_512 SSL_MD_GOST12_512_IDX # define SSL_HANDSHAKE_MAC_DEFAULT SSL_HANDSHAKE_MAC_MD5_SHA1 /* Bits 8-15 bits are PRF */ # define TLS1_PRF_DGST_SHIFT 8 # define TLS1_PRF_SHA1_MD5 (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_SHA256 (SSL_MD_SHA256_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_SHA384 (SSL_MD_SHA384_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_GOST94 (SSL_MD_GOST94_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_GOST12_256 (SSL_MD_GOST12_256_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF_GOST12_512 (SSL_MD_GOST12_512_IDX << TLS1_PRF_DGST_SHIFT) # define TLS1_PRF (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT) /* * Stream MAC for GOST ciphersuites from cryptopro draft (currently this also * goes into algorithm2) */ # define TLS1_STREAM_MAC 0x10000 /* * TLSTREE cipher/mac key derivation from draft-smyshlyaev-tls12-gost-suites * (currently this also goes into algorithm2) */ # define TLS1_TLSTREE 0x20000 /* Ciphersuite supported in QUIC */ # define SSL_QUIC 0x00040000U # define SSL_STRONG_MASK 0x0000001FU # define SSL_DEFAULT_MASK 0X00000020U # define SSL_STRONG_NONE 0x00000001U # define SSL_LOW 0x00000002U # define SSL_MEDIUM 0x00000004U # define SSL_HIGH 0x00000008U # define SSL_FIPS 0x00000010U # define SSL_NOT_DEFAULT 0x00000020U /* we have used 0000003f - 26 bits left to go */ /* Flag used on OpenSSL ciphersuite ids to indicate they are for SSLv3+ */ # define SSL3_CK_CIPHERSUITE_FLAG 0x03000000 /* Check if an SSL structure is using DTLS */ # define SSL_CONNECTION_IS_DTLS(s) \ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) /* Check if we are using TLSv1.3 */ # define SSL_CONNECTION_IS_TLS13(s) (!SSL_CONNECTION_IS_DTLS(s) \ && SSL_CONNECTION_GET_SSL(s)->method->version >= TLS1_3_VERSION \ && SSL_CONNECTION_GET_SSL(s)->method->version != TLS_ANY_VERSION) # define SSL_CONNECTION_TREAT_AS_TLS13(s) \ (SSL_CONNECTION_IS_TLS13(s) \ || (s)->early_data_state == SSL_EARLY_DATA_CONNECTING \ || (s)->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY \ || (s)->early_data_state == SSL_EARLY_DATA_WRITING \ || (s)->early_data_state == SSL_EARLY_DATA_WRITE_RETRY \ || (s)->hello_retry_request == SSL_HRR_PENDING) # define SSL_IS_FIRST_HANDSHAKE(s) ((s)->s3.tmp.finish_md_len == 0 \ || (s)->s3.tmp.peer_finish_md_len == 0) /* See if we need explicit IV */ # define SSL_USE_EXPLICIT_IV(s) \ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_EXPLICIT_IV) /* * See if we use signature algorithms extension and signature algorithm * before signatures. */ # define SSL_USE_SIGALGS(s) \ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SIGALGS) /* * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may * apply to others in future. */ # define SSL_USE_TLS1_2_CIPHERS(s) \ (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS) /* * Determine if a client can use TLS 1.2 ciphersuites: can't rely on method * flags because it may not be set to correct version yet. */ # define SSL_CLIENT_USE_TLS1_2_CIPHERS(s) \ ((!SSL_CONNECTION_IS_DTLS(s) && s->client_version >= TLS1_2_VERSION) || \ (SSL_CONNECTION_IS_DTLS(s) && DTLS_VERSION_GE(s->client_version, DTLS1_2_VERSION))) /* * Determine if a client should send signature algorithms extension: * as with TLS1.2 cipher we can't rely on method flags. */ # define SSL_CLIENT_USE_SIGALGS(s) \ SSL_CLIENT_USE_TLS1_2_CIPHERS(s) # define IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value) \ (((value) >= TLSEXT_max_fragment_length_512) && \ ((value) <= TLSEXT_max_fragment_length_4096)) # define USE_MAX_FRAGMENT_LENGTH_EXT(session) \ IS_MAX_FRAGMENT_LENGTH_EXT_VALID(session->ext.max_fragment_len_mode) # define GET_MAX_FRAGMENT_LENGTH(session) \ (512U << (session->ext.max_fragment_len_mode - 1)) # define SSL_READ_ETM(s) (s->s3.flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_READ) # define SSL_WRITE_ETM(s) (s->s3.flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE) # define SSL_IS_QUIC_HANDSHAKE(s) (((s)->s3.flags & TLS1_FLAGS_QUIC) != 0) /* alert_dispatch values */ /* No alert pending */ # define SSL_ALERT_DISPATCH_NONE 0 /* Alert pending */ # define SSL_ALERT_DISPATCH_PENDING 1 /* Pending alert write needs to be retried */ # define SSL_ALERT_DISPATCH_RETRY 2 /* Mostly for SSLv3 */ # define SSL_PKEY_RSA 0 # define SSL_PKEY_RSA_PSS_SIGN 1 # define SSL_PKEY_DSA_SIGN 2 # define SSL_PKEY_ECC 3 # define SSL_PKEY_GOST01 4 # define SSL_PKEY_GOST12_256 5 # define SSL_PKEY_GOST12_512 6 # define SSL_PKEY_ED25519 7 # define SSL_PKEY_ED448 8 # define SSL_PKEY_NUM 9 # define SSL_ENC_DES_IDX 0 # define SSL_ENC_3DES_IDX 1 # define SSL_ENC_RC4_IDX 2 # define SSL_ENC_RC2_IDX 3 # define SSL_ENC_IDEA_IDX 4 # define SSL_ENC_NULL_IDX 5 # define SSL_ENC_AES128_IDX 6 # define SSL_ENC_AES256_IDX 7 # define SSL_ENC_CAMELLIA128_IDX 8 # define SSL_ENC_CAMELLIA256_IDX 9 # define SSL_ENC_GOST89_IDX 10 # define SSL_ENC_SEED_IDX 11 # define SSL_ENC_AES128GCM_IDX 12 # define SSL_ENC_AES256GCM_IDX 13 # define SSL_ENC_AES128CCM_IDX 14 # define SSL_ENC_AES256CCM_IDX 15 # define SSL_ENC_AES128CCM8_IDX 16 # define SSL_ENC_AES256CCM8_IDX 17 # define SSL_ENC_GOST8912_IDX 18 # define SSL_ENC_CHACHA_IDX 19 # define SSL_ENC_ARIA128GCM_IDX 20 # define SSL_ENC_ARIA256GCM_IDX 21 # define SSL_ENC_MAGMA_IDX 22 # define SSL_ENC_KUZNYECHIK_IDX 23 # define SSL_ENC_NUM_IDX 24 /*- * SSL_kRSA <- RSA_ENC * SSL_kDH <- DH_ENC & (RSA_ENC | RSA_SIGN | DSA_SIGN) * SSL_kDHE <- RSA_ENC | RSA_SIGN | DSA_SIGN * SSL_aRSA <- RSA_ENC | RSA_SIGN * SSL_aDSS <- DSA_SIGN */ /*- #define CERT_INVALID 0 #define CERT_PUBLIC_KEY 1 #define CERT_PRIVATE_KEY 2 */ /* Certificate Type State */ # define OSSL_CERT_TYPE_CTOS_NONE 0 # define OSSL_CERT_TYPE_CTOS_GOOD 1 # define OSSL_CERT_TYPE_CTOS_ERROR 2 /* Post-Handshake Authentication state */ typedef enum { SSL_PHA_NONE = 0, SSL_PHA_EXT_SENT, /* client-side only: extension sent */ SSL_PHA_EXT_RECEIVED, /* server-side only: extension received */ SSL_PHA_REQUEST_PENDING, /* server-side only: request pending */ SSL_PHA_REQUESTED /* request received by client, or sent by server */ } SSL_PHA_STATE; /* CipherSuite length. SSLv3 and all TLS versions. */ # define TLS_CIPHER_LEN 2 /* used to hold info on the particular ciphers used */ struct ssl_cipher_st { uint32_t valid; const char *name; /* text name */ const char *stdname; /* RFC name */ uint32_t id; /* id, 4 bytes, first is version */ /* * changed in 1.0.0: these four used to be portions of a single value * 'algorithms' */ uint32_t algorithm_mkey; /* key exchange algorithm */ uint32_t algorithm_auth; /* server authentication */ uint32_t algorithm_enc; /* symmetric encryption */ uint32_t algorithm_mac; /* symmetric authentication */ int min_tls; /* minimum SSL/TLS protocol version */ int max_tls; /* maximum SSL/TLS protocol version */ int min_dtls; /* minimum DTLS protocol version */ int max_dtls; /* maximum DTLS protocol version */ uint32_t algo_strength; /* strength and export flags */ uint32_t algorithm2; /* Extra flags */ int32_t strength_bits; /* Number of bits really used */ uint32_t alg_bits; /* Number of bits for algorithm */ }; /* Used to hold SSL/TLS functions */ struct ssl_method_st { int version; unsigned flags; unsigned long mask; SSL *(*ssl_new) (SSL_CTX *ctx); void (*ssl_free) (SSL *s); int (*ssl_reset) (SSL *s); int (*ssl_init) (SSL *s); int (*ssl_clear) (SSL *s); void (*ssl_deinit) (SSL *s); int (*ssl_accept) (SSL *s); int (*ssl_connect) (SSL *s); int (*ssl_read) (SSL *s, void *buf, size_t len, size_t *readbytes); int (*ssl_peek) (SSL *s, void *buf, size_t len, size_t *readbytes); int (*ssl_write) (SSL *s, const void *buf, size_t len, size_t *written); int (*ssl_shutdown) (SSL *s); int (*ssl_renegotiate) (SSL *s); int (*ssl_renegotiate_check) (SSL *s, int); int (*ssl_read_bytes) (SSL *s, uint8_t type, uint8_t *recvd_type, unsigned char *buf, size_t len, int peek, size_t *readbytes); int (*ssl_write_bytes) (SSL *s, uint8_t type, const void *buf_, size_t len, size_t *written); int (*ssl_dispatch_alert) (SSL *s); long (*ssl_ctrl) (SSL *s, int cmd, long larg, void *parg); long (*ssl_ctx_ctrl) (SSL_CTX *ctx, int cmd, long larg, void *parg); const SSL_CIPHER *(*get_cipher_by_char) (const unsigned char *ptr); int (*put_cipher_by_char) (const SSL_CIPHER *cipher, WPACKET *pkt, size_t *len); size_t (*ssl_pending) (const SSL *s); int (*num_ciphers) (void); const SSL_CIPHER *(*get_cipher) (unsigned ncipher); OSSL_TIME (*get_timeout) (void); const struct ssl3_enc_method *ssl3_enc; /* Extra SSLv3/TLS stuff */ int (*ssl_version) (void); long (*ssl_callback_ctrl) (SSL *s, int cb_id, void (*fp) (void)); long (*ssl_ctx_callback_ctrl) (SSL_CTX *s, int cb_id, void (*fp) (void)); }; /* * Matches the length of PSK_MAX_PSK_LEN. We keep it the same value for * consistency, even in the event of OPENSSL_NO_PSK being defined. */ # define TLS13_MAX_RESUMPTION_PSK_LENGTH 512 /*- * Lets make this into an ASN.1 type structure as follows * SSL_SESSION_ID ::= SEQUENCE { * version INTEGER, -- structure version number * SSLversion INTEGER, -- SSL version number * Cipher OCTET STRING, -- the 3 byte cipher ID * Session_ID OCTET STRING, -- the Session ID * Master_key OCTET STRING, -- the master key * Key_Arg [ 0 ] IMPLICIT OCTET STRING, -- the optional Key argument * Time [ 1 ] EXPLICIT INTEGER, -- optional Start Time * Timeout [ 2 ] EXPLICIT INTEGER, -- optional Timeout ins seconds * Peer [ 3 ] EXPLICIT X509, -- optional Peer Certificate * Session_ID_context [ 4 ] EXPLICIT OCTET STRING, -- the Session ID context * Verify_result [ 5 ] EXPLICIT INTEGER, -- X509_V_... code for `Peer' * HostName [ 6 ] EXPLICIT OCTET STRING, -- optional HostName from servername TLS extension * PSK_identity_hint [ 7 ] EXPLICIT OCTET STRING, -- optional PSK identity hint * PSK_identity [ 8 ] EXPLICIT OCTET STRING, -- optional PSK identity * Ticket_lifetime_hint [9] EXPLICIT INTEGER, -- server's lifetime hint for session ticket * Ticket [10] EXPLICIT OCTET STRING, -- session ticket (clients only) * Compression_meth [11] EXPLICIT OCTET STRING, -- optional compression method * SRP_username [ 12 ] EXPLICIT OCTET STRING -- optional SRP username * flags [ 13 ] EXPLICIT INTEGER -- optional flags * } * Look in ssl/ssl_asn1.c for more details * I'm using EXPLICIT tags so I can read the damn things using asn1parse :-). */ struct ssl_session_st { int ssl_version; /* what ssl version session info is being kept * in here? */ size_t master_key_length; /* TLSv1.3 early_secret used for external PSKs */ unsigned char early_secret[EVP_MAX_MD_SIZE]; /* * For <=TLS1.2 this is the master_key. For TLS1.3 this is the resumption * PSK */ unsigned char master_key[TLS13_MAX_RESUMPTION_PSK_LENGTH]; /* session_id - valid? */ size_t session_id_length; unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; /* * this is used to determine whether the session is being reused in the * appropriate context. It is up to the application to set this, via * SSL_new */ size_t sid_ctx_length; unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; # ifndef OPENSSL_NO_PSK char *psk_identity_hint; char *psk_identity; # endif /* * Used to indicate that session resumption is not allowed. Applications * can also set this bit for a new session via not_resumable_session_cb * to disable session caching and tickets. */ int not_resumable; /* Peer raw public key, if available */ EVP_PKEY *peer_rpk; /* This is the cert and type for the other end. */ X509 *peer; /* Certificate chain peer sent. */ STACK_OF(X509) *peer_chain; /* * when app_verify_callback accepts a session where the peer's * certificate is not ok, we must remember the error for session reuse: */ long verify_result; /* only for servers */ CRYPTO_REF_COUNT references; OSSL_TIME timeout; OSSL_TIME time; OSSL_TIME calc_timeout; unsigned int compress_meth; /* Need to lookup the method */ const SSL_CIPHER *cipher; unsigned long cipher_id; /* when ASN.1 loaded, this needs to be used to * load the 'cipher' structure */ unsigned int kex_group; /* TLS group from key exchange */ CRYPTO_EX_DATA ex_data; /* application specific data */ /* * These are used to make removal of session-ids more efficient and to * implement a maximum cache size. */ struct ssl_session_st *prev, *next; struct { char *hostname; /* RFC4507 info */ unsigned char *tick; /* Session ticket */ size_t ticklen; /* Session ticket length */ /* Session lifetime hint in seconds */ unsigned long tick_lifetime_hint; uint32_t tick_age_add; /* Max number of bytes that can be sent as early data */ uint32_t max_early_data; /* The ALPN protocol selected for this session */ unsigned char *alpn_selected; size_t alpn_selected_len; /* * Maximum Fragment Length as per RFC 4366. * If this value does not contain RFC 4366 allowed values (1-4) then * either the Maximum Fragment Length Negotiation failed or was not * performed at all. */ uint8_t max_fragment_len_mode; } ext; # ifndef OPENSSL_NO_SRP char *srp_username; # endif unsigned char *ticket_appdata; size_t ticket_appdata_len; uint32_t flags; SSL_CTX *owner; }; /* Extended master secret support */ # define SSL_SESS_FLAG_EXTMS 0x1 # ifndef OPENSSL_NO_SRP typedef struct srp_ctx_st { /* param for all the callbacks */ void *SRP_cb_arg; /* set client Hello login callback */ int (*TLS_ext_srp_username_callback) (SSL *, int *, void *); /* set SRP N/g param callback for verification */ int (*SRP_verify_param_callback) (SSL *, void *); /* set SRP client passwd callback */ char *(*SRP_give_srp_client_pwd_callback) (SSL *, void *); char *login; BIGNUM *N, *g, *s, *B, *A; BIGNUM *a, *b, *v; char *info; int strength; unsigned long srp_Mask; } SRP_CTX; # endif typedef enum { SSL_EARLY_DATA_NONE = 0, SSL_EARLY_DATA_CONNECT_RETRY, SSL_EARLY_DATA_CONNECTING, SSL_EARLY_DATA_WRITE_RETRY, SSL_EARLY_DATA_WRITING, SSL_EARLY_DATA_WRITE_FLUSH, SSL_EARLY_DATA_UNAUTH_WRITING, SSL_EARLY_DATA_FINISHED_WRITING, SSL_EARLY_DATA_ACCEPT_RETRY, SSL_EARLY_DATA_ACCEPTING, SSL_EARLY_DATA_READ_RETRY, SSL_EARLY_DATA_READING, SSL_EARLY_DATA_FINISHED_READING } SSL_EARLY_DATA_STATE; /* * We check that the amount of unreadable early data doesn't exceed * max_early_data. max_early_data is given in plaintext bytes. However if it is * unreadable then we only know the number of ciphertext bytes. We also don't * know how much the overhead should be because it depends on the ciphersuite. * We make a small allowance. We assume 5 records of actual data plus the end * of early data alert record. Each record has a tag and a content type byte. * The longest tag length we know of is EVP_GCM_TLS_TAG_LEN. We don't count the * content of the alert record either which is 2 bytes. */ # define EARLY_DATA_CIPHERTEXT_OVERHEAD ((6 * (EVP_GCM_TLS_TAG_LEN + 1)) + 2) /* * The allowance we have between the client's calculated ticket age and our own. * We allow for 10 seconds. If a ticket is presented and the * client's age calculation is different by more than this than our own then we * do not allow that ticket for early_data. */ # define TICKET_AGE_ALLOWANCE ossl_seconds2time(10) #define MAX_COMPRESSIONS_SIZE 255 struct ssl_comp_st { int id; const char *name; COMP_METHOD *method; }; typedef struct raw_extension_st { /* Raw packet data for the extension */ PACKET data; /* Set to 1 if the extension is present or 0 otherwise */ int present; /* Set to 1 if we have already parsed the extension or 0 otherwise */ int parsed; /* The type of this extension, i.e. a TLSEXT_TYPE_* value */ unsigned int type; /* Track what order extensions are received in (0-based). */ size_t received_order; } RAW_EXTENSION; typedef struct { unsigned int isv2; unsigned int legacy_version; unsigned char random[SSL3_RANDOM_SIZE]; size_t session_id_len; unsigned char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; size_t dtls_cookie_len; unsigned char dtls_cookie[DTLS1_COOKIE_LENGTH]; PACKET ciphersuites; size_t compressions_len; unsigned char compressions[MAX_COMPRESSIONS_SIZE]; PACKET extensions; size_t pre_proc_exts_len; RAW_EXTENSION *pre_proc_exts; } CLIENTHELLO_MSG; /* * Extension index values NOTE: Any updates to these defines should be mirrored * with equivalent updates to ext_defs in extensions.c */ typedef enum tlsext_index_en { TLSEXT_IDX_renegotiate, TLSEXT_IDX_server_name, TLSEXT_IDX_max_fragment_length, TLSEXT_IDX_srp, TLSEXT_IDX_ec_point_formats, TLSEXT_IDX_supported_groups, TLSEXT_IDX_session_ticket, TLSEXT_IDX_status_request, TLSEXT_IDX_next_proto_neg, TLSEXT_IDX_application_layer_protocol_negotiation, TLSEXT_IDX_use_srtp, TLSEXT_IDX_encrypt_then_mac, TLSEXT_IDX_signed_certificate_timestamp, TLSEXT_IDX_extended_master_secret, TLSEXT_IDX_signature_algorithms_cert, TLSEXT_IDX_post_handshake_auth, TLSEXT_IDX_client_cert_type, TLSEXT_IDX_server_cert_type, TLSEXT_IDX_signature_algorithms, TLSEXT_IDX_supported_versions, TLSEXT_IDX_psk_kex_modes, TLSEXT_IDX_key_share, TLSEXT_IDX_cookie, TLSEXT_IDX_cryptopro_bug, TLSEXT_IDX_compress_certificate, TLSEXT_IDX_early_data, TLSEXT_IDX_certificate_authorities, TLSEXT_IDX_padding, TLSEXT_IDX_psk, /* Dummy index - must always be the last entry */ TLSEXT_IDX_num_builtins } TLSEXT_INDEX; DEFINE_LHASH_OF_EX(SSL_SESSION); /* Needed in ssl_cert.c */ DEFINE_LHASH_OF_EX(X509_NAME); # define TLSEXT_KEYNAME_LENGTH 16 # define TLSEXT_TICK_KEY_LENGTH 32 typedef struct ssl_ctx_ext_secure_st { unsigned char tick_hmac_key[TLSEXT_TICK_KEY_LENGTH]; unsigned char tick_aes_key[TLSEXT_TICK_KEY_LENGTH]; } SSL_CTX_EXT_SECURE; /* * Helper function for HMAC * The structure should be considered opaque, it will change once the low * level deprecated calls are removed. At that point it can be replaced * by EVP_MAC_CTX and most of the functions converted to macros or inlined * directly. */ typedef struct ssl_hmac_st { EVP_MAC_CTX *ctx; # ifndef OPENSSL_NO_DEPRECATED_3_0 HMAC_CTX *old_ctx; # endif } SSL_HMAC; SSL_HMAC *ssl_hmac_new(const SSL_CTX *ctx); void ssl_hmac_free(SSL_HMAC *ctx); # ifndef OPENSSL_NO_DEPRECATED_3_0 HMAC_CTX *ssl_hmac_get0_HMAC_CTX(SSL_HMAC *ctx); # endif EVP_MAC_CTX *ssl_hmac_get0_EVP_MAC_CTX(SSL_HMAC *ctx); int ssl_hmac_init(SSL_HMAC *ctx, void *key, size_t len, char *md); int ssl_hmac_update(SSL_HMAC *ctx, const unsigned char *data, size_t len); int ssl_hmac_final(SSL_HMAC *ctx, unsigned char *md, size_t *len, size_t max_size); size_t ssl_hmac_size(const SSL_HMAC *ctx); int ssl_get_EC_curve_nid(const EVP_PKEY *pkey); __owur int tls13_set_encoded_pub_key(EVP_PKEY *pkey, const unsigned char *enckey, size_t enckeylen); typedef struct tls_group_info_st { char *tlsname; /* Curve Name as in TLS specs */ char *realname; /* Curve Name according to provider */ char *algorithm; /* Algorithm name to fetch */ unsigned int secbits; /* Bits of security (from SP800-57) */ uint16_t group_id; /* Group ID */ int mintls; /* Minimum TLS version, -1 unsupported */ int maxtls; /* Maximum TLS version (or 0 for undefined) */ int mindtls; /* Minimum DTLS version, -1 unsupported */ int maxdtls; /* Maximum DTLS version (or 0 for undefined) */ char is_kem; /* Mode for this Group: 0 is KEX, 1 is KEM */ } TLS_GROUP_INFO; typedef struct tls_sigalg_info_st { char *name; /* name as in IANA TLS specs */ uint16_t code_point; /* IANA-specified code point of sigalg-name */ char *sigalg_name; /* (combined) sigalg name */ char *sigalg_oid; /* (combined) sigalg OID */ char *sig_name; /* pure signature algorithm name */ char *sig_oid; /* pure signature algorithm OID */ char *hash_name; /* hash algorithm name */ char *hash_oid; /* hash algorithm OID */ char *keytype; /* keytype name */ char *keytype_oid; /* keytype OID */ unsigned int secbits; /* Bits of security (from SP800-57) */ int mintls; /* Minimum TLS version, -1 unsupported */ int maxtls; /* Maximum TLS version (or 0 for undefined) */ } TLS_SIGALG_INFO; /* * Structure containing table entry of certificate info corresponding to * CERT_PKEY entries */ typedef struct { int nid; /* NID of public key algorithm */ uint32_t amask; /* authmask corresponding to key type */ } SSL_CERT_LOOKUP; /* flags values */ # define TLS_GROUP_TYPE 0x0000000FU /* Mask for group type */ # define TLS_GROUP_CURVE_PRIME 0x00000001U # define TLS_GROUP_CURVE_CHAR2 0x00000002U # define TLS_GROUP_CURVE_CUSTOM 0x00000004U # define TLS_GROUP_FFDHE 0x00000008U # define TLS_GROUP_ONLY_FOR_TLS1_3 0x00000010U # define TLS_GROUP_FFDHE_FOR_TLS1_3 (TLS_GROUP_FFDHE|TLS_GROUP_ONLY_FOR_TLS1_3) struct ssl_ctx_st { OSSL_LIB_CTX *libctx; const SSL_METHOD *method; STACK_OF(SSL_CIPHER) *cipher_list; /* same as above but sorted for lookup */ STACK_OF(SSL_CIPHER) *cipher_list_by_id; /* TLSv1.3 specific ciphersuites */ STACK_OF(SSL_CIPHER) *tls13_ciphersuites; struct x509_store_st /* X509_STORE */ *cert_store; LHASH_OF(SSL_SESSION) *sessions; /* * Most session-ids that will be cached, default is * SSL_SESSION_CACHE_MAX_SIZE_DEFAULT. 0 is unlimited. */ size_t session_cache_size; struct ssl_session_st *session_cache_head; struct ssl_session_st *session_cache_tail; /* * This can have one of 2 values, ored together, SSL_SESS_CACHE_CLIENT, * SSL_SESS_CACHE_SERVER, Default is SSL_SESSION_CACHE_SERVER, which * means only SSL_accept will cache SSL_SESSIONS. */ uint32_t session_cache_mode; /* * If timeout is not 0, it is the default timeout value set when * SSL_new() is called. This has been put in to make life easier to set * things up */ OSSL_TIME session_timeout; /* * If this callback is not null, it will be called each time a session id * is added to the cache. If this function returns 1, it means that the * callback will do a SSL_SESSION_free() when it has finished using it. * Otherwise, on 0, it means the callback has finished with it. If * remove_session_cb is not null, it will be called when a session-id is * removed from the cache. After the call, OpenSSL will * SSL_SESSION_free() it. */ int (*new_session_cb) (struct ssl_st *ssl, SSL_SESSION *sess); void (*remove_session_cb) (struct ssl_ctx_st *ctx, SSL_SESSION *sess); SSL_SESSION *(*get_session_cb) (struct ssl_st *ssl, const unsigned char *data, int len, int *copy); struct { TSAN_QUALIFIER int sess_connect; /* SSL new conn - started */ TSAN_QUALIFIER int sess_connect_renegotiate; /* SSL reneg - requested */ TSAN_QUALIFIER int sess_connect_good; /* SSL new conne/reneg - finished */ TSAN_QUALIFIER int sess_accept; /* SSL new accept - started */ TSAN_QUALIFIER int sess_accept_renegotiate; /* SSL reneg - requested */ TSAN_QUALIFIER int sess_accept_good; /* SSL accept/reneg - finished */ TSAN_QUALIFIER int sess_miss; /* session lookup misses */ TSAN_QUALIFIER int sess_timeout; /* reuse attempt on timeouted session */ TSAN_QUALIFIER int sess_cache_full; /* session removed due to full cache */ TSAN_QUALIFIER int sess_hit; /* session reuse actually done */ TSAN_QUALIFIER int sess_cb_hit; /* session-id that was not in * the cache was passed back via * the callback. This indicates * that the application is * supplying session-id's from * other processes - spooky * :-) */ } stats; #ifdef TSAN_REQUIRES_LOCKING CRYPTO_RWLOCK *tsan_lock; #endif CRYPTO_REF_COUNT references; /* if defined, these override the X509_verify_cert() calls */ int (*app_verify_callback) (X509_STORE_CTX *, void *); void *app_verify_arg; /* * before OpenSSL 0.9.7, 'app_verify_arg' was ignored * ('app_verify_callback' was called with just one argument) */ /* Default password callback. */ pem_password_cb *default_passwd_callback; /* Default password callback user data. */ void *default_passwd_callback_userdata; /* get client cert callback */ int (*client_cert_cb) (SSL *ssl, X509 **x509, EVP_PKEY **pkey); /* cookie generate callback */ int (*app_gen_cookie_cb) (SSL *ssl, unsigned char *cookie, unsigned int *cookie_len); /* verify cookie callback */ int (*app_verify_cookie_cb) (SSL *ssl, const unsigned char *cookie, unsigned int cookie_len); /* TLS1.3 app-controlled cookie generate callback */ int (*gen_stateless_cookie_cb) (SSL *ssl, unsigned char *cookie, size_t *cookie_len); /* TLS1.3 verify app-controlled cookie callback */ int (*verify_stateless_cookie_cb) (SSL *ssl, const unsigned char *cookie, size_t cookie_len); CRYPTO_EX_DATA ex_data; const EVP_MD *md5; /* For SSLv3/TLSv1 'ssl3-md5' */ const EVP_MD *sha1; /* For SSLv3/TLSv1 'ssl3-sha1' */ STACK_OF(X509) *extra_certs; STACK_OF(SSL_COMP) *comp_methods; /* stack of SSL_COMP, SSLv3/TLSv1 */ /* Default values used when no per-SSL value is defined follow */ /* used if SSL's info_callback is NULL */ void (*info_callback) (const SSL *ssl, int type, int val); /* * What we put in certificate_authorities extension for TLS 1.3 * (ClientHello and CertificateRequest) or just client cert requests for * earlier versions. If client_ca_names is populated then it is only used * for client cert requests, and in preference to ca_names. */ STACK_OF(X509_NAME) *ca_names; STACK_OF(X509_NAME) *client_ca_names; /* * Default values to use in SSL structures follow (these are copied by * SSL_new) */ uint64_t options; uint32_t mode; int min_proto_version; int max_proto_version; size_t max_cert_list; struct cert_st /* CERT */ *cert; SSL_CERT_LOOKUP *ssl_cert_info; int read_ahead; /* callback that allows applications to peek at protocol messages */ ossl_msg_cb msg_callback; void *msg_callback_arg; uint32_t verify_mode; size_t sid_ctx_length; unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; /* called 'verify_callback' in the SSL */ int (*default_verify_callback) (int ok, X509_STORE_CTX *ctx); /* Default generate session ID callback. */ GEN_SESSION_CB generate_session_id; X509_VERIFY_PARAM *param; int quiet_shutdown; # ifndef OPENSSL_NO_CT CTLOG_STORE *ctlog_store; /* CT Log Store */ /* * Validates that the SCTs (Signed Certificate Timestamps) are sufficient. * If they are not, the connection should be aborted. */ ssl_ct_validation_cb ct_validation_callback; void *ct_validation_callback_arg; # endif /* * If we're using more than one pipeline how should we divide the data * up between the pipes? */ size_t split_send_fragment; /* * Maximum amount of data to send in one fragment. actual record size can * be more than this due to padding and MAC overheads. */ size_t max_send_fragment; /* Up to how many pipelines should we use? If 0 then 1 is assumed */ size_t max_pipelines; /* The default read buffer length to use (0 means not set) */ size_t default_read_buf_len; # ifndef OPENSSL_NO_ENGINE /* * Engine to pass requests for client certs to */ ENGINE *client_cert_engine; # endif /* ClientHello callback. Mostly for extensions, but not entirely. */ SSL_client_hello_cb_fn client_hello_cb; void *client_hello_cb_arg; /* TLS extensions. */ struct { /* TLS extensions servername callback */ int (*servername_cb) (SSL *, int *, void *); void *servername_arg; /* RFC 4507 session ticket keys */ unsigned char tick_key_name[TLSEXT_KEYNAME_LENGTH]; SSL_CTX_EXT_SECURE *secure; # ifndef OPENSSL_NO_DEPRECATED_3_0 /* Callback to support customisation of ticket key setting */ int (*ticket_key_cb) (SSL *ssl, unsigned char *name, unsigned char *iv, EVP_CIPHER_CTX *ectx, HMAC_CTX *hctx, int enc); #endif int (*ticket_key_evp_cb) (SSL *ssl, unsigned char *name, unsigned char *iv, EVP_CIPHER_CTX *ectx, EVP_MAC_CTX *hctx, int enc); /* certificate status request info */ /* Callback for status request */ int (*status_cb) (SSL *ssl, void *arg); void *status_arg; /* ext status type used for CSR extension (OCSP Stapling) */ int status_type; /* RFC 4366 Maximum Fragment Length Negotiation */ uint8_t max_fragment_len_mode; /* EC extension values inherited by SSL structure */ size_t ecpointformats_len; unsigned char *ecpointformats; size_t supportedgroups_len; uint16_t *supportedgroups; uint16_t *supported_groups_default; size_t supported_groups_default_len; /* * ALPN information (we are in the process of transitioning from NPN to * ALPN.) */ /*- * For a server, this contains a callback function that allows the * server to select the protocol for the connection. * out: on successful return, this must point to the raw protocol * name (without the length prefix). * outlen: on successful return, this contains the length of |*out|. * in: points to the client's list of supported protocols in * wire-format. * inlen: the length of |in|. */ int (*alpn_select_cb) (SSL *s, const unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg); void *alpn_select_cb_arg; /* * For a client, this contains the list of supported protocols in wire * format. */ unsigned char *alpn; size_t alpn_len; # ifndef OPENSSL_NO_NEXTPROTONEG /* Next protocol negotiation information */ /* * For a server, this contains a callback function by which the set of * advertised protocols can be provided. */ SSL_CTX_npn_advertised_cb_func npn_advertised_cb; void *npn_advertised_cb_arg; /* * For a client, this contains a callback function that selects the next * protocol from the list provided by the server. */ SSL_CTX_npn_select_cb_func npn_select_cb; void *npn_select_cb_arg; # endif unsigned char cookie_hmac_key[SHA256_DIGEST_LENGTH]; } ext; # ifndef OPENSSL_NO_PSK SSL_psk_client_cb_func psk_client_callback; SSL_psk_server_cb_func psk_server_callback; # endif SSL_psk_find_session_cb_func psk_find_session_cb; SSL_psk_use_session_cb_func psk_use_session_cb; # ifndef OPENSSL_NO_SRP SRP_CTX srp_ctx; /* ctx for SRP authentication */ # endif /* Shared DANE context */ struct dane_ctx_st dane; # ifndef OPENSSL_NO_SRTP /* SRTP profiles we are willing to do from RFC 5764 */ STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles; # endif /* * Callback for disabling session caching and ticket support on a session * basis, depending on the chosen cipher. */ int (*not_resumable_session_cb) (SSL *ssl, int is_forward_secure); CRYPTO_RWLOCK *lock; /* * Callback for logging key material for use with debugging tools like * Wireshark. The callback should log `line` followed by a newline. */ SSL_CTX_keylog_cb_func keylog_callback; /* * The maximum number of bytes advertised in session tickets that can be * sent as early data. */ uint32_t max_early_data; /* * The maximum number of bytes of early data that a server will tolerate * (which should be at least as much as max_early_data). */ uint32_t recv_max_early_data; /* TLS1.3 padding callback */ size_t (*record_padding_cb)(SSL *s, int type, size_t len, void *arg); void *record_padding_arg; size_t block_padding; /* Session ticket appdata */ SSL_CTX_generate_session_ticket_fn generate_ticket_cb; SSL_CTX_decrypt_session_ticket_fn decrypt_ticket_cb; void *ticket_cb_data; /* The number of TLS1.3 tickets to automatically send */ size_t num_tickets; /* Callback to determine if early_data is acceptable or not */ SSL_allow_early_data_cb_fn allow_early_data_cb; void *allow_early_data_cb_data; /* Do we advertise Post-handshake auth support? */ int pha_enabled; /* Callback for SSL async handling */ SSL_async_callback_fn async_cb; void *async_cb_arg; char *propq; int ssl_mac_pkey_id[SSL_MD_NUM_IDX]; const EVP_CIPHER *ssl_cipher_methods[SSL_ENC_NUM_IDX]; const EVP_MD *ssl_digest_methods[SSL_MD_NUM_IDX]; size_t ssl_mac_secret_size[SSL_MD_NUM_IDX]; size_t tls12_sigalgs_len; /* Cache of all sigalgs we know and whether they are available or not */ struct sigalg_lookup_st *sigalg_lookup_cache; /* List of all sigalgs (code points) available, incl. from providers */ uint16_t *tls12_sigalgs; TLS_GROUP_INFO *group_list; size_t group_list_len; size_t group_list_max_len; TLS_SIGALG_INFO *sigalg_list; size_t sigalg_list_len; size_t sigalg_list_max_len; /* masks of disabled algorithms */ uint32_t disabled_enc_mask; uint32_t disabled_mac_mask; uint32_t disabled_mkey_mask; uint32_t disabled_auth_mask; #ifndef OPENSSL_NO_COMP_ALG /* certificate compression preferences */ int cert_comp_prefs[TLSEXT_comp_cert_limit]; #endif /* Certificate Type stuff - for RPK vs X.509 */ unsigned char *client_cert_type; size_t client_cert_type_len; unsigned char *server_cert_type; size_t server_cert_type_len; }; typedef struct cert_pkey_st CERT_PKEY; #define SSL_TYPE_SSL_CONNECTION 0 #define SSL_TYPE_QUIC_CONNECTION 1 #define SSL_TYPE_QUIC_XSO 2 struct ssl_st { int type; SSL_CTX *ctx; const SSL_METHOD *defltmeth; const SSL_METHOD *method; CRYPTO_REF_COUNT references; CRYPTO_RWLOCK *lock; /* extra application data */ CRYPTO_EX_DATA ex_data; }; struct ssl_connection_st { /* type identifier and common data */ struct ssl_st ssl; /* * protocol version (one of SSL2_VERSION, SSL3_VERSION, TLS1_VERSION, * DTLS1_VERSION) */ int version; /* * There are 2 BIO's even though they are normally both the same. This * is so data can be read and written to different handlers */ /* used by SSL_read */ BIO *rbio; /* used by SSL_write */ BIO *wbio; /* used during session-id reuse to concatenate messages */ BIO *bbio; /* * This holds a variable that indicates what we were doing when a 0 or -1 * is returned. This is needed for non-blocking IO so we know what * request needs re-doing when in SSL_accept or SSL_connect */ int rwstate; int (*handshake_func) (SSL *); /* * Imagine that here's a boolean member "init" that is switched as soon * as SSL_set_{accept/connect}_state is called for the first time, so * that "state" and "handshake_func" are properly initialized. But as * handshake_func is == 0 until then, we use this test instead of an * "init" member. */ /* are we the server side? */ int server; /* * Generate a new session or reuse an old one. * NB: For servers, the 'new' session may actually be a previously * cached session or even the previous session unless * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION is set */ int new_session; /* don't send shutdown packets */ int quiet_shutdown; /* we have shut things down, 0x01 sent, 0x02 for received */ int shutdown; /* Timestamps used to calculate the handshake RTT */ OSSL_TIME ts_msg_write; OSSL_TIME ts_msg_read; /* where we are */ OSSL_STATEM statem; SSL_EARLY_DATA_STATE early_data_state; BUF_MEM *init_buf; /* buffer used during init */ void *init_msg; /* pointer to handshake message body, set by * tls_get_message_header() */ size_t init_num; /* amount read/written */ size_t init_off; /* amount read/written */ size_t ssl_pkey_num; struct { long flags; unsigned char server_random[SSL3_RANDOM_SIZE]; unsigned char client_random[SSL3_RANDOM_SIZE]; /* used during startup, digest all incoming/outgoing packets */ BIO *handshake_buffer; /* * When handshake digest is determined, buffer is hashed and * freed and MD_CTX for the required digest is stored here. */ EVP_MD_CTX *handshake_dgst; /* * Set whenever an expected ChangeCipherSpec message is processed. * Unset when the peer's Finished message is received. * Unexpected ChangeCipherSpec messages trigger a fatal alert. */ int change_cipher_spec; int warn_alert; int fatal_alert; /* * we allow one fatal and one warning alert to be outstanding, send close * alert via the warning alert */ int alert_dispatch; unsigned char send_alert[2]; /* * This flag is set when we should renegotiate ASAP, basically when there * is no more data in the read or write buffers */ int renegotiate; int total_renegotiations; int num_renegotiations; int in_read_app_data; struct { /* actually only need to be 16+20 for SSLv3 and 12 for TLS */ unsigned char finish_md[EVP_MAX_MD_SIZE * 2]; size_t finish_md_len; unsigned char peer_finish_md[EVP_MAX_MD_SIZE * 2]; size_t peer_finish_md_len; size_t message_size; int message_type; /* used to hold the new cipher we are going to use */ const SSL_CIPHER *new_cipher; EVP_PKEY *pkey; /* holds short lived key exchange key */ /* used for certificate requests */ int cert_req; /* Certificate types in certificate request message. */ uint8_t *ctype; size_t ctype_len; /* Certificate authorities list peer sent */ STACK_OF(X509_NAME) *peer_ca_names; size_t key_block_length; unsigned char *key_block; const EVP_CIPHER *new_sym_enc; const EVP_MD *new_hash; int new_mac_pkey_type; size_t new_mac_secret_size; # ifndef OPENSSL_NO_COMP const SSL_COMP *new_compression; # else char *new_compression; # endif int cert_request; /* Raw values of the cipher list from a client */ unsigned char *ciphers_raw; size_t ciphers_rawlen; /* Temporary storage for premaster secret */ unsigned char *pms; size_t pmslen; # ifndef OPENSSL_NO_PSK /* Temporary storage for PSK key */ unsigned char *psk; size_t psklen; # endif /* Signature algorithm we actually use */ const struct sigalg_lookup_st *sigalg; /* Pointer to certificate we use */ CERT_PKEY *cert; /* * signature algorithms peer reports: e.g. supported signature * algorithms extension for server or as part of a certificate * request for client. * Keep track of the algorithms for TLS and X.509 usage separately. */ uint16_t *peer_sigalgs; uint16_t *peer_cert_sigalgs; /* Size of above arrays */ size_t peer_sigalgslen; size_t peer_cert_sigalgslen; /* Sigalg peer actually uses */ const struct sigalg_lookup_st *peer_sigalg; /* * Set if corresponding CERT_PKEY can be used with current * SSL session: e.g. appropriate curve, signature algorithms etc. * If zero it can't be used at all. */ uint32_t *valid_flags; /* * For servers the following masks are for the key and auth algorithms * that are supported by the certs below. For clients they are masks of * *disabled* algorithms based on the current session. */ uint32_t mask_k; uint32_t mask_a; /* * The following are used by the client to see if a cipher is allowed or * not. It contains the minimum and maximum version the client's using * based on what it knows so far. */ int min_ver; int max_ver; } tmp; /* Connection binding to prevent renegotiation attacks */ unsigned char previous_client_finished[EVP_MAX_MD_SIZE]; size_t previous_client_finished_len; unsigned char previous_server_finished[EVP_MAX_MD_SIZE]; size_t previous_server_finished_len; int send_connection_binding; # ifndef OPENSSL_NO_NEXTPROTONEG /* * Set if we saw the Next Protocol Negotiation extension from our peer. */ int npn_seen; # endif /* * ALPN information (we are in the process of transitioning from NPN to * ALPN.) */ /* * In a server these point to the selected ALPN protocol after the * ClientHello has been processed. In a client these contain the protocol * that the server selected once the ServerHello has been processed. */ unsigned char *alpn_selected; size_t alpn_selected_len; /* used by the server to know what options were proposed */ unsigned char *alpn_proposed; size_t alpn_proposed_len; /* used by the client to know if it actually sent alpn */ int alpn_sent; /* * This is set to true if we believe that this is a version of Safari * running on OS X 10.6 or newer. We wish to know this because Safari on * 10.8 .. 10.8.3 has broken ECDHE-ECDSA support. */ char is_probably_safari; /* * Track whether we did a key exchange this handshake or not, so * SSL_get_negotiated_group() knows whether to fall back to the * value in the SSL_SESSION. */ char did_kex; /* For clients: peer temporary key */ /* The group_id for the key exchange key */ uint16_t group_id; EVP_PKEY *peer_tmp; } s3; struct dtls1_state_st *d1; /* DTLSv1 variables */ /* callback that allows applications to peek at protocol messages */ void (*msg_callback) (int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg); void *msg_callback_arg; int hit; /* reusing a previous session */ X509_VERIFY_PARAM *param; /* Per connection DANE state */ SSL_DANE dane; /* crypto */ STACK_OF(SSL_CIPHER) *peer_ciphers; STACK_OF(SSL_CIPHER) *cipher_list; STACK_OF(SSL_CIPHER) *cipher_list_by_id; /* TLSv1.3 specific ciphersuites */ STACK_OF(SSL_CIPHER) *tls13_ciphersuites; /* * These are the ones being used, the ones in SSL_SESSION are the ones to * be 'copied' into these ones */ uint32_t mac_flags; /* * The TLS1.3 secrets. */ unsigned char early_secret[EVP_MAX_MD_SIZE]; unsigned char handshake_secret[EVP_MAX_MD_SIZE]; unsigned char master_secret[EVP_MAX_MD_SIZE]; unsigned char resumption_master_secret[EVP_MAX_MD_SIZE]; unsigned char client_finished_secret[EVP_MAX_MD_SIZE]; unsigned char server_finished_secret[EVP_MAX_MD_SIZE]; unsigned char server_finished_hash[EVP_MAX_MD_SIZE]; unsigned char handshake_traffic_hash[EVP_MAX_MD_SIZE]; unsigned char client_app_traffic_secret[EVP_MAX_MD_SIZE]; unsigned char server_app_traffic_secret[EVP_MAX_MD_SIZE]; unsigned char exporter_master_secret[EVP_MAX_MD_SIZE]; unsigned char early_exporter_master_secret[EVP_MAX_MD_SIZE]; /* session info */ /* client cert? */ /* This is used to hold the server certificate used */ struct cert_st /* CERT */ *cert; /* * The hash of all messages prior to the CertificateVerify, and the length * of that hash. */ unsigned char cert_verify_hash[EVP_MAX_MD_SIZE]; size_t cert_verify_hash_len; /* Flag to indicate whether we should send a HelloRetryRequest or not */ enum {SSL_HRR_NONE = 0, SSL_HRR_PENDING, SSL_HRR_COMPLETE} hello_retry_request; /* * the session_id_context is used to ensure sessions are only reused in * the appropriate context */ size_t sid_ctx_length; unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH]; /* This can also be in the session once a session is established */ SSL_SESSION *session; /* TLSv1.3 PSK session */ SSL_SESSION *psksession; unsigned char *psksession_id; size_t psksession_id_len; /* Default generate session ID callback. */ GEN_SESSION_CB generate_session_id; /* * The temporary TLSv1.3 session id. This isn't really a session id at all * but is a random value sent in the legacy session id field. */ unsigned char tmp_session_id[SSL_MAX_SSL_SESSION_ID_LENGTH]; size_t tmp_session_id_len; /* Used in SSL3 */ /* * 0 don't care about verify failure. * 1 fail if verify fails */ uint32_t verify_mode; /* fail if callback returns 0 */ int (*verify_callback) (int ok, X509_STORE_CTX *ctx); /* optional informational callback */ void (*info_callback) (const SSL *ssl, int type, int val); /* error bytes to be written */ int error; /* actual code */ int error_code; # ifndef OPENSSL_NO_PSK SSL_psk_client_cb_func psk_client_callback; SSL_psk_server_cb_func psk_server_callback; # endif SSL_psk_find_session_cb_func psk_find_session_cb; SSL_psk_use_session_cb_func psk_use_session_cb; /* Verified chain of peer */ STACK_OF(X509) *verified_chain; long verify_result; /* * What we put in certificate_authorities extension for TLS 1.3 * (ClientHello and CertificateRequest) or just client cert requests for * earlier versions. If client_ca_names is populated then it is only used * for client cert requests, and in preference to ca_names. */ STACK_OF(X509_NAME) *ca_names; STACK_OF(X509_NAME) *client_ca_names; /* protocol behaviour */ uint64_t options; /* API behaviour */ uint32_t mode; int min_proto_version; int max_proto_version; size_t max_cert_list; int first_packet; /* * What was passed in ClientHello.legacy_version. Used for RSA pre-master * secret and SSLv3/TLS (<=1.2) rollback check */ int client_version; /* * If we're using more than one pipeline how should we divide the data * up between the pipes? */ size_t split_send_fragment; /* * Maximum amount of data to send in one fragment. actual record size can * be more than this due to padding and MAC overheads. */ size_t max_send_fragment; /* Up to how many pipelines should we use? If 0 then 1 is assumed */ size_t max_pipelines; struct { /* Built-in extension flags */ uint8_t extflags[TLSEXT_IDX_num_builtins]; /* TLS extension debug callback */ void (*debug_cb)(SSL *s, int client_server, int type, const unsigned char *data, int len, void *arg); void *debug_arg; char *hostname; /* certificate status request info */ /* Status type or -1 if no status type */ int status_type; /* Raw extension data, if seen */ unsigned char *scts; /* Length of raw extension data, if seen */ uint16_t scts_len; /* Expect OCSP CertificateStatus message */ int status_expected; struct { /* OCSP status request only */ STACK_OF(OCSP_RESPID) *ids; X509_EXTENSIONS *exts; /* OCSP response received or to be sent */ unsigned char *resp; size_t resp_len; } ocsp; /* RFC4507 session ticket expected to be received or sent */ int ticket_expected; /* TLS 1.3 tickets requested by the application. */ int extra_tickets_expected; size_t ecpointformats_len; /* our list */ unsigned char *ecpointformats; size_t peer_ecpointformats_len; /* peer's list */ unsigned char *peer_ecpointformats; size_t supportedgroups_len; /* our list */ uint16_t *supportedgroups; size_t peer_supportedgroups_len; /* peer's list */ uint16_t *peer_supportedgroups; /* TLS Session Ticket extension override */ TLS_SESSION_TICKET_EXT *session_ticket; /* TLS Session Ticket extension callback */ tls_session_ticket_ext_cb_fn session_ticket_cb; void *session_ticket_cb_arg; /* TLS pre-shared secret session resumption */ tls_session_secret_cb_fn session_secret_cb; void *session_secret_cb_arg; /* * For a client, this contains the list of supported protocols in wire * format. */ unsigned char *alpn; size_t alpn_len; /* * Next protocol negotiation. For the client, this is the protocol that * we sent in NextProtocol and is set when handling ServerHello * extensions. For a server, this is the client's selected_protocol from * NextProtocol and is set when handling the NextProtocol message, before * the Finished message. */ unsigned char *npn; size_t npn_len; /* The available PSK key exchange modes */ int psk_kex_mode; /* Set to one if we have negotiated ETM */ int use_etm; /* Are we expecting to receive early data? */ int early_data; /* Is the session suitable for early data? */ int early_data_ok; /* May be sent by a server in HRR. Must be echoed back in ClientHello */ unsigned char *tls13_cookie; size_t tls13_cookie_len; /* Have we received a cookie from the client? */ int cookieok; /* * Maximum Fragment Length as per RFC 4366. * If this member contains one of the allowed values (1-4) * then we should include Maximum Fragment Length Negotiation * extension in Client Hello. * Please note that value of this member does not have direct * effect. The actual (binding) value is stored in SSL_SESSION, * as this extension is optional on server side. */ uint8_t max_fragment_len_mode; /* * On the client side the number of ticket identities we sent in the * ClientHello. On the server side the identity of the ticket we * selected. */ int tick_identity; /* This is the list of algorithms the peer supports that we also support */ int compress_certificate_from_peer[TLSEXT_comp_cert_limit]; /* indicate that we sent the extension, so we'll accept it */ int compress_certificate_sent; uint8_t client_cert_type; uint8_t client_cert_type_ctos; uint8_t server_cert_type; uint8_t server_cert_type_ctos; } ext; /* * Parsed form of the ClientHello, kept around across client_hello_cb * calls. */ CLIENTHELLO_MSG *clienthello; /*- * no further mod of servername * 0 : call the servername extension callback. * 1 : prepare 2, allow last ack just after in server callback. * 2 : don't call servername callback, no ack in server hello */ int servername_done; # ifndef OPENSSL_NO_CT /* * Validates that the SCTs (Signed Certificate Timestamps) are sufficient. * If they are not, the connection should be aborted. */ ssl_ct_validation_cb ct_validation_callback; /* User-supplied argument that is passed to the ct_validation_callback */ void *ct_validation_callback_arg; /* * Consolidated stack of SCTs from all sources. * Lazily populated by CT_get_peer_scts(SSL*) */ STACK_OF(SCT) *scts; /* Have we attempted to find/parse SCTs yet? */ int scts_parsed; # endif SSL_CTX *session_ctx; /* initial ctx, used to store sessions */ # ifndef OPENSSL_NO_SRTP /* What we'll do */ STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles; /* What's been chosen */ SRTP_PROTECTION_PROFILE *srtp_profile; # endif /*- * 1 if we are renegotiating. * 2 if we are a server and are inside a handshake * (i.e. not just sending a HelloRequest) */ int renegotiate; /* If sending a KeyUpdate is pending */ int key_update; /* Post-handshake authentication state */ SSL_PHA_STATE post_handshake_auth; int pha_enabled; uint8_t* pha_context; size_t pha_context_len; int certreqs_sent; EVP_MD_CTX *pha_dgst; /* this is just the digest through ClientFinished */ # ifndef OPENSSL_NO_SRP /* ctx for SRP authentication */ SRP_CTX srp_ctx; # endif /* * Callback for disabling session caching and ticket support on a session * basis, depending on the chosen cipher. */ int (*not_resumable_session_cb) (SSL *ssl, int is_forward_secure); /* Record layer data */ RECORD_LAYER rlayer; /* Default password callback. */ pem_password_cb *default_passwd_callback; /* Default password callback user data. */ void *default_passwd_callback_userdata; /* Async Job info */ ASYNC_JOB *job; ASYNC_WAIT_CTX *waitctx; size_t asyncrw; /* * The maximum number of bytes advertised in session tickets that can be * sent as early data. */ uint32_t max_early_data; /* * The maximum number of bytes of early data that a server will tolerate * (which should be at least as much as max_early_data). */ uint32_t recv_max_early_data; /* * The number of bytes of early data received so far. If we accepted early * data then this is a count of the plaintext bytes. If we rejected it then * this is a count of the ciphertext bytes. */ uint32_t early_data_count; /* The number of TLS1.3 tickets to automatically send */ size_t num_tickets; /* The number of TLS1.3 tickets actually sent so far */ size_t sent_tickets; /* The next nonce value to use when we send a ticket on this connection */ uint64_t next_ticket_nonce; /* Callback to determine if early_data is acceptable or not */ SSL_allow_early_data_cb_fn allow_early_data_cb; void *allow_early_data_cb_data; /* Callback for SSL async handling */ SSL_async_callback_fn async_cb; void *async_cb_arg; /* * Signature algorithms shared by client and server: cached because these * are used most often. */ const struct sigalg_lookup_st **shared_sigalgs; size_t shared_sigalgslen; #ifndef OPENSSL_NO_COMP_ALG /* certificate compression preferences */ int cert_comp_prefs[TLSEXT_comp_cert_limit]; #endif /* Certificate Type stuff - for RPK vs X.509 */ unsigned char *client_cert_type; size_t client_cert_type_len; unsigned char *server_cert_type; size_t server_cert_type_len; }; # define SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, c) \ ((ssl) == NULL ? NULL \ : ((ssl)->type == SSL_TYPE_SSL_CONNECTION \ ? (c SSL_CONNECTION *)(ssl) \ : NULL)) # define SSL_CONNECTION_NO_CONST # define SSL_CONNECTION_FROM_SSL_ONLY(ssl) \ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, SSL_CONNECTION_NO_CONST) # define SSL_CONNECTION_FROM_CONST_SSL_ONLY(ssl) \ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, const) # define SSL_CONNECTION_GET_CTX(sc) ((sc)->ssl.ctx) # define SSL_CONNECTION_GET_SSL(sc) (&(sc)->ssl) # ifndef OPENSSL_NO_QUIC # include "quic/quic_local.h" # define SSL_CONNECTION_FROM_SSL_int(ssl, c) \ ((ssl) == NULL ? NULL \ : ((ssl)->type == SSL_TYPE_SSL_CONNECTION \ ? (c SSL_CONNECTION *)(ssl) \ : ((ssl)->type == SSL_TYPE_QUIC_CONNECTION \ ? (c SSL_CONNECTION *)((c QUIC_CONNECTION *)(ssl))->tls \ : NULL))) # define SSL_CONNECTION_FROM_SSL(ssl) \ SSL_CONNECTION_FROM_SSL_int(ssl, SSL_CONNECTION_NO_CONST) # define SSL_CONNECTION_FROM_CONST_SSL(ssl) \ SSL_CONNECTION_FROM_SSL_int(ssl, const) # else # define SSL_CONNECTION_FROM_SSL(ssl) \ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, SSL_CONNECTION_NO_CONST) # define SSL_CONNECTION_FROM_CONST_SSL(ssl) \ SSL_CONNECTION_FROM_SSL_ONLY_int(ssl, const) # endif /* * Structure containing table entry of values associated with the signature * algorithms (signature scheme) extension */ typedef struct sigalg_lookup_st { /* TLS 1.3 signature scheme name */ const char *name; /* Raw value used in extension */ uint16_t sigalg; /* NID of hash algorithm or NID_undef if no hash */ int hash; /* Index of hash algorithm or -1 if no hash algorithm */ int hash_idx; /* NID of signature algorithm */ int sig; /* Index of signature algorithm */ int sig_idx; /* Combined hash and signature NID, if any */ int sigandhash; /* Required public key curve (ECDSA only) */ int curve; /* Whether this signature algorithm is actually available for use */ int enabled; } SIGALG_LOOKUP; /* DTLS structures */ # ifndef OPENSSL_NO_SCTP # define DTLS1_SCTP_AUTH_LABEL "EXPORTER_DTLS_OVER_SCTP" # endif /* Max MTU overhead we know about so far is 40 for IPv6 + 8 for UDP */ # define DTLS1_MAX_MTU_OVERHEAD 48 /* * Flag used in message reuse to indicate the buffer contains the record * header as well as the handshake message header. */ # define DTLS1_SKIP_RECORD_HEADER 2 struct dtls1_retransmit_state { const OSSL_RECORD_METHOD *wrlmethod; OSSL_RECORD_LAYER *wrl; }; struct hm_header_st { unsigned char type; size_t msg_len; unsigned short seq; size_t frag_off; size_t frag_len; unsigned int is_ccs; struct dtls1_retransmit_state saved_retransmit_state; }; typedef struct hm_fragment_st { struct hm_header_st msg_header; unsigned char *fragment; unsigned char *reassembly; } hm_fragment; typedef struct pqueue_st pqueue; typedef struct pitem_st pitem; struct pitem_st { unsigned char priority[8]; /* 64-bit value in big-endian encoding */ void *data; pitem *next; }; typedef struct pitem_st *piterator; pitem *pitem_new(unsigned char *prio64be, void *data); void pitem_free(pitem *item); pqueue *pqueue_new(void); void pqueue_free(pqueue *pq); pitem *pqueue_insert(pqueue *pq, pitem *item); pitem *pqueue_peek(pqueue *pq); pitem *pqueue_pop(pqueue *pq); pitem *pqueue_find(pqueue *pq, unsigned char *prio64be); pitem *pqueue_iterator(pqueue *pq); pitem *pqueue_next(piterator *iter); size_t pqueue_size(pqueue *pq); typedef struct dtls1_state_st { unsigned char cookie[DTLS1_COOKIE_LENGTH]; size_t cookie_len; unsigned int cookie_verified; /* handshake message numbers */ unsigned short handshake_write_seq; unsigned short next_handshake_write_seq; unsigned short handshake_read_seq; /* Buffered handshake messages */ pqueue *buffered_messages; /* Buffered (sent) handshake records */ pqueue *sent_messages; size_t link_mtu; /* max on-the-wire DTLS packet size */ size_t mtu; /* max DTLS packet size */ struct hm_header_st w_msg_hdr; struct hm_header_st r_msg_hdr; /* Number of alerts received so far */ unsigned int timeout_num_alerts; /* * Indicates when the last handshake msg sent will timeout */ OSSL_TIME next_timeout; /* Timeout duration */ unsigned int timeout_duration_us; unsigned int retransmitting; # ifndef OPENSSL_NO_SCTP int shutdown_received; # endif DTLS_timer_cb timer_cb; } DTLS1_STATE; /* * From ECC-TLS draft, used in encoding the curve type in ECParameters */ # define EXPLICIT_PRIME_CURVE_TYPE 1 # define EXPLICIT_CHAR2_CURVE_TYPE 2 # define NAMED_CURVE_TYPE 3 # ifndef OPENSSL_NO_COMP_ALG struct ossl_comp_cert_st { unsigned char *data; size_t len; size_t orig_len; CRYPTO_REF_COUNT references; int alg; }; typedef struct ossl_comp_cert_st OSSL_COMP_CERT; void OSSL_COMP_CERT_free(OSSL_COMP_CERT *c); int OSSL_COMP_CERT_up_ref(OSSL_COMP_CERT *c); # endif struct cert_pkey_st { X509 *x509; EVP_PKEY *privatekey; /* Chain for this certificate */ STACK_OF(X509) *chain; /*- * serverinfo data for this certificate. The data is in TLS Extension * wire format, specifically it's a series of records like: * uint16_t extension_type; // (RFC 5246, 7.4.1.4, Extension) * uint16_t length; * uint8_t data[length]; */ unsigned char *serverinfo; size_t serverinfo_length; # ifndef OPENSSL_NO_COMP_ALG /* Compressed certificate data - index 0 is unused */ OSSL_COMP_CERT *comp_cert[TLSEXT_comp_cert_limit]; int cert_comp_used; # endif }; /* Retrieve Suite B flags */ # define tls1_suiteb(s) (s->cert->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS) /* Uses to check strict mode: suite B modes are always strict */ # define SSL_CERT_FLAGS_CHECK_TLS_STRICT \ (SSL_CERT_FLAG_SUITEB_128_LOS|SSL_CERT_FLAG_TLS_STRICT) typedef enum { ENDPOINT_CLIENT = 0, ENDPOINT_SERVER, ENDPOINT_BOTH } ENDPOINT; typedef struct { unsigned short ext_type; ENDPOINT role; /* The context which this extension applies to */ unsigned int context; /* * Per-connection flags relating to this extension type: not used if * part of an SSL_CTX structure. */ uint32_t ext_flags; SSL_custom_ext_add_cb_ex add_cb; SSL_custom_ext_free_cb_ex free_cb; void *add_arg; SSL_custom_ext_parse_cb_ex parse_cb; void *parse_arg; } custom_ext_method; /* ext_flags values */ /* * Indicates an extension has been received. Used to check for unsolicited or * duplicate extensions. */ # define SSL_EXT_FLAG_RECEIVED 0x1 /* * Indicates an extension has been sent: used to enable sending of * corresponding ServerHello extension. */ # define SSL_EXT_FLAG_SENT 0x2 typedef struct { custom_ext_method *meths; size_t meths_count; } custom_ext_methods; typedef struct cert_st { /* Current active set */ /* * ALWAYS points to an element of the pkeys array * Probably it would make more sense to store * an index, not a pointer. */ CERT_PKEY *key; EVP_PKEY *dh_tmp; DH *(*dh_tmp_cb) (SSL *ssl, int is_export, int keysize); int dh_tmp_auto; /* Flags related to certificates */ uint32_t cert_flags; CERT_PKEY *pkeys; size_t ssl_pkey_num; /* Custom certificate types sent in certificate request message. */ uint8_t *ctype; size_t ctype_len; /* * supported signature algorithms. When set on a client this is sent in * the client hello as the supported signature algorithms extension. For * servers it represents the signature algorithms we are willing to use. */ uint16_t *conf_sigalgs; /* Size of above array */ size_t conf_sigalgslen; /* * Client authentication signature algorithms, if not set then uses * conf_sigalgs. On servers these will be the signature algorithms sent * to the client in a certificate request for TLS 1.2. On a client this * represents the signature algorithms we are willing to use for client * authentication. */ uint16_t *client_sigalgs; /* Size of above array */ size_t client_sigalgslen; /* * Certificate setup callback: if set is called whenever a certificate * may be required (client or server). the callback can then examine any * appropriate parameters and setup any certificates required. This * allows advanced applications to select certificates on the fly: for * example based on supported signature algorithms or curves. */ int (*cert_cb) (SSL *ssl, void *arg); void *cert_cb_arg; /* * Optional X509_STORE for chain building or certificate validation If * NULL the parent SSL_CTX store is used instead. */ X509_STORE *chain_store; X509_STORE *verify_store; /* Custom extensions */ custom_ext_methods custext; /* Security callback */ int (*sec_cb) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex); /* Security level */ int sec_level; void *sec_ex; # ifndef OPENSSL_NO_PSK /* If not NULL psk identity hint to use for servers */ char *psk_identity_hint; # endif CRYPTO_REF_COUNT references; /* >1 only if SSL_copy_session_id is used */ } CERT; # define FP_ICC (int (*)(const void *,const void *)) /* * This is for the SSLv3/TLSv1.0 differences in crypto/hash stuff It is a bit * of a mess of functions, but hell, think of it as an opaque structure :-) */ typedef struct ssl3_enc_method { int (*setup_key_block) (SSL_CONNECTION *); int (*generate_master_secret) (SSL_CONNECTION *, unsigned char *, unsigned char *, size_t, size_t *); int (*change_cipher_state) (SSL_CONNECTION *, int); size_t (*final_finish_mac) (SSL_CONNECTION *, const char *, size_t, unsigned char *); const char *client_finished_label; size_t client_finished_label_len; const char *server_finished_label; size_t server_finished_label_len; int (*alert_value) (int); int (*export_keying_material) (SSL_CONNECTION *, unsigned char *, size_t, const char *, size_t, const unsigned char *, size_t, int use_context); /* Various flags indicating protocol version requirements */ uint32_t enc_flags; /* Set the handshake header */ int (*set_handshake_header) (SSL_CONNECTION *s, WPACKET *pkt, int type); /* Close construction of the handshake message */ int (*close_construct_packet) (SSL_CONNECTION *s, WPACKET *pkt, int htype); /* Write out handshake message */ int (*do_write) (SSL_CONNECTION *s); } SSL3_ENC_METHOD; # define ssl_set_handshake_header(s, pkt, htype) \ SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->set_handshake_header((s), (pkt), (htype)) # define ssl_close_construct_packet(s, pkt, htype) \ SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->close_construct_packet((s), (pkt), (htype)) # define ssl_do_write(s) SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->do_write(s) /* Values for enc_flags */ /* Uses explicit IV for CBC mode */ # define SSL_ENC_FLAG_EXPLICIT_IV 0x1 /* Uses signature algorithms extension */ # define SSL_ENC_FLAG_SIGALGS 0x2 /* Uses SHA256 default PRF */ # define SSL_ENC_FLAG_SHA256_PRF 0x4 /* Is DTLS */ # define SSL_ENC_FLAG_DTLS 0x8 /* * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may * apply to others in future. */ # define SSL_ENC_FLAG_TLS1_2_CIPHERS 0x10 typedef enum downgrade_en { DOWNGRADE_NONE, DOWNGRADE_TO_1_2, DOWNGRADE_TO_1_1 } DOWNGRADE; /* * Dummy status type for the status_type extension. Indicates no status type * set */ #define TLSEXT_STATUSTYPE_nothing -1 /* Sigalgs values */ #define TLSEXT_SIGALG_ecdsa_secp256r1_sha256 0x0403 #define TLSEXT_SIGALG_ecdsa_secp384r1_sha384 0x0503 #define TLSEXT_SIGALG_ecdsa_secp521r1_sha512 0x0603 #define TLSEXT_SIGALG_ecdsa_sha224 0x0303 #define TLSEXT_SIGALG_ecdsa_sha1 0x0203 #define TLSEXT_SIGALG_rsa_pss_rsae_sha256 0x0804 #define TLSEXT_SIGALG_rsa_pss_rsae_sha384 0x0805 #define TLSEXT_SIGALG_rsa_pss_rsae_sha512 0x0806 #define TLSEXT_SIGALG_rsa_pss_pss_sha256 0x0809 #define TLSEXT_SIGALG_rsa_pss_pss_sha384 0x080a #define TLSEXT_SIGALG_rsa_pss_pss_sha512 0x080b #define TLSEXT_SIGALG_rsa_pkcs1_sha256 0x0401 #define TLSEXT_SIGALG_rsa_pkcs1_sha384 0x0501 #define TLSEXT_SIGALG_rsa_pkcs1_sha512 0x0601 #define TLSEXT_SIGALG_rsa_pkcs1_sha224 0x0301 #define TLSEXT_SIGALG_rsa_pkcs1_sha1 0x0201 #define TLSEXT_SIGALG_dsa_sha256 0x0402 #define TLSEXT_SIGALG_dsa_sha384 0x0502 #define TLSEXT_SIGALG_dsa_sha512 0x0602 #define TLSEXT_SIGALG_dsa_sha224 0x0302 #define TLSEXT_SIGALG_dsa_sha1 0x0202 #define TLSEXT_SIGALG_gostr34102012_256_intrinsic 0x0840 #define TLSEXT_SIGALG_gostr34102012_512_intrinsic 0x0841 #define TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256 0xeeee #define TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512 0xefef #define TLSEXT_SIGALG_gostr34102001_gostr3411 0xeded #define TLSEXT_SIGALG_ed25519 0x0807 #define TLSEXT_SIGALG_ed448 0x0808 #define TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256 0x081a #define TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384 0x081b #define TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512 0x081c /* Known PSK key exchange modes */ #define TLSEXT_KEX_MODE_KE 0x00 #define TLSEXT_KEX_MODE_KE_DHE 0x01 /* * Internal representations of key exchange modes */ #define TLSEXT_KEX_MODE_FLAG_NONE 0 #define TLSEXT_KEX_MODE_FLAG_KE 1 #define TLSEXT_KEX_MODE_FLAG_KE_DHE 2 #define SSL_USE_PSS(s) (s->s3.tmp.peer_sigalg != NULL && \ s->s3.tmp.peer_sigalg->sig == EVP_PKEY_RSA_PSS) /* A dummy signature value not valid for TLSv1.2 signature algs */ #define TLSEXT_signature_rsa_pss 0x0101 /* TLSv1.3 downgrade protection sentinel values */ extern const unsigned char tls11downgrade[8]; extern const unsigned char tls12downgrade[8]; extern SSL3_ENC_METHOD ssl3_undef_enc_method; __owur const SSL_METHOD *ssl_bad_method(int ver); __owur const SSL_METHOD *sslv3_method(void); __owur const SSL_METHOD *sslv3_server_method(void); __owur const SSL_METHOD *sslv3_client_method(void); __owur const SSL_METHOD *tlsv1_method(void); __owur const SSL_METHOD *tlsv1_server_method(void); __owur const SSL_METHOD *tlsv1_client_method(void); __owur const SSL_METHOD *tlsv1_1_method(void); __owur const SSL_METHOD *tlsv1_1_server_method(void); __owur const SSL_METHOD *tlsv1_1_client_method(void); __owur const SSL_METHOD *tlsv1_2_method(void); __owur const SSL_METHOD *tlsv1_2_server_method(void); __owur const SSL_METHOD *tlsv1_2_client_method(void); __owur const SSL_METHOD *tlsv1_3_method(void); __owur const SSL_METHOD *tlsv1_3_server_method(void); __owur const SSL_METHOD *tlsv1_3_client_method(void); __owur const SSL_METHOD *dtlsv1_method(void); __owur const SSL_METHOD *dtlsv1_server_method(void); __owur const SSL_METHOD *dtlsv1_client_method(void); __owur const SSL_METHOD *dtls_bad_ver_client_method(void); __owur const SSL_METHOD *dtlsv1_2_method(void); __owur const SSL_METHOD *dtlsv1_2_server_method(void); __owur const SSL_METHOD *dtlsv1_2_client_method(void); extern const SSL3_ENC_METHOD TLSv1_enc_data; extern const SSL3_ENC_METHOD TLSv1_1_enc_data; extern const SSL3_ENC_METHOD TLSv1_2_enc_data; extern const SSL3_ENC_METHOD TLSv1_3_enc_data; extern const SSL3_ENC_METHOD SSLv3_enc_data; extern const SSL3_ENC_METHOD DTLSv1_enc_data; extern const SSL3_ENC_METHOD DTLSv1_2_enc_data; /* * Flags for SSL methods */ # define SSL_METHOD_NO_FIPS (1U<<0) # define SSL_METHOD_NO_SUITEB (1U<<1) # define IMPLEMENT_tls_meth_func(version, flags, mask, func_name, s_accept, \ s_connect, enc_data) \ const SSL_METHOD *func_name(void) \ { \ static const SSL_METHOD func_name##_data= { \ version, \ flags, \ mask, \ ossl_ssl_connection_new, \ ossl_ssl_connection_free, \ ossl_ssl_connection_reset, \ tls1_new, \ tls1_clear, \ tls1_free, \ s_accept, \ s_connect, \ ssl3_read, \ ssl3_peek, \ ssl3_write, \ ssl3_shutdown, \ ssl3_renegotiate, \ ssl3_renegotiate_check, \ ssl3_read_bytes, \ ssl3_write_bytes, \ ssl3_dispatch_alert, \ ssl3_ctrl, \ ssl3_ctx_ctrl, \ ssl3_get_cipher_by_char, \ ssl3_put_cipher_by_char, \ ssl3_pending, \ ssl3_num_ciphers, \ ssl3_get_cipher, \ tls1_default_timeout, \ &enc_data, \ ssl_undefined_void_function, \ ssl3_callback_ctrl, \ ssl3_ctx_callback_ctrl, \ }; \ return &func_name##_data; \ } # define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect) \ const SSL_METHOD *func_name(void) \ { \ static const SSL_METHOD func_name##_data= { \ SSL3_VERSION, \ SSL_METHOD_NO_FIPS | SSL_METHOD_NO_SUITEB, \ SSL_OP_NO_SSLv3, \ ossl_ssl_connection_new, \ ossl_ssl_connection_free, \ ossl_ssl_connection_reset, \ ssl3_new, \ ssl3_clear, \ ssl3_free, \ s_accept, \ s_connect, \ ssl3_read, \ ssl3_peek, \ ssl3_write, \ ssl3_shutdown, \ ssl3_renegotiate, \ ssl3_renegotiate_check, \ ssl3_read_bytes, \ ssl3_write_bytes, \ ssl3_dispatch_alert, \ ssl3_ctrl, \ ssl3_ctx_ctrl, \ ssl3_get_cipher_by_char, \ ssl3_put_cipher_by_char, \ ssl3_pending, \ ssl3_num_ciphers, \ ssl3_get_cipher, \ ssl3_default_timeout, \ &SSLv3_enc_data, \ ssl_undefined_void_function, \ ssl3_callback_ctrl, \ ssl3_ctx_callback_ctrl, \ }; \ return &func_name##_data; \ } # define IMPLEMENT_dtls1_meth_func(version, flags, mask, func_name, s_accept, \ s_connect, enc_data) \ const SSL_METHOD *func_name(void) \ { \ static const SSL_METHOD func_name##_data= { \ version, \ flags, \ mask, \ ossl_ssl_connection_new, \ ossl_ssl_connection_free, \ ossl_ssl_connection_reset, \ dtls1_new, \ dtls1_clear, \ dtls1_free, \ s_accept, \ s_connect, \ ssl3_read, \ ssl3_peek, \ ssl3_write, \ dtls1_shutdown, \ ssl3_renegotiate, \ ssl3_renegotiate_check, \ dtls1_read_bytes, \ dtls1_write_app_data_bytes, \ dtls1_dispatch_alert, \ dtls1_ctrl, \ ssl3_ctx_ctrl, \ ssl3_get_cipher_by_char, \ ssl3_put_cipher_by_char, \ ssl3_pending, \ ssl3_num_ciphers, \ ssl3_get_cipher, \ dtls1_default_timeout, \ &enc_data, \ ssl_undefined_void_function, \ ssl3_callback_ctrl, \ ssl3_ctx_callback_ctrl, \ }; \ return &func_name##_data; \ } struct openssl_ssl_test_functions { int (*p_ssl_init_wbio_buffer) (SSL_CONNECTION *s); }; const char *ssl_protocol_to_string(int version); static ossl_inline int tls12_rpk_and_privkey(const SSL_CONNECTION *sc, int idx) { /* * This is to check for special cases when using RPK with just * a private key, and NO CERTIFICATE */ return ((sc->server && sc->ext.server_cert_type == TLSEXT_cert_type_rpk) || (!sc->server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk)) && sc->cert->pkeys[idx].privatekey != NULL && sc->cert->pkeys[idx].x509 == NULL; } static ossl_inline int ssl_has_cert_type(const SSL_CONNECTION *sc, unsigned char ct) { unsigned char *ptr; size_t len; if (sc->server) { ptr = sc->server_cert_type; len = sc->server_cert_type_len; } else { ptr = sc->client_cert_type; len = sc->client_cert_type_len; } if (ptr == NULL) return 0; return memchr(ptr, ct, len) != NULL; } /* Returns true if certificate and private key for 'idx' are present */ static ossl_inline int ssl_has_cert(const SSL_CONNECTION *s, int idx) { if (idx < 0 || idx >= (int)s->ssl_pkey_num) return 0; /* If RPK is enabled for this SSL... only require private key */ if (ssl_has_cert_type(s, TLSEXT_cert_type_rpk)) return s->cert->pkeys[idx].privatekey != NULL; return s->cert->pkeys[idx].x509 != NULL && s->cert->pkeys[idx].privatekey != NULL; } static ossl_inline void tls1_get_peer_groups(SSL_CONNECTION *s, const uint16_t **pgroups, size_t *pgroupslen) { *pgroups = s->ext.peer_supportedgroups; *pgroupslen = s->ext.peer_supportedgroups_len; } # ifndef OPENSSL_UNIT_TEST __owur int ossl_ssl_init(SSL *ssl, SSL_CTX *ctx, const SSL_METHOD *method, int type); __owur SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, const SSL_METHOD *method); __owur SSL *ossl_ssl_connection_new(SSL_CTX *ctx); void ossl_ssl_connection_free(SSL *ssl); __owur int ossl_ssl_connection_reset(SSL *ssl); __owur int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes); __owur int ssl_write_internal(SSL *s, const void *buf, size_t num, size_t *written); int ssl_clear_bad_session(SSL_CONNECTION *s); __owur CERT *ssl_cert_new(size_t ssl_pkey_num); __owur CERT *ssl_cert_dup(CERT *cert); void ssl_cert_clear_certs(CERT *c); void ssl_cert_free(CERT *c); __owur int ssl_generate_session_id(SSL_CONNECTION *s, SSL_SESSION *ss); __owur int ssl_get_new_session(SSL_CONNECTION *s, int session); __owur SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s, const unsigned char *sess_id, size_t sess_id_len); __owur int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello); __owur SSL_SESSION *ssl_session_dup(const SSL_SESSION *src, int ticket); __owur int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b); DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id); __owur int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap, const SSL_CIPHER *const *bp); __owur STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx, STACK_OF(SSL_CIPHER) *tls13_ciphersuites, STACK_OF(SSL_CIPHER) **cipher_list, STACK_OF(SSL_CIPHER) **cipher_list_by_id, const char *rule_str, CERT *c); __owur int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites, int sslv2format); __owur int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites, STACK_OF(SSL_CIPHER) **skp, STACK_OF(SSL_CIPHER) **scsvs, int sslv2format, int fatal); void ssl_update_cache(SSL_CONNECTION *s, int mode); __owur int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc, const EVP_CIPHER **enc); __owur int ssl_cipher_get_evp(SSL_CTX *ctxc, const SSL_SESSION *s, const EVP_CIPHER **enc, const EVP_MD **md, int *mac_pkey_type, size_t *mac_secret_size, SSL_COMP **comp, int use_etm); __owur int ssl_cipher_get_overhead(const SSL_CIPHER *c, size_t *mac_overhead, size_t *int_overhead, size_t *blocksize, size_t *ext_overhead); __owur int ssl_cert_is_disabled(SSL_CTX *ctx, size_t idx); __owur const SSL_CIPHER *ssl_get_cipher_by_char(SSL_CONNECTION *ssl, const unsigned char *ptr, int all); __owur int ssl_cert_set0_chain(SSL_CONNECTION *s, SSL_CTX *ctx, STACK_OF(X509) *chain); __owur int ssl_cert_set1_chain(SSL_CONNECTION *s, SSL_CTX *ctx, STACK_OF(X509) *chain); __owur int ssl_cert_add0_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x); __owur int ssl_cert_add1_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x); __owur int ssl_cert_select_current(CERT *c, X509 *x); __owur int ssl_cert_set_current(CERT *c, long arg); void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg); __owur int ssl_verify_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk); __owur int ssl_verify_rpk(SSL_CONNECTION *s, EVP_PKEY *rpk); __owur int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags); __owur int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref); __owur int ssl_cert_get_cert_store(CERT *c, X509_STORE **pstore, int chain); __owur int ssl_security(const SSL_CONNECTION *s, int op, int bits, int nid, void *other); __owur int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid, void *other); int ssl_get_security_level_bits(const SSL *s, const SSL_CTX *ctx, int *levelp); __owur int ssl_cert_lookup_by_nid(int nid, size_t *pidx, SSL_CTX *ctx); __owur const SSL_CERT_LOOKUP *ssl_cert_lookup_by_pkey(const EVP_PKEY *pk, size_t *pidx, SSL_CTX *ctx); __owur const SSL_CERT_LOOKUP *ssl_cert_lookup_by_idx(size_t idx, SSL_CTX *ctx); int ssl_undefined_function(SSL *s); __owur int ssl_undefined_void_function(void); __owur int ssl_undefined_const_function(const SSL *s); __owur int ssl_get_server_cert_serverinfo(SSL_CONNECTION *s, const unsigned char **serverinfo, size_t *serverinfo_length); void ssl_set_masks(SSL_CONNECTION *s); __owur STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL_CONNECTION *sc); __owur int ssl_x509err2alert(int type); void ssl_sort_cipher_list(void); int ssl_load_ciphers(SSL_CTX *ctx); __owur int ssl_setup_sigalgs(SSL_CTX *ctx); int ssl_load_groups(SSL_CTX *ctx); int ssl_load_sigalgs(SSL_CTX *ctx); __owur int ssl_fill_hello_random(SSL_CONNECTION *s, int server, unsigned char *field, size_t len, DOWNGRADE dgrd); __owur int ssl_generate_master_secret(SSL_CONNECTION *s, unsigned char *pms, size_t pmslen, int free_pms); __owur EVP_PKEY *ssl_generate_pkey(SSL_CONNECTION *s, EVP_PKEY *pm); __owur int ssl_gensecret(SSL_CONNECTION *s, unsigned char *pms, size_t pmslen); __owur int ssl_derive(SSL_CONNECTION *s, EVP_PKEY *privkey, EVP_PKEY *pubkey, int genmaster); __owur int ssl_decapsulate(SSL_CONNECTION *s, EVP_PKEY *privkey, const unsigned char *ct, size_t ctlen, int gensecret); __owur int ssl_encapsulate(SSL_CONNECTION *s, EVP_PKEY *pubkey, unsigned char **ctp, size_t *ctlenp, int gensecret); __owur EVP_PKEY *ssl_dh_to_pkey(DH *dh); __owur int ssl_set_tmp_ecdh_groups(uint16_t **pext, size_t *pextlen, void *key); __owur unsigned int ssl_get_max_send_fragment(const SSL_CONNECTION *sc); __owur unsigned int ssl_get_split_send_fragment(const SSL_CONNECTION *sc); __owur const SSL_CIPHER *ssl3_get_cipher_by_id(uint32_t id); __owur const SSL_CIPHER *ssl3_get_cipher_by_std_name(const char *stdname); __owur const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p); __owur int ssl3_put_cipher_by_char(const SSL_CIPHER *c, WPACKET *pkt, size_t *len); int ssl3_init_finished_mac(SSL_CONNECTION *s); __owur int ssl3_setup_key_block(SSL_CONNECTION *s); __owur int ssl3_change_cipher_state(SSL_CONNECTION *s, int which); void ssl3_cleanup_key_block(SSL_CONNECTION *s); __owur int ssl3_do_write(SSL_CONNECTION *s, uint8_t type); int ssl3_send_alert(SSL_CONNECTION *s, int level, int desc); __owur int ssl3_generate_master_secret(SSL_CONNECTION *s, unsigned char *out, unsigned char *p, size_t len, size_t *secret_size); __owur int ssl3_get_req_cert_type(SSL_CONNECTION *s, WPACKET *pkt); __owur int ssl3_num_ciphers(void); __owur const SSL_CIPHER *ssl3_get_cipher(unsigned int u); int ssl3_renegotiate(SSL *ssl); int ssl3_renegotiate_check(SSL *ssl, int initok); void ssl3_digest_master_key_set_params(const SSL_SESSION *session, OSSL_PARAM params[]); __owur int ssl3_dispatch_alert(SSL *s); __owur size_t ssl3_final_finish_mac(SSL_CONNECTION *s, const char *sender, size_t slen, unsigned char *p); __owur int ssl3_finish_mac(SSL_CONNECTION *s, const unsigned char *buf, size_t len); void ssl3_free_digest_list(SSL_CONNECTION *s); __owur unsigned long ssl3_output_cert_chain(SSL_CONNECTION *s, WPACKET *pkt, CERT_PKEY *cpk, int for_comp); __owur const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *clnt, STACK_OF(SSL_CIPHER) *srvr); __owur int ssl3_digest_cached_records(SSL_CONNECTION *s, int keep); __owur int ssl3_new(SSL *s); void ssl3_free(SSL *s); __owur int ssl3_read(SSL *s, void *buf, size_t len, size_t *readbytes); __owur int ssl3_peek(SSL *s, void *buf, size_t len, size_t *readbytes); __owur int ssl3_write(SSL *s, const void *buf, size_t len, size_t *written); __owur int ssl3_shutdown(SSL *s); int ssl3_clear(SSL *s); __owur long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg); __owur long ssl3_ctx_ctrl(SSL_CTX *s, int cmd, long larg, void *parg); __owur long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void)); __owur long ssl3_ctx_callback_ctrl(SSL_CTX *s, int cmd, void (*fp) (void)); __owur int ssl3_do_change_cipher_spec(SSL_CONNECTION *s); __owur OSSL_TIME ssl3_default_timeout(void); __owur int ssl3_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype); __owur int tls_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype); __owur int tls_setup_handshake(SSL_CONNECTION *s); __owur int dtls1_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype); __owur int dtls1_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype); __owur int ssl3_handshake_write(SSL_CONNECTION *s); __owur int ssl_allow_compression(SSL_CONNECTION *s); __owur int ssl_version_cmp(const SSL_CONNECTION *s, int versiona, int versionb); __owur int ssl_version_supported(const SSL_CONNECTION *s, int version, const SSL_METHOD **meth); __owur int ssl_set_client_hello_version(SSL_CONNECTION *s); __owur int ssl_check_version_downgrade(SSL_CONNECTION *s); __owur int ssl_set_version_bound(int method_version, int version, int *bound); __owur int ssl_choose_server_version(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello, DOWNGRADE *dgrd); __owur int ssl_choose_client_version(SSL_CONNECTION *s, int version, RAW_EXTENSION *extensions); __owur int ssl_get_min_max_version(const SSL_CONNECTION *s, int *min_version, int *max_version, int *real_max); __owur OSSL_TIME tls1_default_timeout(void); __owur int dtls1_do_write(SSL_CONNECTION *s, uint8_t type); void dtls1_set_message_header(SSL_CONNECTION *s, unsigned char mt, size_t len, size_t frag_off, size_t frag_len); int dtls1_write_app_data_bytes(SSL *s, uint8_t type, const void *buf_, size_t len, size_t *written); __owur int dtls1_read_failed(SSL_CONNECTION *s, int code); __owur int dtls1_buffer_message(SSL_CONNECTION *s, int ccs); __owur int dtls1_retransmit_message(SSL_CONNECTION *s, unsigned short seq, int *found); __owur int dtls1_get_queue_priority(unsigned short seq, int is_ccs); int dtls1_retransmit_buffered_messages(SSL_CONNECTION *s); void dtls1_clear_received_buffer(SSL_CONNECTION *s); void dtls1_clear_sent_buffer(SSL_CONNECTION *s); void dtls1_get_message_header(const unsigned char *data, struct hm_header_st *msg_hdr); __owur OSSL_TIME dtls1_default_timeout(void); __owur int dtls1_get_timeout(const SSL_CONNECTION *s, OSSL_TIME *timeleft); __owur int dtls1_check_timeout_num(SSL_CONNECTION *s); __owur int dtls1_handle_timeout(SSL_CONNECTION *s); void dtls1_start_timer(SSL_CONNECTION *s); void dtls1_stop_timer(SSL_CONNECTION *s); __owur int dtls1_is_timer_expired(SSL_CONNECTION *s); __owur int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie, size_t cookie_len); __owur size_t dtls1_min_mtu(SSL_CONNECTION *s); void dtls1_hm_fragment_free(hm_fragment *frag); __owur int dtls1_query_mtu(SSL_CONNECTION *s); __owur int tls1_new(SSL *s); void tls1_free(SSL *s); int tls1_clear(SSL *s); __owur int dtls1_new(SSL *s); void dtls1_free(SSL *s); int dtls1_clear(SSL *s); long dtls1_ctrl(SSL *s, int cmd, long larg, void *parg); __owur int dtls1_shutdown(SSL *s); __owur int dtls1_dispatch_alert(SSL *s); __owur int ssl_init_wbio_buffer(SSL_CONNECTION *s); int ssl_free_wbio_buffer(SSL_CONNECTION *s); __owur int tls1_change_cipher_state(SSL_CONNECTION *s, int which); __owur int tls1_setup_key_block(SSL_CONNECTION *s); __owur size_t tls1_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen, unsigned char *p); __owur int tls1_generate_master_secret(SSL_CONNECTION *s, unsigned char *out, unsigned char *p, size_t len, size_t *secret_size); __owur int tls13_setup_key_block(SSL_CONNECTION *s); __owur size_t tls13_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen, unsigned char *p); __owur int tls13_change_cipher_state(SSL_CONNECTION *s, int which); __owur int tls13_update_key(SSL_CONNECTION *s, int send); __owur int tls13_hkdf_expand(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *secret, const unsigned char *label, size_t labellen, const unsigned char *data, size_t datalen, unsigned char *out, size_t outlen, int fatal); __owur int tls13_hkdf_expand_ex(OSSL_LIB_CTX *libctx, const char *propq, const EVP_MD *md, const unsigned char *secret, const unsigned char *label, size_t labellen, const unsigned char *data, size_t datalen, unsigned char *out, size_t outlen, int raise_error); __owur int tls13_derive_key(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *secret, unsigned char *key, size_t keylen); __owur int tls13_derive_iv(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *secret, unsigned char *iv, size_t ivlen); __owur int tls13_derive_finishedkey(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *secret, unsigned char *fin, size_t finlen); int tls13_generate_secret(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *prevsecret, const unsigned char *insecret, size_t insecretlen, unsigned char *outsecret); __owur int tls13_generate_handshake_secret(SSL_CONNECTION *s, const unsigned char *insecret, size_t insecretlen); __owur int tls13_generate_master_secret(SSL_CONNECTION *s, unsigned char *out, unsigned char *prev, size_t prevlen, size_t *secret_size); __owur int tls1_export_keying_material(SSL_CONNECTION *s, unsigned char *out, size_t olen, const char *label, size_t llen, const unsigned char *p, size_t plen, int use_context); __owur int tls13_export_keying_material(SSL_CONNECTION *s, unsigned char *out, size_t olen, const char *label, size_t llen, const unsigned char *context, size_t contextlen, int use_context); __owur int tls13_export_keying_material_early(SSL_CONNECTION *s, unsigned char *out, size_t olen, const char *label, size_t llen, const unsigned char *context, size_t contextlen); __owur int tls1_alert_code(int code); __owur int tls13_alert_code(int code); __owur int ssl3_alert_code(int code); __owur int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL_CONNECTION *s); SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n); __owur const TLS_GROUP_INFO *tls1_group_id_lookup(SSL_CTX *ctx, uint16_t curve_id); __owur const char *tls1_group_id2name(SSL_CTX *ctx, uint16_t group_id); __owur int tls1_group_id2nid(uint16_t group_id, int include_unknown); __owur uint16_t tls1_nid2group_id(int nid); __owur int tls1_check_group_id(SSL_CONNECTION *s, uint16_t group_id, int check_own_curves); __owur uint16_t tls1_shared_group(SSL_CONNECTION *s, int nmatch); __owur int tls1_set_groups(uint16_t **pext, size_t *pextlen, int *curves, size_t ncurves); __owur int tls1_set_groups_list(SSL_CTX *ctx, uint16_t **pext, size_t *pextlen, const char *str); __owur EVP_PKEY *ssl_generate_pkey_group(SSL_CONNECTION *s, uint16_t id); __owur int tls_valid_group(SSL_CONNECTION *s, uint16_t group_id, int minversion, int maxversion, int isec, int *okfortls13); __owur EVP_PKEY *ssl_generate_param_group(SSL_CONNECTION *s, uint16_t id); void tls1_get_formatlist(SSL_CONNECTION *s, const unsigned char **pformats, size_t *num_formats); __owur int tls1_check_ec_tmp_key(SSL_CONNECTION *s, unsigned long id); __owur int tls_group_allowed(SSL_CONNECTION *s, uint16_t curve, int op); void tls1_get_supported_groups(SSL_CONNECTION *s, const uint16_t **pgroups, size_t *pgroupslen); __owur int tls1_set_server_sigalgs(SSL_CONNECTION *s); __owur SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello, SSL_SESSION **ret); __owur SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s, const unsigned char *etick, size_t eticklen, const unsigned char *sess_id, size_t sesslen, SSL_SESSION **psess); __owur int tls_use_ticket(SSL_CONNECTION *s); void ssl_set_sig_mask(uint32_t *pmask_a, SSL_CONNECTION *s, int op); __owur int tls1_set_sigalgs_list(CERT *c, const char *str, int client); __owur int tls1_set_raw_sigalgs(CERT *c, const uint16_t *psigs, size_t salglen, int client); __owur int tls1_set_sigalgs(CERT *c, const int *salg, size_t salglen, int client); int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk, STACK_OF(X509) *chain, int idx); void tls1_set_cert_validity(SSL_CONNECTION *s); # ifndef OPENSSL_NO_CT __owur int ssl_validate_ct(SSL_CONNECTION *s); # endif __owur EVP_PKEY *ssl_get_auto_dh(SSL_CONNECTION *s); __owur int ssl_security_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int vfy, int is_ee); __owur int ssl_security_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk, X509 *ex, int vfy); int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs); __owur long ssl_get_algorithm2(SSL_CONNECTION *s); __owur int tls12_copy_sigalgs(SSL_CONNECTION *s, WPACKET *pkt, const uint16_t *psig, size_t psiglen); __owur int tls1_save_u16(PACKET *pkt, uint16_t **pdest, size_t *pdestlen); __owur int tls1_save_sigalgs(SSL_CONNECTION *s, PACKET *pkt, int cert); __owur int tls1_process_sigalgs(SSL_CONNECTION *s); __owur int tls1_set_peer_legacy_sigalg(SSL_CONNECTION *s, const EVP_PKEY *pkey); __owur int tls1_lookup_md(SSL_CTX *ctx, const SIGALG_LOOKUP *lu, const EVP_MD **pmd); __owur size_t tls12_get_psigalgs(SSL_CONNECTION *s, int sent, const uint16_t **psigs); __owur int tls_check_sigalg_curve(const SSL_CONNECTION *s, int curve); __owur int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t, EVP_PKEY *pkey); __owur int ssl_set_client_disabled(SSL_CONNECTION *s); __owur int ssl_cipher_disabled(const SSL_CONNECTION *s, const SSL_CIPHER *c, int op, int echde); __owur int ssl_handshake_hash(SSL_CONNECTION *s, unsigned char *out, size_t outlen, size_t *hashlen); __owur const EVP_MD *ssl_md(SSL_CTX *ctx, int idx); int ssl_get_md_idx(int md_nid); __owur const EVP_MD *ssl_handshake_md(SSL_CONNECTION *s); __owur const EVP_MD *ssl_prf_md(SSL_CONNECTION *s); /* * ssl_log_rsa_client_key_exchange logs |premaster| to the SSL_CTX associated * with |ssl|, if logging is enabled. It returns one on success and zero on * failure. The entry is identified by the first 8 bytes of * |encrypted_premaster|. */ __owur int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *s, const uint8_t *encrypted_premaster, size_t encrypted_premaster_len, const uint8_t *premaster, size_t premaster_len); /* * ssl_log_secret logs |secret| to the SSL_CTX associated with |ssl|, if * logging is available. It returns one on success and zero on failure. It tags * the entry with |label|. */ __owur int ssl_log_secret(SSL_CONNECTION *s, const char *label, const uint8_t *secret, size_t secret_len); #define MASTER_SECRET_LABEL "CLIENT_RANDOM" #define CLIENT_EARLY_LABEL "CLIENT_EARLY_TRAFFIC_SECRET" #define CLIENT_HANDSHAKE_LABEL "CLIENT_HANDSHAKE_TRAFFIC_SECRET" #define SERVER_HANDSHAKE_LABEL "SERVER_HANDSHAKE_TRAFFIC_SECRET" #define CLIENT_APPLICATION_LABEL "CLIENT_TRAFFIC_SECRET_0" #define CLIENT_APPLICATION_N_LABEL "CLIENT_TRAFFIC_SECRET_N" #define SERVER_APPLICATION_LABEL "SERVER_TRAFFIC_SECRET_0" #define SERVER_APPLICATION_N_LABEL "SERVER_TRAFFIC_SECRET_N" #define EARLY_EXPORTER_SECRET_LABEL "EARLY_EXPORTER_SECRET" #define EXPORTER_SECRET_LABEL "EXPORTER_SECRET" __owur int srp_generate_server_master_secret(SSL_CONNECTION *s); __owur int srp_generate_client_master_secret(SSL_CONNECTION *s); __owur int srp_verify_server_param(SSL_CONNECTION *s); /* statem/statem_srvr.c */ __owur int send_certificate_request(SSL_CONNECTION *s); /* statem/extensions_cust.c */ custom_ext_method *custom_ext_find(const custom_ext_methods *exts, ENDPOINT role, unsigned int ext_type, size_t *idx); void custom_ext_init(custom_ext_methods *meths); int ossl_tls_add_custom_ext_intern(SSL_CTX *ctx, custom_ext_methods *exts, ENDPOINT role, unsigned int ext_type, unsigned int context, SSL_custom_ext_add_cb_ex add_cb, SSL_custom_ext_free_cb_ex free_cb, void *add_arg, SSL_custom_ext_parse_cb_ex parse_cb, void *parse_arg); __owur int custom_ext_parse(SSL_CONNECTION *s, unsigned int context, unsigned int ext_type, const unsigned char *ext_data, size_t ext_size, X509 *x, size_t chainidx); __owur int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x, size_t chainidx, int maxversion); __owur int custom_exts_copy(custom_ext_methods *dst, const custom_ext_methods *src); __owur int custom_exts_copy_flags(custom_ext_methods *dst, const custom_ext_methods *src); void custom_exts_free(custom_ext_methods *exts); void ssl_comp_free_compression_methods_int(void); /* ssl_mcnf.c */ void ssl_ctx_system_config(SSL_CTX *ctx); const EVP_CIPHER *ssl_evp_cipher_fetch(OSSL_LIB_CTX *libctx, int nid, const char *properties); int ssl_evp_cipher_up_ref(const EVP_CIPHER *cipher); void ssl_evp_cipher_free(const EVP_CIPHER *cipher); const EVP_MD *ssl_evp_md_fetch(OSSL_LIB_CTX *libctx, int nid, const char *properties); int ssl_evp_md_up_ref(const EVP_MD *md); void ssl_evp_md_free(const EVP_MD *md); void tls_engine_finish(ENGINE *e); const EVP_CIPHER *tls_get_cipher_from_engine(int nid); const EVP_MD *tls_get_digest_from_engine(int nid); int tls_engine_load_ssl_client_cert(SSL_CONNECTION *s, X509 **px509, EVP_PKEY **ppkey); int ssl_hmac_old_new(SSL_HMAC *ret); void ssl_hmac_old_free(SSL_HMAC *ctx); int ssl_hmac_old_init(SSL_HMAC *ctx, void *key, size_t len, char *md); int ssl_hmac_old_update(SSL_HMAC *ctx, const unsigned char *data, size_t len); int ssl_hmac_old_final(SSL_HMAC *ctx, unsigned char *md, size_t *len); size_t ssl_hmac_old_size(const SSL_HMAC *ctx); int ssl_ctx_srp_ctx_free_intern(SSL_CTX *ctx); int ssl_ctx_srp_ctx_init_intern(SSL_CTX *ctx); int ssl_srp_ctx_free_intern(SSL_CONNECTION *s); int ssl_srp_ctx_init_intern(SSL_CONNECTION *s); int ssl_srp_calc_a_param_intern(SSL_CONNECTION *s); int ssl_srp_server_param_with_username_intern(SSL_CONNECTION *s, int *ad); void ssl_session_calculate_timeout(SSL_SESSION *ss); # else /* OPENSSL_UNIT_TEST */ # define ssl_init_wbio_buffer SSL_test_functions()->p_ssl_init_wbio_buffer # endif /* Some helper routines to support TSAN operations safely */ static ossl_unused ossl_inline int ssl_tsan_lock(const SSL_CTX *ctx) { #ifdef TSAN_REQUIRES_LOCKING if (!CRYPTO_THREAD_write_lock(ctx->tsan_lock)) return 0; #endif return 1; } static ossl_unused ossl_inline void ssl_tsan_unlock(const SSL_CTX *ctx) { #ifdef TSAN_REQUIRES_LOCKING CRYPTO_THREAD_unlock(ctx->tsan_lock); #endif } static ossl_unused ossl_inline void ssl_tsan_counter(const SSL_CTX *ctx, TSAN_QUALIFIER int *stat) { if (ssl_tsan_lock(ctx)) { tsan_counter(stat); ssl_tsan_unlock(ctx); } } int ossl_comp_has_alg(int a); size_t ossl_calculate_comp_expansion(int alg, size_t length); void ossl_ssl_set_custom_record_layer(SSL_CONNECTION *s, const OSSL_RECORD_METHOD *meth, void *rlarg); long ossl_ctrl_internal(SSL *s, int cmd, long larg, void *parg, int no_quic); /* * Options which no longer have any effect, but which can be implemented * as no-ops for QUIC. */ #define OSSL_LEGACY_SSL_OPTIONS \ (SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG | \ SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER | \ SSL_OP_SSLEAY_080_CLIENT_DH_BUG | \ SSL_OP_TLS_D5_BUG | \ SSL_OP_TLS_BLOCK_PADDING_BUG | \ SSL_OP_MSIE_SSLV2_RSA_PADDING | \ SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG | \ SSL_OP_MICROSOFT_SESS_ID_BUG | \ SSL_OP_NETSCAPE_CHALLENGE_BUG | \ SSL_OP_PKCS1_CHECK_1 | \ SSL_OP_PKCS1_CHECK_2 | \ SSL_OP_SINGLE_DH_USE | \ SSL_OP_SINGLE_ECDH_USE | \ SSL_OP_EPHEMERAL_RSA ) /* This option is undefined in public headers with no-dtls1-method. */ #ifndef SSL_OP_CISCO_ANYCONNECT # define SSL_OP_CISCO_ANYCONNECT 0 #endif /* * Options which are no-ops under QUIC or TLSv1.3 and which are therefore * allowed but ignored under QUIC. */ #define OSSL_TLS1_2_OPTIONS \ (SSL_OP_CRYPTOPRO_TLSEXT_BUG | \ SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS | \ SSL_OP_ALLOW_CLIENT_RENEGOTIATION | \ SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION | \ SSL_OP_NO_COMPRESSION | \ SSL_OP_NO_SSLv3 | \ SSL_OP_NO_TLSv1 | \ SSL_OP_NO_TLSv1_1 | \ SSL_OP_NO_TLSv1_2 | \ SSL_OP_NO_DTLSv1 | \ SSL_OP_NO_DTLSv1_2 | \ SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION | \ SSL_OP_CISCO_ANYCONNECT | \ SSL_OP_NO_RENEGOTIATION | \ SSL_OP_NO_EXTENDED_MASTER_SECRET | \ SSL_OP_NO_ENCRYPT_THEN_MAC | \ SSL_OP_COOKIE_EXCHANGE | \ SSL_OP_LEGACY_SERVER_CONNECT | \ SSL_OP_IGNORE_UNEXPECTED_EOF ) /* Total mask of connection-level options permitted or ignored under QUIC. */ #define OSSL_QUIC_PERMITTED_OPTIONS_CONN \ (OSSL_LEGACY_SSL_OPTIONS | \ OSSL_TLS1_2_OPTIONS | \ SSL_OP_CIPHER_SERVER_PREFERENCE | \ SSL_OP_DISABLE_TLSEXT_CA_NAMES | \ SSL_OP_NO_TX_CERTIFICATE_COMPRESSION | \ SSL_OP_NO_RX_CERTIFICATE_COMPRESSION | \ SSL_OP_PRIORITIZE_CHACHA | \ SSL_OP_NO_QUERY_MTU | \ SSL_OP_NO_TICKET | \ SSL_OP_NO_ANTI_REPLAY ) /* Total mask of stream-level options permitted or ignored under QUIC. */ #define OSSL_QUIC_PERMITTED_OPTIONS_STREAM \ (OSSL_LEGACY_SSL_OPTIONS | \ OSSL_TLS1_2_OPTIONS | \ SSL_OP_CLEANSE_PLAINTEXT ) /* Total mask of options permitted on either connections or streams. */ #define OSSL_QUIC_PERMITTED_OPTIONS \ (OSSL_QUIC_PERMITTED_OPTIONS_CONN | \ OSSL_QUIC_PERMITTED_OPTIONS_STREAM) #endif

./openssl/ssl/ssl_conf.c

/* * Copyright 2012-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include "ssl_local.h" #include <openssl/conf.h> #include <openssl/objects.h> #include <openssl/decoder.h> #include <openssl/core_dispatch.h> #include "internal/nelem.h" /* * structure holding name tables. This is used for permitted elements in lists * such as TLSv1. */ typedef struct { const char *name; int namelen; unsigned int name_flags; uint64_t option_value; } ssl_flag_tbl; /* Switch table: use for single command line switches like no_tls2 */ typedef struct { uint64_t option_value; unsigned int name_flags; } ssl_switch_tbl; /* Sense of name is inverted e.g. "TLSv1" will clear SSL_OP_NO_TLSv1 */ #define SSL_TFLAG_INV 0x1 /* Mask for type of flag referred to */ #define SSL_TFLAG_TYPE_MASK 0xf00 /* Flag is for options */ #define SSL_TFLAG_OPTION 0x000 /* Flag is for cert_flags */ #define SSL_TFLAG_CERT 0x100 /* Flag is for verify mode */ #define SSL_TFLAG_VFY 0x200 /* Option can only be used for clients */ #define SSL_TFLAG_CLIENT SSL_CONF_FLAG_CLIENT /* Option can only be used for servers */ #define SSL_TFLAG_SERVER SSL_CONF_FLAG_SERVER #define SSL_TFLAG_BOTH (SSL_TFLAG_CLIENT|SSL_TFLAG_SERVER) #define SSL_FLAG_TBL(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_BOTH, flag} #define SSL_FLAG_TBL_SRV(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_SERVER, flag} #define SSL_FLAG_TBL_CLI(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_CLIENT, flag} #define SSL_FLAG_TBL_INV(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV|SSL_TFLAG_BOTH, flag} #define SSL_FLAG_TBL_SRV_INV(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV|SSL_TFLAG_SERVER, flag} #define SSL_FLAG_TBL_CERT(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_CERT|SSL_TFLAG_BOTH, flag} #define SSL_FLAG_VFY_CLI(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_CLIENT, flag} #define SSL_FLAG_VFY_SRV(str, flag) \ {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_SERVER, flag} /* * Opaque structure containing SSL configuration context. */ struct ssl_conf_ctx_st { /* * Various flags indicating (among other things) which options we will * recognise. */ unsigned int flags; /* Prefix and length of commands */ char *prefix; size_t prefixlen; /* SSL_CTX or SSL structure to perform operations on */ SSL_CTX *ctx; SSL *ssl; /* Pointer to SSL or SSL_CTX options field or NULL if none */ uint64_t *poptions; /* Certificate filenames for each type */ char *cert_filename[SSL_PKEY_NUM]; /* Pointer to SSL or SSL_CTX cert_flags or NULL if none */ uint32_t *pcert_flags; /* Pointer to SSL or SSL_CTX verify_mode or NULL if none */ uint32_t *pvfy_flags; /* Pointer to SSL or SSL_CTX min_version field or NULL if none */ int *min_version; /* Pointer to SSL or SSL_CTX max_version field or NULL if none */ int *max_version; /* Current flag table being worked on */ const ssl_flag_tbl *tbl; /* Size of table */ size_t ntbl; /* Client CA names */ STACK_OF(X509_NAME) *canames; }; static void ssl_set_option(SSL_CONF_CTX *cctx, unsigned int name_flags, uint64_t option_value, int onoff) { uint32_t *pflags; if (cctx->poptions == NULL) return; if (name_flags & SSL_TFLAG_INV) onoff ^= 1; switch (name_flags & SSL_TFLAG_TYPE_MASK) { case SSL_TFLAG_CERT: pflags = cctx->pcert_flags; break; case SSL_TFLAG_VFY: pflags = cctx->pvfy_flags; break; case SSL_TFLAG_OPTION: if (onoff) *cctx->poptions |= option_value; else *cctx->poptions &= ~option_value; return; default: return; } if (onoff) *pflags |= option_value; else *pflags &= ~option_value; } static int ssl_match_option(SSL_CONF_CTX *cctx, const ssl_flag_tbl *tbl, const char *name, int namelen, int onoff) { /* If name not relevant for context skip */ if (!(cctx->flags & tbl->name_flags & SSL_TFLAG_BOTH)) return 0; if (namelen == -1) { if (strcmp(tbl->name, name)) return 0; } else if (tbl->namelen != namelen || OPENSSL_strncasecmp(tbl->name, name, namelen)) return 0; ssl_set_option(cctx, tbl->name_flags, tbl->option_value, onoff); return 1; } static int ssl_set_option_list(const char *elem, int len, void *usr) { SSL_CONF_CTX *cctx = usr; size_t i; const ssl_flag_tbl *tbl; int onoff = 1; /* * len == -1 indicates not being called in list context, just for single * command line switches, so don't allow +, -. */ if (elem == NULL) return 0; if (len != -1) { if (*elem == '+') { elem++; len--; onoff = 1; } else if (*elem == '-') { elem++; len--; onoff = 0; } } for (i = 0, tbl = cctx->tbl; i < cctx->ntbl; i++, tbl++) { if (ssl_match_option(cctx, tbl, elem, len, onoff)) return 1; } return 0; } /* Set supported signature algorithms */ static int cmd_SignatureAlgorithms(SSL_CONF_CTX *cctx, const char *value) { int rv; if (cctx->ssl) rv = SSL_set1_sigalgs_list(cctx->ssl, value); /* NB: ctx == NULL performs syntax checking only */ else rv = SSL_CTX_set1_sigalgs_list(cctx->ctx, value); return rv > 0; } /* Set supported client signature algorithms */ static int cmd_ClientSignatureAlgorithms(SSL_CONF_CTX *cctx, const char *value) { int rv; if (cctx->ssl) rv = SSL_set1_client_sigalgs_list(cctx->ssl, value); /* NB: ctx == NULL performs syntax checking only */ else rv = SSL_CTX_set1_client_sigalgs_list(cctx->ctx, value); return rv > 0; } static int cmd_Groups(SSL_CONF_CTX *cctx, const char *value) { int rv; if (cctx->ssl) rv = SSL_set1_groups_list(cctx->ssl, value); /* NB: ctx == NULL performs syntax checking only */ else rv = SSL_CTX_set1_groups_list(cctx->ctx, value); return rv > 0; } /* This is the old name for cmd_Groups - retained for backwards compatibility */ static int cmd_Curves(SSL_CONF_CTX *cctx, const char *value) { return cmd_Groups(cctx, value); } /* ECDH temporary parameters */ static int cmd_ECDHParameters(SSL_CONF_CTX *cctx, const char *value) { int rv = 1; /* Ignore values supported by 1.0.2 for the automatic selection */ if ((cctx->flags & SSL_CONF_FLAG_FILE) && (OPENSSL_strcasecmp(value, "+automatic") == 0 || OPENSSL_strcasecmp(value, "automatic") == 0)) return 1; if ((cctx->flags & SSL_CONF_FLAG_CMDLINE) && strcmp(value, "auto") == 0) return 1; /* ECDHParameters accepts a single group name */ if (strstr(value, ":") != NULL) return 0; if (cctx->ctx) rv = SSL_CTX_set1_groups_list(cctx->ctx, value); else if (cctx->ssl) rv = SSL_set1_groups_list(cctx->ssl, value); return rv > 0; } static int cmd_CipherString(SSL_CONF_CTX *cctx, const char *value) { int rv = 1; if (cctx->ctx) rv = SSL_CTX_set_cipher_list(cctx->ctx, value); if (cctx->ssl) rv = SSL_set_cipher_list(cctx->ssl, value); return rv > 0; } static int cmd_Ciphersuites(SSL_CONF_CTX *cctx, const char *value) { int rv = 1; if (cctx->ctx) rv = SSL_CTX_set_ciphersuites(cctx->ctx, value); if (cctx->ssl) rv = SSL_set_ciphersuites(cctx->ssl, value); return rv > 0; } static int cmd_Protocol(SSL_CONF_CTX *cctx, const char *value) { static const ssl_flag_tbl ssl_protocol_list[] = { SSL_FLAG_TBL_INV("ALL", SSL_OP_NO_SSL_MASK), SSL_FLAG_TBL_INV("SSLv2", SSL_OP_NO_SSLv2), SSL_FLAG_TBL_INV("SSLv3", SSL_OP_NO_SSLv3), SSL_FLAG_TBL_INV("TLSv1", SSL_OP_NO_TLSv1), SSL_FLAG_TBL_INV("TLSv1.1", SSL_OP_NO_TLSv1_1), SSL_FLAG_TBL_INV("TLSv1.2", SSL_OP_NO_TLSv1_2), SSL_FLAG_TBL_INV("TLSv1.3", SSL_OP_NO_TLSv1_3), SSL_FLAG_TBL_INV("DTLSv1", SSL_OP_NO_DTLSv1), SSL_FLAG_TBL_INV("DTLSv1.2", SSL_OP_NO_DTLSv1_2) }; cctx->tbl = ssl_protocol_list; cctx->ntbl = OSSL_NELEM(ssl_protocol_list); return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx); } /* * protocol_from_string - converts a protocol version string to a number * * Returns -1 on failure or the version on success */ static int protocol_from_string(const char *value) { struct protocol_versions { const char *name; int version; }; /* * Note: To avoid breaking previously valid configurations, we must retain * legacy entries in this table even if the underlying protocol is no * longer supported. This also means that the constants SSL3_VERSION, ... * need to be retained indefinitely. This table can only grow, never * shrink. */ static const struct protocol_versions versions[] = { {"None", 0}, {"SSLv3", SSL3_VERSION}, {"TLSv1", TLS1_VERSION}, {"TLSv1.1", TLS1_1_VERSION}, {"TLSv1.2", TLS1_2_VERSION}, {"TLSv1.3", TLS1_3_VERSION}, {"DTLSv1", DTLS1_VERSION}, {"DTLSv1.2", DTLS1_2_VERSION} }; size_t i; size_t n = OSSL_NELEM(versions); for (i = 0; i < n; i++) if (strcmp(versions[i].name, value) == 0) return versions[i].version; return -1; } static int min_max_proto(SSL_CONF_CTX *cctx, const char *value, int *bound) { int method_version; int new_version; if (cctx->ctx != NULL) method_version = cctx->ctx->method->version; else if (cctx->ssl != NULL) method_version = cctx->ssl->defltmeth->version; else return 0; if ((new_version = protocol_from_string(value)) < 0) return 0; return ssl_set_version_bound(method_version, new_version, bound); } /* * cmd_MinProtocol - Set min protocol version * @cctx: config structure to save settings in * @value: The min protocol version in string form * * Returns 1 on success and 0 on failure. */ static int cmd_MinProtocol(SSL_CONF_CTX *cctx, const char *value) { return min_max_proto(cctx, value, cctx->min_version); } /* * cmd_MaxProtocol - Set max protocol version * @cctx: config structure to save settings in * @value: The max protocol version in string form * * Returns 1 on success and 0 on failure. */ static int cmd_MaxProtocol(SSL_CONF_CTX *cctx, const char *value) { return min_max_proto(cctx, value, cctx->max_version); } static int cmd_Options(SSL_CONF_CTX *cctx, const char *value) { static const ssl_flag_tbl ssl_option_list[] = { SSL_FLAG_TBL_INV("SessionTicket", SSL_OP_NO_TICKET), SSL_FLAG_TBL_INV("EmptyFragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS), SSL_FLAG_TBL("Bugs", SSL_OP_ALL), SSL_FLAG_TBL_INV("Compression", SSL_OP_NO_COMPRESSION), SSL_FLAG_TBL_SRV("ServerPreference", SSL_OP_CIPHER_SERVER_PREFERENCE), SSL_FLAG_TBL_SRV("NoResumptionOnRenegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION), SSL_FLAG_TBL_SRV("DHSingle", SSL_OP_SINGLE_DH_USE), SSL_FLAG_TBL_SRV("ECDHSingle", SSL_OP_SINGLE_ECDH_USE), SSL_FLAG_TBL("UnsafeLegacyRenegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION), SSL_FLAG_TBL("UnsafeLegacyServerConnect", SSL_OP_LEGACY_SERVER_CONNECT), SSL_FLAG_TBL("ClientRenegotiation", SSL_OP_ALLOW_CLIENT_RENEGOTIATION), SSL_FLAG_TBL_INV("EncryptThenMac", SSL_OP_NO_ENCRYPT_THEN_MAC), SSL_FLAG_TBL("NoRenegotiation", SSL_OP_NO_RENEGOTIATION), SSL_FLAG_TBL("AllowNoDHEKEX", SSL_OP_ALLOW_NO_DHE_KEX), SSL_FLAG_TBL("PreferNoDHEKEX", SSL_OP_PREFER_NO_DHE_KEX), SSL_FLAG_TBL("PrioritizeChaCha", SSL_OP_PRIORITIZE_CHACHA), SSL_FLAG_TBL("MiddleboxCompat", SSL_OP_ENABLE_MIDDLEBOX_COMPAT), SSL_FLAG_TBL_INV("AntiReplay", SSL_OP_NO_ANTI_REPLAY), SSL_FLAG_TBL_INV("ExtendedMasterSecret", SSL_OP_NO_EXTENDED_MASTER_SECRET), SSL_FLAG_TBL_INV("CANames", SSL_OP_DISABLE_TLSEXT_CA_NAMES), SSL_FLAG_TBL("KTLS", SSL_OP_ENABLE_KTLS), SSL_FLAG_TBL_CERT("StrictCertCheck", SSL_CERT_FLAG_TLS_STRICT), SSL_FLAG_TBL_INV("TxCertificateCompression", SSL_OP_NO_TX_CERTIFICATE_COMPRESSION), SSL_FLAG_TBL_INV("RxCertificateCompression", SSL_OP_NO_RX_CERTIFICATE_COMPRESSION), SSL_FLAG_TBL("KTLSTxZerocopySendfile", SSL_OP_ENABLE_KTLS_TX_ZEROCOPY_SENDFILE), SSL_FLAG_TBL("IgnoreUnexpectedEOF", SSL_OP_IGNORE_UNEXPECTED_EOF), }; if (value == NULL) return -3; cctx->tbl = ssl_option_list; cctx->ntbl = OSSL_NELEM(ssl_option_list); return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx); } static int cmd_VerifyMode(SSL_CONF_CTX *cctx, const char *value) { static const ssl_flag_tbl ssl_vfy_list[] = { SSL_FLAG_VFY_CLI("Peer", SSL_VERIFY_PEER), SSL_FLAG_VFY_SRV("Request", SSL_VERIFY_PEER), SSL_FLAG_VFY_SRV("Require", SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT), SSL_FLAG_VFY_SRV("Once", SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE), SSL_FLAG_VFY_SRV("RequestPostHandshake", SSL_VERIFY_PEER | SSL_VERIFY_POST_HANDSHAKE), SSL_FLAG_VFY_SRV("RequirePostHandshake", SSL_VERIFY_PEER | SSL_VERIFY_POST_HANDSHAKE | SSL_VERIFY_FAIL_IF_NO_PEER_CERT), }; if (value == NULL) return -3; cctx->tbl = ssl_vfy_list; cctx->ntbl = OSSL_NELEM(ssl_vfy_list); return CONF_parse_list(value, ',', 1, ssl_set_option_list, cctx); } static int cmd_Certificate(SSL_CONF_CTX *cctx, const char *value) { int rv = 1; CERT *c = NULL; if (cctx->ctx != NULL) { rv = SSL_CTX_use_certificate_chain_file(cctx->ctx, value); c = cctx->ctx->cert; } if (cctx->ssl != NULL) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(cctx->ssl); if (sc != NULL) { rv = SSL_use_certificate_chain_file(cctx->ssl, value); c = sc->cert; } else { rv = 0; } } if (rv > 0 && c != NULL && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) { char **pfilename = &cctx->cert_filename[c->key - c->pkeys]; OPENSSL_free(*pfilename); *pfilename = OPENSSL_strdup(value); if (*pfilename == NULL) rv = 0; } return rv > 0; } static int cmd_PrivateKey(SSL_CONF_CTX *cctx, const char *value) { int rv = 1; if (!(cctx->flags & SSL_CONF_FLAG_CERTIFICATE)) return -2; if (cctx->ctx) rv = SSL_CTX_use_PrivateKey_file(cctx->ctx, value, SSL_FILETYPE_PEM); if (cctx->ssl) rv = SSL_use_PrivateKey_file(cctx->ssl, value, SSL_FILETYPE_PEM); return rv > 0; } static int cmd_ServerInfoFile(SSL_CONF_CTX *cctx, const char *value) { int rv = 1; if (cctx->ctx) rv = SSL_CTX_use_serverinfo_file(cctx->ctx, value); return rv > 0; } static int do_store(SSL_CONF_CTX *cctx, const char *CAfile, const char *CApath, const char *CAstore, int verify_store) { CERT *cert; X509_STORE **st; SSL_CTX *ctx; OSSL_LIB_CTX *libctx = NULL; const char *propq = NULL; if (cctx->ctx != NULL) { cert = cctx->ctx->cert; ctx = cctx->ctx; } else if (cctx->ssl != NULL) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(cctx->ssl); if (sc == NULL) return 0; cert = sc->cert; ctx = cctx->ssl->ctx; } else { return 1; } if (ctx != NULL) { libctx = ctx->libctx; propq = ctx->propq; } st = verify_store ? &cert->verify_store : &cert->chain_store; if (*st == NULL) { *st = X509_STORE_new(); if (*st == NULL) return 0; } if (CAfile != NULL && !X509_STORE_load_file_ex(*st, CAfile, libctx, propq)) return 0; if (CApath != NULL && !X509_STORE_load_path(*st, CApath)) return 0; if (CAstore != NULL && !X509_STORE_load_store_ex(*st, CAstore, libctx, propq)) return 0; return 1; } static int cmd_ChainCAPath(SSL_CONF_CTX *cctx, const char *value) { return do_store(cctx, NULL, value, NULL, 0); } static int cmd_ChainCAFile(SSL_CONF_CTX *cctx, const char *value) { return do_store(cctx, value, NULL, NULL, 0); } static int cmd_ChainCAStore(SSL_CONF_CTX *cctx, const char *value) { return do_store(cctx, NULL, NULL, value, 0); } static int cmd_VerifyCAPath(SSL_CONF_CTX *cctx, const char *value) { return do_store(cctx, NULL, value, NULL, 1); } static int cmd_VerifyCAFile(SSL_CONF_CTX *cctx, const char *value) { return do_store(cctx, value, NULL, NULL, 1); } static int cmd_VerifyCAStore(SSL_CONF_CTX *cctx, const char *value) { return do_store(cctx, NULL, NULL, value, 1); } static int cmd_RequestCAFile(SSL_CONF_CTX *cctx, const char *value) { if (cctx->canames == NULL) cctx->canames = sk_X509_NAME_new_null(); if (cctx->canames == NULL) return 0; return SSL_add_file_cert_subjects_to_stack(cctx->canames, value); } static int cmd_ClientCAFile(SSL_CONF_CTX *cctx, const char *value) { return cmd_RequestCAFile(cctx, value); } static int cmd_RequestCAPath(SSL_CONF_CTX *cctx, const char *value) { if (cctx->canames == NULL) cctx->canames = sk_X509_NAME_new_null(); if (cctx->canames == NULL) return 0; return SSL_add_dir_cert_subjects_to_stack(cctx->canames, value); } static int cmd_ClientCAPath(SSL_CONF_CTX *cctx, const char *value) { return cmd_RequestCAPath(cctx, value); } static int cmd_RequestCAStore(SSL_CONF_CTX *cctx, const char *value) { if (cctx->canames == NULL) cctx->canames = sk_X509_NAME_new_null(); if (cctx->canames == NULL) return 0; return SSL_add_store_cert_subjects_to_stack(cctx->canames, value); } static int cmd_ClientCAStore(SSL_CONF_CTX *cctx, const char *value) { return cmd_RequestCAStore(cctx, value); } static int cmd_DHParameters(SSL_CONF_CTX *cctx, const char *value) { int rv = 0; EVP_PKEY *dhpkey = NULL; BIO *in = NULL; SSL_CTX *sslctx = (cctx->ssl != NULL) ? cctx->ssl->ctx : cctx->ctx; OSSL_DECODER_CTX *decoderctx = NULL; if (cctx->ctx != NULL || cctx->ssl != NULL) { in = BIO_new(BIO_s_file()); if (in == NULL) goto end; if (BIO_read_filename(in, value) <= 0) goto end; decoderctx = OSSL_DECODER_CTX_new_for_pkey(&dhpkey, "PEM", NULL, "DH", OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS, sslctx->libctx, sslctx->propq); if (decoderctx == NULL) goto end; ERR_set_mark(); while (!OSSL_DECODER_from_bio(decoderctx, in) && dhpkey == NULL && !BIO_eof(in)); OSSL_DECODER_CTX_free(decoderctx); if (dhpkey == NULL) { ERR_clear_last_mark(); goto end; } ERR_pop_to_mark(); } else { return 1; } if (cctx->ctx != NULL) { if ((rv = SSL_CTX_set0_tmp_dh_pkey(cctx->ctx, dhpkey)) > 0) dhpkey = NULL; } if (cctx->ssl != NULL) { if ((rv = SSL_set0_tmp_dh_pkey(cctx->ssl, dhpkey)) > 0) dhpkey = NULL; } end: EVP_PKEY_free(dhpkey); BIO_free(in); return rv > 0; } static int cmd_RecordPadding(SSL_CONF_CTX *cctx, const char *value) { int rv = 0; int block_size = atoi(value); /* * All we care about is a non-negative value, * the setters check the range */ if (block_size >= 0) { if (cctx->ctx) rv = SSL_CTX_set_block_padding(cctx->ctx, block_size); if (cctx->ssl) rv = SSL_set_block_padding(cctx->ssl, block_size); } return rv; } static int cmd_NumTickets(SSL_CONF_CTX *cctx, const char *value) { int rv = 0; int num_tickets = atoi(value); if (num_tickets >= 0) { if (cctx->ctx) rv = SSL_CTX_set_num_tickets(cctx->ctx, num_tickets); if (cctx->ssl) rv = SSL_set_num_tickets(cctx->ssl, num_tickets); } return rv; } typedef struct { int (*cmd) (SSL_CONF_CTX *cctx, const char *value); const char *str_file; const char *str_cmdline; unsigned short flags; unsigned short value_type; } ssl_conf_cmd_tbl; /* Table of supported parameters */ #define SSL_CONF_CMD(name, cmdopt, flags, type) \ {cmd_##name, #name, cmdopt, flags, type} #define SSL_CONF_CMD_STRING(name, cmdopt, flags) \ SSL_CONF_CMD(name, cmdopt, flags, SSL_CONF_TYPE_STRING) #define SSL_CONF_CMD_SWITCH(name, flags) \ {0, NULL, name, flags, SSL_CONF_TYPE_NONE} /* See apps/include/opt.h if you change this table. */ /* The SSL_CONF_CMD_SWITCH should be the same order as ssl_cmd_switches */ static const ssl_conf_cmd_tbl ssl_conf_cmds[] = { SSL_CONF_CMD_SWITCH("no_ssl3", 0), SSL_CONF_CMD_SWITCH("no_tls1", 0), SSL_CONF_CMD_SWITCH("no_tls1_1", 0), SSL_CONF_CMD_SWITCH("no_tls1_2", 0), SSL_CONF_CMD_SWITCH("no_tls1_3", 0), SSL_CONF_CMD_SWITCH("bugs", 0), SSL_CONF_CMD_SWITCH("no_comp", 0), SSL_CONF_CMD_SWITCH("comp", 0), SSL_CONF_CMD_SWITCH("no_tx_cert_comp", 0), SSL_CONF_CMD_SWITCH("tx_cert_comp", 0), SSL_CONF_CMD_SWITCH("no_rx_cert_comp", 0), SSL_CONF_CMD_SWITCH("rx_cert_comp", 0), SSL_CONF_CMD_SWITCH("ecdh_single", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("no_ticket", 0), SSL_CONF_CMD_SWITCH("serverpref", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("legacy_renegotiation", 0), SSL_CONF_CMD_SWITCH("client_renegotiation", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("legacy_server_connect", SSL_CONF_FLAG_CLIENT), SSL_CONF_CMD_SWITCH("no_renegotiation", 0), SSL_CONF_CMD_SWITCH("no_resumption_on_reneg", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("no_legacy_server_connect", SSL_CONF_FLAG_CLIENT), SSL_CONF_CMD_SWITCH("allow_no_dhe_kex", 0), SSL_CONF_CMD_SWITCH("prefer_no_dhe_kex", 0), SSL_CONF_CMD_SWITCH("prioritize_chacha", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("strict", 0), SSL_CONF_CMD_SWITCH("no_middlebox", 0), SSL_CONF_CMD_SWITCH("anti_replay", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("no_anti_replay", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_SWITCH("no_etm", 0), SSL_CONF_CMD_SWITCH("no_ems", 0), SSL_CONF_CMD_STRING(SignatureAlgorithms, "sigalgs", 0), SSL_CONF_CMD_STRING(ClientSignatureAlgorithms, "client_sigalgs", 0), SSL_CONF_CMD_STRING(Curves, "curves", 0), SSL_CONF_CMD_STRING(Groups, "groups", 0), SSL_CONF_CMD_STRING(ECDHParameters, "named_curve", SSL_CONF_FLAG_SERVER), SSL_CONF_CMD_STRING(CipherString, "cipher", 0), SSL_CONF_CMD_STRING(Ciphersuites, "ciphersuites", 0), SSL_CONF_CMD_STRING(Protocol, NULL, 0), SSL_CONF_CMD_STRING(MinProtocol, "min_protocol", 0), SSL_CONF_CMD_STRING(MaxProtocol, "max_protocol", 0), SSL_CONF_CMD_STRING(Options, NULL, 0), SSL_CONF_CMD_STRING(VerifyMode, NULL, 0), SSL_CONF_CMD(Certificate, "cert", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(PrivateKey, "key", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(ServerInfoFile, NULL, SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(ChainCAPath, "chainCApath", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_DIR), SSL_CONF_CMD(ChainCAFile, "chainCAfile", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(ChainCAStore, "chainCAstore", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_STORE), SSL_CONF_CMD(VerifyCAPath, "verifyCApath", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_DIR), SSL_CONF_CMD(VerifyCAFile, "verifyCAfile", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(VerifyCAStore, "verifyCAstore", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_STORE), SSL_CONF_CMD(RequestCAFile, "requestCAFile", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(ClientCAFile, NULL, SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD(RequestCAPath, NULL, SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_DIR), SSL_CONF_CMD(ClientCAPath, NULL, SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_DIR), SSL_CONF_CMD(RequestCAStore, "requestCAStore", SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_STORE), SSL_CONF_CMD(ClientCAStore, NULL, SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_STORE), SSL_CONF_CMD(DHParameters, "dhparam", SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE, SSL_CONF_TYPE_FILE), SSL_CONF_CMD_STRING(RecordPadding, "record_padding", 0), SSL_CONF_CMD_STRING(NumTickets, "num_tickets", SSL_CONF_FLAG_SERVER), }; /* Supported switches: must match order of switches in ssl_conf_cmds */ static const ssl_switch_tbl ssl_cmd_switches[] = { {SSL_OP_NO_SSLv3, 0}, /* no_ssl3 */ {SSL_OP_NO_TLSv1, 0}, /* no_tls1 */ {SSL_OP_NO_TLSv1_1, 0}, /* no_tls1_1 */ {SSL_OP_NO_TLSv1_2, 0}, /* no_tls1_2 */ {SSL_OP_NO_TLSv1_3, 0}, /* no_tls1_3 */ {SSL_OP_ALL, 0}, /* bugs */ {SSL_OP_NO_COMPRESSION, 0}, /* no_comp */ {SSL_OP_NO_COMPRESSION, SSL_TFLAG_INV}, /* comp */ {SSL_OP_NO_TX_CERTIFICATE_COMPRESSION, 0}, /* no_tx_cert_comp */ {SSL_OP_NO_TX_CERTIFICATE_COMPRESSION, SSL_TFLAG_INV}, /* tx_cert_comp */ {SSL_OP_NO_RX_CERTIFICATE_COMPRESSION, 0}, /* no_rx_cert_comp */ {SSL_OP_NO_RX_CERTIFICATE_COMPRESSION, SSL_TFLAG_INV}, /* rx_cert_comp */ {SSL_OP_SINGLE_ECDH_USE, 0}, /* ecdh_single */ {SSL_OP_NO_TICKET, 0}, /* no_ticket */ {SSL_OP_CIPHER_SERVER_PREFERENCE, 0}, /* serverpref */ /* legacy_renegotiation */ {SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, 0}, /* Allow client renegotiation */ {SSL_OP_ALLOW_CLIENT_RENEGOTIATION, 0}, /* legacy_server_connect */ {SSL_OP_LEGACY_SERVER_CONNECT, 0}, /* no_renegotiation */ {SSL_OP_NO_RENEGOTIATION, 0}, /* no_resumption_on_reneg */ {SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, 0}, /* no_legacy_server_connect */ {SSL_OP_LEGACY_SERVER_CONNECT, SSL_TFLAG_INV}, /* allow_no_dhe_kex */ {SSL_OP_ALLOW_NO_DHE_KEX, 0}, /* prefer_no_dhe_kex */ {SSL_OP_PREFER_NO_DHE_KEX, 0}, /* chacha reprioritization */ {SSL_OP_PRIORITIZE_CHACHA, 0}, {SSL_CERT_FLAG_TLS_STRICT, SSL_TFLAG_CERT}, /* strict */ /* no_middlebox */ {SSL_OP_ENABLE_MIDDLEBOX_COMPAT, SSL_TFLAG_INV}, /* anti_replay */ {SSL_OP_NO_ANTI_REPLAY, SSL_TFLAG_INV}, /* no_anti_replay */ {SSL_OP_NO_ANTI_REPLAY, 0}, /* no Encrypt-then-Mac */ {SSL_OP_NO_ENCRYPT_THEN_MAC, 0}, /* no Extended master secret */ {SSL_OP_NO_EXTENDED_MASTER_SECRET, 0}, }; static int ssl_conf_cmd_skip_prefix(SSL_CONF_CTX *cctx, const char **pcmd) { if (pcmd == NULL || *pcmd == NULL) return 0; /* If a prefix is set, check and skip */ if (cctx->prefix) { if (strlen(*pcmd) <= cctx->prefixlen) return 0; if (cctx->flags & SSL_CONF_FLAG_CMDLINE && strncmp(*pcmd, cctx->prefix, cctx->prefixlen)) return 0; if (cctx->flags & SSL_CONF_FLAG_FILE && OPENSSL_strncasecmp(*pcmd, cctx->prefix, cctx->prefixlen)) return 0; *pcmd += cctx->prefixlen; } else if (cctx->flags & SSL_CONF_FLAG_CMDLINE) { if (**pcmd != '-' || !(*pcmd)[1]) return 0; *pcmd += 1; } return 1; } /* Determine if a command is allowed according to cctx flags */ static int ssl_conf_cmd_allowed(SSL_CONF_CTX *cctx, const ssl_conf_cmd_tbl *t) { unsigned int tfl = t->flags; unsigned int cfl = cctx->flags; if ((tfl & SSL_CONF_FLAG_SERVER) && !(cfl & SSL_CONF_FLAG_SERVER)) return 0; if ((tfl & SSL_CONF_FLAG_CLIENT) && !(cfl & SSL_CONF_FLAG_CLIENT)) return 0; if ((tfl & SSL_CONF_FLAG_CERTIFICATE) && !(cfl & SSL_CONF_FLAG_CERTIFICATE)) return 0; return 1; } static const ssl_conf_cmd_tbl *ssl_conf_cmd_lookup(SSL_CONF_CTX *cctx, const char *cmd) { const ssl_conf_cmd_tbl *t; size_t i; if (cmd == NULL) return NULL; /* Look for matching parameter name in table */ for (i = 0, t = ssl_conf_cmds; i < OSSL_NELEM(ssl_conf_cmds); i++, t++) { if (ssl_conf_cmd_allowed(cctx, t)) { if (cctx->flags & SSL_CONF_FLAG_CMDLINE) { if (t->str_cmdline && strcmp(t->str_cmdline, cmd) == 0) return t; } if (cctx->flags & SSL_CONF_FLAG_FILE) { if (t->str_file && OPENSSL_strcasecmp(t->str_file, cmd) == 0) return t; } } } return NULL; } static int ctrl_switch_option(SSL_CONF_CTX *cctx, const ssl_conf_cmd_tbl *cmd) { /* Find index of command in table */ size_t idx = cmd - ssl_conf_cmds; const ssl_switch_tbl *scmd; /* Sanity check index */ if (idx >= OSSL_NELEM(ssl_cmd_switches)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } /* Obtain switches entry with same index */ scmd = ssl_cmd_switches + idx; ssl_set_option(cctx, scmd->name_flags, scmd->option_value, 1); return 1; } int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value) { const ssl_conf_cmd_tbl *runcmd; if (cmd == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_NULL_CMD_NAME); return 0; } if (!ssl_conf_cmd_skip_prefix(cctx, &cmd)) goto unknown_cmd; runcmd = ssl_conf_cmd_lookup(cctx, cmd); if (runcmd) { int rv = -3; if (runcmd->value_type == SSL_CONF_TYPE_NONE) { return ctrl_switch_option(cctx, runcmd); } if (value == NULL) goto bad_value; rv = runcmd->cmd(cctx, value); if (rv > 0) return 2; if (rv != -2) rv = 0; bad_value: if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS) ERR_raise_data(ERR_LIB_SSL, SSL_R_BAD_VALUE, "cmd=%s, value=%s", cmd, value != NULL ? value : "<EMPTY>"); return rv; } unknown_cmd: if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS) ERR_raise_data(ERR_LIB_SSL, SSL_R_UNKNOWN_CMD_NAME, "cmd=%s", cmd); return -2; } int SSL_CONF_cmd_argv(SSL_CONF_CTX *cctx, int *pargc, char ***pargv) { int rv; const char *arg = NULL, *argn; if (pargc != NULL && *pargc == 0) return 0; if (pargc == NULL || *pargc > 0) arg = **pargv; if (arg == NULL) return 0; if (pargc == NULL || *pargc > 1) argn = (*pargv)[1]; else argn = NULL; cctx->flags &= ~SSL_CONF_FLAG_FILE; cctx->flags |= SSL_CONF_FLAG_CMDLINE; rv = SSL_CONF_cmd(cctx, arg, argn); if (rv > 0) { /* Success: update pargc, pargv */ (*pargv) += rv; if (pargc) (*pargc) -= rv; return rv; } /* Unknown switch: indicate no arguments processed */ if (rv == -2) return 0; /* Some error occurred processing command, return fatal error */ if (rv == 0) return -1; return rv; } int SSL_CONF_cmd_value_type(SSL_CONF_CTX *cctx, const char *cmd) { if (ssl_conf_cmd_skip_prefix(cctx, &cmd)) { const ssl_conf_cmd_tbl *runcmd; runcmd = ssl_conf_cmd_lookup(cctx, cmd); if (runcmd) return runcmd->value_type; } return SSL_CONF_TYPE_UNKNOWN; } SSL_CONF_CTX *SSL_CONF_CTX_new(void) { SSL_CONF_CTX *ret = OPENSSL_zalloc(sizeof(*ret)); return ret; } int SSL_CONF_CTX_finish(SSL_CONF_CTX *cctx) { /* See if any certificates are missing private keys */ size_t i; CERT *c = NULL; if (cctx->ctx != NULL) { c = cctx->ctx->cert; } else if (cctx->ssl != NULL) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(cctx->ssl); if (sc != NULL) c = sc->cert; } if (c != NULL && cctx->flags & SSL_CONF_FLAG_REQUIRE_PRIVATE) { for (i = 0; i < SSL_PKEY_NUM; i++) { const char *p = cctx->cert_filename[i]; /* * If missing private key try to load one from certificate file */ if (p && !c->pkeys[i].privatekey) { if (!cmd_PrivateKey(cctx, p)) return 0; } } } if (cctx->canames) { if (cctx->ssl) SSL_set0_CA_list(cctx->ssl, cctx->canames); else if (cctx->ctx) SSL_CTX_set0_CA_list(cctx->ctx, cctx->canames); else sk_X509_NAME_pop_free(cctx->canames, X509_NAME_free); cctx->canames = NULL; } return 1; } void SSL_CONF_CTX_free(SSL_CONF_CTX *cctx) { if (cctx) { size_t i; for (i = 0; i < SSL_PKEY_NUM; i++) OPENSSL_free(cctx->cert_filename[i]); OPENSSL_free(cctx->prefix); sk_X509_NAME_pop_free(cctx->canames, X509_NAME_free); OPENSSL_free(cctx); } } unsigned int SSL_CONF_CTX_set_flags(SSL_CONF_CTX *cctx, unsigned int flags) { cctx->flags |= flags; return cctx->flags; } unsigned int SSL_CONF_CTX_clear_flags(SSL_CONF_CTX *cctx, unsigned int flags) { cctx->flags &= ~flags; return cctx->flags; } int SSL_CONF_CTX_set1_prefix(SSL_CONF_CTX *cctx, const char *pre) { char *tmp = NULL; if (pre) { tmp = OPENSSL_strdup(pre); if (tmp == NULL) return 0; } OPENSSL_free(cctx->prefix); cctx->prefix = tmp; if (tmp) cctx->prefixlen = strlen(tmp); else cctx->prefixlen = 0; return 1; } void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl) { cctx->ssl = ssl; cctx->ctx = NULL; if (ssl != NULL) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return; cctx->poptions = &sc->options; cctx->min_version = &sc->min_proto_version; cctx->max_version = &sc->max_proto_version; cctx->pcert_flags = &sc->cert->cert_flags; cctx->pvfy_flags = &sc->verify_mode; } else { cctx->poptions = NULL; cctx->min_version = NULL; cctx->max_version = NULL; cctx->pcert_flags = NULL; cctx->pvfy_flags = NULL; } } void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx) { cctx->ctx = ctx; cctx->ssl = NULL; if (ctx) { cctx->poptions = &ctx->options; cctx->min_version = &ctx->min_proto_version; cctx->max_version = &ctx->max_proto_version; cctx->pcert_flags = &ctx->cert->cert_flags; cctx->pvfy_flags = &ctx->verify_mode; } else { cctx->poptions = NULL; cctx->min_version = NULL; cctx->max_version = NULL; cctx->pcert_flags = NULL; cctx->pvfy_flags = NULL; } }

./openssl/ssl/methods.c

/* * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <openssl/macros.h> #include <openssl/objects.h> #include "ssl_local.h" /*- * TLS/SSLv3 methods */ IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0, TLS_method, ossl_statem_accept, ossl_statem_connect, TLSv1_2_enc_data) IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3, tlsv1_3_method, ossl_statem_accept, ossl_statem_connect, TLSv1_3_enc_data) #ifndef OPENSSL_NO_TLS1_2_METHOD IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2, tlsv1_2_method, ossl_statem_accept, ossl_statem_connect, TLSv1_2_enc_data) #endif #ifndef OPENSSL_NO_TLS1_1_METHOD IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1, tlsv1_1_method, ossl_statem_accept, ossl_statem_connect, TLSv1_1_enc_data) #endif #ifndef OPENSSL_NO_TLS1_METHOD IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1, tlsv1_method, ossl_statem_accept, ossl_statem_connect, TLSv1_enc_data) #endif #ifndef OPENSSL_NO_SSL3_METHOD IMPLEMENT_ssl3_meth_func(sslv3_method, ossl_statem_accept, ossl_statem_connect) #endif /*- * TLS/SSLv3 server methods */ IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0, TLS_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_2_enc_data) IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3, tlsv1_3_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_3_enc_data) #ifndef OPENSSL_NO_TLS1_2_METHOD IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2, tlsv1_2_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_2_enc_data) #endif #ifndef OPENSSL_NO_TLS1_1_METHOD IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1, tlsv1_1_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_1_enc_data) #endif #ifndef OPENSSL_NO_TLS1_METHOD IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1, tlsv1_server_method, ossl_statem_accept, ssl_undefined_function, TLSv1_enc_data) #endif #ifndef OPENSSL_NO_SSL3_METHOD IMPLEMENT_ssl3_meth_func(sslv3_server_method, ossl_statem_accept, ssl_undefined_function) #endif /*- * TLS/SSLv3 client methods */ IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0, TLS_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_2_enc_data) IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3, tlsv1_3_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_3_enc_data) #ifndef OPENSSL_NO_TLS1_2_METHOD IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2, tlsv1_2_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_2_enc_data) #endif #ifndef OPENSSL_NO_TLS1_1_METHOD IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1, tlsv1_1_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_1_enc_data) #endif #ifndef OPENSSL_NO_TLS1_METHOD IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1, tlsv1_client_method, ssl_undefined_function, ossl_statem_connect, TLSv1_enc_data) #endif #ifndef OPENSSL_NO_SSL3_METHOD IMPLEMENT_ssl3_meth_func(sslv3_client_method, ssl_undefined_function, ossl_statem_connect) #endif /*- * DTLS methods */ #ifndef OPENSSL_NO_DTLS1_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1, dtlsv1_method, ossl_statem_accept, ossl_statem_connect, DTLSv1_enc_data) #endif #ifndef OPENSSL_NO_DTLS1_2_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2, dtlsv1_2_method, ossl_statem_accept, ossl_statem_connect, DTLSv1_2_enc_data) #endif IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0, DTLS_method, ossl_statem_accept, ossl_statem_connect, DTLSv1_2_enc_data) /*- * DTLS server methods */ #ifndef OPENSSL_NO_DTLS1_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1, dtlsv1_server_method, ossl_statem_accept, ssl_undefined_function, DTLSv1_enc_data) #endif #ifndef OPENSSL_NO_DTLS1_2_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2, dtlsv1_2_server_method, ossl_statem_accept, ssl_undefined_function, DTLSv1_2_enc_data) #endif IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0, DTLS_server_method, ossl_statem_accept, ssl_undefined_function, DTLSv1_2_enc_data) /*- * DTLS client methods */ #ifndef OPENSSL_NO_DTLS1_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1, dtlsv1_client_method, ssl_undefined_function, ossl_statem_connect, DTLSv1_enc_data) IMPLEMENT_dtls1_meth_func(DTLS1_BAD_VER, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1, dtls_bad_ver_client_method, ssl_undefined_function, ossl_statem_connect, DTLSv1_enc_data) #endif #ifndef OPENSSL_NO_DTLS1_2_METHOD IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2, dtlsv1_2_client_method, ssl_undefined_function, ossl_statem_connect, DTLSv1_2_enc_data) #endif IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0, DTLS_client_method, ssl_undefined_function, ossl_statem_connect, DTLSv1_2_enc_data) #ifndef OPENSSL_NO_DEPRECATED_1_1_0 # ifndef OPENSSL_NO_TLS1_2_METHOD const SSL_METHOD *TLSv1_2_method(void) { return tlsv1_2_method(); } const SSL_METHOD *TLSv1_2_server_method(void) { return tlsv1_2_server_method(); } const SSL_METHOD *TLSv1_2_client_method(void) { return tlsv1_2_client_method(); } # endif # ifndef OPENSSL_NO_TLS1_1_METHOD const SSL_METHOD *TLSv1_1_method(void) { return tlsv1_1_method(); } const SSL_METHOD *TLSv1_1_server_method(void) { return tlsv1_1_server_method(); } const SSL_METHOD *TLSv1_1_client_method(void) { return tlsv1_1_client_method(); } # endif # ifndef OPENSSL_NO_TLS1_METHOD const SSL_METHOD *TLSv1_method(void) { return tlsv1_method(); } const SSL_METHOD *TLSv1_server_method(void) { return tlsv1_server_method(); } const SSL_METHOD *TLSv1_client_method(void) { return tlsv1_client_method(); } # endif # ifndef OPENSSL_NO_SSL3_METHOD const SSL_METHOD *SSLv3_method(void) { return sslv3_method(); } const SSL_METHOD *SSLv3_server_method(void) { return sslv3_server_method(); } const SSL_METHOD *SSLv3_client_method(void) { return sslv3_client_method(); } # endif # ifndef OPENSSL_NO_DTLS1_2_METHOD const SSL_METHOD *DTLSv1_2_method(void) { return dtlsv1_2_method(); } const SSL_METHOD *DTLSv1_2_server_method(void) { return dtlsv1_2_server_method(); } const SSL_METHOD *DTLSv1_2_client_method(void) { return dtlsv1_2_client_method(); } # endif # ifndef OPENSSL_NO_DTLS1_METHOD const SSL_METHOD *DTLSv1_method(void) { return dtlsv1_method(); } const SSL_METHOD *DTLSv1_server_method(void) { return dtlsv1_server_method(); } const SSL_METHOD *DTLSv1_client_method(void) { return dtlsv1_client_method(); } # endif #endif

./openssl/ssl/ssl_cert_comp.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include "ssl_local.h" #include "internal/e_os.h" #include "internal/refcount.h" size_t ossl_calculate_comp_expansion(int alg, size_t length) { size_t ret; /* * Uncompressibility expansion: * ZLIB: N + 11 + 5 * (N >> 14) * Brotli: per RFC7932: N + 5 + 3 * (N >> 16) * ZSTD: N + 4 + 14 + 3 * (N >> 17) + 4 */ switch (alg) { case TLSEXT_comp_cert_zlib: ret = length + 11 + 5 * (length >> 14); break; case TLSEXT_comp_cert_brotli: ret = length + 5 + 3 * (length >> 16); break; case TLSEXT_comp_cert_zstd: ret = length + 22 + 3 * (length >> 17); break; default: return 0; } /* Check for overflow */ if (ret < length) return 0; return ret; } int ossl_comp_has_alg(int a) { #ifndef OPENSSL_NO_COMP_ALG /* 0 means "any" algorithm */ if ((a == 0 || a == TLSEXT_comp_cert_brotli) && BIO_f_brotli() != NULL) return 1; if ((a == 0 || a == TLSEXT_comp_cert_zstd) && BIO_f_zstd() != NULL) return 1; if ((a == 0 || a == TLSEXT_comp_cert_zlib) && BIO_f_zlib() != NULL) return 1; #endif return 0; } /* New operation Helper routine */ #ifndef OPENSSL_NO_COMP_ALG static OSSL_COMP_CERT *OSSL_COMP_CERT_new(unsigned char *data, size_t len, size_t orig_len, int alg) { OSSL_COMP_CERT *ret = NULL; if (!ossl_comp_has_alg(alg) || data == NULL || (ret = OPENSSL_zalloc(sizeof(*ret))) == NULL || !CRYPTO_NEW_REF(&ret->references, 1)) goto err; ret->data = data; ret->len = len; ret->orig_len = orig_len; ret->alg = alg; return ret; err: ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE); OPENSSL_free(data); OPENSSL_free(ret); return NULL; } __owur static OSSL_COMP_CERT *OSSL_COMP_CERT_from_compressed_data(unsigned char *data, size_t len, size_t orig_len, int alg) { return OSSL_COMP_CERT_new(OPENSSL_memdup(data, len), len, orig_len, alg); } __owur static OSSL_COMP_CERT *OSSL_COMP_CERT_from_uncompressed_data(unsigned char *data, size_t len, int alg) { OSSL_COMP_CERT *ret = NULL; size_t max_length; int comp_length; COMP_METHOD *method; unsigned char *comp_data = NULL; COMP_CTX *comp_ctx = NULL; switch (alg) { case TLSEXT_comp_cert_brotli: method = COMP_brotli_oneshot(); break; case TLSEXT_comp_cert_zlib: method = COMP_zlib_oneshot(); break; case TLSEXT_comp_cert_zstd: method = COMP_zstd_oneshot(); break; default: goto err; } if ((max_length = ossl_calculate_comp_expansion(alg, len)) == 0 || method == NULL || (comp_ctx = COMP_CTX_new(method)) == NULL || (comp_data = OPENSSL_zalloc(max_length)) == NULL) goto err; comp_length = COMP_compress_block(comp_ctx, comp_data, max_length, data, len); if (comp_length <= 0) goto err; ret = OSSL_COMP_CERT_new(comp_data, comp_length, len, alg); comp_data = NULL; err: OPENSSL_free(comp_data); COMP_CTX_free(comp_ctx); return ret; } void OSSL_COMP_CERT_free(OSSL_COMP_CERT *cc) { int i; if (cc == NULL) return; CRYPTO_DOWN_REF(&cc->references, &i); REF_PRINT_COUNT("OSSL_COMP_CERT", cc); if (i > 0) return; REF_ASSERT_ISNT(i < 0); OPENSSL_free(cc->data); CRYPTO_FREE_REF(&cc->references); OPENSSL_free(cc); } int OSSL_COMP_CERT_up_ref(OSSL_COMP_CERT *cc) { int i; if (CRYPTO_UP_REF(&cc->references, &i) <= 0) return 0; REF_PRINT_COUNT("OSSL_COMP_CERT", cc); REF_ASSERT_ISNT(i < 2); return ((i > 1) ? 1 : 0); } static int ssl_set_cert_comp_pref(int *prefs, int *algs, size_t len) { size_t j = 0; size_t i; int found = 0; int already_set[TLSEXT_comp_cert_limit]; int tmp_prefs[TLSEXT_comp_cert_limit]; /* Note that |len| is the number of |algs| elements */ /* clear all algorithms */ if (len == 0 || algs == NULL) { memset(prefs, 0, sizeof(tmp_prefs)); return 1; } /* This will 0-terminate the array */ memset(tmp_prefs, 0, sizeof(tmp_prefs)); memset(already_set, 0, sizeof(already_set)); /* Include only those algorithms we support, ignoring duplicates and unknowns */ for (i = 0; i < len; i++) { if (algs[i] != 0 && ossl_comp_has_alg(algs[i])) { /* Check for duplicate */ if (already_set[algs[i]]) return 0; tmp_prefs[j++] = algs[i]; already_set[algs[i]] = 1; found = 1; } } if (found) memcpy(prefs, tmp_prefs, sizeof(tmp_prefs)); return found; } static size_t ssl_get_cert_to_compress(SSL *ssl, CERT_PKEY *cpk, unsigned char **data) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); WPACKET tmppkt; BUF_MEM buf = { 0 }; size_t ret = 0; if (sc == NULL || cpk == NULL || !sc->server || !SSL_in_before(ssl)) return 0; /* Use the |tmppkt| for the to-be-compressed data */ if (!WPACKET_init(&tmppkt, &buf)) goto out; /* no context present, add 0-length context */ if (!WPACKET_put_bytes_u8(&tmppkt, 0)) goto out; /* * ssl3_output_cert_chain() may generate an SSLfatal() error, * for this case, we want to ignore it, argument for_comp = 1 */ if (!ssl3_output_cert_chain(sc, &tmppkt, cpk, 1)) goto out; WPACKET_get_total_written(&tmppkt, &ret); out: WPACKET_cleanup(&tmppkt); if (ret != 0 && data != NULL) *data = (unsigned char *)buf.data; else OPENSSL_free(buf.data); return ret; } static int ssl_compress_one_cert(SSL *ssl, CERT_PKEY *cpk, int alg) { unsigned char *cert_data = NULL; OSSL_COMP_CERT *comp_cert = NULL; size_t length; if (cpk == NULL || alg == TLSEXT_comp_cert_none || !ossl_comp_has_alg(alg)) return 0; if ((length = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0) return 0; comp_cert = OSSL_COMP_CERT_from_uncompressed_data(cert_data, length, alg); OPENSSL_free(cert_data); if (comp_cert == NULL) return 0; OSSL_COMP_CERT_free(cpk->comp_cert[alg]); cpk->comp_cert[alg] = comp_cert; return 1; } /* alg_in can be 0, meaning any/all algorithms */ static int ssl_compress_certs(SSL *ssl, CERT_PKEY *cpks, int alg_in) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); int i; int j; int alg; int count = 0; if (sc == NULL || cpks == NULL || !ossl_comp_has_alg(alg_in)) return 0; /* Look through the preferences to see what we have */ for (i = 0; i < TLSEXT_comp_cert_limit; i++) { /* * alg = 0 means compress for everything, but only for algorithms enabled * alg != 0 means compress for that algorithm if enabled */ alg = sc->cert_comp_prefs[i]; if ((alg_in == 0 && alg != TLSEXT_comp_cert_none) || (alg_in != 0 && alg == alg_in)) { for (j = 0; j < SSL_PKEY_NUM; j++) { /* No cert, move on */ if (cpks[j].x509 == NULL) continue; if (!ssl_compress_one_cert(ssl, &cpks[j], alg)) return 0; /* if the cert expanded, set the value in the CERT_PKEY to NULL */ if (cpks[j].comp_cert[alg]->len >= cpks[j].comp_cert[alg]->orig_len) { OSSL_COMP_CERT_free(cpks[j].comp_cert[alg]); cpks[j].comp_cert[alg] = NULL; } else { count++; } } } } return (count > 0); } static size_t ssl_get_compressed_cert(SSL *ssl, CERT_PKEY *cpk, int alg, unsigned char **data, size_t *orig_len) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); size_t cert_len = 0; size_t comp_len = 0; unsigned char *cert_data = NULL; OSSL_COMP_CERT *comp_cert = NULL; if (sc == NULL || cpk == NULL || data == NULL || orig_len == NULL || !sc->server || !SSL_in_before(ssl) || !ossl_comp_has_alg(alg)) return 0; if ((cert_len = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0) goto err; comp_cert = OSSL_COMP_CERT_from_uncompressed_data(cert_data, cert_len, alg); OPENSSL_free(cert_data); if (comp_cert == NULL) goto err; comp_len = comp_cert->len; *orig_len = comp_cert->orig_len; *data = comp_cert->data; comp_cert->data = NULL; err: OSSL_COMP_CERT_free(comp_cert); return comp_len; } static int ossl_set1_compressed_cert(CERT *cert, int algorithm, unsigned char *comp_data, size_t comp_length, size_t orig_length) { OSSL_COMP_CERT *comp_cert; /* No explicit cert set */ if (cert == NULL || cert->key == NULL) return 0; comp_cert = OSSL_COMP_CERT_from_compressed_data(comp_data, comp_length, orig_length, algorithm); if (comp_cert == NULL) return 0; OSSL_COMP_CERT_free(cert->key->comp_cert[algorithm]); cert->key->comp_cert[algorithm] = comp_cert; return 1; } #endif /*- * Public API */ int SSL_CTX_set1_cert_comp_preference(SSL_CTX *ctx, int *algs, size_t len) { #ifndef OPENSSL_NO_COMP_ALG return ssl_set_cert_comp_pref(ctx->cert_comp_prefs, algs, len); #else return 0; #endif } int SSL_set1_cert_comp_preference(SSL *ssl, int *algs, size_t len) { #ifndef OPENSSL_NO_COMP_ALG SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; return ssl_set_cert_comp_pref(sc->cert_comp_prefs, algs, len); #else return 0; #endif } int SSL_compress_certs(SSL *ssl, int alg) { #ifndef OPENSSL_NO_COMP_ALG SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL || sc->cert == NULL) return 0; return ssl_compress_certs(ssl, sc->cert->pkeys, alg); #endif return 0; } int SSL_CTX_compress_certs(SSL_CTX *ctx, int alg) { int ret = 0; #ifndef OPENSSL_NO_COMP_ALG SSL *new = SSL_new(ctx); if (new == NULL) return 0; ret = ssl_compress_certs(new, ctx->cert->pkeys, alg); SSL_free(new); #endif return ret; } size_t SSL_get1_compressed_cert(SSL *ssl, int alg, unsigned char **data, size_t *orig_len) { #ifndef OPENSSL_NO_COMP_ALG SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); CERT_PKEY *cpk = NULL; if (sc->cert != NULL) cpk = sc->cert->key; else cpk = ssl->ctx->cert->key; return ssl_get_compressed_cert(ssl, cpk, alg, data, orig_len); #else return 0; #endif } size_t SSL_CTX_get1_compressed_cert(SSL_CTX *ctx, int alg, unsigned char **data, size_t *orig_len) { #ifndef OPENSSL_NO_COMP_ALG size_t ret; SSL *new = SSL_new(ctx); ret = ssl_get_compressed_cert(new, ctx->cert->key, alg, data, orig_len); SSL_free(new); return ret; #else return 0; #endif } int SSL_CTX_set1_compressed_cert(SSL_CTX *ctx, int algorithm, unsigned char *comp_data, size_t comp_length, size_t orig_length) { #ifndef OPENSSL_NO_COMP_ALG return ossl_set1_compressed_cert(ctx->cert, algorithm, comp_data, comp_length, orig_length); #else return 0; #endif } int SSL_set1_compressed_cert(SSL *ssl, int algorithm, unsigned char *comp_data, size_t comp_length, size_t orig_length) { #ifndef OPENSSL_NO_COMP_ALG SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); /* Cannot set a pre-compressed certificate on a client */ if (sc == NULL || !sc->server) return 0; return ossl_set1_compressed_cert(sc->cert, algorithm, comp_data, comp_length, orig_length); #else return 0; #endif }

./openssl/ssl/ssl_txt.c

/* * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <openssl/buffer.h> #include "ssl_local.h" #ifndef OPENSSL_NO_STDIO int SSL_SESSION_print_fp(FILE *fp, const SSL_SESSION *x) { BIO *b; int ret; if ((b = BIO_new(BIO_s_file())) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); return 0; } BIO_set_fp(b, fp, BIO_NOCLOSE); ret = SSL_SESSION_print(b, x); BIO_free(b); return ret; } #endif int SSL_SESSION_print(BIO *bp, const SSL_SESSION *x) { size_t i; const char *s; int istls13; if (x == NULL) goto err; istls13 = (x->ssl_version == TLS1_3_VERSION); if (BIO_puts(bp, "SSL-Session:\n") <= 0) goto err; s = ssl_protocol_to_string(x->ssl_version); if (BIO_printf(bp, " Protocol : %s\n", s) <= 0) goto err; if (x->cipher == NULL) { if (((x->cipher_id) & 0xff000000) == 0x02000000) { if (BIO_printf(bp, " Cipher : %06lX\n", x->cipher_id & 0xffffff) <= 0) goto err; } else { if (BIO_printf(bp, " Cipher : %04lX\n", x->cipher_id & 0xffff) <= 0) goto err; } } else { if (BIO_printf(bp, " Cipher : %s\n", ((x->cipher->name == NULL) ? "unknown" : x->cipher->name)) <= 0) goto err; } if (BIO_puts(bp, " Session-ID: ") <= 0) goto err; for (i = 0; i < x->session_id_length; i++) { if (BIO_printf(bp, "%02X", x->session_id[i]) <= 0) goto err; } if (BIO_puts(bp, "\n Session-ID-ctx: ") <= 0) goto err; for (i = 0; i < x->sid_ctx_length; i++) { if (BIO_printf(bp, "%02X", x->sid_ctx[i]) <= 0) goto err; } if (istls13) { if (BIO_puts(bp, "\n Resumption PSK: ") <= 0) goto err; } else if (BIO_puts(bp, "\n Master-Key: ") <= 0) goto err; for (i = 0; i < x->master_key_length; i++) { if (BIO_printf(bp, "%02X", x->master_key[i]) <= 0) goto err; } #ifndef OPENSSL_NO_PSK if (BIO_puts(bp, "\n PSK identity: ") <= 0) goto err; if (BIO_printf(bp, "%s", x->psk_identity ? x->psk_identity : "None") <= 0) goto err; if (BIO_puts(bp, "\n PSK identity hint: ") <= 0) goto err; if (BIO_printf (bp, "%s", x->psk_identity_hint ? x->psk_identity_hint : "None") <= 0) goto err; #endif #ifndef OPENSSL_NO_SRP if (BIO_puts(bp, "\n SRP username: ") <= 0) goto err; if (BIO_printf(bp, "%s", x->srp_username ? x->srp_username : "None") <= 0) goto err; #endif if (x->ext.tick_lifetime_hint) { if (BIO_printf(bp, "\n TLS session ticket lifetime hint: %ld (seconds)", x->ext.tick_lifetime_hint) <= 0) goto err; } if (x->ext.tick) { if (BIO_puts(bp, "\n TLS session ticket:\n") <= 0) goto err; if (BIO_dump_indent (bp, (const char *)x->ext.tick, (int)x->ext.ticklen, 4) <= 0) goto err; } #ifndef OPENSSL_NO_COMP if (x->compress_meth != 0) { SSL_COMP *comp = NULL; if (!ssl_cipher_get_evp(NULL, x, NULL, NULL, NULL, NULL, &comp, 0)) goto err; if (comp == NULL) { if (BIO_printf(bp, "\n Compression: %d", x->compress_meth) <= 0) goto err; } else { if (BIO_printf(bp, "\n Compression: %d (%s)", comp->id, comp->name) <= 0) goto err; } } #endif if (!ossl_time_is_zero(x->time)) { if (BIO_printf(bp, "\n Start Time: %lld", (long long)ossl_time_to_time_t(x->time)) <= 0) goto err; } if (!ossl_time_is_zero(x->timeout)) { if (BIO_printf(bp, "\n Timeout : %lld (sec)", (long long)ossl_time2seconds(x->timeout)) <= 0) goto err; } if (BIO_puts(bp, "\n") <= 0) goto err; if (BIO_puts(bp, " Verify return code: ") <= 0) goto err; if (BIO_printf(bp, "%ld (%s)\n", x->verify_result, X509_verify_cert_error_string(x->verify_result)) <= 0) goto err; if (BIO_printf(bp, " Extended master secret: %s\n", x->flags & SSL_SESS_FLAG_EXTMS ? "yes" : "no") <= 0) goto err; if (istls13) { if (BIO_printf(bp, " Max Early Data: %u\n", (unsigned int)x->ext.max_early_data) <= 0) goto err; } return 1; err: return 0; } /* * print session id and master key in NSS keylog format (RSA * Session-ID:<session id> Master-Key:<master key>) */ int SSL_SESSION_print_keylog(BIO *bp, const SSL_SESSION *x) { size_t i; if (x == NULL) goto err; if (x->session_id_length == 0 || x->master_key_length == 0) goto err; /* * the RSA prefix is required by the format's definition although there's * nothing RSA-specific in the output, therefore, we don't have to check if * the cipher suite is based on RSA */ if (BIO_puts(bp, "RSA ") <= 0) goto err; if (BIO_puts(bp, "Session-ID:") <= 0) goto err; for (i = 0; i < x->session_id_length; i++) { if (BIO_printf(bp, "%02X", x->session_id[i]) <= 0) goto err; } if (BIO_puts(bp, " Master-Key:") <= 0) goto err; for (i = 0; i < x->master_key_length; i++) { if (BIO_printf(bp, "%02X", x->master_key[i]) <= 0) goto err; } if (BIO_puts(bp, "\n") <= 0) goto err; return 1; err: return 0; }

./openssl/ssl/s3_enc.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include "ssl_local.h" #include <openssl/evp.h> #include <openssl/md5.h> #include <openssl/core_names.h> #include "internal/cryptlib.h" static int ssl3_generate_key_block(SSL_CONNECTION *s, unsigned char *km, int num) { const EVP_MD *md5 = NULL, *sha1 = NULL; EVP_MD_CTX *m5; EVP_MD_CTX *s1; unsigned char buf[16], smd[SHA_DIGEST_LENGTH]; unsigned char c = 'A'; unsigned int i, k; int ret = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); #ifdef CHARSET_EBCDIC c = os_toascii[c]; /* 'A' in ASCII */ #endif k = 0; md5 = ssl_evp_md_fetch(sctx->libctx, NID_md5, sctx->propq); sha1 = ssl_evp_md_fetch(sctx->libctx, NID_sha1, sctx->propq); m5 = EVP_MD_CTX_new(); s1 = EVP_MD_CTX_new(); if (md5 == NULL || sha1 == NULL || m5 == NULL || s1 == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } for (i = 0; (int)i < num; i += MD5_DIGEST_LENGTH) { k++; if (k > sizeof(buf)) { /* bug: 'buf' is too small for this ciphersuite */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } memset(buf, c, k); c++; if (!EVP_DigestInit_ex(s1, sha1, NULL) || !EVP_DigestUpdate(s1, buf, k) || !EVP_DigestUpdate(s1, s->session->master_key, s->session->master_key_length) || !EVP_DigestUpdate(s1, s->s3.server_random, SSL3_RANDOM_SIZE) || !EVP_DigestUpdate(s1, s->s3.client_random, SSL3_RANDOM_SIZE) || !EVP_DigestFinal_ex(s1, smd, NULL) || !EVP_DigestInit_ex(m5, md5, NULL) || !EVP_DigestUpdate(m5, s->session->master_key, s->session->master_key_length) || !EVP_DigestUpdate(m5, smd, SHA_DIGEST_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if ((int)(i + MD5_DIGEST_LENGTH) > num) { if (!EVP_DigestFinal_ex(m5, smd, NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } memcpy(km, smd, (num - i)); } else { if (!EVP_DigestFinal_ex(m5, km, NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } km += MD5_DIGEST_LENGTH; } OPENSSL_cleanse(smd, sizeof(smd)); ret = 1; err: EVP_MD_CTX_free(m5); EVP_MD_CTX_free(s1); ssl_evp_md_free(md5); ssl_evp_md_free(sha1); return ret; } int ssl3_change_cipher_state(SSL_CONNECTION *s, int which) { unsigned char *p, *mac_secret; size_t md_len; unsigned char *key, *iv; const EVP_CIPHER *ciph; const SSL_COMP *comp = NULL; const EVP_MD *md; int mdi; size_t n, iv_len, key_len; int direction = (which & SSL3_CC_READ) != 0 ? OSSL_RECORD_DIRECTION_READ : OSSL_RECORD_DIRECTION_WRITE; ciph = s->s3.tmp.new_sym_enc; md = s->s3.tmp.new_hash; /* m == NULL will lead to a crash later */ if (!ossl_assert(md != NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } #ifndef OPENSSL_NO_COMP comp = s->s3.tmp.new_compression; #endif p = s->s3.tmp.key_block; mdi = EVP_MD_get_size(md); if (mdi < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } md_len = (size_t)mdi; key_len = EVP_CIPHER_get_key_length(ciph); iv_len = EVP_CIPHER_get_iv_length(ciph); if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) || (which == SSL3_CHANGE_CIPHER_SERVER_READ)) { mac_secret = &(p[0]); n = md_len + md_len; key = &(p[n]); n += key_len + key_len; iv = &(p[n]); n += iv_len + iv_len; } else { n = md_len; mac_secret = &(p[n]); n += md_len + key_len; key = &(p[n]); n += key_len + iv_len; iv = &(p[n]); n += iv_len; } if (n > s->s3.tmp.key_block_length) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!ssl_set_new_record_layer(s, SSL3_VERSION, direction, OSSL_RECORD_PROTECTION_LEVEL_APPLICATION, NULL, 0, key, key_len, iv, iv_len, mac_secret, md_len, ciph, 0, NID_undef, md, comp, NULL)) { /* SSLfatal already called */ goto err; } return 1; err: return 0; } int ssl3_setup_key_block(SSL_CONNECTION *s) { unsigned char *p; const EVP_CIPHER *c; const EVP_MD *hash; int num; int ret = 0; SSL_COMP *comp; if (s->s3.tmp.key_block_length != 0) return 1; if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash, NULL, NULL, &comp, 0)) { /* Error is already recorded */ SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); return 0; } ssl_evp_cipher_free(s->s3.tmp.new_sym_enc); s->s3.tmp.new_sym_enc = c; ssl_evp_md_free(s->s3.tmp.new_hash); s->s3.tmp.new_hash = hash; #ifdef OPENSSL_NO_COMP s->s3.tmp.new_compression = NULL; #else s->s3.tmp.new_compression = comp; #endif num = EVP_MD_get_size(hash); if (num < 0) return 0; num = EVP_CIPHER_get_key_length(c) + num + EVP_CIPHER_get_iv_length(c); num *= 2; ssl3_cleanup_key_block(s); if ((p = OPENSSL_malloc(num)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } s->s3.tmp.key_block_length = num; s->s3.tmp.key_block = p; /* Calls SSLfatal() as required */ ret = ssl3_generate_key_block(s, p, num); return ret; } void ssl3_cleanup_key_block(SSL_CONNECTION *s) { OPENSSL_clear_free(s->s3.tmp.key_block, s->s3.tmp.key_block_length); s->s3.tmp.key_block = NULL; s->s3.tmp.key_block_length = 0; } int ssl3_init_finished_mac(SSL_CONNECTION *s) { BIO *buf = BIO_new(BIO_s_mem()); if (buf == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BIO_LIB); return 0; } ssl3_free_digest_list(s); s->s3.handshake_buffer = buf; (void)BIO_set_close(s->s3.handshake_buffer, BIO_CLOSE); return 1; } /* * Free digest list. Also frees handshake buffer since they are always freed * together. */ void ssl3_free_digest_list(SSL_CONNECTION *s) { BIO_free(s->s3.handshake_buffer); s->s3.handshake_buffer = NULL; EVP_MD_CTX_free(s->s3.handshake_dgst); s->s3.handshake_dgst = NULL; } int ssl3_finish_mac(SSL_CONNECTION *s, const unsigned char *buf, size_t len) { int ret; if (s->s3.handshake_dgst == NULL) { /* Note: this writes to a memory BIO so a failure is a fatal error */ if (len > INT_MAX) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_OVERFLOW_ERROR); return 0; } ret = BIO_write(s->s3.handshake_buffer, (void *)buf, (int)len); if (ret <= 0 || ret != (int)len) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } else { ret = EVP_DigestUpdate(s->s3.handshake_dgst, buf, len); if (!ret) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int ssl3_digest_cached_records(SSL_CONNECTION *s, int keep) { const EVP_MD *md; long hdatalen; void *hdata; if (s->s3.handshake_dgst == NULL) { hdatalen = BIO_get_mem_data(s->s3.handshake_buffer, &hdata); if (hdatalen <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_LENGTH); return 0; } s->s3.handshake_dgst = EVP_MD_CTX_new(); if (s->s3.handshake_dgst == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } md = ssl_handshake_md(s); if (md == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM); return 0; } if (!EVP_DigestInit_ex(s->s3.handshake_dgst, md, NULL) || !EVP_DigestUpdate(s->s3.handshake_dgst, hdata, hdatalen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } if (keep == 0) { BIO_free(s->s3.handshake_buffer); s->s3.handshake_buffer = NULL; } return 1; } void ssl3_digest_master_key_set_params(const SSL_SESSION *session, OSSL_PARAM params[]) { int n = 0; params[n++] = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS, (void *)session->master_key, session->master_key_length); params[n++] = OSSL_PARAM_construct_end(); } size_t ssl3_final_finish_mac(SSL_CONNECTION *s, const char *sender, size_t len, unsigned char *p) { int ret; EVP_MD_CTX *ctx = NULL; if (!ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called */ return 0; } if (EVP_MD_CTX_get_type(s->s3.handshake_dgst) != NID_md5_sha1) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_REQUIRED_DIGEST); return 0; } ctx = EVP_MD_CTX_new(); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } if (!EVP_MD_CTX_copy_ex(ctx, s->s3.handshake_dgst)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); ret = 0; goto err; } ret = EVP_MD_CTX_get_size(ctx); if (ret < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); ret = 0; goto err; } if (sender != NULL) { OSSL_PARAM digest_cmd_params[3]; ssl3_digest_master_key_set_params(s->session, digest_cmd_params); if (EVP_DigestUpdate(ctx, sender, len) <= 0 || EVP_MD_CTX_set_params(ctx, digest_cmd_params) <= 0 || EVP_DigestFinal_ex(ctx, p, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); ret = 0; } } err: EVP_MD_CTX_free(ctx); return ret; } int ssl3_generate_master_secret(SSL_CONNECTION *s, unsigned char *out, unsigned char *p, size_t len, size_t *secret_size) { static const unsigned char *salt[3] = { #ifndef CHARSET_EBCDIC (const unsigned char *)"A", (const unsigned char *)"BB", (const unsigned char *)"CCC", #else (const unsigned char *)"\x41", (const unsigned char *)"\x42\x42", (const unsigned char *)"\x43\x43\x43", #endif }; unsigned char buf[EVP_MAX_MD_SIZE]; EVP_MD_CTX *ctx = EVP_MD_CTX_new(); int i, ret = 1; unsigned int n; size_t ret_secret_size = 0; if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } for (i = 0; i < 3; i++) { if (EVP_DigestInit_ex(ctx, SSL_CONNECTION_GET_CTX(s)->sha1, NULL) <= 0 || EVP_DigestUpdate(ctx, salt[i], strlen((const char *)salt[i])) <= 0 || EVP_DigestUpdate(ctx, p, len) <= 0 || EVP_DigestUpdate(ctx, &(s->s3.client_random[0]), SSL3_RANDOM_SIZE) <= 0 || EVP_DigestUpdate(ctx, &(s->s3.server_random[0]), SSL3_RANDOM_SIZE) <= 0 || EVP_DigestFinal_ex(ctx, buf, &n) <= 0 || EVP_DigestInit_ex(ctx, SSL_CONNECTION_GET_CTX(s)->md5, NULL) <= 0 || EVP_DigestUpdate(ctx, p, len) <= 0 || EVP_DigestUpdate(ctx, buf, n) <= 0 || EVP_DigestFinal_ex(ctx, out, &n) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); ret = 0; break; } out += n; ret_secret_size += n; } EVP_MD_CTX_free(ctx); OPENSSL_cleanse(buf, sizeof(buf)); if (ret) *secret_size = ret_secret_size; return ret; } int ssl3_alert_code(int code) { switch (code) { case SSL_AD_CLOSE_NOTIFY: return SSL3_AD_CLOSE_NOTIFY; case SSL_AD_UNEXPECTED_MESSAGE: return SSL3_AD_UNEXPECTED_MESSAGE; case SSL_AD_BAD_RECORD_MAC: return SSL3_AD_BAD_RECORD_MAC; case SSL_AD_DECRYPTION_FAILED: return SSL3_AD_BAD_RECORD_MAC; case SSL_AD_RECORD_OVERFLOW: return SSL3_AD_BAD_RECORD_MAC; case SSL_AD_DECOMPRESSION_FAILURE: return SSL3_AD_DECOMPRESSION_FAILURE; case SSL_AD_HANDSHAKE_FAILURE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_NO_CERTIFICATE: return SSL3_AD_NO_CERTIFICATE; case SSL_AD_BAD_CERTIFICATE: return SSL3_AD_BAD_CERTIFICATE; case SSL_AD_UNSUPPORTED_CERTIFICATE: return SSL3_AD_UNSUPPORTED_CERTIFICATE; case SSL_AD_CERTIFICATE_REVOKED: return SSL3_AD_CERTIFICATE_REVOKED; case SSL_AD_CERTIFICATE_EXPIRED: return SSL3_AD_CERTIFICATE_EXPIRED; case SSL_AD_CERTIFICATE_UNKNOWN: return SSL3_AD_CERTIFICATE_UNKNOWN; case SSL_AD_ILLEGAL_PARAMETER: return SSL3_AD_ILLEGAL_PARAMETER; case SSL_AD_UNKNOWN_CA: return SSL3_AD_BAD_CERTIFICATE; case SSL_AD_ACCESS_DENIED: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_DECODE_ERROR: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_DECRYPT_ERROR: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_EXPORT_RESTRICTION: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_PROTOCOL_VERSION: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_INSUFFICIENT_SECURITY: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_INTERNAL_ERROR: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_USER_CANCELLED: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_NO_RENEGOTIATION: return -1; /* Don't send it :-) */ case SSL_AD_UNSUPPORTED_EXTENSION: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_CERTIFICATE_UNOBTAINABLE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_UNRECOGNIZED_NAME: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_BAD_CERTIFICATE_HASH_VALUE: return SSL3_AD_HANDSHAKE_FAILURE; case SSL_AD_UNKNOWN_PSK_IDENTITY: return TLS1_AD_UNKNOWN_PSK_IDENTITY; case SSL_AD_INAPPROPRIATE_FALLBACK: return TLS1_AD_INAPPROPRIATE_FALLBACK; case SSL_AD_NO_APPLICATION_PROTOCOL: return TLS1_AD_NO_APPLICATION_PROTOCOL; case SSL_AD_CERTIFICATE_REQUIRED: return SSL_AD_HANDSHAKE_FAILURE; case TLS13_AD_MISSING_EXTENSION: return SSL_AD_HANDSHAKE_FAILURE; default: return -1; } }

./openssl/ssl/ssl_rsa.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include "ssl_local.h" #include "internal/packet.h" #include <openssl/bio.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/x509.h> #include <openssl/x509v3.h> #include <openssl/pem.h> static int ssl_set_cert(CERT *c, X509 *x509, SSL_CTX *ctx); static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey, SSL_CTX *ctx); #define SYNTHV1CONTEXT (SSL_EXT_TLS1_2_AND_BELOW_ONLY \ | SSL_EXT_CLIENT_HELLO \ | SSL_EXT_TLS1_2_SERVER_HELLO \ | SSL_EXT_IGNORE_ON_RESUMPTION) #define NAME_PREFIX1 "SERVERINFO FOR " #define NAME_PREFIX2 "SERVERINFOV2 FOR " int SSL_use_certificate(SSL *ssl, X509 *x) { int rv; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } rv = ssl_security_cert(sc, NULL, x, 0, 1); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); return 0; } return ssl_set_cert(sc->cert, x, SSL_CONNECTION_GET_CTX(sc)); } int SSL_use_certificate_file(SSL *ssl, const char *file, int type) { int j; BIO *in; int ret = 0; X509 *cert = NULL, *x = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } x = X509_new_ex(ssl->ctx->libctx, ssl->ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto end; } if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; cert = d2i_X509_bio(in, &x); } else if (type == SSL_FILETYPE_PEM) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) goto end; j = ERR_R_PEM_LIB; cert = PEM_read_bio_X509(in, &x, sc->default_passwd_callback, sc->default_passwd_callback_userdata); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (cert == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_use_certificate(ssl, x); end: X509_free(x); BIO_free(in); return ret; } int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len) { X509 *x; int ret; x = X509_new_ex(ssl->ctx->libctx, ssl->ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } if (d2i_X509(&x, &d, (long)len)== NULL) { X509_free(x); ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_use_certificate(ssl, x); X509_free(x); return ret; } static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey, SSL_CTX *ctx) { size_t i; if (ssl_cert_lookup_by_pkey(pkey, &i, ctx) == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE); return 0; } if (c->pkeys[i].x509 != NULL && !X509_check_private_key(c->pkeys[i].x509, pkey)) return 0; EVP_PKEY_free(c->pkeys[i].privatekey); EVP_PKEY_up_ref(pkey); c->pkeys[i].privatekey = pkey; c->key = &c->pkeys[i]; return 1; } int SSL_use_PrivateKey(SSL *ssl, EVP_PKEY *pkey) { int ret; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } ret = ssl_set_pkey(sc->cert, pkey, SSL_CONNECTION_GET_CTX(sc)); return ret; } int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type) { int j, ret = 0; BIO *in; EVP_PKEY *pkey = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } if (type == SSL_FILETYPE_PEM) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) goto end; j = ERR_R_PEM_LIB; pkey = PEM_read_bio_PrivateKey_ex(in, NULL, sc->default_passwd_callback, sc->default_passwd_callback_userdata, ssl->ctx->libctx, ssl->ctx->propq); } else if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; pkey = d2i_PrivateKey_ex_bio(in, NULL, ssl->ctx->libctx, ssl->ctx->propq); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_use_PrivateKey(ssl, pkey); EVP_PKEY_free(pkey); end: BIO_free(in); return ret; } int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, const unsigned char *d, long len) { int ret; const unsigned char *p; EVP_PKEY *pkey; p = d; if ((pkey = d2i_PrivateKey_ex(type, NULL, &p, (long)len, ssl->ctx->libctx, ssl->ctx->propq)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_use_PrivateKey(ssl, pkey); EVP_PKEY_free(pkey); return ret; } int SSL_CTX_use_certificate(SSL_CTX *ctx, X509 *x) { int rv; if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } rv = ssl_security_cert(NULL, ctx, x, 0, 1); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); return 0; } return ssl_set_cert(ctx->cert, x, ctx); } static int ssl_set_cert(CERT *c, X509 *x, SSL_CTX *ctx) { EVP_PKEY *pkey; size_t i; pkey = X509_get0_pubkey(x); if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_X509_LIB); return 0; } if (ssl_cert_lookup_by_pkey(pkey, &i, ctx) == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE); return 0; } if (i == SSL_PKEY_ECC && !EVP_PKEY_can_sign(pkey)) { ERR_raise(ERR_LIB_SSL, SSL_R_ECC_CERT_NOT_FOR_SIGNING); return 0; } if (c->pkeys[i].privatekey != NULL) { /* * The return code from EVP_PKEY_copy_parameters is deliberately * ignored. Some EVP_PKEY types cannot do this. * coverity[check_return] */ EVP_PKEY_copy_parameters(pkey, c->pkeys[i].privatekey); ERR_clear_error(); if (!X509_check_private_key(x, c->pkeys[i].privatekey)) { /* * don't fail for a cert/key mismatch, just free current private * key (when switching to a different cert & key, first this * function should be used, then ssl_set_pkey */ EVP_PKEY_free(c->pkeys[i].privatekey); c->pkeys[i].privatekey = NULL; /* clear error queue */ ERR_clear_error(); } } X509_free(c->pkeys[i].x509); X509_up_ref(x); c->pkeys[i].x509 = x; c->key = &(c->pkeys[i]); return 1; } int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type) { int j = SSL_R_BAD_VALUE; BIO *in; int ret = 0; X509 *x = NULL, *cert = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } x = X509_new_ex(ctx->libctx, ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto end; } if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; cert = d2i_X509_bio(in, &x); } else if (type == SSL_FILETYPE_PEM) { j = ERR_R_PEM_LIB; cert = PEM_read_bio_X509(in, &x, ctx->default_passwd_callback, ctx->default_passwd_callback_userdata); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (cert == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_CTX_use_certificate(ctx, x); end: X509_free(x); BIO_free(in); return ret; } int SSL_CTX_use_certificate_ASN1(SSL_CTX *ctx, int len, const unsigned char *d) { X509 *x; int ret; x = X509_new_ex(ctx->libctx, ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } if (d2i_X509(&x, &d, (long)len) == NULL) { X509_free(x); ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_CTX_use_certificate(ctx, x); X509_free(x); return ret; } int SSL_CTX_use_PrivateKey(SSL_CTX *ctx, EVP_PKEY *pkey) { if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } return ssl_set_pkey(ctx->cert, pkey, ctx); } int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type) { int j, ret = 0; BIO *in; EVP_PKEY *pkey = NULL; in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } if (type == SSL_FILETYPE_PEM) { j = ERR_R_PEM_LIB; pkey = PEM_read_bio_PrivateKey_ex(in, NULL, ctx->default_passwd_callback, ctx->default_passwd_callback_userdata, ctx->libctx, ctx->propq); } else if (type == SSL_FILETYPE_ASN1) { j = ERR_R_ASN1_LIB; pkey = d2i_PrivateKey_ex_bio(in, NULL, ctx->libctx, ctx->propq); } else { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE); goto end; } if (pkey == NULL) { ERR_raise(ERR_LIB_SSL, j); goto end; } ret = SSL_CTX_use_PrivateKey(ctx, pkey); EVP_PKEY_free(pkey); end: BIO_free(in); return ret; } int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx, const unsigned char *d, long len) { int ret; const unsigned char *p; EVP_PKEY *pkey; p = d; if ((pkey = d2i_PrivateKey_ex(type, NULL, &p, (long)len, ctx->libctx, ctx->propq)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); return 0; } ret = SSL_CTX_use_PrivateKey(ctx, pkey); EVP_PKEY_free(pkey); return ret; } /* * Read a file that contains our certificate in "PEM" format, possibly * followed by a sequence of CA certificates that should be sent to the peer * in the Certificate message. */ static int use_certificate_chain_file(SSL_CTX *ctx, SSL *ssl, const char *file) { BIO *in; int ret = 0; X509 *x = NULL; pem_password_cb *passwd_callback; void *passwd_callback_userdata; SSL_CTX *real_ctx = (ssl == NULL) ? ctx : ssl->ctx; if (ctx == NULL && ssl == NULL) return 0; ERR_clear_error(); /* clear error stack for * SSL_CTX_use_certificate() */ if (ctx != NULL) { passwd_callback = ctx->default_passwd_callback; passwd_callback_userdata = ctx->default_passwd_callback_userdata; } else { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; passwd_callback = sc->default_passwd_callback; passwd_callback_userdata = sc->default_passwd_callback_userdata; } in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(in, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } x = X509_new_ex(real_ctx->libctx, real_ctx->propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto end; } if (PEM_read_bio_X509_AUX(in, &x, passwd_callback, passwd_callback_userdata) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PEM_LIB); goto end; } if (ctx) ret = SSL_CTX_use_certificate(ctx, x); else ret = SSL_use_certificate(ssl, x); if (ERR_peek_error() != 0) ret = 0; /* Key/certificate mismatch doesn't imply * ret==0 ... */ if (ret) { /* * If we could set up our certificate, now proceed to the CA * certificates. */ X509 *ca; int r; unsigned long err; if (ctx) r = SSL_CTX_clear_chain_certs(ctx); else r = SSL_clear_chain_certs(ssl); if (r == 0) { ret = 0; goto end; } while (1) { ca = X509_new_ex(real_ctx->libctx, real_ctx->propq); if (ca == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto end; } if (PEM_read_bio_X509(in, &ca, passwd_callback, passwd_callback_userdata) != NULL) { if (ctx) r = SSL_CTX_add0_chain_cert(ctx, ca); else r = SSL_add0_chain_cert(ssl, ca); /* * Note that we must not free ca if it was successfully added to * the chain (while we must free the main certificate, since its * reference count is increased by SSL_CTX_use_certificate). */ if (!r) { X509_free(ca); ret = 0; goto end; } } else { X509_free(ca); break; } } /* When the while loop ends, it's usually just EOF. */ err = ERR_peek_last_error(); if (ERR_GET_LIB(err) == ERR_LIB_PEM && ERR_GET_REASON(err) == PEM_R_NO_START_LINE) ERR_clear_error(); else ret = 0; /* some real error */ } end: X509_free(x); BIO_free(in); return ret; } int SSL_CTX_use_certificate_chain_file(SSL_CTX *ctx, const char *file) { return use_certificate_chain_file(ctx, NULL, file); } int SSL_use_certificate_chain_file(SSL *ssl, const char *file) { return use_certificate_chain_file(NULL, ssl, file); } static int serverinfo_find_extension(const unsigned char *serverinfo, size_t serverinfo_length, unsigned int extension_type, const unsigned char **extension_data, size_t *extension_length) { PACKET pkt, data; *extension_data = NULL; *extension_length = 0; if (serverinfo == NULL || serverinfo_length == 0) return -1; if (!PACKET_buf_init(&pkt, serverinfo, serverinfo_length)) return -1; for (;;) { unsigned int type = 0; unsigned long context = 0; /* end of serverinfo */ if (PACKET_remaining(&pkt) == 0) return 0; /* Extension not found */ if (!PACKET_get_net_4(&pkt, &context) || !PACKET_get_net_2(&pkt, &type) || !PACKET_get_length_prefixed_2(&pkt, &data)) return -1; if (type == extension_type) { *extension_data = PACKET_data(&data); *extension_length = PACKET_remaining(&data); return 1; /* Success */ } } /* Unreachable */ } static int serverinfoex_srv_parse_cb(SSL *s, unsigned int ext_type, unsigned int context, const unsigned char *in, size_t inlen, X509 *x, size_t chainidx, int *al, void *arg) { if (inlen != 0) { *al = SSL_AD_DECODE_ERROR; return 0; } return 1; } static int serverinfo_srv_parse_cb(SSL *s, unsigned int ext_type, const unsigned char *in, size_t inlen, int *al, void *arg) { return serverinfoex_srv_parse_cb(s, ext_type, 0, in, inlen, NULL, 0, al, arg); } static int serverinfoex_srv_add_cb(SSL *s, unsigned int ext_type, unsigned int context, const unsigned char **out, size_t *outlen, X509 *x, size_t chainidx, int *al, void *arg) { const unsigned char *serverinfo = NULL; size_t serverinfo_length = 0; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) { *al = SSL_AD_INTERNAL_ERROR; return -1; } /* We only support extensions for the first Certificate */ if ((context & SSL_EXT_TLS1_3_CERTIFICATE) != 0 && chainidx > 0) return 0; /* Is there serverinfo data for the chosen server cert? */ if ((ssl_get_server_cert_serverinfo(sc, &serverinfo, &serverinfo_length)) != 0) { /* Find the relevant extension from the serverinfo */ int retval = serverinfo_find_extension(serverinfo, serverinfo_length, ext_type, out, outlen); if (retval == -1) { *al = SSL_AD_INTERNAL_ERROR; return -1; /* Error */ } if (retval == 0) return 0; /* No extension found, don't send extension */ return 1; /* Send extension */ } return 0; /* No serverinfo data found, don't send * extension */ } static int serverinfo_srv_add_cb(SSL *s, unsigned int ext_type, const unsigned char **out, size_t *outlen, int *al, void *arg) { return serverinfoex_srv_add_cb(s, ext_type, 0, out, outlen, NULL, 0, al, arg); } /* * With a NULL context, this function just checks that the serverinfo data * parses correctly. With a non-NULL context, it registers callbacks for * the included extensions. */ static int serverinfo_process_buffer(unsigned int version, const unsigned char *serverinfo, size_t serverinfo_length, SSL_CTX *ctx) { PACKET pkt; if (serverinfo == NULL || serverinfo_length == 0) return 0; if (version != SSL_SERVERINFOV1 && version != SSL_SERVERINFOV2) return 0; if (!PACKET_buf_init(&pkt, serverinfo, serverinfo_length)) return 0; while (PACKET_remaining(&pkt)) { unsigned long context = 0; unsigned int ext_type = 0; PACKET data; if ((version == SSL_SERVERINFOV2 && !PACKET_get_net_4(&pkt, &context)) || !PACKET_get_net_2(&pkt, &ext_type) || !PACKET_get_length_prefixed_2(&pkt, &data)) return 0; if (ctx == NULL) continue; /* * The old style custom extensions API could be set separately for * server/client, i.e. you could set one custom extension for a client, * and *for the same extension in the same SSL_CTX* you could set a * custom extension for the server as well. It seems quite weird to be * setting a custom extension for both client and server in a single * SSL_CTX - but theoretically possible. This isn't possible in the * new API. Therefore, if we have V1 serverinfo we use the old API. We * also use the old API even if we have V2 serverinfo but the context * looks like an old style <= TLSv1.2 extension. */ if (version == SSL_SERVERINFOV1 || context == SYNTHV1CONTEXT) { if (!SSL_CTX_add_server_custom_ext(ctx, ext_type, serverinfo_srv_add_cb, NULL, NULL, serverinfo_srv_parse_cb, NULL)) return 0; } else { if (!SSL_CTX_add_custom_ext(ctx, ext_type, context, serverinfoex_srv_add_cb, NULL, NULL, serverinfoex_srv_parse_cb, NULL)) return 0; } } return 1; } static size_t extension_contextoff(unsigned int version) { return version == SSL_SERVERINFOV1 ? 4 : 0; } static size_t extension_append_length(unsigned int version, size_t extension_length) { return extension_length + extension_contextoff(version); } static void extension_append(unsigned int version, const unsigned char *extension, const size_t extension_length, unsigned char *serverinfo) { const size_t contextoff = extension_contextoff(version); if (contextoff > 0) { /* We know this only uses the last 2 bytes */ serverinfo[0] = 0; serverinfo[1] = 0; serverinfo[2] = (SYNTHV1CONTEXT >> 8) & 0xff; serverinfo[3] = SYNTHV1CONTEXT & 0xff; } memcpy(serverinfo + contextoff, extension, extension_length); } int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version, const unsigned char *serverinfo, size_t serverinfo_length) { unsigned char *new_serverinfo = NULL; if (ctx == NULL || serverinfo == NULL || serverinfo_length == 0) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } if (version == SSL_SERVERINFOV1) { /* * Convert serverinfo version v1 to v2 and call yourself recursively * over the converted serverinfo. */ const size_t sinfo_length = extension_append_length(SSL_SERVERINFOV1, serverinfo_length); unsigned char *sinfo; int ret; sinfo = OPENSSL_malloc(sinfo_length); if (sinfo == NULL) return 0; extension_append(SSL_SERVERINFOV1, serverinfo, serverinfo_length, sinfo); ret = SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV2, sinfo, sinfo_length); OPENSSL_free(sinfo); return ret; } if (!serverinfo_process_buffer(version, serverinfo, serverinfo_length, NULL)) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SERVERINFO_DATA); return 0; } if (ctx->cert->key == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } new_serverinfo = OPENSSL_realloc(ctx->cert->key->serverinfo, serverinfo_length); if (new_serverinfo == NULL) return 0; ctx->cert->key->serverinfo = new_serverinfo; memcpy(ctx->cert->key->serverinfo, serverinfo, serverinfo_length); ctx->cert->key->serverinfo_length = serverinfo_length; /* * Now that the serverinfo is validated and stored, go ahead and * register callbacks. */ if (!serverinfo_process_buffer(version, serverinfo, serverinfo_length, ctx)) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SERVERINFO_DATA); return 0; } return 1; } int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo, size_t serverinfo_length) { return SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV1, serverinfo, serverinfo_length); } int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file) { unsigned char *serverinfo = NULL; unsigned char *tmp; size_t serverinfo_length = 0; unsigned char *extension = 0; long extension_length = 0; char *name = NULL; char *header = NULL; unsigned int name_len; int ret = 0; BIO *bin = NULL; size_t num_extensions = 0; if (ctx == NULL || file == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); goto end; } bin = BIO_new(BIO_s_file()); if (bin == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto end; } if (BIO_read_filename(bin, file) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto end; } for (num_extensions = 0;; num_extensions++) { unsigned int version; size_t append_length; if (PEM_read_bio(bin, &name, &header, &extension, &extension_length) == 0) { /* * There must be at least one extension in this file */ if (num_extensions == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_PEM_EXTENSIONS); goto end; } else /* End of file, we're done */ break; } /* Check that PEM name starts with "BEGIN SERVERINFO FOR " */ name_len = strlen(name); if (name_len < sizeof(NAME_PREFIX1) - 1) { ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_TOO_SHORT); goto end; } if (HAS_PREFIX(name, NAME_PREFIX1)) { version = SSL_SERVERINFOV1; } else { if (name_len < sizeof(NAME_PREFIX2) - 1) { ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_TOO_SHORT); goto end; } if (!HAS_PREFIX(name, NAME_PREFIX2)) { ERR_raise(ERR_LIB_SSL, SSL_R_PEM_NAME_BAD_PREFIX); goto end; } version = SSL_SERVERINFOV2; } /* * Check that the decoded PEM data is plausible (valid length field) */ if (version == SSL_SERVERINFOV1) { /* 4 byte header: 2 bytes type, 2 bytes len */ if (extension_length < 4 || (extension[2] << 8) + extension[3] != extension_length - 4) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA); goto end; } } else { /* 8 byte header: 4 bytes context, 2 bytes type, 2 bytes len */ if (extension_length < 8 || (extension[6] << 8) + extension[7] != extension_length - 8) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA); goto end; } } /* Append the decoded extension to the serverinfo buffer */ append_length = extension_append_length(version, extension_length); tmp = OPENSSL_realloc(serverinfo, serverinfo_length + append_length); if (tmp == NULL) goto end; serverinfo = tmp; extension_append(version, extension, extension_length, serverinfo + serverinfo_length); serverinfo_length += append_length; OPENSSL_free(name); name = NULL; OPENSSL_free(header); header = NULL; OPENSSL_free(extension); extension = NULL; } ret = SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV2, serverinfo, serverinfo_length); end: /* SSL_CTX_use_serverinfo makes a local copy of the serverinfo. */ OPENSSL_free(name); OPENSSL_free(header); OPENSSL_free(extension); OPENSSL_free(serverinfo); BIO_free(bin); return ret; } static int ssl_set_cert_and_key(SSL *ssl, SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey, STACK_OF(X509) *chain, int override) { int ret = 0; size_t i; int j; int rv; CERT *c; STACK_OF(X509) *dup_chain = NULL; EVP_PKEY *pubkey = NULL; SSL_CONNECTION *sc = NULL; if (ctx == NULL && (sc = SSL_CONNECTION_FROM_SSL(ssl)) == NULL) return 0; c = sc != NULL ? sc->cert : ctx->cert; /* Do all security checks before anything else */ rv = ssl_security_cert(sc, ctx, x509, 0, 1); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); goto out; } for (j = 0; j < sk_X509_num(chain); j++) { rv = ssl_security_cert(sc, ctx, sk_X509_value(chain, j), 0, 0); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); goto out; } } pubkey = X509_get_pubkey(x509); /* bumps reference */ if (pubkey == NULL) goto out; if (privatekey == NULL) { privatekey = pubkey; } else { /* For RSA, which has no parameters, missing returns 0 */ if (EVP_PKEY_missing_parameters(privatekey)) { if (EVP_PKEY_missing_parameters(pubkey)) { /* nobody has parameters? - error */ ERR_raise(ERR_LIB_SSL, SSL_R_MISSING_PARAMETERS); goto out; } else { /* copy to privatekey from pubkey */ if (!EVP_PKEY_copy_parameters(privatekey, pubkey)) { ERR_raise(ERR_LIB_SSL, SSL_R_COPY_PARAMETERS_FAILED); goto out; } } } else if (EVP_PKEY_missing_parameters(pubkey)) { /* copy to pubkey from privatekey */ if (!EVP_PKEY_copy_parameters(pubkey, privatekey)) { ERR_raise(ERR_LIB_SSL, SSL_R_COPY_PARAMETERS_FAILED); goto out; } } /* else both have parameters */ /* check that key <-> cert match */ if (EVP_PKEY_eq(pubkey, privatekey) != 1) { ERR_raise(ERR_LIB_SSL, SSL_R_PRIVATE_KEY_MISMATCH); goto out; } } if (ssl_cert_lookup_by_pkey(pubkey, &i, ctx) == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_CERTIFICATE_TYPE); goto out; } if (!override && (c->pkeys[i].x509 != NULL || c->pkeys[i].privatekey != NULL || c->pkeys[i].chain != NULL)) { /* No override, and something already there */ ERR_raise(ERR_LIB_SSL, SSL_R_NOT_REPLACING_CERTIFICATE); goto out; } if (chain != NULL) { dup_chain = X509_chain_up_ref(chain); if (dup_chain == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto out; } } OSSL_STACK_OF_X509_free(c->pkeys[i].chain); c->pkeys[i].chain = dup_chain; X509_free(c->pkeys[i].x509); X509_up_ref(x509); c->pkeys[i].x509 = x509; EVP_PKEY_free(c->pkeys[i].privatekey); EVP_PKEY_up_ref(privatekey); c->pkeys[i].privatekey = privatekey; c->key = &(c->pkeys[i]); ret = 1; out: EVP_PKEY_free(pubkey); return ret; } int SSL_use_cert_and_key(SSL *ssl, X509 *x509, EVP_PKEY *privatekey, STACK_OF(X509) *chain, int override) { return ssl_set_cert_and_key(ssl, NULL, x509, privatekey, chain, override); } int SSL_CTX_use_cert_and_key(SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey, STACK_OF(X509) *chain, int override) { return ssl_set_cert_and_key(NULL, ctx, x509, privatekey, chain, override); }

./openssl/ssl/ssl_cert.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <sys/types.h> #include "internal/nelem.h" #include "internal/o_dir.h" #include <openssl/bio.h> #include <openssl/pem.h> #include <openssl/store.h> #include <openssl/x509v3.h> #include <openssl/dh.h> #include <openssl/bn.h> #include <openssl/crypto.h> #include "internal/refcount.h" #include "ssl_local.h" #include "ssl_cert_table.h" #include "internal/thread_once.h" #ifndef OPENSSL_NO_POSIX_IO # include <sys/stat.h> # ifdef _WIN32 # define stat _stat # endif # ifndef S_ISDIR # define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR) # endif #endif static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex); static CRYPTO_ONCE ssl_x509_store_ctx_once = CRYPTO_ONCE_STATIC_INIT; static volatile int ssl_x509_store_ctx_idx = -1; DEFINE_RUN_ONCE_STATIC(ssl_x509_store_ctx_init) { ssl_x509_store_ctx_idx = X509_STORE_CTX_get_ex_new_index(0, "SSL for verify callback", NULL, NULL, NULL); return ssl_x509_store_ctx_idx >= 0; } int SSL_get_ex_data_X509_STORE_CTX_idx(void) { if (!RUN_ONCE(&ssl_x509_store_ctx_once, ssl_x509_store_ctx_init)) return -1; return ssl_x509_store_ctx_idx; } CERT *ssl_cert_new(size_t ssl_pkey_num) { CERT *ret = NULL; /* Should never happen */ if (!ossl_assert(ssl_pkey_num >= SSL_PKEY_NUM)) return NULL; ret = OPENSSL_zalloc(sizeof(*ret)); if (ret == NULL) return NULL; ret->ssl_pkey_num = ssl_pkey_num; ret->pkeys = OPENSSL_zalloc(ret->ssl_pkey_num * sizeof(CERT_PKEY)); if (ret->pkeys == NULL) { OPENSSL_free(ret); return NULL; } ret->key = &(ret->pkeys[SSL_PKEY_RSA]); ret->sec_cb = ssl_security_default_callback; ret->sec_level = OPENSSL_TLS_SECURITY_LEVEL; ret->sec_ex = NULL; if (!CRYPTO_NEW_REF(&ret->references, 1)) { OPENSSL_free(ret->pkeys); OPENSSL_free(ret); return NULL; } return ret; } CERT *ssl_cert_dup(CERT *cert) { CERT *ret = OPENSSL_zalloc(sizeof(*ret)); size_t i; #ifndef OPENSSL_NO_COMP_ALG int j; #endif if (ret == NULL) return NULL; ret->ssl_pkey_num = cert->ssl_pkey_num; ret->pkeys = OPENSSL_zalloc(ret->ssl_pkey_num * sizeof(CERT_PKEY)); if (ret->pkeys == NULL) { OPENSSL_free(ret); return NULL; } ret->key = &ret->pkeys[cert->key - cert->pkeys]; if (!CRYPTO_NEW_REF(&ret->references, 1)) { OPENSSL_free(ret->pkeys); OPENSSL_free(ret); return NULL; } if (cert->dh_tmp != NULL) { ret->dh_tmp = cert->dh_tmp; EVP_PKEY_up_ref(ret->dh_tmp); } ret->dh_tmp_cb = cert->dh_tmp_cb; ret->dh_tmp_auto = cert->dh_tmp_auto; for (i = 0; i < ret->ssl_pkey_num; i++) { CERT_PKEY *cpk = cert->pkeys + i; CERT_PKEY *rpk = ret->pkeys + i; if (cpk->x509 != NULL) { rpk->x509 = cpk->x509; X509_up_ref(rpk->x509); } if (cpk->privatekey != NULL) { rpk->privatekey = cpk->privatekey; EVP_PKEY_up_ref(cpk->privatekey); } if (cpk->chain) { rpk->chain = X509_chain_up_ref(cpk->chain); if (!rpk->chain) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } } if (cpk->serverinfo != NULL) { /* Just copy everything. */ rpk->serverinfo = OPENSSL_memdup(cpk->serverinfo, cpk->serverinfo_length); if (rpk->serverinfo == NULL) goto err; rpk->serverinfo_length = cpk->serverinfo_length; } #ifndef OPENSSL_NO_COMP_ALG for (j = TLSEXT_comp_cert_none; j < TLSEXT_comp_cert_limit; j++) { if (cpk->comp_cert[j] != NULL) { if (!OSSL_COMP_CERT_up_ref(cpk->comp_cert[j])) goto err; rpk->comp_cert[j] = cpk->comp_cert[j]; } } #endif } /* Configured sigalgs copied across */ if (cert->conf_sigalgs) { ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen * sizeof(*cert->conf_sigalgs)); if (ret->conf_sigalgs == NULL) goto err; memcpy(ret->conf_sigalgs, cert->conf_sigalgs, cert->conf_sigalgslen * sizeof(*cert->conf_sigalgs)); ret->conf_sigalgslen = cert->conf_sigalgslen; } else ret->conf_sigalgs = NULL; if (cert->client_sigalgs) { ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen * sizeof(*cert->client_sigalgs)); if (ret->client_sigalgs == NULL) goto err; memcpy(ret->client_sigalgs, cert->client_sigalgs, cert->client_sigalgslen * sizeof(*cert->client_sigalgs)); ret->client_sigalgslen = cert->client_sigalgslen; } else ret->client_sigalgs = NULL; /* Copy any custom client certificate types */ if (cert->ctype) { ret->ctype = OPENSSL_memdup(cert->ctype, cert->ctype_len); if (ret->ctype == NULL) goto err; ret->ctype_len = cert->ctype_len; } ret->cert_flags = cert->cert_flags; ret->cert_cb = cert->cert_cb; ret->cert_cb_arg = cert->cert_cb_arg; if (cert->verify_store) { X509_STORE_up_ref(cert->verify_store); ret->verify_store = cert->verify_store; } if (cert->chain_store) { X509_STORE_up_ref(cert->chain_store); ret->chain_store = cert->chain_store; } ret->sec_cb = cert->sec_cb; ret->sec_level = cert->sec_level; ret->sec_ex = cert->sec_ex; if (!custom_exts_copy(&ret->custext, &cert->custext)) goto err; #ifndef OPENSSL_NO_PSK if (cert->psk_identity_hint) { ret->psk_identity_hint = OPENSSL_strdup(cert->psk_identity_hint); if (ret->psk_identity_hint == NULL) goto err; } #endif return ret; err: ssl_cert_free(ret); return NULL; } /* Free up and clear all certificates and chains */ void ssl_cert_clear_certs(CERT *c) { size_t i; #ifndef OPENSSL_NO_COMP_ALG int j; #endif if (c == NULL) return; for (i = 0; i < c->ssl_pkey_num; i++) { CERT_PKEY *cpk = c->pkeys + i; X509_free(cpk->x509); cpk->x509 = NULL; EVP_PKEY_free(cpk->privatekey); cpk->privatekey = NULL; OSSL_STACK_OF_X509_free(cpk->chain); cpk->chain = NULL; OPENSSL_free(cpk->serverinfo); cpk->serverinfo = NULL; cpk->serverinfo_length = 0; #ifndef OPENSSL_NO_COMP_ALG for (j = 0; j < TLSEXT_comp_cert_limit; j++) { OSSL_COMP_CERT_free(cpk->comp_cert[j]); cpk->comp_cert[j] = NULL; cpk->cert_comp_used = 0; } #endif } } void ssl_cert_free(CERT *c) { int i; if (c == NULL) return; CRYPTO_DOWN_REF(&c->references, &i); REF_PRINT_COUNT("CERT", c); if (i > 0) return; REF_ASSERT_ISNT(i < 0); EVP_PKEY_free(c->dh_tmp); ssl_cert_clear_certs(c); OPENSSL_free(c->conf_sigalgs); OPENSSL_free(c->client_sigalgs); OPENSSL_free(c->ctype); X509_STORE_free(c->verify_store); X509_STORE_free(c->chain_store); custom_exts_free(&c->custext); #ifndef OPENSSL_NO_PSK OPENSSL_free(c->psk_identity_hint); #endif OPENSSL_free(c->pkeys); CRYPTO_FREE_REF(&c->references); OPENSSL_free(c); } int ssl_cert_set0_chain(SSL_CONNECTION *s, SSL_CTX *ctx, STACK_OF(X509) *chain) { int i, r; CERT_PKEY *cpk = s != NULL ? s->cert->key : ctx->cert->key; if (!cpk) return 0; for (i = 0; i < sk_X509_num(chain); i++) { X509 *x = sk_X509_value(chain, i); r = ssl_security_cert(s, ctx, x, 0, 0); if (r != 1) { ERR_raise(ERR_LIB_SSL, r); return 0; } } OSSL_STACK_OF_X509_free(cpk->chain); cpk->chain = chain; return 1; } int ssl_cert_set1_chain(SSL_CONNECTION *s, SSL_CTX *ctx, STACK_OF(X509) *chain) { STACK_OF(X509) *dchain; if (!chain) return ssl_cert_set0_chain(s, ctx, NULL); dchain = X509_chain_up_ref(chain); if (!dchain) return 0; if (!ssl_cert_set0_chain(s, ctx, dchain)) { OSSL_STACK_OF_X509_free(dchain); return 0; } return 1; } int ssl_cert_add0_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x) { int r; CERT_PKEY *cpk = s ? s->cert->key : ctx->cert->key; if (!cpk) return 0; r = ssl_security_cert(s, ctx, x, 0, 0); if (r != 1) { ERR_raise(ERR_LIB_SSL, r); return 0; } if (!cpk->chain) cpk->chain = sk_X509_new_null(); if (!cpk->chain || !sk_X509_push(cpk->chain, x)) return 0; return 1; } int ssl_cert_add1_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x) { if (!ssl_cert_add0_chain_cert(s, ctx, x)) return 0; X509_up_ref(x); return 1; } int ssl_cert_select_current(CERT *c, X509 *x) { size_t i; if (x == NULL) return 0; for (i = 0; i < c->ssl_pkey_num; i++) { CERT_PKEY *cpk = c->pkeys + i; if (cpk->x509 == x && cpk->privatekey) { c->key = cpk; return 1; } } for (i = 0; i < c->ssl_pkey_num; i++) { CERT_PKEY *cpk = c->pkeys + i; if (cpk->privatekey && cpk->x509 && !X509_cmp(cpk->x509, x)) { c->key = cpk; return 1; } } return 0; } int ssl_cert_set_current(CERT *c, long op) { size_t i, idx; if (!c) return 0; if (op == SSL_CERT_SET_FIRST) idx = 0; else if (op == SSL_CERT_SET_NEXT) { idx = (size_t)(c->key - c->pkeys + 1); if (idx >= c->ssl_pkey_num) return 0; } else return 0; for (i = idx; i < c->ssl_pkey_num; i++) { CERT_PKEY *cpk = c->pkeys + i; if (cpk->x509 && cpk->privatekey) { c->key = cpk; return 1; } } return 0; } void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg) { c->cert_cb = cb; c->cert_cb_arg = arg; } /* * Verify a certificate chain/raw public key * Return codes: * 1: Verify success * 0: Verify failure or error * -1: Retry required */ static int ssl_verify_internal(SSL_CONNECTION *s, STACK_OF(X509) *sk, EVP_PKEY *rpk) { X509 *x; int i = 0; X509_STORE *verify_store; X509_STORE_CTX *ctx = NULL; X509_VERIFY_PARAM *param; SSL_CTX *sctx; /* Something must be passed in */ if ((sk == NULL || sk_X509_num(sk) == 0) && rpk == NULL) return 0; /* Only one can be set */ if (sk != NULL && rpk != NULL) return 0; sctx = SSL_CONNECTION_GET_CTX(s); if (s->cert->verify_store) verify_store = s->cert->verify_store; else verify_store = sctx->cert_store; ctx = X509_STORE_CTX_new_ex(sctx->libctx, sctx->propq); if (ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); return 0; } if (sk != NULL) { x = sk_X509_value(sk, 0); if (!X509_STORE_CTX_init(ctx, verify_store, x, sk)) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto end; } } else { if (!X509_STORE_CTX_init_rpk(ctx, verify_store, rpk)) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto end; } } param = X509_STORE_CTX_get0_param(ctx); /* * XXX: Separate @AUTHSECLEVEL and @TLSSECLEVEL would be useful at some * point, for now a single @SECLEVEL sets the same policy for TLS crypto * and PKI authentication. */ X509_VERIFY_PARAM_set_auth_level(param, SSL_get_security_level(SSL_CONNECTION_GET_SSL(s))); /* Set suite B flags if needed */ X509_STORE_CTX_set_flags(ctx, tls1_suiteb(s)); if (!X509_STORE_CTX_set_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx(), s)) { goto end; } /* Verify via DANE if enabled */ if (DANETLS_ENABLED(&s->dane)) X509_STORE_CTX_set0_dane(ctx, &s->dane); /* * We need to inherit the verify parameters. These can be determined by * the context: if its a server it will verify SSL client certificates or * vice versa. */ X509_STORE_CTX_set_default(ctx, s->server ? "ssl_client" : "ssl_server"); /* * Anything non-default in "s->param" should overwrite anything in the ctx. */ X509_VERIFY_PARAM_set1(param, s->param); if (s->verify_callback) X509_STORE_CTX_set_verify_cb(ctx, s->verify_callback); if (sctx->app_verify_callback != NULL) { i = sctx->app_verify_callback(ctx, sctx->app_verify_arg); } else { i = X509_verify_cert(ctx); /* We treat an error in the same way as a failure to verify */ if (i < 0) i = 0; } s->verify_result = X509_STORE_CTX_get_error(ctx); OSSL_STACK_OF_X509_free(s->verified_chain); s->verified_chain = NULL; if (sk != NULL && X509_STORE_CTX_get0_chain(ctx) != NULL) { s->verified_chain = X509_STORE_CTX_get1_chain(ctx); if (s->verified_chain == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); i = 0; } } /* Move peername from the store context params to the SSL handle's */ X509_VERIFY_PARAM_move_peername(s->param, param); end: X509_STORE_CTX_free(ctx); return i; } /* * Verify a raw public key * Return codes: * 1: Verify success * 0: Verify failure or error * -1: Retry required */ int ssl_verify_rpk(SSL_CONNECTION *s, EVP_PKEY *rpk) { return ssl_verify_internal(s, NULL, rpk); } /* * Verify a certificate chain * Return codes: * 1: Verify success * 0: Verify failure or error * -1: Retry required */ int ssl_verify_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk) { return ssl_verify_internal(s, sk, NULL); } static void set0_CA_list(STACK_OF(X509_NAME) **ca_list, STACK_OF(X509_NAME) *name_list) { sk_X509_NAME_pop_free(*ca_list, X509_NAME_free); *ca_list = name_list; } STACK_OF(X509_NAME) *SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk) { int i; const int num = sk_X509_NAME_num(sk); STACK_OF(X509_NAME) *ret; X509_NAME *name; ret = sk_X509_NAME_new_reserve(NULL, num); if (ret == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return NULL; } for (i = 0; i < num; i++) { name = X509_NAME_dup(sk_X509_NAME_value(sk, i)); if (name == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); sk_X509_NAME_pop_free(ret, X509_NAME_free); return NULL; } sk_X509_NAME_push(ret, name); /* Cannot fail after reserve call */ } return ret; } void SSL_set0_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; set0_CA_list(&sc->ca_names, name_list); } void SSL_CTX_set0_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list) { set0_CA_list(&ctx->ca_names, name_list); } const STACK_OF(X509_NAME) *SSL_CTX_get0_CA_list(const SSL_CTX *ctx) { return ctx->ca_names; } const STACK_OF(X509_NAME) *SSL_get0_CA_list(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->ca_names != NULL ? sc->ca_names : s->ctx->ca_names; } void SSL_CTX_set_client_CA_list(SSL_CTX *ctx, STACK_OF(X509_NAME) *name_list) { set0_CA_list(&ctx->client_ca_names, name_list); } STACK_OF(X509_NAME) *SSL_CTX_get_client_CA_list(const SSL_CTX *ctx) { return ctx->client_ca_names; } void SSL_set_client_CA_list(SSL *s, STACK_OF(X509_NAME) *name_list) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; set0_CA_list(&sc->client_ca_names, name_list); } const STACK_OF(X509_NAME) *SSL_get0_peer_CA_list(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->s3.tmp.peer_ca_names; } STACK_OF(X509_NAME) *SSL_get_client_CA_list(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (!sc->server) return sc->s3.tmp.peer_ca_names; return sc->client_ca_names != NULL ? sc->client_ca_names : s->ctx->client_ca_names; } static int add_ca_name(STACK_OF(X509_NAME) **sk, const X509 *x) { X509_NAME *name; if (x == NULL) return 0; if (*sk == NULL && ((*sk = sk_X509_NAME_new_null()) == NULL)) return 0; if ((name = X509_NAME_dup(X509_get_subject_name(x))) == NULL) return 0; if (!sk_X509_NAME_push(*sk, name)) { X509_NAME_free(name); return 0; } return 1; } int SSL_add1_to_CA_list(SSL *ssl, const X509 *x) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; return add_ca_name(&sc->ca_names, x); } int SSL_CTX_add1_to_CA_list(SSL_CTX *ctx, const X509 *x) { return add_ca_name(&ctx->ca_names, x); } /* * The following two are older names are to be replaced with * SSL(_CTX)_add1_to_CA_list */ int SSL_add_client_CA(SSL *ssl, X509 *x) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; return add_ca_name(&sc->client_ca_names, x); } int SSL_CTX_add_client_CA(SSL_CTX *ctx, X509 *x) { return add_ca_name(&ctx->client_ca_names, x); } static int xname_cmp(const X509_NAME *a, const X509_NAME *b) { unsigned char *abuf = NULL, *bbuf = NULL; int alen, blen, ret; /* X509_NAME_cmp() itself casts away constness in this way, so * assume it's safe: */ alen = i2d_X509_NAME((X509_NAME *)a, &abuf); blen = i2d_X509_NAME((X509_NAME *)b, &bbuf); if (alen < 0 || blen < 0) ret = -2; else if (alen != blen) ret = alen - blen; else /* alen == blen */ ret = memcmp(abuf, bbuf, alen); OPENSSL_free(abuf); OPENSSL_free(bbuf); return ret; } static int xname_sk_cmp(const X509_NAME *const *a, const X509_NAME *const *b) { return xname_cmp(*a, *b); } static unsigned long xname_hash(const X509_NAME *a) { /* This returns 0 also if SHA1 is not available */ return X509_NAME_hash_ex((X509_NAME *)a, NULL, NULL, NULL); } STACK_OF(X509_NAME) *SSL_load_client_CA_file_ex(const char *file, OSSL_LIB_CTX *libctx, const char *propq) { BIO *in = BIO_new(BIO_s_file()); X509 *x = NULL; X509_NAME *xn = NULL; STACK_OF(X509_NAME) *ret = NULL; LHASH_OF(X509_NAME) *name_hash = lh_X509_NAME_new(xname_hash, xname_cmp); OSSL_LIB_CTX *prev_libctx = NULL; if (name_hash == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB); goto err; } x = X509_new_ex(libctx, propq); if (x == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } if (BIO_read_filename(in, file) <= 0) goto err; /* Internally lh_X509_NAME_retrieve() needs the libctx to retrieve SHA1 */ prev_libctx = OSSL_LIB_CTX_set0_default(libctx); for (;;) { if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL) break; if (ret == NULL) { ret = sk_X509_NAME_new_null(); if (ret == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } } if ((xn = X509_get_subject_name(x)) == NULL) goto err; /* check for duplicates */ xn = X509_NAME_dup(xn); if (xn == NULL) goto err; if (lh_X509_NAME_retrieve(name_hash, xn) != NULL) { /* Duplicate. */ X509_NAME_free(xn); xn = NULL; } else { lh_X509_NAME_insert(name_hash, xn); if (!sk_X509_NAME_push(ret, xn)) goto err; } } goto done; err: X509_NAME_free(xn); sk_X509_NAME_pop_free(ret, X509_NAME_free); ret = NULL; done: /* restore the old libctx */ OSSL_LIB_CTX_set0_default(prev_libctx); BIO_free(in); X509_free(x); lh_X509_NAME_free(name_hash); if (ret != NULL) ERR_clear_error(); return ret; } STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file) { return SSL_load_client_CA_file_ex(file, NULL, NULL); } int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack, const char *file) { BIO *in; X509 *x = NULL; X509_NAME *xn = NULL; int ret = 1; int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b); oldcmp = sk_X509_NAME_set_cmp_func(stack, xname_sk_cmp); in = BIO_new(BIO_s_file()); if (in == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB); goto err; } if (BIO_read_filename(in, file) <= 0) goto err; for (;;) { if (PEM_read_bio_X509(in, &x, NULL, NULL) == NULL) break; if ((xn = X509_get_subject_name(x)) == NULL) goto err; xn = X509_NAME_dup(xn); if (xn == NULL) goto err; if (sk_X509_NAME_find(stack, xn) >= 0) { /* Duplicate. */ X509_NAME_free(xn); } else if (!sk_X509_NAME_push(stack, xn)) { X509_NAME_free(xn); goto err; } } ERR_clear_error(); goto done; err: ret = 0; done: BIO_free(in); X509_free(x); (void)sk_X509_NAME_set_cmp_func(stack, oldcmp); return ret; } int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack, const char *dir) { OPENSSL_DIR_CTX *d = NULL; const char *filename; int ret = 0; /* Note that a side effect is that the CAs will be sorted by name */ while ((filename = OPENSSL_DIR_read(&d, dir))) { char buf[1024]; int r; #ifndef OPENSSL_NO_POSIX_IO struct stat st; #else /* Cannot use stat so just skip current and parent directories */ if (strcmp(filename, ".") == 0 || strcmp(filename, "..") == 0) continue; #endif if (strlen(dir) + strlen(filename) + 2 > sizeof(buf)) { ERR_raise(ERR_LIB_SSL, SSL_R_PATH_TOO_LONG); goto err; } #ifdef OPENSSL_SYS_VMS r = BIO_snprintf(buf, sizeof(buf), "%s%s", dir, filename); #else r = BIO_snprintf(buf, sizeof(buf), "%s/%s", dir, filename); #endif #ifndef OPENSSL_NO_POSIX_IO /* Skip subdirectories */ if (!stat(buf, &st) && S_ISDIR(st.st_mode)) continue; #endif if (r <= 0 || r >= (int)sizeof(buf)) goto err; if (!SSL_add_file_cert_subjects_to_stack(stack, buf)) goto err; } if (errno) { ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(), "calling OPENSSL_dir_read(%s)", dir); ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB); goto err; } ret = 1; err: if (d) OPENSSL_DIR_end(&d); return ret; } static int add_uris_recursive(STACK_OF(X509_NAME) *stack, const char *uri, int depth) { int ok = 1; OSSL_STORE_CTX *ctx = NULL; X509 *x = NULL; X509_NAME *xn = NULL; if ((ctx = OSSL_STORE_open(uri, NULL, NULL, NULL, NULL)) == NULL) goto err; while (!OSSL_STORE_eof(ctx) && !OSSL_STORE_error(ctx)) { OSSL_STORE_INFO *info = OSSL_STORE_load(ctx); int infotype = info == 0 ? 0 : OSSL_STORE_INFO_get_type(info); if (info == NULL) continue; if (infotype == OSSL_STORE_INFO_NAME) { /* * This is an entry in the "directory" represented by the current * uri. if |depth| allows, dive into it. */ if (depth > 0) ok = add_uris_recursive(stack, OSSL_STORE_INFO_get0_NAME(info), depth - 1); } else if (infotype == OSSL_STORE_INFO_CERT) { if ((x = OSSL_STORE_INFO_get0_CERT(info)) == NULL || (xn = X509_get_subject_name(x)) == NULL || (xn = X509_NAME_dup(xn)) == NULL) goto err; if (sk_X509_NAME_find(stack, xn) >= 0) { /* Duplicate. */ X509_NAME_free(xn); } else if (!sk_X509_NAME_push(stack, xn)) { X509_NAME_free(xn); goto err; } } OSSL_STORE_INFO_free(info); } ERR_clear_error(); goto done; err: ok = 0; done: OSSL_STORE_close(ctx); return ok; } int SSL_add_store_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack, const char *store) { int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b) = sk_X509_NAME_set_cmp_func(stack, xname_sk_cmp); int ret = add_uris_recursive(stack, store, 1); (void)sk_X509_NAME_set_cmp_func(stack, oldcmp); return ret; } /* Build a certificate chain for current certificate */ int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags) { CERT *c = s != NULL ? s->cert : ctx->cert; CERT_PKEY *cpk = c->key; X509_STORE *chain_store = NULL; X509_STORE_CTX *xs_ctx = NULL; STACK_OF(X509) *chain = NULL, *untrusted = NULL; X509 *x; SSL_CTX *real_ctx = (s == NULL) ? ctx : SSL_CONNECTION_GET_CTX(s); int i, rv = 0; if (cpk->x509 == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_SET); goto err; } /* Rearranging and check the chain: add everything to a store */ if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) { chain_store = X509_STORE_new(); if (chain_store == NULL) goto err; for (i = 0; i < sk_X509_num(cpk->chain); i++) { x = sk_X509_value(cpk->chain, i); if (!X509_STORE_add_cert(chain_store, x)) goto err; } /* Add EE cert too: it might be self signed */ if (!X509_STORE_add_cert(chain_store, cpk->x509)) goto err; } else { if (c->chain_store != NULL) chain_store = c->chain_store; else chain_store = real_ctx->cert_store; if (flags & SSL_BUILD_CHAIN_FLAG_UNTRUSTED) untrusted = cpk->chain; } xs_ctx = X509_STORE_CTX_new_ex(real_ctx->libctx, real_ctx->propq); if (xs_ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } if (!X509_STORE_CTX_init(xs_ctx, chain_store, cpk->x509, untrusted)) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } /* Set suite B flags if needed */ X509_STORE_CTX_set_flags(xs_ctx, c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS); i = X509_verify_cert(xs_ctx); if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) { if (flags & SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR) ERR_clear_error(); i = 1; rv = 2; } if (i > 0) chain = X509_STORE_CTX_get1_chain(xs_ctx); if (i <= 0) { i = X509_STORE_CTX_get_error(xs_ctx); ERR_raise_data(ERR_LIB_SSL, SSL_R_CERTIFICATE_VERIFY_FAILED, "Verify error:%s", X509_verify_cert_error_string(i)); goto err; } /* Remove EE certificate from chain */ x = sk_X509_shift(chain); X509_free(x); if (flags & SSL_BUILD_CHAIN_FLAG_NO_ROOT) { if (sk_X509_num(chain) > 0) { /* See if last cert is self signed */ x = sk_X509_value(chain, sk_X509_num(chain) - 1); if (X509_get_extension_flags(x) & EXFLAG_SS) { x = sk_X509_pop(chain); X509_free(x); } } } /* * Check security level of all CA certificates: EE will have been checked * already. */ for (i = 0; i < sk_X509_num(chain); i++) { x = sk_X509_value(chain, i); rv = ssl_security_cert(s, ctx, x, 0, 0); if (rv != 1) { ERR_raise(ERR_LIB_SSL, rv); OSSL_STACK_OF_X509_free(chain); rv = 0; goto err; } } OSSL_STACK_OF_X509_free(cpk->chain); cpk->chain = chain; if (rv == 0) rv = 1; err: if (flags & SSL_BUILD_CHAIN_FLAG_CHECK) X509_STORE_free(chain_store); X509_STORE_CTX_free(xs_ctx); return rv; } int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain, int ref) { X509_STORE **pstore; if (chain) pstore = &c->chain_store; else pstore = &c->verify_store; X509_STORE_free(*pstore); *pstore = store; if (ref && store) X509_STORE_up_ref(store); return 1; } int ssl_cert_get_cert_store(CERT *c, X509_STORE **pstore, int chain) { *pstore = (chain ? c->chain_store : c->verify_store); return 1; } int ssl_get_security_level_bits(const SSL *s, const SSL_CTX *ctx, int *levelp) { int level; /* * note that there's a corresponding minbits_table * in crypto/x509/x509_vfy.c that's used for checking the security level * of RSA and DSA keys */ static const int minbits_table[5 + 1] = { 0, 80, 112, 128, 192, 256 }; if (ctx != NULL) level = SSL_CTX_get_security_level(ctx); else level = SSL_get_security_level(s); if (level > 5) level = 5; else if (level < 0) level = 0; if (levelp != NULL) *levelp = level; return minbits_table[level]; } static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex) { int level, minbits, pfs_mask; const SSL_CONNECTION *sc; minbits = ssl_get_security_level_bits(s, ctx, &level); if (level == 0) { /* * No EDH keys weaker than 1024-bits even at level 0, otherwise, * anything goes. */ if (op == SSL_SECOP_TMP_DH && bits < 80) return 0; return 1; } switch (op) { case SSL_SECOP_CIPHER_SUPPORTED: case SSL_SECOP_CIPHER_SHARED: case SSL_SECOP_CIPHER_CHECK: { const SSL_CIPHER *c = other; /* No ciphers below security level */ if (bits < minbits) return 0; /* No unauthenticated ciphersuites */ if (c->algorithm_auth & SSL_aNULL) return 0; /* No MD5 mac ciphersuites */ if (c->algorithm_mac & SSL_MD5) return 0; /* SHA1 HMAC is 160 bits of security */ if (minbits > 160 && c->algorithm_mac & SSL_SHA1) return 0; /* Level 3: forward secure ciphersuites only */ pfs_mask = SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK; if (level >= 3 && c->min_tls != TLS1_3_VERSION && !(c->algorithm_mkey & pfs_mask)) return 0; break; } case SSL_SECOP_VERSION: if ((sc = SSL_CONNECTION_FROM_CONST_SSL(s)) == NULL) return 0; if (!SSL_CONNECTION_IS_DTLS(sc)) { /* SSLv3, TLS v1.0 and TLS v1.1 only allowed at level 0 */ if (nid <= TLS1_1_VERSION && level > 0) return 0; } else { /* DTLS v1.0 only allowed at level 0 */ if (DTLS_VERSION_LT(nid, DTLS1_2_VERSION) && level > 0) return 0; } break; case SSL_SECOP_COMPRESSION: if (level >= 2) return 0; break; case SSL_SECOP_TICKET: if (level >= 3) return 0; break; default: if (bits < minbits) return 0; } return 1; } int ssl_security(const SSL_CONNECTION *s, int op, int bits, int nid, void *other) { return s->cert->sec_cb(SSL_CONNECTION_GET_SSL(s), NULL, op, bits, nid, other, s->cert->sec_ex); } int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid, void *other) { return ctx->cert->sec_cb(NULL, ctx, op, bits, nid, other, ctx->cert->sec_ex); } int ssl_cert_lookup_by_nid(int nid, size_t *pidx, SSL_CTX *ctx) { size_t i; for (i = 0; i < OSSL_NELEM(ssl_cert_info); i++) { if (ssl_cert_info[i].nid == nid) { *pidx = i; return 1; } } for (i = 0; i < ctx->sigalg_list_len; i++) { if (ctx->ssl_cert_info[i].nid == nid) { *pidx = SSL_PKEY_NUM + i; return 1; } } return 0; } const SSL_CERT_LOOKUP *ssl_cert_lookup_by_pkey(const EVP_PKEY *pk, size_t *pidx, SSL_CTX *ctx) { size_t i; /* check classic pk types */ for (i = 0; i < OSSL_NELEM(ssl_cert_info); i++) { const SSL_CERT_LOOKUP *tmp_lu = &ssl_cert_info[i]; if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->nid)) || EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->nid))) { if (pidx != NULL) *pidx = i; return tmp_lu; } } /* check provider-loaded pk types */ for (i = 0; ctx->sigalg_list_len; i++) { SSL_CERT_LOOKUP *tmp_lu = &(ctx->ssl_cert_info[i]); if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->nid)) || EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->nid))) { if (pidx != NULL) *pidx = SSL_PKEY_NUM + i; return &ctx->ssl_cert_info[i]; } } return NULL; } const SSL_CERT_LOOKUP *ssl_cert_lookup_by_idx(size_t idx, SSL_CTX *ctx) { if (idx >= (OSSL_NELEM(ssl_cert_info) + ctx->sigalg_list_len)) return NULL; else if (idx >= (OSSL_NELEM(ssl_cert_info))) return &(ctx->ssl_cert_info[idx - SSL_PKEY_NUM]); return &ssl_cert_info[idx]; }

./openssl/ssl/d1_lib.c

/* * Copyright 2005-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/e_os.h" #include <stdio.h> #include <openssl/objects.h> #include <openssl/rand.h> #include "ssl_local.h" #include "internal/time.h" static int dtls1_handshake_write(SSL_CONNECTION *s); static size_t dtls1_link_min_mtu(void); /* XDTLS: figure out the right values */ static const size_t g_probable_mtu[] = { 1500, 512, 256 }; const SSL3_ENC_METHOD DTLSv1_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, SSL_ENC_FLAG_DTLS | SSL_ENC_FLAG_EXPLICIT_IV, dtls1_set_handshake_header, dtls1_close_construct_packet, dtls1_handshake_write }; const SSL3_ENC_METHOD DTLSv1_2_enc_data = { tls1_setup_key_block, tls1_generate_master_secret, tls1_change_cipher_state, tls1_final_finish_mac, TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE, TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE, tls1_alert_code, tls1_export_keying_material, SSL_ENC_FLAG_DTLS | SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF | SSL_ENC_FLAG_TLS1_2_CIPHERS, dtls1_set_handshake_header, dtls1_close_construct_packet, dtls1_handshake_write }; OSSL_TIME dtls1_default_timeout(void) { /* * 2 hours, the 24 hours mentioned in the DTLSv1 spec is way too long for * http, the cache would over fill */ return ossl_seconds2time(60 * 60 * 2); } int dtls1_new(SSL *ssl) { DTLS1_STATE *d1; SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return 0; if (!DTLS_RECORD_LAYER_new(&s->rlayer)) { return 0; } if (!ssl3_new(ssl)) return 0; if ((d1 = OPENSSL_zalloc(sizeof(*d1))) == NULL) { ssl3_free(ssl); return 0; } d1->buffered_messages = pqueue_new(); d1->sent_messages = pqueue_new(); if (s->server) { d1->cookie_len = sizeof(s->d1->cookie); } d1->link_mtu = 0; d1->mtu = 0; if (d1->buffered_messages == NULL || d1->sent_messages == NULL) { pqueue_free(d1->buffered_messages); pqueue_free(d1->sent_messages); OPENSSL_free(d1); ssl3_free(ssl); return 0; } s->d1 = d1; if (!ssl->method->ssl_clear(ssl)) return 0; return 1; } static void dtls1_clear_queues(SSL_CONNECTION *s) { dtls1_clear_received_buffer(s); dtls1_clear_sent_buffer(s); } void dtls1_clear_received_buffer(SSL_CONNECTION *s) { pitem *item = NULL; hm_fragment *frag = NULL; while ((item = pqueue_pop(s->d1->buffered_messages)) != NULL) { frag = (hm_fragment *)item->data; dtls1_hm_fragment_free(frag); pitem_free(item); } } void dtls1_clear_sent_buffer(SSL_CONNECTION *s) { pitem *item = NULL; hm_fragment *frag = NULL; while ((item = pqueue_pop(s->d1->sent_messages)) != NULL) { frag = (hm_fragment *)item->data; if (frag->msg_header.is_ccs && frag->msg_header.saved_retransmit_state.wrlmethod != NULL && s->rlayer.wrl != frag->msg_header.saved_retransmit_state.wrl) { /* * If we're freeing the CCS then we're done with the old wrl and it * can bee freed */ frag->msg_header.saved_retransmit_state.wrlmethod->free(frag->msg_header.saved_retransmit_state.wrl); } dtls1_hm_fragment_free(frag); pitem_free(item); } } void dtls1_free(SSL *ssl) { SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return; if (s->d1 != NULL) { dtls1_clear_queues(s); pqueue_free(s->d1->buffered_messages); pqueue_free(s->d1->sent_messages); } DTLS_RECORD_LAYER_free(&s->rlayer); ssl3_free(ssl); OPENSSL_free(s->d1); s->d1 = NULL; } int dtls1_clear(SSL *ssl) { pqueue *buffered_messages; pqueue *sent_messages; size_t mtu; size_t link_mtu; SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return 0; DTLS_RECORD_LAYER_clear(&s->rlayer); if (s->d1) { DTLS_timer_cb timer_cb = s->d1->timer_cb; buffered_messages = s->d1->buffered_messages; sent_messages = s->d1->sent_messages; mtu = s->d1->mtu; link_mtu = s->d1->link_mtu; dtls1_clear_queues(s); memset(s->d1, 0, sizeof(*s->d1)); /* Restore the timer callback from previous state */ s->d1->timer_cb = timer_cb; if (s->server) { s->d1->cookie_len = sizeof(s->d1->cookie); } if (SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU) { s->d1->mtu = mtu; s->d1->link_mtu = link_mtu; } s->d1->buffered_messages = buffered_messages; s->d1->sent_messages = sent_messages; } if (!ssl3_clear(ssl)) return 0; if (ssl->method->version == DTLS_ANY_VERSION) s->version = DTLS_MAX_VERSION_INTERNAL; #ifndef OPENSSL_NO_DTLS1_METHOD else if (s->options & SSL_OP_CISCO_ANYCONNECT) s->client_version = s->version = DTLS1_BAD_VER; #endif else s->version = ssl->method->version; return 1; } long dtls1_ctrl(SSL *ssl, int cmd, long larg, void *parg) { int ret = 0; OSSL_TIME t; SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return 0; switch (cmd) { case DTLS_CTRL_GET_TIMEOUT: if (dtls1_get_timeout(s, &t)) { *(struct timeval *)parg = ossl_time_to_timeval(t); ret = 1; } break; case DTLS_CTRL_HANDLE_TIMEOUT: ret = dtls1_handle_timeout(s); break; case DTLS_CTRL_SET_LINK_MTU: if (larg < (long)dtls1_link_min_mtu()) return 0; s->d1->link_mtu = larg; return 1; case DTLS_CTRL_GET_LINK_MIN_MTU: return (long)dtls1_link_min_mtu(); case SSL_CTRL_SET_MTU: /* * We may not have a BIO set yet so can't call dtls1_min_mtu() * We'll have to make do with dtls1_link_min_mtu() and max overhead */ if (larg < (long)dtls1_link_min_mtu() - DTLS1_MAX_MTU_OVERHEAD) return 0; s->d1->mtu = larg; return larg; default: ret = ssl3_ctrl(ssl, cmd, larg, parg); break; } return ret; } static void dtls1_bio_set_next_timeout(BIO *bio, const DTLS1_STATE *d1) { struct timeval tv = ossl_time_to_timeval(d1->next_timeout); BIO_ctrl(bio, BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0, &tv); } void dtls1_start_timer(SSL_CONNECTION *s) { OSSL_TIME duration; SSL *ssl = SSL_CONNECTION_GET_SSL(s); #ifndef OPENSSL_NO_SCTP /* Disable timer for SCTP */ if (BIO_dgram_is_sctp(SSL_get_wbio(ssl))) { s->d1->next_timeout = ossl_time_zero(); return; } #endif /* * If timer is not set, initialize duration with 1 second or * a user-specified value if the timer callback is installed. */ if (ossl_time_is_zero(s->d1->next_timeout)) { if (s->d1->timer_cb != NULL) s->d1->timeout_duration_us = s->d1->timer_cb(ssl, 0); else s->d1->timeout_duration_us = 1000000; } /* Set timeout to current time plus duration */ duration = ossl_us2time(s->d1->timeout_duration_us); s->d1->next_timeout = ossl_time_add(ossl_time_now(), duration); /* set s->d1->next_timeout into ssl->rbio interface */ dtls1_bio_set_next_timeout(SSL_get_rbio(ssl), s->d1); } int dtls1_get_timeout(const SSL_CONNECTION *s, OSSL_TIME *timeleft) { OSSL_TIME timenow; /* If no timeout is set, just return NULL */ if (ossl_time_is_zero(s->d1->next_timeout)) return 0; /* Get current time */ timenow = ossl_time_now(); /* * If timer already expired or if remaining time is less than 15 ms, * set it to 0 to prevent issues because of small divergences with * socket timeouts. */ *timeleft = ossl_time_subtract(s->d1->next_timeout, timenow); if (ossl_time_compare(*timeleft, ossl_ms2time(15)) <= 0) *timeleft = ossl_time_zero(); return 1; } int dtls1_is_timer_expired(SSL_CONNECTION *s) { OSSL_TIME timeleft; /* Get time left until timeout, return false if no timer running */ if (!dtls1_get_timeout(s, &timeleft)) return 0; /* Return false if timer is not expired yet */ if (!ossl_time_is_zero(timeleft)) return 0; /* Timer expired, so return true */ return 1; } static void dtls1_double_timeout(SSL_CONNECTION *s) { s->d1->timeout_duration_us *= 2; if (s->d1->timeout_duration_us > 60000000) s->d1->timeout_duration_us = 60000000; } void dtls1_stop_timer(SSL_CONNECTION *s) { /* Reset everything */ s->d1->timeout_num_alerts = 0; s->d1->next_timeout = ossl_time_zero(); s->d1->timeout_duration_us = 1000000; dtls1_bio_set_next_timeout(s->rbio, s->d1); /* Clear retransmission buffer */ dtls1_clear_sent_buffer(s); } int dtls1_check_timeout_num(SSL_CONNECTION *s) { size_t mtu; SSL *ssl = SSL_CONNECTION_GET_SSL(s); s->d1->timeout_num_alerts++; /* Reduce MTU after 2 unsuccessful retransmissions */ if (s->d1->timeout_num_alerts > 2 && !(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) { mtu = BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0, NULL); if (mtu < s->d1->mtu) s->d1->mtu = mtu; } if (s->d1->timeout_num_alerts > DTLS1_TMO_ALERT_COUNT) { /* fail the connection, enough alerts have been sent */ SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_READ_TIMEOUT_EXPIRED); return -1; } return 0; } int dtls1_handle_timeout(SSL_CONNECTION *s) { /* if no timer is expired, don't do anything */ if (!dtls1_is_timer_expired(s)) { return 0; } if (s->d1->timer_cb != NULL) s->d1->timeout_duration_us = s->d1->timer_cb(SSL_CONNECTION_GET_SSL(s), s->d1->timeout_duration_us); else dtls1_double_timeout(s); if (dtls1_check_timeout_num(s) < 0) { /* SSLfatal() already called */ return -1; } dtls1_start_timer(s); /* Calls SSLfatal() if required */ return dtls1_retransmit_buffered_messages(s); } #define LISTEN_SUCCESS 2 #define LISTEN_SEND_VERIFY_REQUEST 1 #ifndef OPENSSL_NO_SOCK int DTLSv1_listen(SSL *ssl, BIO_ADDR *client) { int next, n, ret = 0; unsigned char cookie[DTLS1_COOKIE_LENGTH]; unsigned char seq[SEQ_NUM_SIZE]; const unsigned char *data; unsigned char *buf = NULL, *wbuf; size_t fragoff, fraglen, msglen; unsigned int rectype, versmajor, versminor, msgseq, msgtype, clientvers, cookielen; BIO *rbio, *wbio; BIO_ADDR *tmpclient = NULL; PACKET pkt, msgpkt, msgpayload, session, cookiepkt; SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return -1; if (s->handshake_func == NULL) { /* Not properly initialized yet */ SSL_set_accept_state(ssl); } /* Ensure there is no state left over from a previous invocation */ if (!SSL_clear(ssl)) return -1; ERR_clear_error(); rbio = SSL_get_rbio(ssl); wbio = SSL_get_wbio(ssl); if (!rbio || !wbio) { ERR_raise(ERR_LIB_SSL, SSL_R_BIO_NOT_SET); return -1; } /* * Note: This check deliberately excludes DTLS1_BAD_VER because that version * requires the MAC to be calculated *including* the first ClientHello * (without the cookie). Since DTLSv1_listen is stateless that cannot be * supported. DTLS1_BAD_VER must use cookies in a stateful manner (e.g. via * SSL_accept) */ if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00)) { ERR_raise(ERR_LIB_SSL, SSL_R_UNSUPPORTED_SSL_VERSION); return -1; } buf = OPENSSL_malloc(DTLS1_RT_HEADER_LENGTH + SSL3_RT_MAX_PLAIN_LENGTH); if (buf == NULL) return -1; wbuf = OPENSSL_malloc(DTLS1_RT_HEADER_LENGTH + SSL3_RT_MAX_PLAIN_LENGTH); if (wbuf == NULL) { OPENSSL_free(buf); return -1; } do { /* Get a packet */ clear_sys_error(); n = BIO_read(rbio, buf, SSL3_RT_MAX_PLAIN_LENGTH + DTLS1_RT_HEADER_LENGTH); if (n <= 0) { if (BIO_should_retry(rbio)) { /* Non-blocking IO */ goto end; } ret = -1; goto end; } if (!PACKET_buf_init(&pkt, buf, n)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); ret = -1; goto end; } /* * Parse the received record. If there are any problems with it we just * dump it - with no alert. RFC6347 says this "Unlike TLS, DTLS is * resilient in the face of invalid records (e.g., invalid formatting, * length, MAC, etc.). In general, invalid records SHOULD be silently * discarded, thus preserving the association; however, an error MAY be * logged for diagnostic purposes." */ /* this packet contained a partial record, dump it */ if (n < DTLS1_RT_HEADER_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_RECORD_TOO_SMALL); goto end; } /* Get the record header */ if (!PACKET_get_1(&pkt, &rectype) || !PACKET_get_1(&pkt, &versmajor) || !PACKET_get_1(&pkt, &versminor)) { ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } if (s->msg_callback) s->msg_callback(0, (versmajor << 8) | versminor, SSL3_RT_HEADER, buf, DTLS1_RT_HEADER_LENGTH, ssl, s->msg_callback_arg); if (rectype != SSL3_RT_HANDSHAKE) { ERR_raise(ERR_LIB_SSL, SSL_R_UNEXPECTED_MESSAGE); goto end; } /* * Check record version number. We only check that the major version is * the same. */ if (versmajor != DTLS1_VERSION_MAJOR) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_PROTOCOL_VERSION_NUMBER); goto end; } /* Save the sequence number: 64 bits, with top 2 bytes = epoch */ if (!PACKET_copy_bytes(&pkt, seq, SEQ_NUM_SIZE) || !PACKET_get_length_prefixed_2(&pkt, &msgpkt)) { ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } /* * We allow data remaining at the end of the packet because there could * be a second record (but we ignore it) */ /* This is an initial ClientHello so the epoch has to be 0 */ if (seq[0] != 0 || seq[1] != 0) { ERR_raise(ERR_LIB_SSL, SSL_R_UNEXPECTED_MESSAGE); goto end; } /* Get a pointer to the raw message for the later callback */ data = PACKET_data(&msgpkt); /* Finished processing the record header, now process the message */ if (!PACKET_get_1(&msgpkt, &msgtype) || !PACKET_get_net_3_len(&msgpkt, &msglen) || !PACKET_get_net_2(&msgpkt, &msgseq) || !PACKET_get_net_3_len(&msgpkt, &fragoff) || !PACKET_get_net_3_len(&msgpkt, &fraglen) || !PACKET_get_sub_packet(&msgpkt, &msgpayload, fraglen) || PACKET_remaining(&msgpkt) != 0) { ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } if (msgtype != SSL3_MT_CLIENT_HELLO) { ERR_raise(ERR_LIB_SSL, SSL_R_UNEXPECTED_MESSAGE); goto end; } /* Message sequence number can only be 0 or 1 */ if (msgseq > 2) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SEQUENCE_NUMBER); goto end; } /* * We don't support fragment reassembly for ClientHellos whilst * listening because that would require server side state (which is * against the whole point of the ClientHello/HelloVerifyRequest * mechanism). Instead we only look at the first ClientHello fragment * and require that the cookie must be contained within it. */ if (fragoff != 0 || fraglen > msglen) { /* Non initial ClientHello fragment (or bad fragment) */ ERR_raise(ERR_LIB_SSL, SSL_R_FRAGMENTED_CLIENT_HELLO); goto end; } if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, data, fraglen + DTLS1_HM_HEADER_LENGTH, ssl, s->msg_callback_arg); if (!PACKET_get_net_2(&msgpayload, &clientvers)) { ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } /* * Verify client version is supported */ if (DTLS_VERSION_LT(clientvers, (unsigned int)ssl->method->version) && ssl->method->version != DTLS_ANY_VERSION) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_VERSION_NUMBER); goto end; } if (!PACKET_forward(&msgpayload, SSL3_RANDOM_SIZE) || !PACKET_get_length_prefixed_1(&msgpayload, &session) || !PACKET_get_length_prefixed_1(&msgpayload, &cookiepkt)) { /* * Could be malformed or the cookie does not fit within the initial * ClientHello fragment. Either way we can't handle it. */ ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH); goto end; } /* * Check if we have a cookie or not. If not we need to send a * HelloVerifyRequest. */ if (PACKET_remaining(&cookiepkt) == 0) { next = LISTEN_SEND_VERIFY_REQUEST; } else { /* * We have a cookie, so lets check it. */ if (ssl->ctx->app_verify_cookie_cb == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_VERIFY_COOKIE_CALLBACK); /* This is fatal */ ret = -1; goto end; } if (ssl->ctx->app_verify_cookie_cb(ssl, PACKET_data(&cookiepkt), (unsigned int)PACKET_remaining(&cookiepkt)) == 0) { /* * We treat invalid cookies in the same was as no cookie as * per RFC6347 */ next = LISTEN_SEND_VERIFY_REQUEST; } else { /* Cookie verification succeeded */ next = LISTEN_SUCCESS; } } if (next == LISTEN_SEND_VERIFY_REQUEST) { WPACKET wpkt; unsigned int version; size_t wreclen; /* * There was no cookie in the ClientHello so we need to send a * HelloVerifyRequest. If this fails we do not worry about trying * to resend, we just drop it. */ /* Generate the cookie */ if (ssl->ctx->app_gen_cookie_cb == NULL || ssl->ctx->app_gen_cookie_cb(ssl, cookie, &cookielen) == 0 || cookielen > 255) { ERR_raise(ERR_LIB_SSL, SSL_R_COOKIE_GEN_CALLBACK_FAILURE); /* This is fatal */ ret = -1; goto end; } /* * Special case: for hello verify request, client version 1.0 and we * haven't decided which version to use yet send back using version * 1.0 header: otherwise some clients will ignore it. */ version = (ssl->method->version == DTLS_ANY_VERSION) ? DTLS1_VERSION : s->version; /* Construct the record and message headers */ if (!WPACKET_init_static_len(&wpkt, wbuf, ssl_get_max_send_fragment(s) + DTLS1_RT_HEADER_LENGTH, 0) || !WPACKET_put_bytes_u8(&wpkt, SSL3_RT_HANDSHAKE) || !WPACKET_put_bytes_u16(&wpkt, version) /* * Record sequence number is always the same as in the * received ClientHello */ || !WPACKET_memcpy(&wpkt, seq, SEQ_NUM_SIZE) /* End of record, start sub packet for message */ || !WPACKET_start_sub_packet_u16(&wpkt) /* Message type */ || !WPACKET_put_bytes_u8(&wpkt, DTLS1_MT_HELLO_VERIFY_REQUEST) /* * Message length - doesn't follow normal TLS convention: * the length isn't the last thing in the message header. * We'll need to fill this in later when we know the * length. Set it to zero for now */ || !WPACKET_put_bytes_u24(&wpkt, 0) /* * Message sequence number is always 0 for a * HelloVerifyRequest */ || !WPACKET_put_bytes_u16(&wpkt, 0) /* * We never fragment a HelloVerifyRequest, so fragment * offset is 0 */ || !WPACKET_put_bytes_u24(&wpkt, 0) /* * Fragment length is the same as message length, but * this *is* the last thing in the message header so we * can just start a sub-packet. No need to come back * later for this one. */ || !WPACKET_start_sub_packet_u24(&wpkt) /* Create the actual HelloVerifyRequest body */ || !dtls_raw_hello_verify_request(&wpkt, cookie, cookielen) /* Close message body */ || !WPACKET_close(&wpkt) /* Close record body */ || !WPACKET_close(&wpkt) || !WPACKET_get_total_written(&wpkt, &wreclen) || !WPACKET_finish(&wpkt)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); WPACKET_cleanup(&wpkt); /* This is fatal */ ret = -1; goto end; } /* * Fix up the message len in the message header. Its the same as the * fragment len which has been filled in by WPACKET, so just copy * that. Destination for the message len is after the record header * plus one byte for the message content type. The source is the * last 3 bytes of the message header */ memcpy(&wbuf[DTLS1_RT_HEADER_LENGTH + 1], &wbuf[DTLS1_RT_HEADER_LENGTH + DTLS1_HM_HEADER_LENGTH - 3], 3); if (s->msg_callback) s->msg_callback(1, 0, SSL3_RT_HEADER, buf, DTLS1_RT_HEADER_LENGTH, ssl, s->msg_callback_arg); if ((tmpclient = BIO_ADDR_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB); goto end; } /* * This is unnecessary if rbio and wbio are one and the same - but * maybe they're not. We ignore errors here - some BIOs do not * support this. */ if (BIO_dgram_get_peer(rbio, tmpclient) > 0) { (void)BIO_dgram_set_peer(wbio, tmpclient); } BIO_ADDR_free(tmpclient); tmpclient = NULL; if (BIO_write(wbio, wbuf, wreclen) < (int)wreclen) { if (BIO_should_retry(wbio)) { /* * Non-blocking IO...but we're stateless, so we're just * going to drop this packet. */ goto end; } ret = -1; goto end; } if (BIO_flush(wbio) <= 0) { if (BIO_should_retry(wbio)) { /* * Non-blocking IO...but we're stateless, so we're just * going to drop this packet. */ goto end; } ret = -1; goto end; } } } while (next != LISTEN_SUCCESS); /* * Set expected sequence numbers to continue the handshake. */ s->d1->handshake_read_seq = 1; s->d1->handshake_write_seq = 1; s->d1->next_handshake_write_seq = 1; s->rlayer.wrlmethod->increment_sequence_ctr(s->rlayer.wrl); /* * We are doing cookie exchange, so make sure we set that option in the * SSL object */ SSL_set_options(ssl, SSL_OP_COOKIE_EXCHANGE); /* * Tell the state machine that we've done the initial hello verify * exchange */ ossl_statem_set_hello_verify_done(s); /* * Some BIOs may not support this. If we fail we clear the client address */ if (BIO_dgram_get_peer(rbio, client) <= 0) BIO_ADDR_clear(client); /* Buffer the record for use by the record layer */ if (BIO_write(s->rlayer.rrlnext, buf, n) != n) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); ret = -1; goto end; } /* * Reset the record layer - but this time we can use the record we just * buffered in s->rlayer.rrlnext */ if (!ssl_set_new_record_layer(s, DTLS_ANY_VERSION, OSSL_RECORD_DIRECTION_READ, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL)) { /* SSLfatal already called */ ret = -1; goto end; } ret = 1; end: BIO_ADDR_free(tmpclient); OPENSSL_free(buf); OPENSSL_free(wbuf); return ret; } #endif static int dtls1_handshake_write(SSL_CONNECTION *s) { return dtls1_do_write(s, SSL3_RT_HANDSHAKE); } int dtls1_shutdown(SSL *s) { int ret; #ifndef OPENSSL_NO_SCTP BIO *wbio; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (s == NULL) return -1; wbio = SSL_get_wbio(s); if (wbio != NULL && BIO_dgram_is_sctp(wbio) && !(sc->shutdown & SSL_SENT_SHUTDOWN)) { ret = BIO_dgram_sctp_wait_for_dry(wbio); if (ret < 0) return -1; if (ret == 0) BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 1, NULL); } #endif ret = ssl3_shutdown(s); #ifndef OPENSSL_NO_SCTP BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 0, NULL); #endif return ret; } int dtls1_query_mtu(SSL_CONNECTION *s) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->d1->link_mtu) { s->d1->mtu = s->d1->link_mtu - BIO_dgram_get_mtu_overhead(SSL_get_wbio(ssl)); s->d1->link_mtu = 0; } /* AHA! Figure out the MTU, and stick to the right size */ if (s->d1->mtu < dtls1_min_mtu(s)) { if (!(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) { s->d1->mtu = BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL); /* * I've seen the kernel return bogus numbers when it doesn't know * (initial write), so just make sure we have a reasonable number */ if (s->d1->mtu < dtls1_min_mtu(s)) { /* Set to min mtu */ s->d1->mtu = dtls1_min_mtu(s); BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SET_MTU, (long)s->d1->mtu, NULL); } } else return 0; } return 1; } static size_t dtls1_link_min_mtu(void) { return (g_probable_mtu[(sizeof(g_probable_mtu) / sizeof(g_probable_mtu[0])) - 1]); } size_t dtls1_min_mtu(SSL_CONNECTION *s) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); return dtls1_link_min_mtu() - BIO_dgram_get_mtu_overhead(SSL_get_wbio(ssl)); } size_t DTLS_get_data_mtu(const SSL *ssl) { size_t mac_overhead, int_overhead, blocksize, ext_overhead; const SSL_CIPHER *ciph = SSL_get_current_cipher(ssl); size_t mtu; const SSL_CONNECTION *s = SSL_CONNECTION_FROM_CONST_SSL_ONLY(ssl); if (s == NULL) return 0; mtu = s->d1->mtu; if (ciph == NULL) return 0; if (!ssl_cipher_get_overhead(ciph, &mac_overhead, &int_overhead, &blocksize, &ext_overhead)) return 0; if (SSL_READ_ETM(s)) ext_overhead += mac_overhead; else int_overhead += mac_overhead; /* Subtract external overhead (e.g. IV/nonce, separate MAC) */ if (ext_overhead + DTLS1_RT_HEADER_LENGTH >= mtu) return 0; mtu -= ext_overhead + DTLS1_RT_HEADER_LENGTH; /* Round encrypted payload down to cipher block size (for CBC etc.) * No check for overflow since 'mtu % blocksize' cannot exceed mtu. */ if (blocksize) mtu -= (mtu % blocksize); /* Subtract internal overhead (e.g. CBC padding len byte) */ if (int_overhead >= mtu) return 0; mtu -= int_overhead; return mtu; } void DTLS_set_timer_cb(SSL *ssl, DTLS_timer_cb cb) { SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return; s->d1->timer_cb = cb; }

./openssl/ssl/ssl_asn1.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <stdlib.h> #include "ssl_local.h" #include <openssl/asn1t.h> #include <openssl/encoder.h> #include <openssl/x509.h> typedef struct { uint32_t version; int32_t ssl_version; ASN1_OCTET_STRING *cipher; ASN1_OCTET_STRING *comp_id; ASN1_OCTET_STRING *master_key; ASN1_OCTET_STRING *session_id; ASN1_OCTET_STRING *key_arg; int64_t time; int64_t timeout; X509 *peer; ASN1_OCTET_STRING *session_id_context; int32_t verify_result; ASN1_OCTET_STRING *tlsext_hostname; uint64_t tlsext_tick_lifetime_hint; uint32_t tlsext_tick_age_add; ASN1_OCTET_STRING *tlsext_tick; #ifndef OPENSSL_NO_PSK ASN1_OCTET_STRING *psk_identity_hint; ASN1_OCTET_STRING *psk_identity; #endif #ifndef OPENSSL_NO_SRP ASN1_OCTET_STRING *srp_username; #endif uint64_t flags; uint32_t max_early_data; ASN1_OCTET_STRING *alpn_selected; uint32_t tlsext_max_fragment_len_mode; ASN1_OCTET_STRING *ticket_appdata; uint32_t kex_group; ASN1_OCTET_STRING *peer_rpk; } SSL_SESSION_ASN1; ASN1_SEQUENCE(SSL_SESSION_ASN1) = { ASN1_EMBED(SSL_SESSION_ASN1, version, UINT32), ASN1_EMBED(SSL_SESSION_ASN1, ssl_version, INT32), ASN1_SIMPLE(SSL_SESSION_ASN1, cipher, ASN1_OCTET_STRING), ASN1_SIMPLE(SSL_SESSION_ASN1, session_id, ASN1_OCTET_STRING), ASN1_SIMPLE(SSL_SESSION_ASN1, master_key, ASN1_OCTET_STRING), ASN1_IMP_OPT(SSL_SESSION_ASN1, key_arg, ASN1_OCTET_STRING, 0), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, time, ZINT64, 1), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, timeout, ZINT64, 2), ASN1_EXP_OPT(SSL_SESSION_ASN1, peer, X509, 3), ASN1_EXP_OPT(SSL_SESSION_ASN1, session_id_context, ASN1_OCTET_STRING, 4), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, verify_result, ZINT32, 5), ASN1_EXP_OPT(SSL_SESSION_ASN1, tlsext_hostname, ASN1_OCTET_STRING, 6), #ifndef OPENSSL_NO_PSK ASN1_EXP_OPT(SSL_SESSION_ASN1, psk_identity_hint, ASN1_OCTET_STRING, 7), ASN1_EXP_OPT(SSL_SESSION_ASN1, psk_identity, ASN1_OCTET_STRING, 8), #endif ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, tlsext_tick_lifetime_hint, ZUINT64, 9), ASN1_EXP_OPT(SSL_SESSION_ASN1, tlsext_tick, ASN1_OCTET_STRING, 10), ASN1_EXP_OPT(SSL_SESSION_ASN1, comp_id, ASN1_OCTET_STRING, 11), #ifndef OPENSSL_NO_SRP ASN1_EXP_OPT(SSL_SESSION_ASN1, srp_username, ASN1_OCTET_STRING, 12), #endif ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, flags, ZUINT64, 13), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, tlsext_tick_age_add, ZUINT32, 14), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, max_early_data, ZUINT32, 15), ASN1_EXP_OPT(SSL_SESSION_ASN1, alpn_selected, ASN1_OCTET_STRING, 16), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, tlsext_max_fragment_len_mode, ZUINT32, 17), ASN1_EXP_OPT(SSL_SESSION_ASN1, ticket_appdata, ASN1_OCTET_STRING, 18), ASN1_EXP_OPT_EMBED(SSL_SESSION_ASN1, kex_group, UINT32, 19), ASN1_EXP_OPT(SSL_SESSION_ASN1, peer_rpk, ASN1_OCTET_STRING, 20) } static_ASN1_SEQUENCE_END(SSL_SESSION_ASN1) IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(SSL_SESSION_ASN1) /* Utility functions for i2d_SSL_SESSION */ /* Initialise OCTET STRING from buffer and length */ static void ssl_session_oinit(ASN1_OCTET_STRING **dest, ASN1_OCTET_STRING *os, const unsigned char *data, size_t len) { os->data = (unsigned char *)data; /* justified cast: data is not modified */ os->length = (int)len; os->flags = 0; *dest = os; } /* Initialise OCTET STRING from string */ static void ssl_session_sinit(ASN1_OCTET_STRING **dest, ASN1_OCTET_STRING *os, const char *data) { if (data != NULL) ssl_session_oinit(dest, os, (const unsigned char *)data, strlen(data)); else *dest = NULL; } int i2d_SSL_SESSION(const SSL_SESSION *in, unsigned char **pp) { SSL_SESSION_ASN1 as; ASN1_OCTET_STRING cipher; unsigned char cipher_data[2]; ASN1_OCTET_STRING master_key, session_id, sid_ctx; #ifndef OPENSSL_NO_COMP ASN1_OCTET_STRING comp_id; unsigned char comp_id_data; #endif ASN1_OCTET_STRING tlsext_hostname, tlsext_tick; #ifndef OPENSSL_NO_SRP ASN1_OCTET_STRING srp_username; #endif #ifndef OPENSSL_NO_PSK ASN1_OCTET_STRING psk_identity, psk_identity_hint; #endif ASN1_OCTET_STRING alpn_selected; ASN1_OCTET_STRING ticket_appdata; ASN1_OCTET_STRING peer_rpk; long l; int ret; if ((in == NULL) || ((in->cipher == NULL) && (in->cipher_id == 0))) return 0; memset(&as, 0, sizeof(as)); as.version = SSL_SESSION_ASN1_VERSION; as.ssl_version = in->ssl_version; as.kex_group = in->kex_group; if (in->cipher == NULL) l = in->cipher_id; else l = in->cipher->id; cipher_data[0] = ((unsigned char)(l >> 8L)) & 0xff; cipher_data[1] = ((unsigned char)(l)) & 0xff; ssl_session_oinit(&as.cipher, &cipher, cipher_data, 2); #ifndef OPENSSL_NO_COMP if (in->compress_meth) { comp_id_data = (unsigned char)in->compress_meth; ssl_session_oinit(&as.comp_id, &comp_id, &comp_id_data, 1); } #endif ssl_session_oinit(&as.master_key, &master_key, in->master_key, in->master_key_length); ssl_session_oinit(&as.session_id, &session_id, in->session_id, in->session_id_length); ssl_session_oinit(&as.session_id_context, &sid_ctx, in->sid_ctx, in->sid_ctx_length); as.time = (int64_t)ossl_time_to_time_t(in->time); as.timeout = (int64_t)ossl_time2seconds(in->timeout); as.verify_result = in->verify_result; as.peer = in->peer; as.peer_rpk = NULL; peer_rpk.data = NULL; if (in->peer_rpk != NULL) { peer_rpk.length = i2d_PUBKEY(in->peer_rpk, &peer_rpk.data); if (peer_rpk.length > 0 && peer_rpk.data != NULL) as.peer_rpk = &peer_rpk; } ssl_session_sinit(&as.tlsext_hostname, &tlsext_hostname, in->ext.hostname); if (in->ext.tick) { ssl_session_oinit(&as.tlsext_tick, &tlsext_tick, in->ext.tick, in->ext.ticklen); } if (in->ext.tick_lifetime_hint > 0) as.tlsext_tick_lifetime_hint = in->ext.tick_lifetime_hint; as.tlsext_tick_age_add = in->ext.tick_age_add; #ifndef OPENSSL_NO_PSK ssl_session_sinit(&as.psk_identity_hint, &psk_identity_hint, in->psk_identity_hint); ssl_session_sinit(&as.psk_identity, &psk_identity, in->psk_identity); #endif /* OPENSSL_NO_PSK */ #ifndef OPENSSL_NO_SRP ssl_session_sinit(&as.srp_username, &srp_username, in->srp_username); #endif /* OPENSSL_NO_SRP */ as.flags = in->flags; as.max_early_data = in->ext.max_early_data; if (in->ext.alpn_selected == NULL) as.alpn_selected = NULL; else ssl_session_oinit(&as.alpn_selected, &alpn_selected, in->ext.alpn_selected, in->ext.alpn_selected_len); as.tlsext_max_fragment_len_mode = in->ext.max_fragment_len_mode; if (in->ticket_appdata == NULL) as.ticket_appdata = NULL; else ssl_session_oinit(&as.ticket_appdata, &ticket_appdata, in->ticket_appdata, in->ticket_appdata_len); ret = i2d_SSL_SESSION_ASN1(&as, pp); OPENSSL_free(peer_rpk.data); return ret; } /* Utility functions for d2i_SSL_SESSION */ /* OPENSSL_strndup an OCTET STRING */ static int ssl_session_strndup(char **pdst, ASN1_OCTET_STRING *src) { OPENSSL_free(*pdst); *pdst = NULL; if (src == NULL) return 1; *pdst = OPENSSL_strndup((char *)src->data, src->length); if (*pdst == NULL) return 0; return 1; } /* Copy an OCTET STRING, return error if it exceeds maximum length */ static int ssl_session_memcpy(unsigned char *dst, size_t *pdstlen, ASN1_OCTET_STRING *src, size_t maxlen) { if (src == NULL || src->length == 0) { *pdstlen = 0; return 1; } if (src->length < 0 || src->length > (int)maxlen) return 0; memcpy(dst, src->data, src->length); *pdstlen = src->length; return 1; } SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp, long length) { return d2i_SSL_SESSION_ex(a, pp, length, NULL, NULL); } SSL_SESSION *d2i_SSL_SESSION_ex(SSL_SESSION **a, const unsigned char **pp, long length, OSSL_LIB_CTX *libctx, const char *propq) { long id; size_t tmpl; const unsigned char *p = *pp; SSL_SESSION_ASN1 *as = NULL; SSL_SESSION *ret = NULL; as = d2i_SSL_SESSION_ASN1(NULL, &p, length); /* ASN.1 code returns suitable error */ if (as == NULL) goto err; if (a == NULL || *a == NULL) { ret = SSL_SESSION_new(); if (ret == NULL) goto err; } else { ret = *a; } if (as->version != SSL_SESSION_ASN1_VERSION) { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_SSL_VERSION); goto err; } if ((as->ssl_version >> 8) != SSL3_VERSION_MAJOR && (as->ssl_version >> 8) != DTLS1_VERSION_MAJOR && as->ssl_version != DTLS1_BAD_VER) { ERR_raise(ERR_LIB_SSL, SSL_R_UNSUPPORTED_SSL_VERSION); goto err; } ret->ssl_version = (int)as->ssl_version; ret->kex_group = as->kex_group; if (as->cipher->length != 2) { ERR_raise(ERR_LIB_SSL, SSL_R_CIPHER_CODE_WRONG_LENGTH); goto err; } id = 0x03000000L | ((unsigned long)as->cipher->data[0] << 8L) | (unsigned long)as->cipher->data[1]; ret->cipher_id = id; ret->cipher = ssl3_get_cipher_by_id(id); if (ret->cipher == NULL) goto err; if (!ssl_session_memcpy(ret->session_id, &ret->session_id_length, as->session_id, SSL3_MAX_SSL_SESSION_ID_LENGTH)) goto err; if (!ssl_session_memcpy(ret->master_key, &tmpl, as->master_key, TLS13_MAX_RESUMPTION_PSK_LENGTH)) goto err; ret->master_key_length = tmpl; if (as->time != 0) ret->time = ossl_time_from_time_t(as->time); else ret->time = ossl_time_now(); if (as->timeout != 0) ret->timeout = ossl_seconds2time(as->timeout); else ret->timeout = ossl_seconds2time(3); ssl_session_calculate_timeout(ret); X509_free(ret->peer); ret->peer = as->peer; as->peer = NULL; EVP_PKEY_free(ret->peer_rpk); ret->peer_rpk = NULL; if (as->peer_rpk != NULL) { const unsigned char *data = as->peer_rpk->data; /* * |data| is incremented; we don't want to lose original ptr */ ret->peer_rpk = d2i_PUBKEY_ex(NULL, &data, as->peer_rpk->length, libctx, propq); if (ret->peer_rpk == NULL) goto err; } if (!ssl_session_memcpy(ret->sid_ctx, &ret->sid_ctx_length, as->session_id_context, SSL_MAX_SID_CTX_LENGTH)) goto err; /* NB: this defaults to zero which is X509_V_OK */ ret->verify_result = as->verify_result; if (!ssl_session_strndup(&ret->ext.hostname, as->tlsext_hostname)) goto err; #ifndef OPENSSL_NO_PSK if (!ssl_session_strndup(&ret->psk_identity_hint, as->psk_identity_hint)) goto err; if (!ssl_session_strndup(&ret->psk_identity, as->psk_identity)) goto err; #endif ret->ext.tick_lifetime_hint = (unsigned long)as->tlsext_tick_lifetime_hint; ret->ext.tick_age_add = as->tlsext_tick_age_add; OPENSSL_free(ret->ext.tick); if (as->tlsext_tick != NULL) { ret->ext.tick = as->tlsext_tick->data; ret->ext.ticklen = as->tlsext_tick->length; as->tlsext_tick->data = NULL; } else { ret->ext.tick = NULL; } #ifndef OPENSSL_NO_COMP if (as->comp_id) { if (as->comp_id->length != 1) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); goto err; } ret->compress_meth = as->comp_id->data[0]; } else { ret->compress_meth = 0; } #endif #ifndef OPENSSL_NO_SRP if (!ssl_session_strndup(&ret->srp_username, as->srp_username)) goto err; #endif /* OPENSSL_NO_SRP */ /* Flags defaults to zero which is fine */ ret->flags = (int32_t)as->flags; ret->ext.max_early_data = as->max_early_data; OPENSSL_free(ret->ext.alpn_selected); if (as->alpn_selected != NULL) { ret->ext.alpn_selected = as->alpn_selected->data; ret->ext.alpn_selected_len = as->alpn_selected->length; as->alpn_selected->data = NULL; } else { ret->ext.alpn_selected = NULL; ret->ext.alpn_selected_len = 0; } ret->ext.max_fragment_len_mode = as->tlsext_max_fragment_len_mode; OPENSSL_free(ret->ticket_appdata); if (as->ticket_appdata != NULL) { ret->ticket_appdata = as->ticket_appdata->data; ret->ticket_appdata_len = as->ticket_appdata->length; as->ticket_appdata->data = NULL; } else { ret->ticket_appdata = NULL; ret->ticket_appdata_len = 0; } M_ASN1_free_of(as, SSL_SESSION_ASN1); if ((a != NULL) && (*a == NULL)) *a = ret; *pp = p; return ret; err: M_ASN1_free_of(as, SSL_SESSION_ASN1); if ((a == NULL) || (*a != ret)) SSL_SESSION_free(ret); return NULL; }

./openssl/ssl/ssl_lib.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include "ssl_local.h" #include "internal/e_os.h" #include <openssl/objects.h> #include <openssl/x509v3.h> #include <openssl/rand.h> #include <openssl/ocsp.h> #include <openssl/dh.h> #include <openssl/engine.h> #include <openssl/async.h> #include <openssl/ct.h> #include <openssl/trace.h> #include <openssl/core_names.h> #include "internal/cryptlib.h" #include "internal/nelem.h" #include "internal/refcount.h" #include "internal/ktls.h" #include "quic/quic_local.h" static int ssl_undefined_function_3(SSL_CONNECTION *sc, unsigned char *r, unsigned char *s, size_t t, size_t *u) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } static int ssl_undefined_function_4(SSL_CONNECTION *sc, int r) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } static size_t ssl_undefined_function_5(SSL_CONNECTION *sc, const char *r, size_t s, unsigned char *t) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } static int ssl_undefined_function_6(int r) { return ssl_undefined_function(NULL); } static int ssl_undefined_function_7(SSL_CONNECTION *sc, unsigned char *r, size_t s, const char *t, size_t u, const unsigned char *v, size_t w, int x) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } static int ssl_undefined_function_8(SSL_CONNECTION *sc) { return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } SSL3_ENC_METHOD ssl3_undef_enc_method = { ssl_undefined_function_8, ssl_undefined_function_3, ssl_undefined_function_4, ssl_undefined_function_5, NULL, /* client_finished_label */ 0, /* client_finished_label_len */ NULL, /* server_finished_label */ 0, /* server_finished_label_len */ ssl_undefined_function_6, ssl_undefined_function_7, }; struct ssl_async_args { SSL *s; void *buf; size_t num; enum { READFUNC, WRITEFUNC, OTHERFUNC } type; union { int (*func_read) (SSL *, void *, size_t, size_t *); int (*func_write) (SSL *, const void *, size_t, size_t *); int (*func_other) (SSL *); } f; }; static const struct { uint8_t mtype; uint8_t ord; int nid; } dane_mds[] = { { DANETLS_MATCHING_FULL, 0, NID_undef }, { DANETLS_MATCHING_2256, 1, NID_sha256 }, { DANETLS_MATCHING_2512, 2, NID_sha512 }, }; static int dane_ctx_enable(struct dane_ctx_st *dctx) { const EVP_MD **mdevp; uint8_t *mdord; uint8_t mdmax = DANETLS_MATCHING_LAST; int n = ((int)mdmax) + 1; /* int to handle PrivMatch(255) */ size_t i; if (dctx->mdevp != NULL) return 1; mdevp = OPENSSL_zalloc(n * sizeof(*mdevp)); mdord = OPENSSL_zalloc(n * sizeof(*mdord)); if (mdord == NULL || mdevp == NULL) { OPENSSL_free(mdord); OPENSSL_free(mdevp); return 0; } /* Install default entries */ for (i = 0; i < OSSL_NELEM(dane_mds); ++i) { const EVP_MD *md; if (dane_mds[i].nid == NID_undef || (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL) continue; mdevp[dane_mds[i].mtype] = md; mdord[dane_mds[i].mtype] = dane_mds[i].ord; } dctx->mdevp = mdevp; dctx->mdord = mdord; dctx->mdmax = mdmax; return 1; } static void dane_ctx_final(struct dane_ctx_st *dctx) { OPENSSL_free(dctx->mdevp); dctx->mdevp = NULL; OPENSSL_free(dctx->mdord); dctx->mdord = NULL; dctx->mdmax = 0; } static void tlsa_free(danetls_record *t) { if (t == NULL) return; OPENSSL_free(t->data); EVP_PKEY_free(t->spki); OPENSSL_free(t); } static void dane_final(SSL_DANE *dane) { sk_danetls_record_pop_free(dane->trecs, tlsa_free); dane->trecs = NULL; OSSL_STACK_OF_X509_free(dane->certs); dane->certs = NULL; X509_free(dane->mcert); dane->mcert = NULL; dane->mtlsa = NULL; dane->mdpth = -1; dane->pdpth = -1; } /* * dane_copy - Copy dane configuration, sans verification state. */ static int ssl_dane_dup(SSL_CONNECTION *to, SSL_CONNECTION *from) { int num; int i; if (!DANETLS_ENABLED(&from->dane)) return 1; num = sk_danetls_record_num(from->dane.trecs); dane_final(&to->dane); to->dane.flags = from->dane.flags; to->dane.dctx = &SSL_CONNECTION_GET_CTX(to)->dane; to->dane.trecs = sk_danetls_record_new_reserve(NULL, num); if (to->dane.trecs == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 0; } for (i = 0; i < num; ++i) { danetls_record *t = sk_danetls_record_value(from->dane.trecs, i); if (SSL_dane_tlsa_add(SSL_CONNECTION_GET_SSL(to), t->usage, t->selector, t->mtype, t->data, t->dlen) <= 0) return 0; } return 1; } static int dane_mtype_set(struct dane_ctx_st *dctx, const EVP_MD *md, uint8_t mtype, uint8_t ord) { int i; if (mtype == DANETLS_MATCHING_FULL && md != NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL); return 0; } if (mtype > dctx->mdmax) { const EVP_MD **mdevp; uint8_t *mdord; int n = ((int)mtype) + 1; mdevp = OPENSSL_realloc(dctx->mdevp, n * sizeof(*mdevp)); if (mdevp == NULL) return -1; dctx->mdevp = mdevp; mdord = OPENSSL_realloc(dctx->mdord, n * sizeof(*mdord)); if (mdord == NULL) return -1; dctx->mdord = mdord; /* Zero-fill any gaps */ for (i = dctx->mdmax + 1; i < mtype; ++i) { mdevp[i] = NULL; mdord[i] = 0; } dctx->mdmax = mtype; } dctx->mdevp[mtype] = md; /* Coerce ordinal of disabled matching types to 0 */ dctx->mdord[mtype] = (md == NULL) ? 0 : ord; return 1; } static const EVP_MD *tlsa_md_get(SSL_DANE *dane, uint8_t mtype) { if (mtype > dane->dctx->mdmax) return NULL; return dane->dctx->mdevp[mtype]; } static int dane_tlsa_add(SSL_DANE *dane, uint8_t usage, uint8_t selector, uint8_t mtype, const unsigned char *data, size_t dlen) { danetls_record *t; const EVP_MD *md = NULL; int ilen = (int)dlen; int i; int num; if (dane->trecs == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_NOT_ENABLED); return -1; } if (ilen < 0 || dlen != (size_t)ilen) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_DATA_LENGTH); return 0; } if (usage > DANETLS_USAGE_LAST) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE); return 0; } if (selector > DANETLS_SELECTOR_LAST) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_SELECTOR); return 0; } if (mtype != DANETLS_MATCHING_FULL) { md = tlsa_md_get(dane, mtype); if (md == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE); return 0; } } if (md != NULL && dlen != (size_t)EVP_MD_get_size(md)) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH); return 0; } if (!data) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_NULL_DATA); return 0; } if ((t = OPENSSL_zalloc(sizeof(*t))) == NULL) return -1; t->usage = usage; t->selector = selector; t->mtype = mtype; t->data = OPENSSL_malloc(dlen); if (t->data == NULL) { tlsa_free(t); return -1; } memcpy(t->data, data, dlen); t->dlen = dlen; /* Validate and cache full certificate or public key */ if (mtype == DANETLS_MATCHING_FULL) { const unsigned char *p = data; X509 *cert = NULL; EVP_PKEY *pkey = NULL; switch (selector) { case DANETLS_SELECTOR_CERT: if (!d2i_X509(&cert, &p, ilen) || p < data || dlen != (size_t)(p - data)) { X509_free(cert); tlsa_free(t); ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE); return 0; } if (X509_get0_pubkey(cert) == NULL) { X509_free(cert); tlsa_free(t); ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE); return 0; } if ((DANETLS_USAGE_BIT(usage) & DANETLS_TA_MASK) == 0) { /* * The Full(0) certificate decodes to a seemingly valid X.509 * object with a plausible key, so the TLSA record is well * formed. However, we don't actually need the certificate for * usages PKIX-EE(1) or DANE-EE(3), because at least the EE * certificate is always presented by the peer. We discard the * certificate, and just use the TLSA data as an opaque blob * for matching the raw presented DER octets. * * DO NOT FREE `t` here, it will be added to the TLSA record * list below! */ X509_free(cert); break; } /* * For usage DANE-TA(2), we support authentication via "2 0 0" TLSA * records that contain full certificates of trust-anchors that are * not present in the wire chain. For usage PKIX-TA(0), we augment * the chain with untrusted Full(0) certificates from DNS, in case * they are missing from the chain. */ if ((dane->certs == NULL && (dane->certs = sk_X509_new_null()) == NULL) || !sk_X509_push(dane->certs, cert)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); X509_free(cert); tlsa_free(t); return -1; } break; case DANETLS_SELECTOR_SPKI: if (!d2i_PUBKEY(&pkey, &p, ilen) || p < data || dlen != (size_t)(p - data)) { EVP_PKEY_free(pkey); tlsa_free(t); ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY); return 0; } /* * For usage DANE-TA(2), we support authentication via "2 1 0" TLSA * records that contain full bare keys of trust-anchors that are * not present in the wire chain. */ if (usage == DANETLS_USAGE_DANE_TA) t->spki = pkey; else EVP_PKEY_free(pkey); break; } } /*- * Find the right insertion point for the new record. * * See crypto/x509/x509_vfy.c. We sort DANE-EE(3) records first, so that * they can be processed first, as they require no chain building, and no * expiration or hostname checks. Because DANE-EE(3) is numerically * largest, this is accomplished via descending sort by "usage". * * We also sort in descending order by matching ordinal to simplify * the implementation of digest agility in the verification code. * * The choice of order for the selector is not significant, so we * use the same descending order for consistency. */ num = sk_danetls_record_num(dane->trecs); for (i = 0; i < num; ++i) { danetls_record *rec = sk_danetls_record_value(dane->trecs, i); if (rec->usage > usage) continue; if (rec->usage < usage) break; if (rec->selector > selector) continue; if (rec->selector < selector) break; if (dane->dctx->mdord[rec->mtype] > dane->dctx->mdord[mtype]) continue; break; } if (!sk_danetls_record_insert(dane->trecs, t, i)) { tlsa_free(t); ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return -1; } dane->umask |= DANETLS_USAGE_BIT(usage); return 1; } /* * Return 0 if there is only one version configured and it was disabled * at configure time. Return 1 otherwise. */ static int ssl_check_allowed_versions(int min_version, int max_version) { int minisdtls = 0, maxisdtls = 0; /* Figure out if we're doing DTLS versions or TLS versions */ if (min_version == DTLS1_BAD_VER || min_version >> 8 == DTLS1_VERSION_MAJOR) minisdtls = 1; if (max_version == DTLS1_BAD_VER || max_version >> 8 == DTLS1_VERSION_MAJOR) maxisdtls = 1; /* A wildcard version of 0 could be DTLS or TLS. */ if ((minisdtls && !maxisdtls && max_version != 0) || (maxisdtls && !minisdtls && min_version != 0)) { /* Mixing DTLS and TLS versions will lead to sadness; deny it. */ return 0; } if (minisdtls || maxisdtls) { /* Do DTLS version checks. */ if (min_version == 0) /* Ignore DTLS1_BAD_VER */ min_version = DTLS1_VERSION; if (max_version == 0) max_version = DTLS1_2_VERSION; #ifdef OPENSSL_NO_DTLS1_2 if (max_version == DTLS1_2_VERSION) max_version = DTLS1_VERSION; #endif #ifdef OPENSSL_NO_DTLS1 if (min_version == DTLS1_VERSION) min_version = DTLS1_2_VERSION; #endif /* Done massaging versions; do the check. */ if (0 #ifdef OPENSSL_NO_DTLS1 || (DTLS_VERSION_GE(min_version, DTLS1_VERSION) && DTLS_VERSION_GE(DTLS1_VERSION, max_version)) #endif #ifdef OPENSSL_NO_DTLS1_2 || (DTLS_VERSION_GE(min_version, DTLS1_2_VERSION) && DTLS_VERSION_GE(DTLS1_2_VERSION, max_version)) #endif ) return 0; } else { /* Regular TLS version checks. */ if (min_version == 0) min_version = SSL3_VERSION; if (max_version == 0) max_version = TLS1_3_VERSION; #ifdef OPENSSL_NO_TLS1_3 if (max_version == TLS1_3_VERSION) max_version = TLS1_2_VERSION; #endif #ifdef OPENSSL_NO_TLS1_2 if (max_version == TLS1_2_VERSION) max_version = TLS1_1_VERSION; #endif #ifdef OPENSSL_NO_TLS1_1 if (max_version == TLS1_1_VERSION) max_version = TLS1_VERSION; #endif #ifdef OPENSSL_NO_TLS1 if (max_version == TLS1_VERSION) max_version = SSL3_VERSION; #endif #ifdef OPENSSL_NO_SSL3 if (min_version == SSL3_VERSION) min_version = TLS1_VERSION; #endif #ifdef OPENSSL_NO_TLS1 if (min_version == TLS1_VERSION) min_version = TLS1_1_VERSION; #endif #ifdef OPENSSL_NO_TLS1_1 if (min_version == TLS1_1_VERSION) min_version = TLS1_2_VERSION; #endif #ifdef OPENSSL_NO_TLS1_2 if (min_version == TLS1_2_VERSION) min_version = TLS1_3_VERSION; #endif /* Done massaging versions; do the check. */ if (0 #ifdef OPENSSL_NO_SSL3 || (min_version <= SSL3_VERSION && SSL3_VERSION <= max_version) #endif #ifdef OPENSSL_NO_TLS1 || (min_version <= TLS1_VERSION && TLS1_VERSION <= max_version) #endif #ifdef OPENSSL_NO_TLS1_1 || (min_version <= TLS1_1_VERSION && TLS1_1_VERSION <= max_version) #endif #ifdef OPENSSL_NO_TLS1_2 || (min_version <= TLS1_2_VERSION && TLS1_2_VERSION <= max_version) #endif #ifdef OPENSSL_NO_TLS1_3 || (min_version <= TLS1_3_VERSION && TLS1_3_VERSION <= max_version) #endif ) return 0; } return 1; } #if defined(__TANDEM) && defined(OPENSSL_VPROC) /* * Define a VPROC function for HP NonStop build ssl library. * This is used by platform version identification tools. * Do not inline this procedure or make it static. */ # define OPENSSL_VPROC_STRING_(x) x##_SSL # define OPENSSL_VPROC_STRING(x) OPENSSL_VPROC_STRING_(x) # define OPENSSL_VPROC_FUNC OPENSSL_VPROC_STRING(OPENSSL_VPROC) void OPENSSL_VPROC_FUNC(void) {} #endif static int clear_record_layer(SSL_CONNECTION *s) { int ret; /* We try and reset both record layers even if one fails */ ret = ssl_set_new_record_layer(s, SSL_CONNECTION_IS_DTLS(s) ? DTLS_ANY_VERSION : TLS_ANY_VERSION, OSSL_RECORD_DIRECTION_READ, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL); ret &= ssl_set_new_record_layer(s, SSL_CONNECTION_IS_DTLS(s) ? DTLS_ANY_VERSION : TLS_ANY_VERSION, OSSL_RECORD_DIRECTION_WRITE, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL); /* SSLfatal already called in the event of failure */ return ret; } int SSL_clear(SSL *s) { if (s->method == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_METHOD_SPECIFIED); return 0; } return s->method->ssl_reset(s); } int ossl_ssl_connection_reset(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (ssl_clear_bad_session(sc)) { SSL_SESSION_free(sc->session); sc->session = NULL; } SSL_SESSION_free(sc->psksession); sc->psksession = NULL; OPENSSL_free(sc->psksession_id); sc->psksession_id = NULL; sc->psksession_id_len = 0; sc->hello_retry_request = SSL_HRR_NONE; sc->sent_tickets = 0; sc->error = 0; sc->hit = 0; sc->shutdown = 0; if (sc->renegotiate) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } ossl_statem_clear(sc); sc->version = s->method->version; sc->client_version = sc->version; sc->rwstate = SSL_NOTHING; BUF_MEM_free(sc->init_buf); sc->init_buf = NULL; sc->first_packet = 0; sc->key_update = SSL_KEY_UPDATE_NONE; memset(sc->ext.compress_certificate_from_peer, 0, sizeof(sc->ext.compress_certificate_from_peer)); sc->ext.compress_certificate_sent = 0; EVP_MD_CTX_free(sc->pha_dgst); sc->pha_dgst = NULL; /* Reset DANE verification result state */ sc->dane.mdpth = -1; sc->dane.pdpth = -1; X509_free(sc->dane.mcert); sc->dane.mcert = NULL; sc->dane.mtlsa = NULL; /* Clear the verification result peername */ X509_VERIFY_PARAM_move_peername(sc->param, NULL); /* Clear any shared connection state */ OPENSSL_free(sc->shared_sigalgs); sc->shared_sigalgs = NULL; sc->shared_sigalgslen = 0; /* * Check to see if we were changed into a different method, if so, revert * back. */ if (s->method != s->defltmeth) { s->method->ssl_deinit(s); s->method = s->defltmeth; if (!s->method->ssl_init(s)) return 0; } else { if (!s->method->ssl_clear(s)) return 0; } RECORD_LAYER_clear(&sc->rlayer); BIO_free(sc->rlayer.rrlnext); sc->rlayer.rrlnext = NULL; if (!clear_record_layer(sc)) return 0; return 1; } #ifndef OPENSSL_NO_DEPRECATED_3_0 /** Used to change an SSL_CTXs default SSL method type */ int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth) { STACK_OF(SSL_CIPHER) *sk; if (IS_QUIC_CTX(ctx)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } ctx->method = meth; if (!SSL_CTX_set_ciphersuites(ctx, OSSL_default_ciphersuites())) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS); return 0; } sk = ssl_create_cipher_list(ctx, ctx->tls13_ciphersuites, &(ctx->cipher_list), &(ctx->cipher_list_by_id), OSSL_default_cipher_list(), ctx->cert); if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS); return 0; } return 1; } #endif SSL *SSL_new(SSL_CTX *ctx) { if (ctx == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NULL_SSL_CTX); return NULL; } if (ctx->method == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION); return NULL; } return ctx->method->ssl_new(ctx); } int ossl_ssl_init(SSL *ssl, SSL_CTX *ctx, const SSL_METHOD *method, int type) { ssl->type = type; ssl->lock = CRYPTO_THREAD_lock_new(); if (ssl->lock == NULL) return 0; if (!CRYPTO_NEW_REF(&ssl->references, 1)) { CRYPTO_THREAD_lock_free(ssl->lock); return 0; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, ssl, &ssl->ex_data)) { CRYPTO_THREAD_lock_free(ssl->lock); CRYPTO_FREE_REF(&ssl->references); ssl->lock = NULL; return 0; } SSL_CTX_up_ref(ctx); ssl->ctx = ctx; ssl->defltmeth = ssl->method = method; return 1; } SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, const SSL_METHOD *method) { SSL_CONNECTION *s; SSL *ssl; s = OPENSSL_zalloc(sizeof(*s)); if (s == NULL) return NULL; ssl = &s->ssl; if (!ossl_ssl_init(ssl, ctx, method, SSL_TYPE_SSL_CONNECTION)) { OPENSSL_free(s); s = NULL; ssl = NULL; goto sslerr; } RECORD_LAYER_init(&s->rlayer, s); s->options = ctx->options; s->dane.flags = ctx->dane.flags; if (method->version == ctx->method->version) { s->min_proto_version = ctx->min_proto_version; s->max_proto_version = ctx->max_proto_version; } s->mode = ctx->mode; s->max_cert_list = ctx->max_cert_list; s->max_early_data = ctx->max_early_data; s->recv_max_early_data = ctx->recv_max_early_data; s->num_tickets = ctx->num_tickets; s->pha_enabled = ctx->pha_enabled; /* Shallow copy of the ciphersuites stack */ s->tls13_ciphersuites = sk_SSL_CIPHER_dup(ctx->tls13_ciphersuites); if (s->tls13_ciphersuites == NULL) goto cerr; /* * Earlier library versions used to copy the pointer to the CERT, not * its contents; only when setting new parameters for the per-SSL * copy, ssl_cert_new would be called (and the direct reference to * the per-SSL_CTX settings would be lost, but those still were * indirectly accessed for various purposes, and for that reason they * used to be known as s->ctx->default_cert). Now we don't look at the * SSL_CTX's CERT after having duplicated it once. */ s->cert = ssl_cert_dup(ctx->cert); if (s->cert == NULL) goto sslerr; RECORD_LAYER_set_read_ahead(&s->rlayer, ctx->read_ahead); s->msg_callback = ctx->msg_callback; s->msg_callback_arg = ctx->msg_callback_arg; s->verify_mode = ctx->verify_mode; s->not_resumable_session_cb = ctx->not_resumable_session_cb; s->rlayer.record_padding_cb = ctx->record_padding_cb; s->rlayer.record_padding_arg = ctx->record_padding_arg; s->rlayer.block_padding = ctx->block_padding; s->sid_ctx_length = ctx->sid_ctx_length; if (!ossl_assert(s->sid_ctx_length <= sizeof(s->sid_ctx))) goto err; memcpy(&s->sid_ctx, &ctx->sid_ctx, sizeof(s->sid_ctx)); s->verify_callback = ctx->default_verify_callback; s->generate_session_id = ctx->generate_session_id; s->param = X509_VERIFY_PARAM_new(); if (s->param == NULL) goto asn1err; X509_VERIFY_PARAM_inherit(s->param, ctx->param); s->quiet_shutdown = IS_QUIC_CTX(ctx) ? 0 : ctx->quiet_shutdown; if (!IS_QUIC_CTX(ctx)) s->ext.max_fragment_len_mode = ctx->ext.max_fragment_len_mode; s->max_send_fragment = ctx->max_send_fragment; s->split_send_fragment = ctx->split_send_fragment; s->max_pipelines = ctx->max_pipelines; s->rlayer.default_read_buf_len = ctx->default_read_buf_len; s->ext.debug_cb = 0; s->ext.debug_arg = NULL; s->ext.ticket_expected = 0; s->ext.status_type = ctx->ext.status_type; s->ext.status_expected = 0; s->ext.ocsp.ids = NULL; s->ext.ocsp.exts = NULL; s->ext.ocsp.resp = NULL; s->ext.ocsp.resp_len = 0; SSL_CTX_up_ref(ctx); s->session_ctx = ctx; if (ctx->ext.ecpointformats) { s->ext.ecpointformats = OPENSSL_memdup(ctx->ext.ecpointformats, ctx->ext.ecpointformats_len); if (!s->ext.ecpointformats) { s->ext.ecpointformats_len = 0; goto err; } s->ext.ecpointformats_len = ctx->ext.ecpointformats_len; } if (ctx->ext.supportedgroups) { s->ext.supportedgroups = OPENSSL_memdup(ctx->ext.supportedgroups, ctx->ext.supportedgroups_len * sizeof(*ctx->ext.supportedgroups)); if (!s->ext.supportedgroups) { s->ext.supportedgroups_len = 0; goto err; } s->ext.supportedgroups_len = ctx->ext.supportedgroups_len; } #ifndef OPENSSL_NO_NEXTPROTONEG s->ext.npn = NULL; #endif if (ctx->ext.alpn != NULL) { s->ext.alpn = OPENSSL_malloc(ctx->ext.alpn_len); if (s->ext.alpn == NULL) { s->ext.alpn_len = 0; goto err; } memcpy(s->ext.alpn, ctx->ext.alpn, ctx->ext.alpn_len); s->ext.alpn_len = ctx->ext.alpn_len; } s->verified_chain = NULL; s->verify_result = X509_V_OK; s->default_passwd_callback = ctx->default_passwd_callback; s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata; s->key_update = SSL_KEY_UPDATE_NONE; if (!IS_QUIC_CTX(ctx)) { s->allow_early_data_cb = ctx->allow_early_data_cb; s->allow_early_data_cb_data = ctx->allow_early_data_cb_data; } if (!method->ssl_init(ssl)) goto sslerr; s->server = (method->ssl_accept == ssl_undefined_function) ? 0 : 1; if (!method->ssl_reset(ssl)) goto sslerr; #ifndef OPENSSL_NO_PSK s->psk_client_callback = ctx->psk_client_callback; s->psk_server_callback = ctx->psk_server_callback; #endif s->psk_find_session_cb = ctx->psk_find_session_cb; s->psk_use_session_cb = ctx->psk_use_session_cb; s->async_cb = ctx->async_cb; s->async_cb_arg = ctx->async_cb_arg; s->job = NULL; #ifndef OPENSSL_NO_COMP_ALG memcpy(s->cert_comp_prefs, ctx->cert_comp_prefs, sizeof(s->cert_comp_prefs)); #endif if (ctx->client_cert_type != NULL) { s->client_cert_type = OPENSSL_memdup(ctx->client_cert_type, ctx->client_cert_type_len); if (s->client_cert_type == NULL) goto sslerr; s->client_cert_type_len = ctx->client_cert_type_len; } if (ctx->server_cert_type != NULL) { s->server_cert_type = OPENSSL_memdup(ctx->server_cert_type, ctx->server_cert_type_len); if (s->server_cert_type == NULL) goto sslerr; s->server_cert_type_len = ctx->server_cert_type_len; } #ifndef OPENSSL_NO_CT if (!SSL_set_ct_validation_callback(ssl, ctx->ct_validation_callback, ctx->ct_validation_callback_arg)) goto sslerr; #endif s->ssl_pkey_num = SSL_PKEY_NUM + ctx->sigalg_list_len; return ssl; cerr: ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; asn1err: ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB); goto err; sslerr: ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); err: SSL_free(ssl); return NULL; } SSL *ossl_ssl_connection_new(SSL_CTX *ctx) { return ossl_ssl_connection_new_int(ctx, ctx->method); } int SSL_is_dtls(const SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO) return 0; #endif if (sc == NULL) return 0; return SSL_CONNECTION_IS_DTLS(sc) ? 1 : 0; } int SSL_is_tls(const SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO) return 0; #endif if (sc == NULL) return 0; return SSL_CONNECTION_IS_DTLS(sc) ? 0 : 1; } int SSL_is_quic(const SSL *s) { #ifndef OPENSSL_NO_QUIC if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO) return 1; #endif return 0; } int SSL_up_ref(SSL *s) { int i; if (CRYPTO_UP_REF(&s->references, &i) <= 0) return 0; REF_PRINT_COUNT("SSL", s); REF_ASSERT_ISNT(i < 2); return ((i > 1) ? 1 : 0); } int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx, unsigned int sid_ctx_len) { if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG); return 0; } ctx->sid_ctx_length = sid_ctx_len; memcpy(ctx->sid_ctx, sid_ctx, sid_ctx_len); return 1; } int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx, unsigned int sid_ctx_len) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG); return 0; } sc->sid_ctx_length = sid_ctx_len; memcpy(sc->sid_ctx, sid_ctx, sid_ctx_len); return 1; } int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb) { if (!CRYPTO_THREAD_write_lock(ctx->lock)) return 0; ctx->generate_session_id = cb; CRYPTO_THREAD_unlock(ctx->lock); return 1; } int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL || !CRYPTO_THREAD_write_lock(ssl->lock)) return 0; sc->generate_session_id = cb; CRYPTO_THREAD_unlock(ssl->lock); return 1; } int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id, unsigned int id_len) { /* * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how * we can "construct" a session to give us the desired check - i.e. to * find if there's a session in the hash table that would conflict with * any new session built out of this id/id_len and the ssl_version in use * by this SSL. */ SSL_SESSION r, *p; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL || id_len > sizeof(r.session_id)) return 0; r.ssl_version = sc->version; r.session_id_length = id_len; memcpy(r.session_id, id, id_len); if (!CRYPTO_THREAD_read_lock(sc->session_ctx->lock)) return 0; p = lh_SSL_SESSION_retrieve(sc->session_ctx->sessions, &r); CRYPTO_THREAD_unlock(sc->session_ctx->lock); return (p != NULL); } int SSL_CTX_set_purpose(SSL_CTX *s, int purpose) { return X509_VERIFY_PARAM_set_purpose(s->param, purpose); } int SSL_set_purpose(SSL *s, int purpose) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return X509_VERIFY_PARAM_set_purpose(sc->param, purpose); } int SSL_CTX_set_trust(SSL_CTX *s, int trust) { return X509_VERIFY_PARAM_set_trust(s->param, trust); } int SSL_set_trust(SSL *s, int trust) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return X509_VERIFY_PARAM_set_trust(sc->param, trust); } int SSL_set1_host(SSL *s, const char *hostname) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* If a hostname is provided and parses as an IP address, * treat it as such. */ if (hostname != NULL && X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname) == 1) return 1; return X509_VERIFY_PARAM_set1_host(sc->param, hostname, 0); } int SSL_add1_host(SSL *s, const char *hostname) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* If a hostname is provided and parses as an IP address, * treat it as such. */ if (hostname) { ASN1_OCTET_STRING *ip; char *old_ip; ip = a2i_IPADDRESS(hostname); if (ip) { /* We didn't want it; only to check if it *is* an IP address */ ASN1_OCTET_STRING_free(ip); old_ip = X509_VERIFY_PARAM_get1_ip_asc(sc->param); if (old_ip) { OPENSSL_free(old_ip); /* There can be only one IP address */ return 0; } return X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname); } } return X509_VERIFY_PARAM_add1_host(sc->param, hostname, 0); } void SSL_set_hostflags(SSL *s, unsigned int flags) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; X509_VERIFY_PARAM_set_hostflags(sc->param, flags); } const char *SSL_get0_peername(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return X509_VERIFY_PARAM_get0_peername(sc->param); } int SSL_CTX_dane_enable(SSL_CTX *ctx) { return dane_ctx_enable(&ctx->dane); } unsigned long SSL_CTX_dane_set_flags(SSL_CTX *ctx, unsigned long flags) { unsigned long orig = ctx->dane.flags; ctx->dane.flags |= flags; return orig; } unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags) { unsigned long orig = ctx->dane.flags; ctx->dane.flags &= ~flags; return orig; } int SSL_dane_enable(SSL *s, const char *basedomain) { SSL_DANE *dane; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; dane = &sc->dane; if (s->ctx->dane.mdmax == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_CONTEXT_NOT_DANE_ENABLED); return 0; } if (dane->trecs != NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_DANE_ALREADY_ENABLED); return 0; } /* * Default SNI name. This rejects empty names, while set1_host below * accepts them and disables hostname checks. To avoid side-effects with * invalid input, set the SNI name first. */ if (sc->ext.hostname == NULL) { if (!SSL_set_tlsext_host_name(s, basedomain)) { ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN); return -1; } } /* Primary RFC6125 reference identifier */ if (!X509_VERIFY_PARAM_set1_host(sc->param, basedomain, 0)) { ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN); return -1; } dane->mdpth = -1; dane->pdpth = -1; dane->dctx = &s->ctx->dane; dane->trecs = sk_danetls_record_new_null(); if (dane->trecs == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return -1; } return 1; } unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags) { unsigned long orig; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; orig = sc->dane.flags; sc->dane.flags |= flags; return orig; } unsigned long SSL_dane_clear_flags(SSL *ssl, unsigned long flags) { unsigned long orig; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; orig = sc->dane.flags; sc->dane.flags &= ~flags; return orig; } int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki) { SSL_DANE *dane; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; dane = &sc->dane; if (!DANETLS_ENABLED(dane) || sc->verify_result != X509_V_OK) return -1; if (dane->mtlsa) { if (mcert) *mcert = dane->mcert; if (mspki) *mspki = (dane->mcert == NULL) ? dane->mtlsa->spki : NULL; } return dane->mdpth; } int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector, uint8_t *mtype, const unsigned char **data, size_t *dlen) { SSL_DANE *dane; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; dane = &sc->dane; if (!DANETLS_ENABLED(dane) || sc->verify_result != X509_V_OK) return -1; if (dane->mtlsa) { if (usage) *usage = dane->mtlsa->usage; if (selector) *selector = dane->mtlsa->selector; if (mtype) *mtype = dane->mtlsa->mtype; if (data) *data = dane->mtlsa->data; if (dlen) *dlen = dane->mtlsa->dlen; } return dane->mdpth; } SSL_DANE *SSL_get0_dane(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return &sc->dane; } int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector, uint8_t mtype, const unsigned char *data, size_t dlen) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return dane_tlsa_add(&sc->dane, usage, selector, mtype, data, dlen); } int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, uint8_t mtype, uint8_t ord) { return dane_mtype_set(&ctx->dane, md, mtype, ord); } int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm) { return X509_VERIFY_PARAM_set1(ctx->param, vpm); } int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; return X509_VERIFY_PARAM_set1(sc->param, vpm); } X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx) { return ctx->param; } X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return NULL; return sc->param; } void SSL_certs_clear(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; ssl_cert_clear_certs(sc->cert); } void SSL_free(SSL *s) { int i; if (s == NULL) return; CRYPTO_DOWN_REF(&s->references, &i); REF_PRINT_COUNT("SSL", s); if (i > 0) return; REF_ASSERT_ISNT(i < 0); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data); if (s->method != NULL) s->method->ssl_free(s); SSL_CTX_free(s->ctx); CRYPTO_THREAD_lock_free(s->lock); CRYPTO_FREE_REF(&s->references); OPENSSL_free(s); } void ossl_ssl_connection_free(SSL *ssl) { SSL_CONNECTION *s; s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return; X509_VERIFY_PARAM_free(s->param); dane_final(&s->dane); /* Ignore return value */ ssl_free_wbio_buffer(s); RECORD_LAYER_clear(&s->rlayer); BUF_MEM_free(s->init_buf); /* add extra stuff */ sk_SSL_CIPHER_free(s->cipher_list); sk_SSL_CIPHER_free(s->cipher_list_by_id); sk_SSL_CIPHER_free(s->tls13_ciphersuites); sk_SSL_CIPHER_free(s->peer_ciphers); /* Make the next call work :-) */ if (s->session != NULL) { ssl_clear_bad_session(s); SSL_SESSION_free(s->session); } SSL_SESSION_free(s->psksession); OPENSSL_free(s->psksession_id); ssl_cert_free(s->cert); OPENSSL_free(s->shared_sigalgs); /* Free up if allocated */ OPENSSL_free(s->ext.hostname); SSL_CTX_free(s->session_ctx); OPENSSL_free(s->ext.ecpointformats); OPENSSL_free(s->ext.peer_ecpointformats); OPENSSL_free(s->ext.supportedgroups); OPENSSL_free(s->ext.peer_supportedgroups); sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts, X509_EXTENSION_free); #ifndef OPENSSL_NO_OCSP sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free); #endif #ifndef OPENSSL_NO_CT SCT_LIST_free(s->scts); OPENSSL_free(s->ext.scts); #endif OPENSSL_free(s->ext.ocsp.resp); OPENSSL_free(s->ext.alpn); OPENSSL_free(s->ext.tls13_cookie); if (s->clienthello != NULL) OPENSSL_free(s->clienthello->pre_proc_exts); OPENSSL_free(s->clienthello); OPENSSL_free(s->pha_context); EVP_MD_CTX_free(s->pha_dgst); sk_X509_NAME_pop_free(s->ca_names, X509_NAME_free); sk_X509_NAME_pop_free(s->client_ca_names, X509_NAME_free); OPENSSL_free(s->client_cert_type); OPENSSL_free(s->server_cert_type); OSSL_STACK_OF_X509_free(s->verified_chain); if (ssl->method != NULL) ssl->method->ssl_deinit(ssl); ASYNC_WAIT_CTX_free(s->waitctx); #if !defined(OPENSSL_NO_NEXTPROTONEG) OPENSSL_free(s->ext.npn); #endif #ifndef OPENSSL_NO_SRTP sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles); #endif /* * We do this late. We want to ensure that any other references we held to * these BIOs are freed first *before* we call BIO_free_all(), because * BIO_free_all() will only free each BIO in the chain if the number of * references to the first BIO have dropped to 0 */ BIO_free_all(s->wbio); s->wbio = NULL; BIO_free_all(s->rbio); s->rbio = NULL; OPENSSL_free(s->s3.tmp.valid_flags); } void SSL_set0_rbio(SSL *s, BIO *rbio) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { ossl_quic_conn_set0_net_rbio(s, rbio); return; } #endif if (sc == NULL) return; BIO_free_all(sc->rbio); sc->rbio = rbio; sc->rlayer.rrlmethod->set1_bio(sc->rlayer.rrl, sc->rbio); } void SSL_set0_wbio(SSL *s, BIO *wbio) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { ossl_quic_conn_set0_net_wbio(s, wbio); return; } #endif if (sc == NULL) return; /* * If the output buffering BIO is still in place, remove it */ if (sc->bbio != NULL) sc->wbio = BIO_pop(sc->wbio); BIO_free_all(sc->wbio); sc->wbio = wbio; /* Re-attach |bbio| to the new |wbio|. */ if (sc->bbio != NULL) sc->wbio = BIO_push(sc->bbio, sc->wbio); sc->rlayer.wrlmethod->set1_bio(sc->rlayer.wrl, sc->wbio); } void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio) { /* * For historical reasons, this function has many different cases in * ownership handling. */ /* If nothing has changed, do nothing */ if (rbio == SSL_get_rbio(s) && wbio == SSL_get_wbio(s)) return; /* * If the two arguments are equal then one fewer reference is granted by the * caller than we want to take */ if (rbio != NULL && rbio == wbio) BIO_up_ref(rbio); /* * If only the wbio is changed only adopt one reference. */ if (rbio == SSL_get_rbio(s)) { SSL_set0_wbio(s, wbio); return; } /* * There is an asymmetry here for historical reasons. If only the rbio is * changed AND the rbio and wbio were originally different, then we only * adopt one reference. */ if (wbio == SSL_get_wbio(s) && SSL_get_rbio(s) != SSL_get_wbio(s)) { SSL_set0_rbio(s, rbio); return; } /* Otherwise, adopt both references. */ SSL_set0_rbio(s, rbio); SSL_set0_wbio(s, wbio); } BIO *SSL_get_rbio(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_conn_get_net_rbio(s); #endif if (sc == NULL) return NULL; return sc->rbio; } BIO *SSL_get_wbio(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_conn_get_net_wbio(s); #endif if (sc == NULL) return NULL; if (sc->bbio != NULL) { /* * If |bbio| is active, the true caller-configured BIO is its * |next_bio|. */ return BIO_next(sc->bbio); } return sc->wbio; } int SSL_get_fd(const SSL *s) { return SSL_get_rfd(s); } int SSL_get_rfd(const SSL *s) { int ret = -1; BIO *b, *r; b = SSL_get_rbio(s); r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR); if (r != NULL) BIO_get_fd(r, &ret); return ret; } int SSL_get_wfd(const SSL *s) { int ret = -1; BIO *b, *r; b = SSL_get_wbio(s); r = BIO_find_type(b, BIO_TYPE_DESCRIPTOR); if (r != NULL) BIO_get_fd(r, &ret); return ret; } #ifndef OPENSSL_NO_SOCK static const BIO_METHOD *fd_method(SSL *s) { #ifndef OPENSSL_NO_DGRAM if (IS_QUIC(s)) return BIO_s_datagram(); #endif return BIO_s_socket(); } int SSL_set_fd(SSL *s, int fd) { int ret = 0; BIO *bio = NULL; if (s->type == SSL_TYPE_QUIC_XSO) { ERR_raise(ERR_LIB_SSL, SSL_R_CONN_USE_ONLY); goto err; } bio = BIO_new(fd_method(s)); if (bio == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); goto err; } BIO_set_fd(bio, fd, BIO_NOCLOSE); SSL_set_bio(s, bio, bio); #ifndef OPENSSL_NO_KTLS /* * The new socket is created successfully regardless of ktls_enable. * ktls_enable doesn't change any functionality of the socket, except * changing the setsockopt to enable the processing of ktls_start. * Thus, it is not a problem to call it for non-TLS sockets. */ ktls_enable(fd); #endif /* OPENSSL_NO_KTLS */ ret = 1; err: return ret; } int SSL_set_wfd(SSL *s, int fd) { BIO *rbio = SSL_get_rbio(s); int desired_type = IS_QUIC(s) ? BIO_TYPE_DGRAM : BIO_TYPE_SOCKET; if (s->type == SSL_TYPE_QUIC_XSO) { ERR_raise(ERR_LIB_SSL, SSL_R_CONN_USE_ONLY); return 0; } if (rbio == NULL || BIO_method_type(rbio) != desired_type || (int)BIO_get_fd(rbio, NULL) != fd) { BIO *bio = BIO_new(fd_method(s)); if (bio == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); return 0; } BIO_set_fd(bio, fd, BIO_NOCLOSE); SSL_set0_wbio(s, bio); #ifndef OPENSSL_NO_KTLS /* * The new socket is created successfully regardless of ktls_enable. * ktls_enable doesn't change any functionality of the socket, except * changing the setsockopt to enable the processing of ktls_start. * Thus, it is not a problem to call it for non-TLS sockets. */ ktls_enable(fd); #endif /* OPENSSL_NO_KTLS */ } else { BIO_up_ref(rbio); SSL_set0_wbio(s, rbio); } return 1; } int SSL_set_rfd(SSL *s, int fd) { BIO *wbio = SSL_get_wbio(s); int desired_type = IS_QUIC(s) ? BIO_TYPE_DGRAM : BIO_TYPE_SOCKET; if (s->type == SSL_TYPE_QUIC_XSO) { ERR_raise(ERR_LIB_SSL, SSL_R_CONN_USE_ONLY); return 0; } if (wbio == NULL || BIO_method_type(wbio) != desired_type || ((int)BIO_get_fd(wbio, NULL) != fd)) { BIO *bio = BIO_new(fd_method(s)); if (bio == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); return 0; } BIO_set_fd(bio, fd, BIO_NOCLOSE); SSL_set0_rbio(s, bio); } else { BIO_up_ref(wbio); SSL_set0_rbio(s, wbio); } return 1; } #endif /* return length of latest Finished message we sent, copy to 'buf' */ size_t SSL_get_finished(const SSL *s, void *buf, size_t count) { size_t ret = 0; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; ret = sc->s3.tmp.finish_md_len; if (count > ret) count = ret; memcpy(buf, sc->s3.tmp.finish_md, count); return ret; } /* return length of latest Finished message we expected, copy to 'buf' */ size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count) { size_t ret = 0; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; ret = sc->s3.tmp.peer_finish_md_len; if (count > ret) count = ret; memcpy(buf, sc->s3.tmp.peer_finish_md, count); return ret; } int SSL_get_verify_mode(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->verify_mode; } int SSL_get_verify_depth(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return X509_VERIFY_PARAM_get_depth(sc->param); } int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->verify_callback; } int SSL_CTX_get_verify_mode(const SSL_CTX *ctx) { return ctx->verify_mode; } int SSL_CTX_get_verify_depth(const SSL_CTX *ctx) { return X509_VERIFY_PARAM_get_depth(ctx->param); } int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) { return ctx->default_verify_callback; } void SSL_set_verify(SSL *s, int mode, int (*callback) (int ok, X509_STORE_CTX *ctx)) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->verify_mode = mode; if (callback != NULL) sc->verify_callback = callback; } void SSL_set_verify_depth(SSL *s, int depth) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; X509_VERIFY_PARAM_set_depth(sc->param, depth); } void SSL_set_read_ahead(SSL *s, int yes) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); OSSL_PARAM options[2], *opts = options; if (sc == NULL) return; RECORD_LAYER_set_read_ahead(&sc->rlayer, yes); *opts++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD, &sc->rlayer.read_ahead); *opts = OSSL_PARAM_construct_end(); /* Ignore return value */ sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options); } int SSL_get_read_ahead(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); if (sc == NULL) return 0; return RECORD_LAYER_get_read_ahead(&sc->rlayer); } int SSL_pending(const SSL *s) { size_t pending = s->method->ssl_pending(s); /* * SSL_pending cannot work properly if read-ahead is enabled * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)), and it is * impossible to fix since SSL_pending cannot report errors that may be * observed while scanning the new data. (Note that SSL_pending() is * often used as a boolean value, so we'd better not return -1.) * * SSL_pending also cannot work properly if the value >INT_MAX. In that case * we just return INT_MAX. */ return pending < INT_MAX ? (int)pending : INT_MAX; } int SSL_has_pending(const SSL *s) { /* * Similar to SSL_pending() but returns a 1 to indicate that we have * processed or unprocessed data available or 0 otherwise (as opposed to the * number of bytes available). Unlike SSL_pending() this will take into * account read_ahead data. A 1 return simply indicates that we have data. * That data may not result in any application data, or we may fail to parse * the records for some reason. */ const SSL_CONNECTION *sc; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_has_pending(s); #endif sc = SSL_CONNECTION_FROM_CONST_SSL(s); /* Check buffered app data if any first */ if (SSL_CONNECTION_IS_DTLS(sc)) { TLS_RECORD *rdata; pitem *item, *iter; iter = pqueue_iterator(sc->rlayer.d->buffered_app_data.q); while ((item = pqueue_next(&iter)) != NULL) { rdata = item->data; if (rdata->length > 0) return 1; } } if (RECORD_LAYER_processed_read_pending(&sc->rlayer)) return 1; return RECORD_LAYER_read_pending(&sc->rlayer); } X509 *SSL_get1_peer_certificate(const SSL *s) { X509 *r = SSL_get0_peer_certificate(s); if (r != NULL) X509_up_ref(r); return r; } X509 *SSL_get0_peer_certificate(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (sc->session == NULL) return NULL; else return sc->session->peer; } STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s) { STACK_OF(X509) *r; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (sc->session == NULL) r = NULL; else r = sc->session->peer_chain; /* * If we are a client, cert_chain includes the peer's own certificate; if * we are a server, it does not. */ return r; } /* * Now in theory, since the calling process own 't' it should be safe to * modify. We need to be able to read f without being hassled */ int SSL_copy_session_id(SSL *t, const SSL *f) { int i; /* TODO(QUIC FUTURE): Not allowed for QUIC currently. */ SSL_CONNECTION *tsc = SSL_CONNECTION_FROM_SSL_ONLY(t); const SSL_CONNECTION *fsc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(f); if (tsc == NULL || fsc == NULL) return 0; /* Do we need to do SSL locking? */ if (!SSL_set_session(t, SSL_get_session(f))) { return 0; } /* * what if we are setup for one protocol version but want to talk another */ if (t->method != f->method) { t->method->ssl_deinit(t); t->method = f->method; if (t->method->ssl_init(t) == 0) return 0; } CRYPTO_UP_REF(&fsc->cert->references, &i); ssl_cert_free(tsc->cert); tsc->cert = fsc->cert; if (!SSL_set_session_id_context(t, fsc->sid_ctx, (int)fsc->sid_ctx_length)) { return 0; } return 1; } /* Fix this so it checks all the valid key/cert options */ int SSL_CTX_check_private_key(const SSL_CTX *ctx) { if ((ctx == NULL) || (ctx->cert->key->x509 == NULL)) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED); return 0; } if (ctx->cert->key->privatekey == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED); return 0; } return X509_check_private_key (ctx->cert->key->x509, ctx->cert->key->privatekey); } /* Fix this function so that it takes an optional type parameter */ int SSL_check_private_key(const SSL *ssl) { const SSL_CONNECTION *sc; if ((sc = SSL_CONNECTION_FROM_CONST_SSL(ssl)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } if (sc->cert->key->x509 == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED); return 0; } if (sc->cert->key->privatekey == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED); return 0; } return X509_check_private_key(sc->cert->key->x509, sc->cert->key->privatekey); } int SSL_waiting_for_async(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->job) return 1; return 0; } int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds) { ASYNC_WAIT_CTX *ctx; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if ((ctx = sc->waitctx) == NULL) return 0; return ASYNC_WAIT_CTX_get_all_fds(ctx, fds, numfds); } int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds, OSSL_ASYNC_FD *delfd, size_t *numdelfds) { ASYNC_WAIT_CTX *ctx; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if ((ctx = sc->waitctx) == NULL) return 0; return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd, numdelfds); } int SSL_CTX_set_async_callback(SSL_CTX *ctx, SSL_async_callback_fn callback) { ctx->async_cb = callback; return 1; } int SSL_CTX_set_async_callback_arg(SSL_CTX *ctx, void *arg) { ctx->async_cb_arg = arg; return 1; } int SSL_set_async_callback(SSL *s, SSL_async_callback_fn callback) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->async_cb = callback; return 1; } int SSL_set_async_callback_arg(SSL *s, void *arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->async_cb_arg = arg; return 1; } int SSL_get_async_status(SSL *s, int *status) { ASYNC_WAIT_CTX *ctx; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if ((ctx = sc->waitctx) == NULL) return 0; *status = ASYNC_WAIT_CTX_get_status(ctx); return 1; } int SSL_accept(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_accept(s); #endif if (sc == NULL) return 0; if (sc->handshake_func == NULL) { /* Not properly initialized yet */ SSL_set_accept_state(s); } return SSL_do_handshake(s); } int SSL_connect(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_connect(s); #endif if (sc == NULL) return 0; if (sc->handshake_func == NULL) { /* Not properly initialized yet */ SSL_set_connect_state(s); } return SSL_do_handshake(s); } long SSL_get_default_timeout(const SSL *s) { return (long int)ossl_time2seconds(s->method->get_timeout()); } static int ssl_async_wait_ctx_cb(void *arg) { SSL *s = (SSL *)arg; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return sc->async_cb(s, sc->async_cb_arg); } static int ssl_start_async_job(SSL *s, struct ssl_async_args *args, int (*func) (void *)) { int ret; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->waitctx == NULL) { sc->waitctx = ASYNC_WAIT_CTX_new(); if (sc->waitctx == NULL) return -1; if (sc->async_cb != NULL && !ASYNC_WAIT_CTX_set_callback (sc->waitctx, ssl_async_wait_ctx_cb, s)) return -1; } sc->rwstate = SSL_NOTHING; switch (ASYNC_start_job(&sc->job, sc->waitctx, &ret, func, args, sizeof(struct ssl_async_args))) { case ASYNC_ERR: sc->rwstate = SSL_NOTHING; ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_INIT_ASYNC); return -1; case ASYNC_PAUSE: sc->rwstate = SSL_ASYNC_PAUSED; return -1; case ASYNC_NO_JOBS: sc->rwstate = SSL_ASYNC_NO_JOBS; return -1; case ASYNC_FINISH: sc->job = NULL; return ret; default: sc->rwstate = SSL_NOTHING; ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); /* Shouldn't happen */ return -1; } } static int ssl_io_intern(void *vargs) { struct ssl_async_args *args; SSL *s; void *buf; size_t num; SSL_CONNECTION *sc; args = (struct ssl_async_args *)vargs; s = args->s; buf = args->buf; num = args->num; if ((sc = SSL_CONNECTION_FROM_SSL(s)) == NULL) return -1; switch (args->type) { case READFUNC: return args->f.func_read(s, buf, num, &sc->asyncrw); case WRITEFUNC: return args->f.func_write(s, buf, num, &sc->asyncrw); case OTHERFUNC: return args->f.func_other(s); } return -1; } int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_read(s, buf, num, readbytes); #endif if (sc == NULL) return -1; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) { sc->rwstate = SSL_NOTHING; return 0; } if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } /* * If we are a client and haven't received the ServerHello etc then we * better do that */ ossl_statem_check_finish_init(sc, 0); if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { struct ssl_async_args args; int ret; args.s = s; args.buf = buf; args.num = num; args.type = READFUNC; args.f.func_read = s->method->ssl_read; ret = ssl_start_async_job(s, &args, ssl_io_intern); *readbytes = sc->asyncrw; return ret; } else { return s->method->ssl_read(s, buf, num, readbytes); } } int SSL_read(SSL *s, void *buf, int num) { int ret; size_t readbytes; if (num < 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); return -1; } ret = ssl_read_internal(s, buf, (size_t)num, &readbytes); /* * The cast is safe here because ret should be <= INT_MAX because num is * <= INT_MAX */ if (ret > 0) ret = (int)readbytes; return ret; } int SSL_read_ex(SSL *s, void *buf, size_t num, size_t *readbytes) { int ret = ssl_read_internal(s, buf, num, readbytes); if (ret < 0) ret = 0; return ret; } int SSL_read_early_data(SSL *s, void *buf, size_t num, size_t *readbytes) { int ret; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); /* TODO(QUIC 0RTT): 0-RTT support */ if (sc == NULL || !sc->server) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return SSL_READ_EARLY_DATA_ERROR; } switch (sc->early_data_state) { case SSL_EARLY_DATA_NONE: if (!SSL_in_before(s)) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return SSL_READ_EARLY_DATA_ERROR; } /* fall through */ case SSL_EARLY_DATA_ACCEPT_RETRY: sc->early_data_state = SSL_EARLY_DATA_ACCEPTING; ret = SSL_accept(s); if (ret <= 0) { /* NBIO or error */ sc->early_data_state = SSL_EARLY_DATA_ACCEPT_RETRY; return SSL_READ_EARLY_DATA_ERROR; } /* fall through */ case SSL_EARLY_DATA_READ_RETRY: if (sc->ext.early_data == SSL_EARLY_DATA_ACCEPTED) { sc->early_data_state = SSL_EARLY_DATA_READING; ret = SSL_read_ex(s, buf, num, readbytes); /* * State machine will update early_data_state to * SSL_EARLY_DATA_FINISHED_READING if we get an EndOfEarlyData * message */ if (ret > 0 || (ret <= 0 && sc->early_data_state != SSL_EARLY_DATA_FINISHED_READING)) { sc->early_data_state = SSL_EARLY_DATA_READ_RETRY; return ret > 0 ? SSL_READ_EARLY_DATA_SUCCESS : SSL_READ_EARLY_DATA_ERROR; } } else { sc->early_data_state = SSL_EARLY_DATA_FINISHED_READING; } *readbytes = 0; return SSL_READ_EARLY_DATA_FINISH; default: ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return SSL_READ_EARLY_DATA_ERROR; } } int SSL_get_early_data_status(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); /* TODO(QUIC 0RTT): 0-RTT support */ if (sc == NULL) return 0; return sc->ext.early_data; } static int ssl_peek_internal(SSL *s, void *buf, size_t num, size_t *readbytes) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_peek(s, buf, num, readbytes); #endif if (sc == NULL) return 0; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) { return 0; } if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { struct ssl_async_args args; int ret; args.s = s; args.buf = buf; args.num = num; args.type = READFUNC; args.f.func_read = s->method->ssl_peek; ret = ssl_start_async_job(s, &args, ssl_io_intern); *readbytes = sc->asyncrw; return ret; } else { return s->method->ssl_peek(s, buf, num, readbytes); } } int SSL_peek(SSL *s, void *buf, int num) { int ret; size_t readbytes; if (num < 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); return -1; } ret = ssl_peek_internal(s, buf, (size_t)num, &readbytes); /* * The cast is safe here because ret should be <= INT_MAX because num is * <= INT_MAX */ if (ret > 0) ret = (int)readbytes; return ret; } int SSL_peek_ex(SSL *s, void *buf, size_t num, size_t *readbytes) { int ret = ssl_peek_internal(s, buf, num, readbytes); if (ret < 0) ret = 0; return ret; } int ssl_write_internal(SSL *s, const void *buf, size_t num, size_t *written) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return s->method->ssl_write(s, buf, num, written); #endif if (sc == NULL) return 0; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (sc->shutdown & SSL_SENT_SHUTDOWN) { sc->rwstate = SSL_NOTHING; ERR_raise(ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN); return -1; } if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY || sc->early_data_state == SSL_EARLY_DATA_READ_RETRY) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } /* If we are a client and haven't sent the Finished we better do that */ ossl_statem_check_finish_init(sc, 1); if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { int ret; struct ssl_async_args args; args.s = s; args.buf = (void *)buf; args.num = num; args.type = WRITEFUNC; args.f.func_write = s->method->ssl_write; ret = ssl_start_async_job(s, &args, ssl_io_intern); *written = sc->asyncrw; return ret; } else { return s->method->ssl_write(s, buf, num, written); } } ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size, int flags) { ossl_ssize_t ret; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (sc->shutdown & SSL_SENT_SHUTDOWN) { sc->rwstate = SSL_NOTHING; ERR_raise(ERR_LIB_SSL, SSL_R_PROTOCOL_IS_SHUTDOWN); return -1; } if (!BIO_get_ktls_send(sc->wbio)) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } /* If we have an alert to send, lets send it */ if (sc->s3.alert_dispatch > 0) { ret = (ossl_ssize_t)s->method->ssl_dispatch_alert(s); if (ret <= 0) { /* SSLfatal() already called if appropriate */ return ret; } /* if it went, fall through and send more stuff */ } sc->rwstate = SSL_WRITING; if (BIO_flush(sc->wbio) <= 0) { if (!BIO_should_retry(sc->wbio)) { sc->rwstate = SSL_NOTHING; } else { #ifdef EAGAIN set_sys_error(EAGAIN); #endif } return -1; } #ifdef OPENSSL_NO_KTLS ERR_raise_data(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR, "can't call ktls_sendfile(), ktls disabled"); return -1; #else ret = ktls_sendfile(SSL_get_wfd(s), fd, offset, size, flags); if (ret < 0) { #if defined(EAGAIN) && defined(EINTR) && defined(EBUSY) if ((get_last_sys_error() == EAGAIN) || (get_last_sys_error() == EINTR) || (get_last_sys_error() == EBUSY)) BIO_set_retry_write(sc->wbio); else #endif ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return ret; } sc->rwstate = SSL_NOTHING; return ret; #endif } int SSL_write(SSL *s, const void *buf, int num) { int ret; size_t written; if (num < 0) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); return -1; } ret = ssl_write_internal(s, buf, (size_t)num, &written); /* * The cast is safe here because ret should be <= INT_MAX because num is * <= INT_MAX */ if (ret > 0) ret = (int)written; return ret; } int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written) { int ret = ssl_write_internal(s, buf, num, written); if (ret < 0) ret = 0; return ret; } int SSL_write_early_data(SSL *s, const void *buf, size_t num, size_t *written) { int ret, early_data_state; size_t writtmp; uint32_t partialwrite; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); /* TODO(QUIC 0RTT): This will need special handling for QUIC */ if (sc == NULL) return 0; switch (sc->early_data_state) { case SSL_EARLY_DATA_NONE: if (sc->server || !SSL_in_before(s) || ((sc->session == NULL || sc->session->ext.max_early_data == 0) && (sc->psk_use_session_cb == NULL))) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } /* fall through */ case SSL_EARLY_DATA_CONNECT_RETRY: sc->early_data_state = SSL_EARLY_DATA_CONNECTING; ret = SSL_connect(s); if (ret <= 0) { /* NBIO or error */ sc->early_data_state = SSL_EARLY_DATA_CONNECT_RETRY; return 0; } /* fall through */ case SSL_EARLY_DATA_WRITE_RETRY: sc->early_data_state = SSL_EARLY_DATA_WRITING; /* * We disable partial write for early data because we don't keep track * of how many bytes we've written between the SSL_write_ex() call and * the flush if the flush needs to be retried) */ partialwrite = sc->mode & SSL_MODE_ENABLE_PARTIAL_WRITE; sc->mode &= ~SSL_MODE_ENABLE_PARTIAL_WRITE; ret = SSL_write_ex(s, buf, num, &writtmp); sc->mode |= partialwrite; if (!ret) { sc->early_data_state = SSL_EARLY_DATA_WRITE_RETRY; return ret; } sc->early_data_state = SSL_EARLY_DATA_WRITE_FLUSH; /* fall through */ case SSL_EARLY_DATA_WRITE_FLUSH: /* The buffering BIO is still in place so we need to flush it */ if (statem_flush(sc) != 1) return 0; *written = num; sc->early_data_state = SSL_EARLY_DATA_WRITE_RETRY; return 1; case SSL_EARLY_DATA_FINISHED_READING: case SSL_EARLY_DATA_READ_RETRY: early_data_state = sc->early_data_state; /* We are a server writing to an unauthenticated client */ sc->early_data_state = SSL_EARLY_DATA_UNAUTH_WRITING; ret = SSL_write_ex(s, buf, num, written); /* The buffering BIO is still in place */ if (ret) (void)BIO_flush(sc->wbio); sc->early_data_state = early_data_state; return ret; default: ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } } int SSL_shutdown(SSL *s) { /* * Note that this function behaves differently from what one might * expect. Return values are 0 for no success (yet), 1 for success; but * calling it once is usually not enough, even if blocking I/O is used * (see ssl3_shutdown). */ SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_conn_shutdown(s, 0, NULL, 0); #endif if (sc == NULL) return -1; if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_UNINITIALIZED); return -1; } if (!SSL_in_init(s)) { if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { struct ssl_async_args args; memset(&args, 0, sizeof(args)); args.s = s; args.type = OTHERFUNC; args.f.func_other = s->method->ssl_shutdown; return ssl_start_async_job(s, &args, ssl_io_intern); } else { return s->method->ssl_shutdown(s); } } else { ERR_raise(ERR_LIB_SSL, SSL_R_SHUTDOWN_WHILE_IN_INIT); return -1; } } int SSL_key_update(SSL *s, int updatetype) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_key_update(s, updatetype); #endif if (sc == NULL) return 0; if (!SSL_CONNECTION_IS_TLS13(sc)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED && updatetype != SSL_KEY_UPDATE_REQUESTED) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_KEY_UPDATE_TYPE); return 0; } if (!SSL_is_init_finished(s)) { ERR_raise(ERR_LIB_SSL, SSL_R_STILL_IN_INIT); return 0; } if (RECORD_LAYER_write_pending(&sc->rlayer)) { ERR_raise(ERR_LIB_SSL, SSL_R_BAD_WRITE_RETRY); return 0; } ossl_statem_set_in_init(sc, 1); sc->key_update = updatetype; return 1; } int SSL_get_key_update_type(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_key_update_type(s); #endif if (sc == NULL) return 0; return sc->key_update; } /* * Can we accept a renegotiation request? If yes, set the flag and * return 1 if yes. If not, raise error and return 0. */ static int can_renegotiate(const SSL_CONNECTION *sc) { if (SSL_CONNECTION_IS_TLS13(sc)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } if ((sc->options & SSL_OP_NO_RENEGOTIATION) != 0) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_RENEGOTIATION); return 0; } return 1; } int SSL_renegotiate(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (!can_renegotiate(sc)) return 0; sc->renegotiate = 1; sc->new_session = 1; return s->method->ssl_renegotiate(s); } int SSL_renegotiate_abbreviated(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (!can_renegotiate(sc)) return 0; sc->renegotiate = 1; sc->new_session = 0; return s->method->ssl_renegotiate(s); } int SSL_renegotiate_pending(const SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; /* * becomes true when negotiation is requested; false again once a * handshake has finished */ return (sc->renegotiate != 0); } int SSL_new_session_ticket(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* If we are in init because we're sending tickets, okay to send more. */ if ((SSL_in_init(s) && sc->ext.extra_tickets_expected == 0) || SSL_IS_FIRST_HANDSHAKE(sc) || !sc->server || !SSL_CONNECTION_IS_TLS13(sc)) return 0; sc->ext.extra_tickets_expected++; if (!RECORD_LAYER_write_pending(&sc->rlayer) && !SSL_in_init(s)) ossl_statem_set_in_init(sc, 1); return 1; } long SSL_ctrl(SSL *s, int cmd, long larg, void *parg) { return ossl_ctrl_internal(s, cmd, larg, parg, /*no_quic=*/0); } long ossl_ctrl_internal(SSL *s, int cmd, long larg, void *parg, int no_quic) { long l; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* * Routing of ctrl calls for QUIC is a little counterintuitive: * * - Firstly (no_quic=0), we pass the ctrl directly to our QUIC * implementation in case it wants to handle the ctrl specially. * * - If our QUIC implementation does not care about the ctrl, it * will reenter this function with no_quic=1 and we will try to handle * it directly using the QCSO SSL object stub (not the handshake layer * SSL object). This is important for e.g. the version configuration * ctrls below, which must use s->defltmeth (and not sc->defltmeth). * * - If we don't handle a ctrl here specially, then processing is * redirected to the handshake layer SSL object. */ if (!no_quic && IS_QUIC(s)) return s->method->ssl_ctrl(s, cmd, larg, parg); switch (cmd) { case SSL_CTRL_GET_READ_AHEAD: return RECORD_LAYER_get_read_ahead(&sc->rlayer); case SSL_CTRL_SET_READ_AHEAD: l = RECORD_LAYER_get_read_ahead(&sc->rlayer); RECORD_LAYER_set_read_ahead(&sc->rlayer, larg); return l; case SSL_CTRL_MODE: { OSSL_PARAM options[2], *opts = options; sc->mode |= larg; *opts++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE, &sc->mode); *opts = OSSL_PARAM_construct_end(); /* Ignore return value */ sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options); return sc->mode; } case SSL_CTRL_CLEAR_MODE: return (sc->mode &= ~larg); case SSL_CTRL_GET_MAX_CERT_LIST: return (long)sc->max_cert_list; case SSL_CTRL_SET_MAX_CERT_LIST: if (larg < 0) return 0; l = (long)sc->max_cert_list; sc->max_cert_list = (size_t)larg; return l; case SSL_CTRL_SET_MAX_SEND_FRAGMENT: if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH) return 0; #ifndef OPENSSL_NO_KTLS if (sc->wbio != NULL && BIO_get_ktls_send(sc->wbio)) return 0; #endif /* OPENSSL_NO_KTLS */ sc->max_send_fragment = larg; if (sc->max_send_fragment < sc->split_send_fragment) sc->split_send_fragment = sc->max_send_fragment; sc->rlayer.wrlmethod->set_max_frag_len(sc->rlayer.wrl, larg); return 1; case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT: if ((size_t)larg > sc->max_send_fragment || larg == 0) return 0; sc->split_send_fragment = larg; return 1; case SSL_CTRL_SET_MAX_PIPELINES: if (larg < 1 || larg > SSL_MAX_PIPELINES) return 0; sc->max_pipelines = larg; if (sc->rlayer.rrlmethod->set_max_pipelines != NULL) sc->rlayer.rrlmethod->set_max_pipelines(sc->rlayer.rrl, (size_t)larg); return 1; case SSL_CTRL_GET_RI_SUPPORT: return sc->s3.send_connection_binding; case SSL_CTRL_SET_RETRY_VERIFY: sc->rwstate = SSL_RETRY_VERIFY; return 1; case SSL_CTRL_CERT_FLAGS: return (sc->cert->cert_flags |= larg); case SSL_CTRL_CLEAR_CERT_FLAGS: return (sc->cert->cert_flags &= ~larg); case SSL_CTRL_GET_RAW_CIPHERLIST: if (parg) { if (sc->s3.tmp.ciphers_raw == NULL) return 0; *(unsigned char **)parg = sc->s3.tmp.ciphers_raw; return (int)sc->s3.tmp.ciphers_rawlen; } else { return TLS_CIPHER_LEN; } case SSL_CTRL_GET_EXTMS_SUPPORT: if (!sc->session || SSL_in_init(s) || ossl_statem_get_in_handshake(sc)) return -1; if (sc->session->flags & SSL_SESS_FLAG_EXTMS) return 1; else return 0; case SSL_CTRL_SET_MIN_PROTO_VERSION: return ssl_check_allowed_versions(larg, sc->max_proto_version) && ssl_set_version_bound(s->defltmeth->version, (int)larg, &sc->min_proto_version); case SSL_CTRL_GET_MIN_PROTO_VERSION: return sc->min_proto_version; case SSL_CTRL_SET_MAX_PROTO_VERSION: return ssl_check_allowed_versions(sc->min_proto_version, larg) && ssl_set_version_bound(s->defltmeth->version, (int)larg, &sc->max_proto_version); case SSL_CTRL_GET_MAX_PROTO_VERSION: return sc->max_proto_version; default: if (IS_QUIC(s)) return SSL_ctrl((SSL *)sc, cmd, larg, parg); else return s->method->ssl_ctrl(s, cmd, larg, parg); } } long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void)) { return s->method->ssl_callback_ctrl(s, cmd, fp); } LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx) { return ctx->sessions; } static int ssl_tsan_load(SSL_CTX *ctx, TSAN_QUALIFIER int *stat) { int res = 0; if (ssl_tsan_lock(ctx)) { res = tsan_load(stat); ssl_tsan_unlock(ctx); } return res; } long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg) { long l; /* For some cases with ctx == NULL perform syntax checks */ if (ctx == NULL) { switch (cmd) { case SSL_CTRL_SET_GROUPS_LIST: return tls1_set_groups_list(ctx, NULL, NULL, parg); case SSL_CTRL_SET_SIGALGS_LIST: case SSL_CTRL_SET_CLIENT_SIGALGS_LIST: return tls1_set_sigalgs_list(NULL, parg, 0); default: return 0; } } switch (cmd) { case SSL_CTRL_GET_READ_AHEAD: return ctx->read_ahead; case SSL_CTRL_SET_READ_AHEAD: l = ctx->read_ahead; ctx->read_ahead = larg; return l; case SSL_CTRL_SET_MSG_CALLBACK_ARG: ctx->msg_callback_arg = parg; return 1; case SSL_CTRL_GET_MAX_CERT_LIST: return (long)ctx->max_cert_list; case SSL_CTRL_SET_MAX_CERT_LIST: if (larg < 0) return 0; l = (long)ctx->max_cert_list; ctx->max_cert_list = (size_t)larg; return l; case SSL_CTRL_SET_SESS_CACHE_SIZE: if (larg < 0) return 0; l = (long)ctx->session_cache_size; ctx->session_cache_size = (size_t)larg; return l; case SSL_CTRL_GET_SESS_CACHE_SIZE: return (long)ctx->session_cache_size; case SSL_CTRL_SET_SESS_CACHE_MODE: l = ctx->session_cache_mode; ctx->session_cache_mode = larg; return l; case SSL_CTRL_GET_SESS_CACHE_MODE: return ctx->session_cache_mode; case SSL_CTRL_SESS_NUMBER: return lh_SSL_SESSION_num_items(ctx->sessions); case SSL_CTRL_SESS_CONNECT: return ssl_tsan_load(ctx, &ctx->stats.sess_connect); case SSL_CTRL_SESS_CONNECT_GOOD: return ssl_tsan_load(ctx, &ctx->stats.sess_connect_good); case SSL_CTRL_SESS_CONNECT_RENEGOTIATE: return ssl_tsan_load(ctx, &ctx->stats.sess_connect_renegotiate); case SSL_CTRL_SESS_ACCEPT: return ssl_tsan_load(ctx, &ctx->stats.sess_accept); case SSL_CTRL_SESS_ACCEPT_GOOD: return ssl_tsan_load(ctx, &ctx->stats.sess_accept_good); case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE: return ssl_tsan_load(ctx, &ctx->stats.sess_accept_renegotiate); case SSL_CTRL_SESS_HIT: return ssl_tsan_load(ctx, &ctx->stats.sess_hit); case SSL_CTRL_SESS_CB_HIT: return ssl_tsan_load(ctx, &ctx->stats.sess_cb_hit); case SSL_CTRL_SESS_MISSES: return ssl_tsan_load(ctx, &ctx->stats.sess_miss); case SSL_CTRL_SESS_TIMEOUTS: return ssl_tsan_load(ctx, &ctx->stats.sess_timeout); case SSL_CTRL_SESS_CACHE_FULL: return ssl_tsan_load(ctx, &ctx->stats.sess_cache_full); case SSL_CTRL_MODE: return (ctx->mode |= larg); case SSL_CTRL_CLEAR_MODE: return (ctx->mode &= ~larg); case SSL_CTRL_SET_MAX_SEND_FRAGMENT: if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH) return 0; ctx->max_send_fragment = larg; if (ctx->max_send_fragment < ctx->split_send_fragment) ctx->split_send_fragment = ctx->max_send_fragment; return 1; case SSL_CTRL_SET_SPLIT_SEND_FRAGMENT: if ((size_t)larg > ctx->max_send_fragment || larg == 0) return 0; ctx->split_send_fragment = larg; return 1; case SSL_CTRL_SET_MAX_PIPELINES: if (larg < 1 || larg > SSL_MAX_PIPELINES) return 0; ctx->max_pipelines = larg; return 1; case SSL_CTRL_CERT_FLAGS: return (ctx->cert->cert_flags |= larg); case SSL_CTRL_CLEAR_CERT_FLAGS: return (ctx->cert->cert_flags &= ~larg); case SSL_CTRL_SET_MIN_PROTO_VERSION: return ssl_check_allowed_versions(larg, ctx->max_proto_version) && ssl_set_version_bound(ctx->method->version, (int)larg, &ctx->min_proto_version); case SSL_CTRL_GET_MIN_PROTO_VERSION: return ctx->min_proto_version; case SSL_CTRL_SET_MAX_PROTO_VERSION: return ssl_check_allowed_versions(ctx->min_proto_version, larg) && ssl_set_version_bound(ctx->method->version, (int)larg, &ctx->max_proto_version); case SSL_CTRL_GET_MAX_PROTO_VERSION: return ctx->max_proto_version; default: return ctx->method->ssl_ctx_ctrl(ctx, cmd, larg, parg); } } long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void)) { switch (cmd) { case SSL_CTRL_SET_MSG_CALLBACK: ctx->msg_callback = (void (*) (int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp); return 1; default: return ctx->method->ssl_ctx_callback_ctrl(ctx, cmd, fp); } } int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b) { if (a->id > b->id) return 1; if (a->id < b->id) return -1; return 0; } int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap, const SSL_CIPHER *const *bp) { if ((*ap)->id > (*bp)->id) return 1; if ((*ap)->id < (*bp)->id) return -1; return 0; } /* * return a STACK of the ciphers available for the SSL and in order of * preference */ STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc != NULL) { if (sc->cipher_list != NULL) { return sc->cipher_list; } else if ((s->ctx != NULL) && (s->ctx->cipher_list != NULL)) { return s->ctx->cipher_list; } } return NULL; } STACK_OF(SSL_CIPHER) *SSL_get_client_ciphers(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL || !sc->server) return NULL; return sc->peer_ciphers; } STACK_OF(SSL_CIPHER) *SSL_get1_supported_ciphers(SSL *s) { STACK_OF(SSL_CIPHER) *sk = NULL, *ciphers; int i; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; ciphers = SSL_get_ciphers(s); if (!ciphers) return NULL; if (!ssl_set_client_disabled(sc)) return NULL; for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) { const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i); if (!ssl_cipher_disabled(sc, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) { if (!sk) sk = sk_SSL_CIPHER_new_null(); if (!sk) return NULL; if (!sk_SSL_CIPHER_push(sk, c)) { sk_SSL_CIPHER_free(sk); return NULL; } } } return sk; } /** return a STACK of the ciphers available for the SSL and in order of * algorithm id */ STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL_CONNECTION *s) { if (s != NULL) { if (s->cipher_list_by_id != NULL) return s->cipher_list_by_id; else if (s->ssl.ctx != NULL && s->ssl.ctx->cipher_list_by_id != NULL) return s->ssl.ctx->cipher_list_by_id; } return NULL; } /** The old interface to get the same thing as SSL_get_ciphers() */ const char *SSL_get_cipher_list(const SSL *s, int n) { const SSL_CIPHER *c; STACK_OF(SSL_CIPHER) *sk; if (s == NULL) return NULL; sk = SSL_get_ciphers(s); if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n)) return NULL; c = sk_SSL_CIPHER_value(sk, n); if (c == NULL) return NULL; return c->name; } /** return a STACK of the ciphers available for the SSL_CTX and in order of * preference */ STACK_OF(SSL_CIPHER) *SSL_CTX_get_ciphers(const SSL_CTX *ctx) { if (ctx != NULL) return ctx->cipher_list; return NULL; } /* * Distinguish between ciphers controlled by set_ciphersuite() and * set_cipher_list() when counting. */ static int cipher_list_tls12_num(STACK_OF(SSL_CIPHER) *sk) { int i, num = 0; const SSL_CIPHER *c; if (sk == NULL) return 0; for (i = 0; i < sk_SSL_CIPHER_num(sk); ++i) { c = sk_SSL_CIPHER_value(sk, i); if (c->min_tls >= TLS1_3_VERSION) continue; num++; } return num; } /** specify the ciphers to be used by default by the SSL_CTX */ int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str) { STACK_OF(SSL_CIPHER) *sk; sk = ssl_create_cipher_list(ctx, ctx->tls13_ciphersuites, &ctx->cipher_list, &ctx->cipher_list_by_id, str, ctx->cert); /* * ssl_create_cipher_list may return an empty stack if it was unable to * find a cipher matching the given rule string (for example if the rule * string specifies a cipher which has been disabled). This is not an * error as far as ssl_create_cipher_list is concerned, and hence * ctx->cipher_list and ctx->cipher_list_by_id has been updated. */ if (sk == NULL) return 0; else if (cipher_list_tls12_num(sk) == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH); return 0; } return 1; } /** specify the ciphers to be used by the SSL */ int SSL_set_cipher_list(SSL *s, const char *str) { STACK_OF(SSL_CIPHER) *sk; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sk = ssl_create_cipher_list(s->ctx, sc->tls13_ciphersuites, &sc->cipher_list, &sc->cipher_list_by_id, str, sc->cert); /* see comment in SSL_CTX_set_cipher_list */ if (sk == NULL) return 0; else if (cipher_list_tls12_num(sk) == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH); return 0; } return 1; } char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size) { char *p; STACK_OF(SSL_CIPHER) *clntsk, *srvrsk; const SSL_CIPHER *c; int i; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (!sc->server || sc->peer_ciphers == NULL || size < 2) return NULL; p = buf; clntsk = sc->peer_ciphers; srvrsk = SSL_get_ciphers(s); if (clntsk == NULL || srvrsk == NULL) return NULL; if (sk_SSL_CIPHER_num(clntsk) == 0 || sk_SSL_CIPHER_num(srvrsk) == 0) return NULL; for (i = 0; i < sk_SSL_CIPHER_num(clntsk); i++) { int n; c = sk_SSL_CIPHER_value(clntsk, i); if (sk_SSL_CIPHER_find(srvrsk, c) < 0) continue; n = OPENSSL_strnlen(c->name, size); if (n >= size) { if (p != buf) --p; *p = '\0'; return buf; } memcpy(p, c->name, n); p += n; *(p++) = ':'; size -= n + 1; } p[-1] = '\0'; return buf; } /** * Return the requested servername (SNI) value. Note that the behaviour varies * depending on: * - whether this is called by the client or the server, * - if we are before or during/after the handshake, * - if a resumption or normal handshake is being attempted/has occurred * - whether we have negotiated TLSv1.2 (or below) or TLSv1.3 * * Note that only the host_name type is defined (RFC 3546). */ const char *SSL_get_servername(const SSL *s, const int type) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); int server; if (sc == NULL) return NULL; /* * If we don't know if we are the client or the server yet then we assume * client. */ server = sc->handshake_func == NULL ? 0 : sc->server; if (type != TLSEXT_NAMETYPE_host_name) return NULL; if (server) { /** * Server side * In TLSv1.3 on the server SNI is not associated with the session * but in TLSv1.2 or below it is. * * Before the handshake: * - return NULL * * During/after the handshake (TLSv1.2 or below resumption occurred): * - If a servername was accepted by the server in the original * handshake then it will return that servername, or NULL otherwise. * * During/after the handshake (TLSv1.2 or below resumption did not occur): * - The function will return the servername requested by the client in * this handshake or NULL if none was requested. */ if (sc->hit && !SSL_CONNECTION_IS_TLS13(sc)) return sc->session->ext.hostname; } else { /** * Client side * * Before the handshake: * - If a servername has been set via a call to * SSL_set_tlsext_host_name() then it will return that servername * - If one has not been set, but a TLSv1.2 resumption is being * attempted and the session from the original handshake had a * servername accepted by the server then it will return that * servername * - Otherwise it returns NULL * * During/after the handshake (TLSv1.2 or below resumption occurred): * - If the session from the original handshake had a servername accepted * by the server then it will return that servername. * - Otherwise it returns the servername set via * SSL_set_tlsext_host_name() (or NULL if it was not called). * * During/after the handshake (TLSv1.2 or below resumption did not occur): * - It will return the servername set via SSL_set_tlsext_host_name() * (or NULL if it was not called). */ if (SSL_in_before(s)) { if (sc->ext.hostname == NULL && sc->session != NULL && sc->session->ssl_version != TLS1_3_VERSION) return sc->session->ext.hostname; } else { if (!SSL_CONNECTION_IS_TLS13(sc) && sc->hit && sc->session->ext.hostname != NULL) return sc->session->ext.hostname; } } return sc->ext.hostname; } int SSL_get_servername_type(const SSL *s) { if (SSL_get_servername(s, TLSEXT_NAMETYPE_host_name) != NULL) return TLSEXT_NAMETYPE_host_name; return -1; } /* * SSL_select_next_proto implements the standard protocol selection. It is * expected that this function is called from the callback set by * SSL_CTX_set_next_proto_select_cb. The protocol data is assumed to be a * vector of 8-bit, length prefixed byte strings. The length byte itself is * not included in the length. A byte string of length 0 is invalid. No byte * string may be truncated. The current, but experimental algorithm for * selecting the protocol is: 1) If the server doesn't support NPN then this * is indicated to the callback. In this case, the client application has to * abort the connection or have a default application level protocol. 2) If * the server supports NPN, but advertises an empty list then the client * selects the first protocol in its list, but indicates via the API that this * fallback case was enacted. 3) Otherwise, the client finds the first * protocol in the server's list that it supports and selects this protocol. * This is because it's assumed that the server has better information about * which protocol a client should use. 4) If the client doesn't support any * of the server's advertised protocols, then this is treated the same as * case 2. It returns either OPENSSL_NPN_NEGOTIATED if a common protocol was * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached. */ int SSL_select_next_proto(unsigned char **out, unsigned char *outlen, const unsigned char *server, unsigned int server_len, const unsigned char *client, unsigned int client_len) { unsigned int i, j; const unsigned char *result; int status = OPENSSL_NPN_UNSUPPORTED; /* * For each protocol in server preference order, see if we support it. */ for (i = 0; i < server_len;) { for (j = 0; j < client_len;) { if (server[i] == client[j] && memcmp(&server[i + 1], &client[j + 1], server[i]) == 0) { /* We found a match */ result = &server[i]; status = OPENSSL_NPN_NEGOTIATED; goto found; } j += client[j]; j++; } i += server[i]; i++; } /* There's no overlap between our protocols and the server's list. */ result = client; status = OPENSSL_NPN_NO_OVERLAP; found: *out = (unsigned char *)result + 1; *outlen = result[0]; return status; } #ifndef OPENSSL_NO_NEXTPROTONEG /* * SSL_get0_next_proto_negotiated sets *data and *len to point to the * client's requested protocol for this connection and returns 0. If the * client didn't request any protocol, then *data is set to NULL. Note that * the client can request any protocol it chooses. The value returned from * this function need not be a member of the list of supported protocols * provided by the callback. */ void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data, unsigned *len) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) { /* We have no other way to indicate error */ *data = NULL; *len = 0; return; } *data = sc->ext.npn; if (*data == NULL) { *len = 0; } else { *len = (unsigned int)sc->ext.npn_len; } } /* * SSL_CTX_set_npn_advertised_cb sets a callback that is called when * a TLS server needs a list of supported protocols for Next Protocol * Negotiation. The returned list must be in wire format. The list is * returned by setting |out| to point to it and |outlen| to its length. This * memory will not be modified, but one should assume that the SSL* keeps a * reference to it. The callback should return SSL_TLSEXT_ERR_OK if it * wishes to advertise. Otherwise, no such extension will be included in the * ServerHello. */ void SSL_CTX_set_npn_advertised_cb(SSL_CTX *ctx, SSL_CTX_npn_advertised_cb_func cb, void *arg) { if (IS_QUIC_CTX(ctx)) /* NPN not allowed for QUIC */ return; ctx->ext.npn_advertised_cb = cb; ctx->ext.npn_advertised_cb_arg = arg; } /* * SSL_CTX_set_next_proto_select_cb sets a callback that is called when a * client needs to select a protocol from the server's provided list. |out| * must be set to point to the selected protocol (which may be within |in|). * The length of the protocol name must be written into |outlen|. The * server's advertised protocols are provided in |in| and |inlen|. The * callback can assume that |in| is syntactically valid. The client must * select a protocol. It is fatal to the connection if this callback returns * a value other than SSL_TLSEXT_ERR_OK. */ void SSL_CTX_set_npn_select_cb(SSL_CTX *ctx, SSL_CTX_npn_select_cb_func cb, void *arg) { if (IS_QUIC_CTX(ctx)) /* NPN not allowed for QUIC */ return; ctx->ext.npn_select_cb = cb; ctx->ext.npn_select_cb_arg = arg; } #endif static int alpn_value_ok(const unsigned char *protos, unsigned int protos_len) { unsigned int idx; if (protos_len < 2 || protos == NULL) return 0; for (idx = 0; idx < protos_len; idx += protos[idx] + 1) { if (protos[idx] == 0) return 0; } return idx == protos_len; } /* * SSL_CTX_set_alpn_protos sets the ALPN protocol list on |ctx| to |protos|. * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit * length-prefixed strings). Returns 0 on success. */ int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos, unsigned int protos_len) { unsigned char *alpn; if (protos_len == 0 || protos == NULL) { OPENSSL_free(ctx->ext.alpn); ctx->ext.alpn = NULL; ctx->ext.alpn_len = 0; return 0; } /* Not valid per RFC */ if (!alpn_value_ok(protos, protos_len)) return 1; alpn = OPENSSL_memdup(protos, protos_len); if (alpn == NULL) return 1; OPENSSL_free(ctx->ext.alpn); ctx->ext.alpn = alpn; ctx->ext.alpn_len = protos_len; return 0; } /* * SSL_set_alpn_protos sets the ALPN protocol list on |ssl| to |protos|. * |protos| must be in wire-format (i.e. a series of non-empty, 8-bit * length-prefixed strings). Returns 0 on success. */ int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos, unsigned int protos_len) { unsigned char *alpn; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 1; if (protos_len == 0 || protos == NULL) { OPENSSL_free(sc->ext.alpn); sc->ext.alpn = NULL; sc->ext.alpn_len = 0; return 0; } /* Not valid per RFC */ if (!alpn_value_ok(protos, protos_len)) return 1; alpn = OPENSSL_memdup(protos, protos_len); if (alpn == NULL) return 1; OPENSSL_free(sc->ext.alpn); sc->ext.alpn = alpn; sc->ext.alpn_len = protos_len; return 0; } /* * SSL_CTX_set_alpn_select_cb sets a callback function on |ctx| that is * called during ClientHello processing in order to select an ALPN protocol * from the client's list of offered protocols. */ void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx, SSL_CTX_alpn_select_cb_func cb, void *arg) { ctx->ext.alpn_select_cb = cb; ctx->ext.alpn_select_cb_arg = arg; } /* * SSL_get0_alpn_selected gets the selected ALPN protocol (if any) from |ssl|. * On return it sets |*data| to point to |*len| bytes of protocol name * (not including the leading length-prefix byte). If the server didn't * respond with a negotiated protocol then |*len| will be zero. */ void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data, unsigned int *len) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) { /* We have no other way to indicate error */ *data = NULL; *len = 0; return; } *data = sc->s3.alpn_selected; if (*data == NULL) *len = 0; else *len = (unsigned int)sc->s3.alpn_selected_len; } int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen, const char *label, size_t llen, const unsigned char *context, size_t contextlen, int use_context) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; if (sc->session == NULL || (sc->version < TLS1_VERSION && sc->version != DTLS1_BAD_VER)) return -1; return s->method->ssl3_enc->export_keying_material(sc, out, olen, label, llen, context, contextlen, use_context); } int SSL_export_keying_material_early(SSL *s, unsigned char *out, size_t olen, const char *label, size_t llen, const unsigned char *context, size_t contextlen) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; if (sc->version != TLS1_3_VERSION) return 0; return tls13_export_keying_material_early(sc, out, olen, label, llen, context, contextlen); } static unsigned long ssl_session_hash(const SSL_SESSION *a) { const unsigned char *session_id = a->session_id; unsigned long l; unsigned char tmp_storage[4]; if (a->session_id_length < sizeof(tmp_storage)) { memset(tmp_storage, 0, sizeof(tmp_storage)); memcpy(tmp_storage, a->session_id, a->session_id_length); session_id = tmp_storage; } l = (unsigned long) ((unsigned long)session_id[0]) | ((unsigned long)session_id[1] << 8L) | ((unsigned long)session_id[2] << 16L) | ((unsigned long)session_id[3] << 24L); return l; } /* * NB: If this function (or indeed the hash function which uses a sort of * coarser function than this one) is changed, ensure * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on * being able to construct an SSL_SESSION that will collide with any existing * session with a matching session ID. */ static int ssl_session_cmp(const SSL_SESSION *a, const SSL_SESSION *b) { if (a->ssl_version != b->ssl_version) return 1; if (a->session_id_length != b->session_id_length) return 1; return memcmp(a->session_id, b->session_id, a->session_id_length); } /* * These wrapper functions should remain rather than redeclaring * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each * variable. The reason is that the functions aren't static, they're exposed * via ssl.h. */ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq, const SSL_METHOD *meth) { SSL_CTX *ret = NULL; #ifndef OPENSSL_NO_COMP_ALG int i; #endif if (meth == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_NULL_SSL_METHOD_PASSED); return NULL; } if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL)) return NULL; /* Doing this for the run once effect */ if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0) { ERR_raise(ERR_LIB_SSL, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS); goto err; } ret = OPENSSL_zalloc(sizeof(*ret)); if (ret == NULL) return NULL; /* Init the reference counting before any call to SSL_CTX_free */ if (!CRYPTO_NEW_REF(&ret->references, 1)) { OPENSSL_free(ret); return NULL; } ret->lock = CRYPTO_THREAD_lock_new(); if (ret->lock == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } #ifdef TSAN_REQUIRES_LOCKING ret->tsan_lock = CRYPTO_THREAD_lock_new(); if (ret->tsan_lock == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } #endif ret->libctx = libctx; if (propq != NULL) { ret->propq = OPENSSL_strdup(propq); if (ret->propq == NULL) goto err; } ret->method = meth; ret->min_proto_version = 0; ret->max_proto_version = 0; ret->mode = SSL_MODE_AUTO_RETRY; ret->session_cache_mode = SSL_SESS_CACHE_SERVER; ret->session_cache_size = SSL_SESSION_CACHE_MAX_SIZE_DEFAULT; /* We take the system default. */ ret->session_timeout = meth->get_timeout(); ret->max_cert_list = SSL_MAX_CERT_LIST_DEFAULT; ret->verify_mode = SSL_VERIFY_NONE; ret->sessions = lh_SSL_SESSION_new(ssl_session_hash, ssl_session_cmp); if (ret->sessions == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } ret->cert_store = X509_STORE_new(); if (ret->cert_store == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } #ifndef OPENSSL_NO_CT ret->ctlog_store = CTLOG_STORE_new_ex(libctx, propq); if (ret->ctlog_store == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CT_LIB); goto err; } #endif /* initialize cipher/digest methods table */ if (!ssl_load_ciphers(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } if (!ssl_load_groups(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } /* load provider sigalgs */ if (!ssl_load_sigalgs(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } /* initialise sig algs */ if (!ssl_setup_sigalgs(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } if (!SSL_CTX_set_ciphersuites(ret, OSSL_default_ciphersuites())) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } if ((ret->cert = ssl_cert_new(SSL_PKEY_NUM + ret->sigalg_list_len)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } if (!ssl_create_cipher_list(ret, ret->tls13_ciphersuites, &ret->cipher_list, &ret->cipher_list_by_id, OSSL_default_cipher_list(), ret->cert) || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) { ERR_raise(ERR_LIB_SSL, SSL_R_LIBRARY_HAS_NO_CIPHERS); goto err; } ret->param = X509_VERIFY_PARAM_new(); if (ret->param == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_X509_LIB); goto err; } /* * If these aren't available from the provider we'll get NULL returns. * That's fine but will cause errors later if SSLv3 is negotiated */ ret->md5 = ssl_evp_md_fetch(libctx, NID_md5, propq); ret->sha1 = ssl_evp_md_fetch(libctx, NID_sha1, propq); if ((ret->ca_names = sk_X509_NAME_new_null()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if ((ret->client_ca_names = sk_X509_NAME_new_null()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } if ((ret->ext.secure = OPENSSL_secure_zalloc(sizeof(*ret->ext.secure))) == NULL) goto err; /* No compression for DTLS */ if (!(meth->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS)) ret->comp_methods = SSL_COMP_get_compression_methods(); ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH; ret->split_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH; /* Setup RFC5077 ticket keys */ if ((RAND_bytes_ex(libctx, ret->ext.tick_key_name, sizeof(ret->ext.tick_key_name), 0) <= 0) || (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_hmac_key, sizeof(ret->ext.secure->tick_hmac_key), 0) <= 0) || (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_aes_key, sizeof(ret->ext.secure->tick_aes_key), 0) <= 0)) ret->options |= SSL_OP_NO_TICKET; if (RAND_priv_bytes_ex(libctx, ret->ext.cookie_hmac_key, sizeof(ret->ext.cookie_hmac_key), 0) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_RAND_LIB); goto err; } #ifndef OPENSSL_NO_SRP if (!ssl_ctx_srp_ctx_init_intern(ret)) { ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); goto err; } #endif #ifndef OPENSSL_NO_ENGINE # ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO # define eng_strx(x) #x # define eng_str(x) eng_strx(x) /* Use specific client engine automatically... ignore errors */ { ENGINE *eng; eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO)); if (!eng) { ERR_clear_error(); ENGINE_load_builtin_engines(); eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO)); } if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng)) ERR_clear_error(); } # endif #endif #ifndef OPENSSL_NO_COMP_ALG /* * Set the default order: brotli, zlib, zstd * Including only those enabled algorithms */ memset(ret->cert_comp_prefs, 0, sizeof(ret->cert_comp_prefs)); i = 0; if (ossl_comp_has_alg(TLSEXT_comp_cert_brotli)) ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_brotli; if (ossl_comp_has_alg(TLSEXT_comp_cert_zlib)) ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_zlib; if (ossl_comp_has_alg(TLSEXT_comp_cert_zstd)) ret->cert_comp_prefs[i++] = TLSEXT_comp_cert_zstd; #endif /* * Disable compression by default to prevent CRIME. Applications can * re-enable compression by configuring * SSL_CTX_clear_options(ctx, SSL_OP_NO_COMPRESSION); * or by using the SSL_CONF library. Similarly we also enable TLSv1.3 * middlebox compatibility by default. This may be disabled by default in * a later OpenSSL version. */ ret->options |= SSL_OP_NO_COMPRESSION | SSL_OP_ENABLE_MIDDLEBOX_COMPAT; ret->ext.status_type = TLSEXT_STATUSTYPE_nothing; /* * We cannot usefully set a default max_early_data here (which gets * propagated in SSL_new(), for the following reason: setting the * SSL field causes tls_construct_stoc_early_data() to tell the * client that early data will be accepted when constructing a TLS 1.3 * session ticket, and the client will accordingly send us early data * when using that ticket (if the client has early data to send). * However, in order for the early data to actually be consumed by * the application, the application must also have calls to * SSL_read_early_data(); otherwise we'll just skip past the early data * and ignore it. So, since the application must add calls to * SSL_read_early_data(), we also require them to add * calls to SSL_CTX_set_max_early_data() in order to use early data, * eliminating the bandwidth-wasting early data in the case described * above. */ ret->max_early_data = 0; /* * Default recv_max_early_data is a fully loaded single record. Could be * split across multiple records in practice. We set this differently to * max_early_data so that, in the default case, we do not advertise any * support for early_data, but if a client were to send us some (e.g. * because of an old, stale ticket) then we will tolerate it and skip over * it. */ ret->recv_max_early_data = SSL3_RT_MAX_PLAIN_LENGTH; /* By default we send two session tickets automatically in TLSv1.3 */ ret->num_tickets = 2; ssl_ctx_system_config(ret); return ret; err: SSL_CTX_free(ret); return NULL; } SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth) { return SSL_CTX_new_ex(NULL, NULL, meth); } int SSL_CTX_up_ref(SSL_CTX *ctx) { int i; if (CRYPTO_UP_REF(&ctx->references, &i) <= 0) return 0; REF_PRINT_COUNT("SSL_CTX", ctx); REF_ASSERT_ISNT(i < 2); return ((i > 1) ? 1 : 0); } void SSL_CTX_free(SSL_CTX *a) { int i; size_t j; if (a == NULL) return; CRYPTO_DOWN_REF(&a->references, &i); REF_PRINT_COUNT("SSL_CTX", a); if (i > 0) return; REF_ASSERT_ISNT(i < 0); X509_VERIFY_PARAM_free(a->param); dane_ctx_final(&a->dane); /* * Free internal session cache. However: the remove_cb() may reference * the ex_data of SSL_CTX, thus the ex_data store can only be removed * after the sessions were flushed. * As the ex_data handling routines might also touch the session cache, * the most secure solution seems to be: empty (flush) the cache, then * free ex_data, then finally free the cache. * (See ticket [openssl.org #212].) */ if (a->sessions != NULL) SSL_CTX_flush_sessions(a, 0); CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data); lh_SSL_SESSION_free(a->sessions); X509_STORE_free(a->cert_store); #ifndef OPENSSL_NO_CT CTLOG_STORE_free(a->ctlog_store); #endif sk_SSL_CIPHER_free(a->cipher_list); sk_SSL_CIPHER_free(a->cipher_list_by_id); sk_SSL_CIPHER_free(a->tls13_ciphersuites); ssl_cert_free(a->cert); sk_X509_NAME_pop_free(a->ca_names, X509_NAME_free); sk_X509_NAME_pop_free(a->client_ca_names, X509_NAME_free); OSSL_STACK_OF_X509_free(a->extra_certs); a->comp_methods = NULL; #ifndef OPENSSL_NO_SRTP sk_SRTP_PROTECTION_PROFILE_free(a->srtp_profiles); #endif #ifndef OPENSSL_NO_SRP ssl_ctx_srp_ctx_free_intern(a); #endif #ifndef OPENSSL_NO_ENGINE tls_engine_finish(a->client_cert_engine); #endif OPENSSL_free(a->ext.ecpointformats); OPENSSL_free(a->ext.supportedgroups); OPENSSL_free(a->ext.supported_groups_default); OPENSSL_free(a->ext.alpn); OPENSSL_secure_free(a->ext.secure); ssl_evp_md_free(a->md5); ssl_evp_md_free(a->sha1); for (j = 0; j < SSL_ENC_NUM_IDX; j++) ssl_evp_cipher_free(a->ssl_cipher_methods[j]); for (j = 0; j < SSL_MD_NUM_IDX; j++) ssl_evp_md_free(a->ssl_digest_methods[j]); for (j = 0; j < a->group_list_len; j++) { OPENSSL_free(a->group_list[j].tlsname); OPENSSL_free(a->group_list[j].realname); OPENSSL_free(a->group_list[j].algorithm); } OPENSSL_free(a->group_list); for (j = 0; j < a->sigalg_list_len; j++) { OPENSSL_free(a->sigalg_list[j].name); OPENSSL_free(a->sigalg_list[j].sigalg_name); OPENSSL_free(a->sigalg_list[j].sigalg_oid); OPENSSL_free(a->sigalg_list[j].sig_name); OPENSSL_free(a->sigalg_list[j].sig_oid); OPENSSL_free(a->sigalg_list[j].hash_name); OPENSSL_free(a->sigalg_list[j].hash_oid); OPENSSL_free(a->sigalg_list[j].keytype); OPENSSL_free(a->sigalg_list[j].keytype_oid); } OPENSSL_free(a->sigalg_list); OPENSSL_free(a->ssl_cert_info); OPENSSL_free(a->sigalg_lookup_cache); OPENSSL_free(a->tls12_sigalgs); OPENSSL_free(a->client_cert_type); OPENSSL_free(a->server_cert_type); CRYPTO_THREAD_lock_free(a->lock); CRYPTO_FREE_REF(&a->references); #ifdef TSAN_REQUIRES_LOCKING CRYPTO_THREAD_lock_free(a->tsan_lock); #endif OPENSSL_free(a->propq); OPENSSL_free(a); } void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb) { ctx->default_passwd_callback = cb; } void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx, void *u) { ctx->default_passwd_callback_userdata = u; } pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx) { return ctx->default_passwd_callback; } void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx) { return ctx->default_passwd_callback_userdata; } void SSL_set_default_passwd_cb(SSL *s, pem_password_cb *cb) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->default_passwd_callback = cb; } void SSL_set_default_passwd_cb_userdata(SSL *s, void *u) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->default_passwd_callback_userdata = u; } pem_password_cb *SSL_get_default_passwd_cb(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return sc->default_passwd_callback; } void *SSL_get_default_passwd_cb_userdata(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return sc->default_passwd_callback_userdata; } void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, int (*cb) (X509_STORE_CTX *, void *), void *arg) { ctx->app_verify_callback = cb; ctx->app_verify_arg = arg; } void SSL_CTX_set_verify(SSL_CTX *ctx, int mode, int (*cb) (int, X509_STORE_CTX *)) { ctx->verify_mode = mode; ctx->default_verify_callback = cb; } void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth) { X509_VERIFY_PARAM_set_depth(ctx->param, depth); } void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg), void *arg) { ssl_cert_set_cert_cb(c->cert, cb, arg); } void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; ssl_cert_set_cert_cb(sc->cert, cb, arg); } void ssl_set_masks(SSL_CONNECTION *s) { CERT *c = s->cert; uint32_t *pvalid = s->s3.tmp.valid_flags; int rsa_enc, rsa_sign, dh_tmp, dsa_sign; unsigned long mask_k, mask_a; int have_ecc_cert, ecdsa_ok; if (c == NULL) return; dh_tmp = (c->dh_tmp != NULL || c->dh_tmp_cb != NULL || c->dh_tmp_auto); rsa_enc = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID; rsa_sign = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID; dsa_sign = pvalid[SSL_PKEY_DSA_SIGN] & CERT_PKEY_VALID; have_ecc_cert = pvalid[SSL_PKEY_ECC] & CERT_PKEY_VALID; mask_k = 0; mask_a = 0; OSSL_TRACE4(TLS_CIPHER, "dh_tmp=%d rsa_enc=%d rsa_sign=%d dsa_sign=%d\n", dh_tmp, rsa_enc, rsa_sign, dsa_sign); #ifndef OPENSSL_NO_GOST if (ssl_has_cert(s, SSL_PKEY_GOST12_512)) { mask_k |= SSL_kGOST | SSL_kGOST18; mask_a |= SSL_aGOST12; } if (ssl_has_cert(s, SSL_PKEY_GOST12_256)) { mask_k |= SSL_kGOST | SSL_kGOST18; mask_a |= SSL_aGOST12; } if (ssl_has_cert(s, SSL_PKEY_GOST01)) { mask_k |= SSL_kGOST; mask_a |= SSL_aGOST01; } #endif if (rsa_enc) mask_k |= SSL_kRSA; if (dh_tmp) mask_k |= SSL_kDHE; /* * If we only have an RSA-PSS certificate allow RSA authentication * if TLS 1.2 and peer supports it. */ if (rsa_enc || rsa_sign || (ssl_has_cert(s, SSL_PKEY_RSA_PSS_SIGN) && pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_EXPLICIT_SIGN && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)) mask_a |= SSL_aRSA; if (dsa_sign) { mask_a |= SSL_aDSS; } mask_a |= SSL_aNULL; /* * You can do anything with an RPK key, since there's no cert to restrict it * But we need to check for private keys */ if (pvalid[SSL_PKEY_RSA] & CERT_PKEY_RPK) { mask_a |= SSL_aRSA; mask_k |= SSL_kRSA; } if (pvalid[SSL_PKEY_ECC] & CERT_PKEY_RPK) mask_a |= SSL_aECDSA; if (TLS1_get_version(&s->ssl) == TLS1_2_VERSION) { if (pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_RPK) mask_a |= SSL_aRSA; if (pvalid[SSL_PKEY_ED25519] & CERT_PKEY_RPK || pvalid[SSL_PKEY_ED448] & CERT_PKEY_RPK) mask_a |= SSL_aECDSA; } /* * An ECC certificate may be usable for ECDH and/or ECDSA cipher suites * depending on the key usage extension. */ if (have_ecc_cert) { uint32_t ex_kusage; ex_kusage = X509_get_key_usage(c->pkeys[SSL_PKEY_ECC].x509); ecdsa_ok = ex_kusage & X509v3_KU_DIGITAL_SIGNATURE; if (!(pvalid[SSL_PKEY_ECC] & CERT_PKEY_SIGN)) ecdsa_ok = 0; if (ecdsa_ok) mask_a |= SSL_aECDSA; } /* Allow Ed25519 for TLS 1.2 if peer supports it */ if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED25519) && pvalid[SSL_PKEY_ED25519] & CERT_PKEY_EXPLICIT_SIGN && TLS1_get_version(&s->ssl) == TLS1_2_VERSION) mask_a |= SSL_aECDSA; /* Allow Ed448 for TLS 1.2 if peer supports it */ if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED448) && pvalid[SSL_PKEY_ED448] & CERT_PKEY_EXPLICIT_SIGN && TLS1_get_version(&s->ssl) == TLS1_2_VERSION) mask_a |= SSL_aECDSA; mask_k |= SSL_kECDHE; #ifndef OPENSSL_NO_PSK mask_k |= SSL_kPSK; mask_a |= SSL_aPSK; if (mask_k & SSL_kRSA) mask_k |= SSL_kRSAPSK; if (mask_k & SSL_kDHE) mask_k |= SSL_kDHEPSK; if (mask_k & SSL_kECDHE) mask_k |= SSL_kECDHEPSK; #endif s->s3.tmp.mask_k = mask_k; s->s3.tmp.mask_a = mask_a; } int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL_CONNECTION *s) { if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aECDSA) { /* key usage, if present, must allow signing */ if (!(X509_get_key_usage(x) & X509v3_KU_DIGITAL_SIGNATURE)) { ERR_raise(ERR_LIB_SSL, SSL_R_ECC_CERT_NOT_FOR_SIGNING); return 0; } } return 1; /* all checks are ok */ } int ssl_get_server_cert_serverinfo(SSL_CONNECTION *s, const unsigned char **serverinfo, size_t *serverinfo_length) { CERT_PKEY *cpk = s->s3.tmp.cert; *serverinfo_length = 0; if (cpk == NULL || cpk->serverinfo == NULL) return 0; *serverinfo = cpk->serverinfo; *serverinfo_length = cpk->serverinfo_length; return 1; } void ssl_update_cache(SSL_CONNECTION *s, int mode) { int i; /* * If the session_id_length is 0, we are not supposed to cache it, and it * would be rather hard to do anyway :-) */ if (s->session->session_id_length == 0) return; /* * If sid_ctx_length is 0 there is no specific application context * associated with this session, so when we try to resume it and * SSL_VERIFY_PEER is requested to verify the client identity, we have no * indication that this is actually a session for the proper application * context, and the *handshake* will fail, not just the resumption attempt. * Do not cache (on the server) these sessions that are not resumable * (clients can set SSL_VERIFY_PEER without needing a sid_ctx set). */ if (s->server && s->session->sid_ctx_length == 0 && (s->verify_mode & SSL_VERIFY_PEER) != 0) return; i = s->session_ctx->session_cache_mode; if ((i & mode) != 0 && (!s->hit || SSL_CONNECTION_IS_TLS13(s))) { /* * Add the session to the internal cache. In server side TLSv1.3 we * normally don't do this because by default it's a full stateless ticket * with only a dummy session id so there is no reason to cache it, * unless: * - we are doing early_data, in which case we cache so that we can * detect replays * - the application has set a remove_session_cb so needs to know about * session timeout events * - SSL_OP_NO_TICKET is set in which case it is a stateful ticket */ if ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0 && (!SSL_CONNECTION_IS_TLS13(s) || !s->server || (s->max_early_data > 0 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0) || s->session_ctx->remove_session_cb != NULL || (s->options & SSL_OP_NO_TICKET) != 0)) SSL_CTX_add_session(s->session_ctx, s->session); /* * Add the session to the external cache. We do this even in server side * TLSv1.3 without early data because some applications just want to * know about the creation of a session and aren't doing a full cache. */ if (s->session_ctx->new_session_cb != NULL) { SSL_SESSION_up_ref(s->session); if (!s->session_ctx->new_session_cb(SSL_CONNECTION_GET_SSL(s), s->session)) SSL_SESSION_free(s->session); } } /* auto flush every 255 connections */ if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) && ((i & mode) == mode)) { TSAN_QUALIFIER int *stat; if (mode & SSL_SESS_CACHE_CLIENT) stat = &s->session_ctx->stats.sess_connect_good; else stat = &s->session_ctx->stats.sess_accept_good; if ((ssl_tsan_load(s->session_ctx, stat) & 0xff) == 0xff) SSL_CTX_flush_sessions(s->session_ctx, (unsigned long)time(NULL)); } } const SSL_METHOD *SSL_CTX_get_ssl_method(const SSL_CTX *ctx) { return ctx->method; } const SSL_METHOD *SSL_get_ssl_method(const SSL *s) { return s->method; } int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth) { int ret = 1; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); /* Not allowed for QUIC */ if (sc == NULL || (s->type != SSL_TYPE_SSL_CONNECTION && s->method != meth) || (s->type == SSL_TYPE_SSL_CONNECTION && IS_QUIC_METHOD(meth))) return 0; if (s->method != meth) { const SSL_METHOD *sm = s->method; int (*hf) (SSL *) = sc->handshake_func; if (sm->version == meth->version) s->method = meth; else { sm->ssl_deinit(s); s->method = meth; ret = s->method->ssl_init(s); } if (hf == sm->ssl_connect) sc->handshake_func = meth->ssl_connect; else if (hf == sm->ssl_accept) sc->handshake_func = meth->ssl_accept; } return ret; } int SSL_get_error(const SSL *s, int i) { return ossl_ssl_get_error(s, i, /*check_err=*/1); } int ossl_ssl_get_error(const SSL *s, int i, int check_err) { int reason; unsigned long l; BIO *bio; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (i > 0) return SSL_ERROR_NONE; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { reason = ossl_quic_get_error(s, i); if (reason != SSL_ERROR_NONE) return reason; } #endif if (sc == NULL) return SSL_ERROR_SSL; /* * Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake etc, * where we do encode the error */ if (check_err && (l = ERR_peek_error()) != 0) { if (ERR_GET_LIB(l) == ERR_LIB_SYS) return SSL_ERROR_SYSCALL; else return SSL_ERROR_SSL; } #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) #endif { if (SSL_want_read(s)) { bio = SSL_get_rbio(s); if (BIO_should_read(bio)) return SSL_ERROR_WANT_READ; else if (BIO_should_write(bio)) /* * This one doesn't make too much sense ... We never try to * write to the rbio, and an application program where rbio and * wbio are separate couldn't even know what it should wait for. * However if we ever set s->rwstate incorrectly (so that we * have SSL_want_read(s) instead of SSL_want_write(s)) and rbio * and wbio *are* the same, this test works around that bug; so * it might be safer to keep it. */ return SSL_ERROR_WANT_WRITE; else if (BIO_should_io_special(bio)) { reason = BIO_get_retry_reason(bio); if (reason == BIO_RR_CONNECT) return SSL_ERROR_WANT_CONNECT; else if (reason == BIO_RR_ACCEPT) return SSL_ERROR_WANT_ACCEPT; else return SSL_ERROR_SYSCALL; /* unknown */ } } if (SSL_want_write(s)) { /* * Access wbio directly - in order to use the buffered bio if * present */ bio = sc->wbio; if (BIO_should_write(bio)) return SSL_ERROR_WANT_WRITE; else if (BIO_should_read(bio)) /* * See above (SSL_want_read(s) with BIO_should_write(bio)) */ return SSL_ERROR_WANT_READ; else if (BIO_should_io_special(bio)) { reason = BIO_get_retry_reason(bio); if (reason == BIO_RR_CONNECT) return SSL_ERROR_WANT_CONNECT; else if (reason == BIO_RR_ACCEPT) return SSL_ERROR_WANT_ACCEPT; else return SSL_ERROR_SYSCALL; } } } if (SSL_want_x509_lookup(s)) return SSL_ERROR_WANT_X509_LOOKUP; if (SSL_want_retry_verify(s)) return SSL_ERROR_WANT_RETRY_VERIFY; if (SSL_want_async(s)) return SSL_ERROR_WANT_ASYNC; if (SSL_want_async_job(s)) return SSL_ERROR_WANT_ASYNC_JOB; if (SSL_want_client_hello_cb(s)) return SSL_ERROR_WANT_CLIENT_HELLO_CB; if ((sc->shutdown & SSL_RECEIVED_SHUTDOWN) && (sc->s3.warn_alert == SSL_AD_CLOSE_NOTIFY)) return SSL_ERROR_ZERO_RETURN; return SSL_ERROR_SYSCALL; } static int ssl_do_handshake_intern(void *vargs) { struct ssl_async_args *args = (struct ssl_async_args *)vargs; SSL *s = args->s; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; return sc->handshake_func(s); } int SSL_do_handshake(SSL *s) { int ret = 1; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_do_handshake(s); #endif if (sc->handshake_func == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_CONNECTION_TYPE_NOT_SET); return -1; } ossl_statem_check_finish_init(sc, -1); s->method->ssl_renegotiate_check(s, 0); if (SSL_in_init(s) || SSL_in_before(s)) { if ((sc->mode & SSL_MODE_ASYNC) && ASYNC_get_current_job() == NULL) { struct ssl_async_args args; memset(&args, 0, sizeof(args)); args.s = s; ret = ssl_start_async_job(s, &args, ssl_do_handshake_intern); } else { ret = sc->handshake_func(s); } } return ret; } void SSL_set_accept_state(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { ossl_quic_set_accept_state(s); return; } #endif sc->server = 1; sc->shutdown = 0; ossl_statem_clear(sc); sc->handshake_func = s->method->ssl_accept; /* Ignore return value. Its a void public API function */ clear_record_layer(sc); } void SSL_set_connect_state(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) { ossl_quic_set_connect_state(s); return; } #endif sc->server = 0; sc->shutdown = 0; ossl_statem_clear(sc); sc->handshake_func = s->method->ssl_connect; /* Ignore return value. Its a void public API function */ clear_record_layer(sc); } int ssl_undefined_function(SSL *s) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } int ssl_undefined_void_function(void) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } int ssl_undefined_const_function(const SSL *s) { return 0; } const SSL_METHOD *ssl_bad_method(int ver) { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return NULL; } const char *ssl_protocol_to_string(int version) { switch (version) { case TLS1_3_VERSION: return "TLSv1.3"; case TLS1_2_VERSION: return "TLSv1.2"; case TLS1_1_VERSION: return "TLSv1.1"; case TLS1_VERSION: return "TLSv1"; case SSL3_VERSION: return "SSLv3"; case DTLS1_BAD_VER: return "DTLSv0.9"; case DTLS1_VERSION: return "DTLSv1"; case DTLS1_2_VERSION: return "DTLSv1.2"; default: return "unknown"; } } const char *SSL_get_version(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC /* We only support QUICv1 - so if its QUIC its QUICv1 */ if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO) return "QUICv1"; #endif if (sc == NULL) return NULL; return ssl_protocol_to_string(sc->version); } __owur int SSL_get_handshake_rtt(const SSL *s, uint64_t *rtt) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return -1; if (sc->ts_msg_write.t <= 0 || sc->ts_msg_read.t <= 0) return 0; /* data not (yet) available */ if (sc->ts_msg_read.t < sc->ts_msg_write.t) return -1; *rtt = ossl_time2us(ossl_time_subtract(sc->ts_msg_read, sc->ts_msg_write)); return 1; } static int dup_ca_names(STACK_OF(X509_NAME) **dst, STACK_OF(X509_NAME) *src) { STACK_OF(X509_NAME) *sk; X509_NAME *xn; int i; if (src == NULL) { *dst = NULL; return 1; } if ((sk = sk_X509_NAME_new_null()) == NULL) return 0; for (i = 0; i < sk_X509_NAME_num(src); i++) { xn = X509_NAME_dup(sk_X509_NAME_value(src, i)); if (xn == NULL) { sk_X509_NAME_pop_free(sk, X509_NAME_free); return 0; } if (sk_X509_NAME_insert(sk, xn, i) == 0) { X509_NAME_free(xn); sk_X509_NAME_pop_free(sk, X509_NAME_free); return 0; } } *dst = sk; return 1; } SSL *SSL_dup(SSL *s) { SSL *ret; int i; /* TODO(QUIC FUTURE): Add a SSL_METHOD function for duplication */ SSL_CONNECTION *retsc; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return NULL; /* If we're not quiescent, just up_ref! */ if (!SSL_in_init(s) || !SSL_in_before(s)) { CRYPTO_UP_REF(&s->references, &i); return s; } /* * Otherwise, copy configuration state, and session if set. */ if ((ret = SSL_new(SSL_get_SSL_CTX(s))) == NULL) return NULL; if ((retsc = SSL_CONNECTION_FROM_SSL_ONLY(ret)) == NULL) goto err; if (sc->session != NULL) { /* * Arranges to share the same session via up_ref. This "copies" * session-id, SSL_METHOD, sid_ctx, and 'cert' */ if (!SSL_copy_session_id(ret, s)) goto err; } else { /* * No session has been established yet, so we have to expect that * s->cert or ret->cert will be changed later -- they should not both * point to the same object, and thus we can't use * SSL_copy_session_id. */ if (!SSL_set_ssl_method(ret, s->method)) goto err; if (sc->cert != NULL) { ssl_cert_free(retsc->cert); retsc->cert = ssl_cert_dup(sc->cert); if (retsc->cert == NULL) goto err; } if (!SSL_set_session_id_context(ret, sc->sid_ctx, (int)sc->sid_ctx_length)) goto err; } if (!ssl_dane_dup(retsc, sc)) goto err; retsc->version = sc->version; retsc->options = sc->options; retsc->min_proto_version = sc->min_proto_version; retsc->max_proto_version = sc->max_proto_version; retsc->mode = sc->mode; SSL_set_max_cert_list(ret, SSL_get_max_cert_list(s)); SSL_set_read_ahead(ret, SSL_get_read_ahead(s)); retsc->msg_callback = sc->msg_callback; retsc->msg_callback_arg = sc->msg_callback_arg; SSL_set_verify(ret, SSL_get_verify_mode(s), SSL_get_verify_callback(s)); SSL_set_verify_depth(ret, SSL_get_verify_depth(s)); retsc->generate_session_id = sc->generate_session_id; SSL_set_info_callback(ret, SSL_get_info_callback(s)); /* copy app data, a little dangerous perhaps */ if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data)) goto err; retsc->server = sc->server; if (sc->handshake_func) { if (sc->server) SSL_set_accept_state(ret); else SSL_set_connect_state(ret); } retsc->shutdown = sc->shutdown; retsc->hit = sc->hit; retsc->default_passwd_callback = sc->default_passwd_callback; retsc->default_passwd_callback_userdata = sc->default_passwd_callback_userdata; X509_VERIFY_PARAM_inherit(retsc->param, sc->param); /* dup the cipher_list and cipher_list_by_id stacks */ if (sc->cipher_list != NULL) { if ((retsc->cipher_list = sk_SSL_CIPHER_dup(sc->cipher_list)) == NULL) goto err; } if (sc->cipher_list_by_id != NULL) if ((retsc->cipher_list_by_id = sk_SSL_CIPHER_dup(sc->cipher_list_by_id)) == NULL) goto err; /* Dup the client_CA list */ if (!dup_ca_names(&retsc->ca_names, sc->ca_names) || !dup_ca_names(&retsc->client_ca_names, sc->client_ca_names)) goto err; return ret; err: SSL_free(ret); return NULL; } X509 *SSL_get_certificate(const SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (sc->cert != NULL) return sc->cert->key->x509; else return NULL; } EVP_PKEY *SSL_get_privatekey(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if (sc->cert != NULL) return sc->cert->key->privatekey; else return NULL; } X509 *SSL_CTX_get0_certificate(const SSL_CTX *ctx) { if (ctx->cert != NULL) return ctx->cert->key->x509; else return NULL; } EVP_PKEY *SSL_CTX_get0_privatekey(const SSL_CTX *ctx) { if (ctx->cert != NULL) return ctx->cert->key->privatekey; else return NULL; } const SSL_CIPHER *SSL_get_current_cipher(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; if ((sc->session != NULL) && (sc->session->cipher != NULL)) return sc->session->cipher; return NULL; } const SSL_CIPHER *SSL_get_pending_cipher(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->s3.tmp.new_cipher; } const COMP_METHOD *SSL_get_current_compression(const SSL *s) { #ifndef OPENSSL_NO_COMP const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); if (sc == NULL) return NULL; return sc->rlayer.wrlmethod->get_compression(sc->rlayer.wrl); #else return NULL; #endif } const COMP_METHOD *SSL_get_current_expansion(const SSL *s) { #ifndef OPENSSL_NO_COMP const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); if (sc == NULL) return NULL; return sc->rlayer.rrlmethod->get_compression(sc->rlayer.rrl); #else return NULL; #endif } int ssl_init_wbio_buffer(SSL_CONNECTION *s) { BIO *bbio; if (s->bbio != NULL) { /* Already buffered. */ return 1; } bbio = BIO_new(BIO_f_buffer()); if (bbio == NULL || BIO_set_read_buffer_size(bbio, 1) <= 0) { BIO_free(bbio); ERR_raise(ERR_LIB_SSL, ERR_R_BUF_LIB); return 0; } s->bbio = bbio; s->wbio = BIO_push(bbio, s->wbio); s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio); return 1; } int ssl_free_wbio_buffer(SSL_CONNECTION *s) { /* callers ensure s is never null */ if (s->bbio == NULL) return 1; s->wbio = BIO_pop(s->wbio); s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio); BIO_free(s->bbio); s->bbio = NULL; return 1; } void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx, int mode) { ctx->quiet_shutdown = mode; } int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx) { return ctx->quiet_shutdown; } void SSL_set_quiet_shutdown(SSL *s, int mode) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); /* Not supported with QUIC */ if (sc == NULL) return; sc->quiet_shutdown = mode; } int SSL_get_quiet_shutdown(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); /* Not supported with QUIC */ if (sc == NULL) return 0; return sc->quiet_shutdown; } void SSL_set_shutdown(SSL *s, int mode) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); /* Not supported with QUIC */ if (sc == NULL) return; sc->shutdown = mode; } int SSL_get_shutdown(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL_ONLY(s); #ifndef OPENSSL_NO_QUIC /* QUIC: Just indicate whether the connection was shutdown cleanly. */ if (IS_QUIC(s)) return ossl_quic_get_shutdown(s); #endif if (sc == NULL) return 0; return sc->shutdown; } int SSL_version(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC /* We only support QUICv1 - so if its QUIC its QUICv1 */ if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO) return OSSL_QUIC1_VERSION; #endif if (sc == NULL) return 0; return sc->version; } int SSL_client_version(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC /* We only support QUICv1 - so if its QUIC its QUICv1 */ if (s->type == SSL_TYPE_QUIC_CONNECTION || s->type == SSL_TYPE_QUIC_XSO) return OSSL_QUIC1_VERSION; #endif if (sc == NULL) return 0; return sc->client_version; } SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl) { return ssl->ctx; } SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx) { CERT *new_cert; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl); /* TODO(QUIC FUTURE): Add support for QUIC */ if (sc == NULL) return NULL; if (ssl->ctx == ctx) return ssl->ctx; if (ctx == NULL) ctx = sc->session_ctx; new_cert = ssl_cert_dup(ctx->cert); if (new_cert == NULL) { return NULL; } if (!custom_exts_copy_flags(&new_cert->custext, &sc->cert->custext)) { ssl_cert_free(new_cert); return NULL; } ssl_cert_free(sc->cert); sc->cert = new_cert; /* * Program invariant: |sid_ctx| has fixed size (SSL_MAX_SID_CTX_LENGTH), * so setter APIs must prevent invalid lengths from entering the system. */ if (!ossl_assert(sc->sid_ctx_length <= sizeof(sc->sid_ctx))) return NULL; /* * If the session ID context matches that of the parent SSL_CTX, * inherit it from the new SSL_CTX as well. If however the context does * not match (i.e., it was set per-ssl with SSL_set_session_id_context), * leave it unchanged. */ if ((ssl->ctx != NULL) && (sc->sid_ctx_length == ssl->ctx->sid_ctx_length) && (memcmp(sc->sid_ctx, ssl->ctx->sid_ctx, sc->sid_ctx_length) == 0)) { sc->sid_ctx_length = ctx->sid_ctx_length; memcpy(&sc->sid_ctx, &ctx->sid_ctx, sizeof(sc->sid_ctx)); } SSL_CTX_up_ref(ctx); SSL_CTX_free(ssl->ctx); /* decrement reference count */ ssl->ctx = ctx; return ssl->ctx; } int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx) { return X509_STORE_set_default_paths_ex(ctx->cert_store, ctx->libctx, ctx->propq); } int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx) { X509_LOOKUP *lookup; lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_hash_dir()); if (lookup == NULL) return 0; /* We ignore errors, in case the directory doesn't exist */ ERR_set_mark(); X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT); ERR_pop_to_mark(); return 1; } int SSL_CTX_set_default_verify_file(SSL_CTX *ctx) { X509_LOOKUP *lookup; lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_file()); if (lookup == NULL) return 0; /* We ignore errors, in case the file doesn't exist */ ERR_set_mark(); X509_LOOKUP_load_file_ex(lookup, NULL, X509_FILETYPE_DEFAULT, ctx->libctx, ctx->propq); ERR_pop_to_mark(); return 1; } int SSL_CTX_set_default_verify_store(SSL_CTX *ctx) { X509_LOOKUP *lookup; lookup = X509_STORE_add_lookup(ctx->cert_store, X509_LOOKUP_store()); if (lookup == NULL) return 0; /* We ignore errors, in case the directory doesn't exist */ ERR_set_mark(); X509_LOOKUP_add_store_ex(lookup, NULL, ctx->libctx, ctx->propq); ERR_pop_to_mark(); return 1; } int SSL_CTX_load_verify_file(SSL_CTX *ctx, const char *CAfile) { return X509_STORE_load_file_ex(ctx->cert_store, CAfile, ctx->libctx, ctx->propq); } int SSL_CTX_load_verify_dir(SSL_CTX *ctx, const char *CApath) { return X509_STORE_load_path(ctx->cert_store, CApath); } int SSL_CTX_load_verify_store(SSL_CTX *ctx, const char *CAstore) { return X509_STORE_load_store_ex(ctx->cert_store, CAstore, ctx->libctx, ctx->propq); } int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile, const char *CApath) { if (CAfile == NULL && CApath == NULL) return 0; if (CAfile != NULL && !SSL_CTX_load_verify_file(ctx, CAfile)) return 0; if (CApath != NULL && !SSL_CTX_load_verify_dir(ctx, CApath)) return 0; return 1; } void SSL_set_info_callback(SSL *ssl, void (*cb) (const SSL *ssl, int type, int val)) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return; sc->info_callback = cb; } /* * One compiler (Diab DCC) doesn't like argument names in returned function * pointer. */ void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ , int /* type */ , int /* val */ ) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return NULL; return sc->info_callback; } void SSL_set_verify_result(SSL *ssl, long arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return; sc->verify_result = arg; } long SSL_get_verify_result(const SSL *ssl) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return 0; return sc->verify_result; } size_t SSL_get_client_random(const SSL *ssl, unsigned char *out, size_t outlen) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return 0; if (outlen == 0) return sizeof(sc->s3.client_random); if (outlen > sizeof(sc->s3.client_random)) outlen = sizeof(sc->s3.client_random); memcpy(out, sc->s3.client_random, outlen); return outlen; } size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return 0; if (outlen == 0) return sizeof(sc->s3.server_random); if (outlen > sizeof(sc->s3.server_random)) outlen = sizeof(sc->s3.server_random); memcpy(out, sc->s3.server_random, outlen); return outlen; } size_t SSL_SESSION_get_master_key(const SSL_SESSION *session, unsigned char *out, size_t outlen) { if (outlen == 0) return session->master_key_length; if (outlen > session->master_key_length) outlen = session->master_key_length; memcpy(out, session->master_key, outlen); return outlen; } int SSL_SESSION_set1_master_key(SSL_SESSION *sess, const unsigned char *in, size_t len) { if (len > sizeof(sess->master_key)) return 0; memcpy(sess->master_key, in, len); sess->master_key_length = len; return 1; } int SSL_set_ex_data(SSL *s, int idx, void *arg) { return CRYPTO_set_ex_data(&s->ex_data, idx, arg); } void *SSL_get_ex_data(const SSL *s, int idx) { return CRYPTO_get_ex_data(&s->ex_data, idx); } int SSL_CTX_set_ex_data(SSL_CTX *s, int idx, void *arg) { return CRYPTO_set_ex_data(&s->ex_data, idx, arg); } void *SSL_CTX_get_ex_data(const SSL_CTX *s, int idx) { return CRYPTO_get_ex_data(&s->ex_data, idx); } X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx) { return ctx->cert_store; } void SSL_CTX_set_cert_store(SSL_CTX *ctx, X509_STORE *store) { X509_STORE_free(ctx->cert_store); ctx->cert_store = store; } void SSL_CTX_set1_cert_store(SSL_CTX *ctx, X509_STORE *store) { if (store != NULL) X509_STORE_up_ref(store); SSL_CTX_set_cert_store(ctx, store); } int SSL_want(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_want(s); #endif if (sc == NULL) return SSL_NOTHING; return sc->rwstate; } #ifndef OPENSSL_NO_PSK int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint) { if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) { ERR_raise(ERR_LIB_SSL, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } OPENSSL_free(ctx->cert->psk_identity_hint); if (identity_hint != NULL) { ctx->cert->psk_identity_hint = OPENSSL_strdup(identity_hint); if (ctx->cert->psk_identity_hint == NULL) return 0; } else ctx->cert->psk_identity_hint = NULL; return 1; } int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN) { ERR_raise(ERR_LIB_SSL, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } OPENSSL_free(sc->cert->psk_identity_hint); if (identity_hint != NULL) { sc->cert->psk_identity_hint = OPENSSL_strdup(identity_hint); if (sc->cert->psk_identity_hint == NULL) return 0; } else sc->cert->psk_identity_hint = NULL; return 1; } const char *SSL_get_psk_identity_hint(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL || sc->session == NULL) return NULL; return sc->session->psk_identity_hint; } const char *SSL_get_psk_identity(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL || sc->session == NULL) return NULL; return sc->session->psk_identity; } void SSL_set_psk_client_callback(SSL *s, SSL_psk_client_cb_func cb) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->psk_client_callback = cb; } void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx, SSL_psk_client_cb_func cb) { ctx->psk_client_callback = cb; } void SSL_set_psk_server_callback(SSL *s, SSL_psk_server_cb_func cb) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->psk_server_callback = cb; } void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx, SSL_psk_server_cb_func cb) { ctx->psk_server_callback = cb; } #endif void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->psk_find_session_cb = cb; } void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx, SSL_psk_find_session_cb_func cb) { ctx->psk_find_session_cb = cb; } void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->psk_use_session_cb = cb; } void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx, SSL_psk_use_session_cb_func cb) { ctx->psk_use_session_cb = cb; } void SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb) (int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)) { SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb); } void SSL_set_msg_callback(SSL *ssl, void (*cb) (int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)) { SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb); } void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx, int (*cb) (SSL *ssl, int is_forward_secure)) { SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB, (void (*)(void))cb); } void SSL_set_not_resumable_session_callback(SSL *ssl, int (*cb) (SSL *ssl, int is_forward_secure)) { SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB, (void (*)(void))cb); } void SSL_CTX_set_record_padding_callback(SSL_CTX *ctx, size_t (*cb) (SSL *ssl, int type, size_t len, void *arg)) { ctx->record_padding_cb = cb; } void SSL_CTX_set_record_padding_callback_arg(SSL_CTX *ctx, void *arg) { ctx->record_padding_arg = arg; } void *SSL_CTX_get_record_padding_callback_arg(const SSL_CTX *ctx) { return ctx->record_padding_arg; } int SSL_CTX_set_block_padding(SSL_CTX *ctx, size_t block_size) { if (IS_QUIC_CTX(ctx) && block_size > 1) return 0; /* block size of 0 or 1 is basically no padding */ if (block_size == 1) ctx->block_padding = 0; else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH) ctx->block_padding = block_size; else return 0; return 1; } int SSL_set_record_padding_callback(SSL *ssl, size_t (*cb) (SSL *ssl, int type, size_t len, void *arg)) { BIO *b; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (sc == NULL) return 0; b = SSL_get_wbio(ssl); if (b == NULL || !BIO_get_ktls_send(b)) { sc->rlayer.record_padding_cb = cb; return 1; } return 0; } void SSL_set_record_padding_callback_arg(SSL *ssl, void *arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return; sc->rlayer.record_padding_arg = arg; } void *SSL_get_record_padding_callback_arg(const SSL *ssl) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return NULL; return sc->rlayer.record_padding_arg; } int SSL_set_block_padding(SSL *ssl, size_t block_size) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL || (IS_QUIC(ssl) && block_size > 1)) return 0; /* block size of 0 or 1 is basically no padding */ if (block_size == 1) sc->rlayer.block_padding = 0; else if (block_size <= SSL3_RT_MAX_PLAIN_LENGTH) sc->rlayer.block_padding = block_size; else return 0; return 1; } int SSL_set_num_tickets(SSL *s, size_t num_tickets) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->num_tickets = num_tickets; return 1; } size_t SSL_get_num_tickets(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->num_tickets; } int SSL_CTX_set_num_tickets(SSL_CTX *ctx, size_t num_tickets) { ctx->num_tickets = num_tickets; return 1; } size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx) { return ctx->num_tickets; } /* Retrieve handshake hashes */ int ssl_handshake_hash(SSL_CONNECTION *s, unsigned char *out, size_t outlen, size_t *hashlen) { EVP_MD_CTX *ctx = NULL; EVP_MD_CTX *hdgst = s->s3.handshake_dgst; int hashleni = EVP_MD_CTX_get_size(hdgst); int ret = 0; if (hashleni < 0 || (size_t)hashleni > outlen) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ctx = EVP_MD_CTX_new(); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!EVP_MD_CTX_copy_ex(ctx, hdgst) || EVP_DigestFinal_ex(ctx, out, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } *hashlen = hashleni; ret = 1; err: EVP_MD_CTX_free(ctx); return ret; } int SSL_session_reused(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->hit; } int SSL_is_server(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->server; } #ifndef OPENSSL_NO_DEPRECATED_1_1_0 void SSL_set_debug(SSL *s, int debug) { /* Old function was do-nothing anyway... */ (void)s; (void)debug; } #endif void SSL_set_security_level(SSL *s, int level) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->cert->sec_level = level; } int SSL_get_security_level(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->cert->sec_level; } void SSL_set_security_callback(SSL *s, int (*cb) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex)) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->cert->sec_cb = cb; } int (*SSL_get_security_callback(const SSL *s)) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->cert->sec_cb; } void SSL_set0_security_ex_data(SSL *s, void *ex) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; sc->cert->sec_ex = ex; } void *SSL_get0_security_ex_data(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->cert->sec_ex; } void SSL_CTX_set_security_level(SSL_CTX *ctx, int level) { ctx->cert->sec_level = level; } int SSL_CTX_get_security_level(const SSL_CTX *ctx) { return ctx->cert->sec_level; } void SSL_CTX_set_security_callback(SSL_CTX *ctx, int (*cb) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex)) { ctx->cert->sec_cb = cb; } int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid, void *other, void *ex) { return ctx->cert->sec_cb; } void SSL_CTX_set0_security_ex_data(SSL_CTX *ctx, void *ex) { ctx->cert->sec_ex = ex; } void *SSL_CTX_get0_security_ex_data(const SSL_CTX *ctx) { return ctx->cert->sec_ex; } uint64_t SSL_CTX_get_options(const SSL_CTX *ctx) { return ctx->options; } uint64_t SSL_get_options(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_options(s); #endif if (sc == NULL) return 0; return sc->options; } uint64_t SSL_CTX_set_options(SSL_CTX *ctx, uint64_t op) { return ctx->options |= op; } uint64_t SSL_set_options(SSL *s, uint64_t op) { SSL_CONNECTION *sc; OSSL_PARAM options[2], *opts = options; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_set_options(s, op); #endif sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->options |= op; *opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS, &sc->options); *opts = OSSL_PARAM_construct_end(); /* Ignore return value */ sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options); sc->rlayer.wrlmethod->set_options(sc->rlayer.wrl, options); return sc->options; } uint64_t SSL_CTX_clear_options(SSL_CTX *ctx, uint64_t op) { return ctx->options &= ~op; } uint64_t SSL_clear_options(SSL *s, uint64_t op) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); OSSL_PARAM options[2], *opts = options; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_clear_options(s, op); #endif if (sc == NULL) return 0; sc->options &= ~op; *opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS, &sc->options); *opts = OSSL_PARAM_construct_end(); /* Ignore return value */ sc->rlayer.rrlmethod->set_options(sc->rlayer.rrl, options); sc->rlayer.wrlmethod->set_options(sc->rlayer.wrl, options); return sc->options; } STACK_OF(X509) *SSL_get0_verified_chain(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return NULL; return sc->verified_chain; } IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id); #ifndef OPENSSL_NO_CT /* * Moves SCTs from the |src| stack to the |dst| stack. * The source of each SCT will be set to |origin|. * If |dst| points to a NULL pointer, a new stack will be created and owned by * the caller. * Returns the number of SCTs moved, or a negative integer if an error occurs. * The |dst| stack is created and possibly partially populated even in case * of error, likewise the |src| stack may be left in an intermediate state. */ static int ct_move_scts(STACK_OF(SCT) **dst, STACK_OF(SCT) *src, sct_source_t origin) { int scts_moved = 0; SCT *sct = NULL; if (*dst == NULL) { *dst = sk_SCT_new_null(); if (*dst == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } } while ((sct = sk_SCT_pop(src)) != NULL) { if (SCT_set_source(sct, origin) != 1) goto err; if (!sk_SCT_push(*dst, sct)) goto err; scts_moved += 1; } return scts_moved; err: SCT_free(sct); return -1; } /* * Look for data collected during ServerHello and parse if found. * Returns the number of SCTs extracted. */ static int ct_extract_tls_extension_scts(SSL_CONNECTION *s) { int scts_extracted = 0; if (s->ext.scts != NULL) { const unsigned char *p = s->ext.scts; STACK_OF(SCT) *scts = o2i_SCT_LIST(NULL, &p, s->ext.scts_len); scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_TLS_EXTENSION); SCT_LIST_free(scts); } return scts_extracted; } /* * Checks for an OCSP response and then attempts to extract any SCTs found if it * contains an SCT X509 extension. They will be stored in |s->scts|. * Returns: * - The number of SCTs extracted, assuming an OCSP response exists. * - 0 if no OCSP response exists or it contains no SCTs. * - A negative integer if an error occurs. */ static int ct_extract_ocsp_response_scts(SSL_CONNECTION *s) { # ifndef OPENSSL_NO_OCSP int scts_extracted = 0; const unsigned char *p; OCSP_BASICRESP *br = NULL; OCSP_RESPONSE *rsp = NULL; STACK_OF(SCT) *scts = NULL; int i; if (s->ext.ocsp.resp == NULL || s->ext.ocsp.resp_len == 0) goto err; p = s->ext.ocsp.resp; rsp = d2i_OCSP_RESPONSE(NULL, &p, (int)s->ext.ocsp.resp_len); if (rsp == NULL) goto err; br = OCSP_response_get1_basic(rsp); if (br == NULL) goto err; for (i = 0; i < OCSP_resp_count(br); ++i) { OCSP_SINGLERESP *single = OCSP_resp_get0(br, i); if (single == NULL) continue; scts = OCSP_SINGLERESP_get1_ext_d2i(single, NID_ct_cert_scts, NULL, NULL); scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_OCSP_STAPLED_RESPONSE); if (scts_extracted < 0) goto err; } err: SCT_LIST_free(scts); OCSP_BASICRESP_free(br); OCSP_RESPONSE_free(rsp); return scts_extracted; # else /* Behave as if no OCSP response exists */ return 0; # endif } /* * Attempts to extract SCTs from the peer certificate. * Return the number of SCTs extracted, or a negative integer if an error * occurs. */ static int ct_extract_x509v3_extension_scts(SSL_CONNECTION *s) { int scts_extracted = 0; X509 *cert = s->session != NULL ? s->session->peer : NULL; if (cert != NULL) { STACK_OF(SCT) *scts = X509_get_ext_d2i(cert, NID_ct_precert_scts, NULL, NULL); scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_X509V3_EXTENSION); SCT_LIST_free(scts); } return scts_extracted; } /* * Attempts to find all received SCTs by checking TLS extensions, the OCSP * response (if it exists) and X509v3 extensions in the certificate. * Returns NULL if an error occurs. */ const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; if (!sc->scts_parsed) { if (ct_extract_tls_extension_scts(sc) < 0 || ct_extract_ocsp_response_scts(sc) < 0 || ct_extract_x509v3_extension_scts(sc) < 0) goto err; sc->scts_parsed = 1; } return sc->scts; err: return NULL; } static int ct_permissive(const CT_POLICY_EVAL_CTX *ctx, const STACK_OF(SCT) *scts, void *unused_arg) { return 1; } static int ct_strict(const CT_POLICY_EVAL_CTX *ctx, const STACK_OF(SCT) *scts, void *unused_arg) { int count = scts != NULL ? sk_SCT_num(scts) : 0; int i; for (i = 0; i < count; ++i) { SCT *sct = sk_SCT_value(scts, i); int status = SCT_get_validation_status(sct); if (status == SCT_VALIDATION_STATUS_VALID) return 1; } ERR_raise(ERR_LIB_SSL, SSL_R_NO_VALID_SCTS); return 0; } int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback, void *arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; /* * Since code exists that uses the custom extension handler for CT, look * for this and throw an error if they have already registered to use CT. */ if (callback != NULL && SSL_CTX_has_client_custom_ext(s->ctx, TLSEXT_TYPE_signed_certificate_timestamp)) { ERR_raise(ERR_LIB_SSL, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED); return 0; } if (callback != NULL) { /* * If we are validating CT, then we MUST accept SCTs served via OCSP */ if (!SSL_set_tlsext_status_type(s, TLSEXT_STATUSTYPE_ocsp)) return 0; } sc->ct_validation_callback = callback; sc->ct_validation_callback_arg = arg; return 1; } int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx, ssl_ct_validation_cb callback, void *arg) { /* * Since code exists that uses the custom extension handler for CT, look for * this and throw an error if they have already registered to use CT. */ if (callback != NULL && SSL_CTX_has_client_custom_ext(ctx, TLSEXT_TYPE_signed_certificate_timestamp)) { ERR_raise(ERR_LIB_SSL, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED); return 0; } ctx->ct_validation_callback = callback; ctx->ct_validation_callback_arg = arg; return 1; } int SSL_ct_is_enabled(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->ct_validation_callback != NULL; } int SSL_CTX_ct_is_enabled(const SSL_CTX *ctx) { return ctx->ct_validation_callback != NULL; } int ssl_validate_ct(SSL_CONNECTION *s) { int ret = 0; X509 *cert = s->session != NULL ? s->session->peer : NULL; X509 *issuer; SSL_DANE *dane = &s->dane; CT_POLICY_EVAL_CTX *ctx = NULL; const STACK_OF(SCT) *scts; /* * If no callback is set, the peer is anonymous, or its chain is invalid, * skip SCT validation - just return success. Applications that continue * handshakes without certificates, with unverified chains, or pinned leaf * certificates are outside the scope of the WebPKI and CT. * * The above exclusions notwithstanding the vast majority of peers will * have rather ordinary certificate chains validated by typical * applications that perform certificate verification and therefore will * process SCTs when enabled. */ if (s->ct_validation_callback == NULL || cert == NULL || s->verify_result != X509_V_OK || s->verified_chain == NULL || sk_X509_num(s->verified_chain) <= 1) return 1; /* * CT not applicable for chains validated via DANE-TA(2) or DANE-EE(3) * trust-anchors. See https://tools.ietf.org/html/rfc7671#section-4.2 */ if (DANETLS_ENABLED(dane) && dane->mtlsa != NULL) { switch (dane->mtlsa->usage) { case DANETLS_USAGE_DANE_TA: case DANETLS_USAGE_DANE_EE: return 1; } } ctx = CT_POLICY_EVAL_CTX_new_ex(SSL_CONNECTION_GET_CTX(s)->libctx, SSL_CONNECTION_GET_CTX(s)->propq); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CT_LIB); goto end; } issuer = sk_X509_value(s->verified_chain, 1); CT_POLICY_EVAL_CTX_set1_cert(ctx, cert); CT_POLICY_EVAL_CTX_set1_issuer(ctx, issuer); CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(ctx, SSL_CONNECTION_GET_CTX(s)->ctlog_store); CT_POLICY_EVAL_CTX_set_time( ctx, (uint64_t)SSL_SESSION_get_time(s->session) * 1000); scts = SSL_get0_peer_scts(SSL_CONNECTION_GET_SSL(s)); /* * This function returns success (> 0) only when all the SCTs are valid, 0 * when some are invalid, and < 0 on various internal errors (out of * memory, etc.). Having some, or even all, invalid SCTs is not sufficient * reason to abort the handshake, that decision is up to the callback. * Therefore, we error out only in the unexpected case that the return * value is negative. * * XXX: One might well argue that the return value of this function is an * unfortunate design choice. Its job is only to determine the validation * status of each of the provided SCTs. So long as it correctly separates * the wheat from the chaff it should return success. Failure in this case * ought to correspond to an inability to carry out its duties. */ if (SCT_LIST_validate(scts, ctx) < 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_SCT_VERIFICATION_FAILED); goto end; } ret = s->ct_validation_callback(ctx, scts, s->ct_validation_callback_arg); if (ret < 0) ret = 0; /* This function returns 0 on failure */ if (!ret) SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_CALLBACK_FAILED); end: CT_POLICY_EVAL_CTX_free(ctx); /* * With SSL_VERIFY_NONE the session may be cached and re-used despite a * failure return code here. Also the application may wish the complete * the handshake, and then disconnect cleanly at a higher layer, after * checking the verification status of the completed connection. * * We therefore force a certificate verification failure which will be * visible via SSL_get_verify_result() and cached as part of any resumed * session. * * Note: the permissive callback is for information gathering only, always * returns success, and does not affect verification status. Only the * strict callback or a custom application-specified callback can trigger * connection failure or record a verification error. */ if (ret <= 0) s->verify_result = X509_V_ERR_NO_VALID_SCTS; return ret; } int SSL_CTX_enable_ct(SSL_CTX *ctx, int validation_mode) { switch (validation_mode) { default: ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CT_VALIDATION_TYPE); return 0; case SSL_CT_VALIDATION_PERMISSIVE: return SSL_CTX_set_ct_validation_callback(ctx, ct_permissive, NULL); case SSL_CT_VALIDATION_STRICT: return SSL_CTX_set_ct_validation_callback(ctx, ct_strict, NULL); } } int SSL_enable_ct(SSL *s, int validation_mode) { switch (validation_mode) { default: ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CT_VALIDATION_TYPE); return 0; case SSL_CT_VALIDATION_PERMISSIVE: return SSL_set_ct_validation_callback(s, ct_permissive, NULL); case SSL_CT_VALIDATION_STRICT: return SSL_set_ct_validation_callback(s, ct_strict, NULL); } } int SSL_CTX_set_default_ctlog_list_file(SSL_CTX *ctx) { return CTLOG_STORE_load_default_file(ctx->ctlog_store); } int SSL_CTX_set_ctlog_list_file(SSL_CTX *ctx, const char *path) { return CTLOG_STORE_load_file(ctx->ctlog_store, path); } void SSL_CTX_set0_ctlog_store(SSL_CTX *ctx, CTLOG_STORE *logs) { CTLOG_STORE_free(ctx->ctlog_store); ctx->ctlog_store = logs; } const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx) { return ctx->ctlog_store; } #endif /* OPENSSL_NO_CT */ void SSL_CTX_set_client_hello_cb(SSL_CTX *c, SSL_client_hello_cb_fn cb, void *arg) { c->client_hello_cb = cb; c->client_hello_cb_arg = arg; } int SSL_client_hello_isv2(SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; return sc->clienthello->isv2; } unsigned int SSL_client_hello_get0_legacy_version(SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; return sc->clienthello->legacy_version; } size_t SSL_client_hello_get0_random(SSL *s, const unsigned char **out) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; if (out != NULL) *out = sc->clienthello->random; return SSL3_RANDOM_SIZE; } size_t SSL_client_hello_get0_session_id(SSL *s, const unsigned char **out) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; if (out != NULL) *out = sc->clienthello->session_id; return sc->clienthello->session_id_len; } size_t SSL_client_hello_get0_ciphers(SSL *s, const unsigned char **out) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; if (out != NULL) *out = PACKET_data(&sc->clienthello->ciphersuites); return PACKET_remaining(&sc->clienthello->ciphersuites); } size_t SSL_client_hello_get0_compression_methods(SSL *s, const unsigned char **out) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; if (out != NULL) *out = sc->clienthello->compressions; return sc->clienthello->compressions_len; } int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen) { RAW_EXTENSION *ext; int *present; size_t num = 0, i; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL || out == NULL || outlen == NULL) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) { ext = sc->clienthello->pre_proc_exts + i; if (ext->present) num++; } if (num == 0) { *out = NULL; *outlen = 0; return 1; } if ((present = OPENSSL_malloc(sizeof(*present) * num)) == NULL) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) { ext = sc->clienthello->pre_proc_exts + i; if (ext->present) { if (ext->received_order >= num) goto err; present[ext->received_order] = ext->type; } } *out = present; *outlen = num; return 1; err: OPENSSL_free(present); return 0; } int SSL_client_hello_get_extension_order(SSL *s, uint16_t *exts, size_t *num_exts) { RAW_EXTENSION *ext; size_t num = 0, i; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL || num_exts == NULL) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) { ext = sc->clienthello->pre_proc_exts + i; if (ext->present) num++; } if (num == 0) { *num_exts = 0; return 1; } if (exts == NULL) { *num_exts = num; return 1; } if (*num_exts < num) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; i++) { ext = sc->clienthello->pre_proc_exts + i; if (ext->present) { if (ext->received_order >= num) return 0; exts[ext->received_order] = ext->type; } } *num_exts = num; return 1; } int SSL_client_hello_get0_ext(SSL *s, unsigned int type, const unsigned char **out, size_t *outlen) { size_t i; RAW_EXTENSION *r; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (sc->clienthello == NULL) return 0; for (i = 0; i < sc->clienthello->pre_proc_exts_len; ++i) { r = sc->clienthello->pre_proc_exts + i; if (r->present && r->type == type) { if (out != NULL) *out = PACKET_data(&r->data); if (outlen != NULL) *outlen = PACKET_remaining(&r->data); return 1; } } return 0; } int SSL_free_buffers(SSL *ssl) { RECORD_LAYER *rl; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (sc == NULL) return 0; rl = &sc->rlayer; return rl->rrlmethod->free_buffers(rl->rrl) && rl->wrlmethod->free_buffers(rl->wrl); } int SSL_alloc_buffers(SSL *ssl) { RECORD_LAYER *rl; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); if (sc == NULL) return 0; /* QUIC always has buffers allocated. */ if (IS_QUIC(ssl)) return 1; rl = &sc->rlayer; return rl->rrlmethod->alloc_buffers(rl->rrl) && rl->wrlmethod->alloc_buffers(rl->wrl); } void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb) { ctx->keylog_callback = cb; } SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx) { return ctx->keylog_callback; } static int nss_keylog_int(const char *prefix, SSL_CONNECTION *sc, const uint8_t *parameter_1, size_t parameter_1_len, const uint8_t *parameter_2, size_t parameter_2_len) { char *out = NULL; char *cursor = NULL; size_t out_len = 0; size_t i; size_t prefix_len; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(sc); if (sctx->keylog_callback == NULL) return 1; /* * Our output buffer will contain the following strings, rendered with * space characters in between, terminated by a NULL character: first the * prefix, then the first parameter, then the second parameter. The * meaning of each parameter depends on the specific key material being * logged. Note that the first and second parameters are encoded in * hexadecimal, so we need a buffer that is twice their lengths. */ prefix_len = strlen(prefix); out_len = prefix_len + (2 * parameter_1_len) + (2 * parameter_2_len) + 3; if ((out = cursor = OPENSSL_malloc(out_len)) == NULL) return 0; strcpy(cursor, prefix); cursor += prefix_len; *cursor++ = ' '; for (i = 0; i < parameter_1_len; i++) { sprintf(cursor, "%02x", parameter_1[i]); cursor += 2; } *cursor++ = ' '; for (i = 0; i < parameter_2_len; i++) { sprintf(cursor, "%02x", parameter_2[i]); cursor += 2; } *cursor = '\0'; sctx->keylog_callback(SSL_CONNECTION_GET_SSL(sc), (const char *)out); OPENSSL_clear_free(out, out_len); return 1; } int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *sc, const uint8_t *encrypted_premaster, size_t encrypted_premaster_len, const uint8_t *premaster, size_t premaster_len) { if (encrypted_premaster_len < 8) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* We only want the first 8 bytes of the encrypted premaster as a tag. */ return nss_keylog_int("RSA", sc, encrypted_premaster, 8, premaster, premaster_len); } int ssl_log_secret(SSL_CONNECTION *sc, const char *label, const uint8_t *secret, size_t secret_len) { return nss_keylog_int(label, sc, sc->s3.client_random, SSL3_RANDOM_SIZE, secret, secret_len); } #define SSLV2_CIPHER_LEN 3 int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites, int sslv2format) { int n; n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN; if (PACKET_remaining(cipher_suites) == 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CIPHERS_SPECIFIED); return 0; } if (PACKET_remaining(cipher_suites) % n != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST); return 0; } OPENSSL_free(s->s3.tmp.ciphers_raw); s->s3.tmp.ciphers_raw = NULL; s->s3.tmp.ciphers_rawlen = 0; if (sslv2format) { size_t numciphers = PACKET_remaining(cipher_suites) / n; PACKET sslv2ciphers = *cipher_suites; unsigned int leadbyte; unsigned char *raw; /* * We store the raw ciphers list in SSLv3+ format so we need to do some * preprocessing to convert the list first. If there are any SSLv2 only * ciphersuites with a non-zero leading byte then we are going to * slightly over allocate because we won't store those. But that isn't a * problem. */ raw = OPENSSL_malloc(numciphers * TLS_CIPHER_LEN); s->s3.tmp.ciphers_raw = raw; if (raw == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } for (s->s3.tmp.ciphers_rawlen = 0; PACKET_remaining(&sslv2ciphers) > 0; raw += TLS_CIPHER_LEN) { if (!PACKET_get_1(&sslv2ciphers, &leadbyte) || (leadbyte == 0 && !PACKET_copy_bytes(&sslv2ciphers, raw, TLS_CIPHER_LEN)) || (leadbyte != 0 && !PACKET_forward(&sslv2ciphers, TLS_CIPHER_LEN))) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_PACKET); OPENSSL_free(s->s3.tmp.ciphers_raw); s->s3.tmp.ciphers_raw = NULL; s->s3.tmp.ciphers_rawlen = 0; return 0; } if (leadbyte == 0) s->s3.tmp.ciphers_rawlen += TLS_CIPHER_LEN; } } else if (!PACKET_memdup(cipher_suites, &s->s3.tmp.ciphers_raw, &s->s3.tmp.ciphers_rawlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len, int isv2format, STACK_OF(SSL_CIPHER) **sk, STACK_OF(SSL_CIPHER) **scsvs) { PACKET pkt; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (!PACKET_buf_init(&pkt, bytes, len)) return 0; return ossl_bytes_to_cipher_list(sc, &pkt, sk, scsvs, isv2format, 0); } int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites, STACK_OF(SSL_CIPHER) **skp, STACK_OF(SSL_CIPHER) **scsvs_out, int sslv2format, int fatal) { const SSL_CIPHER *c; STACK_OF(SSL_CIPHER) *sk = NULL; STACK_OF(SSL_CIPHER) *scsvs = NULL; int n; /* 3 = SSLV2_CIPHER_LEN > TLS_CIPHER_LEN = 2. */ unsigned char cipher[SSLV2_CIPHER_LEN]; n = sslv2format ? SSLV2_CIPHER_LEN : TLS_CIPHER_LEN; if (PACKET_remaining(cipher_suites) == 0) { if (fatal) SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CIPHERS_SPECIFIED); else ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHERS_SPECIFIED); return 0; } if (PACKET_remaining(cipher_suites) % n != 0) { if (fatal) SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST); else ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST); return 0; } sk = sk_SSL_CIPHER_new_null(); scsvs = sk_SSL_CIPHER_new_null(); if (sk == NULL || scsvs == NULL) { if (fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); else ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } while (PACKET_copy_bytes(cipher_suites, cipher, n)) { /* * SSLv3 ciphers wrapped in an SSLv2-compatible ClientHello have the * first byte set to zero, while true SSLv2 ciphers have a non-zero * first byte. We don't support any true SSLv2 ciphers, so skip them. */ if (sslv2format && cipher[0] != '\0') continue; /* For SSLv2-compat, ignore leading 0-byte. */ c = ssl_get_cipher_by_char(s, sslv2format ? &cipher[1] : cipher, 1); if (c != NULL) { if ((c->valid && !sk_SSL_CIPHER_push(sk, c)) || (!c->valid && !sk_SSL_CIPHER_push(scsvs, c))) { if (fatal) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); else ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } } } if (PACKET_remaining(cipher_suites) > 0) { if (fatal) SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); else ERR_raise(ERR_LIB_SSL, SSL_R_BAD_LENGTH); goto err; } if (skp != NULL) *skp = sk; else sk_SSL_CIPHER_free(sk); if (scsvs_out != NULL) *scsvs_out = scsvs; else sk_SSL_CIPHER_free(scsvs); return 1; err: sk_SSL_CIPHER_free(sk); sk_SSL_CIPHER_free(scsvs); return 0; } int SSL_CTX_set_max_early_data(SSL_CTX *ctx, uint32_t max_early_data) { ctx->max_early_data = max_early_data; return 1; } uint32_t SSL_CTX_get_max_early_data(const SSL_CTX *ctx) { return ctx->max_early_data; } int SSL_set_max_early_data(SSL *s, uint32_t max_early_data) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; sc->max_early_data = max_early_data; return 1; } uint32_t SSL_get_max_early_data(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->max_early_data; } int SSL_CTX_set_recv_max_early_data(SSL_CTX *ctx, uint32_t recv_max_early_data) { ctx->recv_max_early_data = recv_max_early_data; return 1; } uint32_t SSL_CTX_get_recv_max_early_data(const SSL_CTX *ctx) { return ctx->recv_max_early_data; } int SSL_set_recv_max_early_data(SSL *s, uint32_t recv_max_early_data) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; sc->recv_max_early_data = recv_max_early_data; return 1; } uint32_t SSL_get_recv_max_early_data(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->recv_max_early_data; } __owur unsigned int ssl_get_max_send_fragment(const SSL_CONNECTION *sc) { /* Return any active Max Fragment Len extension */ if (sc->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(sc->session)) return GET_MAX_FRAGMENT_LENGTH(sc->session); /* return current SSL connection setting */ return sc->max_send_fragment; } __owur unsigned int ssl_get_split_send_fragment(const SSL_CONNECTION *sc) { /* Return a value regarding an active Max Fragment Len extension */ if (sc->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(sc->session) && sc->split_send_fragment > GET_MAX_FRAGMENT_LENGTH(sc->session)) return GET_MAX_FRAGMENT_LENGTH(sc->session); /* else limit |split_send_fragment| to current |max_send_fragment| */ if (sc->split_send_fragment > sc->max_send_fragment) return sc->max_send_fragment; /* return current SSL connection setting */ return sc->split_send_fragment; } int SSL_stateless(SSL *s) { int ret; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; /* Ensure there is no state left over from a previous invocation */ if (!SSL_clear(s)) return 0; ERR_clear_error(); sc->s3.flags |= TLS1_FLAGS_STATELESS; ret = SSL_accept(s); sc->s3.flags &= ~TLS1_FLAGS_STATELESS; if (ret > 0 && sc->ext.cookieok) return 1; if (sc->hello_retry_request == SSL_HRR_PENDING && !ossl_statem_in_error(sc)) return 0; return -1; } void SSL_CTX_set_post_handshake_auth(SSL_CTX *ctx, int val) { ctx->pha_enabled = val; } void SSL_set_post_handshake_auth(SSL *ssl, int val) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (sc == NULL) return; sc->pha_enabled = val; } int SSL_verify_client_post_handshake(SSL *ssl) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(ssl)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } #endif if (sc == NULL) return 0; if (!SSL_CONNECTION_IS_TLS13(sc)) { ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_SSL_VERSION); return 0; } if (!sc->server) { ERR_raise(ERR_LIB_SSL, SSL_R_NOT_SERVER); return 0; } if (!SSL_is_init_finished(ssl)) { ERR_raise(ERR_LIB_SSL, SSL_R_STILL_IN_INIT); return 0; } switch (sc->post_handshake_auth) { case SSL_PHA_NONE: ERR_raise(ERR_LIB_SSL, SSL_R_EXTENSION_NOT_RECEIVED); return 0; default: case SSL_PHA_EXT_SENT: ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; case SSL_PHA_EXT_RECEIVED: break; case SSL_PHA_REQUEST_PENDING: ERR_raise(ERR_LIB_SSL, SSL_R_REQUEST_PENDING); return 0; case SSL_PHA_REQUESTED: ERR_raise(ERR_LIB_SSL, SSL_R_REQUEST_SENT); return 0; } sc->post_handshake_auth = SSL_PHA_REQUEST_PENDING; /* checks verify_mode and algorithm_auth */ if (!send_certificate_request(sc)) { sc->post_handshake_auth = SSL_PHA_EXT_RECEIVED; /* restore on error */ ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_CONFIG); return 0; } ossl_statem_set_in_init(sc, 1); return 1; } int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx, SSL_CTX_generate_session_ticket_fn gen_cb, SSL_CTX_decrypt_session_ticket_fn dec_cb, void *arg) { ctx->generate_ticket_cb = gen_cb; ctx->decrypt_ticket_cb = dec_cb; ctx->ticket_cb_data = arg; return 1; } void SSL_CTX_set_allow_early_data_cb(SSL_CTX *ctx, SSL_allow_early_data_cb_fn cb, void *arg) { ctx->allow_early_data_cb = cb; ctx->allow_early_data_cb_data = arg; } void SSL_set_allow_early_data_cb(SSL *s, SSL_allow_early_data_cb_fn cb, void *arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return; sc->allow_early_data_cb = cb; sc->allow_early_data_cb_data = arg; } const EVP_CIPHER *ssl_evp_cipher_fetch(OSSL_LIB_CTX *libctx, int nid, const char *properties) { const EVP_CIPHER *ciph; ciph = tls_get_cipher_from_engine(nid); if (ciph != NULL) return ciph; /* * If there is no engine cipher then we do an explicit fetch. This may fail * and that could be ok */ ERR_set_mark(); ciph = EVP_CIPHER_fetch(libctx, OBJ_nid2sn(nid), properties); ERR_pop_to_mark(); return ciph; } int ssl_evp_cipher_up_ref(const EVP_CIPHER *cipher) { /* Don't up-ref an implicit EVP_CIPHER */ if (EVP_CIPHER_get0_provider(cipher) == NULL) return 1; /* * The cipher was explicitly fetched and therefore it is safe to cast * away the const */ return EVP_CIPHER_up_ref((EVP_CIPHER *)cipher); } void ssl_evp_cipher_free(const EVP_CIPHER *cipher) { if (cipher == NULL) return; if (EVP_CIPHER_get0_provider(cipher) != NULL) { /* * The cipher was explicitly fetched and therefore it is safe to cast * away the const */ EVP_CIPHER_free((EVP_CIPHER *)cipher); } } const EVP_MD *ssl_evp_md_fetch(OSSL_LIB_CTX *libctx, int nid, const char *properties) { const EVP_MD *md; md = tls_get_digest_from_engine(nid); if (md != NULL) return md; /* Otherwise we do an explicit fetch */ ERR_set_mark(); md = EVP_MD_fetch(libctx, OBJ_nid2sn(nid), properties); ERR_pop_to_mark(); return md; } int ssl_evp_md_up_ref(const EVP_MD *md) { /* Don't up-ref an implicit EVP_MD */ if (EVP_MD_get0_provider(md) == NULL) return 1; /* * The digest was explicitly fetched and therefore it is safe to cast * away the const */ return EVP_MD_up_ref((EVP_MD *)md); } void ssl_evp_md_free(const EVP_MD *md) { if (md == NULL) return; if (EVP_MD_get0_provider(md) != NULL) { /* * The digest was explicitly fetched and therefore it is safe to cast * away the const */ EVP_MD_free((EVP_MD *)md); } } int SSL_set0_tmp_dh_pkey(SSL *s, EVP_PKEY *dhpkey) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (!ssl_security(sc, SSL_SECOP_TMP_DH, EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) { ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL); return 0; } EVP_PKEY_free(sc->cert->dh_tmp); sc->cert->dh_tmp = dhpkey; return 1; } int SSL_CTX_set0_tmp_dh_pkey(SSL_CTX *ctx, EVP_PKEY *dhpkey) { if (!ssl_ctx_security(ctx, SSL_SECOP_TMP_DH, EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) { ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL); return 0; } EVP_PKEY_free(ctx->cert->dh_tmp); ctx->cert->dh_tmp = dhpkey; return 1; } /* QUIC-specific methods which are supported on QUIC connections only. */ int SSL_handle_events(SSL *s) { SSL_CONNECTION *sc; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_handle_events(s); #endif sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc != NULL && SSL_CONNECTION_IS_DTLS(sc)) /* * DTLSv1_handle_timeout returns 0 if the timer wasn't expired yet, * which we consider a success case. Theoretically DTLSv1_handle_timeout * can also return 0 if s is NULL or not a DTLS object, but we've * already ruled out those possibilities above, so this is not possible * here. Thus the only failure cases are where DTLSv1_handle_timeout * returns -1. */ return DTLSv1_handle_timeout(s) >= 0; return 1; } int SSL_get_event_timeout(SSL *s, struct timeval *tv, int *is_infinite) { SSL_CONNECTION *sc; #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_event_timeout(s, tv, is_infinite); #endif sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc != NULL && SSL_CONNECTION_IS_DTLS(sc) && DTLSv1_get_timeout(s, tv)) { *is_infinite = 0; return 1; } tv->tv_sec = 1000000; tv->tv_usec = 0; *is_infinite = 1; return 1; } int SSL_get_rpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_rpoll_descriptor(s, desc); #endif if (sc == NULL || sc->rbio == NULL) return 0; return BIO_get_rpoll_descriptor(sc->rbio, desc); } int SSL_get_wpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); #ifndef OPENSSL_NO_QUIC if (IS_QUIC(s)) return ossl_quic_get_wpoll_descriptor(s, desc); #endif if (sc == NULL || sc->wbio == NULL) return 0; return BIO_get_wpoll_descriptor(sc->wbio, desc); } int SSL_net_read_desired(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_want_read(s); return ossl_quic_get_net_read_desired(s); #else return SSL_want_read(s); #endif } int SSL_net_write_desired(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_want_write(s); return ossl_quic_get_net_write_desired(s); #else return SSL_want_write(s); #endif } int SSL_set_blocking_mode(SSL *s, int blocking) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_conn_set_blocking_mode(s, blocking); #else return 0; #endif } int SSL_get_blocking_mode(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_conn_get_blocking_mode(s); #else return -1; #endif } int SSL_set1_initial_peer_addr(SSL *s, const BIO_ADDR *peer_addr) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_conn_set_initial_peer_addr(s, peer_addr); #else return 0; #endif } int SSL_shutdown_ex(SSL *ssl, uint64_t flags, const SSL_SHUTDOWN_EX_ARGS *args, size_t args_len) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(ssl)) return SSL_shutdown(ssl); return ossl_quic_conn_shutdown(ssl, flags, args, args_len); #else return SSL_shutdown(ssl); #endif } int SSL_stream_conclude(SSL *ssl, uint64_t flags) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(ssl)) return 0; return ossl_quic_conn_stream_conclude(ssl); #else return 0; #endif } SSL *SSL_new_stream(SSL *s, uint64_t flags) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return NULL; return ossl_quic_conn_stream_new(s, flags); #else return NULL; #endif } SSL *SSL_get0_connection(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return s; return ossl_quic_get0_connection(s); #else return s; #endif } int SSL_is_connection(SSL *s) { return SSL_get0_connection(s) == s; } int SSL_get_stream_type(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_STREAM_TYPE_BIDI; return ossl_quic_get_stream_type(s); #else return SSL_STREAM_TYPE_BIDI; #endif } uint64_t SSL_get_stream_id(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return UINT64_MAX; return ossl_quic_get_stream_id(s); #else return UINT64_MAX; #endif } int SSL_is_stream_local(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_is_stream_local(s); #else return -1; #endif } int SSL_set_default_stream_mode(SSL *s, uint32_t mode) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_set_default_stream_mode(s, mode); #else return 0; #endif } int SSL_set_incoming_stream_policy(SSL *s, int policy, uint64_t aec) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_set_incoming_stream_policy(s, policy, aec); #else return 0; #endif } SSL *SSL_accept_stream(SSL *s, uint64_t flags) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return NULL; return ossl_quic_accept_stream(s, flags); #else return NULL; #endif } size_t SSL_get_accept_stream_queue_len(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_get_accept_stream_queue_len(s); #else return 0; #endif } int SSL_stream_reset(SSL *s, const SSL_STREAM_RESET_ARGS *args, size_t args_len) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return 0; return ossl_quic_stream_reset(s, args, args_len); #else return 0; #endif } int SSL_get_stream_read_state(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_STREAM_STATE_NONE; return ossl_quic_get_stream_read_state(s); #else return SSL_STREAM_STATE_NONE; #endif } int SSL_get_stream_write_state(SSL *s) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return SSL_STREAM_STATE_NONE; return ossl_quic_get_stream_write_state(s); #else return SSL_STREAM_STATE_NONE; #endif } int SSL_get_stream_read_error_code(SSL *s, uint64_t *app_error_code) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_get_stream_read_error_code(s, app_error_code); #else return -1; #endif } int SSL_get_stream_write_error_code(SSL *s, uint64_t *app_error_code) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_get_stream_write_error_code(s, app_error_code); #else return -1; #endif } int SSL_get_conn_close_info(SSL *s, SSL_CONN_CLOSE_INFO *info, size_t info_len) { #ifndef OPENSSL_NO_QUIC if (!IS_QUIC(s)) return -1; return ossl_quic_get_conn_close_info(s, info, info_len); #else return -1; #endif } int SSL_add_expected_rpk(SSL *s, EVP_PKEY *rpk) { unsigned char *data = NULL; SSL_DANE *dane = SSL_get0_dane(s); int ret; if (dane == NULL || dane->dctx == NULL) return 0; if ((ret = i2d_PUBKEY(rpk, &data)) <= 0) return 0; ret = SSL_dane_tlsa_add(s, DANETLS_USAGE_DANE_EE, DANETLS_SELECTOR_SPKI, DANETLS_MATCHING_FULL, data, (size_t)ret) > 0; OPENSSL_free(data); return ret; } EVP_PKEY *SSL_get0_peer_rpk(const SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL || sc->session == NULL) return NULL; return sc->session->peer_rpk; } int SSL_get_negotiated_client_cert_type(const SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return sc->ext.client_cert_type; } int SSL_get_negotiated_server_cert_type(const SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; return sc->ext.server_cert_type; } static int validate_cert_type(const unsigned char *val, size_t len) { size_t i; int saw_rpk = 0; int saw_x509 = 0; if (val == NULL && len == 0) return 1; if (val == NULL || len == 0) return 0; for (i = 0; i < len; i++) { switch (val[i]) { case TLSEXT_cert_type_rpk: if (saw_rpk) return 0; saw_rpk = 1; break; case TLSEXT_cert_type_x509: if (saw_x509) return 0; saw_x509 = 1; break; case TLSEXT_cert_type_pgp: case TLSEXT_cert_type_1609dot2: default: return 0; } } return 1; } static int set_cert_type(unsigned char **cert_type, size_t *cert_type_len, const unsigned char *val, size_t len) { unsigned char *tmp = NULL; if (!validate_cert_type(val, len)) return 0; if (val != NULL && (tmp = OPENSSL_memdup(val, len)) == NULL) return 0; OPENSSL_free(*cert_type); *cert_type = tmp; *cert_type_len = len; return 1; } int SSL_set1_client_cert_type(SSL *s, const unsigned char *val, size_t len) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); return set_cert_type(&sc->client_cert_type, &sc->client_cert_type_len, val, len); } int SSL_set1_server_cert_type(SSL *s, const unsigned char *val, size_t len) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); return set_cert_type(&sc->server_cert_type, &sc->server_cert_type_len, val, len); } int SSL_CTX_set1_client_cert_type(SSL_CTX *ctx, const unsigned char *val, size_t len) { return set_cert_type(&ctx->client_cert_type, &ctx->client_cert_type_len, val, len); } int SSL_CTX_set1_server_cert_type(SSL_CTX *ctx, const unsigned char *val, size_t len) { return set_cert_type(&ctx->server_cert_type, &ctx->server_cert_type_len, val, len); } int SSL_get0_client_cert_type(const SSL *s, unsigned char **t, size_t *len) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (t == NULL || len == NULL) return 0; *t = sc->client_cert_type; *len = sc->client_cert_type_len; return 1; } int SSL_get0_server_cert_type(const SSL *s, unsigned char **t, size_t *len) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (t == NULL || len == NULL) return 0; *t = sc->server_cert_type; *len = sc->server_cert_type_len; return 1; } int SSL_CTX_get0_client_cert_type(const SSL_CTX *ctx, unsigned char **t, size_t *len) { if (t == NULL || len == NULL) return 0; *t = ctx->client_cert_type; *len = ctx->client_cert_type_len; return 1; } int SSL_CTX_get0_server_cert_type(const SSL_CTX *ctx, unsigned char **t, size_t *len) { if (t == NULL || len == NULL) return 0; *t = ctx->server_cert_type; *len = ctx->server_cert_type_len; return 1; }

./openssl/ssl/event_queue.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdlib.h> #include "internal/event_queue.h" #include "ssl_local.h" struct ossl_event_queue_st { PRIORITY_QUEUE_OF(OSSL_EVENT) *timed_events; PRIORITY_QUEUE_OF(OSSL_EVENT) *now_events; }; static int event_compare_times(const OSSL_EVENT *a, const OSSL_EVENT *b) { return ossl_time_compare(a->when, b->when); } static int event_compare_priority(const OSSL_EVENT *a, const OSSL_EVENT *b) { if (a->priority > b->priority) return -1; if (a->priority < b->priority) return 1; return 0; } OSSL_EVENT_QUEUE *ossl_event_queue_new(void) { OSSL_EVENT_QUEUE *r = OPENSSL_malloc(sizeof(*r)); if (r != NULL) { r->timed_events = ossl_pqueue_OSSL_EVENT_new(&event_compare_times); r->now_events = ossl_pqueue_OSSL_EVENT_new(&event_compare_priority); if (r->timed_events == NULL || r->now_events == NULL) { ossl_event_queue_free(r); return NULL; } } return r; } void ossl_event_free(OSSL_EVENT *event) { if (event != NULL) { if (event->flag_dynamic) OPENSSL_free(event); else event->queue = NULL; } } static void event_queue_free(PRIORITY_QUEUE_OF(OSSL_EVENT) *queue) { OSSL_EVENT *e; if (queue != NULL) { while ((e = ossl_pqueue_OSSL_EVENT_pop(queue)) != NULL) ossl_event_free(e); ossl_pqueue_OSSL_EVENT_free(queue); } } void ossl_event_queue_free(OSSL_EVENT_QUEUE *queue) { if (queue != NULL) { event_queue_free(queue->now_events); event_queue_free(queue->timed_events); OPENSSL_free(queue); } } static ossl_inline int event_queue_add(OSSL_EVENT_QUEUE *queue, OSSL_EVENT *event) { PRIORITY_QUEUE_OF(OSSL_EVENT) *pq = ossl_time_compare(event->when, ossl_time_now()) <= 0 ? queue->now_events : queue->timed_events; if (ossl_pqueue_OSSL_EVENT_push(pq, event, &event->ref)) { event->queue = pq; return 1; } return 0; } static ossl_inline void ossl_event_set(OSSL_EVENT *event, uint32_t type, uint32_t priority, OSSL_TIME when, void *ctx, void *payload, size_t payload_size) { event->type = type; event->priority = priority; event->when = when; event->ctx = ctx; event->payload = payload; event->payload_size = payload_size; } OSSL_EVENT *ossl_event_queue_add_new(OSSL_EVENT_QUEUE *queue, uint32_t type, uint32_t priority, OSSL_TIME when, void *ctx, void *payload, size_t payload_size) { OSSL_EVENT *e = OPENSSL_malloc(sizeof(*e)); if (e == NULL || queue == NULL) { OPENSSL_free(e); return NULL; } ossl_event_set(e, type, priority, when, ctx, payload, payload_size); e->flag_dynamic = 1; if (event_queue_add(queue, e)) return e; OPENSSL_free(e); return NULL; } int ossl_event_queue_add(OSSL_EVENT_QUEUE *queue, OSSL_EVENT *event, uint32_t type, uint32_t priority, OSSL_TIME when, void *ctx, void *payload, size_t payload_size) { if (event == NULL || queue == NULL) return 0; ossl_event_set(event, type, priority, when, ctx, payload, payload_size); event->flag_dynamic = 0; return event_queue_add(queue, event); } int ossl_event_queue_remove(OSSL_EVENT_QUEUE *queue, OSSL_EVENT *event) { if (event != NULL && event->queue != NULL) { ossl_pqueue_OSSL_EVENT_remove(event->queue, event->ref); event->queue = NULL; } return 1; } OSSL_TIME ossl_event_time_until(const OSSL_EVENT *event) { if (event == NULL) return ossl_time_infinite(); return ossl_time_subtract(event->when, ossl_time_now()); } OSSL_TIME ossl_event_queue_time_until_next(const OSSL_EVENT_QUEUE *queue) { if (queue == NULL) return ossl_time_infinite(); if (ossl_pqueue_OSSL_EVENT_num(queue->now_events) > 0) return ossl_time_zero(); return ossl_event_time_until(ossl_pqueue_OSSL_EVENT_peek(queue->timed_events)); } int ossl_event_queue_postpone_until(OSSL_EVENT_QUEUE *queue, OSSL_EVENT *event, OSSL_TIME when) { if (ossl_event_queue_remove(queue, event)) { event->when = when; return event_queue_add(queue, event); } return 0; } int ossl_event_queue_get1_next_event(OSSL_EVENT_QUEUE *queue, OSSL_EVENT **event) { OSSL_TIME now = ossl_time_now(); OSSL_EVENT *e; /* Check for expired timer based events and convert them to now events */ while ((e = ossl_pqueue_OSSL_EVENT_peek(queue->timed_events)) != NULL && ossl_time_compare(e->when, now) <= 0) { e = ossl_pqueue_OSSL_EVENT_pop(queue->timed_events); if (!ossl_pqueue_OSSL_EVENT_push(queue->now_events, e, &e->ref)) { e->queue = NULL; return 0; } } /* * Get next event from the now queue. * The pop returns NULL when there is none. */ *event = ossl_pqueue_OSSL_EVENT_pop(queue->now_events); return 1; }

./openssl/ssl/priority_queue.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/crypto.h> #include <openssl/err.h> #include <assert.h> #include "internal/priority_queue.h" #include "internal/safe_math.h" #include "internal/numbers.h" OSSL_SAFE_MATH_UNSIGNED(size_t, size_t) /* * Fundamental operations: * Binary Heap Fibonacci Heap * Get smallest O(1) O(1) * Delete any O(log n) O(log n) average but worst O(n) * Insert O(log n) O(1) * * Not supported: * Merge two structures O(log n) O(1) * Decrease key O(log n) O(1) * Increase key O(log n) ? * * The Fibonacci heap is quite a bit more complicated to implement and has * larger overhead in practice. We favour the binary heap here. A multi-way * (ternary or quaternary) heap might elicit a performance advantage via better * cache access patterns. */ struct pq_heap_st { void *data; /* User supplied data pointer */ size_t index; /* Constant index in elements[] */ }; struct pq_elem_st { size_t posn; /* Current index in heap[] or link in free list */ #ifndef NDEBUG int used; /* Debug flag indicating that this is in use */ #endif }; struct ossl_pqueue_st { struct pq_heap_st *heap; struct pq_elem_st *elements; int (*compare)(const void *, const void *); size_t htop; /* Highest used heap element */ size_t hmax; /* Allocated heap & element space */ size_t freelist; /* Index into elements[], start of free element list */ }; /* * The initial and maximum number of elements in the heap. */ static const size_t min_nodes = 8; static const size_t max_nodes = SIZE_MAX / (sizeof(struct pq_heap_st) > sizeof(struct pq_elem_st) ? sizeof(struct pq_heap_st) : sizeof(struct pq_elem_st)); #ifndef NDEBUG /* Some basic sanity checking of the data structure */ # define ASSERT_USED(pq, idx) \ assert(pq->elements[pq->heap[idx].index].used); \ assert(pq->elements[pq->heap[idx].index].posn == idx) # define ASSERT_ELEM_USED(pq, elem) \ assert(pq->elements[elem].used) #else # define ASSERT_USED(pq, idx) # define ASSERT_ELEM_USED(pq, elem) #endif /* * Calculate the array growth based on the target size. * * The growth factor is a rational number and is defined by a numerator * and a denominator. According to Andrew Koenig in his paper "Why Are * Vectors Efficient?" from JOOP 11(5) 1998, this factor should be less * than the golden ratio (1.618...). * * We use an expansion factor of 8 / 5 = 1.6 */ static ossl_inline size_t compute_pqueue_growth(size_t target, size_t current) { int err = 0; while (current < target) { if (current >= max_nodes) return 0; current = safe_muldiv_size_t(current, 8, 5, &err); if (err) return 0; if (current >= max_nodes) current = max_nodes; } return current; } static ossl_inline void pqueue_swap_elem(OSSL_PQUEUE *pq, size_t i, size_t j) { struct pq_heap_st *h = pq->heap, t_h; struct pq_elem_st *e = pq->elements; ASSERT_USED(pq, i); ASSERT_USED(pq, j); t_h = h[i]; h[i] = h[j]; h[j] = t_h; e[h[i].index].posn = i; e[h[j].index].posn = j; } static ossl_inline void pqueue_move_elem(OSSL_PQUEUE *pq, size_t from, size_t to) { struct pq_heap_st *h = pq->heap; struct pq_elem_st *e = pq->elements; ASSERT_USED(pq, from); h[to] = h[from]; e[h[to].index].posn = to; } /* * Force the specified element to the front of the heap. This breaks * the heap partial ordering pre-condition. */ static ossl_inline void pqueue_force_bottom(OSSL_PQUEUE *pq, size_t n) { ASSERT_USED(pq, n); while (n > 0) { const size_t p = (n - 1) / 2; ASSERT_USED(pq, p); pqueue_swap_elem(pq, n, p); n = p; } } /* * Move an element down to its correct position to restore the partial * order pre-condition. */ static ossl_inline void pqueue_move_down(OSSL_PQUEUE *pq, size_t n) { struct pq_heap_st *h = pq->heap; ASSERT_USED(pq, n); while (n > 0) { const size_t p = (n - 1) / 2; ASSERT_USED(pq, p); if (pq->compare(h[n].data, h[p].data) >= 0) break; pqueue_swap_elem(pq, n, p); n = p; } } /* * Move an element up to its correct position to restore the partial * order pre-condition. */ static ossl_inline void pqueue_move_up(OSSL_PQUEUE *pq, size_t n) { struct pq_heap_st *h = pq->heap; size_t p = n * 2 + 1; ASSERT_USED(pq, n); if (pq->htop > p + 1) { ASSERT_USED(pq, p); ASSERT_USED(pq, p + 1); if (pq->compare(h[p].data, h[p + 1].data) > 0) p++; } while (pq->htop > p && pq->compare(h[p].data, h[n].data) < 0) { ASSERT_USED(pq, p); pqueue_swap_elem(pq, n, p); n = p; p = n * 2 + 1; if (pq->htop > p + 1) { ASSERT_USED(pq, p + 1); if (pq->compare(h[p].data, h[p + 1].data) > 0) p++; } } } int ossl_pqueue_push(OSSL_PQUEUE *pq, void *data, size_t *elem) { size_t n, m; if (!ossl_pqueue_reserve(pq, 1)) return 0; n = pq->htop++; m = pq->freelist; pq->freelist = pq->elements[m].posn; pq->heap[n].data = data; pq->heap[n].index = m; pq->elements[m].posn = n; #ifndef NDEBUG pq->elements[m].used = 1; #endif pqueue_move_down(pq, n); if (elem != NULL) *elem = m; return 1; } void *ossl_pqueue_peek(const OSSL_PQUEUE *pq) { if (pq->htop > 0) { ASSERT_USED(pq, 0); return pq->heap->data; } return NULL; } void *ossl_pqueue_pop(OSSL_PQUEUE *pq) { void *res; size_t elem; if (pq == NULL || pq->htop == 0) return NULL; ASSERT_USED(pq, 0); res = pq->heap->data; elem = pq->heap->index; if (--pq->htop != 0) { pqueue_move_elem(pq, pq->htop, 0); pqueue_move_up(pq, 0); } pq->elements[elem].posn = pq->freelist; pq->freelist = elem; #ifndef NDEBUG pq->elements[elem].used = 0; #endif return res; } void *ossl_pqueue_remove(OSSL_PQUEUE *pq, size_t elem) { size_t n; if (pq == NULL || elem >= pq->hmax || pq->htop == 0) return 0; ASSERT_ELEM_USED(pq, elem); n = pq->elements[elem].posn; ASSERT_USED(pq, n); if (n == pq->htop - 1) { pq->elements[elem].posn = pq->freelist; pq->freelist = elem; #ifndef NDEBUG pq->elements[elem].used = 0; #endif return pq->heap[--pq->htop].data; } if (n > 0) pqueue_force_bottom(pq, n); return ossl_pqueue_pop(pq); } static void pqueue_add_freelist(OSSL_PQUEUE *pq, size_t from) { struct pq_elem_st *e = pq->elements; size_t i; #ifndef NDEBUG for (i = from; i < pq->hmax; i++) e[i].used = 0; #endif e[from].posn = pq->freelist; for (i = from + 1; i < pq->hmax; i++) e[i].posn = i - 1; pq->freelist = pq->hmax - 1; } int ossl_pqueue_reserve(OSSL_PQUEUE *pq, size_t n) { size_t new_max, cur_max; struct pq_heap_st *h; struct pq_elem_st *e; if (pq == NULL) return 0; cur_max = pq->hmax; if (pq->htop + n < cur_max) return 1; new_max = compute_pqueue_growth(n + cur_max, cur_max); if (new_max == 0) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } h = OPENSSL_realloc(pq->heap, new_max * sizeof(*pq->heap)); if (h == NULL) return 0; pq->heap = h; e = OPENSSL_realloc(pq->elements, new_max * sizeof(*pq->elements)); if (e == NULL) return 0; pq->elements = e; pq->hmax = new_max; pqueue_add_freelist(pq, cur_max); return 1; } OSSL_PQUEUE *ossl_pqueue_new(int (*compare)(const void *, const void *)) { OSSL_PQUEUE *pq; if (compare == NULL) return NULL; pq = OPENSSL_malloc(sizeof(*pq)); if (pq == NULL) return NULL; pq->compare = compare; pq->hmax = min_nodes; pq->htop = 0; pq->freelist = 0; pq->heap = OPENSSL_malloc(sizeof(*pq->heap) * min_nodes); pq->elements = OPENSSL_malloc(sizeof(*pq->elements) * min_nodes); if (pq->heap == NULL || pq->elements == NULL) { ossl_pqueue_free(pq); return NULL; } pqueue_add_freelist(pq, 0); return pq; } void ossl_pqueue_free(OSSL_PQUEUE *pq) { if (pq != NULL) { OPENSSL_free(pq->heap); OPENSSL_free(pq->elements); OPENSSL_free(pq); } } void ossl_pqueue_pop_free(OSSL_PQUEUE *pq, void (*freefunc)(void *)) { size_t i; if (pq != NULL) { for (i = 0; i < pq->htop; i++) (*freefunc)(pq->heap[i].data); ossl_pqueue_free(pq); } } size_t ossl_pqueue_num(const OSSL_PQUEUE *pq) { return pq != NULL ? pq->htop : 0; }

./openssl/ssl/pqueue.c

/* * Copyright 2005-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "ssl_local.h" #include <openssl/bn.h> struct pqueue_st { pitem *items; int count; }; pitem *pitem_new(unsigned char *prio64be, void *data) { pitem *item = OPENSSL_malloc(sizeof(*item)); if (item == NULL) return NULL; memcpy(item->priority, prio64be, sizeof(item->priority)); item->data = data; item->next = NULL; return item; } void pitem_free(pitem *item) { OPENSSL_free(item); } pqueue *pqueue_new(void) { pqueue *pq = OPENSSL_zalloc(sizeof(*pq)); return pq; } void pqueue_free(pqueue *pq) { OPENSSL_free(pq); } pitem *pqueue_insert(pqueue *pq, pitem *item) { pitem *curr, *next; if (pq->items == NULL) { pq->items = item; return item; } for (curr = NULL, next = pq->items; next != NULL; curr = next, next = next->next) { /* * we can compare 64-bit value in big-endian encoding with memcmp:-) */ int cmp = memcmp(next->priority, item->priority, 8); if (cmp > 0) { /* next > item */ item->next = next; if (curr == NULL) pq->items = item; else curr->next = item; return item; } else if (cmp == 0) /* duplicates not allowed */ return NULL; } item->next = NULL; curr->next = item; return item; } pitem *pqueue_peek(pqueue *pq) { return pq->items; } pitem *pqueue_pop(pqueue *pq) { pitem *item = pq->items; if (pq->items != NULL) pq->items = pq->items->next; return item; } pitem *pqueue_find(pqueue *pq, unsigned char *prio64be) { pitem *next; pitem *found = NULL; if (pq->items == NULL) return NULL; for (next = pq->items; next->next != NULL; next = next->next) { if (memcmp(next->priority, prio64be, 8) == 0) { found = next; break; } } /* check the one last node */ if (memcmp(next->priority, prio64be, 8) == 0) found = next; if (!found) return NULL; return found; } pitem *pqueue_iterator(pqueue *pq) { return pqueue_peek(pq); } pitem *pqueue_next(piterator *item) { pitem *ret; if (item == NULL || *item == NULL) return NULL; /* *item != NULL */ ret = *item; *item = (*item)->next; return ret; } size_t pqueue_size(pqueue *pq) { pitem *item = pq->items; size_t count = 0; while (item != NULL) { count++; item = item->next; } return count; }

./openssl/ssl/ssl_mcnf.c

/* * Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <openssl/conf.h> #include <openssl/ssl.h> #include "ssl_local.h" #include "internal/sslconf.h" /* SSL library configuration module. */ void SSL_add_ssl_module(void) { /* Do nothing. This will be added automatically by libcrypto */ } static int ssl_do_config(SSL *s, SSL_CTX *ctx, const char *name, int system) { SSL_CONF_CTX *cctx = NULL; size_t i, idx, cmd_count; int err = 1; unsigned int flags; const SSL_METHOD *meth; const SSL_CONF_CMD *cmds; OSSL_LIB_CTX *prev_libctx = NULL; OSSL_LIB_CTX *libctx = NULL; if (s == NULL && ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); goto err; } if (name == NULL && system) name = "system_default"; if (!conf_ssl_name_find(name, &idx)) { if (!system) ERR_raise_data(ERR_LIB_SSL, SSL_R_INVALID_CONFIGURATION_NAME, "name=%s", name); goto err; } cmds = conf_ssl_get(idx, &name, &cmd_count); cctx = SSL_CONF_CTX_new(); if (cctx == NULL) goto err; flags = SSL_CONF_FLAG_FILE; if (!system) flags |= SSL_CONF_FLAG_CERTIFICATE | SSL_CONF_FLAG_REQUIRE_PRIVATE; if (s != NULL) { meth = s->method; SSL_CONF_CTX_set_ssl(cctx, s); libctx = s->ctx->libctx; } else { meth = ctx->method; SSL_CONF_CTX_set_ssl_ctx(cctx, ctx); libctx = ctx->libctx; } if (meth->ssl_accept != ssl_undefined_function) flags |= SSL_CONF_FLAG_SERVER; if (meth->ssl_connect != ssl_undefined_function) flags |= SSL_CONF_FLAG_CLIENT; SSL_CONF_CTX_set_flags(cctx, flags); prev_libctx = OSSL_LIB_CTX_set0_default(libctx); err = 0; for (i = 0; i < cmd_count; i++) { char *cmdstr, *arg; int rv; conf_ssl_get_cmd(cmds, i, &cmdstr, &arg); rv = SSL_CONF_cmd(cctx, cmdstr, arg); if (rv <= 0) ++err; } if (!SSL_CONF_CTX_finish(cctx)) ++err; err: OSSL_LIB_CTX_set0_default(prev_libctx); SSL_CONF_CTX_free(cctx); return err == 0; } int SSL_config(SSL *s, const char *name) { return ssl_do_config(s, NULL, name, 0); } int SSL_CTX_config(SSL_CTX *ctx, const char *name) { return ssl_do_config(NULL, ctx, name, 0); } void ssl_ctx_system_config(SSL_CTX *ctx) { ssl_do_config(NULL, ctx, NULL, 1); }

./openssl/ssl/d1_msg.c

/* * Copyright 2005-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "ssl_local.h" int dtls1_write_app_data_bytes(SSL *s, uint8_t type, const void *buf_, size_t len, size_t *written) { int i; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return -1; if (SSL_in_init(s) && !ossl_statem_get_in_handshake(sc)) { i = sc->handshake_func(s); if (i < 0) return i; if (i == 0) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL_HANDSHAKE_FAILURE); return -1; } } if (len > SSL3_RT_MAX_PLAIN_LENGTH) { ERR_raise(ERR_LIB_SSL, SSL_R_DTLS_MESSAGE_TOO_BIG); return -1; } return dtls1_write_bytes(sc, type, buf_, len, written); } int dtls1_dispatch_alert(SSL *ssl) { int i, j; void (*cb) (const SSL *ssl, int type, int val) = NULL; unsigned char buf[DTLS1_AL_HEADER_LENGTH]; unsigned char *ptr = &buf[0]; size_t written; SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); if (s == NULL) return 0; s->s3.alert_dispatch = SSL_ALERT_DISPATCH_NONE; memset(buf, 0, sizeof(buf)); *ptr++ = s->s3.send_alert[0]; *ptr++ = s->s3.send_alert[1]; i = do_dtls1_write(s, SSL3_RT_ALERT, &buf[0], sizeof(buf), &written); if (i <= 0) { s->s3.alert_dispatch = 1; /* fprintf(stderr, "not done with alert\n"); */ } else { (void)BIO_flush(s->wbio); if (s->msg_callback) s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3.send_alert, 2, ssl, s->msg_callback_arg); if (s->info_callback != NULL) cb = s->info_callback; else if (ssl->ctx->info_callback != NULL) cb = ssl->ctx->info_callback; if (cb != NULL) { j = (s->s3.send_alert[0] << 8) | s->s3.send_alert[1]; cb(ssl, SSL_CB_WRITE_ALERT, j); } } return i; }

./openssl/ssl/ssl_err.c

/* * Generated by util/mkerr.pl DO NOT EDIT * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/err.h> #include <openssl/sslerr.h> #include "sslerr.h" #ifndef OPENSSL_NO_ERR static const ERR_STRING_DATA SSL_str_reasons[] = { {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY), "application data after close notify"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_APP_DATA_IN_HANDSHAKE), "app data in handshake"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT), "attempt to reuse session in different context"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE), "at least (D)TLS 1.2 needed in Suite B mode"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CERTIFICATE), "bad certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CHANGE_CIPHER_SPEC), "bad change cipher spec"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_CIPHER), "bad cipher"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_COMPRESSION_ALGORITHM), "bad compression algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DATA), "bad data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DATA_RETURNED_BY_CALLBACK), "bad data returned by callback"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DECOMPRESSION), "bad decompression"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DH_VALUE), "bad dh value"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_DIGEST_LENGTH), "bad digest length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_EARLY_DATA), "bad early data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_ECC_CERT), "bad ecc cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_ECPOINT), "bad ecpoint"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_EXTENSION), "bad extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HANDSHAKE_LENGTH), "bad handshake length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HANDSHAKE_STATE), "bad handshake state"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HELLO_REQUEST), "bad hello request"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_HRR_VERSION), "bad hrr version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_KEY_SHARE), "bad key share"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_KEY_UPDATE), "bad key update"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_LEGACY_VERSION), "bad legacy version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_LENGTH), "bad length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PACKET), "bad packet"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PACKET_LENGTH), "bad packet length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PROTOCOL_VERSION_NUMBER), "bad protocol version number"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PSK), "bad psk"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_PSK_IDENTITY), "bad psk identity"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_RECORD_TYPE), "bad record type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_RSA_ENCRYPT), "bad rsa encrypt"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SIGNATURE), "bad signature"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRP_A_LENGTH), "bad srp a length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRP_PARAMETERS), "bad srp parameters"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRTP_MKI_VALUE), "bad srtp mki value"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST), "bad srtp protection profile list"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_SSL_FILETYPE), "bad ssl filetype"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_VALUE), "bad value"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BAD_WRITE_RETRY), "bad write retry"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BINDER_DOES_NOT_VERIFY), "binder does not verify"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BIO_NOT_SET), "bio not set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BLOCK_CIPHER_PAD_IS_WRONG), "block cipher pad is wrong"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_BN_LIB), "bn lib"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CALLBACK_FAILED), "callback failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CANNOT_CHANGE_CIPHER), "cannot change cipher"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CANNOT_GET_GROUP_NAME), "cannot get group name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_DN_LENGTH_MISMATCH), "ca dn length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_KEY_TOO_SMALL), "ca key too small"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CA_MD_TOO_WEAK), "ca md too weak"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CCS_RECEIVED_EARLY), "ccs received early"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERTIFICATE_VERIFY_FAILED), "certificate verify failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERT_CB_ERROR), "cert cb error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CERT_LENGTH_MISMATCH), "cert length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED), "ciphersuite digest has changed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CIPHER_CODE_WRONG_LENGTH), "cipher code wrong length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CLIENTHELLO_TLSEXT), "clienthello tlsext"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSED_LENGTH_TOO_LONG), "compressed length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_DISABLED), "compression disabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_FAILURE), "compression failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE), "compression id not within private range"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COMPRESSION_LIBRARY_ERROR), "compression library error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONNECTION_TYPE_NOT_SET), "connection type not set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONN_USE_ONLY), "conn use only"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CONTEXT_NOT_DANE_ENABLED), "context not dane enabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COOKIE_GEN_CALLBACK_FAILURE), "cookie gen callback failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COOKIE_MISMATCH), "cookie mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_COPY_PARAMETERS_FAILED), "copy parameters failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED), "custom ext handler already installed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_ALREADY_ENABLED), "dane already enabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_CANNOT_OVERRIDE_MTYPE_FULL), "dane cannot override mtype full"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_NOT_ENABLED), "dane not enabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_CERTIFICATE), "dane tlsa bad certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_CERTIFICATE_USAGE), "dane tlsa bad certificate usage"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_DATA_LENGTH), "dane tlsa bad data length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_DIGEST_LENGTH), "dane tlsa bad digest length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_MATCHING_TYPE), "dane tlsa bad matching type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY), "dane tlsa bad public key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_BAD_SELECTOR), "dane tlsa bad selector"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DANE_TLSA_NULL_DATA), "dane tlsa null data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED), "data between ccs and finished"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DATA_LENGTH_TOO_LONG), "data length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DECRYPTION_FAILED), "decryption failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC), "decryption failed or bad record mac"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DH_KEY_TOO_SMALL), "dh key too small"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG), "dh public value length is wrong"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DIGEST_CHECK_FAILED), "digest check failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DTLS_MESSAGE_TOO_BIG), "dtls message too big"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_DUPLICATE_COMPRESSION_ID), "duplicate compression id"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ECC_CERT_NOT_FOR_SIGNING), "ecc cert not for signing"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ECDH_REQUIRED_FOR_SUITEB_MODE), "ecdh required for suiteb mode"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EE_KEY_TOO_SMALL), "ee key too small"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EMPTY_RAW_PUBLIC_KEY), "empty raw public key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EMPTY_SRTP_PROTECTION_PROFILE_LIST), "empty srtp protection profile list"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ENCRYPTED_LENGTH_TOO_LONG), "encrypted length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST), "error in received cipher list"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN), "error setting tlsa base domain"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE), "exceeds max fragment size"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXCESSIVE_MESSAGE_SIZE), "excessive message size"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXTENSION_NOT_RECEIVED), "extension not received"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXTRA_DATA_IN_MESSAGE), "extra data in message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_EXT_LENGTH_MISMATCH), "ext length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FAILED_TO_GET_PARAMETER), "failed to get parameter"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FAILED_TO_INIT_ASYNC), "failed to init async"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_FRAGMENTED_CLIENT_HELLO), "fragmented client hello"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_GOT_A_FIN_BEFORE_A_CCS), "got a fin before a ccs"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_HTTPS_PROXY_REQUEST), "https proxy request"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_HTTP_REQUEST), "http request"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ILLEGAL_POINT_COMPRESSION), "illegal point compression"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_ILLEGAL_SUITEB_DIGEST), "illegal Suite B digest"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INAPPROPRIATE_FALLBACK), "inappropriate fallback"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_COMPRESSION), "inconsistent compression"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EARLY_DATA_ALPN), "inconsistent early data alpn"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EARLY_DATA_SNI), "inconsistent early data sni"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INCONSISTENT_EXTMS), "inconsistent extms"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INSUFFICIENT_SECURITY), "insufficient security"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_ALERT), "invalid alert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CCS_MESSAGE), "invalid ccs message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CERTIFICATE_OR_ALG), "invalid certificate or alg"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_COMMAND), "invalid command"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_COMPRESSION_ALGORITHM), "invalid compression algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONFIG), "invalid config"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONFIGURATION_NAME), "invalid configuration name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CONTEXT), "invalid context"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_CT_VALIDATION_TYPE), "invalid ct validation type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_KEY_UPDATE_TYPE), "invalid key update type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_MAX_EARLY_DATA), "invalid max early data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_NULL_CMD_NAME), "invalid null cmd name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_RAW_PUBLIC_KEY), "invalid raw public key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_RECORD), "invalid record"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SEQUENCE_NUMBER), "invalid sequence number"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SERVERINFO_DATA), "invalid serverinfo data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SESSION_ID), "invalid session id"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_SRP_USERNAME), "invalid srp username"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_STATUS_RESPONSE), "invalid status response"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_INVALID_TICKET_KEYS_LENGTH), "invalid ticket keys length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED), "legacy sigalg disallowed or unsupported"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_MISMATCH), "length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_TOO_LONG), "length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LENGTH_TOO_SHORT), "length too short"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LIBRARY_BUG), "library bug"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_LIBRARY_HAS_NO_CIPHERS), "library has no ciphers"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MAXIMUM_ENCRYPTED_PKTS_REACHED), "maximum encrypted pkts reached"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_DSA_SIGNING_CERT), "missing dsa signing cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_ECDSA_SIGNING_CERT), "missing ecdsa signing cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_FATAL), "missing fatal"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_PARAMETERS), "missing parameters"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_PSK_KEX_MODES_EXTENSION), "missing psk kex modes extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_CERTIFICATE), "missing rsa certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_ENCRYPTING_CERT), "missing rsa encrypting cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_RSA_SIGNING_CERT), "missing rsa signing cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SIGALGS_EXTENSION), "missing sigalgs extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SIGNING_CERT), "missing signing cert"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SRP_PARAM), "can't find SRP server param"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION), "missing supported groups extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_TMP_DH_KEY), "missing tmp dh key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MISSING_TMP_ECDH_KEY), "missing tmp ecdh key"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA), "mixed handshake and non handshake data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_ON_RECORD_BOUNDARY), "not on record boundary"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_REPLACING_CERTIFICATE), "not replacing certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NOT_SERVER), "not server"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_APPLICATION_PROTOCOL), "no application protocol"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATES_RETURNED), "no certificates returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATE_ASSIGNED), "no certificate assigned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CERTIFICATE_SET), "no certificate set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CHANGE_FOLLOWING_HRR), "no change following hrr"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHERS_AVAILABLE), "no ciphers available"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHERS_SPECIFIED), "no ciphers specified"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CIPHER_MATCH), "no cipher match"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_CLIENT_CERT_METHOD), "no client cert method"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_COMPRESSION_SPECIFIED), "no compression specified"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_COOKIE_CALLBACK_SET), "no cookie callback set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER), "Peer haven't sent GOST certificate, required for selected ciphersuite"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_METHOD_SPECIFIED), "no method specified"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PEM_EXTENSIONS), "no pem extensions"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PRIVATE_KEY_ASSIGNED), "no private key assigned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_PROTOCOLS_AVAILABLE), "no protocols available"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_RENEGOTIATION), "no renegotiation"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_REQUIRED_DIGEST), "no required digest"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_CIPHER), "no shared cipher"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_GROUPS), "no shared groups"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS), "no shared signature algorithms"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SRTP_PROFILES), "no srtp profiles"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_STREAM), "no stream"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM), "no suitable digest algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_GROUPS), "no suitable groups"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_KEY_SHARE), "no suitable key share"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_RECORD_LAYER), "no suitable record layer"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM), "no suitable signature algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_VALID_SCTS), "no valid scts"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NO_VERIFY_COOKIE_CALLBACK), "no verify cookie callback"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NULL_SSL_CTX), "null ssl ctx"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_NULL_SSL_METHOD_PASSED), "null ssl method passed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OCSP_CALLBACK_FAILURE), "ocsp callback failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED), "old session cipher not returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED), "old session compression algorithm not returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_OVERFLOW_ERROR), "overflow error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PACKET_LENGTH_TOO_LONG), "packet length too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PARSE_TLSEXT), "parse tlsext"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PATH_TOO_LONG), "path too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE), "peer did not return a certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEM_NAME_BAD_PREFIX), "pem name bad prefix"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PEM_NAME_TOO_SHORT), "pem name too short"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PIPELINE_FAILURE), "pipeline failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR), "post handshake auth encoding err"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PRIVATE_KEY_MISMATCH), "private key mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PROTOCOL_IS_SHUTDOWN), "protocol is shutdown"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_IDENTITY_NOT_FOUND), "psk identity not found"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_NO_CLIENT_CB), "psk no client cb"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_PSK_NO_SERVER_CB), "psk no server cb"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_HANDSHAKE_LAYER_ERROR), "quic handshake layer error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_NETWORK_ERROR), "quic network error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_QUIC_PROTOCOL_ERROR), "quic protocol error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_READ_BIO_NOT_SET), "read bio not set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_READ_TIMEOUT_EXPIRED), "read timeout expired"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORDS_NOT_RELEASED), "records not released"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_LAYER_FAILURE), "record layer failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_LENGTH_MISMATCH), "record length mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RECORD_TOO_SMALL), "record too small"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REMOTE_PEER_ADDRESS_NOT_SET), "remote peer address not set"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATE_EXT_TOO_LONG), "renegotiate ext too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATION_ENCODING_ERR), "renegotiation encoding err"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_RENEGOTIATION_MISMATCH), "renegotiation mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUEST_PENDING), "request pending"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUEST_SENT), "request sent"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUIRED_CIPHER_MISSING), "required cipher missing"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING), "required compression algorithm missing"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING), "scsv received when renegotiating"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SCT_VERIFICATION_FAILED), "sct verification failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SEQUENCE_CTR_WRAPPED), "sequence ctr wrapped"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SERVERHELLO_TLSEXT), "serverhello tlsext"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED), "session id context uninitialized"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHUTDOWN_WHILE_IN_INIT), "shutdown while in init"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SIGNATURE_ALGORITHMS_ERROR), "signature algorithms error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE), "signature for non signing certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRP_A_CALC), "error with the srp params"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES), "srtp could not allocate profiles"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_PROTECTION_PROFILE_LIST_TOO_LONG), "srtp protection profile list too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE), "srtp unknown protection profile"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH), "ssl3 ext invalid max fragment length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL3_EXT_INVALID_SERVERNAME), "ssl3 ext invalid servername"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE), "ssl3 ext invalid servername type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL3_SESSION_ID_TOO_LONG), "ssl3 session id too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_BAD_CERTIFICATE), "ssl/tls alert bad certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_BAD_RECORD_MAC), "ssl/tls alert bad record mac"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED), "ssl/tls alert certificate expired"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED), "ssl/tls alert certificate revoked"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN), "ssl/tls alert certificate unknown"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE), "ssl/tls alert decompression failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE), "ssl/tls alert handshake failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER), "ssl/tls alert illegal parameter"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_NO_CERTIFICATE), "ssl/tls alert no certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE), "ssl/tls alert unexpected message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE), "ssl/tls alert unsupported certificate"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_COMMAND_SECTION_EMPTY), "ssl command section empty"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_COMMAND_SECTION_NOT_FOUND), "ssl command section not found"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION), "ssl ctx has no default ssl version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_HANDSHAKE_FAILURE), "ssl handshake failure"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS), "ssl library has no ciphers"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_NEGATIVE_LENGTH), "ssl negative length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SECTION_EMPTY), "ssl section empty"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SECTION_NOT_FOUND), "ssl section not found"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CALLBACK_FAILED), "ssl session id callback failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CONFLICT), "ssl session id conflict"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG), "ssl session id context too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH), "ssl session id has bad length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_ID_TOO_LONG), "ssl session id too long"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SSL_SESSION_VERSION_MISMATCH), "ssl session version mismatch"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STILL_IN_INIT), "still in init"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_COUNT_LIMITED), "stream count limited"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_FINISHED), "stream finished"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_RECV_ONLY), "stream recv only"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_RESET), "stream reset"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_STREAM_SEND_ONLY), "stream send only"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV13_ALERT_CERTIFICATE_REQUIRED), "tlsv13 alert certificate required"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV13_ALERT_MISSING_EXTENSION), "tlsv13 alert missing extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_ACCESS_DENIED), "tlsv1 alert access denied"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECODE_ERROR), "tlsv1 alert decode error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECRYPTION_FAILED), "tlsv1 alert decryption failed"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_DECRYPT_ERROR), "tlsv1 alert decrypt error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION), "tlsv1 alert export restriction"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK), "tlsv1 alert inappropriate fallback"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY), "tlsv1 alert insufficient security"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_INTERNAL_ERROR), "tlsv1 alert internal error"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_NO_RENEGOTIATION), "tlsv1 alert no renegotiation"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_PROTOCOL_VERSION), "tlsv1 alert protocol version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_RECORD_OVERFLOW), "tlsv1 alert record overflow"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_UNKNOWN_CA), "tlsv1 alert unknown ca"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_ALERT_USER_CANCELLED), "tlsv1 alert user cancelled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_BAD_CERTIFICATE_HASH_VALUE), "tlsv1 bad certificate hash value"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE), "tlsv1 bad certificate status response"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_CERTIFICATE_UNOBTAINABLE), "tlsv1 certificate unobtainable"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_UNRECOGNIZED_NAME), "tlsv1 unrecognized name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLSV1_UNSUPPORTED_EXTENSION), "tlsv1 unsupported extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL), "tls illegal exporter label"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST), "tls invalid ecpointformat list"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MANY_KEY_UPDATES), "too many key updates"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MANY_WARN_ALERTS), "too many warn alerts"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_TOO_MUCH_EARLY_DATA), "too much early data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS), "unable to find ecdh parameters"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS), "unable to find public key parameters"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES), "unable to load ssl3 md5 routines"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES), "unable to load ssl3 sha1 routines"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_CCS_MESSAGE), "unexpected ccs message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_END_OF_EARLY_DATA), "unexpected end of early data"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_EOF_WHILE_READING), "unexpected eof while reading"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_MESSAGE), "unexpected message"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNEXPECTED_RECORD), "unexpected record"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNINITIALIZED), "uninitialized"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_ALERT_TYPE), "unknown alert type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CERTIFICATE_TYPE), "unknown certificate type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CIPHER_RETURNED), "unknown cipher returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CIPHER_TYPE), "unknown cipher type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_CMD_NAME), "unknown cmd name"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_COMMAND), "unknown command"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_DIGEST), "unknown digest"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE), "unknown key exchange type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_MANDATORY_PARAMETER), "unknown mandatory parameter"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_PKEY_TYPE), "unknown pkey type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_PROTOCOL), "unknown protocol"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_SSL_VERSION), "unknown ssl version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNKNOWN_STATE), "unknown state"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED), "unsafe legacy renegotiation disabled"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSOLICITED_EXTENSION), "unsolicited extension"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM), "unsupported compression algorithm"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_ELLIPTIC_CURVE), "unsupported elliptic curve"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_PROTOCOL), "unsupported protocol"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_SSL_VERSION), "unsupported ssl version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_UNSUPPORTED_STATUS_TYPE), "unsupported status type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_USE_SRTP_NOT_NEGOTIATED), "use srtp not negotiated"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_VERSION_TOO_HIGH), "version too high"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_VERSION_TOO_LOW), "version too low"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CERTIFICATE_TYPE), "wrong certificate type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CIPHER_RETURNED), "wrong cipher returned"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_CURVE), "wrong curve"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_RPK_TYPE), "wrong rpk type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_LENGTH), "wrong signature length"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_SIZE), "wrong signature size"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SIGNATURE_TYPE), "wrong signature type"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_SSL_VERSION), "wrong ssl version"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_WRONG_VERSION_NUMBER), "wrong version number"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_X509_LIB), "x509 lib"}, {ERR_PACK(ERR_LIB_SSL, 0, SSL_R_X509_VERIFICATION_SETUP_PROBLEMS), "x509 verification setup problems"}, {0, NULL} }; #endif int ossl_err_load_SSL_strings(void) { #ifndef OPENSSL_NO_ERR if (ERR_reason_error_string(SSL_str_reasons[0].error) == NULL) ERR_load_strings_const(SSL_str_reasons); #endif return 1; }

./openssl/ssl/s3_lib.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <openssl/objects.h> #include "internal/nelem.h" #include "ssl_local.h" #include <openssl/md5.h> #include <openssl/dh.h> #include <openssl/rand.h> #include <openssl/trace.h> #include <openssl/x509v3.h> #include <openssl/core_names.h> #include "internal/cryptlib.h" #define TLS13_NUM_CIPHERS OSSL_NELEM(tls13_ciphers) #define SSL3_NUM_CIPHERS OSSL_NELEM(ssl3_ciphers) #define SSL3_NUM_SCSVS OSSL_NELEM(ssl3_scsvs) /* TLSv1.3 downgrade protection sentinel values */ const unsigned char tls11downgrade[] = { 0x44, 0x4f, 0x57, 0x4e, 0x47, 0x52, 0x44, 0x00 }; const unsigned char tls12downgrade[] = { 0x44, 0x4f, 0x57, 0x4e, 0x47, 0x52, 0x44, 0x01 }; /* The list of available TLSv1.3 ciphers */ static SSL_CIPHER tls13_ciphers[] = { { 1, TLS1_3_RFC_AES_128_GCM_SHA256, TLS1_3_RFC_AES_128_GCM_SHA256, TLS1_3_CK_AES_128_GCM_SHA256, SSL_kANY, SSL_aANY, SSL_AES128GCM, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | SSL_QUIC, 128, 128, }, { 1, TLS1_3_RFC_AES_256_GCM_SHA384, TLS1_3_RFC_AES_256_GCM_SHA384, TLS1_3_CK_AES_256_GCM_SHA384, SSL_kANY, SSL_aANY, SSL_AES256GCM, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | SSL_QUIC, 256, 256, }, { 1, TLS1_3_RFC_CHACHA20_POLY1305_SHA256, TLS1_3_RFC_CHACHA20_POLY1305_SHA256, TLS1_3_CK_CHACHA20_POLY1305_SHA256, SSL_kANY, SSL_aANY, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | SSL_QUIC, 256, 256, }, { 1, TLS1_3_RFC_AES_128_CCM_SHA256, TLS1_3_RFC_AES_128_CCM_SHA256, TLS1_3_CK_AES_128_CCM_SHA256, SSL_kANY, SSL_aANY, SSL_AES128CCM, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256, 128, 128, }, { 1, TLS1_3_RFC_AES_128_CCM_8_SHA256, TLS1_3_RFC_AES_128_CCM_8_SHA256, TLS1_3_CK_AES_128_CCM_8_SHA256, SSL_kANY, SSL_aANY, SSL_AES128CCM8, SSL_AEAD, TLS1_3_VERSION, TLS1_3_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 128, } }; /* * The list of available ciphers, mostly organized into the following * groups: * Always there * EC * PSK * SRP (within that: RSA EC PSK) * Cipher families: Chacha/poly, Camellia, Gost, IDEA, SEED * Weak ciphers */ static SSL_CIPHER ssl3_ciphers[] = { { 1, SSL3_TXT_RSA_NULL_MD5, SSL3_RFC_RSA_NULL_MD5, SSL3_CK_RSA_NULL_MD5, SSL_kRSA, SSL_aRSA, SSL_eNULL, SSL_MD5, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, SSL3_TXT_RSA_NULL_SHA, SSL3_RFC_RSA_NULL_SHA, SSL3_CK_RSA_NULL_SHA, SSL_kRSA, SSL_aRSA, SSL_eNULL, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, #ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, SSL3_TXT_RSA_DES_192_CBC3_SHA, SSL3_RFC_RSA_DES_192_CBC3_SHA, SSL3_CK_RSA_DES_192_CBC3_SHA, SSL_kRSA, SSL_aRSA, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, { 1, SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA, SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA, SSL3_CK_DHE_DSS_DES_192_CBC3_SHA, SSL_kDHE, SSL_aDSS, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, { 1, SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA, SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA, SSL3_CK_DHE_RSA_DES_192_CBC3_SHA, SSL_kDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, { 1, SSL3_TXT_ADH_DES_192_CBC_SHA, SSL3_RFC_ADH_DES_192_CBC_SHA, SSL3_CK_ADH_DES_192_CBC_SHA, SSL_kDHE, SSL_aNULL, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, #endif { 1, TLS1_TXT_RSA_WITH_AES_128_SHA, TLS1_RFC_RSA_WITH_AES_128_SHA, TLS1_CK_RSA_WITH_AES_128_SHA, SSL_kRSA, SSL_aRSA, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_128_SHA, TLS1_RFC_DHE_DSS_WITH_AES_128_SHA, TLS1_CK_DHE_DSS_WITH_AES_128_SHA, SSL_kDHE, SSL_aDSS, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_SHA, TLS1_RFC_DHE_RSA_WITH_AES_128_SHA, TLS1_CK_DHE_RSA_WITH_AES_128_SHA, SSL_kDHE, SSL_aRSA, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_AES_128_SHA, TLS1_RFC_ADH_WITH_AES_128_SHA, TLS1_CK_ADH_WITH_AES_128_SHA, SSL_kDHE, SSL_aNULL, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_SHA, TLS1_RFC_RSA_WITH_AES_256_SHA, TLS1_CK_RSA_WITH_AES_256_SHA, SSL_kRSA, SSL_aRSA, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_256_SHA, TLS1_RFC_DHE_DSS_WITH_AES_256_SHA, TLS1_CK_DHE_DSS_WITH_AES_256_SHA, SSL_kDHE, SSL_aDSS, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_SHA, TLS1_RFC_DHE_RSA_WITH_AES_256_SHA, TLS1_CK_DHE_RSA_WITH_AES_256_SHA, SSL_kDHE, SSL_aRSA, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_AES_256_SHA, TLS1_RFC_ADH_WITH_AES_256_SHA, TLS1_CK_ADH_WITH_AES_256_SHA, SSL_kDHE, SSL_aNULL, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_NULL_SHA256, TLS1_RFC_RSA_WITH_NULL_SHA256, TLS1_CK_RSA_WITH_NULL_SHA256, SSL_kRSA, SSL_aRSA, SSL_eNULL, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_RSA_WITH_AES_128_SHA256, TLS1_RFC_RSA_WITH_AES_128_SHA256, TLS1_CK_RSA_WITH_AES_128_SHA256, SSL_kRSA, SSL_aRSA, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_SHA256, TLS1_RFC_RSA_WITH_AES_256_SHA256, TLS1_CK_RSA_WITH_AES_256_SHA256, SSL_kRSA, SSL_aRSA, SSL_AES256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256, TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256, TLS1_CK_DHE_DSS_WITH_AES_128_SHA256, SSL_kDHE, SSL_aDSS, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256, TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256, TLS1_CK_DHE_RSA_WITH_AES_128_SHA256, SSL_kDHE, SSL_aRSA, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256, TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256, TLS1_CK_DHE_DSS_WITH_AES_256_SHA256, SSL_kDHE, SSL_aDSS, SSL_AES256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256, TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256, TLS1_CK_DHE_RSA_WITH_AES_256_SHA256, SSL_kDHE, SSL_aRSA, SSL_AES256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_AES_128_SHA256, TLS1_RFC_ADH_WITH_AES_128_SHA256, TLS1_CK_ADH_WITH_AES_128_SHA256, SSL_kDHE, SSL_aNULL, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_AES_256_SHA256, TLS1_RFC_ADH_WITH_AES_256_SHA256, TLS1_CK_ADH_WITH_AES_256_SHA256, SSL_kDHE, SSL_aNULL, SSL_AES256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256, TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256, TLS1_CK_RSA_WITH_AES_128_GCM_SHA256, SSL_kRSA, SSL_aRSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384, TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384, TLS1_CK_RSA_WITH_AES_256_GCM_SHA384, SSL_kRSA, SSL_aRSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256, TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256, TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256, SSL_kDHE, SSL_aRSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384, TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384, TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384, SSL_kDHE, SSL_aRSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256, TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256, TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256, SSL_kDHE, SSL_aDSS, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384, TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384, TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384, SSL_kDHE, SSL_aDSS, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256, TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256, TLS1_CK_ADH_WITH_AES_128_GCM_SHA256, SSL_kDHE, SSL_aNULL, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384, TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384, TLS1_CK_ADH_WITH_AES_256_GCM_SHA384, SSL_kDHE, SSL_aNULL, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_AES_128_CCM, TLS1_RFC_RSA_WITH_AES_128_CCM, TLS1_CK_RSA_WITH_AES_128_CCM, SSL_kRSA, SSL_aRSA, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_CCM, TLS1_RFC_RSA_WITH_AES_256_CCM, TLS1_CK_RSA_WITH_AES_256_CCM, SSL_kRSA, SSL_aRSA, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_CCM, TLS1_RFC_DHE_RSA_WITH_AES_128_CCM, TLS1_CK_DHE_RSA_WITH_AES_128_CCM, SSL_kDHE, SSL_aRSA, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_CCM, TLS1_RFC_DHE_RSA_WITH_AES_256_CCM, TLS1_CK_DHE_RSA_WITH_AES_256_CCM, SSL_kDHE, SSL_aRSA, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_AES_128_CCM_8, TLS1_RFC_RSA_WITH_AES_128_CCM_8, TLS1_CK_RSA_WITH_AES_128_CCM_8, SSL_kRSA, SSL_aRSA, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 128, }, { 1, TLS1_TXT_RSA_WITH_AES_256_CCM_8, TLS1_RFC_RSA_WITH_AES_256_CCM_8, TLS1_CK_RSA_WITH_AES_256_CCM_8, SSL_kRSA, SSL_aRSA, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8, TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8, TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8, SSL_kDHE, SSL_aRSA, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8, TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8, TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8, SSL_kDHE, SSL_aRSA, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 256, }, { 1, TLS1_TXT_PSK_WITH_AES_128_CCM, TLS1_RFC_PSK_WITH_AES_128_CCM, TLS1_CK_PSK_WITH_AES_128_CCM, SSL_kPSK, SSL_aPSK, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_CCM, TLS1_RFC_PSK_WITH_AES_256_CCM, TLS1_CK_PSK_WITH_AES_256_CCM, SSL_kPSK, SSL_aPSK, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_CCM, TLS1_RFC_DHE_PSK_WITH_AES_128_CCM, TLS1_CK_DHE_PSK_WITH_AES_128_CCM, SSL_kDHEPSK, SSL_aPSK, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_CCM, TLS1_RFC_DHE_PSK_WITH_AES_256_CCM, TLS1_CK_DHE_PSK_WITH_AES_256_CCM, SSL_kDHEPSK, SSL_aPSK, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_AES_128_CCM_8, TLS1_RFC_PSK_WITH_AES_128_CCM_8, TLS1_CK_PSK_WITH_AES_128_CCM_8, SSL_kPSK, SSL_aPSK, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_CCM_8, TLS1_RFC_PSK_WITH_AES_256_CCM_8, TLS1_CK_PSK_WITH_AES_256_CCM_8, SSL_kPSK, SSL_aPSK, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8, TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8, TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8, SSL_kDHEPSK, SSL_aPSK, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8, TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8, TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8, SSL_kDHEPSK, SSL_aPSK, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM, SSL_kECDHE, SSL_aECDSA, SSL_AES128CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM, SSL_kECDHE, SSL_aECDSA, SSL_AES256CCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8, SSL_kECDHE, SSL_aECDSA, SSL_AES128CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8, SSL_kECDHE, SSL_aECDSA, SSL_AES256CCM8, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 64, /* CCM8 uses a short tag, so we have a low security strength */ 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA, TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA, SSL_kECDHE, SSL_aECDSA, SSL_eNULL, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA, TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA, SSL_kECDHE, SSL_aECDSA, SSL_3DES, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, SSL_kECDHE, SSL_aECDSA, SSL_AES128, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, SSL_kECDHE, SSL_aECDSA, SSL_AES256, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA, TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA, TLS1_CK_ECDHE_RSA_WITH_NULL_SHA, SSL_kECDHE, SSL_aRSA, SSL_eNULL, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA, TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA, TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA, SSL_kECDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA, TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA, TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA, SSL_kECDHE, SSL_aRSA, SSL_AES128, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA, TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA, TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA, SSL_kECDHE, SSL_aRSA, SSL_AES256, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ECDH_anon_WITH_NULL_SHA, TLS1_RFC_ECDH_anon_WITH_NULL_SHA, TLS1_CK_ECDH_anon_WITH_NULL_SHA, SSL_kECDHE, SSL_aNULL, SSL_eNULL, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA, TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA, TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA, SSL_kECDHE, SSL_aNULL, SSL_3DES, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA, TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA, TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA, SSL_kECDHE, SSL_aNULL, SSL_AES128, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA, TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA, TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA, SSL_kECDHE, SSL_aNULL, SSL_AES256, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256, SSL_kECDHE, SSL_aECDSA, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384, SSL_kECDHE, SSL_aECDSA, SSL_AES256, SSL_SHA384, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256, TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256, TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256, SSL_kECDHE, SSL_aRSA, SSL_AES128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384, TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384, TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384, SSL_kECDHE, SSL_aRSA, SSL_AES256, SSL_SHA384, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, SSL_kECDHE, SSL_aECDSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, SSL_kECDHE, SSL_aECDSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256, TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256, TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256, SSL_kECDHE, SSL_aRSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384, TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384, TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384, SSL_kECDHE, SSL_aRSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_NULL_SHA, TLS1_RFC_PSK_WITH_NULL_SHA, TLS1_CK_PSK_WITH_NULL_SHA, SSL_kPSK, SSL_aPSK, SSL_eNULL, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_DHE_PSK_WITH_NULL_SHA, TLS1_RFC_DHE_PSK_WITH_NULL_SHA, TLS1_CK_DHE_PSK_WITH_NULL_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_RSA_PSK_WITH_NULL_SHA, TLS1_RFC_RSA_PSK_WITH_NULL_SHA, TLS1_CK_RSA_PSK_WITH_NULL_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_eNULL, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA, SSL_kPSK, SSL_aPSK, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_PSK_WITH_AES_128_CBC_SHA, TLS1_RFC_PSK_WITH_AES_128_CBC_SHA, TLS1_CK_PSK_WITH_AES_128_CBC_SHA, SSL_kPSK, SSL_aPSK, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_CBC_SHA, TLS1_RFC_PSK_WITH_AES_256_CBC_SHA, TLS1_CK_PSK_WITH_AES_256_CBC_SHA, SSL_kPSK, SSL_aPSK, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA, TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA, TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA, TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA, TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA, TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA, TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA, TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA, TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256, TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256, TLS1_CK_PSK_WITH_AES_128_GCM_SHA256, SSL_kPSK, SSL_aPSK, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384, TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384, TLS1_CK_PSK_WITH_AES_256_GCM_SHA384, SSL_kPSK, SSL_aPSK, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256, TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256, TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384, TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384, TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256, TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256, TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_AES128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384, TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384, TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_AES256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256, TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256, TLS1_CK_PSK_WITH_AES_128_CBC_SHA256, SSL_kPSK, SSL_aPSK, SSL_AES128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384, TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384, TLS1_CK_PSK_WITH_AES_256_CBC_SHA384, SSL_kPSK, SSL_aPSK, SSL_AES256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_NULL_SHA256, TLS1_RFC_PSK_WITH_NULL_SHA256, TLS1_CK_PSK_WITH_NULL_SHA256, SSL_kPSK, SSL_aPSK, SSL_eNULL, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_PSK_WITH_NULL_SHA384, TLS1_RFC_PSK_WITH_NULL_SHA384, TLS1_CK_PSK_WITH_NULL_SHA384, SSL_kPSK, SSL_aPSK, SSL_eNULL, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 0, 0, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256, TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256, TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_AES128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384, TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384, TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_AES256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_NULL_SHA256, TLS1_RFC_DHE_PSK_WITH_NULL_SHA256, TLS1_CK_DHE_PSK_WITH_NULL_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_DHE_PSK_WITH_NULL_SHA384, TLS1_RFC_DHE_PSK_WITH_NULL_SHA384, TLS1_CK_DHE_PSK_WITH_NULL_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 0, 0, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256, TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256, TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_AES128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384, TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384, TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_AES256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_NULL_SHA256, TLS1_RFC_RSA_PSK_WITH_NULL_SHA256, TLS1_CK_RSA_PSK_WITH_NULL_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_eNULL, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_RSA_PSK_WITH_NULL_SHA384, TLS1_RFC_RSA_PSK_WITH_NULL_SHA384, TLS1_CK_RSA_PSK_WITH_NULL_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_eNULL, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_3DES, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA, TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA, TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_AES128, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA, TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA, TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_AES256, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256, TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256, TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256, SSL_kECDHEPSK, SSL_aPSK, SSL_AES128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384, TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384, TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384, SSL_kECDHEPSK, SSL_aPSK, SSL_AES256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA, TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA, TLS1_CK_ECDHE_PSK_WITH_NULL_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256, TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256, TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256, SSL_kECDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 0, 0, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384, TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384, TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384, SSL_kECDHEPSK, SSL_aPSK, SSL_eNULL, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_STRONG_NONE | SSL_FIPS, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 0, 0, }, # ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA, TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA, SSL_kSRP, SSL_aSRP, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, { 1, TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA, TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA, SSL_kSRP, SSL_aRSA, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, { 1, TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA, TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA, TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA, SSL_kSRP, SSL_aDSS, SSL_3DES, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 112, 168, }, # endif { 1, TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA, TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA, TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA, SSL_kSRP, SSL_aSRP, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA, TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA, TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA, SSL_kSRP, SSL_aRSA, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA, TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA, TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA, SSL_kSRP, SSL_aDSS, SSL_AES128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA, TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA, TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA, SSL_kSRP, SSL_aSRP, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA, TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA, TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA, SSL_kSRP, SSL_aRSA, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA, TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA, TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA, SSL_kSRP, SSL_aDSS, SSL_AES256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305, TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305, TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305, SSL_kDHE, SSL_aRSA, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305, TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305, TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305, SSL_kECDHE, SSL_aRSA, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305, SSL_kECDHE, SSL_aECDSA, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_CHACHA20_POLY1305, TLS1_RFC_PSK_WITH_CHACHA20_POLY1305, TLS1_CK_PSK_WITH_CHACHA20_POLY1305, SSL_kPSK, SSL_aPSK, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305, TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305, TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305, SSL_kECDHEPSK, SSL_aPSK, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305, TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305, TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305, SSL_kDHEPSK, SSL_aPSK, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305, TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305, TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305, SSL_kRSAPSK, SSL_aRSA, SSL_CHACHA20POLY1305, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256, SSL_kRSA, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256, SSL_kDHE, SSL_aDSS, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, SSL_kDHE, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256, SSL_kDHE, SSL_aNULL, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256, TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256, TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256, SSL_kRSA, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256, TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256, TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256, SSL_kDHE, SSL_aDSS, SSL_CAMELLIA256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, SSL_kDHE, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256, TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256, TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256, SSL_kDHE, SSL_aNULL, SSL_CAMELLIA256, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA, TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA, TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA, SSL_kRSA, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, SSL_kDHE, SSL_aDSS, SSL_CAMELLIA256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, SSL_kDHE, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA, TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA, TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA, SSL_kDHE, SSL_aNULL, SSL_CAMELLIA256, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 256, 256, }, { 1, TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA, TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA, TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA, SSL_kRSA, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, SSL_kDHE, SSL_aDSS, SSL_CAMELLIA128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, SSL_kDHE, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA, TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA, TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA, SSL_kDHE, SSL_aNULL, SSL_CAMELLIA128, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, SSL_kECDHE, SSL_aECDSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, SSL_kECDHE, SSL_aECDSA, SSL_CAMELLIA256, SSL_SHA384, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, SSL_kECDHE, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, SSL_kECDHE, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA384, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256, SSL_kPSK, SSL_aPSK, SSL_CAMELLIA128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384, SSL_kPSK, SSL_aPSK, SSL_CAMELLIA256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_CAMELLIA128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_CAMELLIA256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_CAMELLIA128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_CAMELLIA256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, SSL_kECDHEPSK, SSL_aPSK, SSL_CAMELLIA128, SSL_SHA256, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, SSL_kECDHEPSK, SSL_aPSK, SSL_CAMELLIA256, SSL_SHA384, TLS1_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, #ifndef OPENSSL_NO_GOST { 1, "GOST2001-GOST89-GOST89", "TLS_GOSTR341001_WITH_28147_CNT_IMIT", 0x3000081, SSL_kGOST, SSL_aGOST01, SSL_eGOST2814789CNT, SSL_GOST89MAC, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST94 | TLS1_PRF_GOST94 | TLS1_STREAM_MAC, 256, 256, }, { 1, "GOST2001-NULL-GOST94", "TLS_GOSTR341001_WITH_NULL_GOSTR3411", 0x3000083, SSL_kGOST, SSL_aGOST01, SSL_eNULL, SSL_GOST94, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_STRONG_NONE, SSL_HANDSHAKE_MAC_GOST94 | TLS1_PRF_GOST94, 0, 0, }, { 1, "IANA-GOST2012-GOST8912-GOST8912", NULL, 0x0300c102, SSL_kGOST, SSL_aGOST12 | SSL_aGOST01, SSL_eGOST2814789CNT12, SSL_GOST89MAC12, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC, 256, 256, }, { 1, "LEGACY-GOST2012-GOST8912-GOST8912", NULL, 0x0300ff85, SSL_kGOST, SSL_aGOST12 | SSL_aGOST01, SSL_eGOST2814789CNT12, SSL_GOST89MAC12, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC, 256, 256, }, { 1, "GOST2012-NULL-GOST12", NULL, 0x0300ff87, SSL_kGOST, SSL_aGOST12 | SSL_aGOST01, SSL_eNULL, SSL_GOST12_256, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_STRONG_NONE, SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC, 0, 0, }, { 1, "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC", NULL, 0x0300C100, SSL_kGOST18, SSL_aGOST12, SSL_KUZNYECHIK, SSL_KUZNYECHIKOMAC, TLS1_2_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_TLSTREE, 256, 256, }, { 1, "GOST2012-MAGMA-MAGMAOMAC", NULL, 0x0300C101, SSL_kGOST18, SSL_aGOST12, SSL_MAGMA, SSL_MAGMAOMAC, TLS1_2_VERSION, TLS1_2_VERSION, 0, 0, SSL_HIGH, SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_TLSTREE, 256, 256, }, #endif /* OPENSSL_NO_GOST */ { 1, SSL3_TXT_RSA_IDEA_128_SHA, SSL3_RFC_RSA_IDEA_128_SHA, SSL3_CK_RSA_IDEA_128_SHA, SSL_kRSA, SSL_aRSA, SSL_IDEA, SSL_SHA1, SSL3_VERSION, TLS1_1_VERSION, DTLS1_BAD_VER, DTLS1_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_SEED_SHA, TLS1_RFC_RSA_WITH_SEED_SHA, TLS1_CK_RSA_WITH_SEED_SHA, SSL_kRSA, SSL_aRSA, SSL_SEED, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_SEED_SHA, TLS1_RFC_DHE_DSS_WITH_SEED_SHA, TLS1_CK_DHE_DSS_WITH_SEED_SHA, SSL_kDHE, SSL_aDSS, SSL_SEED, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_SEED_SHA, TLS1_RFC_DHE_RSA_WITH_SEED_SHA, TLS1_CK_DHE_RSA_WITH_SEED_SHA, SSL_kDHE, SSL_aRSA, SSL_SEED, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, { 1, TLS1_TXT_ADH_WITH_SEED_SHA, TLS1_RFC_ADH_WITH_SEED_SHA, TLS1_CK_ADH_WITH_SEED_SHA, SSL_kDHE, SSL_aNULL, SSL_SEED, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, DTLS1_BAD_VER, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 128, 128, }, #ifndef OPENSSL_NO_WEAK_SSL_CIPHERS { 1, SSL3_TXT_RSA_RC4_128_MD5, SSL3_RFC_RSA_RC4_128_MD5, SSL3_CK_RSA_RC4_128_MD5, SSL_kRSA, SSL_aRSA, SSL_RC4, SSL_MD5, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, SSL3_TXT_RSA_RC4_128_SHA, SSL3_RFC_RSA_RC4_128_SHA, SSL3_CK_RSA_RC4_128_SHA, SSL_kRSA, SSL_aRSA, SSL_RC4, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, SSL3_TXT_ADH_RC4_128_MD5, SSL3_RFC_ADH_RC4_128_MD5, SSL3_CK_ADH_RC4_128_MD5, SSL_kDHE, SSL_aNULL, SSL_RC4, SSL_MD5, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA, TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA, TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA, SSL_kECDHEPSK, SSL_aPSK, SSL_RC4, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA, TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA, TLS1_CK_ECDH_anon_WITH_RC4_128_SHA, SSL_kECDHE, SSL_aNULL, SSL_RC4, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA, TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA, TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA, SSL_kECDHE, SSL_aECDSA, SSL_RC4, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA, TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA, TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA, SSL_kECDHE, SSL_aRSA, SSL_RC4, SSL_SHA1, TLS1_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_PSK_WITH_RC4_128_SHA, TLS1_RFC_PSK_WITH_RC4_128_SHA, TLS1_CK_PSK_WITH_RC4_128_SHA, SSL_kPSK, SSL_aPSK, SSL_RC4, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA, TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA, TLS1_CK_RSA_PSK_WITH_RC4_128_SHA, SSL_kRSAPSK, SSL_aRSA, SSL_RC4, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA, TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA, TLS1_CK_DHE_PSK_WITH_RC4_128_SHA, SSL_kDHEPSK, SSL_aPSK, SSL_RC4, SSL_SHA1, SSL3_VERSION, TLS1_2_VERSION, 0, 0, SSL_NOT_DEFAULT | SSL_MEDIUM, SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF, 80, 128, }, #endif /* OPENSSL_NO_WEAK_SSL_CIPHERS */ { 1, TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256, SSL_kRSA, SSL_aRSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384, SSL_kRSA, SSL_aRSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256, SSL_kDHE, SSL_aRSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384, SSL_kDHE, SSL_aRSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256, TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256, SSL_kDHE, SSL_aDSS, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384, TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384, SSL_kDHE, SSL_aDSS, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256, TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256, SSL_kECDHE, SSL_aECDSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384, TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384, SSL_kECDHE, SSL_aECDSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256, TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256, SSL_kECDHE, SSL_aRSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384, TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384, SSL_kECDHE, SSL_aRSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256, SSL_kPSK, SSL_aPSK, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384, SSL_kPSK, SSL_aPSK, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256, SSL_kDHEPSK, SSL_aPSK, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384, SSL_kDHEPSK, SSL_aPSK, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, { 1, TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256, TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256, SSL_kRSAPSK, SSL_aRSA, SSL_ARIA128GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256, 128, 128, }, { 1, TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384, TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384, SSL_kRSAPSK, SSL_aRSA, SSL_ARIA256GCM, SSL_AEAD, TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION, SSL_NOT_DEFAULT | SSL_HIGH, SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384, 256, 256, }, }; /* * The list of known Signalling Cipher-Suite Value "ciphers", non-valid * values stuffed into the ciphers field of the wire protocol for signalling * purposes. */ static SSL_CIPHER ssl3_scsvs[] = { { 0, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV", "TLS_EMPTY_RENEGOTIATION_INFO_SCSV", SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, { 0, "TLS_FALLBACK_SCSV", "TLS_FALLBACK_SCSV", SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }, }; static int cipher_compare(const void *a, const void *b) { const SSL_CIPHER *ap = (const SSL_CIPHER *)a; const SSL_CIPHER *bp = (const SSL_CIPHER *)b; if (ap->id == bp->id) return 0; return ap->id < bp->id ? -1 : 1; } void ssl_sort_cipher_list(void) { qsort(tls13_ciphers, TLS13_NUM_CIPHERS, sizeof(tls13_ciphers[0]), cipher_compare); qsort(ssl3_ciphers, SSL3_NUM_CIPHERS, sizeof(ssl3_ciphers[0]), cipher_compare); qsort(ssl3_scsvs, SSL3_NUM_SCSVS, sizeof(ssl3_scsvs[0]), cipher_compare); } static int sslcon_undefined_function_1(SSL_CONNECTION *sc, unsigned char *r, size_t s, const char *t, size_t u, const unsigned char *v, size_t w, int x) { (void)r; (void)s; (void)t; (void)u; (void)v; (void)w; (void)x; return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc)); } const SSL3_ENC_METHOD SSLv3_enc_data = { ssl3_setup_key_block, ssl3_generate_master_secret, ssl3_change_cipher_state, ssl3_final_finish_mac, SSL3_MD_CLIENT_FINISHED_CONST, 4, SSL3_MD_SERVER_FINISHED_CONST, 4, ssl3_alert_code, sslcon_undefined_function_1, 0, ssl3_set_handshake_header, tls_close_construct_packet, ssl3_handshake_write }; OSSL_TIME ssl3_default_timeout(void) { /* * 2 hours, the 24 hours mentioned in the SSLv3 spec is way too long for * http, the cache would over fill */ return ossl_seconds2time(60 * 60 * 2); } int ssl3_num_ciphers(void) { return SSL3_NUM_CIPHERS; } const SSL_CIPHER *ssl3_get_cipher(unsigned int u) { if (u < SSL3_NUM_CIPHERS) return &(ssl3_ciphers[SSL3_NUM_CIPHERS - 1 - u]); else return NULL; } int ssl3_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype) { /* No header in the event of a CCS */ if (htype == SSL3_MT_CHANGE_CIPHER_SPEC) return 1; /* Set the content type and 3 bytes for the message len */ if (!WPACKET_put_bytes_u8(pkt, htype) || !WPACKET_start_sub_packet_u24(pkt)) return 0; return 1; } int ssl3_handshake_write(SSL_CONNECTION *s) { return ssl3_do_write(s, SSL3_RT_HANDSHAKE); } int ssl3_new(SSL *s) { #ifndef OPENSSL_NO_SRP SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; if (!ssl_srp_ctx_init_intern(sc)) return 0; #endif if (!s->method->ssl_clear(s)) return 0; return 1; } void ssl3_free(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return; ssl3_cleanup_key_block(sc); EVP_PKEY_free(sc->s3.peer_tmp); sc->s3.peer_tmp = NULL; EVP_PKEY_free(sc->s3.tmp.pkey); sc->s3.tmp.pkey = NULL; ssl_evp_cipher_free(sc->s3.tmp.new_sym_enc); ssl_evp_md_free(sc->s3.tmp.new_hash); OPENSSL_free(sc->s3.tmp.ctype); sk_X509_NAME_pop_free(sc->s3.tmp.peer_ca_names, X509_NAME_free); OPENSSL_free(sc->s3.tmp.ciphers_raw); OPENSSL_clear_free(sc->s3.tmp.pms, sc->s3.tmp.pmslen); OPENSSL_free(sc->s3.tmp.peer_sigalgs); OPENSSL_free(sc->s3.tmp.peer_cert_sigalgs); OPENSSL_free(sc->s3.tmp.valid_flags); ssl3_free_digest_list(sc); OPENSSL_free(sc->s3.alpn_selected); OPENSSL_free(sc->s3.alpn_proposed); #ifndef OPENSSL_NO_PSK OPENSSL_free(sc->s3.tmp.psk); #endif #ifndef OPENSSL_NO_SRP ssl_srp_ctx_free_intern(sc); #endif memset(&sc->s3, 0, sizeof(sc->s3)); } int ssl3_clear(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); int flags; if (sc == NULL) return 0; ssl3_cleanup_key_block(sc); OPENSSL_free(sc->s3.tmp.ctype); sk_X509_NAME_pop_free(sc->s3.tmp.peer_ca_names, X509_NAME_free); OPENSSL_free(sc->s3.tmp.ciphers_raw); OPENSSL_clear_free(sc->s3.tmp.pms, sc->s3.tmp.pmslen); OPENSSL_free(sc->s3.tmp.peer_sigalgs); OPENSSL_free(sc->s3.tmp.peer_cert_sigalgs); OPENSSL_free(sc->s3.tmp.valid_flags); EVP_PKEY_free(sc->s3.tmp.pkey); EVP_PKEY_free(sc->s3.peer_tmp); ssl3_free_digest_list(sc); OPENSSL_free(sc->s3.alpn_selected); OPENSSL_free(sc->s3.alpn_proposed); /* * NULL/zero-out everything in the s3 struct, but remember if we are doing * QUIC. */ flags = sc->s3.flags & TLS1_FLAGS_QUIC; memset(&sc->s3, 0, sizeof(sc->s3)); sc->s3.flags |= flags; if (!ssl_free_wbio_buffer(sc)) return 0; sc->version = SSL3_VERSION; #if !defined(OPENSSL_NO_NEXTPROTONEG) OPENSSL_free(sc->ext.npn); sc->ext.npn = NULL; sc->ext.npn_len = 0; #endif return 1; } #ifndef OPENSSL_NO_SRP static char *srp_password_from_info_cb(SSL *s, void *arg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return NULL; return OPENSSL_strdup(sc->srp_ctx.info); } #endif static int ssl3_set_req_cert_type(CERT *c, const unsigned char *p, size_t len); long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg) { int ret = 0; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return ret; switch (cmd) { case SSL_CTRL_GET_CLIENT_CERT_REQUEST: break; case SSL_CTRL_GET_NUM_RENEGOTIATIONS: ret = sc->s3.num_renegotiations; break; case SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS: ret = sc->s3.num_renegotiations; sc->s3.num_renegotiations = 0; break; case SSL_CTRL_GET_TOTAL_RENEGOTIATIONS: ret = sc->s3.total_renegotiations; break; case SSL_CTRL_GET_FLAGS: ret = (int)(sc->s3.flags); break; #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_DH: { EVP_PKEY *pkdh = NULL; if (parg == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } pkdh = ssl_dh_to_pkey(parg); if (pkdh == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB); return 0; } if (!SSL_set0_tmp_dh_pkey(s, pkdh)) { EVP_PKEY_free(pkdh); return 0; } return 1; } break; case SSL_CTRL_SET_TMP_DH_CB: { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return ret; } #endif case SSL_CTRL_SET_DH_AUTO: sc->cert->dh_tmp_auto = larg; return 1; #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_ECDH: { if (parg == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } return ssl_set_tmp_ecdh_groups(&sc->ext.supportedgroups, &sc->ext.supportedgroups_len, parg); } #endif /* !OPENSSL_NO_DEPRECATED_3_0 */ case SSL_CTRL_SET_TLSEXT_HOSTNAME: /* * This API is only used for a client to set what SNI it will request * from the server, but we currently allow it to be used on servers * as well, which is a programming error. Currently we just clear * the field in SSL_do_handshake() for server SSLs, but when we can * make ABI-breaking changes, we may want to make use of this API * an error on server SSLs. */ if (larg == TLSEXT_NAMETYPE_host_name) { size_t len; OPENSSL_free(sc->ext.hostname); sc->ext.hostname = NULL; ret = 1; if (parg == NULL) break; len = strlen((char *)parg); if (len == 0 || len > TLSEXT_MAXLEN_host_name) { ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_SERVERNAME); return 0; } if ((sc->ext.hostname = OPENSSL_strdup((char *)parg)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } } else { ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_SERVERNAME_TYPE); return 0; } break; case SSL_CTRL_SET_TLSEXT_DEBUG_ARG: sc->ext.debug_arg = parg; ret = 1; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE: ret = sc->ext.status_type; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE: sc->ext.status_type = larg; ret = 1; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_EXTS: *(STACK_OF(X509_EXTENSION) **)parg = sc->ext.ocsp.exts; ret = 1; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_EXTS: sc->ext.ocsp.exts = parg; ret = 1; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_IDS: *(STACK_OF(OCSP_RESPID) **)parg = sc->ext.ocsp.ids; ret = 1; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_IDS: sc->ext.ocsp.ids = parg; ret = 1; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP: *(unsigned char **)parg = sc->ext.ocsp.resp; if (sc->ext.ocsp.resp_len == 0 || sc->ext.ocsp.resp_len > LONG_MAX) return -1; return (long)sc->ext.ocsp.resp_len; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP: OPENSSL_free(sc->ext.ocsp.resp); sc->ext.ocsp.resp = parg; sc->ext.ocsp.resp_len = larg; ret = 1; break; case SSL_CTRL_CHAIN: if (larg) return ssl_cert_set1_chain(sc, NULL, (STACK_OF(X509) *)parg); else return ssl_cert_set0_chain(sc, NULL, (STACK_OF(X509) *)parg); case SSL_CTRL_CHAIN_CERT: if (larg) return ssl_cert_add1_chain_cert(sc, NULL, (X509 *)parg); else return ssl_cert_add0_chain_cert(sc, NULL, (X509 *)parg); case SSL_CTRL_GET_CHAIN_CERTS: *(STACK_OF(X509) **)parg = sc->cert->key->chain; ret = 1; break; case SSL_CTRL_SELECT_CURRENT_CERT: return ssl_cert_select_current(sc->cert, (X509 *)parg); case SSL_CTRL_SET_CURRENT_CERT: if (larg == SSL_CERT_SET_SERVER) { const SSL_CIPHER *cipher; if (!sc->server) return 0; cipher = sc->s3.tmp.new_cipher; if (cipher == NULL) return 0; /* * No certificate for unauthenticated ciphersuites or using SRP * authentication */ if (cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP)) return 2; if (sc->s3.tmp.cert == NULL) return 0; sc->cert->key = sc->s3.tmp.cert; return 1; } return ssl_cert_set_current(sc->cert, larg); case SSL_CTRL_GET_GROUPS: { uint16_t *clist; size_t clistlen; if (!sc->session) return 0; clist = sc->ext.peer_supportedgroups; clistlen = sc->ext.peer_supportedgroups_len; if (parg) { size_t i; int *cptr = parg; for (i = 0; i < clistlen; i++) { const TLS_GROUP_INFO *cinf = tls1_group_id_lookup(s->ctx, clist[i]); if (cinf != NULL) cptr[i] = tls1_group_id2nid(cinf->group_id, 1); else cptr[i] = TLSEXT_nid_unknown | clist[i]; } } return (int)clistlen; } case SSL_CTRL_SET_GROUPS: return tls1_set_groups(&sc->ext.supportedgroups, &sc->ext.supportedgroups_len, parg, larg); case SSL_CTRL_SET_GROUPS_LIST: return tls1_set_groups_list(s->ctx, &sc->ext.supportedgroups, &sc->ext.supportedgroups_len, parg); case SSL_CTRL_GET_SHARED_GROUP: { uint16_t id = tls1_shared_group(sc, larg); if (larg != -1) return tls1_group_id2nid(id, 1); return id; } case SSL_CTRL_GET_NEGOTIATED_GROUP: { unsigned int id; if (SSL_CONNECTION_IS_TLS13(sc) && sc->s3.did_kex) id = sc->s3.group_id; else id = sc->session->kex_group; ret = tls1_group_id2nid(id, 1); break; } case SSL_CTRL_SET_SIGALGS: return tls1_set_sigalgs(sc->cert, parg, larg, 0); case SSL_CTRL_SET_SIGALGS_LIST: return tls1_set_sigalgs_list(sc->cert, parg, 0); case SSL_CTRL_SET_CLIENT_SIGALGS: return tls1_set_sigalgs(sc->cert, parg, larg, 1); case SSL_CTRL_SET_CLIENT_SIGALGS_LIST: return tls1_set_sigalgs_list(sc->cert, parg, 1); case SSL_CTRL_GET_CLIENT_CERT_TYPES: { const unsigned char **pctype = parg; if (sc->server || !sc->s3.tmp.cert_req) return 0; if (pctype) *pctype = sc->s3.tmp.ctype; return sc->s3.tmp.ctype_len; } case SSL_CTRL_SET_CLIENT_CERT_TYPES: if (!sc->server) return 0; return ssl3_set_req_cert_type(sc->cert, parg, larg); case SSL_CTRL_BUILD_CERT_CHAIN: return ssl_build_cert_chain(sc, NULL, larg); case SSL_CTRL_SET_VERIFY_CERT_STORE: return ssl_cert_set_cert_store(sc->cert, parg, 0, larg); case SSL_CTRL_SET_CHAIN_CERT_STORE: return ssl_cert_set_cert_store(sc->cert, parg, 1, larg); case SSL_CTRL_GET_VERIFY_CERT_STORE: return ssl_cert_get_cert_store(sc->cert, parg, 0); case SSL_CTRL_GET_CHAIN_CERT_STORE: return ssl_cert_get_cert_store(sc->cert, parg, 1); case SSL_CTRL_GET_PEER_SIGNATURE_NID: if (sc->s3.tmp.peer_sigalg == NULL) return 0; *(int *)parg = sc->s3.tmp.peer_sigalg->hash; return 1; case SSL_CTRL_GET_SIGNATURE_NID: if (sc->s3.tmp.sigalg == NULL) return 0; *(int *)parg = sc->s3.tmp.sigalg->hash; return 1; case SSL_CTRL_GET_PEER_TMP_KEY: if (sc->session == NULL || sc->s3.peer_tmp == NULL) { return 0; } else { EVP_PKEY_up_ref(sc->s3.peer_tmp); *(EVP_PKEY **)parg = sc->s3.peer_tmp; return 1; } case SSL_CTRL_GET_TMP_KEY: if (sc->session == NULL || sc->s3.tmp.pkey == NULL) { return 0; } else { EVP_PKEY_up_ref(sc->s3.tmp.pkey); *(EVP_PKEY **)parg = sc->s3.tmp.pkey; return 1; } case SSL_CTRL_GET_EC_POINT_FORMATS: { const unsigned char **pformat = parg; if (sc->ext.peer_ecpointformats == NULL) return 0; *pformat = sc->ext.peer_ecpointformats; return (int)sc->ext.peer_ecpointformats_len; } case SSL_CTRL_GET_IANA_GROUPS: { if (parg != NULL) { *(uint16_t **)parg = (uint16_t *)sc->ext.peer_supportedgroups; } return (int)sc->ext.peer_supportedgroups_len; } case SSL_CTRL_SET_MSG_CALLBACK_ARG: sc->msg_callback_arg = parg; return 1; default: break; } return ret; } long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void)) { int ret = 0; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return ret; switch (cmd) { #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_DH_CB: sc->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp; ret = 1; break; #endif case SSL_CTRL_SET_TLSEXT_DEBUG_CB: sc->ext.debug_cb = (void (*)(SSL *, int, int, const unsigned char *, int, void *))fp; ret = 1; break; case SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB: sc->not_resumable_session_cb = (int (*)(SSL *, int))fp; ret = 1; break; case SSL_CTRL_SET_MSG_CALLBACK: sc->msg_callback = (ossl_msg_cb)fp; return 1; default: break; } return ret; } long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg) { switch (cmd) { #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_DH: { EVP_PKEY *pkdh = NULL; if (parg == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } pkdh = ssl_dh_to_pkey(parg); if (pkdh == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB); return 0; } if (!SSL_CTX_set0_tmp_dh_pkey(ctx, pkdh)) { EVP_PKEY_free(pkdh); return 0; } return 1; } case SSL_CTRL_SET_TMP_DH_CB: { ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return 0; } #endif case SSL_CTRL_SET_DH_AUTO: ctx->cert->dh_tmp_auto = larg; return 1; #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_ECDH: { if (parg == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return 0; } return ssl_set_tmp_ecdh_groups(&ctx->ext.supportedgroups, &ctx->ext.supportedgroups_len, parg); } #endif /* !OPENSSL_NO_DEPRECATED_3_0 */ case SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG: ctx->ext.servername_arg = parg; break; case SSL_CTRL_SET_TLSEXT_TICKET_KEYS: case SSL_CTRL_GET_TLSEXT_TICKET_KEYS: { unsigned char *keys = parg; long tick_keylen = (sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key) + sizeof(ctx->ext.secure->tick_aes_key)); if (keys == NULL) return tick_keylen; if (larg != tick_keylen) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_TICKET_KEYS_LENGTH); return 0; } if (cmd == SSL_CTRL_SET_TLSEXT_TICKET_KEYS) { memcpy(ctx->ext.tick_key_name, keys, sizeof(ctx->ext.tick_key_name)); memcpy(ctx->ext.secure->tick_hmac_key, keys + sizeof(ctx->ext.tick_key_name), sizeof(ctx->ext.secure->tick_hmac_key)); memcpy(ctx->ext.secure->tick_aes_key, keys + sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key), sizeof(ctx->ext.secure->tick_aes_key)); } else { memcpy(keys, ctx->ext.tick_key_name, sizeof(ctx->ext.tick_key_name)); memcpy(keys + sizeof(ctx->ext.tick_key_name), ctx->ext.secure->tick_hmac_key, sizeof(ctx->ext.secure->tick_hmac_key)); memcpy(keys + sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key), ctx->ext.secure->tick_aes_key, sizeof(ctx->ext.secure->tick_aes_key)); } return 1; } case SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE: return ctx->ext.status_type; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE: ctx->ext.status_type = larg; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG: ctx->ext.status_arg = parg; return 1; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG: *(void**)parg = ctx->ext.status_arg; break; case SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB: *(int (**)(SSL*, void*))parg = ctx->ext.status_cb; break; #ifndef OPENSSL_NO_SRP case SSL_CTRL_SET_TLS_EXT_SRP_USERNAME: ctx->srp_ctx.srp_Mask |= SSL_kSRP; OPENSSL_free(ctx->srp_ctx.login); ctx->srp_ctx.login = NULL; if (parg == NULL) break; if (strlen((const char *)parg) > 255 || strlen((const char *)parg) < 1) { ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SRP_USERNAME); return 0; } if ((ctx->srp_ctx.login = OPENSSL_strdup((char *)parg)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } break; case SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD: ctx->srp_ctx.SRP_give_srp_client_pwd_callback = srp_password_from_info_cb; if (ctx->srp_ctx.info != NULL) OPENSSL_free(ctx->srp_ctx.info); if ((ctx->srp_ctx.info = OPENSSL_strdup((char *)parg)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } break; case SSL_CTRL_SET_SRP_ARG: ctx->srp_ctx.srp_Mask |= SSL_kSRP; ctx->srp_ctx.SRP_cb_arg = parg; break; case SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH: ctx->srp_ctx.strength = larg; break; #endif case SSL_CTRL_SET_GROUPS: return tls1_set_groups(&ctx->ext.supportedgroups, &ctx->ext.supportedgroups_len, parg, larg); case SSL_CTRL_SET_GROUPS_LIST: return tls1_set_groups_list(ctx, &ctx->ext.supportedgroups, &ctx->ext.supportedgroups_len, parg); case SSL_CTRL_SET_SIGALGS: return tls1_set_sigalgs(ctx->cert, parg, larg, 0); case SSL_CTRL_SET_SIGALGS_LIST: return tls1_set_sigalgs_list(ctx->cert, parg, 0); case SSL_CTRL_SET_CLIENT_SIGALGS: return tls1_set_sigalgs(ctx->cert, parg, larg, 1); case SSL_CTRL_SET_CLIENT_SIGALGS_LIST: return tls1_set_sigalgs_list(ctx->cert, parg, 1); case SSL_CTRL_SET_CLIENT_CERT_TYPES: return ssl3_set_req_cert_type(ctx->cert, parg, larg); case SSL_CTRL_BUILD_CERT_CHAIN: return ssl_build_cert_chain(NULL, ctx, larg); case SSL_CTRL_SET_VERIFY_CERT_STORE: return ssl_cert_set_cert_store(ctx->cert, parg, 0, larg); case SSL_CTRL_SET_CHAIN_CERT_STORE: return ssl_cert_set_cert_store(ctx->cert, parg, 1, larg); case SSL_CTRL_GET_VERIFY_CERT_STORE: return ssl_cert_get_cert_store(ctx->cert, parg, 0); case SSL_CTRL_GET_CHAIN_CERT_STORE: return ssl_cert_get_cert_store(ctx->cert, parg, 1); /* A Thawte special :-) */ case SSL_CTRL_EXTRA_CHAIN_CERT: if (ctx->extra_certs == NULL) { if ((ctx->extra_certs = sk_X509_new_null()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 0; } } if (!sk_X509_push(ctx->extra_certs, (X509 *)parg)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 0; } break; case SSL_CTRL_GET_EXTRA_CHAIN_CERTS: if (ctx->extra_certs == NULL && larg == 0) *(STACK_OF(X509) **)parg = ctx->cert->key->chain; else *(STACK_OF(X509) **)parg = ctx->extra_certs; break; case SSL_CTRL_CLEAR_EXTRA_CHAIN_CERTS: OSSL_STACK_OF_X509_free(ctx->extra_certs); ctx->extra_certs = NULL; break; case SSL_CTRL_CHAIN: if (larg) return ssl_cert_set1_chain(NULL, ctx, (STACK_OF(X509) *)parg); else return ssl_cert_set0_chain(NULL, ctx, (STACK_OF(X509) *)parg); case SSL_CTRL_CHAIN_CERT: if (larg) return ssl_cert_add1_chain_cert(NULL, ctx, (X509 *)parg); else return ssl_cert_add0_chain_cert(NULL, ctx, (X509 *)parg); case SSL_CTRL_GET_CHAIN_CERTS: *(STACK_OF(X509) **)parg = ctx->cert->key->chain; break; case SSL_CTRL_SELECT_CURRENT_CERT: return ssl_cert_select_current(ctx->cert, (X509 *)parg); case SSL_CTRL_SET_CURRENT_CERT: return ssl_cert_set_current(ctx->cert, larg); default: return 0; } return 1; } long ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void)) { switch (cmd) { #if !defined(OPENSSL_NO_DEPRECATED_3_0) case SSL_CTRL_SET_TMP_DH_CB: { ctx->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp; } break; #endif case SSL_CTRL_SET_TLSEXT_SERVERNAME_CB: ctx->ext.servername_cb = (int (*)(SSL *, int *, void *))fp; break; case SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB: ctx->ext.status_cb = (int (*)(SSL *, void *))fp; break; # ifndef OPENSSL_NO_DEPRECATED_3_0 case SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB: ctx->ext.ticket_key_cb = (int (*)(SSL *, unsigned char *, unsigned char *, EVP_CIPHER_CTX *, HMAC_CTX *, int))fp; break; #endif #ifndef OPENSSL_NO_SRP case SSL_CTRL_SET_SRP_VERIFY_PARAM_CB: ctx->srp_ctx.srp_Mask |= SSL_kSRP; ctx->srp_ctx.SRP_verify_param_callback = (int (*)(SSL *, void *))fp; break; case SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB: ctx->srp_ctx.srp_Mask |= SSL_kSRP; ctx->srp_ctx.TLS_ext_srp_username_callback = (int (*)(SSL *, int *, void *))fp; break; case SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB: ctx->srp_ctx.srp_Mask |= SSL_kSRP; ctx->srp_ctx.SRP_give_srp_client_pwd_callback = (char *(*)(SSL *, void *))fp; break; #endif case SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB: { ctx->not_resumable_session_cb = (int (*)(SSL *, int))fp; } break; default: return 0; } return 1; } int SSL_CTX_set_tlsext_ticket_key_evp_cb (SSL_CTX *ctx, int (*fp)(SSL *, unsigned char *, unsigned char *, EVP_CIPHER_CTX *, EVP_MAC_CTX *, int)) { ctx->ext.ticket_key_evp_cb = fp; return 1; } const SSL_CIPHER *ssl3_get_cipher_by_id(uint32_t id) { SSL_CIPHER c; const SSL_CIPHER *cp; c.id = id; cp = OBJ_bsearch_ssl_cipher_id(&c, tls13_ciphers, TLS13_NUM_CIPHERS); if (cp != NULL) return cp; cp = OBJ_bsearch_ssl_cipher_id(&c, ssl3_ciphers, SSL3_NUM_CIPHERS); if (cp != NULL) return cp; return OBJ_bsearch_ssl_cipher_id(&c, ssl3_scsvs, SSL3_NUM_SCSVS); } const SSL_CIPHER *ssl3_get_cipher_by_std_name(const char *stdname) { SSL_CIPHER *tbl; SSL_CIPHER *alltabs[] = {tls13_ciphers, ssl3_ciphers, ssl3_scsvs}; size_t i, j, tblsize[] = {TLS13_NUM_CIPHERS, SSL3_NUM_CIPHERS, SSL3_NUM_SCSVS}; /* this is not efficient, necessary to optimize this? */ for (j = 0; j < OSSL_NELEM(alltabs); j++) { for (i = 0, tbl = alltabs[j]; i < tblsize[j]; i++, tbl++) { if (tbl->stdname == NULL) continue; if (strcmp(stdname, tbl->stdname) == 0) { return tbl; } } } return NULL; } /* * This function needs to check if the ciphers required are actually * available */ const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p) { return ssl3_get_cipher_by_id(SSL3_CK_CIPHERSUITE_FLAG | ((uint32_t)p[0] << 8L) | (uint32_t)p[1]); } int ssl3_put_cipher_by_char(const SSL_CIPHER *c, WPACKET *pkt, size_t *len) { if ((c->id & 0xff000000) != SSL3_CK_CIPHERSUITE_FLAG) { *len = 0; return 1; } if (!WPACKET_put_bytes_u16(pkt, c->id & 0xffff)) return 0; *len = 2; return 1; } /* * ssl3_choose_cipher - choose a cipher from those offered by the client * @s: SSL connection * @clnt: ciphers offered by the client * @srvr: ciphers enabled on the server? * * Returns the selected cipher or NULL when no common ciphers. */ const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *clnt, STACK_OF(SSL_CIPHER) *srvr) { const SSL_CIPHER *c, *ret = NULL; STACK_OF(SSL_CIPHER) *prio, *allow; int i, ii, ok, prefer_sha256 = 0; unsigned long alg_k = 0, alg_a = 0, mask_k = 0, mask_a = 0; STACK_OF(SSL_CIPHER) *prio_chacha = NULL; /* Let's see which ciphers we can support */ /* * Do not set the compare functions, because this may lead to a * reordering by "id". We want to keep the original ordering. We may pay * a price in performance during sk_SSL_CIPHER_find(), but would have to * pay with the price of sk_SSL_CIPHER_dup(). */ OSSL_TRACE_BEGIN(TLS_CIPHER) { BIO_printf(trc_out, "Server has %d from %p:\n", sk_SSL_CIPHER_num(srvr), (void *)srvr); for (i = 0; i < sk_SSL_CIPHER_num(srvr); ++i) { c = sk_SSL_CIPHER_value(srvr, i); BIO_printf(trc_out, "%p:%s\n", (void *)c, c->name); } BIO_printf(trc_out, "Client sent %d from %p:\n", sk_SSL_CIPHER_num(clnt), (void *)clnt); for (i = 0; i < sk_SSL_CIPHER_num(clnt); ++i) { c = sk_SSL_CIPHER_value(clnt, i); BIO_printf(trc_out, "%p:%s\n", (void *)c, c->name); } } OSSL_TRACE_END(TLS_CIPHER); /* SUITE-B takes precedence over server preference and ChaCha priortiy */ if (tls1_suiteb(s)) { prio = srvr; allow = clnt; } else if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) { prio = srvr; allow = clnt; /* If ChaCha20 is at the top of the client preference list, and there are ChaCha20 ciphers in the server list, then temporarily prioritize all ChaCha20 ciphers in the servers list. */ if (s->options & SSL_OP_PRIORITIZE_CHACHA && sk_SSL_CIPHER_num(clnt) > 0) { c = sk_SSL_CIPHER_value(clnt, 0); if (c->algorithm_enc == SSL_CHACHA20POLY1305) { /* ChaCha20 is client preferred, check server... */ int num = sk_SSL_CIPHER_num(srvr); int found = 0; for (i = 0; i < num; i++) { c = sk_SSL_CIPHER_value(srvr, i); if (c->algorithm_enc == SSL_CHACHA20POLY1305) { found = 1; break; } } if (found) { prio_chacha = sk_SSL_CIPHER_new_reserve(NULL, num); /* if reserve fails, then there's likely a memory issue */ if (prio_chacha != NULL) { /* Put all ChaCha20 at the top, starting with the one we just found */ sk_SSL_CIPHER_push(prio_chacha, c); for (i++; i < num; i++) { c = sk_SSL_CIPHER_value(srvr, i); if (c->algorithm_enc == SSL_CHACHA20POLY1305) sk_SSL_CIPHER_push(prio_chacha, c); } /* Pull in the rest */ for (i = 0; i < num; i++) { c = sk_SSL_CIPHER_value(srvr, i); if (c->algorithm_enc != SSL_CHACHA20POLY1305) sk_SSL_CIPHER_push(prio_chacha, c); } prio = prio_chacha; } } } } } else { prio = clnt; allow = srvr; } if (SSL_CONNECTION_IS_TLS13(s)) { #ifndef OPENSSL_NO_PSK size_t j; /* * If we allow "old" style PSK callbacks, and we have no certificate (so * we're not going to succeed without a PSK anyway), and we're in * TLSv1.3 then the default hash for a PSK is SHA-256 (as per the * TLSv1.3 spec). Therefore we should prioritise ciphersuites using * that. */ if (s->psk_server_callback != NULL) { for (j = 0; j < s->ssl_pkey_num && !ssl_has_cert(s, j); j++); if (j == s->ssl_pkey_num) { /* There are no certificates */ prefer_sha256 = 1; } } #endif } else { tls1_set_cert_validity(s); ssl_set_masks(s); } for (i = 0; i < sk_SSL_CIPHER_num(prio); i++) { int minversion, maxversion; c = sk_SSL_CIPHER_value(prio, i); minversion = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls; maxversion = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls; /* Skip ciphers not supported by the protocol version */ if (ssl_version_cmp(s, s->version, minversion) < 0 || ssl_version_cmp(s, s->version, maxversion) > 0) continue; /* * Since TLS 1.3 ciphersuites can be used with any auth or * key exchange scheme skip tests. */ if (!SSL_CONNECTION_IS_TLS13(s)) { mask_k = s->s3.tmp.mask_k; mask_a = s->s3.tmp.mask_a; #ifndef OPENSSL_NO_SRP if (s->srp_ctx.srp_Mask & SSL_kSRP) { mask_k |= SSL_kSRP; mask_a |= SSL_aSRP; } #endif alg_k = c->algorithm_mkey; alg_a = c->algorithm_auth; #ifndef OPENSSL_NO_PSK /* with PSK there must be server callback set */ if ((alg_k & SSL_PSK) && s->psk_server_callback == NULL) continue; #endif /* OPENSSL_NO_PSK */ ok = (alg_k & mask_k) && (alg_a & mask_a); OSSL_TRACE7(TLS_CIPHER, "%d:[%08lX:%08lX:%08lX:%08lX]%p:%s\n", ok, alg_k, alg_a, mask_k, mask_a, (void *)c, c->name); /* * if we are considering an ECC cipher suite that uses an ephemeral * EC key check it */ if (alg_k & SSL_kECDHE) ok = ok && tls1_check_ec_tmp_key(s, c->id); if (!ok) continue; } ii = sk_SSL_CIPHER_find(allow, c); if (ii >= 0) { /* Check security callback permits this cipher */ if (!ssl_security(s, SSL_SECOP_CIPHER_SHARED, c->strength_bits, 0, (void *)c)) continue; if ((alg_k & SSL_kECDHE) && (alg_a & SSL_aECDSA) && s->s3.is_probably_safari) { if (!ret) ret = sk_SSL_CIPHER_value(allow, ii); continue; } if (prefer_sha256) { const SSL_CIPHER *tmp = sk_SSL_CIPHER_value(allow, ii); const EVP_MD *md = ssl_md(SSL_CONNECTION_GET_CTX(s), tmp->algorithm2); if (md != NULL && EVP_MD_is_a(md, OSSL_DIGEST_NAME_SHA2_256)) { ret = tmp; break; } if (ret == NULL) ret = tmp; continue; } ret = sk_SSL_CIPHER_value(allow, ii); break; } } sk_SSL_CIPHER_free(prio_chacha); return ret; } int ssl3_get_req_cert_type(SSL_CONNECTION *s, WPACKET *pkt) { uint32_t alg_k, alg_a = 0; /* If we have custom certificate types set, use them */ if (s->cert->ctype) return WPACKET_memcpy(pkt, s->cert->ctype, s->cert->ctype_len); /* Get mask of algorithms disabled by signature list */ ssl_set_sig_mask(&alg_a, s, SSL_SECOP_SIGALG_MASK); alg_k = s->s3.tmp.new_cipher->algorithm_mkey; #ifndef OPENSSL_NO_GOST if (s->version >= TLS1_VERSION && (alg_k & SSL_kGOST)) if (!WPACKET_put_bytes_u8(pkt, TLS_CT_GOST01_SIGN) || !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_IANA_SIGN) || !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_IANA_512_SIGN) || !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_LEGACY_SIGN) || !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_LEGACY_512_SIGN)) return 0; if (s->version >= TLS1_2_VERSION && (alg_k & SSL_kGOST18)) if (!WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_IANA_SIGN) || !WPACKET_put_bytes_u8(pkt, TLS_CT_GOST12_IANA_512_SIGN)) return 0; #endif if ((s->version == SSL3_VERSION) && (alg_k & SSL_kDHE)) { if (!WPACKET_put_bytes_u8(pkt, SSL3_CT_RSA_EPHEMERAL_DH)) return 0; if (!(alg_a & SSL_aDSS) && !WPACKET_put_bytes_u8(pkt, SSL3_CT_DSS_EPHEMERAL_DH)) return 0; } if (!(alg_a & SSL_aRSA) && !WPACKET_put_bytes_u8(pkt, SSL3_CT_RSA_SIGN)) return 0; if (!(alg_a & SSL_aDSS) && !WPACKET_put_bytes_u8(pkt, SSL3_CT_DSS_SIGN)) return 0; /* * ECDSA certs can be used with RSA cipher suites too so we don't * need to check for SSL_kECDH or SSL_kECDHE */ if (s->version >= TLS1_VERSION && !(alg_a & SSL_aECDSA) && !WPACKET_put_bytes_u8(pkt, TLS_CT_ECDSA_SIGN)) return 0; return 1; } static int ssl3_set_req_cert_type(CERT *c, const unsigned char *p, size_t len) { OPENSSL_free(c->ctype); c->ctype = NULL; c->ctype_len = 0; if (p == NULL || len == 0) return 1; if (len > 0xff) return 0; c->ctype = OPENSSL_memdup(p, len); if (c->ctype == NULL) return 0; c->ctype_len = len; return 1; } int ssl3_shutdown(SSL *s) { int ret; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; /* * Don't do anything much if we have not done the handshake or we don't * want to send messages :-) */ if (sc->quiet_shutdown || SSL_in_before(s)) { sc->shutdown = (SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN); return 1; } if (!(sc->shutdown & SSL_SENT_SHUTDOWN)) { sc->shutdown |= SSL_SENT_SHUTDOWN; ssl3_send_alert(sc, SSL3_AL_WARNING, SSL_AD_CLOSE_NOTIFY); /* * our shutdown alert has been sent now, and if it still needs to be * written, s->s3.alert_dispatch will be > 0 */ if (sc->s3.alert_dispatch > 0) return -1; /* return WANT_WRITE */ } else if (sc->s3.alert_dispatch > 0) { /* resend it if not sent */ ret = s->method->ssl_dispatch_alert(s); if (ret == -1) { /* * we only get to return -1 here the 2nd/Nth invocation, we must * have already signalled return 0 upon a previous invocation, * return WANT_WRITE */ return ret; } } else if (!(sc->shutdown & SSL_RECEIVED_SHUTDOWN)) { size_t readbytes; /* * If we are waiting for a close from our peer, we are closed */ s->method->ssl_read_bytes(s, 0, NULL, NULL, 0, 0, &readbytes); if (!(sc->shutdown & SSL_RECEIVED_SHUTDOWN)) { return -1; /* return WANT_READ */ } } if ((sc->shutdown == (SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN)) && sc->s3.alert_dispatch == SSL_ALERT_DISPATCH_NONE) return 1; else return 0; } int ssl3_write(SSL *s, const void *buf, size_t len, size_t *written) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; clear_sys_error(); if (sc->s3.renegotiate) ssl3_renegotiate_check(s, 0); return s->method->ssl_write_bytes(s, SSL3_RT_APPLICATION_DATA, buf, len, written); } static int ssl3_read_internal(SSL *s, void *buf, size_t len, int peek, size_t *readbytes) { int ret; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; clear_sys_error(); if (sc->s3.renegotiate) ssl3_renegotiate_check(s, 0); sc->s3.in_read_app_data = 1; ret = s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf, len, peek, readbytes); if ((ret == -1) && (sc->s3.in_read_app_data == 2)) { /* * ssl3_read_bytes decided to call s->handshake_func, which called * ssl3_read_bytes to read handshake data. However, ssl3_read_bytes * actually found application data and thinks that application data * makes sense here; so disable handshake processing and try to read * application data again. */ ossl_statem_set_in_handshake(sc, 1); ret = s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf, len, peek, readbytes); ossl_statem_set_in_handshake(sc, 0); } else sc->s3.in_read_app_data = 0; return ret; } int ssl3_read(SSL *s, void *buf, size_t len, size_t *readbytes) { return ssl3_read_internal(s, buf, len, 0, readbytes); } int ssl3_peek(SSL *s, void *buf, size_t len, size_t *readbytes) { return ssl3_read_internal(s, buf, len, 1, readbytes); } int ssl3_renegotiate(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (sc->handshake_func == NULL) return 1; sc->s3.renegotiate = 1; return 1; } /* * Check if we are waiting to do a renegotiation and if so whether now is a * good time to do it. If |initok| is true then we are being called from inside * the state machine so ignore the result of SSL_in_init(s). Otherwise we * should not do a renegotiation if SSL_in_init(s) is true. Returns 1 if we * should do a renegotiation now and sets up the state machine for it. Otherwise * returns 0. */ int ssl3_renegotiate_check(SSL *s, int initok) { int ret = 0; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s); if (sc == NULL) return 0; if (sc->s3.renegotiate) { if (!RECORD_LAYER_read_pending(&sc->rlayer) && !RECORD_LAYER_write_pending(&sc->rlayer) && (initok || !SSL_in_init(s))) { /* * if we are the server, and we have sent a 'RENEGOTIATE' * message, we need to set the state machine into the renegotiate * state. */ ossl_statem_set_renegotiate(sc); sc->s3.renegotiate = 0; sc->s3.num_renegotiations++; sc->s3.total_renegotiations++; ret = 1; } } return ret; } /* * If we are using default SHA1+MD5 algorithms switch to new SHA256 PRF and * handshake macs if required. * * If PSK and using SHA384 for TLS < 1.2 switch to default. */ long ssl_get_algorithm2(SSL_CONNECTION *s) { long alg2; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->s3.tmp.new_cipher == NULL) return -1; alg2 = s->s3.tmp.new_cipher->algorithm2; if (ssl->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SHA256_PRF) { if (alg2 == (SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF)) return SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256; } else if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK) { if (alg2 == (SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384)) return SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF; } return alg2; } /* * Fill a ClientRandom or ServerRandom field of length len. Returns <= 0 on * failure, 1 on success. */ int ssl_fill_hello_random(SSL_CONNECTION *s, int server, unsigned char *result, size_t len, DOWNGRADE dgrd) { int send_time = 0, ret; if (len < 4) return 0; if (server) send_time = (s->mode & SSL_MODE_SEND_SERVERHELLO_TIME) != 0; else send_time = (s->mode & SSL_MODE_SEND_CLIENTHELLO_TIME) != 0; if (send_time) { unsigned long Time = (unsigned long)time(NULL); unsigned char *p = result; l2n(Time, p); ret = RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, p, len - 4, 0); } else { ret = RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, result, len, 0); } if (ret > 0) { if (!ossl_assert(sizeof(tls11downgrade) < len) || !ossl_assert(sizeof(tls12downgrade) < len)) return 0; if (dgrd == DOWNGRADE_TO_1_2) memcpy(result + len - sizeof(tls12downgrade), tls12downgrade, sizeof(tls12downgrade)); else if (dgrd == DOWNGRADE_TO_1_1) memcpy(result + len - sizeof(tls11downgrade), tls11downgrade, sizeof(tls11downgrade)); } return ret; } int ssl_generate_master_secret(SSL_CONNECTION *s, unsigned char *pms, size_t pmslen, int free_pms) { unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey; int ret = 0; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (alg_k & SSL_PSK) { #ifndef OPENSSL_NO_PSK unsigned char *pskpms, *t; size_t psklen = s->s3.tmp.psklen; size_t pskpmslen; /* create PSK premaster_secret */ /* For plain PSK "other_secret" is psklen zeroes */ if (alg_k & SSL_kPSK) pmslen = psklen; pskpmslen = 4 + pmslen + psklen; pskpms = OPENSSL_malloc(pskpmslen); if (pskpms == NULL) goto err; t = pskpms; s2n(pmslen, t); if (alg_k & SSL_kPSK) memset(t, 0, pmslen); else memcpy(t, pms, pmslen); t += pmslen; s2n(psklen, t); memcpy(t, s->s3.tmp.psk, psklen); OPENSSL_clear_free(s->s3.tmp.psk, psklen); s->s3.tmp.psk = NULL; s->s3.tmp.psklen = 0; if (!ssl->method->ssl3_enc->generate_master_secret(s, s->session->master_key, pskpms, pskpmslen, &s->session->master_key_length)) { OPENSSL_clear_free(pskpms, pskpmslen); /* SSLfatal() already called */ goto err; } OPENSSL_clear_free(pskpms, pskpmslen); #else /* Should never happen */ goto err; #endif } else { if (!ssl->method->ssl3_enc->generate_master_secret(s, s->session->master_key, pms, pmslen, &s->session->master_key_length)) { /* SSLfatal() already called */ goto err; } } ret = 1; err: if (pms) { if (free_pms) OPENSSL_clear_free(pms, pmslen); else OPENSSL_cleanse(pms, pmslen); } if (s->server == 0) { s->s3.tmp.pms = NULL; s->s3.tmp.pmslen = 0; } return ret; } /* Generate a private key from parameters */ EVP_PKEY *ssl_generate_pkey(SSL_CONNECTION *s, EVP_PKEY *pm) { EVP_PKEY_CTX *pctx = NULL; EVP_PKEY *pkey = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (pm == NULL) return NULL; pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pm, sctx->propq); if (pctx == NULL) goto err; if (EVP_PKEY_keygen_init(pctx) <= 0) goto err; if (EVP_PKEY_keygen(pctx, &pkey) <= 0) { EVP_PKEY_free(pkey); pkey = NULL; } err: EVP_PKEY_CTX_free(pctx); return pkey; } /* Generate a private key from a group ID */ EVP_PKEY *ssl_generate_pkey_group(SSL_CONNECTION *s, uint16_t id) { SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); const TLS_GROUP_INFO *ginf = tls1_group_id_lookup(sctx, id); EVP_PKEY_CTX *pctx = NULL; EVP_PKEY *pkey = NULL; if (ginf == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, ginf->algorithm, sctx->propq); if (pctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_keygen_init(pctx) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_CTX_set_group_name(pctx, ginf->realname) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_keygen(pctx, &pkey) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); EVP_PKEY_free(pkey); pkey = NULL; } err: EVP_PKEY_CTX_free(pctx); return pkey; } /* * Generate parameters from a group ID */ EVP_PKEY *ssl_generate_param_group(SSL_CONNECTION *s, uint16_t id) { SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); EVP_PKEY_CTX *pctx = NULL; EVP_PKEY *pkey = NULL; const TLS_GROUP_INFO *ginf = tls1_group_id_lookup(sctx, id); if (ginf == NULL) goto err; pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, ginf->algorithm, sctx->propq); if (pctx == NULL) goto err; if (EVP_PKEY_paramgen_init(pctx) <= 0) goto err; if (EVP_PKEY_CTX_set_group_name(pctx, ginf->realname) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_paramgen(pctx, &pkey) <= 0) { EVP_PKEY_free(pkey); pkey = NULL; } err: EVP_PKEY_CTX_free(pctx); return pkey; } /* Generate secrets from pms */ int ssl_gensecret(SSL_CONNECTION *s, unsigned char *pms, size_t pmslen) { int rv = 0; /* SSLfatal() called as appropriate in the below functions */ if (SSL_CONNECTION_IS_TLS13(s)) { /* * If we are resuming then we already generated the early secret * when we created the ClientHello, so don't recreate it. */ if (!s->hit) rv = tls13_generate_secret(s, ssl_handshake_md(s), NULL, NULL, 0, (unsigned char *)&s->early_secret); else rv = 1; rv = rv && tls13_generate_handshake_secret(s, pms, pmslen); } else { rv = ssl_generate_master_secret(s, pms, pmslen, 0); } return rv; } /* Derive secrets for ECDH/DH */ int ssl_derive(SSL_CONNECTION *s, EVP_PKEY *privkey, EVP_PKEY *pubkey, int gensecret) { int rv = 0; unsigned char *pms = NULL; size_t pmslen = 0; EVP_PKEY_CTX *pctx; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (privkey == NULL || pubkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, privkey, sctx->propq); if (EVP_PKEY_derive_init(pctx) <= 0 || EVP_PKEY_derive_set_peer(pctx, pubkey) <= 0 || EVP_PKEY_derive(pctx, NULL, &pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (SSL_CONNECTION_IS_TLS13(s) && EVP_PKEY_is_a(privkey, "DH")) EVP_PKEY_CTX_set_dh_pad(pctx, 1); pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (EVP_PKEY_derive(pctx, pms, &pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (gensecret) { /* SSLfatal() called as appropriate in the below functions */ rv = ssl_gensecret(s, pms, pmslen); } else { /* Save premaster secret */ s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; pms = NULL; rv = 1; } err: OPENSSL_clear_free(pms, pmslen); EVP_PKEY_CTX_free(pctx); return rv; } /* Decapsulate secrets for KEM */ int ssl_decapsulate(SSL_CONNECTION *s, EVP_PKEY *privkey, const unsigned char *ct, size_t ctlen, int gensecret) { int rv = 0; unsigned char *pms = NULL; size_t pmslen = 0; EVP_PKEY_CTX *pctx; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (privkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, privkey, sctx->propq); if (EVP_PKEY_decapsulate_init(pctx, NULL) <= 0 || EVP_PKEY_decapsulate(pctx, NULL, &pmslen, ct, ctlen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (EVP_PKEY_decapsulate(pctx, pms, &pmslen, ct, ctlen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (gensecret) { /* SSLfatal() called as appropriate in the below functions */ rv = ssl_gensecret(s, pms, pmslen); } else { /* Save premaster secret */ s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; pms = NULL; rv = 1; } err: OPENSSL_clear_free(pms, pmslen); EVP_PKEY_CTX_free(pctx); return rv; } int ssl_encapsulate(SSL_CONNECTION *s, EVP_PKEY *pubkey, unsigned char **ctp, size_t *ctlenp, int gensecret) { int rv = 0; unsigned char *pms = NULL, *ct = NULL; size_t pmslen = 0, ctlen = 0; EVP_PKEY_CTX *pctx; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (pubkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pubkey, sctx->propq); if (EVP_PKEY_encapsulate_init(pctx, NULL) <= 0 || EVP_PKEY_encapsulate(pctx, NULL, &ctlen, NULL, &pmslen) <= 0 || pmslen == 0 || ctlen == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pms = OPENSSL_malloc(pmslen); ct = OPENSSL_malloc(ctlen); if (pms == NULL || ct == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (EVP_PKEY_encapsulate(pctx, ct, &ctlen, pms, &pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (gensecret) { /* SSLfatal() called as appropriate in the below functions */ rv = ssl_gensecret(s, pms, pmslen); } else { /* Save premaster secret */ s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; pms = NULL; rv = 1; } if (rv > 0) { /* Pass ownership of ct to caller */ *ctp = ct; *ctlenp = ctlen; ct = NULL; } err: OPENSSL_clear_free(pms, pmslen); OPENSSL_free(ct); EVP_PKEY_CTX_free(pctx); return rv; } const char *SSL_get0_group_name(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); unsigned int id; if (sc == NULL) return NULL; if (SSL_CONNECTION_IS_TLS13(sc) && sc->s3.did_kex) id = sc->s3.group_id; else id = sc->session->kex_group; return tls1_group_id2name(s->ctx, id); } const char *SSL_group_to_name(SSL *s, int nid) { int group_id = 0; const TLS_GROUP_INFO *cinf = NULL; /* first convert to real group id for internal and external IDs */ if (nid & TLSEXT_nid_unknown) group_id = nid & 0xFFFF; else group_id = tls1_nid2group_id(nid); /* then look up */ cinf = tls1_group_id_lookup(s->ctx, group_id); if (cinf != NULL) return cinf->tlsname; return NULL; }

./openssl/ssl/statem/extensions_srvr.c

/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/ocsp.h> #include "../ssl_local.h" #include "statem_local.h" #include "internal/cryptlib.h" #define COOKIE_STATE_FORMAT_VERSION 1 /* * 2 bytes for packet length, 2 bytes for format version, 2 bytes for * protocol version, 2 bytes for group id, 2 bytes for cipher id, 1 byte for * key_share present flag, 8 bytes for timestamp, 2 bytes for the hashlen, * EVP_MAX_MD_SIZE for transcript hash, 1 byte for app cookie length, app cookie * length bytes, SHA256_DIGEST_LENGTH bytes for the HMAC of the whole thing. */ #define MAX_COOKIE_SIZE (2 + 2 + 2 + 2 + 2 + 1 + 8 + 2 + EVP_MAX_MD_SIZE + 1 \ + SSL_COOKIE_LENGTH + SHA256_DIGEST_LENGTH) /* * Message header + 2 bytes for protocol version + number of random bytes + * + 1 byte for legacy session id length + number of bytes in legacy session id * + 2 bytes for ciphersuite + 1 byte for legacy compression * + 2 bytes for extension block length + 6 bytes for key_share extension * + 4 bytes for cookie extension header + the number of bytes in the cookie */ #define MAX_HRR_SIZE (SSL3_HM_HEADER_LENGTH + 2 + SSL3_RANDOM_SIZE + 1 \ + SSL_MAX_SSL_SESSION_ID_LENGTH + 2 + 1 + 2 + 6 + 4 \ + MAX_COOKIE_SIZE) /* * Parse the client's renegotiation binding and abort if it's not right */ int tls_parse_ctos_renegotiate(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned int ilen; const unsigned char *data; int ok; /* Parse the length byte */ if (!PACKET_get_1(pkt, &ilen) || !PACKET_get_bytes(pkt, &data, ilen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RENEGOTIATION_ENCODING_ERR); return 0; } /* Check that the extension matches */ if (ilen != s->s3.previous_client_finished_len) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_RENEGOTIATION_MISMATCH); return 0; } ok = memcmp(data, s->s3.previous_client_finished, s->s3.previous_client_finished_len); #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if (ok) { if ((data[0] ^ s->s3.previous_client_finished[0]) != 0xFF) { ok = 0; } } #endif if (ok) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_RENEGOTIATION_MISMATCH); return 0; } s->s3.send_connection_binding = 1; return 1; } /*- * The servername extension is treated as follows: * * - Only the hostname type is supported with a maximum length of 255. * - The servername is rejected if too long or if it contains zeros, * in which case an fatal alert is generated. * - The servername field is maintained together with the session cache. * - When a session is resumed, the servername call back invoked in order * to allow the application to position itself to the right context. * - The servername is acknowledged if it is new for a session or when * it is identical to a previously used for the same session. * Applications can control the behaviour. They can at any time * set a 'desirable' servername for a new SSL object. This can be the * case for example with HTTPS when a Host: header field is received and * a renegotiation is requested. In this case, a possible servername * presented in the new client hello is only acknowledged if it matches * the value of the Host: field. * - Applications must use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION * if they provide for changing an explicit servername context for the * session, i.e. when the session has been established with a servername * extension. * - On session reconnect, the servername extension may be absent. */ int tls_parse_ctos_server_name(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned int servname_type; PACKET sni, hostname; if (!PACKET_as_length_prefixed_2(pkt, &sni) /* ServerNameList must be at least 1 byte long. */ || PACKET_remaining(&sni) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* * Although the intent was for server_name to be extensible, RFC 4366 * was not clear about it; and so OpenSSL among other implementations, * always and only allows a 'host_name' name types. * RFC 6066 corrected the mistake but adding new name types * is nevertheless no longer feasible, so act as if no other * SNI types can exist, to simplify parsing. * * Also note that the RFC permits only one SNI value per type, * i.e., we can only have a single hostname. */ if (!PACKET_get_1(&sni, &servname_type) || servname_type != TLSEXT_NAMETYPE_host_name || !PACKET_as_length_prefixed_2(&sni, &hostname)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* * In TLSv1.2 and below the SNI is associated with the session. In TLSv1.3 * we always use the SNI value from the handshake. */ if (!s->hit || SSL_CONNECTION_IS_TLS13(s)) { if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) { SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME, SSL_R_BAD_EXTENSION); return 0; } if (PACKET_contains_zero_byte(&hostname)) { SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME, SSL_R_BAD_EXTENSION); return 0; } /* * Store the requested SNI in the SSL as temporary storage. * If we accept it, it will get stored in the SSL_SESSION as well. */ OPENSSL_free(s->ext.hostname); s->ext.hostname = NULL; if (!PACKET_strndup(&hostname, &s->ext.hostname)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->servername_done = 1; } else { /* * In TLSv1.2 and below we should check if the SNI is consistent between * the initial handshake and the resumption. In TLSv1.3 SNI is not * associated with the session. */ s->servername_done = (s->session->ext.hostname != NULL) && PACKET_equal(&hostname, s->session->ext.hostname, strlen(s->session->ext.hostname)); } return 1; } int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned int value; if (PACKET_remaining(pkt) != 1 || !PACKET_get_1(pkt, &value)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* Received |value| should be a valid max-fragment-length code. */ if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } /* * RFC 6066: The negotiated length applies for the duration of the session * including session resumptions. * We should receive the same code as in resumed session ! */ if (s->hit && s->session->ext.max_fragment_len_mode != value) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } /* * Store it in session, so it'll become binding for us * and we'll include it in a next Server Hello. */ s->session->ext.max_fragment_len_mode = value; return 1; } #ifndef OPENSSL_NO_SRP int tls_parse_ctos_srp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET srp_I; if (!PACKET_as_length_prefixed_1(pkt, &srp_I) || PACKET_contains_zero_byte(&srp_I)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } #endif int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET ec_point_format_list; if (!PACKET_as_length_prefixed_1(pkt, &ec_point_format_list) || PACKET_remaining(&ec_point_format_list) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit) { if (!PACKET_memdup(&ec_point_format_list, &s->ext.peer_ecpointformats, &s->ext.peer_ecpointformats_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_parse_ctos_session_ticket(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->ext.session_ticket_cb && !s->ext.session_ticket_cb(SSL_CONNECTION_GET_SSL(s), PACKET_data(pkt), PACKET_remaining(pkt), s->ext.session_ticket_cb_arg)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION *s, PACKET *pkt, ossl_unused unsigned int context, ossl_unused X509 *x, ossl_unused size_t chainidx) { PACKET supported_sig_algs; if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs) || PACKET_remaining(&supported_sig_algs) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit && !tls1_save_sigalgs(s, &supported_sig_algs, 1)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } return 1; } int tls_parse_ctos_sig_algs(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET supported_sig_algs; if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs) || PACKET_remaining(&supported_sig_algs) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit && !tls1_save_sigalgs(s, &supported_sig_algs, 0)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } return 1; } #ifndef OPENSSL_NO_OCSP int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET responder_id_list, exts; /* We ignore this in a resumption handshake */ if (s->hit) return 1; /* Not defined if we get one of these in a client Certificate */ if (x != NULL) return 1; if (!PACKET_get_1(pkt, (unsigned int *)&s->ext.status_type)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) { /* * We don't know what to do with any other type so ignore it. */ s->ext.status_type = TLSEXT_STATUSTYPE_nothing; return 1; } if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* * We remove any OCSP_RESPIDs from a previous handshake * to prevent unbounded memory growth - CVE-2016-6304 */ sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free); if (PACKET_remaining(&responder_id_list) > 0) { s->ext.ocsp.ids = sk_OCSP_RESPID_new_null(); if (s->ext.ocsp.ids == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } } else { s->ext.ocsp.ids = NULL; } while (PACKET_remaining(&responder_id_list) > 0) { OCSP_RESPID *id; PACKET responder_id; const unsigned char *id_data; if (!PACKET_get_length_prefixed_2(&responder_id_list, &responder_id) || PACKET_remaining(&responder_id) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } id_data = PACKET_data(&responder_id); id = d2i_OCSP_RESPID(NULL, &id_data, (int)PACKET_remaining(&responder_id)); if (id == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (id_data != PACKET_end(&responder_id)) { OCSP_RESPID_free(id); SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!sk_OCSP_RESPID_push(s->ext.ocsp.ids, id)) { OCSP_RESPID_free(id); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } /* Read in request_extensions */ if (!PACKET_as_length_prefixed_2(pkt, &exts)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (PACKET_remaining(&exts) > 0) { const unsigned char *ext_data = PACKET_data(&exts); sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts, X509_EXTENSION_free); s->ext.ocsp.exts = d2i_X509_EXTENSIONS(NULL, &ext_data, (int)PACKET_remaining(&exts)); if (s->ext.ocsp.exts == NULL || ext_data != PACKET_end(&exts)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } } return 1; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG int tls_parse_ctos_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { /* * We shouldn't accept this extension on a * renegotiation. */ if (SSL_IS_FIRST_HANDSHAKE(s)) s->s3.npn_seen = 1; return 1; } #endif /* * Save the ALPN extension in a ClientHello.|pkt| holds the contents of the ALPN * extension, not including type and length. Returns: 1 on success, 0 on error. */ int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET protocol_list, save_protocol_list, protocol; if (!SSL_IS_FIRST_HANDSHAKE(s)) return 1; if (!PACKET_as_length_prefixed_2(pkt, &protocol_list) || PACKET_remaining(&protocol_list) < 2) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } save_protocol_list = protocol_list; do { /* Protocol names can't be empty. */ if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol) || PACKET_remaining(&protocol) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } } while (PACKET_remaining(&protocol_list) != 0); OPENSSL_free(s->s3.alpn_proposed); s->s3.alpn_proposed = NULL; s->s3.alpn_proposed_len = 0; if (!PACKET_memdup(&save_protocol_list, &s->s3.alpn_proposed, &s->s3.alpn_proposed_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } #ifndef OPENSSL_NO_SRTP int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { STACK_OF(SRTP_PROTECTION_PROFILE) *srvr; unsigned int ct, mki_len, id; int i, srtp_pref; PACKET subpkt; SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* Ignore this if we have no SRTP profiles */ if (SSL_get_srtp_profiles(ssl) == NULL) return 1; /* Pull off the length of the cipher suite list and check it is even */ if (!PACKET_get_net_2(pkt, &ct) || (ct & 1) != 0 || !PACKET_get_sub_packet(pkt, &subpkt, ct)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } srvr = SSL_get_srtp_profiles(ssl); s->srtp_profile = NULL; /* Search all profiles for a match initially */ srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr); while (PACKET_remaining(&subpkt)) { if (!PACKET_get_net_2(&subpkt, &id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } /* * Only look for match in profiles of higher preference than * current match. * If no profiles have been have been configured then this * does nothing. */ for (i = 0; i < srtp_pref; i++) { SRTP_PROTECTION_PROFILE *sprof = sk_SRTP_PROTECTION_PROFILE_value(srvr, i); if (sprof->id == id) { s->srtp_profile = sprof; srtp_pref = i; break; } } } /* Now extract the MKI value as a sanity check, but discard it for now */ if (!PACKET_get_1(pkt, &mki_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } if (!PACKET_forward(pkt, mki_len) || PACKET_remaining(pkt)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_MKI_VALUE); return 0; } return 1; } #endif int tls_parse_ctos_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)) s->ext.use_etm = 1; return 1; } /* * Process a psk_kex_modes extension received in the ClientHello. |pkt| contains * the raw PACKET data for the extension. Returns 1 on success or 0 on failure. */ int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 PACKET psk_kex_modes; unsigned int mode; if (!PACKET_as_length_prefixed_1(pkt, &psk_kex_modes) || PACKET_remaining(&psk_kex_modes) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } while (PACKET_get_1(&psk_kex_modes, &mode)) { if (mode == TLSEXT_KEX_MODE_KE_DHE) s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE_DHE; else if (mode == TLSEXT_KEX_MODE_KE && (s->options & SSL_OP_ALLOW_NO_DHE_KEX) != 0) s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE; } if (((s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) != 0) && (s->options & SSL_OP_PREFER_NO_DHE_KEX) != 0) { /* * If NO_DHE is supported and preferred, then we only remember this * mode. DHE PSK will not be used for sure, because in any case where * it would be supported (i.e. if a key share is present), NO_DHE would * be supported as well. As the latter is preferred it would be * chosen. By removing DHE PSK here, we don't have to deal with the * SSL_OP_PREFER_NO_DHE_KEX option in any other place. */ s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_KE; } #endif return 1; } /* * Process a key_share extension received in the ClientHello. |pkt| contains * the raw PACKET data for the extension. Returns 1 on success or 0 on failure. */ int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned int group_id; PACKET key_share_list, encoded_pt; const uint16_t *clntgroups, *srvrgroups; size_t clnt_num_groups, srvr_num_groups; int found = 0; if (s->hit && (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) == 0) return 1; /* Sanity check */ if (s->s3.peer_tmp != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } /* Get our list of supported groups */ tls1_get_supported_groups(s, &srvrgroups, &srvr_num_groups); /* Get the clients list of supported groups. */ tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups); if (clnt_num_groups == 0) { /* * This can only happen if the supported_groups extension was not sent, * because we verify that the length is non-zero when we process that * extension. */ SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION); return 0; } if (s->s3.group_id != 0 && PACKET_remaining(&key_share_list) == 0) { /* * If we set a group_id already, then we must have sent an HRR * requesting a new key_share. If we haven't got one then that is an * error */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } while (PACKET_remaining(&key_share_list) > 0) { if (!PACKET_get_net_2(&key_share_list, &group_id) || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt) || PACKET_remaining(&encoded_pt) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } /* * If we already found a suitable key_share we loop through the * rest to verify the structure, but don't process them. */ if (found) continue; /* * If we sent an HRR then the key_share sent back MUST be for the group * we requested, and must be the only key_share sent. */ if (s->s3.group_id != 0 && (group_id != s->s3.group_id || PACKET_remaining(&key_share_list) != 0)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } /* Check if this share is in supported_groups sent from client */ if (!check_in_list(s, group_id, clntgroups, clnt_num_groups, 0)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } /* Check if this share is for a group we can use */ if (!check_in_list(s, group_id, srvrgroups, srvr_num_groups, 1) || !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED) /* * We tolerate but ignore a group id that we don't think is * suitable for TLSv1.3 */ || !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION, 0, NULL)) { /* Share not suitable */ continue; } s->s3.group_id = group_id; /* Cache the selected group ID in the SSL_SESSION */ s->session->kex_group = group_id; if ((s->s3.peer_tmp = ssl_generate_param_group(s, group_id)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS); return 0; } if (tls13_set_encoded_pub_key(s->s3.peer_tmp, PACKET_data(&encoded_pt), PACKET_remaining(&encoded_pt)) <= 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT); return 0; } found = 1; } #endif return 1; } int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned int format, version, key_share, group_id; EVP_MD_CTX *hctx; EVP_PKEY *pkey; PACKET cookie, raw, chhash, appcookie; WPACKET hrrpkt; const unsigned char *data, *mdin, *ciphdata; unsigned char hmac[SHA256_DIGEST_LENGTH]; unsigned char hrr[MAX_HRR_SIZE]; size_t rawlen, hmaclen, hrrlen, ciphlen; uint64_t tm, now; SSL *ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* Ignore any cookie if we're not set up to verify it */ if (sctx->verify_stateless_cookie_cb == NULL || (s->s3.flags & TLS1_FLAGS_STATELESS) == 0) return 1; if (!PACKET_as_length_prefixed_2(pkt, &cookie)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } raw = cookie; data = PACKET_data(&raw); rawlen = PACKET_remaining(&raw); if (rawlen < SHA256_DIGEST_LENGTH || !PACKET_forward(&raw, rawlen - SHA256_DIGEST_LENGTH)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } mdin = PACKET_data(&raw); /* Verify the HMAC of the cookie */ hctx = EVP_MD_CTX_create(); pkey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC", sctx->propq, s->session_ctx->ext.cookie_hmac_key, sizeof(s->session_ctx->ext.cookie_hmac_key)); if (hctx == NULL || pkey == NULL) { EVP_MD_CTX_free(hctx); EVP_PKEY_free(pkey); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } hmaclen = SHA256_DIGEST_LENGTH; if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", sctx->libctx, sctx->propq, pkey, NULL) <= 0 || EVP_DigestSign(hctx, hmac, &hmaclen, data, rawlen - SHA256_DIGEST_LENGTH) <= 0 || hmaclen != SHA256_DIGEST_LENGTH) { EVP_MD_CTX_free(hctx); EVP_PKEY_free(pkey); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } EVP_MD_CTX_free(hctx); EVP_PKEY_free(pkey); if (CRYPTO_memcmp(hmac, mdin, SHA256_DIGEST_LENGTH) != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COOKIE_MISMATCH); return 0; } if (!PACKET_get_net_2(&cookie, &format)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } /* Check the cookie format is something we recognise. Ignore it if not */ if (format != COOKIE_STATE_FORMAT_VERSION) return 1; /* * The rest of these checks really shouldn't fail since we have verified the * HMAC above. */ /* Check the version number is sane */ if (!PACKET_get_net_2(&cookie, &version)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (version != TLS1_3_VERSION) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_PROTOCOL_VERSION_NUMBER); return 0; } if (!PACKET_get_net_2(&cookie, &group_id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } ciphdata = PACKET_data(&cookie); if (!PACKET_forward(&cookie, 2)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (group_id != s->s3.group_id || s->s3.tmp.new_cipher != ssl_get_cipher_by_char(s, ciphdata, 0)) { /* * We chose a different cipher or group id this time around to what is * in the cookie. Something must have changed. */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_CIPHER); return 0; } if (!PACKET_get_1(&cookie, &key_share) || !PACKET_get_net_8(&cookie, &tm) || !PACKET_get_length_prefixed_2(&cookie, &chhash) || !PACKET_get_length_prefixed_1(&cookie, &appcookie) || PACKET_remaining(&cookie) != SHA256_DIGEST_LENGTH) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } /* We tolerate a cookie age of up to 10 minutes (= 60 * 10 seconds) */ now = time(NULL); if (tm > now || (now - tm) > 600) { /* Cookie is stale. Ignore it */ return 1; } /* Verify the app cookie */ if (sctx->verify_stateless_cookie_cb(ssl, PACKET_data(&appcookie), PACKET_remaining(&appcookie)) == 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COOKIE_MISMATCH); return 0; } /* * Reconstruct the HRR that we would have sent in response to the original * ClientHello so we can add it to the transcript hash. * Note: This won't work with custom HRR extensions */ if (!WPACKET_init_static_len(&hrrpkt, hrr, sizeof(hrr), 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!WPACKET_put_bytes_u8(&hrrpkt, SSL3_MT_SERVER_HELLO) || !WPACKET_start_sub_packet_u24(&hrrpkt) || !WPACKET_put_bytes_u16(&hrrpkt, TLS1_2_VERSION) || !WPACKET_memcpy(&hrrpkt, hrrrandom, SSL3_RANDOM_SIZE) || !WPACKET_sub_memcpy_u8(&hrrpkt, s->tmp_session_id, s->tmp_session_id_len) || !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, &hrrpkt, &ciphlen) || !WPACKET_put_bytes_u8(&hrrpkt, 0) || !WPACKET_start_sub_packet_u16(&hrrpkt)) { WPACKET_cleanup(&hrrpkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_supported_versions) || !WPACKET_start_sub_packet_u16(&hrrpkt) || !WPACKET_put_bytes_u16(&hrrpkt, s->version) || !WPACKET_close(&hrrpkt)) { WPACKET_cleanup(&hrrpkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (key_share) { if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_key_share) || !WPACKET_start_sub_packet_u16(&hrrpkt) || !WPACKET_put_bytes_u16(&hrrpkt, s->s3.group_id) || !WPACKET_close(&hrrpkt)) { WPACKET_cleanup(&hrrpkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_cookie) || !WPACKET_start_sub_packet_u16(&hrrpkt) || !WPACKET_sub_memcpy_u16(&hrrpkt, data, rawlen) || !WPACKET_close(&hrrpkt) /* cookie extension */ || !WPACKET_close(&hrrpkt) /* extension block */ || !WPACKET_close(&hrrpkt) /* message */ || !WPACKET_get_total_written(&hrrpkt, &hrrlen) || !WPACKET_finish(&hrrpkt)) { WPACKET_cleanup(&hrrpkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* Reconstruct the transcript hash */ if (!create_synthetic_message_hash(s, PACKET_data(&chhash), PACKET_remaining(&chhash), hrr, hrrlen)) { /* SSLfatal() already called */ return 0; } /* Act as if this ClientHello came after a HelloRetryRequest */ s->hello_retry_request = SSL_HRR_PENDING; s->ext.cookieok = 1; #endif return 1; } int tls_parse_ctos_supported_groups(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET supported_groups_list; /* Each group is 2 bytes and we must have at least 1. */ if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list) || PACKET_remaining(&supported_groups_list) == 0 || (PACKET_remaining(&supported_groups_list) % 2) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit || SSL_CONNECTION_IS_TLS13(s)) { OPENSSL_free(s->ext.peer_supportedgroups); s->ext.peer_supportedgroups = NULL; s->ext.peer_supportedgroups_len = 0; if (!tls1_save_u16(&supported_groups_list, &s->ext.peer_supportedgroups, &s->ext.peer_supportedgroups_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_parse_ctos_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { /* The extension must always be empty */ if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET) return 1; s->s3.flags |= TLS1_FLAGS_RECEIVED_EXTMS; return 1; } int tls_parse_ctos_early_data(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (s->hello_retry_request != SSL_HRR_NONE) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); return 0; } return 1; } static SSL_TICKET_STATUS tls_get_stateful_ticket(SSL_CONNECTION *s, PACKET *tick, SSL_SESSION **sess) { SSL_SESSION *tmpsess = NULL; s->ext.ticket_expected = 1; switch (PACKET_remaining(tick)) { case 0: return SSL_TICKET_EMPTY; case SSL_MAX_SSL_SESSION_ID_LENGTH: break; default: return SSL_TICKET_NO_DECRYPT; } tmpsess = lookup_sess_in_cache(s, PACKET_data(tick), SSL_MAX_SSL_SESSION_ID_LENGTH); if (tmpsess == NULL) return SSL_TICKET_NO_DECRYPT; *sess = tmpsess; return SSL_TICKET_SUCCESS; } int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET identities, binders, binder; size_t binderoffset, hashsize; SSL_SESSION *sess = NULL; unsigned int id, i, ext = 0; const EVP_MD *md = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* * If we have no PSK kex mode that we recognise then we can't resume so * ignore this extension */ if ((s->ext.psk_kex_mode & (TLSEXT_KEX_MODE_FLAG_KE | TLSEXT_KEX_MODE_FLAG_KE_DHE)) == 0) return 1; if (!PACKET_get_length_prefixed_2(pkt, &identities)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } s->ext.ticket_expected = 0; for (id = 0; PACKET_remaining(&identities) != 0; id++) { PACKET identity; unsigned long ticket_agel; size_t idlen; if (!PACKET_get_length_prefixed_2(&identities, &identity) || !PACKET_get_net_4(&identities, &ticket_agel)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } idlen = PACKET_remaining(&identity); if (s->psk_find_session_cb != NULL && !s->psk_find_session_cb(ssl, PACKET_data(&identity), idlen, &sess)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_EXTENSION); return 0; } #ifndef OPENSSL_NO_PSK if (sess == NULL && s->psk_server_callback != NULL && idlen <= PSK_MAX_IDENTITY_LEN) { char *pskid = NULL; unsigned char pskdata[PSK_MAX_PSK_LEN]; unsigned int pskdatalen; if (!PACKET_strndup(&identity, &pskid)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pskdatalen = s->psk_server_callback(ssl, pskid, pskdata, sizeof(pskdata)); OPENSSL_free(pskid); if (pskdatalen > PSK_MAX_PSK_LEN) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } else if (pskdatalen > 0) { const SSL_CIPHER *cipher; const unsigned char tls13_aes128gcmsha256_id[] = { 0x13, 0x01 }; /* * We found a PSK using an old style callback. We don't know * the digest so we default to SHA256 as per the TLSv1.3 spec */ cipher = SSL_CIPHER_find(ssl, tls13_aes128gcmsha256_id); if (cipher == NULL) { OPENSSL_cleanse(pskdata, pskdatalen); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } sess = SSL_SESSION_new(); if (sess == NULL || !SSL_SESSION_set1_master_key(sess, pskdata, pskdatalen) || !SSL_SESSION_set_cipher(sess, cipher) || !SSL_SESSION_set_protocol_version(sess, TLS1_3_VERSION)) { OPENSSL_cleanse(pskdata, pskdatalen); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } OPENSSL_cleanse(pskdata, pskdatalen); } } #endif /* OPENSSL_NO_PSK */ if (sess != NULL) { /* We found a PSK */ SSL_SESSION *sesstmp = ssl_session_dup(sess, 0); if (sesstmp == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } SSL_SESSION_free(sess); sess = sesstmp; /* * We've just been told to use this session for this context so * make sure the sid_ctx matches up. */ memcpy(sess->sid_ctx, s->sid_ctx, s->sid_ctx_length); sess->sid_ctx_length = s->sid_ctx_length; ext = 1; if (id == 0) s->ext.early_data_ok = 1; s->ext.ticket_expected = 1; } else { OSSL_TIME t, age, expire; int ret; /* * If we are using anti-replay protection then we behave as if * SSL_OP_NO_TICKET is set - we are caching tickets anyway so there * is no point in using full stateless tickets. */ if ((s->options & SSL_OP_NO_TICKET) != 0 || (s->max_early_data > 0 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0)) ret = tls_get_stateful_ticket(s, &identity, &sess); else ret = tls_decrypt_ticket(s, PACKET_data(&identity), PACKET_remaining(&identity), NULL, 0, &sess); if (ret == SSL_TICKET_EMPTY) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (ret == SSL_TICKET_FATAL_ERR_MALLOC || ret == SSL_TICKET_FATAL_ERR_OTHER) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (ret == SSL_TICKET_NONE || ret == SSL_TICKET_NO_DECRYPT) continue; /* Check for replay */ if (s->max_early_data > 0 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0 && !SSL_CTX_remove_session(s->session_ctx, sess)) { SSL_SESSION_free(sess); sess = NULL; continue; } age = ossl_time_subtract(ossl_ms2time(ticket_agel), ossl_ms2time(sess->ext.tick_age_add)); t = ossl_time_subtract(ossl_time_now(), sess->time); /* * Although internally we use OSS_TIME which has ns granularity, * when SSL_SESSION structures are serialised/deserialised we use * second granularity for the sess->time field. Therefore it could * appear that the client's ticket age is longer than ours (our * ticket age calculation should always be slightly longer than the * client's due to the network latency). Therefore we add 1000ms to * our age calculation to adjust for rounding errors. */ expire = ossl_time_add(t, ossl_ms2time(1000)); if (id == 0 && ossl_time_compare(sess->timeout, t) >= 0 && ossl_time_compare(age, expire) <= 0 && ossl_time_compare(ossl_time_add(age, TICKET_AGE_ALLOWANCE), expire) >= 0) { /* * Ticket age is within tolerance and not expired. We allow it * for early data */ s->ext.early_data_ok = 1; } } md = ssl_md(sctx, sess->cipher->algorithm2); if (md == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!EVP_MD_is_a(md, EVP_MD_get0_name(ssl_md(sctx, s->s3.tmp.new_cipher->algorithm2)))) { /* The ciphersuite is not compatible with this session. */ SSL_SESSION_free(sess); sess = NULL; s->ext.early_data_ok = 0; s->ext.ticket_expected = 0; continue; } break; } if (sess == NULL) return 1; binderoffset = PACKET_data(pkt) - (const unsigned char *)s->init_buf->data; hashsize = EVP_MD_get_size(md); if (!PACKET_get_length_prefixed_2(pkt, &binders)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); goto err; } for (i = 0; i <= id; i++) { if (!PACKET_get_length_prefixed_1(&binders, &binder)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); goto err; } } if (PACKET_remaining(&binder) != hashsize) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); goto err; } if (tls_psk_do_binder(s, md, (const unsigned char *)s->init_buf->data, binderoffset, PACKET_data(&binder), NULL, sess, 0, ext) != 1) { /* SSLfatal() already called */ goto err; } s->ext.tick_identity = id; SSL_SESSION_free(s->session); s->session = sess; return 1; err: SSL_SESSION_free(sess); return 0; } int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION *s, PACKET *pkt, ossl_unused unsigned int context, ossl_unused X509 *x, ossl_unused size_t chainidx) { if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR); return 0; } s->post_handshake_auth = SSL_PHA_EXT_RECEIVED; return 1; } /* * Add the server's renegotiation binding */ EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (!s->s3.send_connection_binding) return EXT_RETURN_NOT_SENT; /* Still add this even if SSL_OP_NO_RENEGOTIATION is set */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u8(pkt) || !WPACKET_memcpy(pkt, s->s3.previous_client_finished, s->s3.previous_client_finished_len) || !WPACKET_memcpy(pkt, s->s3.previous_server_finished, s->s3.previous_server_finished_len) || !WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->servername_done != 1) return EXT_RETURN_NOT_SENT; /* * Prior to TLSv1.3 we ignore any SNI in the current handshake if resuming. * We just use the servername from the initial handshake. */ if (s->hit && !SSL_CONNECTION_IS_TLS13(s)) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } /* Add/include the server's max fragment len extension into ServerHello */ EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (!USE_MAX_FRAGMENT_LENGTH_EXT(s->session)) return EXT_RETURN_NOT_SENT; /*- * 4 bytes for this extension type and extension length * 1 byte for the Max Fragment Length code value. */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u8(pkt, s->session->ext.max_fragment_len_mode) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey; unsigned long alg_a = s->s3.tmp.new_cipher->algorithm_auth; int using_ecc = ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA)) && (s->ext.peer_ecpointformats != NULL); const unsigned char *plist; size_t plistlen; if (!using_ecc) return EXT_RETURN_NOT_SENT; tls1_get_formatlist(s, &plist, &plistlen); if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { const uint16_t *groups; size_t numgroups, i, first = 1; int version; /* s->s3.group_id is non zero if we accepted a key_share */ if (s->s3.group_id == 0) return EXT_RETURN_NOT_SENT; /* Get our list of supported groups */ tls1_get_supported_groups(s, &groups, &numgroups); if (numgroups == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } /* Copy group ID if supported */ version = SSL_version(SSL_CONNECTION_GET_SSL(s)); for (i = 0; i < numgroups; i++) { uint16_t group = groups[i]; if (tls_valid_group(s, group, version, version, 0, NULL) && tls_group_allowed(s, group, SSL_SECOP_CURVE_SUPPORTED)) { if (first) { /* * Check if the client is already using our preferred group. If * so we don't need to add this extension */ if (s->s3.group_id == group) return EXT_RETURN_NOT_SENT; /* Add extension header */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups) /* Sub-packet for supported_groups extension */ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } first = 0; } if (!WPACKET_put_bytes_u16(pkt, group)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } } if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (!s->ext.ticket_expected || !tls_use_ticket(s)) { s->ext.ticket_expected = 0; return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_OCSP EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { /* We don't currently support this extension inside a CertificateRequest */ if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) return EXT_RETURN_NOT_SENT; if (!s->ext.status_expected) return EXT_RETURN_NOT_SENT; if (SSL_CONNECTION_IS_TLS13(s) && chainidx != 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request) || !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } /* * In TLSv1.3 we include the certificate status itself. In <= TLSv1.2 we * send back an empty extension, with the certificate status appearing as a * separate message */ if (SSL_CONNECTION_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt)) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { const unsigned char *npa; unsigned int npalen; int ret; int npn_seen = s->s3.npn_seen; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); s->s3.npn_seen = 0; if (!npn_seen || sctx->ext.npn_advertised_cb == NULL) return EXT_RETURN_NOT_SENT; ret = sctx->ext.npn_advertised_cb(SSL_CONNECTION_GET_SSL(s), &npa, &npalen, sctx->ext.npn_advertised_cb_arg); if (ret == SSL_TLSEXT_ERR_OK) { if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg) || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->s3.npn_seen = 1; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->s3.alpn_selected == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_application_layer_protocol_negotiation) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_sub_memcpy_u8(pkt, s->s3.alpn_selected, s->s3.alpn_selected_len) || !WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_SRTP EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->srtp_profile == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u16(pkt, 2) || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id) || !WPACKET_put_bytes_u8(pkt, 0) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (!s->ext.use_etm) return EXT_RETURN_NOT_SENT; /* * Don't use encrypt_then_mac if AEAD or RC4 might want to disable * for other cases too. */ if (s->s3.tmp.new_cipher->algorithm_mac == SSL_AEAD || s->s3.tmp.new_cipher->algorithm_enc == SSL_RC4 || s->s3.tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT || s->s3.tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12 || s->s3.tmp.new_cipher->algorithm_enc == SSL_MAGMA || s->s3.tmp.new_cipher->algorithm_enc == SSL_KUZNYECHIK) { s->ext.use_etm = 0; return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if ((s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (!ossl_assert(SSL_CONNECTION_IS_TLS13(s))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u16(pkt, s->version) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned char *encodedPoint; size_t encoded_pt_len = 0; EVP_PKEY *ckey = s->s3.peer_tmp, *skey = NULL; const TLS_GROUP_INFO *ginf = NULL; if (s->hello_retry_request == SSL_HRR_PENDING) { if (ckey != NULL) { /* Original key_share was acceptable so don't ask for another one */ return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u16(pkt, s->s3.group_id) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } if (ckey == NULL) { /* No key_share received from client - must be resuming */ if (!s->hit || !tls13_generate_handshake_secret(s, NULL, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_NOT_SENT; } if (s->hit && (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) == 0) { /* * PSK ('hit') and explicitly not doing DHE. If the client sent the * DHE option, we take it by default, except if non-DHE would be * preferred by config, but this case would have been handled in * tls_parse_ctos_psk_kex_modes(). */ return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u16(pkt, s->s3.group_id)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if ((ginf = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s), s->s3.group_id)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (!ginf->is_kem) { /* Regular KEX */ skey = ssl_generate_pkey(s, ckey); if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); return EXT_RETURN_FAIL; } /* Generate encoding of server key */ encoded_pt_len = EVP_PKEY_get1_encoded_public_key(skey, &encodedPoint); if (encoded_pt_len == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); EVP_PKEY_free(skey); return EXT_RETURN_FAIL; } if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_PKEY_free(skey); OPENSSL_free(encodedPoint); return EXT_RETURN_FAIL; } OPENSSL_free(encodedPoint); /* * This causes the crypto state to be updated based on the derived keys */ s->s3.tmp.pkey = skey; if (ssl_derive(s, skey, ckey, 1) == 0) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } } else { /* KEM mode */ unsigned char *ct = NULL; size_t ctlen = 0; /* * This does not update the crypto state. * * The generated pms is stored in `s->s3.tmp.pms` to be later used via * ssl_gensecret(). */ if (ssl_encapsulate(s, ckey, &ct, &ctlen, 0) == 0) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } if (ctlen == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); OPENSSL_free(ct); return EXT_RETURN_FAIL; } if (!WPACKET_sub_memcpy_u16(pkt, ct, ctlen) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); OPENSSL_free(ct); return EXT_RETURN_FAIL; } OPENSSL_free(ct); /* * This causes the crypto state to be updated based on the generated pms */ if (ssl_gensecret(s, s->s3.tmp.pms, s->s3.tmp.pmslen) == 0) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } } s->s3.did_kex = 1; return EXT_RETURN_SENT; #else return EXT_RETURN_FAIL; #endif } EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned char *hashval1, *hashval2, *appcookie1, *appcookie2, *cookie; unsigned char *hmac, *hmac2; size_t startlen, ciphlen, totcookielen, hashlen, hmaclen, appcookielen; EVP_MD_CTX *hctx; EVP_PKEY *pkey; int ret = EXT_RETURN_FAIL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); SSL *ssl = SSL_CONNECTION_GET_SSL(s); if ((s->s3.flags & TLS1_FLAGS_STATELESS) == 0) return EXT_RETURN_NOT_SENT; if (sctx->gen_stateless_cookie_cb == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_COOKIE_CALLBACK_SET); return EXT_RETURN_FAIL; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_get_total_written(pkt, &startlen) || !WPACKET_reserve_bytes(pkt, MAX_COOKIE_SIZE, &cookie) || !WPACKET_put_bytes_u16(pkt, COOKIE_STATE_FORMAT_VERSION) || !WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION) || !WPACKET_put_bytes_u16(pkt, s->s3.group_id) || !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt, &ciphlen) /* Is there a key_share extension present in this HRR? */ || !WPACKET_put_bytes_u8(pkt, s->s3.peer_tmp == NULL) || !WPACKET_put_bytes_u64(pkt, time(NULL)) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &hashval1)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } /* * Get the hash of the initial ClientHello. ssl_handshake_hash() operates * on raw buffers, so we first reserve sufficient bytes (above) and then * subsequently allocate them (below) */ if (!ssl3_digest_cached_records(s, 0) || !ssl_handshake_hash(s, hashval1, EVP_MAX_MD_SIZE, &hashlen)) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } if (!WPACKET_allocate_bytes(pkt, hashlen, &hashval2) || !ossl_assert(hashval1 == hashval2) || !WPACKET_close(pkt) || !WPACKET_start_sub_packet_u8(pkt) || !WPACKET_reserve_bytes(pkt, SSL_COOKIE_LENGTH, &appcookie1)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } /* Generate the application cookie */ if (sctx->gen_stateless_cookie_cb(ssl, appcookie1, &appcookielen) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COOKIE_GEN_CALLBACK_FAILURE); return EXT_RETURN_FAIL; } if (!WPACKET_allocate_bytes(pkt, appcookielen, &appcookie2) || !ossl_assert(appcookie1 == appcookie2) || !WPACKET_close(pkt) || !WPACKET_get_total_written(pkt, &totcookielen) || !WPACKET_reserve_bytes(pkt, SHA256_DIGEST_LENGTH, &hmac)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } hmaclen = SHA256_DIGEST_LENGTH; totcookielen -= startlen; if (!ossl_assert(totcookielen <= MAX_COOKIE_SIZE - SHA256_DIGEST_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } /* HMAC the cookie */ hctx = EVP_MD_CTX_create(); pkey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC", sctx->propq, s->session_ctx->ext.cookie_hmac_key, sizeof(s->session_ctx->ext.cookie_hmac_key)); if (hctx == NULL || pkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", sctx->libctx, sctx->propq, pkey, NULL) <= 0 || EVP_DigestSign(hctx, hmac, &hmaclen, cookie, totcookielen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!ossl_assert(totcookielen + hmaclen <= MAX_COOKIE_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!WPACKET_allocate_bytes(pkt, hmaclen, &hmac2) || !ossl_assert(hmac == hmac2) || !ossl_assert(cookie == hmac - totcookielen) || !WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ret = EXT_RETURN_SENT; err: EVP_MD_CTX_free(hctx); EVP_PKEY_free(pkey); return ret; #else return EXT_RETURN_FAIL; #endif } EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { const unsigned char cryptopro_ext[36] = { 0xfd, 0xe8, /* 65000 */ 0x00, 0x20, /* 32 bytes length */ 0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17 }; if (((s->s3.tmp.new_cipher->id & 0xFFFF) != 0x80 && (s->s3.tmp.new_cipher->id & 0xFFFF) != 0x81) || (SSL_get_options(SSL_CONNECTION_GET_SSL(s)) & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) { if (s->max_early_data == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u32(pkt, s->max_early_data) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (!s->hit) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u16(pkt, s->ext.tick_identity) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (sc->ext.client_cert_type_ctos == OSSL_CERT_TYPE_CTOS_ERROR && (send_certificate_request(sc) || sc->post_handshake_auth == SSL_PHA_EXT_RECEIVED)) { /* Did not receive an acceptable cert type - and doing client auth */ SSLfatal(sc, SSL_AD_UNSUPPORTED_CERTIFICATE, SSL_R_BAD_EXTENSION); return EXT_RETURN_FAIL; } if (sc->ext.client_cert_type == TLSEXT_cert_type_x509) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; return EXT_RETURN_NOT_SENT; } /* * Note: only supposed to send this if we are going to do a cert request, * but TLSv1.3 could do a PHA request if the client supports it */ if ((!send_certificate_request(sc) && sc->post_handshake_auth != SSL_PHA_EXT_RECEIVED) || sc->ext.client_cert_type_ctos != OSSL_CERT_TYPE_CTOS_GOOD || sc->client_cert_type == NULL) { /* if we don't send it, reset to TLSEXT_cert_type_x509 */ sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.client_cert_type = TLSEXT_cert_type_x509; return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_client_cert_type) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u8(pkt, sc->ext.client_cert_type) || !WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } /* One of |pref|, |other| is configured and the values are sanitized */ static int reconcile_cert_type(const unsigned char *pref, size_t pref_len, const unsigned char *other, size_t other_len, uint8_t *chosen_cert_type) { size_t i; for (i = 0; i < pref_len; i++) { if (memchr(other, pref[i], other_len) != NULL) { *chosen_cert_type = pref[i]; return OSSL_CERT_TYPE_CTOS_GOOD; } } return OSSL_CERT_TYPE_CTOS_ERROR; } int tls_parse_ctos_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET supported_cert_types; const unsigned char *data; size_t len; /* Ignore the extension */ if (sc->client_cert_type == NULL) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.client_cert_type = TLSEXT_cert_type_x509; return 1; } if (!PACKET_as_length_prefixed_1(pkt, &supported_cert_types)) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_ERROR; SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if ((len = PACKET_remaining(&supported_cert_types)) == 0) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_ERROR; SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_get_bytes(&supported_cert_types, &data, len)) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_ERROR; SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* client_cert_type: client (peer) has priority */ sc->ext.client_cert_type_ctos = reconcile_cert_type(data, len, sc->client_cert_type, sc->client_cert_type_len, &sc->ext.client_cert_type); /* Ignore the error until sending - so we can check cert auth*/ return 1; } EXT_RETURN tls_construct_stoc_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (sc->ext.server_cert_type == TLSEXT_cert_type_x509) { sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; return EXT_RETURN_NOT_SENT; } if (sc->ext.server_cert_type_ctos != OSSL_CERT_TYPE_CTOS_GOOD || sc->server_cert_type == NULL) { /* if we don't send it, reset to TLSEXT_cert_type_x509 */ sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.server_cert_type = TLSEXT_cert_type_x509; return EXT_RETURN_NOT_SENT; } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_cert_type) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u8(pkt, sc->ext.server_cert_type) || !WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } int tls_parse_ctos_server_cert_type(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET supported_cert_types; const unsigned char *data; size_t len; /* Ignore the extension */ if (sc->server_cert_type == NULL) { sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.server_cert_type = TLSEXT_cert_type_x509; return 1; } if (!PACKET_as_length_prefixed_1(pkt, &supported_cert_types)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if ((len = PACKET_remaining(&supported_cert_types)) == 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_get_bytes(&supported_cert_types, &data, len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* server_cert_type: server (this) has priority */ sc->ext.server_cert_type_ctos = reconcile_cert_type(sc->server_cert_type, sc->server_cert_type_len, data, len, &sc->ext.server_cert_type); if (sc->ext.server_cert_type_ctos == OSSL_CERT_TYPE_CTOS_GOOD) return 1; /* Did not receive an acceptable cert type */ SSLfatal(sc, SSL_AD_UNSUPPORTED_CERTIFICATE, SSL_R_BAD_EXTENSION); return 0; }

./openssl/ssl/statem/statem_local.h

/* * Copyright 2015-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /***************************************************************************** * * * The following definitions are PRIVATE to the state machine. They should * * NOT be used outside of the state machine. * * * *****************************************************************************/ /* Max message length definitions */ /* The spec allows for a longer length than this, but we limit it */ #define HELLO_VERIFY_REQUEST_MAX_LENGTH 258 #define END_OF_EARLY_DATA_MAX_LENGTH 0 #define HELLO_RETRY_REQUEST_MAX_LENGTH 20000 #define ENCRYPTED_EXTENSIONS_MAX_LENGTH 20000 #define SESSION_TICKET_MAX_LENGTH_TLS13 131338 #define SESSION_TICKET_MAX_LENGTH_TLS12 65541 #define SERVER_KEY_EXCH_MAX_LENGTH 102400 #define SERVER_HELLO_DONE_MAX_LENGTH 0 #define KEY_UPDATE_MAX_LENGTH 1 #define CCS_MAX_LENGTH 1 /* Max ServerHello size permitted by RFC 8446 */ #define SERVER_HELLO_MAX_LENGTH 65607 /* Max CertificateVerify size permitted by RFC 8446 */ #define CERTIFICATE_VERIFY_MAX_LENGTH 65539 /* Max should actually be 36 but we are generous */ #define FINISHED_MAX_LENGTH 64 /* Dummy message type */ #define SSL3_MT_DUMMY -1 /* Invalid extension ID for non-supported extensions */ #define TLSEXT_TYPE_invalid 0x10000 #define TLSEXT_TYPE_out_of_range 0x10001 unsigned int ossl_get_extension_type(size_t idx); extern const unsigned char hrrrandom[]; /* Message processing return codes */ typedef enum { /* Something bad happened */ MSG_PROCESS_ERROR, /* We've finished reading - swap to writing */ MSG_PROCESS_FINISHED_READING, /* * We've completed the main processing of this message but there is some * post processing to be done. */ MSG_PROCESS_CONTINUE_PROCESSING, /* We've finished this message - read the next message */ MSG_PROCESS_CONTINUE_READING } MSG_PROCESS_RETURN; typedef CON_FUNC_RETURN (*confunc_f) (SSL_CONNECTION *s, WPACKET *pkt); int ssl3_take_mac(SSL_CONNECTION *s); int check_in_list(SSL_CONNECTION *s, uint16_t group_id, const uint16_t *groups, size_t num_groups, int checkallow); int create_synthetic_message_hash(SSL_CONNECTION *s, const unsigned char *hashval, size_t hashlen, const unsigned char *hrr, size_t hrrlen); int parse_ca_names(SSL_CONNECTION *s, PACKET *pkt); const STACK_OF(X509_NAME) *get_ca_names(SSL_CONNECTION *s); int construct_ca_names(SSL_CONNECTION *s, const STACK_OF(X509_NAME) *ca_sk, WPACKET *pkt); size_t construct_key_exchange_tbs(SSL_CONNECTION *s, unsigned char **ptbs, const void *param, size_t paramlen); /* * TLS/DTLS client state machine functions */ int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt); WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION *s); WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION *s, WORK_STATE wst); WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst); int ossl_statem_client_construct_message(SSL_CONNECTION *s, confunc_f *confunc, int *mt); size_t ossl_statem_client_max_message_size(SSL_CONNECTION *s); MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION *s, PACKET *pkt); WORK_STATE ossl_statem_client_post_process_message(SSL_CONNECTION *s, WORK_STATE wst); /* * TLS/DTLS server state machine functions */ int ossl_statem_server_read_transition(SSL_CONNECTION *s, int mt); WRITE_TRAN ossl_statem_server_write_transition(SSL_CONNECTION *s); WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION *s, WORK_STATE wst); WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst); int ossl_statem_server_construct_message(SSL_CONNECTION *s, confunc_f *confunc,int *mt); size_t ossl_statem_server_max_message_size(SSL_CONNECTION *s); MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION *s, PACKET *pkt); WORK_STATE ossl_statem_server_post_process_message(SSL_CONNECTION *s, WORK_STATE wst); /* Functions for getting new message data */ __owur int tls_get_message_header(SSL_CONNECTION *s, int *mt); __owur int tls_get_message_body(SSL_CONNECTION *s, size_t *len); __owur int dtls_get_message(SSL_CONNECTION *s, int *mt); __owur int dtls_get_message_body(SSL_CONNECTION *s, size_t *len); /* Message construction and processing functions */ __owur int tls_process_initial_server_flight(SSL_CONNECTION *s); __owur MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION *s, PACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt); __owur CON_FUNC_RETURN tls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt); __owur CON_FUNC_RETURN dtls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt); __owur CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt); __owur CON_FUNC_RETURN tls_construct_key_update(SSL_CONNECTION *s, WPACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION *s, PACKET *pkt); __owur WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, WORK_STATE wst, int clearbufs, int stop); __owur WORK_STATE dtls_wait_for_dry(SSL_CONNECTION *s); #ifndef OPENSSL_NO_COMP_ALG __owur MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION *sc, PACKET *pkt, PACKET *tmppkt, BUF_MEM *buf); #endif /* some client-only functions */ __owur CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s, PACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s, PACKET *pkt); __owur int tls_process_cert_status_body(SSL_CONNECTION *s, PACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION *s, PACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_server_done(SSL_CONNECTION *s, PACKET *pkt); __owur CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt); __owur WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION *s, WORK_STATE wst); __owur CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION *s, WPACKET *pkt); #ifndef OPENSSL_NO_COMP_ALG __owur CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc, WPACKET *pkt); #endif __owur int ssl_do_client_cert_cb(SSL_CONNECTION *s, X509 **px509, EVP_PKEY **ppkey); __owur CON_FUNC_RETURN tls_construct_client_key_exchange(SSL_CONNECTION *s, WPACKET *pkt); __owur int tls_client_key_exchange_post_work(SSL_CONNECTION *s); __owur int tls_construct_cert_status_body(SSL_CONNECTION *s, WPACKET *pkt); __owur CON_FUNC_RETURN tls_construct_cert_status(SSL_CONNECTION *s, WPACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s, PACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_server_rpk(SSL_CONNECTION *sc, PACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_client_rpk(SSL_CONNECTION *sc, PACKET *pkt); __owur unsigned long tls_output_rpk(SSL_CONNECTION *sc, WPACKET *pkt, CERT_PKEY *cpk); __owur int tls_process_rpk(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **peer_rpk); __owur MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s, PACKET *pkt); __owur WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s, WORK_STATE wst); #ifndef OPENSSL_NO_COMP_ALG __owur MSG_PROCESS_RETURN tls_process_server_compressed_certificate(SSL_CONNECTION *sc, PACKET *pkt); #endif __owur int ssl3_check_cert_and_algorithm(SSL_CONNECTION *s); #ifndef OPENSSL_NO_NEXTPROTONEG __owur CON_FUNC_RETURN tls_construct_next_proto(SSL_CONNECTION *s, WPACKET *pkt); #endif __owur MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION *s, PACKET *pkt); __owur MSG_PROCESS_RETURN dtls_process_hello_verify(SSL_CONNECTION *s, PACKET *pkt); __owur CON_FUNC_RETURN tls_construct_end_of_early_data(SSL_CONNECTION *s, WPACKET *pkt); /* some server-only functions */ __owur MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt); __owur WORK_STATE tls_post_process_client_hello(SSL_CONNECTION *s, WORK_STATE wst); __owur CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION *s, WPACKET *pkt); __owur CON_FUNC_RETURN dtls_construct_hello_verify_request(SSL_CONNECTION *s, WPACKET *pkt); __owur CON_FUNC_RETURN tls_construct_server_certificate(SSL_CONNECTION *s, WPACKET *pkt); #ifndef OPENSSL_NO_COMP_ALG __owur CON_FUNC_RETURN tls_construct_server_compressed_certificate(SSL_CONNECTION *sc, WPACKET *pkt); #endif __owur CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s, WPACKET *pkt); __owur CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION *s, WPACKET *pkt); __owur CON_FUNC_RETURN tls_construct_server_done(SSL_CONNECTION *s, WPACKET *pkt); __owur MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s, PACKET *pkt); #ifndef OPENSSL_NO_COMP_ALG __owur MSG_PROCESS_RETURN tls_process_client_compressed_certificate(SSL_CONNECTION *sc, PACKET *pkt); #endif __owur MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION *s, PACKET *pkt); __owur WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION *s, WORK_STATE wst); __owur MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt); #ifndef OPENSSL_NO_NEXTPROTONEG __owur MSG_PROCESS_RETURN tls_process_next_proto(SSL_CONNECTION *s, PACKET *pkt); #endif __owur CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt); MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION *s, PACKET *pkt); #ifndef OPENSSL_NO_GOST /* These functions are used in GOST18 CKE, both for client and server */ int ossl_gost18_cke_cipher_nid(const SSL_CONNECTION *s); int ossl_gost_ukm(const SSL_CONNECTION *s, unsigned char *dgst_buf); #endif /* Extension processing */ typedef enum ext_return_en { EXT_RETURN_FAIL, EXT_RETURN_SENT, EXT_RETURN_NOT_SENT } EXT_RETURN; __owur int tls_validate_all_contexts(SSL_CONNECTION *s, unsigned int thisctx, RAW_EXTENSION *exts); __owur int extension_is_relevant(SSL_CONNECTION *s, unsigned int extctx, unsigned int thisctx); __owur int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet, unsigned int context, RAW_EXTENSION **res, size_t *len, int init); __owur int tls_parse_extension(SSL_CONNECTION *s, TLSEXT_INDEX idx, int context, RAW_EXTENSION *exts, X509 *x, size_t chainidx); __owur int tls_parse_all_extensions(SSL_CONNECTION *s, int context, RAW_EXTENSION *exts, X509 *x, size_t chainidx, int fin); __owur int should_add_extension(SSL_CONNECTION *s, unsigned int extctx, unsigned int thisctx, int max_version); __owur int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); __owur int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *msgstart, size_t binderoffset, const unsigned char *binderin, unsigned char *binderout, SSL_SESSION *sess, int sign, int external); /* Server Extension processing */ int tls_parse_ctos_renegotiate(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_server_name(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_SRP int tls_parse_ctos_srp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif int tls_parse_ctos_early_data(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_supported_groups(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidxl); int tls_parse_ctos_session_ticket(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_sig_algs(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_OCSP int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif #ifndef OPENSSL_NO_NEXTPROTONEG int tls_parse_ctos_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_SRTP int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif int tls_parse_ctos_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION *, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_OCSP EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif #ifndef OPENSSL_NO_NEXTPROTONEG EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_SRTP EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); /* * Not in public headers as this is not an official extension. Only used when * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set. */ #define TLSEXT_TYPE_cryptopro_bug 0xfde8 EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); /* Client Extension processing */ EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_SRP EXT_RETURN tls_construct_ctos_srp(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_OCSP EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif #ifndef OPENSSL_NO_NEXTPROTONEG EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_SRTP EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_CT EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_server_name(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_early_data(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_session_ticket(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_OCSP int tls_parse_stoc_status_request(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif #ifndef OPENSSL_NO_CT int tls_parse_stoc_sct(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif #ifndef OPENSSL_NO_NEXTPROTONEG int tls_parse_stoc_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_SRTP int tls_parse_stoc_use_srtp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #endif int tls_parse_stoc_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_supported_versions(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_handle_alpn(SSL_CONNECTION *s); int tls13_save_handshake_digest_for_pha(SSL_CONNECTION *s); int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION *s); __owur EVP_PKEY* tls_get_peer_pkey(const SSL_CONNECTION *sc); /* RFC7250 */ EXT_RETURN tls_construct_ctos_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_ctos_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN tls_construct_stoc_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_ctos_server_cert_type(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); int tls_parse_stoc_server_cert_type(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx);

./openssl/ssl/statem/extensions_cust.c

/* * Copyright 2014-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* Custom extension utility functions */ #include <openssl/ct.h> #include "../ssl_local.h" #include "internal/cryptlib.h" #include "statem_local.h" typedef struct { void *add_arg; custom_ext_add_cb add_cb; custom_ext_free_cb free_cb; } custom_ext_add_cb_wrap; typedef struct { void *parse_arg; custom_ext_parse_cb parse_cb; } custom_ext_parse_cb_wrap; /* * Provide thin wrapper callbacks which convert new style arguments to old style */ static int custom_ext_add_old_cb_wrap(SSL *s, unsigned int ext_type, unsigned int context, const unsigned char **out, size_t *outlen, X509 *x, size_t chainidx, int *al, void *add_arg) { custom_ext_add_cb_wrap *add_cb_wrap = (custom_ext_add_cb_wrap *)add_arg; if (add_cb_wrap->add_cb == NULL) return 1; return add_cb_wrap->add_cb(s, ext_type, out, outlen, al, add_cb_wrap->add_arg); } static void custom_ext_free_old_cb_wrap(SSL *s, unsigned int ext_type, unsigned int context, const unsigned char *out, void *add_arg) { custom_ext_add_cb_wrap *add_cb_wrap = (custom_ext_add_cb_wrap *)add_arg; if (add_cb_wrap->free_cb == NULL) return; add_cb_wrap->free_cb(s, ext_type, out, add_cb_wrap->add_arg); } static int custom_ext_parse_old_cb_wrap(SSL *s, unsigned int ext_type, unsigned int context, const unsigned char *in, size_t inlen, X509 *x, size_t chainidx, int *al, void *parse_arg) { custom_ext_parse_cb_wrap *parse_cb_wrap = (custom_ext_parse_cb_wrap *)parse_arg; if (parse_cb_wrap->parse_cb == NULL) return 1; return parse_cb_wrap->parse_cb(s, ext_type, in, inlen, al, parse_cb_wrap->parse_arg); } /* * Find a custom extension from the list. The |role| param is there to * support the legacy API where custom extensions for client and server could * be set independently on the same SSL_CTX. It is set to ENDPOINT_SERVER if we * are trying to find a method relevant to the server, ENDPOINT_CLIENT for the * client, or ENDPOINT_BOTH for either */ custom_ext_method *custom_ext_find(const custom_ext_methods *exts, ENDPOINT role, unsigned int ext_type, size_t *idx) { size_t i; custom_ext_method *meth = exts->meths; for (i = 0; i < exts->meths_count; i++, meth++) { if (ext_type == meth->ext_type && (role == ENDPOINT_BOTH || role == meth->role || meth->role == ENDPOINT_BOTH)) { if (idx != NULL) *idx = i; return meth; } } return NULL; } /* * Initialise custom extensions flags to indicate neither sent nor received. */ void custom_ext_init(custom_ext_methods *exts) { size_t i; custom_ext_method *meth = exts->meths; for (i = 0; i < exts->meths_count; i++, meth++) meth->ext_flags = 0; } /* Pass received custom extension data to the application for parsing. */ int custom_ext_parse(SSL_CONNECTION *s, unsigned int context, unsigned int ext_type, const unsigned char *ext_data, size_t ext_size, X509 *x, size_t chainidx) { int al = 0; custom_ext_methods *exts = &s->cert->custext; custom_ext_method *meth; ENDPOINT role = ENDPOINT_BOTH; if ((context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO)) != 0) role = s->server ? ENDPOINT_SERVER : ENDPOINT_CLIENT; meth = custom_ext_find(exts, role, ext_type, NULL); /* If not found return success */ if (!meth) return 1; /* Check if extension is defined for our protocol. If not, skip */ if (!extension_is_relevant(s, meth->context, context)) return 1; if ((context & (SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS)) != 0) { /* * If it's ServerHello or EncryptedExtensions we can't have any * extensions not sent in ClientHello. */ if ((meth->ext_flags & SSL_EXT_FLAG_SENT) == 0) { SSLfatal(s, TLS1_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } } /* * Extensions received in the ClientHello or CertificateRequest are marked * with the SSL_EXT_FLAG_RECEIVED. This is so we know to add the equivalent * extensions in the response messages */ if ((context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST)) != 0) meth->ext_flags |= SSL_EXT_FLAG_RECEIVED; /* If no parse function set return success */ if (meth->parse_cb == NULL) return 1; if (meth->parse_cb(SSL_CONNECTION_GET_SSL(s), ext_type, context, ext_data, ext_size, x, chainidx, &al, meth->parse_arg) <= 0) { SSLfatal(s, al, SSL_R_BAD_EXTENSION); return 0; } return 1; } /* * Request custom extension data from the application and add to the return * buffer. */ int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x, size_t chainidx, int maxversion) { custom_ext_methods *exts = &s->cert->custext; custom_ext_method *meth; size_t i; int al; int for_comp = (context & SSL_EXT_TLS1_3_CERTIFICATE_COMPRESSION) != 0; for (i = 0; i < exts->meths_count; i++) { const unsigned char *out = NULL; size_t outlen = 0; meth = exts->meths + i; if (!should_add_extension(s, meth->context, context, maxversion)) continue; if ((context & (SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_RAW_PUBLIC_KEY | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST)) != 0) { /* Only send extensions present in ClientHello/CertificateRequest */ if (!(meth->ext_flags & SSL_EXT_FLAG_RECEIVED)) continue; } /* * We skip it if the callback is absent - except for a ClientHello where * we add an empty extension. */ if ((context & SSL_EXT_CLIENT_HELLO) == 0 && meth->add_cb == NULL) continue; if (meth->add_cb != NULL) { int cb_retval = meth->add_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context, &out, &outlen, x, chainidx, &al, meth->add_arg); if (cb_retval < 0) { if (!for_comp) SSLfatal(s, al, SSL_R_CALLBACK_FAILED); return 0; /* error */ } if (cb_retval == 0) continue; /* skip this extension */ } if (!WPACKET_put_bytes_u16(pkt, meth->ext_type) || !WPACKET_start_sub_packet_u16(pkt) || (outlen > 0 && !WPACKET_memcpy(pkt, out, outlen)) || !WPACKET_close(pkt)) { if (meth->free_cb != NULL) meth->free_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context, out, meth->add_arg); if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((context & SSL_EXT_CLIENT_HELLO) != 0) { /* * We can't send duplicates: code logic should prevent this. */ if (!ossl_assert((meth->ext_flags & SSL_EXT_FLAG_SENT) == 0)) { if (meth->free_cb != NULL) meth->free_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context, out, meth->add_arg); if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * Indicate extension has been sent: this is both a sanity check to * ensure we don't send duplicate extensions and indicates that it * is not an error if the extension is present in ServerHello. */ meth->ext_flags |= SSL_EXT_FLAG_SENT; } if (meth->free_cb != NULL) meth->free_cb(SSL_CONNECTION_GET_SSL(s), meth->ext_type, context, out, meth->add_arg); } return 1; } /* Copy the flags from src to dst for any extensions that exist in both */ int custom_exts_copy_flags(custom_ext_methods *dst, const custom_ext_methods *src) { size_t i; custom_ext_method *methsrc = src->meths; for (i = 0; i < src->meths_count; i++, methsrc++) { custom_ext_method *methdst = custom_ext_find(dst, methsrc->role, methsrc->ext_type, NULL); if (methdst == NULL) continue; methdst->ext_flags = methsrc->ext_flags; } return 1; } /* Copy table of custom extensions */ int custom_exts_copy(custom_ext_methods *dst, const custom_ext_methods *src) { size_t i; int err = 0; if (src->meths_count > 0) { dst->meths = OPENSSL_memdup(src->meths, sizeof(*src->meths) * src->meths_count); if (dst->meths == NULL) return 0; dst->meths_count = src->meths_count; for (i = 0; i < src->meths_count; i++) { custom_ext_method *methsrc = src->meths + i; custom_ext_method *methdst = dst->meths + i; if (methsrc->add_cb != custom_ext_add_old_cb_wrap) continue; /* * We have found an old style API wrapper. We need to copy the * arguments too. */ if (err) { methdst->add_arg = NULL; methdst->parse_arg = NULL; continue; } methdst->add_arg = OPENSSL_memdup(methsrc->add_arg, sizeof(custom_ext_add_cb_wrap)); methdst->parse_arg = OPENSSL_memdup(methsrc->parse_arg, sizeof(custom_ext_parse_cb_wrap)); if (methdst->add_arg == NULL || methdst->parse_arg == NULL) err = 1; } } if (err) { custom_exts_free(dst); return 0; } return 1; } void custom_exts_free(custom_ext_methods *exts) { size_t i; custom_ext_method *meth; for (i = 0, meth = exts->meths; i < exts->meths_count; i++, meth++) { if (meth->add_cb != custom_ext_add_old_cb_wrap) continue; /* Old style API wrapper. Need to free the arguments too */ OPENSSL_free(meth->add_arg); OPENSSL_free(meth->parse_arg); } OPENSSL_free(exts->meths); exts->meths = NULL; exts->meths_count = 0; } /* Return true if a client custom extension exists, false otherwise */ int SSL_CTX_has_client_custom_ext(const SSL_CTX *ctx, unsigned int ext_type) { return custom_ext_find(&ctx->cert->custext, ENDPOINT_CLIENT, ext_type, NULL) != NULL; } int ossl_tls_add_custom_ext_intern(SSL_CTX *ctx, custom_ext_methods *exts, ENDPOINT role, unsigned int ext_type, unsigned int context, SSL_custom_ext_add_cb_ex add_cb, SSL_custom_ext_free_cb_ex free_cb, void *add_arg, SSL_custom_ext_parse_cb_ex parse_cb, void *parse_arg) { custom_ext_method *meth, *tmp; /* * Check application error: if add_cb is not set free_cb will never be * called. */ if (add_cb == NULL && free_cb != NULL) return 0; if (exts == NULL) exts = &ctx->cert->custext; #ifndef OPENSSL_NO_CT /* * We don't want applications registering callbacks for SCT extensions * whilst simultaneously using the built-in SCT validation features, as * these two things may not play well together. */ if (ext_type == TLSEXT_TYPE_signed_certificate_timestamp && (context & SSL_EXT_CLIENT_HELLO) != 0 && ctx != NULL && SSL_CTX_ct_is_enabled(ctx)) return 0; #endif /* * Don't add if extension supported internally, but make exception * for extension types that previously were not supported, but now are. */ if (SSL_extension_supported(ext_type) && ext_type != TLSEXT_TYPE_signed_certificate_timestamp) return 0; /* Extension type must fit in 16 bits */ if (ext_type > 0xffff) return 0; /* Search for duplicate */ if (custom_ext_find(exts, role, ext_type, NULL)) return 0; tmp = OPENSSL_realloc(exts->meths, (exts->meths_count + 1) * sizeof(custom_ext_method)); if (tmp == NULL) return 0; exts->meths = tmp; meth = exts->meths + exts->meths_count; memset(meth, 0, sizeof(*meth)); meth->role = role; meth->context = context; meth->parse_cb = parse_cb; meth->add_cb = add_cb; meth->free_cb = free_cb; meth->ext_type = ext_type; meth->add_arg = add_arg; meth->parse_arg = parse_arg; exts->meths_count++; return 1; } static int add_old_custom_ext(SSL_CTX *ctx, ENDPOINT role, unsigned int ext_type, unsigned int context, custom_ext_add_cb add_cb, custom_ext_free_cb free_cb, void *add_arg, custom_ext_parse_cb parse_cb, void *parse_arg) { custom_ext_add_cb_wrap *add_cb_wrap = OPENSSL_malloc(sizeof(*add_cb_wrap)); custom_ext_parse_cb_wrap *parse_cb_wrap = OPENSSL_malloc(sizeof(*parse_cb_wrap)); int ret; if (add_cb_wrap == NULL || parse_cb_wrap == NULL) { OPENSSL_free(add_cb_wrap); OPENSSL_free(parse_cb_wrap); return 0; } add_cb_wrap->add_arg = add_arg; add_cb_wrap->add_cb = add_cb; add_cb_wrap->free_cb = free_cb; parse_cb_wrap->parse_arg = parse_arg; parse_cb_wrap->parse_cb = parse_cb; ret = ossl_tls_add_custom_ext_intern(ctx, NULL, role, ext_type, context, custom_ext_add_old_cb_wrap, custom_ext_free_old_cb_wrap, add_cb_wrap, custom_ext_parse_old_cb_wrap, parse_cb_wrap); if (!ret) { OPENSSL_free(add_cb_wrap); OPENSSL_free(parse_cb_wrap); } return ret; } /* Application level functions to add the old custom extension callbacks */ int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx, unsigned int ext_type, custom_ext_add_cb add_cb, custom_ext_free_cb free_cb, void *add_arg, custom_ext_parse_cb parse_cb, void *parse_arg) { return add_old_custom_ext(ctx, ENDPOINT_CLIENT, ext_type, SSL_EXT_TLS1_2_AND_BELOW_ONLY | SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_IGNORE_ON_RESUMPTION, add_cb, free_cb, add_arg, parse_cb, parse_arg); } int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx, unsigned int ext_type, custom_ext_add_cb add_cb, custom_ext_free_cb free_cb, void *add_arg, custom_ext_parse_cb parse_cb, void *parse_arg) { return add_old_custom_ext(ctx, ENDPOINT_SERVER, ext_type, SSL_EXT_TLS1_2_AND_BELOW_ONLY | SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_IGNORE_ON_RESUMPTION, add_cb, free_cb, add_arg, parse_cb, parse_arg); } int SSL_CTX_add_custom_ext(SSL_CTX *ctx, unsigned int ext_type, unsigned int context, SSL_custom_ext_add_cb_ex add_cb, SSL_custom_ext_free_cb_ex free_cb, void *add_arg, SSL_custom_ext_parse_cb_ex parse_cb, void *parse_arg) { return ossl_tls_add_custom_ext_intern(ctx, NULL, ENDPOINT_BOTH, ext_type, context, add_cb, free_cb, add_arg, parse_cb, parse_arg); } int SSL_extension_supported(unsigned int ext_type) { switch (ext_type) { /* Internally supported extensions. */ case TLSEXT_TYPE_application_layer_protocol_negotiation: case TLSEXT_TYPE_ec_point_formats: case TLSEXT_TYPE_supported_groups: case TLSEXT_TYPE_key_share: #ifndef OPENSSL_NO_NEXTPROTONEG case TLSEXT_TYPE_next_proto_neg: #endif case TLSEXT_TYPE_padding: case TLSEXT_TYPE_renegotiate: case TLSEXT_TYPE_max_fragment_length: case TLSEXT_TYPE_server_name: case TLSEXT_TYPE_session_ticket: case TLSEXT_TYPE_signature_algorithms: #ifndef OPENSSL_NO_SRP case TLSEXT_TYPE_srp: #endif #ifndef OPENSSL_NO_OCSP case TLSEXT_TYPE_status_request: #endif #ifndef OPENSSL_NO_CT case TLSEXT_TYPE_signed_certificate_timestamp: #endif #ifndef OPENSSL_NO_SRTP case TLSEXT_TYPE_use_srtp: #endif case TLSEXT_TYPE_encrypt_then_mac: case TLSEXT_TYPE_supported_versions: case TLSEXT_TYPE_extended_master_secret: case TLSEXT_TYPE_psk_kex_modes: case TLSEXT_TYPE_cookie: case TLSEXT_TYPE_early_data: case TLSEXT_TYPE_certificate_authorities: case TLSEXT_TYPE_psk: case TLSEXT_TYPE_post_handshake_auth: case TLSEXT_TYPE_compress_certificate: case TLSEXT_TYPE_client_cert_type: case TLSEXT_TYPE_server_cert_type: return 1; default: return 0; } }

./openssl/ssl/statem/statem.c

/* * Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #if defined(__TANDEM) && defined(_SPT_MODEL_) # include <spthread.h> # include <spt_extensions.h> /* timeval */ #endif #include "internal/cryptlib.h" #include <openssl/rand.h> #include "../ssl_local.h" #include "statem_local.h" #include <assert.h> /* * This file implements the SSL/TLS/DTLS state machines. * * There are two primary state machines: * * 1) Message flow state machine * 2) Handshake state machine * * The Message flow state machine controls the reading and sending of messages * including handling of non-blocking IO events, flushing of the underlying * write BIO, handling unexpected messages, etc. It is itself broken into two * separate sub-state machines which control reading and writing respectively. * * The Handshake state machine keeps track of the current SSL/TLS handshake * state. Transitions of the handshake state are the result of events that * occur within the Message flow state machine. * * Overall it looks like this: * * --------------------------------------------- ------------------- * | | | | * | Message flow state machine | | | * | | | | * | -------------------- -------------------- | Transition | Handshake state | * | | MSG_FLOW_READING | | MSG_FLOW_WRITING | | Event | machine | * | | sub-state | | sub-state | |----------->| | * | | machine for | | machine for | | | | * | | reading messages | | writing messages | | | | * | -------------------- -------------------- | | | * | | | | * --------------------------------------------- ------------------- * */ /* Sub state machine return values */ typedef enum { /* Something bad happened or NBIO */ SUB_STATE_ERROR, /* Sub state finished go to the next sub state */ SUB_STATE_FINISHED, /* Sub state finished and handshake was completed */ SUB_STATE_END_HANDSHAKE } SUB_STATE_RETURN; static int state_machine(SSL_CONNECTION *s, int server); static void init_read_state_machine(SSL_CONNECTION *s); static SUB_STATE_RETURN read_state_machine(SSL_CONNECTION *s); static void init_write_state_machine(SSL_CONNECTION *s); static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION *s); OSSL_HANDSHAKE_STATE SSL_get_state(const SSL *ssl) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl); if (sc == NULL) return TLS_ST_BEFORE; return sc->statem.hand_state; } int SSL_in_init(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return sc->statem.in_init; } int SSL_is_init_finished(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; return !(sc->statem.in_init) && (sc->statem.hand_state == TLS_ST_OK); } int SSL_in_before(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; /* * Historically being "in before" meant before anything had happened. In the * current code though we remain in the "before" state for a while after we * have started the handshake process (e.g. as a server waiting for the * first message to arrive). There "in before" is taken to mean "in before" * and not started any handshake process yet. */ return (sc->statem.hand_state == TLS_ST_BEFORE) && (sc->statem.state == MSG_FLOW_UNINITED); } OSSL_HANDSHAKE_STATE ossl_statem_get_state(SSL_CONNECTION *s) { return s != NULL ? s->statem.hand_state : TLS_ST_BEFORE; } /* * Clear the state machine state and reset back to MSG_FLOW_UNINITED */ void ossl_statem_clear(SSL_CONNECTION *s) { s->statem.state = MSG_FLOW_UNINITED; s->statem.hand_state = TLS_ST_BEFORE; ossl_statem_set_in_init(s, 1); s->statem.no_cert_verify = 0; } /* * Set the state machine up ready for a renegotiation handshake */ void ossl_statem_set_renegotiate(SSL_CONNECTION *s) { ossl_statem_set_in_init(s, 1); s->statem.request_state = TLS_ST_SW_HELLO_REQ; } void ossl_statem_send_fatal(SSL_CONNECTION *s, int al) { /* We shouldn't call SSLfatal() twice. Once is enough */ if (s->statem.in_init && s->statem.state == MSG_FLOW_ERROR) return; ossl_statem_set_in_init(s, 1); s->statem.state = MSG_FLOW_ERROR; if (al != SSL_AD_NO_ALERT) ssl3_send_alert(s, SSL3_AL_FATAL, al); } /* * Error reporting building block that's used instead of ERR_set_error(). * In addition to what ERR_set_error() does, this puts the state machine * into an error state and sends an alert if appropriate. * This is a permanent error for the current connection. */ void ossl_statem_fatal(SSL_CONNECTION *s, int al, int reason, const char *fmt, ...) { va_list args; va_start(args, fmt); ERR_vset_error(ERR_LIB_SSL, reason, fmt, args); va_end(args); ossl_statem_send_fatal(s, al); } /* * This macro should only be called if we are already expecting to be in * a fatal error state. We verify that we are, and set it if not (this would * indicate a bug). */ #define check_fatal(s) \ do { \ if (!ossl_assert((s)->statem.in_init \ && (s)->statem.state == MSG_FLOW_ERROR)) \ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_FATAL); \ } while (0) /* * Discover whether the current connection is in the error state. * * Valid return values are: * 1: Yes * 0: No */ int ossl_statem_in_error(const SSL_CONNECTION *s) { if (s->statem.state == MSG_FLOW_ERROR) return 1; return 0; } void ossl_statem_set_in_init(SSL_CONNECTION *s, int init) { s->statem.in_init = init; if (s->rlayer.rrlmethod != NULL && s->rlayer.rrlmethod->set_in_init != NULL) s->rlayer.rrlmethod->set_in_init(s->rlayer.rrl, init); } int ossl_statem_get_in_handshake(SSL_CONNECTION *s) { return s->statem.in_handshake; } void ossl_statem_set_in_handshake(SSL_CONNECTION *s, int inhand) { if (inhand) s->statem.in_handshake++; else s->statem.in_handshake--; } /* Are we in a sensible state to skip over unreadable early data? */ int ossl_statem_skip_early_data(SSL_CONNECTION *s) { if (s->ext.early_data != SSL_EARLY_DATA_REJECTED) return 0; if (!s->server || s->statem.hand_state != TLS_ST_EARLY_DATA || s->hello_retry_request == SSL_HRR_COMPLETE) return 0; return 1; } /* * Called when we are in SSL_read*(), SSL_write*(), or SSL_accept() * /SSL_connect()/SSL_do_handshake(). Used to test whether we are in an early * data state and whether we should attempt to move the handshake on if so. * |sending| is 1 if we are attempting to send data (SSL_write*()), 0 if we are * attempting to read data (SSL_read*()), or -1 if we are in SSL_do_handshake() * or similar. */ void ossl_statem_check_finish_init(SSL_CONNECTION *s, int sending) { if (sending == -1) { if (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END || s->statem.hand_state == TLS_ST_EARLY_DATA) { ossl_statem_set_in_init(s, 1); if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY) { /* * SSL_connect() or SSL_do_handshake() has been called directly. * We don't allow any more writing of early data. */ s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING; } } } else if (!s->server) { if ((sending && (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END || s->statem.hand_state == TLS_ST_EARLY_DATA) && s->early_data_state != SSL_EARLY_DATA_WRITING) || (!sending && s->statem.hand_state == TLS_ST_EARLY_DATA)) { ossl_statem_set_in_init(s, 1); /* * SSL_write() has been called directly. We don't allow any more * writing of early data. */ if (sending && s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY) s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING; } } else { if (s->early_data_state == SSL_EARLY_DATA_FINISHED_READING && s->statem.hand_state == TLS_ST_EARLY_DATA) ossl_statem_set_in_init(s, 1); } } void ossl_statem_set_hello_verify_done(SSL_CONNECTION *s) { s->statem.state = MSG_FLOW_UNINITED; ossl_statem_set_in_init(s, 1); /* * This will get reset (briefly) back to TLS_ST_BEFORE when we enter * state_machine() because |state| is MSG_FLOW_UNINITED, but until then any * calls to SSL_in_before() will return false. Also calls to * SSL_state_string() and SSL_state_string_long() will return something * sensible. */ s->statem.hand_state = TLS_ST_SR_CLNT_HELLO; } int ossl_statem_connect(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; return state_machine(sc, 0); } int ossl_statem_accept(SSL *s) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; return state_machine(sc, 1); } typedef void (*info_cb) (const SSL *, int, int); static info_cb get_callback(SSL_CONNECTION *s) { SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (s->info_callback != NULL) return s->info_callback; else if (sctx->info_callback != NULL) return sctx->info_callback; return NULL; } /* * The main message flow state machine. We start in the MSG_FLOW_UNINITED or * MSG_FLOW_FINISHED state and finish in MSG_FLOW_FINISHED. Valid states and * transitions are as follows: * * MSG_FLOW_UNINITED MSG_FLOW_FINISHED * | | * +-----------------------+ * v * MSG_FLOW_WRITING <---> MSG_FLOW_READING * | * V * MSG_FLOW_FINISHED * | * V * [SUCCESS] * * We may exit at any point due to an error or NBIO event. If an NBIO event * occurs then we restart at the point we left off when we are recalled. * MSG_FLOW_WRITING and MSG_FLOW_READING have sub-state machines associated with them. * * In addition to the above there is also the MSG_FLOW_ERROR state. We can move * into that state at any point in the event that an irrecoverable error occurs. * * Valid return values are: * 1: Success * <=0: NBIO or error */ static int state_machine(SSL_CONNECTION *s, int server) { BUF_MEM *buf = NULL; void (*cb) (const SSL *ssl, int type, int val) = NULL; OSSL_STATEM *st = &s->statem; int ret = -1; int ssret; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (st->state == MSG_FLOW_ERROR) { /* Shouldn't have been called if we're already in the error state */ return -1; } ERR_clear_error(); clear_sys_error(); cb = get_callback(s); st->in_handshake++; if (!SSL_in_init(ssl) || SSL_in_before(ssl)) { /* * If we are stateless then we already called SSL_clear() - don't do * it again and clear the STATELESS flag itself. */ if ((s->s3.flags & TLS1_FLAGS_STATELESS) == 0 && !SSL_clear(ssl)) return -1; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) { /* * Notify SCTP BIO socket to enter handshake mode and prevent stream * identifier other than 0. */ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE, st->in_handshake, NULL); } #endif /* Initialise state machine */ if (st->state == MSG_FLOW_UNINITED || st->state == MSG_FLOW_FINISHED) { if (st->state == MSG_FLOW_UNINITED) { st->hand_state = TLS_ST_BEFORE; st->request_state = TLS_ST_BEFORE; } s->server = server; if (cb != NULL) { if (SSL_IS_FIRST_HANDSHAKE(s) || !SSL_CONNECTION_IS_TLS13(s)) cb(ssl, SSL_CB_HANDSHAKE_START, 1); } /* * Fatal errors in this block don't send an alert because we have * failed to even initialise properly. Sending an alert is probably * doomed to failure. */ if (SSL_CONNECTION_IS_DTLS(s)) { if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00) && (server || (s->version & 0xff00) != (DTLS1_BAD_VER & 0xff00))) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } } else { if ((s->version >> 8) != SSL3_VERSION_MAJOR) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } } if (!ssl_security(s, SSL_SECOP_VERSION, 0, s->version, NULL)) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } if (s->init_buf == NULL) { if ((buf = BUF_MEM_new()) == NULL) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } if (!BUF_MEM_grow(buf, SSL3_RT_MAX_PLAIN_LENGTH)) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } s->init_buf = buf; buf = NULL; } s->init_num = 0; /* * Should have been reset by tls_process_finished, too. */ s->s3.change_cipher_spec = 0; /* * Ok, we now need to push on a buffering BIO ...but not with * SCTP */ #ifndef OPENSSL_NO_SCTP if (!SSL_CONNECTION_IS_DTLS(s) || !BIO_dgram_is_sctp(SSL_get_wbio(ssl))) #endif if (!ssl_init_wbio_buffer(s)) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); goto end; } if ((SSL_in_before(ssl)) || s->renegotiate) { if (!tls_setup_handshake(s)) { /* SSLfatal() already called */ goto end; } if (SSL_IS_FIRST_HANDSHAKE(s)) st->read_state_first_init = 1; } st->state = MSG_FLOW_WRITING; init_write_state_machine(s); } while (st->state != MSG_FLOW_FINISHED) { if (st->state == MSG_FLOW_READING) { ssret = read_state_machine(s); if (ssret == SUB_STATE_FINISHED) { st->state = MSG_FLOW_WRITING; init_write_state_machine(s); } else { /* NBIO or error */ goto end; } } else if (st->state == MSG_FLOW_WRITING) { ssret = write_state_machine(s); if (ssret == SUB_STATE_FINISHED) { st->state = MSG_FLOW_READING; init_read_state_machine(s); } else if (ssret == SUB_STATE_END_HANDSHAKE) { st->state = MSG_FLOW_FINISHED; } else { /* NBIO or error */ goto end; } } else { /* Error */ check_fatal(s); ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); goto end; } } ret = 1; end: st->in_handshake--; #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) { /* * Notify SCTP BIO socket to leave handshake mode and allow stream * identifier other than 0. */ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE, st->in_handshake, NULL); } #endif BUF_MEM_free(buf); if (cb != NULL) { if (server) cb(ssl, SSL_CB_ACCEPT_EXIT, ret); else cb(ssl, SSL_CB_CONNECT_EXIT, ret); } return ret; } /* * Initialise the MSG_FLOW_READING sub-state machine */ static void init_read_state_machine(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; st->read_state = READ_STATE_HEADER; } static int grow_init_buf(SSL_CONNECTION *s, size_t size) { size_t msg_offset = (char *)s->init_msg - s->init_buf->data; if (!BUF_MEM_grow_clean(s->init_buf, (int)size)) return 0; if (size < msg_offset) return 0; s->init_msg = s->init_buf->data + msg_offset; return 1; } /* * This function implements the sub-state machine when the message flow is in * MSG_FLOW_READING. The valid sub-states and transitions are: * * READ_STATE_HEADER <--+<-------------+ * | | | * v | | * READ_STATE_BODY -----+-->READ_STATE_POST_PROCESS * | | * +----------------------------+ * v * [SUB_STATE_FINISHED] * * READ_STATE_HEADER has the responsibility for reading in the message header * and transitioning the state of the handshake state machine. * * READ_STATE_BODY reads in the rest of the message and then subsequently * processes it. * * READ_STATE_POST_PROCESS is an optional step that may occur if some post * processing activity performed on the message may block. * * Any of the above states could result in an NBIO event occurring in which case * control returns to the calling application. When this function is recalled we * will resume in the same state where we left off. */ static SUB_STATE_RETURN read_state_machine(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; int ret, mt; size_t len = 0; int (*transition) (SSL_CONNECTION *s, int mt); PACKET pkt; MSG_PROCESS_RETURN(*process_message) (SSL_CONNECTION *s, PACKET *pkt); WORK_STATE(*post_process_message) (SSL_CONNECTION *s, WORK_STATE wst); size_t (*max_message_size) (SSL_CONNECTION *s); void (*cb) (const SSL *ssl, int type, int val) = NULL; SSL *ssl = SSL_CONNECTION_GET_SSL(s); cb = get_callback(s); if (s->server) { transition = ossl_statem_server_read_transition; process_message = ossl_statem_server_process_message; max_message_size = ossl_statem_server_max_message_size; post_process_message = ossl_statem_server_post_process_message; } else { transition = ossl_statem_client_read_transition; process_message = ossl_statem_client_process_message; max_message_size = ossl_statem_client_max_message_size; post_process_message = ossl_statem_client_post_process_message; } if (st->read_state_first_init) { s->first_packet = 1; st->read_state_first_init = 0; } while (1) { switch (st->read_state) { case READ_STATE_HEADER: /* Get the state the peer wants to move to */ if (SSL_CONNECTION_IS_DTLS(s)) { /* * In DTLS we get the whole message in one go - header and body */ ret = dtls_get_message(s, &mt); } else { ret = tls_get_message_header(s, &mt); } if (ret == 0) { /* Could be non-blocking IO */ return SUB_STATE_ERROR; } if (cb != NULL) { /* Notify callback of an impending state change */ if (s->server) cb(ssl, SSL_CB_ACCEPT_LOOP, 1); else cb(ssl, SSL_CB_CONNECT_LOOP, 1); } /* * Validate that we are allowed to move to the new state and move * to that state if so */ if (!transition(s, mt)) return SUB_STATE_ERROR; if (s->s3.tmp.message_size > max_message_size(s)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE); return SUB_STATE_ERROR; } /* dtls_get_message already did this */ if (!SSL_CONNECTION_IS_DTLS(s) && s->s3.tmp.message_size > 0 && !grow_init_buf(s, s->s3.tmp.message_size + SSL3_HM_HEADER_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BUF_LIB); return SUB_STATE_ERROR; } st->read_state = READ_STATE_BODY; /* Fall through */ case READ_STATE_BODY: if (SSL_CONNECTION_IS_DTLS(s)) { /* * Actually we already have the body, but we give DTLS the * opportunity to do any further processing. */ ret = dtls_get_message_body(s, &len); } else { ret = tls_get_message_body(s, &len); } if (ret == 0) { /* Could be non-blocking IO */ return SUB_STATE_ERROR; } s->first_packet = 0; if (!PACKET_buf_init(&pkt, s->init_msg, len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } ret = process_message(s, &pkt); /* Discard the packet data */ s->init_num = 0; switch (ret) { case MSG_PROCESS_ERROR: check_fatal(s); return SUB_STATE_ERROR; case MSG_PROCESS_FINISHED_READING: if (SSL_CONNECTION_IS_DTLS(s)) { dtls1_stop_timer(s); } return SUB_STATE_FINISHED; case MSG_PROCESS_CONTINUE_PROCESSING: st->read_state = READ_STATE_POST_PROCESS; st->read_state_work = WORK_MORE_A; break; default: st->read_state = READ_STATE_HEADER; break; } break; case READ_STATE_POST_PROCESS: st->read_state_work = post_process_message(s, st->read_state_work); switch (st->read_state_work) { case WORK_ERROR: check_fatal(s); /* Fall through */ case WORK_MORE_A: case WORK_MORE_B: case WORK_MORE_C: return SUB_STATE_ERROR; case WORK_FINISHED_CONTINUE: st->read_state = READ_STATE_HEADER; break; case WORK_FINISHED_STOP: if (SSL_CONNECTION_IS_DTLS(s)) { dtls1_stop_timer(s); } return SUB_STATE_FINISHED; } break; default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } } } /* * Send a previously constructed message to the peer. */ static int statem_do_write(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; if (st->hand_state == TLS_ST_CW_CHANGE || st->hand_state == TLS_ST_SW_CHANGE) { if (SSL_CONNECTION_IS_DTLS(s)) return dtls1_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC); else return ssl3_do_write(s, SSL3_RT_CHANGE_CIPHER_SPEC); } else { return ssl_do_write(s); } } /* * Initialise the MSG_FLOW_WRITING sub-state machine */ static void init_write_state_machine(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; st->write_state = WRITE_STATE_TRANSITION; } /* * This function implements the sub-state machine when the message flow is in * MSG_FLOW_WRITING. The valid sub-states and transitions are: * * +-> WRITE_STATE_TRANSITION ------> [SUB_STATE_FINISHED] * | | * | v * | WRITE_STATE_PRE_WORK -----> [SUB_STATE_END_HANDSHAKE] * | | * | v * | WRITE_STATE_SEND * | | * | v * | WRITE_STATE_POST_WORK * | | * +-------------+ * * WRITE_STATE_TRANSITION transitions the state of the handshake state machine * WRITE_STATE_PRE_WORK performs any work necessary to prepare the later * sending of the message. This could result in an NBIO event occurring in * which case control returns to the calling application. When this function * is recalled we will resume in the same state where we left off. * * WRITE_STATE_SEND sends the message and performs any work to be done after * sending. * * WRITE_STATE_POST_WORK performs any work necessary after the sending of the * message has been completed. As for WRITE_STATE_PRE_WORK this could also * result in an NBIO event. */ static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; int ret; WRITE_TRAN(*transition) (SSL_CONNECTION *s); WORK_STATE(*pre_work) (SSL_CONNECTION *s, WORK_STATE wst); WORK_STATE(*post_work) (SSL_CONNECTION *s, WORK_STATE wst); int (*get_construct_message_f) (SSL_CONNECTION *s, CON_FUNC_RETURN (**confunc) (SSL_CONNECTION *s, WPACKET *pkt), int *mt); void (*cb) (const SSL *ssl, int type, int val) = NULL; CON_FUNC_RETURN (*confunc) (SSL_CONNECTION *s, WPACKET *pkt); int mt; WPACKET pkt; SSL *ssl = SSL_CONNECTION_GET_SSL(s); cb = get_callback(s); if (s->server) { transition = ossl_statem_server_write_transition; pre_work = ossl_statem_server_pre_work; post_work = ossl_statem_server_post_work; get_construct_message_f = ossl_statem_server_construct_message; } else { transition = ossl_statem_client_write_transition; pre_work = ossl_statem_client_pre_work; post_work = ossl_statem_client_post_work; get_construct_message_f = ossl_statem_client_construct_message; } while (1) { switch (st->write_state) { case WRITE_STATE_TRANSITION: if (cb != NULL) { /* Notify callback of an impending state change */ if (s->server) cb(ssl, SSL_CB_ACCEPT_LOOP, 1); else cb(ssl, SSL_CB_CONNECT_LOOP, 1); } switch (transition(s)) { case WRITE_TRAN_CONTINUE: st->write_state = WRITE_STATE_PRE_WORK; st->write_state_work = WORK_MORE_A; break; case WRITE_TRAN_FINISHED: return SUB_STATE_FINISHED; break; case WRITE_TRAN_ERROR: check_fatal(s); return SUB_STATE_ERROR; } break; case WRITE_STATE_PRE_WORK: switch (st->write_state_work = pre_work(s, st->write_state_work)) { case WORK_ERROR: check_fatal(s); /* Fall through */ case WORK_MORE_A: case WORK_MORE_B: case WORK_MORE_C: return SUB_STATE_ERROR; case WORK_FINISHED_CONTINUE: st->write_state = WRITE_STATE_SEND; break; case WORK_FINISHED_STOP: return SUB_STATE_END_HANDSHAKE; } if (!get_construct_message_f(s, &confunc, &mt)) { /* SSLfatal() already called */ return SUB_STATE_ERROR; } if (mt == SSL3_MT_DUMMY) { /* Skip construction and sending. This isn't a "real" state */ st->write_state = WRITE_STATE_POST_WORK; st->write_state_work = WORK_MORE_A; break; } if (!WPACKET_init(&pkt, s->init_buf) || !ssl_set_handshake_header(s, &pkt, mt)) { WPACKET_cleanup(&pkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } if (confunc != NULL) { CON_FUNC_RETURN tmpret; tmpret = confunc(s, &pkt); if (tmpret == CON_FUNC_ERROR) { WPACKET_cleanup(&pkt); check_fatal(s); return SUB_STATE_ERROR; } else if (tmpret == CON_FUNC_DONT_SEND) { /* * The construction function decided not to construct the * message after all and continue. Skip sending. */ WPACKET_cleanup(&pkt); st->write_state = WRITE_STATE_POST_WORK; st->write_state_work = WORK_MORE_A; break; } /* else success */ } if (!ssl_close_construct_packet(s, &pkt, mt) || !WPACKET_finish(&pkt)) { WPACKET_cleanup(&pkt); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } /* Fall through */ case WRITE_STATE_SEND: if (SSL_CONNECTION_IS_DTLS(s) && st->use_timer) { dtls1_start_timer(s); } ret = statem_do_write(s); if (ret <= 0) { return SUB_STATE_ERROR; } st->write_state = WRITE_STATE_POST_WORK; st->write_state_work = WORK_MORE_A; /* Fall through */ case WRITE_STATE_POST_WORK: switch (st->write_state_work = post_work(s, st->write_state_work)) { case WORK_ERROR: check_fatal(s); /* Fall through */ case WORK_MORE_A: case WORK_MORE_B: case WORK_MORE_C: return SUB_STATE_ERROR; case WORK_FINISHED_CONTINUE: st->write_state = WRITE_STATE_TRANSITION; break; case WORK_FINISHED_STOP: return SUB_STATE_END_HANDSHAKE; } break; default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return SUB_STATE_ERROR; } } } /* * Flush the write BIO */ int statem_flush(SSL_CONNECTION *s) { s->rwstate = SSL_WRITING; if (BIO_flush(s->wbio) <= 0) { return 0; } s->rwstate = SSL_NOTHING; return 1; } /* * Called by the record layer to determine whether application data is * allowed to be received in the current handshake state or not. * * Return values are: * 1: Yes (application data allowed) * 0: No (application data not allowed) */ int ossl_statem_app_data_allowed(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; if (st->state == MSG_FLOW_UNINITED) return 0; if (!s->s3.in_read_app_data || (s->s3.total_renegotiations == 0)) return 0; if (s->server) { /* * If we're a server and we haven't got as far as writing our * ServerHello yet then we allow app data */ if (st->hand_state == TLS_ST_BEFORE || st->hand_state == TLS_ST_SR_CLNT_HELLO) return 1; } else { /* * If we're a client and we haven't read the ServerHello yet then we * allow app data */ if (st->hand_state == TLS_ST_CW_CLNT_HELLO) return 1; } return 0; } /* * This function returns 1 if TLS exporter is ready to export keying * material, or 0 if otherwise. */ int ossl_statem_export_allowed(SSL_CONNECTION *s) { return s->s3.previous_server_finished_len != 0 && s->statem.hand_state != TLS_ST_SW_FINISHED; } /* * Return 1 if early TLS exporter is ready to export keying material, * or 0 if otherwise. */ int ossl_statem_export_early_allowed(SSL_CONNECTION *s) { /* * The early exporter secret is only present on the server if we * have accepted early_data. It is present on the client as long * as we have sent early_data. */ return s->ext.early_data == SSL_EARLY_DATA_ACCEPTED || (!s->server && s->ext.early_data != SSL_EARLY_DATA_NOT_SENT); }

./openssl/ssl/statem/extensions.c

/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #if defined(__TANDEM) && defined(_SPT_MODEL_) # include <spthread.h> # include <spt_extensions.h> /* timeval */ #endif #include <string.h> #include "internal/nelem.h" #include "internal/cryptlib.h" #include "../ssl_local.h" #include "statem_local.h" static int final_renegotiate(SSL_CONNECTION *s, unsigned int context, int sent); static int init_server_name(SSL_CONNECTION *s, unsigned int context); static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent); static int final_ec_pt_formats(SSL_CONNECTION *s, unsigned int context, int sent); static int init_session_ticket(SSL_CONNECTION *s, unsigned int context); #ifndef OPENSSL_NO_OCSP static int init_status_request(SSL_CONNECTION *s, unsigned int context); #endif #ifndef OPENSSL_NO_NEXTPROTONEG static int init_npn(SSL_CONNECTION *s, unsigned int context); #endif static int init_alpn(SSL_CONNECTION *s, unsigned int context); static int final_alpn(SSL_CONNECTION *s, unsigned int context, int sent); static int init_sig_algs_cert(SSL_CONNECTION *s, unsigned int context); static int init_sig_algs(SSL_CONNECTION *s, unsigned int context); static int init_server_cert_type(SSL_CONNECTION *sc, unsigned int context); static int init_client_cert_type(SSL_CONNECTION *sc, unsigned int context); static int init_certificate_authorities(SSL_CONNECTION *s, unsigned int context); static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); static int tls_parse_certificate_authorities(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); #ifndef OPENSSL_NO_SRP static int init_srp(SSL_CONNECTION *s, unsigned int context); #endif static int init_ec_point_formats(SSL_CONNECTION *s, unsigned int context); static int init_etm(SSL_CONNECTION *s, unsigned int context); static int init_ems(SSL_CONNECTION *s, unsigned int context); static int final_ems(SSL_CONNECTION *s, unsigned int context, int sent); static int init_psk_kex_modes(SSL_CONNECTION *s, unsigned int context); static int final_key_share(SSL_CONNECTION *s, unsigned int context, int sent); #ifndef OPENSSL_NO_SRTP static int init_srtp(SSL_CONNECTION *s, unsigned int context); #endif static int final_sig_algs(SSL_CONNECTION *s, unsigned int context, int sent); static int final_early_data(SSL_CONNECTION *s, unsigned int context, int sent); static int final_maxfragmentlen(SSL_CONNECTION *s, unsigned int context, int sent); static int init_post_handshake_auth(SSL_CONNECTION *s, unsigned int context); static int final_psk(SSL_CONNECTION *s, unsigned int context, int sent); static int tls_init_compress_certificate(SSL_CONNECTION *sc, unsigned int context); static EXT_RETURN tls_construct_compress_certificate(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); static int tls_parse_compress_certificate(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); /* Structure to define a built-in extension */ typedef struct extensions_definition_st { /* The defined type for the extension */ unsigned int type; /* * The context that this extension applies to, e.g. what messages and * protocol versions */ unsigned int context; /* * Initialise extension before parsing. Always called for relevant contexts * even if extension not present */ int (*init)(SSL_CONNECTION *s, unsigned int context); /* Parse extension sent from client to server */ int (*parse_ctos)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); /* Parse extension send from server to client */ int (*parse_stoc)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx); /* Construct extension sent from server to client */ EXT_RETURN (*construct_stoc)(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); /* Construct extension sent from client to server */ EXT_RETURN (*construct_ctos)(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); /* * Finalise extension after parsing. Always called where an extensions was * initialised even if the extension was not present. |sent| is set to 1 if * the extension was seen, or 0 otherwise. */ int (*final)(SSL_CONNECTION *s, unsigned int context, int sent); } EXTENSION_DEFINITION; /* * Definitions of all built-in extensions. NOTE: Changes in the number or order * of these extensions should be mirrored with equivalent changes to the * indexes ( TLSEXT_IDX_* ) defined in ssl_local.h. * Extensions should be added to test/ext_internal_test.c as well, as that * tests the ordering of the extensions. * * Each extension has an initialiser, a client and * server side parser and a finaliser. The initialiser is called (if the * extension is relevant to the given context) even if we did not see the * extension in the message that we received. The parser functions are only * called if we see the extension in the message. The finalisers are always * called if the initialiser was called. * There are also server and client side constructor functions which are always * called during message construction if the extension is relevant for the * given context. * The initialisation, parsing, finalisation and construction functions are * always called in the order defined in this list. Some extensions may depend * on others having been processed first, so the order of this list is * significant. * The extension context is defined by a series of flags which specify which * messages the extension is relevant to. These flags also specify whether the * extension is relevant to a particular protocol or protocol version. * * NOTE: WebSphere Application Server 7+ cannot handle empty extensions at * the end, keep these extensions before signature_algorithm. */ #define INVALID_EXTENSION { TLSEXT_TYPE_invalid, 0, NULL, NULL, NULL, NULL, NULL, NULL } static const EXTENSION_DEFINITION ext_defs[] = { { TLSEXT_TYPE_renegotiate, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_SSL3_ALLOWED | SSL_EXT_TLS1_2_AND_BELOW_ONLY, NULL, tls_parse_ctos_renegotiate, tls_parse_stoc_renegotiate, tls_construct_stoc_renegotiate, tls_construct_ctos_renegotiate, final_renegotiate }, { TLSEXT_TYPE_server_name, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, init_server_name, tls_parse_ctos_server_name, tls_parse_stoc_server_name, tls_construct_stoc_server_name, tls_construct_ctos_server_name, final_server_name }, { TLSEXT_TYPE_max_fragment_length, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, NULL, tls_parse_ctos_maxfragmentlen, tls_parse_stoc_maxfragmentlen, tls_construct_stoc_maxfragmentlen, tls_construct_ctos_maxfragmentlen, final_maxfragmentlen }, #ifndef OPENSSL_NO_SRP { TLSEXT_TYPE_srp, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_srp, tls_parse_ctos_srp, NULL, NULL, tls_construct_ctos_srp, NULL }, #else INVALID_EXTENSION, #endif { TLSEXT_TYPE_ec_point_formats, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_ec_point_formats, tls_parse_ctos_ec_pt_formats, tls_parse_stoc_ec_pt_formats, tls_construct_stoc_ec_pt_formats, tls_construct_ctos_ec_pt_formats, final_ec_pt_formats }, { /* * "supported_groups" is spread across several specifications. * It was originally specified as "elliptic_curves" in RFC 4492, * and broadened to include named FFDH groups by RFC 7919. * Both RFCs 4492 and 7919 do not include a provision for the server * to indicate to the client the complete list of groups supported * by the server, with the server instead just indicating the * selected group for this connection in the ServerKeyExchange * message. TLS 1.3 adds a scheme for the server to indicate * to the client its list of supported groups in the * EncryptedExtensions message, but none of the relevant * specifications permit sending supported_groups in the ServerHello. * Nonetheless (possibly due to the close proximity to the * "ec_point_formats" extension, which is allowed in the ServerHello), * there are several servers that send this extension in the * ServerHello anyway. Up to and including the 1.1.0 release, * we did not check for the presence of nonpermitted extensions, * so to avoid a regression, we must permit this extension in the * TLS 1.2 ServerHello as well. * * Note that there is no tls_parse_stoc_supported_groups function, * so we do not perform any additional parsing, validation, or * processing on the server's group list -- this is just a minimal * change to preserve compatibility with these misbehaving servers. */ TLSEXT_TYPE_supported_groups, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_TLS1_2_SERVER_HELLO, NULL, tls_parse_ctos_supported_groups, NULL, tls_construct_stoc_supported_groups, tls_construct_ctos_supported_groups, NULL }, { TLSEXT_TYPE_session_ticket, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_session_ticket, tls_parse_ctos_session_ticket, tls_parse_stoc_session_ticket, tls_construct_stoc_session_ticket, tls_construct_ctos_session_ticket, NULL }, #ifndef OPENSSL_NO_OCSP { TLSEXT_TYPE_status_request, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, init_status_request, tls_parse_ctos_status_request, tls_parse_stoc_status_request, tls_construct_stoc_status_request, tls_construct_ctos_status_request, NULL }, #else INVALID_EXTENSION, #endif #ifndef OPENSSL_NO_NEXTPROTONEG { TLSEXT_TYPE_next_proto_neg, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_npn, tls_parse_ctos_npn, tls_parse_stoc_npn, tls_construct_stoc_next_proto_neg, tls_construct_ctos_npn, NULL }, #else INVALID_EXTENSION, #endif { /* * Must appear in this list after server_name so that finalisation * happens after server_name callbacks */ TLSEXT_TYPE_application_layer_protocol_negotiation, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, init_alpn, tls_parse_ctos_alpn, tls_parse_stoc_alpn, tls_construct_stoc_alpn, tls_construct_ctos_alpn, final_alpn }, #ifndef OPENSSL_NO_SRTP { TLSEXT_TYPE_use_srtp, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_DTLS_ONLY, init_srtp, tls_parse_ctos_use_srtp, tls_parse_stoc_use_srtp, tls_construct_stoc_use_srtp, tls_construct_ctos_use_srtp, NULL }, #else INVALID_EXTENSION, #endif { TLSEXT_TYPE_encrypt_then_mac, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_etm, tls_parse_ctos_etm, tls_parse_stoc_etm, tls_construct_stoc_etm, tls_construct_ctos_etm, NULL }, #ifndef OPENSSL_NO_CT { TLSEXT_TYPE_signed_certificate_timestamp, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, NULL, /* * No server side support for this, but can be provided by a custom * extension. This is an exception to the rule that custom extensions * cannot override built in ones. */ NULL, tls_parse_stoc_sct, NULL, tls_construct_ctos_sct, NULL }, #else INVALID_EXTENSION, #endif { TLSEXT_TYPE_extended_master_secret, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY, init_ems, tls_parse_ctos_ems, tls_parse_stoc_ems, tls_construct_stoc_ems, tls_construct_ctos_ems, final_ems }, { TLSEXT_TYPE_signature_algorithms_cert, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, init_sig_algs_cert, tls_parse_ctos_sig_algs_cert, tls_parse_ctos_sig_algs_cert, /* We do not generate signature_algorithms_cert at present. */ NULL, NULL, NULL }, { TLSEXT_TYPE_post_handshake_auth, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ONLY, init_post_handshake_auth, tls_parse_ctos_post_handshake_auth, NULL, NULL, tls_construct_ctos_post_handshake_auth, NULL, }, { TLSEXT_TYPE_client_cert_type, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_TLS1_2_SERVER_HELLO, init_client_cert_type, tls_parse_ctos_client_cert_type, tls_parse_stoc_client_cert_type, tls_construct_stoc_client_cert_type, tls_construct_ctos_client_cert_type, NULL }, { TLSEXT_TYPE_server_cert_type, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_TLS1_2_SERVER_HELLO, init_server_cert_type, tls_parse_ctos_server_cert_type, tls_parse_stoc_server_cert_type, tls_construct_stoc_server_cert_type, tls_construct_ctos_server_cert_type, NULL }, { TLSEXT_TYPE_signature_algorithms, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, init_sig_algs, tls_parse_ctos_sig_algs, tls_parse_ctos_sig_algs, tls_construct_ctos_sig_algs, tls_construct_ctos_sig_algs, final_sig_algs }, { TLSEXT_TYPE_supported_versions, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY, NULL, /* Processed inline as part of version selection */ NULL, tls_parse_stoc_supported_versions, tls_construct_stoc_supported_versions, tls_construct_ctos_supported_versions, NULL }, { TLSEXT_TYPE_psk_kex_modes, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY, init_psk_kex_modes, tls_parse_ctos_psk_kex_modes, NULL, NULL, tls_construct_ctos_psk_kex_modes, NULL }, { /* * Must be in this list after supported_groups. We need that to have * been parsed before we do this one. */ TLSEXT_TYPE_key_share, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY, NULL, tls_parse_ctos_key_share, tls_parse_stoc_key_share, tls_construct_stoc_key_share, tls_construct_ctos_key_share, final_key_share }, { /* Must be after key_share */ TLSEXT_TYPE_cookie, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY, NULL, tls_parse_ctos_cookie, tls_parse_stoc_cookie, tls_construct_stoc_cookie, tls_construct_ctos_cookie, NULL }, { /* * Special unsolicited ServerHello extension only used when * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set. We allow it in a ClientHello but * ignore it. */ TLSEXT_TYPE_cryptopro_bug, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY, NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL }, { TLSEXT_TYPE_compress_certificate, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY, tls_init_compress_certificate, tls_parse_compress_certificate, tls_parse_compress_certificate, tls_construct_compress_certificate, tls_construct_compress_certificate, NULL }, { TLSEXT_TYPE_early_data, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_TLS1_3_NEW_SESSION_TICKET | SSL_EXT_TLS1_3_ONLY, NULL, tls_parse_ctos_early_data, tls_parse_stoc_early_data, tls_construct_stoc_early_data, tls_construct_ctos_early_data, final_early_data }, { TLSEXT_TYPE_certificate_authorities, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST | SSL_EXT_TLS1_3_ONLY, init_certificate_authorities, tls_parse_certificate_authorities, tls_parse_certificate_authorities, tls_construct_certificate_authorities, tls_construct_certificate_authorities, NULL, }, { /* Must be immediately before pre_shared_key */ TLSEXT_TYPE_padding, SSL_EXT_CLIENT_HELLO, NULL, /* We send this, but don't read it */ NULL, NULL, NULL, tls_construct_ctos_padding, NULL }, { /* Required by the TLSv1.3 spec to always be the last extension */ TLSEXT_TYPE_psk, SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY, NULL, tls_parse_ctos_psk, tls_parse_stoc_psk, tls_construct_stoc_psk, tls_construct_ctos_psk, final_psk } }; /* Returns a TLSEXT_TYPE for the given index */ unsigned int ossl_get_extension_type(size_t idx) { size_t num_exts = OSSL_NELEM(ext_defs); if (idx >= num_exts) return TLSEXT_TYPE_out_of_range; return ext_defs[idx].type; } /* Check whether an extension's context matches the current context */ static int validate_context(SSL_CONNECTION *s, unsigned int extctx, unsigned int thisctx) { /* Check we're allowed to use this extension in this context */ if ((thisctx & extctx) == 0) return 0; if (SSL_CONNECTION_IS_DTLS(s)) { if ((extctx & SSL_EXT_TLS_ONLY) != 0) return 0; } else if ((extctx & SSL_EXT_DTLS_ONLY) != 0) { return 0; } return 1; } int tls_validate_all_contexts(SSL_CONNECTION *s, unsigned int thisctx, RAW_EXTENSION *exts) { size_t i, num_exts, builtin_num = OSSL_NELEM(ext_defs), offset; RAW_EXTENSION *thisext; unsigned int context; ENDPOINT role = ENDPOINT_BOTH; if ((thisctx & SSL_EXT_CLIENT_HELLO) != 0) role = ENDPOINT_SERVER; else if ((thisctx & SSL_EXT_TLS1_2_SERVER_HELLO) != 0) role = ENDPOINT_CLIENT; /* Calculate the number of extensions in the extensions list */ num_exts = builtin_num + s->cert->custext.meths_count; for (thisext = exts, i = 0; i < num_exts; i++, thisext++) { if (!thisext->present) continue; if (i < builtin_num) { context = ext_defs[i].context; } else { custom_ext_method *meth = NULL; meth = custom_ext_find(&s->cert->custext, role, thisext->type, &offset); if (!ossl_assert(meth != NULL)) return 0; context = meth->context; } if (!validate_context(s, context, thisctx)) return 0; } return 1; } /* * Verify whether we are allowed to use the extension |type| in the current * |context|. Returns 1 to indicate the extension is allowed or unknown or 0 to * indicate the extension is not allowed. If returning 1 then |*found| is set to * the definition for the extension we found. */ static int verify_extension(SSL_CONNECTION *s, unsigned int context, unsigned int type, custom_ext_methods *meths, RAW_EXTENSION *rawexlist, RAW_EXTENSION **found) { size_t i; size_t builtin_num = OSSL_NELEM(ext_defs); const EXTENSION_DEFINITION *thisext; for (i = 0, thisext = ext_defs; i < builtin_num; i++, thisext++) { if (type == thisext->type) { if (!validate_context(s, thisext->context, context)) return 0; *found = &rawexlist[i]; return 1; } } /* Check the custom extensions */ if (meths != NULL) { size_t offset = 0; ENDPOINT role = ENDPOINT_BOTH; custom_ext_method *meth = NULL; if ((context & SSL_EXT_CLIENT_HELLO) != 0) role = ENDPOINT_SERVER; else if ((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0) role = ENDPOINT_CLIENT; meth = custom_ext_find(meths, role, type, &offset); if (meth != NULL) { if (!validate_context(s, meth->context, context)) return 0; *found = &rawexlist[offset + builtin_num]; return 1; } } /* Unknown extension. We allow it */ *found = NULL; return 1; } /* * Check whether the context defined for an extension |extctx| means whether * the extension is relevant for the current context |thisctx| or not. Returns * 1 if the extension is relevant for this context, and 0 otherwise */ int extension_is_relevant(SSL_CONNECTION *s, unsigned int extctx, unsigned int thisctx) { int is_tls13; /* * For HRR we haven't selected the version yet but we know it will be * TLSv1.3 */ if ((thisctx & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) is_tls13 = 1; else is_tls13 = SSL_CONNECTION_IS_TLS13(s); if ((SSL_CONNECTION_IS_DTLS(s) && (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0) || (s->version == SSL3_VERSION && (extctx & SSL_EXT_SSL3_ALLOWED) == 0) /* * Note that SSL_IS_TLS13() means "TLS 1.3 has been negotiated", * which is never true when generating the ClientHello. * However, version negotiation *has* occurred by the time the * ClientHello extensions are being parsed. * Be careful to allow TLS 1.3-only extensions when generating * the ClientHello. */ || (is_tls13 && (extctx & SSL_EXT_TLS1_2_AND_BELOW_ONLY) != 0) || (!is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0 && (thisctx & SSL_EXT_CLIENT_HELLO) == 0) || (s->server && !is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0) || (s->hit && (extctx & SSL_EXT_IGNORE_ON_RESUMPTION) != 0)) return 0; return 1; } /* * Gather a list of all the extensions from the data in |packet]. |context| * tells us which message this extension is for. The raw extension data is * stored in |*res| on success. We don't actually process the content of the * extensions yet, except to check their types. This function also runs the * initialiser functions for all known extensions if |init| is nonzero (whether * we have collected them or not). If successful the caller is responsible for * freeing the contents of |*res|. * * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be * more than one extension of the same type in a ClientHello or ServerHello. * This function returns 1 if all extensions are unique and we have parsed their * types, and 0 if the extensions contain duplicates, could not be successfully * found, or an internal error occurred. We only check duplicates for * extensions that we know about. We ignore others. */ int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet, unsigned int context, RAW_EXTENSION **res, size_t *len, int init) { PACKET extensions = *packet; size_t i = 0; size_t num_exts; custom_ext_methods *exts = &s->cert->custext; RAW_EXTENSION *raw_extensions = NULL; const EXTENSION_DEFINITION *thisexd; *res = NULL; /* * Initialise server side custom extensions. Client side is done during * construction of extensions for the ClientHello. */ if ((context & SSL_EXT_CLIENT_HELLO) != 0) custom_ext_init(&s->cert->custext); num_exts = OSSL_NELEM(ext_defs) + (exts != NULL ? exts->meths_count : 0); raw_extensions = OPENSSL_zalloc(num_exts * sizeof(*raw_extensions)); if (raw_extensions == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } i = 0; while (PACKET_remaining(&extensions) > 0) { unsigned int type, idx; PACKET extension; RAW_EXTENSION *thisex; if (!PACKET_get_net_2(&extensions, &type) || !PACKET_get_length_prefixed_2(&extensions, &extension)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); goto err; } /* * Verify this extension is allowed. We only check duplicates for * extensions that we recognise. We also have a special case for the * PSK extension, which must be the last one in the ClientHello. */ if (!verify_extension(s, context, type, exts, raw_extensions, &thisex) || (thisex != NULL && thisex->present == 1) || (type == TLSEXT_TYPE_psk && (context & SSL_EXT_CLIENT_HELLO) != 0 && PACKET_remaining(&extensions) != 0)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); goto err; } idx = thisex - raw_extensions; /*- * Check that we requested this extension (if appropriate). Requests can * be sent in the ClientHello and CertificateRequest. Unsolicited * extensions can be sent in the NewSessionTicket. We only do this for * the built-in extensions. Custom extensions have a different but * similar check elsewhere. * Special cases: * - The HRR cookie extension is unsolicited * - The renegotiate extension is unsolicited (the client signals * support via an SCSV) * - The signed_certificate_timestamp extension can be provided by a * custom extension or by the built-in version. We let the extension * itself handle unsolicited response checks. */ if (idx < OSSL_NELEM(ext_defs) && (context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) == 0 && type != TLSEXT_TYPE_cookie && type != TLSEXT_TYPE_renegotiate && type != TLSEXT_TYPE_signed_certificate_timestamp && (s->ext.extflags[idx] & SSL_EXT_FLAG_SENT) == 0 #ifndef OPENSSL_NO_GOST && !((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0 && type == TLSEXT_TYPE_cryptopro_bug) #endif ) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_UNSOLICITED_EXTENSION); goto err; } if (thisex != NULL) { thisex->data = extension; thisex->present = 1; thisex->type = type; thisex->received_order = i++; if (s->ext.debug_cb) s->ext.debug_cb(SSL_CONNECTION_GET_SSL(s), !s->server, thisex->type, PACKET_data(&thisex->data), PACKET_remaining(&thisex->data), s->ext.debug_arg); } } if (init) { /* * Initialise all known extensions relevant to this context, * whether we have found them or not */ for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs); i++, thisexd++) { if (thisexd->init != NULL && (thisexd->context & context) != 0 && extension_is_relevant(s, thisexd->context, context) && !thisexd->init(s, context)) { /* SSLfatal() already called */ goto err; } } } *res = raw_extensions; if (len != NULL) *len = num_exts; return 1; err: OPENSSL_free(raw_extensions); return 0; } /* * Runs the parser for a given extension with index |idx|. |exts| contains the * list of all parsed extensions previously collected by * tls_collect_extensions(). The parser is only run if it is applicable for the * given |context| and the parser has not already been run. If this is for a * Certificate message, then we also provide the parser with the relevant * Certificate |x| and its position in the |chainidx| with 0 being the first * Certificate. Returns 1 on success or 0 on failure. If an extension is not * present this counted as success. */ int tls_parse_extension(SSL_CONNECTION *s, TLSEXT_INDEX idx, int context, RAW_EXTENSION *exts, X509 *x, size_t chainidx) { RAW_EXTENSION *currext = &exts[idx]; int (*parser)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) = NULL; /* Skip if the extension is not present */ if (!currext->present) return 1; /* Skip if we've already parsed this extension */ if (currext->parsed) return 1; currext->parsed = 1; if (idx < OSSL_NELEM(ext_defs)) { /* We are handling a built-in extension */ const EXTENSION_DEFINITION *extdef = &ext_defs[idx]; /* Check if extension is defined for our protocol. If not, skip */ if (!extension_is_relevant(s, extdef->context, context)) return 1; parser = s->server ? extdef->parse_ctos : extdef->parse_stoc; if (parser != NULL) return parser(s, &currext->data, context, x, chainidx); /* * If the parser is NULL we fall through to the custom extension * processing */ } /* Parse custom extensions */ return custom_ext_parse(s, context, currext->type, PACKET_data(&currext->data), PACKET_remaining(&currext->data), x, chainidx); } /* * Parse all remaining extensions that have not yet been parsed. Also calls the * finalisation for all extensions at the end if |fin| is nonzero, whether we * collected them or not. Returns 1 for success or 0 for failure. If we are * working on a Certificate message then we also pass the Certificate |x| and * its position in the |chainidx|, with 0 being the first certificate. */ int tls_parse_all_extensions(SSL_CONNECTION *s, int context, RAW_EXTENSION *exts, X509 *x, size_t chainidx, int fin) { size_t i, numexts = OSSL_NELEM(ext_defs); const EXTENSION_DEFINITION *thisexd; /* Calculate the number of extensions in the extensions list */ numexts += s->cert->custext.meths_count; /* Parse each extension in turn */ for (i = 0; i < numexts; i++) { if (!tls_parse_extension(s, i, context, exts, x, chainidx)) { /* SSLfatal() already called */ return 0; } } if (fin) { /* * Finalise all known extensions relevant to this context, * whether we have found them or not */ for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) { if (thisexd->final != NULL && (thisexd->context & context) != 0 && !thisexd->final(s, context, exts[i].present)) { /* SSLfatal() already called */ return 0; } } } return 1; } int should_add_extension(SSL_CONNECTION *s, unsigned int extctx, unsigned int thisctx, int max_version) { /* Skip if not relevant for our context */ if ((extctx & thisctx) == 0) return 0; /* Check if this extension is defined for our protocol. If not, skip */ if (!extension_is_relevant(s, extctx, thisctx) || ((extctx & SSL_EXT_TLS1_3_ONLY) != 0 && (thisctx & SSL_EXT_CLIENT_HELLO) != 0 && (SSL_CONNECTION_IS_DTLS(s) || max_version < TLS1_3_VERSION))) return 0; return 1; } /* * Construct all the extensions relevant to the current |context| and write * them to |pkt|. If this is an extension for a Certificate in a Certificate * message, then |x| will be set to the Certificate we are handling, and * |chainidx| will indicate the position in the chainidx we are processing (with * 0 being the first in the chain). Returns 1 on success or 0 on failure. On a * failure construction stops at the first extension to fail to construct. */ int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { size_t i; int min_version, max_version = 0, reason; const EXTENSION_DEFINITION *thisexd; int for_comp = (context & SSL_EXT_TLS1_3_CERTIFICATE_COMPRESSION) != 0; if (!WPACKET_start_sub_packet_u16(pkt) /* * If extensions are of zero length then we don't even add the * extensions length bytes to a ClientHello/ServerHello * (for non-TLSv1.3). */ || ((context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO)) != 0 && !WPACKET_set_flags(pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((context & SSL_EXT_CLIENT_HELLO) != 0) { reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); if (reason != 0) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); return 0; } } /* Add custom extensions first */ if ((context & SSL_EXT_CLIENT_HELLO) != 0) { /* On the server side with initialise during ClientHello parsing */ custom_ext_init(&s->cert->custext); } if (!custom_ext_add(s, context, pkt, x, chainidx, max_version)) { /* SSLfatal() already called */ return 0; } for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) { EXT_RETURN (*construct)(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx); EXT_RETURN ret; /* Skip if not relevant for our context */ if (!should_add_extension(s, thisexd->context, context, max_version)) continue; construct = s->server ? thisexd->construct_stoc : thisexd->construct_ctos; if (construct == NULL) continue; ret = construct(s, pkt, context, x, chainidx); if (ret == EXT_RETURN_FAIL) { /* SSLfatal() already called */ return 0; } if (ret == EXT_RETURN_SENT && (context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) != 0) s->ext.extflags[i] |= SSL_EXT_FLAG_SENT; } if (!WPACKET_close(pkt)) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } /* * Built in extension finalisation and initialisation functions. All initialise * or finalise the associated extension type for the given |context|. For * finalisers |sent| is set to 1 if we saw the extension during parsing, and 0 * otherwise. These functions return 1 on success or 0 on failure. */ static int final_renegotiate(SSL_CONNECTION *s, unsigned int context, int sent) { if (!s->server) { /* * Check if we can connect to a server that doesn't support safe * renegotiation */ if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT) && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) && !sent) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED); return 0; } return 1; } /* Need RI if renegotiating */ if (s->renegotiate && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) && !sent) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED); return 0; } return 1; } static ossl_inline void ssl_tsan_decr(const SSL_CTX *ctx, TSAN_QUALIFIER int *stat) { if (ssl_tsan_lock(ctx)) { tsan_decr(stat); ssl_tsan_unlock(ctx); } } static int init_server_name(SSL_CONNECTION *s, unsigned int context) { if (s->server) { s->servername_done = 0; OPENSSL_free(s->ext.hostname); s->ext.hostname = NULL; } return 1; } static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent) { int ret = SSL_TLSEXT_ERR_NOACK; int altmp = SSL_AD_UNRECOGNIZED_NAME; SSL *ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); int was_ticket = (SSL_get_options(ssl) & SSL_OP_NO_TICKET) == 0; if (!ossl_assert(sctx != NULL) || !ossl_assert(s->session_ctx != NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (sctx->ext.servername_cb != NULL) ret = sctx->ext.servername_cb(ssl, &altmp, sctx->ext.servername_arg); else if (s->session_ctx->ext.servername_cb != NULL) ret = s->session_ctx->ext.servername_cb(ssl, &altmp, s->session_ctx->ext.servername_arg); /* * For servers, propagate the SNI hostname from the temporary * storage in the SSL to the persistent SSL_SESSION, now that we * know we accepted it. * Clients make this copy when parsing the server's response to * the extension, which is when they find out that the negotiation * was successful. */ if (s->server) { if (sent && ret == SSL_TLSEXT_ERR_OK && !s->hit) { /* Only store the hostname in the session if we accepted it. */ OPENSSL_free(s->session->ext.hostname); s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname); if (s->session->ext.hostname == NULL && s->ext.hostname != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); } } } /* * If we switched contexts (whether here or in the client_hello callback), * move the sess_accept increment from the session_ctx to the new * context, to avoid the confusing situation of having sess_accept_good * exceed sess_accept (zero) for the new context. */ if (SSL_IS_FIRST_HANDSHAKE(s) && sctx != s->session_ctx && s->hello_retry_request == SSL_HRR_NONE) { ssl_tsan_counter(sctx, &sctx->stats.sess_accept); ssl_tsan_decr(s->session_ctx, &s->session_ctx->stats.sess_accept); } /* * If we're expecting to send a ticket, and tickets were previously enabled, * and now tickets are disabled, then turn off expected ticket. * Also, if this is not a resumption, create a new session ID */ if (ret == SSL_TLSEXT_ERR_OK && s->ext.ticket_expected && was_ticket && (SSL_get_options(ssl) & SSL_OP_NO_TICKET) != 0) { s->ext.ticket_expected = 0; if (!s->hit) { SSL_SESSION* ss = SSL_get_session(ssl); if (ss != NULL) { OPENSSL_free(ss->ext.tick); ss->ext.tick = NULL; ss->ext.ticklen = 0; ss->ext.tick_lifetime_hint = 0; ss->ext.tick_age_add = 0; if (!ssl_generate_session_id(s, ss)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } else { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } switch (ret) { case SSL_TLSEXT_ERR_ALERT_FATAL: SSLfatal(s, altmp, SSL_R_CALLBACK_FAILED); return 0; case SSL_TLSEXT_ERR_ALERT_WARNING: /* TLSv1.3 doesn't have warning alerts so we suppress this */ if (!SSL_CONNECTION_IS_TLS13(s)) ssl3_send_alert(s, SSL3_AL_WARNING, altmp); s->servername_done = 0; return 1; case SSL_TLSEXT_ERR_NOACK: s->servername_done = 0; return 1; default: return 1; } } static int final_ec_pt_formats(SSL_CONNECTION *s, unsigned int context, int sent) { unsigned long alg_k, alg_a; if (s->server) return 1; alg_k = s->s3.tmp.new_cipher->algorithm_mkey; alg_a = s->s3.tmp.new_cipher->algorithm_auth; /* * If we are client and using an elliptic curve cryptography cipher * suite, then if server returns an EC point formats lists extension it * must contain uncompressed. */ if (s->ext.ecpointformats != NULL && s->ext.ecpointformats_len > 0 && s->ext.peer_ecpointformats != NULL && s->ext.peer_ecpointformats_len > 0 && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) { /* we are using an ECC cipher */ size_t i; unsigned char *list = s->ext.peer_ecpointformats; for (i = 0; i < s->ext.peer_ecpointformats_len; i++) { if (*list++ == TLSEXT_ECPOINTFORMAT_uncompressed) break; } if (i == s->ext.peer_ecpointformats_len) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST); return 0; } } return 1; } static int init_session_ticket(SSL_CONNECTION *s, unsigned int context) { if (!s->server) s->ext.ticket_expected = 0; return 1; } #ifndef OPENSSL_NO_OCSP static int init_status_request(SSL_CONNECTION *s, unsigned int context) { if (s->server) { s->ext.status_type = TLSEXT_STATUSTYPE_nothing; } else { /* * Ensure we get sensible values passed to tlsext_status_cb in the event * that we don't receive a status message */ OPENSSL_free(s->ext.ocsp.resp); s->ext.ocsp.resp = NULL; s->ext.ocsp.resp_len = 0; } return 1; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG static int init_npn(SSL_CONNECTION *s, unsigned int context) { s->s3.npn_seen = 0; return 1; } #endif static int init_alpn(SSL_CONNECTION *s, unsigned int context) { OPENSSL_free(s->s3.alpn_selected); s->s3.alpn_selected = NULL; s->s3.alpn_selected_len = 0; if (s->server) { OPENSSL_free(s->s3.alpn_proposed); s->s3.alpn_proposed = NULL; s->s3.alpn_proposed_len = 0; } return 1; } static int final_alpn(SSL_CONNECTION *s, unsigned int context, int sent) { if (!s->server && !sent && s->session->ext.alpn_selected != NULL) s->ext.early_data_ok = 0; if (!s->server || !SSL_CONNECTION_IS_TLS13(s)) return 1; /* * Call alpn_select callback if needed. Has to be done after SNI and * cipher negotiation (HTTP/2 restricts permitted ciphers). In TLSv1.3 * we also have to do this before we decide whether to accept early_data. * In TLSv1.3 we've already negotiated our cipher so we do this call now. * For < TLSv1.3 we defer it until after cipher negotiation. * * On failure SSLfatal() already called. */ return tls_handle_alpn(s); } static int init_sig_algs(SSL_CONNECTION *s, unsigned int context) { /* Clear any signature algorithms extension received */ OPENSSL_free(s->s3.tmp.peer_sigalgs); s->s3.tmp.peer_sigalgs = NULL; s->s3.tmp.peer_sigalgslen = 0; return 1; } static int init_sig_algs_cert(SSL_CONNECTION *s, ossl_unused unsigned int context) { /* Clear any signature algorithms extension received */ OPENSSL_free(s->s3.tmp.peer_cert_sigalgs); s->s3.tmp.peer_cert_sigalgs = NULL; s->s3.tmp.peer_cert_sigalgslen = 0; return 1; } #ifndef OPENSSL_NO_SRP static int init_srp(SSL_CONNECTION *s, unsigned int context) { OPENSSL_free(s->srp_ctx.login); s->srp_ctx.login = NULL; return 1; } #endif static int init_ec_point_formats(SSL_CONNECTION *s, unsigned int context) { OPENSSL_free(s->ext.peer_ecpointformats); s->ext.peer_ecpointformats = NULL; s->ext.peer_ecpointformats_len = 0; return 1; } static int init_etm(SSL_CONNECTION *s, unsigned int context) { s->ext.use_etm = 0; return 1; } static int init_ems(SSL_CONNECTION *s, unsigned int context) { if (s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) { s->s3.flags &= ~TLS1_FLAGS_RECEIVED_EXTMS; s->s3.flags |= TLS1_FLAGS_REQUIRED_EXTMS; } return 1; } static int final_ems(SSL_CONNECTION *s, unsigned int context, int sent) { /* * Check extended master secret extension is not dropped on * renegotiation. */ if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) && (s->s3.flags & TLS1_FLAGS_REQUIRED_EXTMS)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_EXTMS); return 0; } if (!s->server && s->hit) { /* * Check extended master secret extension is consistent with * original session. */ if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) != !(s->session->flags & SSL_SESS_FLAG_EXTMS)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_EXTMS); return 0; } } return 1; } static int init_certificate_authorities(SSL_CONNECTION *s, unsigned int context) { sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free); s->s3.tmp.peer_ca_names = NULL; return 1; } static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { const STACK_OF(X509_NAME) *ca_sk = get_ca_names(s); if (ca_sk == NULL || sk_X509_NAME_num(ca_sk) == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_certificate_authorities) || !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (!construct_ca_names(s, ca_sk, pkt)) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } static int tls_parse_certificate_authorities(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (!parse_ca_names(s, pkt)) return 0; if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } return 1; } #ifndef OPENSSL_NO_SRTP static int init_srtp(SSL_CONNECTION *s, unsigned int context) { if (s->server) s->srtp_profile = NULL; return 1; } #endif static int final_sig_algs(SSL_CONNECTION *s, unsigned int context, int sent) { if (!sent && SSL_CONNECTION_IS_TLS13(s) && !s->hit) { SSLfatal(s, TLS13_AD_MISSING_EXTENSION, SSL_R_MISSING_SIGALGS_EXTENSION); return 0; } return 1; } static int final_key_share(SSL_CONNECTION *s, unsigned int context, int sent) { #if !defined(OPENSSL_NO_TLS1_3) if (!SSL_CONNECTION_IS_TLS13(s)) return 1; /* Nothing to do for key_share in an HRR */ if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) return 1; /* * If * we are a client * AND * we have no key_share * AND * (we are not resuming * OR the kex_mode doesn't allow non key_share resumes) * THEN * fail; */ if (!s->server && !sent && (!s->hit || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0)) { /* Nothing left we can do - just fail */ SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_R_NO_SUITABLE_KEY_SHARE); return 0; } /* * IF * we are a server * THEN * IF * we have a suitable key_share * THEN * IF * we are stateless AND we have no cookie * THEN * send a HelloRetryRequest * ELSE * IF * we didn't already send a HelloRetryRequest * AND * the client sent a key_share extension * AND * (we are not resuming * OR the kex_mode allows key_share resumes) * AND * a shared group exists * THEN * send a HelloRetryRequest * ELSE IF * we are not resuming * OR * the kex_mode doesn't allow non key_share resumes * THEN * fail * ELSE IF * we are stateless AND we have no cookie * THEN * send a HelloRetryRequest */ if (s->server) { if (s->s3.peer_tmp != NULL) { /* We have a suitable key_share */ if ((s->s3.flags & TLS1_FLAGS_STATELESS) != 0 && !s->ext.cookieok) { if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) { /* * If we are stateless then we wouldn't know about any * previously sent HRR - so how can this be anything other * than 0? */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->hello_retry_request = SSL_HRR_PENDING; return 1; } } else { /* No suitable key_share */ if (s->hello_retry_request == SSL_HRR_NONE && sent && (!s->hit || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) != 0)) { const uint16_t *pgroups, *clntgroups; size_t num_groups, clnt_num_groups, i; unsigned int group_id = 0; /* Check if a shared group exists */ /* Get the clients list of supported groups. */ tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups); tls1_get_supported_groups(s, &pgroups, &num_groups); /* * Find the first group we allow that is also in client's list */ for (i = 0; i < num_groups; i++) { group_id = pgroups[i]; if (check_in_list(s, group_id, clntgroups, clnt_num_groups, 1) && tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED) && tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION, 0, NULL)) break; } if (i < num_groups) { /* A shared group exists so send a HelloRetryRequest */ s->s3.group_id = group_id; s->hello_retry_request = SSL_HRR_PENDING; return 1; } } if (!s->hit || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) { /* Nothing left we can do - just fail */ SSLfatal(s, sent ? SSL_AD_HANDSHAKE_FAILURE : SSL_AD_MISSING_EXTENSION, SSL_R_NO_SUITABLE_KEY_SHARE); return 0; } if ((s->s3.flags & TLS1_FLAGS_STATELESS) != 0 && !s->ext.cookieok) { if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) { /* * If we are stateless then we wouldn't know about any * previously sent HRR - so how can this be anything other * than 0? */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->hello_retry_request = SSL_HRR_PENDING; return 1; } } /* * We have a key_share so don't send any more HelloRetryRequest * messages */ if (s->hello_retry_request == SSL_HRR_PENDING) s->hello_retry_request = SSL_HRR_COMPLETE; } else { /* * For a client side resumption with no key_share we need to generate * the handshake secret (otherwise this is done during key_share * processing). */ if (!sent && !tls13_generate_handshake_secret(s, NULL, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } #endif /* !defined(OPENSSL_NO_TLS1_3) */ return 1; } static int init_psk_kex_modes(SSL_CONNECTION *s, unsigned int context) { s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_NONE; return 1; } int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md, const unsigned char *msgstart, size_t binderoffset, const unsigned char *binderin, unsigned char *binderout, SSL_SESSION *sess, int sign, int external) { EVP_PKEY *mackey = NULL; EVP_MD_CTX *mctx = NULL; unsigned char hash[EVP_MAX_MD_SIZE], binderkey[EVP_MAX_MD_SIZE]; unsigned char finishedkey[EVP_MAX_MD_SIZE], tmpbinder[EVP_MAX_MD_SIZE]; unsigned char *early_secret; /* ASCII: "res binder", in hex for EBCDIC compatibility */ static const unsigned char resumption_label[] = "\x72\x65\x73\x20\x62\x69\x6E\x64\x65\x72"; /* ASCII: "ext binder", in hex for EBCDIC compatibility */ static const unsigned char external_label[] = "\x65\x78\x74\x20\x62\x69\x6E\x64\x65\x72"; const unsigned char *label; size_t bindersize, labelsize, hashsize; int hashsizei = EVP_MD_get_size(md); int ret = -1; int usepskfored = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* Ensure cast to size_t is safe */ if (!ossl_assert(hashsizei >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hashsize = (size_t)hashsizei; if (external && s->early_data_state == SSL_EARLY_DATA_CONNECTING && s->session->ext.max_early_data == 0 && sess->ext.max_early_data > 0) usepskfored = 1; if (external) { label = external_label; labelsize = sizeof(external_label) - 1; } else { label = resumption_label; labelsize = sizeof(resumption_label) - 1; } /* * Generate the early_secret. On the server side we've selected a PSK to * resume with (internal or external) so we always do this. On the client * side we do this for a non-external (i.e. resumption) PSK or external PSK * that will be used for early_data so that it is in place for sending early * data. For client side external PSK not being used for early_data we * generate it but store it away for later use. */ if (s->server || !external || usepskfored) early_secret = (unsigned char *)s->early_secret; else early_secret = (unsigned char *)sess->early_secret; if (!tls13_generate_secret(s, md, NULL, sess->master_key, sess->master_key_length, early_secret)) { /* SSLfatal() already called */ goto err; } /* * Create the handshake hash for the binder key...the messages so far are * empty! */ mctx = EVP_MD_CTX_new(); if (mctx == NULL || EVP_DigestInit_ex(mctx, md, NULL) <= 0 || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Generate the binder key */ if (!tls13_hkdf_expand(s, md, early_secret, label, labelsize, hash, hashsize, binderkey, hashsize, 1)) { /* SSLfatal() already called */ goto err; } /* Generate the finished key */ if (!tls13_derive_finishedkey(s, md, binderkey, finishedkey, hashsize)) { /* SSLfatal() already called */ goto err; } if (EVP_DigestInit_ex(mctx, md, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* * Get a hash of the ClientHello up to the start of the binders. If we are * following a HelloRetryRequest then this includes the hash of the first * ClientHello and the HelloRetryRequest itself. */ if (s->hello_retry_request == SSL_HRR_PENDING) { size_t hdatalen; long hdatalen_l; void *hdata; hdatalen = hdatalen_l = BIO_get_mem_data(s->s3.handshake_buffer, &hdata); if (hdatalen_l <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_LENGTH); goto err; } /* * For servers the handshake buffer data will include the second * ClientHello - which we don't want - so we need to take that bit off. */ if (s->server) { PACKET hashprefix, msg; /* Find how many bytes are left after the first two messages */ if (!PACKET_buf_init(&hashprefix, hdata, hdatalen) || !PACKET_forward(&hashprefix, 1) || !PACKET_get_length_prefixed_3(&hashprefix, &msg) || !PACKET_forward(&hashprefix, 1) || !PACKET_get_length_prefixed_3(&hashprefix, &msg)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hdatalen -= PACKET_remaining(&hashprefix); } if (EVP_DigestUpdate(mctx, hdata, hdatalen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (EVP_DigestUpdate(mctx, msgstart, binderoffset) <= 0 || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } mackey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC", sctx->propq, finishedkey, hashsize); if (mackey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!sign) binderout = tmpbinder; bindersize = hashsize; if (EVP_DigestSignInit_ex(mctx, NULL, EVP_MD_get0_name(md), sctx->libctx, sctx->propq, mackey, NULL) <= 0 || EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0 || EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0 || bindersize != hashsize) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (sign) { ret = 1; } else { /* HMAC keys can't do EVP_DigestVerify* - use CRYPTO_memcmp instead */ ret = (CRYPTO_memcmp(binderin, binderout, hashsize) == 0); if (!ret) SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BINDER_DOES_NOT_VERIFY); } err: OPENSSL_cleanse(binderkey, sizeof(binderkey)); OPENSSL_cleanse(finishedkey, sizeof(finishedkey)); EVP_PKEY_free(mackey); EVP_MD_CTX_free(mctx); return ret; } static int final_early_data(SSL_CONNECTION *s, unsigned int context, int sent) { if (!sent) return 1; if (!s->server) { if (context == SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS && sent && !s->ext.early_data_ok) { /* * If we get here then the server accepted our early_data but we * later realised that it shouldn't have done (e.g. inconsistent * ALPN) */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EARLY_DATA); return 0; } return 1; } if (s->max_early_data == 0 || !s->hit || s->early_data_state != SSL_EARLY_DATA_ACCEPTING || !s->ext.early_data_ok || s->hello_retry_request != SSL_HRR_NONE || (s->allow_early_data_cb != NULL && !s->allow_early_data_cb(SSL_CONNECTION_GET_SSL(s), s->allow_early_data_cb_data))) { s->ext.early_data = SSL_EARLY_DATA_REJECTED; } else { s->ext.early_data = SSL_EARLY_DATA_ACCEPTED; if (!tls13_change_cipher_state(s, SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_SERVER_READ)) { /* SSLfatal() already called */ return 0; } } return 1; } static int final_maxfragmentlen(SSL_CONNECTION *s, unsigned int context, int sent) { /* * Session resumption on server-side with MFL extension active * BUT MFL extension packet was not resent (i.e. sent == 0) */ if (s->server && s->hit && USE_MAX_FRAGMENT_LENGTH_EXT(s->session) && !sent ) { SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } if (s->session && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)) { s->rlayer.rrlmethod->set_max_frag_len(s->rlayer.rrl, GET_MAX_FRAGMENT_LENGTH(s->session)); s->rlayer.wrlmethod->set_max_frag_len(s->rlayer.wrl, ssl_get_max_send_fragment(s)); } return 1; } static int init_post_handshake_auth(SSL_CONNECTION *s, ossl_unused unsigned int context) { s->post_handshake_auth = SSL_PHA_NONE; return 1; } /* * If clients offer "pre_shared_key" without a "psk_key_exchange_modes" * extension, servers MUST abort the handshake. */ static int final_psk(SSL_CONNECTION *s, unsigned int context, int sent) { if (s->server && sent && s->clienthello != NULL && !s->clienthello->pre_proc_exts[TLSEXT_IDX_psk_kex_modes].present) { SSLfatal(s, TLS13_AD_MISSING_EXTENSION, SSL_R_MISSING_PSK_KEX_MODES_EXTENSION); return 0; } return 1; } static int tls_init_compress_certificate(SSL_CONNECTION *sc, unsigned int context) { memset(sc->ext.compress_certificate_from_peer, 0, sizeof(sc->ext.compress_certificate_from_peer)); return 1; } /* The order these are put into the packet imply a preference order: [brotli, zlib, zstd] */ static EXT_RETURN tls_construct_compress_certificate(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_COMP_ALG int i; if (!ossl_comp_has_alg(0)) return EXT_RETURN_NOT_SENT; /* Server: Don't attempt to compress a non-X509 (i.e. an RPK) */ if (sc->server && sc->ext.server_cert_type != TLSEXT_cert_type_x509) { sc->cert_comp_prefs[0] = TLSEXT_comp_cert_none; return EXT_RETURN_NOT_SENT; } /* Client: If we sent a client cert-type extension, don't indicate compression */ if (!sc->server && sc->ext.client_cert_type_ctos) { sc->cert_comp_prefs[0] = TLSEXT_comp_cert_none; return EXT_RETURN_NOT_SENT; } /* Do not indicate we support receiving compressed certificates */ if ((sc->options & SSL_OP_NO_RX_CERTIFICATE_COMPRESSION) != 0) return EXT_RETURN_NOT_SENT; if (sc->cert_comp_prefs[0] == TLSEXT_comp_cert_none) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_compress_certificate) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u8(pkt)) goto err; for (i = 0; sc->cert_comp_prefs[i] != TLSEXT_comp_cert_none; i++) { if (!WPACKET_put_bytes_u16(pkt, sc->cert_comp_prefs[i])) goto err; } if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) goto err; sc->ext.compress_certificate_sent = 1; return EXT_RETURN_SENT; err: SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; #else return EXT_RETURN_NOT_SENT; #endif } #ifndef OPENSSL_NO_COMP_ALG static int tls_comp_in_pref(SSL_CONNECTION *sc, int alg) { int i; /* ossl_comp_has_alg() considers 0 as "any" */ if (alg == 0) return 0; /* Make sure algorithm is enabled */ if (!ossl_comp_has_alg(alg)) return 0; /* If no preferences are set, it's ok */ if (sc->cert_comp_prefs[0] == TLSEXT_comp_cert_none) return 1; /* Find the algorithm */ for (i = 0; i < TLSEXT_comp_cert_limit; i++) if (sc->cert_comp_prefs[i] == alg) return 1; return 0; } #endif int tls_parse_compress_certificate(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_COMP_ALG PACKET supported_comp_algs; unsigned int comp; int already_set[TLSEXT_comp_cert_limit]; int j = 0; /* If no algorithms are available, ignore the extension */ if (!ossl_comp_has_alg(0)) return 1; /* Don't attempt to compress a non-X509 (i.e. an RPK) */ if (sc->server && sc->ext.server_cert_type != TLSEXT_cert_type_x509) return 1; if (!sc->server && sc->ext.client_cert_type != TLSEXT_cert_type_x509) return 1; /* Ignore the extension and don't send compressed certificates */ if ((sc->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0) return 1; if (!PACKET_as_length_prefixed_1(pkt, &supported_comp_algs) || PACKET_remaining(&supported_comp_algs) == 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } memset(already_set, 0, sizeof(already_set)); /* * The preference array has real values, so take a look at each * value coming in, and make sure it's in our preference list * The array is 0 (i.e. "none") terminated * The preference list only contains supported algorithms */ while (PACKET_get_net_2(&supported_comp_algs, &comp)) { if (tls_comp_in_pref(sc, comp) && !already_set[comp]) { sc->ext.compress_certificate_from_peer[j++] = comp; already_set[comp] = 1; } } #endif return 1; } static int init_server_cert_type(SSL_CONNECTION *sc, unsigned int context) { /* Only reset when parsing client hello */ if (sc->server) { sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.server_cert_type = TLSEXT_cert_type_x509; } return 1; } static int init_client_cert_type(SSL_CONNECTION *sc, unsigned int context) { /* Only reset when parsing client hello */ if (sc->server) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; sc->ext.client_cert_type = TLSEXT_cert_type_x509; } return 1; }

./openssl/ssl/statem/statem_lib.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <limits.h> #include <string.h> #include <stdio.h> #include "../ssl_local.h" #include "statem_local.h" #include "internal/cryptlib.h" #include <openssl/buffer.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/rsa.h> #include <openssl/x509.h> #include <openssl/trace.h> #include <openssl/encoder.h> /* * Map error codes to TLS/SSL alart types. */ typedef struct x509err2alert_st { int x509err; int alert; } X509ERR2ALERT; /* Fixed value used in the ServerHello random field to identify an HRR */ const unsigned char hrrrandom[] = { 0xcf, 0x21, 0xad, 0x74, 0xe5, 0x9a, 0x61, 0x11, 0xbe, 0x1d, 0x8c, 0x02, 0x1e, 0x65, 0xb8, 0x91, 0xc2, 0xa2, 0x11, 0x16, 0x7a, 0xbb, 0x8c, 0x5e, 0x07, 0x9e, 0x09, 0xe2, 0xc8, 0xa8, 0x33, 0x9c }; int ossl_statem_set_mutator(SSL *s, ossl_statem_mutate_handshake_cb mutate_handshake_cb, ossl_statem_finish_mutate_handshake_cb finish_mutate_handshake_cb, void *mutatearg) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return 0; sc->statem.mutate_handshake_cb = mutate_handshake_cb; sc->statem.mutatearg = mutatearg; sc->statem.finish_mutate_handshake_cb = finish_mutate_handshake_cb; return 1; } /* * send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or * SSL3_RT_CHANGE_CIPHER_SPEC) */ int ssl3_do_write(SSL_CONNECTION *s, uint8_t type) { int ret; size_t written = 0; SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* * If we're running the test suite then we may need to mutate the message * we've been asked to write. Does not happen in normal operation. */ if (s->statem.mutate_handshake_cb != NULL && !s->statem.write_in_progress && type == SSL3_RT_HANDSHAKE && s->init_num >= SSL3_HM_HEADER_LENGTH) { unsigned char *msg; size_t msglen; if (!s->statem.mutate_handshake_cb((unsigned char *)s->init_buf->data, s->init_num, &msg, &msglen, s->statem.mutatearg)) return -1; if (msglen < SSL3_HM_HEADER_LENGTH || !BUF_MEM_grow(s->init_buf, msglen)) return -1; memcpy(s->init_buf->data, msg, msglen); s->init_num = msglen; s->init_msg = s->init_buf->data + SSL3_HM_HEADER_LENGTH; s->statem.finish_mutate_handshake_cb(s->statem.mutatearg); s->statem.write_in_progress = 1; } ret = ssl3_write_bytes(ssl, type, &s->init_buf->data[s->init_off], s->init_num, &written); if (ret <= 0) return -1; if (type == SSL3_RT_HANDSHAKE) /* * should not be done for 'Hello Request's, but in that case we'll * ignore the result anyway * TLS1.3 KeyUpdate and NewSessionTicket do not need to be added */ if (!SSL_CONNECTION_IS_TLS13(s) || (s->statem.hand_state != TLS_ST_SW_SESSION_TICKET && s->statem.hand_state != TLS_ST_CW_KEY_UPDATE && s->statem.hand_state != TLS_ST_SW_KEY_UPDATE)) if (!ssl3_finish_mac(s, (unsigned char *)&s->init_buf->data[s->init_off], written)) return -1; if (written == s->init_num) { s->statem.write_in_progress = 0; if (s->msg_callback) s->msg_callback(1, s->version, type, s->init_buf->data, (size_t)(s->init_off + s->init_num), ssl, s->msg_callback_arg); return 1; } s->init_off += written; s->init_num -= written; return 0; } int tls_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype) { size_t msglen; if ((htype != SSL3_MT_CHANGE_CIPHER_SPEC && !WPACKET_close(pkt)) || !WPACKET_get_length(pkt, &msglen) || msglen > INT_MAX) return 0; s->init_num = (int)msglen; s->init_off = 0; return 1; } int tls_setup_handshake(SSL_CONNECTION *s) { int ver_min, ver_max, ok; SSL *ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (!ssl3_init_finished_mac(s)) { /* SSLfatal() already called */ return 0; } /* Reset any extension flags */ memset(s->ext.extflags, 0, sizeof(s->ext.extflags)); if (ssl_get_min_max_version(s, &ver_min, &ver_max, NULL) != 0) { SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_NO_PROTOCOLS_AVAILABLE); return 0; } /* Sanity check that we have MD5-SHA1 if we need it */ if (sctx->ssl_digest_methods[SSL_MD_MD5_SHA1_IDX] == NULL) { int negotiated_minversion; int md5sha1_needed_maxversion = SSL_CONNECTION_IS_DTLS(s) ? DTLS1_VERSION : TLS1_1_VERSION; /* We don't have MD5-SHA1 - do we need it? */ if (ssl_version_cmp(s, ver_max, md5sha1_needed_maxversion) <= 0) { SSLfatal_data(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM, "The max supported SSL/TLS version needs the" " MD5-SHA1 digest but it is not available" " in the loaded providers. Use (D)TLSv1.2 or" " above, or load different providers"); return 0; } ok = 1; /* Don't allow TLSv1.1 or below to be negotiated */ negotiated_minversion = SSL_CONNECTION_IS_DTLS(s) ? DTLS1_2_VERSION : TLS1_2_VERSION; if (ssl_version_cmp(s, ver_min, negotiated_minversion) < 0) ok = SSL_set_min_proto_version(ssl, negotiated_minversion); if (!ok) { /* Shouldn't happen */ SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR); return 0; } } ok = 0; if (s->server) { STACK_OF(SSL_CIPHER) *ciphers = SSL_get_ciphers(ssl); int i; /* * Sanity check that the maximum version we accept has ciphers * enabled. For clients we do this check during construction of the * ClientHello. */ for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) { const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i); int cipher_minprotover = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls; int cipher_maxprotover = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls; if (ssl_version_cmp(s, ver_max, cipher_minprotover) >= 0 && ssl_version_cmp(s, ver_max, cipher_maxprotover) <= 0) { ok = 1; break; } } if (!ok) { SSLfatal_data(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_CIPHERS_AVAILABLE, "No ciphers enabled for max supported " "SSL/TLS version"); return 0; } if (SSL_IS_FIRST_HANDSHAKE(s)) { /* N.B. s->session_ctx == s->ctx here */ ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_accept); } else { /* N.B. s->ctx may not equal s->session_ctx */ ssl_tsan_counter(sctx, &sctx->stats.sess_accept_renegotiate); s->s3.tmp.cert_request = 0; } } else { if (SSL_IS_FIRST_HANDSHAKE(s)) ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_connect); else ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_connect_renegotiate); /* mark client_random uninitialized */ memset(s->s3.client_random, 0, sizeof(s->s3.client_random)); s->hit = 0; s->s3.tmp.cert_req = 0; if (SSL_CONNECTION_IS_DTLS(s)) s->statem.use_timer = 1; } return 1; } /* * Size of the to-be-signed TLS13 data, without the hash size itself: * 64 bytes of value 32, 33 context bytes, 1 byte separator */ #define TLS13_TBS_START_SIZE 64 #define TLS13_TBS_PREAMBLE_SIZE (TLS13_TBS_START_SIZE + 33 + 1) static int get_cert_verify_tbs_data(SSL_CONNECTION *s, unsigned char *tls13tbs, void **hdata, size_t *hdatalen) { /* ASCII: "TLS 1.3, server CertificateVerify", in hex for EBCDIC compatibility */ static const char servercontext[] = "\x54\x4c\x53\x20\x31\x2e\x33\x2c\x20\x73\x65\x72" "\x76\x65\x72\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x56\x65\x72\x69\x66\x79"; /* ASCII: "TLS 1.3, client CertificateVerify", in hex for EBCDIC compatibility */ static const char clientcontext[] = "\x54\x4c\x53\x20\x31\x2e\x33\x2c\x20\x63\x6c\x69" "\x65\x6e\x74\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x56\x65\x72\x69\x66\x79"; if (SSL_CONNECTION_IS_TLS13(s)) { size_t hashlen; /* Set the first 64 bytes of to-be-signed data to octet 32 */ memset(tls13tbs, 32, TLS13_TBS_START_SIZE); /* This copies the 33 bytes of context plus the 0 separator byte */ if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY || s->statem.hand_state == TLS_ST_SW_CERT_VRFY) strcpy((char *)tls13tbs + TLS13_TBS_START_SIZE, servercontext); else strcpy((char *)tls13tbs + TLS13_TBS_START_SIZE, clientcontext); /* * If we're currently reading then we need to use the saved handshake * hash value. We can't use the current handshake hash state because * that includes the CertVerify itself. */ if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY || s->statem.hand_state == TLS_ST_SR_CERT_VRFY) { memcpy(tls13tbs + TLS13_TBS_PREAMBLE_SIZE, s->cert_verify_hash, s->cert_verify_hash_len); hashlen = s->cert_verify_hash_len; } else if (!ssl_handshake_hash(s, tls13tbs + TLS13_TBS_PREAMBLE_SIZE, EVP_MAX_MD_SIZE, &hashlen)) { /* SSLfatal() already called */ return 0; } *hdata = tls13tbs; *hdatalen = TLS13_TBS_PREAMBLE_SIZE + hashlen; } else { size_t retlen; long retlen_l; retlen = retlen_l = BIO_get_mem_data(s->s3.handshake_buffer, hdata); if (retlen_l <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } *hdatalen = retlen; } return 1; } CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt) { EVP_PKEY *pkey = NULL; const EVP_MD *md = NULL; EVP_MD_CTX *mctx = NULL; EVP_PKEY_CTX *pctx = NULL; size_t hdatalen = 0, siglen = 0; void *hdata; unsigned char *sig = NULL; unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE]; const SIGALG_LOOKUP *lu = s->s3.tmp.sigalg; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (lu == NULL || s->s3.tmp.cert == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pkey = s->s3.tmp.cert->privatekey; if (pkey == NULL || !tls1_lookup_md(sctx, lu, &md)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } mctx = EVP_MD_CTX_new(); if (mctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } /* Get the data to be signed */ if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) { /* SSLfatal() already called */ goto err; } if (SSL_USE_SIGALGS(s) && !WPACKET_put_bytes_u16(pkt, lu->sigalg)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (EVP_DigestSignInit_ex(mctx, &pctx, md == NULL ? NULL : EVP_MD_get0_name(md), sctx->libctx, sctx->propq, pkey, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (lu->sig == EVP_PKEY_RSA_PSS) { if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } if (s->version == SSL3_VERSION) { /* * Here we use EVP_DigestSignUpdate followed by EVP_DigestSignFinal * in order to add the EVP_CTRL_SSL3_MASTER_SECRET call between them. */ if (EVP_DigestSignUpdate(mctx, hdata, hdatalen) <= 0 || EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET, (int)s->session->master_key_length, s->session->master_key) <= 0 || EVP_DigestSignFinal(mctx, NULL, &siglen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } sig = OPENSSL_malloc(siglen); if (sig == NULL || EVP_DigestSignFinal(mctx, sig, &siglen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } else { /* * Here we *must* use EVP_DigestSign() because Ed25519/Ed448 does not * support streaming via EVP_DigestSignUpdate/EVP_DigestSignFinal */ if (EVP_DigestSign(mctx, NULL, &siglen, hdata, hdatalen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } sig = OPENSSL_malloc(siglen); if (sig == NULL || EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } #ifndef OPENSSL_NO_GOST { int pktype = lu->sig; if (pktype == NID_id_GostR3410_2001 || pktype == NID_id_GostR3410_2012_256 || pktype == NID_id_GostR3410_2012_512) BUF_reverse(sig, NULL, siglen); } #endif if (!WPACKET_sub_memcpy_u16(pkt, sig, siglen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Digest cached records and discard handshake buffer */ if (!ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called */ goto err; } OPENSSL_free(sig); EVP_MD_CTX_free(mctx); return CON_FUNC_SUCCESS; err: OPENSSL_free(sig); EVP_MD_CTX_free(mctx); return CON_FUNC_ERROR; } MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt) { EVP_PKEY *pkey = NULL; const unsigned char *data; #ifndef OPENSSL_NO_GOST unsigned char *gost_data = NULL; #endif MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; int j; unsigned int len; const EVP_MD *md = NULL; size_t hdatalen = 0; void *hdata; unsigned char tls13tbs[TLS13_TBS_PREAMBLE_SIZE + EVP_MAX_MD_SIZE]; EVP_MD_CTX *mctx = EVP_MD_CTX_new(); EVP_PKEY_CTX *pctx = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (mctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } pkey = tls_get_peer_pkey(s); if (pkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (ssl_cert_lookup_by_pkey(pkey, NULL, sctx) == NULL) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE); goto err; } if (SSL_USE_SIGALGS(s)) { unsigned int sigalg; if (!PACKET_get_net_2(pkt, &sigalg)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_PACKET); goto err; } if (tls12_check_peer_sigalg(s, sigalg, pkey) <= 0) { /* SSLfatal() already called */ goto err; } } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED); goto err; } if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (SSL_USE_SIGALGS(s)) OSSL_TRACE1(TLS, "USING TLSv1.2 HASH %s\n", md == NULL ? "n/a" : EVP_MD_get0_name(md)); /* Check for broken implementations of GOST ciphersuites */ /* * If key is GOST and len is exactly 64 or 128, it is signature without * length field (CryptoPro implementations at least till TLS 1.2) */ #ifndef OPENSSL_NO_GOST if (!SSL_USE_SIGALGS(s) && ((PACKET_remaining(pkt) == 64 && (EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2001 || EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2012_256)) || (PACKET_remaining(pkt) == 128 && EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2012_512))) { len = PACKET_remaining(pkt); } else #endif if (!PACKET_get_net_2(pkt, &len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_get_bytes(pkt, &data, len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!get_cert_verify_tbs_data(s, tls13tbs, &hdata, &hdatalen)) { /* SSLfatal() already called */ goto err; } OSSL_TRACE1(TLS, "Using client verify alg %s\n", md == NULL ? "n/a" : EVP_MD_get0_name(md)); if (EVP_DigestVerifyInit_ex(mctx, &pctx, md == NULL ? NULL : EVP_MD_get0_name(md), sctx->libctx, sctx->propq, pkey, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } #ifndef OPENSSL_NO_GOST { int pktype = EVP_PKEY_get_id(pkey); if (pktype == NID_id_GostR3410_2001 || pktype == NID_id_GostR3410_2012_256 || pktype == NID_id_GostR3410_2012_512) { if ((gost_data = OPENSSL_malloc(len)) == NULL) goto err; BUF_reverse(gost_data, data, len); data = gost_data; } } #endif if (SSL_USE_PSS(s)) { if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } if (s->version == SSL3_VERSION) { if (EVP_DigestVerifyUpdate(mctx, hdata, hdatalen) <= 0 || EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET, (int)s->session->master_key_length, s->session->master_key) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_DigestVerifyFinal(mctx, data, len) <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BAD_SIGNATURE); goto err; } } else { j = EVP_DigestVerify(mctx, data, len, hdata, hdatalen); #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION /* Ignore bad signatures when fuzzing */ if (SSL_IS_QUIC_HANDSHAKE(s)) j = 1; #endif if (j <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BAD_SIGNATURE); goto err; } } /* * In TLSv1.3 on the client side we make sure we prepare the client * certificate after the CertVerify instead of when we get the * CertificateRequest. This is because in TLSv1.3 the CertificateRequest * comes *before* the Certificate message. In TLSv1.2 it comes after. We * want to make sure that SSL_get1_peer_certificate() will return the actual * server certificate from the client_cert_cb callback. */ if (!s->server && SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.cert_req == 1) ret = MSG_PROCESS_CONTINUE_PROCESSING; else ret = MSG_PROCESS_CONTINUE_READING; err: BIO_free(s->s3.handshake_buffer); s->s3.handshake_buffer = NULL; EVP_MD_CTX_free(mctx); #ifndef OPENSSL_NO_GOST OPENSSL_free(gost_data); #endif return ret; } CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt) { size_t finish_md_len; const char *sender; size_t slen; SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* This is a real handshake so make sure we clean it up at the end */ if (!s->server && s->post_handshake_auth != SSL_PHA_REQUESTED) s->statem.cleanuphand = 1; /* * If we attempted to write early data or we're in middlebox compat mode * then we deferred changing the handshake write keys to the last possible * moment. If we didn't already do this when we sent the client certificate * then we need to do it now. */ if (SSL_CONNECTION_IS_TLS13(s) && !s->server && (s->early_data_state != SSL_EARLY_DATA_NONE || (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) && s->s3.tmp.cert_req == 0 && (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {; /* SSLfatal() already called */ return CON_FUNC_ERROR; } if (s->server) { sender = ssl->method->ssl3_enc->server_finished_label; slen = ssl->method->ssl3_enc->server_finished_label_len; } else { sender = ssl->method->ssl3_enc->client_finished_label; slen = ssl->method->ssl3_enc->client_finished_label_len; } finish_md_len = ssl->method->ssl3_enc->final_finish_mac(s, sender, slen, s->s3.tmp.finish_md); if (finish_md_len == 0) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } s->s3.tmp.finish_md_len = finish_md_len; if (!WPACKET_memcpy(pkt, s->s3.tmp.finish_md, finish_md_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* * Log the master secret, if logging is enabled. We don't log it for * TLSv1.3: there's a different key schedule for that. */ if (!SSL_CONNECTION_IS_TLS13(s) && !ssl_log_secret(s, MASTER_SECRET_LABEL, s->session->master_key, s->session->master_key_length)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } /* * Copy the finished so we can use it for renegotiation checks */ if (!ossl_assert(finish_md_len <= EVP_MAX_MD_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (!s->server) { memcpy(s->s3.previous_client_finished, s->s3.tmp.finish_md, finish_md_len); s->s3.previous_client_finished_len = finish_md_len; } else { memcpy(s->s3.previous_server_finished, s->s3.tmp.finish_md, finish_md_len); s->s3.previous_server_finished_len = finish_md_len; } return CON_FUNC_SUCCESS; } CON_FUNC_RETURN tls_construct_key_update(SSL_CONNECTION *s, WPACKET *pkt) { if (!WPACKET_put_bytes_u8(pkt, s->key_update)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } s->key_update = SSL_KEY_UPDATE_NONE; return CON_FUNC_SUCCESS; } MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION *s, PACKET *pkt) { unsigned int updatetype; /* * A KeyUpdate message signals a key change so the end of the message must * be on a record boundary. */ if (RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); return MSG_PROCESS_ERROR; } if (!PACKET_get_1(pkt, &updatetype) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_KEY_UPDATE); return MSG_PROCESS_ERROR; } /* * There are only two defined key update types. Fail if we get a value we * didn't recognise. */ if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED && updatetype != SSL_KEY_UPDATE_REQUESTED) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_UPDATE); return MSG_PROCESS_ERROR; } /* * If we get a request for us to update our sending keys too then, we need * to additionally send a KeyUpdate message. However that message should * not also request an update (otherwise we get into an infinite loop). */ if (updatetype == SSL_KEY_UPDATE_REQUESTED) s->key_update = SSL_KEY_UPDATE_NOT_REQUESTED; if (!tls13_update_key(s, 0)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } return MSG_PROCESS_FINISHED_READING; } /* * ssl3_take_mac calculates the Finished MAC for the handshakes messages seen * to far. */ int ssl3_take_mac(SSL_CONNECTION *s) { const char *sender; size_t slen; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (!s->server) { sender = ssl->method->ssl3_enc->server_finished_label; slen = ssl->method->ssl3_enc->server_finished_label_len; } else { sender = ssl->method->ssl3_enc->client_finished_label; slen = ssl->method->ssl3_enc->client_finished_label_len; } s->s3.tmp.peer_finish_md_len = ssl->method->ssl3_enc->final_finish_mac(s, sender, slen, s->s3.tmp.peer_finish_md); if (s->s3.tmp.peer_finish_md_len == 0) { /* SSLfatal() already called */ return 0; } return 1; } MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION *s, PACKET *pkt) { size_t remain; remain = PACKET_remaining(pkt); /* * 'Change Cipher Spec' is just a single byte, which should already have * been consumed by ssl_get_message() so there should be no bytes left, * unless we're using DTLS1_BAD_VER, which has an extra 2 bytes */ if (SSL_CONNECTION_IS_DTLS(s)) { if ((s->version == DTLS1_BAD_VER && remain != DTLS1_CCS_HEADER_LENGTH + 1) || (s->version != DTLS1_BAD_VER && remain != DTLS1_CCS_HEADER_LENGTH - 1)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_CHANGE_CIPHER_SPEC); return MSG_PROCESS_ERROR; } } else { if (remain != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_CHANGE_CIPHER_SPEC); return MSG_PROCESS_ERROR; } } /* Check we have a cipher to change to */ if (s->s3.tmp.new_cipher == NULL) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY); return MSG_PROCESS_ERROR; } s->s3.change_cipher_spec = 1; if (!ssl3_do_change_cipher_spec(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } if (SSL_CONNECTION_IS_DTLS(s)) { if (s->version == DTLS1_BAD_VER) s->d1->handshake_read_seq++; #ifndef OPENSSL_NO_SCTP /* * Remember that a CCS has been received, so that an old key of * SCTP-Auth can be deleted when a CCS is sent. Will be ignored if no * SCTP is used */ BIO_ctrl(SSL_get_wbio(SSL_CONNECTION_GET_SSL(s)), BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL); #endif } return MSG_PROCESS_CONTINUE_READING; } MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt) { size_t md_len; SSL *ssl = SSL_CONNECTION_GET_SSL(s); int was_first = SSL_IS_FIRST_HANDSHAKE(s); int ok; /* This is a real handshake so make sure we clean it up at the end */ if (s->server) { /* * To get this far we must have read encrypted data from the client. We * no longer tolerate unencrypted alerts. This is ignored if less than * TLSv1.3 */ if (s->rlayer.rrlmethod->set_plain_alerts != NULL) s->rlayer.rrlmethod->set_plain_alerts(s->rlayer.rrl, 0); if (s->post_handshake_auth != SSL_PHA_REQUESTED) s->statem.cleanuphand = 1; if (SSL_CONNECTION_IS_TLS13(s) && !tls13_save_handshake_digest_for_pha(s)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } } /* * In TLSv1.3 a Finished message signals a key change so the end of the * message must be on a record boundary. */ if (SSL_CONNECTION_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); return MSG_PROCESS_ERROR; } /* If this occurs, we have missed a message */ if (!SSL_CONNECTION_IS_TLS13(s) && !s->s3.change_cipher_spec) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_GOT_A_FIN_BEFORE_A_CCS); return MSG_PROCESS_ERROR; } s->s3.change_cipher_spec = 0; md_len = s->s3.tmp.peer_finish_md_len; if (md_len != PACKET_remaining(pkt)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_DIGEST_LENGTH); return MSG_PROCESS_ERROR; } ok = CRYPTO_memcmp(PACKET_data(pkt), s->s3.tmp.peer_finish_md, md_len); #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if (ok != 0) { if ((PACKET_data(pkt)[0] ^ s->s3.tmp.peer_finish_md[0]) != 0xFF) { ok = 0; } } #endif if (ok != 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DIGEST_CHECK_FAILED); return MSG_PROCESS_ERROR; } /* * Copy the finished so we can use it for renegotiation checks */ if (!ossl_assert(md_len <= EVP_MAX_MD_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } if (s->server) { memcpy(s->s3.previous_client_finished, s->s3.tmp.peer_finish_md, md_len); s->s3.previous_client_finished_len = md_len; } else { memcpy(s->s3.previous_server_finished, s->s3.tmp.peer_finish_md, md_len); s->s3.previous_server_finished_len = md_len; } /* * In TLS1.3 we also have to change cipher state and do any final processing * of the initial server flight (if we are a client) */ if (SSL_CONNECTION_IS_TLS13(s)) { if (s->server) { if (s->post_handshake_auth != SSL_PHA_REQUESTED && !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_READ)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } } else { /* TLS 1.3 gets the secret size from the handshake md */ size_t dummy; if (!ssl->method->ssl3_enc->generate_master_secret(s, s->master_secret, s->handshake_secret, 0, &dummy)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_READ)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } if (!tls_process_initial_server_flight(s)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } } } if (was_first && !SSL_IS_FIRST_HANDSHAKE(s) && s->rlayer.rrlmethod->set_first_handshake != NULL) s->rlayer.rrlmethod->set_first_handshake(s->rlayer.rrl, 0); return MSG_PROCESS_FINISHED_READING; } CON_FUNC_RETURN tls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt) { if (!WPACKET_put_bytes_u8(pkt, SSL3_MT_CCS)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } /* Add a certificate to the WPACKET */ static int ssl_add_cert_to_wpacket(SSL_CONNECTION *s, WPACKET *pkt, X509 *x, int chain, int for_comp) { int len; unsigned char *outbytes; int context = SSL_EXT_TLS1_3_CERTIFICATE; if (for_comp) context |= SSL_EXT_TLS1_3_CERTIFICATE_COMPRESSION; len = i2d_X509(x, NULL); if (len < 0) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BUF_LIB); return 0; } if (!WPACKET_sub_allocate_bytes_u24(pkt, len, &outbytes) || i2d_X509(x, &outbytes) != len) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((SSL_CONNECTION_IS_TLS13(s) || for_comp) && !tls_construct_extensions(s, pkt, context, x, chain)) { /* SSLfatal() already called */ return 0; } return 1; } /* Add certificate chain to provided WPACKET */ static int ssl_add_cert_chain(SSL_CONNECTION *s, WPACKET *pkt, CERT_PKEY *cpk, int for_comp) { int i, chain_count; X509 *x; STACK_OF(X509) *extra_certs; STACK_OF(X509) *chain = NULL; X509_STORE *chain_store; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (cpk == NULL || cpk->x509 == NULL) return 1; x = cpk->x509; /* * If we have a certificate specific chain use it, else use parent ctx. */ if (cpk->chain != NULL) extra_certs = cpk->chain; else extra_certs = sctx->extra_certs; if ((s->mode & SSL_MODE_NO_AUTO_CHAIN) || extra_certs) chain_store = NULL; else if (s->cert->chain_store) chain_store = s->cert->chain_store; else chain_store = sctx->cert_store; if (chain_store != NULL) { X509_STORE_CTX *xs_ctx = X509_STORE_CTX_new_ex(sctx->libctx, sctx->propq); if (xs_ctx == NULL) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_X509_LIB); return 0; } if (!X509_STORE_CTX_init(xs_ctx, chain_store, x, NULL)) { X509_STORE_CTX_free(xs_ctx); if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_X509_LIB); return 0; } /* * It is valid for the chain not to be complete (because normally we * don't include the root cert in the chain). Therefore we deliberately * ignore the error return from this call. We're not actually verifying * the cert - we're just building as much of the chain as we can */ (void)X509_verify_cert(xs_ctx); /* Don't leave errors in the queue */ ERR_clear_error(); chain = X509_STORE_CTX_get0_chain(xs_ctx); i = ssl_security_cert_chain(s, chain, NULL, 0); if (i != 1) { #if 0 /* Dummy error calls so mkerr generates them */ ERR_raise(ERR_LIB_SSL, SSL_R_EE_KEY_TOO_SMALL); ERR_raise(ERR_LIB_SSL, SSL_R_CA_KEY_TOO_SMALL); ERR_raise(ERR_LIB_SSL, SSL_R_CA_MD_TOO_WEAK); #endif X509_STORE_CTX_free(xs_ctx); if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, i); return 0; } chain_count = sk_X509_num(chain); for (i = 0; i < chain_count; i++) { x = sk_X509_value(chain, i); if (!ssl_add_cert_to_wpacket(s, pkt, x, i, for_comp)) { /* SSLfatal() already called */ X509_STORE_CTX_free(xs_ctx); return 0; } } X509_STORE_CTX_free(xs_ctx); } else { i = ssl_security_cert_chain(s, extra_certs, x, 0); if (i != 1) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, i); return 0; } if (!ssl_add_cert_to_wpacket(s, pkt, x, 0, for_comp)) { /* SSLfatal() already called */ return 0; } for (i = 0; i < sk_X509_num(extra_certs); i++) { x = sk_X509_value(extra_certs, i); if (!ssl_add_cert_to_wpacket(s, pkt, x, i + 1, for_comp)) { /* SSLfatal() already called */ return 0; } } } return 1; } EVP_PKEY* tls_get_peer_pkey(const SSL_CONNECTION *sc) { if (sc->session->peer_rpk != NULL) return sc->session->peer_rpk; if (sc->session->peer != NULL) return X509_get0_pubkey(sc->session->peer); return NULL; } int tls_process_rpk(SSL_CONNECTION *sc, PACKET *pkt, EVP_PKEY **peer_rpk) { EVP_PKEY *pkey = NULL; int ret = 0; RAW_EXTENSION *rawexts = NULL; PACKET extensions; PACKET context; unsigned long cert_len = 0, spki_len = 0; const unsigned char *spki, *spkistart; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(sc); /*- * ---------------------------- * TLS 1.3 Certificate message: * ---------------------------- * https://datatracker.ietf.org/doc/html/rfc8446#section-4.4.2 * * enum { * X509(0), * RawPublicKey(2), * (255) * } CertificateType; * * struct { * select (certificate_type) { * case RawPublicKey: * // From RFC 7250 ASN.1_subjectPublicKeyInfo * opaque ASN1_subjectPublicKeyInfo<1..2^24-1>; * * case X509: * opaque cert_data<1..2^24-1>; * }; * Extension extensions<0..2^16-1>; * } CertificateEntry; * * struct { * opaque certificate_request_context<0..2^8-1>; * CertificateEntry certificate_list<0..2^24-1>; * } Certificate; * * The client MUST send a Certificate message if and only if the server * has requested client authentication via a CertificateRequest message * (Section 4.3.2). If the server requests client authentication but no * suitable certificate is available, the client MUST send a Certificate * message containing no certificates (i.e., with the "certificate_list" * field having length 0). * * ---------------------------- * TLS 1.2 Certificate message: * ---------------------------- * https://datatracker.ietf.org/doc/html/rfc7250#section-3 * * opaque ASN.1Cert<1..2^24-1>; * * struct { * select(certificate_type){ * * // certificate type defined in this document. * case RawPublicKey: * opaque ASN.1_subjectPublicKeyInfo<1..2^24-1>; * * // X.509 certificate defined in RFC 5246 * case X.509: * ASN.1Cert certificate_list<0..2^24-1>; * * // Additional certificate type based on * // "TLS Certificate Types" subregistry * }; * } Certificate; * * ------------- * Consequently: * ------------- * After the (TLS 1.3 only) context octet string (1 byte length + data) the * Certificate message has a 3-byte length that is zero in the client to * server message when the client has no RPK to send. In that case, there * are no (TLS 1.3 only) per-certificate extensions either, because the * [CertificateEntry] list is empty. * * In the server to client direction, or when the client had an RPK to send, * the TLS 1.3 message just prepends the length of the RPK+extensions, * while TLS <= 1.2 sends just the RPK (octet-string). * * The context must be zero-length in the server to client direction, and * must match the value recorded in the certificate request in the client * to server direction. */ if (SSL_CONNECTION_IS_TLS13(sc)) { if (!PACKET_get_length_prefixed_1(pkt, &context)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } if (sc->server) { if (sc->pha_context == NULL) { if (PACKET_remaining(&context) != 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } } else { if (!PACKET_equal(&context, sc->pha_context, sc->pha_context_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } } } else { if (PACKET_remaining(&context) != 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } } } if (!PACKET_get_net_3(pkt, &cert_len) || PACKET_remaining(pkt) != cert_len) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } /* * The list length may be zero when there is no RPK. In the case of TLS * 1.2 this is actually the RPK length, which cannot be zero as specified, * but that breaks the ability of the client to decline client auth. We * overload the 0 RPK length to mean "no RPK". This interpretation is * also used some other (reference?) implementations, but is not supported * by the verbatim RFC7250 text. */ if (cert_len == 0) return 1; if (SSL_CONNECTION_IS_TLS13(sc)) { /* * With TLS 1.3, a non-empty explicit-length RPK octet-string followed * by a possibly empty extension block. */ if (!PACKET_get_net_3(pkt, &spki_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (spki_len == 0) { /* empty RPK */ SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_EMPTY_RAW_PUBLIC_KEY); goto err; } } else { spki_len = cert_len; } if (!PACKET_get_bytes(pkt, &spki, spki_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } spkistart = spki; if ((pkey = d2i_PUBKEY_ex(NULL, &spki, spki_len, sctx->libctx, sctx->propq)) == NULL || spki != (spkistart + spki_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (EVP_PKEY_missing_parameters(pkey)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS); goto err; } /* Process the Extensions block */ if (SSL_CONNECTION_IS_TLS13(sc)) { if (PACKET_remaining(pkt) != (cert_len - 3 - spki_len)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); goto err; } if (!PACKET_as_length_prefixed_2(pkt, &extensions) || PACKET_remaining(pkt) != 0) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!tls_collect_extensions(sc, &extensions, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY, &rawexts, NULL, 1)) { /* SSLfatal already called */ goto err; } /* chain index is always zero and fin always 1 for RPK */ if (!tls_parse_all_extensions(sc, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY, rawexts, NULL, 0, 1)) { /* SSLfatal already called */ goto err; } } ret = 1; if (peer_rpk != NULL) { *peer_rpk = pkey; pkey = NULL; } err: OPENSSL_free(rawexts); EVP_PKEY_free(pkey); return ret; } unsigned long tls_output_rpk(SSL_CONNECTION *sc, WPACKET *pkt, CERT_PKEY *cpk) { int pdata_len = 0; unsigned char *pdata = NULL; X509_PUBKEY *xpk = NULL; unsigned long ret = 0; X509 *x509 = NULL; if (cpk != NULL && cpk->x509 != NULL) { x509 = cpk->x509; /* Get the RPK from the certificate */ xpk = X509_get_X509_PUBKEY(cpk->x509); if (xpk == NULL) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pdata_len = i2d_X509_PUBKEY(xpk, &pdata); } else if (cpk != NULL && cpk->privatekey != NULL) { /* Get the RPK from the private key */ pdata_len = i2d_PUBKEY(cpk->privatekey, &pdata); } else { /* The server RPK is not optional */ if (sc->server) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* The client can send a zero length certificate list */ if (!WPACKET_sub_memcpy_u24(pkt, pdata, pdata_len)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } return 1; } if (pdata_len <= 0) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* * TLSv1.2 is _just_ the raw public key * TLSv1.3 includes extensions, so there's a length wrapper */ if (SSL_CONNECTION_IS_TLS13(sc)) { if (!WPACKET_start_sub_packet_u24(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (!WPACKET_sub_memcpy_u24(pkt, pdata, pdata_len)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (SSL_CONNECTION_IS_TLS13(sc)) { /* * Only send extensions relevant to raw public keys. Until such * extensions are defined, this will be an empty set of extensions. * |x509| may be NULL, which raw public-key extensions need to handle. */ if (!tls_construct_extensions(sc, pkt, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY, x509, 0)) { /* SSLfatal() already called */ goto err; } if (!WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } ret = 1; err: OPENSSL_free(pdata); return ret; } unsigned long ssl3_output_cert_chain(SSL_CONNECTION *s, WPACKET *pkt, CERT_PKEY *cpk, int for_comp) { if (!WPACKET_start_sub_packet_u24(pkt)) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!ssl_add_cert_chain(s, pkt, cpk, for_comp)) return 0; if (!WPACKET_close(pkt)) { if (!for_comp) SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } /* * Tidy up after the end of a handshake. In the case of SCTP this may result * in NBIO events. If |clearbufs| is set then init_buf and the wbio buffer is * freed up as well. */ WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, ossl_unused WORK_STATE wst, int clearbufs, int stop) { void (*cb) (const SSL *ssl, int type, int val) = NULL; int cleanuphand = s->statem.cleanuphand; SSL *ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (clearbufs) { if (!SSL_CONNECTION_IS_DTLS(s) #ifndef OPENSSL_NO_SCTP /* * RFC6083: SCTP provides a reliable and in-sequence transport service for DTLS * messages that require it. Therefore, DTLS procedures for retransmissions * MUST NOT be used. * Hence the init_buf can be cleared when DTLS over SCTP as transport is used. */ || BIO_dgram_is_sctp(SSL_get_wbio(ssl)) #endif ) { /* * We don't do this in DTLS over UDP because we may still need the init_buf * in case there are any unexpected retransmits */ BUF_MEM_free(s->init_buf); s->init_buf = NULL; } if (!ssl_free_wbio_buffer(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } s->init_num = 0; } if (SSL_CONNECTION_IS_TLS13(s) && !s->server && s->post_handshake_auth == SSL_PHA_REQUESTED) s->post_handshake_auth = SSL_PHA_EXT_SENT; /* * Only set if there was a Finished message and this isn't after a TLSv1.3 * post handshake exchange */ if (cleanuphand) { /* skipped if we just sent a HelloRequest */ s->renegotiate = 0; s->new_session = 0; s->statem.cleanuphand = 0; s->ext.ticket_expected = 0; ssl3_cleanup_key_block(s); if (s->server) { /* * In TLSv1.3 we update the cache as part of constructing the * NewSessionTicket */ if (!SSL_CONNECTION_IS_TLS13(s)) ssl_update_cache(s, SSL_SESS_CACHE_SERVER); /* N.B. s->ctx may not equal s->session_ctx */ ssl_tsan_counter(sctx, &sctx->stats.sess_accept_good); s->handshake_func = ossl_statem_accept; } else { if (SSL_CONNECTION_IS_TLS13(s)) { /* * We encourage applications to only use TLSv1.3 tickets once, * so we remove this one from the cache. */ if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) != 0) SSL_CTX_remove_session(s->session_ctx, s->session); } else { /* * In TLSv1.3 we update the cache as part of processing the * NewSessionTicket */ ssl_update_cache(s, SSL_SESS_CACHE_CLIENT); } if (s->hit) ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_hit); s->handshake_func = ossl_statem_connect; ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_connect_good); } if (SSL_CONNECTION_IS_DTLS(s)) { /* done with handshaking */ s->d1->handshake_read_seq = 0; s->d1->handshake_write_seq = 0; s->d1->next_handshake_write_seq = 0; dtls1_clear_received_buffer(s); } } if (s->info_callback != NULL) cb = s->info_callback; else if (sctx->info_callback != NULL) cb = sctx->info_callback; /* The callback may expect us to not be in init at handshake done */ ossl_statem_set_in_init(s, 0); if (cb != NULL) { if (cleanuphand || !SSL_CONNECTION_IS_TLS13(s) || SSL_IS_FIRST_HANDSHAKE(s)) cb(ssl, SSL_CB_HANDSHAKE_DONE, 1); } if (!stop) { /* If we've got more work to do we go back into init */ ossl_statem_set_in_init(s, 1); return WORK_FINISHED_CONTINUE; } return WORK_FINISHED_STOP; } int tls_get_message_header(SSL_CONNECTION *s, int *mt) { /* s->init_num < SSL3_HM_HEADER_LENGTH */ int skip_message, i; uint8_t recvd_type; unsigned char *p; size_t l, readbytes; SSL *ssl = SSL_CONNECTION_GET_SSL(s); p = (unsigned char *)s->init_buf->data; do { while (s->init_num < SSL3_HM_HEADER_LENGTH) { i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, &recvd_type, &p[s->init_num], SSL3_HM_HEADER_LENGTH - s->init_num, 0, &readbytes); if (i <= 0) { s->rwstate = SSL_READING; return 0; } if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) { /* * A ChangeCipherSpec must be a single byte and may not occur * in the middle of a handshake message. */ if (s->init_num != 0 || readbytes != 1 || p[0] != SSL3_MT_CCS) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_CHANGE_CIPHER_SPEC); return 0; } if (s->statem.hand_state == TLS_ST_BEFORE && (s->s3.flags & TLS1_FLAGS_STATELESS) != 0) { /* * We are stateless and we received a CCS. Probably this is * from a client between the first and second ClientHellos. * We should ignore this, but return an error because we do * not return success until we see the second ClientHello * with a valid cookie. */ return 0; } s->s3.tmp.message_type = *mt = SSL3_MT_CHANGE_CIPHER_SPEC; s->init_num = readbytes - 1; s->init_msg = s->init_buf->data; s->s3.tmp.message_size = readbytes; return 1; } else if (recvd_type != SSL3_RT_HANDSHAKE) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY); return 0; } s->init_num += readbytes; } skip_message = 0; if (!s->server) if (s->statem.hand_state != TLS_ST_OK && p[0] == SSL3_MT_HELLO_REQUEST) /* * The server may always send 'Hello Request' messages -- * we are doing a handshake anyway now, so ignore them if * their format is correct. Does not count for 'Finished' * MAC. */ if (p[1] == 0 && p[2] == 0 && p[3] == 0) { s->init_num = 0; skip_message = 1; if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, p, SSL3_HM_HEADER_LENGTH, ssl, s->msg_callback_arg); } } while (skip_message); /* s->init_num == SSL3_HM_HEADER_LENGTH */ *mt = *p; s->s3.tmp.message_type = *(p++); if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) { /* * Only happens with SSLv3+ in an SSLv2 backward compatible * ClientHello * * Total message size is the remaining record bytes to read * plus the SSL3_HM_HEADER_LENGTH bytes that we already read */ l = s->rlayer.tlsrecs[0].length + SSL3_HM_HEADER_LENGTH; s->s3.tmp.message_size = l; s->init_msg = s->init_buf->data; s->init_num = SSL3_HM_HEADER_LENGTH; } else { n2l3(p, l); /* BUF_MEM_grow takes an 'int' parameter */ if (l > (INT_MAX - SSL3_HM_HEADER_LENGTH)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE); return 0; } s->s3.tmp.message_size = l; s->init_msg = s->init_buf->data + SSL3_HM_HEADER_LENGTH; s->init_num = 0; } return 1; } int tls_get_message_body(SSL_CONNECTION *s, size_t *len) { size_t n, readbytes; unsigned char *p; int i; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->s3.tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC) { /* We've already read everything in */ *len = (unsigned long)s->init_num; return 1; } p = s->init_msg; n = s->s3.tmp.message_size - s->init_num; while (n > 0) { i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, &p[s->init_num], n, 0, &readbytes); if (i <= 0) { s->rwstate = SSL_READING; *len = 0; return 0; } s->init_num += readbytes; n -= readbytes; } /* * If receiving Finished, record MAC of prior handshake messages for * Finished verification. */ if (*(s->init_buf->data) == SSL3_MT_FINISHED && !ssl3_take_mac(s)) { /* SSLfatal() already called */ *len = 0; return 0; } /* Feed this message into MAC computation. */ if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) { if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data, s->init_num)) { /* SSLfatal() already called */ *len = 0; return 0; } if (s->msg_callback) s->msg_callback(0, SSL2_VERSION, 0, s->init_buf->data, (size_t)s->init_num, ssl, s->msg_callback_arg); } else { /* * We defer feeding in the HRR until later. We'll do it as part of * processing the message * The TLsv1.3 handshake transcript stops at the ClientFinished * message. */ #define SERVER_HELLO_RANDOM_OFFSET (SSL3_HM_HEADER_LENGTH + 2) /* KeyUpdate and NewSessionTicket do not need to be added */ if (!SSL_CONNECTION_IS_TLS13(s) || (s->s3.tmp.message_type != SSL3_MT_NEWSESSION_TICKET && s->s3.tmp.message_type != SSL3_MT_KEY_UPDATE)) { if (s->s3.tmp.message_type != SSL3_MT_SERVER_HELLO || s->init_num < SERVER_HELLO_RANDOM_OFFSET + SSL3_RANDOM_SIZE || memcmp(hrrrandom, s->init_buf->data + SERVER_HELLO_RANDOM_OFFSET, SSL3_RANDOM_SIZE) != 0) { if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data, s->init_num + SSL3_HM_HEADER_LENGTH)) { /* SSLfatal() already called */ *len = 0; return 0; } } } if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data, (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, ssl, s->msg_callback_arg); } *len = s->init_num; return 1; } static const X509ERR2ALERT x509table[] = { {X509_V_ERR_APPLICATION_VERIFICATION, SSL_AD_HANDSHAKE_FAILURE}, {X509_V_ERR_CA_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_EC_KEY_EXPLICIT_PARAMS, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CA_MD_TOO_WEAK, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CERT_CHAIN_TOO_LONG, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_CERT_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED}, {X509_V_ERR_CERT_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CERT_REJECTED, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CERT_REVOKED, SSL_AD_CERTIFICATE_REVOKED}, {X509_V_ERR_CERT_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR}, {X509_V_ERR_CERT_UNTRUSTED, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CRL_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED}, {X509_V_ERR_CRL_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_CRL_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR}, {X509_V_ERR_DANE_NO_MATCH, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_EE_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_EMAIL_MISMATCH, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_HOSTNAME_MISMATCH, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_INVALID_CA, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_INVALID_CALL, SSL_AD_INTERNAL_ERROR}, {X509_V_ERR_INVALID_PURPOSE, SSL_AD_UNSUPPORTED_CERTIFICATE}, {X509_V_ERR_IP_ADDRESS_MISMATCH, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_OUT_OF_MEM, SSL_AD_INTERNAL_ERROR}, {X509_V_ERR_PATH_LENGTH_EXCEEDED, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_STORE_LOOKUP, SSL_AD_INTERNAL_ERROR}, {X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE, SSL_AD_BAD_CERTIFICATE}, {X509_V_ERR_UNABLE_TO_GET_CRL, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE, SSL_AD_UNKNOWN_CA}, {X509_V_ERR_UNSPECIFIED, SSL_AD_INTERNAL_ERROR}, /* Last entry; return this if we don't find the value above. */ {X509_V_OK, SSL_AD_CERTIFICATE_UNKNOWN} }; int ssl_x509err2alert(int x509err) { const X509ERR2ALERT *tp; for (tp = x509table; tp->x509err != X509_V_OK; ++tp) if (tp->x509err == x509err) break; return tp->alert; } int ssl_allow_compression(SSL_CONNECTION *s) { if (s->options & SSL_OP_NO_COMPRESSION) return 0; return ssl_security(s, SSL_SECOP_COMPRESSION, 0, 0, NULL); } /* * SSL/TLS/DTLS version comparison * * Returns * 0 if versiona is equal to versionb * 1 if versiona is greater than versionb * -1 if versiona is less than versionb */ int ssl_version_cmp(const SSL_CONNECTION *s, int versiona, int versionb) { int dtls = SSL_CONNECTION_IS_DTLS(s); if (versiona == versionb) return 0; if (!dtls) return versiona < versionb ? -1 : 1; return DTLS_VERSION_LT(versiona, versionb) ? -1 : 1; } typedef struct { int version; const SSL_METHOD *(*cmeth) (void); const SSL_METHOD *(*smeth) (void); } version_info; #if TLS_MAX_VERSION_INTERNAL != TLS1_3_VERSION # error Code needs update for TLS_method() support beyond TLS1_3_VERSION. #endif /* Must be in order high to low */ static const version_info tls_version_table[] = { #ifndef OPENSSL_NO_TLS1_3 {TLS1_3_VERSION, tlsv1_3_client_method, tlsv1_3_server_method}, #else {TLS1_3_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_TLS1_2 {TLS1_2_VERSION, tlsv1_2_client_method, tlsv1_2_server_method}, #else {TLS1_2_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_TLS1_1 {TLS1_1_VERSION, tlsv1_1_client_method, tlsv1_1_server_method}, #else {TLS1_1_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_TLS1 {TLS1_VERSION, tlsv1_client_method, tlsv1_server_method}, #else {TLS1_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_SSL3 {SSL3_VERSION, sslv3_client_method, sslv3_server_method}, #else {SSL3_VERSION, NULL, NULL}, #endif {0, NULL, NULL}, }; #if DTLS_MAX_VERSION_INTERNAL != DTLS1_2_VERSION # error Code needs update for DTLS_method() support beyond DTLS1_2_VERSION. #endif /* Must be in order high to low */ static const version_info dtls_version_table[] = { #ifndef OPENSSL_NO_DTLS1_2 {DTLS1_2_VERSION, dtlsv1_2_client_method, dtlsv1_2_server_method}, #else {DTLS1_2_VERSION, NULL, NULL}, #endif #ifndef OPENSSL_NO_DTLS1 {DTLS1_VERSION, dtlsv1_client_method, dtlsv1_server_method}, {DTLS1_BAD_VER, dtls_bad_ver_client_method, NULL}, #else {DTLS1_VERSION, NULL, NULL}, {DTLS1_BAD_VER, NULL, NULL}, #endif {0, NULL, NULL}, }; /* * ssl_method_error - Check whether an SSL_METHOD is enabled. * * @s: The SSL handle for the candidate method * @method: the intended method. * * Returns 0 on success, or an SSL error reason on failure. */ static int ssl_method_error(const SSL_CONNECTION *s, const SSL_METHOD *method) { int version = method->version; if ((s->min_proto_version != 0 && ssl_version_cmp(s, version, s->min_proto_version) < 0) || ssl_security(s, SSL_SECOP_VERSION, 0, version, NULL) == 0) return SSL_R_VERSION_TOO_LOW; if (s->max_proto_version != 0 && ssl_version_cmp(s, version, s->max_proto_version) > 0) return SSL_R_VERSION_TOO_HIGH; if ((s->options & method->mask) != 0) return SSL_R_UNSUPPORTED_PROTOCOL; if ((method->flags & SSL_METHOD_NO_SUITEB) != 0 && tls1_suiteb(s)) return SSL_R_AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE; return 0; } /* * Only called by servers. Returns 1 if the server has a TLSv1.3 capable * certificate type, or has PSK or a certificate callback configured, or has * a servername callback configure. Otherwise returns 0. */ static int is_tls13_capable(const SSL_CONNECTION *s) { size_t i; int curve; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (!ossl_assert(sctx != NULL) || !ossl_assert(s->session_ctx != NULL)) return 0; /* * A servername callback can change the available certs, so if a servername * cb is set then we just assume TLSv1.3 will be ok */ if (sctx->ext.servername_cb != NULL || s->session_ctx->ext.servername_cb != NULL) return 1; #ifndef OPENSSL_NO_PSK if (s->psk_server_callback != NULL) return 1; #endif if (s->psk_find_session_cb != NULL || s->cert->cert_cb != NULL) return 1; /* All provider-based sig algs are required to support at least TLS1.3 */ for (i = 0; i < s->ssl_pkey_num; i++) { /* Skip over certs disallowed for TLSv1.3 */ switch (i) { case SSL_PKEY_DSA_SIGN: case SSL_PKEY_GOST01: case SSL_PKEY_GOST12_256: case SSL_PKEY_GOST12_512: continue; default: break; } if (!ssl_has_cert(s, i)) continue; if (i != SSL_PKEY_ECC) return 1; /* * Prior to TLSv1.3 sig algs allowed any curve to be used. TLSv1.3 is * more restrictive so check that our sig algs are consistent with this * EC cert. See section 4.2.3 of RFC8446. */ curve = ssl_get_EC_curve_nid(s->cert->pkeys[SSL_PKEY_ECC].privatekey); if (tls_check_sigalg_curve(s, curve)) return 1; } return 0; } /* * ssl_version_supported - Check that the specified `version` is supported by * `SSL *` instance * * @s: The SSL handle for the candidate method * @version: Protocol version to test against * * Returns 1 when supported, otherwise 0 */ int ssl_version_supported(const SSL_CONNECTION *s, int version, const SSL_METHOD **meth) { const version_info *vent; const version_info *table; switch (SSL_CONNECTION_GET_SSL(s)->method->version) { default: /* Version should match method version for non-ANY method */ return ssl_version_cmp(s, version, s->version) == 0; case TLS_ANY_VERSION: table = tls_version_table; break; case DTLS_ANY_VERSION: table = dtls_version_table; break; } for (vent = table; vent->version != 0 && ssl_version_cmp(s, version, vent->version) <= 0; ++vent) { if (vent->cmeth != NULL && ssl_version_cmp(s, version, vent->version) == 0 && ssl_method_error(s, vent->cmeth()) == 0 && (!s->server || version != TLS1_3_VERSION || is_tls13_capable(s))) { if (meth != NULL) *meth = vent->cmeth(); return 1; } } return 0; } /* * ssl_check_version_downgrade - In response to RFC7507 SCSV version * fallback indication from a client check whether we're using the highest * supported protocol version. * * @s server SSL handle. * * Returns 1 when using the highest enabled version, 0 otherwise. */ int ssl_check_version_downgrade(SSL_CONNECTION *s) { const version_info *vent; const version_info *table; SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* * Check that the current protocol is the highest enabled version * (according to ssl->defltmethod, as version negotiation may have changed * s->method). */ if (s->version == ssl->defltmeth->version) return 1; /* * Apparently we're using a version-flexible SSL_METHOD (not at its * highest protocol version). */ if (ssl->defltmeth->version == TLS_method()->version) table = tls_version_table; else if (ssl->defltmeth->version == DTLS_method()->version) table = dtls_version_table; else { /* Unexpected state; fail closed. */ return 0; } for (vent = table; vent->version != 0; ++vent) { if (vent->smeth != NULL && ssl_method_error(s, vent->smeth()) == 0) return s->version == vent->version; } return 0; } /* * ssl_set_version_bound - set an upper or lower bound on the supported (D)TLS * protocols, provided the initial (D)TLS method is version-flexible. This * function sanity-checks the proposed value and makes sure the method is * version-flexible, then sets the limit if all is well. * * @method_version: The version of the current SSL_METHOD. * @version: the intended limit. * @bound: pointer to limit to be updated. * * Returns 1 on success, 0 on failure. */ int ssl_set_version_bound(int method_version, int version, int *bound) { int valid_tls; int valid_dtls; if (version == 0) { *bound = version; return 1; } valid_tls = version >= SSL3_VERSION && version <= TLS_MAX_VERSION_INTERNAL; valid_dtls = /* We support client side pre-standardisation version of DTLS */ (version == DTLS1_BAD_VER) || (DTLS_VERSION_LE(version, DTLS_MAX_VERSION_INTERNAL) && DTLS_VERSION_GE(version, DTLS1_VERSION)); if (!valid_tls && !valid_dtls) return 0; /*- * Restrict TLS methods to TLS protocol versions. * Restrict DTLS methods to DTLS protocol versions. * Note, DTLS version numbers are decreasing, use comparison macros. * * Note that for both lower-bounds we use explicit versions, not * (D)TLS_MIN_VERSION. This is because we don't want to break user * configurations. If the MIN (supported) version ever rises, the user's * "floor" remains valid even if no longer available. We don't expect the * MAX ceiling to ever get lower, so making that variable makes sense. * * We ignore attempts to set bounds on version-inflexible methods, * returning success. */ switch (method_version) { default: break; case TLS_ANY_VERSION: if (valid_tls) *bound = version; break; case DTLS_ANY_VERSION: if (valid_dtls) *bound = version; break; } return 1; } static void check_for_downgrade(SSL_CONNECTION *s, int vers, DOWNGRADE *dgrd) { if (vers == TLS1_2_VERSION && ssl_version_supported(s, TLS1_3_VERSION, NULL)) { *dgrd = DOWNGRADE_TO_1_2; } else if (!SSL_CONNECTION_IS_DTLS(s) && vers < TLS1_2_VERSION /* * We need to ensure that a server that disables TLSv1.2 * (creating a hole between TLSv1.3 and TLSv1.1) can still * complete handshakes with clients that support TLSv1.2 and * below. Therefore we do not enable the sentinel if TLSv1.3 is * enabled and TLSv1.2 is not. */ && ssl_version_supported(s, TLS1_2_VERSION, NULL)) { *dgrd = DOWNGRADE_TO_1_1; } else { *dgrd = DOWNGRADE_NONE; } } /* * ssl_choose_server_version - Choose server (D)TLS version. Called when the * client HELLO is received to select the final server protocol version and * the version specific method. * * @s: server SSL handle. * * Returns 0 on success or an SSL error reason number on failure. */ int ssl_choose_server_version(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello, DOWNGRADE *dgrd) { /*- * With version-flexible methods we have an initial state with: * * s->method->version == (D)TLS_ANY_VERSION, * s->version == (D)TLS_MAX_VERSION_INTERNAL. * * So we detect version-flexible methods via the method version, not the * handle version. */ SSL *ssl = SSL_CONNECTION_GET_SSL(s); int server_version = ssl->method->version; int client_version = hello->legacy_version; const version_info *vent; const version_info *table; int disabled = 0; RAW_EXTENSION *suppversions; s->client_version = client_version; switch (server_version) { default: if (!SSL_CONNECTION_IS_TLS13(s)) { if (ssl_version_cmp(s, client_version, s->version) < 0) return SSL_R_WRONG_SSL_VERSION; *dgrd = DOWNGRADE_NONE; /* * If this SSL handle is not from a version flexible method we don't * (and never did) check min/max FIPS or Suite B constraints. Hope * that's OK. It is up to the caller to not choose fixed protocol * versions they don't want. If not, then easy to fix, just return * ssl_method_error(s, s->method) */ return 0; } /* * Fall through if we are TLSv1.3 already (this means we must be after * a HelloRetryRequest */ /* fall thru */ case TLS_ANY_VERSION: table = tls_version_table; break; case DTLS_ANY_VERSION: table = dtls_version_table; break; } suppversions = &hello->pre_proc_exts[TLSEXT_IDX_supported_versions]; /* If we did an HRR then supported versions is mandatory */ if (!suppversions->present && s->hello_retry_request != SSL_HRR_NONE) return SSL_R_UNSUPPORTED_PROTOCOL; if (suppversions->present && !SSL_CONNECTION_IS_DTLS(s)) { unsigned int candidate_vers = 0; unsigned int best_vers = 0; const SSL_METHOD *best_method = NULL; PACKET versionslist; suppversions->parsed = 1; if (!PACKET_as_length_prefixed_1(&suppversions->data, &versionslist)) { /* Trailing or invalid data? */ return SSL_R_LENGTH_MISMATCH; } /* * The TLSv1.3 spec says the client MUST set this to TLS1_2_VERSION. * The spec only requires servers to check that it isn't SSLv3: * "Any endpoint receiving a Hello message with * ClientHello.legacy_version or ServerHello.legacy_version set to * 0x0300 MUST abort the handshake with a "protocol_version" alert." * We are slightly stricter and require that it isn't SSLv3 or lower. * We tolerate TLSv1 and TLSv1.1. */ if (client_version <= SSL3_VERSION) return SSL_R_BAD_LEGACY_VERSION; while (PACKET_get_net_2(&versionslist, &candidate_vers)) { if (ssl_version_cmp(s, candidate_vers, best_vers) <= 0) continue; if (ssl_version_supported(s, candidate_vers, &best_method)) best_vers = candidate_vers; } if (PACKET_remaining(&versionslist) != 0) { /* Trailing data? */ return SSL_R_LENGTH_MISMATCH; } if (best_vers > 0) { if (s->hello_retry_request != SSL_HRR_NONE) { /* * This is after a HelloRetryRequest so we better check that we * negotiated TLSv1.3 */ if (best_vers != TLS1_3_VERSION) return SSL_R_UNSUPPORTED_PROTOCOL; return 0; } check_for_downgrade(s, best_vers, dgrd); s->version = best_vers; ssl->method = best_method; if (!ssl_set_record_protocol_version(s, best_vers)) return ERR_R_INTERNAL_ERROR; return 0; } return SSL_R_UNSUPPORTED_PROTOCOL; } /* * If the supported versions extension isn't present, then the highest * version we can negotiate is TLSv1.2 */ if (ssl_version_cmp(s, client_version, TLS1_3_VERSION) >= 0) client_version = TLS1_2_VERSION; /* * No supported versions extension, so we just use the version supplied in * the ClientHello. */ for (vent = table; vent->version != 0; ++vent) { const SSL_METHOD *method; if (vent->smeth == NULL || ssl_version_cmp(s, client_version, vent->version) < 0) continue; method = vent->smeth(); if (ssl_method_error(s, method) == 0) { check_for_downgrade(s, vent->version, dgrd); s->version = vent->version; ssl->method = method; if (!ssl_set_record_protocol_version(s, s->version)) return ERR_R_INTERNAL_ERROR; return 0; } disabled = 1; } return disabled ? SSL_R_UNSUPPORTED_PROTOCOL : SSL_R_VERSION_TOO_LOW; } /* * ssl_choose_client_version - Choose client (D)TLS version. Called when the * server HELLO is received to select the final client protocol version and * the version specific method. * * @s: client SSL handle. * @version: The proposed version from the server's HELLO. * @extensions: The extensions received * * Returns 1 on success or 0 on error. */ int ssl_choose_client_version(SSL_CONNECTION *s, int version, RAW_EXTENSION *extensions) { const version_info *vent; const version_info *table; int ret, ver_min, ver_max, real_max, origv; SSL *ssl = SSL_CONNECTION_GET_SSL(s); origv = s->version; s->version = version; /* This will overwrite s->version if the extension is present */ if (!tls_parse_extension(s, TLSEXT_IDX_supported_versions, SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO, extensions, NULL, 0)) { s->version = origv; return 0; } if (s->hello_retry_request != SSL_HRR_NONE && s->version != TLS1_3_VERSION) { s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_SSL_VERSION); return 0; } switch (ssl->method->version) { default: if (s->version != ssl->method->version) { s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_SSL_VERSION); return 0; } /* * If this SSL handle is not from a version flexible method we don't * (and never did) check min/max, FIPS or Suite B constraints. Hope * that's OK. It is up to the caller to not choose fixed protocol * versions they don't want. If not, then easy to fix, just return * ssl_method_error(s, s->method) */ if (!ssl_set_record_protocol_version(s, s->version)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; case TLS_ANY_VERSION: table = tls_version_table; break; case DTLS_ANY_VERSION: table = dtls_version_table; break; } ret = ssl_get_min_max_version(s, &ver_min, &ver_max, &real_max); if (ret != 0) { s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, ret); return 0; } if (ssl_version_cmp(s, s->version, ver_min) < 0 || ssl_version_cmp(s, s->version, ver_max) > 0) { s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_UNSUPPORTED_PROTOCOL); return 0; } if ((s->mode & SSL_MODE_SEND_FALLBACK_SCSV) == 0) real_max = ver_max; /* Check for downgrades */ if (s->version == TLS1_2_VERSION && real_max > s->version) { if (memcmp(tls12downgrade, s->s3.server_random + SSL3_RANDOM_SIZE - sizeof(tls12downgrade), sizeof(tls12downgrade)) == 0) { s->version = origv; SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INAPPROPRIATE_FALLBACK); return 0; } } else if (!SSL_CONNECTION_IS_DTLS(s) && s->version < TLS1_2_VERSION && real_max > s->version) { if (memcmp(tls11downgrade, s->s3.server_random + SSL3_RANDOM_SIZE - sizeof(tls11downgrade), sizeof(tls11downgrade)) == 0) { s->version = origv; SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INAPPROPRIATE_FALLBACK); return 0; } } for (vent = table; vent->version != 0; ++vent) { if (vent->cmeth == NULL || s->version != vent->version) continue; ssl->method = vent->cmeth(); if (!ssl_set_record_protocol_version(s, s->version)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } s->version = origv; SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_UNSUPPORTED_PROTOCOL); return 0; } /* * ssl_get_min_max_version - get minimum and maximum protocol version * @s: The SSL connection * @min_version: The minimum supported version * @max_version: The maximum supported version * @real_max: The highest version below the lowest compile time version hole * where that hole lies above at least one run-time enabled * protocol. * * Work out what version we should be using for the initial ClientHello if the * version is initially (D)TLS_ANY_VERSION. We apply any explicit SSL_OP_NO_xxx * options, the MinProtocol and MaxProtocol configuration commands, any Suite B * constraints and any floor imposed by the security level here, * so we don't advertise the wrong protocol version to only reject the outcome later. * * Computing the right floor matters. If, e.g., TLS 1.0 and 1.2 are enabled, * TLS 1.1 is disabled, but the security level, Suite-B and/or MinProtocol * only allow TLS 1.2, we want to advertise TLS1.2, *not* TLS1. * * Returns 0 on success or an SSL error reason number on failure. On failure * min_version and max_version will also be set to 0. */ int ssl_get_min_max_version(const SSL_CONNECTION *s, int *min_version, int *max_version, int *real_max) { int version, tmp_real_max; int hole; const SSL_METHOD *method; const version_info *table; const version_info *vent; const SSL *ssl = SSL_CONNECTION_GET_SSL(s); switch (ssl->method->version) { default: /* * If this SSL handle is not from a version flexible method we don't * (and never did) check min/max FIPS or Suite B constraints. Hope * that's OK. It is up to the caller to not choose fixed protocol * versions they don't want. If not, then easy to fix, just return * ssl_method_error(s, s->method) */ *min_version = *max_version = s->version; /* * Providing a real_max only makes sense where we're using a version * flexible method. */ if (!ossl_assert(real_max == NULL)) return ERR_R_INTERNAL_ERROR; return 0; case TLS_ANY_VERSION: table = tls_version_table; break; case DTLS_ANY_VERSION: table = dtls_version_table; break; } /* * SSL_OP_NO_X disables all protocols above X *if* there are some protocols * below X enabled. This is required in order to maintain the "version * capability" vector contiguous. Any versions with a NULL client method * (protocol version client is disabled at compile-time) is also a "hole". * * Our initial state is hole == 1, version == 0. That is, versions above * the first version in the method table are disabled (a "hole" above * the valid protocol entries) and we don't have a selected version yet. * * Whenever "hole == 1", and we hit an enabled method, its version becomes * the selected version. We're no longer in a hole, so "hole" becomes 0. * * If "hole == 0" and we hit an enabled method, we support a contiguous * range of at least two methods. If we hit a disabled method, * then hole becomes true again, but nothing else changes yet, * because all the remaining methods may be disabled too. * If we again hit an enabled method after the new hole, it becomes * selected, as we start from scratch. */ *min_version = version = 0; hole = 1; if (real_max != NULL) *real_max = 0; tmp_real_max = 0; for (vent = table; vent->version != 0; ++vent) { /* * A table entry with a NULL client method is still a hole in the * "version capability" vector. */ if (vent->cmeth == NULL) { hole = 1; tmp_real_max = 0; continue; } method = vent->cmeth(); if (hole == 1 && tmp_real_max == 0) tmp_real_max = vent->version; if (ssl_method_error(s, method) != 0) { hole = 1; } else if (!hole) { *min_version = method->version; } else { if (real_max != NULL && tmp_real_max != 0) *real_max = tmp_real_max; version = method->version; *min_version = version; hole = 0; } } *max_version = version; /* Fail if everything is disabled */ if (version == 0) return SSL_R_NO_PROTOCOLS_AVAILABLE; return 0; } /* * ssl_set_client_hello_version - Work out what version we should be using for * the initial ClientHello.legacy_version field. * * @s: client SSL handle. * * Returns 0 on success or an SSL error reason number on failure. */ int ssl_set_client_hello_version(SSL_CONNECTION *s) { int ver_min, ver_max, ret; /* * In a renegotiation we always send the same client_version that we sent * last time, regardless of which version we eventually negotiated. */ if (!SSL_IS_FIRST_HANDSHAKE(s)) return 0; ret = ssl_get_min_max_version(s, &ver_min, &ver_max, NULL); if (ret != 0) return ret; s->version = ver_max; if (SSL_CONNECTION_IS_DTLS(s)) { if (ver_max == DTLS1_BAD_VER) { /* * Even though this is technically before version negotiation, * because we have asked for DTLS1_BAD_VER we will never negotiate * anything else, and this has impacts on the record layer for when * we read the ServerHello. So we need to tell the record layer * about this immediately. */ if (!ssl_set_record_protocol_version(s, ver_max)) return 0; } } else if (ver_max > TLS1_2_VERSION) { /* TLS1.3 always uses TLS1.2 in the legacy_version field */ ver_max = TLS1_2_VERSION; } s->client_version = ver_max; return 0; } /* * Checks a list of |groups| to determine if the |group_id| is in it. If it is * and |checkallow| is 1 then additionally check if the group is allowed to be * used. Returns 1 if the group is in the list (and allowed if |checkallow| is * 1) or 0 otherwise. */ int check_in_list(SSL_CONNECTION *s, uint16_t group_id, const uint16_t *groups, size_t num_groups, int checkallow) { size_t i; if (groups == NULL || num_groups == 0) return 0; for (i = 0; i < num_groups; i++) { uint16_t group = groups[i]; if (group_id == group && (!checkallow || tls_group_allowed(s, group, SSL_SECOP_CURVE_CHECK))) { return 1; } } return 0; } /* Replace ClientHello1 in the transcript hash with a synthetic message */ int create_synthetic_message_hash(SSL_CONNECTION *s, const unsigned char *hashval, size_t hashlen, const unsigned char *hrr, size_t hrrlen) { unsigned char hashvaltmp[EVP_MAX_MD_SIZE]; unsigned char msghdr[SSL3_HM_HEADER_LENGTH]; memset(msghdr, 0, sizeof(msghdr)); if (hashval == NULL) { hashval = hashvaltmp; hashlen = 0; /* Get the hash of the initial ClientHello */ if (!ssl3_digest_cached_records(s, 0) || !ssl_handshake_hash(s, hashvaltmp, sizeof(hashvaltmp), &hashlen)) { /* SSLfatal() already called */ return 0; } } /* Reinitialise the transcript hash */ if (!ssl3_init_finished_mac(s)) { /* SSLfatal() already called */ return 0; } /* Inject the synthetic message_hash message */ msghdr[0] = SSL3_MT_MESSAGE_HASH; msghdr[SSL3_HM_HEADER_LENGTH - 1] = (unsigned char)hashlen; if (!ssl3_finish_mac(s, msghdr, SSL3_HM_HEADER_LENGTH) || !ssl3_finish_mac(s, hashval, hashlen)) { /* SSLfatal() already called */ return 0; } /* * Now re-inject the HRR and current message if appropriate (we just deleted * it when we reinitialised the transcript hash above). Only necessary after * receiving a ClientHello2 with a cookie. */ if (hrr != NULL && (!ssl3_finish_mac(s, hrr, hrrlen) || !ssl3_finish_mac(s, (unsigned char *)s->init_buf->data, s->s3.tmp.message_size + SSL3_HM_HEADER_LENGTH))) { /* SSLfatal() already called */ return 0; } return 1; } static int ca_dn_cmp(const X509_NAME *const *a, const X509_NAME *const *b) { return X509_NAME_cmp(*a, *b); } int parse_ca_names(SSL_CONNECTION *s, PACKET *pkt) { STACK_OF(X509_NAME) *ca_sk = sk_X509_NAME_new(ca_dn_cmp); X509_NAME *xn = NULL; PACKET cadns; if (ca_sk == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } /* get the CA RDNs */ if (!PACKET_get_length_prefixed_2(pkt, &cadns)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } while (PACKET_remaining(&cadns)) { const unsigned char *namestart, *namebytes; unsigned int name_len; if (!PACKET_get_net_2(&cadns, &name_len) || !PACKET_get_bytes(&cadns, &namebytes, name_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } namestart = namebytes; if ((xn = d2i_X509_NAME(NULL, &namebytes, name_len)) == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_ASN1_LIB); goto err; } if (namebytes != (namestart + name_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CA_DN_LENGTH_MISMATCH); goto err; } if (!sk_X509_NAME_push(ca_sk, xn)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } xn = NULL; } sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free); s->s3.tmp.peer_ca_names = ca_sk; return 1; err: sk_X509_NAME_pop_free(ca_sk, X509_NAME_free); X509_NAME_free(xn); return 0; } const STACK_OF(X509_NAME) *get_ca_names(SSL_CONNECTION *s) { const STACK_OF(X509_NAME) *ca_sk = NULL; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->server) { ca_sk = SSL_get_client_CA_list(ssl); if (ca_sk != NULL && sk_X509_NAME_num(ca_sk) == 0) ca_sk = NULL; } if (ca_sk == NULL) ca_sk = SSL_get0_CA_list(ssl); return ca_sk; } int construct_ca_names(SSL_CONNECTION *s, const STACK_OF(X509_NAME) *ca_sk, WPACKET *pkt) { /* Start sub-packet for client CA list */ if (!WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((ca_sk != NULL) && !(s->options & SSL_OP_DISABLE_TLSEXT_CA_NAMES)) { int i; for (i = 0; i < sk_X509_NAME_num(ca_sk); i++) { unsigned char *namebytes; X509_NAME *name = sk_X509_NAME_value(ca_sk, i); int namelen; if (name == NULL || (namelen = i2d_X509_NAME(name, NULL)) < 0 || !WPACKET_sub_allocate_bytes_u16(pkt, namelen, &namebytes) || i2d_X509_NAME(name, &namebytes) != namelen) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } /* Create a buffer containing data to be signed for server key exchange */ size_t construct_key_exchange_tbs(SSL_CONNECTION *s, unsigned char **ptbs, const void *param, size_t paramlen) { size_t tbslen = 2 * SSL3_RANDOM_SIZE + paramlen; unsigned char *tbs = OPENSSL_malloc(tbslen); if (tbs == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } memcpy(tbs, s->s3.client_random, SSL3_RANDOM_SIZE); memcpy(tbs + SSL3_RANDOM_SIZE, s->s3.server_random, SSL3_RANDOM_SIZE); memcpy(tbs + SSL3_RANDOM_SIZE * 2, param, paramlen); *ptbs = tbs; return tbslen; } /* * Saves the current handshake digest for Post-Handshake Auth, * Done after ClientFinished is processed, done exactly once */ int tls13_save_handshake_digest_for_pha(SSL_CONNECTION *s) { if (s->pha_dgst == NULL) { if (!ssl3_digest_cached_records(s, 1)) /* SSLfatal() already called */ return 0; s->pha_dgst = EVP_MD_CTX_new(); if (s->pha_dgst == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!EVP_MD_CTX_copy_ex(s->pha_dgst, s->s3.handshake_dgst)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_MD_CTX_free(s->pha_dgst); s->pha_dgst = NULL; return 0; } } return 1; } /* * Restores the Post-Handshake Auth handshake digest * Done just before sending/processing the Cert Request */ int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION *s) { if (s->pha_dgst == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!EVP_MD_CTX_copy_ex(s->s3.handshake_dgst, s->pha_dgst)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } #ifndef OPENSSL_NO_COMP_ALG MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION *sc, PACKET *pkt, PACKET *tmppkt, BUF_MEM *buf) { MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; int comp_alg; COMP_METHOD *method = NULL; COMP_CTX *comp = NULL; size_t expected_length; size_t comp_length; int i; int found = 0; if (buf == NULL) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!PACKET_get_net_2(pkt, (unsigned int*)&comp_alg)) { SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, ERR_R_INTERNAL_ERROR); goto err; } /* If we have a prefs list, make sure the algorithm is in it */ if (sc->cert_comp_prefs[0] != TLSEXT_comp_cert_none) { for (i = 0; sc->cert_comp_prefs[i] != TLSEXT_comp_cert_none; i++) { if (sc->cert_comp_prefs[i] == comp_alg) { found = 1; break; } } if (!found) { SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_COMPRESSION_ALGORITHM); goto err; } } if (!ossl_comp_has_alg(comp_alg)) { SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_COMPRESSION_ALGORITHM); goto err; } switch (comp_alg) { case TLSEXT_comp_cert_zlib: method = COMP_zlib_oneshot(); break; case TLSEXT_comp_cert_brotli: method = COMP_brotli_oneshot(); break; case TLSEXT_comp_cert_zstd: method = COMP_zstd_oneshot(); break; default: SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_COMPRESSION_ALGORITHM); goto err; } if ((comp = COMP_CTX_new(method)) == NULL || !PACKET_get_net_3_len(pkt, &expected_length) || !PACKET_get_net_3_len(pkt, &comp_length) || PACKET_remaining(pkt) != comp_length || !BUF_MEM_grow(buf, expected_length) || !PACKET_buf_init(tmppkt, (unsigned char *)buf->data, expected_length) || COMP_expand_block(comp, (unsigned char *)buf->data, expected_length, (unsigned char*)PACKET_data(pkt), comp_length) != (int)expected_length) { SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_DECOMPRESSION); goto err; } ret = MSG_PROCESS_CONTINUE_PROCESSING; err: COMP_CTX_free(comp); return ret; } #endif

./openssl/ssl/statem/statem_dtls.c

/* * Copyright 2005-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <assert.h> #include <limits.h> #include <string.h> #include <stdio.h> #include "../ssl_local.h" #include "statem_local.h" #include "internal/cryptlib.h" #include <openssl/buffer.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/x509.h> #define RSMBLY_BITMASK_SIZE(msg_len) (((msg_len) + 7) / 8) #define RSMBLY_BITMASK_MARK(bitmask, start, end) { \ if ((end) - (start) <= 8) { \ long ii; \ for (ii = (start); ii < (end); ii++) bitmask[((ii) >> 3)] |= (1 << ((ii) & 7)); \ } else { \ long ii; \ bitmask[((start) >> 3)] |= bitmask_start_values[((start) & 7)]; \ for (ii = (((start) >> 3) + 1); ii < ((((end) - 1)) >> 3); ii++) bitmask[ii] = 0xff; \ bitmask[(((end) - 1) >> 3)] |= bitmask_end_values[((end) & 7)]; \ } } #define RSMBLY_BITMASK_IS_COMPLETE(bitmask, msg_len, is_complete) { \ long ii; \ is_complete = 1; \ if (bitmask[(((msg_len) - 1) >> 3)] != bitmask_end_values[((msg_len) & 7)]) is_complete = 0; \ if (is_complete) for (ii = (((msg_len) - 1) >> 3) - 1; ii >= 0 ; ii--) \ if (bitmask[ii] != 0xff) { is_complete = 0; break; } } static const unsigned char bitmask_start_values[] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 }; static const unsigned char bitmask_end_values[] = { 0xff, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f }; static void dtls1_fix_message_header(SSL_CONNECTION *s, size_t frag_off, size_t frag_len); static unsigned char *dtls1_write_message_header(SSL_CONNECTION *s, unsigned char *p); static void dtls1_set_message_header_int(SSL_CONNECTION *s, unsigned char mt, size_t len, unsigned short seq_num, size_t frag_off, size_t frag_len); static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype, size_t *len); static hm_fragment *dtls1_hm_fragment_new(size_t frag_len, int reassembly) { hm_fragment *frag = NULL; unsigned char *buf = NULL; unsigned char *bitmask = NULL; if ((frag = OPENSSL_zalloc(sizeof(*frag))) == NULL) return NULL; if (frag_len) { if ((buf = OPENSSL_malloc(frag_len)) == NULL) { OPENSSL_free(frag); return NULL; } } /* zero length fragment gets zero frag->fragment */ frag->fragment = buf; /* Initialize reassembly bitmask if necessary */ if (reassembly) { bitmask = OPENSSL_zalloc(RSMBLY_BITMASK_SIZE(frag_len)); if (bitmask == NULL) { OPENSSL_free(buf); OPENSSL_free(frag); return NULL; } } frag->reassembly = bitmask; return frag; } void dtls1_hm_fragment_free(hm_fragment *frag) { if (!frag) return; OPENSSL_free(frag->fragment); OPENSSL_free(frag->reassembly); OPENSSL_free(frag); } /* * send s->init_buf in records of type 'type' (SSL3_RT_HANDSHAKE or * SSL3_RT_CHANGE_CIPHER_SPEC) */ int dtls1_do_write(SSL_CONNECTION *s, uint8_t type) { int ret; size_t written; size_t curr_mtu; int retry = 1; size_t len, frag_off, overhead, used_len; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (!dtls1_query_mtu(s)) return -1; if (s->d1->mtu < dtls1_min_mtu(s)) /* should have something reasonable now */ return -1; if (s->init_off == 0 && type == SSL3_RT_HANDSHAKE) { if (!ossl_assert(s->init_num == s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH)) return -1; } overhead = s->rlayer.wrlmethod->get_max_record_overhead(s->rlayer.wrl); frag_off = 0; s->rwstate = SSL_NOTHING; /* s->init_num shouldn't ever be < 0...but just in case */ while (s->init_num > 0) { if (type == SSL3_RT_HANDSHAKE && s->init_off != 0) { /* We must be writing a fragment other than the first one */ if (frag_off > 0) { /* This is the first attempt at writing out this fragment */ if (s->init_off <= DTLS1_HM_HEADER_LENGTH) { /* * Each fragment that was already sent must at least have * contained the message header plus one other byte. * Therefore |init_off| must have progressed by at least * |DTLS1_HM_HEADER_LENGTH + 1| bytes. If not something went * wrong. */ return -1; } /* * Adjust |init_off| and |init_num| to allow room for a new * message header for this fragment. */ s->init_off -= DTLS1_HM_HEADER_LENGTH; s->init_num += DTLS1_HM_HEADER_LENGTH; } else { /* * We must have been called again after a retry so use the * fragment offset from our last attempt. We do not need * to adjust |init_off| and |init_num| as above, because * that should already have been done before the retry. */ frag_off = s->d1->w_msg_hdr.frag_off; } } used_len = BIO_wpending(s->wbio) + overhead; if (s->d1->mtu > used_len) curr_mtu = s->d1->mtu - used_len; else curr_mtu = 0; if (curr_mtu <= DTLS1_HM_HEADER_LENGTH) { /* * grr.. we could get an error if MTU picked was wrong */ ret = BIO_flush(s->wbio); if (ret <= 0) { s->rwstate = SSL_WRITING; return ret; } if (s->d1->mtu > overhead + DTLS1_HM_HEADER_LENGTH) { curr_mtu = s->d1->mtu - overhead; } else { /* Shouldn't happen */ return -1; } } /* * We just checked that s->init_num > 0 so this cast should be safe */ if (((unsigned int)s->init_num) > curr_mtu) len = curr_mtu; else len = s->init_num; if (len > ssl_get_max_send_fragment(s)) len = ssl_get_max_send_fragment(s); /* * XDTLS: this function is too long. split out the CCS part */ if (type == SSL3_RT_HANDSHAKE) { if (len < DTLS1_HM_HEADER_LENGTH) { /* * len is so small that we really can't do anything sensible * so fail */ return -1; } dtls1_fix_message_header(s, frag_off, len - DTLS1_HM_HEADER_LENGTH); dtls1_write_message_header(s, (unsigned char *)&s->init_buf-> data[s->init_off]); } ret = dtls1_write_bytes(s, type, &s->init_buf->data[s->init_off], len, &written); if (ret <= 0) { /* * might need to update MTU here, but we don't know which * previous packet caused the failure -- so can't really * retransmit anything. continue as if everything is fine and * wait for an alert to handle the retransmit */ if (retry && BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_MTU_EXCEEDED, 0, NULL) > 0) { if (!(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) { if (!dtls1_query_mtu(s)) return -1; /* Have one more go */ retry = 0; } else return -1; } else { return -1; } } else { /* * bad if this assert fails, only part of the handshake message * got sent. but why would this happen? */ if (!ossl_assert(len == written)) return -1; /* * We should not exceed the MTU size. If compression is in use * then the max record overhead calculation is unreliable so we do * not check in that case. We use assert rather than ossl_assert * because in a production build, if this assert were ever to fail, * then the best thing to do is probably carry on regardless. */ assert(s->s3.tmp.new_compression != NULL || BIO_wpending(s->wbio) <= (int)s->d1->mtu); if (type == SSL3_RT_HANDSHAKE && !s->d1->retransmitting) { /* * should not be done for 'Hello Request's, but in that case * we'll ignore the result anyway */ unsigned char *p = (unsigned char *)&s->init_buf->data[s->init_off]; const struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr; size_t xlen; if (frag_off == 0 && s->version != DTLS1_BAD_VER) { /* * reconstruct message header is if it is being sent in * single fragment */ *p++ = msg_hdr->type; l2n3(msg_hdr->msg_len, p); s2n(msg_hdr->seq, p); l2n3(0, p); l2n3(msg_hdr->msg_len, p); p -= DTLS1_HM_HEADER_LENGTH; xlen = written; } else { p += DTLS1_HM_HEADER_LENGTH; xlen = written - DTLS1_HM_HEADER_LENGTH; } if (!ssl3_finish_mac(s, p, xlen)) return -1; } if (written == s->init_num) { if (s->msg_callback) s->msg_callback(1, s->version, type, s->init_buf->data, (size_t)(s->init_off + s->init_num), ssl, s->msg_callback_arg); s->init_off = 0; /* done writing this message */ s->init_num = 0; return 1; } s->init_off += written; s->init_num -= written; written -= DTLS1_HM_HEADER_LENGTH; frag_off += written; /* * We save the fragment offset for the next fragment so we have it * available in case of an IO retry. We don't know the length of the * next fragment yet so just set that to 0 for now. It will be * updated again later. */ dtls1_fix_message_header(s, frag_off, 0); } } return 0; } int dtls_get_message(SSL_CONNECTION *s, int *mt) { struct hm_header_st *msg_hdr; unsigned char *p; size_t msg_len; size_t tmplen; int errtype; msg_hdr = &s->d1->r_msg_hdr; memset(msg_hdr, 0, sizeof(*msg_hdr)); again: if (!dtls_get_reassembled_message(s, &errtype, &tmplen)) { if (errtype == DTLS1_HM_BAD_FRAGMENT || errtype == DTLS1_HM_FRAGMENT_RETRY) { /* bad fragment received */ goto again; } return 0; } *mt = s->s3.tmp.message_type; p = (unsigned char *)s->init_buf->data; if (*mt == SSL3_MT_CHANGE_CIPHER_SPEC) { if (s->msg_callback) { s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC, p, 1, SSL_CONNECTION_GET_SSL(s), s->msg_callback_arg); } /* * This isn't a real handshake message so skip the processing below. */ return 1; } msg_len = msg_hdr->msg_len; /* reconstruct message header */ *(p++) = msg_hdr->type; l2n3(msg_len, p); s2n(msg_hdr->seq, p); l2n3(0, p); l2n3(msg_len, p); memset(msg_hdr, 0, sizeof(*msg_hdr)); s->d1->handshake_read_seq++; s->init_msg = s->init_buf->data + DTLS1_HM_HEADER_LENGTH; return 1; } /* * Actually we already have the message body - but this is an opportunity for * DTLS to do any further processing it wants at the same point that TLS would * be asked for the message body. */ int dtls_get_message_body(SSL_CONNECTION *s, size_t *len) { unsigned char *msg = (unsigned char *)s->init_buf->data; size_t msg_len = s->init_num + DTLS1_HM_HEADER_LENGTH; if (s->s3.tmp.message_type == SSL3_MT_CHANGE_CIPHER_SPEC) { /* Nothing to be done */ goto end; } /* * If receiving Finished, record MAC of prior handshake messages for * Finished verification. */ if (*(s->init_buf->data) == SSL3_MT_FINISHED && !ssl3_take_mac(s)) { /* SSLfatal() already called */ return 0; } if (s->version == DTLS1_BAD_VER) { msg += DTLS1_HM_HEADER_LENGTH; msg_len -= DTLS1_HM_HEADER_LENGTH; } if (!ssl3_finish_mac(s, msg, msg_len)) return 0; if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data, s->init_num + DTLS1_HM_HEADER_LENGTH, SSL_CONNECTION_GET_SSL(s), s->msg_callback_arg); end: *len = s->init_num; return 1; } /* * dtls1_max_handshake_message_len returns the maximum number of bytes * permitted in a DTLS handshake message for |s|. The minimum is 16KB, but * may be greater if the maximum certificate list size requires it. */ static size_t dtls1_max_handshake_message_len(const SSL_CONNECTION *s) { size_t max_len = DTLS1_HM_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH; if (max_len < s->max_cert_list) return s->max_cert_list; return max_len; } static int dtls1_preprocess_fragment(SSL_CONNECTION *s, struct hm_header_st *msg_hdr) { size_t frag_off, frag_len, msg_len; msg_len = msg_hdr->msg_len; frag_off = msg_hdr->frag_off; frag_len = msg_hdr->frag_len; /* sanity checking */ if ((frag_off + frag_len) > msg_len || msg_len > dtls1_max_handshake_message_len(s)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE); return 0; } if (s->d1->r_msg_hdr.frag_off == 0) { /* first fragment */ /* * msg_len is limited to 2^24, but is effectively checked against * dtls_max_handshake_message_len(s) above */ if (!BUF_MEM_grow_clean(s->init_buf, msg_len + DTLS1_HM_HEADER_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BUF_LIB); return 0; } s->s3.tmp.message_size = msg_len; s->d1->r_msg_hdr.msg_len = msg_len; s->s3.tmp.message_type = msg_hdr->type; s->d1->r_msg_hdr.type = msg_hdr->type; s->d1->r_msg_hdr.seq = msg_hdr->seq; } else if (msg_len != s->d1->r_msg_hdr.msg_len) { /* * They must be playing with us! BTW, failure to enforce upper limit * would open possibility for buffer overrun. */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE); return 0; } return 1; } /* * Returns 1 if there is a buffered fragment available, 0 if not, or -1 on a * fatal error. */ static int dtls1_retrieve_buffered_fragment(SSL_CONNECTION *s, size_t *len) { /*- * (0) check whether the desired fragment is available * if so: * (1) copy over the fragment to s->init_buf->data[] * (2) update s->init_num */ pitem *item; piterator iter; hm_fragment *frag; int ret; int chretran = 0; iter = pqueue_iterator(s->d1->buffered_messages); do { item = pqueue_next(&iter); if (item == NULL) return 0; frag = (hm_fragment *)item->data; if (frag->msg_header.seq < s->d1->handshake_read_seq) { pitem *next; hm_fragment *nextfrag; if (!s->server || frag->msg_header.seq != 0 || s->d1->handshake_read_seq != 1 || s->statem.hand_state != DTLS_ST_SW_HELLO_VERIFY_REQUEST) { /* * This is a stale message that has been buffered so clear it. * It is safe to pop this message from the queue even though * we have an active iterator */ pqueue_pop(s->d1->buffered_messages); dtls1_hm_fragment_free(frag); pitem_free(item); item = NULL; frag = NULL; } else { /* * We have fragments for a ClientHello without a cookie, * even though we have sent a HelloVerifyRequest. It is possible * that the HelloVerifyRequest got lost and this is a * retransmission of the original ClientHello */ next = pqueue_next(&iter); if (next != NULL) { nextfrag = (hm_fragment *)next->data; if (nextfrag->msg_header.seq == s->d1->handshake_read_seq) { /* * We have fragments for both a ClientHello without * cookie and one with. Ditch the one without. */ pqueue_pop(s->d1->buffered_messages); dtls1_hm_fragment_free(frag); pitem_free(item); item = next; frag = nextfrag; } else { chretran = 1; } } else { chretran = 1; } } } } while (item == NULL); /* Don't return if reassembly still in progress */ if (frag->reassembly != NULL) return 0; if (s->d1->handshake_read_seq == frag->msg_header.seq || chretran) { size_t frag_len = frag->msg_header.frag_len; pqueue_pop(s->d1->buffered_messages); /* Calls SSLfatal() as required */ ret = dtls1_preprocess_fragment(s, &frag->msg_header); if (ret && frag->msg_header.frag_len > 0) { unsigned char *p = (unsigned char *)s->init_buf->data + DTLS1_HM_HEADER_LENGTH; memcpy(&p[frag->msg_header.frag_off], frag->fragment, frag->msg_header.frag_len); } dtls1_hm_fragment_free(frag); pitem_free(item); if (ret) { if (chretran) { /* * We got a new ClientHello with a message sequence of 0. * Reset the read/write sequences back to the beginning. * We process it like this is the first time we've seen a * ClientHello from the client. */ s->d1->handshake_read_seq = 0; s->d1->next_handshake_write_seq = 0; } *len = frag_len; return 1; } /* Fatal error */ s->init_num = 0; return -1; } else { return 0; } } static int dtls1_reassemble_fragment(SSL_CONNECTION *s, const struct hm_header_st *msg_hdr) { hm_fragment *frag = NULL; pitem *item = NULL; int i = -1, is_complete; unsigned char seq64be[8]; size_t frag_len = msg_hdr->frag_len; size_t readbytes; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len || msg_hdr->msg_len > dtls1_max_handshake_message_len(s)) goto err; if (frag_len == 0) { return DTLS1_HM_FRAGMENT_RETRY; } /* Try to find item in queue */ memset(seq64be, 0, sizeof(seq64be)); seq64be[6] = (unsigned char)(msg_hdr->seq >> 8); seq64be[7] = (unsigned char)msg_hdr->seq; item = pqueue_find(s->d1->buffered_messages, seq64be); if (item == NULL) { frag = dtls1_hm_fragment_new(msg_hdr->msg_len, 1); if (frag == NULL) goto err; memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr)); frag->msg_header.frag_len = frag->msg_header.msg_len; frag->msg_header.frag_off = 0; } else { frag = (hm_fragment *)item->data; if (frag->msg_header.msg_len != msg_hdr->msg_len) { item = NULL; frag = NULL; goto err; } } /* * If message is already reassembled, this must be a retransmit and can * be dropped. In this case item != NULL and so frag does not need to be * freed. */ if (frag->reassembly == NULL) { unsigned char devnull[256]; while (frag_len) { i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, devnull, frag_len > sizeof(devnull) ? sizeof(devnull) : frag_len, 0, &readbytes); if (i <= 0) goto err; frag_len -= readbytes; } return DTLS1_HM_FRAGMENT_RETRY; } /* read the body of the fragment (header has already been read */ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, frag->fragment + msg_hdr->frag_off, frag_len, 0, &readbytes); if (i <= 0 || readbytes != frag_len) i = -1; if (i <= 0) goto err; RSMBLY_BITMASK_MARK(frag->reassembly, (long)msg_hdr->frag_off, (long)(msg_hdr->frag_off + frag_len)); if (!ossl_assert(msg_hdr->msg_len > 0)) goto err; RSMBLY_BITMASK_IS_COMPLETE(frag->reassembly, (long)msg_hdr->msg_len, is_complete); if (is_complete) { OPENSSL_free(frag->reassembly); frag->reassembly = NULL; } if (item == NULL) { item = pitem_new(seq64be, frag); if (item == NULL) { i = -1; goto err; } item = pqueue_insert(s->d1->buffered_messages, item); /* * pqueue_insert fails iff a duplicate item is inserted. However, * |item| cannot be a duplicate. If it were, |pqueue_find|, above, * would have returned it and control would never have reached this * branch. */ if (!ossl_assert(item != NULL)) goto err; } return DTLS1_HM_FRAGMENT_RETRY; err: if (item == NULL) dtls1_hm_fragment_free(frag); return -1; } static int dtls1_process_out_of_seq_message(SSL_CONNECTION *s, const struct hm_header_st *msg_hdr) { int i = -1; hm_fragment *frag = NULL; pitem *item = NULL; unsigned char seq64be[8]; size_t frag_len = msg_hdr->frag_len; size_t readbytes; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len) goto err; /* Try to find item in queue, to prevent duplicate entries */ memset(seq64be, 0, sizeof(seq64be)); seq64be[6] = (unsigned char)(msg_hdr->seq >> 8); seq64be[7] = (unsigned char)msg_hdr->seq; item = pqueue_find(s->d1->buffered_messages, seq64be); /* * If we already have an entry and this one is a fragment, don't discard * it and rather try to reassemble it. */ if (item != NULL && frag_len != msg_hdr->msg_len) item = NULL; /* * Discard the message if sequence number was already there, is too far * in the future, already in the queue or if we received a FINISHED * before the SERVER_HELLO, which then must be a stale retransmit. */ if (msg_hdr->seq <= s->d1->handshake_read_seq || msg_hdr->seq > s->d1->handshake_read_seq + 10 || item != NULL || (s->d1->handshake_read_seq == 0 && msg_hdr->type == SSL3_MT_FINISHED)) { unsigned char devnull[256]; while (frag_len) { i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, devnull, frag_len > sizeof(devnull) ? sizeof(devnull) : frag_len, 0, &readbytes); if (i <= 0) goto err; frag_len -= readbytes; } } else { if (frag_len != msg_hdr->msg_len) { return dtls1_reassemble_fragment(s, msg_hdr); } if (frag_len > dtls1_max_handshake_message_len(s)) goto err; frag = dtls1_hm_fragment_new(frag_len, 0); if (frag == NULL) goto err; memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr)); if (frag_len) { /* * read the body of the fragment (header has already been read */ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, frag->fragment, frag_len, 0, &readbytes); if (i<=0 || readbytes != frag_len) i = -1; if (i <= 0) goto err; } item = pitem_new(seq64be, frag); if (item == NULL) goto err; item = pqueue_insert(s->d1->buffered_messages, item); /* * pqueue_insert fails iff a duplicate item is inserted. However, * |item| cannot be a duplicate. If it were, |pqueue_find|, above, * would have returned it. Then, either |frag_len| != * |msg_hdr->msg_len| in which case |item| is set to NULL and it will * have been processed with |dtls1_reassemble_fragment|, above, or * the record will have been discarded. */ if (!ossl_assert(item != NULL)) goto err; } return DTLS1_HM_FRAGMENT_RETRY; err: if (item == NULL) dtls1_hm_fragment_free(frag); return 0; } static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype, size_t *len) { unsigned char wire[DTLS1_HM_HEADER_LENGTH]; size_t mlen, frag_off, frag_len; int i, ret; uint8_t recvd_type; struct hm_header_st msg_hdr; size_t readbytes; SSL *ssl = SSL_CONNECTION_GET_SSL(s); int chretran = 0; *errtype = 0; redo: /* see if we have the required fragment already */ ret = dtls1_retrieve_buffered_fragment(s, &frag_len); if (ret < 0) { /* SSLfatal() already called */ return 0; } if (ret > 0) { s->init_num = frag_len; *len = frag_len; return 1; } /* read handshake message header */ i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, &recvd_type, wire, DTLS1_HM_HEADER_LENGTH, 0, &readbytes); if (i <= 0) { /* nbio, or an error */ s->rwstate = SSL_READING; *len = 0; return 0; } if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) { if (wire[0] != SSL3_MT_CCS) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_CHANGE_CIPHER_SPEC); goto f_err; } memcpy(s->init_buf->data, wire, readbytes); s->init_num = readbytes - 1; s->init_msg = s->init_buf->data + 1; s->s3.tmp.message_type = SSL3_MT_CHANGE_CIPHER_SPEC; s->s3.tmp.message_size = readbytes - 1; *len = readbytes - 1; return 1; } /* Handshake fails if message header is incomplete */ if (readbytes != DTLS1_HM_HEADER_LENGTH) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto f_err; } /* parse the message fragment header */ dtls1_get_message_header(wire, &msg_hdr); mlen = msg_hdr.msg_len; frag_off = msg_hdr.frag_off; frag_len = msg_hdr.frag_len; /* * We must have at least frag_len bytes left in the record to be read. * Fragments must not span records. */ if (frag_len > s->rlayer.tlsrecs[s->rlayer.curr_rec].length) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_LENGTH); goto f_err; } /* * if this is a future (or stale) message it gets buffered * (or dropped)--no further processing at this time * While listening, we accept seq 1 (ClientHello with cookie) * although we're still expecting seq 0 (ClientHello) */ if (msg_hdr.seq != s->d1->handshake_read_seq) { if (!s->server || msg_hdr.seq != 0 || s->d1->handshake_read_seq != 1 || wire[0] != SSL3_MT_CLIENT_HELLO || s->statem.hand_state != DTLS_ST_SW_HELLO_VERIFY_REQUEST) { *errtype = dtls1_process_out_of_seq_message(s, &msg_hdr); return 0; } /* * We received a ClientHello and sent back a HelloVerifyRequest. We * now seem to have received a retransmitted initial ClientHello. That * is allowed (possibly our HelloVerifyRequest got lost). */ chretran = 1; } if (frag_len && frag_len < mlen) { *errtype = dtls1_reassemble_fragment(s, &msg_hdr); return 0; } if (!s->server && s->d1->r_msg_hdr.frag_off == 0 && s->statem.hand_state != TLS_ST_OK && wire[0] == SSL3_MT_HELLO_REQUEST) { /* * The server may always send 'Hello Request' messages -- we are * doing a handshake anyway now, so ignore them if their format is * correct. Does not count for 'Finished' MAC. */ if (wire[1] == 0 && wire[2] == 0 && wire[3] == 0) { if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, wire, DTLS1_HM_HEADER_LENGTH, ssl, s->msg_callback_arg); s->init_num = 0; goto redo; } else { /* Incorrectly formatted Hello request */ SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto f_err; } } if (!dtls1_preprocess_fragment(s, &msg_hdr)) { /* SSLfatal() already called */ goto f_err; } if (frag_len > 0) { unsigned char *p = (unsigned char *)s->init_buf->data + DTLS1_HM_HEADER_LENGTH; i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL, &p[frag_off], frag_len, 0, &readbytes); /* * This shouldn't ever fail due to NBIO because we already checked * that we have enough data in the record */ if (i <= 0) { s->rwstate = SSL_READING; *len = 0; return 0; } } else { readbytes = 0; } /* * XDTLS: an incorrectly formatted fragment should cause the handshake * to fail */ if (readbytes != frag_len) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_LENGTH); goto f_err; } if (chretran) { /* * We got a new ClientHello with a message sequence of 0. * Reset the read/write sequences back to the beginning. * We process it like this is the first time we've seen a ClientHello * from the client. */ s->d1->handshake_read_seq = 0; s->d1->next_handshake_write_seq = 0; } /* * Note that s->init_num is *not* used as current offset in * s->init_buf->data, but as a counter summing up fragments' lengths: as * soon as they sum up to handshake packet length, we assume we have got * all the fragments. */ *len = s->init_num = frag_len; return 1; f_err: s->init_num = 0; *len = 0; return 0; } /*- * for these 2 messages, we need to * ssl->session->read_sym_enc assign * ssl->session->read_compression assign * ssl->session->read_hash assign */ CON_FUNC_RETURN dtls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt) { if (s->version == DTLS1_BAD_VER) { s->d1->next_handshake_write_seq++; if (!WPACKET_put_bytes_u16(pkt, s->d1->handshake_write_seq)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } return CON_FUNC_SUCCESS; } #ifndef OPENSSL_NO_SCTP /* * Wait for a dry event. Should only be called at a point in the handshake * where we are not expecting any data from the peer except an alert. */ WORK_STATE dtls_wait_for_dry(SSL_CONNECTION *s) { int ret, errtype; size_t len; SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* read app data until dry event */ ret = BIO_dgram_sctp_wait_for_dry(SSL_get_wbio(ssl)); if (ret < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } if (ret == 0) { /* * We're not expecting any more messages from the peer at this point - * but we could get an alert. If an alert is waiting then we will never * return successfully. Therefore we attempt to read a message. This * should never succeed but will process any waiting alerts. */ if (dtls_get_reassembled_message(s, &errtype, &len)) { /* The call succeeded! This should never happen */ SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); return WORK_ERROR; } s->s3.in_read_app_data = 2; s->rwstate = SSL_READING; BIO_clear_retry_flags(SSL_get_rbio(ssl)); BIO_set_retry_read(SSL_get_rbio(ssl)); return WORK_MORE_A; } return WORK_FINISHED_CONTINUE; } #endif int dtls1_read_failed(SSL_CONNECTION *s, int code) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (code > 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!dtls1_is_timer_expired(s) || ossl_statem_in_error(s)) { /* * not a timeout, none of our business, let higher layers handle * this. in fact it's probably an error */ return code; } /* done, no need to send a retransmit */ if (!SSL_in_init(ssl)) { BIO_set_flags(SSL_get_rbio(ssl), BIO_FLAGS_READ); return code; } return dtls1_handle_timeout(s); } int dtls1_get_queue_priority(unsigned short seq, int is_ccs) { /* * The index of the retransmission queue actually is the message sequence * number, since the queue only contains messages of a single handshake. * However, the ChangeCipherSpec has no message sequence number and so * using only the sequence will result in the CCS and Finished having the * same index. To prevent this, the sequence number is multiplied by 2. * In case of a CCS 1 is subtracted. This does not only differ CSS and * Finished, it also maintains the order of the index (important for * priority queues) and fits in the unsigned short variable. */ return seq * 2 - is_ccs; } int dtls1_retransmit_buffered_messages(SSL_CONNECTION *s) { pqueue *sent = s->d1->sent_messages; piterator iter; pitem *item; hm_fragment *frag; int found = 0; iter = pqueue_iterator(sent); for (item = pqueue_next(&iter); item != NULL; item = pqueue_next(&iter)) { frag = (hm_fragment *)item->data; if (dtls1_retransmit_message(s, (unsigned short) dtls1_get_queue_priority (frag->msg_header.seq, frag->msg_header.is_ccs), &found) <= 0) return -1; } return 1; } int dtls1_buffer_message(SSL_CONNECTION *s, int is_ccs) { pitem *item; hm_fragment *frag; unsigned char seq64be[8]; /* * this function is called immediately after a message has been * serialized */ if (!ossl_assert(s->init_off == 0)) return 0; frag = dtls1_hm_fragment_new(s->init_num, 0); if (frag == NULL) return 0; memcpy(frag->fragment, s->init_buf->data, s->init_num); if (is_ccs) { /* For DTLS1_BAD_VER the header length is non-standard */ if (!ossl_assert(s->d1->w_msg_hdr.msg_len + ((s->version == DTLS1_BAD_VER) ? 3 : DTLS1_CCS_HEADER_LENGTH) == (unsigned int)s->init_num)) { dtls1_hm_fragment_free(frag); return 0; } } else { if (!ossl_assert(s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH == (unsigned int)s->init_num)) { dtls1_hm_fragment_free(frag); return 0; } } frag->msg_header.msg_len = s->d1->w_msg_hdr.msg_len; frag->msg_header.seq = s->d1->w_msg_hdr.seq; frag->msg_header.type = s->d1->w_msg_hdr.type; frag->msg_header.frag_off = 0; frag->msg_header.frag_len = s->d1->w_msg_hdr.msg_len; frag->msg_header.is_ccs = is_ccs; /* save current state */ frag->msg_header.saved_retransmit_state.wrlmethod = s->rlayer.wrlmethod; frag->msg_header.saved_retransmit_state.wrl = s->rlayer.wrl; memset(seq64be, 0, sizeof(seq64be)); seq64be[6] = (unsigned char)(dtls1_get_queue_priority(frag->msg_header.seq, frag->msg_header.is_ccs) >> 8); seq64be[7] = (unsigned char)(dtls1_get_queue_priority(frag->msg_header.seq, frag->msg_header.is_ccs)); item = pitem_new(seq64be, frag); if (item == NULL) { dtls1_hm_fragment_free(frag); return 0; } pqueue_insert(s->d1->sent_messages, item); return 1; } int dtls1_retransmit_message(SSL_CONNECTION *s, unsigned short seq, int *found) { int ret; /* XDTLS: for now assuming that read/writes are blocking */ pitem *item; hm_fragment *frag; unsigned long header_length; unsigned char seq64be[8]; struct dtls1_retransmit_state saved_state; /* XDTLS: the requested message ought to be found, otherwise error */ memset(seq64be, 0, sizeof(seq64be)); seq64be[6] = (unsigned char)(seq >> 8); seq64be[7] = (unsigned char)seq; item = pqueue_find(s->d1->sent_messages, seq64be); if (item == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); *found = 0; return 0; } *found = 1; frag = (hm_fragment *)item->data; if (frag->msg_header.is_ccs) header_length = DTLS1_CCS_HEADER_LENGTH; else header_length = DTLS1_HM_HEADER_LENGTH; memcpy(s->init_buf->data, frag->fragment, frag->msg_header.msg_len + header_length); s->init_num = frag->msg_header.msg_len + header_length; dtls1_set_message_header_int(s, frag->msg_header.type, frag->msg_header.msg_len, frag->msg_header.seq, 0, frag->msg_header.frag_len); /* save current state */ saved_state.wrlmethod = s->rlayer.wrlmethod; saved_state.wrl = s->rlayer.wrl; s->d1->retransmitting = 1; /* restore state in which the message was originally sent */ s->rlayer.wrlmethod = frag->msg_header.saved_retransmit_state.wrlmethod; s->rlayer.wrl = frag->msg_header.saved_retransmit_state.wrl; /* * The old wrl may be still pointing at an old BIO. Update it to what we're * using now. */ s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio); ret = dtls1_do_write(s, frag->msg_header.is_ccs ? SSL3_RT_CHANGE_CIPHER_SPEC : SSL3_RT_HANDSHAKE); /* restore current state */ s->rlayer.wrlmethod = saved_state.wrlmethod; s->rlayer.wrl = saved_state.wrl; s->d1->retransmitting = 0; (void)BIO_flush(s->wbio); return ret; } void dtls1_set_message_header(SSL_CONNECTION *s, unsigned char mt, size_t len, size_t frag_off, size_t frag_len) { if (frag_off == 0) { s->d1->handshake_write_seq = s->d1->next_handshake_write_seq; s->d1->next_handshake_write_seq++; } dtls1_set_message_header_int(s, mt, len, s->d1->handshake_write_seq, frag_off, frag_len); } /* don't actually do the writing, wait till the MTU has been retrieved */ static void dtls1_set_message_header_int(SSL_CONNECTION *s, unsigned char mt, size_t len, unsigned short seq_num, size_t frag_off, size_t frag_len) { struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr; msg_hdr->type = mt; msg_hdr->msg_len = len; msg_hdr->seq = seq_num; msg_hdr->frag_off = frag_off; msg_hdr->frag_len = frag_len; } static void dtls1_fix_message_header(SSL_CONNECTION *s, size_t frag_off, size_t frag_len) { struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr; msg_hdr->frag_off = frag_off; msg_hdr->frag_len = frag_len; } static unsigned char *dtls1_write_message_header(SSL_CONNECTION *s, unsigned char *p) { struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr; *p++ = msg_hdr->type; l2n3(msg_hdr->msg_len, p); s2n(msg_hdr->seq, p); l2n3(msg_hdr->frag_off, p); l2n3(msg_hdr->frag_len, p); return p; } void dtls1_get_message_header(const unsigned char *data, struct hm_header_st *msg_hdr) { memset(msg_hdr, 0, sizeof(*msg_hdr)); msg_hdr->type = *(data++); n2l3(data, msg_hdr->msg_len); n2s(data, msg_hdr->seq); n2l3(data, msg_hdr->frag_off); n2l3(data, msg_hdr->frag_len); } int dtls1_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype) { unsigned char *header; if (htype == SSL3_MT_CHANGE_CIPHER_SPEC) { s->d1->handshake_write_seq = s->d1->next_handshake_write_seq; dtls1_set_message_header_int(s, SSL3_MT_CCS, 0, s->d1->handshake_write_seq, 0, 0); if (!WPACKET_put_bytes_u8(pkt, SSL3_MT_CCS)) return 0; } else { dtls1_set_message_header(s, htype, 0, 0, 0); /* * We allocate space at the start for the message header. This gets * filled in later */ if (!WPACKET_allocate_bytes(pkt, DTLS1_HM_HEADER_LENGTH, &header) || !WPACKET_start_sub_packet(pkt)) return 0; } return 1; } int dtls1_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype) { size_t msglen; if ((htype != SSL3_MT_CHANGE_CIPHER_SPEC && !WPACKET_close(pkt)) || !WPACKET_get_length(pkt, &msglen) || msglen > INT_MAX) return 0; if (htype != SSL3_MT_CHANGE_CIPHER_SPEC) { s->d1->w_msg_hdr.msg_len = msglen - DTLS1_HM_HEADER_LENGTH; s->d1->w_msg_hdr.frag_len = msglen - DTLS1_HM_HEADER_LENGTH; } s->init_num = (int)msglen; s->init_off = 0; if (htype != DTLS1_MT_HELLO_VERIFY_REQUEST) { /* Buffer the message to handle re-xmits */ if (!dtls1_buffer_message(s, htype == SSL3_MT_CHANGE_CIPHER_SPEC ? 1 : 0)) return 0; } return 1; }

./openssl/ssl/statem/statem_srvr.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include "../ssl_local.h" #include "statem_local.h" #include "internal/constant_time.h" #include "internal/cryptlib.h" #include <openssl/buffer.h> #include <openssl/rand.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/x509.h> #include <openssl/dh.h> #include <openssl/rsa.h> #include <openssl/bn.h> #include <openssl/md5.h> #include <openssl/trace.h> #include <openssl/core_names.h> #include <openssl/asn1t.h> #include <openssl/comp.h> #define TICKET_NONCE_SIZE 8 typedef struct { ASN1_TYPE *kxBlob; ASN1_TYPE *opaqueBlob; } GOST_KX_MESSAGE; DECLARE_ASN1_FUNCTIONS(GOST_KX_MESSAGE) ASN1_SEQUENCE(GOST_KX_MESSAGE) = { ASN1_SIMPLE(GOST_KX_MESSAGE, kxBlob, ASN1_ANY), ASN1_OPT(GOST_KX_MESSAGE, opaqueBlob, ASN1_ANY), } ASN1_SEQUENCE_END(GOST_KX_MESSAGE) IMPLEMENT_ASN1_FUNCTIONS(GOST_KX_MESSAGE) static CON_FUNC_RETURN tls_construct_encrypted_extensions(SSL_CONNECTION *s, WPACKET *pkt); static ossl_inline int received_client_cert(const SSL_CONNECTION *sc) { return sc->session->peer_rpk != NULL || sc->session->peer != NULL; } /* * ossl_statem_server13_read_transition() encapsulates the logic for the allowed * handshake state transitions when a TLSv1.3 server is reading messages from * the client. The message type that the client has sent is provided in |mt|. * The current state is in |s->statem.hand_state|. * * Return values are 1 for success (transition allowed) and 0 on error * (transition not allowed) */ static int ossl_statem_server13_read_transition(SSL_CONNECTION *s, int mt) { OSSL_STATEM *st = &s->statem; /* * Note: There is no case for TLS_ST_BEFORE because at that stage we have * not negotiated TLSv1.3 yet, so that case is handled by * ossl_statem_server_read_transition() */ switch (st->hand_state) { default: break; case TLS_ST_EARLY_DATA: if (s->hello_retry_request == SSL_HRR_PENDING) { if (mt == SSL3_MT_CLIENT_HELLO) { st->hand_state = TLS_ST_SR_CLNT_HELLO; return 1; } break; } else if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) { if (mt == SSL3_MT_END_OF_EARLY_DATA) { st->hand_state = TLS_ST_SR_END_OF_EARLY_DATA; return 1; } break; } /* Fall through */ case TLS_ST_SR_END_OF_EARLY_DATA: case TLS_ST_SW_FINISHED: if (s->s3.tmp.cert_request) { if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_SR_CERT; return 1; } #ifndef OPENSSL_NO_COMP_ALG if (mt == SSL3_MT_COMPRESSED_CERTIFICATE && s->ext.compress_certificate_sent) { st->hand_state = TLS_ST_SR_COMP_CERT; return 1; } #endif } else { if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } } break; case TLS_ST_SR_COMP_CERT: case TLS_ST_SR_CERT: if (!received_client_cert(s)) { if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } } else { if (mt == SSL3_MT_CERTIFICATE_VERIFY) { st->hand_state = TLS_ST_SR_CERT_VRFY; return 1; } } break; case TLS_ST_SR_CERT_VRFY: if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } break; case TLS_ST_OK: /* * Its never ok to start processing handshake messages in the middle of * early data (i.e. before we've received the end of early data alert) */ if (s->early_data_state == SSL_EARLY_DATA_READING) break; if (s->post_handshake_auth == SSL_PHA_REQUESTED) { if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_SR_CERT; return 1; } #ifndef OPENSSL_NO_COMP_ALG if (mt == SSL3_MT_COMPRESSED_CERTIFICATE && s->ext.compress_certificate_sent) { st->hand_state = TLS_ST_SR_COMP_CERT; return 1; } #endif } if (mt == SSL3_MT_KEY_UPDATE && !SSL_IS_QUIC_HANDSHAKE(s)) { st->hand_state = TLS_ST_SR_KEY_UPDATE; return 1; } break; } /* No valid transition found */ return 0; } /* * ossl_statem_server_read_transition() encapsulates the logic for the allowed * handshake state transitions when the server is reading messages from the * client. The message type that the client has sent is provided in |mt|. The * current state is in |s->statem.hand_state|. * * Return values are 1 for success (transition allowed) and 0 on error * (transition not allowed) */ int ossl_statem_server_read_transition(SSL_CONNECTION *s, int mt) { OSSL_STATEM *st = &s->statem; if (SSL_CONNECTION_IS_TLS13(s)) { if (!ossl_statem_server13_read_transition(s, mt)) goto err; return 1; } switch (st->hand_state) { default: break; case TLS_ST_BEFORE: case TLS_ST_OK: case DTLS_ST_SW_HELLO_VERIFY_REQUEST: if (mt == SSL3_MT_CLIENT_HELLO) { st->hand_state = TLS_ST_SR_CLNT_HELLO; return 1; } break; case TLS_ST_SW_SRVR_DONE: /* * If we get a CKE message after a ServerDone then either * 1) We didn't request a Certificate * OR * 2) If we did request one then * a) We allow no Certificate to be returned * AND * b) We are running SSL3 (in TLS1.0+ the client must return a 0 * list if we requested a certificate) */ if (mt == SSL3_MT_CLIENT_KEY_EXCHANGE) { if (s->s3.tmp.cert_request) { if (s->version == SSL3_VERSION) { if ((s->verify_mode & SSL_VERIFY_PEER) && (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) { /* * This isn't an unexpected message as such - we're just * not going to accept it because we require a client * cert. */ SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE); return 0; } st->hand_state = TLS_ST_SR_KEY_EXCH; return 1; } } else { st->hand_state = TLS_ST_SR_KEY_EXCH; return 1; } } else if (s->s3.tmp.cert_request) { if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_SR_CERT; return 1; } } break; case TLS_ST_SR_CERT: if (mt == SSL3_MT_CLIENT_KEY_EXCHANGE) { st->hand_state = TLS_ST_SR_KEY_EXCH; return 1; } break; case TLS_ST_SR_KEY_EXCH: /* * We should only process a CertificateVerify message if we have * received a Certificate from the client. If so then |s->session->peer| * will be non NULL. In some instances a CertificateVerify message is * not required even if the peer has sent a Certificate (e.g. such as in * the case of static DH). In that case |st->no_cert_verify| should be * set. */ if (!received_client_cert(s) || st->no_cert_verify) { if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { /* * For the ECDH ciphersuites when the client sends its ECDH * pub key in a certificate, the CertificateVerify message is * not sent. Also for GOST ciphersuites when the client uses * its key from the certificate for key exchange. */ st->hand_state = TLS_ST_SR_CHANGE; return 1; } } else { if (mt == SSL3_MT_CERTIFICATE_VERIFY) { st->hand_state = TLS_ST_SR_CERT_VRFY; return 1; } } break; case TLS_ST_SR_CERT_VRFY: if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_SR_CHANGE; return 1; } break; case TLS_ST_SR_CHANGE: #ifndef OPENSSL_NO_NEXTPROTONEG if (s->s3.npn_seen) { if (mt == SSL3_MT_NEXT_PROTO) { st->hand_state = TLS_ST_SR_NEXT_PROTO; return 1; } } else { #endif if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } #ifndef OPENSSL_NO_NEXTPROTONEG } #endif break; #ifndef OPENSSL_NO_NEXTPROTONEG case TLS_ST_SR_NEXT_PROTO: if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_SR_FINISHED; return 1; } break; #endif case TLS_ST_SW_FINISHED: if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_SR_CHANGE; return 1; } break; } err: /* No valid transition found */ if (SSL_CONNECTION_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) { BIO *rbio; /* * CCS messages don't have a message sequence number so this is probably * because of an out-of-order CCS. We'll just drop it. */ s->init_num = 0; s->rwstate = SSL_READING; rbio = SSL_get_rbio(SSL_CONNECTION_GET_SSL(s)); BIO_clear_retry_flags(rbio); BIO_set_retry_read(rbio); return 0; } SSLfatal(s, SSL3_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); return 0; } /* * Should we send a ServerKeyExchange message? * * Valid return values are: * 1: Yes * 0: No */ static int send_server_key_exchange(SSL_CONNECTION *s) { unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey; /* * only send a ServerKeyExchange if DH or fortezza but we have a * sign only certificate PSK: may send PSK identity hints For * ECC ciphersuites, we send a serverKeyExchange message only if * the cipher suite is either ECDH-anon or ECDHE. In other cases, * the server certificate contains the server's public key for * key exchange. */ if (alg_k & (SSL_kDHE | SSL_kECDHE) /* * PSK: send ServerKeyExchange if PSK identity hint if * provided */ #ifndef OPENSSL_NO_PSK /* Only send SKE if we have identity hint for plain PSK */ || ((alg_k & (SSL_kPSK | SSL_kRSAPSK)) && s->cert->psk_identity_hint) /* For other PSK always send SKE */ || (alg_k & (SSL_PSK & (SSL_kDHEPSK | SSL_kECDHEPSK))) #endif #ifndef OPENSSL_NO_SRP /* SRP: send ServerKeyExchange */ || (alg_k & SSL_kSRP) #endif ) { return 1; } return 0; } /* * Used to determine if we should send a CompressedCertificate message * * Returns the algorithm to use, TLSEXT_comp_cert_none means no compression */ static int get_compressed_certificate_alg(SSL_CONNECTION *sc) { #ifndef OPENSSL_NO_COMP_ALG int *alg = sc->ext.compress_certificate_from_peer; if (sc->s3.tmp.cert == NULL) return TLSEXT_comp_cert_none; for (; *alg != TLSEXT_comp_cert_none; alg++) { if (sc->s3.tmp.cert->comp_cert[*alg] != NULL) return *alg; } #endif return TLSEXT_comp_cert_none; } /* * Should we send a CertificateRequest message? * * Valid return values are: * 1: Yes * 0: No */ int send_certificate_request(SSL_CONNECTION *s) { if ( /* don't request cert unless asked for it: */ s->verify_mode & SSL_VERIFY_PEER /* * don't request if post-handshake-only unless doing * post-handshake in TLSv1.3: */ && (!SSL_CONNECTION_IS_TLS13(s) || !(s->verify_mode & SSL_VERIFY_POST_HANDSHAKE) || s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) /* * if SSL_VERIFY_CLIENT_ONCE is set, don't request cert * a second time: */ && (s->certreqs_sent < 1 || !(s->verify_mode & SSL_VERIFY_CLIENT_ONCE)) /* * never request cert in anonymous ciphersuites (see * section "Certificate request" in SSL 3 drafts and in * RFC 2246): */ && (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL) /* * ... except when the application insists on * verification (against the specs, but statem_clnt.c accepts * this for SSL 3) */ || (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) /* don't request certificate for SRP auth */ && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aSRP) /* * With normal PSK Certificates and Certificate Requests * are omitted */ && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aPSK)) { return 1; } return 0; } static int do_compressed_cert(SSL_CONNECTION *sc) { /* If we negotiated RPK, we won't attempt to compress it */ return sc->ext.server_cert_type == TLSEXT_cert_type_x509 && get_compressed_certificate_alg(sc) != TLSEXT_comp_cert_none; } /* * ossl_statem_server13_write_transition() works out what handshake state to * move to next when a TLSv1.3 server is writing messages to be sent to the * client. */ static WRITE_TRAN ossl_statem_server13_write_transition(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; /* * No case for TLS_ST_BEFORE, because at that stage we have not negotiated * TLSv1.3 yet, so that is handled by ossl_statem_server_write_transition() */ switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; case TLS_ST_OK: if (s->key_update != SSL_KEY_UPDATE_NONE) { st->hand_state = TLS_ST_SW_KEY_UPDATE; return WRITE_TRAN_CONTINUE; } if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) { st->hand_state = TLS_ST_SW_CERT_REQ; return WRITE_TRAN_CONTINUE; } if (s->ext.extra_tickets_expected > 0) { st->hand_state = TLS_ST_SW_SESSION_TICKET; return WRITE_TRAN_CONTINUE; } /* Try to read from the client instead */ return WRITE_TRAN_FINISHED; case TLS_ST_SR_CLNT_HELLO: st->hand_state = TLS_ST_SW_SRVR_HELLO; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_SRVR_HELLO: if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0 && s->hello_retry_request != SSL_HRR_COMPLETE) st->hand_state = TLS_ST_SW_CHANGE; else if (s->hello_retry_request == SSL_HRR_PENDING) st->hand_state = TLS_ST_EARLY_DATA; else st->hand_state = TLS_ST_SW_ENCRYPTED_EXTENSIONS; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CHANGE: if (s->hello_retry_request == SSL_HRR_PENDING) st->hand_state = TLS_ST_EARLY_DATA; else st->hand_state = TLS_ST_SW_ENCRYPTED_EXTENSIONS; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: if (s->hit) st->hand_state = TLS_ST_SW_FINISHED; else if (send_certificate_request(s)) st->hand_state = TLS_ST_SW_CERT_REQ; else if (do_compressed_cert(s)) st->hand_state = TLS_ST_SW_COMP_CERT; else st->hand_state = TLS_ST_SW_CERT; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CERT_REQ: if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) { s->post_handshake_auth = SSL_PHA_REQUESTED; st->hand_state = TLS_ST_OK; } else if (do_compressed_cert(s)) { st->hand_state = TLS_ST_SW_COMP_CERT; } else { st->hand_state = TLS_ST_SW_CERT; } return WRITE_TRAN_CONTINUE; case TLS_ST_SW_COMP_CERT: case TLS_ST_SW_CERT: st->hand_state = TLS_ST_SW_CERT_VRFY; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CERT_VRFY: st->hand_state = TLS_ST_SW_FINISHED; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_FINISHED: st->hand_state = TLS_ST_EARLY_DATA; s->ts_msg_write = ossl_time_now(); return WRITE_TRAN_CONTINUE; case TLS_ST_EARLY_DATA: return WRITE_TRAN_FINISHED; case TLS_ST_SR_FINISHED: s->ts_msg_read = ossl_time_now(); /* * Technically we have finished the handshake at this point, but we're * going to remain "in_init" for now and write out any session tickets * immediately. */ if (s->post_handshake_auth == SSL_PHA_REQUESTED) { s->post_handshake_auth = SSL_PHA_EXT_RECEIVED; } else if (!s->ext.ticket_expected) { /* * If we're not going to renew the ticket then we just finish the * handshake at this point. */ st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } if (s->num_tickets > s->sent_tickets) st->hand_state = TLS_ST_SW_SESSION_TICKET; else st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_SR_KEY_UPDATE: case TLS_ST_SW_KEY_UPDATE: st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_SESSION_TICKET: /* In a resumption we only ever send a maximum of one new ticket. * Following an initial handshake we send the number of tickets we have * been configured for. */ if (!SSL_IS_FIRST_HANDSHAKE(s) && s->ext.extra_tickets_expected > 0) { return WRITE_TRAN_CONTINUE; } else if (s->hit || s->num_tickets <= s->sent_tickets) { /* We've written enough tickets out. */ st->hand_state = TLS_ST_OK; } return WRITE_TRAN_CONTINUE; } } /* * ossl_statem_server_write_transition() works out what handshake state to move * to next when the server is writing messages to be sent to the client. */ WRITE_TRAN ossl_statem_server_write_transition(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; /* * Note that before the ClientHello we don't know what version we are going * to negotiate yet, so we don't take this branch until later */ if (SSL_CONNECTION_IS_TLS13(s)) return ossl_statem_server13_write_transition(s); switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; case TLS_ST_OK: if (st->request_state == TLS_ST_SW_HELLO_REQ) { /* We must be trying to renegotiate */ st->hand_state = TLS_ST_SW_HELLO_REQ; st->request_state = TLS_ST_BEFORE; return WRITE_TRAN_CONTINUE; } /* Must be an incoming ClientHello */ if (!tls_setup_handshake(s)) { /* SSLfatal() already called */ return WRITE_TRAN_ERROR; } /* Fall through */ case TLS_ST_BEFORE: /* Just go straight to trying to read from the client */ return WRITE_TRAN_FINISHED; case TLS_ST_SW_HELLO_REQ: st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_SR_CLNT_HELLO: if (SSL_CONNECTION_IS_DTLS(s) && !s->d1->cookie_verified && (SSL_get_options(SSL_CONNECTION_GET_SSL(s)) & SSL_OP_COOKIE_EXCHANGE)) { st->hand_state = DTLS_ST_SW_HELLO_VERIFY_REQUEST; } else if (s->renegotiate == 0 && !SSL_IS_FIRST_HANDSHAKE(s)) { /* We must have rejected the renegotiation */ st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } else { st->hand_state = TLS_ST_SW_SRVR_HELLO; } return WRITE_TRAN_CONTINUE; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: return WRITE_TRAN_FINISHED; case TLS_ST_SW_SRVR_HELLO: if (s->hit) { if (s->ext.ticket_expected) st->hand_state = TLS_ST_SW_SESSION_TICKET; else st->hand_state = TLS_ST_SW_CHANGE; } else { /* Check if it is anon DH or anon ECDH, */ /* normal PSK or SRP */ if (!(s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP | SSL_aPSK))) { st->hand_state = TLS_ST_SW_CERT; } else if (send_server_key_exchange(s)) { st->hand_state = TLS_ST_SW_KEY_EXCH; } else if (send_certificate_request(s)) { st->hand_state = TLS_ST_SW_CERT_REQ; } else { st->hand_state = TLS_ST_SW_SRVR_DONE; } } return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CERT: if (s->ext.status_expected) { st->hand_state = TLS_ST_SW_CERT_STATUS; return WRITE_TRAN_CONTINUE; } /* Fall through */ case TLS_ST_SW_CERT_STATUS: if (send_server_key_exchange(s)) { st->hand_state = TLS_ST_SW_KEY_EXCH; return WRITE_TRAN_CONTINUE; } /* Fall through */ case TLS_ST_SW_KEY_EXCH: if (send_certificate_request(s)) { st->hand_state = TLS_ST_SW_CERT_REQ; return WRITE_TRAN_CONTINUE; } /* Fall through */ case TLS_ST_SW_CERT_REQ: st->hand_state = TLS_ST_SW_SRVR_DONE; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_SRVR_DONE: s->ts_msg_write = ossl_time_now(); return WRITE_TRAN_FINISHED; case TLS_ST_SR_FINISHED: s->ts_msg_read = ossl_time_now(); if (s->hit) { st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } else if (s->ext.ticket_expected) { st->hand_state = TLS_ST_SW_SESSION_TICKET; } else { st->hand_state = TLS_ST_SW_CHANGE; } return WRITE_TRAN_CONTINUE; case TLS_ST_SW_SESSION_TICKET: st->hand_state = TLS_ST_SW_CHANGE; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_CHANGE: st->hand_state = TLS_ST_SW_FINISHED; return WRITE_TRAN_CONTINUE; case TLS_ST_SW_FINISHED: if (s->hit) { return WRITE_TRAN_FINISHED; } st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } } /* * Perform any pre work that needs to be done prior to sending a message from * the server to the client. */ WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION *s, WORK_STATE wst) { OSSL_STATEM *st = &s->statem; SSL *ssl = SSL_CONNECTION_GET_SSL(s); switch (st->hand_state) { default: /* No pre work to be done */ break; case TLS_ST_SW_HELLO_REQ: s->shutdown = 0; if (SSL_CONNECTION_IS_DTLS(s)) dtls1_clear_sent_buffer(s); break; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: s->shutdown = 0; if (SSL_CONNECTION_IS_DTLS(s)) { dtls1_clear_sent_buffer(s); /* We don't buffer this message so don't use the timer */ st->use_timer = 0; } break; case TLS_ST_SW_SRVR_HELLO: if (SSL_CONNECTION_IS_DTLS(s)) { /* * Messages we write from now on should be buffered and * retransmitted if necessary, so we need to use the timer now */ st->use_timer = 1; } break; case TLS_ST_SW_SRVR_DONE: #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && BIO_dgram_is_sctp(SSL_get_wbio(ssl))) { /* Calls SSLfatal() as required */ return dtls_wait_for_dry(s); } #endif return WORK_FINISHED_CONTINUE; case TLS_ST_SW_SESSION_TICKET: if (SSL_CONNECTION_IS_TLS13(s) && s->sent_tickets == 0 && s->ext.extra_tickets_expected == 0) { /* * Actually this is the end of the handshake, but we're going * straight into writing the session ticket out. So we finish off * the handshake, but keep the various buffers active. * * Calls SSLfatal as required. */ return tls_finish_handshake(s, wst, 0, 0); } if (SSL_CONNECTION_IS_DTLS(s)) { /* * We're into the last flight. We don't retransmit the last flight * unless we need to, so we don't use the timer */ st->use_timer = 0; } break; case TLS_ST_SW_CHANGE: if (SSL_CONNECTION_IS_TLS13(s)) break; /* Writes to s->session are only safe for initial handshakes */ if (s->session->cipher == NULL) { s->session->cipher = s->s3.tmp.new_cipher; } else if (s->session->cipher != s->s3.tmp.new_cipher) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } if (!ssl->method->ssl3_enc->setup_key_block(s)) { /* SSLfatal() already called */ return WORK_ERROR; } if (SSL_CONNECTION_IS_DTLS(s)) { /* * We're into the last flight. We don't retransmit the last flight * unless we need to, so we don't use the timer. This might have * already been set to 0 if we sent a NewSessionTicket message, * but we'll set it again here in case we didn't. */ st->use_timer = 0; } return WORK_FINISHED_CONTINUE; case TLS_ST_EARLY_DATA: if (s->early_data_state != SSL_EARLY_DATA_ACCEPTING && (s->s3.flags & TLS1_FLAGS_STATELESS) == 0) return WORK_FINISHED_CONTINUE; /* Fall through */ case TLS_ST_OK: /* Calls SSLfatal() as required */ return tls_finish_handshake(s, wst, 1, 1); } return WORK_FINISHED_CONTINUE; } static ossl_inline int conn_is_closed(void) { switch (get_last_sys_error()) { #if defined(EPIPE) case EPIPE: return 1; #endif #if defined(ECONNRESET) case ECONNRESET: return 1; #endif #if defined(WSAECONNRESET) case WSAECONNRESET: return 1; #endif default: return 0; } } /* * Perform any work that needs to be done after sending a message from the * server to the client. */ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst) { OSSL_STATEM *st = &s->statem; SSL *ssl = SSL_CONNECTION_GET_SSL(s); s->init_num = 0; switch (st->hand_state) { default: /* No post work to be done */ break; case TLS_ST_SW_HELLO_REQ: if (statem_flush(s) != 1) return WORK_MORE_A; if (!ssl3_init_finished_mac(s)) { /* SSLfatal() already called */ return WORK_ERROR; } break; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: if (statem_flush(s) != 1) return WORK_MORE_A; /* HelloVerifyRequest resets Finished MAC */ if (s->version != DTLS1_BAD_VER && !ssl3_init_finished_mac(s)) { /* SSLfatal() already called */ return WORK_ERROR; } /* * The next message should be another ClientHello which we need to * treat like it was the first packet */ s->first_packet = 1; break; case TLS_ST_SW_SRVR_HELLO: if (SSL_CONNECTION_IS_TLS13(s) && s->hello_retry_request == SSL_HRR_PENDING) { if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0 && statem_flush(s) != 1) return WORK_MORE_A; break; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && s->hit) { unsigned char sctpauthkey[64]; char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)]; size_t labellen; /* * Add new shared key for SCTP-Auth, will be ignored if no * SCTP used. */ memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL, sizeof(DTLS1_SCTP_AUTH_LABEL)); /* Don't include the terminating zero. */ labellen = sizeof(labelbuffer) - 1; if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG) labellen += 1; if (SSL_export_keying_material(ssl, sctpauthkey, sizeof(sctpauthkey), labelbuffer, labellen, NULL, 0, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY, sizeof(sctpauthkey), sctpauthkey); } #endif if (!SSL_CONNECTION_IS_TLS13(s) || ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0 && s->hello_retry_request != SSL_HRR_COMPLETE)) break; /* Fall through */ case TLS_ST_SW_CHANGE: if (s->hello_retry_request == SSL_HRR_PENDING) { if (!statem_flush(s)) return WORK_MORE_A; break; } if (SSL_CONNECTION_IS_TLS13(s)) { if (!ssl->method->ssl3_enc->setup_key_block(s) || !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_WRITE)) { /* SSLfatal() already called */ return WORK_ERROR; } if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED && !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE |SSL3_CHANGE_CIPHER_SERVER_READ)) { /* SSLfatal() already called */ return WORK_ERROR; } /* * We don't yet know whether the next record we are going to receive * is an unencrypted alert, an encrypted alert, or an encrypted * handshake message. We temporarily tolerate unencrypted alerts. */ if (s->rlayer.rrlmethod->set_plain_alerts != NULL) s->rlayer.rrlmethod->set_plain_alerts(s->rlayer.rrl, 1); break; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && !s->hit) { /* * Change to new shared key of SCTP-Auth, will be ignored if * no SCTP used. */ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL); } #endif if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CHANGE_CIPHER_SERVER_WRITE)) { /* SSLfatal() already called */ return WORK_ERROR; } break; case TLS_ST_SW_SRVR_DONE: if (statem_flush(s) != 1) return WORK_MORE_A; break; case TLS_ST_SW_FINISHED: if (statem_flush(s) != 1) return WORK_MORE_A; #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && s->hit) { /* * Change to new shared key of SCTP-Auth, will be ignored if * no SCTP used. */ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL); } #endif if (SSL_CONNECTION_IS_TLS13(s)) { /* TLS 1.3 gets the secret size from the handshake md */ size_t dummy; if (!ssl->method->ssl3_enc->generate_master_secret(s, s->master_secret, s->handshake_secret, 0, &dummy) || !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_WRITE)) /* SSLfatal() already called */ return WORK_ERROR; } break; case TLS_ST_SW_CERT_REQ: if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) { if (statem_flush(s) != 1) return WORK_MORE_A; } else { if (!SSL_CONNECTION_IS_TLS13(s) || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0) s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none; } break; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: if (!s->hit && !send_certificate_request(s)) { if (!SSL_CONNECTION_IS_TLS13(s) || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0) s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none; } break; case TLS_ST_SW_KEY_UPDATE: if (statem_flush(s) != 1) return WORK_MORE_A; if (!tls13_update_key(s, 1)) { /* SSLfatal() already called */ return WORK_ERROR; } break; case TLS_ST_SW_SESSION_TICKET: clear_sys_error(); if (SSL_CONNECTION_IS_TLS13(s) && statem_flush(s) != 1) { if (SSL_get_error(ssl, 0) == SSL_ERROR_SYSCALL && conn_is_closed()) { /* * We ignore connection closed errors in TLSv1.3 when sending a * NewSessionTicket and behave as if we were successful. This is * so that we are still able to read data sent to us by a client * that closes soon after the end of the handshake without * waiting to read our post-handshake NewSessionTickets. */ s->rwstate = SSL_NOTHING; break; } return WORK_MORE_A; } break; } return WORK_FINISHED_CONTINUE; } /* * Get the message construction function and message type for sending from the * server * * Valid return values are: * 1: Success * 0: Error */ int ossl_statem_server_construct_message(SSL_CONNECTION *s, confunc_f *confunc, int *mt) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_STATE); return 0; case TLS_ST_SW_CHANGE: if (SSL_CONNECTION_IS_DTLS(s)) *confunc = dtls_construct_change_cipher_spec; else *confunc = tls_construct_change_cipher_spec; *mt = SSL3_MT_CHANGE_CIPHER_SPEC; break; case DTLS_ST_SW_HELLO_VERIFY_REQUEST: *confunc = dtls_construct_hello_verify_request; *mt = DTLS1_MT_HELLO_VERIFY_REQUEST; break; case TLS_ST_SW_HELLO_REQ: /* No construction function needed */ *confunc = NULL; *mt = SSL3_MT_HELLO_REQUEST; break; case TLS_ST_SW_SRVR_HELLO: *confunc = tls_construct_server_hello; *mt = SSL3_MT_SERVER_HELLO; break; case TLS_ST_SW_CERT: *confunc = tls_construct_server_certificate; *mt = SSL3_MT_CERTIFICATE; break; #ifndef OPENSSL_NO_COMP_ALG case TLS_ST_SW_COMP_CERT: *confunc = tls_construct_server_compressed_certificate; *mt = SSL3_MT_COMPRESSED_CERTIFICATE; break; #endif case TLS_ST_SW_CERT_VRFY: *confunc = tls_construct_cert_verify; *mt = SSL3_MT_CERTIFICATE_VERIFY; break; case TLS_ST_SW_KEY_EXCH: *confunc = tls_construct_server_key_exchange; *mt = SSL3_MT_SERVER_KEY_EXCHANGE; break; case TLS_ST_SW_CERT_REQ: *confunc = tls_construct_certificate_request; *mt = SSL3_MT_CERTIFICATE_REQUEST; break; case TLS_ST_SW_SRVR_DONE: *confunc = tls_construct_server_done; *mt = SSL3_MT_SERVER_DONE; break; case TLS_ST_SW_SESSION_TICKET: *confunc = tls_construct_new_session_ticket; *mt = SSL3_MT_NEWSESSION_TICKET; break; case TLS_ST_SW_CERT_STATUS: *confunc = tls_construct_cert_status; *mt = SSL3_MT_CERTIFICATE_STATUS; break; case TLS_ST_SW_FINISHED: *confunc = tls_construct_finished; *mt = SSL3_MT_FINISHED; break; case TLS_ST_EARLY_DATA: *confunc = NULL; *mt = SSL3_MT_DUMMY; break; case TLS_ST_SW_ENCRYPTED_EXTENSIONS: *confunc = tls_construct_encrypted_extensions; *mt = SSL3_MT_ENCRYPTED_EXTENSIONS; break; case TLS_ST_SW_KEY_UPDATE: *confunc = tls_construct_key_update; *mt = SSL3_MT_KEY_UPDATE; break; } return 1; } /* * Maximum size (excluding the Handshake header) of a ClientHello message, * calculated as follows: * * 2 + # client_version * 32 + # only valid length for random * 1 + # length of session_id * 32 + # maximum size for session_id * 2 + # length of cipher suites * 2^16-2 + # maximum length of cipher suites array * 1 + # length of compression_methods * 2^8-1 + # maximum length of compression methods * 2 + # length of extensions * 2^16-1 # maximum length of extensions */ #define CLIENT_HELLO_MAX_LENGTH 131396 #define CLIENT_KEY_EXCH_MAX_LENGTH 2048 #define NEXT_PROTO_MAX_LENGTH 514 /* * Returns the maximum allowed length for the current message that we are * reading. Excludes the message header. */ size_t ossl_statem_server_max_message_size(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen */ return 0; case TLS_ST_SR_CLNT_HELLO: return CLIENT_HELLO_MAX_LENGTH; case TLS_ST_SR_END_OF_EARLY_DATA: return END_OF_EARLY_DATA_MAX_LENGTH; case TLS_ST_SR_COMP_CERT: case TLS_ST_SR_CERT: return s->max_cert_list; case TLS_ST_SR_KEY_EXCH: return CLIENT_KEY_EXCH_MAX_LENGTH; case TLS_ST_SR_CERT_VRFY: return CERTIFICATE_VERIFY_MAX_LENGTH; #ifndef OPENSSL_NO_NEXTPROTONEG case TLS_ST_SR_NEXT_PROTO: return NEXT_PROTO_MAX_LENGTH; #endif case TLS_ST_SR_CHANGE: return CCS_MAX_LENGTH; case TLS_ST_SR_FINISHED: return FINISHED_MAX_LENGTH; case TLS_ST_SR_KEY_UPDATE: return KEY_UPDATE_MAX_LENGTH; } } /* * Process a message that the server has received from the client. */ MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION *s, PACKET *pkt) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; case TLS_ST_SR_CLNT_HELLO: return tls_process_client_hello(s, pkt); case TLS_ST_SR_END_OF_EARLY_DATA: return tls_process_end_of_early_data(s, pkt); case TLS_ST_SR_CERT: return tls_process_client_certificate(s, pkt); #ifndef OPENSSL_NO_COMP_ALG case TLS_ST_SR_COMP_CERT: return tls_process_client_compressed_certificate(s, pkt); #endif case TLS_ST_SR_KEY_EXCH: return tls_process_client_key_exchange(s, pkt); case TLS_ST_SR_CERT_VRFY: return tls_process_cert_verify(s, pkt); #ifndef OPENSSL_NO_NEXTPROTONEG case TLS_ST_SR_NEXT_PROTO: return tls_process_next_proto(s, pkt); #endif case TLS_ST_SR_CHANGE: return tls_process_change_cipher_spec(s, pkt); case TLS_ST_SR_FINISHED: return tls_process_finished(s, pkt); case TLS_ST_SR_KEY_UPDATE: return tls_process_key_update(s, pkt); } } /* * Perform any further processing required following the receipt of a message * from the client */ WORK_STATE ossl_statem_server_post_process_message(SSL_CONNECTION *s, WORK_STATE wst) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; case TLS_ST_SR_CLNT_HELLO: return tls_post_process_client_hello(s, wst); case TLS_ST_SR_KEY_EXCH: return tls_post_process_client_key_exchange(s, wst); } } #ifndef OPENSSL_NO_SRP /* Returns 1 on success, 0 for retryable error, -1 for fatal error */ static int ssl_check_srp_ext_ClientHello(SSL_CONNECTION *s) { int ret; int al = SSL_AD_UNRECOGNIZED_NAME; if ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) && (s->srp_ctx.TLS_ext_srp_username_callback != NULL)) { if (s->srp_ctx.login == NULL) { /* * RFC 5054 says SHOULD reject, we do so if There is no srp * login name */ SSLfatal(s, SSL_AD_UNKNOWN_PSK_IDENTITY, SSL_R_PSK_IDENTITY_NOT_FOUND); return -1; } else { ret = ssl_srp_server_param_with_username_intern(s, &al); if (ret < 0) return 0; if (ret == SSL3_AL_FATAL) { SSLfatal(s, al, al == SSL_AD_UNKNOWN_PSK_IDENTITY ? SSL_R_PSK_IDENTITY_NOT_FOUND : SSL_R_CLIENTHELLO_TLSEXT); return -1; } } } return 1; } #endif int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie, size_t cookie_len) { /* Always use DTLS 1.0 version: see RFC 6347 */ if (!WPACKET_put_bytes_u16(pkt, DTLS1_VERSION) || !WPACKET_sub_memcpy_u8(pkt, cookie, cookie_len)) return 0; return 1; } CON_FUNC_RETURN dtls_construct_hello_verify_request(SSL_CONNECTION *s, WPACKET *pkt) { unsigned int cookie_leni; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (sctx->app_gen_cookie_cb == NULL || sctx->app_gen_cookie_cb(SSL_CONNECTION_GET_SSL(s), s->d1->cookie, &cookie_leni) == 0 || cookie_leni > DTLS1_COOKIE_LENGTH) { SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_COOKIE_GEN_CALLBACK_FAILURE); return CON_FUNC_ERROR; } s->d1->cookie_len = cookie_leni; if (!dtls_raw_hello_verify_request(pkt, s->d1->cookie, s->d1->cookie_len)) { SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } /*- * ssl_check_for_safari attempts to fingerprint Safari using OS X * SecureTransport using the TLS extension block in |hello|. * Safari, since 10.6, sends exactly these extensions, in this order: * SNI, * elliptic_curves * ec_point_formats * signature_algorithms (for TLSv1.2 only) * * We wish to fingerprint Safari because they broke ECDHE-ECDSA support in 10.8, * but they advertise support. So enabling ECDHE-ECDSA ciphers breaks them. * Sadly we cannot differentiate 10.6, 10.7 and 10.8.4 (which work), from * 10.8..10.8.3 (which don't work). */ static void ssl_check_for_safari(SSL_CONNECTION *s, const CLIENTHELLO_MSG *hello) { static const unsigned char kSafariExtensionsBlock[] = { 0x00, 0x0a, /* elliptic_curves extension */ 0x00, 0x08, /* 8 bytes */ 0x00, 0x06, /* 6 bytes of curve ids */ 0x00, 0x17, /* P-256 */ 0x00, 0x18, /* P-384 */ 0x00, 0x19, /* P-521 */ 0x00, 0x0b, /* ec_point_formats */ 0x00, 0x02, /* 2 bytes */ 0x01, /* 1 point format */ 0x00, /* uncompressed */ /* The following is only present in TLS 1.2 */ 0x00, 0x0d, /* signature_algorithms */ 0x00, 0x0c, /* 12 bytes */ 0x00, 0x0a, /* 10 bytes */ 0x05, 0x01, /* SHA-384/RSA */ 0x04, 0x01, /* SHA-256/RSA */ 0x02, 0x01, /* SHA-1/RSA */ 0x04, 0x03, /* SHA-256/ECDSA */ 0x02, 0x03, /* SHA-1/ECDSA */ }; /* Length of the common prefix (first two extensions). */ static const size_t kSafariCommonExtensionsLength = 18; unsigned int type; PACKET sni, tmppkt; size_t ext_len; tmppkt = hello->extensions; if (!PACKET_forward(&tmppkt, 2) || !PACKET_get_net_2(&tmppkt, &type) || !PACKET_get_length_prefixed_2(&tmppkt, &sni)) { return; } if (type != TLSEXT_TYPE_server_name) return; ext_len = TLS1_get_client_version( SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION ? sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength; s->s3.is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock, ext_len); } #define RENEG_OPTIONS_OK(options) \ ((options & SSL_OP_NO_RENEGOTIATION) == 0 \ && (options & SSL_OP_ALLOW_CLIENT_RENEGOTIATION) != 0) MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt) { /* |cookie| will only be initialized for DTLS. */ PACKET session_id, compression, extensions, cookie; static const unsigned char null_compression = 0; CLIENTHELLO_MSG *clienthello = NULL; /* Check if this is actually an unexpected renegotiation ClientHello */ if (s->renegotiate == 0 && !SSL_IS_FIRST_HANDSHAKE(s)) { if (!ossl_assert(!SSL_CONNECTION_IS_TLS13(s))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!RENEG_OPTIONS_OK(s->options) || (!s->s3.send_connection_binding && (s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) == 0)) { ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION); return MSG_PROCESS_FINISHED_READING; } s->renegotiate = 1; s->new_session = 1; } clienthello = OPENSSL_zalloc(sizeof(*clienthello)); if (clienthello == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* * First, parse the raw ClientHello data into the CLIENTHELLO_MSG structure. */ clienthello->isv2 = RECORD_LAYER_is_sslv2_record(&s->rlayer); PACKET_null_init(&cookie); if (clienthello->isv2) { unsigned int mt; if (!SSL_IS_FIRST_HANDSHAKE(s) || s->hello_retry_request != SSL_HRR_NONE) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto err; } /*- * An SSLv3/TLSv1 backwards-compatible CLIENT-HELLO in an SSLv2 * header is sent directly on the wire, not wrapped as a TLS * record. Our record layer just processes the message length and passes * the rest right through. Its format is: * Byte Content * 0-1 msg_length - decoded by the record layer * 2 msg_type - s->init_msg points here * 3-4 version * 5-6 cipher_spec_length * 7-8 session_id_length * 9-10 challenge_length * ... ... */ if (!PACKET_get_1(pkt, &mt) || mt != SSL2_MT_CLIENT_HELLO) { /* * Should never happen. We should have tested this in the record * layer in order to have determined that this is a SSLv2 record * in the first place */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (!PACKET_get_net_2(pkt, &clienthello->legacy_version)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); goto err; } /* Parse the message and load client random. */ if (clienthello->isv2) { /* * Handle an SSLv2 backwards compatible ClientHello * Note, this is only for SSLv3+ using the backward compatible format. * Real SSLv2 is not supported, and is rejected below. */ unsigned int ciphersuite_len, session_id_len, challenge_len; PACKET challenge; if (!PACKET_get_net_2(pkt, &ciphersuite_len) || !PACKET_get_net_2(pkt, &session_id_len) || !PACKET_get_net_2(pkt, &challenge_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RECORD_LENGTH_MISMATCH); goto err; } if (session_id_len > SSL_MAX_SSL_SESSION_ID_LENGTH) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_get_sub_packet(pkt, &clienthello->ciphersuites, ciphersuite_len) || !PACKET_copy_bytes(pkt, clienthello->session_id, session_id_len) || !PACKET_get_sub_packet(pkt, &challenge, challenge_len) /* No extensions. */ || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RECORD_LENGTH_MISMATCH); goto err; } clienthello->session_id_len = session_id_len; /* Load the client random and compression list. We use SSL3_RANDOM_SIZE * here rather than sizeof(clienthello->random) because that is the limit * for SSLv3 and it is fixed. It won't change even if * sizeof(clienthello->random) does. */ challenge_len = challenge_len > SSL3_RANDOM_SIZE ? SSL3_RANDOM_SIZE : challenge_len; memset(clienthello->random, 0, SSL3_RANDOM_SIZE); if (!PACKET_copy_bytes(&challenge, clienthello->random + SSL3_RANDOM_SIZE - challenge_len, challenge_len) /* Advertise only null compression. */ || !PACKET_buf_init(&compression, &null_compression, 1)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } PACKET_null_init(&clienthello->extensions); } else { /* Regular ClientHello. */ if (!PACKET_copy_bytes(pkt, clienthello->random, SSL3_RANDOM_SIZE) || !PACKET_get_length_prefixed_1(pkt, &session_id) || !PACKET_copy_all(&session_id, clienthello->session_id, SSL_MAX_SSL_SESSION_ID_LENGTH, &clienthello->session_id_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (SSL_CONNECTION_IS_DTLS(s)) { if (!PACKET_get_length_prefixed_1(pkt, &cookie)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_copy_all(&cookie, clienthello->dtls_cookie, DTLS1_COOKIE_LENGTH, &clienthello->dtls_cookie_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* * If we require cookies and this ClientHello doesn't contain one, * just return since we do not want to allocate any memory yet. * So check cookie length... */ if (SSL_get_options(SSL_CONNECTION_GET_SSL(s)) & SSL_OP_COOKIE_EXCHANGE) { if (clienthello->dtls_cookie_len == 0) { OPENSSL_free(clienthello); return MSG_PROCESS_FINISHED_READING; } } } if (!PACKET_get_length_prefixed_2(pkt, &clienthello->ciphersuites)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_get_length_prefixed_1(pkt, &compression)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } /* Could be empty. */ if (PACKET_remaining(pkt) == 0) { PACKET_null_init(&clienthello->extensions); } else { if (!PACKET_get_length_prefixed_2(pkt, &clienthello->extensions) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } } } if (!PACKET_copy_all(&compression, clienthello->compressions, MAX_COMPRESSIONS_SIZE, &clienthello->compressions_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Preserve the raw extensions PACKET for later use */ extensions = clienthello->extensions; if (!tls_collect_extensions(s, &extensions, SSL_EXT_CLIENT_HELLO, &clienthello->pre_proc_exts, &clienthello->pre_proc_exts_len, 1)) { /* SSLfatal already been called */ goto err; } s->clienthello = clienthello; return MSG_PROCESS_CONTINUE_PROCESSING; err: if (clienthello != NULL) OPENSSL_free(clienthello->pre_proc_exts); OPENSSL_free(clienthello); return MSG_PROCESS_ERROR; } static int tls_early_post_process_client_hello(SSL_CONNECTION *s) { unsigned int j; int i, al = SSL_AD_INTERNAL_ERROR; int protverr; size_t loop; unsigned long id; #ifndef OPENSSL_NO_COMP SSL_COMP *comp = NULL; #endif const SSL_CIPHER *c; STACK_OF(SSL_CIPHER) *ciphers = NULL; STACK_OF(SSL_CIPHER) *scsvs = NULL; CLIENTHELLO_MSG *clienthello = s->clienthello; DOWNGRADE dgrd = DOWNGRADE_NONE; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* Finished parsing the ClientHello, now we can start processing it */ /* Give the ClientHello callback a crack at things */ if (sctx->client_hello_cb != NULL) { /* A failure in the ClientHello callback terminates the connection. */ switch (sctx->client_hello_cb(ssl, &al, sctx->client_hello_cb_arg)) { case SSL_CLIENT_HELLO_SUCCESS: break; case SSL_CLIENT_HELLO_RETRY: s->rwstate = SSL_CLIENT_HELLO_CB; return -1; case SSL_CLIENT_HELLO_ERROR: default: SSLfatal(s, al, SSL_R_CALLBACK_FAILED); goto err; } } /* Set up the client_random */ memcpy(s->s3.client_random, clienthello->random, SSL3_RANDOM_SIZE); /* Choose the version */ if (clienthello->isv2) { if (clienthello->legacy_version == SSL2_VERSION || (clienthello->legacy_version & 0xff00) != (SSL3_VERSION_MAJOR << 8)) { /* * This is real SSLv2 or something completely unknown. We don't * support it. */ SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_UNKNOWN_PROTOCOL); goto err; } /* SSLv3/TLS */ s->client_version = clienthello->legacy_version; } /* Choose the server SSL/TLS/DTLS version. */ protverr = ssl_choose_server_version(s, clienthello, &dgrd); if (protverr) { if (SSL_IS_FIRST_HANDSHAKE(s)) { /* like ssl3_get_record, send alert using remote version number */ s->version = s->client_version = clienthello->legacy_version; } SSLfatal(s, SSL_AD_PROTOCOL_VERSION, protverr); goto err; } /* TLSv1.3 specifies that a ClientHello must end on a record boundary */ if (SSL_CONNECTION_IS_TLS13(s) && RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); goto err; } if (SSL_CONNECTION_IS_DTLS(s)) { /* Empty cookie was already handled above by returning early. */ if (SSL_get_options(ssl) & SSL_OP_COOKIE_EXCHANGE) { if (sctx->app_verify_cookie_cb != NULL) { if (sctx->app_verify_cookie_cb(ssl, clienthello->dtls_cookie, clienthello->dtls_cookie_len) == 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_COOKIE_MISMATCH); goto err; /* else cookie verification succeeded */ } /* default verification */ } else if (s->d1->cookie_len != clienthello->dtls_cookie_len || memcmp(clienthello->dtls_cookie, s->d1->cookie, s->d1->cookie_len) != 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_COOKIE_MISMATCH); goto err; } s->d1->cookie_verified = 1; } } s->hit = 0; if (!ssl_cache_cipherlist(s, &clienthello->ciphersuites, clienthello->isv2) || !ossl_bytes_to_cipher_list(s, &clienthello->ciphersuites, &ciphers, &scsvs, clienthello->isv2, 1)) { /* SSLfatal() already called */ goto err; } s->s3.send_connection_binding = 0; /* Check what signalling cipher-suite values were received. */ if (scsvs != NULL) { for (i = 0; i < sk_SSL_CIPHER_num(scsvs); i++) { c = sk_SSL_CIPHER_value(scsvs, i); if (SSL_CIPHER_get_id(c) == SSL3_CK_SCSV) { if (s->renegotiate) { /* SCSV is fatal if renegotiating */ SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING); goto err; } s->s3.send_connection_binding = 1; } else if (SSL_CIPHER_get_id(c) == SSL3_CK_FALLBACK_SCSV && !ssl_check_version_downgrade(s)) { /* * This SCSV indicates that the client previously tried * a higher version. We should fail if the current version * is an unexpected downgrade, as that indicates that the first * connection may have been tampered with in order to trigger * an insecure downgrade. */ SSLfatal(s, SSL_AD_INAPPROPRIATE_FALLBACK, SSL_R_INAPPROPRIATE_FALLBACK); goto err; } } } /* For TLSv1.3 we must select the ciphersuite *before* session resumption */ if (SSL_CONNECTION_IS_TLS13(s)) { const SSL_CIPHER *cipher = ssl3_choose_cipher(s, ciphers, SSL_get_ciphers(ssl)); if (cipher == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER); goto err; } if (s->hello_retry_request == SSL_HRR_PENDING && (s->s3.tmp.new_cipher == NULL || s->s3.tmp.new_cipher->id != cipher->id)) { /* * A previous HRR picked a different ciphersuite to the one we * just selected. Something must have changed. */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_CIPHER); goto err; } s->s3.tmp.new_cipher = cipher; } /* We need to do this before getting the session */ if (!tls_parse_extension(s, TLSEXT_IDX_extended_master_secret, SSL_EXT_CLIENT_HELLO, clienthello->pre_proc_exts, NULL, 0)) { /* SSLfatal() already called */ goto err; } /* * We don't allow resumption in a backwards compatible ClientHello. * In TLS1.1+, session_id MUST be empty. * * Versions before 0.9.7 always allow clients to resume sessions in * renegotiation. 0.9.7 and later allow this by default, but optionally * ignore resumption requests with flag * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION (it's a new flag rather * than a change to default behavior so that applications relying on * this for security won't even compile against older library versions). * 1.0.1 and later also have a function SSL_renegotiate_abbreviated() to * request renegotiation but not a new session (s->new_session remains * unset): for servers, this essentially just means that the * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be * ignored. */ if (clienthello->isv2 || (s->new_session && (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) { if (!ssl_get_new_session(s, 1)) { /* SSLfatal() already called */ goto err; } } else { i = ssl_get_prev_session(s, clienthello); if (i == 1) { /* previous session */ s->hit = 1; } else if (i == -1) { /* SSLfatal() already called */ goto err; } else { /* i == 0 */ if (!ssl_get_new_session(s, 1)) { /* SSLfatal() already called */ goto err; } } } if (SSL_CONNECTION_IS_TLS13(s)) { memcpy(s->tmp_session_id, s->clienthello->session_id, s->clienthello->session_id_len); s->tmp_session_id_len = s->clienthello->session_id_len; } /* * If it is a hit, check that the cipher is in the list. In TLSv1.3 we check * ciphersuite compatibility with the session as part of resumption. */ if (!SSL_CONNECTION_IS_TLS13(s) && s->hit) { j = 0; id = s->session->cipher->id; OSSL_TRACE_BEGIN(TLS_CIPHER) { BIO_printf(trc_out, "client sent %d ciphers\n", sk_SSL_CIPHER_num(ciphers)); } for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) { c = sk_SSL_CIPHER_value(ciphers, i); if (trc_out != NULL) BIO_printf(trc_out, "client [%2d of %2d]:%s\n", i, sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c)); if (c->id == id) { j = 1; break; } } if (j == 0) { /* * we need to have the cipher in the cipher list if we are asked * to reuse it */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_REQUIRED_CIPHER_MISSING); OSSL_TRACE_CANCEL(TLS_CIPHER); goto err; } OSSL_TRACE_END(TLS_CIPHER); } for (loop = 0; loop < clienthello->compressions_len; loop++) { if (clienthello->compressions[loop] == 0) break; } if (loop >= clienthello->compressions_len) { /* no compress */ SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_NO_COMPRESSION_SPECIFIED); goto err; } if (s->options & SSL_OP_SAFARI_ECDHE_ECDSA_BUG) ssl_check_for_safari(s, clienthello); /* TLS extensions */ if (!tls_parse_all_extensions(s, SSL_EXT_CLIENT_HELLO, clienthello->pre_proc_exts, NULL, 0, 1)) { /* SSLfatal() already called */ goto err; } /* * Check if we want to use external pre-shared secret for this handshake * for not reused session only. We need to generate server_random before * calling tls_session_secret_cb in order to allow SessionTicket * processing to use it in key derivation. */ { unsigned char *pos; pos = s->s3.server_random; if (ssl_fill_hello_random(s, 1, pos, SSL3_RANDOM_SIZE, dgrd) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (!s->hit && s->version >= TLS1_VERSION && !SSL_CONNECTION_IS_TLS13(s) && !SSL_CONNECTION_IS_DTLS(s) && s->ext.session_secret_cb != NULL) { const SSL_CIPHER *pref_cipher = NULL; /* * s->session->master_key_length is a size_t, but this is an int for * backwards compat reasons */ int master_key_length; master_key_length = sizeof(s->session->master_key); if (s->ext.session_secret_cb(ssl, s->session->master_key, &master_key_length, ciphers, &pref_cipher, s->ext.session_secret_cb_arg) && master_key_length > 0) { s->session->master_key_length = master_key_length; s->hit = 1; s->peer_ciphers = ciphers; s->session->verify_result = X509_V_OK; ciphers = NULL; /* check if some cipher was preferred by call back */ if (pref_cipher == NULL) pref_cipher = ssl3_choose_cipher(s, s->peer_ciphers, SSL_get_ciphers(ssl)); if (pref_cipher == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER); goto err; } s->session->cipher = pref_cipher; sk_SSL_CIPHER_free(s->cipher_list); s->cipher_list = sk_SSL_CIPHER_dup(s->peer_ciphers); sk_SSL_CIPHER_free(s->cipher_list_by_id); s->cipher_list_by_id = sk_SSL_CIPHER_dup(s->peer_ciphers); } } /* * Worst case, we will use the NULL compression, but if we have other * options, we will now look for them. We have complen-1 compression * algorithms from the client, starting at q. */ s->s3.tmp.new_compression = NULL; if (SSL_CONNECTION_IS_TLS13(s)) { /* * We already checked above that the NULL compression method appears in * the list. Now we check there aren't any others (which is illegal in * a TLSv1.3 ClientHello. */ if (clienthello->compressions_len != 1) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_COMPRESSION_ALGORITHM); goto err; } } #ifndef OPENSSL_NO_COMP /* This only happens if we have a cache hit */ else if (s->session->compress_meth != 0) { int m, comp_id = s->session->compress_meth; unsigned int k; /* Perform sanity checks on resumed compression algorithm */ /* Can't disable compression */ if (!ssl_allow_compression(s)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_COMPRESSION); goto err; } /* Look for resumed compression method */ for (m = 0; m < sk_SSL_COMP_num(sctx->comp_methods); m++) { comp = sk_SSL_COMP_value(sctx->comp_methods, m); if (comp_id == comp->id) { s->s3.tmp.new_compression = comp; break; } } if (s->s3.tmp.new_compression == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INVALID_COMPRESSION_ALGORITHM); goto err; } /* Look for resumed method in compression list */ for (k = 0; k < clienthello->compressions_len; k++) { if (clienthello->compressions[k] == comp_id) break; } if (k >= clienthello->compressions_len) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING); goto err; } } else if (s->hit) { comp = NULL; } else if (ssl_allow_compression(s) && sctx->comp_methods) { /* See if we have a match */ int m, nn, v, done = 0; unsigned int o; nn = sk_SSL_COMP_num(sctx->comp_methods); for (m = 0; m < nn; m++) { comp = sk_SSL_COMP_value(sctx->comp_methods, m); v = comp->id; for (o = 0; o < clienthello->compressions_len; o++) { if (v == clienthello->compressions[o]) { done = 1; break; } } if (done) break; } if (done) s->s3.tmp.new_compression = comp; else comp = NULL; } #else /* * If compression is disabled we'd better not try to resume a session * using compression. */ if (s->session->compress_meth != 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_COMPRESSION); goto err; } #endif /* * Given s->peer_ciphers and SSL_get_ciphers, we must pick a cipher */ if (!s->hit || SSL_CONNECTION_IS_TLS13(s)) { sk_SSL_CIPHER_free(s->peer_ciphers); s->peer_ciphers = ciphers; if (ciphers == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ciphers = NULL; } if (!s->hit) { #ifdef OPENSSL_NO_COMP s->session->compress_meth = 0; #else s->session->compress_meth = (comp == NULL) ? 0 : comp->id; #endif if (!tls1_set_server_sigalgs(s)) { /* SSLfatal() already called */ goto err; } } sk_SSL_CIPHER_free(ciphers); sk_SSL_CIPHER_free(scsvs); OPENSSL_free(clienthello->pre_proc_exts); OPENSSL_free(s->clienthello); s->clienthello = NULL; return 1; err: sk_SSL_CIPHER_free(ciphers); sk_SSL_CIPHER_free(scsvs); OPENSSL_free(clienthello->pre_proc_exts); OPENSSL_free(s->clienthello); s->clienthello = NULL; return 0; } /* * Call the status request callback if needed. Upon success, returns 1. * Upon failure, returns 0. */ static int tls_handle_status_request(SSL_CONNECTION *s) { SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); s->ext.status_expected = 0; /* * If status request then ask callback what to do. Note: this must be * called after servername callbacks in case the certificate has changed, * and must be called after the cipher has been chosen because this may * influence which certificate is sent */ if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing && sctx != NULL && sctx->ext.status_cb != NULL) { int ret; /* If no certificate can't return certificate status */ if (s->s3.tmp.cert != NULL) { /* * Set current certificate to one we will use so SSL_get_certificate * et al can pick it up. */ s->cert->key = s->s3.tmp.cert; ret = sctx->ext.status_cb(SSL_CONNECTION_GET_SSL(s), sctx->ext.status_arg); switch (ret) { /* We don't want to send a status request response */ case SSL_TLSEXT_ERR_NOACK: s->ext.status_expected = 0; break; /* status request response should be sent */ case SSL_TLSEXT_ERR_OK: if (s->ext.ocsp.resp) s->ext.status_expected = 1; break; /* something bad happened */ case SSL_TLSEXT_ERR_ALERT_FATAL: default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CLIENTHELLO_TLSEXT); return 0; } } } return 1; } /* * Call the alpn_select callback if needed. Upon success, returns 1. * Upon failure, returns 0. */ int tls_handle_alpn(SSL_CONNECTION *s) { const unsigned char *selected = NULL; unsigned char selected_len = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (sctx->ext.alpn_select_cb != NULL && s->s3.alpn_proposed != NULL) { int r = sctx->ext.alpn_select_cb(SSL_CONNECTION_GET_SSL(s), &selected, &selected_len, s->s3.alpn_proposed, (unsigned int)s->s3.alpn_proposed_len, sctx->ext.alpn_select_cb_arg); if (r == SSL_TLSEXT_ERR_OK) { OPENSSL_free(s->s3.alpn_selected); s->s3.alpn_selected = OPENSSL_memdup(selected, selected_len); if (s->s3.alpn_selected == NULL) { s->s3.alpn_selected_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->s3.alpn_selected_len = selected_len; #ifndef OPENSSL_NO_NEXTPROTONEG /* ALPN takes precedence over NPN. */ s->s3.npn_seen = 0; #endif /* Check ALPN is consistent with session */ if (s->session->ext.alpn_selected == NULL || selected_len != s->session->ext.alpn_selected_len || memcmp(selected, s->session->ext.alpn_selected, selected_len) != 0) { /* Not consistent so can't be used for early_data */ s->ext.early_data_ok = 0; if (!s->hit) { /* * This is a new session and so alpn_selected should have * been initialised to NULL. We should update it with the * selected ALPN. */ if (!ossl_assert(s->session->ext.alpn_selected == NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.alpn_selected = OPENSSL_memdup(selected, selected_len); if (s->session->ext.alpn_selected == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.alpn_selected_len = selected_len; } } return 1; } else if (r != SSL_TLSEXT_ERR_NOACK) { SSLfatal(s, SSL_AD_NO_APPLICATION_PROTOCOL, SSL_R_NO_APPLICATION_PROTOCOL); return 0; } /* * If r == SSL_TLSEXT_ERR_NOACK then behave as if no callback was * present. */ } /* Check ALPN is consistent with session */ if (s->session->ext.alpn_selected != NULL) { /* Not consistent so can't be used for early_data */ s->ext.early_data_ok = 0; } return 1; } WORK_STATE tls_post_process_client_hello(SSL_CONNECTION *s, WORK_STATE wst) { const SSL_CIPHER *cipher; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (wst == WORK_MORE_A) { int rv = tls_early_post_process_client_hello(s); if (rv == 0) { /* SSLfatal() was already called */ goto err; } if (rv < 0) return WORK_MORE_A; wst = WORK_MORE_B; } if (wst == WORK_MORE_B) { if (!s->hit || SSL_CONNECTION_IS_TLS13(s)) { /* Let cert callback update server certificates if required */ if (!s->hit && s->cert->cert_cb != NULL) { int rv = s->cert->cert_cb(ssl, s->cert->cert_cb_arg); if (rv == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CERT_CB_ERROR); goto err; } if (rv < 0) { s->rwstate = SSL_X509_LOOKUP; return WORK_MORE_B; } s->rwstate = SSL_NOTHING; } /* In TLSv1.3 we selected the ciphersuite before resumption */ if (!SSL_CONNECTION_IS_TLS13(s)) { cipher = ssl3_choose_cipher(s, s->peer_ciphers, SSL_get_ciphers(ssl)); if (cipher == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER); goto err; } s->s3.tmp.new_cipher = cipher; } if (!s->hit) { if (!tls_choose_sigalg(s, 1)) { /* SSLfatal already called */ goto err; } /* check whether we should disable session resumption */ if (s->not_resumable_session_cb != NULL) s->session->not_resumable = s->not_resumable_session_cb(ssl, ((s->s3.tmp.new_cipher->algorithm_mkey & (SSL_kDHE | SSL_kECDHE)) != 0)); if (s->session->not_resumable) /* do not send a session ticket */ s->ext.ticket_expected = 0; } } else { /* Session-id reuse */ s->s3.tmp.new_cipher = s->session->cipher; } /*- * we now have the following setup. * client_random * cipher_list - our preferred list of ciphers * ciphers - the client's preferred list of ciphers * compression - basically ignored right now * ssl version is set - sslv3 * s->session - The ssl session has been setup. * s->hit - session reuse flag * s->s3.tmp.new_cipher - the new cipher to use. */ /* * Call status_request callback if needed. Has to be done after the * certificate callbacks etc above. */ if (!tls_handle_status_request(s)) { /* SSLfatal() already called */ goto err; } /* * Call alpn_select callback if needed. Has to be done after SNI and * cipher negotiation (HTTP/2 restricts permitted ciphers). In TLSv1.3 * we already did this because cipher negotiation happens earlier, and * we must handle ALPN before we decide whether to accept early_data. */ if (!SSL_CONNECTION_IS_TLS13(s) && !tls_handle_alpn(s)) { /* SSLfatal() already called */ goto err; } wst = WORK_MORE_C; } #ifndef OPENSSL_NO_SRP if (wst == WORK_MORE_C) { int ret; if ((ret = ssl_check_srp_ext_ClientHello(s)) == 0) { /* * callback indicates further work to be done */ s->rwstate = SSL_X509_LOOKUP; return WORK_MORE_C; } if (ret < 0) { /* SSLfatal() already called */ goto err; } } #endif return WORK_FINISHED_STOP; err: return WORK_ERROR; } CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION *s, WPACKET *pkt) { int compm; size_t sl, len; int version; unsigned char *session_id; int usetls13 = SSL_CONNECTION_IS_TLS13(s) || s->hello_retry_request == SSL_HRR_PENDING; version = usetls13 ? TLS1_2_VERSION : s->version; if (!WPACKET_put_bytes_u16(pkt, version) /* * Random stuff. Filling of the server_random takes place in * tls_process_client_hello() */ || !WPACKET_memcpy(pkt, s->hello_retry_request == SSL_HRR_PENDING ? hrrrandom : s->s3.server_random, SSL3_RANDOM_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /*- * There are several cases for the session ID to send * back in the server hello: * - For session reuse from the session cache, * we send back the old session ID. * - If stateless session reuse (using a session ticket) * is successful, we send back the client's "session ID" * (which doesn't actually identify the session). * - If it is a new session, we send back the new * session ID. * - However, if we want the new session to be single-use, * we send back a 0-length session ID. * - In TLSv1.3 we echo back the session id sent to us by the client * regardless * s->hit is non-zero in either case of session reuse, * so the following won't overwrite an ID that we're supposed * to send back. */ if (s->session->not_resumable || (!(SSL_CONNECTION_GET_CTX(s)->session_cache_mode & SSL_SESS_CACHE_SERVER) && !s->hit)) s->session->session_id_length = 0; if (usetls13) { sl = s->tmp_session_id_len; session_id = s->tmp_session_id; } else { sl = s->session->session_id_length; session_id = s->session->session_id; } if (sl > sizeof(s->session->session_id)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* set up the compression method */ #ifdef OPENSSL_NO_COMP compm = 0; #else if (usetls13 || s->s3.tmp.new_compression == NULL) compm = 0; else compm = s->s3.tmp.new_compression->id; #endif if (!WPACKET_sub_memcpy_u8(pkt, session_id, sl) || !SSL_CONNECTION_GET_SSL(s)->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt, &len) || !WPACKET_put_bytes_u8(pkt, compm)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (!tls_construct_extensions(s, pkt, s->hello_retry_request == SSL_HRR_PENDING ? SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST : (SSL_CONNECTION_IS_TLS13(s) ? SSL_EXT_TLS1_3_SERVER_HELLO : SSL_EXT_TLS1_2_SERVER_HELLO), NULL, 0)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } if (s->hello_retry_request == SSL_HRR_PENDING) { /* Ditch the session. We'll create a new one next time around */ SSL_SESSION_free(s->session); s->session = NULL; s->hit = 0; /* * Re-initialise the Transcript Hash. We're going to prepopulate it with * a synthetic message_hash in place of ClientHello1. */ if (!create_synthetic_message_hash(s, NULL, 0, NULL, 0)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } } else if (!(s->verify_mode & SSL_VERIFY_PEER) && !ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called */; return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } CON_FUNC_RETURN tls_construct_server_done(SSL_CONNECTION *s, WPACKET *pkt) { if (!s->s3.tmp.cert_request) { if (!ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } } return CON_FUNC_SUCCESS; } CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s, WPACKET *pkt) { EVP_PKEY *pkdh = NULL; unsigned char *encodedPoint = NULL; size_t encodedlen = 0; int curve_id = 0; const SIGALG_LOOKUP *lu = s->s3.tmp.sigalg; int i; unsigned long type; BIGNUM *r[4]; EVP_MD_CTX *md_ctx = EVP_MD_CTX_new(); EVP_PKEY_CTX *pctx = NULL; size_t paramlen, paramoffset; int freer = 0; CON_FUNC_RETURN ret = CON_FUNC_ERROR; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (!WPACKET_get_total_written(pkt, &paramoffset)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (md_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } type = s->s3.tmp.new_cipher->algorithm_mkey; r[0] = r[1] = r[2] = r[3] = NULL; #ifndef OPENSSL_NO_PSK /* Plain PSK or RSAPSK nothing to do */ if (type & (SSL_kPSK | SSL_kRSAPSK)) { } else #endif /* !OPENSSL_NO_PSK */ if (type & (SSL_kDHE | SSL_kDHEPSK)) { CERT *cert = s->cert; EVP_PKEY *pkdhp = NULL; if (s->cert->dh_tmp_auto) { pkdh = ssl_get_auto_dh(s); if (pkdh == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pkdhp = pkdh; } else { pkdhp = cert->dh_tmp; } #if !defined(OPENSSL_NO_DEPRECATED_3_0) if ((pkdhp == NULL) && (s->cert->dh_tmp_cb != NULL)) { pkdh = ssl_dh_to_pkey(s->cert->dh_tmp_cb(SSL_CONNECTION_GET_SSL(s), 0, 1024)); if (pkdh == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pkdhp = pkdh; } #endif if (pkdhp == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_TMP_DH_KEY); goto err; } if (!ssl_security(s, SSL_SECOP_TMP_DH, EVP_PKEY_get_security_bits(pkdhp), 0, pkdhp)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DH_KEY_TOO_SMALL); goto err; } if (s->s3.tmp.pkey != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } s->s3.tmp.pkey = ssl_generate_pkey(s, pkdhp); if (s->s3.tmp.pkey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } EVP_PKEY_free(pkdh); pkdh = NULL; /* These BIGNUMs need to be freed when we're finished */ freer = 1; if (!EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_FFC_P, &r[0]) || !EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_FFC_G, &r[1]) || !EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_PUB_KEY, &r[2])) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } else if (type & (SSL_kECDHE | SSL_kECDHEPSK)) { if (s->s3.tmp.pkey != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Get NID of appropriate shared curve */ curve_id = tls1_shared_group(s, -2); if (curve_id == 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNSUPPORTED_ELLIPTIC_CURVE); goto err; } /* Cache the group used in the SSL_SESSION */ s->session->kex_group = curve_id; /* Generate a new key for this curve */ s->s3.tmp.pkey = ssl_generate_pkey_group(s, curve_id); if (s->s3.tmp.pkey == NULL) { /* SSLfatal() already called */ goto err; } /* Encode the public key. */ encodedlen = EVP_PKEY_get1_encoded_public_key(s->s3.tmp.pkey, &encodedPoint); if (encodedlen == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); goto err; } /* * We'll generate the serverKeyExchange message explicitly so we * can set these to NULLs */ r[0] = NULL; r[1] = NULL; r[2] = NULL; r[3] = NULL; } else #ifndef OPENSSL_NO_SRP if (type & SSL_kSRP) { if ((s->srp_ctx.N == NULL) || (s->srp_ctx.g == NULL) || (s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_SRP_PARAM); goto err; } r[0] = s->srp_ctx.N; r[1] = s->srp_ctx.g; r[2] = s->srp_ctx.s; r[3] = s->srp_ctx.B; } else #endif { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE); goto err; } if (((s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP)) != 0) || ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK)) != 0) { lu = NULL; } else if (lu == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR); goto err; } #ifndef OPENSSL_NO_PSK if (type & SSL_PSK) { size_t len = (s->cert->psk_identity_hint == NULL) ? 0 : strlen(s->cert->psk_identity_hint); /* * It should not happen that len > PSK_MAX_IDENTITY_LEN - we already * checked this when we set the identity hint - but just in case */ if (len > PSK_MAX_IDENTITY_LEN || !WPACKET_sub_memcpy_u16(pkt, s->cert->psk_identity_hint, len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } #endif for (i = 0; i < 4 && r[i] != NULL; i++) { unsigned char *binval; int res; #ifndef OPENSSL_NO_SRP if ((i == 2) && (type & SSL_kSRP)) { res = WPACKET_start_sub_packet_u8(pkt); } else #endif res = WPACKET_start_sub_packet_u16(pkt); if (!res) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /*- * for interoperability with some versions of the Microsoft TLS * stack, we need to zero pad the DHE pub key to the same length * as the prime */ if ((i == 2) && (type & (SSL_kDHE | SSL_kDHEPSK))) { size_t len = BN_num_bytes(r[0]) - BN_num_bytes(r[2]); if (len > 0) { if (!WPACKET_allocate_bytes(pkt, len, &binval)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } memset(binval, 0, len); } } if (!WPACKET_allocate_bytes(pkt, BN_num_bytes(r[i]), &binval) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } BN_bn2bin(r[i], binval); } if (type & (SSL_kECDHE | SSL_kECDHEPSK)) { /* * We only support named (not generic) curves. In this situation, the * ServerKeyExchange message has: [1 byte CurveType], [2 byte CurveName] * [1 byte length of encoded point], followed by the actual encoded * point itself */ if (!WPACKET_put_bytes_u8(pkt, NAMED_CURVE_TYPE) || !WPACKET_put_bytes_u8(pkt, 0) || !WPACKET_put_bytes_u8(pkt, curve_id) || !WPACKET_sub_memcpy_u8(pkt, encodedPoint, encodedlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } OPENSSL_free(encodedPoint); encodedPoint = NULL; } /* not anonymous */ if (lu != NULL) { EVP_PKEY *pkey = s->s3.tmp.cert->privatekey; const EVP_MD *md; unsigned char *sigbytes1, *sigbytes2, *tbs; size_t siglen = 0, tbslen; if (pkey == NULL || !tls1_lookup_md(sctx, lu, &md)) { /* Should never happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Get length of the parameters we have written above */ if (!WPACKET_get_length(pkt, &paramlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* send signature algorithm */ if (SSL_USE_SIGALGS(s) && !WPACKET_put_bytes_u16(pkt, lu->sigalg)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (EVP_DigestSignInit_ex(md_ctx, &pctx, md == NULL ? NULL : EVP_MD_get0_name(md), sctx->libctx, sctx->propq, pkey, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (lu->sig == EVP_PKEY_RSA_PSS) { if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } tbslen = construct_key_exchange_tbs(s, &tbs, s->init_buf->data + paramoffset, paramlen); if (tbslen == 0) { /* SSLfatal() already called */ goto err; } if (EVP_DigestSign(md_ctx, NULL, &siglen, tbs, tbslen) <=0 || !WPACKET_sub_reserve_bytes_u16(pkt, siglen, &sigbytes1) || EVP_DigestSign(md_ctx, sigbytes1, &siglen, tbs, tbslen) <= 0 || !WPACKET_sub_allocate_bytes_u16(pkt, siglen, &sigbytes2) || sigbytes1 != sigbytes2) { OPENSSL_free(tbs); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } OPENSSL_free(tbs); } ret = CON_FUNC_SUCCESS; err: EVP_PKEY_free(pkdh); OPENSSL_free(encodedPoint); EVP_MD_CTX_free(md_ctx); if (freer) { BN_free(r[0]); BN_free(r[1]); BN_free(r[2]); BN_free(r[3]); } return ret; } CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION *s, WPACKET *pkt) { if (SSL_CONNECTION_IS_TLS13(s)) { /* Send random context when doing post-handshake auth */ if (s->post_handshake_auth == SSL_PHA_REQUEST_PENDING) { OPENSSL_free(s->pha_context); s->pha_context_len = 32; if ((s->pha_context = OPENSSL_malloc(s->pha_context_len)) == NULL) { s->pha_context_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, s->pha_context, s->pha_context_len, 0) <= 0 || !WPACKET_sub_memcpy_u8(pkt, s->pha_context, s->pha_context_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* reset the handshake hash back to just after the ClientFinished */ if (!tls13_restore_handshake_digest_for_pha(s)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } } else { if (!WPACKET_put_bytes_u8(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } if (!tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, NULL, 0)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } goto done; } /* get the list of acceptable cert types */ if (!WPACKET_start_sub_packet_u8(pkt) || !ssl3_get_req_cert_type(s, pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (SSL_USE_SIGALGS(s)) { const uint16_t *psigs; size_t nl = tls12_get_psigalgs(s, 1, &psigs); if (!WPACKET_start_sub_packet_u16(pkt) || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH) || !tls12_copy_sigalgs(s, pkt, psigs, nl) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } if (!construct_ca_names(s, get_ca_names(s), pkt)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } done: s->certreqs_sent++; s->s3.tmp.cert_request = 1; return CON_FUNC_SUCCESS; } static int tls_process_cke_psk_preamble(SSL_CONNECTION *s, PACKET *pkt) { #ifndef OPENSSL_NO_PSK unsigned char psk[PSK_MAX_PSK_LEN]; size_t psklen; PACKET psk_identity; if (!PACKET_get_length_prefixed_2(pkt, &psk_identity)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (PACKET_remaining(&psk_identity) > PSK_MAX_IDENTITY_LEN) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } if (s->psk_server_callback == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_PSK_NO_SERVER_CB); return 0; } if (!PACKET_strndup(&psk_identity, &s->session->psk_identity)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } psklen = s->psk_server_callback(SSL_CONNECTION_GET_SSL(s), s->session->psk_identity, psk, sizeof(psk)); if (psklen > PSK_MAX_PSK_LEN) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } else if (psklen == 0) { /* * PSK related to the given identity not found */ SSLfatal(s, SSL_AD_UNKNOWN_PSK_IDENTITY, SSL_R_PSK_IDENTITY_NOT_FOUND); return 0; } OPENSSL_free(s->s3.tmp.psk); s->s3.tmp.psk = OPENSSL_memdup(psk, psklen); OPENSSL_cleanse(psk, psklen); if (s->s3.tmp.psk == NULL) { s->s3.tmp.psklen = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } s->s3.tmp.psklen = psklen; return 1; #else /* Should never happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_cke_rsa(SSL_CONNECTION *s, PACKET *pkt) { size_t outlen; PACKET enc_premaster; EVP_PKEY *rsa = NULL; unsigned char *rsa_decrypt = NULL; int ret = 0; EVP_PKEY_CTX *ctx = NULL; OSSL_PARAM params[3], *p = params; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); rsa = s->cert->pkeys[SSL_PKEY_RSA].privatekey; if (rsa == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_RSA_CERTIFICATE); return 0; } /* SSLv3 and pre-standard DTLS omit the length bytes. */ if (s->version == SSL3_VERSION || s->version == DTLS1_BAD_VER) { enc_premaster = *pkt; } else { if (!PACKET_get_length_prefixed_2(pkt, &enc_premaster) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } } outlen = SSL_MAX_MASTER_KEY_LENGTH; rsa_decrypt = OPENSSL_malloc(outlen); if (rsa_decrypt == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, rsa, sctx->propq); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } /* * We must not leak whether a decryption failure occurs because of * Bleichenbacher's attack on PKCS #1 v1.5 RSA padding (see RFC 2246, * section 7.4.7.1). We use the special padding type * RSA_PKCS1_WITH_TLS_PADDING to do that. It will automatically decrypt the * RSA, check the padding and check that the client version is as expected * in the premaster secret. If any of that fails then the function appears * to return successfully but with a random result. The call below could * still fail if the input is publicly invalid. * See https://tools.ietf.org/html/rfc5246#section-7.4.7.1 */ if (EVP_PKEY_decrypt_init(ctx) <= 0 || EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_WITH_TLS_PADDING) <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } *p++ = OSSL_PARAM_construct_uint(OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION, (unsigned int *)&s->client_version); if ((s->options & SSL_OP_TLS_ROLLBACK_BUG) != 0) *p++ = OSSL_PARAM_construct_uint( OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION, (unsigned int *)&s->version); *p++ = OSSL_PARAM_construct_end(); if (!EVP_PKEY_CTX_set_params(ctx, params) || EVP_PKEY_decrypt(ctx, rsa_decrypt, &outlen, PACKET_data(&enc_premaster), PACKET_remaining(&enc_premaster)) <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } /* * This test should never fail (otherwise we should have failed above) but * we double check anyway. */ if (outlen != SSL_MAX_MASTER_KEY_LENGTH) { OPENSSL_cleanse(rsa_decrypt, SSL_MAX_MASTER_KEY_LENGTH); SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } /* Also cleanses rsa_decrypt (on success or failure) */ if (!ssl_generate_master_secret(s, rsa_decrypt, outlen, 0)) { /* SSLfatal() already called */ goto err; } ret = 1; err: OPENSSL_free(rsa_decrypt); EVP_PKEY_CTX_free(ctx); return ret; } static int tls_process_cke_dhe(SSL_CONNECTION *s, PACKET *pkt) { EVP_PKEY *skey = NULL; unsigned int i; const unsigned char *data; EVP_PKEY *ckey = NULL; int ret = 0; if (!PACKET_get_net_2(pkt, &i) || PACKET_remaining(pkt) != i) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG); goto err; } skey = s->s3.tmp.pkey; if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_TMP_DH_KEY); goto err; } if (PACKET_remaining(pkt) == 0L) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_MISSING_TMP_DH_KEY); goto err; } if (!PACKET_get_bytes(pkt, &data, i)) { /* We already checked we have enough data */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ckey = EVP_PKEY_new(); if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COPY_PARAMETERS_FAILED); goto err; } if (!EVP_PKEY_set1_encoded_public_key(ckey, data, i)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (ssl_derive(s, skey, ckey, 1) == 0) { /* SSLfatal() already called */ goto err; } ret = 1; EVP_PKEY_free(s->s3.tmp.pkey); s->s3.tmp.pkey = NULL; err: EVP_PKEY_free(ckey); return ret; } static int tls_process_cke_ecdhe(SSL_CONNECTION *s, PACKET *pkt) { EVP_PKEY *skey = s->s3.tmp.pkey; EVP_PKEY *ckey = NULL; int ret = 0; if (PACKET_remaining(pkt) == 0L) { /* We don't support ECDH client auth */ SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_MISSING_TMP_ECDH_KEY); goto err; } else { unsigned int i; const unsigned char *data; /* * Get client's public key from encoded point in the * ClientKeyExchange message. */ /* Get encoded point length */ if (!PACKET_get_1(pkt, &i) || !PACKET_get_bytes(pkt, &data, i) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_TMP_ECDH_KEY); goto err; } ckey = EVP_PKEY_new(); if (ckey == NULL || EVP_PKEY_copy_parameters(ckey, skey) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COPY_PARAMETERS_FAILED); goto err; } if (EVP_PKEY_set1_encoded_public_key(ckey, data, i) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); goto err; } } if (ssl_derive(s, skey, ckey, 1) == 0) { /* SSLfatal() already called */ goto err; } ret = 1; EVP_PKEY_free(s->s3.tmp.pkey); s->s3.tmp.pkey = NULL; err: EVP_PKEY_free(ckey); return ret; } static int tls_process_cke_srp(SSL_CONNECTION *s, PACKET *pkt) { #ifndef OPENSSL_NO_SRP unsigned int i; const unsigned char *data; if (!PACKET_get_net_2(pkt, &i) || !PACKET_get_bytes(pkt, &data, i)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRP_A_LENGTH); return 0; } if ((s->srp_ctx.A = BN_bin2bn(data, i, NULL)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB); return 0; } if (BN_ucmp(s->srp_ctx.A, s->srp_ctx.N) >= 0 || BN_is_zero(s->srp_ctx.A)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_SRP_PARAMETERS); return 0; } OPENSSL_free(s->session->srp_username); s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login); if (s->session->srp_username == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } if (!srp_generate_server_master_secret(s)) { /* SSLfatal() already called */ return 0; } return 1; #else /* Should never happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_cke_gost(SSL_CONNECTION *s, PACKET *pkt) { #ifndef OPENSSL_NO_GOST EVP_PKEY_CTX *pkey_ctx; EVP_PKEY *client_pub_pkey = NULL, *pk = NULL; unsigned char premaster_secret[32]; const unsigned char *start; size_t outlen = sizeof(premaster_secret), inlen; unsigned long alg_a; GOST_KX_MESSAGE *pKX = NULL; const unsigned char *ptr; int ret = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* Get our certificate private key */ alg_a = s->s3.tmp.new_cipher->algorithm_auth; if (alg_a & SSL_aGOST12) { /* * New GOST ciphersuites have SSL_aGOST01 bit too */ pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey; if (pk == NULL) { pk = s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey; } if (pk == NULL) { pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey; } } else if (alg_a & SSL_aGOST01) { pk = s->cert->pkeys[SSL_PKEY_GOST01].privatekey; } pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pk, sctx->propq); if (pkey_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * If client certificate is present and is of the same type, maybe * use it for key exchange. Don't mind errors from * EVP_PKEY_derive_set_peer, because it is completely valid to use a * client certificate for authorization only. */ client_pub_pkey = tls_get_peer_pkey(s); if (client_pub_pkey) { if (EVP_PKEY_derive_set_peer(pkey_ctx, client_pub_pkey) <= 0) ERR_clear_error(); } ptr = PACKET_data(pkt); /* Some implementations provide extra data in the opaqueBlob * We have nothing to do with this blob so we just skip it */ pKX = d2i_GOST_KX_MESSAGE(NULL, &ptr, PACKET_remaining(pkt)); if (pKX == NULL || pKX->kxBlob == NULL || ASN1_TYPE_get(pKX->kxBlob) != V_ASN1_SEQUENCE) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } if (!PACKET_forward(pkt, ptr - PACKET_data(pkt))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } inlen = pKX->kxBlob->value.sequence->length; start = pKX->kxBlob->value.sequence->data; if (EVP_PKEY_decrypt(pkey_ctx, premaster_secret, &outlen, start, inlen) <= 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } /* Generate master secret */ if (!ssl_generate_master_secret(s, premaster_secret, outlen, 0)) { /* SSLfatal() already called */ goto err; } /* Check if pubkey from client certificate was used */ if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2, NULL) > 0) s->statem.no_cert_verify = 1; ret = 1; err: EVP_PKEY_CTX_free(pkey_ctx); GOST_KX_MESSAGE_free(pKX); return ret; #else /* Should never happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_cke_gost18(SSL_CONNECTION *s, PACKET *pkt) { #ifndef OPENSSL_NO_GOST unsigned char rnd_dgst[32]; EVP_PKEY_CTX *pkey_ctx = NULL; EVP_PKEY *pk = NULL; unsigned char premaster_secret[32]; const unsigned char *start = NULL; size_t outlen = sizeof(premaster_secret), inlen = 0; int ret = 0; int cipher_nid = ossl_gost18_cke_cipher_nid(s); SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (cipher_nid == NID_undef) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (ossl_gost_ukm(s, rnd_dgst) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Get our certificate private key */ pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey != NULL ? s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey : s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey; if (pk == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_STATE); goto err; } pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pk, sctx->propq); if (pkey_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_decrypt_init(pkey_ctx) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Reuse EVP_PKEY_CTRL_SET_IV, make choice in engine code depending on size */ if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_DECRYPT, EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_DECRYPT, EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } inlen = PACKET_remaining(pkt); start = PACKET_data(pkt); if (EVP_PKEY_decrypt(pkey_ctx, premaster_secret, &outlen, start, inlen) <= 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED); goto err; } /* Generate master secret */ if (!ssl_generate_master_secret(s, premaster_secret, outlen, 0)) { /* SSLfatal() already called */ goto err; } ret = 1; err: EVP_PKEY_CTX_free(pkey_ctx); return ret; #else /* Should never happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION *s, PACKET *pkt) { unsigned long alg_k; alg_k = s->s3.tmp.new_cipher->algorithm_mkey; /* For PSK parse and retrieve identity, obtain PSK key */ if ((alg_k & SSL_PSK) && !tls_process_cke_psk_preamble(s, pkt)) { /* SSLfatal() already called */ goto err; } if (alg_k & SSL_kPSK) { /* Identity extracted earlier: should be nothing left */ if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } /* PSK handled by ssl_generate_master_secret */ if (!ssl_generate_master_secret(s, NULL, 0, 0)) { /* SSLfatal() already called */ goto err; } } else if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) { if (!tls_process_cke_rsa(s, pkt)) { /* SSLfatal() already called */ goto err; } } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) { if (!tls_process_cke_dhe(s, pkt)) { /* SSLfatal() already called */ goto err; } } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) { if (!tls_process_cke_ecdhe(s, pkt)) { /* SSLfatal() already called */ goto err; } } else if (alg_k & SSL_kSRP) { if (!tls_process_cke_srp(s, pkt)) { /* SSLfatal() already called */ goto err; } } else if (alg_k & SSL_kGOST) { if (!tls_process_cke_gost(s, pkt)) { /* SSLfatal() already called */ goto err; } } else if (alg_k & SSL_kGOST18) { if (!tls_process_cke_gost18(s, pkt)) { /* SSLfatal() already called */ goto err; } } else { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNKNOWN_CIPHER_TYPE); goto err; } return MSG_PROCESS_CONTINUE_PROCESSING; err: #ifndef OPENSSL_NO_PSK OPENSSL_clear_free(s->s3.tmp.psk, s->s3.tmp.psklen); s->s3.tmp.psk = NULL; s->s3.tmp.psklen = 0; #endif return MSG_PROCESS_ERROR; } WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION *s, WORK_STATE wst) { #ifndef OPENSSL_NO_SCTP if (wst == WORK_MORE_A) { if (SSL_CONNECTION_IS_DTLS(s)) { unsigned char sctpauthkey[64]; char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)]; size_t labellen; /* * Add new shared key for SCTP-Auth, will be ignored if no SCTP * used. */ memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL, sizeof(DTLS1_SCTP_AUTH_LABEL)); /* Don't include the terminating zero. */ labellen = sizeof(labelbuffer) - 1; if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG) labellen += 1; if (SSL_export_keying_material(SSL_CONNECTION_GET_SSL(s), sctpauthkey, sizeof(sctpauthkey), labelbuffer, labellen, NULL, 0, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } BIO_ctrl(s->wbio, BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY, sizeof(sctpauthkey), sctpauthkey); } } #endif if (s->statem.no_cert_verify || !received_client_cert(s)) { /* * No certificate verify or no peer certificate so we no longer need * the handshake_buffer */ if (!ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called */ return WORK_ERROR; } return WORK_FINISHED_CONTINUE; } else { if (!s->s3.handshake_buffer) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } /* * For sigalgs freeze the handshake buffer. If we support * extms we've done this already so this is a no-op */ if (!ssl3_digest_cached_records(s, 1)) { /* SSLfatal() already called */ return WORK_ERROR; } } return WORK_FINISHED_CONTINUE; } MSG_PROCESS_RETURN tls_process_client_rpk(SSL_CONNECTION *sc, PACKET *pkt) { MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; SSL_SESSION *new_sess = NULL; EVP_PKEY *peer_rpk = NULL; if (!tls_process_rpk(sc, pkt, &peer_rpk)) { /* SSLfatal already called */ goto err; } if (peer_rpk == NULL) { if ((sc->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT) && (sc->verify_mode & SSL_VERIFY_PEER)) { SSLfatal(sc, SSL_AD_CERTIFICATE_REQUIRED, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE); goto err; } } else { if (ssl_verify_rpk(sc, peer_rpk) <= 0) { SSLfatal(sc, ssl_x509err2alert(sc->verify_result), SSL_R_CERTIFICATE_VERIFY_FAILED); goto err; } } /* * Sessions must be immutable once they go into the session cache. Otherwise * we can get multi-thread problems. Therefore we don't "update" sessions, * we replace them with a duplicate. Here, we need to do this every time * a new RPK (or certificate) is received via post-handshake authentication, * as the session may have already gone into the session cache. */ if (sc->post_handshake_auth == SSL_PHA_REQUESTED) { if ((new_sess = ssl_session_dup(sc->session, 0)) == NULL) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_MALLOC_FAILURE); goto err; } SSL_SESSION_free(sc->session); sc->session = new_sess; } /* Ensure there is no peer/peer_chain */ X509_free(sc->session->peer); sc->session->peer = NULL; sk_X509_pop_free(sc->session->peer_chain, X509_free); sc->session->peer_chain = NULL; /* Save RPK */ EVP_PKEY_free(sc->session->peer_rpk); sc->session->peer_rpk = peer_rpk; peer_rpk = NULL; sc->session->verify_result = sc->verify_result; /* * Freeze the handshake buffer. For <TLS1.3 we do this after the CKE * message */ if (SSL_CONNECTION_IS_TLS13(sc)) { if (!ssl3_digest_cached_records(sc, 1)) { /* SSLfatal() already called */ goto err; } /* Save the current hash state for when we receive the CertificateVerify */ if (!ssl_handshake_hash(sc, sc->cert_verify_hash, sizeof(sc->cert_verify_hash), &sc->cert_verify_hash_len)) { /* SSLfatal() already called */; goto err; } /* resend session tickets */ sc->sent_tickets = 0; } ret = MSG_PROCESS_CONTINUE_READING; err: EVP_PKEY_free(peer_rpk); return ret; } MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s, PACKET *pkt) { int i; MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; X509 *x = NULL; unsigned long l; const unsigned char *certstart, *certbytes; STACK_OF(X509) *sk = NULL; PACKET spkt, context; size_t chainidx; SSL_SESSION *new_sess = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* * To get this far we must have read encrypted data from the client. We no * longer tolerate unencrypted alerts. This is ignored if less than TLSv1.3 */ if (s->rlayer.rrlmethod->set_plain_alerts != NULL) s->rlayer.rrlmethod->set_plain_alerts(s->rlayer.rrl, 0); if (s->ext.client_cert_type == TLSEXT_cert_type_rpk) return tls_process_client_rpk(s, pkt); if (s->ext.client_cert_type != TLSEXT_cert_type_x509) { SSLfatal(s, SSL_AD_UNSUPPORTED_CERTIFICATE, SSL_R_UNKNOWN_CERTIFICATE_TYPE); goto err; } if ((sk = sk_X509_new_null()) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (SSL_CONNECTION_IS_TLS13(s) && (!PACKET_get_length_prefixed_1(pkt, &context) || (s->pha_context == NULL && PACKET_remaining(&context) != 0) || (s->pha_context != NULL && !PACKET_equal(&context, s->pha_context, s->pha_context_len)))) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT); goto err; } if (!PACKET_get_length_prefixed_3(pkt, &spkt) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } for (chainidx = 0; PACKET_remaining(&spkt) > 0; chainidx++) { if (!PACKET_get_net_3(&spkt, &l) || !PACKET_get_bytes(&spkt, &certbytes, l)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH); goto err; } certstart = certbytes; x = X509_new_ex(sctx->libctx, sctx->propq); if (x == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_X509_LIB); goto err; } if (d2i_X509(&x, (const unsigned char **)&certbytes, l) == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_ASN1_LIB); goto err; } if (certbytes != (certstart + l)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH); goto err; } if (SSL_CONNECTION_IS_TLS13(s)) { RAW_EXTENSION *rawexts = NULL; PACKET extensions; if (!PACKET_get_length_prefixed_2(&spkt, &extensions)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); goto err; } if (!tls_collect_extensions(s, &extensions, SSL_EXT_TLS1_3_CERTIFICATE, &rawexts, NULL, chainidx == 0) || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE, rawexts, x, chainidx, PACKET_remaining(&spkt) == 0)) { OPENSSL_free(rawexts); goto err; } OPENSSL_free(rawexts); } if (!sk_X509_push(sk, x)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } x = NULL; } if (sk_X509_num(sk) <= 0) { /* TLS does not mind 0 certs returned */ if (s->version == SSL3_VERSION) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_CERTIFICATES_RETURNED); goto err; } /* Fail for TLS only if we required a certificate */ else if ((s->verify_mode & SSL_VERIFY_PEER) && (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) { SSLfatal(s, SSL_AD_CERTIFICATE_REQUIRED, SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE); goto err; } /* No client certificate so digest cached records */ if (s->s3.handshake_buffer && !ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called */ goto err; } } else { EVP_PKEY *pkey; i = ssl_verify_cert_chain(s, sk); if (i <= 0) { SSLfatal(s, ssl_x509err2alert(s->verify_result), SSL_R_CERTIFICATE_VERIFY_FAILED); goto err; } pkey = X509_get0_pubkey(sk_X509_value(sk, 0)); if (pkey == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_UNKNOWN_CERTIFICATE_TYPE); goto err; } } /* * Sessions must be immutable once they go into the session cache. Otherwise * we can get multi-thread problems. Therefore we don't "update" sessions, * we replace them with a duplicate. Here, we need to do this every time * a new certificate is received via post-handshake authentication, as the * session may have already gone into the session cache. */ if (s->post_handshake_auth == SSL_PHA_REQUESTED) { if ((new_sess = ssl_session_dup(s->session, 0)) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); goto err; } SSL_SESSION_free(s->session); s->session = new_sess; } X509_free(s->session->peer); s->session->peer = sk_X509_shift(sk); s->session->verify_result = s->verify_result; OSSL_STACK_OF_X509_free(s->session->peer_chain); s->session->peer_chain = sk; sk = NULL; /* Ensure there is no RPK */ EVP_PKEY_free(s->session->peer_rpk); s->session->peer_rpk = NULL; /* * Freeze the handshake buffer. For <TLS1.3 we do this after the CKE * message */ if (SSL_CONNECTION_IS_TLS13(s) && !ssl3_digest_cached_records(s, 1)) { /* SSLfatal() already called */ goto err; } /* * Inconsistency alert: cert_chain does *not* include the peer's own * certificate, while we do include it in statem_clnt.c */ /* Save the current hash state for when we receive the CertificateVerify */ if (SSL_CONNECTION_IS_TLS13(s)) { if (!ssl_handshake_hash(s, s->cert_verify_hash, sizeof(s->cert_verify_hash), &s->cert_verify_hash_len)) { /* SSLfatal() already called */ goto err; } /* Resend session tickets */ s->sent_tickets = 0; } ret = MSG_PROCESS_CONTINUE_READING; err: X509_free(x); OSSL_STACK_OF_X509_free(sk); return ret; } #ifndef OPENSSL_NO_COMP_ALG MSG_PROCESS_RETURN tls_process_client_compressed_certificate(SSL_CONNECTION *sc, PACKET *pkt) { MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; PACKET tmppkt; BUF_MEM *buf = BUF_MEM_new(); if (tls13_process_compressed_certificate(sc, pkt, &tmppkt, buf) != MSG_PROCESS_ERROR) ret = tls_process_client_certificate(sc, &tmppkt); BUF_MEM_free(buf); return ret; } #endif CON_FUNC_RETURN tls_construct_server_certificate(SSL_CONNECTION *s, WPACKET *pkt) { CERT_PKEY *cpk = s->s3.tmp.cert; if (cpk == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* * In TLSv1.3 the certificate chain is always preceded by a 0 length context * for the server Certificate message */ if (SSL_CONNECTION_IS_TLS13(s) && !WPACKET_put_bytes_u8(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } switch (s->ext.server_cert_type) { case TLSEXT_cert_type_rpk: if (!tls_output_rpk(s, pkt, cpk)) { /* SSLfatal() already called */ return 0; } break; case TLSEXT_cert_type_x509: if (!ssl3_output_cert_chain(s, pkt, cpk, 0)) { /* SSLfatal() already called */ return 0; } break; default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return CON_FUNC_SUCCESS; } #ifndef OPENSSL_NO_COMP_ALG CON_FUNC_RETURN tls_construct_server_compressed_certificate(SSL_CONNECTION *sc, WPACKET *pkt) { int alg = get_compressed_certificate_alg(sc); OSSL_COMP_CERT *cc = sc->s3.tmp.cert->comp_cert[alg]; if (!ossl_assert(cc != NULL)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * Server can't compress on-demand * Use pre-compressed certificate */ if (!WPACKET_put_bytes_u16(pkt, alg) || !WPACKET_put_bytes_u24(pkt, cc->orig_len) || !WPACKET_start_sub_packet_u24(pkt) || !WPACKET_memcpy(pkt, cc->data, cc->len) || !WPACKET_close(pkt)) return 0; sc->s3.tmp.cert->cert_comp_used++; return 1; } #endif static int create_ticket_prequel(SSL_CONNECTION *s, WPACKET *pkt, uint32_t age_add, unsigned char *tick_nonce) { uint32_t timeout = (uint32_t)ossl_time2seconds(s->session->timeout); /* * Ticket lifetime hint: * In TLSv1.3 we reset the "time" field above, and always specify the * timeout, limited to a 1 week period per RFC8446. * For TLSv1.2 this is advisory only and we leave this unspecified for * resumed session (for simplicity). */ #define ONE_WEEK_SEC (7 * 24 * 60 * 60) if (SSL_CONNECTION_IS_TLS13(s)) { if (ossl_time_compare(s->session->timeout, ossl_seconds2time(ONE_WEEK_SEC)) > 0) timeout = ONE_WEEK_SEC; } else if (s->hit) timeout = 0; if (!WPACKET_put_bytes_u32(pkt, timeout)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (SSL_CONNECTION_IS_TLS13(s)) { if (!WPACKET_put_bytes_u32(pkt, age_add) || !WPACKET_sub_memcpy_u8(pkt, tick_nonce, TICKET_NONCE_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } /* Start the sub-packet for the actual ticket data */ if (!WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s, WPACKET *pkt, uint32_t age_add, unsigned char *tick_nonce) { unsigned char *senc = NULL; EVP_CIPHER_CTX *ctx = NULL; SSL_HMAC *hctx = NULL; unsigned char *p, *encdata1, *encdata2, *macdata1, *macdata2; const unsigned char *const_p; int len, slen_full, slen, lenfinal; SSL_SESSION *sess; size_t hlen; SSL_CTX *tctx = s->session_ctx; unsigned char iv[EVP_MAX_IV_LENGTH]; unsigned char key_name[TLSEXT_KEYNAME_LENGTH]; int iv_len; CON_FUNC_RETURN ok = CON_FUNC_ERROR; size_t macoffset, macendoffset; SSL *ssl = SSL_CONNECTION_GET_SSL(s); SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* get session encoding length */ slen_full = i2d_SSL_SESSION(s->session, NULL); /* * Some length values are 16 bits, so forget it if session is too * long */ if (slen_full == 0 || slen_full > 0xFF00) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } senc = OPENSSL_malloc(slen_full); if (senc == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } ctx = EVP_CIPHER_CTX_new(); if (ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } hctx = ssl_hmac_new(tctx); if (hctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); goto err; } p = senc; if (!i2d_SSL_SESSION(s->session, &p)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* * create a fresh copy (not shared with other threads) to clean up */ const_p = senc; sess = d2i_SSL_SESSION_ex(NULL, &const_p, slen_full, sctx->libctx, sctx->propq); if (sess == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } slen = i2d_SSL_SESSION(sess, NULL); if (slen == 0 || slen > slen_full) { /* shouldn't ever happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); SSL_SESSION_free(sess); goto err; } p = senc; if (!i2d_SSL_SESSION(sess, &p)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); SSL_SESSION_free(sess); goto err; } SSL_SESSION_free(sess); /* * Initialize HMAC and cipher contexts. If callback present it does * all the work otherwise use generated values from parent ctx. */ #ifndef OPENSSL_NO_DEPRECATED_3_0 if (tctx->ext.ticket_key_evp_cb != NULL || tctx->ext.ticket_key_cb != NULL) #else if (tctx->ext.ticket_key_evp_cb != NULL) #endif { int ret = 0; if (tctx->ext.ticket_key_evp_cb != NULL) ret = tctx->ext.ticket_key_evp_cb(ssl, key_name, iv, ctx, ssl_hmac_get0_EVP_MAC_CTX(hctx), 1); #ifndef OPENSSL_NO_DEPRECATED_3_0 else if (tctx->ext.ticket_key_cb != NULL) /* if 0 is returned, write an empty ticket */ ret = tctx->ext.ticket_key_cb(ssl, key_name, iv, ctx, ssl_hmac_get0_HMAC_CTX(hctx), 1); #endif if (ret == 0) { /* * In TLSv1.2 we construct a 0 length ticket. In TLSv1.3 a 0 * length ticket is not allowed so we abort construction of the * ticket */ if (SSL_CONNECTION_IS_TLS13(s)) { ok = CON_FUNC_DONT_SEND; goto err; } /* Put timeout and length */ if (!WPACKET_put_bytes_u32(pkt, 0) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } OPENSSL_free(senc); EVP_CIPHER_CTX_free(ctx); ssl_hmac_free(hctx); return CON_FUNC_SUCCESS; } if (ret < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED); goto err; } iv_len = EVP_CIPHER_CTX_get_iv_length(ctx); if (iv_len < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } else { EVP_CIPHER *cipher = EVP_CIPHER_fetch(sctx->libctx, "AES-256-CBC", sctx->propq); if (cipher == NULL) { /* Error is already recorded */ SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); goto err; } iv_len = EVP_CIPHER_get_iv_length(cipher); if (iv_len < 0 || RAND_bytes_ex(sctx->libctx, iv, iv_len, 0) <= 0 || !EVP_EncryptInit_ex(ctx, cipher, NULL, tctx->ext.secure->tick_aes_key, iv) || !ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key, sizeof(tctx->ext.secure->tick_hmac_key), "SHA256")) { EVP_CIPHER_free(cipher); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } EVP_CIPHER_free(cipher); memcpy(key_name, tctx->ext.tick_key_name, sizeof(tctx->ext.tick_key_name)); } if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) { /* SSLfatal() already called */ goto err; } if (!WPACKET_get_total_written(pkt, &macoffset) /* Output key name */ || !WPACKET_memcpy(pkt, key_name, sizeof(key_name)) /* output IV */ || !WPACKET_memcpy(pkt, iv, iv_len) || !WPACKET_reserve_bytes(pkt, slen + EVP_MAX_BLOCK_LENGTH, &encdata1) /* Encrypt session data */ || !EVP_EncryptUpdate(ctx, encdata1, &len, senc, slen) || !WPACKET_allocate_bytes(pkt, len, &encdata2) || encdata1 != encdata2 || !EVP_EncryptFinal(ctx, encdata1 + len, &lenfinal) || !WPACKET_allocate_bytes(pkt, lenfinal, &encdata2) || encdata1 + len != encdata2 || len + lenfinal > slen + EVP_MAX_BLOCK_LENGTH || !WPACKET_get_total_written(pkt, &macendoffset) || !ssl_hmac_update(hctx, (unsigned char *)s->init_buf->data + macoffset, macendoffset - macoffset) || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &macdata1) || !ssl_hmac_final(hctx, macdata1, &hlen, EVP_MAX_MD_SIZE) || hlen > EVP_MAX_MD_SIZE || !WPACKET_allocate_bytes(pkt, hlen, &macdata2) || macdata1 != macdata2) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Close the sub-packet created by create_ticket_prequel() */ if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ok = CON_FUNC_SUCCESS; err: OPENSSL_free(senc); EVP_CIPHER_CTX_free(ctx); ssl_hmac_free(hctx); return ok; } static int construct_stateful_ticket(SSL_CONNECTION *s, WPACKET *pkt, uint32_t age_add, unsigned char *tick_nonce) { if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) { /* SSLfatal() already called */ return 0; } if (!WPACKET_memcpy(pkt, s->session->session_id, s->session->session_id_length) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } static void tls_update_ticket_counts(SSL_CONNECTION *s) { /* * Increment both |sent_tickets| and |next_ticket_nonce|. |sent_tickets| * gets reset to 0 if we send more tickets following a post-handshake * auth, but |next_ticket_nonce| does not. If we're sending extra * tickets, decrement the count of pending extra tickets. */ s->sent_tickets++; s->next_ticket_nonce++; if (s->ext.extra_tickets_expected > 0) s->ext.extra_tickets_expected--; } CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt) { SSL_CTX *tctx = s->session_ctx; unsigned char tick_nonce[TICKET_NONCE_SIZE]; union { unsigned char age_add_c[sizeof(uint32_t)]; uint32_t age_add; } age_add_u; CON_FUNC_RETURN ret = CON_FUNC_ERROR; age_add_u.age_add = 0; if (SSL_CONNECTION_IS_TLS13(s)) { size_t i, hashlen; uint64_t nonce; static const unsigned char nonce_label[] = "resumption"; const EVP_MD *md = ssl_handshake_md(s); int hashleni = EVP_MD_get_size(md); /* Ensure cast to size_t is safe */ if (!ossl_assert(hashleni >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hashlen = (size_t)hashleni; /* * If we already sent one NewSessionTicket, or we resumed then * s->session may already be in a cache and so we must not modify it. * Instead we need to take a copy of it and modify that. */ if (s->sent_tickets != 0 || s->hit) { SSL_SESSION *new_sess = ssl_session_dup(s->session, 0); if (new_sess == NULL) { /* SSLfatal already called */ goto err; } SSL_SESSION_free(s->session); s->session = new_sess; } if (!ssl_generate_session_id(s, s->session)) { /* SSLfatal() already called */ goto err; } if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, age_add_u.age_add_c, sizeof(age_add_u), 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } s->session->ext.tick_age_add = age_add_u.age_add; nonce = s->next_ticket_nonce; for (i = TICKET_NONCE_SIZE; i > 0; i--) { tick_nonce[i - 1] = (unsigned char)(nonce & 0xff); nonce >>= 8; } if (!tls13_hkdf_expand(s, md, s->resumption_master_secret, nonce_label, sizeof(nonce_label) - 1, tick_nonce, TICKET_NONCE_SIZE, s->session->master_key, hashlen, 1)) { /* SSLfatal() already called */ goto err; } s->session->master_key_length = hashlen; s->session->time = ossl_time_now(); ssl_session_calculate_timeout(s->session); if (s->s3.alpn_selected != NULL) { OPENSSL_free(s->session->ext.alpn_selected); s->session->ext.alpn_selected = OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len); if (s->session->ext.alpn_selected == NULL) { s->session->ext.alpn_selected_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } s->session->ext.alpn_selected_len = s->s3.alpn_selected_len; } s->session->ext.max_early_data = s->max_early_data; } if (tctx->generate_ticket_cb != NULL && tctx->generate_ticket_cb(SSL_CONNECTION_GET_SSL(s), tctx->ticket_cb_data) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* * If we are using anti-replay protection then we behave as if * SSL_OP_NO_TICKET is set - we are caching tickets anyway so there * is no point in using full stateless tickets. */ if (SSL_CONNECTION_IS_TLS13(s) && ((s->options & SSL_OP_NO_TICKET) != 0 || (s->max_early_data > 0 && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0))) { if (!construct_stateful_ticket(s, pkt, age_add_u.age_add, tick_nonce)) { /* SSLfatal() already called */ goto err; } } else { CON_FUNC_RETURN tmpret; tmpret = construct_stateless_ticket(s, pkt, age_add_u.age_add, tick_nonce); if (tmpret != CON_FUNC_SUCCESS) { if (tmpret == CON_FUNC_DONT_SEND) { /* Non-fatal. Abort construction but continue */ ret = CON_FUNC_DONT_SEND; /* We count this as a success so update the counts anwyay */ tls_update_ticket_counts(s); } /* else SSLfatal() already called */ goto err; } } if (SSL_CONNECTION_IS_TLS13(s)) { if (!tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_NEW_SESSION_TICKET, NULL, 0)) { /* SSLfatal() already called */ goto err; } tls_update_ticket_counts(s); ssl_update_cache(s, SSL_SESS_CACHE_SERVER); } ret = CON_FUNC_SUCCESS; err: return ret; } /* * In TLSv1.3 this is called from the extensions code, otherwise it is used to * create a separate message. Returns 1 on success or 0 on failure. */ int tls_construct_cert_status_body(SSL_CONNECTION *s, WPACKET *pkt) { if (!WPACKET_put_bytes_u8(pkt, s->ext.status_type) || !WPACKET_sub_memcpy_u24(pkt, s->ext.ocsp.resp, s->ext.ocsp.resp_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } CON_FUNC_RETURN tls_construct_cert_status(SSL_CONNECTION *s, WPACKET *pkt) { if (!tls_construct_cert_status_body(s, pkt)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } #ifndef OPENSSL_NO_NEXTPROTONEG /* * tls_process_next_proto reads a Next Protocol Negotiation handshake message. * It sets the next_proto member in s if found */ MSG_PROCESS_RETURN tls_process_next_proto(SSL_CONNECTION *s, PACKET *pkt) { PACKET next_proto, padding; size_t next_proto_len; /*- * The payload looks like: * uint8 proto_len; * uint8 proto[proto_len]; * uint8 padding_len; * uint8 padding[padding_len]; */ if (!PACKET_get_length_prefixed_1(pkt, &next_proto) || !PACKET_get_length_prefixed_1(pkt, &padding) || PACKET_remaining(pkt) > 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if (!PACKET_memdup(&next_proto, &s->ext.npn, &next_proto_len)) { s->ext.npn_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } s->ext.npn_len = (unsigned char)next_proto_len; return MSG_PROCESS_CONTINUE_READING; } #endif static CON_FUNC_RETURN tls_construct_encrypted_extensions(SSL_CONNECTION *s, WPACKET *pkt) { if (!tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, NULL, 0)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION *s, PACKET *pkt) { if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if (s->early_data_state != SSL_EARLY_DATA_READING && s->early_data_state != SSL_EARLY_DATA_READ_RETRY) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } /* * EndOfEarlyData signals a key change so the end of the message must be on * a record boundary. */ if (RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); return MSG_PROCESS_ERROR; } s->early_data_state = SSL_EARLY_DATA_FINISHED_READING; if (!SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_READ)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } return MSG_PROCESS_CONTINUE_READING; }

./openssl/ssl/statem/statem_clnt.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved * Copyright 2005 Nokia. All rights reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <time.h> #include <assert.h> #include "../ssl_local.h" #include "statem_local.h" #include <openssl/buffer.h> #include <openssl/rand.h> #include <openssl/objects.h> #include <openssl/evp.h> #include <openssl/md5.h> #include <openssl/dh.h> #include <openssl/rsa.h> #include <openssl/bn.h> #include <openssl/engine.h> #include <openssl/trace.h> #include <openssl/core_names.h> #include <openssl/param_build.h> #include "internal/cryptlib.h" static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s, PACKET *pkt); static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION *s, PACKET *pkt); static ossl_inline int cert_req_allowed(SSL_CONNECTION *s); static int key_exchange_expected(SSL_CONNECTION *s); static int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk, WPACKET *pkt); static ossl_inline int received_server_cert(SSL_CONNECTION *sc) { return sc->session->peer_rpk != NULL || sc->session->peer != NULL; } /* * Is a CertificateRequest message allowed at the moment or not? * * Return values are: * 1: Yes * 0: No */ static ossl_inline int cert_req_allowed(SSL_CONNECTION *s) { /* TLS does not like anon-DH with client cert */ if ((s->version > SSL3_VERSION && (s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL)) || (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aSRP | SSL_aPSK))) return 0; return 1; } /* * Should we expect the ServerKeyExchange message or not? * * Return values are: * 1: Yes * 0: No */ static int key_exchange_expected(SSL_CONNECTION *s) { long alg_k = s->s3.tmp.new_cipher->algorithm_mkey; /* * Can't skip server key exchange if this is an ephemeral * ciphersuite or for SRP */ if (alg_k & (SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK | SSL_kSRP)) { return 1; } return 0; } /* * ossl_statem_client_read_transition() encapsulates the logic for the allowed * handshake state transitions when a TLS1.3 client is reading messages from the * server. The message type that the server has sent is provided in |mt|. The * current state is in |s->statem.hand_state|. * * Return values are 1 for success (transition allowed) and 0 on error * (transition not allowed) */ static int ossl_statem_client13_read_transition(SSL_CONNECTION *s, int mt) { OSSL_STATEM *st = &s->statem; /* * Note: There is no case for TLS_ST_CW_CLNT_HELLO, because we haven't * yet negotiated TLSv1.3 at that point so that is handled by * ossl_statem_client_read_transition() */ switch (st->hand_state) { default: break; case TLS_ST_CW_CLNT_HELLO: /* * This must a ClientHello following a HelloRetryRequest, so the only * thing we can get now is a ServerHello. */ if (mt == SSL3_MT_SERVER_HELLO) { st->hand_state = TLS_ST_CR_SRVR_HELLO; return 1; } break; case TLS_ST_CR_SRVR_HELLO: if (mt == SSL3_MT_ENCRYPTED_EXTENSIONS) { st->hand_state = TLS_ST_CR_ENCRYPTED_EXTENSIONS; return 1; } break; case TLS_ST_CR_ENCRYPTED_EXTENSIONS: if (s->hit) { if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_CR_FINISHED; return 1; } } else { if (mt == SSL3_MT_CERTIFICATE_REQUEST) { st->hand_state = TLS_ST_CR_CERT_REQ; return 1; } if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_CR_CERT; return 1; } #ifndef OPENSSL_NO_COMP_ALG if (mt == SSL3_MT_COMPRESSED_CERTIFICATE && s->ext.compress_certificate_sent) { st->hand_state = TLS_ST_CR_COMP_CERT; return 1; } #endif } break; case TLS_ST_CR_CERT_REQ: if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_CR_CERT; return 1; } #ifndef OPENSSL_NO_COMP_ALG if (mt == SSL3_MT_COMPRESSED_CERTIFICATE && s->ext.compress_certificate_sent) { st->hand_state = TLS_ST_CR_COMP_CERT; return 1; } #endif break; case TLS_ST_CR_CERT: case TLS_ST_CR_COMP_CERT: if (mt == SSL3_MT_CERTIFICATE_VERIFY) { st->hand_state = TLS_ST_CR_CERT_VRFY; return 1; } break; case TLS_ST_CR_CERT_VRFY: if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_CR_FINISHED; return 1; } break; case TLS_ST_OK: if (mt == SSL3_MT_NEWSESSION_TICKET) { st->hand_state = TLS_ST_CR_SESSION_TICKET; return 1; } if (mt == SSL3_MT_KEY_UPDATE && !SSL_IS_QUIC_HANDSHAKE(s)) { st->hand_state = TLS_ST_CR_KEY_UPDATE; return 1; } if (mt == SSL3_MT_CERTIFICATE_REQUEST) { #if DTLS_MAX_VERSION_INTERNAL != DTLS1_2_VERSION /* Restore digest for PHA before adding message.*/ # error Internal DTLS version error #endif if (!SSL_CONNECTION_IS_DTLS(s) && s->post_handshake_auth == SSL_PHA_EXT_SENT) { s->post_handshake_auth = SSL_PHA_REQUESTED; /* * In TLS, this is called before the message is added to the * digest. In DTLS, this is expected to be called after adding * to the digest. Either move the digest restore, or add the * message here after the swap, or do it after the clientFinished? */ if (!tls13_restore_handshake_digest_for_pha(s)) { /* SSLfatal() already called */ return 0; } st->hand_state = TLS_ST_CR_CERT_REQ; return 1; } } break; } /* No valid transition found */ return 0; } /* * ossl_statem_client_read_transition() encapsulates the logic for the allowed * handshake state transitions when the client is reading messages from the * server. The message type that the server has sent is provided in |mt|. The * current state is in |s->statem.hand_state|. * * Return values are 1 for success (transition allowed) and 0 on error * (transition not allowed) */ int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt) { OSSL_STATEM *st = &s->statem; int ske_expected; /* * Note that after writing the first ClientHello we don't know what version * we are going to negotiate yet, so we don't take this branch until later. */ if (SSL_CONNECTION_IS_TLS13(s)) { if (!ossl_statem_client13_read_transition(s, mt)) goto err; return 1; } switch (st->hand_state) { default: break; case TLS_ST_CW_CLNT_HELLO: if (mt == SSL3_MT_SERVER_HELLO) { st->hand_state = TLS_ST_CR_SRVR_HELLO; return 1; } if (SSL_CONNECTION_IS_DTLS(s)) { if (mt == DTLS1_MT_HELLO_VERIFY_REQUEST) { st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST; return 1; } } break; case TLS_ST_EARLY_DATA: /* * We've not actually selected TLSv1.3 yet, but we have sent early * data. The only thing allowed now is a ServerHello or a * HelloRetryRequest. */ if (mt == SSL3_MT_SERVER_HELLO) { st->hand_state = TLS_ST_CR_SRVR_HELLO; return 1; } break; case TLS_ST_CR_SRVR_HELLO: if (s->hit) { if (s->ext.ticket_expected) { if (mt == SSL3_MT_NEWSESSION_TICKET) { st->hand_state = TLS_ST_CR_SESSION_TICKET; return 1; } } else if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_CR_CHANGE; return 1; } } else { if (SSL_CONNECTION_IS_DTLS(s) && mt == DTLS1_MT_HELLO_VERIFY_REQUEST) { st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST; return 1; } else if (s->version >= TLS1_VERSION && s->ext.session_secret_cb != NULL && s->session->ext.tick != NULL && mt == SSL3_MT_CHANGE_CIPHER_SPEC) { /* * Normally, we can tell if the server is resuming the session * from the session ID. EAP-FAST (RFC 4851), however, relies on * the next server message after the ServerHello to determine if * the server is resuming. */ s->hit = 1; st->hand_state = TLS_ST_CR_CHANGE; return 1; } else if (!(s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP | SSL_aPSK))) { if (mt == SSL3_MT_CERTIFICATE) { st->hand_state = TLS_ST_CR_CERT; return 1; } } else { ske_expected = key_exchange_expected(s); /* SKE is optional for some PSK ciphersuites */ if (ske_expected || ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK) && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) { if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) { st->hand_state = TLS_ST_CR_KEY_EXCH; return 1; } } else if (mt == SSL3_MT_CERTIFICATE_REQUEST && cert_req_allowed(s)) { st->hand_state = TLS_ST_CR_CERT_REQ; return 1; } else if (mt == SSL3_MT_SERVER_DONE) { st->hand_state = TLS_ST_CR_SRVR_DONE; return 1; } } } break; case TLS_ST_CR_CERT: case TLS_ST_CR_COMP_CERT: /* * The CertificateStatus message is optional even if * |ext.status_expected| is set */ if (s->ext.status_expected && mt == SSL3_MT_CERTIFICATE_STATUS) { st->hand_state = TLS_ST_CR_CERT_STATUS; return 1; } /* Fall through */ case TLS_ST_CR_CERT_STATUS: ske_expected = key_exchange_expected(s); /* SKE is optional for some PSK ciphersuites */ if (ske_expected || ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK) && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) { if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) { st->hand_state = TLS_ST_CR_KEY_EXCH; return 1; } goto err; } /* Fall through */ case TLS_ST_CR_KEY_EXCH: if (mt == SSL3_MT_CERTIFICATE_REQUEST) { if (cert_req_allowed(s)) { st->hand_state = TLS_ST_CR_CERT_REQ; return 1; } goto err; } /* Fall through */ case TLS_ST_CR_CERT_REQ: if (mt == SSL3_MT_SERVER_DONE) { st->hand_state = TLS_ST_CR_SRVR_DONE; return 1; } break; case TLS_ST_CW_FINISHED: if (s->ext.ticket_expected) { if (mt == SSL3_MT_NEWSESSION_TICKET) { st->hand_state = TLS_ST_CR_SESSION_TICKET; return 1; } } else if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_CR_CHANGE; return 1; } break; case TLS_ST_CR_SESSION_TICKET: if (mt == SSL3_MT_CHANGE_CIPHER_SPEC) { st->hand_state = TLS_ST_CR_CHANGE; return 1; } break; case TLS_ST_CR_CHANGE: if (mt == SSL3_MT_FINISHED) { st->hand_state = TLS_ST_CR_FINISHED; return 1; } break; case TLS_ST_OK: if (mt == SSL3_MT_HELLO_REQUEST) { st->hand_state = TLS_ST_CR_HELLO_REQ; return 1; } break; } err: /* No valid transition found */ if (SSL_CONNECTION_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) { BIO *rbio; /* * CCS messages don't have a message sequence number so this is probably * because of an out-of-order CCS. We'll just drop it. */ s->init_num = 0; s->rwstate = SSL_READING; rbio = SSL_get_rbio(SSL_CONNECTION_GET_SSL(s)); BIO_clear_retry_flags(rbio); BIO_set_retry_read(rbio); return 0; } SSLfatal(s, SSL3_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); return 0; } static int do_compressed_cert(SSL_CONNECTION *sc) { /* If we negotiated RPK, we won't try to compress it */ return sc->ext.client_cert_type == TLSEXT_cert_type_x509 && sc->ext.compress_certificate_from_peer[0] != TLSEXT_comp_cert_none; } /* * ossl_statem_client13_write_transition() works out what handshake state to * move to next when the TLSv1.3 client is writing messages to be sent to the * server. */ static WRITE_TRAN ossl_statem_client13_write_transition(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; /* * Note: There are no cases for TLS_ST_BEFORE because we haven't negotiated * TLSv1.3 yet at that point. They are handled by * ossl_statem_client_write_transition(). */ switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; case TLS_ST_CR_CERT_REQ: if (s->post_handshake_auth == SSL_PHA_REQUESTED) { if (do_compressed_cert(s)) st->hand_state = TLS_ST_CW_COMP_CERT; else st->hand_state = TLS_ST_CW_CERT; return WRITE_TRAN_CONTINUE; } /* * We should only get here if we received a CertificateRequest after * we already sent close_notify */ if (!ossl_assert((s->shutdown & SSL_SENT_SHUTDOWN) != 0)) { /* Shouldn't happen - same as default case */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; } st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_CR_FINISHED: if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY || s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING) st->hand_state = TLS_ST_PENDING_EARLY_DATA_END; else if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0 && s->hello_retry_request == SSL_HRR_NONE) st->hand_state = TLS_ST_CW_CHANGE; else if (s->s3.tmp.cert_req == 0) st->hand_state = TLS_ST_CW_FINISHED; else if (do_compressed_cert(s)) st->hand_state = TLS_ST_CW_COMP_CERT; else st->hand_state = TLS_ST_CW_CERT; s->ts_msg_read = ossl_time_now(); return WRITE_TRAN_CONTINUE; case TLS_ST_PENDING_EARLY_DATA_END: if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED) { st->hand_state = TLS_ST_CW_END_OF_EARLY_DATA; return WRITE_TRAN_CONTINUE; } /* Fall through */ case TLS_ST_CW_END_OF_EARLY_DATA: case TLS_ST_CW_CHANGE: if (s->s3.tmp.cert_req == 0) st->hand_state = TLS_ST_CW_FINISHED; else if (do_compressed_cert(s)) st->hand_state = TLS_ST_CW_COMP_CERT; else st->hand_state = TLS_ST_CW_CERT; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_COMP_CERT: case TLS_ST_CW_CERT: /* If a non-empty Certificate we also send CertificateVerify */ st->hand_state = (s->s3.tmp.cert_req == 1) ? TLS_ST_CW_CERT_VRFY : TLS_ST_CW_FINISHED; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CERT_VRFY: st->hand_state = TLS_ST_CW_FINISHED; return WRITE_TRAN_CONTINUE; case TLS_ST_CR_KEY_UPDATE: case TLS_ST_CW_KEY_UPDATE: case TLS_ST_CR_SESSION_TICKET: case TLS_ST_CW_FINISHED: st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; case TLS_ST_OK: if (s->key_update != SSL_KEY_UPDATE_NONE) { st->hand_state = TLS_ST_CW_KEY_UPDATE; return WRITE_TRAN_CONTINUE; } /* Try to read from the server instead */ return WRITE_TRAN_FINISHED; } } /* * ossl_statem_client_write_transition() works out what handshake state to * move to next when the client is writing messages to be sent to the server. */ WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; /* * Note that immediately before/after a ClientHello we don't know what * version we are going to negotiate yet, so we don't take this branch until * later */ if (SSL_CONNECTION_IS_TLS13(s)) return ossl_statem_client13_write_transition(s); switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WRITE_TRAN_ERROR; case TLS_ST_OK: if (!s->renegotiate) { /* * We haven't requested a renegotiation ourselves so we must have * received a message from the server. Better read it. */ return WRITE_TRAN_FINISHED; } /* Renegotiation */ /* fall thru */ case TLS_ST_BEFORE: st->hand_state = TLS_ST_CW_CLNT_HELLO; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CLNT_HELLO: if (s->early_data_state == SSL_EARLY_DATA_CONNECTING) { /* * We are assuming this is a TLSv1.3 connection, although we haven't * actually selected a version yet. */ if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) st->hand_state = TLS_ST_CW_CHANGE; else st->hand_state = TLS_ST_EARLY_DATA; return WRITE_TRAN_CONTINUE; } /* * No transition at the end of writing because we don't know what * we will be sent */ s->ts_msg_write = ossl_time_now(); return WRITE_TRAN_FINISHED; case TLS_ST_CR_SRVR_HELLO: /* * We only get here in TLSv1.3. We just received an HRR, so issue a * CCS unless middlebox compat mode is off, or we already issued one * because we did early data. */ if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0 && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) st->hand_state = TLS_ST_CW_CHANGE; else st->hand_state = TLS_ST_CW_CLNT_HELLO; return WRITE_TRAN_CONTINUE; case TLS_ST_EARLY_DATA: s->ts_msg_write = ossl_time_now(); return WRITE_TRAN_FINISHED; case DTLS_ST_CR_HELLO_VERIFY_REQUEST: st->hand_state = TLS_ST_CW_CLNT_HELLO; return WRITE_TRAN_CONTINUE; case TLS_ST_CR_SRVR_DONE: s->ts_msg_read = ossl_time_now(); if (s->s3.tmp.cert_req) st->hand_state = TLS_ST_CW_CERT; else st->hand_state = TLS_ST_CW_KEY_EXCH; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CERT: st->hand_state = TLS_ST_CW_KEY_EXCH; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_KEY_EXCH: /* * For TLS, cert_req is set to 2, so a cert chain of nothing is * sent, but no verify packet is sent */ /* * XXX: For now, we do not support client authentication in ECDH * cipher suites with ECDH (rather than ECDSA) certificates. We * need to skip the certificate verify message when client's * ECDH public key is sent inside the client certificate. */ if (s->s3.tmp.cert_req == 1) { st->hand_state = TLS_ST_CW_CERT_VRFY; } else { st->hand_state = TLS_ST_CW_CHANGE; } if (s->s3.flags & TLS1_FLAGS_SKIP_CERT_VERIFY) { st->hand_state = TLS_ST_CW_CHANGE; } return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CERT_VRFY: st->hand_state = TLS_ST_CW_CHANGE; return WRITE_TRAN_CONTINUE; case TLS_ST_CW_CHANGE: if (s->hello_retry_request == SSL_HRR_PENDING) { st->hand_state = TLS_ST_CW_CLNT_HELLO; } else if (s->early_data_state == SSL_EARLY_DATA_CONNECTING) { st->hand_state = TLS_ST_EARLY_DATA; } else { #if defined(OPENSSL_NO_NEXTPROTONEG) st->hand_state = TLS_ST_CW_FINISHED; #else if (!SSL_CONNECTION_IS_DTLS(s) && s->s3.npn_seen) st->hand_state = TLS_ST_CW_NEXT_PROTO; else st->hand_state = TLS_ST_CW_FINISHED; #endif } return WRITE_TRAN_CONTINUE; #if !defined(OPENSSL_NO_NEXTPROTONEG) case TLS_ST_CW_NEXT_PROTO: st->hand_state = TLS_ST_CW_FINISHED; return WRITE_TRAN_CONTINUE; #endif case TLS_ST_CW_FINISHED: if (s->hit) { st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } else { return WRITE_TRAN_FINISHED; } case TLS_ST_CR_FINISHED: if (s->hit) { st->hand_state = TLS_ST_CW_CHANGE; return WRITE_TRAN_CONTINUE; } else { st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } case TLS_ST_CR_HELLO_REQ: /* * If we can renegotiate now then do so, otherwise wait for a more * convenient time. */ if (ssl3_renegotiate_check(SSL_CONNECTION_GET_SSL(s), 1)) { if (!tls_setup_handshake(s)) { /* SSLfatal() already called */ return WRITE_TRAN_ERROR; } st->hand_state = TLS_ST_CW_CLNT_HELLO; return WRITE_TRAN_CONTINUE; } st->hand_state = TLS_ST_OK; return WRITE_TRAN_CONTINUE; } } /* * Perform any pre work that needs to be done prior to sending a message from * the client to the server. */ WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION *s, WORK_STATE wst) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* No pre work to be done */ break; case TLS_ST_CW_CLNT_HELLO: s->shutdown = 0; if (SSL_CONNECTION_IS_DTLS(s)) { /* every DTLS ClientHello resets Finished MAC */ if (!ssl3_init_finished_mac(s)) { /* SSLfatal() already called */ return WORK_ERROR; } } else if (s->ext.early_data == SSL_EARLY_DATA_REJECTED) { /* * This must be a second ClientHello after an HRR following an * earlier rejected attempt to send early data. Since we were * previously encrypting the early data we now need to reset the * write record layer in order to write in plaintext again. */ if (!ssl_set_new_record_layer(s, TLS_ANY_VERSION, OSSL_RECORD_DIRECTION_WRITE, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL)) { /* SSLfatal already called */ return WORK_ERROR; } } break; case TLS_ST_CW_CHANGE: if (SSL_CONNECTION_IS_DTLS(s)) { if (s->hit) { /* * We're into the last flight so we don't retransmit these * messages unless we need to. */ st->use_timer = 0; } #ifndef OPENSSL_NO_SCTP if (BIO_dgram_is_sctp(SSL_get_wbio(SSL_CONNECTION_GET_SSL(s)))) { /* Calls SSLfatal() as required */ return dtls_wait_for_dry(s); } #endif } break; case TLS_ST_PENDING_EARLY_DATA_END: /* * If we've been called by SSL_do_handshake()/SSL_write(), or we did not * attempt to write early data before calling SSL_read() then we press * on with the handshake. Otherwise we pause here. */ if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING || s->early_data_state == SSL_EARLY_DATA_NONE) return WORK_FINISHED_CONTINUE; /* Fall through */ case TLS_ST_EARLY_DATA: return tls_finish_handshake(s, wst, 0, 1); case TLS_ST_OK: /* Calls SSLfatal() as required */ return tls_finish_handshake(s, wst, 1, 1); } return WORK_FINISHED_CONTINUE; } /* * Perform any work that needs to be done after sending a message from the * client to the server. */ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst) { OSSL_STATEM *st = &s->statem; SSL *ssl = SSL_CONNECTION_GET_SSL(s); s->init_num = 0; switch (st->hand_state) { default: /* No post work to be done */ break; case TLS_ST_CW_CLNT_HELLO: if (s->early_data_state == SSL_EARLY_DATA_CONNECTING && s->max_early_data > 0) { /* * We haven't selected TLSv1.3 yet so we don't call the change * cipher state function associated with the SSL_METHOD. Instead * we call tls13_change_cipher_state() directly. */ if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0) { if (!tls13_change_cipher_state(s, SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_CLIENT_WRITE)) { /* SSLfatal() already called */ return WORK_ERROR; } } /* else we're in compat mode so we delay flushing until after CCS */ } else if (!statem_flush(s)) { return WORK_MORE_A; } if (SSL_CONNECTION_IS_DTLS(s)) { /* Treat the next message as the first packet */ s->first_packet = 1; } break; case TLS_ST_CW_KEY_EXCH: if (tls_client_key_exchange_post_work(s) == 0) { /* SSLfatal() already called */ return WORK_ERROR; } break; case TLS_ST_CW_CHANGE: if (SSL_CONNECTION_IS_TLS13(s) || s->hello_retry_request == SSL_HRR_PENDING) break; if (s->early_data_state == SSL_EARLY_DATA_CONNECTING && s->max_early_data > 0) { /* * We haven't selected TLSv1.3 yet so we don't call the change * cipher state function associated with the SSL_METHOD. Instead * we call tls13_change_cipher_state() directly. */ if (!tls13_change_cipher_state(s, SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_CLIENT_WRITE)) return WORK_ERROR; break; } s->session->cipher = s->s3.tmp.new_cipher; #ifdef OPENSSL_NO_COMP s->session->compress_meth = 0; #else if (s->s3.tmp.new_compression == NULL) s->session->compress_meth = 0; else s->session->compress_meth = s->s3.tmp.new_compression->id; #endif if (!ssl->method->ssl3_enc->setup_key_block(s)) { /* SSLfatal() already called */ return WORK_ERROR; } if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CHANGE_CIPHER_CLIENT_WRITE)) { /* SSLfatal() already called */ return WORK_ERROR; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && s->hit) { /* * Change to new shared key of SCTP-Auth, will be ignored if * no SCTP used. */ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL); } #endif break; case TLS_ST_CW_FINISHED: #ifndef OPENSSL_NO_SCTP if (wst == WORK_MORE_A && SSL_CONNECTION_IS_DTLS(s) && s->hit == 0) { /* * Change to new shared key of SCTP-Auth, will be ignored if * no SCTP used. */ BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY, 0, NULL); } #endif if (statem_flush(s) != 1) return WORK_MORE_B; if (SSL_CONNECTION_IS_TLS13(s)) { if (!tls13_save_handshake_digest_for_pha(s)) { /* SSLfatal() already called */ return WORK_ERROR; } if (s->post_handshake_auth != SSL_PHA_REQUESTED) { if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_WRITE)) { /* SSLfatal() already called */ return WORK_ERROR; } } } break; case TLS_ST_CW_KEY_UPDATE: if (statem_flush(s) != 1) return WORK_MORE_A; if (!tls13_update_key(s, 1)) { /* SSLfatal() already called */ return WORK_ERROR; } break; } return WORK_FINISHED_CONTINUE; } /* * Get the message construction function and message type for sending from the * client * * Valid return values are: * 1: Success * 0: Error */ int ossl_statem_client_construct_message(SSL_CONNECTION *s, confunc_f *confunc, int *mt) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_STATE); return 0; case TLS_ST_CW_CHANGE: if (SSL_CONNECTION_IS_DTLS(s)) *confunc = dtls_construct_change_cipher_spec; else *confunc = tls_construct_change_cipher_spec; *mt = SSL3_MT_CHANGE_CIPHER_SPEC; break; case TLS_ST_CW_CLNT_HELLO: *confunc = tls_construct_client_hello; *mt = SSL3_MT_CLIENT_HELLO; break; case TLS_ST_CW_END_OF_EARLY_DATA: *confunc = tls_construct_end_of_early_data; *mt = SSL3_MT_END_OF_EARLY_DATA; break; case TLS_ST_PENDING_EARLY_DATA_END: *confunc = NULL; *mt = SSL3_MT_DUMMY; break; case TLS_ST_CW_CERT: *confunc = tls_construct_client_certificate; *mt = SSL3_MT_CERTIFICATE; break; #ifndef OPENSSL_NO_COMP_ALG case TLS_ST_CW_COMP_CERT: *confunc = tls_construct_client_compressed_certificate; *mt = SSL3_MT_COMPRESSED_CERTIFICATE; break; #endif case TLS_ST_CW_KEY_EXCH: *confunc = tls_construct_client_key_exchange; *mt = SSL3_MT_CLIENT_KEY_EXCHANGE; break; case TLS_ST_CW_CERT_VRFY: *confunc = tls_construct_cert_verify; *mt = SSL3_MT_CERTIFICATE_VERIFY; break; #if !defined(OPENSSL_NO_NEXTPROTONEG) case TLS_ST_CW_NEXT_PROTO: *confunc = tls_construct_next_proto; *mt = SSL3_MT_NEXT_PROTO; break; #endif case TLS_ST_CW_FINISHED: *confunc = tls_construct_finished; *mt = SSL3_MT_FINISHED; break; case TLS_ST_CW_KEY_UPDATE: *confunc = tls_construct_key_update; *mt = SSL3_MT_KEY_UPDATE; break; } return 1; } /* * Returns the maximum allowed length for the current message that we are * reading. Excludes the message header. */ size_t ossl_statem_client_max_message_size(SSL_CONNECTION *s) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen */ return 0; case TLS_ST_CR_SRVR_HELLO: return SERVER_HELLO_MAX_LENGTH; case DTLS_ST_CR_HELLO_VERIFY_REQUEST: return HELLO_VERIFY_REQUEST_MAX_LENGTH; case TLS_ST_CR_COMP_CERT: case TLS_ST_CR_CERT: return s->max_cert_list; case TLS_ST_CR_CERT_VRFY: return CERTIFICATE_VERIFY_MAX_LENGTH; case TLS_ST_CR_CERT_STATUS: return SSL3_RT_MAX_PLAIN_LENGTH; case TLS_ST_CR_KEY_EXCH: return SERVER_KEY_EXCH_MAX_LENGTH; case TLS_ST_CR_CERT_REQ: /* * Set to s->max_cert_list for compatibility with previous releases. In * practice these messages can get quite long if servers are configured * to provide a long list of acceptable CAs */ return s->max_cert_list; case TLS_ST_CR_SRVR_DONE: return SERVER_HELLO_DONE_MAX_LENGTH; case TLS_ST_CR_CHANGE: if (s->version == DTLS1_BAD_VER) return 3; return CCS_MAX_LENGTH; case TLS_ST_CR_SESSION_TICKET: return (SSL_CONNECTION_IS_TLS13(s)) ? SESSION_TICKET_MAX_LENGTH_TLS13 : SESSION_TICKET_MAX_LENGTH_TLS12; case TLS_ST_CR_FINISHED: return FINISHED_MAX_LENGTH; case TLS_ST_CR_ENCRYPTED_EXTENSIONS: return ENCRYPTED_EXTENSIONS_MAX_LENGTH; case TLS_ST_CR_KEY_UPDATE: return KEY_UPDATE_MAX_LENGTH; } } /* * Process a message that the client has received from the server. */ MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION *s, PACKET *pkt) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; case TLS_ST_CR_SRVR_HELLO: return tls_process_server_hello(s, pkt); case DTLS_ST_CR_HELLO_VERIFY_REQUEST: return dtls_process_hello_verify(s, pkt); case TLS_ST_CR_CERT: return tls_process_server_certificate(s, pkt); #ifndef OPENSSL_NO_COMP_ALG case TLS_ST_CR_COMP_CERT: return tls_process_server_compressed_certificate(s, pkt); #endif case TLS_ST_CR_CERT_VRFY: return tls_process_cert_verify(s, pkt); case TLS_ST_CR_CERT_STATUS: return tls_process_cert_status(s, pkt); case TLS_ST_CR_KEY_EXCH: return tls_process_key_exchange(s, pkt); case TLS_ST_CR_CERT_REQ: return tls_process_certificate_request(s, pkt); case TLS_ST_CR_SRVR_DONE: return tls_process_server_done(s, pkt); case TLS_ST_CR_CHANGE: return tls_process_change_cipher_spec(s, pkt); case TLS_ST_CR_SESSION_TICKET: return tls_process_new_session_ticket(s, pkt); case TLS_ST_CR_FINISHED: return tls_process_finished(s, pkt); case TLS_ST_CR_HELLO_REQ: return tls_process_hello_req(s, pkt); case TLS_ST_CR_ENCRYPTED_EXTENSIONS: return tls_process_encrypted_extensions(s, pkt); case TLS_ST_CR_KEY_UPDATE: return tls_process_key_update(s, pkt); } } /* * Perform any further processing required following the receipt of a message * from the server */ WORK_STATE ossl_statem_client_post_process_message(SSL_CONNECTION *s, WORK_STATE wst) { OSSL_STATEM *st = &s->statem; switch (st->hand_state) { default: /* Shouldn't happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; case TLS_ST_CR_CERT: case TLS_ST_CR_COMP_CERT: return tls_post_process_server_certificate(s, wst); case TLS_ST_CR_CERT_VRFY: case TLS_ST_CR_CERT_REQ: return tls_prepare_client_certificate(s, wst); } } CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt) { unsigned char *p; size_t sess_id_len; int i, protverr; #ifndef OPENSSL_NO_COMP SSL_COMP *comp; #endif SSL_SESSION *sess = s->session; unsigned char *session_id; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* Work out what SSL/TLS/DTLS version to use */ protverr = ssl_set_client_hello_version(s); if (protverr != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, protverr); return CON_FUNC_ERROR; } if (sess == NULL || !ssl_version_supported(s, sess->ssl_version, NULL) || !SSL_SESSION_is_resumable(sess)) { if (s->hello_retry_request == SSL_HRR_NONE && !ssl_get_new_session(s, 0)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } } /* else use the pre-loaded session */ p = s->s3.client_random; /* * for DTLS if client_random is initialized, reuse it, we are * required to use same upon reply to HelloVerify */ if (SSL_CONNECTION_IS_DTLS(s)) { size_t idx; i = 1; for (idx = 0; idx < sizeof(s->s3.client_random); idx++) { if (p[idx]) { i = 0; break; } } } else { i = (s->hello_retry_request == SSL_HRR_NONE); } if (i && ssl_fill_hello_random(s, 0, p, sizeof(s->s3.client_random), DOWNGRADE_NONE) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /*- * version indicates the negotiated version: for example from * an SSLv2/v3 compatible client hello). The client_version * field is the maximum version we permit and it is also * used in RSA encrypted premaster secrets. Some servers can * choke if we initially report a higher version then * renegotiate to a lower one in the premaster secret. This * didn't happen with TLS 1.0 as most servers supported it * but it can with TLS 1.1 or later if the server only supports * 1.0. * * Possible scenario with previous logic: * 1. Client hello indicates TLS 1.2 * 2. Server hello says TLS 1.0 * 3. RSA encrypted premaster secret uses 1.2. * 4. Handshake proceeds using TLS 1.0. * 5. Server sends hello request to renegotiate. * 6. Client hello indicates TLS v1.0 as we now * know that is maximum server supports. * 7. Server chokes on RSA encrypted premaster secret * containing version 1.0. * * For interoperability it should be OK to always use the * maximum version we support in client hello and then rely * on the checking of version to ensure the servers isn't * being inconsistent: for example initially negotiating with * TLS 1.0 and renegotiating with TLS 1.2. We do this by using * client_version in client hello and not resetting it to * the negotiated version. * * For TLS 1.3 we always set the ClientHello version to 1.2 and rely on the * supported_versions extension for the real supported versions. */ if (!WPACKET_put_bytes_u16(pkt, s->client_version) || !WPACKET_memcpy(pkt, s->s3.client_random, SSL3_RANDOM_SIZE)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* Session ID */ session_id = s->session->session_id; if (s->new_session || s->session->ssl_version == TLS1_3_VERSION) { if (s->version == TLS1_3_VERSION && (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) { sess_id_len = sizeof(s->tmp_session_id); s->tmp_session_id_len = sess_id_len; session_id = s->tmp_session_id; if (s->hello_retry_request == SSL_HRR_NONE && RAND_bytes_ex(sctx->libctx, s->tmp_session_id, sess_id_len, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } else { sess_id_len = 0; } } else { assert(s->session->session_id_length <= sizeof(s->session->session_id)); sess_id_len = s->session->session_id_length; if (s->version == TLS1_3_VERSION) { s->tmp_session_id_len = sess_id_len; memcpy(s->tmp_session_id, s->session->session_id, sess_id_len); } } if (!WPACKET_start_sub_packet_u8(pkt) || (sess_id_len != 0 && !WPACKET_memcpy(pkt, session_id, sess_id_len)) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* cookie stuff for DTLS */ if (SSL_CONNECTION_IS_DTLS(s)) { if (s->d1->cookie_len > sizeof(s->d1->cookie) || !WPACKET_sub_memcpy_u8(pkt, s->d1->cookie, s->d1->cookie_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } /* Ciphers supported */ if (!WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(SSL_CONNECTION_GET_SSL(s)), pkt)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } if (!WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* COMPRESSION */ if (!WPACKET_start_sub_packet_u8(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } #ifndef OPENSSL_NO_COMP if (ssl_allow_compression(s) && sctx->comp_methods && (SSL_CONNECTION_IS_DTLS(s) || s->s3.tmp.max_ver < TLS1_3_VERSION)) { int compnum = sk_SSL_COMP_num(sctx->comp_methods); for (i = 0; i < compnum; i++) { comp = sk_SSL_COMP_value(sctx->comp_methods, i); if (!WPACKET_put_bytes_u8(pkt, comp->id)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } } #endif /* Add the NULL method */ if (!WPACKET_put_bytes_u8(pkt, 0) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* TLS extensions */ if (!tls_construct_extensions(s, pkt, SSL_EXT_CLIENT_HELLO, NULL, 0)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } MSG_PROCESS_RETURN dtls_process_hello_verify(SSL_CONNECTION *s, PACKET *pkt) { size_t cookie_len; PACKET cookiepkt; if (!PACKET_forward(pkt, 2) || !PACKET_get_length_prefixed_1(pkt, &cookiepkt)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } cookie_len = PACKET_remaining(&cookiepkt); if (cookie_len > sizeof(s->d1->cookie)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_LENGTH_TOO_LONG); return MSG_PROCESS_ERROR; } if (!PACKET_copy_bytes(&cookiepkt, s->d1->cookie, cookie_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } s->d1->cookie_len = cookie_len; return MSG_PROCESS_FINISHED_READING; } static int set_client_ciphersuite(SSL_CONNECTION *s, const unsigned char *cipherchars) { STACK_OF(SSL_CIPHER) *sk; const SSL_CIPHER *c; int i; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); c = ssl_get_cipher_by_char(s, cipherchars, 0); if (c == NULL) { /* unknown cipher */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CIPHER_RETURNED); return 0; } /* * If it is a disabled cipher we either didn't send it in client hello, * or it's not allowed for the selected protocol. So we return an error. */ if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_CHECK, 1)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CIPHER_RETURNED); return 0; } sk = ssl_get_ciphers_by_id(s); i = sk_SSL_CIPHER_find(sk, c); if (i < 0) { /* we did not say we would use this cipher */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CIPHER_RETURNED); return 0; } if (SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.new_cipher != NULL && s->s3.tmp.new_cipher->id != c->id) { /* ServerHello selected a different ciphersuite to that in the HRR */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CIPHER_RETURNED); return 0; } /* * Depending on the session caching (internal/external), the cipher * and/or cipher_id values may not be set. Make sure that cipher_id is * set and use it for comparison. */ if (s->session->cipher != NULL) s->session->cipher_id = s->session->cipher->id; if (s->hit && (s->session->cipher_id != c->id)) { if (SSL_CONNECTION_IS_TLS13(s)) { const EVP_MD *md = ssl_md(sctx, c->algorithm2); if (!ossl_assert(s->session->cipher != NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * In TLSv1.3 it is valid for the server to select a different * ciphersuite as long as the hash is the same. */ if (md == NULL || md != ssl_md(sctx, s->session->cipher->algorithm2)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED); return 0; } } else { /* * Prior to TLSv1.3 resuming a session always meant using the same * ciphersuite. */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED); return 0; } } s->s3.tmp.new_cipher = c; return 1; } MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt) { PACKET session_id, extpkt; size_t session_id_len; const unsigned char *cipherchars; int hrr = 0; unsigned int compression; unsigned int sversion; unsigned int context; RAW_EXTENSION *extensions = NULL; SSL *ssl = SSL_CONNECTION_GET_SSL(s); #ifndef OPENSSL_NO_COMP SSL_COMP *comp; #endif if (!PACKET_get_net_2(pkt, &sversion)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } /* load the server random */ if (s->version == TLS1_3_VERSION && sversion == TLS1_2_VERSION && PACKET_remaining(pkt) >= SSL3_RANDOM_SIZE && memcmp(hrrrandom, PACKET_data(pkt), SSL3_RANDOM_SIZE) == 0) { if (s->hello_retry_request != SSL_HRR_NONE) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto err; } s->hello_retry_request = SSL_HRR_PENDING; /* Tell the record layer that we know we're going to get TLSv1.3 */ if (!ssl_set_record_protocol_version(s, s->version)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hrr = 1; if (!PACKET_forward(pkt, SSL3_RANDOM_SIZE)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } } else { if (!PACKET_copy_bytes(pkt, s->s3.server_random, SSL3_RANDOM_SIZE)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } } /* Get the session-id. */ if (!PACKET_get_length_prefixed_1(pkt, &session_id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } session_id_len = PACKET_remaining(&session_id); if (session_id_len > sizeof(s->session->session_id) || session_id_len > SSL3_SESSION_ID_SIZE) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_SESSION_ID_TOO_LONG); goto err; } if (!PACKET_get_bytes(pkt, &cipherchars, TLS_CIPHER_LEN)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!PACKET_get_1(pkt, &compression)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } /* TLS extensions */ if (PACKET_remaining(pkt) == 0 && !hrr) { PACKET_null_init(&extpkt); } else if (!PACKET_as_length_prefixed_2(pkt, &extpkt) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); goto err; } if (!hrr) { if (!tls_collect_extensions(s, &extpkt, SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO, &extensions, NULL, 1)) { /* SSLfatal() already called */ goto err; } if (!ssl_choose_client_version(s, sversion, extensions)) { /* SSLfatal() already called */ goto err; } } if (SSL_CONNECTION_IS_TLS13(s) || hrr) { if (compression != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_COMPRESSION_ALGORITHM); goto err; } if (session_id_len != s->tmp_session_id_len || memcmp(PACKET_data(&session_id), s->tmp_session_id, session_id_len) != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_SESSION_ID); goto err; } } if (hrr) { if (!set_client_ciphersuite(s, cipherchars)) { /* SSLfatal() already called */ goto err; } return tls_process_as_hello_retry_request(s, &extpkt); } /* * Now we have chosen the version we need to check again that the extensions * are appropriate for this version. */ context = SSL_CONNECTION_IS_TLS13(s) ? SSL_EXT_TLS1_3_SERVER_HELLO : SSL_EXT_TLS1_2_SERVER_HELLO; if (!tls_validate_all_contexts(s, context, extensions)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); goto err; } s->hit = 0; if (SSL_CONNECTION_IS_TLS13(s)) { /* * In TLSv1.3 a ServerHello message signals a key change so the end of * the message must be on a record boundary. */ if (RECORD_LAYER_processed_read_pending(&s->rlayer)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_NOT_ON_RECORD_BOUNDARY); goto err; } /* This will set s->hit if we are resuming */ if (!tls_parse_extension(s, TLSEXT_IDX_psk, SSL_EXT_TLS1_3_SERVER_HELLO, extensions, NULL, 0)) { /* SSLfatal() already called */ goto err; } } else { /* * Check if we can resume the session based on external pre-shared * secret. EAP-FAST (RFC 4851) supports two types of session resumption. * Resumption based on server-side state works with session IDs. * Resumption based on pre-shared Protected Access Credentials (PACs) * works by overriding the SessionTicket extension at the application * layer, and does not send a session ID. (We do not know whether * EAP-FAST servers would honour the session ID.) Therefore, the session * ID alone is not a reliable indicator of session resumption, so we * first check if we can resume, and later peek at the next handshake * message to see if the server wants to resume. */ if (s->version >= TLS1_VERSION && s->ext.session_secret_cb != NULL && s->session->ext.tick) { const SSL_CIPHER *pref_cipher = NULL; /* * s->session->master_key_length is a size_t, but this is an int for * backwards compat reasons */ int master_key_length; master_key_length = sizeof(s->session->master_key); if (s->ext.session_secret_cb(ssl, s->session->master_key, &master_key_length, NULL, &pref_cipher, s->ext.session_secret_cb_arg) && master_key_length > 0) { s->session->master_key_length = master_key_length; s->session->cipher = pref_cipher ? pref_cipher : ssl_get_cipher_by_char(s, cipherchars, 0); } else { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (session_id_len != 0 && session_id_len == s->session->session_id_length && memcmp(PACKET_data(&session_id), s->session->session_id, session_id_len) == 0) s->hit = 1; } if (s->hit) { if (s->sid_ctx_length != s->session->sid_ctx_length || memcmp(s->session->sid_ctx, s->sid_ctx, s->sid_ctx_length)) { /* actually a client application bug */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT); goto err; } } else { /* * If we were trying for session-id reuse but the server * didn't resume, make a new SSL_SESSION. * In the case of EAP-FAST and PAC, we do not send a session ID, * so the PAC-based session secret is always preserved. It'll be * overwritten if the server refuses resumption. */ if (s->session->session_id_length > 0) { ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_miss); if (!ssl_get_new_session(s, 0)) { /* SSLfatal() already called */ goto err; } } s->session->ssl_version = s->version; /* * In TLSv1.2 and below we save the session id we were sent so we can * resume it later. In TLSv1.3 the session id we were sent is just an * echo of what we originally sent in the ClientHello and should not be * used for resumption. */ if (!SSL_CONNECTION_IS_TLS13(s)) { s->session->session_id_length = session_id_len; /* session_id_len could be 0 */ if (session_id_len > 0) memcpy(s->session->session_id, PACKET_data(&session_id), session_id_len); } } /* Session version and negotiated protocol version should match */ if (s->version != s->session->ssl_version) { SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_SSL_SESSION_VERSION_MISMATCH); goto err; } /* * Now that we know the version, update the check to see if it's an allowed * version. */ s->s3.tmp.min_ver = s->version; s->s3.tmp.max_ver = s->version; if (!set_client_ciphersuite(s, cipherchars)) { /* SSLfatal() already called */ goto err; } #ifdef OPENSSL_NO_COMP if (compression != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM); goto err; } /* * If compression is disabled we'd better not try to resume a session * using compression. */ if (s->session->compress_meth != 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_COMPRESSION); goto err; } #else if (s->hit && compression != s->session->compress_meth) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED); goto err; } if (compression == 0) comp = NULL; else if (!ssl_allow_compression(s)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COMPRESSION_DISABLED); goto err; } else { comp = ssl3_comp_find(SSL_CONNECTION_GET_CTX(s)->comp_methods, compression); } if (compression != 0 && comp == NULL) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM); goto err; } else { s->s3.tmp.new_compression = comp; } #endif if (!tls_parse_all_extensions(s, context, extensions, NULL, 0, 1)) { /* SSLfatal() already called */ goto err; } #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s) && s->hit) { unsigned char sctpauthkey[64]; char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)]; size_t labellen; /* * Add new shared key for SCTP-Auth, will be ignored if * no SCTP used. */ memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL, sizeof(DTLS1_SCTP_AUTH_LABEL)); /* Don't include the terminating zero. */ labellen = sizeof(labelbuffer) - 1; if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG) labellen += 1; if (SSL_export_keying_material(ssl, sctpauthkey, sizeof(sctpauthkey), labelbuffer, labellen, NULL, 0, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY, sizeof(sctpauthkey), sctpauthkey); } #endif /* * In TLSv1.3 we have some post-processing to change cipher state, otherwise * we're done with this message */ if (SSL_CONNECTION_IS_TLS13(s)) { if (!ssl->method->ssl3_enc->setup_key_block(s) || !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_READ)) { /* SSLfatal() already called */ goto err; } /* * If we're not doing early-data and we're not going to send a dummy CCS * (i.e. no middlebox compat mode) then we can change the write keys * immediately. Otherwise we have to defer this until after all possible * early data is written. We could just always defer until the last * moment except QUIC needs it done at the same time as the read keys * are changed. Since QUIC doesn't do TLS early data or need middlebox * compat this doesn't cause a problem. */ if (s->early_data_state == SSL_EARLY_DATA_NONE && (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0 && !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE)) { /* SSLfatal() already called */ goto err; } } OPENSSL_free(extensions); return MSG_PROCESS_CONTINUE_READING; err: OPENSSL_free(extensions); return MSG_PROCESS_ERROR; } static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s, PACKET *extpkt) { RAW_EXTENSION *extensions = NULL; /* * If we were sending early_data then any alerts should not be sent using * the old wrlmethod. */ if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING && !ssl_set_new_record_layer(s, TLS_ANY_VERSION, OSSL_RECORD_DIRECTION_WRITE, OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0, NID_undef, NULL, NULL, NULL)) { /* SSLfatal already called */ goto err; } /* We are definitely going to be using TLSv1.3 */ s->rlayer.wrlmethod->set_protocol_version(s->rlayer.wrl, TLS1_3_VERSION); if (!tls_collect_extensions(s, extpkt, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST, &extensions, NULL, 1) || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST, extensions, NULL, 0, 1)) { /* SSLfatal() already called */ goto err; } OPENSSL_free(extensions); extensions = NULL; if (s->ext.tls13_cookie_len == 0 && s->s3.tmp.pkey != NULL) { /* * We didn't receive a cookie or a new key_share so the next * ClientHello will not change */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_CHANGE_FOLLOWING_HRR); goto err; } /* * Re-initialise the Transcript Hash. We're going to prepopulate it with * a synthetic message_hash in place of ClientHello1. */ if (!create_synthetic_message_hash(s, NULL, 0, NULL, 0)) { /* SSLfatal() already called */ goto err; } /* * Add this message to the Transcript Hash. Normally this is done * automatically prior to the message processing stage. However due to the * need to create the synthetic message hash, we defer that step until now * for HRR messages. */ if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data, s->init_num + SSL3_HM_HEADER_LENGTH)) { /* SSLfatal() already called */ goto err; } return MSG_PROCESS_FINISHED_READING; err: OPENSSL_free(extensions); return MSG_PROCESS_ERROR; } MSG_PROCESS_RETURN tls_process_server_rpk(SSL_CONNECTION *sc, PACKET *pkt) { EVP_PKEY *peer_rpk; if (!tls_process_rpk(sc, pkt, &peer_rpk)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } if (peer_rpk == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_CERTIFICATE); return MSG_PROCESS_ERROR; } EVP_PKEY_free(sc->session->peer_rpk); sc->session->peer_rpk = peer_rpk; return MSG_PROCESS_CONTINUE_PROCESSING; } static WORK_STATE tls_post_process_server_rpk(SSL_CONNECTION *sc, WORK_STATE wst) { size_t certidx; const SSL_CERT_LOOKUP *clu; if (sc->session->peer_rpk == NULL) { SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_RAW_PUBLIC_KEY); return WORK_ERROR; } if (sc->rwstate == SSL_RETRY_VERIFY) sc->rwstate = SSL_NOTHING; if (ssl_verify_rpk(sc, sc->session->peer_rpk) > 0 && sc->rwstate == SSL_RETRY_VERIFY) return WORK_MORE_A; if ((clu = ssl_cert_lookup_by_pkey(sc->session->peer_rpk, &certidx, SSL_CONNECTION_GET_CTX(sc))) == NULL) { SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CERTIFICATE_TYPE); return WORK_ERROR; } /* * Check certificate type is consistent with ciphersuite. For TLS 1.3 * skip check since TLS 1.3 ciphersuites can be used with any certificate * type. */ if (!SSL_CONNECTION_IS_TLS13(sc)) { if ((clu->amask & sc->s3.tmp.new_cipher->algorithm_auth) == 0) { SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_RPK_TYPE); return WORK_ERROR; } } /* Ensure there is no peer/peer_chain */ X509_free(sc->session->peer); sc->session->peer = NULL; sk_X509_pop_free(sc->session->peer_chain, X509_free); sc->session->peer_chain = NULL; sc->session->verify_result = sc->verify_result; /* Save the current hash state for when we receive the CertificateVerify */ if (SSL_CONNECTION_IS_TLS13(sc) && !ssl_handshake_hash(sc, sc->cert_verify_hash, sizeof(sc->cert_verify_hash), &sc->cert_verify_hash_len)) { /* SSLfatal() already called */ return WORK_ERROR; } return WORK_FINISHED_CONTINUE; } /* prepare server cert verification by setting s->session->peer_chain from pkt */ MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s, PACKET *pkt) { unsigned long cert_list_len, cert_len; X509 *x = NULL; const unsigned char *certstart, *certbytes; size_t chainidx; unsigned int context = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (s->ext.server_cert_type == TLSEXT_cert_type_rpk) return tls_process_server_rpk(s, pkt); if (s->ext.server_cert_type != TLSEXT_cert_type_x509) { SSLfatal(s, SSL_AD_UNSUPPORTED_CERTIFICATE, SSL_R_UNKNOWN_CERTIFICATE_TYPE); goto err; } if ((s->session->peer_chain = sk_X509_new_null()) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if ((SSL_CONNECTION_IS_TLS13(s) && !PACKET_get_1(pkt, &context)) || context != 0 || !PACKET_get_net_3(pkt, &cert_list_len) || PACKET_remaining(pkt) != cert_list_len || PACKET_remaining(pkt) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } for (chainidx = 0; PACKET_remaining(pkt); chainidx++) { if (!PACKET_get_net_3(pkt, &cert_len) || !PACKET_get_bytes(pkt, &certbytes, cert_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH); goto err; } certstart = certbytes; x = X509_new_ex(sctx->libctx, sctx->propq); if (x == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_ASN1_LIB); goto err; } if (d2i_X509(&x, (const unsigned char **)&certbytes, cert_len) == NULL) { SSLfatal(s, SSL_AD_BAD_CERTIFICATE, ERR_R_ASN1_LIB); goto err; } if (certbytes != (certstart + cert_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_CERT_LENGTH_MISMATCH); goto err; } if (SSL_CONNECTION_IS_TLS13(s)) { RAW_EXTENSION *rawexts = NULL; PACKET extensions; if (!PACKET_get_length_prefixed_2(pkt, &extensions)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); goto err; } if (!tls_collect_extensions(s, &extensions, SSL_EXT_TLS1_3_CERTIFICATE, &rawexts, NULL, chainidx == 0) || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE, rawexts, x, chainidx, PACKET_remaining(pkt) == 0)) { OPENSSL_free(rawexts); /* SSLfatal already called */ goto err; } OPENSSL_free(rawexts); } if (!sk_X509_push(s->session->peer_chain, x)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } x = NULL; } return MSG_PROCESS_CONTINUE_PROCESSING; err: X509_free(x); OSSL_STACK_OF_X509_free(s->session->peer_chain); s->session->peer_chain = NULL; return MSG_PROCESS_ERROR; } /* * Verify the s->session->peer_chain and check server cert type. * On success set s->session->peer and s->session->verify_result. * Else the peer certificate verification callback may request retry. */ WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s, WORK_STATE wst) { X509 *x; EVP_PKEY *pkey = NULL; const SSL_CERT_LOOKUP *clu; size_t certidx; int i; if (s->ext.server_cert_type == TLSEXT_cert_type_rpk) return tls_post_process_server_rpk(s, wst); if (s->rwstate == SSL_RETRY_VERIFY) s->rwstate = SSL_NOTHING; i = ssl_verify_cert_chain(s, s->session->peer_chain); if (i > 0 && s->rwstate == SSL_RETRY_VERIFY) { return WORK_MORE_A; } /* * The documented interface is that SSL_VERIFY_PEER should be set in order * for client side verification of the server certificate to take place. * However, historically the code has only checked that *any* flag is set * to cause server verification to take place. Use of the other flags makes * no sense in client mode. An attempt to clean up the semantics was * reverted because at least one application *only* set * SSL_VERIFY_FAIL_IF_NO_PEER_CERT. Prior to the clean up this still caused * server verification to take place, after the clean up it silently did * nothing. SSL_CTX_set_verify()/SSL_set_verify() cannot validate the flags * sent to them because they are void functions. Therefore, we now use the * (less clean) historic behaviour of performing validation if any flag is * set. The *documented* interface remains the same. */ if (s->verify_mode != SSL_VERIFY_NONE && i <= 0) { SSLfatal(s, ssl_x509err2alert(s->verify_result), SSL_R_CERTIFICATE_VERIFY_FAILED); return WORK_ERROR; } ERR_clear_error(); /* but we keep s->verify_result */ /* * Inconsistency alert: cert_chain does include the peer's certificate, * which we don't include in statem_srvr.c */ x = sk_X509_value(s->session->peer_chain, 0); pkey = X509_get0_pubkey(x); if (pkey == NULL || EVP_PKEY_missing_parameters(pkey)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS); return WORK_ERROR; } if ((clu = ssl_cert_lookup_by_pkey(pkey, &certidx, SSL_CONNECTION_GET_CTX(s))) == NULL) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CERTIFICATE_TYPE); return WORK_ERROR; } /* * Check certificate type is consistent with ciphersuite. For TLS 1.3 * skip check since TLS 1.3 ciphersuites can be used with any certificate * type. */ if (!SSL_CONNECTION_IS_TLS13(s)) { if ((clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CERTIFICATE_TYPE); return WORK_ERROR; } } X509_free(s->session->peer); X509_up_ref(x); s->session->peer = x; s->session->verify_result = s->verify_result; /* Ensure there is no RPK */ EVP_PKEY_free(s->session->peer_rpk); s->session->peer_rpk = NULL; /* Save the current hash state for when we receive the CertificateVerify */ if (SSL_CONNECTION_IS_TLS13(s) && !ssl_handshake_hash(s, s->cert_verify_hash, sizeof(s->cert_verify_hash), &s->cert_verify_hash_len)) { /* SSLfatal() already called */; return WORK_ERROR; } return WORK_FINISHED_CONTINUE; } #ifndef OPENSSL_NO_COMP_ALG MSG_PROCESS_RETURN tls_process_server_compressed_certificate(SSL_CONNECTION *sc, PACKET *pkt) { MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR; PACKET tmppkt; BUF_MEM *buf = BUF_MEM_new(); if (tls13_process_compressed_certificate(sc, pkt, &tmppkt, buf) != MSG_PROCESS_ERROR) ret = tls_process_server_certificate(sc, &tmppkt); BUF_MEM_free(buf); return ret; } #endif static int tls_process_ske_psk_preamble(SSL_CONNECTION *s, PACKET *pkt) { #ifndef OPENSSL_NO_PSK PACKET psk_identity_hint; /* PSK ciphersuites are preceded by an identity hint */ if (!PACKET_get_length_prefixed_2(pkt, &psk_identity_hint)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } /* * Store PSK identity hint for later use, hint is used in * tls_construct_client_key_exchange. Assume that the maximum length of * a PSK identity hint can be as long as the maximum length of a PSK * identity. */ if (PACKET_remaining(&psk_identity_hint) > PSK_MAX_IDENTITY_LEN) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } if (PACKET_remaining(&psk_identity_hint) == 0) { OPENSSL_free(s->session->psk_identity_hint); s->session->psk_identity_hint = NULL; } else if (!PACKET_strndup(&psk_identity_hint, &s->session->psk_identity_hint)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_ske_srp(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey) { #ifndef OPENSSL_NO_SRP PACKET prime, generator, salt, server_pub; if (!PACKET_get_length_prefixed_2(pkt, &prime) || !PACKET_get_length_prefixed_2(pkt, &generator) || !PACKET_get_length_prefixed_1(pkt, &salt) || !PACKET_get_length_prefixed_2(pkt, &server_pub)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if ((s->srp_ctx.N = BN_bin2bn(PACKET_data(&prime), (int)PACKET_remaining(&prime), NULL)) == NULL || (s->srp_ctx.g = BN_bin2bn(PACKET_data(&generator), (int)PACKET_remaining(&generator), NULL)) == NULL || (s->srp_ctx.s = BN_bin2bn(PACKET_data(&salt), (int)PACKET_remaining(&salt), NULL)) == NULL || (s->srp_ctx.B = BN_bin2bn(PACKET_data(&server_pub), (int)PACKET_remaining(&server_pub), NULL)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB); return 0; } if (!srp_verify_server_param(s)) { /* SSLfatal() already called */ return 0; } /* We must check if there is a certificate */ if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aRSA | SSL_aDSS)) *pkey = tls_get_peer_pkey(s); return 1; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_process_ske_dhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey) { PACKET prime, generator, pub_key; EVP_PKEY *peer_tmp = NULL; BIGNUM *p = NULL, *g = NULL, *bnpub_key = NULL; EVP_PKEY_CTX *pctx = NULL; OSSL_PARAM *params = NULL; OSSL_PARAM_BLD *tmpl = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); int ret = 0; if (!PACKET_get_length_prefixed_2(pkt, &prime) || !PACKET_get_length_prefixed_2(pkt, &generator) || !PACKET_get_length_prefixed_2(pkt, &pub_key)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } p = BN_bin2bn(PACKET_data(&prime), (int)PACKET_remaining(&prime), NULL); g = BN_bin2bn(PACKET_data(&generator), (int)PACKET_remaining(&generator), NULL); bnpub_key = BN_bin2bn(PACKET_data(&pub_key), (int)PACKET_remaining(&pub_key), NULL); if (p == NULL || g == NULL || bnpub_key == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB); goto err; } tmpl = OSSL_PARAM_BLD_new(); if (tmpl == NULL || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p) || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_G, g) || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_PUB_KEY, bnpub_key) || (params = OSSL_PARAM_BLD_to_param(tmpl)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, "DH", sctx->propq); if (pctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (EVP_PKEY_fromdata_init(pctx) <= 0 || EVP_PKEY_fromdata(pctx, &peer_tmp, EVP_PKEY_KEYPAIR, params) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_DH_VALUE); goto err; } EVP_PKEY_CTX_free(pctx); pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, peer_tmp, sctx->propq); if (pctx == NULL /* * EVP_PKEY_param_check() will verify that the DH params are using * a safe prime. In this context, because we're using ephemeral DH, * we're ok with it not being a safe prime. * EVP_PKEY_param_check_quick() skips the safe prime check. */ || EVP_PKEY_param_check_quick(pctx) != 1 || EVP_PKEY_public_check(pctx) != 1) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DH_VALUE); goto err; } if (!ssl_security(s, SSL_SECOP_TMP_DH, EVP_PKEY_get_security_bits(peer_tmp), 0, peer_tmp)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DH_KEY_TOO_SMALL); goto err; } s->s3.peer_tmp = peer_tmp; peer_tmp = NULL; /* * FIXME: This makes assumptions about which ciphersuites come with * public keys. We should have a less ad-hoc way of doing this */ if (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aRSA | SSL_aDSS)) *pkey = tls_get_peer_pkey(s); /* else anonymous DH, so no certificate or pkey. */ ret = 1; err: OSSL_PARAM_BLD_free(tmpl); OSSL_PARAM_free(params); EVP_PKEY_free(peer_tmp); EVP_PKEY_CTX_free(pctx); BN_free(p); BN_free(g); BN_free(bnpub_key); return ret; } static int tls_process_ske_ecdhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey) { PACKET encoded_pt; unsigned int curve_type, curve_id; /* * Extract elliptic curve parameters and the server's ephemeral ECDH * public key. We only support named (not generic) curves and * ECParameters in this case is just three bytes. */ if (!PACKET_get_1(pkt, &curve_type) || !PACKET_get_net_2(pkt, &curve_id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); return 0; } /* * Check curve is named curve type and one of our preferences, if not * server has sent an invalid curve. */ if (curve_type != NAMED_CURVE_TYPE || !tls1_check_group_id(s, curve_id, 1)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE); return 0; } if ((s->s3.peer_tmp = ssl_generate_param_group(s, curve_id)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS); return 0; } if (!PACKET_get_length_prefixed_1(pkt, &encoded_pt)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (EVP_PKEY_set1_encoded_public_key(s->s3.peer_tmp, PACKET_data(&encoded_pt), PACKET_remaining(&encoded_pt)) <= 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT); return 0; } /* * The ECC/TLS specification does not mention the use of DSA to sign * ECParameters in the server key exchange message. We do support RSA * and ECDSA. */ if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aECDSA) *pkey = tls_get_peer_pkey(s); else if (s->s3.tmp.new_cipher->algorithm_auth & SSL_aRSA) *pkey = tls_get_peer_pkey(s); /* else anonymous ECDH, so no certificate or pkey. */ /* Cache the agreed upon group in the SSL_SESSION */ s->session->kex_group = curve_id; return 1; } MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s, PACKET *pkt) { long alg_k; EVP_PKEY *pkey = NULL; EVP_MD_CTX *md_ctx = NULL; EVP_PKEY_CTX *pctx = NULL; PACKET save_param_start, signature; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); alg_k = s->s3.tmp.new_cipher->algorithm_mkey; save_param_start = *pkt; EVP_PKEY_free(s->s3.peer_tmp); s->s3.peer_tmp = NULL; if (alg_k & SSL_PSK) { if (!tls_process_ske_psk_preamble(s, pkt)) { /* SSLfatal() already called */ goto err; } } /* Nothing else to do for plain PSK or RSAPSK */ if (alg_k & (SSL_kPSK | SSL_kRSAPSK)) { } else if (alg_k & SSL_kSRP) { if (!tls_process_ske_srp(s, pkt, &pkey)) { /* SSLfatal() already called */ goto err; } } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) { if (!tls_process_ske_dhe(s, pkt, &pkey)) { /* SSLfatal() already called */ goto err; } } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) { if (!tls_process_ske_ecdhe(s, pkt, &pkey)) { /* SSLfatal() already called */ goto err; } } else if (alg_k) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); goto err; } /* if it was signed, check the signature */ if (pkey != NULL) { PACKET params; const EVP_MD *md = NULL; unsigned char *tbs; size_t tbslen; int rv; /* * |pkt| now points to the beginning of the signature, so the difference * equals the length of the parameters. */ if (!PACKET_get_sub_packet(&save_param_start, &params, PACKET_remaining(&save_param_start) - PACKET_remaining(pkt))) { SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (SSL_USE_SIGALGS(s)) { unsigned int sigalg; if (!PACKET_get_net_2(pkt, &sigalg)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); goto err; } if (tls12_check_peer_sigalg(s, sigalg, pkey) <=0) { /* SSLfatal() already called */ goto err; } } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED); goto err; } if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_DIGEST_ALGORITHM); goto err; } if (SSL_USE_SIGALGS(s)) OSSL_TRACE1(TLS, "USING TLSv1.2 HASH %s\n", md == NULL ? "n/a" : EVP_MD_get0_name(md)); if (!PACKET_get_length_prefixed_2(pkt, &signature) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } md_ctx = EVP_MD_CTX_new(); if (md_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_DigestVerifyInit_ex(md_ctx, &pctx, md == NULL ? NULL : EVP_MD_get0_name(md), sctx->libctx, sctx->propq, pkey, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (SSL_USE_PSS(s)) { if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx, RSA_PSS_SALTLEN_DIGEST) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } } tbslen = construct_key_exchange_tbs(s, &tbs, PACKET_data(&params), PACKET_remaining(&params)); if (tbslen == 0) { /* SSLfatal() already called */ goto err; } rv = EVP_DigestVerify(md_ctx, PACKET_data(&signature), PACKET_remaining(&signature), tbs, tbslen); OPENSSL_free(tbs); if (rv <= 0) { SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BAD_SIGNATURE); goto err; } EVP_MD_CTX_free(md_ctx); md_ctx = NULL; } else { /* aNULL, aSRP or PSK do not need public keys */ if (!(s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP)) && !(alg_k & SSL_PSK)) { /* Might be wrong key type, check it */ if (ssl3_check_cert_and_algorithm(s)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_DATA); } /* else this shouldn't happen, SSLfatal() already called */ goto err; } /* still data left over */ if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_EXTRA_DATA_IN_MESSAGE); goto err; } } return MSG_PROCESS_CONTINUE_READING; err: EVP_MD_CTX_free(md_ctx); return MSG_PROCESS_ERROR; } MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s, PACKET *pkt) { /* Clear certificate validity flags */ if (s->s3.tmp.valid_flags != NULL) memset(s->s3.tmp.valid_flags, 0, s->ssl_pkey_num * sizeof(uint32_t)); else s->s3.tmp.valid_flags = OPENSSL_zalloc(s->ssl_pkey_num * sizeof(uint32_t)); /* Give up for good if allocation didn't work */ if (s->s3.tmp.valid_flags == NULL) return 0; if (SSL_CONNECTION_IS_TLS13(s)) { PACKET reqctx, extensions; RAW_EXTENSION *rawexts = NULL; if ((s->shutdown & SSL_SENT_SHUTDOWN) != 0) { /* * We already sent close_notify. This can only happen in TLSv1.3 * post-handshake messages. We can't reasonably respond to this, so * we just ignore it */ return MSG_PROCESS_FINISHED_READING; } /* Free and zero certificate types: it is not present in TLS 1.3 */ OPENSSL_free(s->s3.tmp.ctype); s->s3.tmp.ctype = NULL; s->s3.tmp.ctype_len = 0; OPENSSL_free(s->pha_context); s->pha_context = NULL; s->pha_context_len = 0; if (!PACKET_get_length_prefixed_1(pkt, &reqctx) || !PACKET_memdup(&reqctx, &s->pha_context, &s->pha_context_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if (!PACKET_get_length_prefixed_2(pkt, &extensions)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); return MSG_PROCESS_ERROR; } if (!tls_collect_extensions(s, &extensions, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, &rawexts, NULL, 1) || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, rawexts, NULL, 0, 1)) { /* SSLfatal() already called */ OPENSSL_free(rawexts); return MSG_PROCESS_ERROR; } OPENSSL_free(rawexts); if (!tls1_process_sigalgs(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_LENGTH); return MSG_PROCESS_ERROR; } } else { PACKET ctypes; /* get the certificate types */ if (!PACKET_get_length_prefixed_1(pkt, &ctypes)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if (!PACKET_memdup(&ctypes, &s->s3.tmp.ctype, &s->s3.tmp.ctype_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return MSG_PROCESS_ERROR; } if (SSL_USE_SIGALGS(s)) { PACKET sigalgs; if (!PACKET_get_length_prefixed_2(pkt, &sigalgs)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } /* * Despite this being for certificates, preserve compatibility * with pre-TLS 1.3 and use the regular sigalgs field. */ if (!tls1_save_sigalgs(s, &sigalgs, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SIGNATURE_ALGORITHMS_ERROR); return MSG_PROCESS_ERROR; } if (!tls1_process_sigalgs(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); return MSG_PROCESS_ERROR; } } /* get the CA RDNs */ if (!parse_ca_names(s, pkt)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } } if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } /* we should setup a certificate to return.... */ s->s3.tmp.cert_req = 1; /* * In TLSv1.3 we don't prepare the client certificate yet. We wait until * after the CertificateVerify message has been received. This is because * in TLSv1.3 the CertificateRequest arrives before the Certificate message * but in TLSv1.2 it is the other way around. We want to make sure that * SSL_get1_peer_certificate() returns something sensible in * client_cert_cb. */ if (SSL_CONNECTION_IS_TLS13(s) && s->post_handshake_auth != SSL_PHA_REQUESTED) return MSG_PROCESS_CONTINUE_READING; return MSG_PROCESS_CONTINUE_PROCESSING; } MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s, PACKET *pkt) { unsigned int ticklen; unsigned long ticket_lifetime_hint, age_add = 0; unsigned int sess_len; RAW_EXTENSION *exts = NULL; PACKET nonce; EVP_MD *sha256 = NULL; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); PACKET_null_init(&nonce); if (!PACKET_get_net_4(pkt, &ticket_lifetime_hint) || (SSL_CONNECTION_IS_TLS13(s) && (!PACKET_get_net_4(pkt, &age_add) || !PACKET_get_length_prefixed_1(pkt, &nonce))) || !PACKET_get_net_2(pkt, &ticklen) || (SSL_CONNECTION_IS_TLS13(s) ? (ticklen == 0 || PACKET_remaining(pkt) < ticklen) : PACKET_remaining(pkt) != ticklen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } /* * Server is allowed to change its mind (in <=TLSv1.2) and send an empty * ticket. We already checked this TLSv1.3 case above, so it should never * be 0 here in that instance */ if (ticklen == 0) return MSG_PROCESS_CONTINUE_READING; /* * Sessions must be immutable once they go into the session cache. Otherwise * we can get multi-thread problems. Therefore we don't "update" sessions, * we replace them with a duplicate. In TLSv1.3 we need to do this every * time a NewSessionTicket arrives because those messages arrive * post-handshake and the session may have already gone into the session * cache. */ if (SSL_CONNECTION_IS_TLS13(s) || s->session->session_id_length > 0) { SSL_SESSION *new_sess; /* * We reused an existing session, so we need to replace it with a new * one */ if ((new_sess = ssl_session_dup(s->session, 0)) == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); goto err; } if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) != 0 && !SSL_CONNECTION_IS_TLS13(s)) { /* * In TLSv1.2 and below the arrival of a new tickets signals that * any old ticket we were using is now out of date, so we remove the * old session from the cache. We carry on if this fails */ SSL_CTX_remove_session(s->session_ctx, s->session); } SSL_SESSION_free(s->session); s->session = new_sess; } s->session->time = ossl_time_now(); ssl_session_calculate_timeout(s->session); OPENSSL_free(s->session->ext.tick); s->session->ext.tick = NULL; s->session->ext.ticklen = 0; s->session->ext.tick = OPENSSL_malloc(ticklen); if (s->session->ext.tick == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (!PACKET_copy_bytes(pkt, s->session->ext.tick, ticklen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } s->session->ext.tick_lifetime_hint = ticket_lifetime_hint; s->session->ext.tick_age_add = age_add; s->session->ext.ticklen = ticklen; if (SSL_CONNECTION_IS_TLS13(s)) { PACKET extpkt; if (!PACKET_as_length_prefixed_2(pkt, &extpkt) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!tls_collect_extensions(s, &extpkt, SSL_EXT_TLS1_3_NEW_SESSION_TICKET, &exts, NULL, 1) || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_NEW_SESSION_TICKET, exts, NULL, 0, 1)) { /* SSLfatal() already called */ goto err; } } /* * There are two ways to detect a resumed ticket session. One is to set * an appropriate session ID and then the server must return a match in * ServerHello. This allows the normal client session ID matching to work * and we know much earlier that the ticket has been accepted. The * other way is to set zero length session ID when the ticket is * presented and rely on the handshake to determine session resumption. * We choose the former approach because this fits in with assumptions * elsewhere in OpenSSL. The session ID is set to the SHA256 hash of the * ticket. */ sha256 = EVP_MD_fetch(sctx->libctx, "SHA2-256", sctx->propq); if (sha256 == NULL) { /* Error is already recorded */ SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR); goto err; } /* * We use sess_len here because EVP_Digest expects an int * but s->session->session_id_length is a size_t */ if (!EVP_Digest(s->session->ext.tick, ticklen, s->session->session_id, &sess_len, sha256, NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } EVP_MD_free(sha256); sha256 = NULL; s->session->session_id_length = sess_len; s->session->not_resumable = 0; /* This is a standalone message in TLSv1.3, so there is no more to read */ if (SSL_CONNECTION_IS_TLS13(s)) { const EVP_MD *md = ssl_handshake_md(s); int hashleni = EVP_MD_get_size(md); size_t hashlen; static const unsigned char nonce_label[] = "resumption"; /* Ensure cast to size_t is safe */ if (!ossl_assert(hashleni >= 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } hashlen = (size_t)hashleni; if (!tls13_hkdf_expand(s, md, s->resumption_master_secret, nonce_label, sizeof(nonce_label) - 1, PACKET_data(&nonce), PACKET_remaining(&nonce), s->session->master_key, hashlen, 1)) { /* SSLfatal() already called */ goto err; } s->session->master_key_length = hashlen; OPENSSL_free(exts); ssl_update_cache(s, SSL_SESS_CACHE_CLIENT); return MSG_PROCESS_FINISHED_READING; } return MSG_PROCESS_CONTINUE_READING; err: EVP_MD_free(sha256); OPENSSL_free(exts); return MSG_PROCESS_ERROR; } /* * In TLSv1.3 this is called from the extensions code, otherwise it is used to * parse a separate message. Returns 1 on success or 0 on failure */ int tls_process_cert_status_body(SSL_CONNECTION *s, PACKET *pkt) { size_t resplen; unsigned int type; if (!PACKET_get_1(pkt, &type) || type != TLSEXT_STATUSTYPE_ocsp) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_UNSUPPORTED_STATUS_TYPE); return 0; } if (!PACKET_get_net_3_len(pkt, &resplen) || PACKET_remaining(pkt) != resplen) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } s->ext.ocsp.resp = OPENSSL_malloc(resplen); if (s->ext.ocsp.resp == NULL) { s->ext.ocsp.resp_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } s->ext.ocsp.resp_len = resplen; if (!PACKET_copy_bytes(pkt, s->ext.ocsp.resp, resplen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } return 1; } MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION *s, PACKET *pkt) { if (!tls_process_cert_status_body(s, pkt)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } return MSG_PROCESS_CONTINUE_READING; } /* * Perform miscellaneous checks and processing after we have received the * server's initial flight. In TLS1.3 this is after the Server Finished message. * In <=TLS1.2 this is after the ServerDone message. Returns 1 on success or 0 * on failure. */ int tls_process_initial_server_flight(SSL_CONNECTION *s) { SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* * at this point we check that we have the required stuff from * the server */ if (!ssl3_check_cert_and_algorithm(s)) { /* SSLfatal() already called */ return 0; } /* * Call the ocsp status callback if needed. The |ext.ocsp.resp| and * |ext.ocsp.resp_len| values will be set if we actually received a status * message, or NULL and -1 otherwise */ if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing && sctx->ext.status_cb != NULL) { int ret = sctx->ext.status_cb(SSL_CONNECTION_GET_SSL(s), sctx->ext.status_arg); if (ret == 0) { SSLfatal(s, SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE, SSL_R_INVALID_STATUS_RESPONSE); return 0; } if (ret < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_OCSP_CALLBACK_FAILURE); return 0; } } #ifndef OPENSSL_NO_CT if (s->ct_validation_callback != NULL) { /* Note we validate the SCTs whether or not we abort on error */ if (!ssl_validate_ct(s) && (s->verify_mode & SSL_VERIFY_PEER)) { /* SSLfatal() already called */ return 0; } } #endif return 1; } MSG_PROCESS_RETURN tls_process_server_done(SSL_CONNECTION *s, PACKET *pkt) { if (PACKET_remaining(pkt) > 0) { /* should contain no data */ SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } #ifndef OPENSSL_NO_SRP if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) { if (ssl_srp_calc_a_param_intern(s) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SRP_A_CALC); return MSG_PROCESS_ERROR; } } #endif if (!tls_process_initial_server_flight(s)) { /* SSLfatal() already called */ return MSG_PROCESS_ERROR; } return MSG_PROCESS_FINISHED_READING; } static int tls_construct_cke_psk_preamble(SSL_CONNECTION *s, WPACKET *pkt) { #ifndef OPENSSL_NO_PSK int ret = 0; /* * The callback needs PSK_MAX_IDENTITY_LEN + 1 bytes to return a * \0-terminated identity. The last byte is for us for simulating * strnlen. */ char identity[PSK_MAX_IDENTITY_LEN + 1]; size_t identitylen = 0; unsigned char psk[PSK_MAX_PSK_LEN]; unsigned char *tmppsk = NULL; char *tmpidentity = NULL; size_t psklen = 0; if (s->psk_client_callback == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_PSK_NO_CLIENT_CB); goto err; } memset(identity, 0, sizeof(identity)); psklen = s->psk_client_callback(SSL_CONNECTION_GET_SSL(s), s->session->psk_identity_hint, identity, sizeof(identity) - 1, psk, sizeof(psk)); if (psklen > PSK_MAX_PSK_LEN) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR); psklen = PSK_MAX_PSK_LEN; /* Avoid overrunning the array on cleanse */ goto err; } else if (psklen == 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_PSK_IDENTITY_NOT_FOUND); goto err; } identitylen = strlen(identity); if (identitylen > PSK_MAX_IDENTITY_LEN) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } tmppsk = OPENSSL_memdup(psk, psklen); tmpidentity = OPENSSL_strdup(identity); if (tmppsk == NULL || tmpidentity == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } OPENSSL_free(s->s3.tmp.psk); s->s3.tmp.psk = tmppsk; s->s3.tmp.psklen = psklen; tmppsk = NULL; OPENSSL_free(s->session->psk_identity); s->session->psk_identity = tmpidentity; tmpidentity = NULL; if (!WPACKET_sub_memcpy_u16(pkt, identity, identitylen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ret = 1; err: OPENSSL_cleanse(psk, psklen); OPENSSL_cleanse(identity, sizeof(identity)); OPENSSL_clear_free(tmppsk, psklen); OPENSSL_clear_free(tmpidentity, identitylen); return ret; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_construct_cke_rsa(SSL_CONNECTION *s, WPACKET *pkt) { unsigned char *encdata = NULL; EVP_PKEY *pkey = NULL; EVP_PKEY_CTX *pctx = NULL; size_t enclen; unsigned char *pms = NULL; size_t pmslen = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (!received_server_cert(s)) { /* * We should always have a server certificate with SSL_kRSA. */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if ((pkey = tls_get_peer_pkey(s)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!EVP_PKEY_is_a(pkey, "RSA")) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } pmslen = SSL_MAX_MASTER_KEY_LENGTH; pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } pms[0] = s->client_version >> 8; pms[1] = s->client_version & 0xff; if (RAND_bytes_ex(sctx->libctx, pms + 2, pmslen - 2, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_RAND_LIB); goto err; } /* Fix buf for TLS and beyond */ if (s->version > SSL3_VERSION && !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pkey, sctx->propq); if (pctx == NULL || EVP_PKEY_encrypt_init(pctx) <= 0 || EVP_PKEY_encrypt(pctx, NULL, &enclen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (!WPACKET_allocate_bytes(pkt, enclen, &encdata) || EVP_PKEY_encrypt(pctx, encdata, &enclen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_RSA_ENCRYPT); goto err; } EVP_PKEY_CTX_free(pctx); pctx = NULL; /* Fix buf for TLS and beyond */ if (s->version > SSL3_VERSION && !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Log the premaster secret, if logging is enabled. */ if (!ssl_log_rsa_client_key_exchange(s, encdata, enclen, pms, pmslen)) { /* SSLfatal() already called */ goto err; } s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; return 1; err: OPENSSL_clear_free(pms, pmslen); EVP_PKEY_CTX_free(pctx); return 0; } static int tls_construct_cke_dhe(SSL_CONNECTION *s, WPACKET *pkt) { EVP_PKEY *ckey = NULL, *skey = NULL; unsigned char *keybytes = NULL; int prime_len; unsigned char *encoded_pub = NULL; size_t encoded_pub_len, pad_len; int ret = 0; skey = s->s3.peer_tmp; if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ckey = ssl_generate_pkey(s, skey); if (ckey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (ssl_derive(s, ckey, skey, 0) == 0) { /* SSLfatal() already called */ goto err; } /* send off the data */ /* Generate encoding of server key */ encoded_pub_len = EVP_PKEY_get1_encoded_public_key(ckey, &encoded_pub); if (encoded_pub_len == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_PKEY_free(ckey); return EXT_RETURN_FAIL; } /* * For interoperability with some versions of the Microsoft TLS * stack, we need to zero pad the DHE pub key to the same length * as the prime. */ prime_len = EVP_PKEY_get_size(ckey); pad_len = prime_len - encoded_pub_len; if (pad_len > 0) { if (!WPACKET_sub_allocate_bytes_u16(pkt, pad_len, &keybytes)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } memset(keybytes, 0, pad_len); } if (!WPACKET_sub_memcpy_u16(pkt, encoded_pub, encoded_pub_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ret = 1; err: OPENSSL_free(encoded_pub); EVP_PKEY_free(ckey); return ret; } static int tls_construct_cke_ecdhe(SSL_CONNECTION *s, WPACKET *pkt) { unsigned char *encodedPoint = NULL; size_t encoded_pt_len = 0; EVP_PKEY *ckey = NULL, *skey = NULL; int ret = 0; skey = s->s3.peer_tmp; if (skey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } ckey = ssl_generate_pkey(s, skey); if (ckey == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); goto err; } if (ssl_derive(s, ckey, skey, 0) == 0) { /* SSLfatal() already called */ goto err; } /* Generate encoding of client key */ encoded_pt_len = EVP_PKEY_get1_encoded_public_key(ckey, &encodedPoint); if (encoded_pt_len == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); goto err; } if (!WPACKET_sub_memcpy_u8(pkt, encodedPoint, encoded_pt_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } ret = 1; err: OPENSSL_free(encodedPoint); EVP_PKEY_free(ckey); return ret; } static int tls_construct_cke_gost(SSL_CONNECTION *s, WPACKET *pkt) { #ifndef OPENSSL_NO_GOST /* GOST key exchange message creation */ EVP_PKEY_CTX *pkey_ctx = NULL; EVP_PKEY *pkey = NULL; size_t msglen; unsigned int md_len; unsigned char shared_ukm[32], tmp[256]; EVP_MD_CTX *ukm_hash = NULL; int dgst_nid = NID_id_GostR3411_94; unsigned char *pms = NULL; size_t pmslen = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if ((s->s3.tmp.new_cipher->algorithm_auth & SSL_aGOST12) != 0) dgst_nid = NID_id_GostR3411_2012_256; /* * Get server certificate PKEY and create ctx from it */ if ((pkey = tls_get_peer_pkey(s)) == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER); return 0; } pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pkey, sctx->propq); if (pkey_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } /* * If we have send a certificate, and certificate key * parameters match those of server certificate, use * certificate key for key exchange */ /* Otherwise, generate ephemeral key pair */ pmslen = 32; pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0 /* Generate session key */ || RAND_bytes_ex(sctx->libctx, pms, pmslen, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; }; /* * Compute shared IV and store it in algorithm-specific context * data */ ukm_hash = EVP_MD_CTX_new(); if (ukm_hash == NULL || EVP_DigestInit(ukm_hash, EVP_get_digestbynid(dgst_nid)) <= 0 || EVP_DigestUpdate(ukm_hash, s->s3.client_random, SSL3_RANDOM_SIZE) <= 0 || EVP_DigestUpdate(ukm_hash, s->s3.server_random, SSL3_RANDOM_SIZE) <= 0 || EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } EVP_MD_CTX_free(ukm_hash); ukm_hash = NULL; if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT, EVP_PKEY_CTRL_SET_IV, 8, shared_ukm) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } /* Make GOST keytransport blob message */ /* * Encapsulate it into sequence */ msglen = 255; if (EVP_PKEY_encrypt(pkey_ctx, tmp, &msglen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } if (!WPACKET_put_bytes_u8(pkt, V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED) || (msglen >= 0x80 && !WPACKET_put_bytes_u8(pkt, 0x81)) || !WPACKET_sub_memcpy_u8(pkt, tmp, msglen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } EVP_PKEY_CTX_free(pkey_ctx); s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; return 1; err: EVP_PKEY_CTX_free(pkey_ctx); OPENSSL_clear_free(pms, pmslen); EVP_MD_CTX_free(ukm_hash); return 0; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } #ifndef OPENSSL_NO_GOST int ossl_gost18_cke_cipher_nid(const SSL_CONNECTION *s) { if ((s->s3.tmp.new_cipher->algorithm_enc & SSL_MAGMA) != 0) return NID_magma_ctr; else if ((s->s3.tmp.new_cipher->algorithm_enc & SSL_KUZNYECHIK) != 0) return NID_kuznyechik_ctr; return NID_undef; } int ossl_gost_ukm(const SSL_CONNECTION *s, unsigned char *dgst_buf) { EVP_MD_CTX *hash = NULL; unsigned int md_len; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); const EVP_MD *md = ssl_evp_md_fetch(sctx->libctx, NID_id_GostR3411_2012_256, sctx->propq); if (md == NULL) return 0; if ((hash = EVP_MD_CTX_new()) == NULL || EVP_DigestInit(hash, md) <= 0 || EVP_DigestUpdate(hash, s->s3.client_random, SSL3_RANDOM_SIZE) <= 0 || EVP_DigestUpdate(hash, s->s3.server_random, SSL3_RANDOM_SIZE) <= 0 || EVP_DigestFinal_ex(hash, dgst_buf, &md_len) <= 0) { EVP_MD_CTX_free(hash); ssl_evp_md_free(md); return 0; } EVP_MD_CTX_free(hash); ssl_evp_md_free(md); return 1; } #endif static int tls_construct_cke_gost18(SSL_CONNECTION *s, WPACKET *pkt) { #ifndef OPENSSL_NO_GOST /* GOST 2018 key exchange message creation */ unsigned char rnd_dgst[32]; unsigned char *encdata = NULL; EVP_PKEY_CTX *pkey_ctx = NULL; EVP_PKEY *pkey; unsigned char *pms = NULL; size_t pmslen = 0; size_t msglen; int cipher_nid = ossl_gost18_cke_cipher_nid(s); SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); if (cipher_nid == NID_undef) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (ossl_gost_ukm(s, rnd_dgst) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Pre-master secret - random bytes */ pmslen = 32; pms = OPENSSL_malloc(pmslen); if (pms == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); goto err; } if (RAND_bytes_ex(sctx->libctx, pms, pmslen, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* Get server certificate PKEY and create ctx from it */ if ((pkey = tls_get_peer_pkey(s)) == NULL) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER); goto err; } pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pkey, sctx->propq); if (pkey_ctx == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (EVP_PKEY_encrypt_init(pkey_ctx) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; }; /* Reuse EVP_PKEY_CTRL_SET_IV, make choice in engine code */ if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT, EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT, EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); goto err; } if (EVP_PKEY_encrypt(pkey_ctx, NULL, &msglen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } if (!WPACKET_allocate_bytes(pkt, msglen, &encdata) || EVP_PKEY_encrypt(pkey_ctx, encdata, &msglen, pms, pmslen) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); goto err; } EVP_PKEY_CTX_free(pkey_ctx); pkey_ctx = NULL; s->s3.tmp.pms = pms; s->s3.tmp.pmslen = pmslen; return 1; err: EVP_PKEY_CTX_free(pkey_ctx); OPENSSL_clear_free(pms, pmslen); return 0; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } static int tls_construct_cke_srp(SSL_CONNECTION *s, WPACKET *pkt) { #ifndef OPENSSL_NO_SRP unsigned char *abytes = NULL; if (s->srp_ctx.A == NULL || !WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(s->srp_ctx.A), &abytes)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } BN_bn2bin(s->srp_ctx.A, abytes); OPENSSL_free(s->session->srp_username); s->session->srp_username = OPENSSL_strdup(s->srp_ctx.login); if (s->session->srp_username == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } return 1; #else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; #endif } CON_FUNC_RETURN tls_construct_client_key_exchange(SSL_CONNECTION *s, WPACKET *pkt) { unsigned long alg_k; alg_k = s->s3.tmp.new_cipher->algorithm_mkey; /* * All of the construct functions below call SSLfatal() if necessary so * no need to do so here. */ if ((alg_k & SSL_PSK) && !tls_construct_cke_psk_preamble(s, pkt)) goto err; if (alg_k & (SSL_kRSA | SSL_kRSAPSK)) { if (!tls_construct_cke_rsa(s, pkt)) goto err; } else if (alg_k & (SSL_kDHE | SSL_kDHEPSK)) { if (!tls_construct_cke_dhe(s, pkt)) goto err; } else if (alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) { if (!tls_construct_cke_ecdhe(s, pkt)) goto err; } else if (alg_k & SSL_kGOST) { if (!tls_construct_cke_gost(s, pkt)) goto err; } else if (alg_k & SSL_kGOST18) { if (!tls_construct_cke_gost18(s, pkt)) goto err; } else if (alg_k & SSL_kSRP) { if (!tls_construct_cke_srp(s, pkt)) goto err; } else if (!(alg_k & SSL_kPSK)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } return CON_FUNC_SUCCESS; err: OPENSSL_clear_free(s->s3.tmp.pms, s->s3.tmp.pmslen); s->s3.tmp.pms = NULL; s->s3.tmp.pmslen = 0; #ifndef OPENSSL_NO_PSK OPENSSL_clear_free(s->s3.tmp.psk, s->s3.tmp.psklen); s->s3.tmp.psk = NULL; s->s3.tmp.psklen = 0; #endif return CON_FUNC_ERROR; } int tls_client_key_exchange_post_work(SSL_CONNECTION *s) { unsigned char *pms = NULL; size_t pmslen = 0; pms = s->s3.tmp.pms; pmslen = s->s3.tmp.pmslen; #ifndef OPENSSL_NO_SRP /* Check for SRP */ if (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) { if (!srp_generate_client_master_secret(s)) { /* SSLfatal() already called */ goto err; } return 1; } #endif if (pms == NULL && !(s->s3.tmp.new_cipher->algorithm_mkey & SSL_kPSK)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } if (!ssl_generate_master_secret(s, pms, pmslen, 1)) { /* SSLfatal() already called */ /* ssl_generate_master_secret frees the pms even on error */ pms = NULL; pmslen = 0; goto err; } pms = NULL; pmslen = 0; #ifndef OPENSSL_NO_SCTP if (SSL_CONNECTION_IS_DTLS(s)) { unsigned char sctpauthkey[64]; char labelbuffer[sizeof(DTLS1_SCTP_AUTH_LABEL)]; size_t labellen; SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* * Add new shared key for SCTP-Auth, will be ignored if no SCTP * used. */ memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL, sizeof(DTLS1_SCTP_AUTH_LABEL)); /* Don't include the terminating zero. */ labellen = sizeof(labelbuffer) - 1; if (s->mode & SSL_MODE_DTLS_SCTP_LABEL_LENGTH_BUG) labellen += 1; if (SSL_export_keying_material(ssl, sctpauthkey, sizeof(sctpauthkey), labelbuffer, labellen, NULL, 0, 0) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY, sizeof(sctpauthkey), sctpauthkey); } #endif return 1; err: OPENSSL_clear_free(pms, pmslen); s->s3.tmp.pms = NULL; s->s3.tmp.pmslen = 0; return 0; } /* * Check a certificate can be used for client authentication. Currently check * cert exists, if we have a suitable digest for TLS 1.2 if static DH client * certificates can be used and optionally checks suitability for Suite B. */ static int ssl3_check_client_certificate(SSL_CONNECTION *s) { /* If no suitable signature algorithm can't use certificate */ if (!tls_choose_sigalg(s, 0) || s->s3.tmp.sigalg == NULL) return 0; /* * If strict mode check suitability of chain before using it. This also * adjusts suite B digest if necessary. */ if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT && !tls1_check_chain(s, NULL, NULL, NULL, -2)) return 0; return 1; } WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION *s, WORK_STATE wst) { X509 *x509 = NULL; EVP_PKEY *pkey = NULL; int i; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (wst == WORK_MORE_A) { /* Let cert callback update client certificates if required */ if (s->cert->cert_cb) { i = s->cert->cert_cb(ssl, s->cert->cert_cb_arg); if (i < 0) { s->rwstate = SSL_X509_LOOKUP; return WORK_MORE_A; } if (i == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED); return WORK_ERROR; } s->rwstate = SSL_NOTHING; } if (ssl3_check_client_certificate(s)) { if (s->post_handshake_auth == SSL_PHA_REQUESTED) { return WORK_FINISHED_STOP; } return WORK_FINISHED_CONTINUE; } /* Fall through to WORK_MORE_B */ wst = WORK_MORE_B; } /* We need to get a client cert */ if (wst == WORK_MORE_B) { /* * If we get an error, we need to ssl->rwstate=SSL_X509_LOOKUP; * return(-1); We then get retied later */ i = ssl_do_client_cert_cb(s, &x509, &pkey); if (i < 0) { s->rwstate = SSL_X509_LOOKUP; return WORK_MORE_B; } s->rwstate = SSL_NOTHING; if ((i == 1) && (pkey != NULL) && (x509 != NULL)) { if (!SSL_use_certificate(ssl, x509) || !SSL_use_PrivateKey(ssl, pkey)) i = 0; } else if (i == 1) { i = 0; ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA_RETURNED_BY_CALLBACK); } X509_free(x509); EVP_PKEY_free(pkey); if (i && !ssl3_check_client_certificate(s)) i = 0; if (i == 0) { if (s->version == SSL3_VERSION) { s->s3.tmp.cert_req = 0; ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_CERTIFICATE); return WORK_FINISHED_CONTINUE; } else { s->s3.tmp.cert_req = 2; s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none; if (!ssl3_digest_cached_records(s, 0)) { /* SSLfatal() already called */ return WORK_ERROR; } } } if (!SSL_CONNECTION_IS_TLS13(s) || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0) s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none; if (s->post_handshake_auth == SSL_PHA_REQUESTED) return WORK_FINISHED_STOP; return WORK_FINISHED_CONTINUE; } /* Shouldn't ever get here */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return WORK_ERROR; } CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION *s, WPACKET *pkt) { CERT_PKEY *cpk = NULL; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (SSL_CONNECTION_IS_TLS13(s)) { if (s->pha_context == NULL) { /* no context available, add 0-length context */ if (!WPACKET_put_bytes_u8(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } else if (!WPACKET_sub_memcpy_u8(pkt, s->pha_context, s->pha_context_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } } if (s->s3.tmp.cert_req != 2) cpk = s->cert->key; switch (s->ext.client_cert_type) { case TLSEXT_cert_type_rpk: if (!tls_output_rpk(s, pkt, cpk)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } break; case TLSEXT_cert_type_x509: if (!ssl3_output_cert_chain(s, pkt, cpk, 0)) { /* SSLfatal() already called */ return CON_FUNC_ERROR; } break; default: SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } /* * If we attempted to write early data or we're in middlebox compat mode * then we deferred changing the handshake write keys to the last possible * moment. We need to do it now. */ if (SSL_CONNECTION_IS_TLS13(s) && SSL_IS_FIRST_HANDSHAKE(s) && (s->early_data_state != SSL_EARLY_DATA_NONE || (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) && (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) { /* * This is a fatal error, which leaves enc_write_ctx in an inconsistent * state and thus ssl3_send_alert may crash. */ SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_CANNOT_CHANGE_CIPHER); return CON_FUNC_ERROR; } return CON_FUNC_SUCCESS; } #ifndef OPENSSL_NO_COMP_ALG CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc, WPACKET *pkt) { SSL *ssl = SSL_CONNECTION_GET_SSL(sc); WPACKET tmppkt; BUF_MEM *buf = NULL; size_t length; size_t max_length; COMP_METHOD *method; COMP_CTX *comp = NULL; int comp_len; int ret = 0; int alg = sc->ext.compress_certificate_from_peer[0]; /* Note that sc->s3.tmp.cert_req == 2 is checked in write transition */ if ((buf = BUF_MEM_new()) == NULL || !WPACKET_init(&tmppkt, buf)) goto err; /* Use the |tmppkt| for the to-be-compressed data */ if (sc->pha_context == NULL) { /* no context available, add 0-length context */ if (!WPACKET_put_bytes_u8(&tmppkt, 0)) goto err; } else if (!WPACKET_sub_memcpy_u8(&tmppkt, sc->pha_context, sc->pha_context_len)) goto err; if (!ssl3_output_cert_chain(sc, &tmppkt, sc->cert->key, 0)) { /* SSLfatal() already called */ goto out; } /* continue with the real |pkt| */ if (!WPACKET_put_bytes_u16(pkt, alg) || !WPACKET_get_total_written(&tmppkt, &length) || !WPACKET_put_bytes_u24(pkt, length)) goto err; switch (alg) { case TLSEXT_comp_cert_zlib: method = COMP_zlib_oneshot(); break; case TLSEXT_comp_cert_brotli: method = COMP_brotli_oneshot(); break; case TLSEXT_comp_cert_zstd: method = COMP_zstd_oneshot(); break; default: goto err; } max_length = ossl_calculate_comp_expansion(alg, length); if ((comp = COMP_CTX_new(method)) == NULL || !WPACKET_start_sub_packet_u24(pkt) || !WPACKET_reserve_bytes(pkt, max_length, NULL)) goto err; comp_len = COMP_compress_block(comp, WPACKET_get_curr(pkt), max_length, (unsigned char *)buf->data, length); if (comp_len <= 0) goto err; if (!WPACKET_allocate_bytes(pkt, comp_len, NULL) || !WPACKET_close(pkt)) goto err; /* * If we attempted to write early data or we're in middlebox compat mode * then we deferred changing the handshake write keys to the last possible * moment. We need to do it now. */ if (SSL_IS_FIRST_HANDSHAKE(sc) && (sc->early_data_state != SSL_EARLY_DATA_NONE || (sc->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) && (!ssl->method->ssl3_enc->change_cipher_state(sc, SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) { /* * This is a fatal error, which leaves sc->enc_write_ctx in an * inconsistent state and thus ssl3_send_alert may crash. */ SSLfatal(sc, SSL_AD_NO_ALERT, SSL_R_CANNOT_CHANGE_CIPHER); goto out; } ret = 1; goto out; err: SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); out: if (buf != NULL) { /* If |buf| is NULL, then |tmppkt| could not have been initialized */ WPACKET_cleanup(&tmppkt); } BUF_MEM_free(buf); COMP_CTX_free(comp); return ret; } #endif int ssl3_check_cert_and_algorithm(SSL_CONNECTION *s) { const SSL_CERT_LOOKUP *clu; size_t idx; long alg_k, alg_a; EVP_PKEY *pkey; alg_k = s->s3.tmp.new_cipher->algorithm_mkey; alg_a = s->s3.tmp.new_cipher->algorithm_auth; /* we don't have a certificate */ if (!(alg_a & SSL_aCERT)) return 1; /* This is the passed certificate */ pkey = tls_get_peer_pkey(s); clu = ssl_cert_lookup_by_pkey(pkey, &idx, SSL_CONNECTION_GET_CTX(s)); /* Check certificate is recognised and suitable for cipher */ if (clu == NULL || (alg_a & clu->amask) == 0) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_MISSING_SIGNING_CERT); return 0; } if (alg_k & (SSL_kRSA | SSL_kRSAPSK) && idx != SSL_PKEY_RSA) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_MISSING_RSA_ENCRYPTING_CERT); return 0; } if ((alg_k & SSL_kDHE) && (s->s3.peer_tmp == NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* Early out to skip the checks below */ if (s->session->peer_rpk != NULL) return 1; if (clu->amask & SSL_aECDSA) { if (ssl_check_srvr_ecc_cert_and_alg(s->session->peer, s)) return 1; SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_ECC_CERT); return 0; } return 1; } #ifndef OPENSSL_NO_NEXTPROTONEG CON_FUNC_RETURN tls_construct_next_proto(SSL_CONNECTION *s, WPACKET *pkt) { size_t len, padding_len; unsigned char *padding = NULL; len = s->ext.npn_len; padding_len = 32 - ((len + 2) % 32); if (!WPACKET_sub_memcpy_u8(pkt, s->ext.npn, len) || !WPACKET_sub_allocate_bytes_u8(pkt, padding_len, &padding)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return CON_FUNC_ERROR; } memset(padding, 0, padding_len); return CON_FUNC_SUCCESS; } #endif MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION *s, PACKET *pkt) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (PACKET_remaining(pkt) > 0) { /* should contain no data */ SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return MSG_PROCESS_ERROR; } if ((s->options & SSL_OP_NO_RENEGOTIATION)) { ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION); return MSG_PROCESS_FINISHED_READING; } /* * This is a historical discrepancy (not in the RFC) maintained for * compatibility reasons. If a TLS client receives a HelloRequest it will * attempt an abbreviated handshake. However if a DTLS client receives a * HelloRequest it will do a full handshake. Either behaviour is reasonable * but doing one for TLS and another for DTLS is odd. */ if (SSL_CONNECTION_IS_DTLS(s)) SSL_renegotiate(ssl); else SSL_renegotiate_abbreviated(ssl); return MSG_PROCESS_FINISHED_READING; } static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION *s, PACKET *pkt) { PACKET extensions; RAW_EXTENSION *rawexts = NULL; if (!PACKET_as_length_prefixed_2(pkt, &extensions) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); goto err; } if (!tls_collect_extensions(s, &extensions, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, &rawexts, NULL, 1) || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, rawexts, NULL, 0, 1)) { /* SSLfatal() already called */ goto err; } OPENSSL_free(rawexts); return MSG_PROCESS_CONTINUE_READING; err: OPENSSL_free(rawexts); return MSG_PROCESS_ERROR; } int ssl_do_client_cert_cb(SSL_CONNECTION *s, X509 **px509, EVP_PKEY **ppkey) { int i = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); #ifndef OPENSSL_NO_ENGINE if (sctx->client_cert_engine) { i = tls_engine_load_ssl_client_cert(s, px509, ppkey); if (i != 0) return i; } #endif if (sctx->client_cert_cb) i = sctx->client_cert_cb(SSL_CONNECTION_GET_SSL(s), px509, ppkey); return i; } int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk, WPACKET *pkt) { int i; size_t totlen = 0, len, maxlen, maxverok = 0; int empty_reneg_info_scsv = !s->renegotiate && (SSL_CONNECTION_IS_DTLS(s) || s->min_proto_version < TLS1_3_VERSION); SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* Set disabled masks for this session */ if (!ssl_set_client_disabled(s)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_PROTOCOLS_AVAILABLE); return 0; } if (sk == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH # if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6 # error Max cipher length too short # endif /* * Some servers hang if client hello > 256 bytes as hack workaround * chop number of supported ciphers to keep it well below this if we * use TLS v1.2 */ if (TLS1_get_version(ssl) >= TLS1_2_VERSION) maxlen = OPENSSL_MAX_TLS1_2_CIPHER_LENGTH & ~1; else #endif /* Maximum length that can be stored in 2 bytes. Length must be even */ maxlen = 0xfffe; if (empty_reneg_info_scsv) maxlen -= 2; if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) maxlen -= 2; for (i = 0; i < sk_SSL_CIPHER_num(sk) && totlen < maxlen; i++) { const SSL_CIPHER *c; c = sk_SSL_CIPHER_value(sk, i); /* Skip disabled ciphers */ if (ssl_cipher_disabled(s, c, SSL_SECOP_CIPHER_SUPPORTED, 0)) continue; if (!ssl->method->put_cipher_by_char(c, pkt, &len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* Sanity check that the maximum version we offer has ciphers enabled */ if (!maxverok) { int minproto = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls; int maxproto = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls; if (ssl_version_cmp(s, maxproto, s->s3.tmp.max_ver) >= 0 && ssl_version_cmp(s, minproto, s->s3.tmp.max_ver) <= 0) maxverok = 1; } totlen += len; } if (totlen == 0 || !maxverok) { const char *maxvertext = !maxverok ? "No ciphers enabled for max supported SSL/TLS version" : NULL; SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_CIPHERS_AVAILABLE, maxvertext); return 0; } if (totlen != 0) { if (empty_reneg_info_scsv) { static const SSL_CIPHER scsv = { 0, NULL, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } if (s->mode & SSL_MODE_SEND_FALLBACK_SCSV) { static const SSL_CIPHER scsv = { 0, NULL, NULL, SSL3_CK_FALLBACK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; if (!ssl->method->put_cipher_by_char(&scsv, pkt, &len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } return 1; } CON_FUNC_RETURN tls_construct_end_of_early_data(SSL_CONNECTION *s, WPACKET *pkt) { if (s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return CON_FUNC_ERROR; } s->early_data_state = SSL_EARLY_DATA_FINISHED_WRITING; return CON_FUNC_SUCCESS; }

./openssl/ssl/statem/extensions_clnt.c

/* * Copyright 2016-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/ocsp.h> #include "../ssl_local.h" #include "internal/cryptlib.h" #include "statem_local.h" EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { /* Add RI if renegotiating */ if (!s->renegotiate) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_sub_memcpy_u8(pkt, s->s3.previous_client_finished, s->s3.previous_client_finished_len) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->ext.hostname == NULL) return EXT_RETURN_NOT_SENT; /* Add TLS extension servername to the Client Hello message */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name) /* Sub-packet for server_name extension */ || !WPACKET_start_sub_packet_u16(pkt) /* Sub-packet for servername list (always 1 hostname)*/ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name) || !WPACKET_sub_memcpy_u16(pkt, s->ext.hostname, strlen(s->ext.hostname)) || !WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } /* Push a Max Fragment Len extension into ClientHello */ EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->ext.max_fragment_len_mode == TLSEXT_max_fragment_length_DISABLED) return EXT_RETURN_NOT_SENT; /* Add Max Fragment Length extension if client enabled it. */ /*- * 4 bytes for this extension type and extension length * 1 byte for the Max Fragment Length code value. */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length) /* Sub-packet for Max Fragment Length extension (1 byte) */ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u8(pkt, s->ext.max_fragment_len_mode) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_SRP EXT_RETURN tls_construct_ctos_srp(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { /* Add SRP username if there is one */ if (s->srp_ctx.login == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp) /* Sub-packet for SRP extension */ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u8(pkt) /* login must not be zero...internal error if so */ || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH) || !WPACKET_memcpy(pkt, s->srp_ctx.login, strlen(s->srp_ctx.login)) || !WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif static int use_ecc(SSL_CONNECTION *s, int min_version, int max_version) { int i, end, ret = 0; unsigned long alg_k, alg_a; STACK_OF(SSL_CIPHER) *cipher_stack = NULL; const uint16_t *pgroups = NULL; size_t num_groups, j; SSL *ssl = SSL_CONNECTION_GET_SSL(s); /* See if we support any ECC ciphersuites */ if (s->version == SSL3_VERSION) return 0; cipher_stack = SSL_get1_supported_ciphers(ssl); end = sk_SSL_CIPHER_num(cipher_stack); for (i = 0; i < end; i++) { const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i); alg_k = c->algorithm_mkey; alg_a = c->algorithm_auth; if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK)) || (alg_a & SSL_aECDSA) || c->min_tls >= TLS1_3_VERSION) { ret = 1; break; } } sk_SSL_CIPHER_free(cipher_stack); if (!ret) return 0; /* Check we have at least one EC supported group */ tls1_get_supported_groups(s, &pgroups, &num_groups); for (j = 0; j < num_groups; j++) { uint16_t ctmp = pgroups[j]; if (tls_valid_group(s, ctmp, min_version, max_version, 1, NULL) && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) return 1; } return 0; } EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { const unsigned char *pformats; size_t num_formats; int reason, min_version, max_version; reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); if (reason != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); return EXT_RETURN_FAIL; } if (!use_ecc(s, min_version, max_version)) return EXT_RETURN_NOT_SENT; /* Add TLS extension ECPointFormats to the ClientHello message */ tls1_get_formatlist(s, &pformats, &num_formats); if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats) /* Sub-packet for formats extension */ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { const uint16_t *pgroups = NULL; size_t num_groups = 0, i, tls13added = 0, added = 0; int min_version, max_version, reason; reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); if (reason != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); return EXT_RETURN_FAIL; } /* * We only support EC groups in TLSv1.2 or below, and in DTLS. Therefore * if we don't have EC support then we don't send this extension. */ if (!use_ecc(s, min_version, max_version) && (SSL_CONNECTION_IS_DTLS(s) || max_version < TLS1_3_VERSION)) return EXT_RETURN_NOT_SENT; /* * Add TLS extension supported_groups to the ClientHello message */ tls1_get_supported_groups(s, &pgroups, &num_groups); if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups) /* Sub-packet for supported_groups extension */ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } /* Copy group ID if supported */ for (i = 0; i < num_groups; i++) { uint16_t ctmp = pgroups[i]; int okfortls13; if (tls_valid_group(s, ctmp, min_version, max_version, 0, &okfortls13) && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) { if (!WPACKET_put_bytes_u16(pkt, ctmp)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (okfortls13 && max_version == TLS1_3_VERSION) tls13added++; added++; } } if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { if (added == 0) SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_GROUPS, "No groups enabled for max supported SSL/TLS version"); else SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (tls13added == 0 && max_version == TLS1_3_VERSION) { SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_GROUPS, "No groups enabled for max supported SSL/TLS version"); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { size_t ticklen; if (!tls_use_ticket(s)) return EXT_RETURN_NOT_SENT; if (!s->new_session && s->session != NULL && s->session->ext.tick != NULL && s->session->ssl_version != TLS1_3_VERSION) { ticklen = s->session->ext.ticklen; } else if (s->session && s->ext.session_ticket != NULL && s->ext.session_ticket->data != NULL) { ticklen = s->ext.session_ticket->length; s->session->ext.tick = OPENSSL_malloc(ticklen); if (s->session->ext.tick == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } memcpy(s->session->ext.tick, s->ext.session_ticket->data, ticklen); s->session->ext.ticklen = ticklen; } else { ticklen = 0; } if (ticklen == 0 && s->ext.session_ticket != NULL && s->ext.session_ticket->data == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket) || !WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, ticklen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { size_t salglen; const uint16_t *salg; if (!SSL_CLIENT_USE_SIGALGS(s)) return EXT_RETURN_NOT_SENT; salglen = tls12_get_psigalgs(s, 1, &salg); if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms) /* Sub-packet for sig-algs extension */ || !WPACKET_start_sub_packet_u16(pkt) /* Sub-packet for the actual list */ || !WPACKET_start_sub_packet_u16(pkt) || !tls12_copy_sigalgs(s, pkt, salg, salglen) || !WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_OCSP EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { int i; /* This extension isn't defined for client Certificates */ if (x != NULL) return EXT_RETURN_NOT_SENT; if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request) /* Sub-packet for status request extension */ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp) /* Sub-packet for the ids */ || !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } for (i = 0; i < sk_OCSP_RESPID_num(s->ext.ocsp.ids); i++) { unsigned char *idbytes; OCSP_RESPID *id = sk_OCSP_RESPID_value(s->ext.ocsp.ids, i); int idlen = i2d_OCSP_RESPID(id, NULL); if (idlen <= 0 /* Sub-packet for an individual id */ || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes) || i2d_OCSP_RESPID(id, &idbytes) != idlen) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (!WPACKET_close(pkt) || !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (s->ext.ocsp.exts) { unsigned char *extbytes; int extlen = i2d_X509_EXTENSIONS(s->ext.ocsp.exts, NULL); if (extlen < 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes) || i2d_X509_EXTENSIONS(s->ext.ocsp.exts, &extbytes) != extlen) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (SSL_CONNECTION_GET_CTX(s)->ext.npn_select_cb == NULL || !SSL_IS_FIRST_HANDSHAKE(s)) return EXT_RETURN_NOT_SENT; /* * The client advertises an empty extension to indicate its support * for Next Protocol Negotiation */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { s->s3.alpn_sent = 0; if (s->ext.alpn == NULL || !SSL_IS_FIRST_HANDSHAKE(s)) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_application_layer_protocol_negotiation) /* Sub-packet ALPN extension */ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_sub_memcpy_u16(pkt, s->ext.alpn, s->ext.alpn_len) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->s3.alpn_sent = 1; return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_SRTP EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(ssl); int i, end; if (clnt == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp) /* Sub-packet for SRTP extension */ || !WPACKET_start_sub_packet_u16(pkt) /* Sub-packet for the protection profile list */ || !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } end = sk_SRTP_PROTECTION_PROFILE_num(clnt); for (i = 0; i < end; i++) { const SRTP_PROTECTION_PROFILE *prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i); if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (!WPACKET_close(pkt) /* Add an empty use_mki value */ || !WPACKET_put_bytes_u8(pkt, 0) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_CT EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->ct_validation_callback == NULL) return EXT_RETURN_NOT_SENT; /* Not defined for client Certificates */ if (x != NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } #endif EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret) || !WPACKET_put_bytes_u16(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { int currv, min_version, max_version, reason; reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL); if (reason != 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, reason); return EXT_RETURN_FAIL; } /* * Don't include this if we can't negotiate TLSv1.3. We can do a straight * comparison here because we will never be called in DTLS. */ if (max_version < TLS1_3_VERSION) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u8(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } for (currv = max_version; currv >= min_version; currv--) { if (!WPACKET_put_bytes_u16(pkt, currv)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; } /* * Construct a psk_kex_modes extension. */ EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 int nodhe = s->options & SSL_OP_ALLOW_NO_DHE_KEX; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk_kex_modes) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u8(pkt) || !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE_DHE) || (nodhe && !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE)) || !WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_KE_DHE; if (nodhe) s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE; #endif return EXT_RETURN_SENT; } #ifndef OPENSSL_NO_TLS1_3 static int add_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int curve_id) { unsigned char *encoded_point = NULL; EVP_PKEY *key_share_key = NULL; size_t encodedlen; if (s->s3.tmp.pkey != NULL) { if (!ossl_assert(s->hello_retry_request == SSL_HRR_PENDING)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * Could happen if we got an HRR that wasn't requesting a new key_share */ key_share_key = s->s3.tmp.pkey; } else { key_share_key = ssl_generate_pkey_group(s, curve_id); if (key_share_key == NULL) { /* SSLfatal() already called */ return 0; } } /* Encode the public key. */ encodedlen = EVP_PKEY_get1_encoded_public_key(key_share_key, &encoded_point); if (encodedlen == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB); goto err; } /* Create KeyShareEntry */ if (!WPACKET_put_bytes_u16(pkt, curve_id) || !WPACKET_sub_memcpy_u16(pkt, encoded_point, encodedlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } /* * When changing to send more than one key_share we're * going to need to be able to save more than one EVP_PKEY. For now * we reuse the existing tmp.pkey */ s->s3.tmp.pkey = key_share_key; s->s3.group_id = curve_id; OPENSSL_free(encoded_point); return 1; err: if (s->s3.tmp.pkey == NULL) EVP_PKEY_free(key_share_key); OPENSSL_free(encoded_point); return 0; } #endif EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 size_t i, num_groups = 0; const uint16_t *pgroups = NULL; uint16_t curve_id = 0; /* key_share extension */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share) /* Extension data sub-packet */ || !WPACKET_start_sub_packet_u16(pkt) /* KeyShare list sub-packet */ || !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } tls1_get_supported_groups(s, &pgroups, &num_groups); /* * Make the number of key_shares sent configurable. For * now, we just send one */ if (s->s3.group_id != 0) { curve_id = s->s3.group_id; } else { for (i = 0; i < num_groups; i++) { if (!tls_group_allowed(s, pgroups[i], SSL_SECOP_CURVE_SUPPORTED)) continue; if (!tls_valid_group(s, pgroups[i], TLS1_3_VERSION, TLS1_3_VERSION, 0, NULL)) continue; curve_id = pgroups[i]; break; } } if (curve_id == 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_KEY_SHARE); return EXT_RETURN_FAIL; } if (!add_key_share(s, pkt, curve_id)) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; #else return EXT_RETURN_NOT_SENT; #endif } EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { EXT_RETURN ret = EXT_RETURN_FAIL; /* Should only be set if we've had an HRR */ if (s->ext.tls13_cookie_len == 0) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie) /* Extension data sub-packet */ || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_sub_memcpy_u16(pkt, s->ext.tls13_cookie, s->ext.tls13_cookie_len) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto end; } ret = EXT_RETURN_SENT; end: OPENSSL_free(s->ext.tls13_cookie); s->ext.tls13_cookie = NULL; s->ext.tls13_cookie_len = 0; return ret; } EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_PSK char identity[PSK_MAX_IDENTITY_LEN + 1]; #endif /* OPENSSL_NO_PSK */ const unsigned char *id = NULL; size_t idlen = 0; SSL_SESSION *psksess = NULL; SSL_SESSION *edsess = NULL; const EVP_MD *handmd = NULL; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->hello_retry_request == SSL_HRR_PENDING) handmd = ssl_handshake_md(s); if (s->psk_use_session_cb != NULL && (!s->psk_use_session_cb(ssl, handmd, &id, &idlen, &psksess) || (psksess != NULL && psksess->ssl_version != TLS1_3_VERSION))) { SSL_SESSION_free(psksess); SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); return EXT_RETURN_FAIL; } #ifndef OPENSSL_NO_PSK if (psksess == NULL && s->psk_client_callback != NULL) { unsigned char psk[PSK_MAX_PSK_LEN]; size_t psklen = 0; memset(identity, 0, sizeof(identity)); psklen = s->psk_client_callback(ssl, NULL, identity, sizeof(identity) - 1, psk, sizeof(psk)); if (psklen > PSK_MAX_PSK_LEN) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } else if (psklen > 0) { const unsigned char tls13_aes128gcmsha256_id[] = { 0x13, 0x01 }; const SSL_CIPHER *cipher; idlen = strlen(identity); if (idlen > PSK_MAX_IDENTITY_LEN) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } id = (unsigned char *)identity; /* * We found a PSK using an old style callback. We don't know * the digest so we default to SHA256 as per the TLSv1.3 spec */ cipher = SSL_CIPHER_find(ssl, tls13_aes128gcmsha256_id); if (cipher == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } psksess = SSL_SESSION_new(); if (psksess == NULL || !SSL_SESSION_set1_master_key(psksess, psk, psklen) || !SSL_SESSION_set_cipher(psksess, cipher) || !SSL_SESSION_set_protocol_version(psksess, TLS1_3_VERSION)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); OPENSSL_cleanse(psk, psklen); return EXT_RETURN_FAIL; } OPENSSL_cleanse(psk, psklen); } } #endif /* OPENSSL_NO_PSK */ SSL_SESSION_free(s->psksession); s->psksession = psksess; if (psksess != NULL) { OPENSSL_free(s->psksession_id); s->psksession_id = OPENSSL_memdup(id, idlen); if (s->psksession_id == NULL) { s->psksession_id_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->psksession_id_len = idlen; } if (s->early_data_state != SSL_EARLY_DATA_CONNECTING || (s->session->ext.max_early_data == 0 && (psksess == NULL || psksess->ext.max_early_data == 0))) { s->max_early_data = 0; return EXT_RETURN_NOT_SENT; } edsess = s->session->ext.max_early_data != 0 ? s->session : psksess; s->max_early_data = edsess->ext.max_early_data; if (edsess->ext.hostname != NULL) { if (s->ext.hostname == NULL || (s->ext.hostname != NULL && strcmp(s->ext.hostname, edsess->ext.hostname) != 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_INCONSISTENT_EARLY_DATA_SNI); return EXT_RETURN_FAIL; } } if ((s->ext.alpn == NULL && edsess->ext.alpn_selected != NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_INCONSISTENT_EARLY_DATA_ALPN); return EXT_RETURN_FAIL; } /* * Verify that we are offering an ALPN protocol consistent with the early * data. */ if (edsess->ext.alpn_selected != NULL) { PACKET prots, alpnpkt; int found = 0; if (!PACKET_buf_init(&prots, s->ext.alpn, s->ext.alpn_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } while (PACKET_get_length_prefixed_1(&prots, &alpnpkt)) { if (PACKET_equal(&alpnpkt, edsess->ext.alpn_selected, edsess->ext.alpn_selected_len)) { found = 1; break; } } if (!found) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_INCONSISTENT_EARLY_DATA_ALPN); return EXT_RETURN_FAIL; } } if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } /* * We set this to rejected here. Later, if the server acknowledges the * extension, we set it to accepted. */ s->ext.early_data = SSL_EARLY_DATA_REJECTED; s->ext.early_data_ok = 1; return EXT_RETURN_SENT; } #define F5_WORKAROUND_MIN_MSG_LEN 0xff #define F5_WORKAROUND_MAX_MSG_LEN 0x200 /* * PSK pre binder overhead = * 2 bytes for TLSEXT_TYPE_psk * 2 bytes for extension length * 2 bytes for identities list length * 2 bytes for identity length * 4 bytes for obfuscated_ticket_age * 2 bytes for binder list length * 1 byte for binder length * The above excludes the number of bytes for the identity itself and the * subsequent binder bytes */ #define PSK_PRE_BINDER_OVERHEAD (2 + 2 + 2 + 2 + 4 + 2 + 1) EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned char *padbytes; size_t hlen; if ((s->options & SSL_OP_TLSEXT_PADDING) == 0) return EXT_RETURN_NOT_SENT; /* * Add padding to workaround bugs in F5 terminators. See RFC7685. * This code calculates the length of all extensions added so far but * excludes the PSK extension (because that MUST be written last). Therefore * this extension MUST always appear second to last. */ if (!WPACKET_get_total_written(pkt, &hlen)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } /* * If we're going to send a PSK then that will be written out after this * extension, so we need to calculate how long it is going to be. */ if (s->session->ssl_version == TLS1_3_VERSION && s->session->ext.ticklen != 0 && s->session->cipher != NULL) { const EVP_MD *md = ssl_md(SSL_CONNECTION_GET_CTX(s), s->session->cipher->algorithm2); if (md != NULL) { /* * Add the fixed PSK overhead, the identity length and the binder * length. */ hlen += PSK_PRE_BINDER_OVERHEAD + s->session->ext.ticklen + EVP_MD_get_size(md); } } if (hlen > F5_WORKAROUND_MIN_MSG_LEN && hlen < F5_WORKAROUND_MAX_MSG_LEN) { /* Calculate the amount of padding we need to add */ hlen = F5_WORKAROUND_MAX_MSG_LEN - hlen; /* * Take off the size of extension header itself (2 bytes for type and * 2 bytes for length bytes), but ensure that the extension is at least * 1 byte long so as not to have an empty extension last (WebSphere 7.x, * 8.x are intolerant of that condition) */ if (hlen > 4) hlen -= 4; else hlen = 1; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding) || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } memset(padbytes, 0, hlen); } return EXT_RETURN_SENT; } /* * Construct the pre_shared_key extension */ EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 uint32_t agesec, agems = 0; size_t reshashsize = 0, pskhashsize = 0, binderoffset, msglen; unsigned char *resbinder = NULL, *pskbinder = NULL, *msgstart = NULL; const EVP_MD *handmd = NULL, *mdres = NULL, *mdpsk = NULL; int dores = 0; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); OSSL_TIME t; s->ext.tick_identity = 0; /* * Note: At this stage of the code we only support adding a single * resumption PSK. If we add support for multiple PSKs then the length * calculations in the padding extension will need to be adjusted. */ /* * If this is an incompatible or new session then we have nothing to resume * so don't add this extension. */ if (s->session->ssl_version != TLS1_3_VERSION || (s->session->ext.ticklen == 0 && s->psksession == NULL)) return EXT_RETURN_NOT_SENT; if (s->hello_retry_request == SSL_HRR_PENDING) handmd = ssl_handshake_md(s); if (s->session->ext.ticklen != 0) { /* Get the digest associated with the ciphersuite in the session */ if (s->session->cipher == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } mdres = ssl_md(sctx, s->session->cipher->algorithm2); if (mdres == NULL) { /* * Don't recognize this cipher so we can't use the session. * Ignore it */ goto dopsksess; } if (s->hello_retry_request == SSL_HRR_PENDING && mdres != handmd) { /* * Selected ciphersuite hash does not match the hash for the session * so we can't use it. */ goto dopsksess; } /* * Technically the C standard just says time() returns a time_t and says * nothing about the encoding of that type. In practice most * implementations follow POSIX which holds it as an integral type in * seconds since epoch. We've already made the assumption that we can do * this in multiple places in the code, so portability shouldn't be an * issue. */ t = ossl_time_subtract(ossl_time_now(), s->session->time); agesec = (uint32_t)ossl_time2seconds(t); /* * We calculate the age in seconds but the server may work in ms. Due to * rounding errors we could overestimate the age by up to 1s. It is * better to underestimate it. Otherwise, if the RTT is very short, when * the server calculates the age reported by the client it could be * bigger than the age calculated on the server - which should never * happen. */ if (agesec > 0) agesec--; if (s->session->ext.tick_lifetime_hint < agesec) { /* Ticket is too old. Ignore it. */ goto dopsksess; } /* * Calculate age in ms. We're just doing it to nearest second. Should be * good enough. */ agems = agesec * (uint32_t)1000; if (agesec != 0 && agems / (uint32_t)1000 != agesec) { /* * Overflow. Shouldn't happen unless this is a *really* old session. * If so we just ignore it. */ goto dopsksess; } /* * Obfuscate the age. Overflow here is fine, this addition is supposed * to be mod 2^32. */ agems += s->session->ext.tick_age_add; reshashsize = EVP_MD_get_size(mdres); s->ext.tick_identity++; dores = 1; } dopsksess: if (!dores && s->psksession == NULL) return EXT_RETURN_NOT_SENT; if (s->psksession != NULL) { mdpsk = ssl_md(sctx, s->psksession->cipher->algorithm2); if (mdpsk == NULL) { /* * Don't recognize this cipher so we can't use the session. * If this happens it's an application bug. */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); return EXT_RETURN_FAIL; } if (s->hello_retry_request == SSL_HRR_PENDING && mdpsk != handmd) { /* * Selected ciphersuite hash does not match the hash for the PSK * session. This is an application bug. */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK); return EXT_RETURN_FAIL; } pskhashsize = EVP_MD_get_size(mdpsk); } /* Create the extension, but skip over the binder for now */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_start_sub_packet_u16(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } if (dores) { if (!WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, s->session->ext.ticklen) || !WPACKET_put_bytes_u32(pkt, agems)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } } if (s->psksession != NULL) { if (!WPACKET_sub_memcpy_u16(pkt, s->psksession_id, s->psksession_id_len) || !WPACKET_put_bytes_u32(pkt, 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->ext.tick_identity++; } if (!WPACKET_close(pkt) || !WPACKET_get_total_written(pkt, &binderoffset) || !WPACKET_start_sub_packet_u16(pkt) || (dores && !WPACKET_sub_allocate_bytes_u8(pkt, reshashsize, &resbinder)) || (s->psksession != NULL && !WPACKET_sub_allocate_bytes_u8(pkt, pskhashsize, &pskbinder)) || !WPACKET_close(pkt) || !WPACKET_close(pkt) || !WPACKET_get_total_written(pkt, &msglen) /* * We need to fill in all the sub-packet lengths now so we can * calculate the HMAC of the message up to the binders */ || !WPACKET_fill_lengths(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } msgstart = WPACKET_get_curr(pkt) - msglen; if (dores && tls_psk_do_binder(s, mdres, msgstart, binderoffset, NULL, resbinder, s->session, 1, 0) != 1) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } if (s->psksession != NULL && tls_psk_do_binder(s, mdpsk, msgstart, binderoffset, NULL, pskbinder, s->psksession, 1, 1) != 1) { /* SSLfatal() already called */ return EXT_RETURN_FAIL; } return EXT_RETURN_SENT; #else return EXT_RETURN_NOT_SENT; #endif } EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION *s, WPACKET *pkt, ossl_unused unsigned int context, ossl_unused X509 *x, ossl_unused size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 if (!s->pha_enabled) return EXT_RETURN_NOT_SENT; /* construct extension - 0 length, no contents */ if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_post_handshake_auth) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_close(pkt)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } s->post_handshake_auth = SSL_PHA_EXT_SENT; return EXT_RETURN_SENT; #else return EXT_RETURN_NOT_SENT; #endif } /* * Parse the server's renegotiation binding and abort if it's not right */ int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { size_t expected_len = s->s3.previous_client_finished_len + s->s3.previous_server_finished_len; size_t ilen; const unsigned char *data; /* Check for logic errors */ if (!ossl_assert(expected_len == 0 || s->s3.previous_client_finished_len != 0) || !ossl_assert(expected_len == 0 || s->s3.previous_server_finished_len != 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* Parse the length byte */ if (!PACKET_get_1_len(pkt, &ilen)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RENEGOTIATION_ENCODING_ERR); return 0; } /* Consistency check */ if (PACKET_remaining(pkt) != ilen) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_RENEGOTIATION_ENCODING_ERR); return 0; } /* Check that the extension matches */ if (ilen != expected_len) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); return 0; } if (!PACKET_get_bytes(pkt, &data, s->s3.previous_client_finished_len) || memcmp(data, s->s3.previous_client_finished, s->s3.previous_client_finished_len) != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); return 0; } if (!PACKET_get_bytes(pkt, &data, s->s3.previous_server_finished_len) || memcmp(data, s->s3.previous_server_finished, s->s3.previous_server_finished_len) != 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH); return 0; } s->s3.send_connection_binding = 1; return 1; } /* Parse the server's max fragment len extension packet */ int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned int value; if (PACKET_remaining(pkt) != 1 || !PACKET_get_1(pkt, &value)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* |value| should contains a valid max-fragment-length code. */ if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } /* Must be the same value as client-configured one who was sent to server */ /*- * RFC 6066: if a client receives a maximum fragment length negotiation * response that differs from the length it requested, ... * It must abort with SSL_AD_ILLEGAL_PARAMETER alert */ if (value != s->ext.max_fragment_len_mode) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH); return 0; } /* * Maximum Fragment Length Negotiation succeeded. * The negotiated Maximum Fragment Length is binding now. */ s->session->ext.max_fragment_len_mode = value; return 1; } int tls_parse_stoc_server_name(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->ext.hostname == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (PACKET_remaining(pkt) > 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit) { if (s->session->ext.hostname != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname); if (s->session->ext.hostname == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { size_t ecpointformats_len; PACKET ecptformatlist; if (!PACKET_as_length_prefixed_1(pkt, &ecptformatlist)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->hit) { ecpointformats_len = PACKET_remaining(&ecptformatlist); if (ecpointformats_len == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH); return 0; } s->ext.peer_ecpointformats_len = 0; OPENSSL_free(s->ext.peer_ecpointformats); s->ext.peer_ecpointformats = OPENSSL_malloc(ecpointformats_len); if (s->ext.peer_ecpointformats == NULL) { s->ext.peer_ecpointformats_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->ext.peer_ecpointformats_len = ecpointformats_len; if (!PACKET_copy_bytes(&ecptformatlist, s->ext.peer_ecpointformats, ecpointformats_len)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_parse_stoc_session_ticket(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->ext.session_ticket_cb != NULL && !s->ext.session_ticket_cb(ssl, PACKET_data(pkt), PACKET_remaining(pkt), s->ext.session_ticket_cb_arg)) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION); return 0; } if (!tls_use_ticket(s)) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } if (PACKET_remaining(pkt) > 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } s->ext.ticket_expected = 1; return 1; } #ifndef OPENSSL_NO_OCSP int tls_parse_stoc_status_request(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) { /* We ignore this if the server sends a CertificateRequest */ return 1; } /* * MUST only be sent if we've requested a status * request message. In TLS <= 1.2 it must also be empty. */ if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } if (!SSL_CONNECTION_IS_TLS13(s) && PACKET_remaining(pkt) > 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (SSL_CONNECTION_IS_TLS13(s)) { /* We only know how to handle this if it's for the first Certificate in * the chain. We ignore any other responses. */ if (chainidx != 0) return 1; /* SSLfatal() already called */ return tls_process_cert_status_body(s, pkt); } /* Set flag to expect CertificateStatus message */ s->ext.status_expected = 1; return 1; } #endif #ifndef OPENSSL_NO_CT int tls_parse_stoc_sct(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) { /* We ignore this if the server sends it in a CertificateRequest */ return 1; } /* * Only take it if we asked for it - i.e if there is no CT validation * callback set, then a custom extension MAY be processing it, so we * need to let control continue to flow to that. */ if (s->ct_validation_callback != NULL) { size_t size = PACKET_remaining(pkt); /* Simply copy it off for later processing */ OPENSSL_free(s->ext.scts); s->ext.scts = NULL; s->ext.scts_len = (uint16_t)size; if (size > 0) { s->ext.scts = OPENSSL_malloc(size); if (s->ext.scts == NULL) { s->ext.scts_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return 0; } if (!PACKET_copy_bytes(pkt, s->ext.scts, size)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } else { ENDPOINT role = (context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0 ? ENDPOINT_CLIENT : ENDPOINT_BOTH; /* * If we didn't ask for it then there must be a custom extension, * otherwise this is unsolicited. */ if (custom_ext_find(&s->cert->custext, role, TLSEXT_TYPE_signed_certificate_timestamp, NULL) == NULL) { SSLfatal(s, TLS1_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } if (!custom_ext_parse(s, context, TLSEXT_TYPE_signed_certificate_timestamp, PACKET_data(pkt), PACKET_remaining(pkt), x, chainidx)) { /* SSLfatal already called */ return 0; } } return 1; } #endif #ifndef OPENSSL_NO_NEXTPROTONEG /* * ssl_next_proto_validate validates a Next Protocol Negotiation block. No * elements of zero length are allowed and the set of elements must exactly * fill the length of the block. Returns 1 on success or 0 on failure. */ static int ssl_next_proto_validate(SSL_CONNECTION *s, PACKET *pkt) { PACKET tmp_protocol; while (PACKET_remaining(pkt)) { if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol) || PACKET_remaining(&tmp_protocol) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } } return 1; } int tls_parse_stoc_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned char *selected; unsigned char selected_len; PACKET tmppkt; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); /* Check if we are in a renegotiation. If so ignore this extension */ if (!SSL_IS_FIRST_HANDSHAKE(s)) return 1; /* We must have requested it. */ if (sctx->ext.npn_select_cb == NULL) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } /* The data must be valid */ tmppkt = *pkt; if (!ssl_next_proto_validate(s, &tmppkt)) { /* SSLfatal() already called */ return 0; } if (sctx->ext.npn_select_cb(SSL_CONNECTION_GET_SSL(s), &selected, &selected_len, PACKET_data(pkt), PACKET_remaining(pkt), sctx->ext.npn_select_cb_arg) != SSL_TLSEXT_ERR_OK) { SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION); return 0; } /* * Could be non-NULL if server has sent multiple NPN extensions in * a single Serverhello */ OPENSSL_free(s->ext.npn); s->ext.npn = OPENSSL_malloc(selected_len); if (s->ext.npn == NULL) { s->ext.npn_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } memcpy(s->ext.npn, selected, selected_len); s->ext.npn_len = selected_len; s->s3.npn_seen = 1; return 1; } #endif int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { size_t len; /* We must have requested it. */ if (!s->s3.alpn_sent) { SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION); return 0; } /*- * The extension data consists of: * uint16 list_length * uint8 proto_length; * uint8 proto[proto_length]; */ if (!PACKET_get_net_2_len(pkt, &len) || PACKET_remaining(pkt) != len || !PACKET_get_1_len(pkt, &len) || PACKET_remaining(pkt) != len) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } OPENSSL_free(s->s3.alpn_selected); s->s3.alpn_selected = OPENSSL_malloc(len); if (s->s3.alpn_selected == NULL) { s->s3.alpn_selected_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!PACKET_copy_bytes(pkt, s->s3.alpn_selected, len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } s->s3.alpn_selected_len = len; if (s->session->ext.alpn_selected == NULL || s->session->ext.alpn_selected_len != len || memcmp(s->session->ext.alpn_selected, s->s3.alpn_selected, len) != 0) { /* ALPN not consistent with the old session so cannot use early_data */ s->ext.early_data_ok = 0; } if (!s->hit) { /* * This is a new session and so alpn_selected should have been * initialised to NULL. We should update it with the selected ALPN. */ if (!ossl_assert(s->session->ext.alpn_selected == NULL)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.alpn_selected = OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len); if (s->session->ext.alpn_selected == NULL) { s->session->ext.alpn_selected_len = 0; SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->session->ext.alpn_selected_len = s->s3.alpn_selected_len; } return 1; } #ifndef OPENSSL_NO_SRTP int tls_parse_stoc_use_srtp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned int id, ct, mki; int i; STACK_OF(SRTP_PROTECTION_PROFILE) *clnt; SRTP_PROTECTION_PROFILE *prof; if (!PACKET_get_net_2(pkt, &ct) || ct != 2 || !PACKET_get_net_2(pkt, &id) || !PACKET_get_1(pkt, &mki) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } if (mki != 0) { /* Must be no MKI, since we never offer one */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_SRTP_MKI_VALUE); return 0; } /* Throw an error if the server gave us an unsolicited extension */ clnt = SSL_get_srtp_profiles(SSL_CONNECTION_GET_SSL(s)); if (clnt == NULL) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_NO_SRTP_PROFILES); return 0; } /* * Check to see if the server gave us something we support (and * presumably offered) */ for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(clnt); i++) { prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i); if (prof->id == id) { s->srtp_profile = prof; return 1; } } SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST); return 0; } #endif int tls_parse_stoc_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { /* Ignore if inappropriate ciphersuite */ if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC) && s->s3.tmp.new_cipher->algorithm_mac != SSL_AEAD && s->s3.tmp.new_cipher->algorithm_enc != SSL_RC4 && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT12 && s->s3.tmp.new_cipher->algorithm_enc != SSL_MAGMA && s->s3.tmp.new_cipher->algorithm_enc != SSL_KUZNYECHIK) s->ext.use_etm = 1; return 1; } int tls_parse_stoc_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET) return 1; s->s3.flags |= TLS1_FLAGS_RECEIVED_EXTMS; if (!s->hit) s->session->flags |= SSL_SESS_FLAG_EXTMS; return 1; } int tls_parse_stoc_supported_versions(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned int version; if (!PACKET_get_net_2(pkt, &version) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } /* * The only protocol version we support which is valid in this extension in * a ServerHello is TLSv1.3 therefore we shouldn't be getting anything else. */ if (version != TLS1_3_VERSION) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_PROTOCOL_VERSION_NUMBER); return 0; } /* We ignore this extension for HRRs except to sanity check it */ if (context == SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) return 1; /* We just set it here. We validate it in ssl_choose_client_version */ s->version = version; if (!ssl_set_record_protocol_version(s, version)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned int group_id; PACKET encoded_pt; EVP_PKEY *ckey = s->s3.tmp.pkey, *skey = NULL; const TLS_GROUP_INFO *ginf = NULL; /* Sanity check */ if (ckey == NULL || s->s3.peer_tmp != NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!PACKET_get_net_2(pkt, &group_id)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) { const uint16_t *pgroups = NULL; size_t i, num_groups; if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } /* * It is an error if the HelloRetryRequest wants a key_share that we * already sent in the first ClientHello */ if (group_id == s->s3.group_id) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } /* Validate the selected group is one we support */ tls1_get_supported_groups(s, &pgroups, &num_groups); for (i = 0; i < num_groups; i++) { if (group_id == pgroups[i]) break; } if (i >= num_groups || !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED) || !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION, 0, NULL)) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } s->s3.group_id = group_id; EVP_PKEY_free(s->s3.tmp.pkey); s->s3.tmp.pkey = NULL; return 1; } if (group_id != s->s3.group_id) { /* * This isn't for the group that we sent in the original * key_share! */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } /* Retain this group in the SSL_SESSION */ if (!s->hit) { s->session->kex_group = group_id; } else if (group_id != s->session->kex_group) { /* * If this is a resumption but changed what group was used, we need * to record the new group in the session, but the session is not * a new session and could be in use by other threads. So, make * a copy of the session to record the new information so that it's * useful for any sessions resumed from tickets issued on this * connection. */ SSL_SESSION *new_sess; if ((new_sess = ssl_session_dup(s->session, 0)) == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SSL_LIB); return 0; } SSL_SESSION_free(s->session); s->session = new_sess; s->session->kex_group = group_id; } if ((ginf = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s), group_id)) == NULL) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE); return 0; } if (!PACKET_as_length_prefixed_2(pkt, &encoded_pt) || PACKET_remaining(&encoded_pt) == 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (!ginf->is_kem) { /* Regular KEX */ skey = EVP_PKEY_new(); if (skey == NULL || EVP_PKEY_copy_parameters(skey, ckey) <= 0) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COPY_PARAMETERS_FAILED); EVP_PKEY_free(skey); return 0; } if (tls13_set_encoded_pub_key(skey, PACKET_data(&encoded_pt), PACKET_remaining(&encoded_pt)) <= 0) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT); EVP_PKEY_free(skey); return 0; } if (ssl_derive(s, ckey, skey, 1) == 0) { /* SSLfatal() already called */ EVP_PKEY_free(skey); return 0; } s->s3.peer_tmp = skey; } else { /* KEM Mode */ const unsigned char *ct = PACKET_data(&encoded_pt); size_t ctlen = PACKET_remaining(&encoded_pt); if (ssl_decapsulate(s, ckey, ct, ctlen, 1) == 0) { /* SSLfatal() already called */ return 0; } } s->s3.did_kex = 1; #endif return 1; } int tls_parse_stoc_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { PACKET cookie; if (!PACKET_as_length_prefixed_2(pkt, &cookie) || !PACKET_memdup(&cookie, &s->ext.tls13_cookie, &s->ext.tls13_cookie_len)) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } return 1; } int tls_parse_stoc_early_data(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) { unsigned long max_early_data; if (!PACKET_get_net_4(pkt, &max_early_data) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_INVALID_MAX_EARLY_DATA); return 0; } s->session->ext.max_early_data = max_early_data; if (SSL_IS_QUIC_HANDSHAKE(s) && max_early_data != 0xffffffff) { /* * QUIC allows missing max_early_data, or a max_early_data value * of 0xffffffff. Missing max_early_data is stored in the session * as 0. This is indistinguishable in OpenSSL from a present * max_early_data value that was 0. In order that later checks for * invalid max_early_data correctly treat as an error the case where * max_early_data is present and it is 0, we store any invalid * value in the same (non-zero) way. Otherwise we would have to * introduce a new flag just for this. */ s->session->ext.max_early_data = 1; SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_MAX_EARLY_DATA); return 0; } return 1; } if (PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!s->ext.early_data_ok || !s->hit) { /* * If we get here then we didn't send early data, or we didn't resume * using the first identity, or the SNI/ALPN is not consistent so the * server should not be accepting it. */ SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION); return 0; } s->ext.early_data = SSL_EARLY_DATA_ACCEPTED; return 1; } int tls_parse_stoc_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { #ifndef OPENSSL_NO_TLS1_3 unsigned int identity; if (!PACKET_get_net_2(pkt, &identity) || PACKET_remaining(pkt) != 0) { SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH); return 0; } if (identity >= (unsigned int)s->ext.tick_identity) { SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_PSK_IDENTITY); return 0; } /* * Session resumption tickets are always sent before PSK tickets. If the * ticket index is 0 then it must be for a session resumption ticket if we * sent two tickets, or if we didn't send a PSK ticket. */ if (identity == 0 && (s->psksession == NULL || s->ext.tick_identity == 2)) { s->hit = 1; SSL_SESSION_free(s->psksession); s->psksession = NULL; return 1; } if (s->psksession == NULL) { /* Should never happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* * If we used the external PSK for sending early_data then s->early_secret * is already set up, so don't overwrite it. Otherwise we copy the * early_secret across that we generated earlier. */ if ((s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) || s->session->ext.max_early_data > 0 || s->psksession->ext.max_early_data == 0) memcpy(s->early_secret, s->psksession->early_secret, EVP_MAX_MD_SIZE); SSL_SESSION_free(s->session); s->session = s->psksession; s->psksession = NULL; s->hit = 1; /* Early data is only allowed if we used the first ticket */ if (identity != 0) s->ext.early_data_ok = 0; #endif return 1; } EXT_RETURN tls_construct_ctos_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; if (sc->client_cert_type == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_client_cert_type) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_sub_memcpy_u8(pkt, sc->client_cert_type, sc->client_cert_type_len) || !WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_GOOD; return EXT_RETURN_SENT; } int tls_parse_stoc_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned int type; if (PACKET_remaining(pkt) != 1) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_get_1(pkt, &type)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* We did not send/ask for this */ if (!ossl_assert(sc->ext.client_cert_type_ctos == OSSL_CERT_TYPE_CTOS_GOOD)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* We don't have this enabled */ if (sc->client_cert_type == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* Given back a value we didn't configure */ if (memchr(sc->client_cert_type, type, sc->client_cert_type_len) == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_VALUE); return 0; } sc->ext.client_cert_type = type; return 1; } EXT_RETURN tls_construct_ctos_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE; if (sc->server_cert_type == NULL) return EXT_RETURN_NOT_SENT; if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_cert_type) || !WPACKET_start_sub_packet_u16(pkt) || !WPACKET_sub_memcpy_u8(pkt, sc->server_cert_type, sc->server_cert_type_len) || !WPACKET_close(pkt)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return EXT_RETURN_FAIL; } sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_GOOD; return EXT_RETURN_SENT; } int tls_parse_stoc_server_cert_type(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context, X509 *x, size_t chainidx) { unsigned int type; if (PACKET_remaining(pkt) != 1) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } if (!PACKET_get_1(pkt, &type)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* We did not send/ask for this */ if (!ossl_assert(sc->ext.server_cert_type_ctos == OSSL_CERT_TYPE_CTOS_GOOD)) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* We don't have this enabled */ if (sc->server_cert_type == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION); return 0; } /* Given back a value we didn't configure */ if (memchr(sc->server_cert_type, type, sc->server_cert_type_len) == NULL) { SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_VALUE); return 0; } sc->ext.server_cert_type = type; return 1; }

./openssl/ssl/record/rec_layer_d1.c

/* * Copyright 2005-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <errno.h> #include "../ssl_local.h" #include <openssl/evp.h> #include <openssl/buffer.h> #include "record_local.h" #include "internal/packet.h" #include "internal/cryptlib.h" int DTLS_RECORD_LAYER_new(RECORD_LAYER *rl) { DTLS_RECORD_LAYER *d; if ((d = OPENSSL_malloc(sizeof(*d))) == NULL) return 0; rl->d = d; d->buffered_app_data.q = pqueue_new(); if (d->buffered_app_data.q == NULL) { OPENSSL_free(d); rl->d = NULL; return 0; } return 1; } void DTLS_RECORD_LAYER_free(RECORD_LAYER *rl) { if (rl->d == NULL) return; DTLS_RECORD_LAYER_clear(rl); pqueue_free(rl->d->buffered_app_data.q); OPENSSL_free(rl->d); rl->d = NULL; } void DTLS_RECORD_LAYER_clear(RECORD_LAYER *rl) { DTLS_RECORD_LAYER *d; pitem *item = NULL; TLS_RECORD *rec; pqueue *buffered_app_data; d = rl->d; while ((item = pqueue_pop(d->buffered_app_data.q)) != NULL) { rec = (TLS_RECORD *)item->data; if (rl->s->options & SSL_OP_CLEANSE_PLAINTEXT) OPENSSL_cleanse(rec->allocdata, rec->length); OPENSSL_free(rec->allocdata); OPENSSL_free(item->data); pitem_free(item); } buffered_app_data = d->buffered_app_data.q; memset(d, 0, sizeof(*d)); d->buffered_app_data.q = buffered_app_data; } static int dtls_buffer_record(SSL_CONNECTION *s, TLS_RECORD *rec) { TLS_RECORD *rdata; pitem *item; record_pqueue *queue = &(s->rlayer.d->buffered_app_data); /* Limit the size of the queue to prevent DOS attacks */ if (pqueue_size(queue->q) >= 100) return 0; /* We don't buffer partially read records */ if (!ossl_assert(rec->off == 0)) return -1; rdata = OPENSSL_malloc(sizeof(*rdata)); item = pitem_new(rec->seq_num, rdata); if (rdata == NULL || item == NULL) { OPENSSL_free(rdata); pitem_free(item); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } *rdata = *rec; /* * We will release the record from the record layer soon, so we take a copy * now. Copying data isn't good - but this should be infrequent so we * accept it here. */ rdata->data = rdata->allocdata = OPENSSL_memdup(rec->data, rec->length); if (rdata->data == NULL) { OPENSSL_free(rdata); pitem_free(item); SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return -1; } /* * We use a NULL rechandle to indicate that the data field has been * allocated by us. */ rdata->rechandle = NULL; item->data = rdata; #ifndef OPENSSL_NO_SCTP /* Store bio_dgram_sctp_rcvinfo struct */ if (BIO_dgram_is_sctp(s->rbio) && (ossl_statem_get_state(s) == TLS_ST_SR_FINISHED || ossl_statem_get_state(s) == TLS_ST_CR_FINISHED)) { BIO_ctrl(s->rbio, BIO_CTRL_DGRAM_SCTP_GET_RCVINFO, sizeof(rdata->recordinfo), &rdata->recordinfo); } #endif if (pqueue_insert(queue->q, item) == NULL) { /* Must be a duplicate so ignore it */ OPENSSL_free(rdata->allocdata); OPENSSL_free(rdata); pitem_free(item); } return 1; } /* Unbuffer a previously buffered TLS_RECORD structure if any */ static void dtls_unbuffer_record(SSL_CONNECTION *s) { TLS_RECORD *rdata; pitem *item; /* If we already have records to handle then do nothing */ if (s->rlayer.curr_rec < s->rlayer.num_recs) return; item = pqueue_pop(s->rlayer.d->buffered_app_data.q); if (item != NULL) { rdata = (TLS_RECORD *)item->data; s->rlayer.tlsrecs[0] = *rdata; s->rlayer.num_recs = 1; s->rlayer.curr_rec = 0; #ifndef OPENSSL_NO_SCTP /* Restore bio_dgram_sctp_rcvinfo struct */ if (BIO_dgram_is_sctp(s->rbio)) { BIO_ctrl(s->rbio, BIO_CTRL_DGRAM_SCTP_SET_RCVINFO, sizeof(rdata->recordinfo), &rdata->recordinfo); } #endif OPENSSL_free(item->data); pitem_free(item); } } /*- * Return up to 'len' payload bytes received in 'type' records. * 'type' is one of the following: * * - SSL3_RT_HANDSHAKE * - SSL3_RT_APPLICATION_DATA (when ssl3_read calls us) * - 0 (during a shutdown, no data has to be returned) * * If we don't have stored data to work from, read a SSL/TLS record first * (possibly multiple records if we still don't have anything to return). * * This function must handle any surprises the peer may have for us, such as * Alert records (e.g. close_notify) or renegotiation requests. ChangeCipherSpec * messages are treated as if they were handshake messages *if* the |recd_type| * argument is non NULL. * Also if record payloads contain fragments too small to process, we store * them until there is enough for the respective protocol (the record protocol * may use arbitrary fragmentation and even interleaving): * Change cipher spec protocol * just 1 byte needed, no need for keeping anything stored * Alert protocol * 2 bytes needed (AlertLevel, AlertDescription) * Handshake protocol * 4 bytes needed (HandshakeType, uint24 length) -- we just have * to detect unexpected Client Hello and Hello Request messages * here, anything else is handled by higher layers * Application data protocol * none of our business */ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type, unsigned char *buf, size_t len, int peek, size_t *readbytes) { int i, j, ret; size_t n; TLS_RECORD *rr; void (*cb) (const SSL *ssl, int type2, int val) = NULL; SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL) return -1; if ((type && (type != SSL3_RT_APPLICATION_DATA) && (type != SSL3_RT_HANDSHAKE)) || (peek && (type != SSL3_RT_APPLICATION_DATA))) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } if (!ossl_statem_get_in_handshake(sc) && SSL_in_init(s)) { /* type == SSL3_RT_APPLICATION_DATA */ i = sc->handshake_func(s); /* SSLfatal() already called if appropriate */ if (i < 0) return i; if (i == 0) return -1; } start: sc->rwstate = SSL_NOTHING; /* * We are not handshaking and have no data yet, so process data buffered * during the last handshake in advance, if any. */ if (SSL_is_init_finished(s)) dtls_unbuffer_record(sc); /* Check for timeout */ if (dtls1_handle_timeout(sc) > 0) { goto start; } else if (ossl_statem_in_error(sc)) { /* dtls1_handle_timeout() has failed with a fatal error */ return -1; } /* get new packet if necessary */ if (sc->rlayer.curr_rec >= sc->rlayer.num_recs) { sc->rlayer.curr_rec = sc->rlayer.num_recs = 0; do { rr = &sc->rlayer.tlsrecs[sc->rlayer.num_recs]; ret = HANDLE_RLAYER_READ_RETURN(sc, sc->rlayer.rrlmethod->read_record(sc->rlayer.rrl, &rr->rechandle, &rr->version, &rr->type, &rr->data, &rr->length, &rr->epoch, rr->seq_num)); if (ret <= 0) { ret = dtls1_read_failed(sc, ret); /* * Anything other than a timeout is an error. SSLfatal() already * called if appropriate. */ if (ret <= 0) return ret; else goto start; } rr->off = 0; sc->rlayer.num_recs++; } while (sc->rlayer.rrlmethod->processed_read_pending(sc->rlayer.rrl) && sc->rlayer.num_recs < SSL_MAX_PIPELINES); } rr = &sc->rlayer.tlsrecs[sc->rlayer.curr_rec]; /* * Reset the count of consecutive warning alerts if we've got a non-empty * record that isn't an alert. */ if (rr->type != SSL3_RT_ALERT && rr->length != 0) sc->rlayer.alert_count = 0; /* we now have a packet which can be read and processed */ if (sc->s3.change_cipher_spec /* set when we receive ChangeCipherSpec, * reset by ssl3_get_finished */ && (rr->type != SSL3_RT_HANDSHAKE)) { /* * We now have application data between CCS and Finished. Most likely * the packets were reordered on their way, so buffer the application * data for later processing rather than dropping the connection. */ if (dtls_buffer_record(sc, rr) < 0) { /* SSLfatal() already called */ return -1; } if (!ssl_release_record(sc, rr, 0)) return -1; goto start; } /* * If the other end has shut down, throw anything we read away (even in * 'peek' mode) */ if (sc->shutdown & SSL_RECEIVED_SHUTDOWN) { if (!ssl_release_record(sc, rr, 0)) return -1; sc->rwstate = SSL_NOTHING; return 0; } if (type == rr->type || (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC && type == SSL3_RT_HANDSHAKE && recvd_type != NULL)) { /* * SSL3_RT_APPLICATION_DATA or * SSL3_RT_HANDSHAKE or * SSL3_RT_CHANGE_CIPHER_SPEC */ /* * make sure that we are not getting application data when we are * doing a handshake for the first time */ if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) && (SSL_IS_FIRST_HANDSHAKE(sc))) { SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_APP_DATA_IN_HANDSHAKE); return -1; } if (recvd_type != NULL) *recvd_type = rr->type; if (len == 0) { /* * Release a zero length record. This ensures multiple calls to * SSL_read() with a zero length buffer will eventually cause * SSL_pending() to report data as being available. */ if (rr->length == 0 && !ssl_release_record(sc, rr, 0)) return -1; return 0; } if (len > rr->length) n = rr->length; else n = len; memcpy(buf, &(rr->data[rr->off]), n); if (peek) { if (rr->length == 0 && !ssl_release_record(sc, rr, 0)) return -1; } else { if (!ssl_release_record(sc, rr, n)) return -1; } #ifndef OPENSSL_NO_SCTP /* * We might had to delay a close_notify alert because of reordered * app data. If there was an alert and there is no message to read * anymore, finally set shutdown. */ if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && sc->d1->shutdown_received && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) <= 0) { sc->shutdown |= SSL_RECEIVED_SHUTDOWN; return 0; } #endif *readbytes = n; return 1; } /* * If we get here, then type != rr->type; if we have a handshake message, * then it was unexpected (Hello Request or Client Hello). */ if (rr->type == SSL3_RT_ALERT) { unsigned int alert_level, alert_descr; const unsigned char *alert_bytes = rr->data + rr->off; PACKET alert; if (!PACKET_buf_init(&alert, alert_bytes, rr->length) || !PACKET_get_1(&alert, &alert_level) || !PACKET_get_1(&alert, &alert_descr) || PACKET_remaining(&alert) != 0) { SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT); return -1; } if (sc->msg_callback) sc->msg_callback(0, sc->version, SSL3_RT_ALERT, alert_bytes, 2, s, sc->msg_callback_arg); if (sc->info_callback != NULL) cb = sc->info_callback; else if (s->ctx->info_callback != NULL) cb = s->ctx->info_callback; if (cb != NULL) { j = (alert_level << 8) | alert_descr; cb(s, SSL_CB_READ_ALERT, j); } if (alert_level == SSL3_AL_WARNING) { sc->s3.warn_alert = alert_descr; if (!ssl_release_record(sc, rr, 0)) return -1; sc->rlayer.alert_count++; if (sc->rlayer.alert_count == MAX_WARN_ALERT_COUNT) { SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MANY_WARN_ALERTS); return -1; } if (alert_descr == SSL_AD_CLOSE_NOTIFY) { #ifndef OPENSSL_NO_SCTP /* * With SCTP and streams the socket may deliver app data * after a close_notify alert. We have to check this first so * that nothing gets discarded. */ if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) > 0) { sc->d1->shutdown_received = 1; sc->rwstate = SSL_READING; BIO_clear_retry_flags(SSL_get_rbio(s)); BIO_set_retry_read(SSL_get_rbio(s)); return -1; } #endif sc->shutdown |= SSL_RECEIVED_SHUTDOWN; return 0; } } else if (alert_level == SSL3_AL_FATAL) { sc->rwstate = SSL_NOTHING; sc->s3.fatal_alert = alert_descr; SSLfatal_data(sc, SSL_AD_NO_ALERT, SSL_AD_REASON_OFFSET + alert_descr, "SSL alert number %d", alert_descr); sc->shutdown |= SSL_RECEIVED_SHUTDOWN; if (!ssl_release_record(sc, rr, 0)) return -1; SSL_CTX_remove_session(sc->session_ctx, sc->session); return 0; } else { SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_ALERT_TYPE); return -1; } goto start; } if (sc->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a * shutdown */ sc->rwstate = SSL_NOTHING; if (!ssl_release_record(sc, rr, 0)) return -1; return 0; } if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) { /* * We can't process a CCS now, because previous handshake messages * are still missing, so just drop it. */ if (!ssl_release_record(sc, rr, 0)) return -1; goto start; } /* * Unexpected handshake message (Client Hello, or protocol violation) */ if (rr->type == SSL3_RT_HANDSHAKE && !ossl_statem_get_in_handshake(sc)) { struct hm_header_st msg_hdr; /* * This may just be a stale retransmit. Also sanity check that we have * at least enough record bytes for a message header */ if (rr->epoch != sc->rlayer.d->r_epoch || rr->length < DTLS1_HM_HEADER_LENGTH) { if (!ssl_release_record(sc, rr, 0)) return -1; goto start; } dtls1_get_message_header(rr->data, &msg_hdr); /* * If we are server, we may have a repeated FINISHED of the client * here, then retransmit our CCS and FINISHED. */ if (msg_hdr.type == SSL3_MT_FINISHED) { if (dtls1_check_timeout_num(sc) < 0) { /* SSLfatal) already called */ return -1; } if (dtls1_retransmit_buffered_messages(sc) <= 0) { /* Fail if we encountered a fatal error */ if (ossl_statem_in_error(sc)) return -1; } if (!ssl_release_record(sc, rr, 0)) return -1; if (!(sc->mode & SSL_MODE_AUTO_RETRY)) { if (!sc->rlayer.rrlmethod->unprocessed_read_pending(sc->rlayer.rrl)) { /* no read-ahead left? */ BIO *bio; sc->rwstate = SSL_READING; bio = SSL_get_rbio(s); BIO_clear_retry_flags(bio); BIO_set_retry_read(bio); return -1; } } goto start; } /* * To get here we must be trying to read app data but found handshake * data. But if we're trying to read app data, and we're not in init * (which is tested for at the top of this function) then init must be * finished */ if (!ossl_assert(SSL_is_init_finished(s))) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } /* We found handshake data, so we're going back into init */ ossl_statem_set_in_init(sc, 1); i = sc->handshake_func(s); /* SSLfatal() called if appropriate */ if (i < 0) return i; if (i == 0) return -1; if (!(sc->mode & SSL_MODE_AUTO_RETRY)) { if (!sc->rlayer.rrlmethod->unprocessed_read_pending(sc->rlayer.rrl)) { /* no read-ahead left? */ BIO *bio; /* * In the case where we try to read application data, but we * trigger an SSL handshake, we return -1 with the retry * option set. Otherwise renegotiation may cause nasty * problems in the blocking world */ sc->rwstate = SSL_READING; bio = SSL_get_rbio(s); BIO_clear_retry_flags(bio); BIO_set_retry_read(bio); return -1; } } goto start; } switch (rr->type) { default: SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD); return -1; case SSL3_RT_CHANGE_CIPHER_SPEC: case SSL3_RT_ALERT: case SSL3_RT_HANDSHAKE: /* * we already handled all of these, with the possible exception of * SSL3_RT_HANDSHAKE when ossl_statem_get_in_handshake(s) is true, but * that should not happen when type != rr->type */ SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, ERR_R_INTERNAL_ERROR); return -1; case SSL3_RT_APPLICATION_DATA: /* * At this point, we were expecting handshake data, but have * application data. If the library was running inside ssl3_read() * (i.e. in_read_app_data is set) and it makes sense to read * application data at this point (session renegotiation not yet * started), we will indulge it. */ if (sc->s3.in_read_app_data && (sc->s3.total_renegotiations != 0) && ossl_statem_app_data_allowed(sc)) { sc->s3.in_read_app_data = 2; return -1; } else { SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD); return -1; } } /* not reached */ } /* * Call this to write data in records of type 'type' It will return <= 0 if * not all data has been sent or non-blocking IO. */ int dtls1_write_bytes(SSL_CONNECTION *s, uint8_t type, const void *buf, size_t len, size_t *written) { int i; if (!ossl_assert(len <= SSL3_RT_MAX_PLAIN_LENGTH)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } s->rwstate = SSL_NOTHING; i = do_dtls1_write(s, type, buf, len, written); return i; } int do_dtls1_write(SSL_CONNECTION *sc, uint8_t type, const unsigned char *buf, size_t len, size_t *written) { int i; OSSL_RECORD_TEMPLATE tmpl; SSL *s = SSL_CONNECTION_GET_SSL(sc); int ret; /* If we have an alert to send, lets send it */ if (sc->s3.alert_dispatch > 0) { i = s->method->ssl_dispatch_alert(s); if (i <= 0) return i; /* if it went, fall through and send more stuff */ } if (len == 0) return 0; if (len > ssl_get_max_send_fragment(sc)) { SSLfatal(sc, SSL_AD_INTERNAL_ERROR, SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE); return 0; } tmpl.type = type; /* * Special case: for hello verify request, client version 1.0 and we * haven't decided which version to use yet send back using version 1.0 * header: otherwise some clients will ignore it. */ if (s->method->version == DTLS_ANY_VERSION && sc->max_proto_version != DTLS1_BAD_VER) tmpl.version = DTLS1_VERSION; else tmpl.version = sc->version; tmpl.buf = buf; tmpl.buflen = len; ret = HANDLE_RLAYER_WRITE_RETURN(sc, sc->rlayer.wrlmethod->write_records(sc->rlayer.wrl, &tmpl, 1)); if (ret > 0) *written = (int)len; return ret; } void dtls1_increment_epoch(SSL_CONNECTION *s, int rw) { if (rw & SSL3_CC_READ) { s->rlayer.d->r_epoch++; /* * We must not use any buffered messages received from the previous * epoch */ dtls1_clear_received_buffer(s); } else { s->rlayer.d->w_epoch++; } } uint16_t dtls1_get_epoch(SSL_CONNECTION *s, int rw) { uint16_t epoch; if (rw & SSL3_CC_READ) epoch = s->rlayer.d->r_epoch; else epoch = s->rlayer.d->w_epoch; return epoch; }

./openssl/ssl/record/record_local.h

/* * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /***************************************************************************** * * * The following macros/functions are PRIVATE to the record layer. They * * should NOT be used outside of the record layer. * * * *****************************************************************************/ #define MAX_WARN_ALERT_COUNT 5

./openssl/ssl/record/rec_layer_s3.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <stdio.h> #include <limits.h> #include <errno.h> #include <assert.h> #include "../ssl_local.h" #include "../quic/quic_local.h" #include <openssl/evp.h> #include <openssl/buffer.h> #include <openssl/rand.h> #include <openssl/core_names.h> #include "record_local.h" #include "internal/packet.h" void RECORD_LAYER_init(RECORD_LAYER *rl, SSL_CONNECTION *s) { rl->s = s; } void RECORD_LAYER_clear(RECORD_LAYER *rl) { rl->wnum = 0; memset(rl->handshake_fragment, 0, sizeof(rl->handshake_fragment)); rl->handshake_fragment_len = 0; rl->wpend_tot = 0; rl->wpend_type = 0; rl->wpend_buf = NULL; if (rl->rrlmethod != NULL) rl->rrlmethod->free(rl->rrl); /* Ignore return value */ if (rl->wrlmethod != NULL) rl->wrlmethod->free(rl->wrl); /* Ignore return value */ BIO_free(rl->rrlnext); rl->rrlmethod = NULL; rl->wrlmethod = NULL; rl->rrlnext = NULL; rl->rrl = NULL; rl->wrl = NULL; if (rl->d) DTLS_RECORD_LAYER_clear(rl); } /* Checks if we have unprocessed read ahead data pending */ int RECORD_LAYER_read_pending(const RECORD_LAYER *rl) { return rl->rrlmethod->unprocessed_read_pending(rl->rrl); } /* Checks if we have decrypted unread record data pending */ int RECORD_LAYER_processed_read_pending(const RECORD_LAYER *rl) { return (rl->curr_rec < rl->num_recs) || rl->rrlmethod->processed_read_pending(rl->rrl); } int RECORD_LAYER_write_pending(const RECORD_LAYER *rl) { return rl->wpend_tot > 0; } static uint32_t ossl_get_max_early_data(SSL_CONNECTION *s) { uint32_t max_early_data; SSL_SESSION *sess = s->session; /* * If we are a client then we always use the max_early_data from the * session/psksession. Otherwise we go with the lowest out of the max early * data set in the session and the configured max_early_data. */ if (!s->server && sess->ext.max_early_data == 0) { if (!ossl_assert(s->psksession != NULL && s->psksession->ext.max_early_data > 0)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } sess = s->psksession; } if (!s->server) max_early_data = sess->ext.max_early_data; else if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED) max_early_data = s->recv_max_early_data; else max_early_data = s->recv_max_early_data < sess->ext.max_early_data ? s->recv_max_early_data : sess->ext.max_early_data; return max_early_data; } static int ossl_early_data_count_ok(SSL_CONNECTION *s, size_t length, size_t overhead, int send) { uint32_t max_early_data; max_early_data = ossl_get_max_early_data(s); if (max_early_data == 0) { SSLfatal(s, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MUCH_EARLY_DATA); return 0; } /* If we are dealing with ciphertext we need to allow for the overhead */ max_early_data += overhead; if (s->early_data_count + length > max_early_data) { SSLfatal(s, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MUCH_EARLY_DATA); return 0; } s->early_data_count += length; return 1; } size_t ssl3_pending(const SSL *s) { size_t i, num = 0; const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); if (sc == NULL) return 0; if (SSL_CONNECTION_IS_DTLS(sc)) { TLS_RECORD *rdata; pitem *item, *iter; iter = pqueue_iterator(sc->rlayer.d->buffered_app_data.q); while ((item = pqueue_next(&iter)) != NULL) { rdata = item->data; num += rdata->length; } } for (i = 0; i < sc->rlayer.num_recs; i++) { if (sc->rlayer.tlsrecs[i].type != SSL3_RT_APPLICATION_DATA) return num; num += sc->rlayer.tlsrecs[i].length; } num += sc->rlayer.rrlmethod->app_data_pending(sc->rlayer.rrl); return num; } void SSL_CTX_set_default_read_buffer_len(SSL_CTX *ctx, size_t len) { ctx->default_read_buf_len = len; } void SSL_set_default_read_buffer_len(SSL *s, size_t len) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s); if (sc == NULL || IS_QUIC(s)) return; sc->rlayer.default_read_buf_len = len; } const char *SSL_rstate_string_long(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); const char *lng; if (sc == NULL) return NULL; if (sc->rlayer.rrlmethod == NULL || sc->rlayer.rrl == NULL) return "unknown"; sc->rlayer.rrlmethod->get_state(sc->rlayer.rrl, NULL, &lng); return lng; } const char *SSL_rstate_string(const SSL *s) { const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s); const char *shrt; if (sc == NULL) return NULL; if (sc->rlayer.rrlmethod == NULL || sc->rlayer.rrl == NULL) return "unknown"; sc->rlayer.rrlmethod->get_state(sc->rlayer.rrl, &shrt, NULL); return shrt; } static int tls_write_check_pending(SSL_CONNECTION *s, uint8_t type, const unsigned char *buf, size_t len) { if (s->rlayer.wpend_tot == 0) return 0; /* We have pending data, so do some sanity checks */ if ((s->rlayer.wpend_tot > len) || (!(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER) && (s->rlayer.wpend_buf != buf)) || (s->rlayer.wpend_type != type)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_WRITE_RETRY); return -1; } return 1; } /* * Call this to write data in records of type 'type' It will return <= 0 if * not all data has been sent or non-blocking IO. */ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len, size_t *written) { const unsigned char *buf = buf_; size_t tot; size_t n, max_send_fragment, split_send_fragment, maxpipes; int i; SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); OSSL_RECORD_TEMPLATE tmpls[SSL_MAX_PIPELINES]; unsigned int recversion; if (s == NULL) return -1; s->rwstate = SSL_NOTHING; tot = s->rlayer.wnum; /* * ensure that if we end up with a smaller value of data to write out * than the original len from a write which didn't complete for * non-blocking I/O and also somehow ended up avoiding the check for * this in tls_write_check_pending/SSL_R_BAD_WRITE_RETRY as it must never be * possible to end up with (len-tot) as a large number that will then * promptly send beyond the end of the users buffer ... so we trap and * report the error in a way the user will notice */ if ((len < s->rlayer.wnum) || ((s->rlayer.wpend_tot != 0) && (len < (s->rlayer.wnum + s->rlayer.wpend_tot)))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_LENGTH); return -1; } if (s->early_data_state == SSL_EARLY_DATA_WRITING && !ossl_early_data_count_ok(s, len, 0, 1)) { /* SSLfatal() already called */ return -1; } s->rlayer.wnum = 0; /* * If we are supposed to be sending a KeyUpdate or NewSessionTicket then go * into init unless we have writes pending - in which case we should finish * doing that first. */ if (s->rlayer.wpend_tot == 0 && (s->key_update != SSL_KEY_UPDATE_NONE || s->ext.extra_tickets_expected > 0)) ossl_statem_set_in_init(s, 1); /* * When writing early data on the server side we could be "in_init" in * between receiving the EoED and the CF - but we don't want to handle those * messages yet. */ if (SSL_in_init(ssl) && !ossl_statem_get_in_handshake(s) && s->early_data_state != SSL_EARLY_DATA_UNAUTH_WRITING) { i = s->handshake_func(ssl); /* SSLfatal() already called */ if (i < 0) return i; if (i == 0) { return -1; } } i = tls_write_check_pending(s, type, buf, len); if (i < 0) { /* SSLfatal() already called */ return i; } else if (i > 0) { /* Retry needed */ i = HANDLE_RLAYER_WRITE_RETURN(s, s->rlayer.wrlmethod->retry_write_records(s->rlayer.wrl)); if (i <= 0) { s->rlayer.wnum = tot; return i; } tot += s->rlayer.wpend_tot; s->rlayer.wpend_tot = 0; } /* else no retry required */ if (tot == 0) { /* * We've not previously sent any data for this write so memorize * arguments so that we can detect bad write retries later */ s->rlayer.wpend_tot = 0; s->rlayer.wpend_type = type; s->rlayer.wpend_buf = buf; } if (tot == len) { /* done? */ *written = tot; return 1; } /* If we have an alert to send, lets send it */ if (s->s3.alert_dispatch > 0) { i = ssl->method->ssl_dispatch_alert(ssl); if (i <= 0) { /* SSLfatal() already called if appropriate */ s->rlayer.wnum = tot; return i; } /* if it went, fall through and send more stuff */ } n = (len - tot); max_send_fragment = ssl_get_max_send_fragment(s); split_send_fragment = ssl_get_split_send_fragment(s); if (max_send_fragment == 0 || split_send_fragment == 0 || split_send_fragment > max_send_fragment) { /* * We should have prevented this when we set/get the split and max send * fragments so we shouldn't get here */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } /* * Some servers hang if initial client hello is larger than 256 bytes * and record version number > TLS 1.0 */ recversion = (s->version == TLS1_3_VERSION) ? TLS1_2_VERSION : s->version; if (SSL_get_state(ssl) == TLS_ST_CW_CLNT_HELLO && !s->renegotiate && TLS1_get_version(ssl) > TLS1_VERSION && s->hello_retry_request == SSL_HRR_NONE) recversion = TLS1_VERSION; for (;;) { size_t tmppipelen, remain; size_t j, lensofar = 0; /* * Ask the record layer how it would like to split the amount of data * that we have, and how many of those records it would like in one go. */ maxpipes = s->rlayer.wrlmethod->get_max_records(s->rlayer.wrl, type, n, max_send_fragment, &split_send_fragment); /* * If max_pipelines is 0 then this means "undefined" and we default to * whatever the record layer wants to do. Otherwise we use the smallest * value from the number requested by the record layer, and max number * configured by the user. */ if (s->max_pipelines > 0 && maxpipes > s->max_pipelines) maxpipes = s->max_pipelines; if (maxpipes > SSL_MAX_PIPELINES) maxpipes = SSL_MAX_PIPELINES; if (split_send_fragment > max_send_fragment) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } if (n / maxpipes >= split_send_fragment) { /* * We have enough data to completely fill all available * pipelines */ for (j = 0; j < maxpipes; j++) { tmpls[j].type = type; tmpls[j].version = recversion; tmpls[j].buf = &(buf[tot]) + (j * split_send_fragment); tmpls[j].buflen = split_send_fragment; } /* Remember how much data we are going to be sending */ s->rlayer.wpend_tot = maxpipes * split_send_fragment; } else { /* We can partially fill all available pipelines */ tmppipelen = n / maxpipes; remain = n % maxpipes; /* * If there is a remainder we add an extra byte to the first few * pipelines */ if (remain > 0) tmppipelen++; for (j = 0; j < maxpipes; j++) { tmpls[j].type = type; tmpls[j].version = recversion; tmpls[j].buf = &(buf[tot]) + lensofar; tmpls[j].buflen = tmppipelen; lensofar += tmppipelen; if (j + 1 == remain) tmppipelen--; } /* Remember how much data we are going to be sending */ s->rlayer.wpend_tot = n; } i = HANDLE_RLAYER_WRITE_RETURN(s, s->rlayer.wrlmethod->write_records(s->rlayer.wrl, tmpls, maxpipes)); if (i <= 0) { /* SSLfatal() already called if appropriate */ s->rlayer.wnum = tot; return i; } if (s->rlayer.wpend_tot == n || (type == SSL3_RT_APPLICATION_DATA && (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE) != 0)) { *written = tot + s->rlayer.wpend_tot; s->rlayer.wpend_tot = 0; return 1; } n -= s->rlayer.wpend_tot; tot += s->rlayer.wpend_tot; } } int ossl_tls_handle_rlayer_return(SSL_CONNECTION *s, int writing, int ret, char *file, int line) { SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (ret == OSSL_RECORD_RETURN_RETRY) { s->rwstate = writing ? SSL_WRITING : SSL_READING; ret = -1; } else { s->rwstate = SSL_NOTHING; if (ret == OSSL_RECORD_RETURN_EOF) { if (writing) { /* * This shouldn't happen with a writing operation. We treat it * as fatal. */ ERR_new(); ERR_set_debug(file, line, 0); ossl_statem_fatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR, NULL); ret = OSSL_RECORD_RETURN_FATAL; } else if ((s->options & SSL_OP_IGNORE_UNEXPECTED_EOF) != 0) { SSL_set_shutdown(ssl, SSL_RECEIVED_SHUTDOWN); s->s3.warn_alert = SSL_AD_CLOSE_NOTIFY; } else { ERR_new(); ERR_set_debug(file, line, 0); /* * This reason code is part of the API and may be used by * applications for control flow decisions. */ ossl_statem_fatal(s, SSL_AD_DECODE_ERROR, SSL_R_UNEXPECTED_EOF_WHILE_READING, NULL); } } else if (ret == OSSL_RECORD_RETURN_FATAL) { int al = s->rlayer.rrlmethod->get_alert_code(s->rlayer.rrl); if (al != SSL_AD_NO_ALERT) { ERR_new(); ERR_set_debug(file, line, 0); ossl_statem_fatal(s, al, SSL_R_RECORD_LAYER_FAILURE, NULL); } /* * else some failure but there is no alert code. We don't log an * error for this. The record layer should have logged an error * already or, if not, its due to some sys call error which will be * reported via SSL_ERROR_SYSCALL and errno. */ } /* * The record layer distinguishes the cases of EOF, non-fatal * err and retry. Upper layers do not. * If we got a retry or success then *ret is already correct, * otherwise we need to convert the return value. */ if (ret == OSSL_RECORD_RETURN_NON_FATAL_ERR || ret == OSSL_RECORD_RETURN_EOF) ret = 0; else if (ret < OSSL_RECORD_RETURN_NON_FATAL_ERR) ret = -1; } return ret; } int ssl_release_record(SSL_CONNECTION *s, TLS_RECORD *rr, size_t length) { assert(rr->length >= length); if (rr->rechandle != NULL) { if (length == 0) length = rr->length; /* The record layer allocated the buffers for this record */ if (HANDLE_RLAYER_READ_RETURN(s, s->rlayer.rrlmethod->release_record(s->rlayer.rrl, rr->rechandle, length)) <= 0) { /* RLAYER_fatal already called */ return 0; } if (length == rr->length) s->rlayer.curr_rec++; } else if (length == 0 || length == rr->length) { /* We allocated the buffers for this record (only happens with DTLS) */ OPENSSL_free(rr->allocdata); rr->allocdata = NULL; } rr->length -= length; if (rr->length > 0) rr->off += length; else rr->off = 0; return 1; } /*- * Return up to 'len' payload bytes received in 'type' records. * 'type' is one of the following: * * - SSL3_RT_HANDSHAKE (when tls_get_message_header and tls_get_message_body * call us) * - SSL3_RT_APPLICATION_DATA (when ssl3_read calls us) * - 0 (during a shutdown, no data has to be returned) * * If we don't have stored data to work from, read a SSL/TLS record first * (possibly multiple records if we still don't have anything to return). * * This function must handle any surprises the peer may have for us, such as * Alert records (e.g. close_notify) or renegotiation requests. ChangeCipherSpec * messages are treated as if they were handshake messages *if* the |recvd_type| * argument is non NULL. * Also if record payloads contain fragments too small to process, we store * them until there is enough for the respective protocol (the record protocol * may use arbitrary fragmentation and even interleaving): * Change cipher spec protocol * just 1 byte needed, no need for keeping anything stored * Alert protocol * 2 bytes needed (AlertLevel, AlertDescription) * Handshake protocol * 4 bytes needed (HandshakeType, uint24 length) -- we just have * to detect unexpected Client Hello and Hello Request messages * here, anything else is handled by higher layers * Application data protocol * none of our business */ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type, unsigned char *buf, size_t len, int peek, size_t *readbytes) { int i, j, ret; size_t n, curr_rec, totalbytes; TLS_RECORD *rr; void (*cb) (const SSL *ssl, int type2, int val) = NULL; int is_tls13; SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl); is_tls13 = SSL_CONNECTION_IS_TLS13(s); if ((type != 0 && (type != SSL3_RT_APPLICATION_DATA) && (type != SSL3_RT_HANDSHAKE)) || (peek && (type != SSL3_RT_APPLICATION_DATA))) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } if ((type == SSL3_RT_HANDSHAKE) && (s->rlayer.handshake_fragment_len > 0)) /* (partially) satisfy request from storage */ { unsigned char *src = s->rlayer.handshake_fragment; unsigned char *dst = buf; unsigned int k; /* peek == 0 */ n = 0; while ((len > 0) && (s->rlayer.handshake_fragment_len > 0)) { *dst++ = *src++; len--; s->rlayer.handshake_fragment_len--; n++; } /* move any remaining fragment bytes: */ for (k = 0; k < s->rlayer.handshake_fragment_len; k++) s->rlayer.handshake_fragment[k] = *src++; if (recvd_type != NULL) *recvd_type = SSL3_RT_HANDSHAKE; *readbytes = n; return 1; } /* * Now s->rlayer.handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE. */ if (!ossl_statem_get_in_handshake(s) && SSL_in_init(ssl)) { /* type == SSL3_RT_APPLICATION_DATA */ i = s->handshake_func(ssl); /* SSLfatal() already called */ if (i < 0) return i; if (i == 0) return -1; } start: s->rwstate = SSL_NOTHING; /*- * For each record 'i' up to |num_recs] * rr[i].type - is the type of record * rr[i].data, - data * rr[i].off, - offset into 'data' for next read * rr[i].length, - number of bytes. */ /* get new records if necessary */ if (s->rlayer.curr_rec >= s->rlayer.num_recs) { s->rlayer.curr_rec = s->rlayer.num_recs = 0; do { rr = &s->rlayer.tlsrecs[s->rlayer.num_recs]; ret = HANDLE_RLAYER_READ_RETURN(s, s->rlayer.rrlmethod->read_record(s->rlayer.rrl, &rr->rechandle, &rr->version, &rr->type, &rr->data, &rr->length, NULL, NULL)); if (ret <= 0) { /* SSLfatal() already called if appropriate */ return ret; } rr->off = 0; s->rlayer.num_recs++; } while (s->rlayer.rrlmethod->processed_read_pending(s->rlayer.rrl) && s->rlayer.num_recs < SSL_MAX_PIPELINES); } rr = &s->rlayer.tlsrecs[s->rlayer.curr_rec]; if (s->rlayer.handshake_fragment_len > 0 && rr->type != SSL3_RT_HANDSHAKE && SSL_CONNECTION_IS_TLS13(s)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA); return -1; } /* * Reset the count of consecutive warning alerts if we've got a non-empty * record that isn't an alert. */ if (rr->type != SSL3_RT_ALERT && rr->length != 0) s->rlayer.alert_count = 0; /* we now have a packet which can be read and processed */ if (s->s3.change_cipher_spec /* set when we receive ChangeCipherSpec, * reset by ssl3_get_finished */ && (rr->type != SSL3_RT_HANDSHAKE)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_DATA_BETWEEN_CCS_AND_FINISHED); return -1; } /* * If the other end has shut down, throw anything we read away (even in * 'peek' mode) */ if (s->shutdown & SSL_RECEIVED_SHUTDOWN) { s->rlayer.curr_rec++; s->rwstate = SSL_NOTHING; return 0; } if (type == rr->type || (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC && type == SSL3_RT_HANDSHAKE && recvd_type != NULL && !is_tls13)) { /* * SSL3_RT_APPLICATION_DATA or * SSL3_RT_HANDSHAKE or * SSL3_RT_CHANGE_CIPHER_SPEC */ /* * make sure that we are not getting application data when we are * doing a handshake for the first time */ if (SSL_in_init(ssl) && type == SSL3_RT_APPLICATION_DATA && SSL_IS_FIRST_HANDSHAKE(s)) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_APP_DATA_IN_HANDSHAKE); return -1; } if (type == SSL3_RT_HANDSHAKE && rr->type == SSL3_RT_CHANGE_CIPHER_SPEC && s->rlayer.handshake_fragment_len > 0) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY); return -1; } if (recvd_type != NULL) *recvd_type = rr->type; if (len == 0) { /* * Skip a zero length record. This ensures multiple calls to * SSL_read() with a zero length buffer will eventually cause * SSL_pending() to report data as being available. */ if (rr->length == 0 && !ssl_release_record(s, rr, 0)) return -1; return 0; } totalbytes = 0; curr_rec = s->rlayer.curr_rec; do { if (len - totalbytes > rr->length) n = rr->length; else n = len - totalbytes; memcpy(buf, &(rr->data[rr->off]), n); buf += n; if (peek) { /* Mark any zero length record as consumed CVE-2016-6305 */ if (rr->length == 0 && !ssl_release_record(s, rr, 0)) return -1; } else { if (!ssl_release_record(s, rr, n)) return -1; } if (rr->length == 0 || (peek && n == rr->length)) { rr++; curr_rec++; } totalbytes += n; } while (type == SSL3_RT_APPLICATION_DATA && curr_rec < s->rlayer.num_recs && totalbytes < len); if (totalbytes == 0) { /* We must have read empty records. Get more data */ goto start; } *readbytes = totalbytes; return 1; } /* * If we get here, then type != rr->type; if we have a handshake message, * then it was unexpected (Hello Request or Client Hello) or invalid (we * were actually expecting a CCS). */ /* * Lets just double check that we've not got an SSLv2 record */ if (rr->version == SSL2_VERSION) { /* * Should never happen. ssl3_get_record() should only give us an SSLv2 * record back if this is the first packet and we are looking for an * initial ClientHello. Therefore |type| should always be equal to * |rr->type|. If not then something has gone horribly wrong */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } if (ssl->method->version == TLS_ANY_VERSION && (s->server || rr->type != SSL3_RT_ALERT)) { /* * If we've got this far and still haven't decided on what version * we're using then this must be a client side alert we're dealing * with. We shouldn't be receiving anything other than a ClientHello * if we are a server. */ s->version = rr->version; SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE); return -1; } /*- * s->rlayer.handshake_fragment_len == 4 iff rr->type == SSL3_RT_HANDSHAKE; * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) */ if (rr->type == SSL3_RT_ALERT) { unsigned int alert_level, alert_descr; const unsigned char *alert_bytes = rr->data + rr->off; PACKET alert; if (!PACKET_buf_init(&alert, alert_bytes, rr->length) || !PACKET_get_1(&alert, &alert_level) || !PACKET_get_1(&alert, &alert_descr) || PACKET_remaining(&alert) != 0) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT); return -1; } if (s->msg_callback) s->msg_callback(0, s->version, SSL3_RT_ALERT, alert_bytes, 2, ssl, s->msg_callback_arg); if (s->info_callback != NULL) cb = s->info_callback; else if (ssl->ctx->info_callback != NULL) cb = ssl->ctx->info_callback; if (cb != NULL) { j = (alert_level << 8) | alert_descr; cb(ssl, SSL_CB_READ_ALERT, j); } if ((!is_tls13 && alert_level == SSL3_AL_WARNING) || (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED)) { s->s3.warn_alert = alert_descr; if (!ssl_release_record(s, rr, 0)) return -1; s->rlayer.alert_count++; if (s->rlayer.alert_count == MAX_WARN_ALERT_COUNT) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MANY_WARN_ALERTS); return -1; } } /* * Apart from close_notify the only other warning alert in TLSv1.3 * is user_cancelled - which we just ignore. */ if (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED) { goto start; } else if (alert_descr == SSL_AD_CLOSE_NOTIFY && (is_tls13 || alert_level == SSL3_AL_WARNING)) { s->shutdown |= SSL_RECEIVED_SHUTDOWN; return 0; } else if (alert_level == SSL3_AL_FATAL || is_tls13) { s->rwstate = SSL_NOTHING; s->s3.fatal_alert = alert_descr; SSLfatal_data(s, SSL_AD_NO_ALERT, SSL_AD_REASON_OFFSET + alert_descr, "SSL alert number %d", alert_descr); s->shutdown |= SSL_RECEIVED_SHUTDOWN; if (!ssl_release_record(s, rr, 0)) return -1; SSL_CTX_remove_session(s->session_ctx, s->session); return 0; } else if (alert_descr == SSL_AD_NO_RENEGOTIATION) { /* * This is a warning but we receive it if we requested * renegotiation and the peer denied it. Terminate with a fatal * alert because if application tried to renegotiate it * presumably had a good reason and expects it to succeed. In * future we might have a renegotiation where we don't care if * the peer refused it where we carry on. */ SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_RENEGOTIATION); return -1; } else if (alert_level == SSL3_AL_WARNING) { /* We ignore any other warning alert in TLSv1.2 and below */ goto start; } SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_ALERT_TYPE); return -1; } if ((s->shutdown & SSL_SENT_SHUTDOWN) != 0) { if (rr->type == SSL3_RT_HANDSHAKE) { BIO *rbio; /* * We ignore any handshake messages sent to us unless they are * TLSv1.3 in which case we want to process them. For all other * handshake messages we can't do anything reasonable with them * because we are unable to write any response due to having already * sent close_notify. */ if (!SSL_CONNECTION_IS_TLS13(s)) { if (!ssl_release_record(s, rr, 0)) return -1; if ((s->mode & SSL_MODE_AUTO_RETRY) != 0) goto start; s->rwstate = SSL_READING; rbio = SSL_get_rbio(ssl); BIO_clear_retry_flags(rbio); BIO_set_retry_read(rbio); return -1; } } else { /* * The peer is continuing to send application data, but we have * already sent close_notify. If this was expected we should have * been called via SSL_read() and this would have been handled * above. * No alert sent because we already sent close_notify */ if (!ssl_release_record(s, rr, 0)) return -1; SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY); return -1; } } /* * For handshake data we have 'fragment' storage, so fill that so that we * can process the header at a fixed place. This is done after the * "SHUTDOWN" code above to avoid filling the fragment storage with data * that we're just going to discard. */ if (rr->type == SSL3_RT_HANDSHAKE) { size_t dest_maxlen = sizeof(s->rlayer.handshake_fragment); unsigned char *dest = s->rlayer.handshake_fragment; size_t *dest_len = &s->rlayer.handshake_fragment_len; n = dest_maxlen - *dest_len; /* available space in 'dest' */ if (rr->length < n) n = rr->length; /* available bytes */ /* now move 'n' bytes: */ if (n > 0) { memcpy(dest + *dest_len, rr->data + rr->off, n); *dest_len += n; } /* * We release the number of bytes consumed, or the whole record if it * is zero length */ if ((n > 0 || rr->length == 0) && !ssl_release_record(s, rr, n)) return -1; if (*dest_len < dest_maxlen) goto start; /* fragment was too small */ } if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY); return -1; } /* * Unexpected handshake message (ClientHello, NewSessionTicket (TLS1.3) or * protocol violation) */ if ((s->rlayer.handshake_fragment_len >= 4) && !ossl_statem_get_in_handshake(s)) { int ined = (s->early_data_state == SSL_EARLY_DATA_READING); /* We found handshake data, so we're going back into init */ ossl_statem_set_in_init(s, 1); i = s->handshake_func(ssl); /* SSLfatal() already called if appropriate */ if (i < 0) return i; if (i == 0) { return -1; } /* * If we were actually trying to read early data and we found a * handshake message, then we don't want to continue to try and read * the application data any more. It won't be "early" now. */ if (ined) return -1; if (!(s->mode & SSL_MODE_AUTO_RETRY)) { if (!RECORD_LAYER_read_pending(&s->rlayer)) { BIO *bio; /* * In the case where we try to read application data, but we * trigger an SSL handshake, we return -1 with the retry * option set. Otherwise renegotiation may cause nasty * problems in the blocking world */ s->rwstate = SSL_READING; bio = SSL_get_rbio(ssl); BIO_clear_retry_flags(bio); BIO_set_retry_read(bio); return -1; } } goto start; } switch (rr->type) { default: /* * TLS 1.0 and 1.1 say you SHOULD ignore unrecognised record types, but * TLS 1.2 says you MUST send an unexpected message alert. We use the * TLS 1.2 behaviour for all protocol versions to prevent issues where * no progress is being made and the peer continually sends unrecognised * record types, using up resources processing them. */ SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD); return -1; case SSL3_RT_CHANGE_CIPHER_SPEC: case SSL3_RT_ALERT: case SSL3_RT_HANDSHAKE: /* * we already handled all of these, with the possible exception of * SSL3_RT_HANDSHAKE when ossl_statem_get_in_handshake(s) is true, but * that should not happen when type != rr->type */ SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, ERR_R_INTERNAL_ERROR); return -1; case SSL3_RT_APPLICATION_DATA: /* * At this point, we were expecting handshake data, but have * application data. If the library was running inside ssl3_read() * (i.e. in_read_app_data is set) and it makes sense to read * application data at this point (session renegotiation not yet * started), we will indulge it. */ if (ossl_statem_app_data_allowed(s)) { s->s3.in_read_app_data = 2; return -1; } else if (ossl_statem_skip_early_data(s)) { /* * This can happen after a client sends a CH followed by early_data, * but the server responds with a HelloRetryRequest. The server * reads the next record from the client expecting to find a * plaintext ClientHello but gets a record which appears to be * application data. The trial decrypt "works" because null * decryption was applied. We just skip it and move on to the next * record. */ if (!ossl_early_data_count_ok(s, rr->length, EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) { /* SSLfatal() already called */ return -1; } if (!ssl_release_record(s, rr, 0)) return -1; goto start; } else { SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD); return -1; } } } /* * Returns true if the current rrec was sent in SSLv2 backwards compatible * format and false otherwise. */ int RECORD_LAYER_is_sslv2_record(RECORD_LAYER *rl) { if (SSL_CONNECTION_IS_DTLS(rl->s)) return 0; return rl->tlsrecs[0].version == SSL2_VERSION; } static OSSL_FUNC_rlayer_msg_callback_fn rlayer_msg_callback_wrapper; static void rlayer_msg_callback_wrapper(int write_p, int version, int content_type, const void *buf, size_t len, void *cbarg) { SSL_CONNECTION *s = cbarg; SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->msg_callback != NULL) s->msg_callback(write_p, version, content_type, buf, len, ssl, s->msg_callback_arg); } static OSSL_FUNC_rlayer_security_fn rlayer_security_wrapper; static int rlayer_security_wrapper(void *cbarg, int op, int bits, int nid, void *other) { SSL_CONNECTION *s = cbarg; return ssl_security(s, op, bits, nid, other); } static OSSL_FUNC_rlayer_padding_fn rlayer_padding_wrapper; static size_t rlayer_padding_wrapper(void *cbarg, int type, size_t len) { SSL_CONNECTION *s = cbarg; SSL *ssl = SSL_CONNECTION_GET_SSL(s); return s->rlayer.record_padding_cb(ssl, type, len, s->rlayer.record_padding_arg); } static const OSSL_DISPATCH rlayer_dispatch[] = { { OSSL_FUNC_RLAYER_SKIP_EARLY_DATA, (void (*)(void))ossl_statem_skip_early_data }, { OSSL_FUNC_RLAYER_MSG_CALLBACK, (void (*)(void))rlayer_msg_callback_wrapper }, { OSSL_FUNC_RLAYER_SECURITY, (void (*)(void))rlayer_security_wrapper }, { OSSL_FUNC_RLAYER_PADDING, (void (*)(void))rlayer_padding_wrapper }, OSSL_DISPATCH_END }; void ossl_ssl_set_custom_record_layer(SSL_CONNECTION *s, const OSSL_RECORD_METHOD *meth, void *rlarg) { s->rlayer.custom_rlmethod = meth; s->rlayer.rlarg = rlarg; } static const OSSL_RECORD_METHOD *ssl_select_next_record_layer(SSL_CONNECTION *s, int direction, int level) { if (s->rlayer.custom_rlmethod != NULL) return s->rlayer.custom_rlmethod; if (level == OSSL_RECORD_PROTECTION_LEVEL_NONE) { if (SSL_CONNECTION_IS_DTLS(s)) return &ossl_dtls_record_method; return &ossl_tls_record_method; } #ifndef OPENSSL_NO_KTLS /* KTLS does not support renegotiation */ if (level == OSSL_RECORD_PROTECTION_LEVEL_APPLICATION && (s->options & SSL_OP_ENABLE_KTLS) != 0 && (SSL_CONNECTION_IS_TLS13(s) || SSL_IS_FIRST_HANDSHAKE(s))) return &ossl_ktls_record_method; #endif /* Default to the current OSSL_RECORD_METHOD */ return direction == OSSL_RECORD_DIRECTION_READ ? s->rlayer.rrlmethod : s->rlayer.wrlmethod; } static int ssl_post_record_layer_select(SSL_CONNECTION *s, int direction) { const OSSL_RECORD_METHOD *thismethod; OSSL_RECORD_LAYER *thisrl; if (direction == OSSL_RECORD_DIRECTION_READ) { thismethod = s->rlayer.rrlmethod; thisrl = s->rlayer.rrl; } else { thismethod = s->rlayer.wrlmethod; thisrl = s->rlayer.wrl; } #ifndef OPENSSL_NO_KTLS { SSL *ssl = SSL_CONNECTION_GET_SSL(s); if (s->rlayer.rrlmethod == &ossl_ktls_record_method) { /* KTLS does not support renegotiation so disallow it */ SSL_set_options(ssl, SSL_OP_NO_RENEGOTIATION); } } #endif if (SSL_IS_FIRST_HANDSHAKE(s) && thismethod->set_first_handshake != NULL) thismethod->set_first_handshake(thisrl, 1); if (s->max_pipelines != 0 && thismethod->set_max_pipelines != NULL) thismethod->set_max_pipelines(thisrl, s->max_pipelines); return 1; } int ssl_set_new_record_layer(SSL_CONNECTION *s, int version, int direction, int level, unsigned char *secret, size_t secretlen, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, const SSL_COMP *comp, const EVP_MD *kdfdigest) { OSSL_PARAM options[5], *opts = options; OSSL_PARAM settings[6], *set = settings; const OSSL_RECORD_METHOD **thismethod; OSSL_RECORD_LAYER **thisrl, *newrl = NULL; BIO *thisbio; SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s); const OSSL_RECORD_METHOD *meth; int use_etm, stream_mac = 0, tlstree = 0; unsigned int maxfrag = (direction == OSSL_RECORD_DIRECTION_WRITE) ? ssl_get_max_send_fragment(s) : SSL3_RT_MAX_PLAIN_LENGTH; int use_early_data = 0; uint32_t max_early_data; COMP_METHOD *compm = (comp == NULL) ? NULL : comp->method; meth = ssl_select_next_record_layer(s, direction, level); if (direction == OSSL_RECORD_DIRECTION_READ) { thismethod = &s->rlayer.rrlmethod; thisrl = &s->rlayer.rrl; thisbio = s->rbio; } else { thismethod = &s->rlayer.wrlmethod; thisrl = &s->rlayer.wrl; thisbio = s->wbio; } if (meth == NULL) meth = *thismethod; if (!ossl_assert(meth != NULL)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } /* Parameters that *may* be supported by a record layer if passed */ *opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS, &s->options); *opts++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE, &s->mode); if (direction == OSSL_RECORD_DIRECTION_READ) { *opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN, &s->rlayer.default_read_buf_len); *opts++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD, &s->rlayer.read_ahead); } else { *opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING, &s->rlayer.block_padding); } *opts = OSSL_PARAM_construct_end(); /* Parameters that *must* be supported by a record layer if passed */ if (direction == OSSL_RECORD_DIRECTION_READ) { use_etm = SSL_READ_ETM(s) ? 1 : 0; if ((s->mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM) != 0) stream_mac = 1; if ((s->mac_flags & SSL_MAC_FLAG_READ_MAC_TLSTREE) != 0) tlstree = 1; } else { use_etm = SSL_WRITE_ETM(s) ? 1 : 0; if ((s->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM) != 0) stream_mac = 1; if ((s->mac_flags & SSL_MAC_FLAG_WRITE_MAC_TLSTREE) != 0) tlstree = 1; } if (use_etm) *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM, &use_etm); if (stream_mac) *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC, &stream_mac); if (tlstree) *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE, &tlstree); /* * We only need to do this for the read side. The write side should already * have the correct value due to the ssl_get_max_send_fragment() call above */ if (direction == OSSL_RECORD_DIRECTION_READ && s->session != NULL && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)) maxfrag = GET_MAX_FRAGMENT_LENGTH(s->session); if (maxfrag != SSL3_RT_MAX_PLAIN_LENGTH) *set++ = OSSL_PARAM_construct_uint(OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN, &maxfrag); /* * The record layer must check the amount of early data sent or received * using the early keys. A server also needs to worry about rejected early * data that might arrive when the handshake keys are in force. */ if (s->server && direction == OSSL_RECORD_DIRECTION_READ) { use_early_data = (level == OSSL_RECORD_PROTECTION_LEVEL_EARLY || level == OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE); } else if (!s->server && direction == OSSL_RECORD_DIRECTION_WRITE) { use_early_data = (level == OSSL_RECORD_PROTECTION_LEVEL_EARLY); } if (use_early_data) { max_early_data = ossl_get_max_early_data(s); if (max_early_data != 0) *set++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA, &max_early_data); } *set = OSSL_PARAM_construct_end(); for (;;) { int rlret; BIO *prev = NULL; BIO *next = NULL; unsigned int epoch = 0; OSSL_DISPATCH rlayer_dispatch_tmp[OSSL_NELEM(rlayer_dispatch)]; size_t i, j; if (direction == OSSL_RECORD_DIRECTION_READ) { prev = s->rlayer.rrlnext; if (SSL_CONNECTION_IS_DTLS(s) && level != OSSL_RECORD_PROTECTION_LEVEL_NONE) epoch = dtls1_get_epoch(s, SSL3_CC_READ); /* new epoch */ #ifndef OPENSSL_NO_DGRAM if (SSL_CONNECTION_IS_DTLS(s)) next = BIO_new(BIO_s_dgram_mem()); else #endif next = BIO_new(BIO_s_mem()); if (next == NULL) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } s->rlayer.rrlnext = next; } else { if (SSL_CONNECTION_IS_DTLS(s) && level != OSSL_RECORD_PROTECTION_LEVEL_NONE) epoch = dtls1_get_epoch(s, SSL3_CC_WRITE); /* new epoch */ } /* * Create a copy of the dispatch array, missing out wrappers for * callbacks that we don't need. */ for (i = 0, j = 0; i < OSSL_NELEM(rlayer_dispatch); i++) { switch (rlayer_dispatch[i].function_id) { case OSSL_FUNC_RLAYER_MSG_CALLBACK: if (s->msg_callback == NULL) continue; break; case OSSL_FUNC_RLAYER_PADDING: if (s->rlayer.record_padding_cb == NULL) continue; break; default: break; } rlayer_dispatch_tmp[j++] = rlayer_dispatch[i]; } rlret = meth->new_record_layer(sctx->libctx, sctx->propq, version, s->server, direction, level, epoch, secret, secretlen, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, compm, kdfdigest, prev, thisbio, next, NULL, NULL, settings, options, rlayer_dispatch_tmp, s, s->rlayer.rlarg, &newrl); BIO_free(prev); switch (rlret) { case OSSL_RECORD_RETURN_FATAL: SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_RECORD_LAYER_FAILURE); return 0; case OSSL_RECORD_RETURN_NON_FATAL_ERR: if (*thismethod != meth && *thismethod != NULL) { /* * We tried a new record layer method, but it didn't work out, * so we fallback to the original method and try again */ meth = *thismethod; continue; } SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_RECORD_LAYER); return 0; case OSSL_RECORD_RETURN_SUCCESS: break; default: /* Should not happen */ SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } break; } /* * Free the old record layer if we have one except in the case of DTLS when * writing and there are still buffered sent messages in our queue. In that * case the record layer is still referenced by those buffered messages for * potential retransmit. Only when those buffered messages get freed do we * free the record layer object (see dtls1_hm_fragment_free) */ if (!SSL_CONNECTION_IS_DTLS(s) || direction == OSSL_RECORD_DIRECTION_READ || pqueue_peek(s->d1->sent_messages) == NULL) { if (*thismethod != NULL && !(*thismethod)->free(*thisrl)) { SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } *thisrl = newrl; *thismethod = meth; return ssl_post_record_layer_select(s, direction); } int ssl_set_record_protocol_version(SSL_CONNECTION *s, int vers) { if (!ossl_assert(s->rlayer.rrlmethod != NULL) || !ossl_assert(s->rlayer.wrlmethod != NULL)) return 0; s->rlayer.rrlmethod->set_protocol_version(s->rlayer.rrl, s->version); s->rlayer.wrlmethod->set_protocol_version(s->rlayer.wrl, s->version); return 1; }

./openssl/ssl/record/record.h

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/core_dispatch.h> #include "internal/recordmethod.h" /***************************************************************************** * * * These structures should be considered PRIVATE to the record layer. No * * non-record layer code should be using these structures in any way. * * * *****************************************************************************/ #define SEQ_NUM_SIZE 8 typedef struct tls_record_st { void *rechandle; int version; uint8_t type; /* The data buffer containing bytes from the record */ const unsigned char *data; /* * Buffer that we allocated to store data. If non NULL always the same as * data (but non-const) */ unsigned char *allocdata; /* Number of remaining to be read in the data buffer */ size_t length; /* Offset into the data buffer where to start reading */ size_t off; /* epoch number. DTLS only */ uint16_t epoch; /* sequence number. DTLS only */ unsigned char seq_num[SEQ_NUM_SIZE]; #ifndef OPENSSL_NO_SCTP struct bio_dgram_sctp_rcvinfo recordinfo; #endif } TLS_RECORD; typedef struct record_pqueue_st { uint16_t epoch; struct pqueue_st *q; } record_pqueue; typedef struct dtls_record_layer_st { /* * The current data and handshake epoch. This is initially * undefined, and starts at zero once the initial handshake is * completed */ uint16_t r_epoch; uint16_t w_epoch; /* * Buffered application records. Only for records between CCS and * Finished to prevent either protocol violation or unnecessary message * loss. */ record_pqueue buffered_app_data; } DTLS_RECORD_LAYER; /***************************************************************************** * * * This structure should be considered "opaque" to anything outside of the * * record layer. No non-record layer code should be accessing the members of * * this structure. * * * *****************************************************************************/ typedef struct record_layer_st { /* The parent SSL_CONNECTION structure */ SSL_CONNECTION *s; /* Custom record layer: always selected if set */ const OSSL_RECORD_METHOD *custom_rlmethod; /* Record layer specific argument */ void *rlarg; /* Method to use for the read record layer*/ const OSSL_RECORD_METHOD *rrlmethod; /* Method to use for the write record layer*/ const OSSL_RECORD_METHOD *wrlmethod; /* The read record layer object itself */ OSSL_RECORD_LAYER *rrl; /* The write record layer object itself */ OSSL_RECORD_LAYER *wrl; /* BIO to store data destined for the next read record layer epoch */ BIO *rrlnext; /* Default read buffer length to be passed to the record layer */ size_t default_read_buf_len; /* * Read as many input bytes as possible (for * non-blocking reads) */ int read_ahead; /* number of bytes sent so far */ size_t wnum; unsigned char handshake_fragment[4]; size_t handshake_fragment_len; /* partial write - check the numbers match */ /* number bytes written */ size_t wpend_tot; uint8_t wpend_type; const unsigned char *wpend_buf; /* Count of the number of consecutive warning alerts received */ unsigned int alert_count; DTLS_RECORD_LAYER *d; /* TLS1.3 padding callback */ size_t (*record_padding_cb)(SSL *s, int type, size_t len, void *arg); void *record_padding_arg; size_t block_padding; /* How many records we have read from the record layer */ size_t num_recs; /* The next record from the record layer that we need to process */ size_t curr_rec; /* Record layer data to be processed */ TLS_RECORD tlsrecs[SSL_MAX_PIPELINES]; } RECORD_LAYER; /***************************************************************************** * * * The following macros/functions represent the libssl internal API to the * * record layer. Any libssl code may call these functions/macros * * * *****************************************************************************/ #define RECORD_LAYER_set_read_ahead(rl, ra) ((rl)->read_ahead = (ra)) #define RECORD_LAYER_get_read_ahead(rl) ((rl)->read_ahead) void RECORD_LAYER_init(RECORD_LAYER *rl, SSL_CONNECTION *s); void RECORD_LAYER_clear(RECORD_LAYER *rl); int RECORD_LAYER_read_pending(const RECORD_LAYER *rl); int RECORD_LAYER_processed_read_pending(const RECORD_LAYER *rl); int RECORD_LAYER_write_pending(const RECORD_LAYER *rl); int RECORD_LAYER_is_sslv2_record(RECORD_LAYER *rl); __owur size_t ssl3_pending(const SSL *s); __owur int ssl3_write_bytes(SSL *s, uint8_t type, const void *buf, size_t len, size_t *written); __owur int ssl3_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type, unsigned char *buf, size_t len, int peek, size_t *readbytes); int DTLS_RECORD_LAYER_new(RECORD_LAYER *rl); void DTLS_RECORD_LAYER_free(RECORD_LAYER *rl); void DTLS_RECORD_LAYER_clear(RECORD_LAYER *rl); __owur int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type, unsigned char *buf, size_t len, int peek, size_t *readbytes); __owur int dtls1_write_bytes(SSL_CONNECTION *s, uint8_t type, const void *buf, size_t len, size_t *written); int do_dtls1_write(SSL_CONNECTION *s, uint8_t type, const unsigned char *buf, size_t len, size_t *written); void dtls1_increment_epoch(SSL_CONNECTION *s, int rw); uint16_t dtls1_get_epoch(SSL_CONNECTION *s, int rw); int ssl_release_record(SSL_CONNECTION *s, TLS_RECORD *rr, size_t length); # define HANDLE_RLAYER_READ_RETURN(s, ret) \ ossl_tls_handle_rlayer_return(s, 0, ret, OPENSSL_FILE, OPENSSL_LINE) # define HANDLE_RLAYER_WRITE_RETURN(s, ret) \ ossl_tls_handle_rlayer_return(s, 1, ret, OPENSSL_FILE, OPENSSL_LINE) int ossl_tls_handle_rlayer_return(SSL_CONNECTION *s, int writing, int ret, char *file, int line); int ssl_set_new_record_layer(SSL_CONNECTION *s, int version, int direction, int level, unsigned char *secret, size_t secretlen, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, const SSL_COMP *comp, const EVP_MD *kdfdigest); int ssl_set_record_protocol_version(SSL_CONNECTION *s, int vers); # define OSSL_FUNC_RLAYER_SKIP_EARLY_DATA 1 OSSL_CORE_MAKE_FUNC(int, rlayer_skip_early_data, (void *cbarg)) # define OSSL_FUNC_RLAYER_MSG_CALLBACK 2 OSSL_CORE_MAKE_FUNC(void, rlayer_msg_callback, (int write_p, int version, int content_type, const void *buf, size_t len, void *cbarg)) # define OSSL_FUNC_RLAYER_SECURITY 3 OSSL_CORE_MAKE_FUNC(int, rlayer_security, (void *cbarg, int op, int bits, int nid, void *other)) # define OSSL_FUNC_RLAYER_PADDING 4 OSSL_CORE_MAKE_FUNC(size_t, rlayer_padding, (void *cbarg, int type, size_t len))

./openssl/ssl/record/methods/ktls_meth.c

/* * Copyright 2018-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/evp.h> #include <openssl/core_names.h> #include <openssl/rand.h> #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" #include "internal/ktls.h" static struct record_functions_st ossl_ktls_funcs; #if defined(__FreeBSD__) # include "crypto/cryptodev.h" /*- * Check if a given cipher is supported by the KTLS interface. * The kernel might still fail the setsockopt() if no suitable * provider is found, but this checks if the socket option * supports the cipher suite used at all. */ static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl, const EVP_CIPHER *c, const EVP_MD *md, size_t taglen) { switch (rl->version) { case TLS1_VERSION: case TLS1_1_VERSION: case TLS1_2_VERSION: #ifdef OPENSSL_KTLS_TLS13 case TLS1_3_VERSION: #endif break; default: return 0; } if (EVP_CIPHER_is_a(c, "AES-128-GCM") || EVP_CIPHER_is_a(c, "AES-256-GCM") # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 || EVP_CIPHER_is_a(c, "CHACHA20-POLY1305") # endif ) return 1; if (!EVP_CIPHER_is_a(c, "AES-128-CBC") && !EVP_CIPHER_is_a(c, "AES-256-CBC")) return 0; if (rl->use_etm) return 0; if (md == NULL) return 0; if (EVP_MD_is_a(md, "SHA1") || EVP_MD_is_a(md, "SHA2-256") || EVP_MD_is_a(md, "SHA2-384")) return 1; return 0; } /* Function to configure kernel TLS structure */ static int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c, EVP_MD *md, void *rl_sequence, ktls_crypto_info_t *crypto_info, int is_tx, unsigned char *iv, size_t ivlen, unsigned char *key, size_t keylen, unsigned char *mac_key, size_t mac_secret_size) { memset(crypto_info, 0, sizeof(*crypto_info)); if (EVP_CIPHER_is_a(c, "AES-128-GCM") || EVP_CIPHER_is_a(c, "AES-256-GCM")) { crypto_info->cipher_algorithm = CRYPTO_AES_NIST_GCM_16; crypto_info->iv_len = ivlen; } else # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 if (EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")) { crypto_info->cipher_algorithm = CRYPTO_CHACHA20_POLY1305; crypto_info->iv_len = ivlen; } else # endif if (EVP_CIPHER_is_a(c, "AES-128-CBC") || EVP_CIPHER_is_a(c, "AES-256-CBC")) { if (md == NULL) return 0; if (EVP_MD_is_a(md, "SHA1")) crypto_info->auth_algorithm = CRYPTO_SHA1_HMAC; else if (EVP_MD_is_a(md, "SHA2-256")) crypto_info->auth_algorithm = CRYPTO_SHA2_256_HMAC; else if (EVP_MD_is_a(md, "SHA2-384")) crypto_info->auth_algorithm = CRYPTO_SHA2_384_HMAC; else return 0; crypto_info->cipher_algorithm = CRYPTO_AES_CBC; crypto_info->iv_len = ivlen; crypto_info->auth_key = mac_key; crypto_info->auth_key_len = mac_secret_size; } else { return 0; } crypto_info->cipher_key = key; crypto_info->cipher_key_len = keylen; crypto_info->iv = iv; crypto_info->tls_vmajor = (version >> 8) & 0x000000ff; crypto_info->tls_vminor = (version & 0x000000ff); # ifdef TCP_RXTLS_ENABLE memcpy(crypto_info->rec_seq, rl_sequence, sizeof(crypto_info->rec_seq)); # else if (!is_tx) return 0; # endif return 1; }; #endif /* __FreeBSD__ */ #if defined(OPENSSL_SYS_LINUX) /* Function to check supported ciphers in Linux */ static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl, const EVP_CIPHER *c, const EVP_MD *md, size_t taglen) { switch (rl->version) { case TLS1_2_VERSION: #ifdef OPENSSL_KTLS_TLS13 case TLS1_3_VERSION: #endif break; default: return 0; } /* * Check that cipher is AES_GCM_128, AES_GCM_256, AES_CCM_128 * or Chacha20-Poly1305 */ # ifdef OPENSSL_KTLS_AES_CCM_128 if (EVP_CIPHER_is_a(c, "AES-128-CCM")) { if (taglen != EVP_CCM_TLS_TAG_LEN) return 0; return 1; } else # endif if (0 # ifdef OPENSSL_KTLS_AES_GCM_128 || EVP_CIPHER_is_a(c, "AES-128-GCM") # endif # ifdef OPENSSL_KTLS_AES_GCM_256 || EVP_CIPHER_is_a(c, "AES-256-GCM") # endif # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 || EVP_CIPHER_is_a(c, "ChaCha20-Poly1305") # endif ) { return 1; } return 0; } /* Function to configure kernel TLS structure */ static int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c, const EVP_MD *md, void *rl_sequence, ktls_crypto_info_t *crypto_info, int is_tx, unsigned char *iv, size_t ivlen, unsigned char *key, size_t keylen, unsigned char *mac_key, size_t mac_secret_size) { unsigned char geniv[EVP_GCM_TLS_EXPLICIT_IV_LEN]; unsigned char *eiv = NULL; # ifdef OPENSSL_NO_KTLS_RX if (!is_tx) return 0; # endif if (EVP_CIPHER_get_mode(c) == EVP_CIPH_GCM_MODE || EVP_CIPHER_get_mode(c) == EVP_CIPH_CCM_MODE) { if (!ossl_assert(EVP_GCM_TLS_FIXED_IV_LEN == EVP_CCM_TLS_FIXED_IV_LEN) || !ossl_assert(EVP_GCM_TLS_EXPLICIT_IV_LEN == EVP_CCM_TLS_EXPLICIT_IV_LEN)) return 0; if (version == TLS1_2_VERSION) { if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN)) return 0; if (is_tx) { if (RAND_bytes_ex(libctx, geniv, EVP_GCM_TLS_EXPLICIT_IV_LEN, 0) <= 0) return 0; } else { memset(geniv, 0, EVP_GCM_TLS_EXPLICIT_IV_LEN); } eiv = geniv; } else { if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN + EVP_GCM_TLS_EXPLICIT_IV_LEN)) return 0; eiv = iv + TLS_CIPHER_AES_GCM_128_SALT_SIZE; } } memset(crypto_info, 0, sizeof(*crypto_info)); switch (EVP_CIPHER_get_nid(c)) { # ifdef OPENSSL_KTLS_AES_GCM_128 case NID_aes_128_gcm: if (!ossl_assert(TLS_CIPHER_AES_GCM_128_SALT_SIZE == EVP_GCM_TLS_FIXED_IV_LEN) || !ossl_assert(TLS_CIPHER_AES_GCM_128_IV_SIZE == EVP_GCM_TLS_EXPLICIT_IV_LEN)) return 0; crypto_info->gcm128.info.cipher_type = TLS_CIPHER_AES_GCM_128; crypto_info->gcm128.info.version = version; crypto_info->tls_crypto_info_len = sizeof(crypto_info->gcm128); memcpy(crypto_info->gcm128.iv, eiv, TLS_CIPHER_AES_GCM_128_IV_SIZE); memcpy(crypto_info->gcm128.salt, iv, TLS_CIPHER_AES_GCM_128_SALT_SIZE); memcpy(crypto_info->gcm128.key, key, keylen); memcpy(crypto_info->gcm128.rec_seq, rl_sequence, TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE); return 1; # endif # ifdef OPENSSL_KTLS_AES_GCM_256 case NID_aes_256_gcm: if (!ossl_assert(TLS_CIPHER_AES_GCM_256_SALT_SIZE == EVP_GCM_TLS_FIXED_IV_LEN) || !ossl_assert(TLS_CIPHER_AES_GCM_256_IV_SIZE == EVP_GCM_TLS_EXPLICIT_IV_LEN)) return 0; crypto_info->gcm256.info.cipher_type = TLS_CIPHER_AES_GCM_256; crypto_info->gcm256.info.version = version; crypto_info->tls_crypto_info_len = sizeof(crypto_info->gcm256); memcpy(crypto_info->gcm256.iv, eiv, TLS_CIPHER_AES_GCM_256_IV_SIZE); memcpy(crypto_info->gcm256.salt, iv, TLS_CIPHER_AES_GCM_256_SALT_SIZE); memcpy(crypto_info->gcm256.key, key, keylen); memcpy(crypto_info->gcm256.rec_seq, rl_sequence, TLS_CIPHER_AES_GCM_256_REC_SEQ_SIZE); return 1; # endif # ifdef OPENSSL_KTLS_AES_CCM_128 case NID_aes_128_ccm: if (!ossl_assert(TLS_CIPHER_AES_CCM_128_SALT_SIZE == EVP_CCM_TLS_FIXED_IV_LEN) || !ossl_assert(TLS_CIPHER_AES_CCM_128_IV_SIZE == EVP_CCM_TLS_EXPLICIT_IV_LEN)) return 0; crypto_info->ccm128.info.cipher_type = TLS_CIPHER_AES_CCM_128; crypto_info->ccm128.info.version = version; crypto_info->tls_crypto_info_len = sizeof(crypto_info->ccm128); memcpy(crypto_info->ccm128.iv, eiv, TLS_CIPHER_AES_CCM_128_IV_SIZE); memcpy(crypto_info->ccm128.salt, iv, TLS_CIPHER_AES_CCM_128_SALT_SIZE); memcpy(crypto_info->ccm128.key, key, keylen); memcpy(crypto_info->ccm128.rec_seq, rl_sequence, TLS_CIPHER_AES_CCM_128_REC_SEQ_SIZE); return 1; # endif # ifdef OPENSSL_KTLS_CHACHA20_POLY1305 case NID_chacha20_poly1305: if (!ossl_assert(ivlen == TLS_CIPHER_CHACHA20_POLY1305_IV_SIZE)) return 0; crypto_info->chacha20poly1305.info.cipher_type = TLS_CIPHER_CHACHA20_POLY1305; crypto_info->chacha20poly1305.info.version = version; crypto_info->tls_crypto_info_len = sizeof(crypto_info->chacha20poly1305); memcpy(crypto_info->chacha20poly1305.iv, iv, ivlen); memcpy(crypto_info->chacha20poly1305.key, key, keylen); memcpy(crypto_info->chacha20poly1305.rec_seq, rl_sequence, TLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZE); return 1; # endif default: return 0; } } #endif /* OPENSSL_SYS_LINUX */ static int ktls_set_crypto_state(OSSL_RECORD_LAYER *rl, int level, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp) { ktls_crypto_info_t crypto_info; /* * Check if we are suitable for KTLS. If not suitable we return * OSSL_RECORD_RETURN_NON_FATAL_ERR so that other record layers can be tried * instead */ if (comp != NULL) return OSSL_RECORD_RETURN_NON_FATAL_ERR; /* ktls supports only the maximum fragment size */ if (rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH) return OSSL_RECORD_RETURN_NON_FATAL_ERR; /* check that cipher is supported */ if (!ktls_int_check_supported_cipher(rl, ciph, md, taglen)) return OSSL_RECORD_RETURN_NON_FATAL_ERR; /* All future data will get encrypted by ktls. Flush the BIO or skip ktls */ if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) { if (BIO_flush(rl->bio) <= 0) return OSSL_RECORD_RETURN_NON_FATAL_ERR; /* KTLS does not support record padding */ if (rl->padding != NULL || rl->block_padding > 0) return OSSL_RECORD_RETURN_NON_FATAL_ERR; } if (!ktls_configure_crypto(rl->libctx, rl->version, ciph, md, rl->sequence, &crypto_info, rl->direction == OSSL_RECORD_DIRECTION_WRITE, iv, ivlen, key, keylen, mackey, mackeylen)) return OSSL_RECORD_RETURN_NON_FATAL_ERR; if (!BIO_set_ktls(rl->bio, &crypto_info, rl->direction)) return OSSL_RECORD_RETURN_NON_FATAL_ERR; if (rl->direction == OSSL_RECORD_DIRECTION_WRITE && (rl->options & SSL_OP_ENABLE_KTLS_TX_ZEROCOPY_SENDFILE) != 0) /* Ignore errors. The application opts in to using the zerocopy * optimization. If the running kernel doesn't support it, just * continue without the optimization. */ BIO_set_ktls_tx_zerocopy_sendfile(rl->bio); return OSSL_RECORD_RETURN_SUCCESS; } static int ktls_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend, int clearold, size_t *readbytes) { int ret; ret = tls_default_read_n(rl, n, max, extend, clearold, readbytes); if (ret < OSSL_RECORD_RETURN_RETRY) { switch (errno) { case EBADMSG: RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); break; case EMSGSIZE: RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_PACKET_LENGTH_TOO_LONG); break; case EINVAL: RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); break; default: break; } } return ret; } static int ktls_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *inrecs, size_t n_recs, int sending, SSL_MAC_BUF *mac, size_t macsize) { return 1; } static int ktls_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { if (rec->rec_version != TLS1_2_VERSION) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_WRONG_VERSION_NUMBER); return 0; } return 1; } static int ktls_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { if (rl->version == TLS1_3_VERSION) return tls13_common_post_process_record(rl, rec); return 1; } static int ktls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers, int role, int direction, int level, uint16_t epoch, unsigned char *secret, size_t secretlen, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp, const EVP_MD *kdfdigest, BIO *prev, BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer, const OSSL_PARAM *settings, const OSSL_PARAM *options, const OSSL_DISPATCH *fns, void *cbarg, void *rlarg, OSSL_RECORD_LAYER **retrl) { int ret; ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp, prev, transport, next, local, peer, settings, options, fns, cbarg, retrl); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; (*retrl)->funcs = &ossl_ktls_funcs; ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp); if (ret != OSSL_RECORD_RETURN_SUCCESS) { OPENSSL_free(*retrl); *retrl = NULL; } else { /* * With KTLS we always try and read as much as possible and fill the * buffer */ (*retrl)->read_ahead = 1; } return ret; } static int ktls_allocate_write_buffers(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, size_t *prefix) { if (!ossl_assert(numtempl == 1)) return 0; /* * We just use the end application buffer in the case of KTLS, so nothing * to do. We pretend we set up one buffer. */ rl->numwpipes = 1; return 1; } static int ktls_initialise_write_packets(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, OSSL_RECORD_TEMPLATE *prefixtempl, WPACKET *pkt, TLS_BUFFER *bufs, size_t *wpinited) { TLS_BUFFER *wb; /* * We just use the application buffer directly and don't use any WPACKET * structures */ wb = &bufs[0]; wb->type = templates[0].type; /* * ktls doesn't modify the buffer, but to avoid a warning we need * to discard the const qualifier. * This doesn't leak memory because the buffers have never been allocated * with KTLS */ TLS_BUFFER_set_buf(wb, (unsigned char *)templates[0].buf); TLS_BUFFER_set_offset(wb, 0); TLS_BUFFER_set_app_buffer(wb, 1); return 1; } static int ktls_prepare_record_header(OSSL_RECORD_LAYER *rl, WPACKET *thispkt, OSSL_RECORD_TEMPLATE *templ, uint8_t rectype, unsigned char **recdata) { /* The kernel writes the record header, so nothing to do */ *recdata = NULL; return 1; } static int ktls_prepare_for_encryption(OSSL_RECORD_LAYER *rl, size_t mac_size, WPACKET *thispkt, TLS_RL_RECORD *thiswr) { /* No encryption, so nothing to do */ return 1; } static int ktls_post_encryption_processing(OSSL_RECORD_LAYER *rl, size_t mac_size, OSSL_RECORD_TEMPLATE *templ, WPACKET *thispkt, TLS_RL_RECORD *thiswr) { /* The kernel does anything that is needed, so nothing to do here */ return 1; } static int ktls_prepare_write_bio(OSSL_RECORD_LAYER *rl, int type) { /* * To prevent coalescing of control and data messages, * such as in buffer_write, we flush the BIO */ if (type != SSL3_RT_APPLICATION_DATA) { int ret, i = BIO_flush(rl->bio); if (i <= 0) { if (BIO_should_retry(rl->bio)) ret = OSSL_RECORD_RETURN_RETRY; else ret = OSSL_RECORD_RETURN_FATAL; return ret; } BIO_set_ktls_ctrl_msg(rl->bio, type); } return OSSL_RECORD_RETURN_SUCCESS; } static int ktls_alloc_buffers(OSSL_RECORD_LAYER *rl) { /* We use the application buffer directly for writing */ if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) return 1; return tls_alloc_buffers(rl); } static int ktls_free_buffers(OSSL_RECORD_LAYER *rl) { /* We use the application buffer directly for writing */ if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) return 1; return tls_free_buffers(rl); } static struct record_functions_st ossl_ktls_funcs = { ktls_set_crypto_state, ktls_cipher, NULL, tls_default_set_protocol_version, ktls_read_n, tls_get_more_records, ktls_validate_record_header, ktls_post_process_record, tls_get_max_records_default, tls_write_records_default, ktls_allocate_write_buffers, ktls_initialise_write_packets, NULL, ktls_prepare_record_header, NULL, ktls_prepare_for_encryption, ktls_post_encryption_processing, ktls_prepare_write_bio }; const OSSL_RECORD_METHOD ossl_ktls_record_method = { ktls_new_record_layer, tls_free, tls_unprocessed_read_pending, tls_processed_read_pending, tls_app_data_pending, tls_get_max_records, tls_write_records, tls_retry_write_records, tls_read_record, tls_release_record, tls_get_alert_code, tls_set1_bio, tls_set_protocol_version, tls_set_plain_alerts, tls_set_first_handshake, tls_set_max_pipelines, NULL, tls_get_state, tls_set_options, tls_get_compression, tls_set_max_frag_len, NULL, tls_increment_sequence_ctr, ktls_alloc_buffers, ktls_free_buffers };

./openssl/ssl/record/methods/tls_common.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <assert.h> #include <openssl/bio.h> #include <openssl/ssl.h> #include <openssl/err.h> #include <openssl/core_names.h> #include <openssl/comp.h> #include <openssl/ssl.h> #include "internal/e_os.h" #include "internal/packet.h" #include "internal/ssl3_cbc.h" #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" static void tls_int_free(OSSL_RECORD_LAYER *rl); void ossl_tls_buffer_release(TLS_BUFFER *b) { OPENSSL_free(b->buf); b->buf = NULL; } static void TLS_RL_RECORD_release(TLS_RL_RECORD *r, size_t num_recs) { size_t i; for (i = 0; i < num_recs; i++) { OPENSSL_free(r[i].comp); r[i].comp = NULL; } } void ossl_tls_rl_record_set_seq_num(TLS_RL_RECORD *r, const unsigned char *seq_num) { memcpy(r->seq_num, seq_num, SEQ_NUM_SIZE); } void ossl_rlayer_fatal(OSSL_RECORD_LAYER *rl, int al, int reason, const char *fmt, ...) { va_list args; va_start(args, fmt); ERR_vset_error(ERR_LIB_SSL, reason, fmt, args); va_end(args); rl->alert = al; } int ossl_set_tls_provider_parameters(OSSL_RECORD_LAYER *rl, EVP_CIPHER_CTX *ctx, const EVP_CIPHER *ciph, const EVP_MD *md) { /* * Provided cipher, the TLS padding/MAC removal is performed provider * side so we need to tell the ctx about our TLS version and mac size */ OSSL_PARAM params[3], *pprm = params; size_t macsize = 0; int imacsize = -1; if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) == 0 && !rl->use_etm) imacsize = EVP_MD_get_size(md); if (imacsize >= 0) macsize = (size_t)imacsize; *pprm++ = OSSL_PARAM_construct_int(OSSL_CIPHER_PARAM_TLS_VERSION, &rl->version); *pprm++ = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, &macsize); *pprm = OSSL_PARAM_construct_end(); if (!EVP_CIPHER_CTX_set_params(ctx, params)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } return 1; } /* * ssl3_cbc_record_digest_supported returns 1 iff |ctx| uses a hash function * which ssl3_cbc_digest_record supports. */ char ssl3_cbc_record_digest_supported(const EVP_MD_CTX *ctx) { switch (EVP_MD_CTX_get_type(ctx)) { case NID_md5: case NID_sha1: case NID_sha224: case NID_sha256: case NID_sha384: case NID_sha512: return 1; default: return 0; } } #ifndef OPENSSL_NO_COMP static int tls_allow_compression(OSSL_RECORD_LAYER *rl) { if (rl->options & SSL_OP_NO_COMPRESSION) return 0; return rl->security == NULL || rl->security(rl->cbarg, SSL_SECOP_COMPRESSION, 0, 0, NULL); } #endif static void tls_release_write_buffer_int(OSSL_RECORD_LAYER *rl, size_t start) { TLS_BUFFER *wb; size_t pipes; pipes = rl->numwpipes; while (pipes > start) { wb = &rl->wbuf[pipes - 1]; if (TLS_BUFFER_is_app_buffer(wb)) TLS_BUFFER_set_app_buffer(wb, 0); else OPENSSL_free(wb->buf); wb->buf = NULL; pipes--; } } int tls_setup_write_buffer(OSSL_RECORD_LAYER *rl, size_t numwpipes, size_t firstlen, size_t nextlen) { unsigned char *p; size_t align = 0, headerlen; TLS_BUFFER *wb; size_t currpipe; size_t defltlen = 0; size_t contenttypelen = 0; if (firstlen == 0 || (numwpipes > 1 && nextlen == 0)) { if (rl->isdtls) headerlen = DTLS1_RT_HEADER_LENGTH + 1; else headerlen = SSL3_RT_HEADER_LENGTH; /* TLSv1.3 adds an extra content type byte after payload data */ if (rl->version == TLS1_3_VERSION) contenttypelen = 1; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = SSL3_ALIGN_PAYLOAD - 1; #endif defltlen = align + headerlen + rl->eivlen + rl->max_frag_len + contenttypelen + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD; #ifndef OPENSSL_NO_COMP if (tls_allow_compression(rl)) defltlen += SSL3_RT_MAX_COMPRESSED_OVERHEAD; #endif /* * We don't need to add eivlen here since empty fragments only occur * when we don't have an explicit IV. The contenttype byte will also * always be 0 in these protocol versions */ if ((rl->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) == 0) defltlen += headerlen + align + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD; } wb = rl->wbuf; for (currpipe = 0; currpipe < numwpipes; currpipe++) { TLS_BUFFER *thiswb = &wb[currpipe]; size_t len = (currpipe == 0) ? firstlen : nextlen; if (len == 0) len = defltlen; if (thiswb->len != len) { OPENSSL_free(thiswb->buf); thiswb->buf = NULL; /* force reallocation */ } p = thiswb->buf; if (p == NULL) { p = OPENSSL_malloc(len); if (p == NULL) { if (rl->numwpipes < currpipe) rl->numwpipes = currpipe; /* * We've got a malloc failure, and we're still initialising * buffers. We assume we're so doomed that we won't even be able * to send an alert. */ RLAYERfatal(rl, SSL_AD_NO_ALERT, ERR_R_CRYPTO_LIB); return 0; } } memset(thiswb, 0, sizeof(TLS_BUFFER)); thiswb->buf = p; thiswb->len = len; } /* Free any previously allocated buffers that we are no longer using */ tls_release_write_buffer_int(rl, currpipe); rl->numwpipes = numwpipes; return 1; } static void tls_release_write_buffer(OSSL_RECORD_LAYER *rl) { tls_release_write_buffer_int(rl, 0); rl->numwpipes = 0; } int tls_setup_read_buffer(OSSL_RECORD_LAYER *rl) { unsigned char *p; size_t len, align = 0, headerlen; TLS_BUFFER *b; b = &rl->rbuf; if (rl->isdtls) headerlen = DTLS1_RT_HEADER_LENGTH; else headerlen = SSL3_RT_HEADER_LENGTH; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (-SSL3_RT_HEADER_LENGTH) & (SSL3_ALIGN_PAYLOAD - 1); #endif if (b->buf == NULL) { len = rl->max_frag_len + SSL3_RT_MAX_ENCRYPTED_OVERHEAD + headerlen + align; #ifndef OPENSSL_NO_COMP if (tls_allow_compression(rl)) len += SSL3_RT_MAX_COMPRESSED_OVERHEAD; #endif /* Ensure our buffer is large enough to support all our pipelines */ if (rl->max_pipelines > 1) len *= rl->max_pipelines; if (b->default_len > len) len = b->default_len; if ((p = OPENSSL_malloc(len)) == NULL) { /* * We've got a malloc failure, and we're still initialising buffers. * We assume we're so doomed that we won't even be able to send an * alert. */ RLAYERfatal(rl, SSL_AD_NO_ALERT, ERR_R_CRYPTO_LIB); return 0; } b->buf = p; b->len = len; } return 1; } static int tls_release_read_buffer(OSSL_RECORD_LAYER *rl) { TLS_BUFFER *b; b = &rl->rbuf; if ((rl->options & SSL_OP_CLEANSE_PLAINTEXT) != 0) OPENSSL_cleanse(b->buf, b->len); OPENSSL_free(b->buf); b->buf = NULL; return 1; } /* * Return values are as per SSL_read() */ int tls_default_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend, int clearold, size_t *readbytes) { /* * If extend == 0, obtain new n-byte packet; if extend == 1, increase * packet by another n bytes. The packet will be in the sub-array of * rl->rbuf.buf specified by rl->packet and rl->packet_length. (If * rl->read_ahead is set, 'max' bytes may be stored in rbuf [plus * rl->packet_length bytes if extend == 1].) if clearold == 1, move the * packet to the start of the buffer; if clearold == 0 then leave any old * packets where they were */ size_t len, left, align = 0; unsigned char *pkt; TLS_BUFFER *rb; if (n == 0) return OSSL_RECORD_RETURN_NON_FATAL_ERR; rb = &rl->rbuf; left = rb->left; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (size_t)rb->buf + SSL3_RT_HEADER_LENGTH; align = SSL3_ALIGN_PAYLOAD - 1 - ((align - 1) % SSL3_ALIGN_PAYLOAD); #endif if (!extend) { /* start with empty packet ... */ if (left == 0) rb->offset = align; rl->packet = rb->buf + rb->offset; rl->packet_length = 0; /* ... now we can act as if 'extend' was set */ } len = rl->packet_length; pkt = rb->buf + align; /* * Move any available bytes to front of buffer: 'len' bytes already * pointed to by 'packet', 'left' extra ones at the end */ if (rl->packet != pkt && clearold == 1) { memmove(pkt, rl->packet, len + left); rl->packet = pkt; rb->offset = len + align; } /* * For DTLS/UDP reads should not span multiple packets because the read * operation returns the whole packet at once (as long as it fits into * the buffer). */ if (rl->isdtls) { if (left == 0 && extend) { /* * We received a record with a header but no body data. This will * get dumped. */ return OSSL_RECORD_RETURN_NON_FATAL_ERR; } if (left > 0 && n > left) n = left; } /* if there is enough in the buffer from a previous read, take some */ if (left >= n) { rl->packet_length += n; rb->left = left - n; rb->offset += n; *readbytes = n; return OSSL_RECORD_RETURN_SUCCESS; } /* else we need to read more data */ if (n > rb->len - rb->offset) { /* does not happen */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } /* We always act like read_ahead is set for DTLS */ if (!rl->read_ahead && !rl->isdtls) { /* ignore max parameter */ max = n; } else { if (max < n) max = n; if (max > rb->len - rb->offset) max = rb->len - rb->offset; } while (left < n) { size_t bioread = 0; int ret; BIO *bio = rl->prev != NULL ? rl->prev : rl->bio; /* * Now we have len+left bytes at the front of rl->rbuf.buf and * need to read in more until we have len + n (up to len + max if * possible) */ clear_sys_error(); if (bio != NULL) { ret = BIO_read(bio, pkt + len + left, max - left); if (ret > 0) { bioread = ret; ret = OSSL_RECORD_RETURN_SUCCESS; } else if (BIO_should_retry(bio)) { if (rl->prev != NULL) { /* * We were reading from the previous epoch. Now there is no * more data, so swap to the actual transport BIO */ BIO_free(rl->prev); rl->prev = NULL; continue; } ret = OSSL_RECORD_RETURN_RETRY; } else if (BIO_eof(bio)) { ret = OSSL_RECORD_RETURN_EOF; } else { ret = OSSL_RECORD_RETURN_FATAL; } } else { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_READ_BIO_NOT_SET); ret = OSSL_RECORD_RETURN_FATAL; } if (ret <= OSSL_RECORD_RETURN_RETRY) { rb->left = left; if ((rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0 && !rl->isdtls) if (len + left == 0) tls_release_read_buffer(rl); return ret; } left += bioread; /* * reads should *never* span multiple packets for DTLS because the * underlying transport protocol is message oriented as opposed to * byte oriented as in the TLS case. */ if (rl->isdtls) { if (n > left) n = left; /* makes the while condition false */ } } /* done reading, now the book-keeping */ rb->offset += n; rb->left = left - n; rl->packet_length += n; *readbytes = n; return OSSL_RECORD_RETURN_SUCCESS; } /* * Peeks ahead into "read_ahead" data to see if we have a whole record waiting * for us in the buffer. */ static int tls_record_app_data_waiting(OSSL_RECORD_LAYER *rl) { TLS_BUFFER *rbuf; size_t left, len; unsigned char *p; rbuf = &rl->rbuf; p = TLS_BUFFER_get_buf(rbuf); if (p == NULL) return 0; left = TLS_BUFFER_get_left(rbuf); if (left < SSL3_RT_HEADER_LENGTH) return 0; p += TLS_BUFFER_get_offset(rbuf); /* * We only check the type and record length, we will sanity check version * etc later */ if (*p != SSL3_RT_APPLICATION_DATA) return 0; p += 3; n2s(p, len); if (left < SSL3_RT_HEADER_LENGTH + len) return 0; return 1; } static int rlayer_early_data_count_ok(OSSL_RECORD_LAYER *rl, size_t length, size_t overhead, int send) { uint32_t max_early_data = rl->max_early_data; if (max_early_data == 0) { RLAYERfatal(rl, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MUCH_EARLY_DATA); return 0; } /* If we are dealing with ciphertext we need to allow for the overhead */ max_early_data += overhead; if (rl->early_data_count + length > max_early_data) { RLAYERfatal(rl, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE, SSL_R_TOO_MUCH_EARLY_DATA); return 0; } rl->early_data_count += length; return 1; } /* * MAX_EMPTY_RECORDS defines the number of consecutive, empty records that * will be processed per call to tls_get_more_records. Without this limit an * attacker could send empty records at a faster rate than we can process and * cause tls_get_more_records to loop forever. */ #define MAX_EMPTY_RECORDS 32 #define SSL2_RT_HEADER_LENGTH 2 /*- * Call this to buffer new input records in rl->rrec. * It will return a OSSL_RECORD_RETURN_* value. * When it finishes successfully (OSSL_RECORD_RETURN_SUCCESS), |rl->num_recs| * records have been decoded. For each record 'i': * rrec[i].type - is the type of record * rrec[i].data, - data * rrec[i].length, - number of bytes * Multiple records will only be returned if the record types are all * SSL3_RT_APPLICATION_DATA. The number of records returned will always be <= * |max_pipelines| */ int tls_get_more_records(OSSL_RECORD_LAYER *rl) { int enc_err, rret; int i; size_t more, n; TLS_RL_RECORD *rr, *thisrr; TLS_BUFFER *rbuf; unsigned char *p; unsigned char md[EVP_MAX_MD_SIZE]; unsigned int version; size_t mac_size = 0; int imac_size; size_t num_recs = 0, max_recs, j; PACKET pkt, sslv2pkt; SSL_MAC_BUF *macbufs = NULL; int ret = OSSL_RECORD_RETURN_FATAL; rr = rl->rrec; rbuf = &rl->rbuf; if (rbuf->buf == NULL) { if (!tls_setup_read_buffer(rl)) { /* RLAYERfatal() already called */ return OSSL_RECORD_RETURN_FATAL; } } max_recs = rl->max_pipelines; if (max_recs == 0) max_recs = 1; do { thisrr = &rr[num_recs]; /* check if we have the header */ if ((rl->rstate != SSL_ST_READ_BODY) || (rl->packet_length < SSL3_RT_HEADER_LENGTH)) { size_t sslv2len; unsigned int type; rret = rl->funcs->read_n(rl, SSL3_RT_HEADER_LENGTH, TLS_BUFFER_get_len(rbuf), 0, num_recs == 0 ? 1 : 0, &n); if (rret < OSSL_RECORD_RETURN_SUCCESS) return rret; /* error or non-blocking */ rl->rstate = SSL_ST_READ_BODY; p = rl->packet; if (!PACKET_buf_init(&pkt, p, rl->packet_length)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } sslv2pkt = pkt; if (!PACKET_get_net_2_len(&sslv2pkt, &sslv2len) || !PACKET_get_1(&sslv2pkt, &type)) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } /* * The first record received by the server may be a V2ClientHello. */ if (rl->role == OSSL_RECORD_ROLE_SERVER && rl->is_first_record && (sslv2len & 0x8000) != 0 && (type == SSL2_MT_CLIENT_HELLO)) { /* * SSLv2 style record * * |num_recs| here will actually always be 0 because * |num_recs > 0| only ever occurs when we are processing * multiple app data records - which we know isn't the case here * because it is an SSLv2ClientHello. We keep it using * |num_recs| for the sake of consistency */ thisrr->type = SSL3_RT_HANDSHAKE; thisrr->rec_version = SSL2_VERSION; thisrr->length = sslv2len & 0x7fff; if (thisrr->length > TLS_BUFFER_get_len(rbuf) - SSL2_RT_HEADER_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_PACKET_LENGTH_TOO_LONG); return OSSL_RECORD_RETURN_FATAL; } } else { /* SSLv3+ style record */ /* Pull apart the header into the TLS_RL_RECORD */ if (!PACKET_get_1(&pkt, &type) || !PACKET_get_net_2(&pkt, &version) || !PACKET_get_net_2_len(&pkt, &thisrr->length)) { if (rl->msg_callback != NULL) rl->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, rl->cbarg); RLAYERfatal(rl, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } thisrr->type = type; thisrr->rec_version = version; /* * When we call validate_record_header() only records actually * received in SSLv2 format should have the record version set * to SSL2_VERSION. This way validate_record_header() can know * what format the record was in based on the version. */ if (thisrr->rec_version == SSL2_VERSION) { RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); return OSSL_RECORD_RETURN_FATAL; } if (rl->msg_callback != NULL) rl->msg_callback(0, version, SSL3_RT_HEADER, p, 5, rl->cbarg); if (thisrr->length > TLS_BUFFER_get_len(rbuf) - SSL3_RT_HEADER_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_PACKET_LENGTH_TOO_LONG); return OSSL_RECORD_RETURN_FATAL; } } if (!rl->funcs->validate_record_header(rl, thisrr)) { /* RLAYERfatal already called */ return OSSL_RECORD_RETURN_FATAL; } /* now rl->rstate == SSL_ST_READ_BODY */ } /* * rl->rstate == SSL_ST_READ_BODY, get and decode the data. Calculate * how much more data we need to read for the rest of the record */ if (thisrr->rec_version == SSL2_VERSION) { more = thisrr->length + SSL2_RT_HEADER_LENGTH - SSL3_RT_HEADER_LENGTH; } else { more = thisrr->length; } if (more > 0) { /* now rl->packet_length == SSL3_RT_HEADER_LENGTH */ rret = rl->funcs->read_n(rl, more, more, 1, 0, &n); if (rret < OSSL_RECORD_RETURN_SUCCESS) return rret; /* error or non-blocking io */ } /* set state for later operations */ rl->rstate = SSL_ST_READ_HEADER; /* * At this point, rl->packet_length == SSL3_RT_HEADER_LENGTH * + thisrr->length, or rl->packet_length == SSL2_RT_HEADER_LENGTH * + thisrr->length and we have that many bytes in rl->packet */ if (thisrr->rec_version == SSL2_VERSION) thisrr->input = &(rl->packet[SSL2_RT_HEADER_LENGTH]); else thisrr->input = &(rl->packet[SSL3_RT_HEADER_LENGTH]); /* * ok, we can now read from 'rl->packet' data into 'thisrr'. * thisrr->input points at thisrr->length bytes, which need to be copied * into thisrr->data by either the decryption or by the decompression. * When the data is 'copied' into the thisrr->data buffer, * thisrr->input will be updated to point at the new buffer */ /* * We now have - encrypted [ MAC [ compressed [ plain ] ] ] * thisrr->length bytes of encrypted compressed stuff. */ /* decrypt in place in 'thisrr->input' */ thisrr->data = thisrr->input; thisrr->orig_len = thisrr->length; num_recs++; /* we have pulled in a full packet so zero things */ rl->packet_length = 0; rl->is_first_record = 0; } while (num_recs < max_recs && thisrr->type == SSL3_RT_APPLICATION_DATA && RLAYER_USE_EXPLICIT_IV(rl) && rl->enc_ctx != NULL && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx)) & EVP_CIPH_FLAG_PIPELINE) != 0 && tls_record_app_data_waiting(rl)); if (num_recs == 1 && thisrr->type == SSL3_RT_CHANGE_CIPHER_SPEC /* The following can happen in tlsany_meth after HRR */ && rl->version == TLS1_3_VERSION && rl->is_first_handshake) { /* * CCS messages must be exactly 1 byte long, containing the value 0x01 */ if (thisrr->length != 1 || thisrr->data[0] != 0x01) { RLAYERfatal(rl, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_CCS_MESSAGE); return OSSL_RECORD_RETURN_FATAL; } /* * CCS messages are ignored in TLSv1.3. We treat it like an empty * handshake record */ thisrr->type = SSL3_RT_HANDSHAKE; if (++(rl->empty_record_count) > MAX_EMPTY_RECORDS) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_CCS_MESSAGE); return OSSL_RECORD_RETURN_FATAL; } rl->num_recs = 0; rl->curr_rec = 0; rl->num_released = 0; return OSSL_RECORD_RETURN_SUCCESS; } if (rl->md_ctx != NULL) { const EVP_MD *tmpmd = EVP_MD_CTX_get0_md(rl->md_ctx); if (tmpmd != NULL) { imac_size = EVP_MD_get_size(tmpmd); if (!ossl_assert(imac_size >= 0 && imac_size <= EVP_MAX_MD_SIZE)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return OSSL_RECORD_RETURN_FATAL; } mac_size = (size_t)imac_size; } } /* * If in encrypt-then-mac mode calculate mac from encrypted record. All * the details below are public so no timing details can leak. */ if (rl->use_etm && rl->md_ctx != NULL) { unsigned char *mac; for (j = 0; j < num_recs; j++) { thisrr = &rr[j]; if (thisrr->length < mac_size) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); return OSSL_RECORD_RETURN_FATAL; } thisrr->length -= mac_size; mac = thisrr->data + thisrr->length; i = rl->funcs->mac(rl, thisrr, md, 0 /* not send */); if (i == 0 || CRYPTO_memcmp(md, mac, mac_size) != 0) { RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); return OSSL_RECORD_RETURN_FATAL; } } /* * We've handled the mac now - there is no MAC inside the encrypted * record */ mac_size = 0; } if (mac_size > 0) { macbufs = OPENSSL_zalloc(sizeof(*macbufs) * num_recs); if (macbufs == NULL) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB); return OSSL_RECORD_RETURN_FATAL; } } ERR_set_mark(); enc_err = rl->funcs->cipher(rl, rr, num_recs, 0, macbufs, mac_size); /*- * enc_err is: * 0: if the record is publicly invalid, or an internal error, or AEAD * decryption failed, or ETM decryption failed. * 1: Success or MTE decryption failed (MAC will be randomised) */ if (enc_err == 0) { if (rl->alert != SSL_AD_NO_ALERT) { /* RLAYERfatal() already got called */ ERR_clear_last_mark(); goto end; } if (num_recs == 1 && rl->skip_early_data != NULL && rl->skip_early_data(rl->cbarg)) { /* * Valid early_data that we cannot decrypt will fail here. We treat * it like an empty record. */ /* * Remove any errors from the stack. Decryption failures are normal * behaviour. */ ERR_pop_to_mark(); thisrr = &rr[0]; if (!rlayer_early_data_count_ok(rl, thisrr->length, EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) { /* RLAYERfatal() already called */ goto end; } thisrr->length = 0; rl->num_recs = 0; rl->curr_rec = 0; rl->num_released = 0; /* Reset the read sequence */ memset(rl->sequence, 0, sizeof(rl->sequence)); ret = 1; goto end; } ERR_clear_last_mark(); RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); goto end; } else { ERR_clear_last_mark(); } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "dec %lu\n", (unsigned long)rr[0].length); BIO_dump_indent(trc_out, rr[0].data, rr[0].length, 4); } OSSL_TRACE_END(TLS); /* r->length is now the compressed data plus mac */ if (rl->enc_ctx != NULL && !rl->use_etm && EVP_MD_CTX_get0_md(rl->md_ctx) != NULL) { for (j = 0; j < num_recs; j++) { SSL_MAC_BUF *thismb = &macbufs[j]; thisrr = &rr[j]; i = rl->funcs->mac(rl, thisrr, md, 0 /* not send */); if (i == 0 || thismb == NULL || thismb->mac == NULL || CRYPTO_memcmp(md, thismb->mac, (size_t)mac_size) != 0) enc_err = 0; if (thisrr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size) enc_err = 0; #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION if (enc_err == 0 && mac_size > 0 && thismb != NULL && thismb->mac != NULL && (md[0] ^ thismb->mac[0]) != 0xFF) { enc_err = 1; } #endif } } if (enc_err == 0) { if (rl->alert != SSL_AD_NO_ALERT) { /* We already called RLAYERfatal() */ goto end; } /* * A separate 'decryption_failed' alert was introduced with TLS 1.0, * SSL 3.0 only has 'bad_record_mac'. But unless a decryption * failure is directly visible from the ciphertext anyway, we should * not reveal which kind of error occurred -- this might become * visible to an attacker (e.g. via a logfile) */ RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); goto end; } for (j = 0; j < num_recs; j++) { thisrr = &rr[j]; if (!rl->funcs->post_process_record(rl, thisrr)) { /* RLAYERfatal already called */ goto end; } /* * Record overflow checking (e.g. checking if * thisrr->length > SSL3_RT_MAX_PLAIN_LENGTH) is the responsibility of * the post_process_record() function above. However we check here if * the received packet overflows the current Max Fragment Length setting * if there is one. * Note: rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH and KTLS are * mutually exclusive. Also note that with KTLS thisrr->length can * be > SSL3_RT_MAX_PLAIN_LENGTH (and rl->max_frag_len must be ignored) */ if (rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH && thisrr->length > rl->max_frag_len) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); goto end; } thisrr->off = 0; /*- * So at this point the following is true * thisrr->type is the type of record * thisrr->length == number of bytes in record * thisrr->off == offset to first valid byte * thisrr->data == where to take bytes from, increment after use :-). */ /* just read a 0 length packet */ if (thisrr->length == 0) { if (++(rl->empty_record_count) > MAX_EMPTY_RECORDS) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_RECORD_TOO_SMALL); goto end; } } else { rl->empty_record_count = 0; } } if (rl->level == OSSL_RECORD_PROTECTION_LEVEL_EARLY) { thisrr = &rr[0]; if (thisrr->type == SSL3_RT_APPLICATION_DATA && !rlayer_early_data_count_ok(rl, thisrr->length, 0, 0)) { /* RLAYERfatal already called */ goto end; } } rl->num_recs = num_recs; rl->curr_rec = 0; rl->num_released = 0; ret = OSSL_RECORD_RETURN_SUCCESS; end: if (macbufs != NULL) { for (j = 0; j < num_recs; j++) { if (macbufs[j].alloced) OPENSSL_free(macbufs[j].mac); } OPENSSL_free(macbufs); } return ret; } /* Shared by ssl3_meth and tls1_meth */ int tls_default_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { size_t len = SSL3_RT_MAX_ENCRYPTED_LENGTH; if (rec->rec_version != rl->version) { RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); return 0; } #ifndef OPENSSL_NO_COMP /* * If OPENSSL_NO_COMP is defined then SSL3_RT_MAX_ENCRYPTED_LENGTH * does not include the compression overhead anyway. */ if (rl->compctx == NULL) len -= SSL3_RT_MAX_COMPRESSED_OVERHEAD; #endif if (rec->length > len) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_ENCRYPTED_LENGTH_TOO_LONG); return 0; } return 1; } int tls_do_compress(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *wr) { #ifndef OPENSSL_NO_COMP int i; i = COMP_compress_block(rl->compctx, wr->data, (int)(wr->length + SSL3_RT_MAX_COMPRESSED_OVERHEAD), wr->input, (int)wr->length); if (i < 0) return 0; wr->length = i; wr->input = wr->data; return 1; #else return 0; #endif } int tls_do_uncompress(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { #ifndef OPENSSL_NO_COMP int i; if (rec->comp == NULL) { rec->comp = (unsigned char *) OPENSSL_malloc(SSL3_RT_MAX_ENCRYPTED_LENGTH); } if (rec->comp == NULL) return 0; i = COMP_expand_block(rl->compctx, rec->comp, SSL3_RT_MAX_PLAIN_LENGTH, rec->data, (int)rec->length); if (i < 0) return 0; else rec->length = i; rec->data = rec->comp; return 1; #else return 0; #endif } /* Shared by tlsany_meth, ssl3_meth and tls1_meth */ int tls_default_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { if (rl->compctx != NULL) { if (rec->length > SSL3_RT_MAX_COMPRESSED_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_COMPRESSED_LENGTH_TOO_LONG); return 0; } if (!tls_do_uncompress(rl, rec)) { RLAYERfatal(rl, SSL_AD_DECOMPRESSION_FAILURE, SSL_R_BAD_DECOMPRESSION); return 0; } } if (rec->length > SSL3_RT_MAX_PLAIN_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } return 1; } /* Shared by tls13_meth and ktls_meth */ int tls13_common_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { if (rec->type != SSL3_RT_APPLICATION_DATA && rec->type != SSL3_RT_ALERT && rec->type != SSL3_RT_HANDSHAKE) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_RECORD_TYPE); return 0; } if (rl->msg_callback != NULL) rl->msg_callback(0, rl->version, SSL3_RT_INNER_CONTENT_TYPE, &rec->type, 1, rl->cbarg); /* * TLSv1.3 alert and handshake records are required to be non-zero in * length. */ if ((rec->type == SSL3_RT_HANDSHAKE || rec->type == SSL3_RT_ALERT) && rec->length == 0) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_LENGTH); return 0; } return 1; } int tls_read_record(OSSL_RECORD_LAYER *rl, void **rechandle, int *rversion, uint8_t *type, const unsigned char **data, size_t *datalen, uint16_t *epoch, unsigned char *seq_num) { TLS_RL_RECORD *rec; /* * tls_get_more_records() can return success without actually reading * anything useful (i.e. if empty records are read). We loop here until * we have something useful. tls_get_more_records() will eventually fail if * too many sequential empty records are read. */ while (rl->curr_rec >= rl->num_recs) { int ret; if (rl->num_released != rl->num_recs) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_RECORDS_NOT_RELEASED); return OSSL_RECORD_RETURN_FATAL; } ret = rl->funcs->get_more_records(rl); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; } /* * We have now got rl->num_recs records buffered in rl->rrec. rl->curr_rec * points to the next one to read. */ rec = &rl->rrec[rl->curr_rec++]; *rechandle = rec; *rversion = rec->rec_version; *type = rec->type; *data = rec->data + rec->off; *datalen = rec->length; if (rl->isdtls) { *epoch = rec->epoch; memcpy(seq_num, rec->seq_num, sizeof(rec->seq_num)); } return OSSL_RECORD_RETURN_SUCCESS; } int tls_release_record(OSSL_RECORD_LAYER *rl, void *rechandle, size_t length) { TLS_RL_RECORD *rec = &rl->rrec[rl->num_released]; if (!ossl_assert(rl->num_released < rl->curr_rec) || !ossl_assert(rechandle == rec)) { /* Should not happen */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_INVALID_RECORD); return OSSL_RECORD_RETURN_FATAL; } if (rec->length < length) { /* Should not happen */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } if ((rl->options & SSL_OP_CLEANSE_PLAINTEXT) != 0) OPENSSL_cleanse(rec->data + rec->off, length); rec->off += length; rec->length -= length; if (rec->length > 0) return OSSL_RECORD_RETURN_SUCCESS; rl->num_released++; if (rl->curr_rec == rl->num_released && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0 && TLS_BUFFER_get_left(&rl->rbuf) == 0) tls_release_read_buffer(rl); return OSSL_RECORD_RETURN_SUCCESS; } int tls_set_options(OSSL_RECORD_LAYER *rl, const OSSL_PARAM *options) { const OSSL_PARAM *p; p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS); if (p != NULL && !OSSL_PARAM_get_uint64(p, &rl->options)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE); if (p != NULL && !OSSL_PARAM_get_uint32(p, &rl->mode)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } if (rl->direction == OSSL_RECORD_DIRECTION_READ) { p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN); if (p != NULL && !OSSL_PARAM_get_size_t(p, &rl->rbuf.default_len)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } } else { p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING); if (p != NULL && !OSSL_PARAM_get_size_t(p, &rl->block_padding)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } } if (rl->level == OSSL_RECORD_PROTECTION_LEVEL_APPLICATION) { /* * We ignore any read_ahead setting prior to the application protection * level. Otherwise we may read ahead data in a lower protection level * that is destined for a higher protection level. To simplify the logic * we don't support that at this stage. */ p = OSSL_PARAM_locate_const(options, OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD); if (p != NULL && !OSSL_PARAM_get_int(p, &rl->read_ahead)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); return 0; } } return 1; } int tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers, int role, int direction, int level, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp, BIO *prev, BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer, const OSSL_PARAM *settings, const OSSL_PARAM *options, const OSSL_DISPATCH *fns, void *cbarg, OSSL_RECORD_LAYER **retrl) { OSSL_RECORD_LAYER *rl = OPENSSL_zalloc(sizeof(*rl)); const OSSL_PARAM *p; *retrl = NULL; if (rl == NULL) return OSSL_RECORD_RETURN_FATAL; /* * Default the value for max_frag_len. This may be overridden by the * settings */ rl->max_frag_len = SSL3_RT_MAX_PLAIN_LENGTH; /* Loop through all the settings since they must all be understood */ if (settings != NULL) { for (p = settings; p->key != NULL; p++) { if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM) == 0) { if (!OSSL_PARAM_get_int(p, &rl->use_etm)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN) == 0) { if (!OSSL_PARAM_get_uint(p, &rl->max_frag_len)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA) == 0) { if (!OSSL_PARAM_get_uint32(p, &rl->max_early_data)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC) == 0) { if (!OSSL_PARAM_get_int(p, &rl->stream_mac)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else if (strcmp(p->key, OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE) == 0) { if (!OSSL_PARAM_get_int(p, &rl->tlstree)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } } else { ERR_raise(ERR_LIB_SSL, SSL_R_UNKNOWN_MANDATORY_PARAMETER); goto err; } } } rl->libctx = libctx; rl->propq = propq; rl->version = vers; rl->role = role; rl->direction = direction; rl->level = level; rl->taglen = taglen; rl->md = md; rl->alert = SSL_AD_NO_ALERT; rl->rstate = SSL_ST_READ_HEADER; if (level == OSSL_RECORD_PROTECTION_LEVEL_NONE) rl->is_first_record = 1; if (!tls_set1_bio(rl, transport)) goto err; if (prev != NULL && !BIO_up_ref(prev)) goto err; rl->prev = prev; if (next != NULL && !BIO_up_ref(next)) goto err; rl->next = next; rl->cbarg = cbarg; if (fns != NULL) { for (; fns->function_id != 0; fns++) { switch (fns->function_id) { case OSSL_FUNC_RLAYER_SKIP_EARLY_DATA: rl->skip_early_data = OSSL_FUNC_rlayer_skip_early_data(fns); break; case OSSL_FUNC_RLAYER_MSG_CALLBACK: rl->msg_callback = OSSL_FUNC_rlayer_msg_callback(fns); break; case OSSL_FUNC_RLAYER_SECURITY: rl->security = OSSL_FUNC_rlayer_security(fns); break; case OSSL_FUNC_RLAYER_PADDING: rl->padding = OSSL_FUNC_rlayer_padding(fns); default: /* Just ignore anything we don't understand */ break; } } } if (!tls_set_options(rl, options)) { ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER); goto err; } if ((rl->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) == 0 && rl->version <= TLS1_VERSION && !EVP_CIPHER_is_a(ciph, "NULL") && !EVP_CIPHER_is_a(ciph, "RC4")) { /* * Enable vulnerability countermeasure for CBC ciphers with known-IV * problem (http://www.openssl.org/~bodo/tls-cbc.txt) */ rl->need_empty_fragments = 1; } *retrl = rl; return OSSL_RECORD_RETURN_SUCCESS; err: tls_int_free(rl); return OSSL_RECORD_RETURN_FATAL; } static int tls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers, int role, int direction, int level, uint16_t epoch, unsigned char *secret, size_t secretlen, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp, const EVP_MD *kdfdigest, BIO *prev, BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer, const OSSL_PARAM *settings, const OSSL_PARAM *options, const OSSL_DISPATCH *fns, void *cbarg, void *rlarg, OSSL_RECORD_LAYER **retrl) { int ret; ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp, prev, transport, next, local, peer, settings, options, fns, cbarg, retrl); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; switch (vers) { case TLS_ANY_VERSION: (*retrl)->funcs = &tls_any_funcs; break; case TLS1_3_VERSION: (*retrl)->funcs = &tls_1_3_funcs; break; case TLS1_2_VERSION: case TLS1_1_VERSION: case TLS1_VERSION: (*retrl)->funcs = &tls_1_funcs; break; case SSL3_VERSION: (*retrl)->funcs = &ssl_3_0_funcs; break; default: /* Should not happen */ ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); ret = OSSL_RECORD_RETURN_FATAL; goto err; } ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp); err: if (ret != OSSL_RECORD_RETURN_SUCCESS) { tls_int_free(*retrl); *retrl = NULL; } return ret; } static void tls_int_free(OSSL_RECORD_LAYER *rl) { BIO_free(rl->prev); BIO_free(rl->bio); BIO_free(rl->next); ossl_tls_buffer_release(&rl->rbuf); tls_release_write_buffer(rl); EVP_CIPHER_CTX_free(rl->enc_ctx); EVP_MD_CTX_free(rl->md_ctx); #ifndef OPENSSL_NO_COMP COMP_CTX_free(rl->compctx); #endif if (rl->version == SSL3_VERSION) OPENSSL_cleanse(rl->mac_secret, sizeof(rl->mac_secret)); TLS_RL_RECORD_release(rl->rrec, SSL_MAX_PIPELINES); OPENSSL_free(rl); } int tls_free(OSSL_RECORD_LAYER *rl) { TLS_BUFFER *rbuf; size_t left, written; int ret = 1; if (rl == NULL) return 1; rbuf = &rl->rbuf; left = TLS_BUFFER_get_left(rbuf); if (left > 0) { /* * This record layer is closing but we still have data left in our * buffer. It must be destined for the next epoch - so push it there. */ ret = BIO_write_ex(rl->next, rbuf->buf + rbuf->offset, left, &written); } tls_int_free(rl); return ret; } int tls_unprocessed_read_pending(OSSL_RECORD_LAYER *rl) { return TLS_BUFFER_get_left(&rl->rbuf) != 0; } int tls_processed_read_pending(OSSL_RECORD_LAYER *rl) { return rl->curr_rec < rl->num_recs; } size_t tls_app_data_pending(OSSL_RECORD_LAYER *rl) { size_t i; size_t num = 0; for (i = rl->curr_rec; i < rl->num_recs; i++) { if (rl->rrec[i].type != SSL3_RT_APPLICATION_DATA) return num; num += rl->rrec[i].length; } return num; } size_t tls_get_max_records_default(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t maxfrag, size_t *preffrag) { /* * If we have a pipeline capable cipher, and we have been configured to use * it, then return the preferred number of pipelines. */ if (rl->max_pipelines > 0 && rl->enc_ctx != NULL && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx)) & EVP_CIPH_FLAG_PIPELINE) != 0 && RLAYER_USE_EXPLICIT_IV(rl)) { size_t pipes; if (len == 0) return 1; pipes = ((len - 1) / *preffrag) + 1; return (pipes < rl->max_pipelines) ? pipes : rl->max_pipelines; } return 1; } size_t tls_get_max_records(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t maxfrag, size_t *preffrag) { return rl->funcs->get_max_records(rl, type, len, maxfrag, preffrag); } int tls_allocate_write_buffers_default(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, size_t *prefix) { if (!tls_setup_write_buffer(rl, numtempl, 0, 0)) { /* RLAYERfatal() already called */ return 0; } return 1; } int tls_initialise_write_packets_default(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, OSSL_RECORD_TEMPLATE *prefixtempl, WPACKET *pkt, TLS_BUFFER *bufs, size_t *wpinited) { WPACKET *thispkt; size_t j, align; TLS_BUFFER *wb; for (j = 0; j < numtempl; j++) { thispkt = &pkt[j]; wb = &bufs[j]; wb->type = templates[j].type; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (size_t)TLS_BUFFER_get_buf(wb); align += rl->isdtls ? DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH; align = SSL3_ALIGN_PAYLOAD - 1 - ((align - 1) % SSL3_ALIGN_PAYLOAD); #endif TLS_BUFFER_set_offset(wb, align); if (!WPACKET_init_static_len(thispkt, TLS_BUFFER_get_buf(wb), TLS_BUFFER_get_len(wb), 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } (*wpinited)++; if (!WPACKET_allocate_bytes(thispkt, align, NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return 1; } int tls_prepare_record_header_default(OSSL_RECORD_LAYER *rl, WPACKET *thispkt, OSSL_RECORD_TEMPLATE *templ, uint8_t rectype, unsigned char **recdata) { size_t maxcomplen; *recdata = NULL; maxcomplen = templ->buflen; if (rl->compctx != NULL) maxcomplen += SSL3_RT_MAX_COMPRESSED_OVERHEAD; if (!WPACKET_put_bytes_u8(thispkt, rectype) || !WPACKET_put_bytes_u16(thispkt, templ->version) || !WPACKET_start_sub_packet_u16(thispkt) || (rl->eivlen > 0 && !WPACKET_allocate_bytes(thispkt, rl->eivlen, NULL)) || (maxcomplen > 0 && !WPACKET_reserve_bytes(thispkt, maxcomplen, recdata))) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER *rl, size_t mac_size, WPACKET *thispkt, TLS_RL_RECORD *thiswr) { size_t len; unsigned char *recordstart; /* * we should still have the output to thiswr->data and the input from * wr->input. Length should be thiswr->length. thiswr->data still points * in the wb->buf */ if (!rl->use_etm && mac_size != 0) { unsigned char *mac; if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac) || !rl->funcs->mac(rl, thiswr, mac, 1)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } /* * Reserve some bytes for any growth that may occur during encryption. If * we are adding the MAC independently of the cipher algorithm, then the * max encrypted overhead does not need to include an allocation for that * MAC */ if (!WPACKET_reserve_bytes(thispkt, SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD - mac_size, NULL) /* * We also need next the amount of bytes written to this * sub-packet */ || !WPACKET_get_length(thispkt, &len)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* Get a pointer to the start of this record excluding header */ recordstart = WPACKET_get_curr(thispkt) - len; TLS_RL_RECORD_set_data(thiswr, recordstart); TLS_RL_RECORD_reset_input(thiswr); TLS_RL_RECORD_set_length(thiswr, len); return 1; } int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl, size_t mac_size, OSSL_RECORD_TEMPLATE *thistempl, WPACKET *thispkt, TLS_RL_RECORD *thiswr) { size_t origlen, len; size_t headerlen = rl->isdtls ? DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH; /* Allocate bytes for the encryption overhead */ if (!WPACKET_get_length(thispkt, &origlen) /* Check we allowed enough room for the encryption growth */ || !ossl_assert(origlen + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD - mac_size >= thiswr->length) /* Encryption should never shrink the data! */ || origlen > thiswr->length || (thiswr->length > origlen && !WPACKET_allocate_bytes(thispkt, thiswr->length - origlen, NULL))) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (rl->use_etm && mac_size != 0) { unsigned char *mac; if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac) || !rl->funcs->mac(rl, thiswr, mac, 1)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } TLS_RL_RECORD_add_length(thiswr, mac_size); } if (!WPACKET_get_length(thispkt, &len) || !WPACKET_close(thispkt)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (rl->msg_callback != NULL) { unsigned char *recordstart; recordstart = WPACKET_get_curr(thispkt) - len - headerlen; rl->msg_callback(1, thiswr->rec_version, SSL3_RT_HEADER, recordstart, headerlen, rl->cbarg); if (rl->version == TLS1_3_VERSION && rl->enc_ctx != NULL) { unsigned char ctype = thistempl->type; rl->msg_callback(1, thiswr->rec_version, SSL3_RT_INNER_CONTENT_TYPE, &ctype, 1, rl->cbarg); } } if (!WPACKET_finish(thispkt)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } TLS_RL_RECORD_add_length(thiswr, headerlen); return 1; } int tls_write_records_default(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl) { WPACKET pkt[SSL_MAX_PIPELINES + 1]; TLS_RL_RECORD wr[SSL_MAX_PIPELINES + 1]; WPACKET *thispkt; TLS_RL_RECORD *thiswr; int mac_size = 0, ret = 0; size_t wpinited = 0; size_t j, prefix = 0; OSSL_RECORD_TEMPLATE prefixtempl; OSSL_RECORD_TEMPLATE *thistempl; if (rl->md_ctx != NULL && EVP_MD_CTX_get0_md(rl->md_ctx) != NULL) { mac_size = EVP_MD_CTX_get_size(rl->md_ctx); if (mac_size < 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } } if (!rl->funcs->allocate_write_buffers(rl, templates, numtempl, &prefix)) { /* RLAYERfatal() already called */ goto err; } if (!rl->funcs->initialise_write_packets(rl, templates, numtempl, &prefixtempl, pkt, rl->wbuf, &wpinited)) { /* RLAYERfatal() already called */ goto err; } /* Clear our TLS_RL_RECORD structures */ memset(wr, 0, sizeof(wr)); for (j = 0; j < numtempl + prefix; j++) { unsigned char *compressdata = NULL; uint8_t rectype; thispkt = &pkt[j]; thiswr = &wr[j]; thistempl = (j < prefix) ? &prefixtempl : &templates[j - prefix]; /* * Default to the record type as specified in the template unless the * protocol implementation says differently. */ if (rl->funcs->get_record_type != NULL) rectype = rl->funcs->get_record_type(rl, thistempl); else rectype = thistempl->type; TLS_RL_RECORD_set_type(thiswr, rectype); TLS_RL_RECORD_set_rec_version(thiswr, thistempl->version); if (!rl->funcs->prepare_record_header(rl, thispkt, thistempl, rectype, &compressdata)) { /* RLAYERfatal() already called */ goto err; } /* lets setup the record stuff. */ TLS_RL_RECORD_set_data(thiswr, compressdata); TLS_RL_RECORD_set_length(thiswr, thistempl->buflen); TLS_RL_RECORD_set_input(thiswr, (unsigned char *)thistempl->buf); /* * we now 'read' from thiswr->input, thiswr->length bytes into * thiswr->data */ /* first we compress */ if (rl->compctx != NULL) { if (!tls_do_compress(rl, thiswr) || !WPACKET_allocate_bytes(thispkt, thiswr->length, NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_COMPRESSION_FAILURE); goto err; } } else if (compressdata != NULL) { if (!WPACKET_memcpy(thispkt, thiswr->input, thiswr->length)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } TLS_RL_RECORD_reset_input(&wr[j]); } if (rl->funcs->add_record_padding != NULL && !rl->funcs->add_record_padding(rl, thistempl, thispkt, thiswr)) { /* RLAYERfatal() already called */ goto err; } if (!rl->funcs->prepare_for_encryption(rl, mac_size, thispkt, thiswr)) { /* RLAYERfatal() already called */ goto err; } } if (prefix) { if (rl->funcs->cipher(rl, wr, 1, 1, NULL, mac_size) < 1) { if (rl->alert == SSL_AD_NO_ALERT) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); } goto err; } } if (rl->funcs->cipher(rl, wr + prefix, numtempl, 1, NULL, mac_size) < 1) { if (rl->alert == SSL_AD_NO_ALERT) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); } goto err; } for (j = 0; j < numtempl + prefix; j++) { thispkt = &pkt[j]; thiswr = &wr[j]; thistempl = (j < prefix) ? &prefixtempl : &templates[j - prefix]; if (!rl->funcs->post_encryption_processing(rl, mac_size, thistempl, thispkt, thiswr)) { /* RLAYERfatal() already called */ goto err; } /* now let's set up wb */ TLS_BUFFER_set_left(&rl->wbuf[j], TLS_RL_RECORD_get_length(thiswr)); } ret = 1; err: for (j = 0; j < wpinited; j++) WPACKET_cleanup(&pkt[j]); return ret; } int tls_write_records(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl) { /* Check we don't have pending data waiting to write */ if (!ossl_assert(rl->nextwbuf >= rl->numwpipes || TLS_BUFFER_get_left(&rl->wbuf[rl->nextwbuf]) == 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return OSSL_RECORD_RETURN_FATAL; } if (!rl->funcs->write_records(rl, templates, numtempl)) { /* RLAYERfatal already called */ return OSSL_RECORD_RETURN_FATAL; } rl->nextwbuf = 0; /* we now just need to write the buffers */ return tls_retry_write_records(rl); } int tls_retry_write_records(OSSL_RECORD_LAYER *rl) { int i, ret; TLS_BUFFER *thiswb; size_t tmpwrit = 0; if (rl->nextwbuf >= rl->numwpipes) return OSSL_RECORD_RETURN_SUCCESS; for (;;) { thiswb = &rl->wbuf[rl->nextwbuf]; clear_sys_error(); if (rl->bio != NULL) { if (rl->funcs->prepare_write_bio != NULL) { ret = rl->funcs->prepare_write_bio(rl, thiswb->type); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; } i = BIO_write(rl->bio, (char *) &(TLS_BUFFER_get_buf(thiswb) [TLS_BUFFER_get_offset(thiswb)]), (unsigned int)TLS_BUFFER_get_left(thiswb)); if (i >= 0) { tmpwrit = i; if (i == 0 && BIO_should_retry(rl->bio)) ret = OSSL_RECORD_RETURN_RETRY; else ret = OSSL_RECORD_RETURN_SUCCESS; } else { if (BIO_should_retry(rl->bio)) ret = OSSL_RECORD_RETURN_RETRY; else ret = OSSL_RECORD_RETURN_FATAL; } } else { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_BIO_NOT_SET); ret = OSSL_RECORD_RETURN_FATAL; i = -1; } /* * When an empty fragment is sent on a connection using KTLS, * it is sent as a write of zero bytes. If this zero byte * write succeeds, i will be 0 rather than a non-zero value. * Treat i == 0 as success rather than an error for zero byte * writes to permit this case. */ if (i >= 0 && tmpwrit == TLS_BUFFER_get_left(thiswb)) { TLS_BUFFER_set_left(thiswb, 0); TLS_BUFFER_add_offset(thiswb, tmpwrit); if (++(rl->nextwbuf) < rl->numwpipes) continue; if (rl->nextwbuf == rl->numwpipes && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0) tls_release_write_buffer(rl); return OSSL_RECORD_RETURN_SUCCESS; } else if (i <= 0) { if (rl->isdtls) { /* * For DTLS, just drop it. That's kind of the whole point in * using a datagram service */ TLS_BUFFER_set_left(thiswb, 0); if (++(rl->nextwbuf) == rl->numwpipes && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0) tls_release_write_buffer(rl); } return ret; } TLS_BUFFER_add_offset(thiswb, tmpwrit); TLS_BUFFER_sub_left(thiswb, tmpwrit); } } int tls_get_alert_code(OSSL_RECORD_LAYER *rl) { return rl->alert; } int tls_set1_bio(OSSL_RECORD_LAYER *rl, BIO *bio) { if (bio != NULL && !BIO_up_ref(bio)) return 0; BIO_free(rl->bio); rl->bio = bio; return 1; } /* Shared by most methods except tlsany_meth */ int tls_default_set_protocol_version(OSSL_RECORD_LAYER *rl, int version) { if (rl->version != version) return 0; return 1; } int tls_set_protocol_version(OSSL_RECORD_LAYER *rl, int version) { return rl->funcs->set_protocol_version(rl, version); } void tls_set_plain_alerts(OSSL_RECORD_LAYER *rl, int allow) { rl->allow_plain_alerts = allow; } void tls_set_first_handshake(OSSL_RECORD_LAYER *rl, int first) { rl->is_first_handshake = first; } void tls_set_max_pipelines(OSSL_RECORD_LAYER *rl, size_t max_pipelines) { rl->max_pipelines = max_pipelines; if (max_pipelines > 1) rl->read_ahead = 1; } void tls_get_state(OSSL_RECORD_LAYER *rl, const char **shortstr, const char **longstr) { const char *shrt, *lng; switch (rl->rstate) { case SSL_ST_READ_HEADER: shrt = "RH"; lng = "read header"; break; case SSL_ST_READ_BODY: shrt = "RB"; lng = "read body"; break; default: shrt = lng = "unknown"; break; } if (shortstr != NULL) *shortstr = shrt; if (longstr != NULL) *longstr = lng; } const COMP_METHOD *tls_get_compression(OSSL_RECORD_LAYER *rl) { #ifndef OPENSSL_NO_COMP return (rl->compctx == NULL) ? NULL : COMP_CTX_get_method(rl->compctx); #else return NULL; #endif } void tls_set_max_frag_len(OSSL_RECORD_LAYER *rl, size_t max_frag_len) { rl->max_frag_len = max_frag_len; /* * We don't need to adjust buffer sizes. Write buffer sizes are * automatically checked anyway. We should only be changing the read buffer * size during the handshake, so we will create a new buffer when we create * the new record layer. We can't change the existing buffer because it may * already have data in it. */ } int tls_increment_sequence_ctr(OSSL_RECORD_LAYER *rl) { int i; /* Increment the sequence counter */ for (i = SEQ_NUM_SIZE; i > 0; i--) { ++(rl->sequence[i - 1]); if (rl->sequence[i - 1] != 0) break; } if (i == 0) { /* Sequence has wrapped */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_SEQUENCE_CTR_WRAPPED); return 0; } return 1; } int tls_alloc_buffers(OSSL_RECORD_LAYER *rl) { if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) { /* If we have a pending write then buffers are already allocated */ if (rl->nextwbuf < rl->numwpipes) return 1; /* * We assume 1 pipe with default sized buffer. If what we need ends up * being a different size to that then it will be reallocated on demand. * If we need more than 1 pipe then that will also be allocated on * demand */ if (!tls_setup_write_buffer(rl, 1, 0, 0)) return 0; /* * Normally when we allocate write buffers we immediately write * something into it. In this case we're not doing that so mark the * buffer as empty. */ TLS_BUFFER_set_left(&rl->wbuf[0], 0); return 1; } /* Read direction */ /* If we have pending data to be read then buffers are already allocated */ if (rl->curr_rec < rl->num_recs || TLS_BUFFER_get_left(&rl->rbuf) != 0) return 1; return tls_setup_read_buffer(rl); } int tls_free_buffers(OSSL_RECORD_LAYER *rl) { if (rl->direction == OSSL_RECORD_DIRECTION_WRITE) { if (rl->nextwbuf < rl->numwpipes) { /* * We may have pending data. If we've just got one empty buffer * allocated then it has probably just been alloc'd via * tls_alloc_buffers, and it is fine to free it. Otherwise this * looks like real pending data and it is an error. */ if (rl->nextwbuf != 0 || rl->numwpipes != 1 || TLS_BUFFER_get_left(&rl->wbuf[0]) != 0) return 0; } tls_release_write_buffer(rl); return 1; } /* Read direction */ /* If we have pending data to be read then fail */ if (rl->curr_rec < rl->num_recs || TLS_BUFFER_get_left(&rl->rbuf) != 0) return 0; return tls_release_read_buffer(rl); } const OSSL_RECORD_METHOD ossl_tls_record_method = { tls_new_record_layer, tls_free, tls_unprocessed_read_pending, tls_processed_read_pending, tls_app_data_pending, tls_get_max_records, tls_write_records, tls_retry_write_records, tls_read_record, tls_release_record, tls_get_alert_code, tls_set1_bio, tls_set_protocol_version, tls_set_plain_alerts, tls_set_first_handshake, tls_set_max_pipelines, NULL, tls_get_state, tls_set_options, tls_get_compression, tls_set_max_frag_len, NULL, tls_increment_sequence_ctr, tls_alloc_buffers, tls_free_buffers };

./openssl/ssl/record/methods/ssl3_cbc.c

/* * Copyright 2012-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ /* * This file has no dependencies on the rest of libssl because it is shared * with the providers. It contains functions for low level MAC calculations. * Responsibility for this lies with the HMAC implementation in the * providers. However there are legacy code paths in libssl which also need to * do this. In time those legacy code paths can be removed and this file can be * moved out of libssl. */ /* * MD5 and SHA-1 low level APIs are deprecated for public use, but still ok for * internal use. */ #include "internal/deprecated.h" #include <openssl/evp.h> #ifndef FIPS_MODULE # include <openssl/md5.h> #endif #include <openssl/sha.h> #include "internal/ssl3_cbc.h" #include "internal/constant_time.h" #include "internal/cryptlib.h" /* * MAX_HASH_BIT_COUNT_BYTES is the maximum number of bytes in the hash's * length field. (SHA-384/512 have 128-bit length.) */ #define MAX_HASH_BIT_COUNT_BYTES 16 /* * MAX_HASH_BLOCK_SIZE is the maximum hash block size that we'll support. * Currently SHA-384/512 has a 128-byte block size and that's the largest * supported by TLS.) */ #define MAX_HASH_BLOCK_SIZE 128 #ifndef FIPS_MODULE /* * u32toLE serializes an unsigned, 32-bit number (n) as four bytes at (p) in * little-endian order. The value of p is advanced by four. */ # define u32toLE(n, p) \ (*((p)++) = (unsigned char)(n ), \ *((p)++) = (unsigned char)(n >> 8), \ *((p)++) = (unsigned char)(n >> 16), \ *((p)++) = (unsigned char)(n >> 24)) /* * These functions serialize the state of a hash and thus perform the * standard "final" operation without adding the padding and length that such * a function typically does. */ static void tls1_md5_final_raw(void *ctx, unsigned char *md_out) { MD5_CTX *md5 = ctx; u32toLE(md5->A, md_out); u32toLE(md5->B, md_out); u32toLE(md5->C, md_out); u32toLE(md5->D, md_out); } #endif /* FIPS_MODULE */ static void tls1_sha1_final_raw(void *ctx, unsigned char *md_out) { SHA_CTX *sha1 = ctx; l2n(sha1->h0, md_out); l2n(sha1->h1, md_out); l2n(sha1->h2, md_out); l2n(sha1->h3, md_out); l2n(sha1->h4, md_out); } static void tls1_sha256_final_raw(void *ctx, unsigned char *md_out) { SHA256_CTX *sha256 = ctx; unsigned i; for (i = 0; i < 8; i++) l2n(sha256->h[i], md_out); } static void tls1_sha512_final_raw(void *ctx, unsigned char *md_out) { SHA512_CTX *sha512 = ctx; unsigned i; for (i = 0; i < 8; i++) l2n8(sha512->h[i], md_out); } #undef LARGEST_DIGEST_CTX #define LARGEST_DIGEST_CTX SHA512_CTX /*- * ssl3_cbc_digest_record computes the MAC of a decrypted, padded SSLv3/TLS * record. * * ctx: the EVP_MD_CTX from which we take the hash function. * ssl3_cbc_record_digest_supported must return true for this EVP_MD_CTX. * md_out: the digest output. At most EVP_MAX_MD_SIZE bytes will be written. * md_out_size: if non-NULL, the number of output bytes is written here. * header: the 13-byte, TLS record header. * data: the record data itself, less any preceding explicit IV. * data_size: the secret, reported length of the data once the MAC and padding * has been removed. * data_plus_mac_plus_padding_size: the public length of the whole * record, including MAC and padding. * is_sslv3: non-zero if we are to use SSLv3. Otherwise, TLS. * * On entry: we know that data is data_plus_mac_plus_padding_size in length * Returns 1 on success or 0 on error */ int ssl3_cbc_digest_record(const EVP_MD *md, unsigned char *md_out, size_t *md_out_size, const unsigned char *header, const unsigned char *data, size_t data_size, size_t data_plus_mac_plus_padding_size, const unsigned char *mac_secret, size_t mac_secret_length, char is_sslv3) { union { OSSL_UNION_ALIGN; unsigned char c[sizeof(LARGEST_DIGEST_CTX)]; } md_state; void (*md_final_raw) (void *ctx, unsigned char *md_out); void (*md_transform) (void *ctx, const unsigned char *block); size_t md_size, md_block_size = 64; size_t sslv3_pad_length = 40, header_length, variance_blocks, len, max_mac_bytes, num_blocks, num_starting_blocks, k, mac_end_offset, c, index_a, index_b; size_t bits; /* at most 18 bits */ unsigned char length_bytes[MAX_HASH_BIT_COUNT_BYTES]; /* hmac_pad is the masked HMAC key. */ unsigned char hmac_pad[MAX_HASH_BLOCK_SIZE]; unsigned char first_block[MAX_HASH_BLOCK_SIZE]; unsigned char mac_out[EVP_MAX_MD_SIZE]; size_t i, j; unsigned md_out_size_u; EVP_MD_CTX *md_ctx = NULL; /* * mdLengthSize is the number of bytes in the length field that * terminates * the hash. */ size_t md_length_size = 8; char length_is_big_endian = 1; int ret = 0; /* * This is a, hopefully redundant, check that allows us to forget about * many possible overflows later in this function. */ if (!ossl_assert(data_plus_mac_plus_padding_size < 1024 * 1024)) return 0; if (EVP_MD_is_a(md, "MD5")) { #ifdef FIPS_MODULE return 0; #else if (MD5_Init((MD5_CTX *)md_state.c) <= 0) return 0; md_final_raw = tls1_md5_final_raw; md_transform = (void (*)(void *ctx, const unsigned char *block))MD5_Transform; md_size = 16; sslv3_pad_length = 48; length_is_big_endian = 0; #endif } else if (EVP_MD_is_a(md, "SHA1")) { if (SHA1_Init((SHA_CTX *)md_state.c) <= 0) return 0; md_final_raw = tls1_sha1_final_raw; md_transform = (void (*)(void *ctx, const unsigned char *block))SHA1_Transform; md_size = 20; } else if (EVP_MD_is_a(md, "SHA2-224")) { if (SHA224_Init((SHA256_CTX *)md_state.c) <= 0) return 0; md_final_raw = tls1_sha256_final_raw; md_transform = (void (*)(void *ctx, const unsigned char *block))SHA256_Transform; md_size = 224 / 8; } else if (EVP_MD_is_a(md, "SHA2-256")) { if (SHA256_Init((SHA256_CTX *)md_state.c) <= 0) return 0; md_final_raw = tls1_sha256_final_raw; md_transform = (void (*)(void *ctx, const unsigned char *block))SHA256_Transform; md_size = 32; } else if (EVP_MD_is_a(md, "SHA2-384")) { if (SHA384_Init((SHA512_CTX *)md_state.c) <= 0) return 0; md_final_raw = tls1_sha512_final_raw; md_transform = (void (*)(void *ctx, const unsigned char *block))SHA512_Transform; md_size = 384 / 8; md_block_size = 128; md_length_size = 16; } else if (EVP_MD_is_a(md, "SHA2-512")) { if (SHA512_Init((SHA512_CTX *)md_state.c) <= 0) return 0; md_final_raw = tls1_sha512_final_raw; md_transform = (void (*)(void *ctx, const unsigned char *block))SHA512_Transform; md_size = 64; md_block_size = 128; md_length_size = 16; } else { /* * ssl3_cbc_record_digest_supported should have been called first to * check that the hash function is supported. */ if (md_out_size != NULL) *md_out_size = 0; return ossl_assert(0); } if (!ossl_assert(md_length_size <= MAX_HASH_BIT_COUNT_BYTES) || !ossl_assert(md_block_size <= MAX_HASH_BLOCK_SIZE) || !ossl_assert(md_size <= EVP_MAX_MD_SIZE)) return 0; header_length = 13; if (is_sslv3) { header_length = mac_secret_length + sslv3_pad_length + 8 /* sequence number */ + 1 /* record type */ + 2; /* record length */ } /* * variance_blocks is the number of blocks of the hash that we have to * calculate in constant time because they could be altered by the * padding value. In SSLv3, the padding must be minimal so the end of * the plaintext varies by, at most, 15+20 = 35 bytes. (We conservatively * assume that the MAC size varies from 0..20 bytes.) In case the 9 bytes * of hash termination (0x80 + 64-bit length) don't fit in the final * block, we say that the final two blocks can vary based on the padding. * TLSv1 has MACs up to 48 bytes long (SHA-384) and the padding is not * required to be minimal. Therefore we say that the final |variance_blocks| * blocks can * vary based on the padding. Later in the function, if the message is * short and there obviously cannot be this many blocks then * variance_blocks can be reduced. */ variance_blocks = is_sslv3 ? 2 : (((255 + 1 + md_size + md_block_size - 1) / md_block_size) + 1); /* * From now on we're dealing with the MAC, which conceptually has 13 * bytes of `header' before the start of the data (TLS) or 71/75 bytes * (SSLv3) */ len = data_plus_mac_plus_padding_size + header_length; /* * max_mac_bytes contains the maximum bytes of bytes in the MAC, * including * |header|, assuming that there's no padding. */ max_mac_bytes = len - md_size - 1; /* num_blocks is the maximum number of hash blocks. */ num_blocks = (max_mac_bytes + 1 + md_length_size + md_block_size - 1) / md_block_size; /* * In order to calculate the MAC in constant time we have to handle the * final blocks specially because the padding value could cause the end * to appear somewhere in the final |variance_blocks| blocks and we can't * leak where. However, |num_starting_blocks| worth of data can be hashed * right away because no padding value can affect whether they are * plaintext. */ num_starting_blocks = 0; /* * k is the starting byte offset into the conceptual header||data where * we start processing. */ k = 0; /* * mac_end_offset is the index just past the end of the data to be MACed. */ mac_end_offset = data_size + header_length; /* * c is the index of the 0x80 byte in the final hash block that contains * application data. */ c = mac_end_offset % md_block_size; /* * index_a is the hash block number that contains the 0x80 terminating * value. */ index_a = mac_end_offset / md_block_size; /* * index_b is the hash block number that contains the 64-bit hash length, * in bits. */ index_b = (mac_end_offset + md_length_size) / md_block_size; /* * bits is the hash-length in bits. It includes the additional hash block * for the masked HMAC key, or whole of |header| in the case of SSLv3. */ /* * For SSLv3, if we're going to have any starting blocks then we need at * least two because the header is larger than a single block. */ if (num_blocks > variance_blocks + (is_sslv3 ? 1 : 0)) { num_starting_blocks = num_blocks - variance_blocks; k = md_block_size * num_starting_blocks; } bits = 8 * mac_end_offset; if (!is_sslv3) { /* * Compute the initial HMAC block. For SSLv3, the padding and secret * bytes are included in |header| because they take more than a * single block. */ bits += 8 * md_block_size; memset(hmac_pad, 0, md_block_size); if (!ossl_assert(mac_secret_length <= sizeof(hmac_pad))) return 0; memcpy(hmac_pad, mac_secret, mac_secret_length); for (i = 0; i < md_block_size; i++) hmac_pad[i] ^= 0x36; md_transform(md_state.c, hmac_pad); } if (length_is_big_endian) { memset(length_bytes, 0, md_length_size - 4); length_bytes[md_length_size - 4] = (unsigned char)(bits >> 24); length_bytes[md_length_size - 3] = (unsigned char)(bits >> 16); length_bytes[md_length_size - 2] = (unsigned char)(bits >> 8); length_bytes[md_length_size - 1] = (unsigned char)bits; } else { memset(length_bytes, 0, md_length_size); length_bytes[md_length_size - 5] = (unsigned char)(bits >> 24); length_bytes[md_length_size - 6] = (unsigned char)(bits >> 16); length_bytes[md_length_size - 7] = (unsigned char)(bits >> 8); length_bytes[md_length_size - 8] = (unsigned char)bits; } if (k > 0) { if (is_sslv3) { size_t overhang; /* * The SSLv3 header is larger than a single block. overhang is * the number of bytes beyond a single block that the header * consumes: either 7 bytes (SHA1) or 11 bytes (MD5). There are no * ciphersuites in SSLv3 that are not SHA1 or MD5 based and * therefore we can be confident that the header_length will be * greater than |md_block_size|. However we add a sanity check just * in case */ if (header_length <= md_block_size) { /* Should never happen */ return 0; } overhang = header_length - md_block_size; md_transform(md_state.c, header); memcpy(first_block, header + md_block_size, overhang); memcpy(first_block + overhang, data, md_block_size - overhang); md_transform(md_state.c, first_block); for (i = 1; i < k / md_block_size - 1; i++) md_transform(md_state.c, data + md_block_size * i - overhang); } else { /* k is a multiple of md_block_size. */ memcpy(first_block, header, 13); memcpy(first_block + 13, data, md_block_size - 13); md_transform(md_state.c, first_block); for (i = 1; i < k / md_block_size; i++) md_transform(md_state.c, data + md_block_size * i - 13); } } memset(mac_out, 0, sizeof(mac_out)); /* * We now process the final hash blocks. For each block, we construct it * in constant time. If the |i==index_a| then we'll include the 0x80 * bytes and zero pad etc. For each block we selectively copy it, in * constant time, to |mac_out|. */ for (i = num_starting_blocks; i <= num_starting_blocks + variance_blocks; i++) { unsigned char block[MAX_HASH_BLOCK_SIZE]; unsigned char is_block_a = constant_time_eq_8_s(i, index_a); unsigned char is_block_b = constant_time_eq_8_s(i, index_b); for (j = 0; j < md_block_size; j++) { unsigned char b = 0, is_past_c, is_past_cp1; if (k < header_length) b = header[k]; else if (k < data_plus_mac_plus_padding_size + header_length) b = data[k - header_length]; k++; is_past_c = is_block_a & constant_time_ge_8_s(j, c); is_past_cp1 = is_block_a & constant_time_ge_8_s(j, c + 1); /* * If this is the block containing the end of the application * data, and we are at the offset for the 0x80 value, then * overwrite b with 0x80. */ b = constant_time_select_8(is_past_c, 0x80, b); /* * If this block contains the end of the application data * and we're past the 0x80 value then just write zero. */ b = b & ~is_past_cp1; /* * If this is index_b (the final block), but not index_a (the end * of the data), then the 64-bit length didn't fit into index_a * and we're having to add an extra block of zeros. */ b &= ~is_block_b | is_block_a; /* * The final bytes of one of the blocks contains the length. */ if (j >= md_block_size - md_length_size) { /* If this is index_b, write a length byte. */ b = constant_time_select_8(is_block_b, length_bytes[j - (md_block_size - md_length_size)], b); } block[j] = b; } md_transform(md_state.c, block); md_final_raw(md_state.c, block); /* If this is index_b, copy the hash value to |mac_out|. */ for (j = 0; j < md_size; j++) mac_out[j] |= block[j] & is_block_b; } md_ctx = EVP_MD_CTX_new(); if (md_ctx == NULL) goto err; if (EVP_DigestInit_ex(md_ctx, md, NULL /* engine */) <= 0) goto err; if (is_sslv3) { /* We repurpose |hmac_pad| to contain the SSLv3 pad2 block. */ memset(hmac_pad, 0x5c, sslv3_pad_length); if (EVP_DigestUpdate(md_ctx, mac_secret, mac_secret_length) <= 0 || EVP_DigestUpdate(md_ctx, hmac_pad, sslv3_pad_length) <= 0 || EVP_DigestUpdate(md_ctx, mac_out, md_size) <= 0) goto err; } else { /* Complete the HMAC in the standard manner. */ for (i = 0; i < md_block_size; i++) hmac_pad[i] ^= 0x6a; if (EVP_DigestUpdate(md_ctx, hmac_pad, md_block_size) <= 0 || EVP_DigestUpdate(md_ctx, mac_out, md_size) <= 0) goto err; } ret = EVP_DigestFinal(md_ctx, md_out, &md_out_size_u); if (ret && md_out_size) *md_out_size = md_out_size_u; ret = 1; err: EVP_MD_CTX_free(md_ctx); return ret; }

./openssl/ssl/record/methods/tlsany_meth.c

/* * Copyright 2022 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/evp.h> #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" #define MIN_SSL2_RECORD_LEN 9 static int tls_any_set_crypto_state(OSSL_RECORD_LAYER *rl, int level, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp) { if (level != OSSL_RECORD_PROTECTION_LEVEL_NONE) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } /* No crypto protection at the "NONE" level so nothing to be done */ return OSSL_RECORD_RETURN_SUCCESS; } static int tls_any_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs, size_t n_recs, int sending, SSL_MAC_BUF *macs, size_t macsize) { return 1; } static int tls_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { if (rec->rec_version == SSL2_VERSION) { /* SSLv2 format ClientHello */ if (!ossl_assert(rl->version == TLS_ANY_VERSION)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (rec->length < MIN_SSL2_RECORD_LEN) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); return 0; } } else { if (rl->version == TLS_ANY_VERSION) { if ((rec->rec_version >> 8) != SSL3_VERSION_MAJOR) { if (rl->is_first_record) { unsigned char *p; /* * Go back to start of packet, look at the five bytes that * we have. */ p = rl->packet; if (HAS_PREFIX((char *)p, "GET ") || HAS_PREFIX((char *)p, "POST ") || HAS_PREFIX((char *)p, "HEAD ") || HAS_PREFIX((char *)p, "PUT ")) { RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_HTTP_REQUEST); return 0; } else if (HAS_PREFIX((char *)p, "CONNE")) { RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_HTTPS_PROXY_REQUEST); return 0; } /* Doesn't look like TLS - don't send an alert */ RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_WRONG_VERSION_NUMBER); return 0; } else { RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); return 0; } } } else if (rl->version == TLS1_3_VERSION) { /* * In this case we know we are going to negotiate TLSv1.3, but we've * had an HRR, so we haven't actually done so yet. In TLSv1.3 we * must ignore the legacy record version in plaintext records. */ } else if (rec->rec_version != rl->version) { if ((rl->version & 0xFF00) == (rec->rec_version & 0xFF00)) { if (rec->type == SSL3_RT_ALERT) { /* * The record is using an incorrect version number, * but what we've got appears to be an alert. We * haven't read the body yet to check whether its a * fatal or not - but chances are it is. We probably * shouldn't send a fatal alert back. We'll just * end. */ RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_WRONG_VERSION_NUMBER); return 0; } /* Send back error using their minor version number */ rl->version = (unsigned short)rec->rec_version; } RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_VERSION_NUMBER); return 0; } } if (rec->length > SSL3_RT_MAX_PLAIN_LENGTH) { /* * We use SSL_R_DATA_LENGTH_TOO_LONG instead of * SSL_R_ENCRYPTED_LENGTH_TOO_LONG here because we are the "any" method * and we know that we are dealing with plaintext data */ RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } return 1; } static int tls_any_set_protocol_version(OSSL_RECORD_LAYER *rl, int vers) { if (rl->version != TLS_ANY_VERSION && rl->version != vers) return 0; rl->version = vers; return 1; } static int tls_any_prepare_for_encryption(OSSL_RECORD_LAYER *rl, size_t mac_size, WPACKET *thispkt, TLS_RL_RECORD *thiswr) { /* No encryption, so nothing to do */ return 1; } struct record_functions_st tls_any_funcs = { tls_any_set_crypto_state, tls_any_cipher, NULL, tls_any_set_protocol_version, tls_default_read_n, tls_get_more_records, tls_validate_record_header, tls_default_post_process_record, tls_get_max_records_default, tls_write_records_default, tls_allocate_write_buffers_default, tls_initialise_write_packets_default, NULL, tls_prepare_record_header_default, NULL, tls_any_prepare_for_encryption, tls_post_encryption_processing_default, NULL }; static int dtls_any_set_protocol_version(OSSL_RECORD_LAYER *rl, int vers) { if (rl->version != DTLS_ANY_VERSION && rl->version != vers) return 0; rl->version = vers; return 1; } struct record_functions_st dtls_any_funcs = { tls_any_set_crypto_state, tls_any_cipher, NULL, dtls_any_set_protocol_version, tls_default_read_n, dtls_get_more_records, NULL, NULL, NULL, tls_write_records_default, tls_allocate_write_buffers_default, tls_initialise_write_packets_default, NULL, dtls_prepare_record_header, NULL, tls_prepare_for_encryption_default, dtls_post_encryption_processing, NULL };

./openssl/ssl/record/methods/tls13_meth.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/evp.h> #include <openssl/core_names.h> #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" static int tls13_set_crypto_state(OSSL_RECORD_LAYER *rl, int level, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp) { EVP_CIPHER_CTX *ciph_ctx; int mode; int enc = (rl->direction == OSSL_RECORD_DIRECTION_WRITE) ? 1 : 0; if (ivlen > sizeof(rl->iv)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } memcpy(rl->iv, iv, ivlen); ciph_ctx = rl->enc_ctx = EVP_CIPHER_CTX_new(); if (ciph_ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } mode = EVP_CIPHER_get_mode(ciph); if (EVP_CipherInit_ex(ciph_ctx, ciph, NULL, NULL, NULL, enc) <= 0 || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_IVLEN, ivlen, NULL) <= 0 || (mode == EVP_CIPH_CCM_MODE && EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_TAG, taglen, NULL) <= 0) || EVP_CipherInit_ex(ciph_ctx, NULL, NULL, key, NULL, enc) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } return OSSL_RECORD_RETURN_SUCCESS; } static int tls13_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs, size_t n_recs, int sending, SSL_MAC_BUF *mac, size_t macsize) { EVP_CIPHER_CTX *ctx; unsigned char iv[EVP_MAX_IV_LENGTH], recheader[SSL3_RT_HEADER_LENGTH]; size_t ivlen, offset, loop, hdrlen; unsigned char *staticiv; unsigned char *seq = rl->sequence; int lenu, lenf; TLS_RL_RECORD *rec = &recs[0]; WPACKET wpkt; const EVP_CIPHER *cipher; int mode; if (n_recs != 1) { /* Should not happen */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } ctx = rl->enc_ctx; staticiv = rl->iv; cipher = EVP_CIPHER_CTX_get0_cipher(ctx); if (cipher == NULL) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } mode = EVP_CIPHER_get_mode(cipher); /* * If we're sending an alert and ctx != NULL then we must be forcing * plaintext alerts. If we're reading and ctx != NULL then we allow * plaintext alerts at certain points in the handshake. If we've got this * far then we have already validated that a plaintext alert is ok here. */ if (ctx == NULL || rec->type == SSL3_RT_ALERT) { memmove(rec->data, rec->input, rec->length); rec->input = rec->data; return 1; } ivlen = EVP_CIPHER_CTX_get_iv_length(ctx); if (!sending) { /* * Take off tag. There must be at least one byte of content type as * well as the tag */ if (rec->length < rl->taglen + 1) return 0; rec->length -= rl->taglen; } /* Set up IV */ if (ivlen < SEQ_NUM_SIZE) { /* Should not happen */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } offset = ivlen - SEQ_NUM_SIZE; memcpy(iv, staticiv, offset); for (loop = 0; loop < SEQ_NUM_SIZE; loop++) iv[offset + loop] = staticiv[offset + loop] ^ seq[loop]; if (!tls_increment_sequence_ctr(rl)) { /* RLAYERfatal already called */ return 0; } if (EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, sending) <= 0 || (!sending && EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, rl->taglen, rec->data + rec->length) <= 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* Set up the AAD */ if (!WPACKET_init_static_len(&wpkt, recheader, sizeof(recheader), 0) || !WPACKET_put_bytes_u8(&wpkt, rec->type) || !WPACKET_put_bytes_u16(&wpkt, rec->rec_version) || !WPACKET_put_bytes_u16(&wpkt, rec->length + rl->taglen) || !WPACKET_get_total_written(&wpkt, &hdrlen) || hdrlen != SSL3_RT_HEADER_LENGTH || !WPACKET_finish(&wpkt)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); WPACKET_cleanup(&wpkt); return 0; } /* * For CCM we must explicitly set the total plaintext length before we add * any AAD. */ if ((mode == EVP_CIPH_CCM_MODE && EVP_CipherUpdate(ctx, NULL, &lenu, NULL, (unsigned int)rec->length) <= 0) || EVP_CipherUpdate(ctx, NULL, &lenu, recheader, sizeof(recheader)) <= 0 || EVP_CipherUpdate(ctx, rec->data, &lenu, rec->input, (unsigned int)rec->length) <= 0 || EVP_CipherFinal_ex(ctx, rec->data + lenu, &lenf) <= 0 || (size_t)(lenu + lenf) != rec->length) { return 0; } if (sending) { /* Add the tag */ if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_GET_TAG, rl->taglen, rec->data + rec->length) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } rec->length += rl->taglen; } return 1; } static int tls13_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { if (rec->type != SSL3_RT_APPLICATION_DATA && (rec->type != SSL3_RT_CHANGE_CIPHER_SPEC || !rl->is_first_handshake) && (rec->type != SSL3_RT_ALERT || !rl->allow_plain_alerts)) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_RECORD_TYPE); return 0; } if (rec->rec_version != TLS1_2_VERSION) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_WRONG_VERSION_NUMBER); return 0; } if (rec->length > SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_ENCRYPTED_LENGTH_TOO_LONG); return 0; } return 1; } static int tls13_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec) { /* Skip this if we've received a plaintext alert */ if (rec->type != SSL3_RT_ALERT) { size_t end; if (rec->length == 0 || rec->type != SSL3_RT_APPLICATION_DATA) { RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_RECORD_TYPE); return 0; } /* Strip trailing padding */ for (end = rec->length - 1; end > 0 && rec->data[end] == 0; end--) continue; rec->length = end; rec->type = rec->data[end]; } if (rec->length > SSL3_RT_MAX_PLAIN_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); return 0; } if (!tls13_common_post_process_record(rl, rec)) { /* RLAYERfatal already called */ return 0; } return 1; } static uint8_t tls13_get_record_type(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *template) { if (rl->allow_plain_alerts && template->type == SSL3_RT_ALERT) return SSL3_RT_ALERT; /* * Aside from the above case we always use the application data record type * when encrypting in TLSv1.3. The "inner" record type encodes the "real" * record type from the template. */ return SSL3_RT_APPLICATION_DATA; } static int tls13_add_record_padding(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *thistempl, WPACKET *thispkt, TLS_RL_RECORD *thiswr) { size_t rlen; /* Nothing to be done in the case of a plaintext alert */ if (rl->allow_plain_alerts && thistempl->type != SSL3_RT_ALERT) return 1; if (!WPACKET_put_bytes_u8(thispkt, thistempl->type)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } TLS_RL_RECORD_add_length(thiswr, 1); /* Add TLS1.3 padding */ rlen = TLS_RL_RECORD_get_length(thiswr); if (rlen < rl->max_frag_len) { size_t padding = 0; size_t max_padding = rl->max_frag_len - rlen; if (rl->padding != NULL) { padding = rl->padding(rl->cbarg, thistempl->type, rlen); } else if (rl->block_padding > 0) { size_t mask = rl->block_padding - 1; size_t remainder; /* optimize for power of 2 */ if ((rl->block_padding & mask) == 0) remainder = rlen & mask; else remainder = rlen % rl->block_padding; /* don't want to add a block of padding if we don't have to */ if (remainder == 0) padding = 0; else padding = rl->block_padding - remainder; } if (padding > 0) { /* do not allow the record to exceed max plaintext length */ if (padding > max_padding) padding = max_padding; if (!WPACKET_memset(thispkt, 0, padding)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } TLS_RL_RECORD_add_length(thiswr, padding); } } return 1; } struct record_functions_st tls_1_3_funcs = { tls13_set_crypto_state, tls13_cipher, NULL, tls_default_set_protocol_version, tls_default_read_n, tls_get_more_records, tls13_validate_record_header, tls13_post_process_record, tls_get_max_records_default, tls_write_records_default, tls_allocate_write_buffers_default, tls_initialise_write_packets_default, tls13_get_record_type, tls_prepare_record_header_default, tls13_add_record_padding, tls_prepare_for_encryption_default, tls_post_encryption_processing_default, NULL };

./openssl/ssl/record/methods/tls1_meth.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/evp.h> #include <openssl/core_names.h> #include <openssl/rand.h> #include <openssl/ssl.h> #include "internal/ssl3_cbc.h" #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" static int tls1_set_crypto_state(OSSL_RECORD_LAYER *rl, int level, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp) { EVP_CIPHER_CTX *ciph_ctx; EVP_PKEY *mac_key; int enc = (rl->direction == OSSL_RECORD_DIRECTION_WRITE) ? 1 : 0; if (level != OSSL_RECORD_PROTECTION_LEVEL_APPLICATION) return OSSL_RECORD_RETURN_FATAL; if ((rl->enc_ctx = EVP_CIPHER_CTX_new()) == NULL) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return OSSL_RECORD_RETURN_FATAL; } ciph_ctx = rl->enc_ctx; rl->md_ctx = EVP_MD_CTX_new(); if (rl->md_ctx == NULL) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } #ifndef OPENSSL_NO_COMP if (comp != NULL) { rl->compctx = COMP_CTX_new(comp); if (rl->compctx == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_COMPRESSION_LIBRARY_ERROR); return OSSL_RECORD_RETURN_FATAL; } } #endif /* * If we have an AEAD Cipher, then there is no separate MAC, so we can skip * setting up the MAC key. */ if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) == 0) { if (mactype == EVP_PKEY_HMAC) { mac_key = EVP_PKEY_new_raw_private_key_ex(rl->libctx, "HMAC", rl->propq, mackey, mackeylen); } else { /* * If its not HMAC then the only other types of MAC we support are * the GOST MACs, so we need to use the old style way of creating * a MAC key. */ mac_key = EVP_PKEY_new_mac_key(mactype, NULL, mackey, (int)mackeylen); } if (mac_key == NULL || EVP_DigestSignInit_ex(rl->md_ctx, NULL, EVP_MD_get0_name(md), rl->libctx, rl->propq, mac_key, NULL) <= 0) { EVP_PKEY_free(mac_key); ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } EVP_PKEY_free(mac_key); } if (EVP_CIPHER_get_mode(ciph) == EVP_CIPH_GCM_MODE) { if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, key, NULL, enc) || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_GCM_SET_IV_FIXED, (int)ivlen, iv) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } } else if (EVP_CIPHER_get_mode(ciph) == EVP_CIPH_CCM_MODE) { if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, NULL, NULL, enc) || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_IVLEN, 12, NULL) <= 0 || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_TAG, (int)taglen, NULL) <= 0 || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_CCM_SET_IV_FIXED, (int)ivlen, iv) <= 0 || !EVP_CipherInit_ex(ciph_ctx, NULL, NULL, key, NULL, enc)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } } else { if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, key, iv, enc)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } } /* Needed for "composite" AEADs, such as RC4-HMAC-MD5 */ if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0 && mackeylen != 0 && EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_MAC_KEY, (int)mackeylen, mackey) <= 0) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } /* * The cipher we actually ended up using in the EVP_CIPHER_CTX may be * different to that in ciph if we have an ENGINE in use */ if (EVP_CIPHER_get0_provider(EVP_CIPHER_CTX_get0_cipher(ciph_ctx)) != NULL && !ossl_set_tls_provider_parameters(rl, ciph_ctx, ciph, md)) { /* ERR_raise already called */ return OSSL_RECORD_RETURN_FATAL; } /* Calculate the explicit IV length */ if (RLAYER_USE_EXPLICIT_IV(rl)) { int mode = EVP_CIPHER_CTX_get_mode(ciph_ctx); int eivlen = 0; if (mode == EVP_CIPH_CBC_MODE) { eivlen = EVP_CIPHER_CTX_get_iv_length(ciph_ctx); if (eivlen < 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG); return OSSL_RECORD_RETURN_FATAL; } if (eivlen <= 1) eivlen = 0; } else if (mode == EVP_CIPH_GCM_MODE) { /* Need explicit part of IV for GCM mode */ eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN; } else if (mode == EVP_CIPH_CCM_MODE) { eivlen = EVP_CCM_TLS_EXPLICIT_IV_LEN; } rl->eivlen = (size_t)eivlen; } return OSSL_RECORD_RETURN_SUCCESS; } #define MAX_PADDING 256 /*- * tls1_cipher encrypts/decrypts |n_recs| in |recs|. Calls RLAYERfatal on * internal error, but not otherwise. It is the responsibility of the caller to * report a bad_record_mac - if appropriate (DTLS just drops the record). * * Returns: * 0: if the record is publicly invalid, or an internal error, or AEAD * decryption failed, or Encrypt-then-mac decryption failed. * 1: Success or Mac-then-encrypt decryption failed (MAC will be randomised) */ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs, size_t n_recs, int sending, SSL_MAC_BUF *macs, size_t macsize) { EVP_CIPHER_CTX *ds; size_t reclen[SSL_MAX_PIPELINES]; unsigned char buf[SSL_MAX_PIPELINES][EVP_AEAD_TLS1_AAD_LEN]; unsigned char *data[SSL_MAX_PIPELINES]; int pad = 0, tmpr, provided; size_t bs, ctr, padnum, loop; unsigned char padval; const EVP_CIPHER *enc; if (n_recs == 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (EVP_MD_CTX_get0_md(rl->md_ctx)) { int n = EVP_MD_CTX_get_size(rl->md_ctx); if (!ossl_assert(n >= 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } ds = rl->enc_ctx; if (!ossl_assert(rl->enc_ctx != NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } enc = EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx); if (sending) { int ivlen; /* For TLSv1.1 and later explicit IV */ if (RLAYER_USE_EXPLICIT_IV(rl) && EVP_CIPHER_get_mode(enc) == EVP_CIPH_CBC_MODE) ivlen = EVP_CIPHER_get_iv_length(enc); else ivlen = 0; if (ivlen > 1) { for (ctr = 0; ctr < n_recs; ctr++) { if (recs[ctr].data != recs[ctr].input) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } else if (RAND_bytes_ex(rl->libctx, recs[ctr].input, ivlen, 0) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } } if (!ossl_assert(enc != NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } provided = (EVP_CIPHER_get0_provider(enc) != NULL); bs = EVP_CIPHER_get_block_size(EVP_CIPHER_CTX_get0_cipher(ds)); if (n_recs > 1) { if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds)) & EVP_CIPH_FLAG_PIPELINE) == 0) { /* * We shouldn't have been called with pipeline data if the * cipher doesn't support pipelining */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_PIPELINE_FAILURE); return 0; } } for (ctr = 0; ctr < n_recs; ctr++) { reclen[ctr] = recs[ctr].length; if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds)) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0) { unsigned char *seq; seq = rl->sequence; if (rl->isdtls) { unsigned char dtlsseq[8], *p = dtlsseq; s2n(rl->epoch, p); memcpy(p, &seq[2], 6); memcpy(buf[ctr], dtlsseq, 8); } else { memcpy(buf[ctr], seq, 8); if (!tls_increment_sequence_ctr(rl)) { /* RLAYERfatal already called */ return 0; } } buf[ctr][8] = recs[ctr].type; buf[ctr][9] = (unsigned char)(rl->version >> 8); buf[ctr][10] = (unsigned char)(rl->version); buf[ctr][11] = (unsigned char)(recs[ctr].length >> 8); buf[ctr][12] = (unsigned char)(recs[ctr].length & 0xff); pad = EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_AEAD_TLS1_AAD, EVP_AEAD_TLS1_AAD_LEN, buf[ctr]); if (pad <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (sending) { reclen[ctr] += pad; recs[ctr].length += pad; } } else if ((bs != 1) && sending && !provided) { /* * We only do this for legacy ciphers. Provided ciphers add the * padding on the provider side. */ padnum = bs - (reclen[ctr] % bs); /* Add weird padding of up to 256 bytes */ if (padnum > MAX_PADDING) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } /* we need to add 'padnum' padding bytes of value padval */ padval = (unsigned char)(padnum - 1); for (loop = reclen[ctr]; loop < reclen[ctr] + padnum; loop++) recs[ctr].input[loop] = padval; reclen[ctr] += padnum; recs[ctr].length += padnum; } if (!sending) { if (reclen[ctr] == 0 || reclen[ctr] % bs != 0) { /* Publicly invalid */ return 0; } } } if (n_recs > 1) { /* Set the output buffers */ for (ctr = 0; ctr < n_recs; ctr++) data[ctr] = recs[ctr].data; if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS, (int)n_recs, data) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_PIPELINE_FAILURE); return 0; } /* Set the input buffers */ for (ctr = 0; ctr < n_recs; ctr++) data[ctr] = recs[ctr].input; if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_BUFS, (int)n_recs, data) <= 0 || EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_LENS, (int)n_recs, reclen) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_PIPELINE_FAILURE); return 0; } } if (!rl->isdtls && rl->tlstree) { int decrement_seq = 0; /* * When sending, seq is incremented after MAC calculation. * So if we are in ETM mode, we use seq 'as is' in the ctrl-function. * Otherwise we have to decrease it in the implementation */ if (sending && !rl->use_etm) decrement_seq = 1; if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_TLSTREE, decrement_seq, rl->sequence) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } if (provided) { int outlen; /* Provided cipher - we do not support pipelining on this path */ if (n_recs > 1) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } if (!EVP_CipherUpdate(ds, recs[0].data, &outlen, recs[0].input, (unsigned int)reclen[0])) return 0; recs[0].length = outlen; /* * The length returned from EVP_CipherUpdate above is the actual * payload length. We need to adjust the data/input ptr to skip over * any explicit IV */ if (!sending) { if (EVP_CIPHER_get_mode(enc) == EVP_CIPH_GCM_MODE) { recs[0].data += EVP_GCM_TLS_EXPLICIT_IV_LEN; recs[0].input += EVP_GCM_TLS_EXPLICIT_IV_LEN; } else if (EVP_CIPHER_get_mode(enc) == EVP_CIPH_CCM_MODE) { recs[0].data += EVP_CCM_TLS_EXPLICIT_IV_LEN; recs[0].input += EVP_CCM_TLS_EXPLICIT_IV_LEN; } else if (bs != 1 && RLAYER_USE_EXPLICIT_IV(rl)) { recs[0].data += bs; recs[0].input += bs; recs[0].orig_len -= bs; } /* Now get a pointer to the MAC (if applicable) */ if (macs != NULL) { OSSL_PARAM params[2], *p = params; /* Get the MAC */ macs[0].alloced = 0; *p++ = OSSL_PARAM_construct_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, (void **)&macs[0].mac, macsize); *p = OSSL_PARAM_construct_end(); if (!EVP_CIPHER_CTX_get_params(ds, params)) { /* Shouldn't normally happen */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } } else { /* Legacy cipher */ tmpr = EVP_Cipher(ds, recs[0].data, recs[0].input, (unsigned int)reclen[0]); if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds)) & EVP_CIPH_FLAG_CUSTOM_CIPHER) != 0 ? (tmpr < 0) : (tmpr == 0)) { /* AEAD can fail to verify MAC */ return 0; } if (!sending) { for (ctr = 0; ctr < n_recs; ctr++) { /* Adjust the record to remove the explicit IV/MAC/Tag */ if (EVP_CIPHER_get_mode(enc) == EVP_CIPH_GCM_MODE) { recs[ctr].data += EVP_GCM_TLS_EXPLICIT_IV_LEN; recs[ctr].input += EVP_GCM_TLS_EXPLICIT_IV_LEN; recs[ctr].length -= EVP_GCM_TLS_EXPLICIT_IV_LEN; } else if (EVP_CIPHER_get_mode(enc) == EVP_CIPH_CCM_MODE) { recs[ctr].data += EVP_CCM_TLS_EXPLICIT_IV_LEN; recs[ctr].input += EVP_CCM_TLS_EXPLICIT_IV_LEN; recs[ctr].length -= EVP_CCM_TLS_EXPLICIT_IV_LEN; } else if (bs != 1 && RLAYER_USE_EXPLICIT_IV(rl)) { if (recs[ctr].length < bs) return 0; recs[ctr].data += bs; recs[ctr].input += bs; recs[ctr].length -= bs; recs[ctr].orig_len -= bs; } /* * If using Mac-then-encrypt, then this will succeed but * with a random MAC if padding is invalid */ if (!tls1_cbc_remove_padding_and_mac(&recs[ctr].length, recs[ctr].orig_len, recs[ctr].data, (macs != NULL) ? &macs[ctr].mac : NULL, (macs != NULL) ? &macs[ctr].alloced : NULL, bs, pad ? (size_t)pad : macsize, (EVP_CIPHER_get_flags(enc) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0, rl->libctx)) return 0; } } } return 1; } static int tls1_mac(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md, int sending) { unsigned char *seq = rl->sequence; EVP_MD_CTX *hash; size_t md_size; EVP_MD_CTX *hmac = NULL, *mac_ctx; unsigned char header[13]; int t; int ret = 0; hash = rl->md_ctx; t = EVP_MD_CTX_get_size(hash); if (!ossl_assert(t >= 0)) return 0; md_size = t; if (rl->stream_mac) { mac_ctx = hash; } else { hmac = EVP_MD_CTX_new(); if (hmac == NULL || !EVP_MD_CTX_copy(hmac, hash)) { goto end; } mac_ctx = hmac; } if (!rl->isdtls && rl->tlstree && EVP_MD_CTX_ctrl(mac_ctx, EVP_MD_CTRL_TLSTREE, 0, seq) <= 0) goto end; if (rl->isdtls) { unsigned char dtlsseq[8], *p = dtlsseq; s2n(rl->epoch, p); memcpy(p, &seq[2], 6); memcpy(header, dtlsseq, 8); } else { memcpy(header, seq, 8); } header[8] = rec->type; header[9] = (unsigned char)(rl->version >> 8); header[10] = (unsigned char)(rl->version); header[11] = (unsigned char)(rec->length >> 8); header[12] = (unsigned char)(rec->length & 0xff); if (!sending && !rl->use_etm && EVP_CIPHER_CTX_get_mode(rl->enc_ctx) == EVP_CIPH_CBC_MODE && ssl3_cbc_record_digest_supported(mac_ctx)) { OSSL_PARAM tls_hmac_params[2], *p = tls_hmac_params; *p++ = OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_TLS_DATA_SIZE, &rec->orig_len); *p++ = OSSL_PARAM_construct_end(); if (!EVP_PKEY_CTX_set_params(EVP_MD_CTX_get_pkey_ctx(mac_ctx), tls_hmac_params)) goto end; } if (EVP_DigestSignUpdate(mac_ctx, header, sizeof(header)) <= 0 || EVP_DigestSignUpdate(mac_ctx, rec->input, rec->length) <= 0 || EVP_DigestSignFinal(mac_ctx, md, &md_size) <= 0) goto end; OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "seq:\n"); BIO_dump_indent(trc_out, seq, 8, 4); BIO_printf(trc_out, "rec:\n"); BIO_dump_indent(trc_out, rec->data, rec->length, 4); } OSSL_TRACE_END(TLS); if (!rl->isdtls && !tls_increment_sequence_ctr(rl)) { /* RLAYERfatal already called */ goto end; } OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "md:\n"); BIO_dump_indent(trc_out, md, md_size, 4); } OSSL_TRACE_END(TLS); ret = 1; end: EVP_MD_CTX_free(hmac); return ret; } #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 # ifndef OPENSSL_NO_COMP # define MAX_PREFIX_LEN ((SSL3_ALIGN_PAYLOAD - 1) \ + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ + SSL3_RT_HEADER_LENGTH \ + SSL3_RT_MAX_COMPRESSED_OVERHEAD) # else # define MAX_PREFIX_LEN ((SSL3_ALIGN_PAYLOAD - 1) \ + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ + SSL3_RT_HEADER_LENGTH) # endif /* OPENSSL_NO_COMP */ #else # ifndef OPENSSL_NO_COMP # define MAX_PREFIX_LEN (SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ + SSL3_RT_HEADER_LENGTH \ + SSL3_RT_MAX_COMPRESSED_OVERHEAD) # else # define MAX_PREFIX_LEN (SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \ + SSL3_RT_HEADER_LENGTH) # endif /* OPENSSL_NO_COMP */ #endif /* This function is also used by the SSLv3 implementation */ int tls1_allocate_write_buffers(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, size_t *prefix) { /* Do we need to add an empty record prefix? */ *prefix = rl->need_empty_fragments && templates[0].type == SSL3_RT_APPLICATION_DATA; /* * In the prefix case we can allocate a much smaller buffer. Otherwise we * just allocate the default buffer size */ if (!tls_setup_write_buffer(rl, numtempl + *prefix, *prefix ? MAX_PREFIX_LEN : 0, 0)) { /* RLAYERfatal() already called */ return 0; } return 1; } /* This function is also used by the SSLv3 implementation */ int tls1_initialise_write_packets(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, OSSL_RECORD_TEMPLATE *prefixtempl, WPACKET *pkt, TLS_BUFFER *bufs, size_t *wpinited) { size_t align = 0; TLS_BUFFER *wb; size_t prefix; /* Do we need to add an empty record prefix? */ prefix = rl->need_empty_fragments && templates[0].type == SSL3_RT_APPLICATION_DATA; if (prefix) { /* * countermeasure against known-IV weakness in CBC ciphersuites (see * http://www.openssl.org/~bodo/tls-cbc.txt) */ prefixtempl->buf = NULL; prefixtempl->version = templates[0].version; prefixtempl->buflen = 0; prefixtempl->type = SSL3_RT_APPLICATION_DATA; wb = &bufs[0]; #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (size_t)TLS_BUFFER_get_buf(wb) + SSL3_RT_HEADER_LENGTH; align = SSL3_ALIGN_PAYLOAD - 1 - ((align - 1) % SSL3_ALIGN_PAYLOAD); #endif TLS_BUFFER_set_offset(wb, align); if (!WPACKET_init_static_len(&pkt[0], TLS_BUFFER_get_buf(wb), TLS_BUFFER_get_len(wb), 0)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } *wpinited = 1; if (!WPACKET_allocate_bytes(&pkt[0], align, NULL)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } return tls_initialise_write_packets_default(rl, templates, numtempl, NULL, pkt + prefix, bufs + prefix, wpinited); } /* TLSv1.0, TLSv1.1 and TLSv1.2 all use the same funcs */ struct record_functions_st tls_1_funcs = { tls1_set_crypto_state, tls1_cipher, tls1_mac, tls_default_set_protocol_version, tls_default_read_n, tls_get_more_records, tls_default_validate_record_header, tls_default_post_process_record, tls_get_max_records_multiblock, tls_write_records_multiblock, /* Defined in tls_multib.c */ tls1_allocate_write_buffers, tls1_initialise_write_packets, NULL, tls_prepare_record_header_default, NULL, tls_prepare_for_encryption_default, tls_post_encryption_processing_default, NULL }; struct record_functions_st dtls_1_funcs = { tls1_set_crypto_state, tls1_cipher, tls1_mac, tls_default_set_protocol_version, tls_default_read_n, dtls_get_more_records, NULL, NULL, NULL, tls_write_records_default, /* * Don't use tls1_allocate_write_buffers since that handles empty fragment * records which aren't needed in DTLS. We just use the default allocation * instead. */ tls_allocate_write_buffers_default, /* Don't use tls1_initialise_write_packets for same reason as above */ tls_initialise_write_packets_default, NULL, dtls_prepare_record_header, NULL, tls_prepare_for_encryption_default, dtls_post_encryption_processing, NULL };

./openssl/ssl/record/methods/recmethod_local.h

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/bio.h> #include <openssl/ssl.h> #include <openssl/err.h> #include "../../ssl_local.h" #include "../record_local.h" typedef struct dtls_bitmap_st { /* Track 64 packets */ uint64_t map; /* Max record number seen so far, 64-bit value in big-endian encoding */ unsigned char max_seq_num[SEQ_NUM_SIZE]; } DTLS_BITMAP; typedef struct ssl_mac_buf_st { unsigned char *mac; int alloced; } SSL_MAC_BUF; typedef struct tls_buffer_st { /* at least SSL3_RT_MAX_PACKET_SIZE bytes */ unsigned char *buf; /* default buffer size (or 0 if no default set) */ size_t default_len; /* buffer size */ size_t len; /* where to 'copy from' */ size_t offset; /* how many bytes left */ size_t left; /* 'buf' is from application for KTLS */ int app_buffer; /* The type of data stored in this buffer. Only used for writing */ int type; } TLS_BUFFER; typedef struct tls_rl_record_st { /* Record layer version */ /* r */ int rec_version; /* type of record */ /* r */ int type; /* How many bytes available */ /* rw */ size_t length; /* * How many bytes were available before padding was removed? This is used * to implement the MAC check in constant time for CBC records. */ /* rw */ size_t orig_len; /* read/write offset into 'buf' */ /* r */ size_t off; /* pointer to the record data */ /* rw */ unsigned char *data; /* where the decode bytes are */ /* rw */ unsigned char *input; /* only used with decompression - malloc()ed */ /* r */ unsigned char *comp; /* epoch number, needed by DTLS1 */ /* r */ uint16_t epoch; /* sequence number, needed by DTLS1 */ /* r */ unsigned char seq_num[SEQ_NUM_SIZE]; } TLS_RL_RECORD; /* Macros/functions provided by the TLS_RL_RECORD component */ #define TLS_RL_RECORD_set_type(r, t) ((r)->type = (t)) #define TLS_RL_RECORD_set_rec_version(r, v) ((r)->rec_version = (v)) #define TLS_RL_RECORD_get_length(r) ((r)->length) #define TLS_RL_RECORD_set_length(r, l) ((r)->length = (l)) #define TLS_RL_RECORD_add_length(r, l) ((r)->length += (l)) #define TLS_RL_RECORD_set_data(r, d) ((r)->data = (d)) #define TLS_RL_RECORD_set_input(r, i) ((r)->input = (i)) #define TLS_RL_RECORD_reset_input(r) ((r)->input = (r)->data) /* Protocol version specific function pointers */ struct record_functions_st { /* * Returns either OSSL_RECORD_RETURN_SUCCESS, OSSL_RECORD_RETURN_FATAL or * OSSL_RECORD_RETURN_NON_FATAL_ERR if we can keep trying to find an * alternative record layer. */ int (*set_crypto_state)(OSSL_RECORD_LAYER *rl, int level, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp); /* * Returns: * 0: if the record is publicly invalid, or an internal error, or AEAD * decryption failed, or EtM decryption failed. * 1: Success or MtE decryption failed (MAC will be randomised) */ int (*cipher)(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs, size_t n_recs, int sending, SSL_MAC_BUF *macs, size_t macsize); /* Returns 1 for success or 0 for error */ int (*mac)(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md, int sending); /* Return 1 for success or 0 for error */ int (*set_protocol_version)(OSSL_RECORD_LAYER *rl, int version); /* Read related functions */ int (*read_n)(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend, int clearold, size_t *readbytes); int (*get_more_records)(OSSL_RECORD_LAYER *rl); /* Return 1 for success or 0 for error */ int (*validate_record_header)(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec); /* Return 1 for success or 0 for error */ int (*post_process_record)(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec); /* Write related functions */ size_t (*get_max_records)(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t maxfrag, size_t *preffrag); /* Return 1 for success or 0 for error */ int (*write_records)(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl); /* Allocate the rl->wbuf buffers. Return 1 for success or 0 for error */ int (*allocate_write_buffers)(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, size_t *prefix); /* * Initialise the packets in the |pkt| array using the buffers in |rl->wbuf|. * Some protocol versions may use the space in |prefixtempl| to add * an artificial template in front of the |templates| array and hence may * initialise 1 more WPACKET than there are templates. |*wpinited| * returns the number of WPACKETs in |pkt| that were successfully * initialised. This must be 0 on entry and will be filled in even on error. */ int (*initialise_write_packets)(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, OSSL_RECORD_TEMPLATE *prefixtempl, WPACKET *pkt, TLS_BUFFER *bufs, size_t *wpinited); /* Get the actual record type to be used for a given template */ uint8_t (*get_record_type)(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *template); /* Write the record header data to the WPACKET */ int (*prepare_record_header)(OSSL_RECORD_LAYER *rl, WPACKET *thispkt, OSSL_RECORD_TEMPLATE *templ, uint8_t rectype, unsigned char **recdata); int (*add_record_padding)(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *thistempl, WPACKET *thispkt, TLS_RL_RECORD *thiswr); /* * This applies any mac that might be necessary, ensures that we have enough * space in the WPACKET to perform the encryption and sets up the * TLS_RL_RECORD ready for that encryption. */ int (*prepare_for_encryption)(OSSL_RECORD_LAYER *rl, size_t mac_size, WPACKET *thispkt, TLS_RL_RECORD *thiswr); /* * Any updates required to the record after encryption has been applied. For * example, adding a MAC if using encrypt-then-mac */ int (*post_encryption_processing)(OSSL_RECORD_LAYER *rl, size_t mac_size, OSSL_RECORD_TEMPLATE *thistempl, WPACKET *thispkt, TLS_RL_RECORD *thiswr); /* * Some record layer implementations need to do some custom preparation of * the BIO before we write to it. KTLS does this to prevent coalescing of * control and data messages. */ int (*prepare_write_bio)(OSSL_RECORD_LAYER *rl, int type); }; struct ossl_record_layer_st { OSSL_LIB_CTX *libctx; const char *propq; int isdtls; int version; int role; int direction; int level; const EVP_MD *md; /* DTLS only */ uint16_t epoch; /* * A BIO containing any data read in the previous epoch that was destined * for this epoch */ BIO *prev; /* The transport BIO */ BIO *bio; /* * A BIO where we will send any data read by us that is destined for the * next epoch. */ BIO *next; /* Types match the equivalent fields in the SSL object */ uint64_t options; uint32_t mode; /* write IO goes into here */ TLS_BUFFER wbuf[SSL_MAX_PIPELINES + 1]; /* Next wbuf with pending data still to write */ size_t nextwbuf; /* How many pipelines can be used to write data */ size_t numwpipes; /* read IO goes into here */ TLS_BUFFER rbuf; /* each decoded record goes in here */ TLS_RL_RECORD rrec[SSL_MAX_PIPELINES]; /* How many records have we got available in the rrec buffer */ size_t num_recs; /* The record number in the rrec buffer that can be read next */ size_t curr_rec; /* The number of records that have been released via tls_release_record */ size_t num_released; /* where we are when reading */ int rstate; /* used internally to point at a raw packet */ unsigned char *packet; size_t packet_length; /* Sequence number for the next record */ unsigned char sequence[SEQ_NUM_SIZE]; /* Alert code to be used if an error occurs */ int alert; /* * Read as many input bytes as possible (for non-blocking reads) */ int read_ahead; /* The number of consecutive empty records we have received */ size_t empty_record_count; /* * Do we need to send a prefix empty record before application data as a * countermeasure against known-IV weakness (necessary for SSLv3 and * TLSv1.0) */ int need_empty_fragments; /* cryptographic state */ EVP_CIPHER_CTX *enc_ctx; /* Explicit IV length */ size_t eivlen; /* used for mac generation */ EVP_MD_CTX *md_ctx; /* compress/uncompress */ COMP_CTX *compctx; /* Set to 1 if this is the first handshake. 0 otherwise */ int is_first_handshake; /* * The smaller of the configured and negotiated maximum fragment length * or SSL3_RT_MAX_PLAIN_LENGTH if none */ unsigned int max_frag_len; /* The maximum amount of early data we can receive/send */ uint32_t max_early_data; /* The amount of early data that we have sent/received */ size_t early_data_count; /* TLSv1.3 record padding */ size_t block_padding; /* Only used by SSLv3 */ unsigned char mac_secret[EVP_MAX_MD_SIZE]; /* TLSv1.0/TLSv1.1/TLSv1.2 */ int use_etm; /* Flags for GOST ciphers */ int stream_mac; int tlstree; /* TLSv1.3 fields */ /* static IV */ unsigned char iv[EVP_MAX_IV_LENGTH]; int allow_plain_alerts; /* TLS "any" fields */ /* Set to true if this is the first record in a connection */ unsigned int is_first_record; size_t taglen; /* DTLS received handshake records (processed and unprocessed) */ record_pqueue unprocessed_rcds; record_pqueue processed_rcds; /* records being received in the current epoch */ DTLS_BITMAP bitmap; /* renegotiation starts a new set of sequence numbers */ DTLS_BITMAP next_bitmap; /* * Whether we are currently in a handshake or not. Only maintained for DTLS */ int in_init; /* Callbacks */ void *cbarg; OSSL_FUNC_rlayer_skip_early_data_fn *skip_early_data; OSSL_FUNC_rlayer_msg_callback_fn *msg_callback; OSSL_FUNC_rlayer_security_fn *security; OSSL_FUNC_rlayer_padding_fn *padding; size_t max_pipelines; /* Function pointers for version specific functions */ struct record_functions_st *funcs; }; typedef struct dtls_rlayer_record_data_st { unsigned char *packet; size_t packet_length; TLS_BUFFER rbuf; TLS_RL_RECORD rrec; } DTLS_RLAYER_RECORD_DATA; extern struct record_functions_st ssl_3_0_funcs; extern struct record_functions_st tls_1_funcs; extern struct record_functions_st tls_1_3_funcs; extern struct record_functions_st tls_any_funcs; extern struct record_functions_st dtls_1_funcs; extern struct record_functions_st dtls_any_funcs; void ossl_rlayer_fatal(OSSL_RECORD_LAYER *rl, int al, int reason, const char *fmt, ...); #define RLAYERfatal(rl, al, r) RLAYERfatal_data((rl), (al), (r), NULL) #define RLAYERfatal_data \ (ERR_new(), \ ERR_set_debug(OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC), \ ossl_rlayer_fatal) #define RLAYER_USE_EXPLICIT_IV(rl) ((rl)->version == TLS1_1_VERSION \ || (rl)->version == TLS1_2_VERSION \ || (rl)->isdtls) void ossl_tls_rl_record_set_seq_num(TLS_RL_RECORD *r, const unsigned char *seq_num); int ossl_set_tls_provider_parameters(OSSL_RECORD_LAYER *rl, EVP_CIPHER_CTX *ctx, const EVP_CIPHER *ciph, const EVP_MD *md); int tls_increment_sequence_ctr(OSSL_RECORD_LAYER *rl); int tls_alloc_buffers(OSSL_RECORD_LAYER *rl); int tls_free_buffers(OSSL_RECORD_LAYER *rl); int tls_default_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend, int clearold, size_t *readbytes); int tls_get_more_records(OSSL_RECORD_LAYER *rl); int dtls_get_more_records(OSSL_RECORD_LAYER *rl); int dtls_prepare_record_header(OSSL_RECORD_LAYER *rl, WPACKET *thispkt, OSSL_RECORD_TEMPLATE *templ, uint8_t rectype, unsigned char **recdata); int dtls_post_encryption_processing(OSSL_RECORD_LAYER *rl, size_t mac_size, OSSL_RECORD_TEMPLATE *thistempl, WPACKET *thispkt, TLS_RL_RECORD *thiswr); int tls_default_set_protocol_version(OSSL_RECORD_LAYER *rl, int version); int tls_default_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *re); int tls_do_compress(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *wr); int tls_do_uncompress(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec); int tls_default_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec); int tls13_common_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec); int tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers, int role, int direction, int level, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp, BIO *prev, BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer, const OSSL_PARAM *settings, const OSSL_PARAM *options, const OSSL_DISPATCH *fns, void *cbarg, OSSL_RECORD_LAYER **retrl); int tls_free(OSSL_RECORD_LAYER *rl); int tls_unprocessed_read_pending(OSSL_RECORD_LAYER *rl); int tls_processed_read_pending(OSSL_RECORD_LAYER *rl); size_t tls_app_data_pending(OSSL_RECORD_LAYER *rl); size_t tls_get_max_records(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t maxfrag, size_t *preffrag); int tls_write_records(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl); int tls_retry_write_records(OSSL_RECORD_LAYER *rl); int tls_get_alert_code(OSSL_RECORD_LAYER *rl); int tls_set1_bio(OSSL_RECORD_LAYER *rl, BIO *bio); int tls_read_record(OSSL_RECORD_LAYER *rl, void **rechandle, int *rversion, uint8_t *type, const unsigned char **data, size_t *datalen, uint16_t *epoch, unsigned char *seq_num); int tls_release_record(OSSL_RECORD_LAYER *rl, void *rechandle, size_t length); int tls_default_set_protocol_version(OSSL_RECORD_LAYER *rl, int version); int tls_set_protocol_version(OSSL_RECORD_LAYER *rl, int version); void tls_set_plain_alerts(OSSL_RECORD_LAYER *rl, int allow); void tls_set_first_handshake(OSSL_RECORD_LAYER *rl, int first); void tls_set_max_pipelines(OSSL_RECORD_LAYER *rl, size_t max_pipelines); void tls_get_state(OSSL_RECORD_LAYER *rl, const char **shortstr, const char **longstr); int tls_set_options(OSSL_RECORD_LAYER *rl, const OSSL_PARAM *options); const COMP_METHOD *tls_get_compression(OSSL_RECORD_LAYER *rl); void tls_set_max_frag_len(OSSL_RECORD_LAYER *rl, size_t max_frag_len); int tls_setup_read_buffer(OSSL_RECORD_LAYER *rl); int tls_setup_write_buffer(OSSL_RECORD_LAYER *rl, size_t numwpipes, size_t firstlen, size_t nextlen); int tls_write_records_multiblock(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl); size_t tls_get_max_records_default(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t maxfrag, size_t *preffrag); size_t tls_get_max_records_multiblock(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t maxfrag, size_t *preffrag); int tls_allocate_write_buffers_default(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, size_t *prefix); int tls_initialise_write_packets_default(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, OSSL_RECORD_TEMPLATE *prefixtempl, WPACKET *pkt, TLS_BUFFER *bufs, size_t *wpinited); int tls1_allocate_write_buffers(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, size_t *prefix); int tls1_initialise_write_packets(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl, OSSL_RECORD_TEMPLATE *prefixtempl, WPACKET *pkt, TLS_BUFFER *bufs, size_t *wpinited); int tls_prepare_record_header_default(OSSL_RECORD_LAYER *rl, WPACKET *thispkt, OSSL_RECORD_TEMPLATE *templ, uint8_t rectype, unsigned char **recdata); int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER *rl, size_t mac_size, WPACKET *thispkt, TLS_RL_RECORD *thiswr); int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl, size_t mac_size, OSSL_RECORD_TEMPLATE *thistempl, WPACKET *thispkt, TLS_RL_RECORD *thiswr); int tls_write_records_default(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl); /* Macros/functions provided by the TLS_BUFFER component */ #define TLS_BUFFER_get_buf(b) ((b)->buf) #define TLS_BUFFER_set_buf(b, n) ((b)->buf = (n)) #define TLS_BUFFER_get_len(b) ((b)->len) #define TLS_BUFFER_get_left(b) ((b)->left) #define TLS_BUFFER_set_left(b, l) ((b)->left = (l)) #define TLS_BUFFER_sub_left(b, l) ((b)->left -= (l)) #define TLS_BUFFER_get_offset(b) ((b)->offset) #define TLS_BUFFER_set_offset(b, o) ((b)->offset = (o)) #define TLS_BUFFER_add_offset(b, o) ((b)->offset += (o)) #define TLS_BUFFER_set_app_buffer(b, l) ((b)->app_buffer = (l)) #define TLS_BUFFER_is_app_buffer(b) ((b)->app_buffer) void ossl_tls_buffer_release(TLS_BUFFER *b);

./openssl/ssl/record/methods/tls_multib.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" #if defined(OPENSSL_SMALL_FOOTPRINT) \ || !(defined(AES_ASM) && (defined(__x86_64) \ || defined(__x86_64__) \ || defined(_M_AMD64) \ || defined(_M_X64))) # undef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK # define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0 #endif static int tls_is_multiblock_capable(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t fraglen) { #if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK if (type == SSL3_RT_APPLICATION_DATA && len >= 4 * fraglen && rl->compctx == NULL && rl->msg_callback == NULL && !rl->use_etm && RLAYER_USE_EXPLICIT_IV(rl) && !BIO_get_ktls_send(rl->bio) && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx)) & EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK) != 0) return 1; #endif return 0; } size_t tls_get_max_records_multiblock(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t maxfrag, size_t *preffrag) { if (tls_is_multiblock_capable(rl, type, len, *preffrag)) { /* minimize address aliasing conflicts */ if ((*preffrag & 0xfff) == 0) *preffrag -= 512; if (len >= 8 * (*preffrag)) return 8; return 4; } return tls_get_max_records_default(rl, type, len, maxfrag, preffrag); } /* * Write records using the multiblock method. * * Returns 1 on success, 0 if multiblock isn't suitable (non-fatal error), or * -1 on fatal error. */ static int tls_write_records_multiblock_int(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl) { #if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK size_t i; size_t totlen; TLS_BUFFER *wb; unsigned char aad[13]; EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param; size_t packlen; int packleni; if (numtempl != 4 && numtempl != 8) return 0; /* * Check templates have contiguous buffers and are all the same type and * length */ for (i = 1; i < numtempl; i++) { if (templates[i - 1].type != templates[i].type || templates[i - 1].buflen != templates[i].buflen || templates[i - 1].buf + templates[i - 1].buflen != templates[i].buf) return 0; } totlen = templates[0].buflen * numtempl; if (!tls_is_multiblock_capable(rl, templates[0].type, totlen, templates[0].buflen)) return 0; /* * If we get this far, then multiblock is suitable * Depending on platform multi-block can deliver several *times* * better performance. Downside is that it has to allocate * jumbo buffer to accommodate up to 8 records, but the * compromise is considered worthy. */ /* * Allocate jumbo buffer. This will get freed next time we do a non * multiblock write in the call to tls_setup_write_buffer() - the different * buffer sizes will be spotted and the buffer reallocated. */ packlen = EVP_CIPHER_CTX_ctrl(rl->enc_ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE, (int)templates[0].buflen, NULL); packlen *= numtempl; if (!tls_setup_write_buffer(rl, 1, packlen, packlen)) { /* RLAYERfatal() already called */ return -1; } wb = &rl->wbuf[0]; mb_param.interleave = numtempl; memcpy(aad, rl->sequence, 8); aad[8] = templates[0].type; aad[9] = (unsigned char)(templates[0].version >> 8); aad[10] = (unsigned char)(templates[0].version); aad[11] = 0; aad[12] = 0; mb_param.out = NULL; mb_param.inp = aad; mb_param.len = totlen; packleni = EVP_CIPHER_CTX_ctrl(rl->enc_ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD, sizeof(mb_param), &mb_param); packlen = (size_t)packleni; if (packleni <= 0 || packlen > wb->len) { /* never happens */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } mb_param.out = wb->buf; mb_param.inp = templates[0].buf; mb_param.len = totlen; if (EVP_CIPHER_CTX_ctrl(rl->enc_ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT, sizeof(mb_param), &mb_param) <= 0) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } rl->sequence[7] += mb_param.interleave; if (rl->sequence[7] < mb_param.interleave) { int j = 6; while (j >= 0 && (++rl->sequence[j--]) == 0) ; } wb->offset = 0; wb->left = packlen; return 1; #else /* !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK */ return 0; #endif } int tls_write_records_multiblock(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates, size_t numtempl) { int ret; ret = tls_write_records_multiblock_int(rl, templates, numtempl); if (ret < 0) { /* RLAYERfatal already called */ return 0; } if (ret == 0) { /* Multiblock wasn't suitable so just do a standard write */ if (!tls_write_records_default(rl, templates, numtempl)) { /* RLAYERfatal already called */ return 0; } } return 1; }

./openssl/ssl/record/methods/tls_pad.c

/* * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/rand.h> #include <openssl/evp.h> #include "internal/constant_time.h" #include "internal/cryptlib.h" #include "internal/ssl3_cbc.h" /* * This file has no dependencies on the rest of libssl because it is shared * with the providers. It contains functions for low level CBC TLS padding * removal. Responsibility for this lies with the cipher implementations in the * providers. However there are legacy code paths in libssl which also need to * do this. In time those legacy code paths can be removed and this file can be * moved out of libssl. */ static int ssl3_cbc_copy_mac(size_t *reclen, size_t origreclen, unsigned char *recdata, unsigned char **mac, int *alloced, size_t block_size, size_t mac_size, size_t good, OSSL_LIB_CTX *libctx); /*- * ssl3_cbc_remove_padding removes padding from the decrypted, SSLv3, CBC * record in |recdata| by updating |reclen| in constant time. It also extracts * the MAC from the underlying record and places a pointer to it in |mac|. The * MAC data can either be newly allocated memory, or a pointer inside the * |recdata| buffer. If allocated then |*alloced| is set to 1, otherwise it is * set to 0. * * origreclen: the original record length before any changes were made * block_size: the block size of the cipher used to encrypt the record. * mac_size: the size of the MAC to be extracted * aead: 1 if an AEAD cipher is in use, or 0 otherwise * returns: * 0: if the record is publicly invalid. * 1: if the record is publicly valid. If the padding removal fails then the * MAC returned is random. */ int ssl3_cbc_remove_padding_and_mac(size_t *reclen, size_t origreclen, unsigned char *recdata, unsigned char **mac, int *alloced, size_t block_size, size_t mac_size, OSSL_LIB_CTX *libctx) { size_t padding_length; size_t good; const size_t overhead = 1 /* padding length byte */ + mac_size; /* * These lengths are all public so we can test them in non-constant time. */ if (overhead > *reclen) return 0; padding_length = recdata[*reclen - 1]; good = constant_time_ge_s(*reclen, padding_length + overhead); /* SSLv3 requires that the padding is minimal. */ good &= constant_time_ge_s(block_size, padding_length + 1); *reclen -= good & (padding_length + 1); return ssl3_cbc_copy_mac(reclen, origreclen, recdata, mac, alloced, block_size, mac_size, good, libctx); } /*- * tls1_cbc_remove_padding_and_mac removes padding from the decrypted, TLS, CBC * record in |recdata| by updating |reclen| in constant time. It also extracts * the MAC from the underlying record and places a pointer to it in |mac|. The * MAC data can either be newly allocated memory, or a pointer inside the * |recdata| buffer. If allocated then |*alloced| is set to 1, otherwise it is * set to 0. * * origreclen: the original record length before any changes were made * block_size: the block size of the cipher used to encrypt the record. * mac_size: the size of the MAC to be extracted * aead: 1 if an AEAD cipher is in use, or 0 otherwise * returns: * 0: if the record is publicly invalid. * 1: if the record is publicly valid. If the padding removal fails then the * MAC returned is random. */ int tls1_cbc_remove_padding_and_mac(size_t *reclen, size_t origreclen, unsigned char *recdata, unsigned char **mac, int *alloced, size_t block_size, size_t mac_size, int aead, OSSL_LIB_CTX *libctx) { size_t good = -1; size_t padding_length, to_check, i; size_t overhead = ((block_size == 1) ? 0 : 1) /* padding length byte */ + mac_size; /* * These lengths are all public so we can test them in non-constant * time. */ if (overhead > *reclen) return 0; if (block_size != 1) { padding_length = recdata[*reclen - 1]; if (aead) { /* padding is already verified and we don't need to check the MAC */ *reclen -= padding_length + 1 + mac_size; return 1; } good = constant_time_ge_s(*reclen, overhead + padding_length); /* * The padding consists of a length byte at the end of the record and * then that many bytes of padding, all with the same value as the * length byte. Thus, with the length byte included, there are i+1 bytes * of padding. We can't check just |padding_length+1| bytes because that * leaks decrypted information. Therefore we always have to check the * maximum amount of padding possible. (Again, the length of the record * is public information so we can use it.) */ to_check = 256; /* maximum amount of padding, inc length byte. */ if (to_check > *reclen) to_check = *reclen; for (i = 0; i < to_check; i++) { unsigned char mask = constant_time_ge_8_s(padding_length, i); unsigned char b = recdata[*reclen - 1 - i]; /* * The final |padding_length+1| bytes should all have the value * |padding_length|. Therefore the XOR should be zero. */ good &= ~(mask & (padding_length ^ b)); } /* * If any of the final |padding_length+1| bytes had the wrong value, one * or more of the lower eight bits of |good| will be cleared. */ good = constant_time_eq_s(0xff, good & 0xff); *reclen -= good & (padding_length + 1); } return ssl3_cbc_copy_mac(reclen, origreclen, recdata, mac, alloced, block_size, mac_size, good, libctx); } /*- * ssl3_cbc_copy_mac copies |md_size| bytes from the end of the record in * |recdata| to |*mac| in constant time (independent of the concrete value of * the record length |reclen|, which may vary within a 256-byte window). * * On entry: * origreclen >= mac_size * mac_size <= EVP_MAX_MD_SIZE * * If CBC_MAC_ROTATE_IN_PLACE is defined then the rotation is performed with * variable accesses in a 64-byte-aligned buffer. Assuming that this fits into * a single or pair of cache-lines, then the variable memory accesses don't * actually affect the timing. CPUs with smaller cache-lines [if any] are * not multi-core and are not considered vulnerable to cache-timing attacks. */ #define CBC_MAC_ROTATE_IN_PLACE static int ssl3_cbc_copy_mac(size_t *reclen, size_t origreclen, unsigned char *recdata, unsigned char **mac, int *alloced, size_t block_size, size_t mac_size, size_t good, OSSL_LIB_CTX *libctx) { #if defined(CBC_MAC_ROTATE_IN_PLACE) unsigned char rotated_mac_buf[64 + EVP_MAX_MD_SIZE]; unsigned char *rotated_mac; char aux1, aux2, aux3, mask; #else unsigned char rotated_mac[EVP_MAX_MD_SIZE]; #endif unsigned char randmac[EVP_MAX_MD_SIZE]; unsigned char *out; /* * mac_end is the index of |recdata| just after the end of the MAC. */ size_t mac_end = *reclen; size_t mac_start = mac_end - mac_size; size_t in_mac; /* * scan_start contains the number of bytes that we can ignore because the * MAC's position can only vary by 255 bytes. */ size_t scan_start = 0; size_t i, j; size_t rotate_offset; if (!ossl_assert(origreclen >= mac_size && mac_size <= EVP_MAX_MD_SIZE)) return 0; /* If no MAC then nothing to be done */ if (mac_size == 0) { /* No MAC so we can do this in non-constant time */ if (good == 0) return 0; return 1; } *reclen -= mac_size; if (block_size == 1) { /* There's no padding so the position of the MAC is fixed */ if (mac != NULL) *mac = &recdata[*reclen]; if (alloced != NULL) *alloced = 0; return 1; } /* Create the random MAC we will emit if padding is bad */ if (RAND_bytes_ex(libctx, randmac, mac_size, 0) <= 0) return 0; if (!ossl_assert(mac != NULL && alloced != NULL)) return 0; *mac = out = OPENSSL_malloc(mac_size); if (*mac == NULL) return 0; *alloced = 1; #if defined(CBC_MAC_ROTATE_IN_PLACE) rotated_mac = rotated_mac_buf + ((0 - (size_t)rotated_mac_buf) & 63); #endif /* This information is public so it's safe to branch based on it. */ if (origreclen > mac_size + 255 + 1) scan_start = origreclen - (mac_size + 255 + 1); in_mac = 0; rotate_offset = 0; memset(rotated_mac, 0, mac_size); for (i = scan_start, j = 0; i < origreclen; i++) { size_t mac_started = constant_time_eq_s(i, mac_start); size_t mac_ended = constant_time_lt_s(i, mac_end); unsigned char b = recdata[i]; in_mac |= mac_started; in_mac &= mac_ended; rotate_offset |= j & mac_started; rotated_mac[j++] |= b & in_mac; j &= constant_time_lt_s(j, mac_size); } /* Now rotate the MAC */ #if defined(CBC_MAC_ROTATE_IN_PLACE) j = 0; for (i = 0; i < mac_size; i++) { /* * in case cache-line is 32 bytes, * load from both lines and select appropriately */ aux1 = rotated_mac[rotate_offset & ~32]; aux2 = rotated_mac[rotate_offset | 32]; mask = constant_time_eq_8(rotate_offset & ~32, rotate_offset); aux3 = constant_time_select_8(mask, aux1, aux2); rotate_offset++; /* If the padding wasn't good we emit a random MAC */ out[j++] = constant_time_select_8((unsigned char)(good & 0xff), aux3, randmac[i]); rotate_offset &= constant_time_lt_s(rotate_offset, mac_size); } #else memset(out, 0, mac_size); rotate_offset = mac_size - rotate_offset; rotate_offset &= constant_time_lt_s(rotate_offset, mac_size); for (i = 0; i < mac_size; i++) { for (j = 0; j < mac_size; j++) out[j] |= rotated_mac[i] & constant_time_eq_8_s(j, rotate_offset); rotate_offset++; rotate_offset &= constant_time_lt_s(rotate_offset, mac_size); /* If the padding wasn't good we emit a random MAC */ out[i] = constant_time_select_8((unsigned char)(good & 0xff), out[i], randmac[i]); } #endif return 1; }

./openssl/ssl/record/methods/ssl3_meth.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/evp.h> #include <openssl/core_names.h> #include "internal/ssl3_cbc.h" #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" static int ssl3_set_crypto_state(OSSL_RECORD_LAYER *rl, int level, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp) { EVP_CIPHER_CTX *ciph_ctx; int enc = (rl->direction == OSSL_RECORD_DIRECTION_WRITE) ? 1 : 0; if (md == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } if ((rl->enc_ctx = EVP_CIPHER_CTX_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } ciph_ctx = rl->enc_ctx; rl->md_ctx = EVP_MD_CTX_new(); if (rl->md_ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } if ((md != NULL && EVP_DigestInit_ex(rl->md_ctx, md, NULL) <= 0)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } #ifndef OPENSSL_NO_COMP if (comp != NULL) { rl->compctx = COMP_CTX_new(comp); if (rl->compctx == NULL) { ERR_raise(ERR_LIB_SSL, SSL_R_COMPRESSION_LIBRARY_ERROR); return OSSL_RECORD_RETURN_FATAL; } } #endif if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, key, iv, enc)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } /* * The cipher we actually ended up using in the EVP_CIPHER_CTX may be * different to that in ciph if we have an ENGINE in use */ if (EVP_CIPHER_get0_provider(EVP_CIPHER_CTX_get0_cipher(ciph_ctx)) != NULL && !ossl_set_tls_provider_parameters(rl, ciph_ctx, ciph, md)) { /* ERR_raise already called */ return OSSL_RECORD_RETURN_FATAL; } if (mackeylen > sizeof(rl->mac_secret)) { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } memcpy(rl->mac_secret, mackey, mackeylen); return OSSL_RECORD_RETURN_SUCCESS; } /* * ssl3_cipher encrypts/decrypts |n_recs| records in |inrecs|. Calls RLAYERfatal * on internal error, but not otherwise. It is the responsibility of the caller * to report a bad_record_mac * * Returns: * 0: if the record is publicly invalid, or an internal error * 1: Success or Mac-then-encrypt decryption failed (MAC will be randomised) */ static int ssl3_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *inrecs, size_t n_recs, int sending, SSL_MAC_BUF *mac, size_t macsize) { TLS_RL_RECORD *rec; EVP_CIPHER_CTX *ds; size_t l, i; size_t bs; const EVP_CIPHER *enc; int provided; rec = inrecs; /* * We shouldn't ever be called with more than one record in the SSLv3 case */ if (n_recs != 1) return 0; ds = rl->enc_ctx; if (ds == NULL || (enc = EVP_CIPHER_CTX_get0_cipher(ds)) == NULL) return 0; provided = (EVP_CIPHER_get0_provider(enc) != NULL); l = rec->length; bs = EVP_CIPHER_CTX_get_block_size(ds); /* COMPRESS */ if ((bs != 1) && sending && !provided) { /* * We only do this for legacy ciphers. Provided ciphers add the * padding on the provider side. */ i = bs - (l % bs); /* we need to add 'i-1' padding bytes */ l += i; /* * the last of these zero bytes will be overwritten with the * padding length. */ memset(&rec->input[rec->length], 0, i); rec->length += i; rec->input[l - 1] = (unsigned char)(i - 1); } if (!sending) { if (l == 0 || l % bs != 0) { /* Publicly invalid */ return 0; } /* otherwise, rec->length >= bs */ } if (provided) { int outlen; if (!EVP_CipherUpdate(ds, rec->data, &outlen, rec->input, (unsigned int)l)) return 0; rec->length = outlen; if (!sending && mac != NULL) { /* Now get a pointer to the MAC */ OSSL_PARAM params[2], *p = params; /* Get the MAC */ mac->alloced = 0; *p++ = OSSL_PARAM_construct_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, (void **)&mac->mac, macsize); *p = OSSL_PARAM_construct_end(); if (!EVP_CIPHER_CTX_get_params(ds, params)) { /* Shouldn't normally happen */ RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } } } else { if (EVP_Cipher(ds, rec->data, rec->input, (unsigned int)l) < 1) { /* Shouldn't happen */ RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, ERR_R_INTERNAL_ERROR); return 0; } if (!sending) return ssl3_cbc_remove_padding_and_mac(&rec->length, rec->orig_len, rec->data, (mac != NULL) ? &mac->mac : NULL, (mac != NULL) ? &mac->alloced : NULL, bs, macsize, rl->libctx); } return 1; } static const unsigned char ssl3_pad_1[48] = { 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36 }; static const unsigned char ssl3_pad_2[48] = { 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c }; static int ssl3_mac(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md, int sending) { unsigned char *mac_sec, *seq = rl->sequence; const EVP_MD_CTX *hash; unsigned char *p, rec_char; size_t md_size; size_t npad; int t; mac_sec = &(rl->mac_secret[0]); hash = rl->md_ctx; t = EVP_MD_CTX_get_size(hash); if (t <= 0) return 0; md_size = t; npad = (48 / md_size) * md_size; if (!sending && EVP_CIPHER_CTX_get_mode(rl->enc_ctx) == EVP_CIPH_CBC_MODE && ssl3_cbc_record_digest_supported(hash)) { #ifdef OPENSSL_NO_DEPRECATED_3_0 return 0; #else /* * This is a CBC-encrypted record. We must avoid leaking any * timing-side channel information about how many blocks of data we * are hashing because that gives an attacker a timing-oracle. */ /*- * npad is, at most, 48 bytes and that's with MD5: * 16 + 48 + 8 (sequence bytes) + 1 + 2 = 75. * * With SHA-1 (the largest hash speced for SSLv3) the hash size * goes up 4, but npad goes down by 8, resulting in a smaller * total size. */ unsigned char header[75]; size_t j = 0; memcpy(header + j, mac_sec, md_size); j += md_size; memcpy(header + j, ssl3_pad_1, npad); j += npad; memcpy(header + j, seq, 8); j += 8; header[j++] = rec->type; header[j++] = (unsigned char)(rec->length >> 8); header[j++] = (unsigned char)(rec->length & 0xff); /* Final param == is SSLv3 */ if (ssl3_cbc_digest_record(EVP_MD_CTX_get0_md(hash), md, &md_size, header, rec->input, rec->length, rec->orig_len, mac_sec, md_size, 1) <= 0) return 0; #endif } else { unsigned int md_size_u; /* Chop the digest off the end :-) */ EVP_MD_CTX *md_ctx = EVP_MD_CTX_new(); if (md_ctx == NULL) return 0; rec_char = rec->type; p = md; s2n(rec->length, p); if (EVP_MD_CTX_copy_ex(md_ctx, hash) <= 0 || EVP_DigestUpdate(md_ctx, mac_sec, md_size) <= 0 || EVP_DigestUpdate(md_ctx, ssl3_pad_1, npad) <= 0 || EVP_DigestUpdate(md_ctx, seq, 8) <= 0 || EVP_DigestUpdate(md_ctx, &rec_char, 1) <= 0 || EVP_DigestUpdate(md_ctx, md, 2) <= 0 || EVP_DigestUpdate(md_ctx, rec->input, rec->length) <= 0 || EVP_DigestFinal_ex(md_ctx, md, NULL) <= 0 || EVP_MD_CTX_copy_ex(md_ctx, hash) <= 0 || EVP_DigestUpdate(md_ctx, mac_sec, md_size) <= 0 || EVP_DigestUpdate(md_ctx, ssl3_pad_2, npad) <= 0 || EVP_DigestUpdate(md_ctx, md, md_size) <= 0 || EVP_DigestFinal_ex(md_ctx, md, &md_size_u) <= 0) { EVP_MD_CTX_free(md_ctx); return 0; } EVP_MD_CTX_free(md_ctx); } if (!tls_increment_sequence_ctr(rl)) return 0; return 1; } struct record_functions_st ssl_3_0_funcs = { ssl3_set_crypto_state, ssl3_cipher, ssl3_mac, tls_default_set_protocol_version, tls_default_read_n, tls_get_more_records, tls_default_validate_record_header, tls_default_post_process_record, tls_get_max_records_default, tls_write_records_default, /* These 2 functions are defined in tls1_meth.c */ tls1_allocate_write_buffers, tls1_initialise_write_packets, NULL, tls_prepare_record_header_default, NULL, tls_prepare_for_encryption_default, tls_post_encryption_processing_default, NULL };

./openssl/ssl/record/methods/dtls_meth.c

/* * Copyright 2018-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <assert.h> #include "../../ssl_local.h" #include "../record_local.h" #include "recmethod_local.h" /* mod 128 saturating subtract of two 64-bit values in big-endian order */ static int satsub64be(const unsigned char *v1, const unsigned char *v2) { int64_t ret; uint64_t l1, l2; n2l8(v1, l1); n2l8(v2, l2); ret = l1 - l2; /* We do not permit wrap-around */ if (l1 > l2 && ret < 0) return 128; else if (l2 > l1 && ret > 0) return -128; if (ret > 128) return 128; else if (ret < -128) return -128; else return (int)ret; } static int dtls_record_replay_check(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap) { int cmp; unsigned int shift; const unsigned char *seq = rl->sequence; cmp = satsub64be(seq, bitmap->max_seq_num); if (cmp > 0) { ossl_tls_rl_record_set_seq_num(&rl->rrec[0], seq); return 1; /* this record in new */ } shift = -cmp; if (shift >= sizeof(bitmap->map) * 8) return 0; /* stale, outside the window */ else if (bitmap->map & ((uint64_t)1 << shift)) return 0; /* record previously received */ ossl_tls_rl_record_set_seq_num(&rl->rrec[0], seq); return 1; } static void dtls_record_bitmap_update(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap) { int cmp; unsigned int shift; const unsigned char *seq = rl->sequence; cmp = satsub64be(seq, bitmap->max_seq_num); if (cmp > 0) { shift = cmp; if (shift < sizeof(bitmap->map) * 8) bitmap->map <<= shift, bitmap->map |= 1UL; else bitmap->map = 1UL; memcpy(bitmap->max_seq_num, seq, SEQ_NUM_SIZE); } else { shift = -cmp; if (shift < sizeof(bitmap->map) * 8) bitmap->map |= (uint64_t)1 << shift; } } static DTLS_BITMAP *dtls_get_bitmap(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rr, unsigned int *is_next_epoch) { *is_next_epoch = 0; /* In current epoch, accept HM, CCS, DATA, & ALERT */ if (rr->epoch == rl->epoch) return &rl->bitmap; /* * We can only handle messages from the next epoch if we have already * processed all of the unprocessed records from the previous epoch */ else if (rr->epoch == (unsigned long)(rl->epoch + 1) && rl->unprocessed_rcds.epoch != rl->epoch) { *is_next_epoch = 1; return &rl->next_bitmap; } return NULL; } static void dtls_set_in_init(OSSL_RECORD_LAYER *rl, int in_init) { rl->in_init = in_init; } static int dtls_process_record(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap) { int i; int enc_err; TLS_RL_RECORD *rr; int imac_size; size_t mac_size = 0; unsigned char md[EVP_MAX_MD_SIZE]; SSL_MAC_BUF macbuf = { NULL, 0 }; int ret = 0; rr = &rl->rrec[0]; /* * At this point, rl->packet_length == DTLS1_RT_HEADER_LENGTH + rr->length, * and we have that many bytes in rl->packet */ rr->input = &(rl->packet[DTLS1_RT_HEADER_LENGTH]); /* * ok, we can now read from 'rl->packet' data into 'rr'. rr->input * points at rr->length bytes, which need to be copied into rr->data by * either the decryption or by the decompression. When the data is 'copied' * into the rr->data buffer, rr->input will be pointed at the new buffer */ /* * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length * bytes of encrypted compressed stuff. */ /* check is not needed I believe */ if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_ENCRYPTED_LENGTH_TOO_LONG); return 0; } /* decrypt in place in 'rr->input' */ rr->data = rr->input; rr->orig_len = rr->length; if (rl->md_ctx != NULL) { const EVP_MD *tmpmd = EVP_MD_CTX_get0_md(rl->md_ctx); if (tmpmd != NULL) { imac_size = EVP_MD_get_size(tmpmd); if (!ossl_assert(imac_size >= 0 && imac_size <= EVP_MAX_MD_SIZE)) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB); return 0; } mac_size = (size_t)imac_size; } } if (rl->use_etm && rl->md_ctx != NULL) { unsigned char *mac; if (rr->orig_len < mac_size) { RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT); return 0; } rr->length -= mac_size; mac = rr->data + rr->length; i = rl->funcs->mac(rl, rr, md, 0 /* not send */); if (i == 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) { RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC, SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC); return 0; } /* * We've handled the mac now - there is no MAC inside the encrypted * record */ mac_size = 0; } /* * Set a mark around the packet decryption attempt. This is DTLS, so * bad packets are just ignored, and we don't want to leave stray * errors in the queue from processing bogus junk that we ignored. */ ERR_set_mark(); enc_err = rl->funcs->cipher(rl, rr, 1, 0, &macbuf, mac_size); /*- * enc_err is: * 0: if the record is publicly invalid, or an internal error, or AEAD * decryption failed, or ETM decryption failed. * 1: Success or MTE decryption failed (MAC will be randomised) */ if (enc_err == 0) { ERR_pop_to_mark(); if (rl->alert != SSL_AD_NO_ALERT) { /* RLAYERfatal() already called */ goto end; } /* For DTLS we simply ignore bad packets. */ rr->length = 0; rl->packet_length = 0; goto end; } ERR_clear_last_mark(); OSSL_TRACE_BEGIN(TLS) { BIO_printf(trc_out, "dec %zd\n", rr->length); BIO_dump_indent(trc_out, rr->data, rr->length, 4); } OSSL_TRACE_END(TLS); /* r->length is now the compressed data plus mac */ if (!rl->use_etm && (rl->enc_ctx != NULL) && (EVP_MD_CTX_get0_md(rl->md_ctx) != NULL)) { /* rl->md_ctx != NULL => mac_size != -1 */ i = rl->funcs->mac(rl, rr, md, 0 /* not send */); if (i == 0 || macbuf.mac == NULL || CRYPTO_memcmp(md, macbuf.mac, mac_size) != 0) enc_err = 0; if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size) enc_err = 0; } if (enc_err == 0) { /* decryption failed, silently discard message */ rr->length = 0; rl->packet_length = 0; goto end; } /* r->length is now just compressed */ if (rl->compctx != NULL) { if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_COMPRESSED_LENGTH_TOO_LONG); goto end; } if (!tls_do_uncompress(rl, rr)) { RLAYERfatal(rl, SSL_AD_DECOMPRESSION_FAILURE, SSL_R_BAD_DECOMPRESSION); goto end; } } /* * Check if the received packet overflows the current Max Fragment * Length setting. */ if (rr->length > rl->max_frag_len) { RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG); goto end; } rr->off = 0; /*- * So at this point the following is true * ssl->s3.rrec.type is the type of record * ssl->s3.rrec.length == number of bytes in record * ssl->s3.rrec.off == offset to first valid byte * ssl->s3.rrec.data == where to take bytes from, increment * after use :-). */ /* we have pulled in a full packet so zero things */ rl->packet_length = 0; /* Mark receipt of record. */ dtls_record_bitmap_update(rl, bitmap); ret = 1; end: if (macbuf.alloced) OPENSSL_free(macbuf.mac); return ret; } static int dtls_rlayer_buffer_record(OSSL_RECORD_LAYER *rl, record_pqueue *queue, unsigned char *priority) { DTLS_RLAYER_RECORD_DATA *rdata; pitem *item; /* Limit the size of the queue to prevent DOS attacks */ if (pqueue_size(queue->q) >= 100) return 0; rdata = OPENSSL_malloc(sizeof(*rdata)); item = pitem_new(priority, rdata); if (rdata == NULL || item == NULL) { OPENSSL_free(rdata); pitem_free(item); RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return -1; } rdata->packet = rl->packet; rdata->packet_length = rl->packet_length; memcpy(&(rdata->rbuf), &rl->rbuf, sizeof(TLS_BUFFER)); memcpy(&(rdata->rrec), &rl->rrec[0], sizeof(TLS_RL_RECORD)); item->data = rdata; rl->packet = NULL; rl->packet_length = 0; memset(&rl->rbuf, 0, sizeof(TLS_BUFFER)); memset(&rl->rrec[0], 0, sizeof(rl->rrec[0])); if (!tls_setup_read_buffer(rl)) { /* RLAYERfatal() already called */ OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(rdata); pitem_free(item); return -1; } if (pqueue_insert(queue->q, item) == NULL) { /* Must be a duplicate so ignore it */ OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(rdata); pitem_free(item); } return 1; } /* copy buffered record into OSSL_RECORD_LAYER structure */ static int dtls_copy_rlayer_record(OSSL_RECORD_LAYER *rl, pitem *item) { DTLS_RLAYER_RECORD_DATA *rdata; rdata = (DTLS_RLAYER_RECORD_DATA *)item->data; ossl_tls_buffer_release(&rl->rbuf); rl->packet = rdata->packet; rl->packet_length = rdata->packet_length; memcpy(&rl->rbuf, &(rdata->rbuf), sizeof(TLS_BUFFER)); memcpy(&rl->rrec[0], &(rdata->rrec), sizeof(TLS_RL_RECORD)); /* Set proper sequence number for mac calculation */ memcpy(&(rl->sequence[2]), &(rdata->packet[5]), 6); return 1; } static int dtls_retrieve_rlayer_buffered_record(OSSL_RECORD_LAYER *rl, record_pqueue *queue) { pitem *item; item = pqueue_pop(queue->q); if (item) { dtls_copy_rlayer_record(rl, item); OPENSSL_free(item->data); pitem_free(item); return 1; } return 0; } /*- * Call this to get a new input record. * It will return <= 0 if more data is needed, normally due to an error * or non-blocking IO. * When it finishes, one packet has been decoded and can be found in * ssl->s3.rrec.type - is the type of record * ssl->s3.rrec.data - data * ssl->s3.rrec.length - number of bytes */ int dtls_get_more_records(OSSL_RECORD_LAYER *rl) { int ssl_major, ssl_minor; int rret; size_t more, n; TLS_RL_RECORD *rr; unsigned char *p = NULL; DTLS_BITMAP *bitmap; unsigned int is_next_epoch; rl->num_recs = 0; rl->curr_rec = 0; rl->num_released = 0; rr = rl->rrec; if (rl->rbuf.buf == NULL) { if (!tls_setup_read_buffer(rl)) { /* RLAYERfatal() already called */ return OSSL_RECORD_RETURN_FATAL; } } again: /* if we're renegotiating, then there may be buffered records */ if (dtls_retrieve_rlayer_buffered_record(rl, &rl->processed_rcds)) { rl->num_recs = 1; return OSSL_RECORD_RETURN_SUCCESS; } /* get something from the wire */ /* check if we have the header */ if ((rl->rstate != SSL_ST_READ_BODY) || (rl->packet_length < DTLS1_RT_HEADER_LENGTH)) { rret = rl->funcs->read_n(rl, DTLS1_RT_HEADER_LENGTH, TLS_BUFFER_get_len(&rl->rbuf), 0, 1, &n); /* read timeout is handled by dtls1_read_bytes */ if (rret < OSSL_RECORD_RETURN_SUCCESS) { /* RLAYERfatal() already called if appropriate */ return rret; /* error or non-blocking */ } /* this packet contained a partial record, dump it */ if (rl->packet_length != DTLS1_RT_HEADER_LENGTH) { rl->packet_length = 0; goto again; } rl->rstate = SSL_ST_READ_BODY; p = rl->packet; /* Pull apart the header into the DTLS1_RECORD */ rr->type = *(p++); ssl_major = *(p++); ssl_minor = *(p++); rr->rec_version = (ssl_major << 8) | ssl_minor; /* sequence number is 64 bits, with top 2 bytes = epoch */ n2s(p, rr->epoch); memcpy(&(rl->sequence[2]), p, 6); p += 6; n2s(p, rr->length); if (rl->msg_callback != NULL) rl->msg_callback(0, rr->rec_version, SSL3_RT_HEADER, rl->packet, DTLS1_RT_HEADER_LENGTH, rl->cbarg); /* * Lets check the version. We tolerate alerts that don't have the exact * version number (e.g. because of protocol version errors) */ if (!rl->is_first_record && rr->type != SSL3_RT_ALERT) { if (rr->rec_version != rl->version) { /* unexpected version, silently discard */ rr->length = 0; rl->packet_length = 0; goto again; } } if (ssl_major != (rl->version == DTLS_ANY_VERSION ? DTLS1_VERSION_MAJOR : rl->version >> 8)) { /* wrong version, silently discard record */ rr->length = 0; rl->packet_length = 0; goto again; } if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) { /* record too long, silently discard it */ rr->length = 0; rl->packet_length = 0; goto again; } /* * If received packet overflows maximum possible fragment length then * silently discard it */ if (rr->length > rl->max_frag_len + SSL3_RT_MAX_ENCRYPTED_OVERHEAD) { /* record too long, silently discard it */ rr->length = 0; rl->packet_length = 0; goto again; } /* now rl->rstate == SSL_ST_READ_BODY */ } /* rl->rstate == SSL_ST_READ_BODY, get and decode the data */ if (rr->length > rl->packet_length - DTLS1_RT_HEADER_LENGTH) { /* now rl->packet_length == DTLS1_RT_HEADER_LENGTH */ more = rr->length; rret = rl->funcs->read_n(rl, more, more, 1, 1, &n); /* this packet contained a partial record, dump it */ if (rret < OSSL_RECORD_RETURN_SUCCESS || n != more) { if (rl->alert != SSL_AD_NO_ALERT) { /* read_n() called RLAYERfatal() */ return OSSL_RECORD_RETURN_FATAL; } rr->length = 0; rl->packet_length = 0; goto again; } /* * now n == rr->length, * and rl->packet_length == DTLS1_RT_HEADER_LENGTH + rr->length */ } /* set state for later operations */ rl->rstate = SSL_ST_READ_HEADER; /* match epochs. NULL means the packet is dropped on the floor */ bitmap = dtls_get_bitmap(rl, rr, &is_next_epoch); if (bitmap == NULL) { rr->length = 0; rl->packet_length = 0; /* dump this record */ goto again; /* get another record */ } #ifndef OPENSSL_NO_SCTP /* Only do replay check if no SCTP bio */ if (!BIO_dgram_is_sctp(rl->bio)) { #endif /* Check whether this is a repeat, or aged record. */ if (!dtls_record_replay_check(rl, bitmap)) { rr->length = 0; rl->packet_length = 0; /* dump this record */ goto again; /* get another record */ } #ifndef OPENSSL_NO_SCTP } #endif /* just read a 0 length packet */ if (rr->length == 0) goto again; /* * If this record is from the next epoch (either HM or ALERT), and a * handshake is currently in progress, buffer it since it cannot be * processed at this time. */ if (is_next_epoch) { if (rl->in_init) { if (dtls_rlayer_buffer_record(rl, &(rl->unprocessed_rcds), rr->seq_num) < 0) { /* RLAYERfatal() already called */ return OSSL_RECORD_RETURN_FATAL; } } rr->length = 0; rl->packet_length = 0; goto again; } if (!dtls_process_record(rl, bitmap)) { if (rl->alert != SSL_AD_NO_ALERT) { /* dtls_process_record() called RLAYERfatal */ return OSSL_RECORD_RETURN_FATAL; } rr->length = 0; rl->packet_length = 0; /* dump this record */ goto again; /* get another record */ } if (rl->funcs->post_process_record && !rl->funcs->post_process_record(rl, rr)) { /* RLAYERfatal already called */ return OSSL_RECORD_RETURN_FATAL; } rl->num_recs = 1; return OSSL_RECORD_RETURN_SUCCESS; } static int dtls_free(OSSL_RECORD_LAYER *rl) { TLS_BUFFER *rbuf; size_t left, written; pitem *item; DTLS_RLAYER_RECORD_DATA *rdata; int ret = 1; rbuf = &rl->rbuf; left = rbuf->left; if (left > 0) { /* * This record layer is closing but we still have data left in our * buffer. It must be destined for the next epoch - so push it there. */ ret = BIO_write_ex(rl->next, rbuf->buf + rbuf->offset, left, &written); rbuf->left = 0; } if (rl->unprocessed_rcds.q != NULL) { while ((item = pqueue_pop(rl->unprocessed_rcds.q)) != NULL) { rdata = (DTLS_RLAYER_RECORD_DATA *)item->data; /* Push to the next record layer */ ret &= BIO_write_ex(rl->next, rdata->packet, rdata->packet_length, &written); OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(item->data); pitem_free(item); } pqueue_free(rl->unprocessed_rcds.q); } if (rl->processed_rcds.q != NULL) { while ((item = pqueue_pop(rl->processed_rcds.q)) != NULL) { rdata = (DTLS_RLAYER_RECORD_DATA *)item->data; OPENSSL_free(rdata->rbuf.buf); OPENSSL_free(item->data); pitem_free(item); } pqueue_free(rl->processed_rcds.q); } return tls_free(rl) && ret; } static int dtls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers, int role, int direction, int level, uint16_t epoch, unsigned char *secret, size_t secretlen, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp, const EVP_MD *kdfdigest, BIO *prev, BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer, const OSSL_PARAM *settings, const OSSL_PARAM *options, const OSSL_DISPATCH *fns, void *cbarg, void *rlarg, OSSL_RECORD_LAYER **retrl) { int ret; ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp, prev, transport, next, local, peer, settings, options, fns, cbarg, retrl); if (ret != OSSL_RECORD_RETURN_SUCCESS) return ret; (*retrl)->unprocessed_rcds.q = pqueue_new(); (*retrl)->processed_rcds.q = pqueue_new(); if ((*retrl)->unprocessed_rcds.q == NULL || (*retrl)->processed_rcds.q == NULL) { dtls_free(*retrl); *retrl = NULL; ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB); return OSSL_RECORD_RETURN_FATAL; } (*retrl)->unprocessed_rcds.epoch = epoch + 1; (*retrl)->processed_rcds.epoch = epoch; (*retrl)->isdtls = 1; (*retrl)->epoch = epoch; (*retrl)->in_init = 1; switch (vers) { case DTLS_ANY_VERSION: (*retrl)->funcs = &dtls_any_funcs; break; case DTLS1_2_VERSION: case DTLS1_VERSION: case DTLS1_BAD_VER: (*retrl)->funcs = &dtls_1_funcs; break; default: /* Should not happen */ ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); ret = OSSL_RECORD_RETURN_FATAL; goto err; } ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv, ivlen, mackey, mackeylen, ciph, taglen, mactype, md, comp); err: if (ret != OSSL_RECORD_RETURN_SUCCESS) { dtls_free(*retrl); *retrl = NULL; } return ret; } int dtls_prepare_record_header(OSSL_RECORD_LAYER *rl, WPACKET *thispkt, OSSL_RECORD_TEMPLATE *templ, uint8_t rectype, unsigned char **recdata) { size_t maxcomplen; *recdata = NULL; maxcomplen = templ->buflen; if (rl->compctx != NULL) maxcomplen += SSL3_RT_MAX_COMPRESSED_OVERHEAD; if (!WPACKET_put_bytes_u8(thispkt, rectype) || !WPACKET_put_bytes_u16(thispkt, templ->version) || !WPACKET_put_bytes_u16(thispkt, rl->epoch) || !WPACKET_memcpy(thispkt, &(rl->sequence[2]), 6) || !WPACKET_start_sub_packet_u16(thispkt) || (rl->eivlen > 0 && !WPACKET_allocate_bytes(thispkt, rl->eivlen, NULL)) || (maxcomplen > 0 && !WPACKET_reserve_bytes(thispkt, maxcomplen, recdata))) { RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } int dtls_post_encryption_processing(OSSL_RECORD_LAYER *rl, size_t mac_size, OSSL_RECORD_TEMPLATE *thistempl, WPACKET *thispkt, TLS_RL_RECORD *thiswr) { if (!tls_post_encryption_processing_default(rl, mac_size, thistempl, thispkt, thiswr)) { /* RLAYERfatal() already called */ return 0; } return tls_increment_sequence_ctr(rl); } static size_t dtls_get_max_record_overhead(OSSL_RECORD_LAYER *rl) { size_t blocksize = 0; if (rl->enc_ctx != NULL && (EVP_CIPHER_CTX_get_mode(rl->enc_ctx) == EVP_CIPH_CBC_MODE)) blocksize = EVP_CIPHER_CTX_get_block_size(rl->enc_ctx); /* * If we have a cipher in place then the tag is mandatory. If the cipher is * CBC mode then an explicit IV is also mandatory. If we know the digest, * then we check it is consistent with the taglen. In the case of stitched * ciphers or AEAD ciphers we don't now the digest (or there isn't one) so * we just trust that the taglen is correct. */ assert(rl->enc_ctx == NULL || ((blocksize == 0 || rl->eivlen > 0) && rl->taglen > 0)); assert(rl->md == NULL || (int)rl->taglen == EVP_MD_size(rl->md)); /* * Record overhead consists of the record header, the explicit IV, any * expansion due to cbc padding, and the mac/tag len. There could be * further expansion due to compression - but we don't know what this will * be without knowing the length of the data. However when this function is * called we don't know what the length will be yet - so this is a catch-22. * We *could* use SSL_3_RT_MAX_COMPRESSED_OVERHEAD which is an upper limit * for the maximum record size. But this value is larger than our fallback * MTU size - so isn't very helpful. We just ignore potential expansion * due to compression. */ return DTLS1_RT_HEADER_LENGTH + rl->eivlen + blocksize + rl->taglen; } const OSSL_RECORD_METHOD ossl_dtls_record_method = { dtls_new_record_layer, dtls_free, tls_unprocessed_read_pending, tls_processed_read_pending, tls_app_data_pending, tls_get_max_records, tls_write_records, tls_retry_write_records, tls_read_record, tls_release_record, tls_get_alert_code, tls_set1_bio, tls_set_protocol_version, NULL, tls_set_first_handshake, tls_set_max_pipelines, dtls_set_in_init, tls_get_state, tls_set_options, tls_get_compression, tls_set_max_frag_len, dtls_get_max_record_overhead, tls_increment_sequence_ctr, tls_alloc_buffers, tls_free_buffers };

./openssl/ssl/quic/quic_rx_depack.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/packet_quic.h" #include "internal/nelem.h" #include "internal/quic_wire.h" #include "internal/quic_record_rx.h" #include "internal/quic_ackm.h" #include "internal/quic_rx_depack.h" #include "internal/quic_error.h" #include "internal/quic_fc.h" #include "internal/quic_channel.h" #include "internal/sockets.h" #include "quic_local.h" #include "quic_channel_local.h" #include "../ssl_local.h" /* * Helper functions to process different frame types. * * Typically, those that are ACK eliciting will take an OSSL_ACKM_RX_PKT * pointer argument, the few that aren't ACK eliciting will not. This makes * them a verifiable pattern against tables where this is specified. */ static int depack_do_implicit_stream_create(QUIC_CHANNEL *ch, uint64_t stream_id, uint64_t frame_type, QUIC_STREAM **result); static int depack_do_frame_padding(PACKET *pkt) { /* We ignore this frame */ ossl_quic_wire_decode_padding(pkt); return 1; } static int depack_do_frame_ping(PACKET *pkt, QUIC_CHANNEL *ch, uint32_t enc_level, OSSL_ACKM_RX_PKT *ackm_data) { /* We ignore this frame, apart from eliciting an ACK */ if (!ossl_quic_wire_decode_frame_ping(pkt)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_PING, "decode error"); return 0; } ossl_quic_tx_packetiser_schedule_ack_eliciting(ch->txp, enc_level); return 1; } static int depack_do_frame_ack(PACKET *pkt, QUIC_CHANNEL *ch, int packet_space, OSSL_TIME received, uint64_t frame_type, OSSL_QRX_PKT *qpacket) { OSSL_QUIC_FRAME_ACK ack; OSSL_QUIC_ACK_RANGE *p; uint64_t total_ranges = 0; uint32_t ack_delay_exp = ch->rx_ack_delay_exp; if (!ossl_quic_wire_peek_frame_ack_num_ranges(pkt, &total_ranges) /* In case sizeof(uint64_t) > sizeof(size_t) */ || total_ranges > SIZE_MAX / sizeof(OSSL_QUIC_ACK_RANGE)) goto malformed; if (ch->num_ack_range_scratch < (size_t)total_ranges) { if ((p = OPENSSL_realloc(ch->ack_range_scratch, sizeof(OSSL_QUIC_ACK_RANGE) * (size_t)total_ranges)) == NULL) goto malformed; ch->ack_range_scratch = p; ch->num_ack_range_scratch = (size_t)total_ranges; } ack.ack_ranges = ch->ack_range_scratch; ack.num_ack_ranges = (size_t)total_ranges; if (!ossl_quic_wire_decode_frame_ack(pkt, ack_delay_exp, &ack, NULL)) goto malformed; if (qpacket->hdr->type == QUIC_PKT_TYPE_1RTT && (qpacket->key_epoch < ossl_qrx_get_key_epoch(ch->qrx) || ch->rxku_expected) && ack.ack_ranges[0].end >= ch->txku_pn) { /* * RFC 9001 s. 6.2: An endpoint that receives an acknowledgment that is * carried in a packet protected with old keys where any acknowledged * packet was protected with newer keys MAY treat that as a connection * error of type KEY_UPDATE_ERROR. * * Two cases to handle here: * * - We did spontaneous TXKU, the peer has responded in kind and we * have detected RXKU; !ch->rxku_expected, but then it sent a packet * with old keys acknowledging a packet in the new key epoch. * * This also covers the case where we got RXKU and triggered * solicited TXKU, and then for some reason the peer sent an ACK of * a PN in our new TX key epoch with old keys. * * - We did spontaneous TXKU; ch->txku_pn is the starting PN of our * new TX key epoch; the peer has not initiated a solicited TXKU in * response (so we have not detected RXKU); in this case the RX key * epoch has not incremented and ch->rxku_expected is still 1. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_KEY_UPDATE_ERROR, frame_type, "acked packet which initiated a " "key update without a " "corresponding key update"); return 0; } if (!ossl_ackm_on_rx_ack_frame(ch->ackm, &ack, packet_space, received)) goto malformed; ++ch->diag_num_rx_ack; return 1; malformed: ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } static int depack_do_frame_reset_stream(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { OSSL_QUIC_FRAME_RESET_STREAM frame_data; QUIC_STREAM *stream = NULL; uint64_t fce; if (!ossl_quic_wire_decode_frame_reset_stream(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, "decode error"); return 0; } if (!depack_do_implicit_stream_create(ch, frame_data.stream_id, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, &stream)) return 0; /* error already raised for us */ if (stream == NULL) return 1; /* old deleted stream, not a protocol violation, ignore */ if (!ossl_quic_stream_has_recv(stream)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, "RESET_STREAM frame for " "TX only stream"); return 0; } /* * The final size field of the RESET_STREAM frame must be used to determine * how much flow control credit the aborted stream was considered to have * consumed. * * We also need to ensure that if we already have a final size for the * stream, the RESET_STREAM frame's Final Size field matches this; we SHOULD * terminate the connection otherwise (RFC 9000 s. 4.5). The RXFC takes care * of this for us. */ if (!ossl_quic_rxfc_on_rx_stream_frame(&stream->rxfc, frame_data.final_size, /*is_fin=*/1)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, "internal error (flow control)"); return 0; } /* Has a flow control error occurred? */ fce = ossl_quic_rxfc_get_error(&stream->rxfc, 0); if (fce != QUIC_ERR_NO_ERROR) { ossl_quic_channel_raise_protocol_error(ch, fce, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, "flow control violation"); return 0; } /* * Depending on the receive part state this is handled either as a reset * transition or a no-op (e.g. if a reset has already been received before, * or the application already retired a FIN). Best effort - there are no * protocol error conditions we need to check for here. */ ossl_quic_stream_map_notify_reset_recv_part(&ch->qsm, stream, frame_data.app_error_code, frame_data.final_size); ossl_quic_stream_map_update_state(&ch->qsm, stream); return 1; } static int depack_do_frame_stop_sending(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { OSSL_QUIC_FRAME_STOP_SENDING frame_data; QUIC_STREAM *stream = NULL; if (!ossl_quic_wire_decode_frame_stop_sending(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, "decode error"); return 0; } if (!depack_do_implicit_stream_create(ch, frame_data.stream_id, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, &stream)) return 0; /* error already raised for us */ if (stream == NULL) return 1; /* old deleted stream, not a protocol violation, ignore */ if (!ossl_quic_stream_has_send(stream)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, "STOP_SENDING frame for " "RX only stream"); return 0; } stream->peer_stop_sending = 1; stream->peer_stop_sending_aec = frame_data.app_error_code; /* * RFC 9000 s. 3.5: Receiving a STOP_SENDING frame means we must respond in * turn with a RESET_STREAM frame for the same part of the stream. The other * part is unaffected. */ ossl_quic_stream_map_reset_stream_send_part(&ch->qsm, stream, frame_data.app_error_code); return 1; } static int depack_do_frame_crypto(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_QRX_PKT *parent_pkt, OSSL_ACKM_RX_PKT *ackm_data, uint64_t *datalen) { OSSL_QUIC_FRAME_CRYPTO f; QUIC_RSTREAM *rstream; QUIC_RXFC *rxfc; *datalen = 0; if (!ossl_quic_wire_decode_frame_crypto(pkt, 0, &f)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_CRYPTO, "decode error"); return 0; } if (f.len == 0) return 1; /* nothing to do */ rstream = ch->crypto_recv[ackm_data->pkt_space]; if (!ossl_assert(rstream != NULL)) /* * This should not happen; we should only have a NULL stream here if * the EL has been discarded, and if the EL has been discarded we * shouldn't be here. */ return 0; rxfc = &ch->crypto_rxfc[ackm_data->pkt_space]; if (!ossl_quic_rxfc_on_rx_stream_frame(rxfc, f.offset + f.len, /*is_fin=*/0)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_CRYPTO, "internal error (crypto RXFC)"); return 0; } if (ossl_quic_rxfc_get_error(rxfc, 0) != QUIC_ERR_NO_ERROR) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CRYPTO_BUFFER_EXCEEDED, OSSL_QUIC_FRAME_TYPE_CRYPTO, "exceeded maximum crypto buffer"); return 0; } if (!ossl_quic_rstream_queue_data(rstream, parent_pkt, f.offset, f.data, f.len, 0)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_CRYPTO, "internal error (rstream queue)"); return 0; } ch->did_crypto_frame = 1; *datalen = f.len; return 1; } static int depack_do_frame_new_token(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { const uint8_t *token; size_t token_len; if (!ossl_quic_wire_decode_frame_new_token(pkt, &token, &token_len)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, "decode error"); return 0; } if (token_len == 0) { /* * RFC 9000 s. 19.7: "A client MUST treat receipt of a NEW_TOKEN frame * with an empty Token field as a connection error of type * FRAME_ENCODING_ERROR." */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, "zero-length NEW_TOKEN"); return 0; } /* TODO(QUIC FUTURE): ADD CODE to send |token| to the session manager */ return 1; } /* * Returns 1 if no protocol violation has occurred. In this case *result will be * non-NULL unless this is an old deleted stream and we should ignore the frame * causing this function to be called. Returns 0 on protocol violation. */ static int depack_do_implicit_stream_create(QUIC_CHANNEL *ch, uint64_t stream_id, uint64_t frame_type, QUIC_STREAM **result) { QUIC_STREAM *stream; uint64_t peer_role, stream_ordinal; uint64_t *p_next_ordinal_local, *p_next_ordinal_remote; QUIC_RXFC *max_streams_fc; int is_uni, is_remote_init; stream = ossl_quic_stream_map_get_by_id(&ch->qsm, stream_id); if (stream != NULL) { *result = stream; return 1; } /* * If we do not yet have a stream with the given ID, there are three * possibilities: * * (a) The stream ID is for a remotely-created stream and the peer * is creating a stream. * * (b) The stream ID is for a locally-created stream which has * previously been deleted. * * (c) The stream ID is for a locally-created stream which does * not exist yet. This is a protocol violation and we must * terminate the connection in this case. * * We distinguish between (b) and (c) using the stream ID allocator * variable. Since stream ordinals are allocated monotonically, we * simply determine if the stream ordinal is in the future. */ peer_role = ch->is_server ? QUIC_STREAM_INITIATOR_CLIENT : QUIC_STREAM_INITIATOR_SERVER; is_remote_init = ((stream_id & QUIC_STREAM_INITIATOR_MASK) == peer_role); is_uni = ((stream_id & QUIC_STREAM_DIR_MASK) == QUIC_STREAM_DIR_UNI); stream_ordinal = stream_id >> 2; if (is_remote_init) { /* * Peer-created stream which does not yet exist. Create it. QUIC stream * ordinals within a given stream type MUST be used in sequence and * receiving a STREAM frame for ordinal n must implicitly create streams * with ordinals [0, n) within that stream type even if no explicit * STREAM frames are received for those ordinals. */ p_next_ordinal_remote = is_uni ? &ch->next_remote_stream_ordinal_uni : &ch->next_remote_stream_ordinal_bidi; /* Check this isn't violating stream count flow control. */ max_streams_fc = is_uni ? &ch->max_streams_uni_rxfc : &ch->max_streams_bidi_rxfc; if (!ossl_quic_rxfc_on_rx_stream_frame(max_streams_fc, stream_ordinal + 1, /*is_fin=*/0)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (stream count RXFC)"); return 0; } if (ossl_quic_rxfc_get_error(max_streams_fc, 0) != QUIC_ERR_NO_ERROR) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_LIMIT_ERROR, frame_type, "exceeded maximum allowed streams"); return 0; } /* * Create the named stream and any streams coming before it yet to be * created. */ while (*p_next_ordinal_remote <= stream_ordinal) { uint64_t cur_stream_id = (*p_next_ordinal_remote << 2) | (stream_id & (QUIC_STREAM_DIR_MASK | QUIC_STREAM_INITIATOR_MASK)); stream = ossl_quic_channel_new_stream_remote(ch, cur_stream_id); if (stream == NULL) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (stream allocation)"); return 0; } ++*p_next_ordinal_remote; } *result = stream; } else { /* Locally-created stream which does not yet exist. */ p_next_ordinal_local = is_uni ? &ch->next_local_stream_ordinal_uni : &ch->next_local_stream_ordinal_bidi; if (stream_ordinal >= *p_next_ordinal_local) { /* * We never created this stream yet, this is a protocol * violation. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, frame_type, "STREAM frame for nonexistent " "stream"); return 0; } /* * Otherwise this is for an old locally-initiated stream which we * have subsequently deleted. Ignore the data; it may simply be a * retransmission. We already take care of notifying the peer of the * termination of the stream during the stream deletion lifecycle. */ *result = NULL; } return 1; } static int depack_do_frame_stream(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_QRX_PKT *parent_pkt, OSSL_ACKM_RX_PKT *ackm_data, uint64_t frame_type, uint64_t *datalen) { OSSL_QUIC_FRAME_STREAM frame_data; QUIC_STREAM *stream; uint64_t fce; size_t rs_avail; int rs_fin = 0; *datalen = 0; if (!ossl_quic_wire_decode_frame_stream(pkt, 0, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } if (!depack_do_implicit_stream_create(ch, frame_data.stream_id, frame_type, &stream)) return 0; /* protocol error raised by above call */ if (stream == NULL) /* * Data for old stream which is not a protocol violation but should be * ignored, so stop here. */ return 1; if (!ossl_quic_stream_has_recv(stream)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, frame_type, "STREAM frame for TX only " "stream"); return 0; } /* Notify stream flow controller. */ if (!ossl_quic_rxfc_on_rx_stream_frame(&stream->rxfc, frame_data.offset + frame_data.len, frame_data.is_fin)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (flow control)"); return 0; } /* Has a flow control error occurred? */ fce = ossl_quic_rxfc_get_error(&stream->rxfc, 0); if (fce != QUIC_ERR_NO_ERROR) { ossl_quic_channel_raise_protocol_error(ch, fce, frame_type, "flow control violation"); return 0; } switch (stream->recv_state) { case QUIC_RSTREAM_STATE_RECV: case QUIC_RSTREAM_STATE_SIZE_KNOWN: /* * It only makes sense to process incoming STREAM frames in these * states. */ break; case QUIC_RSTREAM_STATE_DATA_RECVD: case QUIC_RSTREAM_STATE_DATA_READ: case QUIC_RSTREAM_STATE_RESET_RECVD: case QUIC_RSTREAM_STATE_RESET_READ: default: /* * We have no use for STREAM frames once the receive part reaches any of * these states, so just ignore. */ return 1; } /* If we are in RECV, auto-transition to SIZE_KNOWN on FIN. */ if (frame_data.is_fin && !ossl_quic_stream_recv_get_final_size(stream, NULL)) { /* State was already checked above, so can't fail. */ ossl_quic_stream_map_notify_size_known_recv_part(&ch->qsm, stream, frame_data.offset + frame_data.len); } /* * If we requested STOP_SENDING do not bother buffering the data. Note that * this must happen after RXFC checks above as even if we sent STOP_SENDING * we must still enforce correct flow control (RFC 9000 s. 3.5). */ if (stream->stop_sending) return 1; /* not an error - packet reordering, etc. */ /* * The receive stream buffer may or may not choose to consume the data * without copying by reffing the OSSL_QRX_PKT. In this case * ossl_qrx_pkt_release() will be eventually called when the data is no * longer needed. * * It is OK for the peer to send us a zero-length non-FIN STREAM frame, * which is a no-op, aside from the fact that it ensures the stream exists. * In this case we have nothing to report to the receive buffer. */ if ((frame_data.len > 0 || frame_data.is_fin) && !ossl_quic_rstream_queue_data(stream->rstream, parent_pkt, frame_data.offset, frame_data.data, frame_data.len, frame_data.is_fin)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (rstream queue)"); return 0; } /* * rs_fin will be 1 only if we can read all data up to and including the FIN * without any gaps before it; this implies we have received all data. Avoid * calling ossl_quic_rstream_available() where it is not necessary as it is * more expensive. */ if (stream->recv_state == QUIC_RSTREAM_STATE_SIZE_KNOWN && !ossl_quic_rstream_available(stream->rstream, &rs_avail, &rs_fin)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, frame_type, "internal error (rstream available)"); return 0; } if (rs_fin) ossl_quic_stream_map_notify_totally_received(&ch->qsm, stream); *datalen = frame_data.len; return 1; } static void update_streams(QUIC_STREAM *s, void *arg) { QUIC_CHANNEL *ch = arg; ossl_quic_stream_map_update_state(&ch->qsm, s); } static void update_streams_bidi(QUIC_STREAM *s, void *arg) { QUIC_CHANNEL *ch = arg; if (!ossl_quic_stream_is_bidi(s)) return; ossl_quic_stream_map_update_state(&ch->qsm, s); } static void update_streams_uni(QUIC_STREAM *s, void *arg) { QUIC_CHANNEL *ch = arg; if (ossl_quic_stream_is_bidi(s)) return; ossl_quic_stream_map_update_state(&ch->qsm, s); } static int depack_do_frame_max_data(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { uint64_t max_data = 0; if (!ossl_quic_wire_decode_frame_max_data(pkt, &max_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_MAX_DATA, "decode error"); return 0; } ossl_quic_txfc_bump_cwm(&ch->conn_txfc, max_data); ossl_quic_stream_map_visit(&ch->qsm, update_streams, ch); return 1; } static int depack_do_frame_max_stream_data(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { uint64_t stream_id = 0; uint64_t max_stream_data = 0; QUIC_STREAM *stream; if (!ossl_quic_wire_decode_frame_max_stream_data(pkt, &stream_id, &max_stream_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, "decode error"); return 0; } if (!depack_do_implicit_stream_create(ch, stream_id, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, &stream)) return 0; /* error already raised for us */ if (stream == NULL) return 1; /* old deleted stream, not a protocol violation, ignore */ if (!ossl_quic_stream_has_send(stream)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, "MAX_STREAM_DATA for TX only " "stream"); return 0; } ossl_quic_txfc_bump_cwm(&stream->txfc, max_stream_data); ossl_quic_stream_map_update_state(&ch->qsm, stream); return 1; } static int depack_do_frame_max_streams(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data, uint64_t frame_type) { uint64_t max_streams = 0; if (!ossl_quic_wire_decode_frame_max_streams(pkt, &max_streams)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } if (max_streams > (((uint64_t)1) << 60)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "invalid max streams value"); return 0; } switch (frame_type) { case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI: if (max_streams > ch->max_local_streams_bidi) ch->max_local_streams_bidi = max_streams; /* Some streams may now be able to send. */ ossl_quic_stream_map_visit(&ch->qsm, update_streams_bidi, ch); break; case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI: if (max_streams > ch->max_local_streams_uni) ch->max_local_streams_uni = max_streams; /* Some streams may now be able to send. */ ossl_quic_stream_map_visit(&ch->qsm, update_streams_uni, ch); break; default: ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } return 1; } static int depack_do_frame_data_blocked(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { uint64_t max_data = 0; if (!ossl_quic_wire_decode_frame_data_blocked(pkt, &max_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED, "decode error"); return 0; } /* No-op - informative/debugging frame. */ return 1; } static int depack_do_frame_stream_data_blocked(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { uint64_t stream_id = 0; uint64_t max_data = 0; QUIC_STREAM *stream; if (!ossl_quic_wire_decode_frame_stream_data_blocked(pkt, &stream_id, &max_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, "decode error"); return 0; } /* * This is an informative/debugging frame, so we don't have to do anything, * but it does trigger stream creation. */ if (!depack_do_implicit_stream_create(ch, stream_id, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, &stream)) return 0; /* error already raised for us */ if (stream == NULL) return 1; /* old deleted stream, not a protocol violation, ignore */ if (!ossl_quic_stream_has_recv(stream)) { /* * RFC 9000 s. 19.14: "An endpoint that receives a STREAM_DATA_BLOCKED * frame for a send-only stream MUST terminate the connection with error * STREAM_STATE_ERROR." */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_STATE_ERROR, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, "STREAM_DATA_BLOCKED frame for " "TX only stream"); return 0; } /* No-op - informative/debugging frame. */ return 1; } static int depack_do_frame_streams_blocked(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data, uint64_t frame_type) { uint64_t max_data = 0; if (!ossl_quic_wire_decode_frame_streams_blocked(pkt, &max_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } if (max_data > (((uint64_t)1) << 60)) { /* * RFC 9000 s. 19.14: "This value cannot exceed 2**60, as it is not * possible to encode stream IDs larger than 2**62 - 1. Receipt of a * frame that encodes a larger stream ID MUST be treated as a connection * error of type STREAM_LIMIT_ERROR or FRAME_ENCODING_ERROR." */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_LIMIT_ERROR, frame_type, "invalid stream count limit"); return 0; } /* No-op - informative/debugging frame. */ return 1; } static int depack_do_frame_new_conn_id(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { OSSL_QUIC_FRAME_NEW_CONN_ID frame_data; if (!ossl_quic_wire_decode_frame_new_conn_id(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "decode error"); return 0; } ossl_quic_channel_on_new_conn_id(ch, &frame_data); return 1; } static int depack_do_frame_retire_conn_id(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { uint64_t seq_num; if (!ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, "decode error"); return 0; } /* * RFC 9000 s. 19.16: "An endpoint cannot send this frame if it was provided * with a zero-length connection ID by its peer. An endpoint that provides a * zero-length connection ID MUST treat receipt of a RETIRE_CONNECTION_ID * frame as a connection error of type PROTOCOL_VIOLATION." * * Since we always use a zero-length SCID as a client, there is no case * where it is valid for a server to send this. Our server support is * currently non-conformant and for internal testing use; simply handle it * as a no-op in this case. * * TODO(QUIC SERVER): Revise and implement correctly for server support. */ if (!ch->is_server) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, "conn has zero-length CID"); return 0; } return 1; } static void free_path_response(unsigned char *buf, size_t buf_len, void *arg) { OPENSSL_free(buf); } static int depack_do_frame_path_challenge(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { uint64_t frame_data = 0; unsigned char *encoded = NULL; size_t encoded_len; WPACKET wpkt; if (!ossl_quic_wire_decode_frame_path_challenge(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE, "decode error"); return 0; } /* * RFC 9000 s. 8.2.2: On receiving a PATH_CHALLENGE frame, an endpoint MUST * respond by echoing the data contained in the PATH_CHALLENGE frame in a * PATH_RESPONSE frame. * * TODO(QUIC FUTURE): We should try to avoid allocation here in the future. */ encoded_len = sizeof(uint64_t) + 1; if ((encoded = OPENSSL_malloc(encoded_len)) == NULL) goto err; if (!WPACKET_init_static_len(&wpkt, encoded, encoded_len, 0)) goto err; if (!ossl_quic_wire_encode_frame_path_response(&wpkt, frame_data)) { WPACKET_cleanup(&wpkt); goto err; } WPACKET_finish(&wpkt); if (!ossl_quic_cfq_add_frame(ch->cfq, 0, QUIC_PN_SPACE_APP, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE, QUIC_CFQ_ITEM_FLAG_UNRELIABLE, encoded, encoded_len, free_path_response, NULL)) goto err; return 1; err: OPENSSL_free(encoded); ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE, "internal error"); return 0; } static int depack_do_frame_path_response(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { uint64_t frame_data = 0; if (!ossl_quic_wire_decode_frame_path_response(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE, "decode error"); return 0; } /* TODO(QUIC MULTIPATH): ADD CODE to send |frame_data| to the ch manager */ return 1; } static int depack_do_frame_conn_close(PACKET *pkt, QUIC_CHANNEL *ch, uint64_t frame_type) { OSSL_QUIC_FRAME_CONN_CLOSE frame_data; if (!ossl_quic_wire_decode_frame_conn_close(pkt, &frame_data)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "decode error"); return 0; } ossl_quic_channel_on_remote_conn_close(ch, &frame_data); return 1; } static int depack_do_frame_handshake_done(PACKET *pkt, QUIC_CHANNEL *ch, OSSL_ACKM_RX_PKT *ackm_data) { if (!ossl_quic_wire_decode_frame_handshake_done(pkt)) { /* This can fail only with an internal error. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, "internal error (decode frame handshake done)"); return 0; } ossl_quic_channel_on_handshake_confirmed(ch); return 1; } /* Main frame processor */ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt, OSSL_QRX_PKT *parent_pkt, uint32_t enc_level, OSSL_TIME received, OSSL_ACKM_RX_PKT *ackm_data) { uint32_t pkt_type = parent_pkt->hdr->type; uint32_t packet_space = ossl_quic_enc_level_to_pn_space(enc_level); if (PACKET_remaining(pkt) == 0) { /* * RFC 9000 s. 12.4: An endpoint MUST treat receipt of a packet * containing no frames as a connection error of type * PROTOCOL_VIOLATION. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "empty packet payload"); return 0; } while (PACKET_remaining(pkt) > 0) { int was_minimal; uint64_t frame_type; const unsigned char *sof = NULL; uint64_t datalen = 0; if (ch->msg_callback != NULL) sof = PACKET_data(pkt); if (!ossl_quic_wire_peek_frame_header(pkt, &frame_type, &was_minimal)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "malformed frame header"); return 0; } if (!was_minimal) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "non-minimal frame type encoding"); return 0; } /* * There are only a few frame types which are not ACK-eliciting. Handle * these centrally to make error handling cases more resilient, as we * should tell the ACKM about an ACK-eliciting frame even if it was not * successfully handled. */ switch (frame_type) { case OSSL_QUIC_FRAME_TYPE_PADDING: case OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN: case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN: case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT: case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP: break; default: ackm_data->is_ack_eliciting = 1; break; } switch (frame_type) { case OSSL_QUIC_FRAME_TYPE_PING: /* Allowed in all packet types */ if (!depack_do_frame_ping(pkt, ch, enc_level, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_PADDING: /* Allowed in all packet types */ if (!depack_do_frame_padding(pkt)) return 0; break; case OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN: case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN: /* ACK frames are valid everywhere except in 0RTT packets */ if (pkt_type == QUIC_PKT_TYPE_0RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "ACK not valid in 0-RTT"); return 0; } if (!depack_do_frame_ack(pkt, ch, packet_space, received, frame_type, parent_pkt)) return 0; break; case OSSL_QUIC_FRAME_TYPE_RESET_STREAM: /* RESET_STREAM frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "RESET_STREAM not valid in " "INITIAL/HANDSHAKE"); return 0; } if (!depack_do_frame_reset_stream(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_STOP_SENDING: /* STOP_SENDING frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "STOP_SENDING not valid in " "INITIAL/HANDSHAKE"); return 0; } if (!depack_do_frame_stop_sending(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_CRYPTO: /* CRYPTO frames are valid everywhere except in 0RTT packets */ if (pkt_type == QUIC_PKT_TYPE_0RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "CRYPTO frame not valid in 0-RTT"); return 0; } if (!depack_do_frame_crypto(pkt, ch, parent_pkt, ackm_data, &datalen)) return 0; break; case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN: /* NEW_TOKEN frames are valid in 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "NEW_TOKEN valid only in 1-RTT"); return 0; } if (!depack_do_frame_new_token(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_STREAM: case OSSL_QUIC_FRAME_TYPE_STREAM_FIN: case OSSL_QUIC_FRAME_TYPE_STREAM_LEN: case OSSL_QUIC_FRAME_TYPE_STREAM_LEN_FIN: case OSSL_QUIC_FRAME_TYPE_STREAM_OFF: case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_FIN: case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN: case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN_FIN: /* STREAM frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "STREAM valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_stream(pkt, ch, parent_pkt, ackm_data, frame_type, &datalen)) return 0; break; case OSSL_QUIC_FRAME_TYPE_MAX_DATA: /* MAX_DATA frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "MAX_DATA valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_max_data(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA: /* MAX_STREAM_DATA frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "MAX_STREAM_DATA valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_max_stream_data(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI: case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI: /* MAX_STREAMS frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "MAX_STREAMS valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_max_streams(pkt, ch, ackm_data, frame_type)) return 0; break; case OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED: /* DATA_BLOCKED frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "DATA_BLOCKED valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_data_blocked(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED: /* STREAM_DATA_BLOCKED frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "STREAM_DATA_BLOCKED valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_stream_data_blocked(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI: case OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI: /* STREAMS_BLOCKED frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "STREAMS valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_streams_blocked(pkt, ch, ackm_data, frame_type)) return 0; break; case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID: /* NEW_CONN_ID frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "NEW_CONN_ID valid only in 0/1-RTT"); } if (!depack_do_frame_new_conn_id(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID: /* RETIRE_CONN_ID frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "RETIRE_CONN_ID valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_retire_conn_id(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE: /* PATH_CHALLENGE frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "PATH_CHALLENGE valid only in 0/1-RTT"); return 0; } if (!depack_do_frame_path_challenge(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE: /* PATH_RESPONSE frames are valid in 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "PATH_CHALLENGE valid only in 1-RTT"); return 0; } if (!depack_do_frame_path_response(pkt, ch, ackm_data)) return 0; break; case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP: /* CONN_CLOSE_APP frames are valid in 0RTT and 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_0RTT && pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "CONN_CLOSE (APP) valid only in 0/1-RTT"); return 0; } /* FALLTHRU */ case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT: /* CONN_CLOSE_TRANSPORT frames are valid in all packets */ if (!depack_do_frame_conn_close(pkt, ch, frame_type)) return 0; break; case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE: /* HANDSHAKE_DONE frames are valid in 1RTT packets */ if (pkt_type != QUIC_PKT_TYPE_1RTT) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, frame_type, "HANDSHAKE_DONE valid only in 1-RTT"); return 0; } if (!depack_do_frame_handshake_done(pkt, ch, ackm_data)) return 0; break; default: /* Unknown frame type */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_FRAME_ENCODING_ERROR, frame_type, "Unknown frame type received"); return 0; } if (ch->msg_callback != NULL) { int ctype = SSL3_RT_QUIC_FRAME_FULL; size_t framelen = PACKET_data(pkt) - sof; if (frame_type == OSSL_QUIC_FRAME_TYPE_PADDING) { ctype = SSL3_RT_QUIC_FRAME_PADDING; } else if (OSSL_QUIC_FRAME_TYPE_IS_STREAM(frame_type) || frame_type == OSSL_QUIC_FRAME_TYPE_CRYPTO) { ctype = SSL3_RT_QUIC_FRAME_HEADER; framelen -= (size_t)datalen; } ch->msg_callback(0, OSSL_QUIC1_VERSION, ctype, sof, framelen, ch->msg_callback_ssl, ch->msg_callback_arg); } } return 1; } QUIC_NEEDS_LOCK int ossl_quic_handle_frames(QUIC_CHANNEL *ch, OSSL_QRX_PKT *qpacket) { PACKET pkt; OSSL_ACKM_RX_PKT ackm_data; uint32_t enc_level; /* * ok has three states: * -1 error with ackm_data uninitialized * 0 error with ackm_data initialized * 1 success (ackm_data initialized) */ int ok = -1; /* Assume the worst */ if (ch == NULL) goto end; ch->did_crypto_frame = 0; /* Initialize |ackm_data| (and reinitialize |ok|)*/ memset(&ackm_data, 0, sizeof(ackm_data)); /* * ASSUMPTION: All packets that aren't special case have a * packet number. */ ackm_data.pkt_num = qpacket->pn; ackm_data.time = qpacket->time; enc_level = ossl_quic_pkt_type_to_enc_level(qpacket->hdr->type); if (enc_level >= QUIC_ENC_LEVEL_NUM) /* * Retry and Version Negotiation packets should not be passed to this * function. */ goto end; ok = 0; /* Still assume the worst */ ackm_data.pkt_space = ossl_quic_enc_level_to_pn_space(enc_level); /* Now that special cases are out of the way, parse frames */ if (!PACKET_buf_init(&pkt, qpacket->hdr->data, qpacket->hdr->len) || !depack_process_frames(ch, &pkt, qpacket, enc_level, qpacket->time, &ackm_data)) goto end; ok = 1; end: /* * ASSUMPTION: If this function is called at all, |qpacket| is * a legitimate packet, even if its contents aren't. * Therefore, we call ossl_ackm_on_rx_packet() unconditionally, as long as * |ackm_data| has at least been initialized. */ if (ok >= 0) ossl_ackm_on_rx_packet(ch->ackm, &ackm_data); return ok > 0; }

./openssl/ssl/quic/quic_engine_local.h

/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #ifndef OSSL_QUIC_ENGINE_LOCAL_H # define OSSL_QUIC_ENGINE_LOCAL_H # include "internal/quic_engine.h" # include "internal/quic_reactor.h" # ifndef OPENSSL_NO_QUIC /* * QUIC Engine Structure * ===================== * * QUIC engine internals. It is intended that only the QUIC_ENGINE, QUIC_PORT * and QUIC_CHANNEL implementations be allowed to access this structure * directly. * * Other components should not include this header. */ DECLARE_LIST_OF(port, QUIC_PORT); struct quic_engine_st { /* All objects in a QUIC event domain share the same (libctx, propq). */ OSSL_LIB_CTX *libctx; const char *propq; /* * Master synchronisation mutex for the entire QUIC event domain. Used for * thread assisted mode synchronisation. We don't own this; the instantiator * of the engine passes it to us and is responsible for freeing it after * engine destruction. */ CRYPTO_MUTEX *mutex; /* Callback used to get the current time. */ OSSL_TIME (*now_cb)(void *arg); void *now_cb_arg; /* Asynchronous I/O reactor. */ QUIC_REACTOR rtor; /* List of all child ports. */ OSSL_LIST(port) port_list; /* Inhibit tick for testing purposes? */ unsigned int inhibit_tick : 1; }; # endif #endif

./openssl/ssl/quic/quic_txpim.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_txpim.h" #include <stdlib.h> typedef struct quic_txpim_pkt_ex_st QUIC_TXPIM_PKT_EX; struct quic_txpim_pkt_ex_st { QUIC_TXPIM_PKT public; QUIC_TXPIM_PKT_EX *prev, *next; QUIC_TXPIM_CHUNK *chunks; size_t num_chunks, alloc_chunks; unsigned int chunks_need_sort : 1; }; typedef struct quic_txpim_pkt_ex_list { QUIC_TXPIM_PKT_EX *head, *tail; } QUIC_TXPIM_PKT_EX_LIST; struct quic_txpim_st { QUIC_TXPIM_PKT_EX_LIST free_list; size_t in_use; }; #define MAX_ALLOC_CHUNKS 512 QUIC_TXPIM *ossl_quic_txpim_new(void) { QUIC_TXPIM *txpim = OPENSSL_zalloc(sizeof(*txpim)); if (txpim == NULL) return NULL; return txpim; } static void free_list(QUIC_TXPIM_PKT_EX_LIST *l) { QUIC_TXPIM_PKT_EX *n, *nnext; for (n = l->head; n != NULL; n = nnext) { nnext = n->next; OPENSSL_free(n->chunks); OPENSSL_free(n); } l->head = l->tail = NULL; } void ossl_quic_txpim_free(QUIC_TXPIM *txpim) { if (txpim == NULL) return; assert(txpim->in_use == 0); free_list(&txpim->free_list); OPENSSL_free(txpim); } static void list_remove(QUIC_TXPIM_PKT_EX_LIST *l, QUIC_TXPIM_PKT_EX *n) { if (l->head == n) l->head = n->next; if (l->tail == n) l->tail = n->prev; if (n->prev != NULL) n->prev->next = n->next; if (n->next != NULL) n->next->prev = n->prev; n->prev = n->next = NULL; } static void list_insert_tail(QUIC_TXPIM_PKT_EX_LIST *l, QUIC_TXPIM_PKT_EX *n) { n->prev = l->tail; n->next = NULL; l->tail = n; if (n->prev != NULL) n->prev->next = n; if (l->head == NULL) l->head = n; } static QUIC_TXPIM_PKT_EX *txpim_get_free(QUIC_TXPIM *txpim) { QUIC_TXPIM_PKT_EX *ex = txpim->free_list.head; if (ex != NULL) return ex; ex = OPENSSL_zalloc(sizeof(*ex)); if (ex == NULL) return NULL; list_insert_tail(&txpim->free_list, ex); return ex; } static void txpim_clear(QUIC_TXPIM_PKT_EX *ex) { memset(&ex->public.ackm_pkt, 0, sizeof(ex->public.ackm_pkt)); ossl_quic_txpim_pkt_clear_chunks(&ex->public); ex->public.retx_head = NULL; ex->public.fifd = NULL; ex->public.had_handshake_done_frame = 0; ex->public.had_max_data_frame = 0; ex->public.had_max_streams_bidi_frame = 0; ex->public.had_max_streams_uni_frame = 0; ex->public.had_ack_frame = 0; ex->public.had_conn_close = 0; } QUIC_TXPIM_PKT *ossl_quic_txpim_pkt_alloc(QUIC_TXPIM *txpim) { QUIC_TXPIM_PKT_EX *ex = txpim_get_free(txpim); if (ex == NULL) return NULL; txpim_clear(ex); list_remove(&txpim->free_list, ex); ++txpim->in_use; return &ex->public; } void ossl_quic_txpim_pkt_release(QUIC_TXPIM *txpim, QUIC_TXPIM_PKT *fpkt) { QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt; assert(txpim->in_use > 0); --txpim->in_use; list_insert_tail(&txpim->free_list, ex); } void ossl_quic_txpim_pkt_add_cfq_item(QUIC_TXPIM_PKT *fpkt, QUIC_CFQ_ITEM *item) { item->pkt_next = fpkt->retx_head; item->pkt_prev = NULL; fpkt->retx_head = item; } void ossl_quic_txpim_pkt_clear_chunks(QUIC_TXPIM_PKT *fpkt) { QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt; ex->num_chunks = 0; } int ossl_quic_txpim_pkt_append_chunk(QUIC_TXPIM_PKT *fpkt, const QUIC_TXPIM_CHUNK *chunk) { QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt; QUIC_TXPIM_CHUNK *new_chunk; size_t new_alloc_chunks = ex->alloc_chunks; if (ex->num_chunks == ex->alloc_chunks) { new_alloc_chunks = (ex->alloc_chunks == 0) ? 4 : ex->alloc_chunks * 8 / 5; if (new_alloc_chunks > MAX_ALLOC_CHUNKS) new_alloc_chunks = MAX_ALLOC_CHUNKS; if (ex->num_chunks == new_alloc_chunks) return 0; new_chunk = OPENSSL_realloc(ex->chunks, new_alloc_chunks * sizeof(QUIC_TXPIM_CHUNK)); if (new_chunk == NULL) return 0; ex->chunks = new_chunk; ex->alloc_chunks = new_alloc_chunks; } ex->chunks[ex->num_chunks++] = *chunk; ex->chunks_need_sort = 1; return 1; } static int compare(const void *a, const void *b) { const QUIC_TXPIM_CHUNK *ac = a, *bc = b; if (ac->stream_id < bc->stream_id) return -1; else if (ac->stream_id > bc->stream_id) return 1; if (ac->start < bc->start) return -1; else if (ac->start > bc->start) return 1; return 0; } const QUIC_TXPIM_CHUNK *ossl_quic_txpim_pkt_get_chunks(const QUIC_TXPIM_PKT *fpkt) { QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt; if (ex->chunks_need_sort) { /* * List of chunks will generally be very small so there is no issue * simply sorting here. */ qsort(ex->chunks, ex->num_chunks, sizeof(QUIC_TXPIM_CHUNK), compare); ex->chunks_need_sort = 0; } return ex->chunks; } size_t ossl_quic_txpim_pkt_get_num_chunks(const QUIC_TXPIM_PKT *fpkt) { QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt; return ex->num_chunks; } size_t ossl_quic_txpim_get_in_use(const QUIC_TXPIM *txpim) { return txpim->in_use; }

./openssl/ssl/quic/quic_method.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/macros.h> #include <openssl/objects.h> #include "quic_local.h" IMPLEMENT_quic_meth_func(OSSL_QUIC_ANY_VERSION, OSSL_QUIC_client_method, ssl_undefined_function, ossl_quic_connect, ssl3_undef_enc_method) IMPLEMENT_quic_meth_func(OSSL_QUIC_ANY_VERSION, OSSL_QUIC_client_thread_method, ssl_undefined_function, ossl_quic_connect, ssl3_undef_enc_method)

./openssl/ssl/quic/quic_channel.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/rand.h> #include <openssl/err.h> #include "internal/quic_channel.h" #include "internal/quic_error.h" #include "internal/quic_rx_depack.h" #include "internal/quic_lcidm.h" #include "internal/quic_srtm.h" #include "../ssl_local.h" #include "quic_channel_local.h" #include "quic_port_local.h" #include "quic_engine_local.h" /* * NOTE: While this channel implementation currently has basic server support, * this functionality has been implemented for internal testing purposes and is * not suitable for network use. In particular, it does not implement address * validation, anti-amplification or retry logic. * * TODO(QUIC SERVER): Implement address validation and anti-amplification * TODO(QUIC SERVER): Implement retry logic */ #define INIT_CRYPTO_RECV_BUF_LEN 16384 #define INIT_CRYPTO_SEND_BUF_LEN 16384 #define INIT_APP_BUF_LEN 8192 /* * Interval before we force a PING to ensure NATs don't timeout. This is based * on the lowest commonly seen value of 30 seconds as cited in RFC 9000 s. * 10.1.2. */ #define MAX_NAT_INTERVAL (ossl_ms2time(25000)) /* * Our maximum ACK delay on the TX side. This is up to us to choose. Note that * this could differ from QUIC_DEFAULT_MAX_DELAY in future as that is a protocol * value which determines the value of the maximum ACK delay if the * max_ack_delay transport parameter is not set. */ #define DEFAULT_MAX_ACK_DELAY QUIC_DEFAULT_MAX_ACK_DELAY DEFINE_LIST_OF_IMPL(ch, QUIC_CHANNEL); static void ch_save_err_state(QUIC_CHANNEL *ch); static int ch_rx(QUIC_CHANNEL *ch, int channel_only); static int ch_tx(QUIC_CHANNEL *ch); static int ch_tick_tls(QUIC_CHANNEL *ch, int channel_only); static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only); static OSSL_TIME ch_determine_next_tick_deadline(QUIC_CHANNEL *ch); static int ch_retry(QUIC_CHANNEL *ch, const unsigned char *retry_token, size_t retry_token_len, const QUIC_CONN_ID *retry_scid); static void ch_cleanup(QUIC_CHANNEL *ch); static int ch_generate_transport_params(QUIC_CHANNEL *ch); static int ch_on_transport_params(const unsigned char *params, size_t params_len, void *arg); static int ch_on_handshake_alert(void *arg, unsigned char alert_code); static int ch_on_handshake_complete(void *arg); static int ch_on_handshake_yield_secret(uint32_t enc_level, int direction, uint32_t suite_id, EVP_MD *md, const unsigned char *secret, size_t secret_len, void *arg); static int ch_on_crypto_recv_record(const unsigned char **buf, size_t *bytes_read, void *arg); static int ch_on_crypto_release_record(size_t bytes_read, void *arg); static int crypto_ensure_empty(QUIC_RSTREAM *rstream); static int ch_on_crypto_send(const unsigned char *buf, size_t buf_len, size_t *consumed, void *arg); static OSSL_TIME get_time(void *arg); static uint64_t get_stream_limit(int uni, void *arg); static int rx_late_validate(QUIC_PN pn, int pn_space, void *arg); static void rxku_detected(QUIC_PN pn, void *arg); static int ch_retry(QUIC_CHANNEL *ch, const unsigned char *retry_token, size_t retry_token_len, const QUIC_CONN_ID *retry_scid); static void ch_update_idle(QUIC_CHANNEL *ch); static int ch_discard_el(QUIC_CHANNEL *ch, uint32_t enc_level); static void ch_on_idle_timeout(QUIC_CHANNEL *ch); static void ch_update_idle(QUIC_CHANNEL *ch); static void ch_update_ping_deadline(QUIC_CHANNEL *ch); static void ch_on_terminating_timeout(QUIC_CHANNEL *ch); static void ch_start_terminating(QUIC_CHANNEL *ch, const QUIC_TERMINATE_CAUSE *tcause, int force_immediate); static void ch_on_txp_ack_tx(const OSSL_QUIC_FRAME_ACK *ack, uint32_t pn_space, void *arg); static void ch_rx_handle_version_neg(QUIC_CHANNEL *ch, OSSL_QRX_PKT *pkt); static void ch_raise_version_neg_failure(QUIC_CHANNEL *ch); DEFINE_LHASH_OF_EX(QUIC_SRT_ELEM); /* * QUIC Channel Initialization and Teardown * ======================================== */ #define DEFAULT_INIT_CONN_RXFC_WND (768 * 1024) #define DEFAULT_CONN_RXFC_MAX_WND_MUL 20 #define DEFAULT_INIT_STREAM_RXFC_WND (512 * 1024) #define DEFAULT_STREAM_RXFC_MAX_WND_MUL 12 #define DEFAULT_INIT_CONN_MAX_STREAMS 100 static int ch_init(QUIC_CHANNEL *ch) { OSSL_QUIC_TX_PACKETISER_ARGS txp_args = {0}; OSSL_QTX_ARGS qtx_args = {0}; OSSL_QRX_ARGS qrx_args = {0}; QUIC_TLS_ARGS tls_args = {0}; uint32_t pn_space; size_t rx_short_dcid_len; size_t tx_init_dcid_len; if (ch->port == NULL || ch->lcidm == NULL || ch->srtm == NULL) goto err; rx_short_dcid_len = ossl_quic_port_get_rx_short_dcid_len(ch->port); tx_init_dcid_len = ossl_quic_port_get_tx_init_dcid_len(ch->port); /* For clients, generate our initial DCID. */ if (!ch->is_server && !ossl_quic_gen_rand_conn_id(ch->port->engine->libctx, tx_init_dcid_len, &ch->init_dcid)) goto err; /* We plug in a network write BIO to the QTX later when we get one. */ qtx_args.libctx = ch->port->engine->libctx; qtx_args.mdpl = QUIC_MIN_INITIAL_DGRAM_LEN; ch->rx_max_udp_payload_size = qtx_args.mdpl; ch->ping_deadline = ossl_time_infinite(); ch->qtx = ossl_qtx_new(&qtx_args); if (ch->qtx == NULL) goto err; ch->txpim = ossl_quic_txpim_new(); if (ch->txpim == NULL) goto err; ch->cfq = ossl_quic_cfq_new(); if (ch->cfq == NULL) goto err; if (!ossl_quic_txfc_init(&ch->conn_txfc, NULL)) goto err; /* * Note: The TP we transmit governs what the peer can transmit and thus * applies to the RXFC. */ ch->tx_init_max_stream_data_bidi_local = DEFAULT_INIT_STREAM_RXFC_WND; ch->tx_init_max_stream_data_bidi_remote = DEFAULT_INIT_STREAM_RXFC_WND; ch->tx_init_max_stream_data_uni = DEFAULT_INIT_STREAM_RXFC_WND; if (!ossl_quic_rxfc_init(&ch->conn_rxfc, NULL, DEFAULT_INIT_CONN_RXFC_WND, DEFAULT_CONN_RXFC_MAX_WND_MUL * DEFAULT_INIT_CONN_RXFC_WND, get_time, ch)) goto err; for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) if (!ossl_quic_rxfc_init_standalone(&ch->crypto_rxfc[pn_space], INIT_CRYPTO_RECV_BUF_LEN, get_time, ch)) goto err; if (!ossl_quic_rxfc_init_standalone(&ch->max_streams_bidi_rxfc, DEFAULT_INIT_CONN_MAX_STREAMS, get_time, ch)) goto err; if (!ossl_quic_rxfc_init_standalone(&ch->max_streams_uni_rxfc, DEFAULT_INIT_CONN_MAX_STREAMS, get_time, ch)) goto err; if (!ossl_statm_init(&ch->statm)) goto err; ch->have_statm = 1; ch->cc_method = &ossl_cc_newreno_method; if ((ch->cc_data = ch->cc_method->new(get_time, ch)) == NULL) goto err; if ((ch->ackm = ossl_ackm_new(get_time, ch, &ch->statm, ch->cc_method, ch->cc_data)) == NULL) goto err; if (!ossl_quic_stream_map_init(&ch->qsm, get_stream_limit, ch, &ch->max_streams_bidi_rxfc, &ch->max_streams_uni_rxfc, ch->is_server)) goto err; ch->have_qsm = 1; if (!ch->is_server && !ossl_quic_lcidm_generate_initial(ch->lcidm, ch, &txp_args.cur_scid)) goto err; /* We use a zero-length SCID. */ txp_args.cur_dcid = ch->init_dcid; txp_args.ack_delay_exponent = 3; txp_args.qtx = ch->qtx; txp_args.txpim = ch->txpim; txp_args.cfq = ch->cfq; txp_args.ackm = ch->ackm; txp_args.qsm = &ch->qsm; txp_args.conn_txfc = &ch->conn_txfc; txp_args.conn_rxfc = &ch->conn_rxfc; txp_args.max_streams_bidi_rxfc = &ch->max_streams_bidi_rxfc; txp_args.max_streams_uni_rxfc = &ch->max_streams_uni_rxfc; txp_args.cc_method = ch->cc_method; txp_args.cc_data = ch->cc_data; txp_args.now = get_time; txp_args.now_arg = ch; for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) { ch->crypto_send[pn_space] = ossl_quic_sstream_new(INIT_CRYPTO_SEND_BUF_LEN); if (ch->crypto_send[pn_space] == NULL) goto err; txp_args.crypto[pn_space] = ch->crypto_send[pn_space]; } ch->txp = ossl_quic_tx_packetiser_new(&txp_args); if (ch->txp == NULL) goto err; ossl_quic_tx_packetiser_set_ack_tx_cb(ch->txp, ch_on_txp_ack_tx, ch); qrx_args.libctx = ch->port->engine->libctx; qrx_args.demux = ch->port->demux; qrx_args.short_conn_id_len = rx_short_dcid_len; qrx_args.max_deferred = 32; if ((ch->qrx = ossl_qrx_new(&qrx_args)) == NULL) goto err; if (!ossl_qrx_set_late_validation_cb(ch->qrx, rx_late_validate, ch)) goto err; if (!ossl_qrx_set_key_update_cb(ch->qrx, rxku_detected, ch)) goto err; for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) { ch->crypto_recv[pn_space] = ossl_quic_rstream_new(NULL, NULL, 0); if (ch->crypto_recv[pn_space] == NULL) goto err; } /* Plug in the TLS handshake layer. */ tls_args.s = ch->tls; tls_args.crypto_send_cb = ch_on_crypto_send; tls_args.crypto_send_cb_arg = ch; tls_args.crypto_recv_rcd_cb = ch_on_crypto_recv_record; tls_args.crypto_recv_rcd_cb_arg = ch; tls_args.crypto_release_rcd_cb = ch_on_crypto_release_record; tls_args.crypto_release_rcd_cb_arg = ch; tls_args.yield_secret_cb = ch_on_handshake_yield_secret; tls_args.yield_secret_cb_arg = ch; tls_args.got_transport_params_cb = ch_on_transport_params; tls_args.got_transport_params_cb_arg= ch; tls_args.handshake_complete_cb = ch_on_handshake_complete; tls_args.handshake_complete_cb_arg = ch; tls_args.alert_cb = ch_on_handshake_alert; tls_args.alert_cb_arg = ch; tls_args.is_server = ch->is_server; if ((ch->qtls = ossl_quic_tls_new(&tls_args)) == NULL) goto err; ch->tx_max_ack_delay = DEFAULT_MAX_ACK_DELAY; ch->rx_max_ack_delay = QUIC_DEFAULT_MAX_ACK_DELAY; ch->rx_ack_delay_exp = QUIC_DEFAULT_ACK_DELAY_EXP; ch->rx_active_conn_id_limit = QUIC_MIN_ACTIVE_CONN_ID_LIMIT; ch->max_idle_timeout = QUIC_DEFAULT_IDLE_TIMEOUT; ch->tx_enc_level = QUIC_ENC_LEVEL_INITIAL; ch->rx_enc_level = QUIC_ENC_LEVEL_INITIAL; ch->txku_threshold_override = UINT64_MAX; ossl_ackm_set_tx_max_ack_delay(ch->ackm, ossl_ms2time(ch->tx_max_ack_delay)); ossl_ackm_set_rx_max_ack_delay(ch->ackm, ossl_ms2time(ch->rx_max_ack_delay)); /* * Determine the QUIC Transport Parameters and serialize the transport * parameters block. (For servers, we do this later as we must defer * generation until we have received the client's transport parameters.) */ if (!ch->is_server && !ch_generate_transport_params(ch)) goto err; ch_update_idle(ch); ossl_list_ch_insert_tail(&ch->port->channel_list, ch); ch->on_port_list = 1; return 1; err: ch_cleanup(ch); return 0; } static void ch_cleanup(QUIC_CHANNEL *ch) { uint32_t pn_space; if (ch->ackm != NULL) for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) ossl_ackm_on_pkt_space_discarded(ch->ackm, pn_space); ossl_quic_lcidm_cull(ch->lcidm, ch); ossl_quic_srtm_cull(ch->srtm, ch); ossl_quic_tx_packetiser_free(ch->txp); ossl_quic_txpim_free(ch->txpim); ossl_quic_cfq_free(ch->cfq); ossl_qtx_free(ch->qtx); if (ch->cc_data != NULL) ch->cc_method->free(ch->cc_data); if (ch->have_statm) ossl_statm_destroy(&ch->statm); ossl_ackm_free(ch->ackm); if (ch->have_qsm) ossl_quic_stream_map_cleanup(&ch->qsm); for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) { ossl_quic_sstream_free(ch->crypto_send[pn_space]); ossl_quic_rstream_free(ch->crypto_recv[pn_space]); } ossl_qrx_pkt_release(ch->qrx_pkt); ch->qrx_pkt = NULL; ossl_quic_tls_free(ch->qtls); ossl_qrx_free(ch->qrx); OPENSSL_free(ch->local_transport_params); OPENSSL_free((char *)ch->terminate_cause.reason); OSSL_ERR_STATE_free(ch->err_state); OPENSSL_free(ch->ack_range_scratch); if (ch->on_port_list) { ossl_list_ch_remove(&ch->port->channel_list, ch); ch->on_port_list = 0; } } QUIC_CHANNEL *ossl_quic_channel_new(const QUIC_CHANNEL_ARGS *args) { QUIC_CHANNEL *ch = NULL; if ((ch = OPENSSL_zalloc(sizeof(*ch))) == NULL) return NULL; ch->port = args->port; ch->is_server = args->is_server; ch->tls = args->tls; ch->lcidm = args->lcidm; ch->srtm = args->srtm; if (!ch_init(ch)) { OPENSSL_free(ch); return NULL; } return ch; } void ossl_quic_channel_free(QUIC_CHANNEL *ch) { if (ch == NULL) return; ch_cleanup(ch); OPENSSL_free(ch); } /* Set mutator callbacks for test framework support */ int ossl_quic_channel_set_mutator(QUIC_CHANNEL *ch, ossl_mutate_packet_cb mutatecb, ossl_finish_mutate_cb finishmutatecb, void *mutatearg) { if (ch->qtx == NULL) return 0; ossl_qtx_set_mutator(ch->qtx, mutatecb, finishmutatecb, mutatearg); return 1; } int ossl_quic_channel_get_peer_addr(QUIC_CHANNEL *ch, BIO_ADDR *peer_addr) { if (!ch->addressed_mode) return 0; *peer_addr = ch->cur_peer_addr; return 1; } int ossl_quic_channel_set_peer_addr(QUIC_CHANNEL *ch, const BIO_ADDR *peer_addr) { if (ch->state != QUIC_CHANNEL_STATE_IDLE) return 0; if (peer_addr == NULL || BIO_ADDR_family(peer_addr) == AF_UNSPEC) { BIO_ADDR_clear(&ch->cur_peer_addr); ch->addressed_mode = 0; return 1; } ch->cur_peer_addr = *peer_addr; ch->addressed_mode = 1; return 1; } QUIC_REACTOR *ossl_quic_channel_get_reactor(QUIC_CHANNEL *ch) { return ossl_quic_port_get0_reactor(ch->port); } QUIC_STREAM_MAP *ossl_quic_channel_get_qsm(QUIC_CHANNEL *ch) { return &ch->qsm; } OSSL_STATM *ossl_quic_channel_get_statm(QUIC_CHANNEL *ch) { return &ch->statm; } QUIC_STREAM *ossl_quic_channel_get_stream_by_id(QUIC_CHANNEL *ch, uint64_t stream_id) { return ossl_quic_stream_map_get_by_id(&ch->qsm, stream_id); } int ossl_quic_channel_is_active(const QUIC_CHANNEL *ch) { return ch != NULL && ch->state == QUIC_CHANNEL_STATE_ACTIVE; } int ossl_quic_channel_is_closing(const QUIC_CHANNEL *ch) { return ch->state == QUIC_CHANNEL_STATE_TERMINATING_CLOSING; } static int ossl_quic_channel_is_draining(const QUIC_CHANNEL *ch) { return ch->state == QUIC_CHANNEL_STATE_TERMINATING_DRAINING; } static int ossl_quic_channel_is_terminating(const QUIC_CHANNEL *ch) { return ossl_quic_channel_is_closing(ch) || ossl_quic_channel_is_draining(ch); } int ossl_quic_channel_is_terminated(const QUIC_CHANNEL *ch) { return ch->state == QUIC_CHANNEL_STATE_TERMINATED; } int ossl_quic_channel_is_term_any(const QUIC_CHANNEL *ch) { return ossl_quic_channel_is_terminating(ch) || ossl_quic_channel_is_terminated(ch); } const QUIC_TERMINATE_CAUSE * ossl_quic_channel_get_terminate_cause(const QUIC_CHANNEL *ch) { return ossl_quic_channel_is_term_any(ch) ? &ch->terminate_cause : NULL; } int ossl_quic_channel_is_handshake_complete(const QUIC_CHANNEL *ch) { return ch->handshake_complete; } int ossl_quic_channel_is_handshake_confirmed(const QUIC_CHANNEL *ch) { return ch->handshake_confirmed; } QUIC_DEMUX *ossl_quic_channel_get0_demux(QUIC_CHANNEL *ch) { return ch->port->demux; } QUIC_PORT *ossl_quic_channel_get0_port(QUIC_CHANNEL *ch) { return ch->port; } QUIC_ENGINE *ossl_quic_channel_get0_engine(QUIC_CHANNEL *ch) { return ossl_quic_port_get0_engine(ch->port); } CRYPTO_MUTEX *ossl_quic_channel_get_mutex(QUIC_CHANNEL *ch) { return ossl_quic_port_get0_mutex(ch->port); } int ossl_quic_channel_has_pending(const QUIC_CHANNEL *ch) { return ossl_quic_demux_has_pending(ch->port->demux) || ossl_qrx_processed_read_pending(ch->qrx); } /* * QUIC Channel: Callbacks from Miscellaneous Subsidiary Components * ================================================================ */ /* Used by various components. */ static OSSL_TIME get_time(void *arg) { QUIC_CHANNEL *ch = arg; return ossl_quic_port_get_time(ch->port); } /* Used by QSM. */ static uint64_t get_stream_limit(int uni, void *arg) { QUIC_CHANNEL *ch = arg; return uni ? ch->max_local_streams_uni : ch->max_local_streams_bidi; } /* * Called by QRX to determine if a packet is potentially invalid before trying * to decrypt it. */ static int rx_late_validate(QUIC_PN pn, int pn_space, void *arg) { QUIC_CHANNEL *ch = arg; /* Potential duplicates should not be processed. */ if (!ossl_ackm_is_rx_pn_processable(ch->ackm, pn, pn_space)) return 0; return 1; } /* * Triggers a TXKU (whether spontaneous or solicited). Does not check whether * spontaneous TXKU is currently allowed. */ QUIC_NEEDS_LOCK static void ch_trigger_txku(QUIC_CHANNEL *ch) { uint64_t next_pn = ossl_quic_tx_packetiser_get_next_pn(ch->txp, QUIC_PN_SPACE_APP); if (!ossl_quic_pn_valid(next_pn) || !ossl_qtx_trigger_key_update(ch->qtx)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "key update"); return; } ch->txku_in_progress = 1; ch->txku_pn = next_pn; ch->rxku_expected = ch->ku_locally_initiated; } QUIC_NEEDS_LOCK static int txku_in_progress(QUIC_CHANNEL *ch) { if (ch->txku_in_progress && ossl_ackm_get_largest_acked(ch->ackm, QUIC_PN_SPACE_APP) >= ch->txku_pn) { OSSL_TIME pto = ossl_ackm_get_pto_duration(ch->ackm); /* * RFC 9001 s. 6.5: Endpoints SHOULD wait three times the PTO before * initiating a key update after receiving an acknowledgment that * confirms that the previous key update was received. * * Note that by the above wording, this period starts from when we get * the ack for a TXKU-triggering packet, not when the TXKU is initiated. * So we defer TXKU cooldown deadline calculation to this point. */ ch->txku_in_progress = 0; ch->txku_cooldown_deadline = ossl_time_add(get_time(ch), ossl_time_multiply(pto, 3)); } return ch->txku_in_progress; } QUIC_NEEDS_LOCK static int txku_allowed(QUIC_CHANNEL *ch) { return ch->tx_enc_level == QUIC_ENC_LEVEL_1RTT /* Sanity check. */ /* Strict RFC 9001 criterion for TXKU. */ && ch->handshake_confirmed && !txku_in_progress(ch); } QUIC_NEEDS_LOCK static int txku_recommendable(QUIC_CHANNEL *ch) { if (!txku_allowed(ch)) return 0; return /* Recommended RFC 9001 criterion for TXKU. */ ossl_time_compare(get_time(ch), ch->txku_cooldown_deadline) >= 0 /* Some additional sensible criteria. */ && !ch->rxku_in_progress && !ch->rxku_pending_confirm; } QUIC_NEEDS_LOCK static int txku_desirable(QUIC_CHANNEL *ch) { uint64_t cur_pkt_count, max_pkt_count, thresh_pkt_count; const uint32_t enc_level = QUIC_ENC_LEVEL_1RTT; /* Check AEAD limit to determine if we should perform a spontaneous TXKU. */ cur_pkt_count = ossl_qtx_get_cur_epoch_pkt_count(ch->qtx, enc_level); max_pkt_count = ossl_qtx_get_max_epoch_pkt_count(ch->qtx, enc_level); thresh_pkt_count = max_pkt_count / 2; if (ch->txku_threshold_override != UINT64_MAX) thresh_pkt_count = ch->txku_threshold_override; return cur_pkt_count >= thresh_pkt_count; } QUIC_NEEDS_LOCK static void ch_maybe_trigger_spontaneous_txku(QUIC_CHANNEL *ch) { if (!txku_recommendable(ch) || !txku_desirable(ch)) return; ch->ku_locally_initiated = 1; ch_trigger_txku(ch); } QUIC_NEEDS_LOCK static int rxku_allowed(QUIC_CHANNEL *ch) { /* * RFC 9001 s. 6.1: An endpoint MUST NOT initiate a key update prior to * having confirmed the handshake (Section 4.1.2). * * RFC 9001 s. 6.1: An endpoint MUST NOT initiate a subsequent key update * unless it has received an acknowledgment for a packet that was sent * protected with keys from the current key phase. * * RFC 9001 s. 6.2: If an endpoint detects a second update before it has * sent any packets with updated keys containing an acknowledgment for the * packet that initiated the key update, it indicates that its peer has * updated keys twice without awaiting confirmation. An endpoint MAY treat * such consecutive key updates as a connection error of type * KEY_UPDATE_ERROR. */ return ch->handshake_confirmed && !ch->rxku_pending_confirm; } /* * Called when the QRX detects a new RX key update event. */ enum rxku_decision { DECISION_RXKU_ONLY, DECISION_PROTOCOL_VIOLATION, DECISION_SOLICITED_TXKU }; /* Called when the QRX detects a key update has occurred. */ QUIC_NEEDS_LOCK static void rxku_detected(QUIC_PN pn, void *arg) { QUIC_CHANNEL *ch = arg; enum rxku_decision decision; OSSL_TIME pto; /* * Note: rxku_in_progress is always 0 here as an RXKU cannot be detected * when we are still in UPDATING or COOLDOWN (see quic_record_rx.h). */ assert(!ch->rxku_in_progress); if (!rxku_allowed(ch)) /* Is RXKU even allowed at this time? */ decision = DECISION_PROTOCOL_VIOLATION; else if (ch->ku_locally_initiated) /* * If this key update was locally initiated (meaning that this detected * RXKU event is a result of our own spontaneous TXKU), we do not * trigger another TXKU; after all, to do so would result in an infinite * ping-pong of key updates. We still process it as an RXKU. */ decision = DECISION_RXKU_ONLY; else /* * Otherwise, a peer triggering a KU means we have to trigger a KU also. */ decision = DECISION_SOLICITED_TXKU; if (decision == DECISION_PROTOCOL_VIOLATION) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_KEY_UPDATE_ERROR, 0, "RX key update again too soon"); return; } pto = ossl_ackm_get_pto_duration(ch->ackm); ch->ku_locally_initiated = 0; ch->rxku_in_progress = 1; ch->rxku_pending_confirm = 1; ch->rxku_trigger_pn = pn; ch->rxku_update_end_deadline = ossl_time_add(get_time(ch), pto); ch->rxku_expected = 0; if (decision == DECISION_SOLICITED_TXKU) /* NOT gated by usual txku_allowed() */ ch_trigger_txku(ch); /* * Ordinarily, we only generate ACK when some ACK-eliciting frame has been * received. In some cases, this may not occur for a long time, for example * if transmission of application data is going in only one direction and * nothing else is happening with the connection. However, since the peer * cannot initiate a subsequent (spontaneous) TXKU until its prior * (spontaneous or solicited) TXKU has completed - meaning that prior * TXKU's trigger packet (or subsequent packet) has been acknowledged, this * can lead to very long times before a TXKU is considered 'completed'. * Optimise this by forcing ACK generation after triggering TXKU. * (Basically, we consider a RXKU event something that is 'ACK-eliciting', * which it more or less should be; it is necessarily separate from ordinary * processing of ACK-eliciting frames as key update is not indicated via a * frame.) */ ossl_quic_tx_packetiser_schedule_ack(ch->txp, QUIC_PN_SPACE_APP); } /* Called per tick to handle RXKU timer events. */ QUIC_NEEDS_LOCK static void ch_rxku_tick(QUIC_CHANNEL *ch) { if (!ch->rxku_in_progress || ossl_time_compare(get_time(ch), ch->rxku_update_end_deadline) < 0) return; ch->rxku_update_end_deadline = ossl_time_infinite(); ch->rxku_in_progress = 0; if (!ossl_qrx_key_update_timeout(ch->qrx, /*normal=*/1)) ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "RXKU cooldown internal error"); } QUIC_NEEDS_LOCK static void ch_on_txp_ack_tx(const OSSL_QUIC_FRAME_ACK *ack, uint32_t pn_space, void *arg) { QUIC_CHANNEL *ch = arg; if (pn_space != QUIC_PN_SPACE_APP || !ch->rxku_pending_confirm || !ossl_quic_frame_ack_contains_pn(ack, ch->rxku_trigger_pn)) return; /* * Defer clearing rxku_pending_confirm until TXP generate call returns * successfully. */ ch->rxku_pending_confirm_done = 1; } /* * QUIC Channel: Handshake Layer Event Handling * ============================================ */ static int ch_on_crypto_send(const unsigned char *buf, size_t buf_len, size_t *consumed, void *arg) { int ret; QUIC_CHANNEL *ch = arg; uint32_t enc_level = ch->tx_enc_level; uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level); QUIC_SSTREAM *sstream = ch->crypto_send[pn_space]; if (!ossl_assert(sstream != NULL)) return 0; ret = ossl_quic_sstream_append(sstream, buf, buf_len, consumed); return ret; } static int crypto_ensure_empty(QUIC_RSTREAM *rstream) { size_t avail = 0; int is_fin = 0; if (rstream == NULL) return 1; if (!ossl_quic_rstream_available(rstream, &avail, &is_fin)) return 0; return avail == 0; } static int ch_on_crypto_recv_record(const unsigned char **buf, size_t *bytes_read, void *arg) { QUIC_CHANNEL *ch = arg; QUIC_RSTREAM *rstream; int is_fin = 0; /* crypto stream is never finished, so we don't use this */ uint32_t i; /* * After we move to a later EL we must not allow our peer to send any new * bytes in the crypto stream on a previous EL. Retransmissions of old bytes * are allowed. * * In practice we will only move to a new EL when we have consumed all bytes * which should be sent on the crypto stream at a previous EL. For example, * the Handshake EL should not be provisioned until we have completely * consumed a TLS 1.3 ServerHello. Thus when we provision an EL the output * of ossl_quic_rstream_available() should be 0 for all lower ELs. Thus if a * given EL is available we simply ensure we have not received any further * bytes at a lower EL. */ for (i = QUIC_ENC_LEVEL_INITIAL; i < ch->rx_enc_level; ++i) if (i != QUIC_ENC_LEVEL_0RTT && !crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) { /* Protocol violation (RFC 9001 s. 4.1.3) */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_CRYPTO, "crypto stream data in wrong EL"); return 0; } rstream = ch->crypto_recv[ossl_quic_enc_level_to_pn_space(ch->rx_enc_level)]; if (rstream == NULL) return 0; return ossl_quic_rstream_get_record(rstream, buf, bytes_read, &is_fin); } static int ch_on_crypto_release_record(size_t bytes_read, void *arg) { QUIC_CHANNEL *ch = arg; QUIC_RSTREAM *rstream; OSSL_RTT_INFO rtt_info; uint32_t rx_pn_space = ossl_quic_enc_level_to_pn_space(ch->rx_enc_level); rstream = ch->crypto_recv[rx_pn_space]; if (rstream == NULL) return 0; ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(ch), &rtt_info); if (!ossl_quic_rxfc_on_retire(&ch->crypto_rxfc[rx_pn_space], bytes_read, rtt_info.smoothed_rtt)) return 0; return ossl_quic_rstream_release_record(rstream, bytes_read); } static int ch_on_handshake_yield_secret(uint32_t enc_level, int direction, uint32_t suite_id, EVP_MD *md, const unsigned char *secret, size_t secret_len, void *arg) { QUIC_CHANNEL *ch = arg; uint32_t i; if (enc_level < QUIC_ENC_LEVEL_HANDSHAKE || enc_level >= QUIC_ENC_LEVEL_NUM) /* Invalid EL. */ return 0; if (direction) { /* TX */ if (enc_level <= ch->tx_enc_level) /* * Does not make sense for us to try and provision an EL we have already * attained. */ return 0; if (!ossl_qtx_provide_secret(ch->qtx, enc_level, suite_id, md, secret, secret_len)) return 0; ch->tx_enc_level = enc_level; } else { /* RX */ if (enc_level <= ch->rx_enc_level) /* * Does not make sense for us to try and provision an EL we have already * attained. */ return 0; /* * Ensure all crypto streams for previous ELs are now empty of available * data. */ for (i = QUIC_ENC_LEVEL_INITIAL; i < enc_level; ++i) if (!crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) { /* Protocol violation (RFC 9001 s. 4.1.3) */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_CRYPTO, "crypto stream data in wrong EL"); return 0; } if (!ossl_qrx_provide_secret(ch->qrx, enc_level, suite_id, md, secret, secret_len)) return 0; ch->have_new_rx_secret = 1; ch->rx_enc_level = enc_level; } return 1; } static int ch_on_handshake_complete(void *arg) { QUIC_CHANNEL *ch = arg; if (!ossl_assert(!ch->handshake_complete)) return 0; /* this should not happen twice */ if (!ossl_assert(ch->tx_enc_level == QUIC_ENC_LEVEL_1RTT)) return 0; if (!ch->got_remote_transport_params) { /* * Was not a valid QUIC handshake if we did not get valid transport * params. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CRYPTO_MISSING_EXT, OSSL_QUIC_FRAME_TYPE_CRYPTO, "no transport parameters received"); return 0; } /* Don't need transport parameters anymore. */ OPENSSL_free(ch->local_transport_params); ch->local_transport_params = NULL; /* Tell the QRX it can now process 1-RTT packets. */ ossl_qrx_allow_1rtt_processing(ch->qrx); /* Tell TXP the handshake is complete. */ ossl_quic_tx_packetiser_notify_handshake_complete(ch->txp); ch->handshake_complete = 1; if (ch->is_server) { /* * On the server, the handshake is confirmed as soon as it is complete. */ ossl_quic_channel_on_handshake_confirmed(ch); ossl_quic_tx_packetiser_schedule_handshake_done(ch->txp); } return 1; } static int ch_on_handshake_alert(void *arg, unsigned char alert_code) { QUIC_CHANNEL *ch = arg; /* * RFC 9001 s. 4.4: More specifically, servers MUST NOT send post-handshake * TLS CertificateRequest messages, and clients MUST treat receipt of such * messages as a connection error of type PROTOCOL_VIOLATION. */ if (alert_code == SSL_AD_UNEXPECTED_MESSAGE && ch->handshake_complete && ossl_quic_tls_is_cert_request(ch->qtls)) ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "Post-handshake TLS " "CertificateRequest received"); /* * RFC 9001 s. 4.6.1: Servers MUST NOT send the early_data extension with a * max_early_data_size field set to any value other than 0xffffffff. A * client MUST treat receipt of a NewSessionTicket that contains an * early_data extension with any other value as a connection error of type * PROTOCOL_VIOLATION. */ else if (alert_code == SSL_AD_ILLEGAL_PARAMETER && ch->handshake_complete && ossl_quic_tls_has_bad_max_early_data(ch->qtls)) ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "Bad max_early_data received"); else ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CRYPTO_ERR_BEGIN + alert_code, 0, "handshake alert"); return 1; } /* * QUIC Channel: Transport Parameter Handling * ========================================== */ /* * Called by handshake layer when we receive QUIC Transport Parameters from the * peer. Note that these are not authenticated until the handshake is marked * as complete. */ #define TP_REASON_SERVER_ONLY(x) \ x " may not be sent by a client" #define TP_REASON_DUP(x) \ x " appears multiple times" #define TP_REASON_MALFORMED(x) \ x " is malformed" #define TP_REASON_EXPECTED_VALUE(x) \ x " does not match expected value" #define TP_REASON_NOT_RETRY(x) \ x " sent when not performing a retry" #define TP_REASON_REQUIRED(x) \ x " was not sent but is required" #define TP_REASON_INTERNAL_ERROR(x) \ x " encountered internal error" static void txfc_bump_cwm_bidi(QUIC_STREAM *s, void *arg) { if (!ossl_quic_stream_is_bidi(s) || ossl_quic_stream_is_server_init(s)) return; ossl_quic_txfc_bump_cwm(&s->txfc, *(uint64_t *)arg); } static void txfc_bump_cwm_uni(QUIC_STREAM *s, void *arg) { if (ossl_quic_stream_is_bidi(s) || ossl_quic_stream_is_server_init(s)) return; ossl_quic_txfc_bump_cwm(&s->txfc, *(uint64_t *)arg); } static void do_update(QUIC_STREAM *s, void *arg) { QUIC_CHANNEL *ch = arg; ossl_quic_stream_map_update_state(&ch->qsm, s); } static int ch_on_transport_params(const unsigned char *params, size_t params_len, void *arg) { QUIC_CHANNEL *ch = arg; PACKET pkt; uint64_t id, v; size_t len; const unsigned char *body; int got_orig_dcid = 0; int got_initial_scid = 0; int got_retry_scid = 0; int got_initial_max_data = 0; int got_initial_max_stream_data_bidi_local = 0; int got_initial_max_stream_data_bidi_remote = 0; int got_initial_max_stream_data_uni = 0; int got_initial_max_streams_bidi = 0; int got_initial_max_streams_uni = 0; int got_stateless_reset_token = 0; int got_preferred_addr = 0; int got_ack_delay_exp = 0; int got_max_ack_delay = 0; int got_max_udp_payload_size = 0; int got_max_idle_timeout = 0; int got_active_conn_id_limit = 0; int got_disable_active_migration = 0; QUIC_CONN_ID cid; const char *reason = "bad transport parameter"; if (ch->got_remote_transport_params) { reason = "multiple transport parameter extensions"; goto malformed; } if (!PACKET_buf_init(&pkt, params, params_len)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "internal error (packet buf init)"); return 0; } while (PACKET_remaining(&pkt) > 0) { if (!ossl_quic_wire_peek_transport_param(&pkt, &id)) goto malformed; switch (id) { case QUIC_TPARAM_ORIG_DCID: if (got_orig_dcid) { reason = TP_REASON_DUP("ORIG_DCID"); goto malformed; } if (ch->is_server) { reason = TP_REASON_SERVER_ONLY("ORIG_DCID"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_cid(&pkt, NULL, &cid)) { reason = TP_REASON_MALFORMED("ORIG_DCID"); goto malformed; } #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION /* Must match our initial DCID. */ if (!ossl_quic_conn_id_eq(&ch->init_dcid, &cid)) { reason = TP_REASON_EXPECTED_VALUE("ORIG_DCID"); goto malformed; } #endif got_orig_dcid = 1; break; case QUIC_TPARAM_RETRY_SCID: if (ch->is_server) { reason = TP_REASON_SERVER_ONLY("RETRY_SCID"); goto malformed; } if (got_retry_scid) { reason = TP_REASON_DUP("RETRY_SCID"); goto malformed; } if (!ch->doing_retry) { reason = TP_REASON_NOT_RETRY("RETRY_SCID"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_cid(&pkt, NULL, &cid)) { reason = TP_REASON_MALFORMED("RETRY_SCID"); goto malformed; } /* Must match Retry packet SCID. */ if (!ossl_quic_conn_id_eq(&ch->retry_scid, &cid)) { reason = TP_REASON_EXPECTED_VALUE("RETRY_SCID"); goto malformed; } got_retry_scid = 1; break; case QUIC_TPARAM_INITIAL_SCID: if (got_initial_scid) { /* must not appear more than once */ reason = TP_REASON_DUP("INITIAL_SCID"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_cid(&pkt, NULL, &cid)) { reason = TP_REASON_MALFORMED("INITIAL_SCID"); goto malformed; } /* Must match SCID of first Initial packet from server. */ if (!ossl_quic_conn_id_eq(&ch->init_scid, &cid)) { reason = TP_REASON_EXPECTED_VALUE("INITIAL_SCID"); goto malformed; } got_initial_scid = 1; break; case QUIC_TPARAM_INITIAL_MAX_DATA: if (got_initial_max_data) { /* must not appear more than once */ reason = TP_REASON_DUP("INITIAL_MAX_DATA"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_DATA"); goto malformed; } ossl_quic_txfc_bump_cwm(&ch->conn_txfc, v); got_initial_max_data = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL: if (got_initial_max_stream_data_bidi_local) { /* must not appear more than once */ reason = TP_REASON_DUP("INITIAL_MAX_STREAM_DATA_BIDI_LOCAL"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAM_DATA_BIDI_LOCAL"); goto malformed; } /* * This is correct; the BIDI_LOCAL TP governs streams created by * the endpoint which sends the TP, i.e., our peer. */ ch->rx_init_max_stream_data_bidi_remote = v; got_initial_max_stream_data_bidi_local = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE: if (got_initial_max_stream_data_bidi_remote) { /* must not appear more than once */ reason = TP_REASON_DUP("INITIAL_MAX_STREAM_DATA_BIDI_REMOTE"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAM_DATA_BIDI_REMOTE"); goto malformed; } /* * This is correct; the BIDI_REMOTE TP governs streams created * by the endpoint which receives the TP, i.e., us. */ ch->rx_init_max_stream_data_bidi_local = v; /* Apply to all existing streams. */ ossl_quic_stream_map_visit(&ch->qsm, txfc_bump_cwm_bidi, &v); got_initial_max_stream_data_bidi_remote = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_UNI: if (got_initial_max_stream_data_uni) { /* must not appear more than once */ reason = TP_REASON_DUP("INITIAL_MAX_STREAM_DATA_UNI"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAM_DATA_UNI"); goto malformed; } ch->rx_init_max_stream_data_uni = v; /* Apply to all existing streams. */ ossl_quic_stream_map_visit(&ch->qsm, txfc_bump_cwm_uni, &v); got_initial_max_stream_data_uni = 1; break; case QUIC_TPARAM_ACK_DELAY_EXP: if (got_ack_delay_exp) { /* must not appear more than once */ reason = TP_REASON_DUP("ACK_DELAY_EXP"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) || v > QUIC_MAX_ACK_DELAY_EXP) { reason = TP_REASON_MALFORMED("ACK_DELAY_EXP"); goto malformed; } ch->rx_ack_delay_exp = (unsigned char)v; got_ack_delay_exp = 1; break; case QUIC_TPARAM_MAX_ACK_DELAY: if (got_max_ack_delay) { /* must not appear more than once */ reason = TP_REASON_DUP("MAX_ACK_DELAY"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) || v >= (((uint64_t)1) << 14)) { reason = TP_REASON_MALFORMED("MAX_ACK_DELAY"); goto malformed; } ch->rx_max_ack_delay = v; ossl_ackm_set_rx_max_ack_delay(ch->ackm, ossl_ms2time(ch->rx_max_ack_delay)); got_max_ack_delay = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAMS_BIDI: if (got_initial_max_streams_bidi) { /* must not appear more than once */ reason = TP_REASON_DUP("INITIAL_MAX_STREAMS_BIDI"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) || v > (((uint64_t)1) << 60)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAMS_BIDI"); goto malformed; } assert(ch->max_local_streams_bidi == 0); ch->max_local_streams_bidi = v; got_initial_max_streams_bidi = 1; break; case QUIC_TPARAM_INITIAL_MAX_STREAMS_UNI: if (got_initial_max_streams_uni) { /* must not appear more than once */ reason = TP_REASON_DUP("INITIAL_MAX_STREAMS_UNI"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) || v > (((uint64_t)1) << 60)) { reason = TP_REASON_MALFORMED("INITIAL_MAX_STREAMS_UNI"); goto malformed; } assert(ch->max_local_streams_uni == 0); ch->max_local_streams_uni = v; got_initial_max_streams_uni = 1; break; case QUIC_TPARAM_MAX_IDLE_TIMEOUT: if (got_max_idle_timeout) { /* must not appear more than once */ reason = TP_REASON_DUP("MAX_IDLE_TIMEOUT"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v)) { reason = TP_REASON_MALFORMED("MAX_IDLE_TIMEOUT"); goto malformed; } if (v > 0 && v < ch->max_idle_timeout) ch->max_idle_timeout = v; ch_update_idle(ch); got_max_idle_timeout = 1; break; case QUIC_TPARAM_MAX_UDP_PAYLOAD_SIZE: if (got_max_udp_payload_size) { /* must not appear more than once */ reason = TP_REASON_DUP("MAX_UDP_PAYLOAD_SIZE"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) || v < QUIC_MIN_INITIAL_DGRAM_LEN) { reason = TP_REASON_MALFORMED("MAX_UDP_PAYLOAD_SIZE"); goto malformed; } ch->rx_max_udp_payload_size = v; got_max_udp_payload_size = 1; break; case QUIC_TPARAM_ACTIVE_CONN_ID_LIMIT: if (got_active_conn_id_limit) { /* must not appear more than once */ reason = TP_REASON_DUP("ACTIVE_CONN_ID_LIMIT"); goto malformed; } if (!ossl_quic_wire_decode_transport_param_int(&pkt, &id, &v) || v < QUIC_MIN_ACTIVE_CONN_ID_LIMIT) { reason = TP_REASON_MALFORMED("ACTIVE_CONN_ID_LIMIT"); goto malformed; } ch->rx_active_conn_id_limit = v; got_active_conn_id_limit = 1; break; case QUIC_TPARAM_STATELESS_RESET_TOKEN: if (got_stateless_reset_token) { reason = TP_REASON_DUP("STATELESS_RESET_TOKEN"); goto malformed; } /* * We must ensure a client doesn't send them because we don't have * processing for them. * * TODO(QUIC SERVER): remove this restriction */ if (ch->is_server) { reason = TP_REASON_SERVER_ONLY("STATELESS_RESET_TOKEN"); goto malformed; } body = ossl_quic_wire_decode_transport_param_bytes(&pkt, &id, &len); if (body == NULL || len != QUIC_STATELESS_RESET_TOKEN_LEN) { reason = TP_REASON_MALFORMED("STATELESS_RESET_TOKEN"); goto malformed; } if (!ossl_quic_srtm_add(ch->srtm, ch, ch->cur_remote_seq_num, (const QUIC_STATELESS_RESET_TOKEN *)body)) { reason = TP_REASON_INTERNAL_ERROR("STATELESS_RESET_TOKEN"); goto malformed; } got_stateless_reset_token = 1; break; case QUIC_TPARAM_PREFERRED_ADDR: { /* TODO(QUIC FUTURE): Handle preferred address. */ QUIC_PREFERRED_ADDR pfa; if (got_preferred_addr) { reason = TP_REASON_DUP("PREFERRED_ADDR"); goto malformed; } /* * RFC 9000 s. 18.2: "A server that chooses a zero-length * connection ID MUST NOT provide a preferred address. * Similarly, a server MUST NOT include a zero-length connection * ID in this transport parameter. A client MUST treat a * violation of these requirements as a connection error of type * TRANSPORT_PARAMETER_ERROR." */ if (ch->is_server) { reason = TP_REASON_SERVER_ONLY("PREFERRED_ADDR"); goto malformed; } if (ch->cur_remote_dcid.id_len == 0) { reason = "PREFERRED_ADDR provided for zero-length CID"; goto malformed; } if (!ossl_quic_wire_decode_transport_param_preferred_addr(&pkt, &pfa)) { reason = TP_REASON_MALFORMED("PREFERRED_ADDR"); goto malformed; } if (pfa.cid.id_len == 0) { reason = "zero-length CID in PREFERRED_ADDR"; goto malformed; } got_preferred_addr = 1; } break; case QUIC_TPARAM_DISABLE_ACTIVE_MIGRATION: /* We do not currently handle migration, so nothing to do. */ if (got_disable_active_migration) { /* must not appear more than once */ reason = TP_REASON_DUP("DISABLE_ACTIVE_MIGRATION"); goto malformed; } body = ossl_quic_wire_decode_transport_param_bytes(&pkt, &id, &len); if (body == NULL || len > 0) { reason = TP_REASON_MALFORMED("DISABLE_ACTIVE_MIGRATION"); goto malformed; } got_disable_active_migration = 1; break; default: /* * Skip over and ignore. * * RFC 9000 s. 7.4: We SHOULD treat duplicated transport parameters * as a connection error, but we are not required to. Currently, * handle this programmatically by checking for duplicates in the * parameters that we recognise, as above, but don't bother * maintaining a list of duplicates for anything we don't recognise. */ body = ossl_quic_wire_decode_transport_param_bytes(&pkt, &id, &len); if (body == NULL) goto malformed; break; } } if (!got_initial_scid) { reason = TP_REASON_REQUIRED("INITIAL_SCID"); goto malformed; } if (!ch->is_server) { if (!got_orig_dcid) { reason = TP_REASON_REQUIRED("ORIG_DCID"); goto malformed; } if (ch->doing_retry && !got_retry_scid) { reason = TP_REASON_REQUIRED("RETRY_SCID"); goto malformed; } } ch->got_remote_transport_params = 1; if (got_initial_max_data || got_initial_max_stream_data_bidi_remote || got_initial_max_streams_bidi || got_initial_max_streams_uni) /* * If FC credit was bumped, we may now be able to send. Update all * streams. */ ossl_quic_stream_map_visit(&ch->qsm, do_update, ch); /* If we are a server, we now generate our own transport parameters. */ if (ch->is_server && !ch_generate_transport_params(ch)) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "internal error"); return 0; } return 1; malformed: ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_TRANSPORT_PARAMETER_ERROR, 0, reason); return 0; } /* * Called when we want to generate transport parameters. This is called * immediately at instantiation time for a client and after we receive the * client's transport parameters for a server. */ static int ch_generate_transport_params(QUIC_CHANNEL *ch) { int ok = 0; BUF_MEM *buf_mem = NULL; WPACKET wpkt; int wpkt_valid = 0; size_t buf_len = 0; if (ch->local_transport_params != NULL) goto err; if ((buf_mem = BUF_MEM_new()) == NULL) goto err; if (!WPACKET_init(&wpkt, buf_mem)) goto err; wpkt_valid = 1; if (ossl_quic_wire_encode_transport_param_bytes(&wpkt, QUIC_TPARAM_DISABLE_ACTIVE_MIGRATION, NULL, 0) == NULL) goto err; if (ch->is_server) { if (!ossl_quic_wire_encode_transport_param_cid(&wpkt, QUIC_TPARAM_ORIG_DCID, &ch->init_dcid)) goto err; if (!ossl_quic_wire_encode_transport_param_cid(&wpkt, QUIC_TPARAM_INITIAL_SCID, &ch->cur_local_cid)) goto err; } else { /* Client always uses an empty SCID. */ if (ossl_quic_wire_encode_transport_param_bytes(&wpkt, QUIC_TPARAM_INITIAL_SCID, NULL, 0) == NULL) goto err; } if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_IDLE_TIMEOUT, ch->max_idle_timeout)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_UDP_PAYLOAD_SIZE, QUIC_MIN_INITIAL_DGRAM_LEN)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_ACTIVE_CONN_ID_LIMIT, QUIC_MIN_ACTIVE_CONN_ID_LIMIT)) goto err; if (ch->tx_max_ack_delay != QUIC_DEFAULT_MAX_ACK_DELAY && !ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_ACK_DELAY, ch->tx_max_ack_delay)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_DATA, ossl_quic_rxfc_get_cwm(&ch->conn_rxfc))) goto err; /* Send the default CWM for a new RXFC. */ if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL, ch->tx_init_max_stream_data_bidi_local)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE, ch->tx_init_max_stream_data_bidi_remote)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_UNI, ch->tx_init_max_stream_data_uni)) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAMS_BIDI, ossl_quic_rxfc_get_cwm(&ch->max_streams_bidi_rxfc))) goto err; if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAMS_UNI, ossl_quic_rxfc_get_cwm(&ch->max_streams_uni_rxfc))) goto err; if (!WPACKET_finish(&wpkt)) goto err; wpkt_valid = 0; if (!WPACKET_get_total_written(&wpkt, &buf_len)) goto err; ch->local_transport_params = (unsigned char *)buf_mem->data; buf_mem->data = NULL; if (!ossl_quic_tls_set_transport_params(ch->qtls, ch->local_transport_params, buf_len)) goto err; ok = 1; err: if (wpkt_valid) WPACKET_cleanup(&wpkt); BUF_MEM_free(buf_mem); return ok; } /* * QUIC Channel: Ticker-Mutator * ============================ */ /* * The central ticker function called by the reactor. This does everything, or * at least everything network I/O related. Best effort - not allowed to fail * "loudly". */ void ossl_quic_channel_subtick(QUIC_CHANNEL *ch, QUIC_TICK_RESULT *res, uint32_t flags) { OSSL_TIME now, deadline; int channel_only = (flags & QUIC_REACTOR_TICK_FLAG_CHANNEL_ONLY) != 0; /* * When we tick the QUIC connection, we do everything we need to do * periodically. Network I/O handling will already have been performed * as necessary by the QUIC port. Thus, in order, we: * * - handle any packets the DEMUX has queued up for us; * - handle any timer events which are due to fire (ACKM, etc.); * - generate any packets which need to be sent; * - determine the time at which we should next be ticked. */ /* If we are in the TERMINATED state, there is nothing to do. */ if (ossl_quic_channel_is_terminated(ch)) { res->net_read_desired = 0; res->net_write_desired = 0; res->tick_deadline = ossl_time_infinite(); return; } /* * If we are in the TERMINATING state, check if the terminating timer has * expired. */ if (ossl_quic_channel_is_terminating(ch)) { now = get_time(ch); if (ossl_time_compare(now, ch->terminate_deadline) >= 0) { ch_on_terminating_timeout(ch); res->net_read_desired = 0; res->net_write_desired = 0; res->tick_deadline = ossl_time_infinite(); return; /* abort normal processing, nothing to do */ } } if (!ch->port->engine->inhibit_tick) { /* Handle RXKU timeouts. */ ch_rxku_tick(ch); do { /* Process queued incoming packets. */ ch->did_tls_tick = 0; ch->have_new_rx_secret = 0; ch_rx(ch, channel_only); /* * Allow the handshake layer to check for any new incoming data and * generate new outgoing data. */ if (!ch->did_tls_tick) ch_tick_tls(ch, channel_only); /* * If the handshake layer gave us a new secret, we need to do RX * again because packets that were not previously processable and * were deferred might now be processable. * * TODO(QUIC FUTURE): Consider handling this in the yield_secret callback. */ } while (ch->have_new_rx_secret); } /* * Handle any timer events which are due to fire; namely, the loss * detection deadline and the idle timeout. * * ACKM ACK generation deadline is polled by TXP, so we don't need to * handle it here. */ now = get_time(ch); if (ossl_time_compare(now, ch->idle_deadline) >= 0) { /* * Idle timeout differs from normal protocol violation because we do * not send a CONN_CLOSE frame; go straight to TERMINATED. */ if (!ch->port->engine->inhibit_tick) ch_on_idle_timeout(ch); res->net_read_desired = 0; res->net_write_desired = 0; res->tick_deadline = ossl_time_infinite(); return; } if (!ch->port->engine->inhibit_tick) { deadline = ossl_ackm_get_loss_detection_deadline(ch->ackm); if (!ossl_time_is_zero(deadline) && ossl_time_compare(now, deadline) >= 0) ossl_ackm_on_timeout(ch->ackm); /* If a ping is due, inform TXP. */ if (ossl_time_compare(now, ch->ping_deadline) >= 0) { int pn_space = ossl_quic_enc_level_to_pn_space(ch->tx_enc_level); ossl_quic_tx_packetiser_schedule_ack_eliciting(ch->txp, pn_space); /* * If we have no CC budget at this time we cannot process the above * PING request immediately. In any case we have scheduled the * request so bump the ping deadline. If we don't do this we will * busy-loop endlessly as the above deadline comparison condition * will still be met. */ ch_update_ping_deadline(ch); } /* Queue any data to be sent for transmission. */ ch_tx(ch); /* Do stream GC. */ ossl_quic_stream_map_gc(&ch->qsm); } /* Determine the time at which we should next be ticked. */ res->tick_deadline = ch_determine_next_tick_deadline(ch); /* * Always process network input unless we are now terminated. Although we * had not terminated at the beginning of this tick, network errors in * ch_tx() may have caused us to transition to the Terminated state. */ res->net_read_desired = !ossl_quic_channel_is_terminated(ch); /* We want to write to the network if we have any data in our TX queue. */ res->net_write_desired = (!ossl_quic_channel_is_terminated(ch) && ossl_qtx_get_queue_len_datagrams(ch->qtx) > 0); } static int ch_tick_tls(QUIC_CHANNEL *ch, int channel_only) { uint64_t error_code; const char *error_msg; ERR_STATE *error_state = NULL; if (channel_only) return 1; ch->did_tls_tick = 1; ossl_quic_tls_tick(ch->qtls); if (ossl_quic_tls_get_error(ch->qtls, &error_code, &error_msg, &error_state)) { ossl_quic_channel_raise_protocol_error_state(ch, error_code, 0, error_msg, error_state); return 0; } return 1; } /* Check incoming forged packet limit and terminate connection if needed. */ static void ch_rx_check_forged_pkt_limit(QUIC_CHANNEL *ch) { uint32_t enc_level; uint64_t limit = UINT64_MAX, l; for (enc_level = QUIC_ENC_LEVEL_INITIAL; enc_level < QUIC_ENC_LEVEL_NUM; ++enc_level) { /* * Different ELs can have different AEADs which can in turn impose * different limits, so use the lowest value of any currently valid EL. */ if ((ch->el_discarded & (1U << enc_level)) != 0) continue; if (enc_level > ch->rx_enc_level) break; l = ossl_qrx_get_max_forged_pkt_count(ch->qrx, enc_level); if (l < limit) limit = l; } if (ossl_qrx_get_cur_forged_pkt_count(ch->qrx) < limit) return; ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_AEAD_LIMIT_REACHED, 0, "forgery limit"); } /* Process queued incoming packets and handle frames, if any. */ static int ch_rx(QUIC_CHANNEL *ch, int channel_only) { int handled_any = 0; const int closing = ossl_quic_channel_is_closing(ch); if (!ch->is_server && !ch->have_sent_any_pkt) /* * We have not sent anything yet, therefore there is no need to check * for incoming data. */ return 1; for (;;) { assert(ch->qrx_pkt == NULL); if (!ossl_qrx_read_pkt(ch->qrx, &ch->qrx_pkt)) break; /* Track the amount of data received while in the closing state */ if (closing) ossl_quic_tx_packetiser_record_received_closing_bytes( ch->txp, ch->qrx_pkt->hdr->len); if (!handled_any) { ch_update_idle(ch); ch_update_ping_deadline(ch); } ch_rx_handle_packet(ch, channel_only); /* best effort */ /* * Regardless of the outcome of frame handling, unref the packet. * This will free the packet unless something added another * reference to it during frame processing. */ ossl_qrx_pkt_release(ch->qrx_pkt); ch->qrx_pkt = NULL; ch->have_sent_ack_eliciting_since_rx = 0; handled_any = 1; } ch_rx_check_forged_pkt_limit(ch); /* * When in TERMINATING - CLOSING, generate a CONN_CLOSE frame whenever we * process one or more incoming packets. */ if (handled_any && closing) ch->conn_close_queued = 1; return 1; } static int bio_addr_eq(const BIO_ADDR *a, const BIO_ADDR *b) { if (BIO_ADDR_family(a) != BIO_ADDR_family(b)) return 0; switch (BIO_ADDR_family(a)) { case AF_INET: return !memcmp(&a->s_in.sin_addr, &b->s_in.sin_addr, sizeof(a->s_in.sin_addr)) && a->s_in.sin_port == b->s_in.sin_port; #if OPENSSL_USE_IPV6 case AF_INET6: return !memcmp(&a->s_in6.sin6_addr, &b->s_in6.sin6_addr, sizeof(a->s_in6.sin6_addr)) && a->s_in6.sin6_port == b->s_in6.sin6_port; #endif default: return 0; /* not supported */ } return 1; } /* Handles the packet currently in ch->qrx_pkt->hdr. */ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only) { uint32_t enc_level; int old_have_processed_any_pkt = ch->have_processed_any_pkt; assert(ch->qrx_pkt != NULL); /* * RFC 9000 s. 10.2.1 Closing Connection State: * An endpoint that is closing is not required to process any * received frame. */ if (!ossl_quic_channel_is_active(ch)) return; if (ossl_quic_pkt_type_is_encrypted(ch->qrx_pkt->hdr->type)) { if (!ch->have_received_enc_pkt) { ch->cur_remote_dcid = ch->init_scid = ch->qrx_pkt->hdr->src_conn_id; ch->have_received_enc_pkt = 1; /* * We change to using the SCID in the first Initial packet as the * DCID. */ ossl_quic_tx_packetiser_set_cur_dcid(ch->txp, &ch->init_scid); } enc_level = ossl_quic_pkt_type_to_enc_level(ch->qrx_pkt->hdr->type); if ((ch->el_discarded & (1U << enc_level)) != 0) /* Do not process packets from ELs we have already discarded. */ return; } /* * RFC 9000 s. 9.6: "If a client receives packets from a new server address * when the client has not initiated a migration to that address, the client * SHOULD discard these packets." * * We need to be a bit careful here as due to the BIO abstraction layer an * application is liable to be weird and lie to us about peer addresses. * Only apply this check if we actually are using a real AF_INET or AF_INET6 * address. */ if (!ch->is_server && ch->qrx_pkt->peer != NULL && ( BIO_ADDR_family(&ch->cur_peer_addr) == AF_INET #if OPENSSL_USE_IPV6 || BIO_ADDR_family(&ch->cur_peer_addr) == AF_INET6 #endif ) && !bio_addr_eq(ch->qrx_pkt->peer, &ch->cur_peer_addr)) return; if (!ch->is_server && ch->have_received_enc_pkt && ossl_quic_pkt_type_has_scid(ch->qrx_pkt->hdr->type)) { /* * RFC 9000 s. 7.2: "Once a client has received a valid Initial packet * from the server, it MUST discard any subsequent packet it receives on * that connection with a different SCID." */ if (!ossl_quic_conn_id_eq(&ch->qrx_pkt->hdr->src_conn_id, &ch->init_scid)) return; } if (ossl_quic_pkt_type_has_version(ch->qrx_pkt->hdr->type) && ch->qrx_pkt->hdr->version != QUIC_VERSION_1) /* * RFC 9000 s. 5.2.1: If a client receives a packet that uses a * different version than it initially selected, it MUST discard the * packet. We only ever use v1, so require it. */ return; ch->have_processed_any_pkt = 1; /* * RFC 9000 s. 17.2: "An endpoint MUST treat receipt of a packet that has a * non-zero value for [the reserved bits] after removing both packet and * header protection as a connection error of type PROTOCOL_VIOLATION." */ if (ossl_quic_pkt_type_is_encrypted(ch->qrx_pkt->hdr->type) && ch->qrx_pkt->hdr->reserved != 0) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "packet header reserved bits"); return; } /* Handle incoming packet. */ switch (ch->qrx_pkt->hdr->type) { case QUIC_PKT_TYPE_RETRY: if (ch->doing_retry || ch->is_server) /* * It is not allowed to ask a client to do a retry more than * once. Clients may not send retries. */ return; /* * RFC 9000 s 17.2.5.2: After the client has received and processed an * Initial or Retry packet from the server, it MUST discard any * subsequent Retry packets that it receives. */ if (ch->have_received_enc_pkt) return; if (ch->qrx_pkt->hdr->len <= QUIC_RETRY_INTEGRITY_TAG_LEN) /* Packets with zero-length Retry Tokens are invalid. */ return; /* * TODO(QUIC FUTURE): Theoretically this should probably be in the QRX. * However because validation is dependent on context (namely the * client's initial DCID) we can't do this cleanly. In the future we * should probably add a callback to the QRX to let it call us (via * the DEMUX) and ask us about the correct original DCID, rather * than allow the QRX to emit a potentially malformed packet to the * upper layers. However, special casing this will do for now. */ if (!ossl_quic_validate_retry_integrity_tag(ch->port->engine->libctx, ch->port->engine->propq, ch->qrx_pkt->hdr, &ch->init_dcid)) /* Malformed retry packet, ignore. */ return; if (!ch_retry(ch, ch->qrx_pkt->hdr->data, ch->qrx_pkt->hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN, &ch->qrx_pkt->hdr->src_conn_id)) ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "handling retry packet"); break; case QUIC_PKT_TYPE_0RTT: if (!ch->is_server) /* Clients should never receive 0-RTT packets. */ return; /* * TODO(QUIC 0RTT): Implement 0-RTT on the server side. We currently * do not need to implement this as a client can only do 0-RTT if we * have given it permission to in a previous session. */ break; case QUIC_PKT_TYPE_INITIAL: case QUIC_PKT_TYPE_HANDSHAKE: case QUIC_PKT_TYPE_1RTT: if (ch->is_server && ch->qrx_pkt->hdr->type == QUIC_PKT_TYPE_HANDSHAKE) /* * We automatically drop INITIAL EL keys when first successfully * decrypting a HANDSHAKE packet, as per the RFC. */ ch_discard_el(ch, QUIC_ENC_LEVEL_INITIAL); if (ch->rxku_in_progress && ch->qrx_pkt->hdr->type == QUIC_PKT_TYPE_1RTT && ch->qrx_pkt->pn >= ch->rxku_trigger_pn && ch->qrx_pkt->key_epoch < ossl_qrx_get_key_epoch(ch->qrx)) { /* * RFC 9001 s. 6.4: Packets with higher packet numbers MUST be * protected with either the same or newer packet protection keys * than packets with lower packet numbers. An endpoint that * successfully removes protection with old keys when newer keys * were used for packets with lower packet numbers MUST treat this * as a connection error of type KEY_UPDATE_ERROR. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_KEY_UPDATE_ERROR, 0, "new packet with old keys"); break; } if (!ch->is_server && ch->qrx_pkt->hdr->type == QUIC_PKT_TYPE_INITIAL && ch->qrx_pkt->hdr->token_len > 0) { /* * RFC 9000 s. 17.2.2: Clients that receive an Initial packet with a * non-zero Token Length field MUST either discard the packet or * generate a connection error of type PROTOCOL_VIOLATION. * * TODO(QUIC FUTURE): consider the implications of RFC 9000 s. 10.2.3 * Immediate Close during the Handshake: * However, at the cost of reducing feedback about * errors for legitimate peers, some forms of denial of * service can be made more difficult for an attacker * if endpoints discard illegal packets rather than * terminating a connection with CONNECTION_CLOSE. For * this reason, endpoints MAY discard packets rather * than immediately close if errors are detected in * packets that lack authentication. * I.e. should we drop this packet instead of closing the connection? */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, 0, "client received initial token"); break; } /* This packet contains frames, pass to the RXDP. */ ossl_quic_handle_frames(ch, ch->qrx_pkt); /* best effort */ if (ch->did_crypto_frame) ch_tick_tls(ch, channel_only); break; case QUIC_PKT_TYPE_VERSION_NEG: /* * "A client MUST discard any Version Negotiation packet if it has * received and successfully processed any other packet." */ if (!old_have_processed_any_pkt) ch_rx_handle_version_neg(ch, ch->qrx_pkt); break; default: assert(0); break; } } static void ch_rx_handle_version_neg(QUIC_CHANNEL *ch, OSSL_QRX_PKT *pkt) { /* * We do not support version negotiation at this time. As per RFC 9000 s. * 6.2., we MUST abandon the connection attempt if we receive a Version * Negotiation packet, unless we have already successfully processed another * incoming packet, or the packet lists the QUIC version we want to use. */ PACKET vpkt; unsigned long v; if (!PACKET_buf_init(&vpkt, pkt->hdr->data, pkt->hdr->len)) return; while (PACKET_remaining(&vpkt) > 0) { if (!PACKET_get_net_4(&vpkt, &v)) break; if ((uint32_t)v == QUIC_VERSION_1) return; } /* No match, this is a failure case. */ ch_raise_version_neg_failure(ch); } static void ch_raise_version_neg_failure(QUIC_CHANNEL *ch) { QUIC_TERMINATE_CAUSE tcause = {0}; tcause.error_code = QUIC_ERR_CONNECTION_REFUSED; tcause.reason = "version negotiation failure"; tcause.reason_len = strlen(tcause.reason); /* * Skip TERMINATING state; this is not considered a protocol error and we do * not send CONNECTION_CLOSE. */ ch_start_terminating(ch, &tcause, 1); } /* Try to generate packets and if possible, flush them to the network. */ static int ch_tx(QUIC_CHANNEL *ch) { QUIC_TXP_STATUS status; int res; /* * RFC 9000 s. 10.2.2: Draining Connection State: * While otherwise identical to the closing state, an endpoint * in the draining state MUST NOT send any packets. * and: * An endpoint MUST NOT send further packets. */ if (ossl_quic_channel_is_draining(ch)) return 0; if (ossl_quic_channel_is_closing(ch)) { /* * While closing, only send CONN_CLOSE if we've received more traffic * from the peer. Once we tell the TXP to generate CONN_CLOSE, all * future calls to it generate CONN_CLOSE frames, so otherwise we would * just constantly generate CONN_CLOSE frames. * * Confirming to RFC 9000 s. 10.2.1 Closing Connection State: * An endpoint SHOULD limit the rate at which it generates * packets in the closing state. */ if (!ch->conn_close_queued) return 0; ch->conn_close_queued = 0; } /* Do TXKU if we need to. */ ch_maybe_trigger_spontaneous_txku(ch); ch->rxku_pending_confirm_done = 0; /* Loop until we stop generating packets to send */ do { /* * Send packet, if we need to. Best effort. The TXP consults the CC and * applies any limitations imposed by it, so we don't need to do it here. * * Best effort. In particular if TXP fails for some reason we should * still flush any queued packets which we already generated. */ res = ossl_quic_tx_packetiser_generate(ch->txp, &status); if (status.sent_pkt > 0) { ch->have_sent_any_pkt = 1; /* Packet(s) were sent */ ch->port->have_sent_any_pkt = 1; /* * RFC 9000 s. 10.1. 'An endpoint also restarts its idle timer when * sending an ack-eliciting packet if no other ack-eliciting packets * have been sent since last receiving and processing a packet.' */ if (status.sent_ack_eliciting && !ch->have_sent_ack_eliciting_since_rx) { ch_update_idle(ch); ch->have_sent_ack_eliciting_since_rx = 1; } if (!ch->is_server && status.sent_handshake) /* * RFC 9001 s. 4.9.1: A client MUST discard Initial keys when it * first sends a Handshake packet. */ ch_discard_el(ch, QUIC_ENC_LEVEL_INITIAL); if (ch->rxku_pending_confirm_done) ch->rxku_pending_confirm = 0; ch_update_ping_deadline(ch); } if (!res) { /* * One case where TXP can fail is if we reach a TX PN of 2**62 - 1. * As per RFC 9000 s. 12.3, if this happens we MUST close the * connection without sending a CONNECTION_CLOSE frame. This is * actually handled as an emergent consequence of our design, as the * TX packetiser will never transmit another packet when the TX PN * reaches the limit. * * Calling the below function terminates the connection; its attempt * to schedule a CONNECTION_CLOSE frame will not actually cause a * packet to be transmitted for this reason. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0, "internal error (txp generate)"); break; } } while (status.sent_pkt > 0); /* Flush packets to network. */ switch (ossl_qtx_flush_net(ch->qtx)) { case QTX_FLUSH_NET_RES_OK: case QTX_FLUSH_NET_RES_TRANSIENT_FAIL: /* Best effort, done for now. */ break; case QTX_FLUSH_NET_RES_PERMANENT_FAIL: default: /* Permanent underlying network BIO, start terminating. */ ossl_quic_port_raise_net_error(ch->port, ch); break; } return 1; } /* Determine next tick deadline. */ static OSSL_TIME ch_determine_next_tick_deadline(QUIC_CHANNEL *ch) { OSSL_TIME deadline; int i; if (ossl_quic_channel_is_terminated(ch)) return ossl_time_infinite(); deadline = ossl_ackm_get_loss_detection_deadline(ch->ackm); if (ossl_time_is_zero(deadline)) deadline = ossl_time_infinite(); /* * Check the ack deadline for all enc_levels that are actually provisioned. * ACKs aren't restricted by CC. */ for (i = 0; i < QUIC_ENC_LEVEL_NUM; i++) { if (ossl_qtx_is_enc_level_provisioned(ch->qtx, i)) { deadline = ossl_time_min(deadline, ossl_ackm_get_ack_deadline(ch->ackm, ossl_quic_enc_level_to_pn_space(i))); } } /* * When do we need to send an ACK-eliciting packet to reset the idle * deadline timer for the peer? */ if (!ossl_time_is_infinite(ch->ping_deadline)) deadline = ossl_time_min(deadline, ch->ping_deadline); /* Apply TXP wakeup deadline. */ deadline = ossl_time_min(deadline, ossl_quic_tx_packetiser_get_deadline(ch->txp)); /* Is the terminating timer armed? */ if (ossl_quic_channel_is_terminating(ch)) deadline = ossl_time_min(deadline, ch->terminate_deadline); else if (!ossl_time_is_infinite(ch->idle_deadline)) deadline = ossl_time_min(deadline, ch->idle_deadline); /* When does the RXKU process complete? */ if (ch->rxku_in_progress) deadline = ossl_time_min(deadline, ch->rxku_update_end_deadline); return deadline; } /* * QUIC Channel: Lifecycle Events * ============================== */ int ossl_quic_channel_start(QUIC_CHANNEL *ch) { if (ch->is_server) /* * This is not used by the server. The server moves to active * automatically on receiving an incoming connection. */ return 0; if (ch->state != QUIC_CHANNEL_STATE_IDLE) /* Calls to connect are idempotent */ return 1; /* Inform QTX of peer address. */ if (!ossl_quic_tx_packetiser_set_peer(ch->txp, &ch->cur_peer_addr)) return 0; /* Plug in secrets for the Initial EL. */ if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx, ch->port->engine->propq, &ch->init_dcid, ch->is_server, ch->qrx, ch->qtx)) return 0; /* Change state. */ ch->state = QUIC_CHANNEL_STATE_ACTIVE; ch->doing_proactive_ver_neg = 0; /* not currently supported */ /* Handshake layer: start (e.g. send CH). */ if (!ch_tick_tls(ch, /*channel_only=*/0)) return 0; ossl_quic_reactor_tick(ossl_quic_port_get0_reactor(ch->port), 0); /* best effort */ return 1; } /* Start a locally initiated connection shutdown. */ void ossl_quic_channel_local_close(QUIC_CHANNEL *ch, uint64_t app_error_code, const char *app_reason) { QUIC_TERMINATE_CAUSE tcause = {0}; if (ossl_quic_channel_is_term_any(ch)) return; tcause.app = 1; tcause.error_code = app_error_code; tcause.reason = app_reason; tcause.reason_len = app_reason != NULL ? strlen(app_reason) : 0; ch_start_terminating(ch, &tcause, 0); } static void free_token(const unsigned char *buf, size_t buf_len, void *arg) { OPENSSL_free((unsigned char *)buf); } /* Called when a server asks us to do a retry. */ static int ch_retry(QUIC_CHANNEL *ch, const unsigned char *retry_token, size_t retry_token_len, const QUIC_CONN_ID *retry_scid) { void *buf; /* * RFC 9000 s. 17.2.5.1: "A client MUST discard a Retry packet that contains * a SCID field that is identical to the DCID field of its initial packet." */ if (ossl_quic_conn_id_eq(&ch->init_dcid, retry_scid)) return 1; /* We change to using the SCID in the Retry packet as the DCID. */ if (!ossl_quic_tx_packetiser_set_cur_dcid(ch->txp, retry_scid)) return 0; /* * Now we retry. We will release the Retry packet immediately, so copy * the token. */ if ((buf = OPENSSL_memdup(retry_token, retry_token_len)) == NULL) return 0; if (!ossl_quic_tx_packetiser_set_initial_token(ch->txp, buf, retry_token_len, free_token, NULL)) { /* * This may fail if the token we receive is too big for us to ever be * able to transmit in an outgoing Initial packet. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INVALID_TOKEN, 0, "received oversize token"); OPENSSL_free(buf); return 0; } ch->retry_scid = *retry_scid; ch->doing_retry = 1; /* * We need to stimulate the Initial EL to generate the first CRYPTO frame * again. We can do this most cleanly by simply forcing the ACKM to consider * the first Initial packet as lost, which it effectively was as the server * hasn't processed it. This also maintains the desired behaviour with e.g. * PNs not resetting and so on. * * The PN we used initially is always zero, because QUIC does not allow * repeated retries. */ if (!ossl_ackm_mark_packet_pseudo_lost(ch->ackm, QUIC_PN_SPACE_INITIAL, /*PN=*/0)) return 0; /* * Plug in new secrets for the Initial EL. This is the only time we change * the secrets for an EL after we already provisioned it. */ if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx, ch->port->engine->propq, &ch->retry_scid, /*is_server=*/0, ch->qrx, ch->qtx)) return 0; return 1; } /* Called when an EL is to be discarded. */ static int ch_discard_el(QUIC_CHANNEL *ch, uint32_t enc_level) { if (!ossl_assert(enc_level < QUIC_ENC_LEVEL_1RTT)) return 0; if ((ch->el_discarded & (1U << enc_level)) != 0) /* Already done. */ return 1; /* Best effort for all of these. */ ossl_quic_tx_packetiser_discard_enc_level(ch->txp, enc_level); ossl_qrx_discard_enc_level(ch->qrx, enc_level); ossl_qtx_discard_enc_level(ch->qtx, enc_level); if (enc_level != QUIC_ENC_LEVEL_0RTT) { uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level); ossl_ackm_on_pkt_space_discarded(ch->ackm, pn_space); /* We should still have crypto streams at this point. */ if (!ossl_assert(ch->crypto_send[pn_space] != NULL) || !ossl_assert(ch->crypto_recv[pn_space] != NULL)) return 0; /* Get rid of the crypto stream state for the EL. */ ossl_quic_sstream_free(ch->crypto_send[pn_space]); ch->crypto_send[pn_space] = NULL; ossl_quic_rstream_free(ch->crypto_recv[pn_space]); ch->crypto_recv[pn_space] = NULL; } ch->el_discarded |= (1U << enc_level); return 1; } /* Intended to be called by the RXDP. */ int ossl_quic_channel_on_handshake_confirmed(QUIC_CHANNEL *ch) { if (ch->handshake_confirmed) return 1; if (!ch->handshake_complete) { /* * Does not make sense for handshake to be confirmed before it is * completed. */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, "handshake cannot be confirmed " "before it is completed"); return 0; } ch_discard_el(ch, QUIC_ENC_LEVEL_HANDSHAKE); ch->handshake_confirmed = 1; ossl_ackm_on_handshake_confirmed(ch->ackm); return 1; } /* * Master function used when we want to start tearing down a connection: * * - If the connection is still IDLE we can go straight to TERMINATED; * * - If we are already TERMINATED this is a no-op. * * - If we are TERMINATING - CLOSING and we have now got a CONNECTION_CLOSE * from the peer (tcause->remote == 1), we move to TERMINATING - DRAINING. * * - If we are TERMINATING - DRAINING, we remain here until the terminating * timer expires. * * - Otherwise, we are in ACTIVE and move to TERMINATING - CLOSING. * if we caused the termination (e.g. we have sent a CONNECTION_CLOSE). Note * that we are considered to have caused a termination if we sent the first * CONNECTION_CLOSE frame, even if it is caused by a peer protocol * violation. If the peer sent the first CONNECTION_CLOSE frame, we move to * TERMINATING - DRAINING. * * We record the termination cause structure passed on the first call only. * Any successive calls have their termination cause data discarded; * once we start sending a CONNECTION_CLOSE frame, we don't change the details * in it. * * This conforms to RFC 9000 s. 10.2.1: Closing Connection State: * To minimize the state that an endpoint maintains for a closing * connection, endpoints MAY send the exact same packet in response * to any received packet. * * We don't drop any connection state (specifically packet protection keys) * even though we are permitted to. This conforms to RFC 9000 s. 10.2.1: * Closing Connection State: * An endpoint MAY retain packet protection keys for incoming * packets to allow it to read and process a CONNECTION_CLOSE frame. * * Note that we do not conform to these two from the same section: * An endpoint's selected connection ID and the QUIC version * are sufficient information to identify packets for a closing * connection; the endpoint MAY discard all other connection state. * and: * An endpoint MAY drop packet protection keys when entering the * closing state and send a packet containing a CONNECTION_CLOSE * frame in response to any UDP datagram that is received. */ static void copy_tcause(QUIC_TERMINATE_CAUSE *dst, const QUIC_TERMINATE_CAUSE *src) { dst->error_code = src->error_code; dst->frame_type = src->frame_type; dst->app = src->app; dst->remote = src->remote; dst->reason = NULL; dst->reason_len = 0; if (src->reason != NULL && src->reason_len > 0) { size_t l = src->reason_len; char *r; if (l >= SIZE_MAX) --l; /* * If this fails, dst->reason becomes NULL and we simply do not use a * reason. This ensures termination is infallible. */ dst->reason = r = OPENSSL_memdup(src->reason, l + 1); if (r == NULL) return; r[l] = '\0'; dst->reason_len = l; } } static void ch_start_terminating(QUIC_CHANNEL *ch, const QUIC_TERMINATE_CAUSE *tcause, int force_immediate) { /* No point sending anything if we haven't sent anything yet. */ if (!ch->have_sent_any_pkt) force_immediate = 1; switch (ch->state) { default: case QUIC_CHANNEL_STATE_IDLE: copy_tcause(&ch->terminate_cause, tcause); ch_on_terminating_timeout(ch); break; case QUIC_CHANNEL_STATE_ACTIVE: copy_tcause(&ch->terminate_cause, tcause); if (!force_immediate) { ch->state = tcause->remote ? QUIC_CHANNEL_STATE_TERMINATING_DRAINING : QUIC_CHANNEL_STATE_TERMINATING_CLOSING; /* * RFC 9000 s. 10.2 Immediate Close * These states SHOULD persist for at least three times * the current PTO interval as defined in [QUIC-RECOVERY]. */ ch->terminate_deadline = ossl_time_add(get_time(ch), ossl_time_multiply(ossl_ackm_get_pto_duration(ch->ackm), 3)); if (!tcause->remote) { OSSL_QUIC_FRAME_CONN_CLOSE f = {0}; /* best effort */ f.error_code = ch->terminate_cause.error_code; f.frame_type = ch->terminate_cause.frame_type; f.is_app = ch->terminate_cause.app; f.reason = (char *)ch->terminate_cause.reason; f.reason_len = ch->terminate_cause.reason_len; ossl_quic_tx_packetiser_schedule_conn_close(ch->txp, &f); /* * RFC 9000 s. 10.2.2 Draining Connection State: * An endpoint that receives a CONNECTION_CLOSE frame MAY * send a single packet containing a CONNECTION_CLOSE * frame before entering the draining state, using a * NO_ERROR code if appropriate */ ch->conn_close_queued = 1; } } else { ch_on_terminating_timeout(ch); } break; case QUIC_CHANNEL_STATE_TERMINATING_CLOSING: if (force_immediate) ch_on_terminating_timeout(ch); else if (tcause->remote) /* * RFC 9000 s. 10.2.2 Draining Connection State: * An endpoint MAY enter the draining state from the * closing state if it receives a CONNECTION_CLOSE frame, * which indicates that the peer is also closing or draining. */ ch->state = QUIC_CHANNEL_STATE_TERMINATING_DRAINING; break; case QUIC_CHANNEL_STATE_TERMINATING_DRAINING: /* * Other than in the force-immediate case, we remain here until the * timeout expires. */ if (force_immediate) ch_on_terminating_timeout(ch); break; case QUIC_CHANNEL_STATE_TERMINATED: /* No-op. */ break; } } /* For RXDP use. */ void ossl_quic_channel_on_remote_conn_close(QUIC_CHANNEL *ch, OSSL_QUIC_FRAME_CONN_CLOSE *f) { QUIC_TERMINATE_CAUSE tcause = {0}; if (!ossl_quic_channel_is_active(ch)) return; tcause.remote = 1; tcause.app = f->is_app; tcause.error_code = f->error_code; tcause.frame_type = f->frame_type; tcause.reason = f->reason; tcause.reason_len = f->reason_len; ch_start_terminating(ch, &tcause, 0); } static void free_frame_data(unsigned char *buf, size_t buf_len, void *arg) { OPENSSL_free(buf); } static int ch_enqueue_retire_conn_id(QUIC_CHANNEL *ch, uint64_t seq_num) { BUF_MEM *buf_mem = NULL; WPACKET wpkt; size_t l; ossl_quic_srtm_remove(ch->srtm, ch, seq_num); if ((buf_mem = BUF_MEM_new()) == NULL) goto err; if (!WPACKET_init(&wpkt, buf_mem)) goto err; if (!ossl_quic_wire_encode_frame_retire_conn_id(&wpkt, seq_num)) { WPACKET_cleanup(&wpkt); goto err; } WPACKET_finish(&wpkt); if (!WPACKET_get_total_written(&wpkt, &l)) goto err; if (ossl_quic_cfq_add_frame(ch->cfq, 1, QUIC_PN_SPACE_APP, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, 0, (unsigned char *)buf_mem->data, l, free_frame_data, NULL) == NULL) goto err; buf_mem->data = NULL; BUF_MEM_free(buf_mem); return 1; err: ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "internal error enqueueing retire conn id"); BUF_MEM_free(buf_mem); return 0; } void ossl_quic_channel_on_new_conn_id(QUIC_CHANNEL *ch, OSSL_QUIC_FRAME_NEW_CONN_ID *f) { uint64_t new_remote_seq_num = ch->cur_remote_seq_num; uint64_t new_retire_prior_to = ch->cur_retire_prior_to; if (!ossl_quic_channel_is_active(ch)) return; /* We allow only two active connection ids; first check some constraints */ if (ch->cur_remote_dcid.id_len == 0) { /* Changing from 0 length connection id is disallowed */ ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "zero length connection id in use"); return; } if (f->seq_num > new_remote_seq_num) new_remote_seq_num = f->seq_num; if (f->retire_prior_to > new_retire_prior_to) new_retire_prior_to = f->retire_prior_to; /* * RFC 9000-5.1.1: An endpoint MUST NOT provide more connection IDs * than the peer's limit. * * After processing a NEW_CONNECTION_ID frame and adding and retiring * active connection IDs, if the number of active connection IDs exceeds * the value advertised in its active_connection_id_limit transport * parameter, an endpoint MUST close the connection with an error of * type CONNECTION_ID_LIMIT_ERROR. */ if (new_remote_seq_num - new_retire_prior_to > 1) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CONNECTION_ID_LIMIT_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "active_connection_id limit violated"); return; } /* * RFC 9000-5.1.1: An endpoint MAY send connection IDs that temporarily * exceed a peer's limit if the NEW_CONNECTION_ID frame also requires * the retirement of any excess, by including a sufficiently large * value in the Retire Prior To field. * * RFC 9000-5.1.2: An endpoint SHOULD allow for sending and tracking * a number of RETIRE_CONNECTION_ID frames of at least twice the value * of the active_connection_id_limit transport parameter. An endpoint * MUST NOT forget a connection ID without retiring it, though it MAY * choose to treat having connection IDs in need of retirement that * exceed this limit as a connection error of type CONNECTION_ID_LIMIT_ERROR. * * We are a little bit more liberal than the minimum mandated. */ if (new_retire_prior_to - ch->cur_retire_prior_to > 10) { ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CONNECTION_ID_LIMIT_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "retiring connection id limit violated"); return; } if (new_remote_seq_num > ch->cur_remote_seq_num) { /* Add new stateless reset token */ if (!ossl_quic_srtm_add(ch->srtm, ch, new_remote_seq_num, &f->stateless_reset)) { ossl_quic_channel_raise_protocol_error( ch, QUIC_ERR_CONNECTION_ID_LIMIT_ERROR, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, "unable to store stateless reset token"); return; } ch->cur_remote_seq_num = new_remote_seq_num; ch->cur_remote_dcid = f->conn_id; ossl_quic_tx_packetiser_set_cur_dcid(ch->txp, &ch->cur_remote_dcid); } /* * RFC 9000-5.1.2: Upon receipt of an increased Retire Prior To * field, the peer MUST stop using the corresponding connection IDs * and retire them with RETIRE_CONNECTION_ID frames before adding the * newly provided connection ID to the set of active connection IDs. */ /* * Note: RFC 9000 s. 19.15 says: * "An endpoint that receives a NEW_CONNECTION_ID frame with a sequence * number smaller than the Retire Prior To field of a previously received * NEW_CONNECTION_ID frame MUST send a corresponding * RETIRE_CONNECTION_ID frame that retires the newly received connection * ID, unless it has already done so for that sequence number." * * Since we currently always queue RETIRE_CONN_ID frames based on the Retire * Prior To field of a NEW_CONNECTION_ID frame immediately upon receiving * that NEW_CONNECTION_ID frame, by definition this will always be met. * This may change in future when we change our CID handling. */ while (new_retire_prior_to > ch->cur_retire_prior_to) { if (!ch_enqueue_retire_conn_id(ch, ch->cur_retire_prior_to)) break; ++ch->cur_retire_prior_to; } } static void ch_save_err_state(QUIC_CHANNEL *ch) { if (ch->err_state == NULL) ch->err_state = OSSL_ERR_STATE_new(); if (ch->err_state == NULL) return; OSSL_ERR_STATE_save(ch->err_state); } void ossl_quic_channel_inject(QUIC_CHANNEL *ch, QUIC_URXE *e) { ossl_qrx_inject_urxe(ch->qrx, e); } void ossl_quic_channel_on_stateless_reset(QUIC_CHANNEL *ch) { QUIC_TERMINATE_CAUSE tcause = {0}; tcause.error_code = QUIC_ERR_NO_ERROR; tcause.remote = 1; ch_start_terminating(ch, &tcause, 0); } void ossl_quic_channel_raise_net_error(QUIC_CHANNEL *ch) { QUIC_TERMINATE_CAUSE tcause = {0}; if (ch->net_error) return; ch->net_error = 1; tcause.error_code = QUIC_ERR_INTERNAL_ERROR; tcause.reason = "network BIO I/O error"; tcause.reason_len = strlen(tcause.reason); /* * Skip Terminating state and go directly to Terminated, no point trying to * send CONNECTION_CLOSE if we cannot communicate. */ ch_start_terminating(ch, &tcause, 1); } int ossl_quic_channel_net_error(QUIC_CHANNEL *ch) { return ch->net_error; } void ossl_quic_channel_restore_err_state(QUIC_CHANNEL *ch) { if (ch == NULL) return; if (!ossl_quic_port_is_running(ch->port)) ossl_quic_port_restore_err_state(ch->port); else OSSL_ERR_STATE_restore(ch->err_state); } void ossl_quic_channel_raise_protocol_error_loc(QUIC_CHANNEL *ch, uint64_t error_code, uint64_t frame_type, const char *reason, ERR_STATE *err_state, const char *src_file, int src_line, const char *src_func) { QUIC_TERMINATE_CAUSE tcause = {0}; int err_reason = error_code == QUIC_ERR_INTERNAL_ERROR ? ERR_R_INTERNAL_ERROR : SSL_R_QUIC_PROTOCOL_ERROR; const char *err_str = ossl_quic_err_to_string(error_code); const char *err_str_pfx = " (", *err_str_sfx = ")"; const char *ft_str = NULL; const char *ft_str_pfx = " (", *ft_str_sfx = ")"; if (ch->protocol_error) /* Only the first call to this function matters. */ return; if (err_str == NULL) { err_str = ""; err_str_pfx = ""; err_str_sfx = ""; } /* * If we were provided an underlying error state, restore it and then append * our ERR on top as a "cover letter" error. */ if (err_state != NULL) OSSL_ERR_STATE_restore(err_state); if (frame_type != 0) { ft_str = ossl_quic_frame_type_to_string(frame_type); if (ft_str == NULL) { ft_str = ""; ft_str_pfx = ""; ft_str_sfx = ""; } ERR_raise_data(ERR_LIB_SSL, err_reason, "QUIC error code: 0x%llx%s%s%s " "(triggered by frame type: 0x%llx%s%s%s), reason: \"%s\"", (unsigned long long) error_code, err_str_pfx, err_str, err_str_sfx, (unsigned long long) frame_type, ft_str_pfx, ft_str, ft_str_sfx, reason); } else { ERR_raise_data(ERR_LIB_SSL, err_reason, "QUIC error code: 0x%llx%s%s%s, reason: \"%s\"", (unsigned long long) error_code, err_str_pfx, err_str, err_str_sfx, reason); } if (src_file != NULL) ERR_set_debug(src_file, src_line, src_func); ch_save_err_state(ch); tcause.error_code = error_code; tcause.frame_type = frame_type; tcause.reason = reason; tcause.reason_len = strlen(reason); ch->protocol_error = 1; ch_start_terminating(ch, &tcause, 0); } /* * Called once the terminating timer expires, meaning we move from TERMINATING * to TERMINATED. */ static void ch_on_terminating_timeout(QUIC_CHANNEL *ch) { ch->state = QUIC_CHANNEL_STATE_TERMINATED; } /* * Determines the effective idle timeout duration. This is based on the idle * timeout values that we and our peer signalled in transport parameters * but have some limits applied. */ static OSSL_TIME ch_get_effective_idle_timeout_duration(QUIC_CHANNEL *ch) { OSSL_TIME pto; if (ch->max_idle_timeout == 0) return ossl_time_infinite(); /* * RFC 9000 s. 10.1: Idle Timeout * To avoid excessively small idle timeout periods, endpoints * MUST increase the idle timeout period to be at least three * times the current Probe Timeout (PTO). This allows for * multiple PTOs to expire, and therefore multiple probes to * be sent and lost, prior to idle timeout. */ pto = ossl_ackm_get_pto_duration(ch->ackm); return ossl_time_max(ossl_ms2time(ch->max_idle_timeout), ossl_time_multiply(pto, 3)); } /* * Updates our idle deadline. Called when an event happens which should bump the * idle timeout. */ static void ch_update_idle(QUIC_CHANNEL *ch) { ch->idle_deadline = ossl_time_add(get_time(ch), ch_get_effective_idle_timeout_duration(ch)); } /* * Updates our ping deadline, which determines when we next generate a ping if * we don't have any other ACK-eliciting frames to send. */ static void ch_update_ping_deadline(QUIC_CHANNEL *ch) { OSSL_TIME max_span, idle_duration; idle_duration = ch_get_effective_idle_timeout_duration(ch); if (ossl_time_is_infinite(idle_duration)) { ch->ping_deadline = ossl_time_infinite(); return; } /* * Maximum amount of time without traffic before we send a PING to keep * the connection open. Usually we use max_idle_timeout/2, but ensure * the period never exceeds the assumed NAT interval to ensure NAT * devices don't have their state time out (RFC 9000 s. 10.1.2). */ max_span = ossl_time_divide(idle_duration, 2); max_span = ossl_time_min(max_span, MAX_NAT_INTERVAL); ch->ping_deadline = ossl_time_add(get_time(ch), max_span); } /* Called when the idle timeout expires. */ static void ch_on_idle_timeout(QUIC_CHANNEL *ch) { /* * Idle timeout does not have an error code associated with it because a * CONN_CLOSE is never sent for it. We shouldn't use this data once we reach * TERMINATED anyway. */ ch->terminate_cause.app = 0; ch->terminate_cause.error_code = UINT64_MAX; ch->terminate_cause.frame_type = 0; ch->state = QUIC_CHANNEL_STATE_TERMINATED; } /* Called when we, as a server, get a new incoming connection. */ int ossl_quic_channel_on_new_conn(QUIC_CHANNEL *ch, const BIO_ADDR *peer, const QUIC_CONN_ID *peer_scid, const QUIC_CONN_ID *peer_dcid) { if (!ossl_assert(ch->state == QUIC_CHANNEL_STATE_IDLE && ch->is_server)) return 0; /* Generate an Initial LCID we will use for the connection. */ if (!ossl_quic_lcidm_generate_initial(ch->lcidm, ch, &ch->cur_local_cid)) return 0; /* Note our newly learnt peer address and CIDs. */ ch->cur_peer_addr = *peer; ch->init_dcid = *peer_dcid; ch->cur_remote_dcid = *peer_scid; /* Inform QTX of peer address. */ if (!ossl_quic_tx_packetiser_set_peer(ch->txp, &ch->cur_peer_addr)) return 0; /* Inform TXP of desired CIDs. */ if (!ossl_quic_tx_packetiser_set_cur_dcid(ch->txp, &ch->cur_remote_dcid)) return 0; if (!ossl_quic_tx_packetiser_set_cur_scid(ch->txp, &ch->cur_local_cid)) return 0; /* Plug in secrets for the Initial EL. */ if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx, ch->port->engine->propq, &ch->init_dcid, /*is_server=*/1, ch->qrx, ch->qtx)) return 0; /* Register the peer ODCID in the LCIDM. */ if (!ossl_quic_lcidm_enrol_odcid(ch->lcidm, ch, &ch->init_dcid)) return 0; /* Change state. */ ch->state = QUIC_CHANNEL_STATE_ACTIVE; ch->doing_proactive_ver_neg = 0; /* not currently supported */ return 1; } SSL *ossl_quic_channel_get0_ssl(QUIC_CHANNEL *ch) { return ch->tls; } static int ch_init_new_stream(QUIC_CHANNEL *ch, QUIC_STREAM *qs, int can_send, int can_recv) { uint64_t rxfc_wnd; int server_init = ossl_quic_stream_is_server_init(qs); int local_init = (ch->is_server == server_init); int is_uni = !ossl_quic_stream_is_bidi(qs); if (can_send) if ((qs->sstream = ossl_quic_sstream_new(INIT_APP_BUF_LEN)) == NULL) goto err; if (can_recv) if ((qs->rstream = ossl_quic_rstream_new(NULL, NULL, 0)) == NULL) goto err; /* TXFC */ if (!ossl_quic_txfc_init(&qs->txfc, &ch->conn_txfc)) goto err; if (ch->got_remote_transport_params) { /* * If we already got peer TPs we need to apply the initial CWM credit * now. If we didn't already get peer TPs this will be done * automatically for all extant streams when we do. */ if (can_send) { uint64_t cwm; if (is_uni) cwm = ch->rx_init_max_stream_data_uni; else if (local_init) cwm = ch->rx_init_max_stream_data_bidi_local; else cwm = ch->rx_init_max_stream_data_bidi_remote; ossl_quic_txfc_bump_cwm(&qs->txfc, cwm); } } /* RXFC */ if (!can_recv) rxfc_wnd = 0; else if (is_uni) rxfc_wnd = ch->tx_init_max_stream_data_uni; else if (local_init) rxfc_wnd = ch->tx_init_max_stream_data_bidi_local; else rxfc_wnd = ch->tx_init_max_stream_data_bidi_remote; if (!ossl_quic_rxfc_init(&qs->rxfc, &ch->conn_rxfc, rxfc_wnd, DEFAULT_STREAM_RXFC_MAX_WND_MUL * rxfc_wnd, get_time, ch)) goto err; return 1; err: ossl_quic_sstream_free(qs->sstream); qs->sstream = NULL; ossl_quic_rstream_free(qs->rstream); qs->rstream = NULL; return 0; } static uint64_t *ch_get_local_stream_next_ordinal_ptr(QUIC_CHANNEL *ch, int is_uni) { return is_uni ? &ch->next_local_stream_ordinal_uni : &ch->next_local_stream_ordinal_bidi; } int ossl_quic_channel_is_new_local_stream_admissible(QUIC_CHANNEL *ch, int is_uni) { uint64_t *p_next_ordinal = ch_get_local_stream_next_ordinal_ptr(ch, is_uni); return ossl_quic_stream_map_is_local_allowed_by_stream_limit(&ch->qsm, *p_next_ordinal, is_uni); } QUIC_STREAM *ossl_quic_channel_new_stream_local(QUIC_CHANNEL *ch, int is_uni) { QUIC_STREAM *qs; int type; uint64_t stream_id, *p_next_ordinal; type = ch->is_server ? QUIC_STREAM_INITIATOR_SERVER : QUIC_STREAM_INITIATOR_CLIENT; p_next_ordinal = ch_get_local_stream_next_ordinal_ptr(ch, is_uni); if (is_uni) type |= QUIC_STREAM_DIR_UNI; else type |= QUIC_STREAM_DIR_BIDI; if (*p_next_ordinal >= ((uint64_t)1) << 62) return NULL; stream_id = ((*p_next_ordinal) << 2) | type; if ((qs = ossl_quic_stream_map_alloc(&ch->qsm, stream_id, type)) == NULL) return NULL; /* Locally-initiated stream, so we always want a send buffer. */ if (!ch_init_new_stream(ch, qs, /*can_send=*/1, /*can_recv=*/!is_uni)) goto err; ++*p_next_ordinal; return qs; err: ossl_quic_stream_map_release(&ch->qsm, qs); return NULL; } QUIC_STREAM *ossl_quic_channel_new_stream_remote(QUIC_CHANNEL *ch, uint64_t stream_id) { uint64_t peer_role; int is_uni; QUIC_STREAM *qs; peer_role = ch->is_server ? QUIC_STREAM_INITIATOR_CLIENT : QUIC_STREAM_INITIATOR_SERVER; if ((stream_id & QUIC_STREAM_INITIATOR_MASK) != peer_role) return NULL; is_uni = ((stream_id & QUIC_STREAM_DIR_MASK) == QUIC_STREAM_DIR_UNI); qs = ossl_quic_stream_map_alloc(&ch->qsm, stream_id, stream_id & (QUIC_STREAM_INITIATOR_MASK | QUIC_STREAM_DIR_MASK)); if (qs == NULL) return NULL; if (!ch_init_new_stream(ch, qs, /*can_send=*/!is_uni, /*can_recv=*/1)) goto err; if (ch->incoming_stream_auto_reject) ossl_quic_channel_reject_stream(ch, qs); else ossl_quic_stream_map_push_accept_queue(&ch->qsm, qs); return qs; err: ossl_quic_stream_map_release(&ch->qsm, qs); return NULL; } void ossl_quic_channel_set_incoming_stream_auto_reject(QUIC_CHANNEL *ch, int enable, uint64_t aec) { ch->incoming_stream_auto_reject = (enable != 0); ch->incoming_stream_auto_reject_aec = aec; } void ossl_quic_channel_reject_stream(QUIC_CHANNEL *ch, QUIC_STREAM *qs) { ossl_quic_stream_map_stop_sending_recv_part(&ch->qsm, qs, ch->incoming_stream_auto_reject_aec); ossl_quic_stream_map_reset_stream_send_part(&ch->qsm, qs, ch->incoming_stream_auto_reject_aec); qs->deleted = 1; ossl_quic_stream_map_update_state(&ch->qsm, qs); } /* Replace local connection ID in TXP and DEMUX for testing purposes. */ int ossl_quic_channel_replace_local_cid(QUIC_CHANNEL *ch, const QUIC_CONN_ID *conn_id) { /* Remove the current LCID from the LCIDM. */ if (!ossl_quic_lcidm_debug_remove(ch->lcidm, &ch->cur_local_cid)) return 0; ch->cur_local_cid = *conn_id; /* Set in the TXP, used only for long header packets. */ if (!ossl_quic_tx_packetiser_set_cur_scid(ch->txp, &ch->cur_local_cid)) return 0; /* Add the new LCID to the LCIDM. */ if (!ossl_quic_lcidm_debug_add(ch->lcidm, ch, &ch->cur_local_cid, 100)) return 0; return 1; } void ossl_quic_channel_set_msg_callback(QUIC_CHANNEL *ch, ossl_msg_cb msg_callback, SSL *msg_callback_ssl) { ch->msg_callback = msg_callback; ch->msg_callback_ssl = msg_callback_ssl; ossl_qtx_set_msg_callback(ch->qtx, msg_callback, msg_callback_ssl); ossl_quic_tx_packetiser_set_msg_callback(ch->txp, msg_callback, msg_callback_ssl); ossl_qrx_set_msg_callback(ch->qrx, msg_callback, msg_callback_ssl); } void ossl_quic_channel_set_msg_callback_arg(QUIC_CHANNEL *ch, void *msg_callback_arg) { ch->msg_callback_arg = msg_callback_arg; ossl_qtx_set_msg_callback_arg(ch->qtx, msg_callback_arg); ossl_quic_tx_packetiser_set_msg_callback_arg(ch->txp, msg_callback_arg); ossl_qrx_set_msg_callback_arg(ch->qrx, msg_callback_arg); } void ossl_quic_channel_set_txku_threshold_override(QUIC_CHANNEL *ch, uint64_t tx_pkt_threshold) { ch->txku_threshold_override = tx_pkt_threshold; } uint64_t ossl_quic_channel_get_tx_key_epoch(QUIC_CHANNEL *ch) { return ossl_qtx_get_key_epoch(ch->qtx); } uint64_t ossl_quic_channel_get_rx_key_epoch(QUIC_CHANNEL *ch) { return ossl_qrx_get_key_epoch(ch->qrx); } int ossl_quic_channel_trigger_txku(QUIC_CHANNEL *ch) { if (!txku_allowed(ch)) return 0; ch->ku_locally_initiated = 1; ch_trigger_txku(ch); return 1; } int ossl_quic_channel_ping(QUIC_CHANNEL *ch) { int pn_space = ossl_quic_enc_level_to_pn_space(ch->tx_enc_level); ossl_quic_tx_packetiser_schedule_ack_eliciting(ch->txp, pn_space); return 1; } uint16_t ossl_quic_channel_get_diag_num_rx_ack(QUIC_CHANNEL *ch) { return ch->diag_num_rx_ack; } void ossl_quic_channel_get_diag_local_cid(QUIC_CHANNEL *ch, QUIC_CONN_ID *cid) { *cid = ch->cur_local_cid; }

./openssl/ssl/quic/quic_fifd.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_fifd.h" #include "internal/quic_wire.h" DEFINE_LIST_OF(tx_history, OSSL_ACKM_TX_PKT); int ossl_quic_fifd_init(QUIC_FIFD *fifd, QUIC_CFQ *cfq, OSSL_ACKM *ackm, QUIC_TXPIM *txpim, /* stream_id is UINT64_MAX for the crypto stream */ QUIC_SSTREAM *(*get_sstream_by_id)(uint64_t stream_id, uint32_t pn_space, void *arg), void *get_sstream_by_id_arg, /* stream_id is UINT64_MAX if not applicable */ void (*regen_frame)(uint64_t frame_type, uint64_t stream_id, QUIC_TXPIM_PKT *pkt, void *arg), void *regen_frame_arg, void (*confirm_frame)(uint64_t frame_type, uint64_t stream_id, QUIC_TXPIM_PKT *pkt, void *arg), void *confirm_frame_arg, void (*sstream_updated)(uint64_t stream_id, void *arg), void *sstream_updated_arg) { if (cfq == NULL || ackm == NULL || txpim == NULL || get_sstream_by_id == NULL || regen_frame == NULL) return 0; fifd->cfq = cfq; fifd->ackm = ackm; fifd->txpim = txpim; fifd->get_sstream_by_id = get_sstream_by_id; fifd->get_sstream_by_id_arg = get_sstream_by_id_arg; fifd->regen_frame = regen_frame; fifd->regen_frame_arg = regen_frame_arg; fifd->confirm_frame = confirm_frame; fifd->confirm_frame_arg = confirm_frame_arg; fifd->sstream_updated = sstream_updated; fifd->sstream_updated_arg = sstream_updated_arg; return 1; } void ossl_quic_fifd_cleanup(QUIC_FIFD *fifd) { /* No-op. */ } static void on_acked(void *arg) { QUIC_TXPIM_PKT *pkt = arg; QUIC_FIFD *fifd = pkt->fifd; const QUIC_TXPIM_CHUNK *chunks = ossl_quic_txpim_pkt_get_chunks(pkt); size_t i, num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt); QUIC_SSTREAM *sstream; QUIC_CFQ_ITEM *cfq_item, *cfq_item_next; /* STREAM and CRYPTO stream chunks, FINs and stream FC frames */ for (i = 0; i < num_chunks; ++i) { sstream = fifd->get_sstream_by_id(chunks[i].stream_id, pkt->ackm_pkt.pkt_space, fifd->get_sstream_by_id_arg); if (sstream == NULL) continue; if (chunks[i].end >= chunks[i].start) /* coverity[check_return]: Best effort - we cannot fail here. */ ossl_quic_sstream_mark_acked(sstream, chunks[i].start, chunks[i].end); if (chunks[i].has_fin && chunks[i].stream_id != UINT64_MAX) ossl_quic_sstream_mark_acked_fin(sstream); if (chunks[i].has_stop_sending && chunks[i].stream_id != UINT64_MAX) fifd->confirm_frame(OSSL_QUIC_FRAME_TYPE_STOP_SENDING, chunks[i].stream_id, pkt, fifd->confirm_frame_arg); if (chunks[i].has_reset_stream && chunks[i].stream_id != UINT64_MAX) fifd->confirm_frame(OSSL_QUIC_FRAME_TYPE_RESET_STREAM, chunks[i].stream_id, pkt, fifd->confirm_frame_arg); if (ossl_quic_sstream_is_totally_acked(sstream)) fifd->sstream_updated(chunks[i].stream_id, fifd->sstream_updated_arg); } /* GCR */ for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) { cfq_item_next = cfq_item->pkt_next; ossl_quic_cfq_release(fifd->cfq, cfq_item); } ossl_quic_txpim_pkt_release(fifd->txpim, pkt); } static void on_lost(void *arg) { QUIC_TXPIM_PKT *pkt = arg; QUIC_FIFD *fifd = pkt->fifd; const QUIC_TXPIM_CHUNK *chunks = ossl_quic_txpim_pkt_get_chunks(pkt); size_t i, num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt); QUIC_SSTREAM *sstream; QUIC_CFQ_ITEM *cfq_item, *cfq_item_next; int sstream_updated; /* STREAM and CRYPTO stream chunks, FIN and stream FC frames */ for (i = 0; i < num_chunks; ++i) { sstream = fifd->get_sstream_by_id(chunks[i].stream_id, pkt->ackm_pkt.pkt_space, fifd->get_sstream_by_id_arg); if (sstream == NULL) continue; sstream_updated = 0; if (chunks[i].end >= chunks[i].start) { /* * Note: If the stream is being reset, we do not need to retransmit * old data as this is pointless. In this case this will be handled * by (sstream == NULL) above as the QSM will free the QUIC_SSTREAM * and our call to get_sstream_by_id above will return NULL. */ ossl_quic_sstream_mark_lost(sstream, chunks[i].start, chunks[i].end); sstream_updated = 1; } if (chunks[i].has_fin && chunks[i].stream_id != UINT64_MAX) { ossl_quic_sstream_mark_lost_fin(sstream); sstream_updated = 1; } if (chunks[i].has_stop_sending && chunks[i].stream_id != UINT64_MAX) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_STOP_SENDING, chunks[i].stream_id, pkt, fifd->regen_frame_arg); if (chunks[i].has_reset_stream && chunks[i].stream_id != UINT64_MAX) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_RESET_STREAM, chunks[i].stream_id, pkt, fifd->regen_frame_arg); /* * Inform caller that stream needs an FC frame. * * Note: We could track whether an FC frame was sent originally for the * stream to determine if it really needs to be regenerated or not. * However, if loss has occurred, it's probably better to ensure the * peer has up-to-date flow control data for the stream. Given that * these frames are extremely small, we may as well always send it when * handling loss. */ fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, chunks[i].stream_id, pkt, fifd->regen_frame_arg); if (sstream_updated && chunks[i].stream_id != UINT64_MAX) fifd->sstream_updated(chunks[i].stream_id, fifd->sstream_updated_arg); } /* GCR */ for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) { cfq_item_next = cfq_item->pkt_next; ossl_quic_cfq_mark_lost(fifd->cfq, cfq_item, UINT32_MAX); } /* Regenerate flag frames */ if (pkt->had_handshake_done_frame) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, UINT64_MAX, pkt, fifd->regen_frame_arg); if (pkt->had_max_data_frame) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_DATA, UINT64_MAX, pkt, fifd->regen_frame_arg); if (pkt->had_max_streams_bidi_frame) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI, UINT64_MAX, pkt, fifd->regen_frame_arg); if (pkt->had_max_streams_uni_frame) fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI, UINT64_MAX, pkt, fifd->regen_frame_arg); if (pkt->had_ack_frame) /* * We always use the ACK_WITH_ECN frame type to represent the ACK frame * type in our callback; we assume it is the caller's job to decide * whether it wants to send ECN data or not. */ fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN, UINT64_MAX, pkt, fifd->regen_frame_arg); ossl_quic_txpim_pkt_release(fifd->txpim, pkt); } static void on_discarded(void *arg) { QUIC_TXPIM_PKT *pkt = arg; QUIC_FIFD *fifd = pkt->fifd; QUIC_CFQ_ITEM *cfq_item, *cfq_item_next; /* * Don't need to do anything to SSTREAMs for STREAM and CRYPTO streams, as * we assume caller will clean them up. */ /* GCR */ for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item_next) { cfq_item_next = cfq_item->pkt_next; ossl_quic_cfq_release(fifd->cfq, cfq_item); } ossl_quic_txpim_pkt_release(fifd->txpim, pkt); } int ossl_quic_fifd_pkt_commit(QUIC_FIFD *fifd, QUIC_TXPIM_PKT *pkt) { QUIC_CFQ_ITEM *cfq_item; const QUIC_TXPIM_CHUNK *chunks; size_t i, num_chunks; QUIC_SSTREAM *sstream; pkt->fifd = fifd; pkt->ackm_pkt.on_lost = on_lost; pkt->ackm_pkt.on_acked = on_acked; pkt->ackm_pkt.on_discarded = on_discarded; pkt->ackm_pkt.cb_arg = pkt; ossl_list_tx_history_init_elem(&pkt->ackm_pkt); pkt->ackm_pkt.anext = pkt->ackm_pkt.lnext = NULL; /* * Mark the CFQ items which have been added to this packet as having been * transmitted. */ for (cfq_item = pkt->retx_head; cfq_item != NULL; cfq_item = cfq_item->pkt_next) ossl_quic_cfq_mark_tx(fifd->cfq, cfq_item); /* * Mark the send stream chunks which have been added to the packet as having * been transmitted. */ chunks = ossl_quic_txpim_pkt_get_chunks(pkt); num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt); for (i = 0; i < num_chunks; ++i) { sstream = fifd->get_sstream_by_id(chunks[i].stream_id, pkt->ackm_pkt.pkt_space, fifd->get_sstream_by_id_arg); if (sstream == NULL) continue; if (chunks[i].end >= chunks[i].start && !ossl_quic_sstream_mark_transmitted(sstream, chunks[i].start, chunks[i].end)) return 0; if (chunks[i].has_fin && !ossl_quic_sstream_mark_transmitted_fin(sstream, chunks[i].end + 1)) return 0; } /* Inform the ACKM. */ return ossl_ackm_on_tx_packet(fifd->ackm, &pkt->ackm_pkt); }

./openssl/ssl/quic/quic_wire.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/macros.h> #include <openssl/objects.h> #include "internal/quic_ssl.h" #include "internal/quic_vlint.h" #include "internal/quic_wire.h" #include "internal/quic_error.h" OSSL_SAFE_MATH_UNSIGNED(uint64_t, uint64_t) int ossl_quic_frame_ack_contains_pn(const OSSL_QUIC_FRAME_ACK *ack, QUIC_PN pn) { size_t i; for (i = 0; i < ack->num_ack_ranges; ++i) if (pn >= ack->ack_ranges[i].start && pn <= ack->ack_ranges[i].end) return 1; return 0; } /* * QUIC Wire Format Encoding * ========================= */ int ossl_quic_wire_encode_padding(WPACKET *pkt, size_t num_bytes) { /* * PADDING is frame type zero, which as a variable-length integer is * represented as a single zero byte. As an optimisation, just use memset. */ return WPACKET_memset(pkt, 0, num_bytes); } static int encode_frame_hdr(WPACKET *pkt, uint64_t frame_type) { return WPACKET_quic_write_vlint(pkt, frame_type); } int ossl_quic_wire_encode_frame_ping(WPACKET *pkt) { return encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_PING); } int ossl_quic_wire_encode_frame_ack(WPACKET *pkt, uint32_t ack_delay_exponent, const OSSL_QUIC_FRAME_ACK *ack) { uint64_t frame_type = ack->ecn_present ? OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN : OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN; uint64_t largest_ackd, first_ack_range, ack_delay_enc; uint64_t i, num_ack_ranges = ack->num_ack_ranges; OSSL_TIME delay; if (num_ack_ranges == 0) return 0; delay = ossl_time_divide(ossl_time_divide(ack->delay_time, OSSL_TIME_US), (uint64_t)1 << ack_delay_exponent); ack_delay_enc = ossl_time2ticks(delay); largest_ackd = ack->ack_ranges[0].end; first_ack_range = ack->ack_ranges[0].end - ack->ack_ranges[0].start; if (!encode_frame_hdr(pkt, frame_type) || !WPACKET_quic_write_vlint(pkt, largest_ackd) || !WPACKET_quic_write_vlint(pkt, ack_delay_enc) || !WPACKET_quic_write_vlint(pkt, num_ack_ranges - 1) || !WPACKET_quic_write_vlint(pkt, first_ack_range)) return 0; for (i = 1; i < num_ack_ranges; ++i) { uint64_t gap, range_len; gap = ack->ack_ranges[i - 1].start - ack->ack_ranges[i].end - 2; range_len = ack->ack_ranges[i].end - ack->ack_ranges[i].start; if (!WPACKET_quic_write_vlint(pkt, gap) || !WPACKET_quic_write_vlint(pkt, range_len)) return 0; } if (ack->ecn_present) if (!WPACKET_quic_write_vlint(pkt, ack->ect0) || !WPACKET_quic_write_vlint(pkt, ack->ect1) || !WPACKET_quic_write_vlint(pkt, ack->ecnce)) return 0; return 1; } int ossl_quic_wire_encode_frame_reset_stream(WPACKET *pkt, const OSSL_QUIC_FRAME_RESET_STREAM *f) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_RESET_STREAM) || !WPACKET_quic_write_vlint(pkt, f->stream_id) || !WPACKET_quic_write_vlint(pkt, f->app_error_code) || !WPACKET_quic_write_vlint(pkt, f->final_size)) return 0; return 1; } int ossl_quic_wire_encode_frame_stop_sending(WPACKET *pkt, const OSSL_QUIC_FRAME_STOP_SENDING *f) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_STOP_SENDING) || !WPACKET_quic_write_vlint(pkt, f->stream_id) || !WPACKET_quic_write_vlint(pkt, f->app_error_code)) return 0; return 1; } int ossl_quic_wire_encode_frame_crypto_hdr(WPACKET *pkt, const OSSL_QUIC_FRAME_CRYPTO *f) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_CRYPTO) || !WPACKET_quic_write_vlint(pkt, f->offset) || !WPACKET_quic_write_vlint(pkt, f->len)) return 0; return 1; } size_t ossl_quic_wire_get_encoded_frame_len_crypto_hdr(const OSSL_QUIC_FRAME_CRYPTO *f) { size_t a, b, c; a = ossl_quic_vlint_encode_len(OSSL_QUIC_FRAME_TYPE_CRYPTO); b = ossl_quic_vlint_encode_len(f->offset); c = ossl_quic_vlint_encode_len(f->len); if (a == 0 || b == 0 || c == 0) return 0; return a + b + c; } void *ossl_quic_wire_encode_frame_crypto(WPACKET *pkt, const OSSL_QUIC_FRAME_CRYPTO *f) { unsigned char *p = NULL; if (!ossl_quic_wire_encode_frame_crypto_hdr(pkt, f) || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */ || !WPACKET_allocate_bytes(pkt, (size_t)f->len, &p)) return NULL; if (f->data != NULL) memcpy(p, f->data, (size_t)f->len); return p; } int ossl_quic_wire_encode_frame_new_token(WPACKET *pkt, const unsigned char *token, size_t token_len) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN) || !WPACKET_quic_write_vlint(pkt, token_len) || !WPACKET_memcpy(pkt, token, token_len)) return 0; return 1; } int ossl_quic_wire_encode_frame_stream_hdr(WPACKET *pkt, const OSSL_QUIC_FRAME_STREAM *f) { uint64_t frame_type = OSSL_QUIC_FRAME_TYPE_STREAM; if (f->offset != 0) frame_type |= OSSL_QUIC_FRAME_FLAG_STREAM_OFF; if (f->has_explicit_len) frame_type |= OSSL_QUIC_FRAME_FLAG_STREAM_LEN; if (f->is_fin) frame_type |= OSSL_QUIC_FRAME_FLAG_STREAM_FIN; if (!encode_frame_hdr(pkt, frame_type) || !WPACKET_quic_write_vlint(pkt, f->stream_id)) return 0; if (f->offset != 0 && !WPACKET_quic_write_vlint(pkt, f->offset)) return 0; if (f->has_explicit_len && !WPACKET_quic_write_vlint(pkt, f->len)) return 0; return 1; } size_t ossl_quic_wire_get_encoded_frame_len_stream_hdr(const OSSL_QUIC_FRAME_STREAM *f) { size_t a, b, c, d; a = ossl_quic_vlint_encode_len(OSSL_QUIC_FRAME_TYPE_STREAM); b = ossl_quic_vlint_encode_len(f->stream_id); if (a == 0 || b == 0) return 0; if (f->offset > 0) { c = ossl_quic_vlint_encode_len(f->offset); if (c == 0) return 0; } else { c = 0; } if (f->has_explicit_len) { d = ossl_quic_vlint_encode_len(f->len); if (d == 0) return 0; } else { d = 0; } return a + b + c + d; } void *ossl_quic_wire_encode_frame_stream(WPACKET *pkt, const OSSL_QUIC_FRAME_STREAM *f) { unsigned char *p = NULL; if (!ossl_quic_wire_encode_frame_stream_hdr(pkt, f) || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */) return NULL; if (!WPACKET_allocate_bytes(pkt, (size_t)f->len, &p)) return NULL; if (f->data != NULL) memcpy(p, f->data, (size_t)f->len); return p; } int ossl_quic_wire_encode_frame_max_data(WPACKET *pkt, uint64_t max_data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_MAX_DATA) || !WPACKET_quic_write_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_encode_frame_max_stream_data(WPACKET *pkt, uint64_t stream_id, uint64_t max_data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA) || !WPACKET_quic_write_vlint(pkt, stream_id) || !WPACKET_quic_write_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_encode_frame_max_streams(WPACKET *pkt, char is_uni, uint64_t max_streams) { if (!encode_frame_hdr(pkt, is_uni ? OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI : OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI) || !WPACKET_quic_write_vlint(pkt, max_streams)) return 0; return 1; } int ossl_quic_wire_encode_frame_data_blocked(WPACKET *pkt, uint64_t max_data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED) || !WPACKET_quic_write_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_encode_frame_stream_data_blocked(WPACKET *pkt, uint64_t stream_id, uint64_t max_stream_data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED) || !WPACKET_quic_write_vlint(pkt, stream_id) || !WPACKET_quic_write_vlint(pkt, max_stream_data)) return 0; return 1; } int ossl_quic_wire_encode_frame_streams_blocked(WPACKET *pkt, char is_uni, uint64_t max_streams) { if (!encode_frame_hdr(pkt, is_uni ? OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI : OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI) || !WPACKET_quic_write_vlint(pkt, max_streams)) return 0; return 1; } int ossl_quic_wire_encode_frame_new_conn_id(WPACKET *pkt, const OSSL_QUIC_FRAME_NEW_CONN_ID *f) { if (f->conn_id.id_len < 1 || f->conn_id.id_len > QUIC_MAX_CONN_ID_LEN) return 0; if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID) || !WPACKET_quic_write_vlint(pkt, f->seq_num) || !WPACKET_quic_write_vlint(pkt, f->retire_prior_to) || !WPACKET_put_bytes_u8(pkt, f->conn_id.id_len) || !WPACKET_memcpy(pkt, f->conn_id.id, f->conn_id.id_len) || !WPACKET_memcpy(pkt, f->stateless_reset.token, sizeof(f->stateless_reset.token))) return 0; return 1; } int ossl_quic_wire_encode_frame_retire_conn_id(WPACKET *pkt, uint64_t seq_num) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID) || !WPACKET_quic_write_vlint(pkt, seq_num)) return 0; return 1; } int ossl_quic_wire_encode_frame_path_challenge(WPACKET *pkt, uint64_t data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE) || !WPACKET_put_bytes_u64(pkt, data)) return 0; return 1; } int ossl_quic_wire_encode_frame_path_response(WPACKET *pkt, uint64_t data) { if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE) || !WPACKET_put_bytes_u64(pkt, data)) return 0; return 1; } int ossl_quic_wire_encode_frame_conn_close(WPACKET *pkt, const OSSL_QUIC_FRAME_CONN_CLOSE *f) { if (!encode_frame_hdr(pkt, f->is_app ? OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP : OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT) || !WPACKET_quic_write_vlint(pkt, f->error_code)) return 0; /* * RFC 9000 s. 19.19: The application-specific variant of CONNECTION_CLOSE * (type 0x1d) does not include this field. */ if (!f->is_app && !WPACKET_quic_write_vlint(pkt, f->frame_type)) return 0; if (!WPACKET_quic_write_vlint(pkt, f->reason_len) || !WPACKET_memcpy(pkt, f->reason, f->reason_len)) return 0; return 1; } int ossl_quic_wire_encode_frame_handshake_done(WPACKET *pkt) { return encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE); } unsigned char *ossl_quic_wire_encode_transport_param_bytes(WPACKET *pkt, uint64_t id, const unsigned char *value, size_t value_len) { unsigned char *b = NULL; if (!WPACKET_quic_write_vlint(pkt, id) || !WPACKET_quic_write_vlint(pkt, value_len)) return NULL; if (value_len == 0) b = WPACKET_get_curr(pkt); else if (!WPACKET_allocate_bytes(pkt, value_len, (unsigned char **)&b)) return NULL; if (value != NULL) memcpy(b, value, value_len); return b; } int ossl_quic_wire_encode_transport_param_int(WPACKET *pkt, uint64_t id, uint64_t value) { if (!WPACKET_quic_write_vlint(pkt, id) || !WPACKET_quic_write_vlint(pkt, ossl_quic_vlint_encode_len(value)) || !WPACKET_quic_write_vlint(pkt, value)) return 0; return 1; } int ossl_quic_wire_encode_transport_param_cid(WPACKET *wpkt, uint64_t id, const QUIC_CONN_ID *cid) { if (cid->id_len > QUIC_MAX_CONN_ID_LEN) return 0; if (ossl_quic_wire_encode_transport_param_bytes(wpkt, id, cid->id, cid->id_len) == NULL) return 0; return 1; } /* * QUIC Wire Format Decoding * ========================= */ int ossl_quic_wire_peek_frame_header(PACKET *pkt, uint64_t *type, int *was_minimal) { return PACKET_peek_quic_vlint_ex(pkt, type, was_minimal); } int ossl_quic_wire_skip_frame_header(PACKET *pkt, uint64_t *type) { return PACKET_get_quic_vlint(pkt, type); } static int expect_frame_header_mask(PACKET *pkt, uint64_t expected_frame_type, uint64_t mask_bits, uint64_t *actual_frame_type) { uint64_t actual_frame_type_; if (!ossl_quic_wire_skip_frame_header(pkt, &actual_frame_type_) || (actual_frame_type_ & ~mask_bits) != expected_frame_type) return 0; if (actual_frame_type != NULL) *actual_frame_type = actual_frame_type_; return 1; } static int expect_frame_header(PACKET *pkt, uint64_t expected_frame_type) { uint64_t actual_frame_type; if (!ossl_quic_wire_skip_frame_header(pkt, &actual_frame_type) || actual_frame_type != expected_frame_type) return 0; return 1; } int ossl_quic_wire_peek_frame_ack_num_ranges(const PACKET *orig_pkt, uint64_t *total_ranges) { PACKET pkt = *orig_pkt; uint64_t ack_range_count, i; if (!expect_frame_header_mask(&pkt, OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN, 1, NULL) || !PACKET_skip_quic_vlint(&pkt) || !PACKET_skip_quic_vlint(&pkt) || !PACKET_get_quic_vlint(&pkt, &ack_range_count)) return 0; /* * Ensure the specified number of ack ranges listed in the ACK frame header * actually are available in the frame data. This naturally bounds the * number of ACK ranges which can be requested by the MDPL, and therefore by * the MTU. This ensures we do not allocate memory for an excessive number * of ACK ranges. */ for (i = 0; i < ack_range_count; ++i) if (!PACKET_skip_quic_vlint(&pkt) || !PACKET_skip_quic_vlint(&pkt)) return 0; /* (cannot overflow because QUIC vlints can only encode up to 2**62-1) */ *total_ranges = ack_range_count + 1; return 1; } int ossl_quic_wire_decode_frame_ack(PACKET *pkt, uint32_t ack_delay_exponent, OSSL_QUIC_FRAME_ACK *ack, uint64_t *total_ranges) { uint64_t frame_type, largest_ackd, ack_delay_raw; uint64_t ack_range_count, first_ack_range, start, end, i; /* This call matches both ACK_WITHOUT_ECN and ACK_WITH_ECN. */ if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN, 1, &frame_type) || !PACKET_get_quic_vlint(pkt, &largest_ackd) || !PACKET_get_quic_vlint(pkt, &ack_delay_raw) || !PACKET_get_quic_vlint(pkt, &ack_range_count) || !PACKET_get_quic_vlint(pkt, &first_ack_range)) return 0; if (first_ack_range > largest_ackd) return 0; if (ack_range_count > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */) return 0; start = largest_ackd - first_ack_range; if (ack != NULL) { int err = 0; ack->delay_time = ossl_time_multiply(ossl_ticks2time(OSSL_TIME_US), safe_mul_uint64_t(ack_delay_raw, (uint64_t)1 << ack_delay_exponent, &err)); if (err) ack->delay_time = ossl_time_infinite(); if (ack->num_ack_ranges > 0) { ack->ack_ranges[0].end = largest_ackd; ack->ack_ranges[0].start = start; } } for (i = 0; i < ack_range_count; ++i) { uint64_t gap, len; if (!PACKET_get_quic_vlint(pkt, &gap) || !PACKET_get_quic_vlint(pkt, &len)) return 0; end = start - gap - 2; if (start < gap + 2 || len > end) return 0; if (ack != NULL && i + 1 < ack->num_ack_ranges) { ack->ack_ranges[i + 1].start = start = end - len; ack->ack_ranges[i + 1].end = end; } } if (ack != NULL && ack_range_count + 1 < ack->num_ack_ranges) ack->num_ack_ranges = (size_t)ack_range_count + 1; if (total_ranges != NULL) *total_ranges = ack_range_count + 1; if (frame_type == OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN) { uint64_t ect0, ect1, ecnce; if (!PACKET_get_quic_vlint(pkt, &ect0) || !PACKET_get_quic_vlint(pkt, &ect1) || !PACKET_get_quic_vlint(pkt, &ecnce)) return 0; if (ack != NULL) { ack->ect0 = ect0; ack->ect1 = ect1; ack->ecnce = ecnce; ack->ecn_present = 1; } } else if (ack != NULL) { ack->ecn_present = 0; } return 1; } int ossl_quic_wire_decode_frame_reset_stream(PACKET *pkt, OSSL_QUIC_FRAME_RESET_STREAM *f) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_RESET_STREAM) || !PACKET_get_quic_vlint(pkt, &f->stream_id) || !PACKET_get_quic_vlint(pkt, &f->app_error_code) || !PACKET_get_quic_vlint(pkt, &f->final_size)) return 0; return 1; } int ossl_quic_wire_decode_frame_stop_sending(PACKET *pkt, OSSL_QUIC_FRAME_STOP_SENDING *f) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_STOP_SENDING) || !PACKET_get_quic_vlint(pkt, &f->stream_id) || !PACKET_get_quic_vlint(pkt, &f->app_error_code)) return 0; return 1; } int ossl_quic_wire_decode_frame_crypto(PACKET *pkt, int nodata, OSSL_QUIC_FRAME_CRYPTO *f) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_CRYPTO) || !PACKET_get_quic_vlint(pkt, &f->offset) || !PACKET_get_quic_vlint(pkt, &f->len) || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */) return 0; if (f->offset + f->len > (((uint64_t)1) << 62) - 1) /* RFC 9000 s. 19.6 */ return 0; if (nodata) { f->data = NULL; } else { if (PACKET_remaining(pkt) < f->len) return 0; f->data = PACKET_data(pkt); if (!PACKET_forward(pkt, (size_t)f->len)) return 0; } return 1; } int ossl_quic_wire_decode_frame_new_token(PACKET *pkt, const unsigned char **token, size_t *token_len) { uint64_t token_len_; if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN) || !PACKET_get_quic_vlint(pkt, &token_len_)) return 0; if (token_len_ > SIZE_MAX) return 0; *token = PACKET_data(pkt); *token_len = (size_t)token_len_; if (!PACKET_forward(pkt, (size_t)token_len_)) return 0; return 1; } int ossl_quic_wire_decode_frame_stream(PACKET *pkt, int nodata, OSSL_QUIC_FRAME_STREAM *f) { uint64_t frame_type; /* This call matches all STREAM values (low 3 bits are masked). */ if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_STREAM, OSSL_QUIC_FRAME_FLAG_STREAM_MASK, &frame_type) || !PACKET_get_quic_vlint(pkt, &f->stream_id)) return 0; if ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_OFF) != 0) { if (!PACKET_get_quic_vlint(pkt, &f->offset)) return 0; } else { f->offset = 0; } f->has_explicit_len = ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_LEN) != 0); f->is_fin = ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_FIN) != 0); if (f->has_explicit_len) { if (!PACKET_get_quic_vlint(pkt, &f->len)) return 0; } else { if (nodata) f->len = 0; else f->len = PACKET_remaining(pkt); } /* * RFC 9000 s. 19.8: "The largest offset delivered on a stream -- the sum of * the offset and data length -- cannot exceed 2**62 - 1, as it is not * possible to provide flow control credit for that data." */ if (f->offset + f->len > (((uint64_t)1) << 62) - 1) return 0; if (nodata) { f->data = NULL; } else { f->data = PACKET_data(pkt); if (f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */ || !PACKET_forward(pkt, (size_t)f->len)) return 0; } return 1; } int ossl_quic_wire_decode_frame_max_data(PACKET *pkt, uint64_t *max_data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_MAX_DATA) || !PACKET_get_quic_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_decode_frame_max_stream_data(PACKET *pkt, uint64_t *stream_id, uint64_t *max_stream_data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA) || !PACKET_get_quic_vlint(pkt, stream_id) || !PACKET_get_quic_vlint(pkt, max_stream_data)) return 0; return 1; } int ossl_quic_wire_decode_frame_max_streams(PACKET *pkt, uint64_t *max_streams) { /* This call matches both MAX_STREAMS_BIDI and MAX_STREAMS_UNI. */ if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI, 1, NULL) || !PACKET_get_quic_vlint(pkt, max_streams)) return 0; return 1; } int ossl_quic_wire_decode_frame_data_blocked(PACKET *pkt, uint64_t *max_data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED) || !PACKET_get_quic_vlint(pkt, max_data)) return 0; return 1; } int ossl_quic_wire_decode_frame_stream_data_blocked(PACKET *pkt, uint64_t *stream_id, uint64_t *max_stream_data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED) || !PACKET_get_quic_vlint(pkt, stream_id) || !PACKET_get_quic_vlint(pkt, max_stream_data)) return 0; return 1; } int ossl_quic_wire_decode_frame_streams_blocked(PACKET *pkt, uint64_t *max_streams) { /* This call matches both STREAMS_BLOCKED_BIDI and STREAMS_BLOCKED_UNI. */ if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI, 1, NULL) || !PACKET_get_quic_vlint(pkt, max_streams)) return 0; return 1; } int ossl_quic_wire_decode_frame_new_conn_id(PACKET *pkt, OSSL_QUIC_FRAME_NEW_CONN_ID *f) { unsigned int len; if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID) || !PACKET_get_quic_vlint(pkt, &f->seq_num) || !PACKET_get_quic_vlint(pkt, &f->retire_prior_to) || f->seq_num < f->retire_prior_to || !PACKET_get_1(pkt, &len) || len < 1 || len > QUIC_MAX_CONN_ID_LEN) return 0; f->conn_id.id_len = (unsigned char)len; if (!PACKET_copy_bytes(pkt, f->conn_id.id, len)) return 0; /* Clear unused bytes to allow consistent memcmp. */ if (len < QUIC_MAX_CONN_ID_LEN) memset(f->conn_id.id + len, 0, QUIC_MAX_CONN_ID_LEN - len); if (!PACKET_copy_bytes(pkt, f->stateless_reset.token, sizeof(f->stateless_reset.token))) return 0; return 1; } int ossl_quic_wire_decode_frame_retire_conn_id(PACKET *pkt, uint64_t *seq_num) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID) || !PACKET_get_quic_vlint(pkt, seq_num)) return 0; return 1; } int ossl_quic_wire_decode_frame_path_challenge(PACKET *pkt, uint64_t *data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE) || !PACKET_get_net_8(pkt, data)) return 0; return 1; } int ossl_quic_wire_decode_frame_path_response(PACKET *pkt, uint64_t *data) { if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE) || !PACKET_get_net_8(pkt, data)) return 0; return 1; } int ossl_quic_wire_decode_frame_conn_close(PACKET *pkt, OSSL_QUIC_FRAME_CONN_CLOSE *f) { uint64_t frame_type, reason_len; /* This call matches both CONN_CLOSE_TRANSPORT and CONN_CLOSE_APP. */ if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT, 1, &frame_type) || !PACKET_get_quic_vlint(pkt, &f->error_code)) return 0; f->is_app = ((frame_type & 1) != 0); if (!f->is_app) { if (!PACKET_get_quic_vlint(pkt, &f->frame_type)) return 0; } else { f->frame_type = 0; } if (!PACKET_get_quic_vlint(pkt, &reason_len) || reason_len > SIZE_MAX) return 0; if (!PACKET_get_bytes(pkt, (const unsigned char **)&f->reason, (size_t)reason_len)) return 0; f->reason_len = (size_t)reason_len; return 1; } size_t ossl_quic_wire_decode_padding(PACKET *pkt) { const unsigned char *start = PACKET_data(pkt), *end = PACKET_end(pkt), *p = start; while (p < end && *p == 0) ++p; if (!PACKET_forward(pkt, p - start)) return 0; return p - start; } int ossl_quic_wire_decode_frame_ping(PACKET *pkt) { return expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_PING); } int ossl_quic_wire_decode_frame_handshake_done(PACKET *pkt) { return expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE); } int ossl_quic_wire_peek_transport_param(PACKET *pkt, uint64_t *id) { return PACKET_peek_quic_vlint(pkt, id); } const unsigned char *ossl_quic_wire_decode_transport_param_bytes(PACKET *pkt, uint64_t *id, size_t *len) { uint64_t len_; const unsigned char *b = NULL; uint64_t id_; if (!PACKET_get_quic_vlint(pkt, &id_) || !PACKET_get_quic_vlint(pkt, &len_)) return NULL; if (len_ > SIZE_MAX || !PACKET_get_bytes(pkt, (const unsigned char **)&b, (size_t)len_)) return NULL; *len = (size_t)len_; if (id != NULL) *id = id_; return b; } int ossl_quic_wire_decode_transport_param_int(PACKET *pkt, uint64_t *id, uint64_t *value) { PACKET sub; sub.curr = ossl_quic_wire_decode_transport_param_bytes(pkt, id, &sub.remaining); if (sub.curr == NULL) return 0; if (!PACKET_get_quic_vlint(&sub, value)) return 0; if (PACKET_remaining(&sub) > 0) return 0; return 1; } int ossl_quic_wire_decode_transport_param_cid(PACKET *pkt, uint64_t *id, QUIC_CONN_ID *cid) { const unsigned char *body; size_t len = 0; body = ossl_quic_wire_decode_transport_param_bytes(pkt, id, &len); if (body == NULL || len > QUIC_MAX_CONN_ID_LEN) return 0; cid->id_len = (unsigned char)len; memcpy(cid->id, body, cid->id_len); return 1; } int ossl_quic_wire_decode_transport_param_preferred_addr(PACKET *pkt, QUIC_PREFERRED_ADDR *p) { const unsigned char *body; uint64_t id; size_t len = 0; PACKET pkt2; unsigned int ipv4_port, ipv6_port, cidl; body = ossl_quic_wire_decode_transport_param_bytes(pkt, &id, &len); if (body == NULL || len < QUIC_MIN_ENCODED_PREFERRED_ADDR_LEN || len > QUIC_MAX_ENCODED_PREFERRED_ADDR_LEN || id != QUIC_TPARAM_PREFERRED_ADDR) return 0; if (!PACKET_buf_init(&pkt2, body, len)) return 0; if (!PACKET_copy_bytes(&pkt2, p->ipv4, sizeof(p->ipv4)) || !PACKET_get_net_2(&pkt2, &ipv4_port) || !PACKET_copy_bytes(&pkt2, p->ipv6, sizeof(p->ipv6)) || !PACKET_get_net_2(&pkt2, &ipv6_port) || !PACKET_get_1(&pkt2, &cidl) || cidl > QUIC_MAX_CONN_ID_LEN || !PACKET_copy_bytes(&pkt2, p->cid.id, cidl) || !PACKET_copy_bytes(&pkt2, p->stateless_reset.token, sizeof(p->stateless_reset.token))) return 0; p->ipv4_port = (uint16_t)ipv4_port; p->ipv6_port = (uint16_t)ipv6_port; p->cid.id_len = (unsigned char)cidl; return 1; } const char * ossl_quic_frame_type_to_string(uint64_t frame_type) { switch (frame_type) { #define X(name) case OSSL_QUIC_FRAME_TYPE_##name: return #name; X(PADDING) X(PING) X(ACK_WITHOUT_ECN) X(ACK_WITH_ECN) X(RESET_STREAM) X(STOP_SENDING) X(CRYPTO) X(NEW_TOKEN) X(MAX_DATA) X(MAX_STREAM_DATA) X(MAX_STREAMS_BIDI) X(MAX_STREAMS_UNI) X(DATA_BLOCKED) X(STREAM_DATA_BLOCKED) X(STREAMS_BLOCKED_BIDI) X(STREAMS_BLOCKED_UNI) X(NEW_CONN_ID) X(RETIRE_CONN_ID) X(PATH_CHALLENGE) X(PATH_RESPONSE) X(CONN_CLOSE_TRANSPORT) X(CONN_CLOSE_APP) X(HANDSHAKE_DONE) X(STREAM) X(STREAM_FIN) X(STREAM_LEN) X(STREAM_LEN_FIN) X(STREAM_OFF) X(STREAM_OFF_FIN) X(STREAM_OFF_LEN) X(STREAM_OFF_LEN_FIN) #undef X default: return NULL; } } const char *ossl_quic_err_to_string(uint64_t error_code) { switch (error_code) { #define X(name) case QUIC_ERR_##name: return #name; X(NO_ERROR) X(INTERNAL_ERROR) X(CONNECTION_REFUSED) X(FLOW_CONTROL_ERROR) X(STREAM_LIMIT_ERROR) X(STREAM_STATE_ERROR) X(FINAL_SIZE_ERROR) X(FRAME_ENCODING_ERROR) X(TRANSPORT_PARAMETER_ERROR) X(CONNECTION_ID_LIMIT_ERROR) X(PROTOCOL_VIOLATION) X(INVALID_TOKEN) X(APPLICATION_ERROR) X(CRYPTO_BUFFER_EXCEEDED) X(KEY_UPDATE_ERROR) X(AEAD_LIMIT_REACHED) X(NO_VIABLE_PATH) #undef X default: return NULL; } }

./openssl/ssl/quic/quic_ackm.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_ackm.h" #include "internal/uint_set.h" #include "internal/common.h" #include <assert.h> DEFINE_LIST_OF(tx_history, OSSL_ACKM_TX_PKT); /* * TX Packet History * ***************** * * The TX Packet History object tracks information about packets which have been * sent for which we later expect to receive an ACK. It is essentially a simple * database keeping a list of packet information structures in packet number * order which can also be looked up directly by packet number. * * We currently only allow packets to be appended to the list (i.e. the packet * numbers of the packets appended to the list must monotonically increase), as * we should not currently need more general functionality such as a sorted list * insert. */ struct tx_pkt_history_st { /* A linked list of all our packets. */ OSSL_LIST(tx_history) packets; /* * Mapping from packet numbers (uint64_t) to (OSSL_ACKM_TX_PKT *) * * Invariant: A packet is in this map if and only if it is in the linked * list. */ LHASH_OF(OSSL_ACKM_TX_PKT) *map; /* * The lowest packet number which may currently be added to the history list * (inclusive). We do not allow packet numbers to be added to the history * list non-monotonically, so packet numbers must be greater than or equal * to this value. */ uint64_t watermark; /* * Packet number of the highest packet info structure we have yet appended * to the list. This is usually one less than watermark, except when we have * not added any packet yet. */ uint64_t highest_sent; }; DEFINE_LHASH_OF_EX(OSSL_ACKM_TX_PKT); static unsigned long tx_pkt_info_hash(const OSSL_ACKM_TX_PKT *pkt) { /* Using low bits of the packet number as the hash should be enough */ return (unsigned long)pkt->pkt_num; } static int tx_pkt_info_compare(const OSSL_ACKM_TX_PKT *a, const OSSL_ACKM_TX_PKT *b) { if (a->pkt_num < b->pkt_num) return -1; if (a->pkt_num > b->pkt_num) return 1; return 0; } static int tx_pkt_history_init(struct tx_pkt_history_st *h) { ossl_list_tx_history_init(&h->packets); h->watermark = 0; h->highest_sent = 0; h->map = lh_OSSL_ACKM_TX_PKT_new(tx_pkt_info_hash, tx_pkt_info_compare); if (h->map == NULL) return 0; return 1; } static void tx_pkt_history_destroy(struct tx_pkt_history_st *h) { lh_OSSL_ACKM_TX_PKT_free(h->map); h->map = NULL; ossl_list_tx_history_init(&h->packets); } static int tx_pkt_history_add_actual(struct tx_pkt_history_st *h, OSSL_ACKM_TX_PKT *pkt) { OSSL_ACKM_TX_PKT *existing; /* * There should not be any existing packet with this number * in our mapping. */ existing = lh_OSSL_ACKM_TX_PKT_retrieve(h->map, pkt); if (!ossl_assert(existing == NULL)) return 0; /* Should not already be in a list. */ if (!ossl_assert(ossl_list_tx_history_next(pkt) == NULL && ossl_list_tx_history_prev(pkt) == NULL)) return 0; lh_OSSL_ACKM_TX_PKT_insert(h->map, pkt); ossl_list_tx_history_insert_tail(&h->packets, pkt); return 1; } /* Adds a packet information structure to the history list. */ static int tx_pkt_history_add(struct tx_pkt_history_st *h, OSSL_ACKM_TX_PKT *pkt) { if (!ossl_assert(pkt->pkt_num >= h->watermark)) return 0; if (tx_pkt_history_add_actual(h, pkt) < 1) return 0; h->watermark = pkt->pkt_num + 1; h->highest_sent = pkt->pkt_num; return 1; } /* Retrieve a packet information structure by packet number. */ static OSSL_ACKM_TX_PKT * tx_pkt_history_by_pkt_num(struct tx_pkt_history_st *h, uint64_t pkt_num) { OSSL_ACKM_TX_PKT key; key.pkt_num = pkt_num; return lh_OSSL_ACKM_TX_PKT_retrieve(h->map, &key); } /* Remove a packet information structure from the history log. */ static int tx_pkt_history_remove(struct tx_pkt_history_st *h, uint64_t pkt_num) { OSSL_ACKM_TX_PKT key, *pkt; key.pkt_num = pkt_num; pkt = tx_pkt_history_by_pkt_num(h, pkt_num); if (pkt == NULL) return 0; ossl_list_tx_history_remove(&h->packets, pkt); lh_OSSL_ACKM_TX_PKT_delete(h->map, &key); return 1; } /* * RX Packet Number Tracking * ************************* * * **Background.** The RX side of the ACK manager must track packets we have * received for which we have to generate ACK frames. Broadly, this means we * store a set of packet numbers which we have received but which we do not know * for a fact that the transmitter knows we have received. * * This must handle various situations: * * 1. We receive a packet but have not sent an ACK yet, so the transmitter * does not know whether we have received it or not yet. * * 2. We receive a packet and send an ACK which is lost. We do not * immediately know that the ACK was lost and the transmitter does not know * that we have received the packet. * * 3. We receive a packet and send an ACK which is received by the * transmitter. The transmitter does not immediately respond with an ACK, * or responds with an ACK which is lost. The transmitter knows that we * have received the packet, but we do not know for sure that it knows, * because the ACK we sent could have been lost. * * 4. We receive a packet and send an ACK which is received by the * transmitter. The transmitter subsequently sends us an ACK which confirms * its receipt of the ACK we sent, and we successfully receive that ACK, so * we know that the transmitter knows, that we received the original * packet. * * Only when we reach case (4) are we relieved of any need to track a given * packet number we have received, because only in this case do we know for sure * that the peer knows we have received the packet. Having reached case (4) we * will never again need to generate an ACK containing the PN in question, but * until we reach that point, we must keep track of the PN as not having been * provably ACKed, as we may have to keep generating ACKs for the given PN not * just until the transmitter receives one, but until we know that it has * received one. This will be referred to herein as "provably ACKed". * * **Duplicate handling.** The above discusses the case where we have received a * packet with a given PN but are at best unsure whether the sender knows we * have received it or not. However, we must also handle the case where we have * yet to receive a packet with a given PN in the first place. The reason for * this is because of the requirement expressed by RFC 9000 s. 12.3: * * "A receiver MUST discard a newly unprotected packet unless it is certain * that it has not processed another packet with the same packet number from * the same packet number space." * * We must ensure we never process a duplicate PN. As such, each possible PN we * can receive must exist in one of the following logical states: * * - We have never processed this PN before * (so if we receive such a PN, it can be processed) * * - We have processed this PN but it has not yet been provably ACKed * (and should therefore be in any future ACK frame generated; * if we receive such a PN again, it must be ignored) * * - We have processed this PN and it has been provably ACKed * (if we receive such a PN again, it must be ignored) * * However, if we were to track this state for every PN ever used in the history * of a connection, the amount of state required would increase unboundedly as * the connection goes on (for example, we would have to store a set of every PN * ever received.) * * RFC 9000 s. 12.3 continues: * * "Endpoints that track all individual packets for the purposes of detecting * duplicates are at risk of accumulating excessive state. The data required * for detecting duplicates can be limited by maintaining a minimum packet * number below which all packets are immediately dropped." * * Moreover, RFC 9000 s. 13.2.3 states that: * * "A receiver MUST retain an ACK Range unless it can ensure that it will not * subsequently accept packets with numbers in that range. Maintaining a * minimum packet number that increases as ranges are discarded is one way to * achieve this with minimal state." * * This touches on a subtlety of the original requirement quoted above: the * receiver MUST discard a packet unless it is certain that it has not processed * another packet with the same PN. However, this does not forbid the receiver * from also discarding some PNs even though it has not yet processed them. In * other words, implementations must be conservative and err in the direction of * assuming a packet is a duplicate, but it is acceptable for this to come at * the cost of falsely identifying some packets as duplicates. * * This allows us to bound the amount of state we must keep, and we adopt the * suggested strategy quoted above to do so. We define a watermark PN below * which all PNs are in the same state. This watermark is only ever increased. * Thus the PNs the state for which needs to be explicitly tracked is limited to * only a small number of recent PNs, and all older PNs have an assumed state. * * Any given PN thus falls into one of the following states: * * - (A) The PN is above the watermark but we have not yet received it. * * If we receive such a PN, we should process it and record the PN as * received. * * - (B) The PN is above the watermark and we have received it. * * The PN should be included in any future ACK frame we generate. * If we receive such a PN again, we should ignore it. * * - (C) The PN is below the watermark. * * We do not know whether a packet with the given PN was received or * not. To be safe, if we receive such a packet, it is not processed. * * Note that state (C) corresponds to both "we have processed this PN and it has * been provably ACKed" logical state and a subset of the PNs in the "we have * never processed this PN before" logical state (namely all PNs which were lost * and never received, but which are not recent enough to be above the * watermark). The reason we can merge these states and avoid tracking states * for the PNs in this state is because the provably ACKed and never-received * states are functionally identical in terms of how we need to handle them: we * don't need to do anything for PNs in either of these states, so we don't have * to care about PNs in this state nor do we have to care about distinguishing * the two states for a given PN. * * Note that under this scheme provably ACKed PNs are by definition always below * the watermark; therefore, it follows that when a PN becomes provably ACKed, * the watermark must be immediately increased to exceed it (otherwise we would * keep reporting it in future ACK frames). * * This is in line with RFC 9000 s. 13.2.4's suggested strategy on when * to advance the watermark: * * "When a packet containing an ACK frame is sent, the Largest Acknowledged * field in that frame can be saved. When a packet containing an ACK frame is * acknowledged, the receiver can stop acknowledging packets less than or * equal to the Largest Acknowledged field in the sent ACK frame." * * This is where our scheme's false positives arise. When a packet containing an * ACK frame is itself ACK'd, PNs referenced in that ACK frame become provably * acked, and the watermark is bumped accordingly. However, the Largest * Acknowledged field does not imply that all lower PNs have been received, * because there may be gaps expressed in the ranges of PNs expressed by that * and previous ACK frames. Thus, some unreceived PNs may be moved below the * watermark, and we may subsequently reject those PNs as possibly being * duplicates even though we have not actually received those PNs. Since we bump * the watermark when a PN becomes provably ACKed, it follows that an unreceived * PN falls below the watermark (and thus becomes a false positive for the * purposes of duplicate detection) when a higher-numbered PN becomes provably * ACKed. * * Thus, when PN n becomes provably acked, any unreceived PNs in the range [0, * n) will no longer be processed. Although datagrams may be reordered in the * network, a PN we receive can only become provably ACKed after our own * subsequently generated ACK frame is sent in a future TX packet, and then we * receive another RX PN acknowledging that TX packet. This means that a given RX * PN can only become provably ACKed at least 1 RTT after it is received; it is * unlikely that any reordered datagrams will still be "in the network" (and not * lost) by this time. If this does occur for whatever reason and a late PN is * received, the packet will be discarded unprocessed and the PN is simply * handled as though lost (a "written off" PN). * * **Data structure.** Our state for the RX handling side of the ACK manager, as * discussed above, mainly comprises: * * a) a logical set of PNs, and * b) a monotonically increasing PN counter (the watermark). * * For (a), we define a data structure which stores a logical set of PNs, which * we use to keep track of which PNs we have received but which have not yet * been provably ACKed, and thus will later need to generate an ACK frame for. * * The correspondence with the logical states discussed above is as follows. A * PN is in state (C) if it is below the watermark; otherwise it is in state (B) * if it is in the logical set of PNs, and in state (A) otherwise. * * Note that PNs are only removed from the PN set (when they become provably * ACKed or written off) by virtue of advancement of the watermark. Removing PNs * from the PN set any other way would be ambiguous as it would be * indistinguishable from a PN we have not yet received and risk us processing a * duplicate packet. In other words, for a given PN: * * - State (A) can transition to state (B) or (C) * - State (B) can transition to state (C) only * - State (C) is the terminal state * * We can query the logical set data structure for PNs which have been received * but which have not been provably ACKed when we want to generate ACK frames. * Since ACK frames can be lost and/or we might not know that the peer has * successfully received them, we might generate multiple ACK frames covering a * given PN until that PN becomes provably ACKed and we finally remove it from * our set (by bumping the watermark) as no longer being our concern. * * The data structure used is the UINT_SET structure defined in uint_set.h, * which is used as a PN set. We use the following operations of the structure: * * Insert Range: Used when we receive a new PN. * * Remove Range: Used when bumping the watermark. * * Query: Used to determine if a PN is in the set. * * **Possible duplicates.** A PN is considered a possible duplicate when either: * * a) its PN is already in the PN set (i.e. has already been received), or * b) its PN is below the watermark (i.e. was provably ACKed or written off). * * A packet with a given PN is considered 'processable' when that PN is not * considered a possible duplicate (see ossl_ackm_is_rx_pn_processable). * * **TX/RX interaction.** The watermark is bumped whenever an RX packet becomes * provably ACKed. This occurs when an ACK frame is received by the TX side of * the ACK manager; thus, there is necessary interaction between the TX and RX * sides of the ACK manager. * * This is implemented as follows. When a packet is queued as sent in the TX * side of the ACK manager, it may optionally have a Largest Acked value set on * it. The user of the ACK manager should do this if the packet being * transmitted contains an ACK frame, by setting the field to the Largest Acked * field of that frame. Otherwise, this field should be set to QUIC_PN_INVALID. * When a TX packet is eventually acknowledged which has this field set, it is * used to update the state of the RX side of the ACK manager by bumping the * watermark accordingly. */ struct rx_pkt_history_st { UINT_SET set; /* * Invariant: PNs below this are not in the set. * Invariant: This is monotonic and only ever increases. */ QUIC_PN watermark; }; static int rx_pkt_history_bump_watermark(struct rx_pkt_history_st *h, QUIC_PN watermark); static void rx_pkt_history_init(struct rx_pkt_history_st *h) { ossl_uint_set_init(&h->set); h->watermark = 0; } static void rx_pkt_history_destroy(struct rx_pkt_history_st *h) { ossl_uint_set_destroy(&h->set); } /* * Limit the number of ACK ranges we store to prevent resource consumption DoS * attacks. */ #define MAX_RX_ACK_RANGES 32 static void rx_pkt_history_trim_range_count(struct rx_pkt_history_st *h) { QUIC_PN highest = QUIC_PN_INVALID; while (ossl_list_uint_set_num(&h->set) > MAX_RX_ACK_RANGES) { UINT_RANGE r = ossl_list_uint_set_head(&h->set)->range; highest = (highest == QUIC_PN_INVALID) ? r.end : ossl_quic_pn_max(highest, r.end); ossl_uint_set_remove(&h->set, &r); } /* * Bump watermark to cover all PNs we removed to avoid accidental * reprocessing of packets. */ if (highest != QUIC_PN_INVALID) rx_pkt_history_bump_watermark(h, highest + 1); } static int rx_pkt_history_add_pn(struct rx_pkt_history_st *h, QUIC_PN pn) { UINT_RANGE r; r.start = pn; r.end = pn; if (pn < h->watermark) return 1; /* consider this a success case */ if (ossl_uint_set_insert(&h->set, &r) != 1) return 0; rx_pkt_history_trim_range_count(h); return 1; } static int rx_pkt_history_bump_watermark(struct rx_pkt_history_st *h, QUIC_PN watermark) { UINT_RANGE r; if (watermark <= h->watermark) return 1; /* Remove existing PNs below the watermark. */ r.start = 0; r.end = watermark - 1; if (ossl_uint_set_remove(&h->set, &r) != 1) return 0; h->watermark = watermark; return 1; } /* * ACK Manager Implementation * ************************** * Implementation of the ACK manager proper. */ /* Constants used by the ACK manager; see RFC 9002. */ #define K_GRANULARITY (1 * OSSL_TIME_MS) #define K_PKT_THRESHOLD 3 #define K_TIME_THRESHOLD_NUM 9 #define K_TIME_THRESHOLD_DEN 8 /* The maximum number of times we allow PTO to be doubled. */ #define MAX_PTO_COUNT 16 /* Default maximum amount of time to leave an ACK-eliciting packet un-ACK'd. */ #define DEFAULT_TX_MAX_ACK_DELAY ossl_ms2time(QUIC_DEFAULT_MAX_ACK_DELAY) struct ossl_ackm_st { /* Our list of transmitted packets. Corresponds to RFC 9002 sent_packets. */ struct tx_pkt_history_st tx_history[QUIC_PN_SPACE_NUM]; /* Our list of received PNs which are not yet provably acked. */ struct rx_pkt_history_st rx_history[QUIC_PN_SPACE_NUM]; /* Polymorphic dependencies that we consume. */ OSSL_TIME (*now)(void *arg); void *now_arg; OSSL_STATM *statm; const OSSL_CC_METHOD *cc_method; OSSL_CC_DATA *cc_data; /* RFC 9002 variables. */ uint32_t pto_count; QUIC_PN largest_acked_pkt[QUIC_PN_SPACE_NUM]; OSSL_TIME time_of_last_ack_eliciting_pkt[QUIC_PN_SPACE_NUM]; OSSL_TIME loss_time[QUIC_PN_SPACE_NUM]; OSSL_TIME loss_detection_deadline; /* Lowest PN which is still not known to be ACKed. */ QUIC_PN lowest_unacked_pkt[QUIC_PN_SPACE_NUM]; /* Time at which we got our first RTT sample, or 0. */ OSSL_TIME first_rtt_sample; /* * A packet's num_bytes are added to this if it is inflight, * and removed again once ack'd/lost/discarded. */ uint64_t bytes_in_flight; /* * A packet's num_bytes are added to this if it is both inflight and * ack-eliciting, and removed again once ack'd/lost/discarded. */ uint64_t ack_eliciting_bytes_in_flight[QUIC_PN_SPACE_NUM]; /* Count of ECN-CE events. */ uint64_t peer_ecnce[QUIC_PN_SPACE_NUM]; /* Set to 1 when the handshake is confirmed. */ char handshake_confirmed; /* Set to 1 when the peer has completed address validation. */ char peer_completed_addr_validation; /* Set to 1 when a PN space has been discarded. */ char discarded[QUIC_PN_SPACE_NUM]; /* Set to 1 when we think an ACK frame should be generated. */ char rx_ack_desired[QUIC_PN_SPACE_NUM]; /* Set to 1 if an ACK frame has ever been generated. */ char rx_ack_generated[QUIC_PN_SPACE_NUM]; /* Probe request counts for reporting to the user. */ OSSL_ACKM_PROBE_INFO pending_probe; /* Generated ACK frames for each PN space. */ OSSL_QUIC_FRAME_ACK ack[QUIC_PN_SPACE_NUM]; OSSL_QUIC_ACK_RANGE ack_ranges[QUIC_PN_SPACE_NUM][MAX_RX_ACK_RANGES]; /* Other RX state. */ /* Largest PN we have RX'd. */ QUIC_PN rx_largest_pn[QUIC_PN_SPACE_NUM]; /* Time at which the PN in rx_largest_pn was RX'd. */ OSSL_TIME rx_largest_time[QUIC_PN_SPACE_NUM]; /* * ECN event counters. Each time we receive a packet with a given ECN label, * the corresponding ECN counter here is incremented. */ uint64_t rx_ect0[QUIC_PN_SPACE_NUM]; uint64_t rx_ect1[QUIC_PN_SPACE_NUM]; uint64_t rx_ecnce[QUIC_PN_SPACE_NUM]; /* * Number of ACK-eliciting packets since last ACK. We use this to defer * emitting ACK frames until a threshold number of ACK-eliciting packets * have been received. */ uint32_t rx_ack_eliciting_pkts_since_last_ack[QUIC_PN_SPACE_NUM]; /* * The ACK frame coalescing deadline at which we should flush any unsent ACK * frames. */ OSSL_TIME rx_ack_flush_deadline[QUIC_PN_SPACE_NUM]; /* * The RX maximum ACK delay (the maximum amount of time our peer might * wait to send us an ACK after receiving an ACK-eliciting packet). */ OSSL_TIME rx_max_ack_delay; /* * The TX maximum ACK delay (the maximum amount of time we allow ourselves * to wait before generating an ACK after receiving an ACK-eliciting * packet). */ OSSL_TIME tx_max_ack_delay; /* Callbacks for deadline updates. */ void (*loss_detection_deadline_cb)(OSSL_TIME deadline, void *arg); void *loss_detection_deadline_cb_arg; void (*ack_deadline_cb)(OSSL_TIME deadline, int pkt_space, void *arg); void *ack_deadline_cb_arg; }; static ossl_inline uint32_t min_u32(uint32_t x, uint32_t y) { return x < y ? x : y; } /* * Get TX history for a given packet number space. Must not have been * discarded. */ static struct tx_pkt_history_st *get_tx_history(OSSL_ACKM *ackm, int pkt_space) { assert(!ackm->discarded[pkt_space]); return &ackm->tx_history[pkt_space]; } /* * Get RX history for a given packet number space. Must not have been * discarded. */ static struct rx_pkt_history_st *get_rx_history(OSSL_ACKM *ackm, int pkt_space) { assert(!ackm->discarded[pkt_space]); return &ackm->rx_history[pkt_space]; } /* Does the newly-acknowledged list contain any ack-eliciting packet? */ static int ack_includes_ack_eliciting(OSSL_ACKM_TX_PKT *pkt) { for (; pkt != NULL; pkt = pkt->anext) if (pkt->is_ack_eliciting) return 1; return 0; } /* Return number of ACK-eliciting bytes in flight across all PN spaces. */ static uint64_t ackm_ack_eliciting_bytes_in_flight(OSSL_ACKM *ackm) { int i; uint64_t total = 0; for (i = 0; i < QUIC_PN_SPACE_NUM; ++i) total += ackm->ack_eliciting_bytes_in_flight[i]; return total; } /* Return 1 if the range contains the given PN. */ static int range_contains(const OSSL_QUIC_ACK_RANGE *range, QUIC_PN pn) { return pn >= range->start && pn <= range->end; } /* * Given a logical representation of an ACK frame 'ack', create a singly-linked * list of the newly ACK'd frames; that is, of frames which are matched by the * list of PN ranges contained in the ACK frame. The packet structures in the * list returned are removed from the TX history list. Returns a pointer to the * list head (or NULL) if empty. */ static OSSL_ACKM_TX_PKT *ackm_detect_and_remove_newly_acked_pkts(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack, int pkt_space) { OSSL_ACKM_TX_PKT *acked_pkts = NULL, **fixup = &acked_pkts, *pkt, *pprev; struct tx_pkt_history_st *h; size_t ridx = 0; assert(ack->num_ack_ranges > 0); /* * Our history list is a list of packets sorted in ascending order * by packet number. * * ack->ack_ranges is a list of packet number ranges in descending order. * * Walk through our history list from the end in order to efficiently detect * membership in the specified ack ranges. As an optimization, we use our * hashtable to try and skip to the first matching packet. This may fail if * the ACK ranges given include nonexistent packets. */ h = get_tx_history(ackm, pkt_space); pkt = tx_pkt_history_by_pkt_num(h, ack->ack_ranges[0].end); if (pkt == NULL) pkt = ossl_list_tx_history_tail(&h->packets); for (; pkt != NULL; pkt = pprev) { /* * Save prev value as it will be zeroed if we remove the packet from the * history list below. */ pprev = ossl_list_tx_history_prev(pkt); for (;; ++ridx) { if (ridx >= ack->num_ack_ranges) { /* * We have exhausted all ranges so stop here, even if there are * more packets to look at. */ goto stop; } if (range_contains(&ack->ack_ranges[ridx], pkt->pkt_num)) { /* We have matched this range. */ tx_pkt_history_remove(h, pkt->pkt_num); *fixup = pkt; fixup = &pkt->anext; *fixup = NULL; break; } else if (pkt->pkt_num > ack->ack_ranges[ridx].end) { /* * We have not reached this range yet in our list, so do not * advance ridx. */ break; } else { /* * We have moved beyond this range, so advance to the next range * and try matching again. */ assert(pkt->pkt_num < ack->ack_ranges[ridx].start); continue; } } } stop: return acked_pkts; } /* * Create a singly-linked list of newly detected-lost packets in the given * packet number space. Returns the head of the list or NULL if no packets were * detected lost. The packets in the list are removed from the TX history list. */ static OSSL_ACKM_TX_PKT *ackm_detect_and_remove_lost_pkts(OSSL_ACKM *ackm, int pkt_space) { OSSL_ACKM_TX_PKT *lost_pkts = NULL, **fixup = &lost_pkts, *pkt, *pnext; OSSL_TIME loss_delay, lost_send_time, now; OSSL_RTT_INFO rtt; struct tx_pkt_history_st *h; assert(ackm->largest_acked_pkt[pkt_space] != QUIC_PN_INVALID); ossl_statm_get_rtt_info(ackm->statm, &rtt); ackm->loss_time[pkt_space] = ossl_time_zero(); loss_delay = ossl_time_multiply(ossl_time_max(rtt.latest_rtt, rtt.smoothed_rtt), K_TIME_THRESHOLD_NUM); loss_delay = ossl_time_divide(loss_delay, K_TIME_THRESHOLD_DEN); /* Minimum time of K_GRANULARITY before packets are deemed lost. */ loss_delay = ossl_time_max(loss_delay, ossl_ticks2time(K_GRANULARITY)); /* Packets sent before this time are deemed lost. */ now = ackm->now(ackm->now_arg); lost_send_time = ossl_time_subtract(now, loss_delay); h = get_tx_history(ackm, pkt_space); pkt = ossl_list_tx_history_head(&h->packets); for (; pkt != NULL; pkt = pnext) { assert(pkt_space == pkt->pkt_space); /* * Save prev value as it will be zeroed if we remove the packet from the * history list below. */ pnext = ossl_list_tx_history_next(pkt); if (pkt->pkt_num > ackm->largest_acked_pkt[pkt_space]) continue; /* * Mark packet as lost, or set time when it should be marked. */ if (ossl_time_compare(pkt->time, lost_send_time) <= 0 || ackm->largest_acked_pkt[pkt_space] >= pkt->pkt_num + K_PKT_THRESHOLD) { tx_pkt_history_remove(h, pkt->pkt_num); *fixup = pkt; fixup = &pkt->lnext; *fixup = NULL; } else { if (ossl_time_is_zero(ackm->loss_time[pkt_space])) ackm->loss_time[pkt_space] = ossl_time_add(pkt->time, loss_delay); else ackm->loss_time[pkt_space] = ossl_time_min(ackm->loss_time[pkt_space], ossl_time_add(pkt->time, loss_delay)); } } return lost_pkts; } static OSSL_TIME ackm_get_loss_time_and_space(OSSL_ACKM *ackm, int *pspace) { OSSL_TIME time = ackm->loss_time[QUIC_PN_SPACE_INITIAL]; int i, space = QUIC_PN_SPACE_INITIAL; for (i = space + 1; i < QUIC_PN_SPACE_NUM; ++i) if (ossl_time_is_zero(time) || ossl_time_compare(ackm->loss_time[i], time) == -1) { time = ackm->loss_time[i]; space = i; } *pspace = space; return time; } static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM *ackm, int *space) { OSSL_RTT_INFO rtt; OSSL_TIME duration; OSSL_TIME pto_timeout = ossl_time_infinite(), t; int pto_space = QUIC_PN_SPACE_INITIAL, i; ossl_statm_get_rtt_info(ackm->statm, &rtt); duration = ossl_time_add(rtt.smoothed_rtt, ossl_time_max(ossl_time_multiply(rtt.rtt_variance, 4), ossl_ticks2time(K_GRANULARITY))); duration = ossl_time_multiply(duration, (uint64_t)1 << min_u32(ackm->pto_count, MAX_PTO_COUNT)); /* Anti-deadlock PTO starts from the current time. */ if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0) { assert(!ackm->peer_completed_addr_validation); *space = ackm->discarded[QUIC_PN_SPACE_INITIAL] ? QUIC_PN_SPACE_HANDSHAKE : QUIC_PN_SPACE_INITIAL; return ossl_time_add(ackm->now(ackm->now_arg), duration); } for (i = QUIC_PN_SPACE_INITIAL; i < QUIC_PN_SPACE_NUM; ++i) { if (ackm->ack_eliciting_bytes_in_flight[i] == 0) continue; if (i == QUIC_PN_SPACE_APP) { /* Skip application data until handshake confirmed. */ if (!ackm->handshake_confirmed) break; /* Include max_ack_delay and backoff for app data. */ if (!ossl_time_is_infinite(ackm->rx_max_ack_delay)) { uint64_t factor = (uint64_t)1 << min_u32(ackm->pto_count, MAX_PTO_COUNT); duration = ossl_time_add(duration, ossl_time_multiply(ackm->rx_max_ack_delay, factor)); } } t = ossl_time_add(ackm->time_of_last_ack_eliciting_pkt[i], duration); if (ossl_time_compare(t, pto_timeout) < 0) { pto_timeout = t; pto_space = i; } } *space = pto_space; return pto_timeout; } static void ackm_set_loss_detection_timer_actual(OSSL_ACKM *ackm, OSSL_TIME deadline) { ackm->loss_detection_deadline = deadline; if (ackm->loss_detection_deadline_cb != NULL) ackm->loss_detection_deadline_cb(deadline, ackm->loss_detection_deadline_cb_arg); } static int ackm_set_loss_detection_timer(OSSL_ACKM *ackm) { int space; OSSL_TIME earliest_loss_time, timeout; earliest_loss_time = ackm_get_loss_time_and_space(ackm, &space); if (!ossl_time_is_zero(earliest_loss_time)) { /* Time threshold loss detection. */ ackm_set_loss_detection_timer_actual(ackm, earliest_loss_time); return 1; } if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0 && ackm->peer_completed_addr_validation) { /* * Nothing to detect lost, so no timer is set. However, the client * needs to arm the timer if the server might be blocked by the * anti-amplification limit. */ ackm_set_loss_detection_timer_actual(ackm, ossl_time_zero()); return 1; } timeout = ackm_get_pto_time_and_space(ackm, &space); ackm_set_loss_detection_timer_actual(ackm, timeout); return 1; } static int ackm_in_persistent_congestion(OSSL_ACKM *ackm, const OSSL_ACKM_TX_PKT *lpkt) { /* TODO(QUIC FUTURE): Persistent congestion not currently implemented. */ return 0; } static void ackm_on_pkts_lost(OSSL_ACKM *ackm, int pkt_space, const OSSL_ACKM_TX_PKT *lpkt, int pseudo) { const OSSL_ACKM_TX_PKT *p, *pnext; OSSL_RTT_INFO rtt; QUIC_PN largest_pn_lost = 0; OSSL_CC_LOSS_INFO loss_info = {0}; uint32_t flags = 0; for (p = lpkt; p != NULL; p = pnext) { pnext = p->lnext; if (p->is_inflight) { ackm->bytes_in_flight -= p->num_bytes; if (p->is_ack_eliciting) ackm->ack_eliciting_bytes_in_flight[p->pkt_space] -= p->num_bytes; if (p->pkt_num > largest_pn_lost) largest_pn_lost = p->pkt_num; if (!pseudo) { /* * If this is pseudo-loss (e.g. during connection retry) we do not * inform the CC as it is not a real loss and not reflective of * network conditions. */ loss_info.tx_time = p->time; loss_info.tx_size = p->num_bytes; ackm->cc_method->on_data_lost(ackm->cc_data, &loss_info); } } p->on_lost(p->cb_arg); } /* * Persistent congestion can only be considered if we have gotten at least * one RTT sample. */ ossl_statm_get_rtt_info(ackm->statm, &rtt); if (!ossl_time_is_zero(ackm->first_rtt_sample) && ackm_in_persistent_congestion(ackm, lpkt)) flags |= OSSL_CC_LOST_FLAG_PERSISTENT_CONGESTION; ackm->cc_method->on_data_lost_finished(ackm->cc_data, flags); } static void ackm_on_pkts_acked(OSSL_ACKM *ackm, const OSSL_ACKM_TX_PKT *apkt) { const OSSL_ACKM_TX_PKT *anext; QUIC_PN last_pn_acked = 0; OSSL_CC_ACK_INFO ainfo = {0}; for (; apkt != NULL; apkt = anext) { if (apkt->is_inflight) { ackm->bytes_in_flight -= apkt->num_bytes; if (apkt->is_ack_eliciting) ackm->ack_eliciting_bytes_in_flight[apkt->pkt_space] -= apkt->num_bytes; if (apkt->pkt_num > last_pn_acked) last_pn_acked = apkt->pkt_num; if (apkt->largest_acked != QUIC_PN_INVALID) /* * This can fail, but it is monotonic; worst case we try again * next time. */ rx_pkt_history_bump_watermark(get_rx_history(ackm, apkt->pkt_space), apkt->largest_acked + 1); } ainfo.tx_time = apkt->time; ainfo.tx_size = apkt->num_bytes; anext = apkt->anext; apkt->on_acked(apkt->cb_arg); /* may free apkt */ if (apkt->is_inflight) ackm->cc_method->on_data_acked(ackm->cc_data, &ainfo); } } OSSL_ACKM *ossl_ackm_new(OSSL_TIME (*now)(void *arg), void *now_arg, OSSL_STATM *statm, const OSSL_CC_METHOD *cc_method, OSSL_CC_DATA *cc_data) { OSSL_ACKM *ackm; int i; ackm = OPENSSL_zalloc(sizeof(OSSL_ACKM)); if (ackm == NULL) return NULL; for (i = 0; i < (int)OSSL_NELEM(ackm->tx_history); ++i) { ackm->largest_acked_pkt[i] = QUIC_PN_INVALID; ackm->rx_ack_flush_deadline[i] = ossl_time_infinite(); if (tx_pkt_history_init(&ackm->tx_history[i]) < 1) goto err; } for (i = 0; i < (int)OSSL_NELEM(ackm->rx_history); ++i) rx_pkt_history_init(&ackm->rx_history[i]); ackm->now = now; ackm->now_arg = now_arg; ackm->statm = statm; ackm->cc_method = cc_method; ackm->cc_data = cc_data; ackm->rx_max_ack_delay = ossl_ms2time(QUIC_DEFAULT_MAX_ACK_DELAY); ackm->tx_max_ack_delay = DEFAULT_TX_MAX_ACK_DELAY; return ackm; err: while (--i >= 0) tx_pkt_history_destroy(&ackm->tx_history[i]); OPENSSL_free(ackm); return NULL; } void ossl_ackm_free(OSSL_ACKM *ackm) { size_t i; if (ackm == NULL) return; for (i = 0; i < OSSL_NELEM(ackm->tx_history); ++i) if (!ackm->discarded[i]) { tx_pkt_history_destroy(&ackm->tx_history[i]); rx_pkt_history_destroy(&ackm->rx_history[i]); } OPENSSL_free(ackm); } int ossl_ackm_on_tx_packet(OSSL_ACKM *ackm, OSSL_ACKM_TX_PKT *pkt) { struct tx_pkt_history_st *h = get_tx_history(ackm, pkt->pkt_space); /* Time must be set and not move backwards. */ if (ossl_time_is_zero(pkt->time) || ossl_time_compare(ackm->time_of_last_ack_eliciting_pkt[pkt->pkt_space], pkt->time) > 0) return 0; /* Must have non-zero number of bytes. */ if (pkt->num_bytes == 0) return 0; /* Does not make any sense for a non-in-flight packet to be ACK-eliciting. */ if (!pkt->is_inflight && pkt->is_ack_eliciting) return 0; if (tx_pkt_history_add(h, pkt) == 0) return 0; if (pkt->is_inflight) { if (pkt->is_ack_eliciting) { ackm->time_of_last_ack_eliciting_pkt[pkt->pkt_space] = pkt->time; ackm->ack_eliciting_bytes_in_flight[pkt->pkt_space] += pkt->num_bytes; } ackm->bytes_in_flight += pkt->num_bytes; ackm_set_loss_detection_timer(ackm); ackm->cc_method->on_data_sent(ackm->cc_data, pkt->num_bytes); } return 1; } int ossl_ackm_on_rx_datagram(OSSL_ACKM *ackm, size_t num_bytes) { /* No-op on the client. */ return 1; } static void ackm_process_ecn(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack, int pkt_space) { struct tx_pkt_history_st *h; OSSL_ACKM_TX_PKT *pkt; OSSL_CC_ECN_INFO ecn_info = {0}; /* * If the ECN-CE counter reported by the peer has increased, this could * be a new congestion event. */ if (ack->ecnce > ackm->peer_ecnce[pkt_space]) { ackm->peer_ecnce[pkt_space] = ack->ecnce; h = get_tx_history(ackm, pkt_space); pkt = tx_pkt_history_by_pkt_num(h, ack->ack_ranges[0].end); if (pkt == NULL) return; ecn_info.largest_acked_time = pkt->time; ackm->cc_method->on_ecn(ackm->cc_data, &ecn_info); } } int ossl_ackm_on_rx_ack_frame(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack, int pkt_space, OSSL_TIME rx_time) { OSSL_ACKM_TX_PKT *na_pkts, *lost_pkts; int must_set_timer = 0; if (ackm->largest_acked_pkt[pkt_space] == QUIC_PN_INVALID) ackm->largest_acked_pkt[pkt_space] = ack->ack_ranges[0].end; else ackm->largest_acked_pkt[pkt_space] = ossl_quic_pn_max(ackm->largest_acked_pkt[pkt_space], ack->ack_ranges[0].end); /* * If we get an ACK in the handshake space, address validation is completed. * Make sure we update the timer, even if no packets were ACK'd. */ if (!ackm->peer_completed_addr_validation && pkt_space == QUIC_PN_SPACE_HANDSHAKE) { ackm->peer_completed_addr_validation = 1; must_set_timer = 1; } /* * Find packets that are newly acknowledged and remove them from the list. */ na_pkts = ackm_detect_and_remove_newly_acked_pkts(ackm, ack, pkt_space); if (na_pkts == NULL) { if (must_set_timer) ackm_set_loss_detection_timer(ackm); return 1; } /* * Update the RTT if the largest acknowledged is newly acked and at least * one ACK-eliciting packet was newly acked. * * First packet in the list is always the one with the largest PN. */ if (na_pkts->pkt_num == ack->ack_ranges[0].end && ack_includes_ack_eliciting(na_pkts)) { OSSL_TIME now = ackm->now(ackm->now_arg), ack_delay; if (ossl_time_is_zero(ackm->first_rtt_sample)) ackm->first_rtt_sample = now; /* Enforce maximum ACK delay. */ ack_delay = ack->delay_time; if (ackm->handshake_confirmed) ack_delay = ossl_time_min(ack_delay, ackm->rx_max_ack_delay); ossl_statm_update_rtt(ackm->statm, ack_delay, ossl_time_subtract(now, na_pkts->time)); } /* * Process ECN information if present. * * We deliberately do most ECN processing in the ACKM rather than the * congestion controller to avoid having to give the congestion controller * access to ACKM internal state. */ if (ack->ecn_present) ackm_process_ecn(ackm, ack, pkt_space); /* Handle inferred loss. */ lost_pkts = ackm_detect_and_remove_lost_pkts(ackm, pkt_space); if (lost_pkts != NULL) ackm_on_pkts_lost(ackm, pkt_space, lost_pkts, /*pseudo=*/0); ackm_on_pkts_acked(ackm, na_pkts); /* * Reset pto_count unless the client is unsure if the server validated the * client's address. */ if (ackm->peer_completed_addr_validation) ackm->pto_count = 0; ackm_set_loss_detection_timer(ackm); return 1; } int ossl_ackm_on_pkt_space_discarded(OSSL_ACKM *ackm, int pkt_space) { OSSL_ACKM_TX_PKT *pkt, *pnext; uint64_t num_bytes_invalidated = 0; if (ackm->discarded[pkt_space]) return 0; if (pkt_space == QUIC_PN_SPACE_HANDSHAKE) ackm->peer_completed_addr_validation = 1; for (pkt = ossl_list_tx_history_head(&get_tx_history(ackm, pkt_space)->packets); pkt != NULL; pkt = pnext) { pnext = ossl_list_tx_history_next(pkt); if (pkt->is_inflight) { ackm->bytes_in_flight -= pkt->num_bytes; num_bytes_invalidated += pkt->num_bytes; } pkt->on_discarded(pkt->cb_arg); /* may free pkt */ } tx_pkt_history_destroy(&ackm->tx_history[pkt_space]); rx_pkt_history_destroy(&ackm->rx_history[pkt_space]); if (num_bytes_invalidated > 0) ackm->cc_method->on_data_invalidated(ackm->cc_data, num_bytes_invalidated); ackm->time_of_last_ack_eliciting_pkt[pkt_space] = ossl_time_zero(); ackm->loss_time[pkt_space] = ossl_time_zero(); ackm->pto_count = 0; ackm->discarded[pkt_space] = 1; ackm->ack_eliciting_bytes_in_flight[pkt_space] = 0; ackm_set_loss_detection_timer(ackm); return 1; } int ossl_ackm_on_handshake_confirmed(OSSL_ACKM *ackm) { ackm->handshake_confirmed = 1; ackm->peer_completed_addr_validation = 1; ackm_set_loss_detection_timer(ackm); return 1; } static void ackm_queue_probe_anti_deadlock_handshake(OSSL_ACKM *ackm) { ++ackm->pending_probe.anti_deadlock_handshake; } static void ackm_queue_probe_anti_deadlock_initial(OSSL_ACKM *ackm) { ++ackm->pending_probe.anti_deadlock_initial; } static void ackm_queue_probe(OSSL_ACKM *ackm, int pkt_space) { /* * TODO(QUIC FUTURE): We are allowed to send either one or two probe * packets here. * Determine a strategy for when we should send two probe packets. */ ++ackm->pending_probe.pto[pkt_space]; } int ossl_ackm_on_timeout(OSSL_ACKM *ackm) { int pkt_space; OSSL_TIME earliest_loss_time; OSSL_ACKM_TX_PKT *lost_pkts; earliest_loss_time = ackm_get_loss_time_and_space(ackm, &pkt_space); if (!ossl_time_is_zero(earliest_loss_time)) { /* Time threshold loss detection. */ lost_pkts = ackm_detect_and_remove_lost_pkts(ackm, pkt_space); if (lost_pkts != NULL) ackm_on_pkts_lost(ackm, pkt_space, lost_pkts, /*pseudo=*/0); ackm_set_loss_detection_timer(ackm); return 1; } if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0) { assert(!ackm->peer_completed_addr_validation); /* * Client sends an anti-deadlock packet: Initial is padded to earn more * anti-amplification credit. A handshake packet proves address * ownership. */ if (ackm->discarded[QUIC_PN_SPACE_INITIAL]) ackm_queue_probe_anti_deadlock_handshake(ackm); else ackm_queue_probe_anti_deadlock_initial(ackm); } else { /* * PTO. The user of the ACKM should send new data if available, else * retransmit old data, or if neither is available, send a single PING * frame. */ ackm_get_pto_time_and_space(ackm, &pkt_space); ackm_queue_probe(ackm, pkt_space); } ++ackm->pto_count; ackm_set_loss_detection_timer(ackm); return 1; } OSSL_TIME ossl_ackm_get_loss_detection_deadline(OSSL_ACKM *ackm) { return ackm->loss_detection_deadline; } OSSL_ACKM_PROBE_INFO *ossl_ackm_get0_probe_request(OSSL_ACKM *ackm) { return &ackm->pending_probe; } int ossl_ackm_get_largest_unacked(OSSL_ACKM *ackm, int pkt_space, QUIC_PN *pn) { struct tx_pkt_history_st *h; OSSL_ACKM_TX_PKT *p; h = get_tx_history(ackm, pkt_space); p = ossl_list_tx_history_tail(&h->packets); if (p != NULL) { *pn = p->pkt_num; return 1; } return 0; } /* Number of ACK-eliciting packets RX'd before we always emit an ACK. */ #define PKTS_BEFORE_ACK 2 /* * Return 1 if emission of an ACK frame is currently desired. * * This occurs when one or more of the following conditions occurs: * * - We have flagged that we want to send an ACK frame * (for example, due to the packet threshold count being exceeded), or * * - We have exceeded the ACK flush deadline, meaning that * we have received at least one ACK-eliciting packet, but held off on * sending an ACK frame immediately in the hope that more ACK-eliciting * packets might come in, but not enough did and we are now requesting * transmission of an ACK frame anyway. * */ int ossl_ackm_is_ack_desired(OSSL_ACKM *ackm, int pkt_space) { return ackm->rx_ack_desired[pkt_space] || (!ossl_time_is_infinite(ackm->rx_ack_flush_deadline[pkt_space]) && ossl_time_compare(ackm->now(ackm->now_arg), ackm->rx_ack_flush_deadline[pkt_space]) >= 0); } /* * Returns 1 if an ACK frame matches a given packet number. */ static int ack_contains(const OSSL_QUIC_FRAME_ACK *ack, QUIC_PN pkt_num) { size_t i; for (i = 0; i < ack->num_ack_ranges; ++i) if (range_contains(&ack->ack_ranges[i], pkt_num)) return 1; return 0; } /* * Returns 1 iff a PN (which we have just received) was previously reported as * implied missing (by us, in an ACK frame we previously generated). */ static int ackm_is_missing(OSSL_ACKM *ackm, int pkt_space, QUIC_PN pkt_num) { /* * A PN is implied missing if it is not greater than the highest PN in our * generated ACK frame, but is not matched by the frame. */ return ackm->ack[pkt_space].num_ack_ranges > 0 && pkt_num <= ackm->ack[pkt_space].ack_ranges[0].end && !ack_contains(&ackm->ack[pkt_space], pkt_num); } /* * Returns 1 iff our RX of a PN newly establishes the implication of missing * packets. */ static int ackm_has_newly_missing(OSSL_ACKM *ackm, int pkt_space) { struct rx_pkt_history_st *h; h = get_rx_history(ackm, pkt_space); if (ossl_list_uint_set_is_empty(&h->set)) return 0; /* * The second condition here establishes that the highest PN range in our RX * history comprises only a single PN. If there is more than one, then this * function will have returned 1 during a previous call to * ossl_ackm_on_rx_packet assuming the third condition below was met. Thus * we only return 1 when the missing PN condition is newly established. * * The third condition here establishes that the highest PN range in our RX * history is beyond (and does not border) the highest PN we have yet * reported in any ACK frame. Thus there is a gap of at least one PN between * the PNs we have ACK'd previously and the PN we have just received. */ return ackm->ack[pkt_space].num_ack_ranges > 0 && ossl_list_uint_set_tail(&h->set)->range.start == ossl_list_uint_set_tail(&h->set)->range.end && ossl_list_uint_set_tail(&h->set)->range.start > ackm->ack[pkt_space].ack_ranges[0].end + 1; } static void ackm_set_flush_deadline(OSSL_ACKM *ackm, int pkt_space, OSSL_TIME deadline) { ackm->rx_ack_flush_deadline[pkt_space] = deadline; if (ackm->ack_deadline_cb != NULL) ackm->ack_deadline_cb(ossl_ackm_get_ack_deadline(ackm, pkt_space), pkt_space, ackm->ack_deadline_cb_arg); } /* Explicitly flags that we want to generate an ACK frame. */ static void ackm_queue_ack(OSSL_ACKM *ackm, int pkt_space) { ackm->rx_ack_desired[pkt_space] = 1; /* Cancel deadline. */ ackm_set_flush_deadline(ackm, pkt_space, ossl_time_infinite()); } static void ackm_on_rx_ack_eliciting(OSSL_ACKM *ackm, OSSL_TIME rx_time, int pkt_space, int was_missing) { OSSL_TIME tx_max_ack_delay; if (ackm->rx_ack_desired[pkt_space]) /* ACK generation already requested so nothing to do. */ return; ++ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space]; if (!ackm->rx_ack_generated[pkt_space] || was_missing || ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space] >= PKTS_BEFORE_ACK || ackm_has_newly_missing(ackm, pkt_space)) { /* * Either: * * - We have never yet generated an ACK frame, meaning that this * is the first ever packet received, which we should always * acknowledge immediately, or * * - We previously reported the PN that we have just received as * missing in a previous ACK frame (meaning that we should report * the fact that we now have it to the peer immediately), or * * - We have exceeded the ACK-eliciting packet threshold count * for the purposes of ACK coalescing, so request transmission * of an ACK frame, or * * - The PN we just received and added to our PN RX history * newly implies one or more missing PNs, in which case we should * inform the peer by sending an ACK frame immediately. * * We do not test the ACK flush deadline here because it is tested * separately in ossl_ackm_is_ack_desired. */ ackm_queue_ack(ackm, pkt_space); return; } /* * Not emitting an ACK yet. * * Update the ACK flush deadline. * * RFC 9000 s. 13.2.1: "An endpoint MUST acknowledge all ack-eliciting * Initial and Handshake packets immediately"; don't delay ACK generation if * we are using the Initial or Handshake PN spaces. */ tx_max_ack_delay = ackm->tx_max_ack_delay; if (pkt_space == QUIC_PN_SPACE_INITIAL || pkt_space == QUIC_PN_SPACE_HANDSHAKE) tx_max_ack_delay = ossl_time_zero(); if (ossl_time_is_infinite(ackm->rx_ack_flush_deadline[pkt_space])) ackm_set_flush_deadline(ackm, pkt_space, ossl_time_add(rx_time, tx_max_ack_delay)); else ackm_set_flush_deadline(ackm, pkt_space, ossl_time_min(ackm->rx_ack_flush_deadline[pkt_space], ossl_time_add(rx_time, tx_max_ack_delay))); } int ossl_ackm_on_rx_packet(OSSL_ACKM *ackm, const OSSL_ACKM_RX_PKT *pkt) { struct rx_pkt_history_st *h = get_rx_history(ackm, pkt->pkt_space); int was_missing; if (ossl_ackm_is_rx_pn_processable(ackm, pkt->pkt_num, pkt->pkt_space) != 1) /* PN has already been processed or written off, no-op. */ return 1; /* * Record the largest PN we have RX'd and the time we received it. * We use this to calculate the ACK delay field of ACK frames. */ if (pkt->pkt_num > ackm->rx_largest_pn[pkt->pkt_space]) { ackm->rx_largest_pn[pkt->pkt_space] = pkt->pkt_num; ackm->rx_largest_time[pkt->pkt_space] = pkt->time; } /* * If the PN we just received was previously implied missing by virtue of * being omitted from a previous ACK frame generated, we skip any packet * count thresholds or coalescing delays and emit a new ACK frame * immediately. */ was_missing = ackm_is_missing(ackm, pkt->pkt_space, pkt->pkt_num); /* * Add the packet number to our history list of PNs we have not yet provably * acked. */ if (rx_pkt_history_add_pn(h, pkt->pkt_num) != 1) return 0; /* * Receiving this packet may or may not cause us to emit an ACK frame. * We may not emit an ACK frame yet if we have not yet received a threshold * number of packets. */ if (pkt->is_ack_eliciting) ackm_on_rx_ack_eliciting(ackm, pkt->time, pkt->pkt_space, was_missing); /* Update the ECN counters according to which ECN signal we got, if any. */ switch (pkt->ecn) { case OSSL_ACKM_ECN_ECT0: ++ackm->rx_ect0[pkt->pkt_space]; break; case OSSL_ACKM_ECN_ECT1: ++ackm->rx_ect1[pkt->pkt_space]; break; case OSSL_ACKM_ECN_ECNCE: ++ackm->rx_ecnce[pkt->pkt_space]; break; default: break; } return 1; } static void ackm_fill_rx_ack_ranges(OSSL_ACKM *ackm, int pkt_space, OSSL_QUIC_FRAME_ACK *ack) { struct rx_pkt_history_st *h = get_rx_history(ackm, pkt_space); UINT_SET_ITEM *x; size_t i = 0; /* * Copy out ranges from the PN set, starting at the end, until we reach our * maximum number of ranges. */ for (x = ossl_list_uint_set_tail(&h->set); x != NULL && i < OSSL_NELEM(ackm->ack_ranges); x = ossl_list_uint_set_prev(x), ++i) { ackm->ack_ranges[pkt_space][i].start = x->range.start; ackm->ack_ranges[pkt_space][i].end = x->range.end; } ack->ack_ranges = ackm->ack_ranges[pkt_space]; ack->num_ack_ranges = i; } const OSSL_QUIC_FRAME_ACK *ossl_ackm_get_ack_frame(OSSL_ACKM *ackm, int pkt_space) { OSSL_QUIC_FRAME_ACK *ack = &ackm->ack[pkt_space]; OSSL_TIME now = ackm->now(ackm->now_arg); ackm_fill_rx_ack_ranges(ackm, pkt_space, ack); if (!ossl_time_is_zero(ackm->rx_largest_time[pkt_space]) && ossl_time_compare(now, ackm->rx_largest_time[pkt_space]) > 0 && pkt_space == QUIC_PN_SPACE_APP) ack->delay_time = ossl_time_subtract(now, ackm->rx_largest_time[pkt_space]); else ack->delay_time = ossl_time_zero(); ack->ect0 = ackm->rx_ect0[pkt_space]; ack->ect1 = ackm->rx_ect1[pkt_space]; ack->ecnce = ackm->rx_ecnce[pkt_space]; ack->ecn_present = 1; ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space] = 0; ackm->rx_ack_generated[pkt_space] = 1; ackm->rx_ack_desired[pkt_space] = 0; ackm_set_flush_deadline(ackm, pkt_space, ossl_time_infinite()); return ack; } OSSL_TIME ossl_ackm_get_ack_deadline(OSSL_ACKM *ackm, int pkt_space) { if (ackm->rx_ack_desired[pkt_space]) /* Already desired, deadline is now. */ return ossl_time_zero(); return ackm->rx_ack_flush_deadline[pkt_space]; } int ossl_ackm_is_rx_pn_processable(OSSL_ACKM *ackm, QUIC_PN pn, int pkt_space) { struct rx_pkt_history_st *h = get_rx_history(ackm, pkt_space); return pn >= h->watermark && ossl_uint_set_query(&h->set, pn) == 0; } void ossl_ackm_set_loss_detection_deadline_callback(OSSL_ACKM *ackm, void (*fn)(OSSL_TIME deadline, void *arg), void *arg) { ackm->loss_detection_deadline_cb = fn; ackm->loss_detection_deadline_cb_arg = arg; } void ossl_ackm_set_ack_deadline_callback(OSSL_ACKM *ackm, void (*fn)(OSSL_TIME deadline, int pkt_space, void *arg), void *arg) { ackm->ack_deadline_cb = fn; ackm->ack_deadline_cb_arg = arg; } int ossl_ackm_mark_packet_pseudo_lost(OSSL_ACKM *ackm, int pkt_space, QUIC_PN pn) { struct tx_pkt_history_st *h = get_tx_history(ackm, pkt_space); OSSL_ACKM_TX_PKT *pkt; pkt = tx_pkt_history_by_pkt_num(h, pn); if (pkt == NULL) return 0; tx_pkt_history_remove(h, pkt->pkt_num); pkt->lnext = NULL; ackm_on_pkts_lost(ackm, pkt_space, pkt, /*pseudo=*/1); return 1; } OSSL_TIME ossl_ackm_get_pto_duration(OSSL_ACKM *ackm) { OSSL_TIME duration; OSSL_RTT_INFO rtt; ossl_statm_get_rtt_info(ackm->statm, &rtt); duration = ossl_time_add(rtt.smoothed_rtt, ossl_time_max(ossl_time_multiply(rtt.rtt_variance, 4), ossl_ticks2time(K_GRANULARITY))); if (!ossl_time_is_infinite(ackm->rx_max_ack_delay)) duration = ossl_time_add(duration, ackm->rx_max_ack_delay); return duration; } QUIC_PN ossl_ackm_get_largest_acked(OSSL_ACKM *ackm, int pkt_space) { return ackm->largest_acked_pkt[pkt_space]; } void ossl_ackm_set_rx_max_ack_delay(OSSL_ACKM *ackm, OSSL_TIME rx_max_ack_delay) { ackm->rx_max_ack_delay = rx_max_ack_delay; } void ossl_ackm_set_tx_max_ack_delay(OSSL_ACKM *ackm, OSSL_TIME tx_max_ack_delay) { ackm->tx_max_ack_delay = tx_max_ack_delay; }

./openssl/ssl/quic/quic_srt_gen.c

/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_srt_gen.h" #include <openssl/core_names.h> #include <openssl/evp.h> struct quic_srt_gen_st { EVP_MAC *mac; EVP_MAC_CTX *mac_ctx; }; /* * Simple HMAC-SHA256-based stateless reset token generator. */ QUIC_SRT_GEN *ossl_quic_srt_gen_new(OSSL_LIB_CTX *libctx, const char *propq, const unsigned char *key, size_t key_len) { QUIC_SRT_GEN *srt_gen; OSSL_PARAM params[3], *p = params; if ((srt_gen = OPENSSL_zalloc(sizeof(*srt_gen))) == NULL) return NULL; if ((srt_gen->mac = EVP_MAC_fetch(libctx, "HMAC", propq)) == NULL) goto err; if ((srt_gen->mac_ctx = EVP_MAC_CTX_new(srt_gen->mac)) == NULL) goto err; *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, "SHA256", 7); if (propq != NULL) *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_PROPERTIES, (char *)propq, 0); *p++ = OSSL_PARAM_construct_end(); if (!EVP_MAC_init(srt_gen->mac_ctx, key, key_len, params)) goto err; return srt_gen; err: ossl_quic_srt_gen_free(srt_gen); return NULL; } void ossl_quic_srt_gen_free(QUIC_SRT_GEN *srt_gen) { if (srt_gen == NULL) return; EVP_MAC_CTX_free(srt_gen->mac_ctx); EVP_MAC_free(srt_gen->mac); OPENSSL_free(srt_gen); } int ossl_quic_srt_gen_calculate_token(QUIC_SRT_GEN *srt_gen, const QUIC_CONN_ID *dcid, QUIC_STATELESS_RESET_TOKEN *token) { size_t outl = 0; unsigned char mac[SHA256_DIGEST_LENGTH]; if (!EVP_MAC_init(srt_gen->mac_ctx, NULL, 0, NULL)) return 0; if (!EVP_MAC_update(srt_gen->mac_ctx, (const unsigned char *)dcid->id, dcid->id_len)) return 0; if (!EVP_MAC_final(srt_gen->mac_ctx, mac, &outl, sizeof(mac)) || outl != sizeof(mac)) return 0; assert(sizeof(mac) >= sizeof(token->token)); memcpy(token->token, mac, sizeof(token->token)); return 1; }

./openssl/ssl/quic/quic_rcidm.c

/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_rcidm.h" #include "internal/priority_queue.h" #include "internal/list.h" #include "internal/common.h" /* * QUIC Remote Connection ID Manager * ================================= * * We can receive an arbitrary number of RCIDs via NCID frames. Periodically, we * may desire (for example for anti-connection fingerprinting reasons, etc.) * to switch to a new RCID according to some arbitrary policy such as the number * of packets we have sent. * * When we do this we should move to the next RCID in the sequence of received * RCIDs ordered by sequence number. For example, if a peer sends us three NCID * frames with sequence numbers 10, 11, 12, we should seek to consume these * RCIDs in order. * * However, due to the possibility of packet reordering in the network, NCID * frames might be received out of order. Thus if a peer sends us NCID frames * with sequence numbers 12, 10, 11, we should still consume the RCID with * sequence number 10 before consuming the RCIDs with sequence numbers 11 or 12. * * We use a priority queue for this purpose. */ static void rcidm_update(QUIC_RCIDM *rcidm); static void rcidm_set_preferred_rcid(QUIC_RCIDM *rcidm, const QUIC_CONN_ID *rcid); #define PACKETS_PER_RCID 10000 #define INITIAL_SEQ_NUM 0 #define PREF_ADDR_SEQ_NUM 1 /* * RCID * ==== * * The RCID structure is used to track RCIDs which have sequence numbers (i.e., * INITIAL, PREF_ADDR and NCID type RCIDs). The RCIDs without sequence numbers * (Initial ODCIDs and Retry ODCIDs), hereafter referred to as unnumbered RCIDs, * can logically be viewed as their own type of RCID but are tracked separately * as singletons without needing a discrete structure. * * At any given time an RCID object is in one of these states: * * * (start) * | * [add] * | * _____v_____ ___________ ____________ * | | | | | | * | PENDING | --[select]--> | CURRENT | --[retire]--> | RETIRING | * |___________| |___________| |____________| * | * [pop] * | * v * (fin) * * The transition through the states is monotonic and irreversible. * The RCID object is freed when it is popped. * * PENDING * Invariants: * rcid->state == RCID_STATE_PENDING; * rcid->pq_idx != SIZE_MAX (debug assert only); * the RCID is not the current RCID, rcidm->cur_rcid != rcid; * the RCID is in the priority queue; * the RCID is not in the retiring_list. * * CURRENT * Invariants: * rcid->state == RCID_STATE_CUR; * rcid->pq_idx == SIZE_MAX (debug assert only); * the RCID is the current RCID, rcidm->cur_rcid == rcid; * the RCID is not in the priority queue; * the RCID is not in the retiring_list. * * RETIRING * Invariants: * rcid->state == RCID_STATE_RETIRING; * rcid->pq_idx == SIZE_MAX (debug assert only); * the RCID is not the current RCID, rcidm->cur_rcid != rcid; * the RCID is not in the priority queue; * the RCID is in the retiring_list. * * Invariant: At most one RCID object is in the CURRENT state at any one time. * * (If no RCID object is in the CURRENT state, this means either * an unnumbered RCID is being used as the preferred RCID * or we currently have no preferred RCID.) * * All of the above states can be considered substates of the 'ACTIVE' state * for an RCID as specified in RFC 9000. A CID only ceases to be active * when we send a RETIRE_CONN_ID frame, which is the responsibility of the * user of the RCIDM and happens after the above state machine is terminated. */ enum { RCID_STATE_PENDING, RCID_STATE_CUR, RCID_STATE_RETIRING }; enum { RCID_TYPE_INITIAL, /* CID is from an peer INITIAL packet (seq 0) */ RCID_TYPE_PREF_ADDR, /* CID is from a preferred_address TPARAM (seq 1) */ RCID_TYPE_NCID /* CID is from a NCID frame */ /* * INITIAL_ODCID and RETRY_ODCID also conceptually exist but are tracked * separately. */ }; typedef struct rcid_st { OSSL_LIST_MEMBER(retiring, struct rcid_st); /* valid iff RETIRING */ QUIC_CONN_ID cid; /* The actual CID string for this RCID */ uint64_t seq_num; size_t pq_idx; /* Index of entry into priority queue */ unsigned int state : 2; /* RCID_STATE_* */ unsigned int type : 2; /* RCID_TYPE_* */ } RCID; DEFINE_PRIORITY_QUEUE_OF(RCID); DEFINE_LIST_OF(retiring, RCID); /* * RCID Manager * ============ * * The following "business logic" invariants also apply to the RCIDM * as a whole: * * Invariant: An RCID of INITIAL type has a sequence number of 0. * Invariant: An RCID of PREF_ADDR type has a sequence number of 1. * * Invariant: There is never more than one Initial ODCID * added throughout the lifetime of an RCIDM. * Invariant: There is never more than one Retry ODCID * added throughout the lifetime of an RCIDM. * Invariant: There is never more than one INITIAL RCID created * throughout the lifetime of an RCIDM. * Invariant: There is never more than one PREF_ADDR RCID created * throughout the lifetime of an RCIDM. * Invariant: No INITIAL or PREF_ADDR RCID may be added after * the handshake is completed. * */ struct quic_rcidm_st { /* * The current RCID we prefer to use (value undefined if * !have_preferred_rcid). * * This is preferentially set to a numbered RCID (represented by an RCID * object) if we have one (in which case preferred_rcid == cur_rcid->cid); * otherwise it is set to one of the unnumbered RCIDs (the Initial ODCID or * Retry ODCID) if available (and cur_rcid == NULL). */ QUIC_CONN_ID preferred_rcid; /* * These are initialized if the corresponding added_ flags are set. */ QUIC_CONN_ID initial_odcid, retry_odcid; /* * Total number of packets sent since we last made a packet count-based RCID * update decision. */ uint64_t packets_sent; /* Number of post-handshake RCID changes we have performed. */ uint64_t num_changes; /* * The Retire Prior To watermark value; max(retire_prior_to) of all received * NCID frames. */ uint64_t retire_prior_to; /* (SORT BY seq_num ASC) -> (RCID *) */ PRIORITY_QUEUE_OF(RCID) *rcids; /* * Current RCID object we are using. This may differ from the first item in * the priority queue if we received NCID frames out of order. For example * if we get seq 5, switch to it immediately, then get seq 4, we want to * keep using seq 5 until we decide to roll again rather than immediately * switch to seq 4. Never points to an object on the retiring_list. */ RCID *cur_rcid; /* * When a RCID becomes pending-retirement, it is moved to the retiring_list, * then freed when it is popped from the retired queue. We use a list for * this rather than a priority queue as the order in which items are freed * does not matter. We always append to the tail of the list in order to * maintain the guarantee that the head (if present) only changes when a * caller calls pop(). */ OSSL_LIST(retiring) retiring_list; /* Number of entries on the retiring_list. */ size_t num_retiring; /* preferred_rcid has been changed? */ unsigned int preferred_rcid_changed : 1; /* Do we have any RCID we can use currently? */ unsigned int have_preferred_rcid : 1; /* QUIC handshake has been completed? */ unsigned int handshake_complete : 1; /* odcid was set (not necessarily still valid as a RCID)? */ unsigned int added_initial_odcid : 1; /* retry_odcid was set (not necessarily still valid as a RCID?) */ unsigned int added_retry_odcid : 1; /* An initial RCID was added as an RCID structure? */ unsigned int added_initial_rcid : 1; /* Has a RCID roll been manually requested? */ unsigned int roll_requested : 1; }; /* * Caller must periodically pop retired RCIDs and handle them. If the caller * fails to do so, fail safely rather than start exhibiting integer rollover. * Limit the total number of numbered RCIDs to an implausibly large but safe * value. */ #define MAX_NUMBERED_RCIDS (SIZE_MAX / 2) static void rcidm_transition_rcid(QUIC_RCIDM *rcidm, RCID *rcid, unsigned int state); /* Check invariants of an RCID */ static void rcidm_check_rcid(QUIC_RCIDM *rcidm, RCID *rcid) { assert(rcid->state == RCID_STATE_PENDING || rcid->state == RCID_STATE_CUR || rcid->state == RCID_STATE_RETIRING); assert((rcid->state == RCID_STATE_PENDING) == (rcid->pq_idx != SIZE_MAX)); assert((rcid->state == RCID_STATE_CUR) == (rcidm->cur_rcid == rcid)); assert((ossl_list_retiring_next(rcid) != NULL || ossl_list_retiring_prev(rcid) != NULL || ossl_list_retiring_head(&rcidm->retiring_list) == rcid) == (rcid->state == RCID_STATE_RETIRING)); assert(rcid->type != RCID_TYPE_INITIAL || rcid->seq_num == 0); assert(rcid->type != RCID_TYPE_PREF_ADDR || rcid->seq_num == 1); assert(rcid->seq_num <= OSSL_QUIC_VLINT_MAX); assert(rcid->cid.id_len > 0 && rcid->cid.id_len <= QUIC_MAX_CONN_ID_LEN); assert(rcid->seq_num >= rcidm->retire_prior_to || rcid->state == RCID_STATE_RETIRING); assert(rcidm->num_changes == 0 || rcidm->handshake_complete); assert(rcid->state != RCID_STATE_RETIRING || rcidm->num_retiring > 0); } static int rcid_cmp(const RCID *a, const RCID *b) { if (a->seq_num < b->seq_num) return -1; if (a->seq_num > b->seq_num) return 1; return 0; } QUIC_RCIDM *ossl_quic_rcidm_new(const QUIC_CONN_ID *initial_odcid) { QUIC_RCIDM *rcidm; if ((rcidm = OPENSSL_zalloc(sizeof(*rcidm))) == NULL) return NULL; if ((rcidm->rcids = ossl_pqueue_RCID_new(rcid_cmp)) == NULL) { OPENSSL_free(rcidm); return NULL; } if (initial_odcid != NULL) { rcidm->initial_odcid = *initial_odcid; rcidm->added_initial_odcid = 1; } rcidm_update(rcidm); return rcidm; } void ossl_quic_rcidm_free(QUIC_RCIDM *rcidm) { RCID *rcid, *rnext; if (rcidm == NULL) return; OPENSSL_free(rcidm->cur_rcid); while ((rcid = ossl_pqueue_RCID_pop(rcidm->rcids)) != NULL) OPENSSL_free(rcid); LIST_FOREACH_DELSAFE(rcid, rnext, retiring, &rcidm->retiring_list) OPENSSL_free(rcid); ossl_pqueue_RCID_free(rcidm->rcids); OPENSSL_free(rcidm); } static void rcidm_set_preferred_rcid(QUIC_RCIDM *rcidm, const QUIC_CONN_ID *rcid) { if (rcid == NULL) { rcidm->preferred_rcid_changed = 1; rcidm->have_preferred_rcid = 0; return; } if (ossl_quic_conn_id_eq(&rcidm->preferred_rcid, rcid)) return; rcidm->preferred_rcid = *rcid; rcidm->preferred_rcid_changed = 1; rcidm->have_preferred_rcid = 1; } /* * RCID Lifecycle Management * ========================= */ static RCID *rcidm_create_rcid(QUIC_RCIDM *rcidm, uint64_t seq_num, const QUIC_CONN_ID *cid, unsigned int type) { RCID *rcid; if (cid->id_len < 1 || cid->id_len > QUIC_MAX_CONN_ID_LEN || seq_num > OSSL_QUIC_VLINT_MAX || ossl_pqueue_RCID_num(rcidm->rcids) + rcidm->num_retiring > MAX_NUMBERED_RCIDS) return NULL; if ((rcid = OPENSSL_zalloc(sizeof(*rcid))) == NULL) return NULL; rcid->seq_num = seq_num; rcid->cid = *cid; rcid->type = type; if (rcid->seq_num >= rcidm->retire_prior_to) { rcid->state = RCID_STATE_PENDING; if (!ossl_pqueue_RCID_push(rcidm->rcids, rcid, &rcid->pq_idx)) { OPENSSL_free(rcid); return NULL; } } else { /* RCID is immediately retired upon creation. */ rcid->state = RCID_STATE_RETIRING; rcid->pq_idx = SIZE_MAX; ossl_list_retiring_insert_tail(&rcidm->retiring_list, rcid); ++rcidm->num_retiring; } rcidm_check_rcid(rcidm, rcid); return rcid; } static void rcidm_transition_rcid(QUIC_RCIDM *rcidm, RCID *rcid, unsigned int state) { unsigned int old_state = rcid->state; assert(state >= old_state && state <= RCID_STATE_RETIRING); rcidm_check_rcid(rcidm, rcid); if (state == old_state) return; if (rcidm->cur_rcid != NULL && state == RCID_STATE_CUR) { rcidm_transition_rcid(rcidm, rcidm->cur_rcid, RCID_STATE_RETIRING); assert(rcidm->cur_rcid == NULL); } if (old_state == RCID_STATE_PENDING) { ossl_pqueue_RCID_remove(rcidm->rcids, rcid->pq_idx); rcid->pq_idx = SIZE_MAX; } rcid->state = state; if (state == RCID_STATE_CUR) { rcidm->cur_rcid = rcid; } else if (state == RCID_STATE_RETIRING) { if (old_state == RCID_STATE_CUR) rcidm->cur_rcid = NULL; ossl_list_retiring_insert_tail(&rcidm->retiring_list, rcid); ++rcidm->num_retiring; } rcidm_check_rcid(rcidm, rcid); } static void rcidm_free_rcid(QUIC_RCIDM *rcidm, RCID *rcid) { if (rcid == NULL) return; rcidm_check_rcid(rcidm, rcid); switch (rcid->state) { case RCID_STATE_PENDING: ossl_pqueue_RCID_remove(rcidm->rcids, rcid->pq_idx); break; case RCID_STATE_CUR: rcidm->cur_rcid = NULL; break; case RCID_STATE_RETIRING: ossl_list_retiring_remove(&rcidm->retiring_list, rcid); --rcidm->num_retiring; break; default: assert(0); break; } OPENSSL_free(rcid); } static void rcidm_handle_retire_prior_to(QUIC_RCIDM *rcidm, uint64_t retire_prior_to) { RCID *rcid; if (retire_prior_to <= rcidm->retire_prior_to) return; /* * Retire the current RCID (if any) if it is affected. */ if (rcidm->cur_rcid != NULL && rcidm->cur_rcid->seq_num < retire_prior_to) rcidm_transition_rcid(rcidm, rcidm->cur_rcid, RCID_STATE_RETIRING); /* * Any other RCIDs needing retirement will be at the start of the priority * queue, so just stop once we see a higher sequence number exceeding the * threshold. */ while ((rcid = ossl_pqueue_RCID_peek(rcidm->rcids)) != NULL && rcid->seq_num < retire_prior_to) rcidm_transition_rcid(rcidm, rcid, RCID_STATE_RETIRING); rcidm->retire_prior_to = retire_prior_to; } /* * Decision Logic * ============== */ static void rcidm_roll(QUIC_RCIDM *rcidm) { RCID *rcid; if ((rcid = ossl_pqueue_RCID_peek(rcidm->rcids)) == NULL) return; rcidm_transition_rcid(rcidm, rcid, RCID_STATE_CUR); ++rcidm->num_changes; rcidm->roll_requested = 0; if (rcidm->packets_sent >= PACKETS_PER_RCID) rcidm->packets_sent %= PACKETS_PER_RCID; else rcidm->packets_sent = 0; } static void rcidm_update(QUIC_RCIDM *rcidm) { RCID *rcid; /* * If we have no current numbered RCID but have one or more pending, use it. */ if (rcidm->cur_rcid == NULL && (rcid = ossl_pqueue_RCID_peek(rcidm->rcids)) != NULL) { rcidm_transition_rcid(rcidm, rcid, RCID_STATE_CUR); assert(rcidm->cur_rcid != NULL); } /* Prefer use of any current numbered RCID we have, if possible. */ if (rcidm->cur_rcid != NULL) { rcidm_check_rcid(rcidm, rcidm->cur_rcid); rcidm_set_preferred_rcid(rcidm, &rcidm->cur_rcid->cid); return; } /* * If there are no RCIDs from NCID frames we can use, go through the various * kinds of bootstrapping RCIDs we can use in order of priority. */ if (rcidm->added_retry_odcid && !rcidm->handshake_complete) { rcidm_set_preferred_rcid(rcidm, &rcidm->retry_odcid); return; } if (rcidm->added_initial_odcid && !rcidm->handshake_complete) { rcidm_set_preferred_rcid(rcidm, &rcidm->initial_odcid); return; } /* We don't know of any usable RCIDs */ rcidm_set_preferred_rcid(rcidm, NULL); } static int rcidm_should_roll(QUIC_RCIDM *rcidm) { /* * Always switch as soon as possible if handshake completes; * and every n packets after handshake completes or the last roll; and * whenever manually requested. */ return rcidm->handshake_complete && (rcidm->num_changes == 0 || rcidm->packets_sent >= PACKETS_PER_RCID || rcidm->roll_requested); } static void rcidm_tick(QUIC_RCIDM *rcidm) { if (rcidm_should_roll(rcidm)) rcidm_roll(rcidm); rcidm_update(rcidm); } /* * Events * ====== */ void ossl_quic_rcidm_on_handshake_complete(QUIC_RCIDM *rcidm) { if (rcidm->handshake_complete) return; rcidm->handshake_complete = 1; rcidm_tick(rcidm); } void ossl_quic_rcidm_on_packet_sent(QUIC_RCIDM *rcidm, uint64_t num_packets) { if (num_packets == 0) return; rcidm->packets_sent += num_packets; rcidm_tick(rcidm); } void ossl_quic_rcidm_request_roll(QUIC_RCIDM *rcidm) { rcidm->roll_requested = 1; rcidm_tick(rcidm); } /* * Mutation Operations * =================== */ int ossl_quic_rcidm_add_from_initial(QUIC_RCIDM *rcidm, const QUIC_CONN_ID *rcid) { RCID *rcid_obj; if (rcidm->added_initial_rcid || rcidm->handshake_complete) return 0; rcid_obj = rcidm_create_rcid(rcidm, INITIAL_SEQ_NUM, rcid, RCID_TYPE_INITIAL); if (rcid_obj == NULL) return 0; rcidm->added_initial_rcid = 1; rcidm_tick(rcidm); return 1; } int ossl_quic_rcidm_add_from_server_retry(QUIC_RCIDM *rcidm, const QUIC_CONN_ID *retry_odcid) { if (rcidm->added_retry_odcid || rcidm->handshake_complete) return 0; rcidm->retry_odcid = *retry_odcid; rcidm->added_retry_odcid = 1; rcidm_tick(rcidm); return 1; } int ossl_quic_rcidm_add_from_ncid(QUIC_RCIDM *rcidm, const OSSL_QUIC_FRAME_NEW_CONN_ID *ncid) { RCID *rcid; rcid = rcidm_create_rcid(rcidm, ncid->seq_num, &ncid->conn_id, RCID_TYPE_NCID); if (rcid == NULL) return 0; rcidm_handle_retire_prior_to(rcidm, ncid->retire_prior_to); rcidm_tick(rcidm); return 1; } /* * Queries * ======= */ static int rcidm_get_retire(QUIC_RCIDM *rcidm, uint64_t *seq_num, int peek) { RCID *rcid = ossl_list_retiring_head(&rcidm->retiring_list); if (rcid == NULL) return 0; if (seq_num != NULL) *seq_num = rcid->seq_num; if (!peek) rcidm_free_rcid(rcidm, rcid); return 1; } int ossl_quic_rcidm_pop_retire_seq_num(QUIC_RCIDM *rcidm, uint64_t *seq_num) { return rcidm_get_retire(rcidm, seq_num, /*peek=*/0); } int ossl_quic_rcidm_peek_retire_seq_num(QUIC_RCIDM *rcidm, uint64_t *seq_num) { return rcidm_get_retire(rcidm, seq_num, /*peek=*/1); } int ossl_quic_rcidm_get_preferred_tx_dcid(QUIC_RCIDM *rcidm, QUIC_CONN_ID *tx_dcid) { if (!rcidm->have_preferred_rcid) return 0; *tx_dcid = rcidm->preferred_rcid; return 1; } int ossl_quic_rcidm_get_preferred_tx_dcid_changed(QUIC_RCIDM *rcidm, int clear) { int r = rcidm->preferred_rcid_changed; if (clear) rcidm->preferred_rcid_changed = 0; return r; } size_t ossl_quic_rcidm_get_num_active(const QUIC_RCIDM *rcidm) { return ossl_pqueue_RCID_num(rcidm->rcids) + (rcidm->cur_rcid != NULL ? 1 : 0) + ossl_quic_rcidm_get_num_retiring(rcidm); } size_t ossl_quic_rcidm_get_num_retiring(const QUIC_RCIDM *rcidm) { return rcidm->num_retiring; }

./openssl/ssl/quic/quic_sf_list.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/uint_set.h" #include "internal/common.h" #include "internal/quic_sf_list.h" struct stream_frame_st { struct stream_frame_st *prev, *next; UINT_RANGE range; OSSL_QRX_PKT *pkt; const unsigned char *data; }; static void stream_frame_free(SFRAME_LIST *fl, STREAM_FRAME *sf) { if (fl->cleanse && sf->data != NULL) OPENSSL_cleanse((unsigned char *)sf->data, (size_t)(sf->range.end - sf->range.start)); ossl_qrx_pkt_release(sf->pkt); OPENSSL_free(sf); } static STREAM_FRAME *stream_frame_new(UINT_RANGE *range, OSSL_QRX_PKT *pkt, const unsigned char *data) { STREAM_FRAME *sf = OPENSSL_zalloc(sizeof(*sf)); if (sf == NULL) return NULL; if (pkt != NULL) ossl_qrx_pkt_up_ref(pkt); sf->range = *range; sf->pkt = pkt; sf->data = data; return sf; } void ossl_sframe_list_init(SFRAME_LIST *fl) { memset(fl, 0, sizeof(*fl)); } void ossl_sframe_list_destroy(SFRAME_LIST *fl) { STREAM_FRAME *sf, *next_frame; for (sf = fl->head; sf != NULL; sf = next_frame) { next_frame = sf->next; stream_frame_free(fl, sf); } } static int append_frame(SFRAME_LIST *fl, UINT_RANGE *range, OSSL_QRX_PKT *pkt, const unsigned char *data) { STREAM_FRAME *new_frame; if ((new_frame = stream_frame_new(range, pkt, data)) == NULL) return 0; new_frame->prev = fl->tail; if (fl->tail != NULL) fl->tail->next = new_frame; fl->tail = new_frame; ++fl->num_frames; return 1; } int ossl_sframe_list_insert(SFRAME_LIST *fl, UINT_RANGE *range, OSSL_QRX_PKT *pkt, const unsigned char *data, int fin) { STREAM_FRAME *sf, *new_frame, *prev_frame, *next_frame; #ifndef NDEBUG uint64_t curr_end = fl->tail != NULL ? fl->tail->range.end : fl->offset; /* This check for FINAL_SIZE_ERROR is handled by QUIC FC already */ assert((!fin || curr_end <= range->end) && (!fl->fin || curr_end >= range->end)); #endif if (fl->offset >= range->end) goto end; /* nothing there yet */ if (fl->tail == NULL) { fl->tail = fl->head = stream_frame_new(range, pkt, data); if (fl->tail == NULL) return 0; ++fl->num_frames; goto end; } /* optimize insertion at the end */ if (fl->tail->range.start < range->start) { if (fl->tail->range.end >= range->end) goto end; if (!append_frame(fl, range, pkt, data)) return 0; goto end; } prev_frame = NULL; for (sf = fl->head; sf != NULL && sf->range.start < range->start; sf = sf->next) prev_frame = sf; if (!ossl_assert(sf != NULL)) /* frame list invariant broken */ return 0; if (prev_frame != NULL && prev_frame->range.end >= range->end) goto end; /* * Now we must create a new frame although in the end we might drop it, * because we will be potentially dropping existing overlapping frames. */ new_frame = stream_frame_new(range, pkt, data); if (new_frame == NULL) return 0; for (next_frame = sf; next_frame != NULL && next_frame->range.end <= range->end;) { STREAM_FRAME *drop_frame = next_frame; next_frame = next_frame->next; if (next_frame != NULL) next_frame->prev = drop_frame->prev; if (prev_frame != NULL) prev_frame->next = drop_frame->next; if (fl->head == drop_frame) fl->head = next_frame; if (fl->tail == drop_frame) fl->tail = prev_frame; --fl->num_frames; stream_frame_free(fl, drop_frame); } if (next_frame != NULL) { /* check whether the new_frame is redundant because there is no gap */ if (prev_frame != NULL && next_frame->range.start <= prev_frame->range.end) { stream_frame_free(fl, new_frame); goto end; } next_frame->prev = new_frame; } else { fl->tail = new_frame; } new_frame->next = next_frame; new_frame->prev = prev_frame; if (prev_frame != NULL) prev_frame->next = new_frame; else fl->head = new_frame; ++fl->num_frames; end: fl->fin = fin || fl->fin; return 1; } int ossl_sframe_list_peek(const SFRAME_LIST *fl, void **iter, UINT_RANGE *range, const unsigned char **data, int *fin) { STREAM_FRAME *sf = *iter; uint64_t start; if (sf == NULL) { start = fl->offset; sf = fl->head; } else { start = sf->range.end; sf = sf->next; } range->start = start; if (sf == NULL || sf->range.start > start || !ossl_assert(start < sf->range.end)) { range->end = start; *data = NULL; *iter = NULL; /* set fin only if we are at the end */ *fin = sf == NULL ? fl->fin : 0; return 0; } range->end = sf->range.end; if (sf->data != NULL) *data = sf->data + (start - sf->range.start); else *data = NULL; *fin = sf->next == NULL ? fl->fin : 0; *iter = sf; return 1; } int ossl_sframe_list_drop_frames(SFRAME_LIST *fl, uint64_t limit) { STREAM_FRAME *sf; /* offset cannot move back or past the data received */ if (!ossl_assert(limit >= fl->offset) || !ossl_assert(fl->tail == NULL || limit <= fl->tail->range.end) || !ossl_assert(fl->tail != NULL || limit == fl->offset)) return 0; fl->offset = limit; for (sf = fl->head; sf != NULL && sf->range.end <= limit;) { STREAM_FRAME *drop_frame = sf; sf = sf->next; --fl->num_frames; stream_frame_free(fl, drop_frame); } fl->head = sf; if (sf != NULL) sf->prev = NULL; else fl->tail = NULL; fl->head_locked = 0; return 1; } int ossl_sframe_list_lock_head(SFRAME_LIST *fl, UINT_RANGE *range, const unsigned char **data, int *fin) { int ret; void *iter = NULL; if (fl->head_locked) return 0; ret = ossl_sframe_list_peek(fl, &iter, range, data, fin); if (ret) fl->head_locked = 1; return ret; } int ossl_sframe_list_is_head_locked(SFRAME_LIST *fl) { return fl->head_locked; } int ossl_sframe_list_move_data(SFRAME_LIST *fl, sframe_list_write_at_cb *write_at_cb, void *cb_arg) { STREAM_FRAME *sf = fl->head, *prev_frame = NULL; uint64_t limit = fl->offset; if (sf == NULL) return 1; if (fl->head_locked) sf = sf->next; for (; sf != NULL; sf = sf->next) { size_t len; const unsigned char *data = sf->data; if (limit < sf->range.start) limit = sf->range.start; if (data != NULL) { if (limit > sf->range.start) data += (size_t)(limit - sf->range.start); len = (size_t)(sf->range.end - limit); if (!write_at_cb(limit, data, len, cb_arg)) /* data did not fit */ return 0; if (fl->cleanse) OPENSSL_cleanse((unsigned char *)sf->data, (size_t)(sf->range.end - sf->range.start)); /* release the packet */ sf->data = NULL; ossl_qrx_pkt_release(sf->pkt); sf->pkt = NULL; } limit = sf->range.end; /* merge contiguous frames */ if (prev_frame != NULL && prev_frame->range.end >= sf->range.start) { prev_frame->range.end = sf->range.end; prev_frame->next = sf->next; if (sf->next != NULL) sf->next->prev = prev_frame; else fl->tail = prev_frame; --fl->num_frames; stream_frame_free(fl, sf); sf = prev_frame; continue; } prev_frame = sf; } return 1; }

./openssl/ssl/quic/cc_newreno.c

#include "internal/quic_cc.h" #include "internal/quic_types.h" #include "internal/safe_math.h" OSSL_SAFE_MATH_UNSIGNED(u64, uint64_t) typedef struct ossl_cc_newreno_st { /* Dependencies. */ OSSL_TIME (*now_cb)(void *arg); void *now_cb_arg; /* 'Constants' (which we allow to be configurable). */ uint64_t k_init_wnd, k_min_wnd; uint32_t k_loss_reduction_factor_num, k_loss_reduction_factor_den; uint32_t persistent_cong_thresh; /* State. */ size_t max_dgram_size; uint64_t bytes_in_flight, cong_wnd, slow_start_thresh, bytes_acked; OSSL_TIME cong_recovery_start_time; /* Unflushed state during multiple on-loss calls. */ int processing_loss; /* 1 if not flushed */ OSSL_TIME tx_time_of_last_loss; /* Diagnostic state. */ int in_congestion_recovery; /* Diagnostic output locations. */ size_t *p_diag_max_dgram_payload_len; uint64_t *p_diag_cur_cwnd_size; uint64_t *p_diag_min_cwnd_size; uint64_t *p_diag_cur_bytes_in_flight; uint32_t *p_diag_cur_state; } OSSL_CC_NEWRENO; #define MIN_MAX_INIT_WND_SIZE 14720 /* RFC 9002 s. 7.2 */ /* TODO(QUIC FUTURE): Pacing support. */ static void newreno_set_max_dgram_size(OSSL_CC_NEWRENO *nr, size_t max_dgram_size); static void newreno_update_diag(OSSL_CC_NEWRENO *nr); static void newreno_reset(OSSL_CC_DATA *cc); static OSSL_CC_DATA *newreno_new(OSSL_TIME (*now_cb)(void *arg), void *now_cb_arg) { OSSL_CC_NEWRENO *nr; if ((nr = OPENSSL_zalloc(sizeof(*nr))) == NULL) return NULL; nr->now_cb = now_cb; nr->now_cb_arg = now_cb_arg; newreno_set_max_dgram_size(nr, QUIC_MIN_INITIAL_DGRAM_LEN); newreno_reset((OSSL_CC_DATA *)nr); return (OSSL_CC_DATA *)nr; } static void newreno_free(OSSL_CC_DATA *cc) { OPENSSL_free(cc); } static void newreno_set_max_dgram_size(OSSL_CC_NEWRENO *nr, size_t max_dgram_size) { size_t max_init_wnd; int is_reduced = (max_dgram_size < nr->max_dgram_size); nr->max_dgram_size = max_dgram_size; max_init_wnd = 2 * max_dgram_size; if (max_init_wnd < MIN_MAX_INIT_WND_SIZE) max_init_wnd = MIN_MAX_INIT_WND_SIZE; nr->k_init_wnd = 10 * max_dgram_size; if (nr->k_init_wnd > max_init_wnd) nr->k_init_wnd = max_init_wnd; nr->k_min_wnd = 2 * max_dgram_size; if (is_reduced) nr->cong_wnd = nr->k_init_wnd; newreno_update_diag(nr); } static void newreno_reset(OSSL_CC_DATA *cc) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; nr->k_loss_reduction_factor_num = 1; nr->k_loss_reduction_factor_den = 2; nr->persistent_cong_thresh = 3; nr->cong_wnd = nr->k_init_wnd; nr->bytes_in_flight = 0; nr->bytes_acked = 0; nr->slow_start_thresh = UINT64_MAX; nr->cong_recovery_start_time = ossl_time_zero(); nr->processing_loss = 0; nr->tx_time_of_last_loss = ossl_time_zero(); nr->in_congestion_recovery = 0; } static int newreno_set_input_params(OSSL_CC_DATA *cc, const OSSL_PARAM *params) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; const OSSL_PARAM *p; size_t value; p = OSSL_PARAM_locate_const(params, OSSL_CC_OPTION_MAX_DGRAM_PAYLOAD_LEN); if (p != NULL) { if (!OSSL_PARAM_get_size_t(p, &value)) return 0; if (value < QUIC_MIN_INITIAL_DGRAM_LEN) return 0; newreno_set_max_dgram_size(nr, value); } return 1; } static int bind_diag(OSSL_PARAM *params, const char *param_name, size_t len, void **pp) { const OSSL_PARAM *p = OSSL_PARAM_locate_const(params, param_name); *pp = NULL; if (p == NULL) return 1; if (p->data_type != OSSL_PARAM_UNSIGNED_INTEGER || p->data_size != len) return 0; *pp = p->data; return 1; } static int newreno_bind_diagnostic(OSSL_CC_DATA *cc, OSSL_PARAM *params) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; size_t *new_p_max_dgram_payload_len; uint64_t *new_p_cur_cwnd_size; uint64_t *new_p_min_cwnd_size; uint64_t *new_p_cur_bytes_in_flight; uint32_t *new_p_cur_state; if (!bind_diag(params, OSSL_CC_OPTION_MAX_DGRAM_PAYLOAD_LEN, sizeof(size_t), (void **)&new_p_max_dgram_payload_len) || !bind_diag(params, OSSL_CC_OPTION_CUR_CWND_SIZE, sizeof(uint64_t), (void **)&new_p_cur_cwnd_size) || !bind_diag(params, OSSL_CC_OPTION_MIN_CWND_SIZE, sizeof(uint64_t), (void **)&new_p_min_cwnd_size) || !bind_diag(params, OSSL_CC_OPTION_CUR_BYTES_IN_FLIGHT, sizeof(uint64_t), (void **)&new_p_cur_bytes_in_flight) || !bind_diag(params, OSSL_CC_OPTION_CUR_STATE, sizeof(uint32_t), (void **)&new_p_cur_state)) return 0; if (new_p_max_dgram_payload_len != NULL) nr->p_diag_max_dgram_payload_len = new_p_max_dgram_payload_len; if (new_p_cur_cwnd_size != NULL) nr->p_diag_cur_cwnd_size = new_p_cur_cwnd_size; if (new_p_min_cwnd_size != NULL) nr->p_diag_min_cwnd_size = new_p_min_cwnd_size; if (new_p_cur_bytes_in_flight != NULL) nr->p_diag_cur_bytes_in_flight = new_p_cur_bytes_in_flight; if (new_p_cur_state != NULL) nr->p_diag_cur_state = new_p_cur_state; newreno_update_diag(nr); return 1; } static void unbind_diag(OSSL_PARAM *params, const char *param_name, void **pp) { const OSSL_PARAM *p = OSSL_PARAM_locate_const(params, param_name); if (p != NULL) *pp = NULL; } static int newreno_unbind_diagnostic(OSSL_CC_DATA *cc, OSSL_PARAM *params) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; unbind_diag(params, OSSL_CC_OPTION_MAX_DGRAM_PAYLOAD_LEN, (void **)&nr->p_diag_max_dgram_payload_len); unbind_diag(params, OSSL_CC_OPTION_CUR_CWND_SIZE, (void **)&nr->p_diag_cur_cwnd_size); unbind_diag(params, OSSL_CC_OPTION_MIN_CWND_SIZE, (void **)&nr->p_diag_min_cwnd_size); unbind_diag(params, OSSL_CC_OPTION_CUR_BYTES_IN_FLIGHT, (void **)&nr->p_diag_cur_bytes_in_flight); unbind_diag(params, OSSL_CC_OPTION_CUR_STATE, (void **)&nr->p_diag_cur_state); return 1; } static void newreno_update_diag(OSSL_CC_NEWRENO *nr) { if (nr->p_diag_max_dgram_payload_len != NULL) *nr->p_diag_max_dgram_payload_len = nr->max_dgram_size; if (nr->p_diag_cur_cwnd_size != NULL) *nr->p_diag_cur_cwnd_size = nr->cong_wnd; if (nr->p_diag_min_cwnd_size != NULL) *nr->p_diag_min_cwnd_size = nr->k_min_wnd; if (nr->p_diag_cur_bytes_in_flight != NULL) *nr->p_diag_cur_bytes_in_flight = nr->bytes_in_flight; if (nr->p_diag_cur_state != NULL) { if (nr->in_congestion_recovery) *nr->p_diag_cur_state = 'R'; else if (nr->cong_wnd < nr->slow_start_thresh) *nr->p_diag_cur_state = 'S'; else *nr->p_diag_cur_state = 'A'; } } static int newreno_in_cong_recovery(OSSL_CC_NEWRENO *nr, OSSL_TIME tx_time) { return ossl_time_compare(tx_time, nr->cong_recovery_start_time) <= 0; } static void newreno_cong(OSSL_CC_NEWRENO *nr, OSSL_TIME tx_time) { int err = 0; /* No reaction if already in a recovery period. */ if (newreno_in_cong_recovery(nr, tx_time)) return; /* Start a new recovery period. */ nr->in_congestion_recovery = 1; nr->cong_recovery_start_time = nr->now_cb(nr->now_cb_arg); /* slow_start_thresh = cong_wnd * loss_reduction_factor */ nr->slow_start_thresh = safe_muldiv_u64(nr->cong_wnd, nr->k_loss_reduction_factor_num, nr->k_loss_reduction_factor_den, &err); if (err) nr->slow_start_thresh = UINT64_MAX; nr->cong_wnd = nr->slow_start_thresh; if (nr->cong_wnd < nr->k_min_wnd) nr->cong_wnd = nr->k_min_wnd; } static void newreno_flush(OSSL_CC_NEWRENO *nr, uint32_t flags) { if (!nr->processing_loss) return; newreno_cong(nr, nr->tx_time_of_last_loss); if ((flags & OSSL_CC_LOST_FLAG_PERSISTENT_CONGESTION) != 0) { nr->cong_wnd = nr->k_min_wnd; nr->cong_recovery_start_time = ossl_time_zero(); } nr->processing_loss = 0; newreno_update_diag(nr); } static uint64_t newreno_get_tx_allowance(OSSL_CC_DATA *cc) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; if (nr->bytes_in_flight >= nr->cong_wnd) return 0; return nr->cong_wnd - nr->bytes_in_flight; } static OSSL_TIME newreno_get_wakeup_deadline(OSSL_CC_DATA *cc) { if (newreno_get_tx_allowance(cc) > 0) { /* We have TX allowance now so wakeup immediately */ return ossl_time_zero(); } else { /* * The NewReno congestion controller does not vary its state in time, * only in response to stimulus. */ return ossl_time_infinite(); } } static int newreno_on_data_sent(OSSL_CC_DATA *cc, uint64_t num_bytes) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; nr->bytes_in_flight += num_bytes; newreno_update_diag(nr); return 1; } static int newreno_is_cong_limited(OSSL_CC_NEWRENO *nr) { uint64_t wnd_rem; /* We are congestion-limited if we are already at the congestion window. */ if (nr->bytes_in_flight >= nr->cong_wnd) return 1; wnd_rem = nr->cong_wnd - nr->bytes_in_flight; /* * Consider ourselves congestion-limited if less than three datagrams' worth * of congestion window remains to be spent, or if we are in slow start and * have consumed half of our window. */ return (nr->cong_wnd < nr->slow_start_thresh && wnd_rem <= nr->cong_wnd / 2) || wnd_rem <= 3 * nr->max_dgram_size; } static int newreno_on_data_acked(OSSL_CC_DATA *cc, const OSSL_CC_ACK_INFO *info) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; /* * Packet has been acked. Firstly, remove it from the aggregate count of * bytes in flight. */ nr->bytes_in_flight -= info->tx_size; /* * We use acknowledgement of data as a signal that we are not at channel * capacity and that it may be reasonable to increase the congestion window. * However, acknowledgement is not a useful signal that there is further * capacity if we are not actually saturating the congestion window that we * already have (for example, if the application is not generating much data * or we are limited by flow control). Therefore, we only expand the * congestion window if we are consuming a significant fraction of the * congestion window. */ if (!newreno_is_cong_limited(nr)) goto out; /* * We can handle acknowledgement of a packet in one of three ways * depending on our current state: * * - Congestion Recovery: Do nothing. We don't start increasing * the congestion window in response to acknowledgements until * we are no longer in the Congestion Recovery state. * * - Slow Start: Increase the congestion window using the slow * start scale. * * - Congestion Avoidance: Increase the congestion window using * the congestion avoidance scale. */ if (newreno_in_cong_recovery(nr, info->tx_time)) { /* Congestion recovery, do nothing. */ } else if (nr->cong_wnd < nr->slow_start_thresh) { /* When this condition is true we are in the Slow Start state. */ nr->cong_wnd += info->tx_size; nr->in_congestion_recovery = 0; } else { /* Otherwise, we are in the Congestion Avoidance state. */ nr->bytes_acked += info->tx_size; /* * Avoid integer division as per RFC 9002 s. B.5. / RFC3465 s. 2.1. */ if (nr->bytes_acked >= nr->cong_wnd) { nr->bytes_acked -= nr->cong_wnd; nr->cong_wnd += nr->max_dgram_size; } nr->in_congestion_recovery = 0; } out: newreno_update_diag(nr); return 1; } static int newreno_on_data_lost(OSSL_CC_DATA *cc, const OSSL_CC_LOSS_INFO *info) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; if (info->tx_size > nr->bytes_in_flight) return 0; nr->bytes_in_flight -= info->tx_size; if (!nr->processing_loss) { if (ossl_time_compare(info->tx_time, nr->tx_time_of_last_loss) <= 0) /* * After triggering congestion due to a lost packet at time t, don't * trigger congestion again due to any subsequently detected lost * packet at a time s < t, as we've effectively already signalled * congestion on loss of that and subsequent packets. */ goto out; nr->processing_loss = 1; /* * Cancel any pending window increase in the Congestion Avoidance state. */ nr->bytes_acked = 0; } nr->tx_time_of_last_loss = ossl_time_max(nr->tx_time_of_last_loss, info->tx_time); out: newreno_update_diag(nr); return 1; } static int newreno_on_data_lost_finished(OSSL_CC_DATA *cc, uint32_t flags) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; newreno_flush(nr, flags); return 1; } static int newreno_on_data_invalidated(OSSL_CC_DATA *cc, uint64_t num_bytes) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; nr->bytes_in_flight -= num_bytes; newreno_update_diag(nr); return 1; } static int newreno_on_ecn(OSSL_CC_DATA *cc, const OSSL_CC_ECN_INFO *info) { OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc; nr->processing_loss = 1; nr->bytes_acked = 0; nr->tx_time_of_last_loss = info->largest_acked_time; newreno_flush(nr, 0); return 1; } const OSSL_CC_METHOD ossl_cc_newreno_method = { newreno_new, newreno_free, newreno_reset, newreno_set_input_params, newreno_bind_diagnostic, newreno_unbind_diagnostic, newreno_get_tx_allowance, newreno_get_wakeup_deadline, newreno_on_data_sent, newreno_on_data_acked, newreno_on_data_lost, newreno_on_data_lost_finished, newreno_on_data_invalidated, newreno_on_ecn, };

./openssl/ssl/quic/quic_demux.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_demux.h" #include "internal/quic_wire_pkt.h" #include "internal/common.h" #include <openssl/lhash.h> #include <openssl/err.h> #define URXE_DEMUX_STATE_FREE 0 /* on urx_free list */ #define URXE_DEMUX_STATE_PENDING 1 /* on urx_pending list */ #define URXE_DEMUX_STATE_ISSUED 2 /* on neither list */ #define DEMUX_MAX_MSGS_PER_CALL 32 #define DEMUX_DEFAULT_MTU 1500 struct quic_demux_st { /* The underlying transport BIO with datagram semantics. */ BIO *net_bio; /* * QUIC short packets do not contain the length of the connection ID field, * therefore it must be known contextually. The demuxer requires connection * IDs of the same length to be used for all incoming packets. */ size_t short_conn_id_len; /* * Our current understanding of the upper bound on an incoming datagram size * in bytes. */ size_t mtu; /* Time retrieval callback. */ OSSL_TIME (*now)(void *arg); void *now_arg; /* The default packet handler, if any. */ ossl_quic_demux_cb_fn *default_cb; void *default_cb_arg; /* * List of URXEs which are not currently in use (i.e., not filled with * unconsumed data). These are moved to the pending list as they are filled. */ QUIC_URXE_LIST urx_free; /* * List of URXEs which are filled with received encrypted data. These are * removed from this list as we invoke the callbacks for each of them. They * are then not on any list managed by us; we forget about them until our * user calls ossl_quic_demux_release_urxe to return the URXE to us, at * which point we add it to the free list. */ QUIC_URXE_LIST urx_pending; /* Whether to use local address support. */ char use_local_addr; }; QUIC_DEMUX *ossl_quic_demux_new(BIO *net_bio, size_t short_conn_id_len, OSSL_TIME (*now)(void *arg), void *now_arg) { QUIC_DEMUX *demux; demux = OPENSSL_zalloc(sizeof(QUIC_DEMUX)); if (demux == NULL) return NULL; demux->net_bio = net_bio; demux->short_conn_id_len = short_conn_id_len; /* We update this if possible when we get a BIO. */ demux->mtu = DEMUX_DEFAULT_MTU; demux->now = now; demux->now_arg = now_arg; if (net_bio != NULL && BIO_dgram_get_local_addr_cap(net_bio) && BIO_dgram_set_local_addr_enable(net_bio, 1)) demux->use_local_addr = 1; return demux; } static void demux_free_urxl(QUIC_URXE_LIST *l) { QUIC_URXE *e, *enext; for (e = ossl_list_urxe_head(l); e != NULL; e = enext) { enext = ossl_list_urxe_next(e); ossl_list_urxe_remove(l, e); OPENSSL_free(e); } } void ossl_quic_demux_free(QUIC_DEMUX *demux) { if (demux == NULL) return; /* Free all URXEs we are holding. */ demux_free_urxl(&demux->urx_free); demux_free_urxl(&demux->urx_pending); OPENSSL_free(demux); } void ossl_quic_demux_set_bio(QUIC_DEMUX *demux, BIO *net_bio) { unsigned int mtu; demux->net_bio = net_bio; if (net_bio != NULL) { /* * Try to determine our MTU if possible. The BIO is not required to * support this, in which case we remain at the last known MTU, or our * initial default. */ mtu = BIO_dgram_get_mtu(net_bio); if (mtu >= QUIC_MIN_INITIAL_DGRAM_LEN) ossl_quic_demux_set_mtu(demux, mtu); /* best effort */ } } int ossl_quic_demux_set_mtu(QUIC_DEMUX *demux, unsigned int mtu) { if (mtu < QUIC_MIN_INITIAL_DGRAM_LEN) return 0; demux->mtu = mtu; return 1; } void ossl_quic_demux_set_default_handler(QUIC_DEMUX *demux, ossl_quic_demux_cb_fn *cb, void *cb_arg) { demux->default_cb = cb; demux->default_cb_arg = cb_arg; } static QUIC_URXE *demux_alloc_urxe(size_t alloc_len) { QUIC_URXE *e; if (alloc_len >= SIZE_MAX - sizeof(QUIC_URXE)) return NULL; e = OPENSSL_malloc(sizeof(QUIC_URXE) + alloc_len); if (e == NULL) return NULL; ossl_list_urxe_init_elem(e); e->alloc_len = alloc_len; e->data_len = 0; return e; } static QUIC_URXE *demux_resize_urxe(QUIC_DEMUX *demux, QUIC_URXE *e, size_t new_alloc_len) { QUIC_URXE *e2, *prev; if (!ossl_assert(e->demux_state == URXE_DEMUX_STATE_FREE)) /* Never attempt to resize a URXE which is not on the free list. */ return NULL; prev = ossl_list_urxe_prev(e); ossl_list_urxe_remove(&demux->urx_free, e); e2 = OPENSSL_realloc(e, sizeof(QUIC_URXE) + new_alloc_len); if (e2 == NULL) { /* Failed to resize, abort. */ if (prev == NULL) ossl_list_urxe_insert_head(&demux->urx_free, e); else ossl_list_urxe_insert_after(&demux->urx_free, prev, e); return NULL; } if (prev == NULL) ossl_list_urxe_insert_head(&demux->urx_free, e2); else ossl_list_urxe_insert_after(&demux->urx_free, prev, e2); e2->alloc_len = new_alloc_len; return e2; } static QUIC_URXE *demux_reserve_urxe(QUIC_DEMUX *demux, QUIC_URXE *e, size_t alloc_len) { return e->alloc_len < alloc_len ? demux_resize_urxe(demux, e, alloc_len) : e; } static int demux_ensure_free_urxe(QUIC_DEMUX *demux, size_t min_num_free) { QUIC_URXE *e; while (ossl_list_urxe_num(&demux->urx_free) < min_num_free) { e = demux_alloc_urxe(demux->mtu); if (e == NULL) return 0; ossl_list_urxe_insert_tail(&demux->urx_free, e); e->demux_state = URXE_DEMUX_STATE_FREE; } return 1; } /* * Receive datagrams from network, placing them into URXEs. * * Returns 1 on success or 0 on failure. * * Precondition: at least one URXE is free * Precondition: there are no pending URXEs */ static int demux_recv(QUIC_DEMUX *demux) { BIO_MSG msg[DEMUX_MAX_MSGS_PER_CALL]; size_t rd, i; QUIC_URXE *urxe = ossl_list_urxe_head(&demux->urx_free), *unext; OSSL_TIME now; /* This should never be called when we have any pending URXE. */ assert(ossl_list_urxe_head(&demux->urx_pending) == NULL); assert(urxe->demux_state == URXE_DEMUX_STATE_FREE); if (demux->net_bio == NULL) /* * If no BIO is plugged in, treat this as no datagram being available. */ return QUIC_DEMUX_PUMP_RES_TRANSIENT_FAIL; /* * Opportunistically receive as many messages as possible in a single * syscall, determined by how many free URXEs are available. */ for (i = 0; i < (ossl_ssize_t)OSSL_NELEM(msg); ++i, urxe = ossl_list_urxe_next(urxe)) { if (urxe == NULL) { /* We need at least one URXE to receive into. */ if (!ossl_assert(i > 0)) return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; break; } /* Ensure the URXE is big enough. */ urxe = demux_reserve_urxe(demux, urxe, demux->mtu); if (urxe == NULL) /* Allocation error, fail. */ return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; /* Ensure we zero any fields added to BIO_MSG at a later date. */ memset(&msg[i], 0, sizeof(BIO_MSG)); msg[i].data = ossl_quic_urxe_data(urxe); msg[i].data_len = urxe->alloc_len; msg[i].peer = &urxe->peer; BIO_ADDR_clear(&urxe->peer); if (demux->use_local_addr) msg[i].local = &urxe->local; else BIO_ADDR_clear(&urxe->local); } ERR_set_mark(); if (!BIO_recvmmsg(demux->net_bio, msg, sizeof(BIO_MSG), i, 0, &rd)) { if (BIO_err_is_non_fatal(ERR_peek_last_error())) { /* Transient error, clear the error and stop. */ ERR_pop_to_mark(); return QUIC_DEMUX_PUMP_RES_TRANSIENT_FAIL; } else { /* Non-transient error, do not clear the error. */ ERR_clear_last_mark(); return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; } } ERR_clear_last_mark(); now = demux->now != NULL ? demux->now(demux->now_arg) : ossl_time_zero(); urxe = ossl_list_urxe_head(&demux->urx_free); for (i = 0; i < rd; ++i, urxe = unext) { unext = ossl_list_urxe_next(urxe); /* Set URXE with actual length of received datagram. */ urxe->data_len = msg[i].data_len; /* Time we received datagram. */ urxe->time = now; /* Move from free list to pending list. */ ossl_list_urxe_remove(&demux->urx_free, urxe); ossl_list_urxe_insert_tail(&demux->urx_pending, urxe); urxe->demux_state = URXE_DEMUX_STATE_PENDING; } return QUIC_DEMUX_PUMP_RES_OK; } /* Extract destination connection ID from the first packet in a datagram. */ static int demux_identify_conn_id(QUIC_DEMUX *demux, QUIC_URXE *e, QUIC_CONN_ID *dst_conn_id) { return ossl_quic_wire_get_pkt_hdr_dst_conn_id(ossl_quic_urxe_data(e), e->data_len, demux->short_conn_id_len, dst_conn_id); } /* * Process a single pending URXE. * Returning 1 on success, 0 on failure. */ static int demux_process_pending_urxe(QUIC_DEMUX *demux, QUIC_URXE *e) { QUIC_CONN_ID dst_conn_id; int dst_conn_id_ok = 0; /* The next URXE we process should be at the head of the pending list. */ if (!ossl_assert(e == ossl_list_urxe_head(&demux->urx_pending))) return 0; assert(e->demux_state == URXE_DEMUX_STATE_PENDING); /* Determine the DCID of the first packet in the datagram. */ dst_conn_id_ok = demux_identify_conn_id(demux, e, &dst_conn_id); ossl_list_urxe_remove(&demux->urx_pending, e); if (demux->default_cb != NULL) { /* * Pass to default handler for routing. The URXE now belongs to the * callback. */ e->demux_state = URXE_DEMUX_STATE_ISSUED; demux->default_cb(e, demux->default_cb_arg, dst_conn_id_ok ? &dst_conn_id : NULL); } else { /* Discard. */ ossl_list_urxe_insert_tail(&demux->urx_free, e); e->demux_state = URXE_DEMUX_STATE_FREE; } return 1; /* keep processing pending URXEs */ } /* Process pending URXEs to generate callbacks. */ static int demux_process_pending_urxl(QUIC_DEMUX *demux) { QUIC_URXE *e; int ret; while ((e = ossl_list_urxe_head(&demux->urx_pending)) != NULL) if ((ret = demux_process_pending_urxe(demux, e)) <= 0) return ret; return 1; } /* * Drain the pending URXE list, processing any pending URXEs by making their * callbacks. If no URXEs are pending, a network read is attempted first. */ int ossl_quic_demux_pump(QUIC_DEMUX *demux) { int ret; if (ossl_list_urxe_head(&demux->urx_pending) == NULL) { ret = demux_ensure_free_urxe(demux, DEMUX_MAX_MSGS_PER_CALL); if (ret != 1) return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; ret = demux_recv(demux); if (ret != QUIC_DEMUX_PUMP_RES_OK) return ret; /* * If demux_recv returned successfully, we should always have something. */ assert(ossl_list_urxe_head(&demux->urx_pending) != NULL); } if ((ret = demux_process_pending_urxl(demux)) <= 0) return QUIC_DEMUX_PUMP_RES_PERMANENT_FAIL; return QUIC_DEMUX_PUMP_RES_OK; } /* Artificially inject a packet into the demuxer for testing purposes. */ int ossl_quic_demux_inject(QUIC_DEMUX *demux, const unsigned char *buf, size_t buf_len, const BIO_ADDR *peer, const BIO_ADDR *local) { int ret; QUIC_URXE *urxe; ret = demux_ensure_free_urxe(demux, 1); if (ret != 1) return 0; urxe = ossl_list_urxe_head(&demux->urx_free); assert(urxe->demux_state == URXE_DEMUX_STATE_FREE); urxe = demux_reserve_urxe(demux, urxe, buf_len); if (urxe == NULL) return 0; memcpy(ossl_quic_urxe_data(urxe), buf, buf_len); urxe->data_len = buf_len; if (peer != NULL) urxe->peer = *peer; else BIO_ADDR_clear(&urxe->peer); if (local != NULL) urxe->local = *local; else BIO_ADDR_clear(&urxe->local); urxe->time = demux->now != NULL ? demux->now(demux->now_arg) : ossl_time_zero(); /* Move from free list to pending list. */ ossl_list_urxe_remove(&demux->urx_free, urxe); ossl_list_urxe_insert_tail(&demux->urx_pending, urxe); urxe->demux_state = URXE_DEMUX_STATE_PENDING; return demux_process_pending_urxl(demux) > 0; } /* Called by our user to return a URXE to the free list. */ void ossl_quic_demux_release_urxe(QUIC_DEMUX *demux, QUIC_URXE *e) { assert(ossl_list_urxe_prev(e) == NULL && ossl_list_urxe_next(e) == NULL); assert(e->demux_state == URXE_DEMUX_STATE_ISSUED); ossl_list_urxe_insert_tail(&demux->urx_free, e); e->demux_state = URXE_DEMUX_STATE_FREE; } void ossl_quic_demux_reinject_urxe(QUIC_DEMUX *demux, QUIC_URXE *e) { assert(ossl_list_urxe_prev(e) == NULL && ossl_list_urxe_next(e) == NULL); assert(e->demux_state == URXE_DEMUX_STATE_ISSUED); ossl_list_urxe_insert_head(&demux->urx_pending, e); e->demux_state = URXE_DEMUX_STATE_PENDING; } int ossl_quic_demux_has_pending(const QUIC_DEMUX *demux) { return ossl_list_urxe_head(&demux->urx_pending) != NULL; }

./openssl/ssl/quic/quic_record_util.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_record_util.h" #include "internal/quic_record_rx.h" #include "internal/quic_record_tx.h" #include "internal/quic_wire_pkt.h" #include "../ssl_local.h" #include <openssl/kdf.h> #include <openssl/core_names.h> /* * QUIC Key Derivation Utilities * ============================= */ int ossl_quic_hkdf_extract(OSSL_LIB_CTX *libctx, const char *propq, const EVP_MD *md, const unsigned char *salt, size_t salt_len, const unsigned char *ikm, size_t ikm_len, unsigned char *out, size_t out_len) { int ret = 0; EVP_KDF *kdf = NULL; EVP_KDF_CTX *kctx = NULL; OSSL_PARAM params[7], *p = params; int mode = EVP_PKEY_HKDEF_MODE_EXTRACT_ONLY; const char *md_name; if ((md_name = EVP_MD_get0_name(md)) == NULL || (kdf = EVP_KDF_fetch(libctx, OSSL_KDF_NAME_HKDF, propq)) == NULL || (kctx = EVP_KDF_CTX_new(kdf)) == NULL) goto err; *p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode); *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST, (char *)md_name, 0); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT, (unsigned char *)salt, salt_len); *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY, (unsigned char *)ikm, ikm_len); *p++ = OSSL_PARAM_construct_end(); ret = EVP_KDF_derive(kctx, out, out_len, params); err: EVP_KDF_CTX_free(kctx); EVP_KDF_free(kdf); return ret; } /* Constants used for key derivation in QUIC v1. */ static const unsigned char quic_client_in_label[] = { 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x20, 0x69, 0x6e /* "client in" */ }; static const unsigned char quic_server_in_label[] = { 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x69, 0x6e /* "server in" */ }; /* Salt used to derive Initial packet protection keys (RFC 9001 Section 5.2). */ static const unsigned char quic_v1_initial_salt[] = { 0x38, 0x76, 0x2c, 0xf7, 0xf5, 0x59, 0x34, 0xb3, 0x4d, 0x17, 0x9a, 0xe6, 0xa4, 0xc8, 0x0c, 0xad, 0xcc, 0xbb, 0x7f, 0x0a }; int ossl_quic_provide_initial_secret(OSSL_LIB_CTX *libctx, const char *propq, const QUIC_CONN_ID *dst_conn_id, int is_server, struct ossl_qrx_st *qrx, struct ossl_qtx_st *qtx) { unsigned char initial_secret[32]; unsigned char client_initial_secret[32], server_initial_secret[32]; unsigned char *rx_secret, *tx_secret; EVP_MD *sha256; if (qrx == NULL && qtx == NULL) return 1; /* Initial encryption always uses SHA-256. */ if ((sha256 = EVP_MD_fetch(libctx, "SHA256", propq)) == NULL) return 0; if (is_server) { rx_secret = client_initial_secret; tx_secret = server_initial_secret; } else { rx_secret = server_initial_secret; tx_secret = client_initial_secret; } /* Derive initial secret from destination connection ID. */ if (!ossl_quic_hkdf_extract(libctx, propq, sha256, quic_v1_initial_salt, sizeof(quic_v1_initial_salt), dst_conn_id->id, dst_conn_id->id_len, initial_secret, sizeof(initial_secret))) goto err; /* Derive "client in" secret. */ if (((qtx != NULL && tx_secret == client_initial_secret) || (qrx != NULL && rx_secret == client_initial_secret)) && !tls13_hkdf_expand_ex(libctx, propq, sha256, initial_secret, quic_client_in_label, sizeof(quic_client_in_label), NULL, 0, client_initial_secret, sizeof(client_initial_secret), 1)) goto err; /* Derive "server in" secret. */ if (((qtx != NULL && tx_secret == server_initial_secret) || (qrx != NULL && rx_secret == server_initial_secret)) && !tls13_hkdf_expand_ex(libctx, propq, sha256, initial_secret, quic_server_in_label, sizeof(quic_server_in_label), NULL, 0, server_initial_secret, sizeof(server_initial_secret), 1)) goto err; /* Setup RX EL. Initial encryption always uses AES-128-GCM. */ if (qrx != NULL && !ossl_qrx_provide_secret(qrx, QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, sha256, rx_secret, sizeof(server_initial_secret))) goto err; /* * ossl_qrx_provide_secret takes ownership of our ref to SHA256, so if we * are initialising both sides, get a new ref for the following call for the * TX side. */ if (qrx != NULL && qtx != NULL && !EVP_MD_up_ref(sha256)) { sha256 = NULL; goto err; } /* Setup TX cipher. */ if (qtx != NULL && !ossl_qtx_provide_secret(qtx, QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, sha256, tx_secret, sizeof(server_initial_secret))) goto err; return 1; err: EVP_MD_free(sha256); return 0; } /* * QUIC Record Layer Ciphersuite Info * ================================== */ struct suite_info { const char *cipher_name, *md_name; uint32_t secret_len, cipher_key_len, cipher_iv_len, cipher_tag_len; uint32_t hdr_prot_key_len, hdr_prot_cipher_id; uint64_t max_pkt, max_forged_pkt; }; static const struct suite_info suite_aes128gcm = { "AES-128-GCM", "SHA256", 32, 16, 12, 16, 16, QUIC_HDR_PROT_CIPHER_AES_128, ((uint64_t)1) << 23, /* Limits as prescribed by RFC 9001 */ ((uint64_t)1) << 52, }; static const struct suite_info suite_aes256gcm = { "AES-256-GCM", "SHA384", 48, 32, 12, 16, 32, QUIC_HDR_PROT_CIPHER_AES_256, ((uint64_t)1) << 23, /* Limits as prescribed by RFC 9001 */ ((uint64_t)1) << 52, }; static const struct suite_info suite_chacha20poly1305 = { "ChaCha20-Poly1305", "SHA256", 32, 32, 12, 16, 32, QUIC_HDR_PROT_CIPHER_CHACHA, /* Do not use UINT64_MAX here as this represents an invalid value */ UINT64_MAX - 1, /* No applicable limit for this suite (RFC 9001) */ ((uint64_t)1) << 36, /* Limit as prescribed by RFC 9001 */ }; static const struct suite_info *get_suite(uint32_t suite_id) { switch (suite_id) { case QRL_SUITE_AES128GCM: return &suite_aes128gcm; case QRL_SUITE_AES256GCM: return &suite_aes256gcm; case QRL_SUITE_CHACHA20POLY1305: return &suite_chacha20poly1305; default: return NULL; } } const char *ossl_qrl_get_suite_cipher_name(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->cipher_name : NULL; } const char *ossl_qrl_get_suite_md_name(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->md_name : NULL; } uint32_t ossl_qrl_get_suite_secret_len(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->secret_len : 0; } uint32_t ossl_qrl_get_suite_cipher_key_len(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->cipher_key_len : 0; } uint32_t ossl_qrl_get_suite_cipher_iv_len(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->cipher_iv_len : 0; } uint32_t ossl_qrl_get_suite_cipher_tag_len(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->cipher_tag_len : 0; } uint32_t ossl_qrl_get_suite_hdr_prot_cipher_id(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->hdr_prot_cipher_id : 0; } uint32_t ossl_qrl_get_suite_hdr_prot_key_len(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->hdr_prot_key_len : 0; } uint64_t ossl_qrl_get_suite_max_pkt(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->max_pkt : UINT64_MAX; } uint64_t ossl_qrl_get_suite_max_forged_pkt(uint32_t suite_id) { const struct suite_info *c = get_suite(suite_id); return c != NULL ? c->max_forged_pkt : UINT64_MAX; }

./openssl/ssl/quic/quic_tls.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/ssl.h> #include "internal/recordmethod.h" #include "internal/quic_tls.h" #include "../ssl_local.h" #include "internal/quic_error.h" #define QUIC_TLS_FATAL(rl, ad, err) \ do { \ if ((rl) != NULL) (rl)->alert = (ad); \ ERR_raise(ERR_LIB_SSL, (err)); \ if ((rl) != NULL) (rl)->qtls->inerror = 1; \ } while(0) struct quic_tls_st { QUIC_TLS_ARGS args; /* * Transport parameters which client should send. Buffer lifetime must * exceed the lifetime of the QUIC_TLS object. */ const unsigned char *local_transport_params; size_t local_transport_params_len; ERR_STATE *error_state; /* * QUIC error code (usually in the TLS Alert-mapped CRYPTO_ERR range). Valid * only if inerror is 1. */ uint64_t error_code; /* * Error message with static storage duration. Valid only if inerror is 1. * Should be suitable for encapsulation in a CONNECTION_CLOSE frame. */ const char *error_msg; /* Whether our SSL object for TLS has been configured for use in QUIC */ unsigned int configured : 1; /* Set if we have hit any error state */ unsigned int inerror : 1; /* Set if the handshake has completed */ unsigned int complete : 1; }; struct ossl_record_layer_st { QUIC_TLS *qtls; /* Protection level */ int level; /* Only used for retry flags */ BIO *dummybio; /* Number of bytes written so far if we are part way through a write */ size_t written; /* If we are part way through a write, a copy of the template */ OSSL_RECORD_TEMPLATE template; /* * If we hit an error, what alert code should be used */ int alert; /* Amount of crypto stream data we read in the last call to quic_read_record */ size_t recread; /* Amount of crypto stream data read but not yet released */ size_t recunreleased; /* Callbacks */ OSSL_FUNC_rlayer_msg_callback_fn *msg_callback; void *cbarg; }; static int quic_set1_bio(OSSL_RECORD_LAYER *rl, BIO *bio); static int quic_free(OSSL_RECORD_LAYER *r); static int quic_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers, int role, int direction, int level, uint16_t epoch, unsigned char *secret, size_t secretlen, unsigned char *key, size_t keylen, unsigned char *iv, size_t ivlen, unsigned char *mackey, size_t mackeylen, const EVP_CIPHER *ciph, size_t taglen, int mactype, const EVP_MD *md, COMP_METHOD *comp, const EVP_MD *kdfdigest, BIO *prev, BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer, const OSSL_PARAM *settings, const OSSL_PARAM *options, const OSSL_DISPATCH *fns, void *cbarg, void *rlarg, OSSL_RECORD_LAYER **retrl) { OSSL_RECORD_LAYER *rl = OPENSSL_zalloc(sizeof(*rl)); uint32_t enc_level; int qdir; uint32_t suite_id = 0; if (rl == NULL) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } rl->qtls = (QUIC_TLS *)rlarg; rl->level = level; if (!quic_set1_bio(rl, transport)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } rl->cbarg = cbarg; *retrl = rl; if (fns != NULL) { for (; fns->function_id != 0; fns++) { switch (fns->function_id) { break; case OSSL_FUNC_RLAYER_MSG_CALLBACK: rl->msg_callback = OSSL_FUNC_rlayer_msg_callback(fns); break; default: /* Just ignore anything we don't understand */ break; } } } switch (level) { case OSSL_RECORD_PROTECTION_LEVEL_NONE: return 1; case OSSL_RECORD_PROTECTION_LEVEL_EARLY: enc_level = QUIC_ENC_LEVEL_0RTT; break; case OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE: enc_level = QUIC_ENC_LEVEL_HANDSHAKE; break; case OSSL_RECORD_PROTECTION_LEVEL_APPLICATION: enc_level = QUIC_ENC_LEVEL_1RTT; break; default: QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (direction == OSSL_RECORD_DIRECTION_READ) qdir = 0; else qdir = 1; if (EVP_CIPHER_is_a(ciph, "AES-128-GCM")) { suite_id = QRL_SUITE_AES128GCM; } else if (EVP_CIPHER_is_a(ciph, "AES-256-GCM")) { suite_id = QRL_SUITE_AES256GCM; } else if (EVP_CIPHER_is_a(ciph, "CHACHA20-POLY1305")) { suite_id = QRL_SUITE_CHACHA20POLY1305; } else { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, SSL_R_UNKNOWN_CIPHER_TYPE); goto err; } /* We pass a ref to the md in a successful yield_secret_cb call */ /* TODO(QUIC FUTURE): This cast is horrible. We should try and remove it */ if (!EVP_MD_up_ref((EVP_MD *)kdfdigest)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); goto err; } if (!rl->qtls->args.yield_secret_cb(enc_level, qdir, suite_id, (EVP_MD *)kdfdigest, secret, secretlen, rl->qtls->args.yield_secret_cb_arg)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); EVP_MD_free((EVP_MD *)kdfdigest); goto err; } return 1; err: *retrl = NULL; quic_free(rl); return 0; } static int quic_free(OSSL_RECORD_LAYER *rl) { if (rl == NULL) return 1; BIO_free(rl->dummybio); OPENSSL_free(rl); return 1; } static int quic_unprocessed_read_pending(OSSL_RECORD_LAYER *rl) { /* * Read ahead isn't really a thing for QUIC so we never have unprocessed * data pending */ return 0; } static int quic_processed_read_pending(OSSL_RECORD_LAYER *rl) { /* * This is currently only ever used by: * - SSL_has_pending() * - to check whether we have more records that we want to supply to the * upper layers * * We only ever supply 1 record at a time to the upper layers, and * SSL_has_pending() will go via the QUIC method not the TLS method so that * use case doesn't apply here. * Therefore we can ignore this for now and always return 0. We might * eventually want to change this to check in the receive buffers to see if * we have any more data pending. */ return 0; } static size_t quic_get_max_records(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len, size_t maxfrag, size_t *preffrag) { return 1; } static int quic_write_records(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *template, size_t numtempl) { size_t consumed; unsigned char alert; if (!ossl_assert(numtempl == 1)) { /* How could this be? quic_get_max_records() always returns 1 */ QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } BIO_clear_retry_flags(rl->dummybio); if (rl->msg_callback != NULL) { unsigned char dummyrec[SSL3_RT_HEADER_LENGTH]; /* * For the purposes of the callback we "pretend" to be normal TLS, * and manufacture a dummy record header */ dummyrec[0] = (rl->level == OSSL_RECORD_PROTECTION_LEVEL_NONE) ? template->type : SSL3_RT_APPLICATION_DATA; dummyrec[1] = (unsigned char)((template->version >> 8) & 0xff); dummyrec[2] = (unsigned char)(template->version & 0xff); /* * We assume that buflen is always <= UINT16_MAX. Since this is * generated by libssl itself we actually expect it to never * exceed SSL3_RT_MAX_PLAIN_LENGTH - so it should be a safe * assumption */ dummyrec[3] = (unsigned char)((template->buflen >> 8) & 0xff); dummyrec[4] = (unsigned char)(template->buflen & 0xff); rl->msg_callback(1, TLS1_3_VERSION, SSL3_RT_HEADER, dummyrec, SSL3_RT_HEADER_LENGTH, rl->cbarg); if (rl->level != OSSL_RECORD_PROTECTION_LEVEL_NONE) { rl->msg_callback(1, TLS1_3_VERSION, SSL3_RT_INNER_CONTENT_TYPE, &template->type, 1, rl->cbarg); } } switch (template->type) { case SSL3_RT_ALERT: if (template->buflen != 2) { /* * We assume that libssl always sends both bytes of an alert to * us in one go, and never fragments it. If we ever get more * or less bytes than exactly 2 then this is very unexpected. */ QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_VALUE); return OSSL_RECORD_RETURN_FATAL; } /* * Byte 0 is the alert level (we ignore it) and byte 1 is the alert * description that we are actually interested in. */ alert = template->buf[1]; if (!rl->qtls->args.alert_cb(rl->qtls->args.alert_cb_arg, alert)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } break; case SSL3_RT_HANDSHAKE: /* * We expect this to only fail on some fatal error (e.g. malloc * failure) */ if (!rl->qtls->args.crypto_send_cb(template->buf + rl->written, template->buflen - rl->written, &consumed, rl->qtls->args.crypto_send_cb_arg)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } /* * We might have written less than we wanted to if we have filled the * send stream buffer. */ if (consumed + rl->written != template->buflen) { if (!ossl_assert(consumed + rl->written < template->buflen)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } /* * We've not written everything we wanted to. Take a copy of the * template, remember how much we wrote so far and signal a retry. * The buffer supplied in the template is guaranteed to be the same * on a retry for handshake data */ rl->written += consumed; rl->template = *template; BIO_set_retry_write(rl->dummybio); return OSSL_RECORD_RETURN_RETRY; } rl->written = 0; break; default: /* Anything else is unexpected and an error */ QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } return OSSL_RECORD_RETURN_SUCCESS; } static int quic_retry_write_records(OSSL_RECORD_LAYER *rl) { return quic_write_records(rl, &rl->template, 1); } static int quic_read_record(OSSL_RECORD_LAYER *rl, void **rechandle, int *rversion, uint8_t *type, const unsigned char **data, size_t *datalen, uint16_t *epoch, unsigned char *seq_num) { if (rl->recread != 0 || rl->recunreleased != 0) return OSSL_RECORD_RETURN_FATAL; BIO_clear_retry_flags(rl->dummybio); if (!rl->qtls->args.crypto_recv_rcd_cb(data, datalen, rl->qtls->args.crypto_recv_rcd_cb_arg)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } if (*datalen == 0) { BIO_set_retry_read(rl->dummybio); return OSSL_RECORD_RETURN_RETRY; } *rechandle = rl; *rversion = TLS1_3_VERSION; *type = SSL3_RT_HANDSHAKE; rl->recread = rl->recunreleased = *datalen; /* epoch/seq_num are not relevant for TLS */ if (rl->msg_callback != NULL) { unsigned char dummyrec[SSL3_RT_HEADER_LENGTH]; /* * For the purposes of the callback we "pretend" to be normal TLS, * and manufacture a dummy record header */ dummyrec[0] = (rl->level == OSSL_RECORD_PROTECTION_LEVEL_NONE) ? SSL3_RT_HANDSHAKE : SSL3_RT_APPLICATION_DATA; dummyrec[1] = (unsigned char)((TLS1_2_VERSION >> 8) & 0xff); dummyrec[2] = (unsigned char)(TLS1_2_VERSION & 0xff); /* * *datalen will always fit into 2 bytes because our original buffer * size is less than that. */ dummyrec[3] = (unsigned char)((*datalen >> 8) & 0xff); dummyrec[4] = (unsigned char)(*datalen & 0xff); rl->msg_callback(0, TLS1_3_VERSION, SSL3_RT_HEADER, dummyrec, SSL3_RT_HEADER_LENGTH, rl->cbarg); rl->msg_callback(0, TLS1_3_VERSION, SSL3_RT_INNER_CONTENT_TYPE, type, 1, rl->cbarg); } return OSSL_RECORD_RETURN_SUCCESS; } static int quic_release_record(OSSL_RECORD_LAYER *rl, void *rechandle, size_t length) { if (!ossl_assert(rl->recread > 0) || !ossl_assert(rl->recunreleased <= rl->recread) || !ossl_assert(rl == rechandle) || !ossl_assert(length <= rl->recunreleased)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } rl->recunreleased -= length; if (rl->recunreleased > 0) return OSSL_RECORD_RETURN_SUCCESS; if (!rl->qtls->args.crypto_release_rcd_cb(rl->recread, rl->qtls->args.crypto_release_rcd_cb_arg)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return OSSL_RECORD_RETURN_FATAL; } rl->recread = 0; return OSSL_RECORD_RETURN_SUCCESS; } static int quic_get_alert_code(OSSL_RECORD_LAYER *rl) { return rl->alert; } static int quic_set_protocol_version(OSSL_RECORD_LAYER *rl, int version) { /* We only support TLSv1.3, so its bad if we negotiate anything else */ if (!ossl_assert(version == TLS1_3_VERSION)) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR); return 0; } return 1; } static void quic_set_plain_alerts(OSSL_RECORD_LAYER *rl, int allow) { /* We don't care */ } static void quic_set_first_handshake(OSSL_RECORD_LAYER *rl, int first) { /* We don't care */ } static void quic_set_max_pipelines(OSSL_RECORD_LAYER *rl, size_t max_pipelines) { /* We don't care */ } static void quic_get_state(OSSL_RECORD_LAYER *rl, const char **shortstr, const char **longstr) { /* * According to the docs, valid read state strings are: "RH"/"read header", * "RB"/"read body", and "unknown"/"unknown". We don't read records in quite * that way, so we report every "normal" state as "read header". In the * event of error then we report "unknown". */ if (rl->qtls->inerror) { if (shortstr != NULL) *shortstr = "unknown"; if (longstr != NULL) *longstr = "unknown"; } else { if (shortstr != NULL) *shortstr = "RH"; if (longstr != NULL) *longstr = "read header"; } } static int quic_set_options(OSSL_RECORD_LAYER *rl, const OSSL_PARAM *options) { /* * We don't support any options yet - but we might do at some point so * this could be useful. */ return 1; } static const COMP_METHOD *quic_get_compression(OSSL_RECORD_LAYER *rl) { /* We only support TLSv1.3 which doesn't have compression */ return NULL; } static void quic_set_max_frag_len(OSSL_RECORD_LAYER *rl, size_t max_frag_len) { /* This really doesn't make any sense for QUIC. Ignore it */ } static int quic_alloc_buffers(OSSL_RECORD_LAYER *rl) { /* * This is a hint only. We don't support it (yet), so just ignore the * request */ return 1; } static int quic_free_buffers(OSSL_RECORD_LAYER *rl) { /* * This is a hint only. We don't support it (yet), so just ignore the * request */ return 1; } static int quic_set1_bio(OSSL_RECORD_LAYER *rl, BIO *bio) { if (bio != NULL && !BIO_up_ref(bio)) return 0; BIO_free(rl->dummybio); rl->dummybio = bio; return 1; } /* * Never called functions * * Due to the way we are configured and used we never expect any of the next set * of functions to be called. Therefore we set them to always fail. */ static size_t quic_app_data_pending(OSSL_RECORD_LAYER *rl) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return (size_t)ossl_assert(0); } static size_t quic_get_max_record_overhead(OSSL_RECORD_LAYER *rl) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return (size_t)ossl_assert(0); } static int quic_increment_sequence_ctr(OSSL_RECORD_LAYER *rl) { QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED); return ossl_assert(0); } /* End of never called functions */ static const OSSL_RECORD_METHOD quic_tls_record_method = { quic_new_record_layer, quic_free, quic_unprocessed_read_pending, quic_processed_read_pending, quic_app_data_pending, /* Never called */ quic_get_max_records, quic_write_records, quic_retry_write_records, quic_read_record, quic_release_record, quic_get_alert_code, quic_set1_bio, quic_set_protocol_version, quic_set_plain_alerts, quic_set_first_handshake, quic_set_max_pipelines, NULL, /* set_in_init: Optional - we don't need it */ quic_get_state, quic_set_options, quic_get_compression, quic_set_max_frag_len, quic_get_max_record_overhead, /* Never called */ quic_increment_sequence_ctr, /* Never called */ quic_alloc_buffers, quic_free_buffers }; static int add_transport_params_cb(SSL *s, unsigned int ext_type, unsigned int context, const unsigned char **out, size_t *outlen, X509 *x, size_t chainidx, int *al, void *add_arg) { QUIC_TLS *qtls = add_arg; *out = qtls->local_transport_params; *outlen = qtls->local_transport_params_len; return 1; } static void free_transport_params_cb(SSL *s, unsigned int ext_type, unsigned int context, const unsigned char *out, void *add_arg) { } static int parse_transport_params_cb(SSL *s, unsigned int ext_type, unsigned int context, const unsigned char *in, size_t inlen, X509 *x, size_t chainidx, int *al, void *parse_arg) { QUIC_TLS *qtls = parse_arg; return qtls->args.got_transport_params_cb(in, inlen, qtls->args.got_transport_params_cb_arg); } QUIC_TLS *ossl_quic_tls_new(const QUIC_TLS_ARGS *args) { QUIC_TLS *qtls; if (args->crypto_send_cb == NULL || args->crypto_recv_rcd_cb == NULL || args->crypto_release_rcd_cb == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER); return NULL; } qtls = OPENSSL_zalloc(sizeof(*qtls)); if (qtls == NULL) return NULL; if ((qtls->error_state = OSSL_ERR_STATE_new()) == NULL) { OPENSSL_free(qtls); return NULL; } qtls->args = *args; return qtls; } void ossl_quic_tls_free(QUIC_TLS *qtls) { if (qtls == NULL) return; OSSL_ERR_STATE_free(qtls->error_state); OPENSSL_free(qtls); } static int raise_error(QUIC_TLS *qtls, uint64_t error_code, const char *error_msg, const char *src_file, int src_line, const char *src_func) { /* * When QTLS fails, add a "cover letter" error with information, potentially * with any underlying libssl errors underneath it (but our cover error may * be the only error in some cases). Then capture this into an ERR_STATE so * we can report it later if need be when the QUIC_CHANNEL asks for it. */ ERR_new(); ERR_set_debug(src_file, src_line, src_func); ERR_set_error(ERR_LIB_SSL, SSL_R_QUIC_HANDSHAKE_LAYER_ERROR, "handshake layer error, error code %llu (0x%llx) (\"%s\")", error_code, error_code, error_msg); OSSL_ERR_STATE_save_to_mark(qtls->error_state); /* * We record the error information reported via the QUIC protocol * separately. */ qtls->error_code = error_code; qtls->error_msg = error_msg; qtls->inerror = 1; ERR_pop_to_mark(); return 0; } #define RAISE_ERROR(qtls, error_code, error_msg) \ raise_error((qtls), (error_code), (error_msg), \ OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC) #define RAISE_INTERNAL_ERROR(qtls) \ RAISE_ERROR((qtls), QUIC_ERR_INTERNAL_ERROR, "internal error") int ossl_quic_tls_tick(QUIC_TLS *qtls) { int ret, err; const unsigned char *alpn; unsigned int alpnlen; if (qtls->inerror) return 0; /* * SSL_get_error does not truly know what the cause of an SSL_read failure * is and to some extent guesses based on contextual information. In * particular, if there is _any_ ERR on the error stack, SSL_ERROR_SSL or * SSL_ERROR_SYSCALL will be returned no matter what and there is no * possibility of SSL_ERROR_WANT_READ/WRITE being returned, even if that was * the actual cause of the SSL_read() failure. * * This means that ordinarily, the below code might not work right if the * application has any ERR on the error stack. In order to make this code * perform correctly regardless of prior ERR state, we use a variant of * SSL_get_error() which ignores the error stack. However, some ERRs are * raised by SSL_read() and actually indicate that something has gone wrong * during the call to SSL_read(). We therefore adopt a strategy of marking * the ERR stack and seeing if any errors get appended during the call to * SSL_read(). If they are, we assume SSL_read() has raised an error and * that we should use normal SSL_get_error() handling. * * NOTE: Ensure all escape paths from this function call * ERR_clear_to_mark(). The RAISE macros handle this in failure cases. */ ERR_set_mark(); if (!qtls->configured) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(qtls->args.s); SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(sc); BIO *nullbio; /* * No matter how the user has configured us, there are certain * requirements for QUIC-TLS that we enforce */ /* ALPN is a requirement for QUIC and must be set */ if (qtls->args.is_server) { if (sctx->ext.alpn_select_cb == NULL) return RAISE_INTERNAL_ERROR(qtls); } else { if (sc->ext.alpn == NULL || sc->ext.alpn_len == 0) return RAISE_ERROR(qtls, QUIC_ERR_CRYPTO_NO_APP_PROTO, "ALPN must be configured when using QUIC"); } if (!SSL_set_min_proto_version(qtls->args.s, TLS1_3_VERSION)) return RAISE_INTERNAL_ERROR(qtls); SSL_clear_options(qtls->args.s, SSL_OP_ENABLE_MIDDLEBOX_COMPAT); ossl_ssl_set_custom_record_layer(sc, &quic_tls_record_method, qtls); if (!ossl_tls_add_custom_ext_intern(NULL, &sc->cert->custext, qtls->args.is_server ? ENDPOINT_SERVER : ENDPOINT_CLIENT, TLSEXT_TYPE_quic_transport_parameters, SSL_EXT_TLS1_3_ONLY | SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, add_transport_params_cb, free_transport_params_cb, qtls, parse_transport_params_cb, qtls)) return RAISE_INTERNAL_ERROR(qtls); nullbio = BIO_new(BIO_s_null()); if (nullbio == NULL) return RAISE_INTERNAL_ERROR(qtls); /* * Our custom record layer doesn't use the BIO - but libssl generally * expects one to be present. */ SSL_set_bio(qtls->args.s, nullbio, nullbio); if (qtls->args.is_server) SSL_set_accept_state(qtls->args.s); else SSL_set_connect_state(qtls->args.s); qtls->configured = 1; } if (qtls->complete) /* * There should never be app data to read, but calling SSL_read() will * ensure any post-handshake messages are processed. */ ret = SSL_read(qtls->args.s, NULL, 0); else ret = SSL_do_handshake(qtls->args.s); if (ret <= 0) { err = ossl_ssl_get_error(qtls->args.s, ret, /*check_err=*/ERR_count_to_mark() > 0); switch (err) { case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_CLIENT_HELLO_CB: case SSL_ERROR_WANT_X509_LOOKUP: case SSL_ERROR_WANT_RETRY_VERIFY: ERR_pop_to_mark(); return 1; default: return RAISE_INTERNAL_ERROR(qtls); } } if (!qtls->complete) { /* Validate that we have ALPN */ SSL_get0_alpn_selected(qtls->args.s, &alpn, &alpnlen); if (alpn == NULL || alpnlen == 0) return RAISE_ERROR(qtls, QUIC_ERR_CRYPTO_NO_APP_PROTO, "no application protocol negotiated"); qtls->complete = 1; ERR_pop_to_mark(); return qtls->args.handshake_complete_cb(qtls->args.handshake_complete_cb_arg); } ERR_pop_to_mark(); return 1; } int ossl_quic_tls_set_transport_params(QUIC_TLS *qtls, const unsigned char *transport_params, size_t transport_params_len) { qtls->local_transport_params = transport_params; qtls->local_transport_params_len = transport_params_len; return 1; } int ossl_quic_tls_get_error(QUIC_TLS *qtls, uint64_t *error_code, const char **error_msg, ERR_STATE **error_state) { if (qtls->inerror) { *error_code = qtls->error_code; *error_msg = qtls->error_msg; *error_state = qtls->error_state; } return qtls->inerror; } /* * Returns true if the last handshake record message we processed was a * CertificateRequest */ int ossl_quic_tls_is_cert_request(QUIC_TLS *qtls) { SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(qtls->args.s); return sc->s3.tmp.message_type == SSL3_MT_CERTIFICATE_REQUEST; } /* * Returns true if the last session associated with the connection has an * invalid max_early_data value for QUIC. */ int ossl_quic_tls_has_bad_max_early_data(QUIC_TLS *qtls) { uint32_t max_early_data = SSL_get0_session(qtls->args.s)->ext.max_early_data; /* * If max_early_data was present we always ensure a non-zero value is * stored in the session for QUIC. Therefore if max_early_data == 0 here * we can be confident that it was not present in the NewSessionTicket */ return max_early_data != 0xffffffff && max_early_data != 0; }

./openssl/ssl/quic/quic_types.c

/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_types.h" #include <openssl/rand.h> #include <openssl/err.h> int ossl_quic_gen_rand_conn_id(OSSL_LIB_CTX *libctx, size_t len, QUIC_CONN_ID *cid) { if (len > QUIC_MAX_CONN_ID_LEN) return 0; cid->id_len = (unsigned char)len; if (RAND_bytes_ex(libctx, cid->id, len, len * 8) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_RAND_LIB); cid->id_len = 0; return 0; } return 1; }

./openssl/ssl/quic/quic_srtm.c

/* * Copyright 2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_srtm.h" #include "internal/common.h" #include <openssl/lhash.h> #include <openssl/core_names.h> #include <openssl/rand.h> /* * QUIC Stateless Reset Token Manager * ================================== */ typedef struct srtm_item_st SRTM_ITEM; #define BLINDED_SRT_LEN 16 DEFINE_LHASH_OF_EX(SRTM_ITEM); /* * The SRTM is implemented using two LHASH instances, one matching opaque pointers to * an item structure, and another matching a SRT-derived value to an item * structure. Multiple items with different seq_num values under a given opaque, * and duplicate SRTs, are handled using sorted singly-linked lists. * * The O(n) insert and lookup performance is tolerated on the basis that the * total number of entries for a given opaque (total number of extant CIDs for a * connection) should be quite small, and the QUIC protocol allows us to place a * hard limit on this via the active_connection_id_limit TPARAM. Thus there is * no risk of a large number of SRTs needing to be registered under a given * opaque. * * It is expected one SRTM will exist per QUIC_PORT and track all SRTs across * all connections for that QUIC_PORT. */ struct srtm_item_st { SRTM_ITEM *next_by_srt_blinded; /* SORT BY opaque DESC */ SRTM_ITEM *next_by_seq_num; /* SORT BY seq_num DESC */ void *opaque; /* \__ unique identity for item */ uint64_t seq_num; /* / */ QUIC_STATELESS_RESET_TOKEN srt; unsigned char srt_blinded[BLINDED_SRT_LEN]; /* H(srt) */ #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION uint32_t debug_token; #endif }; struct quic_srtm_st { /* Crypto context used to calculate blinded SRTs H(srt). */ EVP_CIPHER_CTX *blind_ctx; /* kept with key */ LHASH_OF(SRTM_ITEM) *items_fwd; /* (opaque) -> SRTM_ITEM */ LHASH_OF(SRTM_ITEM) *items_rev; /* (H(srt)) -> SRTM_ITEM */ /* * Monotonically transitions to 1 in event of allocation failure. The only * valid operation on such an object is to free it. */ unsigned int alloc_failed : 1; }; static unsigned long items_fwd_hash(const SRTM_ITEM *item) { return (unsigned long)(uintptr_t)item->opaque; } static int items_fwd_cmp(const SRTM_ITEM *a, const SRTM_ITEM *b) { return a->opaque != b->opaque; } static unsigned long items_rev_hash(const SRTM_ITEM *item) { /* * srt_blinded has already been through a crypto-grade hash function, so we * can just use bits from that. */ unsigned long l; memcpy(&l, item->srt_blinded, sizeof(l)); return l; } static int items_rev_cmp(const SRTM_ITEM *a, const SRTM_ITEM *b) { /* * We don't need to use CRYPTO_memcmp here as the relationship of * srt_blinded to srt is already cryptographically obfuscated. */ return memcmp(a->srt_blinded, b->srt_blinded, sizeof(a->srt_blinded)); } static int srtm_check_lh(QUIC_SRTM *srtm, LHASH_OF(SRTM_ITEM) *lh) { if (lh_SRTM_ITEM_error(lh)) { srtm->alloc_failed = 1; return 0; } return 1; } QUIC_SRTM *ossl_quic_srtm_new(OSSL_LIB_CTX *libctx, const char *propq) { QUIC_SRTM *srtm = NULL; unsigned char key[16]; EVP_CIPHER *ecb = NULL; if (RAND_priv_bytes_ex(libctx, key, sizeof(key), sizeof(key) * 8) != 1) goto err; if ((srtm = OPENSSL_zalloc(sizeof(*srtm))) == NULL) return NULL; /* Use AES-128-ECB as a permutation over 128-bit SRTs. */ if ((ecb = EVP_CIPHER_fetch(libctx, "AES-128-ECB", propq)) == NULL) goto err; if ((srtm->blind_ctx = EVP_CIPHER_CTX_new()) == NULL) goto err; if (!EVP_EncryptInit_ex2(srtm->blind_ctx, ecb, key, NULL, NULL)) goto err; EVP_CIPHER_free(ecb); ecb = NULL; /* Create mappings. */ if ((srtm->items_fwd = lh_SRTM_ITEM_new(items_fwd_hash, items_fwd_cmp)) == NULL || (srtm->items_rev = lh_SRTM_ITEM_new(items_rev_hash, items_rev_cmp)) == NULL) goto err; return srtm; err: /* * No cleansing of key needed as blinding exists only for side channel * mitigation. */ ossl_quic_srtm_free(srtm); EVP_CIPHER_free(ecb); return NULL; } static void srtm_free_each(SRTM_ITEM *ihead) { SRTM_ITEM *inext, *item = ihead; for (item = item->next_by_seq_num; item != NULL; item = inext) { inext = item->next_by_seq_num; OPENSSL_free(item); } OPENSSL_free(ihead); } void ossl_quic_srtm_free(QUIC_SRTM *srtm) { if (srtm == NULL) return; lh_SRTM_ITEM_free(srtm->items_rev); if (srtm->items_fwd != NULL) { lh_SRTM_ITEM_doall(srtm->items_fwd, srtm_free_each); lh_SRTM_ITEM_free(srtm->items_fwd); } EVP_CIPHER_CTX_free(srtm->blind_ctx); OPENSSL_free(srtm); } /* * Find a SRTM_ITEM by (opaque, seq_num). Returns NULL if no match. * If head is non-NULL, writes the head of the relevant opaque list to *head if * there is one. * If prev is non-NULL, writes the previous node to *prev or NULL if it is * the first item. */ static SRTM_ITEM *srtm_find(QUIC_SRTM *srtm, void *opaque, uint64_t seq_num, SRTM_ITEM **head_p, SRTM_ITEM **prev_p) { SRTM_ITEM key, *item = NULL, *prev = NULL; key.opaque = opaque; item = lh_SRTM_ITEM_retrieve(srtm->items_fwd, &key); if (head_p != NULL) *head_p = item; for (; item != NULL; prev = item, item = item->next_by_seq_num) if (item->seq_num == seq_num) { break; } else if (item->seq_num < seq_num) { /* * List is sorted in descending order so there can't be any match * after this. */ item = NULL; break; } if (prev_p != NULL) *prev_p = prev; return item; } /* * Inserts a SRTM_ITEM into the singly-linked by-sequence-number linked list. * The new head pointer is written to *new_head (which may or may not be * unchanged). */ static void sorted_insert_seq_num(SRTM_ITEM *head, SRTM_ITEM *item, SRTM_ITEM **new_head) { uint64_t seq_num = item->seq_num; SRTM_ITEM *cur = head, **fixup = new_head; *new_head = head; while (cur != NULL && cur->seq_num > seq_num) { fixup = &cur->next_by_seq_num; cur = cur->next_by_seq_num; } item->next_by_seq_num = *fixup; *fixup = item; } /* * Inserts a SRTM_ITEM into the singly-linked by-SRT list. * The new head pointer is written to *new_head (which may or may not be * unchanged). */ static void sorted_insert_srt(SRTM_ITEM *head, SRTM_ITEM *item, SRTM_ITEM **new_head) { uintptr_t opaque = (uintptr_t)item->opaque; SRTM_ITEM *cur = head, **fixup = new_head; *new_head = head; while (cur != NULL && (uintptr_t)cur->opaque > opaque) { fixup = &cur->next_by_srt_blinded; cur = cur->next_by_srt_blinded; } item->next_by_srt_blinded = *fixup; *fixup = item; } /* * Computes the blinded SRT value used for internal lookup for side channel * mitigation purposes. We compute this once as a cached value when an SRTM_ITEM * is formed. */ static int srtm_compute_blinded(QUIC_SRTM *srtm, SRTM_ITEM *item, const QUIC_STATELESS_RESET_TOKEN *token) { int outl = 0; /* * We use AES-128-ECB as a permutation using a random key to facilitate * blinding for side-channel purposes. Encrypt the token as a single AES * block. */ if (!EVP_EncryptUpdate(srtm->blind_ctx, item->srt_blinded, &outl, (const unsigned char *)token, sizeof(*token))) return 0; if (!ossl_assert(outl == sizeof(*token))) return 0; return 1; } int ossl_quic_srtm_add(QUIC_SRTM *srtm, void *opaque, uint64_t seq_num, const QUIC_STATELESS_RESET_TOKEN *token) { SRTM_ITEM *item = NULL, *head = NULL, *new_head, *r_item; if (srtm->alloc_failed) return 0; /* (opaque, seq_num) duplicates not allowed */ if ((item = srtm_find(srtm, opaque, seq_num, &head, NULL)) != NULL) return 0; if ((item = OPENSSL_zalloc(sizeof(*item))) == NULL) return 0; item->opaque = opaque; item->seq_num = seq_num; item->srt = *token; if (!srtm_compute_blinded(srtm, item, &item->srt)) { OPENSSL_free(item); return 0; } /* Add to forward mapping. */ if (head == NULL) { /* First item under this opaque */ lh_SRTM_ITEM_insert(srtm->items_fwd, item); if (!srtm_check_lh(srtm, srtm->items_fwd)) { OPENSSL_free(item); return 0; } } else { sorted_insert_seq_num(head, item, &new_head); if (new_head != head) { /* head changed, update in lhash */ lh_SRTM_ITEM_insert(srtm->items_fwd, new_head); if (!srtm_check_lh(srtm, srtm->items_fwd)) { OPENSSL_free(item); return 0; } } } /* Add to reverse mapping. */ r_item = lh_SRTM_ITEM_retrieve(srtm->items_rev, item); if (r_item == NULL) { /* First item under this blinded SRT */ lh_SRTM_ITEM_insert(srtm->items_rev, item); if (!srtm_check_lh(srtm, srtm->items_rev)) /* * Can't free the item now as we would have to undo the insertion * into the forward mapping which would require an insert operation * to restore the previous value. which might also fail. However, * the item will be freed OK when we free the entire SRTM. */ return 0; } else { sorted_insert_srt(r_item, item, &new_head); if (new_head != r_item) { /* head changed, update in lhash */ lh_SRTM_ITEM_insert(srtm->items_rev, new_head); if (!srtm_check_lh(srtm, srtm->items_rev)) /* As above. */ return 0; } } return 1; } /* Remove item from reverse mapping. */ static int srtm_remove_from_rev(QUIC_SRTM *srtm, SRTM_ITEM *item) { SRTM_ITEM *rh_item; rh_item = lh_SRTM_ITEM_retrieve(srtm->items_rev, item); assert(rh_item != NULL); if (rh_item == item) { /* * Change lhash to point to item after this one, or remove the entry if * this is the last one. */ if (item->next_by_srt_blinded != NULL) { lh_SRTM_ITEM_insert(srtm->items_rev, item->next_by_srt_blinded); if (!srtm_check_lh(srtm, srtm->items_rev)) return 0; } else { lh_SRTM_ITEM_delete(srtm->items_rev, item); } } else { /* Find our entry in the SRT list */ for (; rh_item->next_by_srt_blinded != item; rh_item = rh_item->next_by_srt_blinded); rh_item->next_by_srt_blinded = item->next_by_srt_blinded; } return 1; } int ossl_quic_srtm_remove(QUIC_SRTM *srtm, void *opaque, uint64_t seq_num) { SRTM_ITEM *item, *prev = NULL; if (srtm->alloc_failed) return 0; if ((item = srtm_find(srtm, opaque, seq_num, NULL, &prev)) == NULL) /* No match */ return 0; /* Remove from forward mapping. */ if (prev == NULL) { /* * Change lhash to point to item after this one, or remove the entry if * this is the last one. */ if (item->next_by_seq_num != NULL) { lh_SRTM_ITEM_insert(srtm->items_fwd, item->next_by_seq_num); if (!srtm_check_lh(srtm, srtm->items_fwd)) return 0; } else { lh_SRTM_ITEM_delete(srtm->items_fwd, item); } } else { prev->next_by_seq_num = item->next_by_seq_num; } /* Remove from reverse mapping. */ if (!srtm_remove_from_rev(srtm, item)) return 0; OPENSSL_free(item); return 1; } int ossl_quic_srtm_cull(QUIC_SRTM *srtm, void *opaque) { SRTM_ITEM key, *item = NULL, *inext, *ihead; key.opaque = opaque; if (srtm->alloc_failed) return 0; if ((ihead = lh_SRTM_ITEM_retrieve(srtm->items_fwd, &key)) == NULL) return 1; /* nothing removed is a success condition */ for (item = ihead; item != NULL; item = inext) { inext = item->next_by_seq_num; if (item != ihead) { srtm_remove_from_rev(srtm, item); OPENSSL_free(item); } } lh_SRTM_ITEM_delete(srtm->items_fwd, ihead); srtm_remove_from_rev(srtm, ihead); OPENSSL_free(ihead); return 1; } int ossl_quic_srtm_lookup(QUIC_SRTM *srtm, const QUIC_STATELESS_RESET_TOKEN *token, size_t idx, void **opaque, uint64_t *seq_num) { SRTM_ITEM key, *item; if (srtm->alloc_failed) return 0; if (!srtm_compute_blinded(srtm, &key, token)) return 0; item = lh_SRTM_ITEM_retrieve(srtm->items_rev, &key); for (; idx > 0 && item != NULL; --idx, item = item->next_by_srt_blinded); if (item == NULL) return 0; if (opaque != NULL) *opaque = item->opaque; if (seq_num != NULL) *seq_num = item->seq_num; return 1; } #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION static uint32_t token_next = 0x5eadbeef; static size_t tokens_seen; struct check_args { uint32_t token; int mode; }; static void check_mark(SRTM_ITEM *item, void *arg) { struct check_args *arg_ = arg; uint32_t token = arg_->token; uint64_t prev_seq_num = 0; void *prev_opaque = NULL; int have_prev = 0; assert(item != NULL); while (item != NULL) { if (have_prev) { assert(!(item->opaque == prev_opaque && item->seq_num == prev_seq_num)); if (!arg_->mode) assert(item->opaque != prev_opaque || item->seq_num < prev_seq_num); } ++tokens_seen; item->debug_token = token; prev_opaque = item->opaque; prev_seq_num = item->seq_num; have_prev = 1; if (arg_->mode) item = item->next_by_srt_blinded; else item = item->next_by_seq_num; } } static void check_count(SRTM_ITEM *item, void *arg) { struct check_args *arg_ = arg; uint32_t token = arg_->token; assert(item != NULL); while (item != NULL) { ++tokens_seen; assert(item->debug_token == token); if (arg_->mode) item = item->next_by_seq_num; else item = item->next_by_srt_blinded; } } #endif void ossl_quic_srtm_check(const QUIC_SRTM *srtm) { #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION struct check_args args = {0}; size_t tokens_expected, tokens_expected_old; args.token = token_next; ++token_next; assert(srtm != NULL); assert(srtm->blind_ctx != NULL); assert(srtm->items_fwd != NULL); assert(srtm->items_rev != NULL); tokens_seen = 0; lh_SRTM_ITEM_doall_arg(srtm->items_fwd, check_mark, &args); tokens_expected = tokens_seen; tokens_seen = 0; lh_SRTM_ITEM_doall_arg(srtm->items_rev, check_count, &args); assert(tokens_seen == tokens_expected); tokens_expected_old = tokens_expected; args.token = token_next; ++token_next; args.mode = 1; tokens_seen = 0; lh_SRTM_ITEM_doall_arg(srtm->items_rev, check_mark, &args); tokens_expected = tokens_seen; tokens_seen = 0; lh_SRTM_ITEM_doall_arg(srtm->items_fwd, check_count, &args); assert(tokens_seen == tokens_expected); assert(tokens_seen == tokens_expected_old); #endif }

./openssl/ssl/quic/quic_rstream.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/err.h> #include "internal/common.h" #include "internal/time.h" #include "internal/quic_stream.h" #include "internal/quic_sf_list.h" #include "internal/ring_buf.h" struct quic_rstream_st { SFRAME_LIST fl; QUIC_RXFC *rxfc; OSSL_STATM *statm; UINT_RANGE head_range; struct ring_buf rbuf; }; QUIC_RSTREAM *ossl_quic_rstream_new(QUIC_RXFC *rxfc, OSSL_STATM *statm, size_t rbuf_size) { QUIC_RSTREAM *ret = OPENSSL_zalloc(sizeof(*ret)); if (ret == NULL) return NULL; ring_buf_init(&ret->rbuf); if (!ring_buf_resize(&ret->rbuf, rbuf_size, 0)) { OPENSSL_free(ret); return NULL; } ossl_sframe_list_init(&ret->fl); ret->rxfc = rxfc; ret->statm = statm; return ret; } void ossl_quic_rstream_free(QUIC_RSTREAM *qrs) { int cleanse; if (qrs == NULL) return; cleanse = qrs->fl.cleanse; ossl_sframe_list_destroy(&qrs->fl); ring_buf_destroy(&qrs->rbuf, cleanse); OPENSSL_free(qrs); } int ossl_quic_rstream_queue_data(QUIC_RSTREAM *qrs, OSSL_QRX_PKT *pkt, uint64_t offset, const unsigned char *data, uint64_t data_len, int fin) { UINT_RANGE range; if ((data == NULL && data_len != 0) || (data_len == 0 && fin == 0)) { /* empty frame allowed only at the end of the stream */ ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); return 0; } range.start = offset; range.end = offset + data_len; return ossl_sframe_list_insert(&qrs->fl, &range, pkt, data, fin); } static int read_internal(QUIC_RSTREAM *qrs, unsigned char *buf, size_t size, size_t *readbytes, int *fin, int drop) { void *iter = NULL; UINT_RANGE range; const unsigned char *data; uint64_t offset = 0; size_t readbytes_ = 0; int fin_ = 0, ret = 1; while (ossl_sframe_list_peek(&qrs->fl, &iter, &range, &data, &fin_)) { size_t l = (size_t)(range.end - range.start); if (l > size) { l = size; fin_ = 0; } offset = range.start + l; if (l == 0) break; if (data == NULL) { size_t max_len; data = ring_buf_get_ptr(&qrs->rbuf, range.start, &max_len); if (!ossl_assert(data != NULL)) return 0; if (max_len < l) { memcpy(buf, data, max_len); size -= max_len; buf += max_len; readbytes_ += max_len; l -= max_len; data = ring_buf_get_ptr(&qrs->rbuf, range.start + max_len, &max_len); if (!ossl_assert(data != NULL) || !ossl_assert(max_len > l)) return 0; } } memcpy(buf, data, l); size -= l; buf += l; readbytes_ += l; if (size == 0) break; } if (drop && offset != 0) { ret = ossl_sframe_list_drop_frames(&qrs->fl, offset); ring_buf_cpop_range(&qrs->rbuf, 0, offset - 1, qrs->fl.cleanse); } if (ret) { *readbytes = readbytes_; *fin = fin_; } return ret; } static OSSL_TIME get_rtt(QUIC_RSTREAM *qrs) { OSSL_TIME rtt; if (qrs->statm != NULL) { OSSL_RTT_INFO rtt_info; ossl_statm_get_rtt_info(qrs->statm, &rtt_info); rtt = rtt_info.smoothed_rtt; } else { rtt = ossl_time_zero(); } return rtt; } int ossl_quic_rstream_read(QUIC_RSTREAM *qrs, unsigned char *buf, size_t size, size_t *readbytes, int *fin) { OSSL_TIME rtt = get_rtt(qrs); if (!read_internal(qrs, buf, size, readbytes, fin, 1)) return 0; if (qrs->rxfc != NULL && !ossl_quic_rxfc_on_retire(qrs->rxfc, *readbytes, rtt)) return 0; return 1; } int ossl_quic_rstream_peek(QUIC_RSTREAM *qrs, unsigned char *buf, size_t size, size_t *readbytes, int *fin) { return read_internal(qrs, buf, size, readbytes, fin, 0); } int ossl_quic_rstream_available(QUIC_RSTREAM *qrs, size_t *avail, int *fin) { void *iter = NULL; UINT_RANGE range; const unsigned char *data; uint64_t avail_ = 0; while (ossl_sframe_list_peek(&qrs->fl, &iter, &range, &data, fin)) avail_ += range.end - range.start; #if SIZE_MAX < UINT64_MAX *avail = avail_ > SIZE_MAX ? SIZE_MAX : (size_t)avail_; #else *avail = (size_t)avail_; #endif return 1; } int ossl_quic_rstream_get_record(QUIC_RSTREAM *qrs, const unsigned char **record, size_t *rec_len, int *fin) { const unsigned char *record_ = NULL; size_t rec_len_, max_len; if (!ossl_sframe_list_lock_head(&qrs->fl, &qrs->head_range, &record_, fin)) { /* No head frame to lock and return */ *record = NULL; *rec_len = 0; return 1; } /* if final empty frame, we drop it immediately */ if (qrs->head_range.end == qrs->head_range.start) { if (!ossl_assert(*fin)) return 0; if (!ossl_sframe_list_drop_frames(&qrs->fl, qrs->head_range.end)) return 0; } rec_len_ = (size_t)(qrs->head_range.end - qrs->head_range.start); if (record_ == NULL && rec_len_ != 0) { record_ = ring_buf_get_ptr(&qrs->rbuf, qrs->head_range.start, &max_len); if (!ossl_assert(record_ != NULL)) return 0; if (max_len < rec_len_) { rec_len_ = max_len; qrs->head_range.end = qrs->head_range.start + max_len; } } *rec_len = rec_len_; *record = record_; return 1; } int ossl_quic_rstream_release_record(QUIC_RSTREAM *qrs, size_t read_len) { uint64_t offset; if (!ossl_sframe_list_is_head_locked(&qrs->fl)) return 0; if (read_len > qrs->head_range.end - qrs->head_range.start) { if (read_len != SIZE_MAX) return 0; offset = qrs->head_range.end; } else { offset = qrs->head_range.start + read_len; } if (!ossl_sframe_list_drop_frames(&qrs->fl, offset)) return 0; if (offset > 0) ring_buf_cpop_range(&qrs->rbuf, 0, offset - 1, qrs->fl.cleanse); if (qrs->rxfc != NULL) { OSSL_TIME rtt = get_rtt(qrs); if (!ossl_quic_rxfc_on_retire(qrs->rxfc, offset, rtt)) return 0; } return 1; } static int write_at_ring_buf_cb(uint64_t logical_offset, const unsigned char *buf, size_t buf_len, void *cb_arg) { struct ring_buf *rbuf = cb_arg; return ring_buf_write_at(rbuf, logical_offset, buf, buf_len); } int ossl_quic_rstream_move_to_rbuf(QUIC_RSTREAM *qrs) { if (ring_buf_avail(&qrs->rbuf) == 0) return 0; return ossl_sframe_list_move_data(&qrs->fl, write_at_ring_buf_cb, &qrs->rbuf); } int ossl_quic_rstream_resize_rbuf(QUIC_RSTREAM *qrs, size_t rbuf_size) { if (ossl_sframe_list_is_head_locked(&qrs->fl)) return 0; if (!ring_buf_resize(&qrs->rbuf, rbuf_size, qrs->fl.cleanse)) return 0; return 1; } void ossl_quic_rstream_set_cleanse(QUIC_RSTREAM *qrs, int cleanse) { qrs->fl.cleanse = cleanse; }

./openssl/ssl/quic/quic_wire_pkt.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include <openssl/err.h> #include "internal/common.h" #include "internal/quic_wire_pkt.h" int ossl_quic_hdr_protector_init(QUIC_HDR_PROTECTOR *hpr, OSSL_LIB_CTX *libctx, const char *propq, uint32_t cipher_id, const unsigned char *quic_hp_key, size_t quic_hp_key_len) { const char *cipher_name = NULL; switch (cipher_id) { case QUIC_HDR_PROT_CIPHER_AES_128: cipher_name = "AES-128-ECB"; break; case QUIC_HDR_PROT_CIPHER_AES_256: cipher_name = "AES-256-ECB"; break; case QUIC_HDR_PROT_CIPHER_CHACHA: cipher_name = "ChaCha20"; break; default: ERR_raise(ERR_LIB_SSL, ERR_R_UNSUPPORTED); return 0; } hpr->cipher_ctx = EVP_CIPHER_CTX_new(); if (hpr->cipher_ctx == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } hpr->cipher = EVP_CIPHER_fetch(libctx, cipher_name, propq); if (hpr->cipher == NULL || quic_hp_key_len != (size_t)EVP_CIPHER_get_key_length(hpr->cipher)) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } if (!EVP_CipherInit_ex(hpr->cipher_ctx, hpr->cipher, NULL, quic_hp_key, NULL, 1)) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } hpr->libctx = libctx; hpr->propq = propq; hpr->cipher_id = cipher_id; return 1; err: ossl_quic_hdr_protector_cleanup(hpr); return 0; } void ossl_quic_hdr_protector_cleanup(QUIC_HDR_PROTECTOR *hpr) { EVP_CIPHER_CTX_free(hpr->cipher_ctx); hpr->cipher_ctx = NULL; EVP_CIPHER_free(hpr->cipher); hpr->cipher = NULL; } static int hdr_generate_mask(QUIC_HDR_PROTECTOR *hpr, const unsigned char *sample, size_t sample_len, unsigned char *mask) { int l = 0; unsigned char dst[16]; static const unsigned char zeroes[5] = {0}; size_t i; if (hpr->cipher_id == QUIC_HDR_PROT_CIPHER_AES_128 || hpr->cipher_id == QUIC_HDR_PROT_CIPHER_AES_256) { if (sample_len < 16) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); return 0; } if (!EVP_CipherInit_ex(hpr->cipher_ctx, NULL, NULL, NULL, NULL, 1) || !EVP_CipherUpdate(hpr->cipher_ctx, dst, &l, sample, 16)) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } for (i = 0; i < 5; ++i) mask[i] = dst[i]; } else if (hpr->cipher_id == QUIC_HDR_PROT_CIPHER_CHACHA) { if (sample_len < 16) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); return 0; } if (!EVP_CipherInit_ex(hpr->cipher_ctx, NULL, NULL, NULL, sample, 1) || !EVP_CipherUpdate(hpr->cipher_ctx, mask, &l, zeroes, sizeof(zeroes))) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } } else { ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR); assert(0); return 0; } #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION /* No matter what we did above we use the same mask in fuzzing mode */ memset(mask, 0, 5); #endif return 1; } int ossl_quic_hdr_protector_decrypt(QUIC_HDR_PROTECTOR *hpr, QUIC_PKT_HDR_PTRS *ptrs) { return ossl_quic_hdr_protector_decrypt_fields(hpr, ptrs->raw_sample, ptrs->raw_sample_len, ptrs->raw_start, ptrs->raw_pn); } int ossl_quic_hdr_protector_decrypt_fields(QUIC_HDR_PROTECTOR *hpr, const unsigned char *sample, size_t sample_len, unsigned char *first_byte, unsigned char *pn_bytes) { unsigned char mask[5], pn_len, i; if (!hdr_generate_mask(hpr, sample, sample_len, mask)) return 0; *first_byte ^= mask[0] & ((*first_byte & 0x80) != 0 ? 0xf : 0x1f); pn_len = (*first_byte & 0x3) + 1; for (i = 0; i < pn_len; ++i) pn_bytes[i] ^= mask[i + 1]; return 1; } int ossl_quic_hdr_protector_encrypt(QUIC_HDR_PROTECTOR *hpr, QUIC_PKT_HDR_PTRS *ptrs) { return ossl_quic_hdr_protector_encrypt_fields(hpr, ptrs->raw_sample, ptrs->raw_sample_len, ptrs->raw_start, ptrs->raw_pn); } int ossl_quic_hdr_protector_encrypt_fields(QUIC_HDR_PROTECTOR *hpr, const unsigned char *sample, size_t sample_len, unsigned char *first_byte, unsigned char *pn_bytes) { unsigned char mask[5], pn_len, i; if (!hdr_generate_mask(hpr, sample, sample_len, mask)) return 0; pn_len = (*first_byte & 0x3) + 1; for (i = 0; i < pn_len; ++i) pn_bytes[i] ^= mask[i + 1]; *first_byte ^= mask[0] & ((*first_byte & 0x80) != 0 ? 0xf : 0x1f); return 1; } int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt, size_t short_conn_id_len, int partial, int nodata, QUIC_PKT_HDR *hdr, QUIC_PKT_HDR_PTRS *ptrs) { unsigned int b0; unsigned char *pn = NULL; size_t l = PACKET_remaining(pkt); if (ptrs != NULL) { ptrs->raw_start = (unsigned char *)PACKET_data(pkt); ptrs->raw_sample = NULL; ptrs->raw_sample_len = 0; ptrs->raw_pn = NULL; } if (l < QUIC_MIN_VALID_PKT_LEN || !PACKET_get_1(pkt, &b0)) return 0; hdr->partial = partial; hdr->unused = 0; hdr->reserved = 0; if ((b0 & 0x80) == 0) { /* Short header. */ if (short_conn_id_len > QUIC_MAX_CONN_ID_LEN) return 0; if ((b0 & 0x40) == 0 /* fixed bit not set? */ || l < QUIC_MIN_VALID_PKT_LEN_CRYPTO) return 0; hdr->type = QUIC_PKT_TYPE_1RTT; hdr->fixed = 1; hdr->spin_bit = (b0 & 0x20) != 0; if (partial) { hdr->key_phase = 0; /* protected, zero for now */ hdr->pn_len = 0; /* protected, zero for now */ hdr->reserved = 0; /* protected, zero for now */ } else { hdr->key_phase = (b0 & 0x04) != 0; hdr->pn_len = (b0 & 0x03) + 1; hdr->reserved = (b0 & 0x18) >> 3; } /* Copy destination connection ID field to header structure. */ if (!PACKET_copy_bytes(pkt, hdr->dst_conn_id.id, short_conn_id_len)) return 0; hdr->dst_conn_id.id_len = (unsigned char)short_conn_id_len; /* * Skip over the PN. If this is a partial decode, the PN length field * currently has header protection applied. Thus we do not know the * length of the PN but we are allowed to assume it is 4 bytes long at * this stage. */ memset(hdr->pn, 0, sizeof(hdr->pn)); pn = (unsigned char *)PACKET_data(pkt); if (partial) { if (!PACKET_forward(pkt, sizeof(hdr->pn))) return 0; } else { if (!PACKET_copy_bytes(pkt, hdr->pn, hdr->pn_len)) return 0; } /* Fields not used in short-header packets. */ hdr->version = 0; hdr->src_conn_id.id_len = 0; hdr->token = NULL; hdr->token_len = 0; /* * Short-header packets always come last in a datagram, the length * is the remainder of the buffer. */ hdr->len = PACKET_remaining(pkt); hdr->data = PACKET_data(pkt); /* * Skip over payload. Since this is a short header packet, which cannot * be followed by any other kind of packet, this advances us to the end * of the datagram. */ if (!PACKET_forward(pkt, hdr->len)) return 0; } else { /* Long header. */ unsigned long version; unsigned int dst_conn_id_len, src_conn_id_len, raw_type; if (!PACKET_get_net_4(pkt, &version)) return 0; /* * All QUIC packets must have the fixed bit set, except exceptionally * for Version Negotiation packets. */ if (version != 0 && (b0 & 0x40) == 0) return 0; if (!PACKET_get_1(pkt, &dst_conn_id_len) || dst_conn_id_len > QUIC_MAX_CONN_ID_LEN || !PACKET_copy_bytes(pkt, hdr->dst_conn_id.id, dst_conn_id_len) || !PACKET_get_1(pkt, &src_conn_id_len) || src_conn_id_len > QUIC_MAX_CONN_ID_LEN || !PACKET_copy_bytes(pkt, hdr->src_conn_id.id, src_conn_id_len)) return 0; hdr->version = (uint32_t)version; hdr->dst_conn_id.id_len = (unsigned char)dst_conn_id_len; hdr->src_conn_id.id_len = (unsigned char)src_conn_id_len; if (version == 0) { /* * Version negotiation packet. Version negotiation packets are * identified by a version field of 0 and the type bits in the first * byte are ignored (they may take any value, and we ignore them). */ hdr->type = QUIC_PKT_TYPE_VERSION_NEG; hdr->fixed = (b0 & 0x40) != 0; hdr->data = PACKET_data(pkt); hdr->len = PACKET_remaining(pkt); /* * Version negotiation packets must contain an array of u32s, so it * is invalid for their payload length to not be divisible by 4. */ if ((hdr->len % 4) != 0) return 0; /* Version negotiation packets are always fully decoded. */ hdr->partial = 0; /* Fields not used in version negotiation packets. */ hdr->pn_len = 0; hdr->spin_bit = 0; hdr->key_phase = 0; hdr->token = NULL; hdr->token_len = 0; memset(hdr->pn, 0, sizeof(hdr->pn)); if (!PACKET_forward(pkt, hdr->len)) return 0; } else if (version != QUIC_VERSION_1) { /* Unknown version, do not decode. */ return 0; } else { if (l < QUIC_MIN_VALID_PKT_LEN_CRYPTO) return 0; /* Get long packet type and decode to QUIC_PKT_TYPE_*. */ raw_type = ((b0 >> 4) & 0x3); switch (raw_type) { case 0: hdr->type = QUIC_PKT_TYPE_INITIAL; break; case 1: hdr->type = QUIC_PKT_TYPE_0RTT; break; case 2: hdr->type = QUIC_PKT_TYPE_HANDSHAKE; break; case 3: hdr->type = QUIC_PKT_TYPE_RETRY; break; } hdr->pn_len = 0; hdr->fixed = 1; /* Fields not used in long-header packets. */ hdr->spin_bit = 0; hdr->key_phase = 0; if (hdr->type == QUIC_PKT_TYPE_INITIAL) { /* Initial packet. */ uint64_t token_len; if (!PACKET_get_quic_vlint(pkt, &token_len) || token_len > SIZE_MAX || !PACKET_get_bytes(pkt, &hdr->token, (size_t)token_len)) return 0; hdr->token_len = (size_t)token_len; if (token_len == 0) hdr->token = NULL; } else { hdr->token = NULL; hdr->token_len = 0; } if (hdr->type == QUIC_PKT_TYPE_RETRY) { /* Retry packet. */ hdr->data = PACKET_data(pkt); hdr->len = PACKET_remaining(pkt); /* Retry packets are always fully decoded. */ hdr->partial = 0; /* Unused bits in Retry header. */ hdr->unused = b0 & 0x0f; /* Fields not used in Retry packets. */ memset(hdr->pn, 0, sizeof(hdr->pn)); if (!PACKET_forward(pkt, hdr->len)) return 0; } else { /* Initial, 0-RTT or Handshake packet. */ uint64_t len; hdr->pn_len = partial ? 0 : ((b0 & 0x03) + 1); hdr->reserved = partial ? 0 : ((b0 & 0x0C) >> 2); if (!PACKET_get_quic_vlint(pkt, &len) || len < sizeof(hdr->pn)) return 0; if (!nodata && len > PACKET_remaining(pkt)) return 0; /* * Skip over the PN. If this is a partial decode, the PN length * field currently has header protection applied. Thus we do not * know the length of the PN but we are allowed to assume it is * 4 bytes long at this stage. */ pn = (unsigned char *)PACKET_data(pkt); memset(hdr->pn, 0, sizeof(hdr->pn)); if (partial) { if (!PACKET_forward(pkt, sizeof(hdr->pn))) return 0; hdr->len = (size_t)(len - sizeof(hdr->pn)); } else { if (!PACKET_copy_bytes(pkt, hdr->pn, hdr->pn_len)) return 0; hdr->len = (size_t)(len - hdr->pn_len); } if (nodata) { hdr->data = NULL; } else { hdr->data = PACKET_data(pkt); /* Skip over packet body. */ if (!PACKET_forward(pkt, hdr->len)) return 0; } } } } if (ptrs != NULL) { ptrs->raw_pn = pn; if (pn != NULL) { ptrs->raw_sample = pn + 4; ptrs->raw_sample_len = PACKET_end(pkt) - ptrs->raw_sample; } } return 1; } int ossl_quic_wire_encode_pkt_hdr(WPACKET *pkt, size_t short_conn_id_len, const QUIC_PKT_HDR *hdr, QUIC_PKT_HDR_PTRS *ptrs) { unsigned char b0; size_t off_start, off_sample, off_pn; unsigned char *start = WPACKET_get_curr(pkt); if (!WPACKET_get_total_written(pkt, &off_start)) return 0; if (ptrs != NULL) { /* ptrs would not be stable on non-static WPACKET */ if (!ossl_assert(pkt->staticbuf != NULL)) return 0; ptrs->raw_start = NULL; ptrs->raw_sample = NULL; ptrs->raw_sample_len = 0; ptrs->raw_pn = 0; } /* Cannot serialize a partial header, or one whose DCID length is wrong. */ if (hdr->partial || (hdr->type == QUIC_PKT_TYPE_1RTT && hdr->dst_conn_id.id_len != short_conn_id_len)) return 0; if (hdr->type == QUIC_PKT_TYPE_1RTT) { /* Short header. */ /* * Cannot serialize a header whose DCID length is wrong, or with an * invalid PN length. */ if (hdr->dst_conn_id.id_len != short_conn_id_len || short_conn_id_len > QUIC_MAX_CONN_ID_LEN || hdr->pn_len < 1 || hdr->pn_len > 4) return 0; b0 = (hdr->spin_bit << 5) | (hdr->key_phase << 2) | (hdr->pn_len - 1) | (hdr->reserved << 3) | 0x40; /* fixed bit */ if (!WPACKET_put_bytes_u8(pkt, b0) || !WPACKET_memcpy(pkt, hdr->dst_conn_id.id, short_conn_id_len) || !WPACKET_get_total_written(pkt, &off_pn) || !WPACKET_memcpy(pkt, hdr->pn, hdr->pn_len)) return 0; } else { /* Long header. */ unsigned int raw_type; if (hdr->dst_conn_id.id_len > QUIC_MAX_CONN_ID_LEN || hdr->src_conn_id.id_len > QUIC_MAX_CONN_ID_LEN) return 0; if (ossl_quic_pkt_type_has_pn(hdr->type) && (hdr->pn_len < 1 || hdr->pn_len > 4)) return 0; switch (hdr->type) { case QUIC_PKT_TYPE_VERSION_NEG: if (hdr->version != 0) return 0; /* Version negotiation packets use zero for the type bits */ raw_type = 0; break; case QUIC_PKT_TYPE_INITIAL: raw_type = 0; break; case QUIC_PKT_TYPE_0RTT: raw_type = 1; break; case QUIC_PKT_TYPE_HANDSHAKE: raw_type = 2; break; case QUIC_PKT_TYPE_RETRY: raw_type = 3; break; default: return 0; } b0 = (raw_type << 4) | 0x80; /* long */ if (hdr->type != QUIC_PKT_TYPE_VERSION_NEG || hdr->fixed) b0 |= 0x40; /* fixed */ if (ossl_quic_pkt_type_has_pn(hdr->type)) { b0 |= hdr->pn_len - 1; b0 |= (hdr->reserved << 2); } if (hdr->type == QUIC_PKT_TYPE_RETRY) b0 |= hdr->unused; if (!WPACKET_put_bytes_u8(pkt, b0) || !WPACKET_put_bytes_u32(pkt, hdr->version) || !WPACKET_put_bytes_u8(pkt, hdr->dst_conn_id.id_len) || !WPACKET_memcpy(pkt, hdr->dst_conn_id.id, hdr->dst_conn_id.id_len) || !WPACKET_put_bytes_u8(pkt, hdr->src_conn_id.id_len) || !WPACKET_memcpy(pkt, hdr->src_conn_id.id, hdr->src_conn_id.id_len)) return 0; if (hdr->type == QUIC_PKT_TYPE_VERSION_NEG || hdr->type == QUIC_PKT_TYPE_RETRY) { if (hdr->len > 0 && !WPACKET_reserve_bytes(pkt, hdr->len, NULL)) return 0; return 1; } if (hdr->type == QUIC_PKT_TYPE_INITIAL) { if (!WPACKET_quic_write_vlint(pkt, hdr->token_len) || !WPACKET_memcpy(pkt, hdr->token, hdr->token_len)) return 0; } if (!WPACKET_quic_write_vlint(pkt, hdr->len + hdr->pn_len) || !WPACKET_get_total_written(pkt, &off_pn) || !WPACKET_memcpy(pkt, hdr->pn, hdr->pn_len)) return 0; } if (hdr->len > 0 && !WPACKET_reserve_bytes(pkt, hdr->len, NULL)) return 0; off_sample = off_pn + 4; if (ptrs != NULL) { ptrs->raw_start = start; ptrs->raw_sample = start + (off_sample - off_start); ptrs->raw_sample_len = WPACKET_get_curr(pkt) + hdr->len - ptrs->raw_sample; ptrs->raw_pn = start + (off_pn - off_start); } return 1; } int ossl_quic_wire_get_encoded_pkt_hdr_len(size_t short_conn_id_len, const QUIC_PKT_HDR *hdr) { size_t len = 0, enclen; /* Cannot serialize a partial header, or one whose DCID length is wrong. */ if (hdr->partial || (hdr->type == QUIC_PKT_TYPE_1RTT && hdr->dst_conn_id.id_len != short_conn_id_len)) return 0; if (hdr->type == QUIC_PKT_TYPE_1RTT) { /* Short header. */ /* * Cannot serialize a header whose DCID length is wrong, or with an * invalid PN length. */ if (hdr->dst_conn_id.id_len != short_conn_id_len || short_conn_id_len > QUIC_MAX_CONN_ID_LEN || hdr->pn_len < 1 || hdr->pn_len > 4) return 0; return 1 + short_conn_id_len + hdr->pn_len; } else { /* Long header. */ if (hdr->dst_conn_id.id_len > QUIC_MAX_CONN_ID_LEN || hdr->src_conn_id.id_len > QUIC_MAX_CONN_ID_LEN) return 0; len += 1 /* Initial byte */ + 4 /* Version */ + 1 + hdr->dst_conn_id.id_len /* DCID Len, DCID */ + 1 + hdr->src_conn_id.id_len /* SCID Len, SCID */ ; if (ossl_quic_pkt_type_has_pn(hdr->type)) { if (hdr->pn_len < 1 || hdr->pn_len > 4) return 0; len += hdr->pn_len; } if (hdr->type == QUIC_PKT_TYPE_INITIAL) { enclen = ossl_quic_vlint_encode_len(hdr->token_len); if (!enclen) return 0; len += enclen + hdr->token_len; } if (!ossl_quic_pkt_type_must_be_last(hdr->type)) { enclen = ossl_quic_vlint_encode_len(hdr->len + hdr->pn_len); if (!enclen) return 0; len += enclen; } return len; } } int ossl_quic_wire_get_pkt_hdr_dst_conn_id(const unsigned char *buf, size_t buf_len, size_t short_conn_id_len, QUIC_CONN_ID *dst_conn_id) { unsigned char b0; size_t blen; if (buf_len < QUIC_MIN_VALID_PKT_LEN || short_conn_id_len > QUIC_MAX_CONN_ID_LEN) return 0; b0 = buf[0]; if ((b0 & 0x80) != 0) { /* * Long header. We need 6 bytes (initial byte, 4 version bytes, DCID * length byte to begin with). This is covered by the buf_len test * above. */ /* * If the version field is non-zero (meaning that this is not a Version * Negotiation packet), the fixed bit must be set. */ if ((buf[1] || buf[2] || buf[3] || buf[4]) && (b0 & 0x40) == 0) return 0; blen = (size_t)buf[5]; /* DCID Length */ if (blen > QUIC_MAX_CONN_ID_LEN || buf_len < QUIC_MIN_VALID_PKT_LEN + blen) return 0; dst_conn_id->id_len = (unsigned char)blen; memcpy(dst_conn_id->id, buf + 6, blen); return 1; } else { /* Short header. */ if ((b0 & 0x40) == 0) /* Fixed bit not set, not a valid QUIC packet header. */ return 0; if (buf_len < QUIC_MIN_VALID_PKT_LEN_CRYPTO + short_conn_id_len) return 0; dst_conn_id->id_len = (unsigned char)short_conn_id_len; memcpy(dst_conn_id->id, buf + 1, short_conn_id_len); return 1; } } int ossl_quic_wire_decode_pkt_hdr_pn(const unsigned char *enc_pn, size_t enc_pn_len, QUIC_PN largest_pn, QUIC_PN *res_pn) { int64_t expected_pn, truncated_pn, candidate_pn, pn_win, pn_hwin, pn_mask; switch (enc_pn_len) { case 1: truncated_pn = enc_pn[0]; break; case 2: truncated_pn = ((QUIC_PN)enc_pn[0] << 8) | (QUIC_PN)enc_pn[1]; break; case 3: truncated_pn = ((QUIC_PN)enc_pn[0] << 16) | ((QUIC_PN)enc_pn[1] << 8) | (QUIC_PN)enc_pn[2]; break; case 4: truncated_pn = ((QUIC_PN)enc_pn[0] << 24) | ((QUIC_PN)enc_pn[1] << 16) | ((QUIC_PN)enc_pn[2] << 8) | (QUIC_PN)enc_pn[3]; break; default: return 0; } /* Implemented as per RFC 9000 Section A.3. */ expected_pn = largest_pn + 1; pn_win = ((int64_t)1) << (enc_pn_len * 8); pn_hwin = pn_win / 2; pn_mask = pn_win - 1; candidate_pn = (expected_pn & ~pn_mask) | truncated_pn; if (candidate_pn <= expected_pn - pn_hwin && candidate_pn < (((int64_t)1) << 62) - pn_win) *res_pn = candidate_pn + pn_win; else if (candidate_pn > expected_pn + pn_hwin && candidate_pn >= pn_win) *res_pn = candidate_pn - pn_win; else *res_pn = candidate_pn; return 1; } /* From RFC 9000 Section A.2. Simplified implementation. */ int ossl_quic_wire_determine_pn_len(QUIC_PN pn, QUIC_PN largest_acked) { uint64_t num_unacked = (largest_acked == QUIC_PN_INVALID) ? pn + 1 : pn - largest_acked; /* * num_unacked \in [ 0, 2** 7] -> 1 byte * num_unacked \in (2** 7, 2**15] -> 2 bytes * num_unacked \in (2**15, 2**23] -> 3 bytes * num_unacked \in (2**23, ] -> 4 bytes */ if (num_unacked <= (1U<<7)) return 1; if (num_unacked <= (1U<<15)) return 2; if (num_unacked <= (1U<<23)) return 3; return 4; } int ossl_quic_wire_encode_pkt_hdr_pn(QUIC_PN pn, unsigned char *enc_pn, size_t enc_pn_len) { switch (enc_pn_len) { case 1: enc_pn[0] = (unsigned char)pn; break; case 2: enc_pn[1] = (unsigned char)pn; enc_pn[0] = (unsigned char)(pn >> 8); break; case 3: enc_pn[2] = (unsigned char)pn; enc_pn[1] = (unsigned char)(pn >> 8); enc_pn[0] = (unsigned char)(pn >> 16); break; case 4: enc_pn[3] = (unsigned char)pn; enc_pn[2] = (unsigned char)(pn >> 8); enc_pn[1] = (unsigned char)(pn >> 16); enc_pn[0] = (unsigned char)(pn >> 24); break; default: return 0; } return 1; } int ossl_quic_validate_retry_integrity_tag(OSSL_LIB_CTX *libctx, const char *propq, const QUIC_PKT_HDR *hdr, const QUIC_CONN_ID *client_initial_dcid) { unsigned char expected_tag[QUIC_RETRY_INTEGRITY_TAG_LEN]; const unsigned char *actual_tag; if (hdr == NULL || hdr->len < QUIC_RETRY_INTEGRITY_TAG_LEN) return 0; if (!ossl_quic_calculate_retry_integrity_tag(libctx, propq, hdr, client_initial_dcid, expected_tag)) return 0; actual_tag = hdr->data + hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN; return !CRYPTO_memcmp(expected_tag, actual_tag, QUIC_RETRY_INTEGRITY_TAG_LEN); } /* RFC 9001 s. 5.8 */ static const unsigned char retry_integrity_key[] = { 0xbe, 0x0c, 0x69, 0x0b, 0x9f, 0x66, 0x57, 0x5a, 0x1d, 0x76, 0x6b, 0x54, 0xe3, 0x68, 0xc8, 0x4e }; static const unsigned char retry_integrity_nonce[] = { 0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb }; int ossl_quic_calculate_retry_integrity_tag(OSSL_LIB_CTX *libctx, const char *propq, const QUIC_PKT_HDR *hdr, const QUIC_CONN_ID *client_initial_dcid, unsigned char *tag) { EVP_CIPHER *cipher = NULL; EVP_CIPHER_CTX *cctx = NULL; int ok = 0, l = 0, l2 = 0, wpkt_valid = 0; WPACKET wpkt; /* Worst case length of the Retry Psuedo-Packet header is 68 bytes. */ unsigned char buf[128]; QUIC_PKT_HDR hdr2; size_t hdr_enc_len = 0; if (hdr->type != QUIC_PKT_TYPE_RETRY || hdr->version == 0 || hdr->len < QUIC_RETRY_INTEGRITY_TAG_LEN || hdr->data == NULL || client_initial_dcid == NULL || tag == NULL || client_initial_dcid->id_len > QUIC_MAX_CONN_ID_LEN) { ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT); goto err; } /* * Do not reserve packet body in WPACKET. Retry packet header * does not contain a Length field so this does not affect * the serialized packet header. */ hdr2 = *hdr; hdr2.len = 0; /* Assemble retry psuedo-packet. */ if (!WPACKET_init_static_len(&wpkt, buf, sizeof(buf), 0)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } wpkt_valid = 1; /* Prepend original DCID to the packet. */ if (!WPACKET_put_bytes_u8(&wpkt, client_initial_dcid->id_len) || !WPACKET_memcpy(&wpkt, client_initial_dcid->id, client_initial_dcid->id_len)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); goto err; } /* Encode main retry header. */ if (!ossl_quic_wire_encode_pkt_hdr(&wpkt, hdr2.dst_conn_id.id_len, &hdr2, NULL)) goto err; if (!WPACKET_get_total_written(&wpkt, &hdr_enc_len)) { ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB); return 0; } /* Create and initialise cipher context. */ /* TODO(QUIC FUTURE): Cipher fetch caching. */ if ((cipher = EVP_CIPHER_fetch(libctx, "AES-128-GCM", propq)) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } if ((cctx = EVP_CIPHER_CTX_new()) == NULL) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } if (!EVP_CipherInit_ex(cctx, cipher, NULL, retry_integrity_key, retry_integrity_nonce, /*enc=*/1)) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); goto err; } /* Feed packet header as AAD data. */ if (EVP_CipherUpdate(cctx, NULL, &l, buf, hdr_enc_len) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } /* Feed packet body as AAD data. */ if (EVP_CipherUpdate(cctx, NULL, &l, hdr->data, hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } /* Finalise and get tag. */ if (EVP_CipherFinal_ex(cctx, NULL, &l2) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } if (EVP_CIPHER_CTX_ctrl(cctx, EVP_CTRL_AEAD_GET_TAG, QUIC_RETRY_INTEGRITY_TAG_LEN, tag) != 1) { ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB); return 0; } ok = 1; err: EVP_CIPHER_free(cipher); EVP_CIPHER_CTX_free(cctx); if (wpkt_valid) WPACKET_finish(&wpkt); return ok; }

./openssl/ssl/quic/quic_cfq.c

/* * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved. * * Licensed under the Apache License 2.0 (the "License"). You may not use * this file except in compliance with the License. You can obtain a copy * in the file LICENSE in the source distribution or at * https://www.openssl.org/source/license.html */ #include "internal/quic_cfq.h" #include "internal/numbers.h" typedef struct quic_cfq_item_ex_st QUIC_CFQ_ITEM_EX; struct quic_cfq_item_ex_st { QUIC_CFQ_ITEM public; QUIC_CFQ_ITEM_EX *prev, *next; unsigned char *encoded; cfq_free_cb *free_cb; void *free_cb_arg; uint64_t frame_type; size_t encoded_len; uint32_t priority, pn_space, flags; int state; }; uint64_t ossl_quic_cfq_item_get_frame_type(const QUIC_CFQ_ITEM *item) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; return ex->frame_type; } const unsigned char *ossl_quic_cfq_item_get_encoded(const QUIC_CFQ_ITEM *item) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; return ex->encoded; } size_t ossl_quic_cfq_item_get_encoded_len(const QUIC_CFQ_ITEM *item) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; return ex->encoded_len; } int ossl_quic_cfq_item_get_state(const QUIC_CFQ_ITEM *item) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; return ex->state; } uint32_t ossl_quic_cfq_item_get_pn_space(const QUIC_CFQ_ITEM *item) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; return ex->pn_space; } int ossl_quic_cfq_item_is_unreliable(const QUIC_CFQ_ITEM *item) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; return (ex->flags & QUIC_CFQ_ITEM_FLAG_UNRELIABLE) != 0; } typedef struct quic_cfq_item_list_st { QUIC_CFQ_ITEM_EX *head, *tail; } QUIC_CFQ_ITEM_LIST; struct quic_cfq_st { /* * Invariant: A CFQ item is always in exactly one of these lists, never more * or less than one. * * Invariant: The list the CFQ item is determined exactly by the state field * of the item. */ QUIC_CFQ_ITEM_LIST new_list, tx_list, free_list; }; static int compare(const QUIC_CFQ_ITEM_EX *a, const QUIC_CFQ_ITEM_EX *b) { if (a->pn_space < b->pn_space) return -1; else if (a->pn_space > b->pn_space) return 1; if (a->priority > b->priority) return -1; else if (a->priority < b->priority) return 1; return 0; } static void list_remove(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n) { if (l->head == n) l->head = n->next; if (l->tail == n) l->tail = n->prev; if (n->prev != NULL) n->prev->next = n->next; if (n->next != NULL) n->next->prev = n->prev; n->prev = n->next = NULL; } static void list_insert_head(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n) { n->next = l->head; n->prev = NULL; l->head = n; if (n->next != NULL) n->next->prev = n; if (l->tail == NULL) l->tail = n; } static void list_insert_tail(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n) { n->prev = l->tail; n->next = NULL; l->tail = n; if (n->prev != NULL) n->prev->next = n; if (l->head == NULL) l->head = n; } static void list_insert_after(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *ref, QUIC_CFQ_ITEM_EX *n) { n->prev = ref; n->next = ref->next; if (ref->next != NULL) ref->next->prev = n; ref->next = n; if (l->tail == ref) l->tail = n; } static void list_insert_sorted(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n, int (*cmp)(const QUIC_CFQ_ITEM_EX *a, const QUIC_CFQ_ITEM_EX *b)) { QUIC_CFQ_ITEM_EX *p = l->head, *pprev = NULL; if (p == NULL) { l->head = l->tail = n; n->prev = n->next = NULL; return; } for (; p != NULL && cmp(p, n) < 0; pprev = p, p = p->next); if (p == NULL) list_insert_tail(l, n); else if (pprev == NULL) list_insert_head(l, n); else list_insert_after(l, pprev, n); } QUIC_CFQ *ossl_quic_cfq_new(void) { QUIC_CFQ *cfq = OPENSSL_zalloc(sizeof(*cfq)); if (cfq == NULL) return NULL; return cfq; } static void clear_item(QUIC_CFQ_ITEM_EX *item) { if (item->free_cb != NULL) { item->free_cb(item->encoded, item->encoded_len, item->free_cb_arg); item->free_cb = NULL; item->encoded = NULL; item->encoded_len = 0; } item->state = -1; } static void free_list_items(QUIC_CFQ_ITEM_LIST *l) { QUIC_CFQ_ITEM_EX *p, *pnext; for (p = l->head; p != NULL; p = pnext) { pnext = p->next; clear_item(p); OPENSSL_free(p); } } void ossl_quic_cfq_free(QUIC_CFQ *cfq) { if (cfq == NULL) return; free_list_items(&cfq->new_list); free_list_items(&cfq->tx_list); free_list_items(&cfq->free_list); OPENSSL_free(cfq); } static QUIC_CFQ_ITEM_EX *cfq_get_free(QUIC_CFQ *cfq) { QUIC_CFQ_ITEM_EX *item = cfq->free_list.head; if (item != NULL) return item; item = OPENSSL_zalloc(sizeof(*item)); if (item == NULL) return NULL; item->state = -1; list_insert_tail(&cfq->free_list, item); return item; } QUIC_CFQ_ITEM *ossl_quic_cfq_add_frame(QUIC_CFQ *cfq, uint32_t priority, uint32_t pn_space, uint64_t frame_type, uint32_t flags, const unsigned char *encoded, size_t encoded_len, cfq_free_cb *free_cb, void *free_cb_arg) { QUIC_CFQ_ITEM_EX *item = cfq_get_free(cfq); if (item == NULL) return NULL; item->priority = priority; item->frame_type = frame_type; item->pn_space = pn_space; item->encoded = (unsigned char *)encoded; item->encoded_len = encoded_len; item->free_cb = free_cb; item->free_cb_arg = free_cb_arg; item->state = QUIC_CFQ_STATE_NEW; item->flags = flags; list_remove(&cfq->free_list, item); list_insert_sorted(&cfq->new_list, item, compare); return &item->public; } void ossl_quic_cfq_mark_tx(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; switch (ex->state) { case QUIC_CFQ_STATE_NEW: list_remove(&cfq->new_list, ex); list_insert_tail(&cfq->tx_list, ex); ex->state = QUIC_CFQ_STATE_TX; break; case QUIC_CFQ_STATE_TX: break; /* nothing to do */ default: assert(0); /* invalid state (e.g. in free state) */ break; } } void ossl_quic_cfq_mark_lost(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item, uint32_t priority) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; if (ossl_quic_cfq_item_is_unreliable(item)) { ossl_quic_cfq_release(cfq, item); return; } switch (ex->state) { case QUIC_CFQ_STATE_NEW: if (priority != UINT32_MAX && priority != ex->priority) { list_remove(&cfq->new_list, ex); ex->priority = priority; list_insert_sorted(&cfq->new_list, ex, compare); } break; /* nothing to do */ case QUIC_CFQ_STATE_TX: if (priority != UINT32_MAX) ex->priority = priority; list_remove(&cfq->tx_list, ex); list_insert_sorted(&cfq->new_list, ex, compare); ex->state = QUIC_CFQ_STATE_NEW; break; default: assert(0); /* invalid state (e.g. in free state) */ break; } } /* * Releases a CFQ item. The item may be in either state (NEW or TX) prior to the * call. The QUIC_CFQ_ITEM pointer must not be used following this call. */ void ossl_quic_cfq_release(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; switch (ex->state) { case QUIC_CFQ_STATE_NEW: list_remove(&cfq->new_list, ex); list_insert_tail(&cfq->free_list, ex); clear_item(ex); break; case QUIC_CFQ_STATE_TX: list_remove(&cfq->tx_list, ex); list_insert_tail(&cfq->free_list, ex); clear_item(ex); break; default: assert(0); /* invalid state (e.g. in free state) */ break; } } QUIC_CFQ_ITEM *ossl_quic_cfq_get_priority_head(const QUIC_CFQ *cfq, uint32_t pn_space) { QUIC_CFQ_ITEM_EX *item = cfq->new_list.head; for (; item != NULL && item->pn_space != pn_space; item = item->next); if (item == NULL) return NULL; return &item->public; } QUIC_CFQ_ITEM *ossl_quic_cfq_item_get_priority_next(const QUIC_CFQ_ITEM *item, uint32_t pn_space) { QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item; if (ex == NULL) return NULL; ex = ex->next; for (; ex != NULL && ex->pn_space != pn_space; ex = ex->next); if (ex == NULL) return NULL; /* ubsan */ return &ex->public; }