Consistently use session_ctx for session caching.
The TLS 1.3 client logic used ctx instead. This is all moot as
SSL_set_SSL_CTX on a client really wouldn't work, but we should be
consistent. Unfortunately, this moves moving the pointer back to SSL
from SSL_CONFIG.
Change-Id: I45f8241e16f499ad416afd5eceb52dc82af9c4f4
Reviewed-on: https://boringssl-review.googlesource.com/27985
Commit-Queue: David Benjamin <davidben@google.com>
Commit-Queue: Steven Valdez <svaldez@google.com>
Reviewed-by: Steven Valdez <svaldez@google.com>
CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
diff --git a/ssl/internal.h b/ssl/internal.h
index 2550aad..05a99b2 100644
--- a/ssl/internal.h
+++ b/ssl/internal.h
@@ -2649,10 +2649,6 @@
size_t supported_group_list_len = 0;
uint16_t *supported_group_list = nullptr; // our list
- // session_ctx is the |SSL_CTX| used for the session cache and related
- // settings.
- SSL_CTX *session_ctx = nullptr;
-
// The client's Channel ID private key.
EVP_PKEY *tlsext_channel_id_private = nullptr;
@@ -2755,6 +2751,10 @@
SSL_CTX *ctx;
+ // session_ctx is the |SSL_CTX| used for the session cache and related
+ // settings.
+ SSL_CTX *session_ctx;
+
// extra application data
CRYPTO_EX_DATA ex_data;
diff --git a/ssl/ssl_lib.cc b/ssl/ssl_lib.cc
index 7b80a03..5a842ac 100644
--- a/ssl/ssl_lib.cc
+++ b/ssl/ssl_lib.cc
@@ -274,7 +274,7 @@
void ssl_update_cache(SSL_HANDSHAKE *hs, int mode) {
SSL *const ssl = hs->ssl;
- SSL_CTX *ctx = hs->config->session_ctx;
+ SSL_CTX *ctx = ssl->session_ctx;
// Never cache sessions with empty session IDs.
if (ssl->s3->established_session->session_id_length == 0 ||
ssl->s3->established_session->not_resumable ||
@@ -728,7 +728,7 @@
SSL_CTX_up_ref(ctx);
ssl->ctx = ctx;
SSL_CTX_up_ref(ctx);
- ssl->config->session_ctx = ctx;
+ ssl->session_ctx = ctx;
if (ctx->supported_group_list) {
ssl->config->supported_group_list = (uint16_t *)BUF_memdup(
@@ -806,7 +806,6 @@
}
Delete(cipher_list);
Delete(cert);
- SSL_CTX_free(session_ctx);
OPENSSL_free(supported_group_list);
OPENSSL_free(alpn_client_proto_list);
OPENSSL_free(token_binding_params);
@@ -838,6 +837,7 @@
ssl->method->ssl_free(ssl);
}
SSL_CTX_free(ssl->ctx);
+ SSL_CTX_free(ssl->session_ctx);
OPENSSL_free(ssl);
}
@@ -2377,7 +2377,7 @@
}
if (ctx == NULL) {
- ctx = ssl->config->session_ctx;
+ ctx = ssl->session_ctx;
}
Delete(ssl->config->cert);
diff --git a/ssl/ssl_session.cc b/ssl/ssl_session.cc
index b992e9a..9ecadcf 100644
--- a/ssl/ssl_session.cc
+++ b/ssl/ssl_session.cc
@@ -381,13 +381,13 @@
if (version >= TLS1_3_VERSION) {
// TLS 1.3 uses tickets as authenticators, so we are willing to use them for
// longer.
- session->timeout = hs->config->session_ctx->session_psk_dhe_timeout;
+ session->timeout = ssl->session_ctx->session_psk_dhe_timeout;
session->auth_timeout = SSL_DEFAULT_SESSION_AUTH_TIMEOUT;
} else {
// TLS 1.2 resumption does not incorporate new key material, so we use a
// much shorter timeout.
- session->timeout = hs->config->session_ctx->session_timeout;
- session->auth_timeout = hs->config->session_ctx->session_timeout;
+ session->timeout = ssl->session_ctx->session_timeout;
+ session->auth_timeout = ssl->session_ctx->session_timeout;
}
if (is_server) {
@@ -493,7 +493,7 @@
// Initialize HMAC and cipher contexts. If callback present it does all the
// work otherwise use generated values from parent ctx.
- SSL_CTX *tctx = hs->config->session_ctx;
+ SSL_CTX *tctx = hs->ssl->session_ctx;
uint8_t iv[EVP_MAX_IV_LENGTH];
uint8_t key_name[16];
if (tctx->tlsext_ticket_key_cb != NULL) {
@@ -557,9 +557,9 @@
static int ssl_encrypt_ticket_with_method(SSL_HANDSHAKE *hs, CBB *out,
const uint8_t *session_buf,
size_t session_len) {
- const SSL_TICKET_AEAD_METHOD *method =
- hs->config->session_ctx->ticket_aead_method;
- const size_t max_overhead = method->max_overhead(hs->ssl);
+ SSL *const ssl = hs->ssl;
+ const SSL_TICKET_AEAD_METHOD *method = ssl->session_ctx->ticket_aead_method;
+ const size_t max_overhead = method->max_overhead(ssl);
const size_t max_out = session_len + max_overhead;
if (max_out < max_overhead) {
OPENSSL_PUT_ERROR(SSL, ERR_R_OVERFLOW);
@@ -572,7 +572,7 @@
}
size_t out_len;
- if (!method->seal(hs->ssl, ptr, &out_len, max_out, session_buf,
+ if (!method->seal(ssl, ptr, &out_len, max_out, session_buf,
session_len)) {
OPENSSL_PUT_ERROR(SSL, SSL_R_TICKET_ENCRYPTION_FAILED);
return 0;
@@ -595,7 +595,7 @@
}
int ret = 0;
- if (hs->config->session_ctx->ticket_aead_method) {
+ if (hs->ssl->session_ctx->ticket_aead_method) {
ret = ssl_encrypt_ticket_with_method(hs, out, session_buf, session_len);
} else {
ret = ssl_encrypt_ticket_with_cipher_ctx(hs, out, session_buf, session_len);
@@ -660,6 +660,7 @@
static enum ssl_hs_wait_t ssl_lookup_session(
SSL_HANDSHAKE *hs, UniquePtr<SSL_SESSION> *out_session,
const uint8_t *session_id, size_t session_id_len) {
+ SSL *const ssl = hs->ssl;
out_session->reset();
if (session_id_len == 0 || session_id_len > SSL_MAX_SSL_SESSION_ID_LENGTH) {
@@ -668,16 +669,15 @@
UniquePtr<SSL_SESSION> session;
// Try the internal cache, if it exists.
- if (!(hs->config->session_ctx->session_cache_mode &
+ if (!(ssl->session_ctx->session_cache_mode &
SSL_SESS_CACHE_NO_INTERNAL_LOOKUP)) {
SSL_SESSION data;
- data.ssl_version = hs->ssl->version;
+ data.ssl_version = ssl->version;
data.session_id_length = session_id_len;
OPENSSL_memcpy(data.session_id, session_id, session_id_len);
- MutexReadLock lock(&hs->config->session_ctx->lock);
- session.reset(
- lh_SSL_SESSION_retrieve(hs->config->session_ctx->sessions, &data));
+ MutexReadLock lock(&ssl->session_ctx->lock);
+ session.reset(lh_SSL_SESSION_retrieve(ssl->session_ctx->sessions, &data));
if (session) {
// |lh_SSL_SESSION_retrieve| returns a non-owning pointer.
SSL_SESSION_up_ref(session.get());
@@ -686,10 +686,10 @@
}
// Fall back to the external cache, if it exists.
- if (!session && hs->config->session_ctx->get_session_cb != nullptr) {
+ if (!session && ssl->session_ctx->get_session_cb != nullptr) {
int copy = 1;
- session.reset(hs->config->session_ctx->get_session_cb(
- hs->ssl, session_id, session_id_len, ©));
+ session.reset(ssl->session_ctx->get_session_cb(ssl, session_id,
+ session_id_len, ©));
if (!session) {
return ssl_hs_ok;
}
@@ -708,15 +708,15 @@
}
// Add the externally cached session to the internal cache if necessary.
- if (!(hs->config->session_ctx->session_cache_mode &
+ if (!(ssl->session_ctx->session_cache_mode &
SSL_SESS_CACHE_NO_INTERNAL_STORE)) {
- SSL_CTX_add_session(hs->config->session_ctx, session.get());
+ SSL_CTX_add_session(ssl->session_ctx, session.get());
}
}
- if (session && !ssl_session_is_time_valid(hs->ssl, session.get())) {
+ if (session && !ssl_session_is_time_valid(ssl, session.get())) {
// The session was from the cache, so remove it.
- SSL_CTX_remove_session(hs->config->session_ctx, session.get());
+ SSL_CTX_remove_session(ssl->session_ctx, session.get());
session.reset();
}
diff --git a/ssl/t1_lib.cc b/ssl/t1_lib.cc
index eb6d90b..7fae0da 100644
--- a/ssl/t1_lib.cc
+++ b/ssl/t1_lib.cc
@@ -3317,9 +3317,9 @@
if (ssl->ctx->tlsext_servername_callback != 0) {
ret = ssl->ctx->tlsext_servername_callback(ssl, &al,
ssl->ctx->tlsext_servername_arg);
- } else if (hs->config->session_ctx->tlsext_servername_callback != 0) {
- ret = hs->config->session_ctx->tlsext_servername_callback(
- ssl, &al, hs->config->session_ctx->tlsext_servername_arg);
+ } else if (ssl->session_ctx->tlsext_servername_callback != 0) {
+ ret = ssl->session_ctx->tlsext_servername_callback(
+ ssl, &al, ssl->session_ctx->tlsext_servername_arg);
}
switch (ret) {
@@ -3408,7 +3408,7 @@
ScopedEVP_CIPHER_CTX cipher_ctx;
ScopedHMAC_CTX hmac_ctx;
const uint8_t *iv = ticket + SSL_TICKET_KEY_NAME_LEN;
- int cb_ret = hs->config->session_ctx->tlsext_ticket_key_cb(
+ int cb_ret = hs->ssl->session_ctx->tlsext_ticket_key_cb(
hs->ssl, (uint8_t *)ticket /* name */, (uint8_t *)iv, cipher_ctx.get(),
hmac_ctx.get(), 0 /* decrypt */);
if (cb_ret < 0) {
@@ -3428,7 +3428,7 @@
SSL_HANDSHAKE *hs, uint8_t **out, size_t *out_len, const uint8_t *ticket,
size_t ticket_len) {
assert(ticket_len >= SSL_TICKET_KEY_NAME_LEN + EVP_MAX_IV_LENGTH);
- SSL_CTX *ctx = hs->config->session_ctx;
+ SSL_CTX *ctx = hs->ssl->session_ctx;
// Rotate the ticket key if necessary.
if (!ssl_ctx_rotate_ticket_encryption_key(ctx)) {
@@ -3475,7 +3475,7 @@
size_t plaintext_len;
const enum ssl_ticket_aead_result_t result =
- hs->config->session_ctx->ticket_aead_method->open(
+ hs->ssl->session_ctx->ticket_aead_method->open(
hs->ssl, plaintext, &plaintext_len, ticket_len, ticket, ticket_len);
if (result == ssl_ticket_aead_success) {
@@ -3503,7 +3503,7 @@
uint8_t *plaintext = NULL;
size_t plaintext_len;
enum ssl_ticket_aead_result_t result;
- if (hs->config->session_ctx->ticket_aead_method != NULL) {
+ if (hs->ssl->session_ctx->ticket_aead_method != NULL) {
result = ssl_decrypt_ticket_with_method(
hs, &plaintext, &plaintext_len, out_renew_ticket, ticket, ticket_len);
} else {
@@ -3514,7 +3514,7 @@
if (ticket_len < SSL_TICKET_KEY_NAME_LEN + EVP_MAX_IV_LENGTH) {
return ssl_ticket_aead_ignore_ticket;
}
- if (hs->config->session_ctx->tlsext_ticket_key_cb != NULL) {
+ if (hs->ssl->session_ctx->tlsext_ticket_key_cb != NULL) {
result = ssl_decrypt_ticket_with_cb(hs, &plaintext, &plaintext_len,
out_renew_ticket, ticket, ticket_len);
} else {
diff --git a/ssl/tls13_client.cc b/ssl/tls13_client.cc
index 3794043..579e6a6 100644
--- a/ssl/tls13_client.cc
+++ b/ssl/tls13_client.cc
@@ -335,7 +335,7 @@
// Resumption incorporates fresh key material, so refresh the timeout.
ssl_session_renew_timeout(ssl, hs->new_session.get(),
- hs->config->session_ctx->session_psk_dhe_timeout);
+ ssl->session_ctx->session_psk_dhe_timeout);
} else if (!ssl_get_new_session(hs, 0)) {
ssl_send_alert(ssl, SSL3_AL_FATAL, SSL_AD_INTERNAL_ERROR);
return ssl_hs_error;
@@ -877,9 +877,9 @@
session->ticket_age_add_valid = 1;
session->not_resumable = 0;
- if ((ssl->ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) &&
- ssl->ctx->new_session_cb != NULL &&
- ssl->ctx->new_session_cb(ssl, session.get())) {
+ if ((ssl->session_ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) &&
+ ssl->session_ctx->new_session_cb != NULL &&
+ ssl->session_ctx->new_session_cb(ssl, session.get())) {
// |new_session_cb|'s return value signals that it took ownership.
session.release();
}
diff --git a/ssl/tls13_server.cc b/ssl/tls13_server.cc
index 5303f3f..81d78fa 100644
--- a/ssl/tls13_server.cc
+++ b/ssl/tls13_server.cc
@@ -408,9 +408,8 @@
ssl->s3->session_reused = true;
// Resumption incorporates fresh key material, so refresh the timeout.
- ssl_session_renew_timeout(
- ssl, hs->new_session.get(),
- hs->config->session_ctx->session_psk_dhe_timeout);
+ ssl_session_renew_timeout(ssl, hs->new_session.get(),
+ ssl->session_ctx->session_psk_dhe_timeout);
break;
case ssl_ticket_aead_error:
