SSL object refactoring using SSL_CONNECTION object

Make the SSL object polymorphic based on whether this is
a traditional SSL connection, QUIC connection, or later
to be implemented a QUIC stream.

It requires adding if after every SSL_CONNECTION_FROM_SSL() call
which itself has to be added to almost every public SSL_ API call.

Reviewed-by: Richard Levitte <levitte@openssl.org>
Reviewed-by: Hugo Landau <hlandau@openssl.org>
Reviewed-by: Paul Dale <pauli@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/18612)

1 files changed, 1437 insertions, 601 deletions

diff --git a/ssl/ssl_lib.c b/ssl/ssl_lib.c
index ff035ea6c8..24bcd7feec 100644
--- a/ssl/ssl_lib.c
+++ b/ssl/ssl_lib.c
@@ -25,33 +25,33 @@
 #include "internal/refcount.h"
 #include "internal/ktls.h"
 
-static int ssl_undefined_function_1(SSL *ssl, SSL3_RECORD *r, size_t s, int t,
-                                    SSL_MAC_BUF *mac, size_t macsize)
+static int ssl_undefined_function_1(SSL_CONNECTION *sc, SSL3_RECORD *r, size_t s,
+                                    int t, SSL_MAC_BUF *mac, size_t macsize)
 {
-    return ssl_undefined_function(ssl);
+    return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
 }
 
-static int ssl_undefined_function_2(SSL *ssl, SSL3_RECORD *r, unsigned char *s,
-                                    int t)
+static int ssl_undefined_function_2(SSL_CONNECTION *sc, SSL3_RECORD *r,
+                                    unsigned char *s, int t)
 {
-    return ssl_undefined_function(ssl);
+    return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
 }
 
-static int ssl_undefined_function_3(SSL *ssl, unsigned char *r,
+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);
+    return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
 }
 
-static int ssl_undefined_function_4(SSL *ssl, int r)
+static int ssl_undefined_function_4(SSL_CONNECTION *sc, int r)
 {
-    return ssl_undefined_function(ssl);
+    return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
 }
 
-static size_t ssl_undefined_function_5(SSL *ssl, const char *r, size_t s,
-                                       unsigned char *t)
+static size_t ssl_undefined_function_5(SSL_CONNECTION *sc, const char *r,
+                                       size_t s, unsigned char *t)
 {
-    return ssl_undefined_function(ssl);
+    return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
 }
 
 static int ssl_undefined_function_6(int r)
@@ -59,17 +59,22 @@ static int ssl_undefined_function_6(int r)
     return ssl_undefined_function(NULL);
 }
 
-static int ssl_undefined_function_7(SSL *ssl, unsigned char *r, size_t s,
-                                    const char *t, size_t u,
+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);
+    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_1,
     ssl_undefined_function_2,
-    ssl_undefined_function,
+    ssl_undefined_function_8,
     ssl_undefined_function_3,
     ssl_undefined_function_4,
     ssl_undefined_function_5,
@@ -185,7 +190,7 @@ static void dane_final(SSL_DANE *dane)
 /*
  * dane_copy - Copy dane configuration, sans verification state.
  */
-static int ssl_dane_dup(SSL *to, SSL *from)
+static int ssl_dane_dup(SSL_CONNECTION *to, SSL_CONNECTION *from)
 {
     int num;
     int i;
@@ -196,7 +201,7 @@ static int ssl_dane_dup(SSL *to, SSL *from)
     num = sk_danetls_record_num(from->dane.trecs);
     dane_final(&to->dane);
     to->dane.flags = from->dane.flags;
-    to->dane.dctx = &to->ctx->dane;
+    to->dane.dctx = &SSL_CONNECTION_GET_CTX(to)->dane;
     to->dane.trecs = sk_danetls_record_new_reserve(NULL, num);
 
     if (to->dane.trecs == NULL) {
@@ -207,8 +212,8 @@ static int ssl_dane_dup(SSL *to, SSL *from)
     for (i = 0; i < num; ++i) {
         danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);
 
-        if (SSL_dane_tlsa_add(to, t->usage, t->selector, t->mtype,
-                              t->data, t->dlen) <= 0)
+        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;
@@ -558,7 +563,7 @@ void OPENSSL_VPROC_FUNC(void) {}
 #endif
 
 
-static void clear_ciphers(SSL *s)
+static void clear_ciphers(SSL_CONNECTION *s)
 {
     /* clear the current cipher */
     ssl_clear_cipher_ctx(s);
@@ -573,73 +578,84 @@ int SSL_clear(SSL *s)
         return 0;
     }
 
-    if (ssl_clear_bad_session(s)) {
-        SSL_SESSION_free(s->session);
-        s->session = NULL;
+    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(s->psksession);
-    s->psksession = NULL;
-    OPENSSL_free(s->psksession_id);
-    s->psksession_id = NULL;
-    s->psksession_id_len = 0;
-    s->hello_retry_request = 0;
-    s->sent_tickets = 0;
+    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 = 0;
+    sc->sent_tickets = 0;
 
-    s->error = 0;
-    s->hit = 0;
-    s->shutdown = 0;
+    sc->error = 0;
+    sc->hit = 0;
+    sc->shutdown = 0;
 
-    if (s->renegotiate) {
+    if (sc->renegotiate) {
         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
         return 0;
     }
 
-    ossl_statem_clear(s);
+    ossl_statem_clear(sc);
 
-    s->version = s->method->version;
-    s->client_version = s->version;
-    s->rwstate = SSL_NOTHING;
+    /* TODO(QUIC): Version handling not yet clear */
+    sc->version = s->method->version;
+    sc->client_version = sc->version;
+    sc->rwstate = SSL_NOTHING;
 
-    BUF_MEM_free(s->init_buf);
-    s->init_buf = NULL;
-    clear_ciphers(s);
-    s->first_packet = 0;
+    BUF_MEM_free(sc->init_buf);
+    sc->init_buf = NULL;
+    clear_ciphers(sc);
+    sc->first_packet = 0;
 
-    s->key_update = SSL_KEY_UPDATE_NONE;
+    sc->key_update = SSL_KEY_UPDATE_NONE;
 
-    EVP_MD_CTX_free(s->pha_dgst);
-    s->pha_dgst = NULL;
+    EVP_MD_CTX_free(sc->pha_dgst);
+    sc->pha_dgst = NULL;
 
     /* Reset DANE verification result state */
-    s->dane.mdpth = -1;
-    s->dane.pdpth = -1;
-    X509_free(s->dane.mcert);
-    s->dane.mcert = NULL;
-    s->dane.mtlsa = NULL;
+    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(s->param, NULL);
+    X509_VERIFY_PARAM_move_peername(sc->param, NULL);
 
     /* Clear any shared connection state */
-    OPENSSL_free(s->shared_sigalgs);
-    s->shared_sigalgs = NULL;
-    s->shared_sigalgslen = 0;
+    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->ctx->method) {
-        s->method->ssl_free(s);
-        s->method = s->ctx->method;
-        if (!s->method->ssl_new(s))
+    if (s->method != SSL_CONNECTION_GET_CTX(sc)->method) {
+        s->method->ssl_deinit(s);
+        s->method = SSL_CONNECTION_GET_CTX(sc)->method;
+        if (!s->method->ssl_init(s))
             return 0;
     } else {
         if (!s->method->ssl_clear(s))
             return 0;
     }
 
-    RECORD_LAYER_clear(&s->rlayer);
+    RECORD_LAYER_clear(&sc->rlayer);
 
     return 1;
 }
@@ -671,8 +687,6 @@ int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
 
 SSL *SSL_new(SSL_CTX *ctx)
 {
-    SSL *s;
-
     if (ctx == NULL) {
         ERR_raise(ERR_LIB_SSL, SSL_R_NULL_SSL_CTX);
         return NULL;
@@ -681,19 +695,50 @@ SSL *SSL_new(SSL_CTX *ctx)
         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, int type)
+{
+    ssl->type = type;
+
+    ssl->references = 1;
+    ssl->lock = CRYPTO_THREAD_lock_new();
+    if (ssl->lock == NULL)
+        return 0;
+
+    SSL_CTX_up_ref(ctx);
+    ssl->ctx = ctx;
+
+    ssl->method = ctx->method;
+
+    if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, ssl, &ssl->ex_data))
+        return 0;
+
+    return 1;
+}
+
+SSL *ossl_ssl_connection_new(SSL_CTX *ctx)
+{
+    SSL_CONNECTION *s;
+    SSL *ssl;
 
     s = OPENSSL_zalloc(sizeof(*s));
     if (s == NULL)
-        goto err;
+        return NULL;
 
-    s->references = 1;
-    s->lock = CRYPTO_THREAD_lock_new();
-    if (s->lock == NULL) {
+    ssl = &s->ssl;
+    if (!ossl_ssl_init(ssl, ctx, SSL_TYPE_SSL_CONNECTION)) {
         OPENSSL_free(s);
         s = NULL;
         goto err;
     }
 
+#ifndef OPENSSL_NO_QUIC
+    /* set the parent (user visible) ssl to self */
+    s->user_ssl = ssl;
+#endif
+
     RECORD_LAYER_init(&s->rlayer, s);
 
     s->options = ctx->options;
@@ -753,10 +798,8 @@ SSL *SSL_new(SSL_CTX *ctx)
     if (s->max_pipelines > 1)
         RECORD_LAYER_set_read_ahead(&s->rlayer, 1);
     if (ctx->default_read_buf_len > 0)
-        SSL_set_default_read_buffer_len(s, ctx->default_read_buf_len);
+        SSL_set_default_read_buffer_len(ssl, ctx->default_read_buf_len);
 
-    SSL_CTX_up_ref(ctx);
-    s->ctx = ctx;
     s->ext.debug_cb = 0;
     s->ext.debug_arg = NULL;
     s->ext.ticket_expected = 0;
@@ -795,14 +838,14 @@ SSL *SSL_new(SSL_CTX *ctx)
     s->ext.npn = NULL;
 #endif
 
-    if (s->ctx->ext.alpn) {
-        s->ext.alpn = OPENSSL_malloc(s->ctx->ext.alpn_len);
+    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, s->ctx->ext.alpn, s->ctx->ext.alpn_len);
-        s->ext.alpn_len = s->ctx->ext.alpn_len;
+        memcpy(s->ext.alpn, ctx->ext.alpn, ctx->ext.alpn_len);
+        s->ext.alpn_len = ctx->ext.alpn_len;
     }
 
     s->verified_chain = NULL;
@@ -811,22 +854,17 @@ SSL *SSL_new(SSL_CTX *ctx)
     s->default_passwd_callback = ctx->default_passwd_callback;
     s->default_passwd_callback_userdata = ctx->default_passwd_callback_userdata;
 
-    s->method = ctx->method;
-
     s->key_update = SSL_KEY_UPDATE_NONE;
 
     s->allow_early_data_cb = ctx->allow_early_data_cb;
     s->allow_early_data_cb_data = ctx->allow_early_data_cb_data;
 
-    if (!s->method->ssl_new(s))
+    if (!ssl->method->ssl_init(ssl))
         goto err;
 
     s->server = (ctx->method->ssl_accept == ssl_undefined_function) ? 0 : 1;
 
-    if (!SSL_clear(s))
-        goto err;
-
-    if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data))
+    if (!SSL_clear(ssl))
         goto err;
 
 #ifndef OPENSSL_NO_PSK
@@ -842,21 +880,26 @@ SSL *SSL_new(SSL_CTX *ctx)
     s->job = NULL;
 
 #ifndef OPENSSL_NO_CT
-    if (!SSL_set_ct_validation_callback(s, ctx->ct_validation_callback,
+    if (!SSL_set_ct_validation_callback(ssl, ctx->ct_validation_callback,
                                         ctx->ct_validation_callback_arg))
         goto err;
 #endif
 
-    return s;
+    return ssl;
  err:
-    SSL_free(s);
+    SSL_free(ssl);
     ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
     return NULL;
 }
 
 int SSL_is_dtls(const SSL *s)
 {
-    return SSL_IS_DTLS(s) ? 1 : 0;
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+    if (sc == NULL)
+        return 0;
+
+    return SSL_CONNECTION_IS_DTLS(sc) ? 1 : 0;
 }
 
 int SSL_up_ref(SSL *s)
@@ -887,12 +930,17 @@ int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
 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;
     }
-    ssl->sid_ctx_length = sid_ctx_len;
-    memcpy(ssl->sid_ctx, sid_ctx, sid_ctx_len);
+    sc->sid_ctx_length = sid_ctx_len;
+    memcpy(sc->sid_ctx, sid_ctx, sid_ctx_len);
 
     return 1;
 }
@@ -908,9 +956,11 @@ int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
 
 int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
 {
-    if (!CRYPTO_THREAD_write_lock(ssl->lock))
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+    if (sc == NULL || !CRYPTO_THREAD_write_lock(ssl->lock))
         return 0;
-    ssl->generate_session_id = cb;
+    sc->generate_session_id = cb;
     CRYPTO_THREAD_unlock(ssl->lock);
     return 1;
 }
@@ -926,18 +976,19 @@ int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
      * by this SSL.
      */
     SSL_SESSION r, *p;
+    const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
 
-    if (id_len > sizeof(r.session_id))
+    if (sc == NULL || id_len > sizeof(r.session_id))
         return 0;
 
-    r.ssl_version = ssl->version;
+    r.ssl_version = sc->version;
     r.session_id_length = id_len;
     memcpy(r.session_id, id, id_len);
 
-    if (!CRYPTO_THREAD_read_lock(ssl->session_ctx->lock))
+    if (!CRYPTO_THREAD_read_lock(sc->session_ctx->lock))
         return 0;
-    p = lh_SSL_SESSION_retrieve(ssl->session_ctx->sessions, &r);
-    CRYPTO_THREAD_unlock(ssl->session_ctx->lock);
+    p = lh_SSL_SESSION_retrieve(sc->session_ctx->sessions, &r);
+    CRYPTO_THREAD_unlock(sc->session_ctx->lock);
     return (p != NULL);
 }
 
@@ -948,7 +999,12 @@ int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
 
 int SSL_set_purpose(SSL *s, int purpose)
 {
-    return X509_VERIFY_PARAM_set_purpose(s->param, 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)
@@ -958,21 +1014,37 @@ int SSL_CTX_set_trust(SSL_CTX *s, int trust)
 
 int SSL_set_trust(SSL *s, int trust)
 {
-    return X509_VERIFY_PARAM_set_trust(s->param, 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 && X509_VERIFY_PARAM_set1_ip_asc(s->param, hostname) == 1)
+    if (hostname != NULL
+        && X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname) == 1)
         return 1;
 
-    return X509_VERIFY_PARAM_set1_host(s->param, hostname, 0);
+    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)
@@ -985,7 +1057,7 @@ int SSL_add1_host(SSL *s, const char *hostname)
             /* 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(s->param);
+            old_ip = X509_VERIFY_PARAM_get1_ip_asc(sc->param);
             if (old_ip)
             {
                 OPENSSL_free(old_ip);
@@ -993,21 +1065,31 @@ int SSL_add1_host(SSL *s, const char *hostname)
                 return 0;
             }
 
-            return X509_VERIFY_PARAM_set1_ip_asc(s->param, hostname);
+            return X509_VERIFY_PARAM_set1_ip_asc(sc->param, hostname);
         }
     }
 
-    return X509_VERIFY_PARAM_add1_host(s->param, hostname, 0);
+    return X509_VERIFY_PARAM_add1_host(sc->param, hostname, 0);
 }
 
 void SSL_set_hostflags(SSL *s, unsigned int flags)
 {
-    X509_VERIFY_PARAM_set_hostflags(s->param, 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)
 {
-    return X509_VERIFY_PARAM_get0_peername(s->param);
+    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)
@@ -1033,8 +1115,13 @@ unsigned long SSL_CTX_dane_clear_flags(SSL_CTX *ctx, unsigned long flags)
 
 int SSL_dane_enable(SSL *s, const char *basedomain)
 {
-    SSL_DANE *dane = &s->dane;
+    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;
@@ -1049,7 +1136,7 @@ int SSL_dane_enable(SSL *s, const char *basedomain)
      * accepts them and disables host name checks.  To avoid side-effects with
      * invalid input, set the SNI name first.
      */
-    if (s->ext.hostname == NULL) {
+    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;
@@ -1057,7 +1144,7 @@ int SSL_dane_enable(SSL *s, const char *basedomain)
     }
 
     /* Primary RFC6125 reference identifier */
-    if (!X509_VERIFY_PARAM_set1_host(s->param, basedomain, 0)) {
+    if (!X509_VERIFY_PARAM_set1_host(sc->param, basedomain, 0)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_SETTING_TLSA_BASE_DOMAIN);
         return -1;
     }
@@ -1076,25 +1163,43 @@ int SSL_dane_enable(SSL *s, const char *basedomain)
 
 unsigned long SSL_dane_set_flags(SSL *ssl, unsigned long flags)
 {
-    unsigned long orig = ssl->dane.flags;
+    unsigned long orig;
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
 
-    ssl->dane.flags |= flags;
+    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->dane.flags;
+    unsigned long orig;
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+    if (sc == NULL)
+        return 0;
 
-    ssl->dane.flags &= ~flags;
+    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 = &s->dane;
+    SSL_DANE *dane;
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
-    if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
+    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)
@@ -1108,9 +1213,15 @@ int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki)
 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 = &s->dane;
+    SSL_DANE *dane;
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+    if (sc == NULL)
+        return -1;
 
-    if (!DANETLS_ENABLED(dane) || s->verify_result != X509_V_OK)
+    dane = &sc->dane;
+
+    if (!DANETLS_ENABLED(dane) || sc->verify_result != X509_V_OK)
         return -1;
     if (dane->mtlsa) {
         if (usage)
@@ -1129,13 +1240,23 @@ int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
 
 SSL_DANE *SSL_get0_dane(SSL *s)
 {
-    return &s->dane;
+    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)
 {
-    return dane_tlsa_add(&s->dane, usage, selector, mtype, data, 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,
@@ -1151,7 +1272,12 @@ int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
 
 int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
 {
-    return X509_VERIFY_PARAM_set1(ssl->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)
@@ -1161,12 +1287,22 @@ X509_VERIFY_PARAM *SSL_CTX_get0_param(SSL_CTX *ctx)
 
 X509_VERIFY_PARAM *SSL_get0_param(SSL *ssl)
 {
-    return ssl->param;
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
+
+    if (sc == NULL)
+        return NULL;
+
+    return sc->param;
 }
 
 void SSL_certs_clear(SSL *s)
 {
-    ssl_cert_clear_certs(s->cert);
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+    if (sc == NULL)
+        return;
+
+    ssl_cert_clear_certs(sc->cert);
 }
 
 void SSL_free(SSL *s)
@@ -1181,9 +1317,27 @@ void SSL_free(SSL *s)
         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);
+
+    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);
-    CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
 
     RECORD_LAYER_release(&s->rlayer);
 
@@ -1245,10 +1399,8 @@ void SSL_free(SSL *s)
 
     OSSL_STACK_OF_X509_free(s->verified_chain);
 
-    if (s->method != NULL)
-        s->method->ssl_free(s);
-
-    SSL_CTX_free(s->ctx);
+    if (ssl->method != NULL)
+        ssl->method->ssl_deinit(ssl);
 
     ASYNC_WAIT_CTX_free(s->waitctx);
 
@@ -1259,32 +1411,38 @@ void SSL_free(SSL *s)
 #ifndef OPENSSL_NO_SRTP
     sk_SRTP_PROTECTION_PROFILE_free(s->srtp_profiles);
 #endif
-
-    CRYPTO_THREAD_lock_free(s->lock);
-
-    OPENSSL_free(s);
 }
 
 void SSL_set0_rbio(SSL *s, BIO *rbio)
 {
-    BIO_free_all(s->rbio);
-    s->rbio = rbio;
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+    if (sc == NULL)
+        return;
+
+    BIO_free_all(sc->rbio);
+    sc->rbio = rbio;
 }
 
 void SSL_set0_wbio(SSL *s, BIO *wbio)
 {
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+    if (sc == NULL)
+        return;
+
     /*
      * If the output buffering BIO is still in place, remove it
      */
-    if (s->bbio != NULL)
-        s->wbio = BIO_pop(s->wbio);
+    if (sc->bbio != NULL)
+        sc->wbio = BIO_pop(sc->wbio);
 
-    BIO_free_all(s->wbio);
-    s->wbio = wbio;
+    BIO_free_all(sc->wbio);
+    sc->wbio = wbio;
 
     /* Re-attach |bbio| to the new |wbio|. */
-    if (s->bbio != NULL)
-        s->wbio = BIO_push(s->bbio, s->wbio);
+    if (sc->bbio != NULL)
+        sc->wbio = BIO_push(sc->bbio, sc->wbio);
 }
 
 void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
@@ -1329,19 +1487,29 @@ void SSL_set_bio(SSL *s, BIO *rbio, BIO *wbio)
 
 BIO *SSL_get_rbio(const SSL *s)
 {
-    return s->rbio;
+    const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+    if (sc == NULL)
+        return NULL;
+
+    return sc->rbio;
 }
 
 BIO *SSL_get_wbio(const SSL *s)
 {
-    if (s->bbio != NULL) {
+    const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+    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(s->bbio);
+        return BIO_next(sc->bbio);
     }
-    return s->wbio;
+    return sc->wbio;
 }
 
 int SSL_get_fd(const SSL *s)
@@ -1458,11 +1626,15 @@ int SSL_set_rfd(SSL *s, int fd)
 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 = s->s3.tmp.finish_md_len;
+    ret = sc->s3.tmp.finish_md_len;
     if (count > ret)
         count = ret;
-    memcpy(buf, s->s3.tmp.finish_md, count);
+    memcpy(buf, sc->s3.tmp.finish_md, count);
     return ret;
 }
 
@@ -1470,26 +1642,45 @@ size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
 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);
 
-    ret = s->s3.tmp.peer_finish_md_len;
+    if (sc == NULL)
+        return 0;
+
+    ret = sc->s3.tmp.peer_finish_md_len;
     if (count > ret)
         count = ret;
-    memcpy(buf, s->s3.tmp.peer_finish_md, count);
+    memcpy(buf, sc->s3.tmp.peer_finish_md, count);
     return ret;
 }
 
 int SSL_get_verify_mode(const SSL *s)
 {
-    return s->verify_mode;
+    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)
 {
-    return X509_VERIFY_PARAM_get_depth(s->param);
+    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 *) {
-    return s->verify_callback;
+    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)
@@ -1509,24 +1700,44 @@ int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
 void SSL_set_verify(SSL *s, int mode,
                     int (*callback) (int ok, X509_STORE_CTX *ctx))
 {
-    s->verify_mode = mode;
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+    if (sc == NULL)
+        return;
+
+    sc->verify_mode = mode;
     if (callback != NULL)
-        s->verify_callback = callback;
+        sc->verify_callback = callback;
 }
 
 void SSL_set_verify_depth(SSL *s, int depth)
 {
-    X509_VERIFY_PARAM_set_depth(s->param, 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)
 {
-    RECORD_LAYER_set_read_ahead(&s->rlayer, yes);
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+    if (sc == NULL)
+        return;
+
+    RECORD_LAYER_set_read_ahead(&sc->rlayer, yes);
 }
 
 int SSL_get_read_ahead(const SSL *s)
 {
-    return RECORD_LAYER_get_read_ahead(&s->rlayer);
+    const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+    if (sc == NULL)
+        return 0;
+
+    return RECORD_LAYER_get_read_ahead(&sc->rlayer);
 }
 
 int SSL_pending(const SSL *s)
@@ -1556,10 +1767,15 @@ int SSL_has_pending(const SSL *s)
      * data. That data may not result in any application data, or we may fail
      * to parse the records for some reason.
      */
-    if (RECORD_LAYER_processed_read_pending(&s->rlayer))
+    const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+    if (sc == NULL)
+        return 0;
+
+    if (RECORD_LAYER_processed_read_pending(&sc->rlayer))
         return 1;
 
-    return RECORD_LAYER_read_pending(&s->rlayer);
+    return RECORD_LAYER_read_pending(&sc->rlayer);
 }
 
 X509 *SSL_get1_peer_certificate(const SSL *s)
@@ -1574,20 +1790,29 @@ X509 *SSL_get1_peer_certificate(const SSL *s)
 
 X509 *SSL_get0_peer_certificate(const SSL *s)
 {
-    if ((s == NULL) || (s->session == NULL))
+    const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
+
+    if (sc == NULL)
+        return NULL;
+
+    if (sc->session == NULL)
         return NULL;
     else
-        return s->session->peer;
+        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 ((s == NULL) || (s->session == NULL))
+    if (sc == NULL)
+        return NULL;
+
+    if (sc->session == NULL)
         r = NULL;
     else
-        r = s->session->peer_chain;
+        r = sc->session->peer_chain;
 
     /*
      * If we are a client, cert_chain includes the peer's own certificate; if
@@ -1604,6 +1829,13 @@ STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
 int SSL_copy_session_id(SSL *t, const SSL *f)
 {
     int i;
+    /* TODO(QUIC): Do we want to support this for QUIC connections? */
+    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;
@@ -1613,16 +1845,16 @@ int SSL_copy_session_id(SSL *t, const SSL *f)
      * what if we are setup for one protocol version but want to talk another
      */
     if (t->method != f->method) {
-        t->method->ssl_free(t);
+        t->method->ssl_deinit(t);
         t->method = f->method;
-        if (t->method->ssl_new(t) == 0)
+        if (t->method->ssl_init(t) == 0)
             return 0;
     }
 
-    CRYPTO_UP_REF(&f->cert->references, &i, f->cert->lock);
-    ssl_cert_free(t->cert);
-    t->cert = f->cert;
-    if (!SSL_set_session_id_context(t, f->sid_ctx, (int)f->sid_ctx_length)) {
+    CRYPTO_UP_REF(&fsc->cert->references, &i, fsc->cert->lock);
+    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;
     }
 
@@ -1647,25 +1879,32 @@ int SSL_CTX_check_private_key(const SSL_CTX *ctx)
 /* Fix this function so that it takes an optional type parameter */
 int SSL_check_private_key(const SSL *ssl)
 {
-    if (ssl == NULL) {
+    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 (ssl->cert->key->x509 == NULL) {
+    if (sc->cert->key->x509 == NULL) {
         ERR_raise(ERR_LIB_SSL, SSL_R_NO_CERTIFICATE_ASSIGNED);
         return 0;
     }
-    if (ssl->cert->key->privatekey == NULL) {
+    if (sc->cert->key->privatekey == NULL) {
         ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
         return 0;
     }
-    return X509_check_private_key(ssl->cert->key->x509,
-                                   ssl->cert->key->privatekey);
+    return X509_check_private_key(sc->cert->key->x509,
+                                   sc->cert->key->privatekey);
 }
 
 int SSL_waiting_for_async(SSL *s)
 {
-    if (s->job)
+    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
+
+    if (sc == NULL)
+        return 0;
+
+    if (sc->job)
         return 1;
 
     return 0;
@@ -1673,9 +1912,13 @@ int SSL_waiting_for_async(SSL *s)